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

voxcity/generator.py

@@ -6,12 +6,19 @@ It handles land cover, building heights, canopy heights, and digital elevation m
 
 The main functions are:
 - get_land_cover_grid: Creates a grid of land cover classifications
-- get_building_height_grid: Creates a grid of building heights 
+- get_building_height_grid: Creates a grid of building heights (supports GeoDataFrame input)
 - get_canopy_height_grid: Creates a grid of tree canopy heights
 - get_dem_grid: Creates a digital elevation model grid
 - create_3d_voxel: Combines the grids into a 3D voxel representation
 - create_3d_voxel_individuals: Creates separate voxel grids for each component
-- get_voxcity: Main function to generate a complete voxel city model
+- get_voxcity: Main function to generate a complete voxel city model (supports GeoDataFrame input)
+
+Key Features:
+- Support for multiple data sources (OpenStreetMap, ESA WorldCover, Google Earth Engine, etc.)
+- Direct GeoDataFrame input for building data (useful for custom datasets)
+- 3D voxel generation with configurable resolution
+- Visualization capabilities for both 2D grids and 3D models
+- Data export in various formats (GeoTIFF, GeoJSON, pickle)
 """
 
 # Standard library imports
@@ -87,6 +94,7 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwar
             - esri_landcover_year: Year for ESRI land cover data
             - dynamic_world_date: Date for Dynamic World data
             - gridvis: Whether to visualize the grid
+            - default_land_cover_class: Default class for grid cells with no intersecting polygons (default: 'Developed space')
 
     Returns:
         numpy.ndarray: Grid of land cover classifications as integer values
@@ -142,7 +150,8 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwar
     # Different processing for vector vs raster data sources
     if source == 'OpenStreetMap':
         # Process vector data directly from GeoDataFrame
-        land_cover_grid_str = create_land_cover_grid_from_gdf_polygon(land_cover_gdf, meshsize, source, rectangle_vertices)
+        default_class = kwargs.get('default_land_cover_class', 'Developed space')
+        land_cover_grid_str = create_land_cover_grid_from_gdf_polygon(land_cover_gdf, meshsize, source, rectangle_vertices, default_class=default_class)
     else:
         # Process raster data from GeoTIFF file
         land_cover_grid_str = create_land_cover_grid_from_geotiff_polygon(geotiff_path, meshsize, land_cover_classes, rectangle_vertices)
@@ -164,14 +173,15 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwar
     return land_cover_grid_int
 
 # def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir="output", visualization=True, maptiler_API_key=None, file_path=None):
-def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
+def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, building_gdf=None, **kwargs):
     """Creates a grid of building heights.
 
     Args:
         rectangle_vertices: List of coordinates defining the area of interest
         meshsize: Size of each grid cell in meters
-        source: Data source for buildings (e.g. 'OpenStreetMap', 'Microsoft Building Footprints')
+        source: Data source for buildings (e.g. 'OpenStreetMap', 'Microsoft Building Footprints', 'GeoDataFrame')
         output_dir: Directory to save output files
+        building_gdf: Optional GeoDataFrame with building footprint, height and other information
         **kwargs: Additional arguments including:
             - maptiler_API_key: API key for MapTiler
             - building_path: Path to local building data file
