Update deformes4D_engine.py

deformes4D_engine.py

@@ -119,40 +119,42 @@ class Deformes4DEngine:
         return output_path
     
     def generate_full_movie(self, keyframes: list, global_prompt: str, storyboard: list, 
-                            # Novos parâmetros de controle vindos da UI
-                            n_chunks_to_generate: int,
-                            video_end_chunk: int,
-                            eco_start_chunk: int,
-                            handler_start_chunk: int,
-                            handler_frame_target: int,
-                            # Parâmetros restantes
+                            seconds_per_fragment: float, trim_percent: int,
                             handler_strength: float, destination_convergence_strength: float, 
                             video_resolution: int, use_continuity_director: bool, 
                             progress: gr.Progress = gr.Progress()):
         
-        # --- Lógica de Geração Dinâmica Baseada nos Parâmetros da UI ---
-        FRAMES_TO_GENERATE = (n_chunks_to_generate - 1) * 8 + 1
+        # --- Lógica de Controle Dinâmico Baseada em Dois Sliders ---
         
-        VIDEO_CHUNK_INDICES = slice(0, video_end_chunk)
-        ECO_CHUNK_INDICES = slice(eco_start_chunk, eco_start_chunk + 2)
-        HANDLER_CHUNK_INDICES = slice(handler_start_chunk, handler_start_chunk + 2)
+        # 1. Calcular o total de chunks a serem gerados a partir dos segundos
+        total_chunks_gerados = max(5, int(round(seconds_per_fragment * 24 / 8)))
+
+        # 2. Calcular o número de chunks a podar com base na porcentagem, com mínimo de 4
+        trim_chunks = max(4, int(round(total_chunks_gerados * (trim_percent / 100))))
         
-        HANDLER_FRAME_TARGET = handler_frame_target
-        DESTINATION_FRAME_TARGET = FRAMES_TO_GENERATE - 1
+        # Regra de segurança para evitar que a poda consuma o vídeo inteiro
+        if trim_chunks >= total_chunks_gerados:
+            trim_chunks = total_chunks_gerados - 1
+            logger.warning(f"A poda ({trim_percent}%) era muito grande. Ajustada para {trim_chunks} chunks para deixar 1 chunk de vídeo.")
 
-        # Validação de sanidade para garantir que as fatias não se sobreponham de forma incorreta
-        if not (video_end_chunk <= eco_start_chunk and 
-                (eco_start_chunk + 2) <= handler_start_chunk and 
-                (handler_start_chunk + 2) <= n_chunks_to_generate):
-            raise gr.Error(f"Configuração de Chunks inválida! Verifique as sobreposições e o total de chunks.")
+        # 3. Definir fatias e alvos com base nos cálculos
+        VIDEO_CHUNK_COUNT = total_chunks_gerados - trim_chunks
+        
+        HANDLER_CHUNK_INDICES = slice(total_chunks_gerados - 2, total_chunks_gerados)
+        ECO_CHUNK_INDICES = slice(total_chunks_gerados - 4, total_chunks_gerados - 2)
+        
+        HANDLER_FRAME_TARGET = (trim_chunks - 2) * 8
+        FRAMES_TO_GENERATE = (total_chunks_gerados - 1) * 8 + 1
+        DESTINATION_FRAME_TARGET = FRAMES_TO_GENERATE - 1
 
         logger.info("="*60)
         logger.info("MODO DE GERAÇÃO: Estratégia de Cauda Longa Dinâmica")
-        logger.info(f"  - Geração Bruta por Fragmento: {n_chunks_to_generate} chunks ({FRAMES_TO_GENERATE} frames)")
-        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(f"  - Duração Solicitada: {seconds_per_fragment}s -> Geração Bruta: {total_chunks_gerados} chunks")
+        logger.info(f"  - Poda Solicitada: {trim_percent}% -> Chunks de Poda (Cauda): {trim_chunks}")
+        logger.info(f"  - Clipe Final por Fragmento: {VIDEO_CHUNK_COUNT} chunks")
+        logger.info(f"  - Guia de Eco (Memória): Chunks {ECO_CHUNK_INDICES.start}-{ECO_CHUNK_INDICES.stop-1}")
+        logger.info(f"  - Guia de Handler (Evolução): Chunks {HANDLER_CHUNK_INDICES.start}-{HANDLER_CHUNK_INDICES.stop-1}")
+        logger.info(f"  - PONTO DE APLICAÇÃO DO HANDLER (DINÂMICO): Frame {HANDLER_FRAME_TARGET}")
         logger.info("="*60)
         
         base_ltx_params = {"guidance_scale": 1.0, "stg_scale": 0.0, "rescaling_scale": 0.15, "num_inference_steps": 20}
@@ -192,16 +194,12 @@ class Deformes4DEngine:
             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:
                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"    - 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}).")
             
             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"    - Guia de Destino: Imagem K{start_keyframe_index + 1} no frame {DESTINATION_FRAME_TARGET}.")
 
             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)
@@ -211,7 +209,7 @@ class Deformes4DEngine:
             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}.")
 
-            latents_for_video = new_full_latents[:, :, VIDEO_CHUNK_INDICES, :, :]
+            latents_for_video = new_full_latents[:, :, :VIDEO_CHUNK_COUNT, :, :]
             logger.info(f"  [2. EDIÇÃO] Tensor final para vídeo extraído com {latents_for_video.shape[2]} chunks.")
 
             base_name = f"fragment_{i}_{int(time.time())}"