Update deformes4D_engine.py

deformes4D_engine.py

@@ -79,11 +79,11 @@ class Deformes4DEngine:
         video_np = (video_tensor.detach().cpu().float().numpy() * 255).astype(np.uint8)
         with imageio.get_writer(path, fps=fps, codec='libx264', quality=8) as writer:
             for frame in video_np: writer.append_data(frame)
-        logger.info(f"Vídeo salvo em: {path}")
+        logger.info(f"Vídeo salvo em: {path}")
 
     def _preprocess_image_for_latent_conversion(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
         if image.size != target_resolution:
-            logger.info(f"  - AÇÃO: Redimensionando imagem de {image.size} para {target_resolution} antes da conversão para latente.")
+            logger.info(f"  - AÇÃO: Redimensionando imagem de {image.size} para {target_resolution} antes da conversão para latente.")
             return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
         return image
 
@@ -92,27 +92,27 @@ class Deformes4DEngine:
         tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
         tensor = (tensor * 2.0) - 1.0
         return self.pixels_to_latents(tensor)
-
+        
     def _generate_video_and_audio_from_latents(self, latent_tensor, audio_prompt, base_name):
         silent_video_path = os.path.join(self.workspace_dir, f"{base_name}_silent.mp4")
         pixel_tensor = self.latents_to_pixels(latent_tensor)
         self.save_video_from_tensor(pixel_tensor, silent_video_path, fps=24)
         del pixel_tensor; gc.collect()
-
+        
         try:
             result = subprocess.run(
                 ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", silent_video_path],
                 capture_output=True, text=True, check=True)
             frag_duration = float(result.stdout.strip())
         except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
-             logger.warning(f"ffprobe falhou em {os.path.basename(silent_video_path)}. Calculando duração manualmente.")
+             logger.warning(f"ffprobe falhou em {os.path.basename(silent_video_path)}. Calculando duração manualmente.")
              num_pixel_frames = latent_tensor.shape[2] * 8
              frag_duration = num_pixel_frames / 24.0
 
         video_with_audio_path = audio_specialist_singleton.generate_audio_for_video(
             video_path=silent_video_path, prompt=audio_prompt,
             duration_seconds=frag_duration)
-
+        
         if os.path.exists(silent_video_path):
              os.remove(silent_video_path)
         return video_with_audio_path
@@ -130,20 +130,20 @@ class Deformes4DEngine:
 
     def concatenate_videos_ffmpeg(self, video_paths: list[str], output_path: str) -> str:
         if not video_paths:
-            raise gr.Error("Nenhum fragmento de vídeo para montar.")
+            raise gr.Error("Nenhum fragmento de vídeo para montar.")
         list_file_path = os.path.join(self.workspace_dir, "concat_list.txt")
         with open(list_file_path, 'w', encoding='utf-8') as f:
             for path in video_paths:
                 f.write(f"file '{os.path.abspath(path)}'\n")
         cmd_list = ['ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file_path, '-c', 'copy', output_path]
-        logger.info("Executando concatenação FFmpeg...")
+        logger.info("Executando concatenação FFmpeg...")
         try:
             subprocess.run(cmd_list, check=True, capture_output=True, text=True)
         except subprocess.CalledProcessError as e:
             logger.error(f"Erro no FFmpeg: {e.stderr}")
-            raise gr.Error(f"Falha na montagem final do vídeo. Detalhes: {e.stderr}")
+            raise gr.Error(f"Falha na montagem final do vídeo. Detalhes: {e.stderr}")
         return output_path
-
+    
     def generate_full_movie(self, 
                             keyframes: list, 
                             global_prompt: str, 
@@ -157,18 +157,18 @@ class Deformes4DEngine:
                             video_resolution: int, 
                             use_continuity_director: bool, 
                             progress: gr.Progress = gr.Progress()):
-
+        
         keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
         video_clips_paths, story_history, audio_history = [], "", "This is the beginning of the film."
         target_resolution_tuple = (video_resolution, video_resolution) 
         n_trim_latents = self._quantize_to_multiple(int(seconds_per_fragment * 24 * (overlap_percent / 100.0)), 8)
         #echo_frames = 8
-
+        
         previous_latents_path = None
         num_transitions_to_generate = len(keyframe_paths) - 1
-
+        
         for i in range(num_transitions_to_generate):
-            progress((i + 1) / num_transitions_to_generate, desc=f"Produzindo Transição {i+1}/{num_transitions_to_generate}")
+            progress((i + 1) / num_transitions_to_generate, desc=f"Produzindo Transição {i+1}/{num_transitions_to_generate}")
 
             start_keyframe_path = keyframe_paths[i]
             destination_keyframe_path = keyframe_paths[i+1]
@@ -191,10 +191,10 @@ class Deformes4DEngine:
                     present_scene_desc=present_scene_desc, future_scene_desc=future_scene_desc
                 )
                 transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
-
+            
             story_history += f"\n- Ato {i+1} ({transition_type}): {motion_prompt}"
 
-            if use_continuity_director: # Assume-se que este checkbox controla os diretores de vídeo e som
+            if use_continuity_director: # Assume-se que este checkbox controla os diretores de vídeo e som
                 if is_first_fragment:
                     audio_prompt = gemini_singleton.get_sound_director_prompt(
                         audio_history=audio_history,
@@ -211,7 +211,7 @@ class Deformes4DEngine:
                     )
             else:
                 audio_prompt = present_scene_desc # Fallback para o prompt da cena se o diretor de som estiver desligado
-
+            
             audio_history = audio_prompt
 
             conditioning_items = []
@@ -232,8 +232,8 @@ class Deformes4DEngine:
                 trimmed_for_echo = previous_latents[:, :, :-n_trim_latents, :, :] if n_trim_latents > 0 and previous_latents.shape[2] > n_trim_latents else previous_latents
                 echo_latents = trimmed_for_echo[:, :, -echo_frames:, :, :]
                 handler_frame_position = n_trim_latents + echo_frames
-
-
+                
+                                
                 conditioning_items.append(LatentConditioningItem(echo_latents, 0, 1.0))
                 conditioning_items.append(LatentConditioningItem(handler_latent, handler_frame_position, handler_strength))
                 del previous_latents, handler_latent, trimmed_for_echo, echo_latents; gc.collect()
@@ -241,42 +241,36 @@ class Deformes4DEngine:
                     img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
                     destination_latent = self.pil_to_latent(img_dest)
                     conditioning_items.append(LatentConditioningItem(destination_latent, total_frames_to_generate - 1, destination_convergence_strength))
-
+            
             new_full_latents = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, total_frames_to_generate)
