Update app.py

app.py

@@ -11,19 +11,14 @@ import io
 import zipfile
 import uuid
 import traceback
-from huggingface_hub import snapshot_download, hf_hub_download, login
+from huggingface_hub import snapshot_download
 from flask_cors import CORS
 import numpy as np
 import trimesh
-from scipy.ndimage import gaussian_filter
+from transformers import pipeline
+from scipy.ndimage import gaussian_filter, uniform_filter, median_filter
+from scipy import interpolate
 import cv2
-import torch.nn.functional as F
-
-# Try to login with token if available
-HF_TOKEN = os.environ.get("HF_TOKEN", None)
-if HF_TOKEN:
-    print("Logging in with Hugging Face token")
-    login(token=HF_TOKEN)
 
 app = Flask(__name__)
 CORS(app)  # Enable CORS for all routes
@@ -43,7 +38,6 @@ os.makedirs(CACHE_DIR, exist_ok=True)
 os.environ['HF_HOME'] = CACHE_DIR
 os.environ['TRANSFORMERS_CACHE'] = os.path.join(CACHE_DIR, 'transformers')
 os.environ['HF_DATASETS_CACHE'] = os.path.join(CACHE_DIR, 'datasets')
-os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'  # Limit CUDA memory splits
 
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max
@@ -52,16 +46,11 @@ app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max
 processing_jobs = {}
 
 # Global model variables
-depth_model = None
-feature_extractor = None
-openlrm_model = None
+depth_estimator = None
 model_loaded = False
 model_loading = False
 
-# Flag to control whether to use simplified mode (for Hugging Face Spaces)
-USE_SIMPLIFIED_MODE = os.environ.get('USE_SIMPLIFIED_MODE', 'false').lower() == 'true'
-
-# Constants for processing
+# Configuration for processing
 TIMEOUT_SECONDS = 240  # 4 minutes max for processing
 MAX_DIMENSION = 512    # Max image dimension to process
 
@@ -99,16 +88,10 @@ def process_with_timeout(function, args, timeout):
     
     return result[0], None
 
-def optimize_memory():
-    """Free up memory to avoid OOM errors"""
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-# Enhanced image preprocessing
+# Enhanced image preprocessing with better detail preservation
 def preprocess_image(image_path):
     with Image.open(image_path) as img:
         img = img.convert("RGB")
@@ -123,13 +106,14 @@ def preprocess_image(image_path):
                 new_height = MAX_DIMENSION
                 new_width = int(img.width * (MAX_DIMENSION / img.height))
             
-            # Use high-quality Lanczos resampling
+            # Use high-quality Lanczos resampling for better detail preservation
             img = img.resize((new_width, new_height), Image.LANCZOS)
         
         # Convert to numpy array for additional preprocessing
         img_array = np.array(img)
         
-        # Apply adaptive histogram equalization for better contrast
+        # Optional: Apply adaptive histogram equalization for better contrast
+        # This helps the depth model detect more details
         if len(img_array.shape) == 3 and img_array.shape[2] == 3:
             # Convert to LAB color space
             lab = cv2.cvtColor(img_array, cv2.COLOR_RGB2LAB)
@@ -150,419 +134,73 @@ def preprocess_image(image_path):
             
         return img
 
-# Try to remove background - simplified version that won't fail if rembg is not available
-def remove_background(image):
-    """Remove background if rembg is available, otherwise return original image"""
-    try:
-        import rembg
-        return rembg.remove(image)
-    except ImportError:
-        print("Rembg not available, skipping background removal")
-        # Create a copy of the image with RGBA
-        if isinstance(image, Image.Image):
-            if image.mode != 'RGBA':
-                return image.convert('RGBA')
-        return image
-
-# Function to select available models - checks which models are accessible
-def select_available_model():
-    """Try to find an available public model for depth estimation"""
-    public_models = [
-        "facebook/dpt-hybrid-midas",  # Public DPT model
-        "Intel/dpt-large",            # Intel's DPT model
-        "facebook/dinov2-base",       # General vision model
-    ]
-    
-    # Try each model in turn
-    for model_name in public_models:
-        try:
-            print(f"Testing model availability: {model_name}")
-            # Just try to download the config to check if accessible
-            from transformers import AutoConfig
-            AutoConfig.from_pretrained(model_name, force_download=False)
-            print(f"Model {model_name} is available")
-            return model_name
-        except Exception as e:
-            print(f"Model {model_name} not available: {str(e)}")
-    
-    print("No suitable models found. Using manual depth map generation.")
-    return None
-
-# Updated OpenLRM loading with fallback to simplified model
-def load_openlrm_model():
-    global openlrm_model, model_loaded, model_loading
+def load_model():
+    global depth_estimator, model_loaded, model_loading
     
-    if model_loaded and openlrm_model is not None:
-        return openlrm_model
+    if model_loaded:
+        return depth_estimator
     
     if model_loading:
         # Wait for model to load if it's already in progress
         while model_loading and not model_loaded:
             time.sleep(0.5)
-        return openlrm_model
+        return depth_estimator
     
     try:
         model_loading = True
-        print("Initializing 3D model generator...")
+        print("Starting model loading...")
         
-        # Device selection - prefer CUDA if available
-        device = "cuda" if torch.cuda.is_available() else "cpu"
+        # Using DPT-Large which provides better detail than DPT-Hybrid
+        # Alternatively, consider "vinvino02/glpn-nyu" for different detail characteristics
+        model_name = "Intel/dpt-large"
         
