Update app.py

app.py

@@ -1,4 +1,3 @@
-
 import os
 import torch
 import time
@@ -9,26 +8,22 @@ from flask import Flask, request, jsonify, send_file, Response, stream_with_cont
 from werkzeug.utils import secure_filename
 from PIL import Image
 import io
+import zipfile
 import uuid
 import traceback
 from huggingface_hub import snapshot_download
 from flask_cors import CORS
 import numpy as np
 import trimesh
+from transformers import pipeline, AutoImageProcessor, AutoModelForDepthEstimation
+from scipy.ndimage import gaussian_filter
+from scipy import interpolate
 import cv2
-try:
-    from lgm.models import LGM
-except ImportError:
-    LGM = None
-
-os.environ["CUDA_VISIBLE_DEVICES"] = ""
-torch.set_default_device("cpu")
-torch.cuda.is_available = lambda: False
-torch.cuda.device_count = lambda: 0
 
 app = Flask(__name__)
 CORS(app)
 
+# Configure directories
 UPLOAD_FOLDER = '/tmp/uploads'
 RESULTS_FOLDER = '/tmp/results'
 CACHE_DIR = '/tmp/huggingface'
@@ -45,13 +40,18 @@ os.environ['HF_DATASETS_CACHE'] = os.path.join(CACHE_DIR, 'datasets')
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
 
+# Job tracking
 processing_jobs = {}
-lgm_model = None
+
+# Model variables
+dpt_estimator = None
+depth_anything_model = None
+depth_anything_processor = None
 model_loaded = False
 model_loading = False
 
-TIMEOUT_SECONDS = 300
-MAX_DIMENSION = 512  # LGM uses 512x512 inputs
+TIMEOUT_SECONDS = 240
+MAX_DIMENSION = 518  # Depth Anything uses 518x518
 
 class TimeoutError(Exception):
     pass
@@ -88,108 +88,267 @@ def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
 def preprocess_image(image_path):
-    try:
-        img = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
-        if img.shape[2] == 4:  # RGBA
-            alpha = img[:, :, 3]
-            rgb = img[:, :, :3]
-            white_bg = np.ones_like(rgb) * 255
-            mask = alpha[:, :, np.newaxis] / 255.0
-            img = rgb * mask + white_bg * (1 - mask)
-            img = img.astype(np.uint8)
-        img = cv2.resize(img, (512, 512), interpolation=cv2.INTER_LANCZOS4)
-        return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
-    except Exception as e:
-        raise Exception(f"Error preprocessing image: {str(e)}")
+    with Image.open(image_path) as img:
+        img = img.convert("RGB")
+        
+        if img.width > MAX_DIMENSION or img.height > MAX_DIMENSION:
+            if img.width > img.height:
+                new_width = MAX_DIMENSION
+                new_height = int(img.height * (MAX_DIMENSION / img.width))
+            else:
+                new_height = MAX_DIMENSION
+                new_width = int(img.width * (MAX_DIMENSION / img.height))
+            img = img.resize((new_width, new_height), Image.LANCZOS)
+        
+        img_array = np.array(img)
+        if len(img_array.shape) == 3 and img_array.shape[2] == 3:
+            lab = cv2.cvtColor(img_array, cv2.COLOR_RGB2LAB)
+            l, a, b = cv2.split(lab)
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+            cl = clahe.apply(l)
+            enhanced_lab = cv2.merge((cl, a, b))
+            img_array = cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2RGB)
+            img = Image.fromarray(img_array)
+        
+        return img
 
-def load_model():
-    global lgm_model, model_loaded, model_loading
+def load_models():
+    global dpt_estimator, depth_anything_model, depth_anything_processor, model_loaded, model_loading
     
     if model_loaded:
-        return lgm_model
+        return dpt_estimator, depth_anything_model, depth_anything_processor
     
     if model_loading:
         while model_loading and not model_loaded:
             time.sleep(0.5)
-        return lgm_model
+        return dpt_estimator, depth_anything_model, depth_anything_processor
     
     try:
         model_loading = True
