ras-commander 0.48.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

ras_commander/HdfFluvialPluvial.py

@@ -1,13 +1,29 @@
+"""
+Class: HdfFluvialPluvial
+
+All of the methods in this class are static and are designed to be used without instantiation.
+
+List of Functions in HdfFluvialPluvial:
+- calculate_fluvial_pluvial_boundary()
+- _process_cell_adjacencies()
+- _identify_boundary_edges()
+
+"""
+
 from typing import Dict, List, Tuple
 import pandas as pd
 import geopandas as gpd
-import matplotlib.pyplot as plt
 from collections import defaultdict
-from shapely.geometry import LineString, MultiLineString
+from shapely.geometry import LineString, MultiLineString  # Added MultiLineString import
 from tqdm import tqdm
-
 from .HdfMesh import HdfMesh
 from .HdfUtils import HdfUtils
+from .Decorators import standardize_input
+from .HdfResultsMesh import HdfResultsMesh
+from .LoggingConfig import get_logger
+from pathlib import Path
+
+logger = get_logger(__name__)
 
 class HdfFluvialPluvial:
     """
@@ -15,312 +31,279 @@ class HdfFluvialPluvial:
 
     This class provides methods to process and visualize HEC-RAS 2D model outputs,
     specifically focusing on the delineation of fluvial and pluvial flood areas.
-    It includes functionality for plotting maximum water surface elevations,
-    extracting cell polygons, and calculating fluvial-pluvial boundaries based on
+    It includes functionality for calculating fluvial-pluvial boundaries based on
     the timing of maximum water surface elevations.
 
-    Key Features:
-    - Plotting maximum water surface elevations and their timing
-    - Extracting and visualizing 2D flow area cell polygons
-    - Calculating and visualizing fluvial-pluvial boundaries
+    Key Concepts:
+    - Fluvial flooding: Flooding from rivers/streams
+    - Pluvial flooding: Flooding from rainfall/surface water
+    - Delta_t: Time threshold (in hours) used to distinguish between fluvial and pluvial cells.
+               Cells with max WSE time differences greater than delta_t are considered boundaries.
 
     Data Requirements:
-    1. For plotting maximum water surface:
-       - Use HdfResultsMesh.mesh_max_ws(hdf_path) to get max_ws_df
-       - Use HdfResultsMesh.mesh_timeseries_output(hdf_path, mesh_name, 'water_surface') 
-         to get time series data
-
-    2. For extracting cell polygons:
-       - Use HdfMesh.mesh_cell_polygons(geom_hdf_path) to get cell_polygons_df
-       - Use HdfUtils.projection(hdf_path) to get the projection
-
-    3. For calculating fluvial-pluvial boundary:
-       - Requires cell_polygons_gdf (from step 2)
-       - Requires max_ws_df with 'cell_id' and 'max_wsel_time' columns
-         (can be derived from HdfResultsMesh.mesh_max_ws(hdf_path))
-
-    Usage:
-    To use this class effectively, first initialize a RasPrj object and load the
-    necessary HDF files. Then, use the methods provided to analyze and visualize
-    the fluvial-pluvial characteristics of your 2D model results.
-
-    Example:
-        ras = RasPrj()
-        ras = init_ras_project(project_path, ras_version)
-        hdf_path = ras.get_plan_value(plan_number, 'Results_Output')
-        
-        # Get maximum water surface data
-        max_ws_df = HdfResultsMesh.mesh_max_ws(hdf_path)
-        
-        # Plot maximum water surface
-        HdfFluvialPluvial.plot_max_water_surface(max_ws_df)
-        
-        # Extract cell polygons
-        cell_polygons_df = HdfMesh.mesh_cell_polygons(hdf_path)
-        projection = HdfUtils.projection(hdf_path)
-        cell_polygons_gdf = HdfFluvialPluvial.plot_cell_polygons(cell_polygons_df, projection)
-        
-        # Calculate fluvial-pluvial boundary
-        boundary_gdf = HdfFluvialPluvial.calculate_fluvial_pluvial_boundary(cell_polygons_gdf, max_ws_df)
-
-    Note: Ensure that you have the necessary permissions and have initialized
-    the RAS project correctly before attempting to access HDF files.
+    - HEC-RAS plan HDF file containing:
+        - 2D mesh cell geometry (accessed via HdfMesh)
+        - Maximum water surface elevation times (accessed via HdfResultsMesh)
+
+    Usage Example:
+        >>> ras = init_ras_project(project_path, ras_version)
+        >>> hdf_path = Path("path/to/plan.hdf")
+        >>> boundary_gdf = HdfFluvialPluvial.calculate_fluvial_pluvial_boundary(
+        ...     hdf_path, 
+        ...     delta_t=12
+        ... )
     """
