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

ras_commander/HdfFluvialPluvial.py

@@ -14,7 +14,7 @@ from typing import Dict, List, Tuple
 import pandas as pd
 import geopandas as gpd
 from collections import defaultdict
-from shapely.geometry import LineString
+from shapely.geometry import LineString, MultiLineString  # Added MultiLineString import
 from tqdm import tqdm
 from .HdfMesh import HdfMesh
 from .HdfUtils import HdfUtils
@@ -53,7 +53,9 @@ class HdfFluvialPluvial:
         ...     delta_t=12
         ... )
     """
-
+    def __init__(self):
+        self.logger = get_logger(__name__)  # Initialize logger with module name
+    
     @staticmethod
     @standardize_input(file_type='plan_hdf')
     def calculate_fluvial_pluvial_boundary(hdf_path: Path, delta_t: float = 12) -> gpd.GeoDataFrame:
@@ -93,106 +95,179 @@ class HdfFluvialPluvial:
                 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 = []
-            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]:
-                        current_line.append(edge)
-                    else:
-                        joined_lines.append(LineString([point for line in current_line for point in line.coords]))
-                        current_line = [edge]
-
-            if current_line:
-                joined_lines.append(LineString([point for line in current_line for point in line.coords]))
+            
+            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:
-            logger.error(f"Error calculating fluvial-pluvial boundary: {str(e)}")
-            raise
-
+            self.logger.error(f"Error calculating fluvial-pluvial boundary: {str(e)}")
+            return None
+        
+        
     @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 spatial indexing for efficiency.
-
+        Optimized method to process cell adjacencies by extracting shared edges directly.
+        
         Args:
             cell_polygons_gdf (gpd.GeoDataFrame): GeoDataFrame containing 2D mesh cell polygons
-                                                 with 'cell_id' and 'geometry' columns
+                                                   with 'cell_id' and 'geometry' columns.
 
         Returns:
             Tuple containing:
-                - Dict[int, List[int]]: Dictionary mapping cell IDs to lists of adjacent cell IDs
+                - 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
-
-        Note:
-            Uses R-tree spatial indexing to efficiently identify potential neighboring cells
-            before performing more detailed geometric operations.
+                                                    where common_edges[cell1][cell2] gives the shared boundary.
         """
-        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)
 
+        # 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

ras_commander/HdfMesh.py

@@ -9,15 +9,25 @@ All methods are designed to work with the mesh geometry data stored in
 HEC-RAS HDF files, providing functionality to retrieve and process various aspects
 of the 2D flow areas and their associated mesh structures.
 
+
 List of Functions:
 -----------------
 get_mesh_area_names()
     Returns list of 2D mesh area names
 get_mesh_areas()
     Returns 2D flow area perimeter polygons
-mesh_cell_polygons()
+get_mesh_cell_polygons()
     Returns 2D flow mesh cell polygons
-[etc...]
+get_mesh_cell_points()
+    Returns 2D flow mesh cell center points
+get_mesh_cell_faces()
+    Returns 2D flow mesh cell faces
+get_mesh_area_attributes()
+    Returns geometry 2D flow area attributes
+get_mesh_face_property_tables()
+    Returns Face Property Tables for each Face in all 2D Flow Areas
+get_mesh_cell_property_tables()
+    Returns Cell Property Tables for each Cell in all 2D Flow Areas
 
 Each function is decorated with @standardize_input and @log_call for consistent
 input handling and logging functionality.
@@ -148,49 +158,45 @@ class HdfMesh:
                 if not mesh_area_names:
                     return GeoDataFrame()
 
+                # Get face geometries once
                 face_gdf = HdfMesh.get_mesh_cell_faces(hdf_path)