-        # Instead of using OpenLRM which is problematic on Spaces, create a simpler wrapper
-        # This will generate basic 3D structure without requiring complex models
-        class Simple3DWrapper:
-            def __init__(self, device):
-                self.device = device
-                print(f"Initialized simple 3D wrapper on {device}")
-                
-            def __call__(self, image):
-                """Create a 3D mesh representation from an image"""
-                # Generate a depth map without complex models
-                depth_map = create_simple_depth_map(image)
-                
-                # Convert depth map to vertices and faces
-                h, w = depth_map.shape
-                vertices = []
-                
-                # Create vertices - scale to [-1, 1] range for x and y
-                scale_factor = 2.0
-                for i in range(h):
-                    for j in range(w):
-                        x = (j / w - 0.5) * scale_factor
-                        y = (i / h - 0.5) * scale_factor
-                        z = depth_map[i, j] * scale_factor * -1  # Negative to make closer objects "pop out"
-                        vertices.append([x, y, z])
-                
-                # Create faces - connect neighboring vertices
-                faces = []
-                for i in range(h-1):
-                    for j in range(w-1):
-                        v0 = i * w + j
-                        v1 = i * w + (j + 1)
-                        v2 = (i + 1) * w + j
-                        v3 = (i + 1) * w + (j + 1)
-                        
-                        # Two triangles per grid cell
-                        faces.append([v0, v1, v3])
-                        faces.append([v0, v3, v2])
-                
-                return {
-                    "vertices": np.array(vertices),
-                    "faces": np.array(faces)
-                }
-        
-        # Create the 3D model wrapper
-        openlrm_model = Simple3DWrapper(device)
+        # Download model with retry mechanism
+        max_retries = 3
+        retry_delay = 5
         
-        model_loaded = True
-        print(f"Simple 3D model generator initialized on {device}")
-        return openlrm_model
-    
-    except Exception as e:
-        print(f"Error initializing 3D model: {str(e)}")
-        print(traceback.format_exc())
-        return None
-    finally:
-        model_loading = False
-
-# Updated depth model loading with public model support
-def load_depth_model():
-    global depth_model, feature_extractor, model_loaded, model_loading
-    
-    if depth_model is not None and feature_extractor is not None:
-        return depth_model, feature_extractor
-    
-    try:
-        print("Loading depth estimation model...")
-        
-        # Select an available public model
-        model_name = select_available_model()
-        
-        if model_name is None:
-            print("No suitable depth model found. Using manual depth map generation.")
-            return None, None
+        for attempt in range(max_retries):
+            try:
+                snapshot_download(
+                    repo_id=model_name,
+                    cache_dir=CACHE_DIR,
+                    resume_download=True,
+                )
+                break
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    print(f"Download attempt {attempt+1} failed: {str(e)}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                else:
+                    raise
         
-        # Device selection
+        # Initialize model with appropriate precision
         device = "cuda" if torch.cuda.is_available() else "cpu"
         
-        # Import appropriate model class for the selected model
-        if "dpt" in model_name.lower():
-            from transformers import DPTForDepthEstimation, DPTFeatureExtractor
-            print(f"Loading DPT model: {model_name}")
-            feature_extractor = DPTFeatureExtractor.from_pretrained(model_name, token=HF_TOKEN)
-            depth_model = DPTForDepthEstimation.from_pretrained(model_name, token=HF_TOKEN)
-        elif "dinov2" in model_name.lower():
-            from transformers import AutoFeatureExtractor, AutoModel
-            print(f"Loading DINOv2 model: {model_name}")
-            feature_extractor = AutoFeatureExtractor.from_pretrained(model_name, token=HF_TOKEN)
-            depth_model = AutoModel.from_pretrained(model_name, token=HF_TOKEN)
-        else:
-            # Generic loading
-            from transformers import AutoFeatureExtractor, AutoModelForDepthEstimation
-            print(f"Loading Auto depth model: {model_name}")
-            feature_extractor = AutoFeatureExtractor.from_pretrained(model_name, token=HF_TOKEN)
-            depth_model = AutoModelForDepthEstimation.from_pretrained(model_name, token=HF_TOKEN)
+        # Load depth estimator pipeline
+        depth_estimator = pipeline(
+            "depth-estimation", 
+            model=model_name,
+            device=device if device == "cuda" else -1,
+            cache_dir=CACHE_DIR
+        )
         
-        # Move to appropriate device
+        # Optimize memory usage
         if device == "cuda":
-            depth_model = depth_model.to(device)
-        
-        print(f"Depth model loaded successfully on {device}")
-        return depth_model, feature_extractor
-    
-    except Exception as e:
-        print(f"Error loading depth model: {str(e)}")
-        print(traceback.format_exc())
-        print("Using manual depth map generation instead.")
-        return None, None
-
-# Create a simple depth map without ML models
-def create_simple_depth_map(image):
-    """Create a simple depth map from image without ML models"""
-    # Convert to numpy array if needed
-    if isinstance(image, Image.Image):
-        img_array = np.array(image)
-    else:
-        img_array = image
-    
-    # Convert to grayscale
-    if len(img_array.shape) == 3 and img_array.shape[2] >= 3:
-        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-    else:
-        gray = img_array.astype(np.uint8)
-    
-    # Apply edge detection
-    edges = cv2.Canny(gray, 100, 200)
-    
-    # Create depth map using blur and edges
-    depth_map = cv2.GaussianBlur(gray, (15, 15), 0)
-    
-    # Combine with edges to preserve details
-    depth_map = depth_map.astype(float) / 255.0
-    edges = edges.astype(float) / 255.0
-    
-    # Edges should be deeper in the depth map
-    depth_map = depth_map * (1.0 - 0.5 * edges)
-    
-    # Center objects usually closer to viewer (create a radial gradient)
-    h, w = depth_map.shape
-    center_y, center_x = h // 2, w // 2
-    y, x = np.ogrid[:h, :w]
-    dist_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2)
-    max_dist = np.sqrt(center_x**2 + center_y**2)
-    dist_factor = dist_from_center / max_dist
-    
-    # Apply center bias - center is closer (lower depth values)
-    depth_map = depth_map + 0.3 * dist_factor
-    
-    # Normalize
-    depth_map = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min() + 1e-10)
-    
-    # Smooth the depth map to avoid artifacts
-    depth_map = gaussian_filter(depth_map, sigma=1.0)
-    
-    return depth_map
-
-# Process image to create 3D model using simplified approach
-def process_openlrm(image, job_id, detail_level='medium', output_format='obj'):
-    try:
-        # Load OpenLRM model - now returns simplified 3D generator
-        model = load_openlrm_model()
-        if model is None:
-            # Fallback to depth-based approach
-            return process_depth_based(image, job_id, detail_level, output_format)
-        
-        # Preprocess image - remove background for better results
-        processing_jobs[job_id]['progress'] = 20
-        image_rgba = remove_background(image)
-        
-        # Update progress
-        processing_jobs[job_id]['progress'] = 40
-        
-        # Process with model to get 3D mesh
-        result = model(image_rgba)
-        
-        # Update progress
-        processing_jobs[job_id]['progress'] = 60
-        
-        # Convert model result to trimesh format
-        mesh = convert_to_trimesh(result, image)
-        
-        # Update progress
-        processing_jobs[job_id]['progress'] = 80
-        
-        # Return the created mesh
-        return mesh
-        
-    except Exception as e:
-        print(f"Error in OpenLRM processing: {str(e)}")
-        print(traceback.format_exc())
-        # Fallback to depth-based approach if OpenLRM fails
-        return process_depth_based(image, job_id, detail_level, output_format)
-
-# Convert OpenLRM result to trimesh
-def convert_to_trimesh(result, image):
-    # Use the provided vertices and faces from the model result
-    vertices = np.array(result.get("vertices", []))
-    faces = np.array(result.get("faces", []))
-    
-    # Create a default mesh if needed
-    if len(vertices) == 0 or len(faces) == 0:
-        # Generate sample vertices and faces
-        x = np.linspace(-1, 1, 20)
-        y = np.linspace(-1, 1, 20)
-        z = np.linspace(-1, 1, 10)
-        
-        # Create grid points
-        xx, yy = np.meshgrid(x, y)
-        zz = np.zeros_like(xx)
-        
-        # Create a simple height field
-        vertices = np.vstack([xx.flatten(), yy.flatten(), zz.flatten()]).T
-        
-        # Create faces
-        faces = []
-        n = 20  # Grid size
-        for i in range(n-1):
-            for j in range(n-1):
-                idx = i*n + j
-                faces.append([idx, idx+1, idx+n])
-                faces.append([idx+1, idx+n+1, idx+n])
-        faces = np.array(faces)
-    
-    # Create mesh with provided data
-    mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
-    
-    # Add texture from the original image
-    if hasattr(image, 'convert'):
-        try:
-            img_array = np.array(image.convert("RGBA"))
-            if img_array.shape[2] == 4:  # RGBA
-                vertex_colors = sample_texture_from_image(img_array, vertices)
-                mesh.visual.vertex_colors = vertex_colors
-        except Exception as e:
-            print(f"Error applying texture: {e}")
-    
-    return mesh
-
-# Sample helper functions for mesh creation
-def sample_texture_from_image(image, vertices):
-    """Sample colors from image based on vertex positions"""
-    # Sample colors from image based on vertex positions
-    h, w = image.shape[:2]
-    colors = np.zeros((len(vertices), 4), dtype=np.uint8)
-    
-    # Find the range of vertex positions
-    min_x, min_y = vertices[:, 0].min(), vertices[:, 1].min()
-    max_x, max_y = vertices[:, 0].max(), vertices[:, 1].max()
-    
-    # Normalize vertex positions to [0,1] for sampling
-    for i, v in enumerate(vertices):
-        # Map from vertex coordinates to image coordinates
-        x_norm = (v[0] - min_x) / (max_x - min_x) if max_x > min_x else 0.5
-        y_norm = (v[1] - min_y) / (max_y - min_y) if max_y > min_y else 0.5
-        
-        # Clamp to valid range
-        x_norm = max(0, min(1, x_norm))
-        y_norm = max(0, min(1, y_norm))
+            torch.cuda.empty_cache()
         
