voxcity 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

voxcity/file/geojson.py

@@ -187,118 +187,325 @@ def extract_building_heights_from_geojson(geojson_data_0: List[Dict], geojson_da
 
     return updated_geojson_data_0
 
-from typing import List, Dict
-from shapely.geometry import shape
-from shapely.errors import GEOSException
-import numpy as np
-
-def complement_building_heights_from_geojson(geojson_data_0: List[Dict], geojson_data_1: List[Dict]) -> List[Dict]:
-    """
-    Complement building heights in one GeoJSON dataset with data from another and add non-intersecting buildings.
+# from typing import List, Dict
+# from shapely.geometry import shape
+# from shapely.errors import GEOSException
+# import numpy as np
+
+# def complement_building_heights_from_geojson(geojson_data_0: List[Dict], geojson_data_1: List[Dict]) -> List[Dict]:
+#     """
+#     Complement building heights in one GeoJSON dataset with data from another and add non-intersecting buildings.
     
-    Args:
-        geojson_data_0 (List[Dict]): Primary GeoJSON features to update with heights
-        geojson_data_1 (List[Dict]): Reference GeoJSON features containing height data
+#     Args:
+#         geojson_data_0 (List[Dict]): Primary GeoJSON features to update with heights
+#         geojson_data_1 (List[Dict]): Reference GeoJSON features containing height data
         
-    Returns:
-        List[Dict]: Updated GeoJSON features with complemented heights and additional buildings
-    """
-    # Convert primary dataset to Shapely polygons for intersection checking
-    existing_buildings = []
-    for feature in geojson_data_0:
-        geom = shape(feature['geometry'])
-        existing_buildings.append(geom)
+#     Returns:
+#         List[Dict]: Updated GeoJSON features with complemented heights and additional buildings
+#     """
+#     # Convert primary dataset to Shapely polygons for intersection checking
+#     existing_buildings = []
+#     for feature in geojson_data_0:
+#         geom = shape(feature['geometry'])
+#         existing_buildings.append(geom)
     
-    # Convert reference dataset to Shapely polygons with height info
-    reference_buildings = []
-    for feature in geojson_data_1:
-        geom = shape(feature['geometry'])
-        height = feature['properties']['height']
-        reference_buildings.append((geom, height, feature))
+#     # Convert reference dataset to Shapely polygons with height info
+#     reference_buildings = []
+#     for feature in geojson_data_1:
+#         geom = shape(feature['geometry'])
+#         height = feature['properties']['height']
+#         reference_buildings.append((geom, height, feature))
     
-    # Initialize counters for statistics
-    count_0 = 0  # Buildings without height
-    count_1 = 0  # Buildings updated with height
-    count_2 = 0  # Buildings with no height data found
-    count_3 = 0  # New non-intersecting buildings added
+#     # Initialize counters for statistics
+#     count_0 = 0  # Buildings without height
+#     count_1 = 0  # Buildings updated with height
+#     count_2 = 0  # Buildings with no height data found
+#     count_3 = 0  # New non-intersecting buildings added
     
-    # Process primary dataset and update heights where needed
-    updated_geojson_data_0 = []
-    for feature in geojson_data_0:
-        geom = shape(feature['geometry'])
-        height = feature['properties']['height']
-        if height == 0:     
-            count_0 += 1       
-            # Calculate weighted average height based on overlapping areas
-            overlapping_height_area = 0
-            overlapping_area = 0
-            for ref_geom, ref_height, _ in reference_buildings:
-                try:
-                    if geom.intersects(ref_geom):
-                        overlap_area = geom.intersection(ref_geom).area
-                        overlapping_height_area += ref_height * overlap_area
-                        overlapping_area += overlap_area
-                except GEOSException as e:
-                    # Try to fix invalid geometries
-                    try:
-                        fixed_ref_geom = ref_geom.buffer(0)
-                        if geom.intersects(fixed_ref_geom):
-                            overlap_area = geom.intersection(ref_geom).area
-                            overlapping_height_area += ref_height * overlap_area
-                            overlapping_area += overlap_area
-                    except Exception as fix_error:
-                        print(f"Failed to fix polygon")
-                    continue
+#     # Process primary dataset and update heights where needed
+#     updated_geojson_data_0 = []
+#     for feature in geojson_data_0:
+#         geom = shape(feature['geometry'])
+#         height = feature['properties']['height']
+#         if height == 0:     
+#             count_0 += 1       
+#             # Calculate weighted average height based on overlapping areas
+#             overlapping_height_area = 0
+#             overlapping_area = 0
+#             for ref_geom, ref_height, _ in reference_buildings:
+#                 try:
+#                     if geom.intersects(ref_geom):
+#                         overlap_area = geom.intersection(ref_geom).area
+#                         overlapping_height_area += ref_height * overlap_area
+#                         overlapping_area += overlap_area
+#                 except GEOSException as e:
+#                     # Try to fix invalid geometries
+#                     try:
+#                         fixed_ref_geom = ref_geom.buffer(0)
+#                         if geom.intersects(fixed_ref_geom):
+#                             overlap_area = geom.intersection(ref_geom).area
+#                             overlapping_height_area += ref_height * overlap_area
+#                             overlapping_area += overlap_area
+#                     except Exception as fix_error:
+#                         print(f"Failed to fix polygon")
+#                     continue
             
-            # Update height if overlapping buildings found
-            if overlapping_height_area > 0:
-                count_1 += 1
-                new_height = overlapping_height_area / overlapping_area
-                feature['properties']['height'] = new_height
-            else:
-                count_2 += 1
-                feature['properties']['height'] = np.nan
+#             # Update height if overlapping buildings found
+#             if overlapping_height_area > 0:
+#                 count_1 += 1
+#                 new_height = overlapping_height_area / overlapping_area
+#                 feature['properties']['height'] = new_height
+#             else:
+#                 count_2 += 1
+#                 feature['properties']['height'] = np.nan
         
-        updated_geojson_data_0.append(feature)
+#         updated_geojson_data_0.append(feature)
     
-    # Add non-intersecting buildings from reference dataset
-    for ref_geom, ref_height, ref_feature in reference_buildings:
-        has_intersection = False
-        try:
-            # Check if reference building intersects with any existing building
-            for existing_geom in existing_buildings:
-                if ref_geom.intersects(existing_geom):
-                    has_intersection = True
-                    break
+#     # Add non-intersecting buildings from reference dataset
+#     for ref_geom, ref_height, ref_feature in reference_buildings:
+#         has_intersection = False
+#         try:
+#             # Check if reference building intersects with any existing building
+#             for existing_geom in existing_buildings:
+#                 if ref_geom.intersects(existing_geom):
+#                     has_intersection = True
+#                     break
             
-            # Add building if it doesn't intersect with any existing ones
-            if not has_intersection:
-                updated_geojson_data_0.append(ref_feature)
-                count_3 += 1
+#             # Add building if it doesn't intersect with any existing ones
+#             if not has_intersection:
+#                 updated_geojson_data_0.append(ref_feature)
+#                 count_3 += 1
                 
-        except GEOSException as e:
-            # Try to fix invalid geometries
-            try:
-                fixed_ref_geom = ref_geom.buffer(0)
-                for existing_geom in existing_buildings:
-                    if fixed_ref_geom.intersects(existing_geom):
-                        has_intersection = True
-                        break
+#         except GEOSException as e:
+#             # Try to fix invalid geometries
+#             try:
+#                 fixed_ref_geom = ref_geom.buffer(0)
+#                 for existing_geom in existing_buildings:
+#                     if fixed_ref_geom.intersects(existing_geom):
+#                         has_intersection = True
+#                         break
                 
-                if not has_intersection:
-                    updated_geojson_data_0.append(ref_feature)
-                    count_3 += 1
-            except Exception as fix_error:
-                print(f"Failed to process non-intersecting building")
-            continue
+#                 if not has_intersection:
+#                     updated_geojson_data_0.append(ref_feature)
+#                     count_3 += 1
+#             except Exception as fix_error:
+#                 print(f"Failed to process non-intersecting building")
+#             continue
     
-    # Print statistics about updates
-    if count_0 > 0:
-        print(f"{count_0} of the total {len(geojson_data_0)} building footprint from base source did not have height data.")
-        print(f"For {count_1} of these building footprints without height, values from complement source were assigned.")
-        print(f"{count_3} non-intersecting buildings from Microsoft Building Footprints were added to the output.")
+#     # Print statistics about updates
+#     if count_0 > 0:
+#         print(f"{count_0} of the total {len(geojson_data_0)} building footprint from base source did not have height data.")
+#         print(f"For {count_1} of these building footprints without height, values from complement source were assigned.")
+#         print(f"{count_3} non-intersecting buildings from Microsoft Building Footprints were added to the output.")
     
-    return updated_geojson_data_0
+#     return updated_geojson_data_0
+
+import numpy as np
+import geopandas as gpd
+import pandas as pd
+from shapely.geometry import shape
+from shapely.errors import GEOSException
+
+def geojson_to_gdf(geojson_data, id_col='id'):
+    """
+    Convert a list of GeoJSON-like dict features into a GeoDataFrame.
+    
+    Args:
+        geojson_data (List[Dict]): A list of feature dicts (Fiona-like).
+        id_col (str): Name of property to use as an identifier. If not found,
+                      we'll try to create a unique ID.
+
+    Returns:
+        gpd.GeoDataFrame: GeoDataFrame with geometry and property columns.
+    """
+    # Build lists for geometry and properties
+    geometries = []
+    all_props = []
+
+    for i, feature in enumerate(geojson_data):
+        # Extract geometry
+        geom = feature.get('geometry')
+        shapely_geom = shape(geom) if geom else None
+
+        # Extract properties
+        props = feature.get('properties', {})
+        
+        # If an ID column is missing, create one
+        if id_col not in props:
+            props[id_col] = i  # fallback ID
+
+        # Capture geometry and all props
+        geometries.append(shapely_geom)
+        all_props.append(props)
+
+    gdf = gpd.GeoDataFrame(all_props, geometry=geometries, crs="EPSG:4326")
+    return gdf
+
+
+def complement_building_heights_gdf(geojson_data_0, geojson_data_1,
+                                    primary_id='id', ref_id='id'):
+    """
+    Use a vectorized approach with GeoPandas to:
+      1) Convert both datasets to GeoDataFrames
+      2) Find intersections and compute weighted average heights
+      3) Update heights in the primary dataset
+      4) Add non-intersecting buildings from the reference dataset
+    
+    Args:
+        geojson_data_0 (List[Dict]): Primary GeoJSON-like features
+        geojson_data_1 (List[Dict]): Reference GeoJSON-like features
+        primary_id (str): Name of the unique identifier in primary dataset's properties
+        ref_id (str): Name of the unique identifier in reference dataset's properties
+
+    Returns:
+        gpd.GeoDataFrame: Updated GeoDataFrame (including new buildings).
+                         You can convert it back to a list of dict features if needed.
+    """
+    # ----------------------------------------------------------------
+    # 1) Convert primary and reference data to GeoDataFrames
+    # ----------------------------------------------------------------
+    gdf_primary = geojson_to_gdf(geojson_data_0, id_col=primary_id)
+    gdf_ref = geojson_to_gdf(geojson_data_1, id_col=ref_id)
+
+    # Ensure both are in the same CRS, e.g. EPSG:4326 or some projected CRS
+    # If needed, do something like:
+    # gdf_primary = gdf_primary.to_crs("EPSG:xxxx")
+    # gdf_ref = gdf_ref.to_crs("EPSG:xxxx")
+
+    # Make sure height columns exist
+    if 'height' not in gdf_primary.columns:
+        gdf_primary['height'] = 0.0
+    if 'height' not in gdf_ref.columns:
+        gdf_ref['height'] = 0.0
+
+    # ----------------------------------------------------------------
+    # 2) Intersection to compute areas for overlapping buildings
+    # ----------------------------------------------------------------
+    # We'll rename columns to avoid collision after overlay
+    gdf_primary = gdf_primary.rename(columns={'height': 'height_primary'})
+    gdf_ref = gdf_ref.rename(columns={'height': 'height_ref'})
+
+    # We perform an 'intersection' overlay to get the overlapping polygons
+    intersect_gdf = gpd.overlay(gdf_primary, gdf_ref, how='intersection')
+
+    # Compute intersection area
+    intersect_gdf['intersect_area'] = intersect_gdf.area
+    # Weighted area (height_ref * intersect_area)
+    intersect_gdf['height_area'] = intersect_gdf['height_ref'] * intersect_gdf['intersect_area']
+
+    # ----------------------------------------------------------------
+    # 3) Aggregate to get weighted average height for each primary building
+    # ----------------------------------------------------------------
+    # We group by the primary building ID, summing up the area and the 'height_area'
+    group_cols = {
+        'height_area': 'sum',
+        'intersect_area': 'sum'
+    }
+    grouped = intersect_gdf.groupby(gdf_primary[primary_id].name).agg(group_cols)
+
+    # Weighted average
+    grouped['weighted_height'] = grouped['height_area'] / grouped['intersect_area']
+
+    # ----------------------------------------------------------------
+    # 4) Merge aggregated results back to the primary GDF
+    # ----------------------------------------------------------------
+    # After merging, the primary GDF will have a column 'weighted_height'
+    gdf_primary = gdf_primary.merge(grouped['weighted_height'],
+                                    left_on=primary_id,
+                                    right_index=True,
+                                    how='left')
+
+    # Where primary had zero or missing height, we assign the new weighted height
+    zero_or_nan_mask = (gdf_primary['height_primary'] == 0) | (gdf_primary['height_primary'].isna())
+    gdf_primary.loc[zero_or_nan_mask, 'height_primary'] = gdf_primary.loc[zero_or_nan_mask, 'weighted_height']
+
+    # For any building that had no overlap, 'weighted_height' might be NaN.
+    # Keep it as NaN or set to 0 if you prefer:
+    gdf_primary['height_primary'] = gdf_primary['height_primary'].fillna(np.nan)
+
+    # ----------------------------------------------------------------
+    # 5) Identify reference buildings that do not intersect any primary building
+    # ----------------------------------------------------------------
+    # Another overlay or spatial join can do this:
+    # Option A: use 'difference' on reference to get non-overlapping parts, but that can chop polygons.
+    # Option B: check building-level intersection. We'll do a bounding test with sjoin.
+    
+    # For building-level intersection, do a left join of ref onto primary.
+    # Then we'll identify which reference IDs are missing from the intersection result.
+    sjoin_gdf = gpd.sjoin(gdf_ref, gdf_primary, how='left', op='intersects')
+
+    # All reference buildings that did not intersect any primary building
+    non_intersect_ids = sjoin_gdf.loc[sjoin_gdf[primary_id].isna(), ref_id].unique()
+
+    # Extract them from the original reference GDF
+    gdf_ref_non_intersect = gdf_ref[gdf_ref[ref_id].isin(non_intersect_ids)]
+
+    # We'll rename columns back to 'height' to be consistent
+    gdf_ref_non_intersect = gdf_ref_non_intersect.rename(columns={'height_ref': 'height'})
+
+    # Also rename any other properties you prefer. For clarity, keep an ID so you know they came from reference.
+
+    # ----------------------------------------------------------------
+    # 6) Combine the updated primary GDF with the new reference buildings
+    # ----------------------------------------------------------------
+    # First, rename columns in updated primary GDF
+    gdf_primary = gdf_primary.rename(columns={'height_primary': 'height'})
+    # Drop the 'weighted_height' column to clean up
+    if 'weighted_height' in gdf_primary.columns:
+        gdf_primary.drop(columns='weighted_height', inplace=True)
+
+    # Concatenate
+    final_gdf = pd.concat([gdf_primary, gdf_ref_non_intersect], ignore_index=True)
+
+    # ----------------------------------------------------------------
+    # Return the combined GeoDataFrame
+    # (You can convert it back to a list of GeoJSON-like dictionaries)
+    # ----------------------------------------------------------------
+    return final_gdf
+
+
+def gdf_to_geojson_dicts(gdf, id_col='id'):
+    """
+    Convert a GeoDataFrame to a list of dicts similar to GeoJSON features.
+    """
+    records = gdf.to_dict(orient='records')
+    features = []
+    for rec in records:
+        # geometry is separate
+        geom = rec.pop('geometry', None)
+        if geom is not None:
+            geom = geom.__geo_interface__
+        # use or set ID
+        feature_id = rec.get(id_col, None)
+        props = {k: v for k, v in rec.items() if k != id_col}
+        # build GeoJSON-like feature dict
+        feature = {
+            'type': 'Feature',
+            'properties': props,
+            'geometry': geom
+        }
+        features.append(feature)
+
+    return features
+
+
+def complement_building_heights_from_geojson(geojson_data_0, geojson_data_1,
+                                             primary_id='id', ref_id='id'):
+    """
+    High-level function that wraps the GeoPandas approach end-to-end.
+    Returns a list of GeoJSON-like feature dicts.
+    """
+    # 1) Complement building heights using the GeoDataFrame approach
+    final_gdf = complement_building_heights_gdf(
+        geojson_data_0,
+        geojson_data_1,
+        primary_id=primary_id,
+        ref_id=ref_id
+    )
+
+    # 2) Convert back to geojson-like dict format
+    updated_features = gdf_to_geojson_dicts(final_gdf, id_col=primary_id)
+    return updated_features
 
 def load_geojsons_from_multiple_gz(file_paths):
     """

voxcity/geo/network.py

@@ -15,103 +15,75 @@ from joblib import Parallel, delayed
 
 from .grid import grid_to_geodataframe
 
-def calculate_edge_values(G, gdf, value_col='value'):
+def vectorized_edge_values(G, polygons_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
+    Compute average polygon values along each edge by:
+    1) Building an Edge GeoDataFrame in linestring form
+    2) Using gpd.overlay or sjoin to get their intersection with polygons
+    3) Computing length-weighted average
     """
-    edge_values = {}
-    for u, v, k, data in G.edges(data=True, keys=True):
+    # 1) Build edge GeoDataFrame (EPSG:4326)
+    records = []
+    for i, (u, v, k, data) in enumerate(G.edges(keys=True, data=True)):
         if 'geometry' in data:
-            edge_line = data['geometry']
+            edge_geom = 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
-    
+            edge_geom = LineString([(start_node['x'], start_node['y']),
+                                    (end_node['x'], end_node['y'])])
+        records.append({
+            'edge_id': i,  # unique ID for grouping
+            'u': u,
+            'v': v,
+            'k': k,
+            'geometry': edge_geom
+        })
+
+    edges_gdf = gpd.GeoDataFrame(records, crs="EPSG:4326")
+    if polygons_gdf.crs != edges_gdf.crs:
+        polygons_gdf = polygons_gdf.to_crs(edges_gdf.crs)
+
+    # 2) Use a projected CRS for length calculations
+    edges_3857 = edges_gdf.to_crs(epsg=3857)
+    polys_3857 = polygons_gdf.to_crs(epsg=3857)
+
+    # 3) Intersection: lines vs polygons -> lines clipped to polygons
+    #    gpd.overlay with how='intersection' can yield partial lines
+    intersected = gpd.overlay(edges_3857, polys_3857, how='intersection')
+
+    # Now each row is a geometry representing the intersection segment,
+    # with columns from edges + polygons.
+    # For lines, 'intersection' yields the line portion inside each polygon.
+    # We'll compute the length, then do a length-weighted average of value_col.
+
+    intersected['seg_length'] = intersected.geometry.length
+    # Weighted contribution = seg_length * polygon_value
+    intersected['weighted_val'] = intersected['seg_length'] * intersected[value_col]
+
+    # 4) Group by edge_id
+    grouped = intersected.groupby('edge_id')
+    results = grouped.apply(
+        lambda df: df['weighted_val'].sum() / df['seg_length'].sum()
+        if df['seg_length'].sum() > 0 else np.nan
+    )
+    # results is a Series with index=edge_id
+
+    # 5) Map results back to edges
+    edge_values = {}
+    for edge_id, val in results.items():
+        rec = edges_gdf.iloc[edge_id]
+        edge_values[(rec['u'], rec['v'], rec['k'])] = val
+
     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
+def get_network_values(
+    grid,
+    rectangle_vertices,
+    meshsize,
+    value_name='value',
+    **kwargs
+):
     defaults = {
         'network_type': 'walk',
         'vis_graph': True,
@@ -124,79 +96,71 @@ def get_network_values(grid, rectangle_vertices, meshsize, value_name='value', *
         'basemap_style': ctx.providers.CartoDB.Positron,
         'save_path': None
     }
-    
-    # Update defaults with provided kwargs
-    settings = defaults.copy()
-    settings.update(kwargs)
+    settings = {**defaults, **kwargs}
 
-    grid_gdf = grid_to_geodataframe(grid, rectangle_vertices, meshsize)
-    
-    # Extract bounding box coordinates
+    # Build polygons GDF if needed
+    polygons_gdf = (grid if isinstance(grid, gpd.GeoDataFrame) 
+                    else grid_to_geodataframe(grid, rectangle_vertices, meshsize))
+    if polygons_gdf.crs is None:
+        polygons_gdf.set_crs(epsg=4326, inplace=True)
+
+    # BBox
     north, south = rectangle_vertices[1][1], rectangle_vertices[0][1]
-    east, west   = rectangle_vertices[2][0], rectangle_vertices[0][0]
+    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
+
+    # Download OSMnx network
+    G = ox.graph.graph_from_bbox(
+        bbox=bbox,
+        network_type=settings['network_type'],
+        simplify=True
+    )
+
+    # Compute edge values with the vectorized function
+    edge_values = vectorized_edge_values(G, polygons_gdf, value_col="value")
+    nx.set_edge_attributes(G, edge_values, name=value_name)
+
+    # Build edge GDF
     edges_with_values = []
     for u, v, k, data in G.edges(data=True, keys=True):
         if 'geometry' in data:
-            edge_line = data['geometry']
+            geom = 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'])])
-        
+            geom = LineString([(start_node['x'], start_node['y']),
+                               (end_node['x'], end_node['y'])])
+
+        val = data.get(value_name, np.nan)
         edges_with_values.append({
-            'geometry': edge_line,
-            value_name: data.get(value_name, np.nan),
-            'u': u,
-            'v': v,
-            'key': k
+            'u': u, 'v': v, 'key': k,
+            'geometry': geom,
+            value_name: val
         })
-    
-    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)
-    
+
+    edge_gdf = gpd.GeoDataFrame(edges_with_values, crs="EPSG:4326")
+
+    # Save
     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'])
-        
+        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}
+        )
+        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

