reports

app.py

@@ -4,7 +4,6 @@ import json
 import tempfile
 import shapely.geometry
 import pyprt
-import trimesh
 import glob
 import shutil
 import pyproj
@@ -66,6 +65,61 @@ def get_rpk_path(filename: str):
         return None
     return path
 
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+def _clean_attributes(raw: Dict[str, Any]) -> Dict[str, Any]:
+    """Sanitise attribute values for PyPRT (ints must be floats, None dropped)."""
+    cleaned = {}
+    for k, v in raw.items():
+        if v is None:
+            continue
+        # PyPRT only accepts float | bool | str for CGA attributes
+        if isinstance(v, int) and not isinstance(v, bool):
+            cleaned[k] = float(v)
+        else:
+            cleaned[k] = v
+    return cleaned
+
+
+def _extract_reports(
+    initial_shape: "pyprt.InitialShape",
+    clean_attrs: Dict[str, Any],
+    rpk_path: str,
+) -> Dict[str, Any]:
+    """
+    Run a dedicated PyEncoder pass (emitGeometry=False, emitReport=True) to
+    collect the CGA report dictionary.
+
+    Background
+    ----------
+    ``GeneratedModel.get_report()`` is **only** populated when the
+    ``com.esri.pyprt.PyEncoder`` is used.  File-based encoders such as
+    ``GLTFEncoder`` and ``I3SEncoder`` write geometry to disk and return an
+    *empty* list from ``generate_model()``, so iterating over that list
+    never reaches ``get_report()``.
+
+    Reference: https://esri.github.io/pyprt/apidoc/pyprt.pyprt.html
+    """
+    reports: Dict[str, Any] = {}
+    try:
+        mg = pyprt.ModelGenerator([initial_shape])
+        report_models = mg.generate_model(
+            [clean_attrs],
+            rpk_path,
+            "com.esri.pyprt.PyEncoder",
+            {"emitReport": True, "emitGeometry": False},
+        )
+        for m in report_models:
+            rep = m.get_report()
+            if rep:
+                reports.update(rep)
+        logger.info(f"CGA reports extracted: {list(reports.keys())}")
+    except Exception as exc:
+        logger.warning(f"Report extraction failed (non-fatal): {exc}")
+    return reports
+
 @app.get("/rpks")
 async def list_rpks():
     """List available RPK files."""
@@ -202,75 +256,73 @@ async def generate_model(request: GenerateRequest):
         # "emitReport": True is needed to get the attributes back? No, that's get_attributes.
         export_options = {
             "outputPath": tempfile.mkdtemp(), # Create a unique temp directory
-            "outputFilename": "model",
-            "emitReport": True, 
-            "emitGeometry": True,
-            # "yUp": False # PyPRT default is Y-up. Cesium is Z-up.
+            "outputFilename": "model",    # GLTFEncoder defaults to building model.glb if we pass proper flags
+            "emitReport": True,
+            "emitGeometry": True
         }
         
         # Generate
         logger.info(f"Generating with RPK: {rpk_path}")
         logger.info(f"Using attributes: {request.attributes}")
         
+        # Sanitise attributes
+        clean_attributes = _clean_attributes(request.attributes)
+        logger.info(f"Clean attributes: {clean_attributes}")
+
         try:
-            model_generator = pyprt.ModelGenerator([initial_shape])
-            
-            # Additional validation for attributes
-            clean_attributes = {}
-            for k, v in request.attributes.items():
-                if v is not None:
-                     # FIX: PyPRT is sensitive to Int vs Float.
-                     # If the attribute is defined as Float in RPK, passing an Int (e.g. 100) causes generation to fail or return no model.
-                     # We convert all standard Integers to Floats to be safe, as CGA attributes are predominantly Floats.
-                     # Note: boolean is a subclass of int, so we must exclude bools.
-                     if isinstance(v, int) and not isinstance(v, bool):
-                         clean_attributes[k] = float(v)
-                     else:
-                         clean_attributes[k] = v
-            
-            logger.info(f"Clean attributes: {clean_attributes}")
+            # Pass 1 – extract CGA reports via PyEncoder
+            # (GLTFEncoder returns an empty list, so get_report() never fires)
+            reports_dict = _extract_reports(initial_shape, clean_attributes, rpk_path)
 