-        # Convert to image coordinates
-        x = int(x_norm * (w-1))
-        y = int(y_norm * (h-1))
-        
-        # Sample color
-        if 0 <= x < w and 0 <= y < h:
-            colors[i] = image[y, x]
-        else:
-            colors[i] = [200, 200, 200, 255]  # Default color
+        model_loaded = True
+        print(f"Model loaded successfully on {device}")
+        return depth_estimator
     
-    return colors
-
-# Process using depth-based approach as fallback
-def process_depth_based(image, job_id, detail_level='medium', output_format='obj'):
-    try:
-        # Load depth model
-        depth_model_result = load_depth_model()
-        
-        # Update progress
-        processing_jobs[job_id]['progress'] = 30
-        
-        # Check if model loading was successful
-        if depth_model_result[0] is None:
-            # Use manual depth map generation
-            print("Using manual depth map generation")
-            depth_map = create_simple_depth_map(image)
-        else:
-            # Extract model and feature extractor
-            depth_model, feature_extractor = depth_model_result
-            
-            # Get depth map from model
-            with torch.no_grad():
-                # Prepare image for the model
-                inputs = feature_extractor(images=image, return_tensors="pt")
-                if torch.cuda.is_available():
-                    inputs = {k: v.cuda() for k, v in inputs.items()}
-                    
-                # Forward pass
-                outputs = depth_model(**inputs)
-                
-                # Different models have different output formats
-                if hasattr(outputs, "predicted_depth"):
-                    predicted_depth = outputs.predicted_depth
-                elif hasattr(outputs, "logits"):  # For some models
-                    predicted_depth = outputs.logits
-                else:
-                    # Generic handling - take the first output tensor
-                    predicted_depth = list(outputs.values())[0]
-                
-                # Resize depth to original image size
-                depth_map = F.interpolate(
-                    predicted_depth.unsqueeze(1),
-                    size=(image.height, image.width),
-                    mode="bicubic",
-                    align_corners=False,
-                ).squeeze().cpu().numpy()
-        
-        # Update progress
-        processing_jobs[job_id]['progress'] = 60
-        
-        # Normalize depth map if from model
-        if 'depth_map' not in locals():
-            depth_min = depth_map.min()
-            depth_max = depth_map.max()
-            depth_normalized = (depth_map - depth_min) / (depth_max - depth_min + 1e-10)
-        else:
-            depth_normalized = depth_map
-        
-        # Create mesh from depth map
-        mesh = depth_to_mesh(depth_normalized, image, 
-                           resolution=100 if detail_level == 'medium' else 
-                                     150 if detail_level == 'high' else 80,
-                           detail_level=detail_level)
-        
-        # Update progress
-        processing_jobs[job_id]['progress'] = 80
-        
-        # Clean up to free memory
-        optimize_memory()
-        
-        return mesh
-        
     except Exception as e:
-        print(f"Error in depth-based processing: {str(e)}")
+        print(f"Error loading model: {str(e)}")
         print(traceback.format_exc())
