voxcity 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

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,
@@ -235,77 +236,6 @@ def tree_height_grid_from_land_cover(land_cover_grid_ori):
 
     return tree_height_grid
 
-def create_land_cover_grid_from_geotiff(tiff_path, mesh_size, land_cover_classes):
-    """
-    Create a land cover grid from a GeoTIFF file.
-    
-    Args:
-        tiff_path (str): Path to GeoTIFF file
-        mesh_size (float): Size of mesh cells
-        land_cover_classes (dict): Dictionary mapping land cover classes
-        
-    Returns:
-        numpy.ndarray: Grid of land cover classes
-    """
-    with rasterio.open(tiff_path) as src:
-        # Read RGB bands
-        img = src.read((1,2,3))
-        left, bottom, right, top = src.bounds
-        src_crs = src.crs
-        
-        # Handle different coordinate reference systems
-        if src_crs.to_epsg() == 3857:  # Web Mercator
-            # Convert bounds from Web Mercator to WGS84 for accurate distance calculations
-            wgs84 = CRS.from_epsg(4326)
-            transformer = Transformer.from_crs(src_crs, wgs84, always_xy=True)
-            left_wgs84, bottom_wgs84 = transformer.transform(left, bottom)
-            right_wgs84, top_wgs84 = transformer.transform(right, top)
-        
-            # Calculate actual distances using geodesic calculations
-            geod = Geod(ellps="WGS84")
-            _, _, width = geod.inv(left_wgs84, bottom_wgs84, right_wgs84, bottom_wgs84)
-            _, _, height = geod.inv(left_wgs84, bottom_wgs84, left_wgs84, top_wgs84)
-        else:
-            # For projections already in meters, use simple subtraction
-            width = right - left
-            height = top - bottom
-        
-        # Calculate grid dimensions based on mesh size
-        num_cells_x = int(width / mesh_size + 0.5)
-        num_cells_y = int(height / mesh_size + 0.5)
-        
-        # Adjust mesh size to fit image exactly
-        adjusted_mesh_size_x = (right - left) / num_cells_x
-        adjusted_mesh_size_y = (top - bottom) / num_cells_y
-        
-        # Create affine transform for new grid
-        new_affine = Affine(adjusted_mesh_size_x, 0, left, 0, -adjusted_mesh_size_y, top)
-        
-        # Create coordinate grids
-        cols, rows = np.meshgrid(np.arange(num_cells_x), np.arange(num_cells_y))
-        xs, ys = new_affine * (cols, rows)
-        xs_flat, ys_flat = xs.flatten(), ys.flatten()
-        
-        # Convert coordinates to image indices
-        row, col = src.index(xs_flat, ys_flat)
-        row, col = np.array(row), np.array(col)
-        
-        # Filter out invalid indices
-        valid = (row >= 0) & (row < src.height) & (col >= 0) & (col < src.width)
-        row, col = row[valid], col[valid]
-        
-        # Create output grid and fill with land cover classes
-        grid = np.full((num_cells_y, num_cells_x), 'No Data', dtype=object)
-        
-        for i, (r, c) in enumerate(zip(row, col)):
-            cell_data = img[:, r, c]
-            dominant_class = get_dominant_class(cell_data, land_cover_classes)
-            grid_row, grid_col = np.unravel_index(i, (num_cells_y, num_cells_x))
-            grid[grid_row, grid_col] = dominant_class
-    
-    # Flip grid vertically before returning
-    return np.flipud(grid)
-
 def create_land_cover_grid_from_geotiff_polygon(tiff_path, mesh_size, land_cover_classes, polygon):
     """
     Create a land cover grid from a GeoTIFF file within a polygon boundary.
@@ -329,7 +259,7 @@ def create_land_cover_grid_from_geotiff_polygon(tiff_path, mesh_size, land_cover
         poly = Polygon(polygon)
         
         # Get bounds of the polygon in WGS84 coordinates
-        bottom_wgs84, left_wgs84, top_wgs84, right_wgs84 = poly.bounds
+        left_wgs84, bottom_wgs84, right_wgs84, top_wgs84 = poly.bounds
         # print(left, bottom, right, top)
 
         # Calculate width and height using geodesic calculations for accuracy
@@ -381,7 +311,7 @@ def create_land_cover_grid_from_geojson_polygon(geojson_data, meshsize, source,
         geojson_data (dict): GeoJSON data containing land cover polygons
         meshsize (float): Size of each grid cell in meters
         source (str): Source of the land cover data to determine class priorities
-        rectangle_vertices (list): List of 4 (lat,lon) coordinate pairs defining the rectangle bounds
+        rectangle_vertices (list): List of 4 (lon,lat) coordinate pairs defining the rectangle bounds
 
     Returns:
         numpy.ndarray: 2D grid of land cover classes as strings
@@ -411,8 +341,8 @@ def create_land_cover_grid_from_geojson_polygon(geojson_data, meshsize, source,
     vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
 
     # Calculate actual distances between vertices using geodesic calculations
-    dist_side_1 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_1[1], vertex_1[0])
-    dist_side_2 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_3[1], vertex_3[0])
+    dist_side_1 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_1[0], vertex_1[1])
+    dist_side_2 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_3[0], vertex_3[1])
 
     # Create vectors representing the sides of the rectangle
     side_1 = np.array(vertex_1) - np.array(vertex_0)
@@ -476,70 +406,6 @@ def create_land_cover_grid_from_geojson_polygon(geojson_data, meshsize, source,
                     continue 
     return grid
 
-def create_canopy_height_grid_from_geotiff(tiff_path, mesh_size):
-    """
-    Create a canopy height grid from a GeoTIFF file.
-    
-    Args:
-        tiff_path (str): Path to GeoTIFF file
-        mesh_size (float): Size of mesh cells
-        
-    Returns:
-        numpy.ndarray: Grid of canopy heights
-    """
-    with rasterio.open(tiff_path) as src:
-        # Read single band height data
-        img = src.read(1)
-        left, bottom, right, top = src.bounds
-        src_crs = src.crs
-
-        # Handle coordinate system conversion and distance calculations
-        if src_crs.to_epsg() == 3857:  # Web Mercator projection
-            # Convert bounds to WGS84 for accurate distance calculation
-            wgs84 = CRS.from_epsg(4326)
-            transformer = Transformer.from_crs(src_crs, wgs84, always_xy=True)
-            left_wgs84, bottom_wgs84 = transformer.transform(left, bottom)
-            right_wgs84, top_wgs84 = transformer.transform(right, top)
-        
-            # Calculate actual distances using geodesic methods
-            geod = Geod(ellps="WGS84")
-            _, _, width = geod.inv(left_wgs84, bottom_wgs84, right_wgs84, bottom_wgs84)
-            _, _, height = geod.inv(left_wgs84, bottom_wgs84, left_wgs84, top_wgs84)
-        else:
-            # For projections already in meters, use simple subtraction
-            width = right - left
-            height = top - bottom
-
-        # Calculate grid dimensions and adjust mesh size
-        num_cells_x = int(width / mesh_size + 0.5)
-        num_cells_y = int(height / mesh_size + 0.5)
-
-        adjusted_mesh_size_x = (right - left) / num_cells_x
-        adjusted_mesh_size_y = (top - bottom) / num_cells_y
-
-        # Create affine transform for coordinate mapping
-        new_affine = Affine(adjusted_mesh_size_x, 0, left, 0, -adjusted_mesh_size_y, top)
-
-        # Generate coordinate grids
-        cols, rows = np.meshgrid(np.arange(num_cells_x), np.arange(num_cells_y))
-        xs, ys = new_affine * (cols, rows)
-        xs_flat, ys_flat = xs.flatten(), ys.flatten()
-
-        # Convert to image coordinates
-        row, col = src.index(xs_flat, ys_flat)
-        row, col = np.array(row), np.array(col)
-
-        # Filter valid indices
-        valid = (row >= 0) & (row < src.height) & (col >= 0) & (col < src.width)
-        row, col = row[valid], col[valid]
-
-        # Create output grid and fill with height values
-        grid = np.full((num_cells_y, num_cells_x), np.nan)
-        flat_indices = np.ravel_multi_index((row, col), img.shape)
-        np.put(grid, np.ravel_multi_index((rows.flatten()[valid], cols.flatten()[valid]), grid.shape), img.flat[flat_indices])
-
-    return np.flipud(grid)
-
 def create_height_grid_from_geotiff_polygon(tiff_path, mesh_size, polygon):
     """
     Create a height grid from a GeoTIFF file within a polygon boundary.
@@ -562,8 +428,9 @@ def create_height_grid_from_geotiff_polygon(tiff_path, mesh_size, polygon):
         poly = Polygon(polygon)
         
         # Get polygon bounds in WGS84
-        bottom_wgs84, left_wgs84, top_wgs84, right_wgs84 = poly.bounds
-        print(left, bottom, right, top)
+        left_wgs84, bottom_wgs84, right_wgs84, top_wgs84 = poly.bounds
+        # print(left, bottom, right, top)
+        # print(left_wgs84, bottom_wgs84, right_wgs84, top_wgs84)
 
         # Calculate actual distances using geodesic methods
         geod = Geod(ellps="WGS84")
@@ -624,8 +491,8 @@ def create_building_height_grid_from_geojson_polygon(geojson_data, meshsize, rec
     vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
 
     # Calculate distances between vertices
-    dist_side_1 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_1[1], vertex_1[0])
-    dist_side_2 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_3[1], vertex_3[0])
+    dist_side_1 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_1[0], vertex_1[1])
+    dist_side_2 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_3[0], vertex_3[1])
 
     # Calculate normalized vectors for grid orientation
     side_1 = np.array(vertex_1) - np.array(vertex_0)
@@ -882,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,193 @@
+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})
+        
+        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