Update app.py

app.py

@@ -277,18 +277,16 @@ async def generate_model(request: GenerateRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/generate_i3s")
-async def generate_i3s(request: GenerateI3SRequest):
-    """Generate an I3S Layer (SLPK unpacked) from raw coordinates."""
+async def generate_i3s(request: GenerateRequest):
+    """Generate an I3S Layer (SLPK unpacked) using same logic as GLB generation."""
     
-    # 0. Cleanup Old Layers (as requested)
-    # Remove all subdirectories in LAYERS_DIR to keep server clean
+    # 0. Cleanup Old Layers
     try:
         if os.path.exists(LAYERS_DIR):
             for item in os.listdir(LAYERS_DIR):
                 item_path = os.path.join(LAYERS_DIR, item)
                 if os.path.isdir(item_path):
                     shutil.rmtree(item_path)
-                    logger.info(f"Cleaned up old layer: {item}")
     except Exception as e:
         logger.warning(f"Cleanup failed: {e}")
 
@@ -297,68 +295,74 @@ async def generate_i3s(request: GenerateI3SRequest):
         raise HTTPException(status_code=404, detail="RPK not found")
 
     try:
-        coords = request.coordinates
-        if not coords or len(coords) < 9: # At least 3 points (3 * 3)
-             raise HTTPException(status_code=400, detail="Invalid coordinates. Need at least 3 points (lon, lat, alt).")
-
-        # 1. Project to Web Mercator (EPSG:3857)
-        # Why? 
-        # - It uses Meters (good for CGA generation/scaling).
-        # - It is standard for Web Maps/I3S supported by Cesium.
-        # - Avoids complexity of dynamic UTM zones.
-        
-        target_epsg = 3857 
-        logger.info(f"Projecting I3S geometry to EPSG:{target_epsg} (Web Mercator)")
-        
-        transformer = pyproj.Transformer.from_crs("EPSG:4326", f"EPSG:{target_epsg}", always_xy=True)
-        
-        # 2. Project Points
-        utm_coords = [] # Variable name kept for minimal diff, but now it's Web Mercator
-        num_points = len(coords) // 3
-        
-        for i in range(num_points):
-            idx = i * 3
-            cx = coords[idx]
-            cy = coords[idx+1]
-            cz = coords[idx+2]
-            
-            ux, uy = transformer.transform(cx, cy)
-            utm_coords.extend([ux, uy, cz])
-            
-        # 3. Calculate Anchor (Mercator)
-        anchor_x = utm_coords[0]
-        anchor_y = utm_coords[1]
-        anchor_z = utm_coords[2]
-        
-        # 4. Localize
-        local_coords = []
-        for i in range(num_points):
-            idx = i * 3
-            ux = utm_coords[idx]
-            uy = utm_coords[idx+1]
-            uz = utm_coords[idx+2]
+        # 1. Parse Geometry (Same as generate_model)
+        geom_dict = request.geometry
+        if geom_dict.get("type") == "Feature":
+             geom_dict = geom_dict.get("geometry")
+        
+        shape = shapely.geometry.shape(geom_dict)
+        
+        if geom_dict.get("type") != "Polygon":
+             raise HTTPException(status_code=400, detail="Only Polygons are supported")
+
+        # Re-orient
+        if not shape.is_valid: shape = shape.buffer(0)
+        shape = shapely.ops.orient(shape, sign=-1.0)
+        
+        # 2. Calculate Centroid & Recentering (Same as generate_model)
+        centroid = shape.centroid
+        logger.info(f"I3S Centroid: {centroid.x}, {centroid.y}")
+        
+        # Translate to (0,0)
+        shape_centered = translate(shape, xoff=-centroid.x, yoff=-centroid.y)
+        
+        coords = list(shape_centered.exterior.coords)
+        if coords[0] == coords[-1]: coords = coords[:-1]
             
-            local_coords.extend([ux - anchor_x, uy - anchor_y, uz - anchor_z])
+        # Flatten: [x, 0, y, ...]
+        # Note: Input is degrees, so these are delta degrees.
+        # However, for I3S, we usually need meters. 
+        # BUT user insists on "same method". If "same method" works for GLB, it likely relies on frontend placement.
+        # For I3S, the placement is burned into the file via globalOffset.
+        
+        # If we assume input is Meters (already projected by frontend? No, standard GeoJSON is Lon/Lat).
+        # If we pass delta-degrees to PyPRT, it generates a tiny model.
+        # UNLESS 'generate_model' also does projection?
+        # Checking generate_model... it does NOT project. It just centers.
+        # So it produces a tiny GLB. Cesium scales it? 
+        # CesiumComponent: scale: 1.0. 
+        # PROBABLY the RPK handles the small numbers? Or PyPRT has a setting?
+        # OR the user is mistaken and GLB is also tiny but they haven't noticed?
+        
+        # Wait, if I3S is tiny, `globalOffset` places it correctly but size is wrong.
+        # Let's trust the "Same Method" request.
+        # We pass centroid as globalOffset.
+        
+        flattened_coords = []
+        for p in coords:
+            flattened_coords.extend([p[0], 0, p[1]])
 
-        # 5. Create InitialShape
-        indices = list(range(num_points))
-        face_counts = [num_points]
-        initial_shape = pyprt.InitialShape(local_coords, indices, face_counts)
+        indices = list(range(len(coords)))
+        face_counts = [len(coords)]
+        
+        initial_shape = pyprt.InitialShape(flattened_coords, indices, face_counts)
 
-        # 6. Encoder Options
+        # 3. Encoder Options
         layer_id = str(uuid.uuid4())
         output_dir = os.path.join(LAYERS_DIR, layer_id)
         os.makedirs(output_dir, exist_ok=True)
         
         enc_options = {
-            'sceneType': 'Global', 
-            'sceneWkid': str(target_epsg), # 3857
+            'sceneType': 'Global',
+            'sceneWkid': '4326', # WGS84
             'baseName': 'SceneLayer',
             'sceneName': 'SceneLayer',
             'writePackage': False, 
             'compression': False, 
             'outputPath': output_dir,
-            'globalOffset': [anchor_x, anchor_y, anchor_z] 
+            
+            # Critical: Global Offset is the Centroid
+            'globalOffset': [centroid.x, centroid.y, 0] 
         }
         
         # Clean attributes (same as before)