@@ -187,7 +197,7 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
     """
 
     # Initialize Earth Engine for satellite-based building data sources
-    if source not in ["OpenStreetMap", "Overture", "Local file"]:
+    if source not in ["OpenStreetMap", "Overture", "Local file", "GeoDataFrame"]:
         initialize_earth_engine()
 
     print("Creating Building Height grid\n ")
@@ -195,32 +205,40 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
 
     os.makedirs(output_dir, exist_ok=True)
     
-    # Fetch building data from primary source
-    # Each source has different data formats and processing requirements
-    if source == 'Microsoft Building Footprints':
-        # Machine learning-derived building footprints from satellite imagery
-        gdf = get_mbfp_gdf(output_dir, rectangle_vertices)
-    elif source == 'OpenStreetMap':
-        # Crowd-sourced building data with varying completeness
-        gdf = load_gdf_from_openstreetmap(rectangle_vertices)
-    elif source == "Open Building 2.5D Temporal":
-        # Special case: this source provides both footprints and heights
-        # Skip GeoDataFrame processing and create grids directly
-        building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_open_building_temporal_polygon(meshsize, rectangle_vertices, output_dir)
-    elif source == 'EUBUCCO v0.1':
-        # European building database with height information
-        gdf = load_gdf_from_eubucco(rectangle_vertices, output_dir)
-    # elif source == "OpenMapTiles":
-    #     # Vector tiles service for building data
-    #     gdf = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
-    elif source == "Overture":
-        # Open building dataset from Overture Maps Foundation
-        gdf = load_gdf_from_overture(rectangle_vertices)
-    elif source == "Local file":
-        # Handle user-provided local building data files
-        _, extension = os.path.splitext(kwargs["building_path"])
-        if extension == ".gpkg":
-            gdf = get_gdf_from_gpkg(kwargs["building_path"], rectangle_vertices)
+    # If building_gdf is provided, use it directly
+    if building_gdf is not None:
+        gdf = building_gdf
+        print("Using provided GeoDataFrame for building data")
+    else:
+        # Fetch building data from primary source
+        # Each source has different data formats and processing requirements
+        if source == 'Microsoft Building Footprints':
+            # Machine learning-derived building footprints from satellite imagery
+            gdf = get_mbfp_gdf(output_dir, rectangle_vertices)
+        elif source == 'OpenStreetMap':
+            # Crowd-sourced building data with varying completeness
+            gdf = load_gdf_from_openstreetmap(rectangle_vertices)
+        elif source == "Open Building 2.5D Temporal":
+            # Special case: this source provides both footprints and heights
+            # Skip GeoDataFrame processing and create grids directly
+            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_open_building_temporal_polygon(meshsize, rectangle_vertices, output_dir)
+        elif source == 'EUBUCCO v0.1':
+            # European building database with height information
+            gdf = load_gdf_from_eubucco(rectangle_vertices, output_dir)
+        # elif source == "OpenMapTiles":
+        #     # Vector tiles service for building data
+        #     gdf = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
+        elif source == "Overture":
+            # Open building dataset from Overture Maps Foundation
+            gdf = load_gdf_from_overture(rectangle_vertices)
+        elif source == "Local file":
+            # Handle user-provided local building data files
+            _, extension = os.path.splitext(kwargs["building_path"])
+            if extension == ".gpkg":
+                gdf = get_gdf_from_gpkg(kwargs["building_path"], rectangle_vertices)
+        elif source == "GeoDataFrame":
+            # This case is handled by the building_gdf parameter above
+            raise ValueError("When source is 'GeoDataFrame', building_gdf parameter must be provided")
     
     # Handle complementary data sources to fill gaps or provide additional information
     # This allows combining multiple sources for better coverage or accuracy
@@ -590,16 +608,17 @@ def create_3d_voxel_individuals(building_height_grid_ori, land_cover_grid_ori, d
 
     return land_cover_voxel_grid, building_voxel_grid, tree_voxel_grid, dem_voxel_grid, layered_voxel_grid
 
-def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_height_source, dem_source, meshsize, **kwargs):
+def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_height_source, dem_source, meshsize, building_gdf=None, **kwargs):
     """Main function to generate a complete voxel city model.
 
     Args:
         rectangle_vertices: List of coordinates defining the area of interest
-        building_source: Source for building height data (e.g. 'OSM', 'EUBUCCO')
+        building_source: Source for building height data (e.g. 'OSM', 'EUBUCCO', 'GeoDataFrame')
         land_cover_source: Source for land cover data (e.g. 'ESA', 'ESRI') 
         canopy_height_source: Source for tree canopy height data
         dem_source: Source for digital elevation model data ('Flat' or other source)
         meshsize: Size of each grid cell in meters
+        building_gdf: Optional GeoDataFrame with building footprint, height and other information
         **kwargs: Additional keyword arguments including:
             - output_dir: Directory to save output files (default: 'output')
             - min_canopy_height: Minimum height threshold for tree canopy
@@ -607,6 +626,7 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
             - mapvis: Whether to visualize grids on map
             - voxelvis: Whether to visualize 3D voxel model
             - voxelvis_img_save_path: Path to save 3D visualization
+            - default_land_cover_class: Default class for land cover grid cells with no intersecting polygons (default: 'Developed space')
 
     Returns:
         tuple containing:
@@ -633,7 +653,7 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
     land_cover_grid = get_land_cover_grid(rectangle_vertices, meshsize, land_cover_source, output_dir, **kwargs)
     
     # Building footprints and height information
