voxcity 0.5.28__py3-none-any.whl → 0.5.30__py3-none-any.whl

voxcity/geoprocessor/draw.py

@@ -372,6 +372,7 @@ def display_buildings_and_draw_polygon(building_gdf=None, rectangle_vertices=Non
        - Enables free-form polygon drawing
        - Captures vertices in consistent (lon,lat) format
        - Maintains GeoJSON compatibility
+       - Supports multiple polygons with unique IDs and colors
     
     3. Map Initialization:
        - Automatic centering based on input data
@@ -391,10 +392,10 @@ def display_buildings_and_draw_polygon(building_gdf=None, rectangle_vertices=Non
             Default of 17 is optimized for building-level detail.
 
     Returns:
-        tuple: (map_object, drawn_polygon_vertices)
+        tuple: (map_object, drawn_polygons)
             - map_object: ipyleaflet Map instance with building footprints and drawing controls
-            - drawn_polygon_vertices: List that gets updated with (lon,lat) coordinates
-              whenever a new polygon is drawn. Coordinates are in GeoJSON order.
+            - drawn_polygons: List of dictionaries with 'id', 'vertices', and 'color' keys for all drawn polygons.
+              Each polygon has a unique ID and color for easy identification.
 
     Note:
         - Building footprints are displayed in blue with 20% opacity
@@ -402,6 +403,8 @@ def display_buildings_and_draw_polygon(building_gdf=None, rectangle_vertices=Non
         - Drawing tools are restricted to polygon creation only
         - All coordinates are handled in (lon,lat) order internally
         - The function automatically determines appropriate map bounds
+        - Each polygon gets a unique ID and different colors for easy identification
+        - Use get_polygon_vertices() helper function to extract specific polygon data
     """
     # ---------------------------------------------------------
     # 1. Determine a suitable map center via bounding box logic
@@ -452,7 +455,10 @@ def display_buildings_and_draw_polygon(building_gdf=None, rectangle_vertices=Non
     # -----------------------------------------------------------------
     # 3. Enable drawing of polygons, capturing the vertices in Lon-Lat
     # -----------------------------------------------------------------
-    drawn_polygon_vertices = []  # We'll store the newly drawn polygon's vertices here (lon, lat).
+    # Store multiple polygons with IDs and colors
+    drawn_polygons = []  # List of dicts with 'id', 'vertices', 'color' keys
+    polygon_counter = 0
+    polygon_colors = ['red', 'blue', 'green', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
 
     draw_control = DrawControl(
         polygon={
@@ -475,27 +481,36 @@ def display_buildings_and_draw_polygon(building_gdf=None, rectangle_vertices=Non
         ipyleaflet's DrawControl returns standard GeoJSON (lon, lat).
         We'll keep them as (lon, lat).
         """
-        # Clear any previously stored vertices
-        drawn_polygon_vertices.clear()
-
         if action == 'created' and geo_json['geometry']['type'] == 'Polygon':
+            nonlocal polygon_counter
+            polygon_counter += 1
+            
             # The polygon's first ring
             coordinates = geo_json['geometry']['coordinates'][0]
-            print("Vertices of the drawn polygon (Lon-Lat):")
-
-            # Keep GeoJSON (lon,lat) format, skip last repeated coordinate
-            for coord in coordinates[:-1]:
-                lon = coord[0]
-                lat = coord[1]
-                drawn_polygon_vertices.append((lon, lat))
-                print(f" - (lon, lat) = ({lon}, {lat})")
+            vertices = [(coord[0], coord[1]) for coord in coordinates[:-1]]
+            
+            # Assign color (cycle through colors)
+            color = polygon_colors[polygon_counter % len(polygon_colors)]
+            
+            # Store polygon data
+            polygon_data = {
+                'id': polygon_counter,
+                'vertices': vertices,
+                'color': color
+            }
+            drawn_polygons.append(polygon_data)
+            
+            print(f"Polygon {polygon_counter} drawn with {len(vertices)} vertices (color: {color}):")
+            for i, (lon, lat) in enumerate(vertices):
+                print(f"  Vertex {i+1}: (lon, lat) = ({lon}, {lat})")
+            print(f"Total polygons: {len(drawn_polygons)}")
 
     draw_control.on_draw(handle_draw)
     m.add_control(draw_control)
 
-    return m, drawn_polygon_vertices
+    return m, drawn_polygons
 
-def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
+def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17, rectangle_vertices=None):
     """
     Creates an interactive map for drawing building footprints with height input.
     
@@ -513,7 +528,12 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
     Args:
         building_gdf (GeoDataFrame, optional): Existing building footprints to display.
             If None, creates a new empty GeoDataFrame.
-            Must have 'geometry' column and optionally 'height' column.
+            Expected columns: ['id', 'height', 'min_height', 'geometry', 'building_id']
+            - 'id': Integer ID from data sources (e.g., OSM building id)
+            - 'height': Building height in meters (set by user input)
+            - 'min_height': Minimum height in meters (defaults to 0.0)
+            - 'geometry': Building footprint polygon
+            - 'building_id': Unique building identifier
         initial_center (tuple, optional): Initial map center as (lon, lat).
             If None, centers on existing buildings or defaults to (-100, 40).
         zoom (int): Initial zoom level (default=17).
@@ -534,16 +554,21 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
     if building_gdf is None:
         # Create empty GeoDataFrame with required columns
         updated_gdf = gpd.GeoDataFrame(
-            columns=['geometry', 'height', 'building_id'],
+            columns=['id', 'height', 'min_height', 'geometry', 'building_id'],
             crs='EPSG:4326'
         )
     else:
         # Make a copy to avoid modifying the original
         updated_gdf = building_gdf.copy()
+        # Ensure all required columns exist
         if 'height' not in updated_gdf.columns:
             updated_gdf['height'] = 10.0  # Default height
+        if 'min_height' not in updated_gdf.columns:
+            updated_gdf['min_height'] = 0.0  # Default min_height
         if 'building_id' not in updated_gdf.columns:
             updated_gdf['building_id'] = range(len(updated_gdf))
+        if 'id' not in updated_gdf.columns:
+            updated_gdf['id'] = range(len(updated_gdf))
     
     # Determine map center
     if initial_center is not None:
@@ -553,6 +578,8 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
         min_lon, min_lat, max_lon, max_lat = bounds
         center_lon = (min_lon + max_lon) / 2
         center_lat = (min_lat + max_lat) / 2
+    elif rectangle_vertices is not None:
+        center_lon, center_lat = (rectangle_vertices[0][0] + rectangle_vertices[2][0]) / 2, (rectangle_vertices[0][1] + rectangle_vertices[2][1]) / 2
     else:
         center_lon, center_lat = -100.0, 40.0
     
@@ -567,14 +594,19 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
             lat_lon_coords = [(c[1], c[0]) for c in coords[:-1]]
             
             height = row.get('height', 10.0)
+            min_height = row.get('min_height', 0.0)
+            building_id = row.get('building_id', idx)
+            bldg_id = row.get('id', idx)
             bldg_layer = LeafletPolygon(
                 locations=lat_lon_coords,
                 color="blue",
                 fill_color="blue",
                 fill_opacity=0.3,
                 weight=2,
-                popup=HTML(f"<b>Building ID:</b> {row.get('building_id', idx)}<br>"
-                          f"<b>Height:</b> {height}m")
+                popup=HTML(f"<b>Building ID:</b> {building_id}<br>"
+                          f"<b>ID:</b> {bldg_id}<br>"
+                          f"<b>Height:</b> {height}m<br>"
+                          f"<b>Min Height:</b> {min_height}m")
             )
             m.add_layer(bldg_layer)
             building_layers[idx] = bldg_layer
@@ -664,17 +696,21 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
                 # Create polygon geometry
                 polygon = geom.Polygon(current_polygon['vertices'])
                 
-                # Get next building ID
+                # Get next building ID and ID values (ensure uniqueness)
                 if len(updated_gdf) > 0:
-                    next_id = int(updated_gdf['building_id'].max() + 1)
+                    next_building_id = int(updated_gdf['building_id'].max() + 1)
+                    next_id = int(updated_gdf['id'].max() + 1)
                 else:
+                    next_building_id = 1
                     next_id = 1
                 
                 # Create new row data
                 new_row_data = {
                     'geometry': polygon,
                     'height': float(height_input.value),
-                    'building_id': next_id
+                    'min_height': 0.0,  # Default value as requested
+                    'building_id': next_building_id,
+                    'id': next_id
                 }
                 
                 # Add any additional columns
@@ -696,8 +732,10 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
                     fill_color="blue",
                     fill_opacity=0.3,
                     weight=2,
-                    popup=HTML(f"<b>Building ID:</b> {next_id}<br>"
-                              f"<b>Height:</b> {height_input.value}m")
+                    popup=HTML(f"<b>Building ID:</b> {next_building_id}<br>"
+                              f"<b>ID:</b> {next_id}<br>"
+                              f"<b>Height:</b> {height_input.value}m<br>"
+                              f"<b>Min Height:</b> 0.0m")
                 )
                 m.add_layer(new_layer)
                 
@@ -707,8 +745,8 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
                 add_button.disabled = True
                 clear_button.disabled = True
                 
-                print(f"Building {next_id} added successfully!")
-                print(f"Height: {height_input.value}m")
+                print(f"Building {next_building_id} added successfully!")
+                print(f"ID: {next_id}, Height: {height_input.value}m, Min Height: 0.0m")
                 print(f"Total buildings: {len(updated_gdf)}")
     
     def clear_drawing_click(b):
@@ -737,8 +775,43 @@ def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
     return m, updated_gdf
 
 
+def get_polygon_vertices(drawn_polygons, polygon_id=None):
+    """
+    Extract vertices from drawn polygons data structure.
+    
+    This helper function provides a convenient way to extract polygon vertices
+    from the drawn_polygons list returned by display_buildings_and_draw_polygon().
+    
+    Args:
+        drawn_polygons: The drawn_polygons list returned from display_buildings_and_draw_polygon()
+        polygon_id (int, optional): Specific polygon ID to extract. If None, returns all polygons.
+    
+    Returns:
+        If polygon_id is specified: List of (lon, lat) tuples for that polygon
+        If polygon_id is None: List of lists, where each inner list contains (lon, lat) tuples
+    
+    Example:
+        >>> m, polygons = display_buildings_and_draw_polygon()
+        >>> # Draw some polygons...
+        >>> vertices = get_polygon_vertices(polygons, polygon_id=1)  # Get polygon 1
+        >>> all_vertices = get_polygon_vertices(polygons)  # Get all polygons
+    """
+    if not drawn_polygons:
+        return []
+    
+    if polygon_id is not None:
+        # Return specific polygon
+        for polygon in drawn_polygons:
+            if polygon['id'] == polygon_id:
+                return polygon['vertices']
+        return []  # Polygon not found
+    else:
+        # Return all polygons
+        return [polygon['vertices'] for polygon in drawn_polygons]
+
+
 # Simple convenience function
-def create_building_editor(building_gdf=None, initial_center=None, zoom=17):
+def create_building_editor(building_gdf=None, initial_center=None, zoom=17, rectangle_vertices=None):
     """
     Creates and displays an interactive building editor.
     
@@ -755,6 +828,6 @@ def create_building_editor(building_gdf=None, initial_center=None, zoom=17):
         >>> # Draw buildings on the displayed map
         >>> print(buildings)  # Automatically contains all drawn buildings
     """
-    m, gdf = draw_additional_buildings(building_gdf, initial_center, zoom)
+    m, gdf = draw_additional_buildings(building_gdf, initial_center, zoom, rectangle_vertices)
     display(m)
     return gdf