-        
-        # Ultimate fallback - create a simple mesh from the image
-        try:
-            print("Using emergency fallback mesh generation")
-            depth_map = create_simple_depth_map(image)
-            mesh = depth_to_mesh(depth_map, image, resolution=50, detail_level='low')
-            return mesh
-        except Exception as fallback_error:
-            print(f"Fallback mesh generation failed: {fallback_error}")
-            raise
+        raise
+    finally:
+        model_loading = False
 
-# Enhanced depth map processing
+# Enhanced depth processing function to improve detail quality
 def enhance_depth_map(depth_map, detail_level='medium'):
     """Apply sophisticated processing to enhance depth map details"""
     # Convert to numpy array if needed
@@ -576,7 +214,7 @@ def enhance_depth_map(depth_map, detail_level='medium'):
     # Create a copy for processing
     enhanced_depth = depth_map.copy().astype(np.float32)
     
-    # Remove outliers using percentile clipping
+    # Remove outliers using percentile clipping (more stable than min/max)
     p_low, p_high = np.percentile(enhanced_depth, [1, 99])
     enhanced_depth = np.clip(enhanced_depth, p_low, p_high)
     
@@ -585,26 +223,33 @@ def enhance_depth_map(depth_map, detail_level='medium'):
     
     # Apply different enhancement methods based on detail level
     if detail_level == 'high':
-        # Apply unsharp masking for edge enhancement
+        # Apply unsharp masking for edge enhancement - simulating Hunyuan's detail technique
+        # First apply gaussian blur
         blurred = gaussian_filter(enhanced_depth, sigma=1.5)
+        # Create the unsharp mask
         mask = enhanced_depth - blurred
+        # Apply the mask with strength factor
         enhanced_depth = enhanced_depth + 1.5 * mask
         
-        # Apply bilateral filter simulation
+        # Apply bilateral filter to preserve edges while smoothing noise
+        # Simulate using gaussian combinations
         smooth1 = gaussian_filter(enhanced_depth, sigma=0.5)
         smooth2 = gaussian_filter(enhanced_depth, sigma=2.0)
         edge_mask = enhanced_depth - smooth2
         enhanced_depth = smooth1 + 1.2 * edge_mask
         
     elif detail_level == 'medium':
-        # Less aggressive enhancement
+        # Less aggressive but still effective enhancement
+        # Apply mild unsharp masking
         blurred = gaussian_filter(enhanced_depth, sigma=1.0)
         mask = enhanced_depth - blurred
         enhanced_depth = enhanced_depth + 0.8 * mask
+        
+        # Apply mild smoothing to reduce noise but preserve edges
         enhanced_depth = gaussian_filter(enhanced_depth, sigma=0.5)
         
     else:  # low
-        # Just apply noise reduction
+        # Just apply noise reduction without too much detail enhancement
         enhanced_depth = gaussian_filter(enhanced_depth, sigma=0.7)
     
     # Normalize again after processing
@@ -612,9 +257,9 @@ def enhance_depth_map(depth_map, detail_level='medium'):
     
     return enhanced_depth
 
-# Improved depth to mesh conversion with better detail
+# Convert depth map to 3D mesh with significantly enhanced detail
 def depth_to_mesh(depth_map, image, resolution=100, detail_level='medium'):
-    """Convert depth map to 3D mesh with improved detail preservation"""
+    """Convert depth map to 3D mesh with highly improved detail preservation"""
     # First, enhance the depth map for better details
     enhanced_depth = enhance_depth_map(depth_map, detail_level)
     
@@ -626,31 +271,50 @@ def depth_to_mesh(depth_map, image, resolution=100, detail_level='medium'):
     y = np.linspace(0, h-1, resolution)
     x_grid, y_grid = np.meshgrid(x, y)
     
-    # Sample depth at grid points
-    from scipy import interpolate
+    # Use bicubic interpolation for smoother surface with better details
+    # Create interpolation function
     interp_func = interpolate.RectBivariateSpline(
         np.arange(h), np.arange(w), enhanced_depth, kx=3, ky=3
     )
+    
+    # Sample depth at grid points with the interpolation function
     z_values = interp_func(y, x, grid=True)
     
+    # Apply a post-processing step to enhance small details even further
+    if detail_level == 'high':
+        # Calculate local gradients to detect edges
+        dx = np.gradient(z_values, axis=1) 
+        dy = np.gradient(z_values, axis=0)
+        
+        # Enhance edges by increasing depth differences at high gradient areas
+        gradient_magnitude = np.sqrt(dx**2 + dy**2)
+        edge_mask = np.clip(gradient_magnitude * 5, 0, 0.2)  # Scale and limit effect
+        
+        # Apply edge enhancement
+        z_values = z_values + edge_mask * (z_values - gaussian_filter(z_values, sigma=1.0))
+    
+    # Normalize z-values with advanced scaling for better depth impression
+    z_min, z_max = np.percentile(z_values, [2, 98])  # Remove outliers
+    z_values = (z_values - z_min) / (z_max - z_min) if z_max > z_min else z_values
+    
     # Apply depth scaling appropriate to the detail level
     if detail_level == 'high':
-        z_scaling = 2.5  # More pronounced depth
+        z_scaling = 2.5  # More pronounced depth variations
     elif detail_level == 'medium':
         z_scaling = 2.0  # Standard depth
     else:
-        z_scaling = 1.5  # Subtle depth
+        z_scaling = 1.5  # More subtle depth variations
         
     z_values = z_values * z_scaling
     
-    # Normalize coordinates
+    # Normalize x and y coordinates
     x_grid = (x_grid / w - 0.5) * 2.0  # Map to -1 to 1
     y_grid = (y_grid / h - 0.5) * 2.0  # Map to -1 to 1
     
     # Create vertices
     vertices = np.vstack([x_grid.flatten(), -y_grid.flatten(), -z_values.flatten()]).T
     
-    # Create faces (triangles)
+    # Create faces (triangles) with optimized winding for better normals
     faces = []
     for i in range(resolution-1):
         for j in range(resolution-1):
@@ -659,167 +323,104 @@ def depth_to_mesh(depth_map, image, resolution=100, detail_level='medium'):
             p3 = (i + 1) * resolution + j
             p4 = (i + 1) * resolution + (j + 1)
             