-
-    @staticmethod
-    def plot_max_water_surface(max_ws_df):
-        """
-        Plots the maximum water surface elevation per cell.
-
-        Parameters:
-        - max_ws_df: DataFrame containing merged data with coordinates and max water surface.
-
-        Returns:
-        - None
-        """
-        # Extract x and y coordinates from the geometry column
-        max_ws_df['x'] = max_ws_df['geometry'].apply(lambda geom: geom.x if geom is not None else None)
-        max_ws_df['y'] = max_ws_df['geometry'].apply(lambda geom: geom.y if geom is not None else None)
-
-        # Check if 'x' and 'y' columns exist in max_ws_df
-        if 'x' not in max_ws_df.columns or 'y' not in max_ws_df.columns:
-            print("Error: 'x' or 'y' columns not found in the merged dataframe.")
-            print("Available columns:", max_ws_df.columns.tolist())
-            return
-
-        # Create the plot
-        fig, ax = plt.subplots(figsize=(12, 8))
-        scatter = ax.scatter(max_ws_df['x'], max_ws_df['y'], c=max_ws_df['maximum_water_surface'], cmap='viridis', s=10)
-
-        # Customize the plot
-        ax.set_title('Max Water Surface per Cell')
-        ax.set_xlabel('X Coordinate')
-        ax.set_ylabel('Y Coordinate')
-        plt.colorbar(scatter, label='Max Water Surface (ft)')
-
-        # Add grid lines
-        ax.grid(True, linestyle='--', alpha=0.7)
-
-        # Increase font size for better readability
-        plt.rcParams.update({'font.size': 12})
-
-        # Adjust layout to prevent cutting off labels
-        plt.tight_layout()
-
-        # Show the plot
-        plt.show()
-    
+    def __init__(self):
+        self.logger = get_logger(__name__)  # Initialize logger with module name
     
-    
-
     @staticmethod
-    def plot_max_wsel_time(max_ws_df: pd.DataFrame) -> None:
+    @standardize_input(file_type='plan_hdf')
+    def calculate_fluvial_pluvial_boundary(hdf_path: Path, delta_t: float = 12) -> gpd.GeoDataFrame:
         """
-        Plots the time of the maximum water surface elevation (WSEL) per cell.
+        Calculate the fluvial-pluvial boundary based on cell polygons and maximum water surface elevation times.
 
-        Parameters:
-        - max_ws_df: DataFrame containing merged data with coordinates and max water surface.
+        Args:
+            hdf_path (Path): Path to the HEC-RAS plan HDF file
+            delta_t (float): Threshold time difference in hours. Cells with time differences
+                        greater than this value are considered boundaries. Default is 12 hours.
 
         Returns:
-        - None
+            gpd.GeoDataFrame: GeoDataFrame containing the fluvial-pluvial boundaries with:
+                - geometry: LineString features representing boundaries
+                - CRS: Coordinate reference system matching the input HDF file
+
+        Raises:
+            ValueError: If no cell polygons or maximum water surface data found in HDF file
+            Exception: If there are errors during boundary calculation
+
+        Note:
+            The returned boundaries represent locations where the timing of maximum water surface
+            elevation changes significantly (> delta_t), indicating potential transitions between
+            fluvial and pluvial flooding mechanisms.
         """