@@ -57,7 +57,7 @@ def compute_direct_solar_irradiance_map_binary(voxel_data, sun_direction, view_p
                 # Check if current voxel is empty/tree and voxel below is solid
                 if voxel_data[x, y, z] in (0, -2) and voxel_data[x, y, z - 1] not in (0, -2):
                     # Skip if standing on building/vegetation/water
-                    if voxel_data[x, y, z - 1] in (-30, -3, -2):
+                    if (voxel_data[x, y, z - 1] in (7, 8, 9)) or (voxel_data[x, y, z - 1] < 0):
                         irradiance_map[x, y] = np.nan
                         found_observer = True
                         break
@@ -148,9 +148,10 @@ def get_direct_solar_irradiance_map(voxel_data, meshsize, azimuth_degrees_ori, e
         cmap = plt.cm.get_cmap(colormap).copy()
         cmap.set_bad(color='lightgray')
         plt.figure(figsize=(10, 8))
-        plt.title("Horizontal Direct Solar Irradiance Map (0° = North)")
+        # plt.title("Horizontal Direct Solar Irradiance Map (0° = North)")
         plt.imshow(direct_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
         plt.colorbar(label='Direct Solar Irradiance (W/m²)')
+        plt.axis('off')
         plt.show()
 
     # Optional OBJ export
@@ -231,9 +232,10 @@ def get_diffuse_solar_irradiance_map(voxel_data, meshsize, diffuse_irradiance=1.
         cmap = plt.cm.get_cmap(colormap).copy()
         cmap.set_bad(color='lightgray')
         plt.figure(figsize=(10, 8))
-        plt.title("Diffuse Solar Irradiance Map")
+        # plt.title("Diffuse Solar Irradiance Map")
         plt.imshow(diffuse_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
         plt.colorbar(label='Diffuse Solar Irradiance (W/m²)')
+        plt.axis('off')
         plt.show()
 
     # Optional OBJ export
@@ -310,7 +312,7 @@ def get_global_solar_irradiance_map(
     # Create kwargs for diffuse calculation
     direct_diffuse_kwargs = kwargs.copy()
     direct_diffuse_kwargs.update({
-        'show_plot': False,
+        'show_plot': True,
         'obj_export': False
     })
 
@@ -343,9 +345,10 @@ def get_global_solar_irradiance_map(
         cmap = plt.cm.get_cmap(colormap).copy()
         cmap.set_bad(color='lightgray')
         plt.figure(figsize=(10, 8))
-        plt.title("Global Solar Irradiance Map")
+        # plt.title("Global Solar Irradiance Map")
         plt.imshow(global_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
         plt.colorbar(label='Global Solar Irradiance (W/m²)')
+        plt.axis('off')
         plt.show()
 
     # Optional OBJ export
@@ -571,8 +574,9 @@ def get_cumulative_global_solar_irradiance(
             cmap = plt.cm.get_cmap(colormap).copy()
             cmap.set_bad(color='lightgray')
             plt.figure(figsize=(8, 6))
-            plt.title(f"Global Solar Irradiance at {time_local.strftime('%Y-%m-%d %H:%M:%S')}")
+            # plt.title(f"Global Solar Irradiance at {time_local.strftime('%Y-%m-%d %H:%M:%S')}")
             plt.imshow(global_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
+            plt.axis('off')
             plt.colorbar(label='Global Solar Irradiance (W/m²)')
             plt.show()
 
@@ -588,9 +592,10 @@ def get_cumulative_global_solar_irradiance(
         cmap = plt.cm.get_cmap(colormap).copy()
         cmap.set_bad(color='lightgray')
         plt.figure(figsize=(8, 6))
-        plt.title("Cumulative Global Solar Irradiance Map")
+        # plt.title("Cumulative Global Solar Irradiance Map")
         plt.imshow(cumulative_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
         plt.colorbar(label='Cumulative Global Solar Irradiance (W/m²·hour)')
+        plt.axis('off')
         plt.show()
 
     # Optional OBJ export

voxcity/sim/view.py

@@ -413,6 +413,7 @@ def get_view_index(voxel_data, meshsize, mode=None, hit_values=None, inclusion_m
     plt.figure(figsize=(10, 8))
     plt.imshow(vi_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
     plt.colorbar(label='View Index')
+    plt.axis('off')
     plt.show()
 
     # Optional OBJ export
@@ -626,7 +627,7 @@ def compute_visibility_map(voxel_data, landmark_positions, opaque_values, view_h
             for z in range(1, nz):
                 if voxel_data[x, y, z] == 0 and voxel_data[x, y, z - 1] != 0:
                     # Skip if standing on building or vegetation
-                    if voxel_data[x, y, z - 1] in (-3, -2, 7, 8, 9):
+                    if (voxel_data[x, y, z - 1] in (7, 8, 9)) or (voxel_data[x, y, z - 1] < 0):
                         visibility_map[x, y] = np.nan
                         found_observer = True
                         break
@@ -696,7 +697,7 @@ def compute_landmark_visibility(voxel_data, target_value=-30, view_height_voxel=
     plt.legend(handles=[visible_patch, not_visible_patch], 
             loc='center left',
             bbox_to_anchor=(1.0, 0.5))
-    
+    plt.axis('off')
     plt.show()
 
     return np.flipud(visibility_map)
@@ -852,9 +853,10 @@ def get_sky_view_factor_map(voxel_data, meshsize, show_plot=False, **kwargs):
         cmap = plt.cm.get_cmap(colormap).copy()
         cmap.set_bad(color='lightgray')
         plt.figure(figsize=(10, 8))
-        plt.title("Sky View Factor Map")
+        # plt.title("Sky View Factor Map")
         plt.imshow(vi_map, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
         plt.colorbar(label='Sky View Factor')
+        plt.axis('off')
         plt.show()
 
     # Optional OBJ export

voxcity/voxcity.py

@@ -294,28 +294,31 @@ def get_dem_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
     print("Creating Digital Elevation Model (DEM) grid\n ")
     print(f"Data source: {source}")
 
-    # Initialize Earth Engine for accessing elevation data
-    initialize_earth_engine()
+    if source == "Local file":
+        geotiff_path = kwargs["dem_path"]
+    else:
+        # Initialize Earth Engine for accessing elevation data
+        initialize_earth_engine()
 
-    geotiff_path = os.path.join(output_dir, "dem.tif")
+        geotiff_path = os.path.join(output_dir, "dem.tif")
 
-    # Add buffer around ROI to ensure smooth interpolation at edges
-    buffer_distance = 100
-    roi = get_roi(rectangle_vertices)
-    roi_buffered = roi.buffer(buffer_distance)
-    
-    # Get DEM data
-    image = get_dem_image(roi_buffered, source)
-    
-    # Save DEM data with appropriate resolution based on source
-    if source in ["England 1m DTM", 'DEM France 1m', 'DEM France 5m', 'AUSTRALIA 5M DEM']:
-        save_geotiff(image, geotiff_path, scale=meshsize, region=roi_buffered, crs='EPSG:4326')
-    elif source == 'USGS 3DEP 1m':
-        scale = max(meshsize, 1.25)
-        save_geotiff(image, geotiff_path, scale=scale, region=roi_buffered, crs='EPSG:4326')
-    else:
-        # Default to 30m resolution for other sources
-        save_geotiff(image, geotiff_path, scale=30, region=roi_buffered)
+        # Add buffer around ROI to ensure smooth interpolation at edges
+        buffer_distance = 100
+        roi = get_roi(rectangle_vertices)
+        roi_buffered = roi.buffer(buffer_distance)
+        
+        # Get DEM data
+        image = get_dem_image(roi_buffered, source)
+        
+        # Save DEM data with appropriate resolution based on source
+        if source in ["England 1m DTM", 'DEM France 1m', 'DEM France 5m', 'AUSTRALIA 5M DEM']:
+            save_geotiff(image, geotiff_path, scale=meshsize, region=roi_buffered, crs='EPSG:4326')
+        elif source == 'USGS 3DEP 1m':
+            scale = max(meshsize, 1.25)
+            save_geotiff(image, geotiff_path, scale=scale, region=roi_buffered, crs='EPSG:4326')
+        else:
+            # Default to 30m resolution for other sources
+            save_geotiff(image, geotiff_path, scale=30, region=roi_buffered)
 
     # Create DEM grid with optional interpolation method
     dem_interpolation = kwargs.get("dem_interpolation")

{voxcity-0.3.9.dist-info → voxcity-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.9
+Version: 0.3.10
 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>
@@ -66,7 +66,7 @@ Requires-Dist: ruff; extra == "dev"
 
 # VoxCity
 
-**VoxCity** is a Python package that facilitates the creation of voxel-based 3D urban environments and related geospatial analyses. It integrates various geospatial datasets—such as building footprints, land cover, canopy height, and digital elevation models (DEMs)—to generate 2D and 3D representations of urban areas. It can export data in formats compatible with popular simulation tools like ENVI-MET, as well as visualization tools like MagicaVoxel, and supports simulations such as sky view index and green view index calculations.
+**VoxCity** is a Python package that provides a one-stop solution for grid-based 3D city model generation and urban simulation for cities worldwide. It integrates various geospatial datasets—such as building footprints, land cover, canopy height, and digital elevation models (DEMs)—to generate 2D and 3D representations of urban areas. It can export data in formats compatible with popular simulation tools like ENVI-MET, as well as visualization tools like MagicaVoxel, and supports simulations such as sky view index and green view index calculations.
 
 <!-- <p align="center">
   <picture>
@@ -284,7 +284,7 @@ The generated OBJ files can be opened and rendered in the following 3D visualiza
   <img src="https://raw.githubusercontent.com/kunifujiwara/VoxCity/main/images/obj.png" alt="OBJ 3D City Model Rendered in Rhino" width="600">
 </p>
 <p align="center">
-  <em>Example Output Exported in OBJ and Rendered in MagicaVoxel</em>
+  <em>Example Output Exported in OBJ and Rendered in Rhino</em>
 </p>
 
 #### MagicaVoxel VOX Files:

{voxcity-0.3.9.dist-info → voxcity-0.3.10.dist-info}/RECORD

@@ -1,5 +1,5 @@
 voxcity/__init__.py,sha256=HJM0D2Mv9qpk4JdVzt2SRAAk-hA1D_pCO0ezZH9F7KA,248
-voxcity/voxcity.py,sha256=aeM1OzW7nmbW4h4SFHceugvb0NhKdXlQz_QcVQrZrIk,33498
+voxcity/voxcity.py,sha256=tZOgRnyvw4ZHuuJr_QP3qeen5DxhYOkDglNDtpB0hzY,33664
 voxcity/download/__init__.py,sha256=OgGcGxOXF4tjcEL6DhOnt13DYPTvOigUelp5xIpTqM0,171
 voxcity/download/eubucco.py,sha256=e1JXBuUfBptSDvNznSGckRs5Xgrj_SAFxk445J_o4KY,14854
 voxcity/download/gee.py,sha256=j7jmzp44T3M6j_4DwhU9Y8Y6gqbZo1zFIlduQPc0jvk,14339
@@ -11,26 +11,26 @@ voxcity/download/overture.py,sha256=daOvsySC2KIcTcMJUSA7XdbMELJuyLAIM2vr1DRLGp0,
 voxcity/download/utils.py,sha256=z6MdPxM96FWQVqvZW2Eg5pMewVHVysUP7F6ueeCwMfI,1375
 voxcity/file/__init_.py,sha256=cVyNyE6axEpSd3CT5hGuMOAlOyU1p8lVP4jkF1-0Ad8,94
 voxcity/file/envimet.py,sha256=SPVoSyYTMNyDRDFWsI0YAsIsb6yt_SXZeDUlhyqlEqY,24282
-voxcity/file/geojson.py,sha256=G8jG5Ffh86uhNZBLmr_hgyU9FwGab_tJBePET5DUQYk,24188
+voxcity/file/geojson.py,sha256=h6WYr1bdvzC46w6CbjKzO4wMtVrKTSF7SGaOUuUMkCM,33412
 voxcity/file/magicavoxel.py,sha256=Fsv7yGRXeKmp82xcG3rOb0t_HtoqltNq2tHl08xVlqY,7500
 voxcity/file/obj.py,sha256=oW-kPoZj53nfmO9tXP3Wvizq6Kkjh-QQR8UBexRuMiI,21609
 voxcity/geo/__init_.py,sha256=AZYQxK1zY1M_mDT1HmgcdVI86OAtwK7CNo3AOScLHco,88
 voxcity/geo/draw.py,sha256=roljWXyqYdsWYkmb-5_WNxrJrfV5lnAt8uZblCCo_3Q,13555
 voxcity/geo/grid.py,sha256=_MzO-Cu2GhlP9nuCql6f1pfbU2_OAL27aQ_zCj1u_zk,36288
-voxcity/geo/network.py,sha256=lcDLgsmPb9MyFeQlJwscXl7_9JCG7TIlbAu19MPf2m8,18846
+voxcity/geo/network.py,sha256=P1oaosieFPuWj9QbU9VmZHpoXV3HR61VssZMcUZLYIw,17403
 voxcity/geo/utils.py,sha256=1BRHp-DDeOA8HG8jplY7Eo75G3oXkVGL6DGONL4BA8A,19815
 voxcity/sim/__init_.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
-voxcity/sim/solar.py,sha256=f9GLANRnEVj7NseSETVRDvTD_t_Bn9hC6dJUV5Ak_cU,31799
+voxcity/sim/solar.py,sha256=wpnDC3BAm4edx5Z-dz2g_5rqnFNi_YKXneHY2RVBk1w,31968
 voxcity/sim/utils.py,sha256=sEYBB2-hLJxTiXQps1_-Fi7t1HN3-1OPOvBCWtgIisA,130
-voxcity/sim/view.py,sha256=oq6G-f0Tn-KT0vjYNJfucmOIrv1GNjljhA-zvU4nNoA,36668
+voxcity/sim/view.py,sha256=FoXovh406hmvL1obaIXi2MyiRnPdXHY9SWxqfqmcJnc,36758
 voxcity/utils/__init_.py,sha256=nLYrj2huBbDBNMqfchCwexGP8Tlt9O_XluVDG7MoFkw,98
 voxcity/utils/lc.py,sha256=RwPd-VY3POV3gTrBhM7TubgGb9MCd3nVah_G8iUEF7k,11562
 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.9.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.3.9.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
-voxcity-0.3.9.dist-info/METADATA,sha256=wbktfEaoqiafDk3sX8gZxM2m6-pYxXDkGI5daZbU-S4,25110
-voxcity-0.3.9.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-voxcity-0.3.9.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.3.9.dist-info/RECORD,,
+voxcity-0.3.10.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.3.10.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
+voxcity-0.3.10.dist-info/METADATA,sha256=Lf4DIH1_hPKyQkxAset4cMlL5dJWwHosXpBgj6Ybta8,25122
+voxcity-0.3.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+voxcity-0.3.10.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.3.10.dist-info/RECORD,,

{voxcity-0.3.9.dist-info → voxcity-0.3.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.7.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any