-            # Standard triangulation
-            faces.append([p1, p2, p4])
-            faces.append([p1, p4, p3])
+            # Calculate normals to ensure consistent orientation
+            v1 = vertices[p1]
+            v2 = vertices[p2]
+            v3 = vertices[p3]
+            v4 = vertices[p4]
+            
+            # Calculate normals for both possible triangulations
+            # and choose the one that's more consistent
+            norm1 = np.cross(v2-v1, v4-v1)
+            norm2 = np.cross(v4-v3, v1-v3)
+            
+            if np.dot(norm1, norm2) >= 0:
+                # Standard triangulation
+                faces.append([p1, p2, p4])
+                faces.append([p1, p4, p3])
+            else:
+                # Alternative triangulation for smoother surface
+                faces.append([p1, p2, p3])
+                faces.append([p2, p4, p3])
     
     faces = np.array(faces)
     
     # Create mesh
     mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
     
-    # Apply texturing if image is provided
-    if image is not None:
+    # Apply advanced texturing if image is provided
+    if image:
         # Convert to numpy array if needed
         if isinstance(image, Image.Image):
             img_array = np.array(image)
         else:
             img_array = image
         
-        # Create vertex colors
-        if len(img_array.shape) >= 2:
-            # Create vertex colors by sampling the image
+        # Create vertex colors with improved sampling
+        if resolution <= img_array.shape[0] and resolution <= img_array.shape[1]:
+            # Create vertex colors by sampling the image with bilinear interpolation
             vertex_colors = np.zeros((vertices.shape[0], 4), dtype=np.uint8)
             
+            # Get normalized coordinates for sampling
             for i in range(resolution):
                 for j in range(resolution):
-                    # Calculate image coordinates
-                    img_x = min(max(0, int(j * (img_array.shape[1] - 1) / (resolution - 1))), img_array.shape[1] - 1)
-                    img_y = min(max(0, int(i * (img_array.shape[0] - 1) / (resolution - 1))), img_array.shape[0] - 1)
+                    # Calculate exact image coordinates with proper scaling
+                    img_x = j * (img_array.shape[1] - 1) / (resolution - 1)
+                    img_y = i * (img_array.shape[0] - 1) / (resolution - 1)
+                    
+                    # Bilinear interpolation for smooth color transitions
+                    x0, y0 = int(img_x), int(img_y)
+                    x1, y1 = min(x0 + 1, img_array.shape[1] - 1), min(y0 + 1, img_array.shape[0] - 1)
+                    
+                    # Calculate interpolation weights
+                    wx = img_x - x0
+                    wy = img_y - y0
                     
                     vertex_idx = i * resolution + j
                     
                     if len(img_array.shape) == 3 and img_array.shape[2] == 3:  # RGB
-                        r, g, b = img_array[img_y, img_x]
-                        vertex_colors[vertex_idx] = [r, g, b, 255]
+                        # Perform bilinear interpolation for each color channel
+                        r = int((1-wx)*(1-wy)*img_array[y0, x0, 0] + wx*(1-wy)*img_array[y0, x1, 0] + 
+                                (1-wx)*wy*img_array[y1, x0, 0] + wx*wy*img_array[y1, x1, 0])
+                        g = int((1-wx)*(1-wy)*img_array[y0, x0, 1] + wx*(1-wy)*img_array[y0, x1, 1] + 
+                                (1-wx)*wy*img_array[y1, x0, 1] + wx*wy*img_array[y1, x1, 1])
+                        b = int((1-wx)*(1-wy)*img_array[y0, x0, 2] + wx*(1-wy)*img_array[y0, x1, 2] + 
+                                (1-wx)*wy*img_array[y1, x0, 2] + wx*wy*img_array[y1, x1, 2])
+                        
+                        vertex_colors[vertex_idx, :3] = [r, g, b]
+                        vertex_colors[vertex_idx, 3] = 255  # Alpha
                     elif len(img_array.shape) == 3 and img_array.shape[2] == 4:  # RGBA
-                        vertex_colors[vertex_idx] = img_array[img_y, img_x]
+                        for c in range(4):  # For each RGBA channel
+                            vertex_colors[vertex_idx, c] = int((1-wx)*(1-wy)*img_array[y0, x0, c] + 
+                                                            wx*(1-wy)*img_array[y0, x1, c] + 
+                                                            (1-wx)*wy*img_array[y1, x0, c] + 
+                                                            wx*wy*img_array[y1, x1, c])
                     else:
-                        # Handle grayscale
-                        gray = img_array[img_y, img_x]
-                        if np.isscalar(gray):
-                            vertex_colors[vertex_idx] = [gray, gray, gray, 255]
-                        else:
-                            # Just in case gray is some kind of array
-                            gray_val = np.mean(gray)
-                            vertex_colors[vertex_idx] = [gray_val, gray_val, gray_val, 255]
+                        # Handle grayscale with bilinear interpolation
+                        gray = int((1-wx)*(1-wy)*img_array[y0, x0] + wx*(1-wy)*img_array[y0, x1] + 
+                                  (1-wx)*wy*img_array[y1, x0] + wx*wy*img_array[y1, x1])
+                        vertex_colors[vertex_idx, :3] = [gray, gray, gray]
+                        vertex_colors[vertex_idx, 3] = 255
             
             mesh.visual.vertex_colors = vertex_colors
     
     # Apply smoothing to get rid of staircase artifacts
     if detail_level != 'high':
-        try:
-            # Use laplacian smoothing if available
-            mesh = mesh.smoothed(method='laplacian', iterations=1)
-        except Exception as e:
-            print(f"Smoothing error (non-critical): {e}")
+        # For medium and low detail, apply Laplacian smoothing
+        # but preserve the overall shape
+        mesh = mesh.smoothed(method='laplacian', iterations=1)
     