-        max_ws_df['max_wsel_time'] = pd.to_datetime(max_ws_df['maximum_water_surface_time'])
-        HdfFluvialPluvial._extract_coordinates(max_ws_df)
-
-        if 'x' not in max_ws_df.columns or 'y' not in max_ws_df.columns:
-            raise ValueError("x and y coordinates are missing from the DataFrame. Make sure the 'face_point' column exists and contains valid coordinate data.")
-
-        fig, ax = plt.subplots(figsize=(12, 8))
-
-        min_time = max_ws_df['max_wsel_time'].min()
-        color_values = (max_ws_df['max_wsel_time'] - min_time).dt.total_seconds() / 3600
-
-        scatter = ax.scatter(max_ws_df['x'], max_ws_df['y'], c=color_values, cmap='viridis', s=10)
-
-        ax.set_title('Time of Maximum Water Surface Elevation per Cell')
-        ax.set_xlabel('X Coordinate')
-        ax.set_ylabel('Y Coordinate')
-
-        cbar = plt.colorbar(scatter)
-        cbar.set_label('Hours since simulation start')
-        cbar.set_ticks(range(0, int(color_values.max()) + 1, 6))
-        cbar.set_ticklabels([f'{h}h' for h in range(0, int(color_values.max()) + 1, 6)])
-
-        ax.grid(True, linestyle='--', alpha=0.7)
-        plt.rcParams.update({'font.size': 12})
-        plt.tight_layout()
-        plt.show()
-
-        HdfFluvialPluvial._print_max_wsel_info(max_ws_df, min_time)
-
+        try:
+            # Get cell polygons from HdfMesh
+            logger.info("Getting cell polygons from HDF file...")
+            cell_polygons_gdf = HdfMesh.get_mesh_cell_polygons(hdf_path)
+            if cell_polygons_gdf.empty:
+                raise ValueError("No cell polygons found in HDF file")
+
+            # Get max water surface data from HdfResultsMesh
+            logger.info("Getting maximum water surface data from HDF file...")
+            max_ws_df = HdfResultsMesh.get_mesh_max_ws(hdf_path)
+            if max_ws_df.empty:
+                raise ValueError("No maximum water surface data found in HDF file")
+
+            # Convert timestamps using the renamed utility function
+            logger.info("Converting maximum water surface timestamps...")
+            if 'maximum_water_surface_time' in max_ws_df.columns:
+                max_ws_df['maximum_water_surface_time'] = max_ws_df['maximum_water_surface_time'].apply(
+                    lambda x: HdfUtils.parse_ras_datetime(x) if isinstance(x, str) else x
+                )
+
+            # Process cell adjacencies
+            logger.info("Processing cell adjacencies...")
+            cell_adjacency, common_edges = HdfFluvialPluvial._process_cell_adjacencies(cell_polygons_gdf)
+            
+            # Get cell times from max_ws_df
+            logger.info("Extracting cell times from maximum water surface data...")
+            cell_times = max_ws_df.set_index('cell_id')['maximum_water_surface_time'].to_dict()
+            
+            # Identify boundary edges
+            logger.info("Identifying boundary edges...")
+            boundary_edges = HdfFluvialPluvial._identify_boundary_edges(
+                cell_adjacency, common_edges, cell_times, delta_t
+            )
+
+            # Join adjacent LineStrings into simple LineStrings
+            logger.info("Joining adjacent LineStrings into simple LineStrings...")
+            joined_lines = []
+            
+            def get_coords(geom):
+                """Helper function to get coordinates from either LineString or MultiLineString"""
+                if isinstance(geom, LineString):
+                    return list(geom.coords)
+                elif isinstance(geom, MultiLineString):
+                    return list(geom.geoms[0].coords)
+                return None
+
+            # Create a dictionary to store start and end points for each line
+            line_endpoints = {}
+            for i, edge in enumerate(boundary_edges):
+                coords = get_coords(edge)
+                if coords:
+                    line_endpoints[i] = (coords[0], coords[-1])
+
+            # Process lines in order
+            used_indices = set()
+            while len(used_indices) < len(boundary_edges):
+                current_line = []
+                current_points = []
+                
+                # Find a new starting line if needed
+                for i in range(len(boundary_edges)):
+                    if i not in used_indices:
+                        current_line.append(boundary_edges[i])
+                        coords = get_coords(boundary_edges[i])
+                        if coords:
+                            current_points.extend(coords)
+                        used_indices.add(i)
+                        break
+                
+                # Continue adding connected lines
+                while True:
+                    found_next = False
+                    current_end = current_points[-1] if current_points else None
+                    
+                    # Look for the next connected line
+                    for i, (start, end) in line_endpoints.items():
+                        if i not in used_indices and current_end:
+                            if start == current_end:
+                                # Add line in forward direction
+                                coords = get_coords(boundary_edges[i])
+                                if coords:
+                                    current_points.extend(coords[1:])  # Skip first point to avoid duplication
+                                current_line.append(boundary_edges[i])
+                                used_indices.add(i)
+                                found_next = True
+                                break
+                            elif end == current_end:
+                                # Add line in reverse direction
+                                coords = get_coords(boundary_edges[i])
+                                if coords:
+                                    current_points.extend(reversed(coords[:-1]))  # Skip last point to avoid duplication
+                                current_line.append(boundary_edges[i])
+                                used_indices.add(i)
+                                found_next = True
+                                break
+                    
+                    if not found_next:
+                        break
+                
+                # Create a single LineString from the collected points
+                if current_points:
+                    joined_lines.append(LineString(current_points))
+
+            # Create final GeoDataFrame with CRS from cell_polygons_gdf
+            logger.info("Creating final GeoDataFrame for boundaries...")
+            boundary_gdf = gpd.GeoDataFrame(
+                geometry=joined_lines, 
+                crs=cell_polygons_gdf.crs
+            )
+
+            # Clean up intermediate dataframes
+            logger.info("Cleaning up intermediate dataframes...")
+            del cell_polygons_gdf
+            del max_ws_df
+
+            logger.info("Fluvial-pluvial boundary calculation completed successfully.")
+            return boundary_gdf
+
+        except Exception as e:
+            self.logger.error(f"Error calculating fluvial-pluvial boundary: {str(e)}")
+            return None
+        
+        
     @staticmethod
