Update engineers/deformes7D.py

engineers/deformes7D.py

@@ -1,32 +1,6 @@
 # engineers/deformes7D.py
-# 
-# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
-# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
 #
-# Contato:
-# Carlos Rodrigues dos Santos
-# carlex22@gmail.com
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
-#
-# Repositórios e Projetos Relacionados:
-# GitHub: https://github.com/carlex22/Aduc-sdr
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License...
-# PENDING PATENT NOTICE: Please see NOTICE.md.
+# Copyright (C) 2025 Carlos Rodrigues dos Santos
 #
 # Version: 3.0.0
 #
@@ -47,7 +21,7 @@ import subprocess
 import gc
 import shutil
 from pathlib import Path
-from typing import List, Tuple, Generator, Dict, Any
+from typing import List, Tuple, Dict
 
 from aduc_types import LatentConditioningItem
 from managers.ltx_manager import ltx_manager_singleton
@@ -70,22 +44,19 @@ class Deformes7DEngine:
         logger.info("Deformes7D Unified Engine initialized.")
         os.makedirs(self.workspace_dir, exist_ok=True)
 
-    # --- HELPER METHODS (from 3D and 4D engines) ---
+    # --- HELPER METHODS ---
 
     def _preprocess_image(self, image: Image.Image, target_resolution: tuple) -> Image.Image:
-        """Resizes and fits an image to the target resolution."""
         if image.size != target_resolution:
             return ImageOps.fit(image, target_resolution, Image.Resampling.LANCZOS)
         return image
 
     def _pil_to_pixel_tensor(self, pil_image: Image.Image) -> torch.Tensor:
-        """Converts PIL to the 5D pixel tensor for VAE encoding."""
         image_np = np.array(pil_image).astype(np.float32) / 255.0
         tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
         return (tensor * 2.0) - 1.0
         
     def _save_image_from_tensor(self, pixel_tensor: torch.Tensor, path: str):
-        """Saves a 1-frame pixel tensor as a PNG image."""
         tensor_chw = pixel_tensor.squeeze(0).squeeze(1)
         tensor_hwc = tensor_chw.permute(1, 2, 0)
         tensor_hwc = (tensor_hwc.clamp(-1, 1) + 1) / 2.0
@@ -93,7 +64,6 @@ class Deformes7DEngine:
         Image.fromarray(image_np).save(path)
 
     def _quantize_to_multiple(self, n, m):
-        """Helper to round n to the nearest multiple of m."""
         if m == 0: return n
         quantized = int(round(n / m) * m)
         return m if n > 0 and quantized == 0 else quantized
@@ -130,7 +100,6 @@ class Deformes7DEngine:
         upscaled_latent = latent_enhancer_specialist_singleton.upscale(final_latent)
         pixel_tensor_out = vae_manager_singleton.decode(upscaled_latent)
 
-        # Save the new keyframe image
         timestamp = int(time.time() * 1000)
         output_path = os.path.join(self.workspace_dir, f"keyframe_{timestamp}.png")
         self._save_image_from_tensor(pixel_tensor_out, output_path)
@@ -144,7 +113,6 @@ class Deformes7DEngine:
         """
         The main interleaved rendering pipeline for Deformes7D.
         """
-        # --- INITIALIZATION ---
         logger.info("--- DEFORMES 7D: INITIATING INTERLEAVED RENDERING PIPELINE ---")
         run_timestamp = int(time.time())
         temp_video_clips_dir = os.path.join(self.workspace_dir, f"temp_clips_{run_timestamp}")
@@ -152,14 +120,11 @@ class Deformes7DEngine:
         
         resolution_tuple = (video_resolution, video_resolution)
         
-        # Lists to store the full sequence of generated artifacts
         generated_keyframe_paths = []
         generated_keyframe_latents = []
         generated_video_fragment_paths = []
         
-        # --- BOOTSTRAP: Generate first two keyframes to start the pipeline ---
-        progress(0, desc="Bootstrap: Generating K0...")
-        # Keyframe 0 is just the processed initial reference
+        progress(0, desc="Bootstrap: Processing K0...")
         k0_path = initial_ref_paths[0]
         k0_pil = Image.open(k0_path).convert("RGB")
         k0_processed_pil = self._preprocess_image(k0_pil, resolution_tuple)
@@ -168,8 +133,7 @@ class Deformes7DEngine:
         generated_keyframe_paths.append(k0_path)
         generated_keyframe_latents.append(k0_latent)
 