-    # Fix normals for better rendering
-    try:
-        mesh.fix_normals()
-    except Exception as e:
-        print(f"Normal fixing error (non-critical): {e}")
-    
-    # Simulate full 3D by duplicating and flipping the mesh only if detail level is higher
-    if detail_level == 'high' and not USE_SIMPLIFIED_MODE:
-        try:
-            # Create a complete 3D object by duplicating and flipping the mesh
-            back_mesh = mesh.copy()
-            # Flip to create the back side
-            back_mesh.vertices[:, 2] = -back_mesh.vertices[:, 2] - 0.1  # Add small offset to avoid z-fighting
-            # Fix normals after flipping
-            back_mesh.fix_normals()
-            
-            # Combine front and back meshes
-            combined_mesh = trimesh.util.concatenate([mesh, back_mesh])
-            
-            # Add side panels to create a watertight model
-            combined_mesh = create_watertight_model(combined_mesh)
-            return combined_mesh
-        except Exception as e:
-            print(f"3D completion error (non-critical): {e}")
+    # Calculate and fix normals for better rendering
+    mesh.fix_normals()
     
     return mesh
 
-    # Create a watertight model by adding side panels
-def create_watertight_model(mesh):
-    try:
-        # Extract boundary edges - simplified approach to avoid errors
-        edges = mesh.edges_unique
-        edge_faces = mesh.edges_face
-        boundary_edges = []
-        
-        # Find edges that are only part of one face (boundaries)
-        edge_face_counts = np.bincount(edge_faces.flatten(), minlength=len(mesh.faces))
-        boundary_face_indices = np.where(edge_face_counts == 1)[0]
-        
-        # Get boundary edges
-        for i, edge in enumerate(edges):
-            faces = edge_faces[i]
-            if -1 in faces or len(np.unique(faces)) == 1:
-                boundary_edges.append(edge)
-        
-        # If no boundary edges, return the original mesh
-        if len(boundary_edges) == 0:
-            return mesh
-        
-        # Simplify for Hugging Face Space - just return original mesh
-        if USE_SIMPLIFIED_MODE:
-            return mesh
-            
-        # Create side panels along boundary edges - simplified version
-        new_faces = []
-        new_vertices = mesh.vertices.copy()
-        
-        # Just add a base and close the model
-        min_z = np.min(mesh.vertices[:, 2])
-        max_z = np.max(mesh.vertices[:, 2])
-        
-        # Find vertices near the minimum z height
-        bottom_vertices = np.where(np.isclose(mesh.vertices[:, 2], min_z, atol=0.1))[0]
-        
-        if len(bottom_vertices) > 3:
-            # Create a simple bottom face - simplified approach
-            center = np.mean(mesh.vertices[bottom_vertices], axis=0)
-            center_idx = len(new_vertices)
-            new_vertices = np.vstack([new_vertices, center])
-            
-            # Add triangles connecting the boundary vertices to the center
-            for i in range(len(bottom_vertices)-1):
-                new_faces.append([bottom_vertices[i], bottom_vertices[i+1], center_idx])
-            
-            # Close the loop
-            new_faces.append([bottom_vertices[-1], bottom_vertices[0], center_idx])
-        
-        # Create new mesh with added faces
-        if len(new_faces) > 0:
-            new_faces = np.array(new_faces)
-            combined_faces = np.vstack([mesh.faces, new_faces])
-            watertight_mesh = trimesh.Trimesh(vertices=new_vertices, faces=combined_faces)
-            
-            # Copy vertex colors if they exist
-            if hasattr(mesh.visual, 'vertex_colors') and mesh.visual.vertex_colors is not None:
-                # Extend vertex colors array for new vertices
-                extended_colors = np.vstack([
-                    mesh.visual.vertex_colors,
-                    np.full((len(new_vertices) - len(mesh.vertices), 4), [200, 200, 200, 255], dtype=np.uint8)
-                ])
-                watertight_mesh.visual.vertex_colors = extended_colors
-            
-            return watertight_mesh
-        
-        return mesh
-    except Exception as e:
-        print(f"Watertight model creation failed (non-critical): {e}")
-        return mesh
-
 @app.route('/health', methods=['GET'])
 def health_check():
     return jsonify({
         "status": "healthy", 
-        "model": "Enhanced 3D Model Generator",
-        "device": "cuda" if torch.cuda.is_available() else "cpu",
-        "simplified_mode": USE_SIMPLIFIED_MODE
+        "model": "Enhanced Depth-Based 3D Model Generator (DPT-Large)",
+        "device": "cuda" if torch.cuda.is_available() else "cpu"
     }), 200
 
 @app.route('/progress/<job_id>', methods=['GET'])
@@ -845,14 +446,14 @@ def progress(job_id):
             time.sleep(0.5)
             check_count += 1
             
-            # Check if job is still running
+            # If client hasn't received updates for a while, check if job is still running
             if check_count > 60:  # 30 seconds with no updates
                 if 'thread_alive' in job and not job['thread_alive']():
                     job['status'] = 'error'
                     job['error'] = 'Processing thread died unexpectedly'
                     break
                 check_count = 0
-
+        
         # Send final status
         if job['status'] == 'completed':
             yield f"data: {json.dumps({'status': 'completed', 'progress': 100, 'result_url': job['result_url'], 'preview_url': job['preview_url']})}\n\n"
@@ -879,13 +480,7 @@ def convert_image_to_3d():
         mesh_resolution = min(int(request.form.get('mesh_resolution', 100)), 200)  # Limit max resolution
         output_format = request.form.get('output_format', 'obj').lower()
         detail_level = request.form.get('detail_level', 'medium').lower()  # Parameter for detail level
-        model_type = request.form.get('model_type', 'openlrm').lower()  # 'openlrm' or 'depth'
-        
-        # Adjust parameters for simplified mode
-        if USE_SIMPLIFIED_MODE:
-            mesh_resolution = min(mesh_resolution, 100)  # Lower resolution for simplified mode
-            if detail_level == 'high':
-                detail_level = 'medium'  # Downgrade detail level in simplified mode
+        texture_quality = request.form.get('texture_quality', 'medium').lower()  # New parameter for texture quality
     except ValueError:
         return jsonify({"error": "Invalid parameter values"}), 400
     
@@ -893,6 +488,12 @@ def convert_image_to_3d():
     if output_format not in ['obj', 'glb']:
         return jsonify({"error": "Unsupported output format. Use 'obj' or 'glb'"}), 400
     
+    # Adjust mesh resolution based on detail level
+    if detail_level == 'high':
+        mesh_resolution = min(int(mesh_resolution * 1.5), 200)
+    elif detail_level == 'low':
+        mesh_resolution = max(int(mesh_resolution * 0.7), 50)
+    
     # Create a job ID
     job_id = str(uuid.uuid4())
     output_dir = os.path.join(RESULTS_FOLDER, job_id)