-    def plot_cell_polygons(cell_polygons_df: pd.DataFrame, projection: str) -> gpd.GeoDataFrame:
+    def _process_cell_adjacencies(cell_polygons_gdf: gpd.GeoDataFrame) -> Tuple[Dict[int, List[int]], Dict[int, Dict[int, LineString]]]:
         """
-        Plots the cell polygons from the provided DataFrame and returns the GeoDataFrame.
-
+        Optimized method to process cell adjacencies by extracting shared edges directly.
+        
         Args:
-            cell_polygons_df (pd.DataFrame): DataFrame containing cell polygons.
-            projection (str): The coordinate reference system to assign to the GeoDataFrame.
+            cell_polygons_gdf (gpd.GeoDataFrame): GeoDataFrame containing 2D mesh cell polygons
+                                                   with 'cell_id' and 'geometry' columns.
 
         Returns:
-            gpd.GeoDataFrame: GeoDataFrame containing the cell polygons.
+            Tuple containing:
+                - Dict[int, List[int]]: Dictionary mapping cell IDs to lists of adjacent cell IDs.
+                - Dict[int, Dict[int, LineString]]: Nested dictionary storing common edges between cells,
+                                                    where common_edges[cell1][cell2] gives the shared boundary.
         """
-        if cell_polygons_df.empty:
-            print("No Cell Polygons found.")
-            return None
-
-        cell_polygons_gdf = HdfFluvialPluvial._convert_to_geodataframe(cell_polygons_df, projection)
-
-        print("Cell Polygons CRS:", cell_polygons_gdf.crs)
-        display(cell_polygons_gdf.head())
-
-        fig, ax = plt.subplots(figsize=(12, 8))
-        cell_polygons_gdf.plot(ax=ax, edgecolor='blue', facecolor='none')
-        ax.set_xlabel('X Coordinate')
-        ax.set_ylabel('Y Coordinate')
-        ax.set_title('2D Flow Area Cell Polygons')
-        ax.grid(True)
-        plt.tight_layout()
-        plt.show()
+        cell_adjacency = defaultdict(list)
+        common_edges = defaultdict(dict)
 