-    building_height_grid, building_min_height_grid, building_id_grid, building_gdf = get_building_height_grid(rectangle_vertices, meshsize, building_source, output_dir, **kwargs)
+    building_height_grid, building_min_height_grid, building_id_grid, building_gdf = get_building_height_grid(rectangle_vertices, meshsize, building_source, output_dir, building_gdf=building_gdf, **kwargs)
     
     # Save building data to file for later analysis or visualization
     if not building_gdf.empty:

voxcity/geoprocessor/draw.py

@@ -25,10 +25,19 @@ Dependencies:
 
 import math
 from pyproj import Proj, transform
-from ipyleaflet import Map, DrawControl, Rectangle, Polygon as LeafletPolygon
-import ipyleaflet
+from ipyleaflet import (
+    Map, 
+    DrawControl, 
+    Rectangle, 
+    Polygon as LeafletPolygon,
+    WidgetControl
+)
 from geopy import distance
 import shapely.geometry as geom
+import geopandas as gpd
+from ipywidgets import VBox, HBox, Button, FloatText, Label, Output, HTML
+import pandas as pd
+from IPython.display import display, clear_output
 
 from .utils import get_coordinates_from_cityname
 
@@ -484,4 +493,268 @@ def display_buildings_and_draw_polygon(building_gdf=None, rectangle_vertices=Non
     draw_control.on_draw(handle_draw)
     m.add_control(draw_control)
 
-    return m, drawn_polygon_vertices
+    return m, drawn_polygon_vertices
+
+def draw_additional_buildings(building_gdf=None, initial_center=None, zoom=17):
+    """
+    Creates an interactive map for drawing building footprints with height input.
+    
+    This function provides an interface for users to:
+    1. Draw building footprints on an interactive map
+    2. Set building height values through a UI widget
+    3. Add new buildings to the existing building_gdf
+    
+    The workflow is:
+    - User draws a polygon on the map
+    - Height input widget appears
+    - User enters height and clicks "Add Building"
+    - Building is added to GeoDataFrame and displayed on map
+    
+    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.
+        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).
+    
+    Returns:
+        tuple: (map_object, updated_building_gdf)
+            - map_object: ipyleaflet Map instance with drawing controls
+            - updated_building_gdf: GeoDataFrame that automatically updates when buildings are added
+    
+    Example:
+        >>> # Start with empty buildings
+        >>> m, buildings = draw_additional_buildings()
+        >>> # Draw buildings on the map...
+        >>> print(buildings)  # Will contain all drawn buildings
+    """
+    
+    # Initialize or copy the building GeoDataFrame
+    if building_gdf is None:
+        # Create empty GeoDataFrame with required columns
+        updated_gdf = gpd.GeoDataFrame(
+            columns=['geometry', 'height', 'building_id'],
+            crs='EPSG:4326'
+        )
+    else:
+        # Make a copy to avoid modifying the original
+        updated_gdf = building_gdf.copy()
+        if 'height' not in updated_gdf.columns:
+            updated_gdf['height'] = 10.0  # Default height
+        if 'building_id' not in updated_gdf.columns:
+            updated_gdf['building_id'] = range(len(updated_gdf))
+    
+    # Determine map center
+    if initial_center is not None:
+        center_lon, center_lat = initial_center
+    elif updated_gdf is not None and len(updated_gdf) > 0:
+        bounds = updated_gdf.total_bounds
+        min_lon, min_lat, max_lon, max_lat = bounds
+        center_lon = (min_lon + max_lon) / 2
+        center_lat = (min_lat + max_lat) / 2
+    else:
+        center_lon, center_lat = -100.0, 40.0
+    
+    # Create the map
+    m = Map(center=(center_lat, center_lon), zoom=zoom, scroll_wheel_zoom=True)
+    
+    # Display existing buildings
+    building_layers = {}
+    for idx, row in updated_gdf.iterrows():
+        if isinstance(row.geometry, geom.Polygon):
+            coords = list(row.geometry.exterior.coords)
+            lat_lon_coords = [(c[1], c[0]) for c in coords[:-1]]
+            
+            height = row.get('height', 10.0)
+            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")
+            )
+            m.add_layer(bldg_layer)
+            building_layers[idx] = bldg_layer
+    
+    # Create UI widgets
+    height_input = FloatText(
+        value=10.0,
+        description='Height (m):',
+        disabled=False,
+        style={'description_width': 'initial'}
+    )
+    
+    add_button = Button(
+        description='Add Building',
+        button_style='success',
+        disabled=True
+    )
+    
+    clear_button = Button(
+        description='Clear Drawing',
+        button_style='warning',
+        disabled=True
+    )
+    
+    status_output = Output()
+    
+    # Create control panel
+    control_panel = VBox([
+        HTML("<h3>Draw Building Tool</h3>"),
+        HTML("<p>1. Draw a polygon on the map<br>2. Set height<br>3. Click 'Add Building'</p>"),
+        height_input,
+        HBox([add_button, clear_button]),
+        status_output
+    ])
+    
+    # Add control panel to map
+    widget_control = WidgetControl(widget=control_panel, position='topright')
+    m.add_control(widget_control)
+    
+    # Store the current drawn polygon
+    current_polygon = {'vertices': [], 'layer': None}
+    
+    # Drawing control
+    draw_control = DrawControl(
+        polygon={
+            "shapeOptions": {
+                "color": "red",
+                "fillColor": "red",
+                "fillOpacity": 0.3,
+                "weight": 3
+            }
+        },
+        rectangle={},
+        circle={},
+        circlemarker={},
+        polyline={},
+        marker={}
+    )
+    
+    def handle_draw(self, action, geo_json):
+        """Handle polygon drawing events"""
+        with status_output:
+            clear_output()
+            
+        if action == 'created' and geo_json['geometry']['type'] == 'Polygon':
+            # Store vertices
+            coordinates = geo_json['geometry']['coordinates'][0]
+            current_polygon['vertices'] = [(coord[0], coord[1]) for coord in coordinates[:-1]]
+            
+            # Enable buttons
+            add_button.disabled = False
+            clear_button.disabled = False
+            
+            with status_output:
+                print(f"Polygon drawn with {len(current_polygon['vertices'])} vertices")
+                print("Set height and click 'Add Building'")
+    
+    def add_building_click(b):
+        """Handle add building button click"""
+        # Use nonlocal to modify the outer scope variable
+        nonlocal updated_gdf
+        
+        with status_output:
+            clear_output()
+            
+            if current_polygon['vertices']:
+                # Create polygon geometry
+                polygon = geom.Polygon(current_polygon['vertices'])
+                
+                # Get next building ID
+                if len(updated_gdf) > 0:
+                    next_id = int(updated_gdf['building_id'].max() + 1)
+                else:
+                    next_id = 1
+                
+                # Create new row data
+                new_row_data = {
+                    'geometry': polygon,
+                    'height': float(height_input.value),
+                    'building_id': next_id
+                }
+                
+                # Add any additional columns
+                for col in updated_gdf.columns:
+                    if col not in new_row_data:
+                        new_row_data[col] = None
+                
+                # Append the new building in-place
+                new_index = len(updated_gdf)
+                updated_gdf.loc[new_index] = new_row_data
+                
+                # Add to map
+                coords = list(polygon.exterior.coords)
+                lat_lon_coords = [(c[1], c[0]) for c in coords[:-1]]
+                
+                new_layer = LeafletPolygon(
+                    locations=lat_lon_coords,
+                    color="blue",
+                    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")
+                )
+                m.add_layer(new_layer)
+                
+                # Clear drawing
+                draw_control.clear()
+                current_polygon['vertices'] = []
+                add_button.disabled = True
+                clear_button.disabled = True
+                
+                print(f"Building {next_id} added successfully!")
+                print(f"Height: {height_input.value}m")
+                print(f"Total buildings: {len(updated_gdf)}")
+    
+    def clear_drawing_click(b):
+        """Handle clear drawing button click"""
+        with status_output:
+            clear_output()
+            draw_control.clear()
+            current_polygon['vertices'] = []
+            add_button.disabled = True
+            clear_button.disabled = True
+            print("Drawing cleared")
+    
+    # Connect event handlers
+    draw_control.on_draw(handle_draw)
+    add_button.on_click(add_building_click)
+    clear_button.on_click(clear_drawing_click)
+    
+    # Add draw control to map
+    m.add_control(draw_control)
+    
+    # Display initial status
+    with status_output:
+        print(f"Total buildings loaded: {len(updated_gdf)}")
+        print("Draw a polygon to add a new building")
+    
+    return m, updated_gdf
+
+
+# Simple convenience function
+def create_building_editor(building_gdf=None, initial_center=None, zoom=17):
+    """
+    Creates and displays an interactive building editor.
+    
+    Args:
+        building_gdf: Existing buildings GeoDataFrame (optional)
+        initial_center: Map center as (lon, lat) tuple (optional)
+        zoom: Initial zoom level (default=17)
+    
+    Returns:
+        GeoDataFrame: The building GeoDataFrame that automatically updates
+    
+    Example:
+        >>> buildings = create_building_editor()
+        >>> # Draw buildings on the displayed map
+        >>> print(buildings)  # Automatically contains all drawn buildings
+    """
+    m, gdf = draw_additional_buildings(building_gdf, initial_center, zoom)
+    display(m)
+    return gdf