@@ -925,17 +526,58 @@ def convert_image_to_3d():
             image = preprocess_image(filepath)
             processing_jobs[job_id]['progress'] = 10
             
-            # Process image based on selected model type
-            if model_type == 'depth' or model_type == 'depth-based':
-                # Use depth-based approach
-                mesh = process_depth_based(image, job_id, detail_level, output_format)
-            else:
-                # Default to OpenLRM approach
-                mesh = process_openlrm(image, job_id, detail_level, output_format)
+            # Load model
+            try:
+                model = load_model()
+                processing_jobs[job_id]['progress'] = 30
+            except Exception as e:
+                processing_jobs[job_id]['status'] = 'error'
+                processing_jobs[job_id]['error'] = f"Error loading model: {str(e)}"
+                return
             
-            processing_jobs[job_id]['progress'] = 80
+            # Process image with thread-safe timeout
+            try:
+                def estimate_depth():
+                    # Get depth map
+                    result = model(image)
+                    depth_map = result["depth"]
+                    
+                    # Convert to numpy array if needed
+                    if isinstance(depth_map, torch.Tensor):
+                        depth_map = depth_map.cpu().numpy()
+                    elif hasattr(depth_map, 'numpy'):
+                        depth_map = depth_map.numpy()
+                    elif isinstance(depth_map, Image.Image):
+                        depth_map = np.array(depth_map)
+                    
+                    return depth_map
+                
+                depth_map, error = process_with_timeout(estimate_depth, [], TIMEOUT_SECONDS)
+                
+                if error:
+                    if isinstance(error, TimeoutError):
+                        processing_jobs[job_id]['status'] = 'error'
+                        processing_jobs[job_id]['error'] = f"Processing timed out after {TIMEOUT_SECONDS} seconds"
+                        return
+                    else:
+                        raise error
+                        
+                processing_jobs[job_id]['progress'] = 60
+                
+                # Create mesh from depth map with enhanced detail handling
+                mesh_resolution_int = int(mesh_resolution)
+                mesh = depth_to_mesh(depth_map, image, resolution=mesh_resolution_int, detail_level=detail_level)
+                processing_jobs[job_id]['progress'] = 80
+                
+            except Exception as e:
+                error_details = traceback.format_exc()
+                processing_jobs[job_id]['status'] = 'error'
+                processing_jobs[job_id]['error'] = f"Error during processing: {str(e)}"
+                print(f"Error processing job {job_id}: {str(e)}")
+                print(error_details)
+                return
             
-            # Export based on requested format
+            # Export based on requested format with enhanced quality settings
             try:
                 if output_format == 'obj':
                     obj_path = os.path.join(output_dir, "model.obj")
@@ -965,7 +607,7 @@ def convert_image_to_3d():
                     processing_jobs[job_id]['preview_url'] = f"/preview/{job_id}"
                     
                 elif output_format == 'glb':
