Add cleaned-up app.py and requirements.txt

app.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # 🌍 OSM 3D Environment Generator - Gradio Web App
+# 
+# **Created for easy 3D city modeling from OpenStreetMap data**
+# 
+# This interactive web application allows you to:
+# - ✅ Enter latitude and longitude coordinates
+# - ✅ Specify search radius for buildings
+# - ✅ Generate 3D models from real map data
+# - ✅ Download GLB files for use in 3D software
+# - ✅ View models directly in the browser
+# 
+# **Perfect for architects, urban planners, game developers, and 3D enthusiasts!**
+
+
+
+
+
+
+
+
+
+import gradio as gr
+import requests
+import pyproj
+import shapely.geometry as sg
+import trimesh
+import numpy as np
+import json
+import os
+import re
+import tempfile
+import shutil
+from typing import Tuple, List, Dict, Optional
+import time
+
+
+
+
+# OSM Overpass API URL
+OVERPASS_URL = "http://overpass-api.de/api/interpreter"
+
+def latlon_to_utm(lat: float, lon: float) -> Tuple[float, float]:
+    """Convert WGS84 (lat/lon in degrees) to UTM (meters)."""
+    proj = pyproj.Proj(proj="utm", zone=int((lon + 180) / 6) + 1, ellps="WGS84")
+    x, y = proj(lon, lat)  # Note: pyproj uses (lon, lat) order
+    return x, y
+
+def fetch_osm_data(lat: float, lon: float, radius: int = 500) -> Optional[Dict]:
+    """Fetch OSM data for buildings within a given radius of a coordinate."""
+    query = f"""
+    [out:json];
+    (
+        way(around:{radius},{lat},{lon})[building];
+    );
+    out body;
+    >;
+    out skel qt;
+    """
+    
+    try:
+        response = requests.get(OVERPASS_URL, params={"data": query}, timeout=30)
+        if response.status_code == 200:
+            data = response.json()
+            return data
+        else:
+            return None
+    except Exception as e:
+        print(f"Error fetching OSM data: {e}")
+        return None
+
+def parse_osm_data(osm_data: Dict) -> List[Dict]:
+    """Extract building footprints and heights from OSM data."""
+    buildings = []
+    nodes = {}
+    
+    # Store node locations
+    for element in osm_data["elements"]:
+        if element["type"] == "node":
+            lon, lat = element["lon"], element["lat"]
+            x, y = latlon_to_utm(lat, lon)
+            nodes[element["id"]] = (x, y)
+    
+    # Extract building footprints
+    for element in osm_data["elements"]:
+        if element["type"] == "way":
+            if "tags" in element and "building" in element["tags"]:
+                try:
+                    # Get height from tags
+                    height_str = element["tags"].get("height", "10")
+                    if isinstance(height_str, str):
+                        height_match = re.search(r'(\d+\.?\d*)', height_str)
+                        if height_match:
+                            height = float(height_match.group(1))
+                        else:
+                            height = 10.0
+                    else:
+                        height = float(height_str)
+                    
+                    footprint = [nodes[node_id] for node_id in element["nodes"] if node_id in nodes]
+                    
+                    if len(footprint) >= 3:
+                        if footprint[0] != footprint[-1]:
+                            footprint.append(footprint[0])
+                        
+                        buildings.append({"footprint": footprint, "height": height})
+                        
+                except Exception as e:
+                    continue
+    
+    return buildings
+
+def create_3d_model(buildings: List[Dict]) -> trimesh.Scene:
+    """Create a 3D model using trimesh with PROPER ORIENTATION FIX."""
+    scene = trimesh.Scene()
+    
+    for building in buildings:
+        footprint = building["footprint"]
+        height = building.get("height", 10)
+        
+        if height <= 0:
+            continue
+        
+        try:
+            polygon = sg.Polygon(footprint)
+            if not polygon.is_valid:
+                polygon = polygon.buffer(0)
+                if not polygon.is_valid:
+                    continue
+        except Exception:
+            continue
+        
+        try:
+            # Try triangle engine first, then earcut
+            try:
+                extruded = trimesh.creation.extrude_polygon(polygon, height, engine="triangle")
+            except ValueError:
+                try:
+                    extruded = trimesh.creation.extrude_polygon(polygon, height, engine="earcut")
+                except ValueError:
+                    continue
+            
+            # ✅ PROPER ORIENTATION FIX - This is the solution you provided
+            # This rotates the model so the front view shows properly
+            transform_x = trimesh.transformations.rotation_matrix(np.pi/2, (1, 0, 0))
+            
+            # Also rotate around Z-axis for proper left-right orientation
+            transform_z = trimesh.transformations.rotation_matrix(np.pi, (0, 0, 1))
+            
+            # Apply the transformations
+            extruded.apply_transform(transform_x)
+            extruded.apply_transform(transform_z)
+            
+            # Add to scene
+            scene.add_geometry(extruded)
+            
+        except Exception:
+            continue
+    
+    return scene
+
+def save_3d_model(scene: trimesh.Scene, filename: str) -> bool:
+    """Export the 3D scene to a GLB file."""
+    try:
+        scene.export(filename)
+        return os.path.exists(filename)
+    except Exception:
+        return False
+
+
+
+
+def generate_3d_model(latitude: float, longitude: float, radius: int) -> Tuple[str, str, str]:
+    """Main function to generate 3D model from coordinates."""
+    
+    # Validate inputs
+    if not (-90 <= latitude <= 90):
+        return None, "❌ Error: Latitude must be between -90 and 90", ""
+    
+    if not (-180 <= longitude <= 180):
+        return None, "❌ Error: Longitude must be between -180 and 180", ""
+    
+    if not (10 <= radius <= 2000):
+        return None, "❌ Error: Radius must be between 10 and 2000 meters", ""
+    
+    try:
+        # Step 1: Fetch OSM data
+        status_msg = f"🔍 Fetching OSM data for coordinates: {latitude}, {longitude} with radius: {radius}m..."
+        print(status_msg)
+        
+        osm_data = fetch_osm_data(latitude, longitude, radius)
+        if not osm_data:
+            return None, "❌ Failed to fetch OSM data. Please check coordinates and try again.", ""
+        
+        # Step 2: Parse buildings
+        status_msg += f"\n✅ OSM data fetched successfully\n🏗️ Parsing building data..."
+        buildings = parse_osm_data(osm_data)
+        
+        if not buildings:
+            return None, "❌ No buildings found in this area. Try a different location or larger radius.", ""
+        
+        # Step 3: Create 3D model
+        status_msg += f"\n✅ Found {len(buildings)} buildings\n🏠 Creating 3D model..."
+        scene = create_3d_model(buildings)
+        
+        if len(scene.geometry) == 0:
+            return None, "❌ Could not create 3D model from the buildings found.", ""
+        
+        # Step 4: Save model
+        timestamp = int(time.time())
+        filename = f"osm_3d_model_{timestamp}.glb"
+        
+        status_msg += f"\n✅ 3D model created with {len(scene.geometry)} buildings\n💾 Saving model..."
+        
+        if save_3d_model(scene, filename):
+            file_size = os.path.getsize(filename)
+            final_msg = f"\n✅ SUCCESS! 3D model saved as {filename}\n📁 File size: {file_size:,} bytes ({file_size/1024:.1f} KB)\n🎉 Ready for download!"
+            status_msg += final_msg
+            
+            # Create summary info
+            summary = f"""🌍 **Location**: {latitude}, {longitude}
+📏 **Radius**: {radius} meters
+🏢 **Buildings Found**: {len(buildings)}
+🔧 **3D Geometries Created**: {len(scene.geometry)}
+📁 **File Size**: {file_size/1024:.1f} KB
+⏰ **Generated**: {time.strftime('%Y-%m-%d %H:%M:%S')}"""
+            
+            return filename, status_msg, summary
+        else:
+            return None, "❌ Failed to save 3D model file.", ""
+            
+    except Exception as e:
+        return None, f"❌ Unexpected error: {str(e)}", ""
+
+
+
+
+
+# Create Gradio interface
+def create_gradio_app():
+    """Create and configure the Gradio interface."""
+    
+    with gr.Blocks(title="🌍 OSM 3D Generator", theme=gr.themes.Soft()) as app:
+        
+        # Header
+        gr.Markdown("""
+        # 🌍 OSM 3D Environment Generator
+        
+        **Transform real-world locations into 3D models!**
+        
+        Enter coordinates and radius to generate 3D building models from OpenStreetMap data.
+        Perfect for architecture, urban planning, game development, and 3D visualization.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input section
+                gr.Markdown("## 📍 Location Settings")
+                
+                latitude = gr.Number(
+                    label="🌐 Latitude",
+                    value=40.748817,  # Empire State Building
+                    precision=6,
+                    info="Enter latitude (-90 to 90)"
+                )
+                
+                longitude = gr.Number(
+                    label="🌐 Longitude", 
+                    value=-73.985428,  # Empire State Building
+                    precision=6,
+                    info="Enter longitude (-180 to 180)"
+                )
+                
+                radius = gr.Slider(
+                    label="📏 Search Radius (meters)",
+                    minimum=10,
+                    maximum=2000,
+                    value=500,
+                    step=10,
+                    info="Larger radius = more buildings but slower processing"
+                )
+                
+                generate_btn = gr.Button(
+                    "🚀 Generate 3D Model", 
+                    variant="primary", 
+                    size="lg"
+                )
+                
+                # Examples
+                gr.Markdown("### 🌆 Quick Examples")
+                gr.Examples(
+                    examples=[
+                        [40.748817, -73.985428, 500],  # Empire State Building, NYC
+                        [48.858844, 2.294351, 300],    # Eiffel Tower, Paris
+                        [51.500729, -0.124625, 400],   # Big Ben, London
+                        [35.676098, 139.650311, 600],  # Tokyo Station
+                        [37.819929, -122.478255, 350], # Golden Gate Bridge area
+                    ],
+                    inputs=[latitude, longitude, radius],
+                    label="Click to load famous locations"
+                )
+            
+            with gr.Column(scale=1):
+                # Output section
+                gr.Markdown("## 📥 Generated Model")
+                
+                file_output = gr.File(
+                    label="📁 Download 3D Model (.glb)",
+                    file_types=[".glb"],
+                    visible=False
+                )
+                
+                status_output = gr.Textbox(
+                    label="📊 Generation Status",
+                    lines=8,
+                    max_lines=15,
+                    placeholder="Click 'Generate 3D Model' to start...",
+                    interactive=False
+                )
+                
+                summary_output = gr.Markdown(
+                    "### 📋 Model Summary\nGeneration results will appear here..."
+                )
+        
+        # Info section
+        with gr.Row():
+            gr.Markdown("""
+            ### 💡 Tips for Best Results
+            
+            - **Urban areas** work best (more buildings = better models)
+            - **Start with 300-500m radius** for good balance of detail and speed
+            - **Large cities** like NYC, Paris, Tokyo have excellent building data
+            - **Rural areas** may have fewer or no buildings
+            - **Generated .glb files** can be opened in Blender, Three.js, or online 3D viewers
+            
+            ### 🛠️ Technical Details
+            
+            - Uses **OpenStreetMap** data via Overpass API
+            - Creates **proper 3D building heights** when available
+            - Applies **correct orientation** for front-view display
+            - Exports as **GLB format** (compatible with most 3D software)
+            - **Processing time** varies by area complexity (typically 10-60 seconds)
+            """)
+        
+        # Event handler
+        def handle_generation(lat, lon, rad):
+            """Handle the generation process and update UI."""
+            file_path, status, summary = generate_3d_model(lat, lon, rad)
+            
+            if file_path:
+                return (
+                    gr.update(value=file_path, visible=True),  # file_output
+                    status,                                    # status_output
+                    f"### 📋 Model Summary\n{summary}"        # summary_output
+                )
+            else:
+                return (
+                    gr.update(visible=False),                  # file_output
+                    status,                                    # status_output
+                    "### ❌ Generation Failed\nPlease check the status above and try again."  # summary_output
+                )
+        
+        # Connect the button
+        generate_btn.click(
+            fn=handle_generation,
+            inputs=[latitude, longitude, radius],
+            outputs=[file_output, status_output, summary_output]
+        )
+    
+    return app
+
+
+
+
+# Create and launch the app
+app = create_gradio_app()
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch(
+        share=True,  # Creates public link for Hugging Face
+        server_name="0.0.0.0",  # Allow external connections
+        server_port=7860,  # Standard port for Hugging Face
+        show_error=True,
+        debug=True
+    )
+else:
+    # For Hugging Face Spaces
+    app.launch()
+
+
+# ## 🚀 Deployment Instructions for Hugging Face Spaces
+# 
+# To deploy this app on Hugging Face Spaces:
+# 
+# 1. **Create a new Space** on [Hugging Face](https://huggingface.co/spaces)
+# 2. **Select "Gradio" as the Space SDK**
+# 3. **Upload this notebook** or copy the code to `app.py`
+# 4. **Add requirements.txt** with these dependencies:
+#    ```
+#    gradio
+#    requests
+#    pyproj
+#    shapely
+#    trimesh
+#    numpy
+#    ```
+# 5. **Commit and push** - your app will automatically deploy!
+# 
+# ### 📁 Alternative: Direct Python File
+# You can also copy all the Python code cells into a single `app.py` file for easier deployment.
+# 
+# ### 🔧 Environment Variables (Optional)
+# For production deployment, consider adding:
+# - `GRADIO_SERVER_NAME=0.0.0.0`
+# - `GRADIO_SERVER_PORT=7860`

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+requests
+pyproj
+shapely
+trimesh
+numpy