voxcity 0.3.14__tar.gz → 0.3.15__tar.gz

{voxcity-0.3.14 → voxcity-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.14
+Version: 0.3.15
 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>
@@ -225,7 +225,7 @@ from voxcity import get_voxcity
 
 voxcity_grid, building_height_grid, building_min_height_grid, \
 building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, \
-building_geojson = get_voxcity(
+building_gdf = get_voxcity(
     rectangle_vertices,
     building_source,
     land_cover_source,
@@ -410,7 +410,7 @@ landmark_kwargs = {
     "output_directory": "output",             # Directory to save output files
     "output_file_name": "landmark_visibility" # Base filename for outputs
 }
-landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, building_geojson, meshsize, **landmark_kwargs)
+landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, building_gdf, meshsize, **landmark_kwargs)
 ```
 <p align="center">
   <img src="https://raw.githubusercontent.com/kunifujiwara/VoxCity/main/images/landmark.png" alt="Landmark Visibility Map Rendered in Rhino" width="500">

{voxcity-0.3.14 → voxcity-0.3.15}/README.md

@@ -167,7 +167,7 @@ from voxcity import get_voxcity
 
 voxcity_grid, building_height_grid, building_min_height_grid, \
 building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, \
-building_geojson = get_voxcity(
+building_gdf = get_voxcity(
     rectangle_vertices,
     building_source,
     land_cover_source,
@@ -352,7 +352,7 @@ landmark_kwargs = {
     "output_directory": "output",             # Directory to save output files
     "output_file_name": "landmark_visibility" # Base filename for outputs
 }
-landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, building_geojson, meshsize, **landmark_kwargs)
+landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, building_gdf, meshsize, **landmark_kwargs)
 ```
 <p align="center">
   <img src="https://raw.githubusercontent.com/kunifujiwara/VoxCity/main/images/landmark.png" alt="Landmark Visibility Map Rendered in Rhino" width="500">

{voxcity-0.3.14 → voxcity-0.3.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "voxcity"
-version = "0.3.14"
+version = "0.3.15"
 requires-python = ">=3.10,<3.13"
 classifiers = [
     "Programming Language :: Python :: 3.10",

{voxcity-0.3.14 → voxcity-0.3.15}/src/voxcity/geoprocessor/grid.py

@@ -883,10 +883,19 @@ def grid_to_geodataframe(grid_ori, rectangle_vertices, meshsize):
     
     rows, cols = grid.shape
     
-    # Calculate cell sizes in degrees (approximate)
-    # 111,111 meters = 1 degree at equator
-    cell_size_lon = meshsize / (111111 * np.cos(np.mean([min_lat, max_lat]) * np.pi / 180))
-    cell_size_lat = meshsize / 111111
+    # Set up transformers for accurate coordinate calculations
+    wgs84 = CRS.from_epsg(4326)
+    web_mercator = CRS.from_epsg(3857)
+    transformer_to_mercator = Transformer.from_crs(wgs84, web_mercator, always_xy=True)
+    transformer_to_wgs84 = Transformer.from_crs(web_mercator, wgs84, always_xy=True)
+    
+    # Convert bounds to Web Mercator for accurate distance calculations
+    min_x, min_y = transformer_to_mercator.transform(min_lon, min_lat)
+    max_x, max_y = transformer_to_mercator.transform(max_lon, max_lat)
+    
+    # Calculate cell sizes in Web Mercator coordinates
+    cell_size_x = (max_x - min_x) / cols
+    cell_size_y = (max_y - min_y) / rows
     
     # Create lists to store data
     polygons = []
@@ -895,12 +904,16 @@ def grid_to_geodataframe(grid_ori, rectangle_vertices, meshsize):
     # Create grid cells
     for i in range(rows):
         for j in range(cols):
-            # Calculate cell bounds
-            cell_min_lon = min_lon + j * cell_size_lon
-            cell_max_lon = min_lon + (j + 1) * cell_size_lon
+            # Calculate cell bounds in Web Mercator
+            cell_min_x = min_x + j * cell_size_x
+            cell_max_x = min_x + (j + 1) * cell_size_x
             # Flip vertical axis since grid is stored with origin at top-left
-            cell_min_lat = max_lat - (i + 1) * cell_size_lat
-            cell_max_lat = max_lat - i * cell_size_lat
+            cell_min_y = max_y - (i + 1) * cell_size_y
+            cell_max_y = max_y - i * cell_size_y
+            
+            # Convert cell corners back to WGS84
+            cell_min_lon, cell_min_lat = transformer_to_wgs84.transform(cell_min_x, cell_min_y)
+            cell_max_lon, cell_max_lat = transformer_to_wgs84.transform(cell_max_x, cell_max_y)
             
             # Create polygon for cell
             cell_poly = box(cell_min_lon, cell_min_lat, cell_max_lon, cell_max_lat)
@@ -914,4 +927,71 @@ def grid_to_geodataframe(grid_ori, rectangle_vertices, meshsize):
         'value': values
     }, crs=CRS.from_epsg(4326))
     
+    return gdf
+
+def grid_to_point_geodataframe(grid_ori, rectangle_vertices, meshsize):
+    """Converts a 2D grid to a GeoDataFrame with point geometries at cell centers and values.
+    
+    Args:
+        grid: 2D numpy array containing grid values
+        rectangle_vertices: List of [lon, lat] coordinates defining area corners
+        meshsize: Size of each grid cell in meters
+        
+    Returns:
+        GeoDataFrame with columns:
+            - geometry: Point geometry at center of each grid cell
+            - value: Value from the grid
+    """
+    grid = np.flipud(grid_ori.copy())
+    
+    # Extract bounds from rectangle vertices
+    min_lon = min(v[0] for v in rectangle_vertices)
+    max_lon = max(v[0] for v in rectangle_vertices)
+    min_lat = min(v[1] for v in rectangle_vertices)
+    max_lat = max(v[1] for v in rectangle_vertices)
+    
+    rows, cols = grid.shape
+    
+    # Set up transformers for accurate coordinate calculations
+    wgs84 = CRS.from_epsg(4326)
+    web_mercator = CRS.from_epsg(3857)
+    transformer_to_mercator = Transformer.from_crs(wgs84, web_mercator, always_xy=True)
+    transformer_to_wgs84 = Transformer.from_crs(web_mercator, wgs84, always_xy=True)
+    
+    # Convert bounds to Web Mercator for accurate distance calculations
+    min_x, min_y = transformer_to_mercator.transform(min_lon, min_lat)
+    max_x, max_y = transformer_to_mercator.transform(max_lon, max_lat)
+    
+    # Calculate cell sizes in Web Mercator coordinates
+    cell_size_x = (max_x - min_x) / cols
+    cell_size_y = (max_y - min_y) / rows
+    
+    # Create lists to store data
+    points = []
+    values = []
+    
+    # Create grid points at cell centers
+    for i in range(rows):
+        for j in range(cols):
+            # Calculate cell center in Web Mercator
+            cell_center_x = min_x + (j + 0.5) * cell_size_x
+            # Flip vertical axis since grid is stored with origin at top-left
+            cell_center_y = max_y - (i + 0.5) * cell_size_y
+            
+            # Convert cell center back to WGS84
+            center_lon, center_lat = transformer_to_wgs84.transform(cell_center_x, cell_center_y)
+            
+            # Create point for cell center
+            from shapely.geometry import Point
+            cell_point = Point(center_lon, center_lat)
+            
+            points.append(cell_point)
+            values.append(grid[i, j])
+    
+    # Create GeoDataFrame
+    gdf = gpd.GeoDataFrame({
+        'geometry': points,
+        'value': values
+    }, crs=CRS.from_epsg(4326))
+    
     return gdf

{voxcity-0.3.14 → voxcity-0.3.15}/src/voxcity/utils/visualization.py

@@ -775,5 +775,140 @@ def visualize_numerical_grid_on_basemap(grid, rectangle_vertices, meshsize, valu
     # Set title and remove axes
     ax.set_axis_off()
     
+    plt.tight_layout()
+    plt.show()
+
+def visualize_numerical_grid_gdf_on_basemap(gdf, value_name="value", cmap='viridis', vmin=None, vmax=None,
+                            alpha=0.6, figsize=(12, 8), basemap='CartoDB light',
+                            show_edge=False, edge_color='black', edge_width=0.5):
+    """Visualizes a GeoDataFrame with numerical values on a basemap.
+    
+    Args:
+        gdf: GeoDataFrame containing grid cells with 'geometry' and 'value' columns
+        value_name: Name of the value column and legend label (default: "value")
+        cmap: Colormap to use (default: 'viridis')
+        vmin: Minimum value for colormap scaling (default: None)
+        vmax: Maximum value for colormap scaling (default: None)
+        alpha: Transparency of the grid overlay (default: 0.6)
+        figsize: Figure size in inches (default: (12, 8))
+        basemap: Basemap style (default: 'CartoDB light')
+        show_edge: Whether to show cell edges (default: False)
+        edge_color: Color of cell edges (default: 'black')
+        edge_width: Width of cell edges (default: 0.5)
+    """
+    # Convert to Web Mercator if not already in that CRS
+    if gdf.crs != 'EPSG:3857':
+        gdf_web = gdf.to_crs(epsg=3857)
+    else:
+        gdf_web = gdf
+    
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=figsize)
+    
+    # Plot the GeoDataFrame
+    gdf_web.plot(column='value',
+                 ax=ax,
+                 alpha=alpha,
+                 cmap=cmap,
+                 vmin=vmin,
+                 vmax=vmax,
+                 legend=True,
+                 legend_kwds={'label': value_name},
+                 edgecolor=edge_color if show_edge else 'none',
+                 linewidth=edge_width if show_edge else 0)
+    
+    # Add basemap
+    basemaps = {
+        'CartoDB dark': ctx.providers.CartoDB.DarkMatter,
+        'CartoDB light': ctx.providers.CartoDB.Positron,
+        'CartoDB voyager': ctx.providers.CartoDB.Voyager,
+        'CartoDB light no labels': ctx.providers.CartoDB.PositronNoLabels,
+        'CartoDB dark no labels': ctx.providers.CartoDB.DarkMatterNoLabels,
+    }
+    ctx.add_basemap(ax, source=basemaps[basemap])
+    
+    # Set title and remove axes
+    ax.set_axis_off()
+    
+    plt.tight_layout()
+    plt.show()
+
+def visualize_point_grid_on_basemap(point_gdf, value_name='value', **kwargs):
+    """Visualizes a point GeoDataFrame on a basemap with colors based on values.
+    
+    Args:
+        point_gdf: GeoDataFrame with point geometries and values
+        value_name: Name of the column containing values to visualize (default: 'value')
+        **kwargs: Optional visualization parameters including:
+            - figsize: Tuple for figure size (default: (12, 8))
+            - colormap: Matplotlib colormap name (default: 'viridis')
+            - markersize: Size of points (default: 20)
+            - alpha: Transparency of points (default: 0.7)
+            - vmin: Minimum value for colormap scaling (default: None)
+            - vmax: Maximum value for colormap scaling (default: None)
+            - title: Plot title (default: None)
+            - basemap_style: Contextily basemap style (default: CartoDB.Positron)
+            - zoom: Basemap zoom level (default: 15)
+            
+    Returns:
+        matplotlib figure and axis objects
+    """
+    import matplotlib.pyplot as plt
+    import contextily as ctx
+    
+    # Set default parameters
+    defaults = {
+        'figsize': (12, 8),
+        'colormap': 'viridis',
+        'markersize': 20,
+        'alpha': 0.7,
+        'vmin': None,
+        'vmax': None,
+        'title': None,
+        'basemap_style': ctx.providers.CartoDB.Positron,
+        'zoom': 15
+    }
+    
+    # Update defaults with provided kwargs
+    settings = {**defaults, **kwargs}
+    
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=settings['figsize'])
+    
+    # Convert to Web Mercator for basemap compatibility
+    point_gdf_web = point_gdf.to_crs(epsg=3857)
+    
+    # Plot points
+    scatter = point_gdf_web.plot(
+        column=value_name,
+        ax=ax,
+        cmap=settings['colormap'],
+        markersize=settings['markersize'],
+        alpha=settings['alpha'],
+        vmin=settings['vmin'],
+        vmax=settings['vmax'],
+        legend=True,
+        legend_kwds={
+            'label': value_name,
+            'orientation': 'vertical',
+            'shrink': 0.8
+        }
+    )
+    
+    # Add basemap
+    ctx.add_basemap(
+        ax,
+        source=settings['basemap_style'],
+        zoom=settings['zoom']
+    )
+    
+    # Set title if provided
+    if settings['title']:
+        plt.title(settings['title'])
+    
+    # Remove axes
+    ax.set_axis_off()
+    
+    # Adjust layout to prevent colorbar cutoff
     plt.tight_layout()
     plt.show()

{voxcity-0.3.14 → voxcity-0.3.15}/src/voxcity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.14
+Version: 0.3.15
 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>
@@ -225,7 +225,7 @@ from voxcity import get_voxcity
 
 voxcity_grid, building_height_grid, building_min_height_grid, \
 building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, \
-building_geojson = get_voxcity(
+building_gdf = get_voxcity(
     rectangle_vertices,
     building_source,
     land_cover_source,
@@ -410,7 +410,7 @@ landmark_kwargs = {
     "output_directory": "output",             # Directory to save output files
     "output_file_name": "landmark_visibility" # Base filename for outputs
 }
-landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, building_geojson, meshsize, **landmark_kwargs)
+landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, building_gdf, meshsize, **landmark_kwargs)
 ```
 <p align="center">
   <img src="https://raw.githubusercontent.com/kunifujiwara/VoxCity/main/images/landmark.png" alt="Landmark Visibility Map Rendered in Rhino" width="500">