-                    # Export as GLB
+                    # Export as GLB with enhanced settings
                     glb_path = os.path.join(output_dir, "model.glb")
                     mesh.export(
                         glb_path, 
@@ -978,7 +620,6 @@ def convert_image_to_3d():
                 # Update job status
                 processing_jobs[job_id]['status'] = 'completed'
                 processing_jobs[job_id]['progress'] = 100
-                processing_jobs[job_id]['completed_at'] = time.time()
                 print(f"Job {job_id} completed successfully")
             except Exception as e:
                 error_details = traceback.format_exc()
@@ -992,7 +633,9 @@ def convert_image_to_3d():
                 os.remove(filepath)
             
             # Force garbage collection to free memory
-            optimize_memory()
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
             
         except Exception as e:
             # Handle errors
@@ -1086,7 +729,7 @@ def cleanup_old_jobs():
     # Schedule the next cleanup
     threading.Timer(300, cleanup_old_jobs).start()  # Run every 5 minutes
 
-# Get detailed information about a model
+# New endpoint to get detailed information about a model
 @app.route('/model-info/<job_id>', methods=['GET'])
 def model_info(job_id):
     if job_id not in processing_jobs:
@@ -1135,7 +778,7 @@ def model_info(job_id):
 @app.route('/', methods=['GET'])
 def index():
     return jsonify({
-        "message": "Enhanced 3D Model Generator", 
+        "message": "Enhanced Image to 3D API (DPT-Large Model)", 
         "endpoints": [
             "/convert", 
             "/progress/<job_id>", 
@@ -1147,54 +790,173 @@ def index():
             "mesh_resolution": "Integer (50-200), controls mesh density",
             "output_format": "obj or glb",
             "detail_level": "low, medium, or high - controls the level of detail in the final model",
-            "model_type": "openlrm (default, full 3D) or depth (faster but simpler)"
+            "texture_quality": "low, medium, or high - controls the quality of textures"
         },
-        "description": "This API creates high-quality 3D models from 2D images with full 3D structure and texturing",
-        "simplified_mode": USE_SIMPLIFIED_MODE
+        "description": "This API creates high-quality 3D models from 2D images with enhanced detail finishing similar to Hunyuan model"
     }), 200
 
-# System compatibility check function
-def check_system_compatibility():
-    """Check if the system can run the full model or needs simplified mode"""
-    print("Checking system compatibility...")
+# Example endpoint showing how to compare different detail levels
+@app.route('/detail-comparison', methods=['POST'])
+def compare_detail_levels():
+    # Check if image is in the request
+    if 'image' not in request.files:
+        return jsonify({"error": "No image provided"}), 400
     
-    # Check available memory
-    try:
-        import psutil
-        mem = psutil.virtual_memory()
-        free_mem_gb = mem.available / (1024 ** 3)
-        print(f"Available memory: {free_mem_gb:.2f} GB")
-    except ImportError:
-        print("psutil not available, cannot check memory")
-        free_mem_gb = 1.0  # Assume low memory
-    
-    # Check GPU
-    gpu_available = torch.cuda.is_available()
-    gpu_mem_gb = 0
-    if gpu_available:
+    file = request.files['image']
+    if file.filename == '':
+        return jsonify({"error": "No image selected"}), 400
+    
+    if not allowed_file(file.filename):
+        return jsonify({"error": f"File type not allowed. Supported types: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
+    
+    # Create a job ID
+    job_id = str(uuid.uuid4())
+    output_dir = os.path.join(RESULTS_FOLDER, job_id)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Save the uploaded file
+    filename = secure_filename(file.filename)
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], f"{job_id}_{filename}")
+    file.save(filepath)
+    
+    # Initialize job tracking
+    processing_jobs[job_id] = {
+        'status': 'processing',
+        'progress': 0,
+        'result_url': None,
+        'preview_url': None,
+        'error': None,
+        'output_format': 'glb',  # Use GLB for comparison
+        'created_at': time.time(),
+        'comparison': True
+    }
+    
+    # Process in separate thread to create 3 different detail levels
+    def process_comparison():
+        thread = threading.current_thread()
+        processing_jobs[job_id]['thread_alive'] = lambda: thread.is_alive()
+        
         try:
-            gpu_mem_gb = torch.cuda.get_device_properties(0).total_memory / (1024 ** 3)
-            print(f"GPU available: {gpu_available}, Memory: {gpu_mem_gb:.2f} GB")
+            # Preprocess image
+            image = preprocess_image(filepath)
+            processing_jobs[job_id]['progress'] = 10
+            
+            # Load model
+            try:
+                model = load_model()
+                processing_jobs[job_id]['progress'] = 20
+            except Exception as e:
+                processing_jobs[job_id]['status'] = 'error'
+                processing_jobs[job_id]['error'] = f"Error loading model: {str(e)}"
+                return
+            
+            # Process image to get depth map
+            try:
+                depth_map = model(image)["depth"]
+                if isinstance(depth_map, torch.Tensor):
+                    depth_map = depth_map.cpu().numpy()
+                elif hasattr(depth_map, 'numpy'):
+                    depth_map = depth_map.numpy()
+                elif isinstance(depth_map, Image.Image):
+                    depth_map = np.array(depth_map)
+                
+                processing_jobs[job_id]['progress'] = 40
+            except Exception as e:
+                processing_jobs[job_id]['status'] = 'error'
+                processing_jobs[job_id]['error'] = f"Error estimating depth: {str(e)}"
+                return
+            
+            # Create meshes at different detail levels
+            result_urls = {}
+            
+            for detail_level in ['low', 'medium', 'high']:
+                try:
+                    # Update progress
+                    if detail_level == 'low':
+                        processing_jobs[job_id]['progress'] = 50
+                    elif detail_level == 'medium':
+                        processing_jobs[job_id]['progress'] = 70
+                    else:
+                        processing_jobs[job_id]['progress'] = 90
+                    
+                    # Create mesh with appropriate detail level
+                    mesh_resolution = 100  # Fixed resolution for fair comparison
+                    if detail_level == 'high':
+                        mesh_resolution = 150
+                    elif detail_level == 'low':
+                        mesh_resolution = 80
+                    
+                    mesh = depth_to_mesh(depth_map, image, 
+                                         resolution=mesh_resolution, 
+                                         detail_level=detail_level)
+                    
+                    # Export as GLB
+                    model_path = os.path.join(output_dir, f"model_{detail_level}.glb")
+                    mesh.export(model_path, file_type='glb')
+                    
+                    # Add to result URLs
+                    result_urls[detail_level] = f"/compare-download/{job_id}/{detail_level}"
+                    
+                except Exception as e:
+                    print(f"Error processing {detail_level} detail level: {str(e)}")
+                    # Continue with other detail levels even if one fails
+            
+            # Update job status
+            processing_jobs[job_id]['status'] = 'completed'
+            processing_jobs[job_id]['progress'] = 100
+            processing_jobs[job_id]['result_urls'] = result_urls
+            processing_jobs[job_id]['completed_at'] = time.time()
+            
+            # Clean up temporary file
+            if os.path.exists(filepath):
+                os.remove(filepath)
+            
+            # Force garbage collection
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
         except Exception as e:
-            print(f"Error checking GPU memory: {e}")
-    else:
-        print("No GPU available")
+            # Handle errors
+            processing_jobs[job_id]['status'] = 'error'
+            processing_jobs[job_id]['error'] = f"Error during processing: {str(e)}"
+            
+            # Clean up on error
+            if os.path.exists(filepath):
+                os.remove(filepath)
     
-    # Set simplified mode if limited resources
-    global USE_SIMPLIFIED_MODE
-    if free_mem_gb < 4.0 or (gpu_available and gpu_mem_gb < 2.0):
-        print("Limited resources detected, using simplified mode")
-        USE_SIMPLIFIED_MODE = True
-    else:
-        print("Sufficient resources detected")
+    # Start processing thread
+    processing_thread = threading.Thread(target=process_comparison)
+    processing_thread.daemon = True
+    processing_thread.start()
+    
+    # Return job ID immediately
+    return jsonify({"job_id": job_id, "check_progress_at": f"/progress/{job_id}"}), 202
 
-if __name__ == '__main__':
-    # Check system compatibility
-    check_system_compatibility()
+@app.route('/compare-download/<job_id>/<detail_level>', methods=['GET'])
+def download_comparison_model(job_id, detail_level):
+    if job_id not in processing_jobs or processing_jobs[job_id]['status'] != 'completed':
+        return jsonify({"error": "Model not found or processing not complete"}), 404
+    
+    if 'comparison' not in processing_jobs[job_id] or not processing_jobs[job_id]['comparison']:
+        return jsonify({"error": "This is not a comparison job"}), 400
+    
+    if detail_level not in ['low', 'medium', 'high']:
+        return jsonify({"error": "Invalid detail level"}), 400
     
+    # Get the output directory for this job
+    output_dir = os.path.join(RESULTS_FOLDER, job_id)
+    model_path = os.path.join(output_dir, f"model_{detail_level}.glb")
+    
+    if os.path.exists(model_path):
+        return send_file(model_path, as_attachment=True, download_name=f"model_{detail_level}.glb")
+    
+    return jsonify({"error": "File not found"}), 404
+
+if __name__ == '__main__':
     # Start the cleanup thread
     cleanup_old_jobs()
     
     # Use port 7860 which is standard for Hugging Face Spaces
     port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port)
+    app.run(host='0.0.0.0', port=port)