-        return cell_polygons_gdf
+        # Build an edge to cells mapping
+        edge_to_cells = defaultdict(set)
+
+        # Function to generate edge keys
+        def edge_key(coords1, coords2, precision=8):
+            # Round coordinates
+            coords1 = tuple(round(coord, precision) for coord in coords1)
+            coords2 = tuple(round(coord, precision) for coord in coords2)
+            # Create sorted key to handle edge direction
+            return tuple(sorted([coords1, coords2]))
+
+        # For each polygon, extract edges
+        for idx, row in cell_polygons_gdf.iterrows():
+            cell_id = row['cell_id']
+            geom = row['geometry']
+            if geom.is_empty or not geom.is_valid:
+                continue
+            # Get exterior coordinates
+            coords = list(geom.exterior.coords)
+            num_coords = len(coords)
+            for i in range(num_coords - 1):
+                coord1 = coords[i]
+                coord2 = coords[i + 1]
+                key = edge_key(coord1, coord2)
+                edge_to_cells[key].add(cell_id)
+
+        # Now, process edge_to_cells to build adjacency
+        for edge, cells in edge_to_cells.items():
+            cells = list(cells)
+            if len(cells) >= 2:
+                # For all pairs of cells sharing this edge
+                for i in range(len(cells)):
+                    for j in range(i + 1, len(cells)):
+                        cell1 = cells[i]
+                        cell2 = cells[j]
+                        # Update adjacency
+                        if cell2 not in cell_adjacency[cell1]:
+                            cell_adjacency[cell1].append(cell2)
+                        if cell1 not in cell_adjacency[cell2]:
+                            cell_adjacency[cell2].append(cell1)
+                        # Store common edge
+                        common_edge = LineString([edge[0], edge[1]])
+                        common_edges[cell1][cell2] = common_edge
+                        common_edges[cell2][cell1] = common_edge
+
+        logger.info("Cell adjacencies processed successfully.")
+        return cell_adjacency, common_edges
 
     @staticmethod
-    def calculate_fluvial_pluvial_boundary(cell_polygons_gdf: gpd.GeoDataFrame, max_ws_df: pd.DataFrame, delta_t: float = 12) -> gpd.GeoDataFrame:
+    def _identify_boundary_edges(cell_adjacency: Dict[int, List[int]], 
+                               common_edges: Dict[int, Dict[int, LineString]], 
+                               cell_times: Dict[int, pd.Timestamp], 
+                               delta_t: float) -> List[LineString]:
         """
-        Calculate the fluvial-pluvial boundary based on cell polygons and maximum water surface elevation times.
+        Identify boundary edges between cells with significant time differences.
 
         Args:
-            cell_polygons_gdf (gpd.GeoDataFrame): GeoDataFrame containing cell polygons with 'cell_id' and 'geometry' columns.
-            max_ws_df (pd.DataFrame): DataFrame containing 'cell_id' and 'max_wsel_time' columns.
-            delta_t (float): Threshold time difference in hours. Default is 12 hours.
+            cell_adjacency (Dict[int, List[int]]): Dictionary of cell adjacencies
+            common_edges (Dict[int, Dict[int, LineString]]): Dictionary of shared edges between cells
+            cell_times (Dict[int, pd.Timestamp]): Dictionary mapping cell IDs to their max WSE times
+            delta_t (float): Time threshold in hours
 
         Returns:
-            gpd.GeoDataFrame: GeoDataFrame containing the fluvial-pluvial boundary as simple LineStrings.
-        """
-        cell_adjacency, common_edges = HdfFluvialPluvial._process_cell_adjacencies(cell_polygons_gdf)
-        cell_times = max_ws_df.set_index('cell_id')['max_wsel_time'].to_dict()
-        boundary_edges = HdfFluvialPluvial._identify_boundary_edges(cell_adjacency, common_edges, cell_times, delta_t)
-
-        # Join adjacent LineStrings into simple LineStrings
-        joined_lines = []
-        current_line = []
-
-        for edge in boundary_edges:
-            if not current_line:
-                current_line.append(edge)
-            else:
-                if current_line[-1].coords[-1] == edge.coords[0]:  # Check if the last point of the current line matches the first point of the new edge
-                    current_line.append(edge)
-                else:
-                    # Create a simple LineString from the current line and reset
-                    joined_lines.append(LineString([point for line in current_line for point in line.coords]))
-                    current_line = [edge]
-
-        # Add the last collected line if exists
-        if current_line:
-            joined_lines.append(LineString([point for line in current_line for point in line.coords]))
-
-        boundary_gdf = gpd.GeoDataFrame(geometry=joined_lines, crs=cell_polygons_gdf.crs)
-        return boundary_gdf
-
-    @staticmethod
-    def _print_max_wsel_info(max_ws_df: pd.DataFrame, min_time: pd.Timestamp) -> None:
-        max_wsel_row = max_ws_df.loc[max_ws_df['maximum_water_surface'].idxmax()]
-        hours_since_start = (max_wsel_row['max_wsel_time'] - min_time).total_seconds() / 3600
-        print(f"\nOverall Maximum WSEL: {max_wsel_row['maximum_water_surface']:.2f} ft")
-        print(f"Time of Overall Maximum WSEL: {max_wsel_row['max_wsel_time']}")
-        print(f"Hours since simulation start: {hours_since_start:.2f} hours")
-        print(f"Location of Overall Maximum WSEL: X={max_wsel_row['x']}, Y={max_wsel_row['y']}")
+            List[LineString]: List of LineString geometries representing boundaries where
+                             adjacent cells have time differences greater than delta_t
 
