Update deformes4D_engine.py

deformes4D_engine.py

@@ -2,8 +2,7 @@
 # Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
 #
 # MODIFICATIONS FOR ADUC-SDR:
-# Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
-#
+# Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved#
 # This file is part of the ADUC-SDR project. It contains the core logic for
 # video fragment generation, latent manipulation, and dynamic editing, 
 # governed by the ADUC orchestrator.
@@ -119,45 +118,38 @@ class Deformes4DEngine:
         return output_path
     
     def generate_full_movie(self, keyframes: list, global_prompt: str, storyboard: list, 
-                            # Os parâmetros a seguir são recebidos da UI, mas serão ignorados pela nova lógica fixa.
+                            # Os parâmetros a seguir da UI são ignorados por esta estratégia fixa.
                             seconds_per_fragment: float, trim_chunks: int, echo_chunks: int,
                             # Parâmetros de força ainda são utilizados.
                             handler_strength: float, destination_convergence_strength: float, 
                             video_resolution: int, use_continuity_director: bool, 
                             progress: gr.Progress = gr.Progress()):
         
-        # --- [INÍCIO DA NOVA LÓGICA FIXA] ---
-        # AVISO: Esta função agora opera com uma estratégia de continuidade fixa, ignorando os parâmetros da UI
-        # 'seconds_per_fragment', 'trim_chunks', e 'echo_chunks' para garantir consistência máxima.
-
-        # Parâmetros Fixos de Geração
+        # --- Estratégia de Geração com Cauda Longa Refinada (Lógica Fixa) ---
         N_CHUNKS_TO_GENERATE = 13
-        FRAMES_TO_GENERATE = (N_CHUNKS_TO_GENERATE - 1) * 8 + 1  # Resulta em 97 frames
+        FRAMES_TO_GENERATE = (N_CHUNKS_TO_GENERATE - 1) * 8 + 1  # 97 frames
         
-        # Fatias Fixas para Extração de Guias (baseado em um tensor de 13 chunks, índices 0-12)
-        ECO_CHUNK_INDICES = slice(7, 9)       # Chunks 7 e 8
-        HANDLER_CHUNK_INDICES = slice(11, 13) # Chunks 11 e 12
-        VIDEO_CHUNK_INDICES = slice(0, 8)     # Chunks 0 a 7 (resultando em 64 frames de vídeo)
+        VIDEO_CHUNK_INDICES = slice(0, 9)       # Chunks 0-8 (gera vídeo de 65 frames)
+        ECO_CHUNK_INDICES = slice(9, 11)        # Chunks 9 e 10
+        HANDLER_CHUNK_INDICES = slice(11, 13)   # Chunks 11 e 12
         
-        # Alvos de Frame Fixos para Condicionamento
-        HANDLER_FRAME_TARGET = 32 # Frame de pixel onde a guia de evolução será aplicada
-        DESTINATION_FRAME_TARGET = FRAMES_TO_GENERATE - 1 # O último frame (96)
+        HANDLER_FRAME_TARGET = 16 # <-- ALTERADO DE 32 PARA 16
+        DESTINATION_FRAME_TARGET = FRAMES_TO_GENERATE - 1
 
         logger.info("="*60)
-        logger.info("MODO DE GERAÇÃO COM LÓGICA DE CONTINUIDADE FIXA ATIVADO")
+        logger.info("MODO DE GERAÇÃO: Estratégia de Cauda Longa Refinada")
         logger.info(f"  - Geração Bruta por Fragmento: {N_CHUNKS_TO_GENERATE} chunks ({FRAMES_TO_GENERATE} frames)")
-        logger.info(f"  - Clipe de Vídeo Final por Fragmento: Chunks {VIDEO_CHUNK_INDICES.start} a {VIDEO_CHUNK_INDICES.stop-1}")
+        logger.info(f"  - Clipe Final por Fragmento: Chunks {VIDEO_CHUNK_INDICES.start} a {VIDEO_CHUNK_INDICES.stop-1}")
         logger.info(f"  - Guia de Eco (Memória): Chunks {ECO_CHUNK_INDICES.start} a {ECO_CHUNK_INDICES.stop-1}")
         logger.info(f"  - Guia de Handler (Evolução): Chunks {HANDLER_CHUNK_INDICES.start} a {HANDLER_CHUNK_INDICES.stop-1}")
+        logger.info(f"  - Ponto de Aplicação do Handler: Frame {HANDLER_FRAME_TARGET}")
         logger.info("="*60)
-        # --- [FIM DA NOVA LÓGICA FIXA] ---
-
+        
         base_ltx_params = {"guidance_scale": 1.0, "stg_scale": 0.0, "rescaling_scale": 0.15, "num_inference_steps": 20}
         keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
         video_clips_paths, story_history = [], ""
         target_resolution_tuple = (video_resolution, video_resolution) 
         
-        # Variáveis para carregar as guias da iteração anterior
         eco_latent_for_next_loop = None
         handler_latent_for_next_loop = None
         