voxcity/geoprocessor/grid.py

@@ -412,7 +412,7 @@ def create_land_cover_grid_from_geotiff_polygon(tiff_path, mesh_size, land_cover
     # Flip grid vertically to match geographic orientation
     return np.flipud(grid)
     
-def create_land_cover_grid_from_gdf_polygon(gdf, meshsize, source, rectangle_vertices):
+def create_land_cover_grid_from_gdf_polygon(gdf, meshsize, source, rectangle_vertices, default_class='Developed space'):
     """Create a grid of land cover classes from GeoDataFrame polygon data.
 
     Args:
@@ -420,6 +420,8 @@ def create_land_cover_grid_from_gdf_polygon(gdf, meshsize, source, rectangle_ver
         meshsize (float): Size of each grid cell in meters
         source (str): Source of the land cover data to determine class priorities
         rectangle_vertices (list): List of 4 (lon,lat) coordinate pairs defining the rectangle bounds
+        default_class (str, optional): Default land cover class for cells with no intersecting polygons.
+                                     Defaults to 'Developed space'.
 
     Returns:
         numpy.ndarray: 2D grid of land cover classes as strings
@@ -466,7 +468,7 @@ def create_land_cover_grid_from_gdf_polygon(gdf, meshsize, source, rectangle_ver
     print(f"Adjusted mesh size: {adjusted_meshsize}")
 
     # Initialize grid with default land cover class
-    grid = np.full(grid_size, 'Developed space', dtype=object)
+    grid = np.full(grid_size, default_class, dtype=object)
 
     # Calculate bounding box for spatial indexing
     extent = [min(coord[1] for coord in rectangle_vertices), max(coord[1] for coord in rectangle_vertices),
@@ -485,7 +487,7 @@ def create_land_cover_grid_from_gdf_polygon(gdf, meshsize, source, rectangle_ver
     # Iterate through each grid cell
     for i in range(grid_size[0]):
         for j in range(grid_size[1]):
-            land_cover_class = 'Developed space'
+            land_cover_class = default_class
             cell = create_cell_polygon(origin, i, j, adjusted_meshsize, u_vec, v_vec)
             
             # Check intersections with polygons that could overlap this cell

{voxcity-0.5.27.dist-info → voxcity-0.5.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.5.27
+Version: 0.5.28
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 Author-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
 Maintainer-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>

{voxcity-0.5.27.dist-info → voxcity-0.5.28.dist-info}/RECORD

@@ -1,12 +1,12 @@
 voxcity/__init__.py,sha256=el9v3gfybHOF_GUYPeSOqN0-vCrTW0eU1mcvi0sEfeU,252
-voxcity/generator.py,sha256=h1C2AaLQ1fqdU47UIUZTK1ox8d_c2I1Dql5mdscr7X8,52552
+voxcity/generator.py,sha256=mEggM4FxE7LChTPCspAQmJlAoUz1PVcbaUfY11cMfzQ,54176
 voxcity/downloader/__init__.py,sha256=o_T_EU7hZLGyXxX9wVWn1x-OAa3ThGYdnpgB1_2v3AE,151
 voxcity/downloader/citygml.py,sha256=jVeHCLlJTf7k55OQGX0lZGQAngz_DD2V5TldSqRFlvc,36024
 voxcity/downloader/eubucco.py,sha256=ln1YNaaOgJfxNfCtVbYaMm775-bUvpAA_LDv60_i22w,17875
 voxcity/downloader/gee.py,sha256=O6HhQnUUumg_tTm4pP_cuyu5YjupDA1uKFxZWxD-i2E,23205
 voxcity/downloader/mbfp.py,sha256=UXDVjsO0fnb0fSal9yqrSFEIBThnRmnutnp08kZTmCA,6595
 voxcity/downloader/oemj.py,sha256=iDacTpiqn7RAXuqyEtHP29m0Cycwta5sMy9-GdvX3Fg,12293
-voxcity/downloader/osm.py,sha256=kXiUedT7dwPOQ_4nxXptfeqNb5RKTIsQLG5km7Q8kKk,41645
+voxcity/downloader/osm.py,sha256=9nOVcVE50N76F5uquJbNIFr8Xajff4ac2Uj2oSGcFrc,42591
 voxcity/downloader/overture.py,sha256=4YG2DMwUSSyZKUw_o8cGhMmAkPJon82aPqOFBvrre-Y,11987
 voxcity/downloader/utils.py,sha256=tz6wt4B9BhEOyvoF5OYXlr8rUd5cBEDedWL3j__oT70,3099
 voxcity/exporter/__init__.py,sha256=dvyWJ184Eik9tFc0VviGbzTQzZi7O0JNyrqi_n39pVI,94
@@ -15,8 +15,8 @@ voxcity/exporter/envimet.py,sha256=Sh7s1JdQ6SgT_L2Xd_c4gtEGWK2hTS87bccaoIqik-s,3
 voxcity/exporter/magicavoxel.py,sha256=SfGEgTZRlossKx3Xrv9d3iKSX-HmfQJEL9lZHgWMDX4,12782
 voxcity/exporter/obj.py,sha256=h1_aInpemcsu96fSTwjKMqX2VZAFYbZbElWd4M1ogyI,27973
 voxcity/geoprocessor/__init__.py,sha256=JzPVhhttxBWvaZ0IGX2w7OWL5bCo_TIvpHefWeNXruA,133
-voxcity/geoprocessor/draw.py,sha256=lcBtf4VAWXjk46cInPdSBeiLCTESdxzLOayr_0YOnus,22184
-voxcity/geoprocessor/grid.py,sha256=Uy8Oz4iL7vnPMqp_qtp4dQrs00yd2L9CSIPmF5KnbtI,63961
+voxcity/geoprocessor/draw.py,sha256=qTYzXEF8GKWh3hquirspzlzwXTIzl39y9VuEJ0WjOis,32031
+voxcity/geoprocessor/grid.py,sha256=lhELyznlk4Jt7vnd0uOpMCLPCjrYQjX7qtQq-xHkYE4,64161
 voxcity/geoprocessor/mesh.py,sha256=ElqAE2MA8KZs7yD7B1P88XYmryC6F9nkkP6cXv7FzIk,30777
 voxcity/geoprocessor/network.py,sha256=YynqR0nq_NUra_cQ3Z_56KxfRia1b6-hIzGCj3QT-wE,25137
 voxcity/geoprocessor/polygon.py,sha256=-LonxtW5du3UP61oygqtDJl6GGsCYnUuN9KYwl1UFdc,53707
@@ -30,9 +30,9 @@ voxcity/utils/lc.py,sha256=h2yOWLUIrrummkyMyhRK5VbyrsPtslS0MJov_y0WGIQ,18925
 voxcity/utils/material.py,sha256=H8K8Lq4wBL6dQtgj7esUW2U6wLCOTeOtelkTDJoRgMo,10007
 voxcity/utils/visualization.py,sha256=T-jKrCA4UMm93p-1O678RWM7e99iE0_Lj4wD07efcwI,112918
 voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.5.27.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.5.27.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.5.27.dist-info/METADATA,sha256=Jq5J4RKe0lXE4WjBJER70F2f9A0HgfxH7GWypmwEBXo,26724
-voxcity-0.5.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-voxcity-0.5.27.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.5.27.dist-info/RECORD,,
+voxcity-0.5.28.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.5.28.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.5.28.dist-info/METADATA,sha256=1-Vf32nGdVvGxmOMXMcfTIi4IM92x4uGq5T7qzlDbxY,26724
+voxcity-0.5.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+voxcity-0.5.28.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.5.28.dist-info/RECORD,,