voxcity 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

voxcity/geo/__init_.py

@@ -1,3 +1,4 @@
 from .draw import *
 from .grid import *
-from .utils import *
+from .utils import *
+from .network import *

voxcity/geo/grid.py

@@ -4,7 +4,7 @@ This module provides functions for creating and manipulating grids of building h
 
 import numpy as np
 import os
-from shapely.geometry import Polygon
+from shapely.geometry import Polygon, box
 from scipy.ndimage import label, generate_binary_structure
 from pyproj import Geod, Transformer, CRS
 import rasterio
@@ -12,6 +12,7 @@ from affine import Affine
 from shapely.geometry import box
 from scipy.interpolate import griddata
 from shapely.errors import GEOSException
+import geopandas as gpd
 
 from .utils import (
     initialize_geod,
@@ -748,4 +749,60 @@ def create_dem_grid_from_geotiff_polygon(tiff_path, mesh_size, rectangle_vertice
             # Use nearest neighbor interpolation for raw data
             grid = griddata(points, values, (xx, yy), method='nearest')
 
-    return np.flipud(grid)
+    return np.flipud(grid)
+
+def grid_to_geodataframe(grid_ori, rectangle_vertices, meshsize):
+    """Converts a 2D grid to a GeoDataFrame with cell polygons 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: Polygon geometry 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
+    
+    # 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
+    
+    # Create lists to store data
+    polygons = []
+    values = []
+    
+    # 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
+            # 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
+            
+            # Create polygon for cell
+            cell_poly = box(cell_min_lon, cell_min_lat, cell_max_lon, cell_max_lat)
+            
+            polygons.append(cell_poly)
+            values.append(grid[i, j])
+    
+    # Create GeoDataFrame
+    gdf = gpd.GeoDataFrame({
+        'geometry': polygons,
+        'value': values
+    }, crs=CRS.from_epsg(4326))
+    
+    return gdf

voxcity/geo/network.py

@@ -0,0 +1,194 @@
+import contextily as ctx
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+from shapely.geometry import LineString
+import networkx as nx
+import osmnx as ox
+
+from .grid import grid_to_geodataframe
+
+def calculate_edge_values(G, gdf, value_col='value'):
+    """
+    Calculate average values for graph edges based on intersection with polygons.
+    
+    Parameters:
+    -----------
+    G : NetworkX Graph
+        Input graph with edges to analyze
+    gdf : GeoDataFrame
+        Grid containing polygons with values
+    value_col : str, default 'value'
+        Name of the column containing values in the grid
+        
+    Returns:
+    --------
+    dict
+        Dictionary with edge identifiers (u,v,k) as keys and average values as values
+    """
+    edge_values = {}
+    for u, v, k, data in G.edges(data=True, keys=True):
+        if 'geometry' in data:
+            edge_line = data['geometry']
+        else:
+            start_node = G.nodes[u]
+            end_node = G.nodes[v]
+            edge_line = LineString([(start_node['x'], start_node['y']),
+                                  (end_node['x'], end_node['y'])])
+        
+        intersecting_polys = gdf[gdf.geometry.intersects(edge_line)]
+        
+        if len(intersecting_polys) > 0:
+            total_length = 0
+            weighted_sum = 0
+            
+            for idx, poly in intersecting_polys.iterrows():
+                if pd.isna(poly[value_col]):
+                    continue
+                
+                intersection = edge_line.intersection(poly.geometry)
+                if not intersection.is_empty:
+                    length = intersection.length
+                    total_length += length
+                    weighted_sum += length * poly[value_col]
+            
+            if total_length > 0:
+                avg_value = weighted_sum / total_length
+                edge_values[(u, v, k)] = avg_value
+            else:
+                edge_values[(u, v, k)] = np.nan
+        else:
+            edge_values[(u, v, k)] = np.nan
+    
+    return edge_values
+
+def get_network_values(grid, rectangle_vertices, meshsize, value_name='value', **kwargs):
+    """
+    Analyze and visualize network values based on grid intersections.
+    
+    Parameters:
+    -----------
+    grid : GeoDataFrame
+        Input grid with geometries and values
+    rectangle_vertices : list
+        List of coordinates defining the bounding box vertices
+    meshsize : float
+        Size of the mesh grid
+    value_name : str, default 'value'
+        Name of the column containing values in the grid
+    **kwargs : dict
+        Optional arguments including:
+        - network_type : str, default 'walk'
+            Type of network to download ('walk', 'drive', 'all', etc.)
+        - vis_graph : bool, default True
+            Whether to visualize the graph
+        - colormap : str, default 'viridis'
+            Matplotlib colormap name for visualization
+        - vmin : float, optional
+            Minimum value for color scaling
+        - vmax : float, optional
+            Maximum value for color scaling
+        - edge_width : float, default 1
+            Width of the edges in visualization
+        - fig_size : tuple, default (15,15)
+            Figure size for visualization
+        - zoom : int, default 16
+            Zoom level for the basemap
+        - basemap_style : ctx.providers, default CartoDB.Positron
+            Contextily basemap provider
+        - save_path : str, optional
+            Path to save the output GeoPackage
+        
+    Returns:
+    --------
+    tuple : (NetworkX Graph, GeoDataFrame)
+        Returns the processed graph and edge GeoDataFrame
+    """
+    # Set default values for optional arguments
+    defaults = {
+        'network_type': 'walk',
+        'vis_graph': True,
+        'colormap': 'viridis',
+        'vmin': None,
+        'vmax': None,
+        'edge_width': 1,
+        'fig_size': (15,15),
+        'zoom': 16,
+        'basemap_style': ctx.providers.CartoDB.Positron,
+        'save_path': None
+    }
+    
+    # Update defaults with provided kwargs
+    settings = defaults.copy()
+    settings.update(kwargs)
+
+    grid_gdf = grid_to_geodataframe(grid, rectangle_vertices, meshsize)
+    
+    # Extract bounding box coordinates
+    north, south = rectangle_vertices[1][1], rectangle_vertices[0][1]
+    east, west   = rectangle_vertices[2][0], rectangle_vertices[0][0]
+    bbox = (west, south, east, north)
+    
+    # Download the road network
+    G = ox.graph.graph_from_bbox(bbox=bbox, network_type=settings['network_type'], simplify=True)
+    
+    # Calculate edge values using the separate function
+    edge_values = calculate_edge_values(G, grid_gdf, "value")
+    
+    # Add values to the graph
+    nx.set_edge_attributes(G, edge_values, value_name)
+    
+    # Create GeoDataFrame from edges
+    edges_with_values = []
+    for u, v, k, data in G.edges(data=True, keys=True):
+        if 'geometry' in data:
+            edge_line = data['geometry']
+        else:
+            start_node = G.nodes[u]
+            end_node = G.nodes[v]
+            edge_line = LineString([(start_node['x'], start_node['y']),
+                                  (end_node['x'], end_node['y'])])
+        
+        edges_with_values.append({
+            'geometry': edge_line,
+            value_name: data.get(value_name, np.nan),
+            'u': u,
+            'v': v,
+            'key': k
+        })
+    
+    edge_gdf = gpd.GeoDataFrame(edges_with_values)
+    
+    # Set CRS and save if requested
+    if edge_gdf.crs is None:
+        edge_gdf.set_crs(epsg=4326, inplace=True)
+    
+    if settings['save_path']:
+        edge_gdf.to_file(settings['save_path'], driver="GPKG")
+    
+    # Visualize if requested
+    if settings['vis_graph']:
+        edge_gdf_web = edge_gdf.to_crs(epsg=3857)
+        
+        fig, ax = plt.subplots(figsize=settings['fig_size'])
+        
+        plot = edge_gdf_web.plot(column=value_name,
+                                ax=ax,
+                                cmap=settings['colormap'],
+                                legend=True,
+                                vmin=settings['vmin'],
+                                vmax=settings['vmax'],
+                                linewidth=settings['edge_width'],
+                                legend_kwds={'label': value_name,
+                                           'shrink': 0.5})  # Make colorbar 50% smaller
+        
+        ctx.add_basemap(ax,
+                       source=settings['basemap_style'],
+                       zoom=settings['zoom'])
+        
+        ax.set_axis_off()
+        # plt.title(f'Network {value_name} Analysis', pad=20)
+        plt.show()
+    
+    return G, edge_gdf

voxcity/sim/solar.py

@@ -675,11 +675,11 @@ def get_global_solar_irradiance_using_epw(
             return None
         else:
             # Calculate center point of rectangle
-            lats = [coord[0] for coord in rectangle_vertices]
-            lons = [coord[1] for coord in rectangle_vertices]
-            center_lat = (min(lats) + max(lats)) / 2
+            lons = [coord[0] for coord in rectangle_vertices]
+            lats = [coord[1] for coord in rectangle_vertices]
             center_lon = (min(lons) + max(lons)) / 2
-            target_point = (center_lat, center_lon)
+            center_lat = (min(lats) + max(lats)) / 2
+            target_point = (center_lon, center_lat)
 
             # Optional: specify maximum distance in kilometers
             max_distance = 100  # None for no limit
@@ -687,8 +687,8 @@ def get_global_solar_irradiance_using_epw(
             output_dir = kwargs.get("output_dir", "output")
 
             epw_file_path, weather_data, metadata = get_nearest_epw_from_climate_onebuilding(
-                latitude=center_lat,
                 longitude=center_lon,
+                latitude=center_lat,
                 output_dir=output_dir,
                 max_distance=max_distance,
                 extract_zip=True,

voxcity/utils/__init_.py

@@ -1,3 +1,4 @@
 from .visualization import *
 from .lc import *
-from .weather import *
+from .weather import *
+from .material import *

voxcity/utils/material.py

@@ -0,0 +1,139 @@
+import numpy as np
+
+def get_material_dict():
+    """
+    Returns a dictionary mapping material names to their corresponding ID values.
+    """
+    return {
+        "unknown": -3,
+        "brick": -11,  
+        "wood": -12,  
+        "concrete": -13,  
+        "metal": -14,  
+        "stone": -15,  
+        "glass": -16,  
+        "plaster": -17,  
+    }
+
+def get_modulo_numbers(window_ratio):
+    """
+    Determines the appropriate modulo numbers for x, y, z based on window_ratio.
+    
+    Parameters:
+    window_ratio: float between 0 and 1.0
+    
+    Returns:
+    tuple (x_mod, y_mod, z_mod): modulo numbers for each dimension
+    """
+    if window_ratio <= 0.125 + 0.0625:  # around 0.125
+        return (2, 2, 2)
+    elif window_ratio <= 0.25 + 0.125:  # around 0.25
+        combinations = [(2, 2, 1), (2, 1, 2), (1, 2, 2)]
+        return combinations[hash(str(window_ratio)) % len(combinations)]
+    elif window_ratio <= 0.5 + 0.125:  # around 0.5
+        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
+        return combinations[hash(str(window_ratio)) % len(combinations)]
+    elif window_ratio <= 0.75 + 0.125:  # around 0.75
+        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
+        return combinations[hash(str(window_ratio)) % len(combinations)]
+    else:  # above 0.875
+        return (1, 1, 1)
+
+def set_building_material_by_id(voxelcity_grid, building_id_grid_ori, ids, mark, window_ratio=0.125, glass_id=-16):
+    """
+    Marks cells in voxelcity_grid based on building IDs and window ratio.
+    Never sets glass_id to cells with maximum z index.
+    
+    Parameters:
+    voxelcity_grid: 3D numpy array
+    building_id_grid_ori: 2D numpy array containing building IDs
+    ids: list/array of building IDs to check
+    mark: value to set for marked cells
+    window_ratio: float between 0 and 1.0, determines window density:
+        ~0.125: sparse windows (2,2,2)
+        ~0.25: medium-sparse windows (2,2,1), (2,1,2), or (1,2,2)
+        ~0.5: medium windows (2,1,1), (1,2,1), or (1,1,2)
+        ~0.75: dense windows (2,1,1), (1,2,1), or (1,1,2)
+        >0.875: maximum density (1,1,1)
+    glass_id: value to set for glass cells (default: -16)
+    
+    Returns:
+    Modified voxelcity_grid
+    """
+    building_id_grid = np.flipud(building_id_grid_ori.copy())
+    
+    # Get modulo numbers based on window_ratio
+    x_mod, y_mod, z_mod = get_modulo_numbers(window_ratio)
+    
+    # Get positions where building IDs match
+    building_positions = np.where(np.isin(building_id_grid, ids))
+    
+    # Loop through each position that matches building IDs
+    for i in range(len(building_positions[0])):
+        x, y = building_positions[0][i], building_positions[1][i]
+        z_mask = voxelcity_grid[x, y, :] == -3
+        voxelcity_grid[x, y, z_mask] = mark
+        
+        # Check if x and y meet the modulo conditions
+        if x % x_mod == 0 and y % y_mod == 0:
+            z_mask = voxelcity_grid[x, y, :] == mark
+            if np.any(z_mask):
+                # Find the maximum z index where z_mask is True
+                z_indices = np.where(z_mask)[0]
+                max_z_index = np.max(z_indices)
+                
+                # Create base mask excluding maximum z index
+                base_mask = z_mask.copy()
+                base_mask[max_z_index] = False
+                
+                # Create pattern mask based on z modulo
+                pattern_mask = np.zeros_like(z_mask)
+                valid_z_indices = z_indices[z_indices != max_z_index]  # Exclude max_z_index
+                if len(valid_z_indices) > 0:
+                    pattern_mask[valid_z_indices[valid_z_indices % z_mod == 0]] = True
+                
+                # For window_ratio around 0.75, add additional pattern
+                if 0.625 < window_ratio <= 0.875 and len(valid_z_indices) > 0:
+                    additional_pattern = np.zeros_like(z_mask)
+                    additional_pattern[valid_z_indices[valid_z_indices % (z_mod + 1) == 0]] = True
+                    pattern_mask = np.logical_or(pattern_mask, additional_pattern)
+                
+                # Final mask combines base_mask and pattern_mask
+                final_glass_mask = np.logical_and(base_mask, pattern_mask)
+                
+                # Set glass_id for all positions in the final mask
+                voxelcity_grid[x, y, final_glass_mask] = glass_id
+    
+    return voxelcity_grid
+
+def set_building_material_by_gdf(voxelcity_grid_ori, building_id_grid, gdf_buildings, material_id_dict=None):
+    """
+    Sets building materials based on a GeoDataFrame containing building information.
+    
+    Parameters:
+    voxelcity_grid_ori: 3D numpy array of the original voxel grid
+    building_id_grid: 2D numpy array containing building IDs
+    gdf_buildings: GeoDataFrame containing building information with columns:
+                  'building_id', 'surface_material', 'window_ratio'
+    material_id_dict: Dictionary mapping material names to their IDs (optional)
+    
+    Returns:
+    Modified voxelcity_grid
+    """
+    voxelcity_grid = voxelcity_grid_ori.copy()
+    if material_id_dict == None:
+        material_id_dict = get_material_dict()
+
+    for index, row in gdf_buildings.iterrows():
+        # Access properties
+        osmid = row['building_id']
+        surface_material = row['surface_material']
+        window_ratio = row['window_ratio']
+        if surface_material is None:
+            surface_material = 'unknown'            
+        set_building_material_by_id(voxelcity_grid, building_id_grid, osmid, 
+                                  material_id_dict[surface_material], 
+                                  window_ratio=window_ratio, 
+                                  glass_id=material_id_dict['glass'])
+    
+    return voxelcity_grid

voxcity/utils/visualization.py

@@ -3,6 +3,7 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
 from tqdm import tqdm
 import matplotlib.colors as mcolors
+from matplotlib.colors import ListedColormap, BoundaryNorm
 import contextily as ctx
 from shapely.geometry import Polygon
 import plotly.graph_objects as go
@@ -21,7 +22,8 @@ from .lc import get_land_cover_classes
 from ..geo.grid import (
     calculate_grid_size,
     create_coordinate_mesh,
-    create_cell_polygon
+    create_cell_polygon,
+    grid_to_geodataframe
 )
 
 from ..geo.utils import (
@@ -31,18 +33,7 @@ from ..geo.utils import (
     setup_transformer,
     transform_coords,
 )
-
-def get_material_dict():
-    return {
-        "unknown": -3,
-        "brick": -11,  
-        "wood": -12,  
-        "concrete": -13,  
-        "metal": -14,  
-        "stone": -15,  
-        "glass": -16,  
-        "plaster": -17,  
-    }
+from .material import get_material_dict
 
 def get_default_voxel_color_map():
     return {
@@ -251,119 +242,6 @@ def visualize_3d_voxel_plotly(voxel_grid, color_map = get_default_voxel_color_ma
     print("Visualization complete. Displaying plot...")
     fig.show()
 
-# def plot_grid(grid, origin, adjusted_meshsize, u_vec, v_vec, transformer, vertices, data_type, vmin=None, vmax=None, alpha=0.5, buf=0.2, edge=True, **kwargs):
-#     fig, ax = plt.subplots(figsize=(12, 12))
-
-#     if data_type == 'land_cover':
-#         land_cover_classes = kwargs.get('land_cover_classes')
-#         colors = [mcolors.to_rgb(f'#{r:02x}{g:02x}{b:02x}') for r, g, b in land_cover_classes.keys()]
-#         cmap = mcolors.ListedColormap(colors)
-#         norm = mcolors.BoundaryNorm(range(len(land_cover_classes)+1), cmap.N)
-#         title = 'Grid Cells with Dominant Land Cover Classes'
-#         label = 'Land Cover Class'
-#         tick_labels = list(land_cover_classes.values())
-#     elif data_type == 'building_height':
-#         # Create a masked array to handle special values
-#         masked_grid = np.ma.masked_array(grid, mask=(np.isnan(grid) | (grid == 0)))
-        
-#         # Set up colormap and normalization for positive values
-#         cmap = plt.cm.viridis
-#         if vmin is None:
-#             vmin = np.nanmin(masked_grid[masked_grid > 0])
-#         if vmax is None:
-#             vmax = np.nanmax(masked_grid)
-#         norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
-        
-#         title = 'Grid Cells with Building Heights'
-#         label = 'Building Height (m)'
-#         tick_labels = None
-#     elif data_type == 'dem':
-#         cmap = plt.cm.terrain
-#         if vmin is None:
-#             vmin = np.nanmin(grid)
-#         if vmax is None:
-#             vmax = np.nanmax(grid)
-#         norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
-#         title = 'DEM Grid Overlaid on Map'
-#         label = 'Elevation (m)'
-#         tick_labels = None
-#     elif data_type == 'canopy_height':
-#         cmap = plt.cm.Greens
-#         if vmin is None:
-#             vmin = np.nanmin(grid)
-#         if vmax is None:
-#             vmax = np.nanmax(grid)
-#         norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
-#         title = 'Canopy Height Grid Overlaid on Map'
-#         label = 'Canopy Height (m)'
-#         tick_labels = None
-#     else:
-#         raise ValueError("Invalid data_type. Choose 'land_cover', 'building_height', 'canopy_height', or 'dem'.")
-
-#     # Ensure grid is in the correct orientation
-#     grid = grid.T
-
-#     for i in range(grid.shape[0]):
-#         for j in range(grid.shape[1]):
-#             cell = create_cell_polygon(origin, j, i, adjusted_meshsize, u_vec, v_vec)  # Note the swap of i and j
-#             x, y = cell.exterior.xy
-#             x, y = zip(*[transformer.transform(lon, lat) for lat, lon in zip(x, y)])
-
-#             value = grid[i, j]
-            
-#             if data_type == 'building_height':
-#                 if np.isnan(value):
-#                     # White fill for NaN values
-#                     ax.fill(x, y, alpha=alpha, fc='white', ec='black' if edge else None, linewidth=0.1)
-#                 elif value == 0:
-#                     # No fill for zero values, only edges if enabled
-#                     if edge:
-#                         ax.plot(x, y, color='black', linewidth=0.1)
-#                 elif value > 0:
-#                     # Viridis colormap for positive values
-#                     color = cmap(norm(value))
-#                     ax.fill(x, y, alpha=alpha, fc=color, ec='black' if edge else None, linewidth=0.1)
-#             else:
-#                 color = cmap(norm(value))
-#                 if edge:
-#                     ax.fill(x, y, alpha=alpha, fc=color, ec='black', linewidth=0.1)
-#                 else:
-#                     ax.fill(x, y, alpha=alpha, fc=color, ec=None)
-
-#     crs_epsg_3857 = CRS.from_epsg(3857)
-#     ctx.add_basemap(ax, crs=crs_epsg_3857, source=ctx.providers.CartoDB.DarkMatter)
-
-#     if data_type == 'building_height':
-#         buildings = kwargs.get('buildings', [])
-#         for building in buildings:
-#             polygon = Polygon(building['geometry']['coordinates'][0])
-#             x, y = polygon.exterior.xy
-#             x, y = zip(*[transformer.transform(lon, lat) for lat, lon in zip(x, y)])
-#             ax.plot(x, y, color='red', linewidth=1)
-
-#     # Safe calculation of plot limits
-#     all_coords = np.array(vertices)
-#     x, y = zip(*[transformer.transform(lon, lat) for lat, lon in all_coords])
-    
-#     # Calculate limits safely
-#     x_min, x_max = min(x), max(x)
-#     y_min, y_max = min(y), max(y)
-    
-#     if x_min != x_max and y_min != y_max and buf != 0:
-#         dist_x = x_max - x_min
-#         dist_y = y_max - y_min
-#         # Set limits with buffer
-#         ax.set_xlim(x_min - buf * dist_x, x_max + buf * dist_x)
-#         ax.set_ylim(y_min - buf * dist_y, y_max + buf * dist_y)
-#     else:
-#         # If coordinates are the same or buffer is 0, set limits without buffer
-#         ax.set_xlim(x_min, x_max)
-#         ax.set_ylim(y_min, y_max)
-
-#     plt.axis('off')
-#     plt.tight_layout()
-#     plt.show()
-
 def plot_grid(grid, origin, adjusted_meshsize, u_vec, v_vec, transformer, vertices, data_type, vmin=None, vmax=None, color_map=None, alpha=0.5, buf=0.2, edge=True, basemap='CartoDB light', **kwargs):
     fig, ax = plt.subplots(figsize=(12, 12))
 
@@ -631,31 +509,6 @@ def visualize_numerical_grid_on_map(canopy_height_grid, rectangle_vertices, mesh
     # Plot the results
     plot_grid(canopy_height_grid, origin, adjusted_meshsize, u_vec, v_vec, transformer,
               rectangle_vertices, type, vmin=vmin, vmax=vmax, color_map=color_map, alpha=alpha, buf=buf, edge=edge, basemap=basemap)
-    
-# def visualize_land_cover_grid(grid, mesh_size, color_map, land_cover_classes):
-#     all_classes = list(land_cover_classes.values())# + ['No Data']
-#     # for cls in all_classes:
-#     #     if cls not in color_map:
-#     #         color_map[cls] = [0.5, 0.5, 0.5]
-
-#     sorted_classes = sorted(all_classes)
-#     colors = [color_map[cls] for cls in sorted_classes]
-#     cmap = mcolors.ListedColormap(colors)
-
-#     bounds = np.arange(len(sorted_classes) + 1)
-#     norm = mcolors.BoundaryNorm(bounds, cmap.N)
-
-#     class_to_num = {cls: i for i, cls in enumerate(sorted_classes)}
-#     numeric_grid = np.vectorize(class_to_num.get)(grid)
-
-#     plt.figure(figsize=(10, 10))
-#     im = plt.imshow(numeric_grid, cmap=cmap, norm=norm, interpolation='nearest')
-#     cbar = plt.colorbar(im, ticks=bounds[:-1] + 0.5)
-#     cbar.set_ticklabels(sorted_classes)
-#     plt.title(f'Land Use/Land Cover Grid (Mesh Size: {mesh_size}m)')
-#     plt.xlabel('Grid Cells (X)')
-#     plt.ylabel('Grid Cells (Y)')
-#     plt.show()
 
 def visualize_land_cover_grid(grid, mesh_size, color_map, land_cover_classes):
     all_classes = list(land_cover_classes.values())
@@ -688,204 +541,6 @@ def visualize_numerical_grid(grid, mesh_size, title, cmap='viridis', label='Valu
     plt.ylabel('Grid Cells (Y)')
     plt.show()
 
-def get_modulo_numbers(window_ratio):
-    """
-    Determines the appropriate modulo numbers for x, y, z based on window_ratio.
-    
-    Parameters:
-    window_ratio: float between 0 and 1.0
-    
-    Returns:
-    tuple (x_mod, y_mod, z_mod): modulo numbers for each dimension
-    """
-    if window_ratio <= 0.125 + 0.0625:  # around 0.125
-        return (2, 2, 2)
-    elif window_ratio <= 0.25 + 0.125:  # around 0.25
-        combinations = [(2, 2, 1), (2, 1, 2), (1, 2, 2)]
-        return combinations[hash(str(window_ratio)) % len(combinations)]
-    elif window_ratio <= 0.5 + 0.125:  # around 0.5
-        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
-        return combinations[hash(str(window_ratio)) % len(combinations)]
-    elif window_ratio <= 0.75 + 0.125:  # around 0.75
-        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
-        return combinations[hash(str(window_ratio)) % len(combinations)]
-    else:  # above 0.875
-        return (1, 1, 1)
-
-def set_building_material_by_id(voxelcity_grid, building_id_grid_ori, ids, mark, window_ratio=0.125, glass_id=-10):
-    """
-    Marks cells in voxelcity_grid based on building IDs and window ratio.
-    Never sets glass_id to cells with maximum z index.
-    
-    Parameters:
-    voxelcity_grid: 3D numpy array
-    building_id_grid_ori: 2D numpy array containing building IDs
-    ids: list/array of building IDs to check
-    mark: value to set for marked cells
-    window_ratio: float between 0 and 1.0, determines window density:
-        ~0.125: sparse windows (2,2,2)
-        ~0.25: medium-sparse windows (2,2,1), (2,1,2), or (1,2,2)
-        ~0.5: medium windows (2,1,1), (1,2,1), or (1,1,2)
-        ~0.75: dense windows (2,1,1), (1,2,1), or (1,1,2)
-        >0.875: maximum density (1,1,1)
-    glass_id: value to set for glass cells (default: -10)
-    
-    Returns:
-    Modified voxelcity_grid
-    """
-    building_id_grid = np.flipud(building_id_grid_ori.copy())
-    
-    # Get modulo numbers based on window_ratio
-    x_mod, y_mod, z_mod = get_modulo_numbers(window_ratio)
-    
-    # Get positions where building IDs match
-    building_positions = np.where(np.isin(building_id_grid, ids))
-    
-    # Loop through each position that matches building IDs
-    for i in range(len(building_positions[0])):
-        x, y = building_positions[0][i], building_positions[1][i]
-        z_mask = voxelcity_grid[x, y, :] == -3
-        voxelcity_grid[x, y, z_mask] = mark
-        
-        # Check if x and y meet the modulo conditions
-        if x % x_mod == 0 and y % y_mod == 0:
-            z_mask = voxelcity_grid[x, y, :] == mark
-            if np.any(z_mask):
-                # Find the maximum z index where z_mask is True
-                z_indices = np.where(z_mask)[0]
-                max_z_index = np.max(z_indices)
-                
-                # Create base mask excluding maximum z index
-                base_mask = z_mask.copy()
-                base_mask[max_z_index] = False
-                
-                # Create pattern mask based on z modulo
-                pattern_mask = np.zeros_like(z_mask)
-                valid_z_indices = z_indices[z_indices != max_z_index]  # Exclude max_z_index
-                if len(valid_z_indices) > 0:
-                    pattern_mask[valid_z_indices[valid_z_indices % z_mod == 0]] = True
-                
-                # For window_ratio around 0.75, add additional pattern
-                if 0.625 < window_ratio <= 0.875 and len(valid_z_indices) > 0:
-                    additional_pattern = np.zeros_like(z_mask)
-                    additional_pattern[valid_z_indices[valid_z_indices % (z_mod + 1) == 0]] = True
-                    pattern_mask = np.logical_or(pattern_mask, additional_pattern)
-                
-                # Final mask combines base_mask and pattern_mask
-                final_glass_mask = np.logical_and(base_mask, pattern_mask)
-                
-                # Set glass_id for all positions in the final mask
-                voxelcity_grid[x, y, final_glass_mask] = glass_id
-    
-    return voxelcity_grid
-
-def set_building_material_by_gdf(voxelcity_grid_ori, building_id_grid, gdf_buildings, material_id_dict=None):
-    voxelcity_grid = voxelcity_grid_ori.copy()
-    if material_id_dict == None:
-        material_id_dict = get_material_dict()
-
-    for index, row in gdf_buildings.iterrows():
-        # Access properties
-        osmid = row['building_id']
-        surface_material = row['surface_material']
-        window_ratio = row['window_ratio']
-        if surface_material is None:
-            surface_material = 'unknown'            
-        set_building_material_by_id(voxelcity_grid, building_id_grid, osmid, material_id_dict[surface_material], window_ratio=window_ratio, glass_id=material_id_dict['glass'])
-    
-    return voxelcity_grid
-
-def get_modulo_numbers(window_ratio):
-    """
-    Determines the appropriate modulo numbers for x, y, z based on window_ratio.
-    
-    Parameters:
-    window_ratio: float between 0 and 1.0
-    
-    Returns:
-    tuple (x_mod, y_mod, z_mod): modulo numbers for each dimension
-    """
-    if window_ratio <= 0.125 + 0.0625:  # around 0.125
-        return (2, 2, 2)
-    elif window_ratio <= 0.25 + 0.125:  # around 0.25
-        combinations = [(2, 2, 1), (2, 1, 2), (1, 2, 2)]
-        return combinations[hash(str(window_ratio)) % len(combinations)]
-    elif window_ratio <= 0.5 + 0.125:  # around 0.5
-        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
-        return combinations[hash(str(window_ratio)) % len(combinations)]
-    elif window_ratio <= 0.75 + 0.125:  # around 0.75
-        combinations = [(2, 1, 1), (1, 2, 1), (1, 1, 2)]
-        return combinations[hash(str(window_ratio)) % len(combinations)]
-    else:  # above 0.875
-        return (1, 1, 1)
-
-def set_building_material_by_id(voxelcity_grid, building_id_grid_ori, ids, mark, window_ratio=0.125, glass_id=-16):
-    """
-    Marks cells in voxelcity_grid based on building IDs and window ratio.
-    Never sets glass_id to cells with maximum z index.
-    
-    Parameters:
-    voxelcity_grid: 3D numpy array
-    building_id_grid_ori: 2D numpy array containing building IDs
-    ids: list/array of building IDs to check
-    mark: value to set for marked cells
-    window_ratio: float between 0 and 1.0, determines window density:
-        ~0.125: sparse windows (2,2,2)
-        ~0.25: medium-sparse windows (2,2,1), (2,1,2), or (1,2,2)
-        ~0.5: medium windows (2,1,1), (1,2,1), or (1,1,2)
-        ~0.75: dense windows (2,1,1), (1,2,1), or (1,1,2)
-        >0.875: maximum density (1,1,1)
-    glass_id: value to set for glass cells (default: -10)
-    
-    Returns:
-    Modified voxelcity_grid
-    """
-    building_id_grid = np.flipud(building_id_grid_ori.copy())
-    
-    # Get modulo numbers based on window_ratio
-    x_mod, y_mod, z_mod = get_modulo_numbers(window_ratio)
-    
-    # Get positions where building IDs match
-    building_positions = np.where(np.isin(building_id_grid, ids))
-    
-    # Loop through each position that matches building IDs
-    for i in range(len(building_positions[0])):
-        x, y = building_positions[0][i], building_positions[1][i]
-        z_mask = voxelcity_grid[x, y, :] == -3
-        voxelcity_grid[x, y, z_mask] = mark
-        
-        # Check if x and y meet the modulo conditions
-        if x % x_mod == 0 and y % y_mod == 0:
-            z_mask = voxelcity_grid[x, y, :] == mark
-            if np.any(z_mask):
-                # Find the maximum z index where z_mask is True
-                z_indices = np.where(z_mask)[0]
-                max_z_index = np.max(z_indices)
-                
-                # Create base mask excluding maximum z index
-                base_mask = z_mask.copy()
-                base_mask[max_z_index] = False
-                
-                # Create pattern mask based on z modulo
-                pattern_mask = np.zeros_like(z_mask)
-                valid_z_indices = z_indices[z_indices != max_z_index]  # Exclude max_z_index
-                if len(valid_z_indices) > 0:
-                    pattern_mask[valid_z_indices[valid_z_indices % z_mod == 0]] = True
-                
-                # For window_ratio around 0.75, add additional pattern
-                if 0.625 < window_ratio <= 0.875 and len(valid_z_indices) > 0:
-                    additional_pattern = np.zeros_like(z_mask)
-                    additional_pattern[valid_z_indices[valid_z_indices % (z_mod + 1) == 0]] = True
-                    pattern_mask = np.logical_or(pattern_mask, additional_pattern)
-                
-                # Final mask combines base_mask and pattern_mask
-                final_glass_mask = np.logical_and(base_mask, pattern_mask)
-                
-                # Set glass_id for all positions in the final mask
-                voxelcity_grid[x, y, final_glass_mask] = glass_id
-    
-    return voxelcity_grid
-
 def convert_coordinates(coords):
     return coords
 
@@ -904,10 +559,6 @@ def calculate_center(features):
             lons.append(lon)
     return sum(lats) / len(lats), sum(lons) / len(lons)
 
-# def format_building_id(id_num):
-#     # Format ID to ensure it's at least 9 digits with leading zeros
-#     return f"{id_num:09d}"
-
 def create_circle_polygon(center_lat, center_lon, radius_meters):
     """Create a circular polygon with given center and radius"""
     # Convert radius from meters to degrees (approximate)
@@ -1002,4 +653,127 @@ def display_builing_ids_on_map(building_geojson, rectangle_vertices):
             ).add_to(m)
 
     # Save the map
-    return m
+    return m
+
+def visualize_landcover_grid_on_basemap(landcover_grid, rectangle_vertices, meshsize, source='Standard', alpha=0.6, figsize=(12, 8), 
+                                     basemap='CartoDB light', show_edge=False, edge_color='black', edge_width=0.5):
+    """Visualizes a land cover grid GeoDataFrame using predefined color schemes.
+    
+    Args:
+        gdf: GeoDataFrame containing grid cells with 'geometry' and 'value' columns
+        source: Source of land cover classification (e.g., 'Standard', 'Urbanwatch', etc.)
+        title: Title for the plot (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: True)
+        edge_color: Color of cell edges (default: 'black')
+        edge_width: Width of cell edges (default: 0.5)
+    """
+    # Get land cover classes and colors
+    land_cover_classes = get_land_cover_classes(source)
+
+    gdf = grid_to_geodataframe(landcover_grid, rectangle_vertices, meshsize)
+    
+    # Convert RGB tuples to normalized RGB values
+    colors = [(r/255, g/255, b/255) for (r,g,b) in land_cover_classes.keys()]
+    
+    # Create custom colormap
+    cmap = ListedColormap(colors)
+    
+    # Create bounds for discrete colorbar
+    bounds = np.arange(len(colors) + 1)
+    norm = BoundaryNorm(bounds, cmap.N)
+    
+    # Convert to Web Mercator
+    gdf_web = gdf.to_crs(epsg=3857)
+    
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=figsize)
+    
+    # Plot the GeoDataFrame
+    gdf_web.plot(column='value',
+                 ax=ax,
+                 alpha=alpha,
+                 cmap=cmap,
+                 norm=norm,
+                 legend=True,
+                 legend_kwds={
+                     'label': 'Land Cover Class',
+                     'ticks': bounds[:-1] + 0.5,
+                     'boundaries': bounds,
+                     'format': lambda x, p: list(land_cover_classes.values())[int(x)]
+                 },
+                 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_numerical_grid_on_basemap(grid, rectangle_vertices, meshsize, 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 numerical grid GeoDataFrame (e.g., heights) on a basemap.
+    
+    Args:
+        gdf: GeoDataFrame containing grid cells with 'geometry' and 'value' columns
+        title: Title for the plot (default: None)
+        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: True)
+        edge_color: Color of cell edges (default: 'black')
+        edge_width: Width of cell edges (default: 0.5)
+    """
+
+    gdf = grid_to_geodataframe(grid, rectangle_vertices, meshsize)
+
+    # Convert to Web Mercator
+    gdf_web = gdf.to_crs(epsg=3857)
+    
+    # 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()

voxcity/utils/weather.py

@@ -512,8 +512,8 @@ def read_epw_for_solar_simulation(epw_file_path):
         month = int(vals[1])
         day = int(vals[2])
         hour = int(vals[3]) - 1
-        dni = float(vals[13])
-        dhi = float(vals[14])
+        dni = float(vals[14])
+        dhi = float(vals[15])
         timestamp = pd.Timestamp(year, month, day, hour)
         data.append([timestamp, dni, dhi])
 

voxcity/voxcity.py

@@ -52,10 +52,12 @@ from .utils.visualization import (
     get_land_cover_classes,
     visualize_land_cover_grid,
     visualize_numerical_grid,
-    visualize_land_cover_grid_on_map,
-    visualize_numerical_grid_on_map,
-    visualize_building_height_grid_on_map,
-    visualize_3d_voxel
+    # visualize_land_cover_grid_on_map,
+    # visualize_numerical_grid_on_map,
+    # visualize_building_height_grid_on_map,
+    visualize_3d_voxel,
+    visualize_landcover_grid_on_basemap,
+    visualize_numerical_grid_on_basemap,
 )
 
 def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
@@ -593,10 +595,56 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
     # Visualize 2D grids on map if requested
     mapvis = kwargs.get("mapvis")
     if mapvis:
-        visualize_land_cover_grid_on_map(land_cover_grid, rectangle_vertices, meshsize, source = land_cover_source)
-        visualize_building_height_grid_on_map(building_height_grid, building_geojson, rectangle_vertices, meshsize)
-        visualize_numerical_grid_on_map(canopy_height_grid, rectangle_vertices, meshsize, "canopy_height")
-        visualize_numerical_grid_on_map(dem_grid, rectangle_vertices, meshsize, "dem")
+        # Visualize land cover using the new function
+        visualize_landcover_grid_on_basemap(
+            land_cover_grid, 
+            rectangle_vertices, 
+            meshsize, 
+            source=land_cover_source,
+            alpha=0.7,
+            figsize=(12, 8),
+            basemap='CartoDB light',
+            show_edge=False
+        )
+        
+        # Visualize building heights using the new function
+        visualize_numerical_grid_on_basemap(
+            building_height_grid,
+            rectangle_vertices,
+            meshsize,
+            value_name="Building Heights (m)",
+            cmap='viridis',
+            alpha=0.7,
+            figsize=(12, 8),
+            basemap='CartoDB light',
+            show_edge=False
+        )
+        
+        # Visualize canopy heights using the new function
+        visualize_numerical_grid_on_basemap(
+            canopy_height_grid,
+            rectangle_vertices,
+            meshsize,
+            value_name="Canopy Heights (m)",
+            cmap='Greens',
+            alpha=0.7,
+            figsize=(12, 8),
+            basemap='CartoDB light',
+            show_edge=False
+        )
+        
+        # Visualize DEM using the new function
+        visualize_numerical_grid_on_basemap(
+            dem_grid,
+            rectangle_vertices,
+            meshsize,
+            value_name="Terrain Elevation (m)",
+            cmap='terrain',
+            alpha=0.7,
+            figsize=(12, 8),
+            basemap='CartoDB light',
+            show_edge=False
+        )
 
     # Generate 3D voxel grid
     voxcity_grid = create_3d_voxel(building_height_grid, building_min_height_grid, building_id_grid, land_cover_grid, dem_grid, canopy_height_grid, meshsize, land_cover_source)

{voxcity-0.3.4.dist-info → voxcity-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: voxcity
-Version: 0.3.4
+Version: 0.3.6
 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>
@@ -48,6 +48,7 @@ Requires-Dist: overturemaps
 Requires-Dist: protobuf==3.20.3
 Requires-Dist: timezonefinder
 Requires-Dist: astral
+Requires-Dist: osmnx
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
@@ -329,7 +330,7 @@ solar_kwargs = {
 }
 
 # Compute global solar irradiance map (direct + diffuse radiation)
-global_map = get_global_solar_irradiance_using_epw(    
+solar_grid = get_global_solar_irradiance_using_epw(    
     voxcity_grid,                        # 3D voxel grid representing the urban environment
     meshsize,                            # Size of each voxel in meters
     calc_type='instantaneous',           # Calculate instantaneous irradiance at specified time
@@ -344,7 +345,7 @@ solar_kwargs["end_time"] = "01-31 23:00:00" # End time for cumulative calculatio
 solar_kwargs["output_file_name"] = 'cummulative_solar_irradiance',  # Base filename for outputs (without extension)
 
 # Calculate cumulative solar irradiance over the specified time period
-global_map = get_global_solar_irradiance_using_epw(    
+cum_solar_grid = get_global_solar_irradiance_using_epw(    
     voxcity_grid,                        # 3D voxel grid representing the urban environment
     meshsize,                            # Size of each voxel in meters
     calc_type='cumulative',              # Calculate cumulative irradiance over time period instead of instantaneous
@@ -417,6 +418,38 @@ landmark_vis_map = get_landmark_visibility_map(voxcity_grid, building_id_grid, b
   <em>Example Result Saved as OBJ and Rendered in Rhino</em>
 </p>
 
+#### Network Analysis:
+
+```python
+from voxcity.geo.network import get_network_values
+
+network_kwargs = {
+    "network_type": "walk",        # Type of network to download from OSM (walk, drive, all, etc.)
+    "colormap": "magma",          # Matplotlib colormap for visualization
+    "vis_graph": True,            # Whether to display the network visualization
+    "vmin": 0.0,                  # Minimum value for color scaling
+    "vmax": 600000,               # Maximum value for color scaling
+    "edge_width": 2,              # Width of network edges in visualization
+    "alpha": 0.8,                 # Transparency of network edges
+    "zoom": 16                    # Zoom level for basemap
+}
+
+G, edge_gdf = get_network_values(
+    cum_solar_grid,               # Grid of cumulative solar irradiance values
+    rectangle_vertices,           # Coordinates defining simulation domain boundary
+    meshsize,                     # Size of each grid cell in meters
+    value_name='Cumulative Global Solar Irradiance (W/m²·hour)',  # Label for values in visualization
+    **network_kwargs              # Additional visualization and network parameters
+)
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/kunifujiwara/VoxCity/main/images/network.png" alt="Example of Graph Output" width="500">
+</p>
+<p align="center">
+  <em>Example Result Saved as OBJ and Rendered in Rhino</em>
+</p>
+
 ## References of Data Sources
 
 ### Building 

{voxcity-0.3.4.dist-info → voxcity-0.3.6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 voxcity/__init__.py,sha256=HJM0D2Mv9qpk4JdVzt2SRAAk-hA1D_pCO0ezZH9F7KA,248
-voxcity/voxcity.py,sha256=ewwSxA_lMIkQ5yiLZutq4UCLfnUm0r5f2Jiy-q6cFm0,32256
+voxcity/voxcity.py,sha256=aeM1OzW7nmbW4h4SFHceugvb0NhKdXlQz_QcVQrZrIk,33498
 voxcity/download/__init__.py,sha256=OgGcGxOXF4tjcEL6DhOnt13DYPTvOigUelp5xIpTqM0,171
 voxcity/download/eubucco.py,sha256=e1JXBuUfBptSDvNznSGckRs5Xgrj_SAFxk445J_o4KY,14854
 voxcity/download/gee.py,sha256=j7jmzp44T3M6j_4DwhU9Y8Y6gqbZo1zFIlduQPc0jvk,14339
@@ -14,21 +14,23 @@ voxcity/file/envimet.py,sha256=SPVoSyYTMNyDRDFWsI0YAsIsb6yt_SXZeDUlhyqlEqY,24282
 voxcity/file/geojson.py,sha256=G8jG5Ffh86uhNZBLmr_hgyU9FwGab_tJBePET5DUQYk,24188
 voxcity/file/magicavoxel.py,sha256=Fsv7yGRXeKmp82xcG3rOb0t_HtoqltNq2tHl08xVlqY,7500
 voxcity/file/obj.py,sha256=oW-kPoZj53nfmO9tXP3Wvizq6Kkjh-QQR8UBexRuMiI,21609
-voxcity/geo/__init_.py,sha256=rsj0OMzrTNACccdvEfmf632mb03BRUtKLuecppsxX40,62
+voxcity/geo/__init_.py,sha256=AZYQxK1zY1M_mDT1HmgcdVI86OAtwK7CNo3AOScLHco,88
 voxcity/geo/draw.py,sha256=roljWXyqYdsWYkmb-5_WNxrJrfV5lnAt8uZblCCo_3Q,13555
-voxcity/geo/grid.py,sha256=YgAityV3KaBsng9R_aDQKRFkdEssv5Yzn5wKCIOJQOQ,34243
+voxcity/geo/grid.py,sha256=_MzO-Cu2GhlP9nuCql6f1pfbU2_OAL27aQ_zCj1u_zk,36288
+voxcity/geo/network.py,sha256=iBgvOaM4YPQKL5gnAU9rxe3ZlJLTjLIt7DoAIWzZRfs,6892
 voxcity/geo/utils.py,sha256=1BRHp-DDeOA8HG8jplY7Eo75G3oXkVGL6DGONL4BA8A,19815
 voxcity/sim/__init_.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
-voxcity/sim/solar.py,sha256=7waUoUMzDBf_Van3qghSG019TrgHgNj-TcVRVf0StuU,31306
+voxcity/sim/solar.py,sha256=GkL0PEjTr_bmtc75ixcyued5iwmiieLxTd-9e69x2R8,31306
 voxcity/sim/utils.py,sha256=sEYBB2-hLJxTiXQps1_-Fi7t1HN3-1OPOvBCWtgIisA,130
 voxcity/sim/view.py,sha256=oq6G-f0Tn-KT0vjYNJfucmOIrv1GNjljhA-zvU4nNoA,36668
-voxcity/utils/__init_.py,sha256=xjEadXQ9wXTw0lsx0JTbyTqASWw0GJLfT6eRr0CyQzw,71
+voxcity/utils/__init_.py,sha256=nLYrj2huBbDBNMqfchCwexGP8Tlt9O_XluVDG7MoFkw,98
 voxcity/utils/lc.py,sha256=RwPd-VY3POV3gTrBhM7TubgGb9MCd3nVah_G8iUEF7k,11562
-voxcity/utils/visualization.py,sha256=GVERj0noHAvJtDT0fV3K6w7pTfuAUfwKez-UMuEakEg,42214
-voxcity/utils/weather.py,sha256=fJ2p5susoMgYSBlrmlTlZVUDe9kpQwmLuyv1TgcOnDM,21482
-voxcity-0.3.4.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.3.4.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
-voxcity-0.3.4.dist-info/METADATA,sha256=wi1ziMnMN8UpySzEQZpGN6SrUW2ZSkY-gOd4kQ9de0U,23608
-voxcity-0.3.4.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-voxcity-0.3.4.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.3.4.dist-info/RECORD,,
+voxcity/utils/material.py,sha256=Vt3IID5Ft54HNJcEC4zi31BCPqi_687X3CSp7rXaRVY,5907
+voxcity/utils/visualization.py,sha256=FNBMN0V5IPuAdqvLHnqSGYqNS7jWesg0ZADEtsUtl0A,31925
+voxcity/utils/weather.py,sha256=P6s1y_EstBL1OGP_MR_6u3vr-t6Uawg8uDckJnoI7FI,21482
+voxcity-0.3.6.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.3.6.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
+voxcity-0.3.6.dist-info/METADATA,sha256=yYrGPuGGkWRSTCu7GwbO65Vgof05NhyUMxsiS3KbV5I,25071
+voxcity-0.3.6.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+voxcity-0.3.6.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.3.6.dist-info/RECORD,,