-        print("Loading LGM...")
-        
-        model_name = "large-gaussian-model/lgm"
+        print("Loading models...")
         
+        # DPT-Large
+        dpt_model_name = "Intel/dpt-large"
         max_retries = 3
         retry_delay = 5
         for attempt in range(max_retries):
             try:
                 snapshot_download(
-                    repo_id=model_name,
+                    repo_id=dpt_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...")
+                    print(f"DPT download attempt {attempt+1} failed: {str(e)}. Retrying...")
                     time.sleep(retry_delay)
                     retry_delay *= 2
                 else:
                     raise
         
-        if LGM is None:
-            raise ImportError("LGM module not available. Ensure lgm is installed from https://github.com/baaivision/LGM.")
+        dpt_estimator = pipeline(
+            "depth-estimation",
+            model=dpt_model_name,
+            device=-1,  # CPU
+            cache_dir=CACHE_DIR
+        )
+        print("DPT-Large loaded")
+        gc.collect()
+        
+        # Depth Anything
+        da_model_name = "LiheYoung/depth-anything-v2-small"
+        for attempt in range(max_retries):
+            try:
+                snapshot_download(
+                    repo_id=da_model_name,
+                    cache_dir=CACHE_DIR,
+                    resume_download=True,
+                )
+                break
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    print(f"Depth Anything download attempt {attempt+1} failed: {str(e)}. Retrying...")
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                else:
+                    raise
         
-        lgm_model = LGM.from_pretrained(
-            model_name,
-            cache_dir=CACHE_DIR,
-            device="cpu",
+        depth_anything_processor = AutoImageProcessor.from_pretrained(
+            da_model_name,
+            cache_dir=CACHE_DIR
         )
+        depth_anything_model = AutoModelForDepthEstimation.from_pretrained(
+            da_model_name,
+            cache_dir=CACHE_DIR
+        ).to("cpu")
         
         model_loaded = True
-        print("LGM loaded successfully on CPU")
-        return lgm_model
+        print("Depth Anything loaded")
+        return dpt_estimator, depth_anything_model, depth_anything_processor
     
     except Exception as e:
-        print(f"Error loading model: {str(e)}")
+        print(f"Error loading models: {str(e)}")
         print(traceback.format_exc())
         raise
     finally:
         model_loading = False
 
-def generate_3d_model(image, detail_level):
-    try:
-        resolution = {'low': 256, 'medium': 512, 'high': 1024}
-        res = resolution[detail_level]
-        
-        with torch.no_grad():
-            mesh_data = lgm_model.generate_mesh(
-                image,
-                resolution=res,
-                device="cpu"
-            )
-        
-        vertices = np.array(mesh_data['vertices'])
-        faces = np.array(mesh_data['faces'])
-        vertex_colors = np.array(mesh_data['vertex_colors']) if 'vertex_colors' in mesh_data else None
-        
-        trimesh_mesh = trimesh.Trimesh(
-            vertices=vertices,
-            faces=faces,
-            vertex_colors=vertex_colors
-        )
-        
-        trimesh_mesh.apply_transform(trimesh.transformations.rotation_matrix(np.pi, [1, 0, 0]))
-        
-        return trimesh_mesh
-    except Exception as e:
-        raise Exception(f"Error generating 3D model: {str(e)}")
+def fuse_depth_maps(dpt_depth, da_depth, detail_level='medium'):
+    if isinstance(dpt_depth, Image.Image):
+        dpt_depth = np.array(dpt_depth)
+    if isinstance(da_depth, torch.Tensor):
+        da_depth = da_depth.cpu().numpy()
+    if len(dpt_depth.shape) > 2:
+        dpt_depth = np.mean(dpt_depth, axis=2)
+    if len(da_depth.shape) > 2:
+        da_depth = np.mean(da_depth, axis=2)
+    
+    # Resize to match
+    if dpt_depth.shape != da_depth.shape:
+        da_depth = cv2.resize(da_depth, (dpt_depth.shape[1], dpt_depth.shape[0]), interpolation=cv2.INTER_CUBIC)
+    
+    # Normalize
+    p_low_dpt, p_high_dpt = np.percentile(dpt_depth, [1, 99])
+    p_low_da, p_high_da = np.percentile(da_depth, [1, 99])
+    dpt_depth = np.clip((dpt_depth - p_low_dpt) / (p_high_dpt - p_low_dpt), 0, 1) if p_high_dpt > p_low_dpt else dpt_depth
+    da_depth = np.clip((da_depth - p_low_da) / (p_high_da - p_low_da), 0, 1) if p_high_da > p_low_da else da_depth
+    
+    # Edge-aware fusion
+    if detail_level == 'high':
+        weight_da = 0.7  # Favor Depth Anything for details
+        edges = cv2.Canny((da_depth * 255).astype(np.uint8), 50, 150)
+        edge_mask = (edges > 0).astype(np.float32)
+        dpt_weight = gaussian_filter(1 - edge_mask, sigma=1.0)
+        da_weight = gaussian_filter(edge_mask, sigma=1.0)
+        fused_depth = dpt_weight * dpt_depth + da_weight * da_depth * weight_da + (1 - weight_da) * dpt_depth
+    else:
+        weight_da = 0.5 if detail_level == 'medium' else 0.3
+        fused_depth = (1 - weight_da) * dpt_depth + weight_da * da_depth
+    
+    fused_depth = np.clip(fused_depth, 0, 1)
+    return fused_depth
+
+def enhance_depth_map(depth_map, detail_level='medium'):
+    enhanced_depth = depth_map.copy().astype(np.float32)
+    p_low, p_high = np.percentile(enhanced_depth, [1, 99])
+    enhanced_depth = np.clip(enhanced_depth, p_low, p_high)
+    enhanced_depth = (enhanced_depth - p_low) / (p_high - p_low) if p_high > p_low else enhanced_depth
+    
+    if detail_level == 'high':
+        blurred = gaussian_filter(enhanced_depth, sigma=1.5)
+        mask = enhanced_depth - blurred
+        enhanced_depth = enhanced_depth + 1.5 * mask
+        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':
+        blurred = gaussian_filter(enhanced_depth, sigma=1.0)
+        mask = enhanced_depth - blurred
+        enhanced_depth = enhanced_depth + 0.8 * mask
+        enhanced_depth = gaussian_filter(enhanced_depth, sigma=0.5)
+    else:
+        enhanced_depth = gaussian_filter(enhanced_depth, sigma=0.7)
+    
+    enhanced_depth = np.clip(enhanced_depth, 0, 1)
+    return enhanced_depth
+
+def depth_to_mesh(depth_map, image, resolution=100, detail_level='medium'):
+    enhanced_depth = enhance_depth_map(depth_map, detail_level)
+    h, w = enhanced_depth.shape
+    x = np.linspace(0, w-1, resolution)
+    y = np.linspace(0, h-1, resolution)
+    x_grid, y_grid = np.meshgrid(x, y)
+    
+    interp_func = interpolate.RectBivariateSpline(
+        np.arange(h), np.arange(w), enhanced_depth, kx=3, ky=3
+    )
+    z_values = interp_func(y, x, grid=True)
+    
+    if detail_level == 'high':
+        dx = np.gradient(z_values, axis=1)
+        dy = np.gradient(z_values, axis=0)
+        gradient_magnitude = np.sqrt(dx**2 + dy**2)
+        edge_mask = np.clip(gradient_magnitude * 5, 0, 0.2)
+        z_values = z_values + edge_mask * (z_values - gaussian_filter(z_values, sigma=1.0))
+    
+    z_min, z_max = np.percentile(z_values, [2, 98])
+    z_values = (z_values - z_min) / (z_max - z_min) if z_max > z_min else z_values
+    z_scaling = 2.5 if detail_level == 'high' else 2.0 if detail_level == 'medium' else 1.5
+    z_values = z_values * z_scaling
+    
+    x_grid = (x_grid / w - 0.5) * 2.0
+    y_grid = (y_grid / h - 0.5) * 2.0
+    vertices = np.vstack([x_grid.flatten(), -y_grid.flatten(), -z_values.flatten()]).T
+    
+    faces = []
+    for i in range(resolution-1):
+        for j in range(resolution-1):
+            p1 = i * resolution + j
+            p2 = i * resolution + (j + 1)
+            p3 = (i + 1) * resolution + j
+            p4 = (i + 1) * resolution + (j + 1)
+            v1 = vertices[p1]
+            v2 = vertices[p2]
+            v3 = vertices[p3]
+            v4 = vertices[p4]
+            norm1 = np.cross(v2-v1, v4-v1)
+            norm2 = np.cross(v4-v3, v1-v3)
+            if np.dot(norm1, norm2) >= 0:
+                faces.append([p1, p2, p4])
+                faces.append([p1, p4, p3])
+            else:
+                faces.append([p1, p2, p3])
+                faces.append([p2, p4, p3])
+    
+    faces = np.array(faces)
+    mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+    
+    if image:
+        img_array = np.array(image)
+        vertex_colors = np.zeros((vertices.shape[0], 4), dtype=np.uint8)
+        for i in range(resolution):
+            for j in range(resolution):
+                img_x = j * (img_array.shape[1] - 1) / (resolution - 1)
+                img_y = i * (img_array.shape[0] - 1) / (resolution - 1)
+                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)
+                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:
+                    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
+                elif len(img_array.shape) == 3 and img_array.shape[2] == 4:
+                    for c in range(4):
+                        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:
+                    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
+    
+    if detail_level != 'high':
+        mesh = mesh.smoothed(method='laplacian', iterations=1)
+    mesh.fix_normals()
+    return mesh
 
 @app.route('/health', methods=['GET'])
 def health_check():
     return jsonify({
         "status": "healthy",
-        "model": "LGM",
+        "model": "DPT-Large + Depth Anything",
         "device": "cpu"
     }), 200
 
@@ -201,19 +360,16 @@ def progress(job_id):
             return
             
         job = processing_jobs[job_id]
-        
         yield f"data: {json.dumps({'status': 'processing', 'progress': job['progress']})}\n\n"
         
-’T        last_progress = job['progress']
+        last_progress = job['progress']
         check_count = 0
         while job['status'] == 'processing':
             if job['progress'] != last_progress:
                 yield f"data: {json.dumps({'status': 'processing', 'progress': job['progress']})}\n\n"
                 last_progress = job['progress']
-            
             time.sleep(0.5)
             check_count += 1
-            
             if check_count > 60:
                 if 'thread_alive' in job and not job['thread_alive']():
                     job['status'] = 'error'
@@ -241,13 +397,20 @@ def convert_image_to_3d():
         return jsonify({"error": f"File type not allowed. Supported types: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
     
     try:
+        mesh_resolution = min(int(request.form.get('mesh_resolution', 100)), 150)
         output_format = request.form.get('output_format', 'glb').lower()
         detail_level = request.form.get('detail_level', 'medium').lower()
+        texture_quality = request.form.get('texture_quality', 'medium').lower()
     except ValueError:
         return jsonify({"error": "Invalid parameter values"}), 400
     
-    if output_format not in ['glb', 'obj']:
-        return jsonify({"error": "Supported formats: glb, obj"}), 400
+    if output_format not in ['obj', 'glb']:
+        return jsonify({"error": "Unsupported output format. Use 'obj' or 'glb'"}), 400
+    
+    if detail_level == 'high':
+        mesh_resolution = min(int(mesh_resolution * 1.5), 150)
+    elif detail_level == 'low':
+        mesh_resolution = max(int(mesh_resolution * 0.7), 50)
     
     job_id = str(uuid.uuid4())
     output_dir = os.path.join(RESULTS_FOLDER, job_id)
@@ -277,18 +440,37 @@ def convert_image_to_3d():
             processing_jobs[job_id]['progress'] = 10
             
             try:
-                model = load_model()
+                dpt_model, da_model, da_processor = load_models()
                 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)}"
+                processing_jobs[job_id]['error'] = f"Error loading models: {str(e)}"
                 return
             
             try:
-                def generate_3d():
-                    return generate_3d_model(image, detail_level)
+                def estimate_depth():
+                    with torch.no_grad():
+                        # DPT-Large
+                        dpt_result = dpt_model(image)
+                        dpt_depth = dpt_result["depth"]
+                        
+                        # Depth Anything
+                        inputs = da_processor(images=image, return_tensors="pt")
+                        inputs = {k: v.to("cpu") for k, v in inputs.items()}
+                        outputs = da_model(**inputs)
+                        da_depth = outputs.predicted_depth.squeeze()
+                        da_depth = torch.nn.functional.interpolate(
+                            da_depth.unsqueeze(0).unsqueeze(0),
+                            size=(image.height, image.width),
+                            mode='bicubic',
+                            align_corners=False
+                        ).squeeze()
+                        
+                        # Fuse depth maps
+                        fused_depth = fuse_depth_maps(dpt_depth, da_depth, detail_level)
+                        return fused_depth
                 
-                mesh, error = process_with_timeout(generate_3d, [], TIMEOUT_SECONDS)
+                fused_depth, error = process_with_timeout(estimate_depth, [], TIMEOUT_SECONDS)
                 
                 if error:
                     if isinstance(error, TimeoutError):
@@ -298,18 +480,45 @@ def convert_image_to_3d():
                     else:
                         raise error
                         
+                processing_jobs[job_id]['progress'] = 60
+                mesh_resolution_int = int(mesh_resolution)
+                mesh = depth_to_mesh(fused_depth, image, resolution=mesh_resolution_int, detail_level=detail_level)
                 processing_jobs[job_id]['progress'] = 80
                 
-                file_path = os.path.join(output_dir, f"model.{output_format}")
-                mesh.export(file_path, file_type=output_format)
+                if output_format == 'obj':
+                    obj_path = os.path.join(output_dir, "model.obj")
+                    mesh.export(
+                        obj_path,
+                        file_type='obj',
+                        include_normals=True,
+                        include_texture=True
+                    )
+                    zip_path = os.path.join(output_dir, "model.zip")
+                    with zipfile.ZipFile(zip_path, 'w') as zipf:
+                        zipf.write(obj_path, arcname="model.obj")
+                        mtl_path = os.path.join(output_dir, "model.mtl")
+                        if os.path.exists(mtl_path):
+                            zipf.write(mtl_path, arcname="model.mtl")
+                        texture_path = os.path.join(output_dir, "model.png")
+                        if os.path.exists(texture_path):
+                            zipf.write(texture_path, arcname="model.png")
+                    
+                    processing_jobs[job_id]['result_url'] = f"/download/{job_id}"
+                    processing_jobs[job_id]['preview_url'] = f"/preview/{job_id}"
                 
-                processing_jobs[job_id]['result_url'] = f"/download/{job_id}"
-                processing_jobs[job_id]['preview_url'] = f"/preview/{job_id}"
+                elif output_format == 'glb':
+                    glb_path = os.path.join(output_dir, "model.glb")
+                    mesh.export(
+                        glb_path,
+                        file_type='glb'
+                    )
+                    processing_jobs[job_id]['result_url'] = f"/download/{job_id}"
+                    processing_jobs[job_id]['preview_url'] = f"/preview/{job_id}"
                 
                 processing_jobs[job_id]['status'] = 'completed'
                 processing_jobs[job_id]['progress'] = 100
                 print(f"Job {job_id} completed")
-                
+            
             except Exception as e:
                 error_details = traceback.format_exc()
                 processing_jobs[job_id]['status'] = 'error'
@@ -320,7 +529,6 @@ def convert_image_to_3d():
             
             if os.path.exists(filepath):
                 os.remove(filepath)
-            
             gc.collect()
             
         except Exception as e:
@@ -329,7 +537,6 @@ def convert_image_to_3d():
             processing_jobs[job_id]['error'] = f"{str(e)}\n{error_details}"
             print(f"Error processing job {job_id}: {str(e)}")
             print(error_details)
-            
             if os.path.exists(filepath):
                 os.remove(filepath)
     
@@ -345,11 +552,16 @@ def download_model(job_id):
         return jsonify({"error": "Model not found or processing not complete"}), 404
     
     output_dir = os.path.join(RESULTS_FOLDER, job_id)
-    output_format = processing_jobs[job_id]['output_format']
-    file_path = os.path.join(output_dir, f"model.{output_format}")
+    output_format = processing_jobs[job_id].get('output_format', 'glb')
     
-    if os.path.exists(file_path):
-        return send_file(file_path, as_attachment=True, download_name=f"model.{output_format}")
+    if output_format == 'obj':
+        zip_path = os.path.join(output_dir, "model.zip")
+        if os.path.exists(zip_path):
+            return send_file(zip_path, as_attachment=True, download_name="model.zip")
+    else:
+        glb_path = os.path.join(output_dir, "model.glb")
+        if os.path.exists(glb_path):
+            return send_file(glb_path, as_attachment=True, download_name="model.glb")
     
     return jsonify({"error": "File not found"}), 404
 
@@ -359,14 +571,16 @@ def preview_model(job_id):
         return jsonify({"error": "Model not found or processing not complete"}), 404
     
     output_dir = os.path.join(RESULTS_FOLDER, job_id)
-    output_format = processing_jobs[job_id]['output_format']
-    file_path = os.path.join(output_dir, f"model.{output_format}")
+    output_format = processing_jobs[job_id].get('output_format', 'glb')
     
-    if os.path.exists(file_path):
-        if output_format == 'glb':
-            return send_file(file_path, mimetype='model/gltf-binary')
-        else:
-            return send_file(file_path, mimetype='text/plain')
+    if output_format == 'obj':
+        obj_path = os.path.join(output_dir, "model.obj")
+        if os.path.exists(obj_path):
+            return send_file(obj_path, mimetype='model/obj')
+    else:
+        glb_path = os.path.join(output_dir, "model.glb")
+        if os.path.exists(glb_path):
+            return send_file(glb_path, mimetype='model/gltf-binary')
     
     return jsonify({"error": "File not found"}), 404
 
@@ -409,16 +623,23 @@ def model_info(job_id):
         }), 200
     
     output_dir = os.path.join(RESULTS_FOLDER, job_id)