-        progress(0, desc="Bootstrap: Generating K1...")
-        # Generate Keyframe 1 from Keyframe 0
+        progress(0.01, desc="Bootstrap: Generating K1...")
         prompt_k1 = deformes2d_thinker_singleton.get_anticipatory_keyframe_prompt(
             global_prompt, "Initial scene.", storyboard[0], storyboard[1], k0_path, initial_ref_paths
         )
@@ -177,29 +141,26 @@ class Deformes7DEngine:
         generated_keyframe_paths.append(k1_path)
         generated_keyframe_latents.append(k1_latent)
 
-        # --- MAIN RENDERING LOOP ---
         story_history = ""
         eco_latent_for_next_loop, dejavu_latent_for_next_loop = None, None
         num_transitions = len(storyboard) - 1
+        
+        base_4d_ltx_params = {"rescaling_scale": 0.15, "image_cond_noise_scale": 0.00, **ltx_params}
 
         for i in range(1, num_transitions):
             progress(i / num_transitions, desc=f"Processing Act {i+1}/{num_transitions}...")
             
-            # --- 1. Generate the NEXT Keyframe (Look-ahead) ---
             logger.info(f"--> Step 3D: Generating Keyframe K{i+1}")
             kx_path = generated_keyframe_paths[i]
             prompt_ky = deformes2d_thinker_singleton.get_anticipatory_keyframe_prompt(
-                global_prompt, "Continuing sequence...", storyboard[i], storyboard[i+1], kx_path, initial_ref_paths
+                global_prompt, story_history, storyboard[i], storyboard[i+1], kx_path, initial_ref_paths
             )
             ky_path, ky_latent = self._generate_next_causal_keyframe(kx_path, initial_ref_paths, prompt_ky, resolution_tuple)
             generated_keyframe_paths.append(ky_path)
             generated_keyframe_latents.append(ky_latent)
 
-            # --- 2. Generate the CURRENT Video Fragment ---
-            logger.info(f"--> Step 4D: Generating Video Fragment V{i}")
-            kb_path = generated_keyframe_paths[i-1] # Past
-            kx_path = generated_keyframe_paths[i]   # Present (Start)
-            ky_path = generated_keyframe_paths[i+1] # Future (End)
+            logger.info(f"--> Step 4D: Generating Video Fragment V{i-1}")
+            kb_path, kx_path, ky_path = generated_keyframe_paths[i-1], generated_keyframe_paths[i], generated_keyframe_paths[i+1]
 
             decision = deformes2d_thinker_singleton.get_cinematic_decision(
                 global_prompt, story_history, kb_path, kx_path, ky_path,
@@ -207,64 +168,37 @@ class Deformes7DEngine:
             )
             transition_type, motion_prompt = decision["transition_type"], decision["motion_prompt"]
             story_history += f"\n- Act {i}: {motion_prompt}"
-
-            # Prepare conditioning items for the video fragment
-            conditioning_items = []
-            if eco_latent_for_next_loop is None:
-                conditioning_items.append(LatentConditioningItem(generated_keyframe_latents[i], 0, 1.0))
-            else:
-                # This part reuses the logic from the old Deformes4D
-                # ... [Implementation of Eco/Deja-Vu conditioning here] ...
-                # For simplicity in this first draft, we'll use the direct keyframe latent
-                conditioning_items.append(LatentConditioningItem(generated_keyframe_latents[i], 0, 1.0))
             
-            # Add the destination anchor
-            conditioning_items.append(LatentConditioningItem(ky_latent, -1, dest_strength)) # Use -1 for last frame
+            # This is a simplified version of the Deformes4D conditioning logic
+            conditioning_items = [LatentConditioningItem(generated_keyframe_latents[i], 0, 1.0)]
+            if transition_type != "cut":
+                conditioning_items.append(LatentConditioningItem(ky_latent, -1, dest_strength))
             
             fragment_latents, _ = ltx_manager_singleton.generate_latent_fragment(
                 height=video_resolution, width=video_resolution,
                 conditioning_items_data=conditioning_items, motion_prompt=motion_prompt,
                 video_total_frames=self._quantize_to_multiple(int(seconds_per_fragment * 24), 8),
-                video_fps=24, **ltx_params
+                video_fps=24, **base_4d_ltx_params
             )
 
-            # Post-process and save the video fragment
             pixel_tensor = vae_manager_singleton.decode(fragment_latents)
