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

voxcity/file/geojson.py

@@ -28,7 +28,7 @@ def filter_and_convert_gdf_to_geojson(gdf, rectangle_vertices):
     
     Args:
         gdf (GeoDataFrame): Input GeoDataFrame containing building data
-        rectangle_vertices (list): List of (lat, lon) tuples defining the bounding rectangle
+        rectangle_vertices (list): List of (lon, lat) tuples defining the bounding rectangle
         
     Returns:
         list: List of GeoJSON features within the bounding rectangle
@@ -43,9 +43,8 @@ def filter_and_convert_gdf_to_geojson(gdf, rectangle_vertices):
     # Add 'confidence' column with default value
     gdf['confidence'] = -1.0
 
-    # Convert rectangle vertices from (lat,lon) to (lon,lat) format for shapely
-    rectangle_vertices_lonlat = [(lon, lat) for lat, lon in rectangle_vertices]
-    rectangle_polygon = Polygon(rectangle_vertices_lonlat)
+    # Rectangle vertices already in (lon,lat) format for shapely
+    rectangle_polygon = Polygon(rectangle_vertices)
 
     # Use spatial index to efficiently filter geometries that intersect with rectangle
     gdf.sindex  # Ensure spatial index is built
@@ -57,13 +56,6 @@ def filter_and_convert_gdf_to_geojson(gdf, rectangle_vertices):
     # Delete intermediate data to save memory
     del gdf, possible_matches, precise_matches
 
-    # Helper function to swap coordinate ordering from (lon,lat) to (lat,lon)
-    def swap_coordinates(coords):
-        if isinstance(coords[0][0], (float, int)):
-            return [[lat, lon] for lon, lat in coords]
-        else:
-            return [swap_coordinates(ring) for ring in coords]
-
     # Create GeoJSON features from filtered geometries
     features = []
     for idx, row in filtered_gdf.iterrows():
@@ -78,7 +70,7 @@ def filter_and_convert_gdf_to_geojson(gdf, rectangle_vertices):
             for polygon_coords in geom['coordinates']:
                 single_geom = {
                     'type': 'Polygon',
-                    'coordinates': swap_coordinates(polygon_coords)
+                    'coordinates': polygon_coords
                 }
                 feature = {
                     'type': 'Feature',
@@ -87,7 +79,6 @@ def filter_and_convert_gdf_to_geojson(gdf, rectangle_vertices):
                 }
                 features.append(feature)
         elif geom['type'] == 'Polygon':