-    output_format = job['output_format']
     model_stats = {}
     
-    file_path = os.path.join(output_dir, f"model.{output_format}")
-    if os.path.exists(file_path):
-        model_stats['model_size'] = os.path.getsize(file_path)
+    if job['output_format'] == 'obj':
+        obj_path = os.path.join(output_dir, "model.obj")
+        zip_path = os.path.join(output_dir, "model.zip")
+        if os.path.exists(obj_path):
+            model_stats['obj_size'] = os.path.getsize(obj_path)
+        if os.path.exists(zip_path):
+            model_stats['package_size'] = os.path.getsize(zip_path)
+    else:
+        glb_path = os.path.join(output_dir, "model.glb")
+        if os.path.exists(glb_path):
+            model_stats['model_size'] = os.path.getsize(glb_path)
     
     return jsonify({
         "status": job['status'],
-        "model_format": output_format,
+        "model_format": job['output_format'],
         "download_url": job['result_url'],
         "preview_url": job['preview_url'],
         "model_stats": model_stats,
@@ -429,7 +650,7 @@ def model_info(job_id):
 @app.route('/', methods=['GET'])
 def index():
     return jsonify({
-        "message": "Image to 3D API (LGM)",
+        "message": "Image to 3D API (DPT-Large + Depth Anything)",
         "endpoints": [
             "/convert",
             "/progress/<job_id>",
@@ -438,13 +659,15 @@ def index():
             "/model-info/<job_id>"
         ],
         "parameters": {
-            "output_format": "glb or obj",
-            "detail_level": "low, medium, or high"
+            "mesh_resolution": "Integer (50-150)",
+            "output_format": "obj or glb",
+            "detail_level": "low, medium, or high",
+            "texture_quality": "low, medium, or high"
         },
-        "description": "Creates 3D models from 2D images using LGM."
+        "description": "Creates high-quality 3D models from 2D images using DPT-Large and Depth Anything."
     }), 200
 
 if __name__ == '__main__':
     cleanup_old_jobs()
     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)