voxcity 0.3.3__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,20 +497,19 @@ 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):
@@ -530,8 +520,8 @@ def find_building_containing_point(features, target_point):
 def get_buildings_in_drawn_polygon(building_geojson, drawn_polygon_vertices, 
                                    operation='within'):
     """
-    Given a list of building footprints (in Lat-Lon) and a set of drawn polygon 
-    vertices (also in Lat-Lon), return the building IDs that fall within or 
+    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:
@@ -543,7 +533,7 @@ def get_buildings_in_drawn_polygon(building_geojson, drawn_polygon_vertices,
                     "type": "Polygon",
                     "coordinates": [
                         [
-                            [lat1, lon1], [lat2, lon2], ...
+                            [lon1, lat1], [lon2, lat2], ...
                         ]
                     ]
                 },
@@ -552,10 +542,9 @@ def get_buildings_in_drawn_polygon(building_geojson, drawn_polygon_vertices,
                     ...
                 }
             }
-            Note: These coordinates are in (lat, lon) order, not standard (lon, lat).
 
         drawn_polygon_vertices (list): 
-            A list of (lat, lon) tuples representing the polygon drawn by the user.
+            A list of (lon, lat) tuples representing the polygon drawn by the user.
 
         operation (str):
             Determines how to include buildings. 
@@ -566,27 +555,24 @@ def get_buildings_in_drawn_polygon(building_geojson, drawn_polygon_vertices,
         list:
             A list of building IDs (strings or ints) that satisfy the condition.
     """
-    # 1. Convert the user-drawn polygon vertices (lat, lon) into a Shapely Polygon.
-    #    Shapely expects (x, y) = (longitude, latitude).
-    #    So we'll do (lon, lat) for each vertex.
-    drawn_polygon_shapely = Polygon([(lon, lat) for (lat, lon) in drawn_polygon_vertices])
+    # Create Shapely Polygon from drawn vertices
+    drawn_polygon_shapely = Polygon(drawn_polygon_vertices)
 
     included_building_ids = []
 
-    # 2. Check each building in the GeoJSON
+    # 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, which are in [ [lat, lon], [lat, lon], ... ]
+        # Extract coordinates
         coords = feature['geometry']['coordinates'][0]
 
         # Create a Shapely polygon for the building
-        # Convert from (lat, lon) to (lon, lat)
-        building_polygon = Polygon([(lon, lat) for (lat, lon) in coords])
+        building_polygon = Polygon(coords)
 
-        # 3. Depending on the operation, check the relationship
+        # 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))

voxcity/geo/draw.py

@@ -16,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!")
@@ -31,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)
@@ -57,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"
     )
@@ -104,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
@@ -179,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
@@ -190,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",
@@ -209,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()
@@ -227,44 +224,44 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
 
 def display_buildings_and_draw_polygon(building_geojson, zoom=17):
     """
-    Displays building footprints (in Lat-Lon order) on an ipyleaflet map,
+    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 Lat-Lon).
+    in a Python list (also in Lon-Lat).
 
     Args:
         building_geojson (list): A list of GeoJSON features (Polygons),
-                                 BUT with coordinates in [lat, lon] order.
+                                 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 (lat, lon) order.
+            a new polygon is created. The list is in (lon, lat) order.
     """
     # ---------------------------------------------------------
     # 1. Determine a suitable map center via bounding box logic
     # ---------------------------------------------------------
-    all_lats = []
     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 [ [lat, lon], [lat, lon], ... ]
+            # Coordinates in this data are [ [lon, lat], [lon, lat], ... ]
             coords = feature['geometry']['coordinates'][0]  # outer ring
-            all_lats.extend(pt[0] for pt in coords)
-            all_lons.extend(pt[1] for pt in coords)
+            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_lat, center_lon = 40.0, -100.0
+        center_lon, center_lat = -100.0, 40.0
     else:
-        min_lat, max_lat = min(all_lats), max(all_lats)
         min_lon, max_lon = min(all_lons), max(all_lons)
-        center_lat = (min_lat + max_lat) / 2
+        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
+    # Create the ipyleaflet map (needs lat,lon)
     m = Map(center=(center_lat, center_lon), zoom=zoom, scroll_wheel_zoom=True)
 
     # -----------------------------------------
@@ -274,8 +271,8 @@ def display_buildings_and_draw_polygon(building_geojson, zoom=17):
         # Only handle simple Polygons
         if feature['geometry']['type'] == 'Polygon':
             coords = feature['geometry']['coordinates'][0]
-            # Because your data is already lat-lon, we do NOT swap:
-            lat_lon_coords = [(c[0], c[1]) for c in coords]
+            # Convert to (lat,lon) for ipyleaflet
+            lat_lon_coords = [(c[1], c[0]) for c in coords]
 
             # Create the polygon layer
             bldg_layer = LeafletPolygon(
@@ -288,15 +285,15 @@ def display_buildings_and_draw_polygon(building_geojson, zoom=17):
             m.add_layer(bldg_layer)
 
     # -----------------------------------------------------------------
-    # 3. Enable drawing of polygons, capturing the vertices in Lat-Lon
+    # 3. Enable drawing of polygons, capturing the vertices in Lon-Lat
     # -----------------------------------------------------------------
-    drawn_polygon_vertices = []  # We'll store the newly drawn polygon's vertices here (lat, lon).
+    drawn_polygon_vertices = []  # We'll store the newly drawn polygon's vertices here (lon, lat).
 
     draw_control = DrawControl(
         polygon={
             "shapeOptions": {
-                "color": "#6bc2e5",
-                "fillColor": "#6bc2e5",
+                "color": "red",
+                "fillColor": "red",
                 "fillOpacity": 0.2
             }
         },
@@ -311,23 +308,22 @@ def display_buildings_and_draw_polygon(building_geojson, zoom=17):
         """
         Callback for whenever a shape is created or edited.
         ipyleaflet's DrawControl returns standard GeoJSON (lon, lat).
-        We'll convert them to (lat, lon).
+        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
+            # The polygon's first ring
             coordinates = geo_json['geometry']['coordinates'][0]
-            print("Vertices of the drawn polygon (Lat-Lon):")
+            print("Vertices of the drawn polygon (Lon-Lat):")
 
-            # By default, drawn polygon coords are [ [lon, lat], [lon, lat], ... ]
-            # The last coordinate repeats the first -> skip it with [:-1]
+            # Keep GeoJSON (lon,lat) format, skip last repeated coordinate
             for coord in coordinates[:-1]:
                 lon = coord[0]
                 lat = coord[1]
-                drawn_polygon_vertices.append((lat, lon))
-                print(f" - (lat, lon) = ({lat}, {lon})")
+                drawn_polygon_vertices.append((lon, lat))
+                print(f" - (lon, lat) = ({lon}, {lat})")
 
     draw_control.on_draw(handle_draw)
     m.add_control(draw_control)

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)