@@ -172,13 +164,11 @@ class Deformes4DEngine:
             logger.info(f"--- INICIANDO FRAGMENTO {i+1}/{num_transitions_to_generate} ---")
             progress((i + 1) / num_transitions_to_generate, desc=f"Produzindo Transição {i+1}/{num_transitions_to_generate}")
             
-            # Define os keyframes de Passado, Presente e Futuro para esta iteração
             past_keyframe_path = keyframe_paths[start_keyframe_index - 1]
             start_keyframe_path = keyframe_paths[start_keyframe_index]
             destination_keyframe_path = keyframe_paths[start_keyframe_index + 1]
             future_story_prompt = storyboard[start_keyframe_index + 1] if (start_keyframe_index + 1) < len(storyboard) else "A cena final."
             
-            # Gemini decide o prompt de movimento com base no contexto completo
             decision = gemini_singleton.get_cinematic_decision(
                 global_prompt, story_history, past_keyframe_path, start_keyframe_path, destination_keyframe_path,
                 storyboard[start_keyframe_index - 1], storyboard[start_keyframe_index], future_story_prompt
@@ -186,46 +176,39 @@ class Deformes4DEngine:
             _, motion_prompt = decision["transition_type"], decision["motion_prompt"]
             story_history += f"\n- Ato {i+1}: {motion_prompt}"
 
-            # Monta a lista de condicionamento para a geração atual
             conditioning_items = []
             logger.info("  [0. PREPARAÇÃO] Montando itens de condicionamento...")
             
-            if i == 0: # Primeira iteração não tem guias anteriores
+            if i == 0:
                img_start = self._preprocess_image_for_latent_conversion(Image.open(start_keyframe_path).convert("RGB"), target_resolution_tuple)
                conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_start), 0, 1.0))
                logger.info("    - Condicionamento inicial: Imagem K1 no frame 0.")
-            else: # Iterações seguintes usam as guias salvas
+            else:
                conditioning_items.append(LatentConditioningItem(eco_latent_for_next_loop, 0, 1.0))
                conditioning_items.append(LatentConditioningItem(handler_latent_for_next_loop, HANDLER_FRAME_TARGET, handler_strength))
-               logger.info(f"    - Condicionamento de Memória (Eco) no frame 0 (shape: {eco_latent_for_next_loop.shape}).")
-               logger.info(f"    - Condicionamento de Evolução (Handler) no frame {HANDLER_FRAME_TARGET} (shape: {handler_latent_for_next_loop.shape}).")
+               logger.info(f"    - Guia de Memória (Eco) aplicada no frame 0 (shape: {eco_latent_for_next_loop.shape}).")
+               logger.info(f"    - Guia de Evolução (Handler) aplicada no frame {HANDLER_FRAME_TARGET} (shape: {handler_latent_for_next_loop.shape}).")
             
-            # O destino é sempre a próxima imagem-chave no final da geração
             img_dest = self._preprocess_image_for_latent_conversion(Image.open(destination_keyframe_path).convert("RGB"), target_resolution_tuple)
             conditioning_items.append(LatentConditioningItem(self.pil_to_latent(img_dest), DESTINATION_FRAME_TARGET, destination_convergence_strength))
-            logger.info(f"    - Condicionamento de Destino: Imagem K{start_keyframe_index + 1} no frame {DESTINATION_FRAME_TARGET}.")
+            logger.info(f"    - Guia de Destino: Imagem K{start_keyframe_index + 1} no frame {DESTINATION_FRAME_TARGET}.")
 
-            # Gera o tensor latente bruto de 13 chunks
             current_ltx_params = {**base_ltx_params, "motion_prompt": motion_prompt}
             new_full_latents = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, FRAMES_TO_GENERATE)
             logger.info(f"  [1. GERAÇÃO] Tensor latente bruto gerado com shape: {new_full_latents.shape}.")
 
-            # Extrai as guias para a PRÓXIMA iteração
             eco_latent_for_next_loop = new_full_latents[:, :, ECO_CHUNK_INDICES, :, :].clone()
             handler_latent_for_next_loop = new_full_latents[:, :, HANDLER_CHUNK_INDICES, :, :].clone()
             logger.info(f"  [GUIAS] Guias para a próxima iteração extraídas. Eco shape: {eco_latent_for_next_loop.shape}, Handler shape: {handler_latent_for_next_loop.shape}.")
 
-            # Extrai os chunks que se tornarão o clipe de vídeo final
             latents_for_video = new_full_latents[:, :, VIDEO_CHUNK_INDICES, :, :]
             logger.info(f"  [2. EDIÇÃO] Tensor final para vídeo extraído com {latents_for_video.shape[2]} chunks.")
 
-            # Gera e salva o vídeo
             base_name = f"fragment_{i}_{int(time.time())}"
             video_path = self._generate_video_from_latents(latents_for_video, base_name)
             video_clips_paths.append(video_path)
             yield {"fragment_path": video_path}
                  
-        # Concatena todos os fragmentos salvos
         final_movie_path = os.path.join(self.workspace_dir, f"final_movie_silent_{int(time.time())}.mp4")
         self.concatenate_videos_ffmpeg(video_clips_paths, final_movie_path)