Create app.py

app.py

@@ -0,0 +1,107 @@
+import torch
+import gradio as gr
+from PIL import Image
+import numpy as np
+import open3d as o3d
+from transformers import pipeline
+
+class CPUFriendlyImageTo3DConverter:
+    def __init__(self):
+        # Use lighter depth estimation model
+        self.depth_estimator = pipeline(
+            "depth-estimation", 
+            model="facebook/dpt-small"  # Lighter model for CPU
+        )
+    
+    def estimate_depth(self, image):
+        """
+        Estimate depth using a lightweight model
+        """
+        depth_result = self.depth_estimator(image)
+        depth_map = np.array(depth_result['depth'])
+        return depth_map
+    
+    def create_point_cloud(self, image, depth_map):
+        """
+        Convert depth map to 3D point cloud with reduced resolution
+        """
+        img_array = np.array(image)
+        height, width = img_array.shape[:2]
+        
+        # Downsample to reduce computational load
+        step = 5  # Reduce resolution
+        points = []
+        for y in range(0, height, step):
+            for x in range(0, width, step):
+                z = depth_map[y, x]
+                points.append([x, y, z])
+        
+        pcd = o3d.geometry.PointCloud()
+        pcd.points = o3d.utility.Vector3dVector(points)
+        
+        return pcd
+    
+    def convert_to_mesh(self, point_cloud):
+        """
+        Simplified mesh reconstruction for CPU
+        """
+        point_cloud.estimate_normals()
+        
+        # Use simpler mesh reconstruction with lower depth
+        mesh, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
+            point_cloud, depth=6  # Reduced depth for faster processing
+        )
+        
+        return mesh
+    
+    def process_image(self, input_image):
+        """
+        CPU-friendly full pipeline for 3D conversion
+        """
+        # Estimate depth
+        depth_map = self.estimate_depth(input_image)
+        
+        # Create point cloud
+        point_cloud = self.create_point_cloud(input_image, depth_map)
+        
+        # Convert to mesh
+        mesh = self.convert_to_mesh(point_cloud)
+        
+        # Save mesh
+        output_path = "/tmp/converted_3d_model.obj"
+        o3d.io.write_triangle_mesh(output_path, mesh)
+        
+        return output_path
+
+def create_huggingface_space():
+    converter = CPUFriendlyImageTo3DConverter()
+    
+    def convert_image(input_image):
+        try:
+            # Ensure image is in PIL format
+            if not isinstance(input_image, Image.Image):
+                input_image = Image.fromarray(input_image)
+            
+            # Process image
+            output_model = converter.process_image(input_image)
+            return output_model
+        except Exception as e:
+            return f"Error during conversion: {str(e)}"
+    
+    # Gradio Interface
+    iface = gr.Interface(
+        fn=convert_image,
+        inputs=gr.Image(type="pil", label="Input Image"),
+        outputs=[
+            gr.File(label="3D Model (OBJ)"),
+            gr.Textbox(label="Conversion Status")
+        ],
+        title="CPU-Friendly Image to 3D Model Converter",
+        description="Convert images to 3D models using lightweight depth estimation and point cloud reconstruction."
+    )
+    
+    return iface
+
+# Launch the Gradio interface
+demo = create_huggingface_space()
+demo.launch()