+            # Pass 2 – generate the actual GLB geometry
+            model_generator = pyprt.ModelGenerator([initial_shape])
             models = model_generator.generate_model(
-                [clean_attributes], 
-                rpk_path, 
-                "com.esri.prt.codecs.OBJEncoder", 
-                export_options
+                [clean_attributes],
+                rpk_path,
+                "com.esri.prt.codecs.GLTFEncoder",
+                export_options,
             )
+            # (models is empty for file encoders — that is expected)
+
         except Exception as e:
             logger.error(f"PyPRT Generation Error: {e}")
             import traceback
             traceback.print_exc()
             raise HTTPException(status_code=500, detail=f"PyPRT Generation Failed: {str(e)}")
         
-        # Check for output OBJ files
-        output_path = export_options["outputPath"] # Define output_path here
-        generated_files = glob.glob(os.path.join(output_path, "*.obj"))
+        output_path = export_options["outputPath"]
         
+        # PyPRT GLTFEncoder usually spits out .glb by default, or .gltf
+        generated_files = glob.glob(os.path.join(output_path, "*.glb"))
+        if not generated_files:
+            generated_files = glob.glob(os.path.join(output_path, "*.gltf"))
+            
         if generated_files:
-            obj_path = generated_files[0]
-            glb_path = os.path.join(output_path, "output.glb")
+            glb_path = generated_files[0]
+            logger.info(f"Found GLTF/GLB at {glb_path}")
             
-            logger.info(f"Converting {obj_path} to {glb_path}")
+            # Return JSONResponse where we provide the file download link and the reports
+            # But the requirement from frontend is typically:
+            # - if we want URL and reports together, we need a JSON response
+            # - we can statically serve the generated file if it's placed in a static dir.
+            # Right now, FileResponse is returned directly. 
+            
+            uuid_folder = str(uuid.uuid4())
+            serve_dir = os.path.join(LAYERS_DIR, uuid_folder)
+            os.makedirs(serve_dir, exist_ok=True)
+            
+            final_glb_path = os.path.join(serve_dir, "model.glb")
+            shutil.copy(glb_path, final_glb_path)
+            
+            return JSONResponse(content={
+                "url": f"/layers/{uuid_folder}/model.glb",
+                "reports": reports_dict,
+                "message": "GLB Generated Natively"
+            })
             
-            # Convert OBJ to GLB using Trimesh
-            try:
-                mesh = trimesh.load(obj_path, process=False)
-                mesh.export(glb_path)
-            except Exception as e:
-                logger.error(f"Conversion failed: {e}")
-                raise HTTPException(status_code=500, detail=f"GLB Conversion failed: {str(e)}")
-
-            if os.path.exists(glb_path):
-                # No headers needed for placement logic anymore.
-                # The frontend reconstructs placement from its own state.
-                return FileResponse(glb_path, media_type="model/gltf-binary", filename="output.glb")
-            else:
-                 logger.error(f"GLB file not created at {glb_path}")
-                 raise HTTPException(status_code=500, detail="GLB generation failed: Conversion produced no output")
         else:
-             logger.error(f"No OBJ file found in {output_path}")
-             raise HTTPException(status_code=500, detail="OBJ generation failed: No file created")
-
+             logger.error(f"No GLB/GLTF file found in {output_path}")
+             raise HTTPException(status_code=500, detail="PyPRT Generation failed: No GLB file created")
 
     except Exception as e:
         logger.error(f"Generation error: {e}")
@@ -368,24 +420,23 @@ async def generate_i3s(request: GenerateRequest):
             'globalOffset': anchor_ecef 
         }
         
-        # Clean attributes (same as before)
-        clean_attributes = {}
-        for k, v in request.attributes.items():
-            if v is not None:
-                if isinstance(v, int) and not isinstance(v, bool):
-                    clean_attributes[k] = float(v)
-                else:
-                    clean_attributes[k] = v
-
+        # Sanitise attributes
+        clean_attributes = _clean_attributes(request.attributes)
         logger.info(f"Generating I3S to {output_dir}")
