fix(3d): Implement correct Hunyuan3D installation and usage

- Replaces the previous flawed dynamic loading with a robust setup process that follows the official documentation.
- After downloading the model, the code now programmatically runs pip install for the custom rasterizer and compiles the mesh painter.
- Updates the pipeline to use the correct `Hunyuan3DDiTFlowMatchingPipeline` and `Hunyuan3DPaintPipeline` classes.
- This should resolve the `FileNotFoundError` and enable the direct 3D generation model.

models/model_3d_generator.py

@@ -71,69 +71,75 @@ class Hunyuan3DGenerator:
             return False
     
     def load_model(self):
-        """Load Hunyuan3D model directly"""
+        """Load Hunyuan3D model and run necessary setup"""
         if self.model is None:
-            logger.info("🚀 Starting Hunyuan3D model loading...")
+            logger.info("🚀 Starting Hunyuan3D model loading and setup...")
             
             try:
-                # Check if we can use the model directly
-                try:
-                    # Try to import the Hunyuan3D modules
-                    logger.info("📦 Attempting to import Hunyuan3D modules...")
-                    
-                    # Download model weights if not already present
-                    logger.info("📥 Downloading Hunyuan3D model weights...")
-                    self.model_path = snapshot_download(
-                        repo_id=self.model_id,
-                        repo_type="space",
-                        cache_dir="./models/hunyuan3d_cache"
-                    )
-                    logger.info(f"✅ Model downloaded to: {self.model_path}")
-                    
-                    # Try to set up the model pipeline
-                    logger.info("🔧 Setting up Hunyuan3D pipeline...")
-                    
-                    # Import necessary modules using importlib for robustness
-                    import sys
-                    import os
-                    import importlib.util
-                    
-                    try:
-                        # Add the model path to sys.path to allow internal imports within Hunyuan3D code
-                        if self.model_path not in sys.path:
-                            sys.path.insert(0, self.model_path)
+                # Download model repository if not already present
+                logger.info(f"📥 Downloading Hunyuan3D repository from {self.model_id}...")
+                self.model_path = snapshot_download(
+                    repo_id=self.model_id,
+                    repo_type="space",
+                    cache_dir="./models/hunyuan3d_cache"
+                )
+                logger.info(f"✅ Model repository downloaded to: {self.model_path}")
+                
+                # --- Installation and Compilation ---
+                logger.info("🔧 Running Hunyuan3D setup scripts...")
+                import subprocess
+                import sys
+                import os
+
+                # 1. Install requirements from the model's specific requirements file
+                requirements_path = os.path.join(self.model_path, 'requirements.txt')
+                if os.path.exists(requirements_path):
+                    logger.info(f"📦 Installing requirements from {requirements_path}...")
+                    subprocess.run([sys.executable, '-m', 'pip', 'install', '-r', requirements_path], check=True, capture_output=True, text=True)
+
+                # 2. Install custom rasterizer
+                rasterizer_path = os.path.join(self.model_path, 'hy3dpaint', 'packages', 'custom_rasterizer')
+                if os.path.exists(rasterizer_path):
+                    logger.info(f"📦 Installing custom_rasterizer from {rasterizer_path}...")
+                    subprocess.run([sys.executable, '-m', 'pip', 'install', '-e', '.'], cwd=rasterizer_path, check=True, capture_output=True, text=True)
+
+                # 3. Compile mesh painter
+                renderer_path = os.path.join(self.model_path, 'hy3dpaint', 'DifferentiableRenderer')
+                compile_script_path = os.path.join(renderer_path, 'compile_mesh_painter.sh')
+                if os.path.exists(compile_script_path):
+                    logger.info(f"🖌️ Compiling mesh painter in {renderer_path}...")
+                    subprocess.run(['bash', 'compile_mesh_painter.sh'], cwd=renderer_path, check=True, capture_output=True, text=True)
+                
+                logger.info("✅ Hunyuan3D setup completed successfully.")
 
-                        # Dynamically load the modules from the downloaded paths
-                        shape_infer_path = os.path.join(self.model_path, 'hy3dshape', 'infer.py')
-                        paint_infer_path = os.path.join(self.model_path, 'hy3dpaint', 'infer.py')
+                # --- Pipeline Initialization ---
+                logger.info("✈️ Initializing Hunyuan3D pipelines...")
+                
+                # Add subdirectories to Python path
+                sys.path.insert(0, os.path.join(self.model_path, 'hy3dshape'))
+                sys.path.insert(0, os.path.join(self.model_path, 'hy3dpaint'))
+                
+                # Import the correct pipelines
+                from hy3dshape.pipelines import Hunyuan3DDiTFlowMatchingPipeline
+                from textureGenPipeline import Hunyuan3DPaintPipeline, Hunyuan3DPaintConfig
 