+                
+                # Pre-allocate lists for better memory efficiency
+                all_mesh_names = []
+                all_cell_ids = []
+                all_geometries = []
+
+                for mesh_name in mesh_area_names:
+                    # Get cell face info in one read
+                    cell_face_info = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Info"][()]
+                    cell_face_values = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Values"][()][:, 0]
+                    
+                    # Create face lookup dictionary for this mesh
+                    mesh_faces_dict = dict(face_gdf[face_gdf.mesh_name == mesh_name][["face_id", "geometry"]].values)
+
+                    # Process each cell
+                    for cell_id, (start, length) in enumerate(cell_face_info[:, :2]):
+                        face_ids = cell_face_values[start:start + length]
+                        face_geoms = [mesh_faces_dict[face_id] for face_id in face_ids]
+                        
+                        # Create polygon
+                        polygons = list(polygonize(face_geoms))
+                        if polygons:
+                            all_mesh_names.append(mesh_name)
+                            all_cell_ids.append(cell_id)
+                            all_geometries.append(Polygon(polygons[0]))
+
+                # Create GeoDataFrame in one go
+                return GeoDataFrame(
+                    {
+                        "mesh_name": all_mesh_names,
+                        "cell_id": all_cell_ids,
+                        "geometry": all_geometries
+                    },
+                    geometry="geometry",
+                    crs=HdfBase.get_projection(hdf_file)
+                )
 
-                cell_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
-                for i, mesh_name in enumerate(mesh_area_names):
-                    cell_cnt = hdf_file["Geometry/2D Flow Areas/Cell Info"][()][i][1]
-                    cell_ids = list(range(cell_cnt))
-                    cell_face_info = hdf_file[
-                        "Geometry/2D Flow Areas/{}/Cells Face and Orientation Info".format(mesh_name)
-                    ][()]
-                    cell_face_values = hdf_file[
-                        "Geometry/2D Flow Areas/{}/Cells Face and Orientation Values".format(mesh_name)
-                    ][()][:, 0]
-                    face_id_lists = list(
-                        np.vectorize(
-                            lambda cell_id: str(
-                                cell_face_values[
-                                    cell_face_info[cell_id][0] : cell_face_info[cell_id][0]
-                                    + cell_face_info[cell_id][1]
-                                ]
-                            )
-                        )(cell_ids)
-                    )
-                    mesh_faces = (
-                        face_gdf[face_gdf.mesh_name == mesh_name][["face_id", "geometry"]]
-                        .set_index("face_id")
-                        .to_numpy()
-                    )
-                    cell_dict["mesh_name"] += [mesh_name] * cell_cnt
-                    cell_dict["cell_id"] += cell_ids
-                    cell_dict["geometry"] += list(
-                        np.vectorize(
-                            lambda face_id_list: (
-                                lambda geom_col: Polygon(list(polygonize(geom_col))[0])
-                            )(
-                                np.ravel(
-                                    mesh_faces[
-                                        np.array(face_id_list.strip("[]").split()).astype(int)
-                                    ]
-                                )
-                            )
-                        )(face_id_lists)
-                    )
-                return GeoDataFrame(cell_dict, geometry="geometry", crs=HdfBase.get_projection(hdf_file))
         except Exception as e:
             logger.error(f"Error reading mesh cell polygons from {hdf_path}: {str(e)}")
             return GeoDataFrame()
@@ -217,19 +223,32 @@ class HdfMesh:
                 if not mesh_area_names:
                     return GeoDataFrame()
                 
-                pnt_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
+                # Pre-allocate lists
+                all_mesh_names = []
+                all_cell_ids = []
+                all_points = []
+
                 for mesh_name in mesh_area_names:
-                    cell_center_coords = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Cells Center Coordinate"][()]
-                    cell_count = len(cell_center_coords)
+                    # Get all cell centers in one read
+                    cell_centers = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Cells Center Coordinate"][()]
+                    cell_count = len(cell_centers)
                     
-                    pnt_dict["mesh_name"] += [mesh_name] * cell_count
-                    pnt_dict["cell_id"] += range(cell_count)
-                    pnt_dict["geometry"] += list(
-                        np.vectorize(lambda coords: Point(coords), signature="(n)->()")(
-                            cell_center_coords
-                        )
-                    )
-                return GeoDataFrame(pnt_dict, geometry="geometry", crs=HdfBase.get_projection(hdf_path))
+                    # Extend lists efficiently
+                    all_mesh_names.extend([mesh_name] * cell_count)
+                    all_cell_ids.extend(range(cell_count))
+                    all_points.extend(Point(coords) for coords in cell_centers)
+
+                # Create GeoDataFrame in one go
+                return GeoDataFrame(
+                    {
+                        "mesh_name": all_mesh_names,
+                        "cell_id": all_cell_ids,
+                        "geometry": all_points
+                    },
+                    geometry="geometry",
+                    crs=HdfBase.get_projection(hdf_file)
+                )
+
         except Exception as e:
             logger.error(f"Error reading mesh cell points from {hdf_path}: {str(e)}")
             return GeoDataFrame()