-    @staticmethod
-    def _process_cell_adjacencies(cell_polygons_gdf: gpd.GeoDataFrame) -> Tuple[Dict[int, List[int]], Dict[int, Dict[int, LineString]]]:
-        """
-        Process cell adjacencies and common edges using R-tree indexing.
+        Note:
+            Boundaries are identified where the absolute time difference between adjacent
+            cells exceeds the specified delta_t threshold.
         """
-        # Install rtree using pip install rtree if not already installed
-        from rtree import index
-        cell_adjacency = defaultdict(list)
-        common_edges = defaultdict(dict)
-        idx = index.Index()
-        for i, geom in enumerate(cell_polygons_gdf.geometry):
-            idx.insert(i, geom.bounds)
-
-        with tqdm(total=len(cell_polygons_gdf), desc="Processing cell adjacencies") as pbar:
-            for idx1, row1 in cell_polygons_gdf.iterrows():
-                cell_id1 = row1['cell_id']
-                poly1 = row1['geometry']
-                potential_neighbors = list(idx.intersection(poly1.bounds))
-                
-                for idx2 in potential_neighbors:
-                    if idx1 >= idx2:
-                        continue
-                    
-                    row2 = cell_polygons_gdf.iloc[idx2]
-                    cell_id2 = row2['cell_id']
-                    poly2 = row2['geometry']
-                    
-                    if poly1.touches(poly2):
-                        intersection = poly1.intersection(poly2)
-                        if isinstance(intersection, LineString):
-                            cell_adjacency[cell_id1].append(cell_id2)
-                            cell_adjacency[cell_id2].append(cell_id1)
-                            common_edges[cell_id1][cell_id2] = intersection
-                            common_edges[cell_id2][cell_id1] = intersection
-                
-                pbar.update(1)
-        
-        return cell_adjacency, common_edges
-
-    @staticmethod
-    def _identify_boundary_edges(cell_adjacency: Dict[int, List[int]], common_edges: Dict[int, Dict[int, LineString]], cell_times: Dict[int, pd.Timestamp], delta_t: float) -> List[LineString]:
         boundary_edges = []
         with tqdm(total=len(cell_adjacency), desc="Processing cell adjacencies") as pbar:
             for cell_id, neighbors in cell_adjacency.items():
                 cell_time = cell_times[cell_id]
-                
+
                 for neighbor_id in neighbors:
                     neighbor_time = cell_times[neighbor_id]
                     time_diff = abs((cell_time - neighbor_time).total_seconds() / 3600)
-                    
+
                     if time_diff >= delta_t:
                         boundary_edges.append(common_edges[cell_id][neighbor_id])
-                
-                pbar.update(1)
-        return boundary_edges
-
-    @staticmethod
-    def _extract_coordinates(df: pd.DataFrame) -> None:
-        """
-        Extract x and y coordinates from the 'face_point' column.
-
-        Parameters:
-        - df: DataFrame containing the 'face_point' column.
-
-        Returns:
-        - None (modifies the DataFrame in-place)
-        """
-        if 'face_point' in df.columns:
-            df[['x', 'y']] = df['face_point'].str.strip('()').str.split(',', expand=True).astype(float)
-        else:
-            print("Warning: 'face_point' column not found in the DataFrame.")
-
-    @staticmethod
-    def _convert_to_geodataframe(df: pd.DataFrame, projection: str) -> gpd.GeoDataFrame:
-        """
-        Convert a DataFrame to a GeoDataFrame.
-
-        Parameters:
-        - df: DataFrame containing 'geometry' column.
-        - projection: The coordinate reference system to assign to the GeoDataFrame.
-
-        Returns:
-        - GeoDataFrame with the specified projection.
-        """
-        gdf = gpd.GeoDataFrame(df, geometry='geometry', crs=projection)
-        
-        return gdf
-
-
 
+                pbar.update(1)
 
+        return boundary_edges