-            geom['coordinates'] = swap_coordinates(geom['coordinates'])
             feature = {
                 'type': 'Feature',
                 'properties': properties,
@@ -114,7 +105,7 @@ def get_geojson_from_gpkg(gpkg_path, rectangle_vertices):
     
     Args:
         gpkg_path (str): Path to the GeoPackage file
-        rectangle_vertices (list): List of (lat, lon) tuples defining the bounding rectangle
+        rectangle_vertices (list): List of (lon, lat) tuples defining the bounding rectangle
         
     Returns:
         list: List of GeoJSON features within the bounding rectangle
@@ -404,9 +395,9 @@ def extract_building_heights_from_geotiff(geotiff_path, geojson_data):
         for feature in geojson:
             if (feature['geometry']['type'] == 'Polygon') & (feature['properties']['height']<=0):
                 count_0 += 1
-                # Transform coordinates from (lat, lon) to raster CRS
+                # Transform coordinates from (lon, lat) to raster CRS
                 coords = feature['geometry']['coordinates'][0]
-                transformed_coords = [transformer.transform(lon, lat) for lat, lon in coords]
+                transformed_coords = [transformer.transform(lon, lat) for lon, lat in coords]
                 
                 # Create polygon in raster CRS
                 polygon = shape({"type": "Polygon", "coordinates": [transformed_coords]})
@@ -447,7 +438,7 @@ def get_geojson_from_gpkg(gpkg_path, rectangle_vertices):
     
     Args:
         gpkg_path (str): Path to the GeoPackage file
-        rectangle_vertices (list): List of (lat, lon) tuples defining the bounding rectangle
+        rectangle_vertices (list): List of (lon, lat) tuples defining the bounding rectangle
         
     Returns:
         list: List of GeoJSON features within the bounding rectangle
@@ -460,7 +451,7 @@ def get_geojson_from_gpkg(gpkg_path, rectangle_vertices):
 
 def swap_coordinates(features):
     """
-    Swap coordinate ordering in GeoJSON features from (lon, lat) to (lat, lon).
+    Swap coordinate ordering in GeoJSON features from (lat, lon) to (lon, lat).
     
     Args:
         features (list): List of GeoJSON features to process
@@ -469,11 +460,11 @@ def swap_coordinates(features):
     for feature in features:
         if feature['geometry']['type'] == 'Polygon':
             # Swap coordinates for simple polygons
-            new_coords = [[[lat, lon] for lon, lat in polygon] for polygon in feature['geometry']['coordinates']]
+            new_coords = [[[lon, lat] for lat, lon in polygon] for polygon in feature['geometry']['coordinates']]
             feature['geometry']['coordinates'] = new_coords
         elif feature['geometry']['type'] == 'MultiPolygon':
             # Swap coordinates for multi-polygons (polygons with holes)
-            new_coords = [[[[lat, lon] for lon, lat in polygon] for polygon in multipolygon] for multipolygon in feature['geometry']['coordinates']]
+            new_coords = [[[[lon, lat] for lat, lon in polygon] for polygon in multipolygon] for multipolygon in feature['geometry']['coordinates']]
             feature['geometry']['coordinates'] = new_coords
 
 def save_geojson(features, save_path):
@@ -506,23 +497,89 @@ def find_building_containing_point(features, target_point):
     
     Args:
         features (list): List of GeoJSON feature dictionaries
-        target_point (tuple): Tuple of (latitude, longitude)
+        target_point (tuple): Tuple of (lon, lat)
         
     Returns:
         list: List of building IDs containing the target point
     """
-    # Create Shapely point (note coordinate order swap)
-    point = Point(target_point[1], target_point[0])
+    # Create Shapely point
+    point = Point(target_point[0], target_point[1])
     
     id_list = []
     for feature in features:
         # Get polygon coordinates and convert to Shapely polygon
         coords = feature['geometry']['coordinates'][0]
-        polygon_coords = [(lon, lat) for lat, lon in coords]
-        polygon = Polygon(polygon_coords)
+        polygon = Polygon(coords)
         
         # Check if point is within polygon
         if polygon.contains(point):
             id_list.append(feature['properties']['id'])
     
-    return id_list
+    return id_list
+
+def get_buildings_in_drawn_polygon(building_geojson, drawn_polygon_vertices, 
+                                   operation='within'):
+    """
+    Given a list of building footprints and a set of drawn polygon 
+    vertices (in lon, lat), return the building IDs that fall within or 
+    intersect the drawn polygon.
+
+    Args:
+        building_geojson (list): 
+            A list of GeoJSON features, each feature is a dict with:
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Polygon",
+                    "coordinates": [
+                        [
+                            [lon1, lat1], [lon2, lat2], ...
+                        ]
+                    ]
+                },
+                "properties": {
+                    "id": ...
+                    ...
+                }
+            }
+
+        drawn_polygon_vertices (list): 
+            A list of (lon, lat) tuples representing the polygon drawn by the user.
+
+        operation (str):
+            Determines how to include buildings. 
+            Use "intersect" to include buildings that intersect the drawn polygon. 
+            Use "within" to include buildings that lie entirely within the drawn polygon.
+
+    Returns:
+        list:
+            A list of building IDs (strings or ints) that satisfy the condition.
+    """
+    # Create Shapely Polygon from drawn vertices
+    drawn_polygon_shapely = Polygon(drawn_polygon_vertices)
+
+    included_building_ids = []
+
+    # Check each building in the GeoJSON
+    for feature in building_geojson:
+        # Skip any feature that is not Polygon
+        if feature['geometry']['type'] != 'Polygon':
+            continue
+
+        # Extract coordinates
+        coords = feature['geometry']['coordinates'][0]
+
+        # Create a Shapely polygon for the building
+        building_polygon = Polygon(coords)
+
+        # Depending on the operation, check the relationship
+        if operation == 'intersect':
+            if building_polygon.intersects(drawn_polygon_shapely):
+                included_building_ids.append(feature['properties'].get('id', None))
+        elif operation == 'within':
+            if building_polygon.within(drawn_polygon_shapely):
+                included_building_ids.append(feature['properties'].get('id', None))
+        else:
+            raise ValueError("operation must be 'intersect' or 'within'")
+
+    return included_building_ids

voxcity/geo/draw.py

@@ -4,10 +4,11 @@ This module provides functions for drawing and manipulating rectangles on maps.
 
 import math
 from pyproj import Proj, transform
-from ipyleaflet import Map, DrawControl, Rectangle
+from ipyleaflet import Map, DrawControl, Rectangle, Polygon as LeafletPolygon
 import ipyleaflet
 from geopy import distance
 from .utils import get_coordinates_from_cityname
+import shapely.geometry as geom
 
 def rotate_rectangle(m, rectangle_vertices, angle):
     """
@@ -15,11 +16,11 @@ def rotate_rectangle(m, rectangle_vertices, angle):
 
     Args:
         m (ipyleaflet.Map): Map object to draw the rotated rectangle on
-        rectangle_vertices (list): List of (lat, lon) tuples defining the rectangle vertices
+        rectangle_vertices (list): List of (lon, lat) tuples defining the rectangle vertices
         angle (float): Rotation angle in degrees
 
     Returns:
-        list: List of rotated (lat, lon) tuples defining the new rectangle vertices
+        list: List of rotated (lon, lat) tuples defining the new rectangle vertices
     """
     if not rectangle_vertices:
         print("Draw a rectangle first!")
@@ -30,7 +31,7 @@ def rotate_rectangle(m, rectangle_vertices, angle):
     mercator = Proj(init='epsg:3857')  # Web Mercator (projection used by most web maps)
 
     # Project vertices from WGS84 to Web Mercator for proper distance calculations
-    projected_vertices = [transform(wgs84, mercator, lon, lat) for lat, lon in rectangle_vertices]
+    projected_vertices = [transform(wgs84, mercator, lon, lat) for lon, lat in rectangle_vertices]
 
     # Calculate the centroid to use as rotation center
     centroid_x = sum(x for x, y in projected_vertices) / len(projected_vertices)
@@ -56,15 +57,12 @@ def rotate_rectangle(m, rectangle_vertices, angle):
 
         rotated_vertices.append((new_x, new_y))
 
-    # Convert coordinates back to WGS84 (lat/lon)
+    # Convert coordinates back to WGS84 (lon/lat)
     new_vertices = [transform(mercator, wgs84, x, y) for x, y in rotated_vertices]
 
-    # Reorder coordinates from (lon,lat) to (lat,lon) format
-    new_vertices = [(lat, lon) for lon, lat in new_vertices]
-
     # Create and add new polygon layer to map
     polygon = ipyleaflet.Polygon(
-        locations=new_vertices,
+        locations=[(lat, lon) for lon, lat in new_vertices],  # Convert to (lat,lon) for ipyleaflet
         color="red",
         fill_color="red"
     )
@@ -103,8 +101,8 @@ def draw_rectangle_map(center=(40, -100), zoom=4):
             print("Vertices of the drawn rectangle:")
             # Store all vertices except last (GeoJSON repeats first vertex at end)
             for coord in coordinates[:-1]:
-                # Convert from GeoJSON (lon,lat) to standard (lat,lon) format
-                rectangle_vertices.append((coord[1], coord[0]))
+                # Keep GeoJSON (lon,lat) format
+                rectangle_vertices.append((coord[0], coord[1]))
                 print(f"Longitude: {coord[0]}, Latitude: {coord[1]}")
 
     # Configure drawing controls - only enable rectangle drawing
@@ -178,9 +176,9 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
 
         # Process only if a point was drawn on the map
         if action == 'created' and geo_json['geometry']['type'] == 'Point':
-            # Extract point coordinates (converting from GeoJSON lon,lat to lat,lon)
-            lat, lon = geo_json['geometry']['coordinates'][1], geo_json['geometry']['coordinates'][0]
-            print(f"Point drawn at Latitude: {lat}, Longitude: {lon}")
+            # Extract point coordinates from GeoJSON (lon,lat)
+            lon, lat = geo_json['geometry']['coordinates'][0], geo_json['geometry']['coordinates'][1]
+            print(f"Point drawn at Longitude: {lon}, Latitude: {lat}")
             
             # Calculate corner points using geopy's distance calculator
             # Each point is calculated as a destination from center point using bearing
@@ -189,15 +187,15 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
             east = distance.distance(meters=east_west_length/2).destination((lat, lon), bearing=90)
             west = distance.distance(meters=east_west_length/2).destination((lat, lon), bearing=270)
 
-            # Create rectangle vertices in counter-clockwise order
+            # Create rectangle vertices in counter-clockwise order (lon,lat)
             rectangle_vertices.extend([
-                (south.latitude, west.longitude),
-                (north.latitude, west.longitude),
-                (north.latitude, east.longitude),
-                (south.latitude, east.longitude)                
+                (west.longitude, south.latitude),
+                (west.longitude, north.latitude),
+                (east.longitude, north.latitude),
+                (east.longitude, south.latitude)                
             ])
 
-            # Create and add new rectangle to map
+            # Create and add new rectangle to map (ipyleaflet expects lat,lon)
             rectangle = Rectangle(
                 bounds=[(north.latitude, west.longitude), (south.latitude, east.longitude)],
                 color="red",
@@ -208,7 +206,7 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
 
             print("Rectangle vertices:")
             for vertex in rectangle_vertices:
-                print(f"Latitude: {vertex[0]}, Longitude: {vertex[1]}")
+                print(f"Longitude: {vertex[0]}, Latitude: {vertex[1]}")
 
     # Configure drawing controls - only enable point drawing
     draw_control = DrawControl()
@@ -222,4 +220,112 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
     # Register event handler for drawing actions
     draw_control.on_draw(handle_draw)
 
-    return m, rectangle_vertices
+    return m, rectangle_vertices
+
+def display_buildings_and_draw_polygon(building_geojson, zoom=17):
+    """
+    Displays building footprints (in Lon-Lat order) on an ipyleaflet map,
+    and allows the user to draw a polygon whose vertices are returned
+    in a Python list (also in Lon-Lat).
+
+    Args:
+        building_geojson (list): A list of GeoJSON features (Polygons),
+                                 with coordinates in [lon, lat] order.
+        zoom (int): Initial zoom level for the map. Default=17.
+
+    Returns:
+        (map_object, drawn_polygon_vertices)
+          - map_object: ipyleaflet Map instance
+          - drawn_polygon_vertices: a Python list that gets updated whenever
+            a new polygon is created. The list is in (lon, lat) order.
+    """
+    # ---------------------------------------------------------
+    # 1. Determine a suitable map center via bounding box logic
+    # ---------------------------------------------------------
+    all_lons = []
+    all_lats = []
+    for feature in building_geojson:
+        # Handle only Polygons here; skip MultiPolygon if present
+        if feature['geometry']['type'] == 'Polygon':
+            # Coordinates in this data are [ [lon, lat], [lon, lat], ... ]
+            coords = feature['geometry']['coordinates'][0]  # outer ring
+            all_lons.extend(pt[0] for pt in coords)
+            all_lats.extend(pt[1] for pt in coords)
+
+    if not all_lats or not all_lons:
+        # Fallback: If no footprints or invalid data, pick a default
+        center_lon, center_lat = -100.0, 40.0
+    else:
+        min_lon, max_lon = min(all_lons), max(all_lons)
+        min_lat, max_lat = min(all_lats), max(all_lats)
+        center_lon = (min_lon + max_lon) / 2
+        center_lat = (min_lat + max_lat) / 2
+
+    # Create the ipyleaflet map (needs lat,lon)
+    m = Map(center=(center_lat, center_lon), zoom=zoom, scroll_wheel_zoom=True)
+
+    # -----------------------------------------
+    # 2. Add each building footprint to the map
+    # -----------------------------------------
+    for feature in building_geojson:
+        # Only handle simple Polygons
+        if feature['geometry']['type'] == 'Polygon':
+            coords = feature['geometry']['coordinates'][0]
+            # Convert to (lat,lon) for ipyleaflet
+            lat_lon_coords = [(c[1], c[0]) for c in coords]
+
+            # Create the polygon layer
+            bldg_layer = LeafletPolygon(
+                locations=lat_lon_coords,
+                color="blue",
+                fill_color="blue",
+                fill_opacity=0.2,
+                weight=2
+            )
+            m.add_layer(bldg_layer)
+
+    # -----------------------------------------------------------------
+    # 3. Enable drawing of polygons, capturing the vertices in Lon-Lat
+    # -----------------------------------------------------------------
+    drawn_polygon_vertices = []  # We'll store the newly drawn polygon's vertices here (lon, lat).
+
+    draw_control = DrawControl(
+        polygon={
+            "shapeOptions": {
+                "color": "red",
+                "fillColor": "red",
+                "fillOpacity": 0.2
+            }
+        },
+        rectangle={},     # Disable rectangles (or enable if needed)
+        circle={},        # Disable circles
+        circlemarker={},  # Disable circlemarkers
+        polyline={},      # Disable polylines
+        marker={}         # Disable markers
+    )
+
+    def handle_draw(self, action, geo_json):
+        """
+        Callback for whenever a shape is created or edited.
+        ipyleaflet's DrawControl returns standard GeoJSON (lon, lat).
+        We'll keep them as (lon, lat).
+        """
+        # Clear any previously stored vertices
+        drawn_polygon_vertices.clear()
+
+        if action == 'created' and geo_json['geometry']['type'] == 'Polygon':
+            # The polygon's first ring
+            coordinates = geo_json['geometry']['coordinates'][0]
+            print("Vertices of the drawn polygon (Lon-Lat):")
+
+            # Keep GeoJSON (lon,lat) format, skip last repeated coordinate
+            for coord in coordinates[:-1]:
+                lon = coord[0]
+                lat = coord[1]
+                drawn_polygon_vertices.append((lon, lat))
+                print(f" - (lon, lat) = ({lon}, {lat})")
+
+    draw_control.on_draw(handle_draw)
+    m.add_control(draw_control)
+
+    return m, drawn_polygon_vertices

voxcity/geo/grid.py

@@ -235,77 +235,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 +258,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 +310,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 +340,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 +405,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 +427,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 +490,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)