-
+            
             base_name = f"fragment_{i}_{int(time.time())}"
             new_full_latents_path = os.path.join(self.workspace_dir, f"{base_name}_full.pt")
             self.save_latent_tensor(new_full_latents, new_full_latents_path)
-
+            
             previous_latents_path = new_full_latents_path
 
             latents_for_video = new_full_latents
-
-            # Aplicar cortes apenas onde necessário para evitar duplicação
+            
             if not is_first_fragment:
-                # Remove apenas o eco do início para evitar duplicação com fragmento anterior
-                if echo_frames > 0 and latents_for_video.shape[2] > echo_frames: 
-                    latents_for_video = latents_for_video[:, :, echo_frames:, :, :]
-
-            # Para todos os fragmentos exceto o último, remove sobreposição do final
-            is_last_fragment = (i == num_transitions_to_generate - 1)
-            if not is_last_fragment:
-                if n_trim_latents > 0 and latents_for_video.shape[2] > n_trim_latents: 
-                    latents_for_video = latents_for_video[:, :, :-n_trim_latents, :, :]
+                if echo_frames > 0 and latents_for_video.shape[2] > echo_frames: latents_for_video = latents_for_video[:, :, echo_frames:, :, :]
+                if n_trim_latents > 0 and latents_for_video.shape[2] > n_trim_latents: latents_for_video = latents_for_video[:, :, :-n_trim_latents, :, :]
+            else:
+                if n_trim_latents > 0 and latents_for_video.shape[2] > n_trim_latents: latents_for_video = latents_for_video[:, :, :-n_trim_latents, :, :]
 
             video_with_audio_path = self._generate_video_and_audio_from_latents(latents_for_video, audio_prompt, base_name)
             video_clips_paths.append(video_with_audio_path)
-
-
+            
+            
             if transition_type == "cut":
                 previous_latents_path = None
-
-
+                
+                
             yield {"fragment_path": video_with_audio_path}
 
         final_movie_path = os.path.join(self.workspace_dir, f"final_movie_{int(time.time())}.mp4")
         self.concatenate_videos_ffmpeg(video_clips_paths, final_movie_path)
-
+        
         logger.info(f"Filme completo salvo em: {final_movie_path}")
         yield {"final_path": final_movie_path}