-            fragment_path = os.path.join(temp_video_clips_dir, f"fragment_{i}.mp4")
+            fragment_path = os.path.join(temp_video_clips_dir, f"fragment_{i-1}.mp4")
             self.save_video_from_tensor(pixel_tensor, fragment_path, fps=24)
             generated_video_fragment_paths.append(fragment_path)
-            logger.info(f"Video Fragment V{i} saved to {fragment_path}")
-            
-            # Here you would also extract the Eco and Deja-Vu from `fragment_latents` for the next loop
-            # ...
+            logger.info(f"Video Fragment V{i-1} saved to {fragment_path}")
 
-        # --- FINAL ASSEMBLY ---
         logger.info("--- Final Assembly of Video Fragments ---")
         final_video_path = os.path.join(self.workspace_dir, f"movie_7D_{run_timestamp}.mp4")
-        video_encode_tool_singleton.concatenate_videos(
-            video_paths=generated_video_fragment_paths,
-            output_path=final_video_path,
-            workspace_dir=self.workspace_dir
-        )
+        video_encode_tool_singleton.concatenate_videos(generated_video_fragment_paths, final_video_path, self.workspace_dir)
         shutil.rmtree(temp_video_clips_dir)
         
         logger.info(f"Full movie generated at: {final_video_path}")
-        # This function would then return the path and other artifacts for post-production
         return {"final_path": final_video_path, "all_keyframes": generated_keyframe_paths}
 
-
-    # --- POST-PRODUCTION METHODS (migrated from Deformes4D) ---
+    # --- POST-PRODUCTION METHODS ---
     
-    def upscale_video(self, source_video_path: str, progress=gr.Progress()):
-        # This would be a more complex function that loads the video in chunks,
-        # encodes to latents, upscales, decodes, and reassembles.
-        # For this example, we assume it's a placeholder.
-        logger.info(f"Placeholder for upscaling video: {source_video_path}")
-        return source_video_path
-
-    def master_video_hd(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress=gr.Progress()):
+    def master_video_hd(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress: gr.Progress):
         logger.info(f"--- POST-PRODUCTION: HD Mastering with SeedVR {model_version} ---")
-        progress(0.1, desc=f"Preparing for HD Mastering...")
         run_timestamp = int(time.time())
         output_path = os.path.join(self.workspace_dir, f"{Path(source_video_path).stem}_hd.mp4")
         try:
@@ -278,9 +212,8 @@ class Deformes7DEngine:
             logger.error(f"HD Mastering failed: {e}", exc_info=True)
             raise gr.Error(f"HD Mastering failed. Details: {e}")
     
-    def generate_audio(self, source_video_path: str, audio_prompt: str, progress=gr.Progress()):
+    def generate_audio(self, source_video_path: str, audio_prompt: str, progress: gr.Progress):
         logger.info(f"--- POST-PRODUCTION: Audio Generation ---")
-        progress(0.1, desc="Preparing for audio generation...")
         run_timestamp = int(time.time())
         output_path = os.path.join(self.workspace_dir, f"{Path(source_video_path).stem}_audio.mp4")
         try:
@@ -288,6 +221,7 @@ class Deformes7DEngine:
                 ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", source_video_path],
                 capture_output=True, text=True, check=True)
             duration = float(result.stdout.strip())
+            logger.info(f"Source video duration: {duration:.2f} seconds.")
             progress(0.5, desc="Generating audio track...")
             final_path = mmaudio_manager_singleton.generate_audio_for_video(
                 video_path=source_video_path, prompt=audio_prompt,
@@ -297,4 +231,14 @@ class Deformes7DEngine:
             yield {"final_path": final_path}
         except Exception as e:
             logger.error(f"Audio generation failed: {e}", exc_info=True)
-            raise gr.Error(f"Audio generation failed. Details: {e}")
+            raise gr.Error(f"Audio generation failed. Details: {e}")
+
+# --- Singleton Instantiation ---
+try:
+    with open("config.yaml", 'r') as f:
+        config = yaml.safe_load(f)
+    WORKSPACE_DIR = config['application']['workspace_dir']
+    deformes7d_engine_singleton = Deformes7DEngine(workspace_dir=WORKSPACE_DIR)
+except Exception as e:
+    logger.error(f"Could not initialize Deformes7DEngine: {e}", exc_info=True)
+    deformes7d_engine_singleton = None