-        
+
+        # Pass 1 – extract CGA reports via PyEncoder
+        # (I3SEncoder returns an empty list, so get_report() never fires)
+        reports_dict = _extract_reports(initial_shape, clean_attributes, rpk_path)
+
+        # Pass 2 – generate the actual I3S scene layer
         model_generator = pyprt.ModelGenerator([initial_shape])
-        model_generator.generate_model(
+        models = model_generator.generate_model(
             [clean_attributes],
             rpk_path,
             'com.esri.prt.codecs.I3SEncoder',
-            enc_options
+            enc_options,
         )
+        # (models is empty for file encoders — that is expected)
         
         # Verify output
         # The encoder usually creates a subfolder based on sceneName or baseName, or just dumps in outputPath?
@@ -430,6 +481,7 @@ async def generate_i3s(request: GenerateRequest):
         return {
             "layerUrl": json_file_path, 
             "layerId": layer_id,
+            "reports": reports_dict,
             "message": "I3S Layer Generated",
             "debug_files": debug_files[:20] # Return first 20 files for debugging
         }
@@ -525,4 +577,90 @@ async def i3s_smart_middleware(request: Request, call_next):
 
 @app.get("/")
 async def root():
-    return {"message": "CityPyPRT 3D Generation API"}
+    return {"message": "CityPyPRT 3D Generation API"}
+
+
+# ---------------------------------------------------------------------------
+# Dedicated report endpoint
+# ---------------------------------------------------------------------------
+
+@app.post("/report")
+async def get_model_report(request: GenerateRequest):
+    """
+    Return **only** the CGA report dict for a given geometry + RPK, without
+    writing any geometry files to disk.
+
+    This uses ``com.esri.pyprt.PyEncoder`` with ``emitReport=True`` and
+    ``emitGeometry=False`` — the only encoder that populates
+    ``GeneratedModel.get_report()``.
+
+    Request body (same as /generate)
+    ---------------------------------
+    .. code-block:: json
+
+        {
+          "rpk_name": "Building.rpk",
+          "geometry": { "type": "Polygon", "coordinates": [...] },
+          "attributes": { "buildingHeight": 30.0 }
+        }
+
+    Response
+    --------
+    .. code-block:: json
+
+        {
+          "report": { "Ground Floor Area": 250.0, "Building Volume": 3200.0 },
+          "rpk_name": "Building.rpk"
+        }
+    """
+    rpk_path = get_rpk_path(request.rpk_name)
+    if not rpk_path:
+        raise HTTPException(status_code=404, detail=f"RPK '{request.rpk_name}' not found")
+
+    try:
+        # --- Parse geometry (same logic as /generate) ---
+        geom_dict = request.geometry
+        if geom_dict.get("type") == "Feature":
+            geom_dict = geom_dict.get("geometry")
+
+        if geom_dict.get("type") != "Polygon":
+            raise HTTPException(status_code=400, detail="Only Polygon geometries are supported")
+
+        shape = shapely.geometry.shape(geom_dict)
+        if not shape.is_valid:
+            shape = shape.buffer(0)
+        shape = shapely.ops.orient(shape, sign=-1.0)  # CW, consistent with /generate
+
+        centroid = shape.centroid
+        shape_centered = translate(shape, xoff=-centroid.x, yoff=-centroid.y)
+
+        coords = list(shape_centered.exterior.coords)
+        if coords[0] == coords[-1]:
+            coords = coords[:-1]
+
+        flattened_coords = []
+        for p in coords:
+            flattened_coords.extend([p[0], 0, p[1]])
+
+        indices = list(range(len(coords)))
+        face_counts = [len(coords)]
+        initial_shape = pyprt.InitialShape(flattened_coords, indices, face_counts)
+
+        # --- Sanitise attributes ---
+        clean_attributes = _clean_attributes(request.attributes)
+
+        # --- Run PyEncoder report pass ---
+        reports_dict = _extract_reports(initial_shape, clean_attributes, rpk_path)
+
+        return JSONResponse(content={
+            "report": reports_dict,
+            "rpk_name": request.rpk_name,
+        })
+
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.error(f"Report endpoint error: {exc}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(exc))