-                        spec_shape = importlib.util.spec_from_file_location("hy3dshape.infer", shape_infer_path)
-                        shape_module = importlib.util.module_from_spec(spec_shape)
-                        spec_shape.loader.exec_module(shape_module)
-                        self.predict_shape = shape_module.predict_shape
-                        
-                        spec_paint = importlib.util.spec_from_file_location("hy3dpaint.infer", paint_infer_path)
-                        paint_module = importlib.util.module_from_spec(spec_paint)
-                        spec_paint.loader.exec_module(paint_module)
-                        self.predict_texture = paint_module.predict_texture
-                        
-                        self.model = "direct_model"
-                        logger.info("✅ Hunyuan3D modules loaded successfully via importlib")
+                # Instantiate pipelines
+                logger.info("Instantiating shape pipeline...")
+                self.shape_pipeline = Hunyuan3DDiTFlowMatchingPipeline.from_pretrained(
+                    self.model_path, torch_dtype=torch.bfloat16
+                ).to(self.device)
+                
+                logger.info("Instantiating paint pipeline...")
+                paint_config = Hunyuan3DPaintConfig(max_num_view=8, resolution=1024, pbr_optimization=True)
+                self.paint_pipeline = Hunyuan3DPaintPipeline(paint_config)
+
+                self.model = "direct_model"
+                logger.info("✅ Hunyuan3D pipelines loaded successfully.")
 
-                    except (ImportError, FileNotFoundError) as e:
-                        logger.warning(f"⚠️ Could not import Hunyuan3D modules dynamically: {e}")
-                        logger.info("🔄 Using simplified implementation...")
-                        self.model = "simplified"
-                        
-                except Exception as e:
-                    logger.error(f"❌ Failed to set up Hunyuan3D: {e}")
-                    logger.info("🔄 Using fallback mode...")
-                    self.model = "fallback_mode"
-                    
             except Exception as e:
-                logger.error(f"❌ Failed to initialize Hunyuan3D: {e}")
-                logger.info("🔄 Falling back to simple 3D generation...")
-                self.model = "fallback_mode"
+                logger.error(f"❌ Failed to set up Hunyuan3D pipeline: {e}", exc_info=True)
+                logger.warning("🔄 Falling back to simplified 3D generation...")
+                self.model = "simplified"
     
     def image_to_3d(self, 
                    image: Union[str, Image.Image, np.ndarray],
@@ -192,7 +198,7 @@ class Hunyuan3DGenerator:
             return self._generate_fallback_3d(image)
     
     def _generate_with_direct_model(self, image: Image.Image, remove_background: bool, texture_resolution: int) -> str:
-        """Generate 3D model using direct Hunyuan3D model"""
+        """Generate 3D model using the official Hunyuan3D pipelines"""
         
         try:
             # Remove background if requested
@@ -200,38 +206,38 @@ class Hunyuan3DGenerator:
                 logger.info("🎭 Removing background...")
                 image = self._remove_background(image)
             
-            # Save image temporarily
+            # Save image to a temporary file, as pipelines expect a path
             temp_image_path = self._save_temp_image(image)
             
-            # Generate shape
-            logger.info("🔲 Generating 3D shape...")
-            shape_output = self.predict_shape(
-                image_path=temp_image_path,
+            # 1. Generate the untextured mesh
+            logger.info("🔲 Generating 3D shape with Hunyuan3DDiTFlowMatchingPipeline...")
+            # The pipeline returns a list of meshes, we take the first one
+            mesh_untextured_path = self.shape_pipeline(
+                image=temp_image_path,
+                num_inference_steps=self.num_inference_steps,
                 guidance_scale=self.guidance_scale,
-                steps=self.num_inference_steps,
-                seed=random.randint(1, 10000),
-                octree_resolution=self.resolution
-            )
-            
-            # Generate texture
-            logger.info("🎨 Generating texture...")
-            textured_output = self.predict_texture(
-                shape_path=shape_output,
+                seed=random.randint(1, 10000)
+            )[0]
+            logger.info(f"✅ Untextured mesh saved to: {mesh_untextured_path}")
+
+            # 2. Generate the texture for the mesh
+            logger.info("🎨 Generating texture with Hunyuan3DPaintPipeline...")
+            mesh_textured_path = self.paint_pipeline(
+                mesh_path=mesh_untextured_path, 
                 image_path=temp_image_path,
                 guidance_scale=self.guidance_scale,
-                steps=self.num_inference_steps,
-                seed=random.randint(1, 10000),
-                texture_resolution=texture_resolution
+                seed=random.randint(1, 10000)
             )
-            
-            # Save final output
-            output_path = self._save_output_mesh(textured_output)
-            logger.info(f"✅ 3D model generated successfully: {output_path}")
+            logger.info(f"✅ Textured mesh saved to: {mesh_textured_path}")
+
+            # 3. Save the final output to a consistent location
+            output_path = self._save_output_mesh(mesh_textured_path)
+            logger.info(f"✅ 3D model generation successful. Final model at: {output_path}")
             
             return output_path
             
         except Exception as e:
-            logger.error(f"❌ Direct model generation failed: {e}")
+            logger.error(f"❌ Direct model generation failed: {e}", exc_info=True)
             raise
     
     def _generate_simplified_3d(self, image: Image.Image) -> str: