update1.2

app.py

@@ -69,34 +69,33 @@ async def get_rpk_info(filename: str):
         
         formatted_attrs = []
         
-        # Handle Dictionary return type (common in some PyPRT versions)
-        if isinstance(attrs_info, dict):
-            for name, attr in attrs_info.items():
-                # attr is likely the Attribute object
-                default_val = ""
-                attr_type = "string"
-                
-                if hasattr(attr, 'get_default_value'):
-                    default_val = attr.get_default_value()
-                elif hasattr(attr, 'get_defaultValue'): # Try alternate naming
-                     default_val = attr.get_defaultValue()
-                
-                if hasattr(attr, 'get_type'):
-                    attr_type = str(attr.get_type())
-                
-                formatted_attrs.append({
-                    "name": name,
-                    "type": attr_type,
-                    "defaultValue": default_val
-                })
         # Handle List of Objects return type (standard PyPRT)
-        elif hasattr(attrs_info, '__iter__'):
+        if hasattr(attrs_info, '__iter__'):
              for attr in attrs_info:
                 if hasattr(attr, 'get_name'):
+                    name = attr.get_name()
+                    attr_type = str(attr.get_type())
+                    default_val = attr.get_default_value()
+                    annotations = []
+                    
+                    if hasattr(attr, 'get_annotations'):
+                        py_annotations = attr.get_annotations()
+                        # Convert PyPRT annotations to serializable format
+                        # Annotations are typically list of objects or similar
+                        for anno in py_annotations:
+                            # anno might be an object with get_key(), get_value_type(), get_arguments()
+                            if hasattr(anno, 'get_key'):
+                                key = anno.get_key()
+                                args = []
+                                if hasattr(anno, 'get_arguments'):
+                                    args = anno.get_arguments()
+                                annotations.append({"key": key, "arguments": args})
+
                     formatted_attrs.append({
-                        "name": attr.get_name(),
-                        "type": str(attr.get_type()), 
-                        "defaultValue": attr.get_default_value(),
+                        "name": name,
+                        "type": attr_type, 
+                        "defaultValue": default_val,
+                        "annotations": annotations
                     })
                 elif isinstance(attr, str):
                     # Fallback if list of strings
@@ -109,7 +108,7 @@ async def get_rpk_info(filename: str):
         return {"attributes": formatted_attrs}
     except Exception as e:
         logger.error(f"Error inspecting RPK: {e}")
-        # Return empty attributes instead of 500 if inspection fails, to allow partial functioning
+        # Return empty attributes instead of 500 if inspection fails
         return {"attributes": []}
 
 @app.post("/generate")
@@ -136,41 +135,30 @@ async def generate_model(request: GenerateRequest):
         if geom_dict.get("type") != "Polygon":
              raise HTTPException(status_code=400, detail="Only Polygons are supported")
 
-        # Extract coordinates
-        # Shapely polygon exterior coords: [(x, y, z?), ...]
-        # PyPRT expects flat list or specific structure depending on version
-        # Using simple approach: create initial shape from vertices
-        
-        # Coordinate Processing for Local Tangent Plane
-        # The frontend now sends coordinates in proper local meters (ENU frame).
-        # We do NOT project or transform them. We explicitly trust the frontend input.
-        
-        # We also don't need to re-center, as the frontend sends relative coordinates from the centroid (0,0).
-        # But to be safe, we can ensure centering if the frontend doesn't perfectly center around 0,0.
-        # Actually, DrawTools sends vectors from center, so they are practically centered.
-        # We'll calculate bounds just for logging.
-        bounds = shape.bounds
-        logger.info(f"Received geometry bounds: {bounds}")
+        # 1. Enforce Counter-Clockwise (CCW) Winding
+        # This prevents the model from being generated upside-down (mirrored on Z)
+        if not shape.is_valid:
+             shape = shape.buffer(0)
         
-        # Centroid should be near 0,0
+        # shapely.ops.orient(geom, sign=1.0) -> CCW
+        shape = shapely.ops.orient(shape, sign=1.0)
+
+        # 2. Re-Center Geometry
+        # To ensure the model is generated around (0,0,0) so it can be placed correctly
+        # at the centroid by the frontend.
         centroid = shape.centroid
         logger.info(f"Geometry Centroid: {centroid.x}, {centroid.y}")
-            
-        coords = list(shape.exterior.coords)
+        
+        # Translate shape so centroid is at (0,0)
+        # origin = (0,0)
+        shape_centered = translate(shape, xoff=-centroid.x, yoff=-centroid.y)
+        
+        coords = list(shape_centered.exterior.coords)
         # Remove last point if duplicate (closed loop)
         if coords[0] == coords[-1]:
             coords = coords[:-1]
             
-        # Flatten and ensure 3D (x, z, y) or (x, y, z) - Mapbox/Cesium usually (lng, lat)
-        # PyPRT often expects local coordinates or projected. 
-        # WARNING: PyPRT does not handle re-projection automatically usually.
-        # For this example, we assume coordinates are suitable for PyPRT (e.g. meter based if RPK expects meters)
-        # OR we just pass them and let PyPRT handle if it's geographic.
-        # Standard CityEngine works best with metric local coordinates.
-        
         # Flatten coordinates: [(x, y), ...] -> [x, 0, y, x, 0, y, ...]
-        # PyPRT expects a flattened list of coords.
-        flattened_coords = []
         flattened_coords = []
         for p in coords:
             x = p[0]
@@ -190,10 +178,7 @@ async def generate_model(request: GenerateRequest):
         output_filename = "model"
 
         # Generate
-        # PyPRT generate_model signature: 
-        # (self: ModelGenerator, shapeAttributes: list[dict], rulePackagePath: str, geometryEncoderName: str, geometryEncoderOptions: dict)
-        
-        # Generate using OBJ Encoder (Workaround for broken GLB encoder)
+        # Using OBJ Encdoer for stability
         models = model_generator.generate_model(
             [request.attributes], 
             rpk_path,