@@ -255,37 +274,45 @@ class HdfMesh:
                 mesh_area_names = HdfMesh.get_mesh_area_names(hdf_path)
                 if not mesh_area_names:
                     return GeoDataFrame()
-                face_dict = {"mesh_name": [], "face_id": [], "geometry": []}
+
+                # Pre-allocate lists
+                all_mesh_names = []
+                all_face_ids = []
+                all_geometries = []
+
                 for mesh_name in mesh_area_names:
-                    facepoints_index = hdf_file[
-                        "Geometry/2D Flow Areas/{}/Faces FacePoint Indexes".format(mesh_name)
-                    ][()]
-                    facepoints_coordinates = hdf_file[
-                        "Geometry/2D Flow Areas/{}/FacePoints Coordinate".format(mesh_name)
-                    ][()]
-                    faces_perimeter_info = hdf_file[
-                        "Geometry/2D Flow Areas/{}/Faces Perimeter Info".format(mesh_name)
-                    ][()]
-                    faces_perimeter_values = hdf_file[
-                        "Geometry/2D Flow Areas/{}/Faces Perimeter Values".format(mesh_name)
-                    ][()]
-                    face_id = -1
-                    for pnt_a_index, pnt_b_index in facepoints_index:
-                        face_id += 1
-                        face_dict["mesh_name"].append(mesh_name)
-                        face_dict["face_id"].append(face_id)
-                        coordinates = list()
-                        coordinates.append(facepoints_coordinates[pnt_a_index])
-                        starting_row, count = faces_perimeter_info[face_id]
+                    # Read all data at once
+                    facepoints_index = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Faces FacePoint Indexes"][()]
+                    facepoints_coords = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/FacePoints Coordinate"][()]
+                    faces_perim_info = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Info"][()]
+                    faces_perim_values = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Values"][()]
+
+                    # Process each face
+                    for face_id, ((pnt_a_idx, pnt_b_idx), (start_row, count)) in enumerate(zip(facepoints_index, faces_perim_info)):
+                        coords = [facepoints_coords[pnt_a_idx]]
+                        
                         if count > 0:
-                            coordinates += list(
-                                faces_perimeter_values[starting_row : starting_row + count]
-                            )
-                        coordinates.append(facepoints_coordinates[pnt_b_index])
-                        face_dict["geometry"].append(LineString(coordinates))
-                return GeoDataFrame(face_dict, geometry="geometry", crs=HdfBase.get_projection(hdf_path))
+                            coords.extend(faces_perim_values[start_row:start_row + count])
+                            
+                        coords.append(facepoints_coords[pnt_b_idx])
+                        
+                        all_mesh_names.append(mesh_name)
+                        all_face_ids.append(face_id)
+                        all_geometries.append(LineString(coords))
+
+                # Create GeoDataFrame in one go
+                return GeoDataFrame(
+                    {
+                        "mesh_name": all_mesh_names,
+                        "face_id": all_face_ids,
+                        "geometry": all_geometries
+                    },
+                    geometry="geometry",
+                    crs=HdfBase.get_projection(hdf_file)
+                )
+
         except Exception as e:
-            self.logger.error(f"Error reading mesh cell faces from {hdf_path}: {str(e)}")
+            logger.error(f"Error reading mesh cell faces from {hdf_path}: {str(e)}")
             return GeoDataFrame()
 
     @staticmethod

ras_commander/HdfPlot.py

@@ -22,7 +22,7 @@ class HdfPlot:
     @staticmethod
     @log_call
     def plot_mesh_cells(
-        cell_polygons_df: pd.DataFrame, 
+        cell_polygons_df: pd.DataFrame, ## THIS IS A GEODATAFRAME - NEED TO EDIT BOTH ARGUMENT AND USAGE
         projection: str,
         title: str = '2D Flow Area Mesh Cells',
         figsize: Tuple[int, int] = (12, 8)

ras_commander/HdfResultsMesh.py

@@ -74,6 +74,7 @@ from .HdfBase import HdfBase
 from .HdfUtils import HdfUtils
 from .Decorators import log_call, standardize_input
 from .LoggingConfig import setup_logging, get_logger
+import geopandas as gpd
 
 logger = get_logger(__name__)
 
@@ -234,7 +235,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def get_mesh_max_ws(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_max_ws(hdf_path: Path, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get maximum water surface elevation for each mesh cell.
 
@@ -243,10 +244,7 @@ class HdfResultsMesh:
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing maximum water surface elevations.
-
-        Raises:
-            ValueError: If there's an error processing the maximum water surface data.
+            gpd.GeoDataFrame: GeoDataFrame containing maximum water surface elevations with geometry.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
@@ -262,7 +260,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def get_mesh_min_ws(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_min_ws(hdf_path: Path, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get minimum water surface elevation for each mesh cell.
 
@@ -271,7 +269,7 @@ class HdfResultsMesh:
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing minimum water surface elevations.
+            gpd.GeoDataFrame: GeoDataFrame containing minimum water surface elevations with geometry.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
@@ -353,7 +351,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def get_mesh_max_iter(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_max_iter(hdf_path: Path, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get maximum iteration count for each mesh cell.
 
@@ -362,36 +360,19 @@ class HdfResultsMesh:
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing maximum iteration counts with face geometry.
-
-        Raises:
-            ValueError: If there's an error processing the maximum iteration data.
-        """
-        """
-        Get maximum iteration count for each mesh cell.
-
-        Args:
-            hdf_path (Path): Path to the HDF file
-            round_to (str): Time rounding specification (default "100ms").
-
-        Returns:
-            pd.DataFrame: DataFrame containing maximum iteration counts with columns:
+            gpd.GeoDataFrame: GeoDataFrame containing maximum iteration counts with geometry.
+                Includes columns:
                 - mesh_name: Name of the mesh
                 - cell_id: ID of the cell
                 - cell_last_iteration: Maximum number of iterations
                 - cell_last_iteration_time: Time when max iterations occurred
                 - geometry: Point geometry representing cell center
-                
-        Raises:
-            ValueError: If there's an error processing the maximum iteration data.
-            
-        Note: The Maximum Iteration is labeled as "Cell Last Iteration" in the HDF file 
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
                 return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Cell Last Iteration", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_max_iter: {str(e)}")
+            logger.error(f"Error in get_mesh_max_iter: {str(e)}")
             raise ValueError(f"Failed to get maximum iteration count: {str(e)}")
         
         
@@ -612,7 +593,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def get_mesh_summary_output(hdf_file: h5py.File, var: str, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_summary_output(hdf_file: h5py.File, var: str, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get the summary output data for a given variable from the HDF file.
 
@@ -627,8 +608,8 @@ class HdfResultsMesh:
 
         Returns
         -------
-        pd.DataFrame
-            A DataFrame containing the summary output data with attributes as metadata.
+        gpd.GeoDataFrame
+            A GeoDataFrame containing the summary output data with attributes as metadata.
 
         Raises
         ------
@@ -642,7 +623,7 @@ class HdfResultsMesh:
             logger.info(f"Processing summary output for variable: {var}")
             d2_flow_areas = hdf_file.get("Geometry/2D Flow Areas/Attributes")
             if d2_flow_areas is None:
-                return pd.DataFrame()
+                return gpd.GeoDataFrame()
 
             for d2_flow_area in d2_flow_areas[:]:
                 mesh_name = HdfUtils.convert_ras_string(d2_flow_area[0])
@@ -707,10 +688,18 @@ class HdfResultsMesh:
                 dfs.append(df)
             
             if not dfs:
-                return pd.DataFrame()
+                return gpd.GeoDataFrame()
                 
             result = pd.concat(dfs, ignore_index=True)
             
+            # Convert to GeoDataFrame
+            gdf = gpd.GeoDataFrame(result, geometry='geometry')
+            
+            # Get CRS from HdfUtils
+            crs = HdfBase.get_projection(hdf_file)
+            if crs:
+                gdf.set_crs(crs, inplace=True)
+            
             # Combine attributes from all meshes
             combined_attrs = {}
             for df in dfs:
@@ -720,15 +709,14 @@ class HdfResultsMesh:
                     elif combined_attrs[key] != value:
                         combined_attrs[key] = f"Multiple values: {combined_attrs[key]}, {value}"
             
-            result.attrs.update(combined_attrs)
+            gdf.attrs.update(combined_attrs)
             
-            logger.info(f"Processed {len(result)} rows of summary output data")
-            return result
+            logger.info(f"Processed {len(gdf)} rows of summary output data")
+            return gdf
         
         except Exception as e:
             logger.error(f"Error processing summary output data: {e}")
             raise ValueError(f"Error processing summary output data: {e}")
-        
 
     @staticmethod
     def get_mesh_summary_output_group(hdf_file: h5py.File, mesh_name: str, var: str) -> Union[h5py.Group, h5py.Dataset]:

ras_commander/LoggingConfig.py

@@ -49,9 +49,19 @@ def setup_logging(log_file=None, log_level=logging.INFO):
     
     _logging_setup_done = True
 
-def get_logger(name):
-    """Get a logger for a specific module."""
-    return logging.getLogger(name)
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance with the specified name.
+    
+    Args:
+        name: The name for the logger, typically __name__ or module path
+        
+    Returns:
+        logging.Logger: Configured logger instance
+    """
+    logger = logging.getLogger(name)
+    if not logger.handlers:  # Only add handler if none exists
+        setup_logging()  # Ensure logging is configured
+    return logger
 
 def log_call(logger=None):
     """Decorator to log function calls."""

{ras_commander-0.49.0.dist-info → ras_commander-0.50.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ras-commander
-Version: 0.49.0
+Version: 0.50.0
 Summary: A Python library for automating HEC-RAS operations
 Home-page: https://github.com/billk-FM/ras-commander
 Author: William M. Katzenmeyer
@@ -61,10 +61,13 @@ Create a virtual environment with conda or venv (ask ChatGPT if you need help)
 
 In your virtual environment, install ras-commander using pip:
 ```
-pip install h5py numpy pandas requests tqdm scipy xarray geopandas matplotlib ras-commander ipython psutil shapely fiona pathlib rtree
+pip install h5py numpy pandas requests tqdm scipy xarray geopandas matplotlib ras-commander ipython psutil shapely fiona pathlib rtree rasterstats
 pip install --upgrade ras-commander
 ```
 
+**Tested with Python 3.11**
+
+
 If you have dependency issues with pip (especially if you have errors with numpy), try clearing your local pip packages 'C:\Users\your_username\AppData\Roaming\Python\' and then creating a new virtual environment.  
    
 

{ras_commander-0.49.0.dist-info → ras_commander-0.50.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
 ras_commander/Decorators.py,sha256=M5r5cHz_yy9YTHNEoytO9uwWbv_S-YYUk2QHNamJJJs,5848
 ras_commander/HdfBase.py,sha256=bJtSWdDUP4MYJ8QgkcixBEDFMSlslUdmVFHZxWMGMDM,11603
 ras_commander/HdfBndry.py,sha256=gcNr22vHNjEiWYigz-4aKUEYUi__3bRl4AeRAQQEmjs,12553
-ras_commander/HdfFluvialPluvial.py,sha256=V6RGpKmnX5E6XzAJPcexcPtC2Qfy56XpJi_Vq4KEV7o,10243
+ras_commander/HdfFluvialPluvial.py,sha256=Bscvv0KBGnl05U7hH9RmsGqtPANDdTxgLwo7kXbTmTU,14281
 ras_commander/HdfInfiltration.py,sha256=QVigQJjYeQNutbazGHhbTmEuIVCb9gIb2f4yM-wyUtQ,15269
-ras_commander/HdfMesh.py,sha256=Yyom3i46AQFqI9cvhUyc5vh_g98aKAAsAjx7akuzsXw,18299
+ras_commander/HdfMesh.py,sha256=R_O8tMsQvzbepa3hy1psO9t7TmYyMndnyZSh3602rFY,18683
 ras_commander/HdfPipe.py,sha256=m-yvPL2GIP23NKt2tcwzOlS7khvgcDPGAshlTPMUAeI,32154
 ras_commander/HdfPlan.py,sha256=NW6g2kS74y44Ci1P9iMo7IKUfR0eYOaJn1QbzsRM1co,10415
-ras_commander/HdfPlot.py,sha256=m4hbVkRbLW5a515jnM-iHSt5CLgtLSn5yxSpzRmgCGk,3337
+ras_commander/HdfPlot.py,sha256=7MNI5T9qIz-Ava1RdlnB6O9oJElE5BEB29QVF5Y2Xuc,3401
 ras_commander/HdfPump.py,sha256=Vc2ff16kRISR7jwtnaAqxI0p-gfBSuZKzR3rQbBLQoE,12951
-ras_commander/HdfResultsMesh.py,sha256=RIwifjvVU3DuO4SpRvPsse7io9TpiJljAuNJe_K82wM,31316
+ras_commander/HdfResultsMesh.py,sha256=T1afgFsJ1NaqmOJEJfMUBm1ZZ5pwbd82aAqeEkHNaLk,30959
 ras_commander/HdfResultsPlan.py,sha256=HoN3wvhj1wtkW-M20UHH9skntDqEvJEgeYeO_QBLF2w,11974
 ras_commander/HdfResultsPlot.py,sha256=ylzfT78CfgoDO0XAlRwlgMNRzvNQYBMn9eyXyBfjv_w,7660
 ras_commander/HdfResultsXsec.py,sha256=-P7nXnbjOLAeUnrdSC_lJQSfzrlWKmDF9Z5gEjmxbJY,13031
 ras_commander/HdfStruc.py,sha256=yzD4_eZLgwZDS3GdYVWqd85jRpdlRdVdbHHfPYTmwjA,12703
 ras_commander/HdfUtils.py,sha256=AbfV5RwbFyNR1SFGKO_izmVtRnDx68u_4wep5FK14xU,14814
 ras_commander/HdfXsec.py,sha256=uuogrJjRFytNHxmluQVuB57X1lILo1Y15wtc_VaHMX8,26809
-ras_commander/LoggingConfig.py,sha256=5bYd_5KMlf81bXsiu2mABBlw0USMhcu5uRv8DIYJSFE,2317
+ras_commander/LoggingConfig.py,sha256=p1OJkQj5dsDdyBQqF0HWsvbsU88n9cYOc3YB2MMBYiw,2666
 ras_commander/RasCmdr.py,sha256=N2PI5n0P3ClLUPOPNcONJHGJYF-fIU5o0GXwHv4VATE,25271
 ras_commander/RasExamples.py,sha256=eYlRKryCG88FN5p23TnA1-E2Bxuaz3OxjdHPHJSqdB8,17006
 ras_commander/RasGeo.py,sha256=M0sVNKlWmmbve8iMXLWq25WgbxqLWBo7_1oDg_rALzU,5607
@@ -27,8 +27,8 @@ ras_commander/RasToGo.py,sha256=TKujfaV1xQhFaOddF4g2ogGy6ky-CLlfelSMPD2J3Nk,1223
 ras_commander/RasUnsteady.py,sha256=NWZbmB3-HT0W00K4-zxFN9OF8H_HlOY64nM72sHicWg,31154
 ras_commander/RasUtils.py,sha256=P2-aBL61kdRINsjnBpstZVD6VVc7hI_D3RUXqr6ldmc,34863
 ras_commander/__init__.py,sha256=vhnZQaejmyFVFP5fcYxAc4A562o8KFcnZNkcY6J5xwY,2068
-ras_commander-0.49.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.49.0.dist-info/METADATA,sha256=EAK_gweDEyFXD8yvAFAywr33gxm7pFrGh37pdTrCrXU,18278
-ras_commander-0.49.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-ras_commander-0.49.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.49.0.dist-info/RECORD,,
+ras_commander-0.50.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.50.0.dist-info/METADATA,sha256=Hjc2Tbk_T7EmArxWMbPzQels8FShtQ2ojkjLd73X6jw,18323
+ras_commander-0.50.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+ras_commander-0.50.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.50.0.dist-info/RECORD,,