ras-commander 0.78.0__py3-none-any.whl → 0.79.0__py3-none-any.whl

ras_commander/HdfFluvialPluvial.py

@@ -4,17 +4,19 @@ 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()
+- calculate_fluvial_pluvial_boundary(): Returns LineStrings representing the boundary.
+- generate_fluvial_pluvial_polygons(): Returns dissolved Polygons for fluvial, pluvial, and ambiguous zones.
 - _process_cell_adjacencies()
+- _get_boundary_cell_pairs()
 - _identify_boundary_edges()
 
 """
 
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Set, Optional
 import pandas as pd
 import geopandas as gpd
 from collections import defaultdict
-from shapely.geometry import LineString, MultiLineString  # Added MultiLineString import
+from shapely.geometry import LineString, MultiLineString
 from tqdm import tqdm
 from .HdfMesh import HdfMesh
 from .HdfUtils import HdfUtils
@@ -37,7 +39,7 @@ class HdfFluvialPluvial:
     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.
+    - 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:
@@ -46,509 +48,369 @@ class HdfFluvialPluvial:
         - Maximum water surface elevation times (accessed via HdfResultsMesh)
 
     Usage Example:
-        >>> ras = init_ras_project(project_path, ras_version)
+        >>> from ras_commander import HdfFluvialPluvial
         >>> hdf_path = Path("path/to/plan.hdf")
-        >>> boundary_gdf = HdfFluvialPluvial.calculate_fluvial_pluvial_boundary(
+        
+        # To get just the boundary lines
+        >>> boundary_lines_gdf = HdfFluvialPluvial.calculate_fluvial_pluvial_boundary(
         ...     hdf_path, 
         ...     delta_t=12
         ... )
+        
+        # To get classified flood polygons
+        >>> flood_polygons_gdf = HdfFluvialPluvial.generate_fluvial_pluvial_polygons(
+        ...     hdf_path,
+        ...     delta_t=12,
+        ...     temporal_tolerance_hours=1.0
+        ... )
     """
     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:
+    def calculate_fluvial_pluvial_boundary(
+        hdf_path: Path, 
+        delta_t: float = 12,
+        min_line_length: Optional[float] = None
+    ) -> gpd.GeoDataFrame:
         """
-        Calculate the fluvial-pluvial boundary based on cell polygons and maximum water surface elevation times.
+        Calculate the fluvial-pluvial boundary lines based on cell polygons and maximum water surface elevation times.
+
+        This function is useful for visualizing the line of transition between flooding mechanisms.
 
         Args:
-            hdf_path (Path): Path to the HEC-RAS plan HDF file
+            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.
+                             greater than this value are considered boundaries. Default is 12 hours.
+            min_line_length (float, optional): Minimum length (in CRS units) for boundary lines to be included.
+                                               Lines shorter than this will be dropped. Default is None (no filtering).
 
         Returns:
-            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.
+            gpd.GeoDataFrame: GeoDataFrame containing the fluvial-pluvial boundary lines.
         """
         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
-                )
+            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
+                cell_adjacency, common_edges, cell_times, delta_t, min_line_length=min_line_length
+            )
+
+            logger.info("Creating final GeoDataFrame for boundaries...")
+            boundary_gdf = gpd.GeoDataFrame(
+                geometry=boundary_edges, 
+                crs=cell_polygons_gdf.crs
+            )
+
+            logger.info("Boundary line calculation completed successfully.")
+            return boundary_gdf
+
+        except Exception as e:
+            logger.error(f"Error calculating fluvial-pluvial boundary lines: {str(e)}")
+            return gpd.GeoDataFrame()
+
+    @staticmethod
+    @standardize_input(file_type='plan_hdf')
+    def generate_fluvial_pluvial_polygons(
+        hdf_path: Path, 
+        delta_t: float = 12, 
+        temporal_tolerance_hours: float = 1.0,
+        min_polygon_area_acres: Optional[float] = None
+    ) -> gpd.GeoDataFrame:
+        """
+        Generates dissolved polygons representing fluvial, pluvial, and ambiguous flood zones.
+
+        This function classifies each wetted cell and merges them into three distinct regions
+        based on the timing of maximum water surface elevation.
+
+        Optionally, for polygons classified as fluvial or pluvial, if their area is less than
+        min_polygon_area_acres, they are reclassified to the opposite type and merged with
+        adjacent polygons of that type. Ambiguous polygons are exempt from this logic.
+
+        Args:
+            hdf_path (Path): Path to the HEC-RAS plan HDF file.
+            delta_t (float): The time difference (in hours) between adjacent cells that defines
+                             the initial boundary between fluvial and pluvial zones. Default is 12.
+            temporal_tolerance_hours (float): The maximum time difference (in hours) for a cell
+                                              to be considered part of an expanding region. 
+                                              Default is 1.0.
+            min_polygon_area_acres (float, optional): Minimum polygon area (in acres). For fluvial or pluvial
+                                                      polygons smaller than this, reclassify to the opposite
+                                                      type and merge with adjacent polygons of that type.
+                                                      Ambiguous polygons are not affected.
+
+        Returns:
+            gpd.GeoDataFrame: A GeoDataFrame with dissolved polygons for 'fluvial', 'pluvial',
+                              and 'ambiguous' zones.
+        """
+        try:
+            # --- 1. Data Loading and Preparation ---
+            logger.info("Loading mesh and results data...")
+            cell_polygons_gdf = HdfMesh.get_mesh_cell_polygons(hdf_path)
+            max_ws_df = HdfResultsMesh.get_mesh_max_ws(hdf_path)
+            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
             )
+            cell_times = max_ws_df.set_index('cell_id')['maximum_water_surface_time'].to_dict()
+            
+            logger.info("Processing cell adjacencies...")
+            cell_adjacency, _ = HdfFluvialPluvial._process_cell_adjacencies(cell_polygons_gdf)
 
-            # FOCUS YOUR REVISIONS HERE: 
-            # Join adjacent LineStrings into simple LineStrings by connecting them at shared endpoints
-            logger.info("Joining adjacent LineStrings into simple LineStrings...")
+            # --- 2. Seeding the Classifications ---
+            logger.info(f"Identifying initial boundary seeds with delta_t = {delta_t} hours...")
+            boundary_pairs = HdfFluvialPluvial._get_boundary_cell_pairs(cell_adjacency, cell_times, delta_t)
+
+            classifications = pd.Series('unclassified', index=cell_polygons_gdf['cell_id'], name='classification')
             
-            def get_coords(geom):
-                """Helper function to extract coordinates from geometry objects
-                
-                Args:
-                    geom: A Shapely LineString or MultiLineString geometry
-                
-                Returns:
-                    tuple: Tuple containing:
-                        - list of original coordinates [(x1,y1), (x2,y2),...]
-                        - list of rounded coordinates for comparison
-                        - None if invalid geometry
-                """
-                if isinstance(geom, LineString):
-                    orig_coords = list(geom.coords)
-                    # Round coordinates to 0.01 for comparison
-                    rounded_coords = [(round(x, 2), round(y, 2)) for x, y in orig_coords]
-                    return orig_coords, rounded_coords
-                elif isinstance(geom, MultiLineString):
-                    orig_coords = list(geom.geoms[0].coords)
-                    rounded_coords = [(round(x, 2), round(y, 2)) for x, y in orig_coords]
-                    return orig_coords, rounded_coords
-                return None, None
-
-            def find_connecting_line(current_end, unused_lines, endpoint_counts, rounded_endpoints):
-                """Find a line that connects to the current endpoint
-                
-                Args:
-                    current_end: Tuple of (x, y) coordinates
-                    unused_lines: Set of unused line indices
-                    endpoint_counts: Dict of endpoint occurrence counts
-                    rounded_endpoints: Dict of rounded endpoint coordinates
-                
-                Returns:
-                    tuple: (line_index, should_reverse, found) or (None, None, False)
-                """
-                rounded_end = (round(current_end[0], 2), round(current_end[1], 2))
-                
-                # Skip if current endpoint is connected to more than 2 lines
-                if endpoint_counts.get(rounded_end, 0) > 2:
-                    return None, None, False
-                
-                for i in unused_lines:
-                    start, end = rounded_endpoints[i]
-                    if start == rounded_end and endpoint_counts.get(start, 0) <= 2:
-                        return i, False, True
-                    elif end == rounded_end and endpoint_counts.get(end, 0) <= 2:
-                        return i, True, True
-                return None, None, False
-
-            # Initialize data structures
-            joined_lines = []
-            unused_lines = set(range(len(boundary_edges)))
+            for cell1, cell2 in boundary_pairs:
+                if cell_times.get(cell1) > cell_times.get(cell2):
+                    classifications.loc[cell1] = 'fluvial'
+                    classifications.loc[cell2] = 'pluvial'
+                else:
+                    classifications.loc[cell1] = 'pluvial'
+                    classifications.loc[cell2] = 'fluvial'
             
-            # Create endpoint lookup dictionaries
-            line_endpoints = {}
-            rounded_endpoints = {}
-            for i, edge in enumerate(boundary_edges):
-                coords_result = get_coords(edge)
-                if coords_result:
-                    orig_coords, rounded_coords = coords_result
-                    line_endpoints[i] = (orig_coords[0], orig_coords[-1])
-                    rounded_endpoints[i] = (rounded_coords[0], rounded_coords[-1])
-
-            # Count endpoint occurrences
-            endpoint_counts = {}
-            for start, end in rounded_endpoints.values():
-                endpoint_counts[start] = endpoint_counts.get(start, 0) + 1
-                endpoint_counts[end] = endpoint_counts.get(end, 0) + 1
-
-            # Iteratively join lines
-            while unused_lines:
-                # Start a new line chain
-                current_points = []
-                
-                # Find first unused line
-                start_idx = unused_lines.pop()
-                start_coords, _ = get_coords(boundary_edges[start_idx])
-                if start_coords:
-                    current_points.extend(start_coords)
-                
-                # Try to extend in both directions
-                continue_joining = True
-                while continue_joining:
-                    continue_joining = False
+            # --- 3. Iterative Region Growth ---
+            logger.info(f"Starting iterative region growth with tolerance = {temporal_tolerance_hours} hours...")
+            fluvial_frontier = set(classifications[classifications == 'fluvial'].index)
+            pluvial_frontier = set(classifications[classifications == 'pluvial'].index)
+            
+            iteration = 0
+            with tqdm(desc="Region Growing", unit="iter") as pbar:
+                while fluvial_frontier or pluvial_frontier:
+                    iteration += 1
                     
-                    # Try to extend forward
-                    next_idx, should_reverse, found = find_connecting_line(
-                        current_points[-1], 
-                        unused_lines,
-                        endpoint_counts,
-                        rounded_endpoints
-                    )
+                    next_fluvial_candidates = set()
+                    for cell_id in fluvial_frontier:
+                        for neighbor_id in cell_adjacency.get(cell_id, []):
+                            if classifications.loc[neighbor_id] == 'unclassified' and pd.notna(cell_times.get(neighbor_id)):
+                                time_diff_seconds = abs((cell_times[cell_id] - cell_times[neighbor_id]).total_seconds())
+                                if time_diff_seconds <= temporal_tolerance_hours * 3600:
+                                    next_fluvial_candidates.add(neighbor_id)
                     
-                    if found:
-                        unused_lines.remove(next_idx)
-                        next_coords, _ = get_coords(boundary_edges[next_idx])
-                        if next_coords:
-                            if should_reverse:
-                                current_points.extend(reversed(next_coords[:-1]))
-                            else:
-                                current_points.extend(next_coords[1:])
-                        continue_joining = True
-                        continue
+                    next_pluvial_candidates = set()
+                    for cell_id in pluvial_frontier:
+                        for neighbor_id in cell_adjacency.get(cell_id, []):
+                            if classifications.loc[neighbor_id] == 'unclassified' and pd.notna(cell_times.get(neighbor_id)):
+                                time_diff_seconds = abs((cell_times[cell_id] - cell_times[neighbor_id]).total_seconds())
+                                if time_diff_seconds <= temporal_tolerance_hours * 3600:
+                                    next_pluvial_candidates.add(neighbor_id)
                     
-                    # Try to extend backward
-                    prev_idx, should_reverse, found = find_connecting_line(
-                        current_points[0], 
-                        unused_lines,
-                        endpoint_counts,
-                        rounded_endpoints
-                    )
+                    # Resolve conflicts
+                    ambiguous_cells = next_fluvial_candidates.intersection(next_pluvial_candidates)
+                    if ambiguous_cells:
+                        classifications.loc[list(ambiguous_cells)] = 'ambiguous'
+                        
+                    # Classify non-conflicted cells
+                    newly_fluvial = next_fluvial_candidates - ambiguous_cells
+                    if newly_fluvial:
+                        classifications.loc[list(newly_fluvial)] = 'fluvial'
+
+                    newly_pluvial = next_pluvial_candidates - ambiguous_cells
+                    if newly_pluvial:
+                        classifications.loc[list(newly_pluvial)] = 'pluvial'
                     
-                    if found:
-                        unused_lines.remove(prev_idx)
-                        prev_coords, _ = get_coords(boundary_edges[prev_idx])
-                        if prev_coords:
-                            if should_reverse:
-                                current_points[0:0] = reversed(prev_coords[:-1])
-                            else:
-                                current_points[0:0] = prev_coords[:-1]
-                        continue_joining = True
-                
-                # Create final LineString from collected points
-                if current_points:
-                    joined_lines.append(LineString(current_points))
-
-            # FILL GAPS BETWEEN JOINED LINES
-            logger.info(f"Starting gap analysis for {len(joined_lines)} line segments...")
-            
-            def find_endpoints(lines):
-                """Get all endpoints of the lines with their indices"""
-                endpoints = []
-                for i, line in enumerate(lines):
-                    coords = list(line.coords)
-                    endpoints.append((coords[0], i, 'start'))
-                    endpoints.append((coords[-1], i, 'end'))
-                return endpoints
-            
-            def find_nearby_points(point1, point2, tolerance=0.01):
-                """Check if two points are within tolerance distance"""
-                return (abs(point1[0] - point2[0]) <= tolerance and 
-                       abs(point1[1] - point2[1]) <= tolerance)
-            
-            def find_gaps(lines, tolerance=0.01):
-                """Find gaps between line endpoints"""
-                logger.info("Analyzing line endpoints to identify gaps...")
-                endpoints = []
-                for i, line in enumerate(lines):
-                    coords = list(line.coords)
-                    start = coords[0]
-                    end = coords[-1]
-                    endpoints.append({
-                        'point': start,
-                        'line_idx': i,
-                        'position': 'start',
-                        'coords': coords
-                    })
-                    endpoints.append({
-                        'point': end,
-                        'line_idx': i,
-                        'position': 'end',
-                        'coords': coords
+                    # Update frontiers for the next iteration
+                    fluvial_frontier = newly_fluvial
+                    pluvial_frontier = newly_pluvial
+                                        
+                    pbar.update(1)
+                    pbar.set_postfix({
+                        "Fluvial": len(fluvial_frontier), 
+                        "Pluvial": len(pluvial_frontier),
+                        "Ambiguous": len(ambiguous_cells)
                     })
-                
-                logger.info(f"Found {len(endpoints)} endpoints to analyze")
-                gaps = []
-                
-                # Compare each endpoint with all others
-                for i, ep1 in enumerate(endpoints):
-                    for ep2 in endpoints[i+1:]:
-                        # Skip if endpoints are from same line
-                        if ep1['line_idx'] == ep2['line_idx']:
-                            continue
-                            
-                        point1 = ep1['point']
-                        point2 = ep2['point']
-                        
-                        # Skip if points are too close (already connected)
-                        if find_nearby_points(point1, point2):
-                            continue
-                            
-                        # Check if this could be a gap
-                        dist = LineString([point1, point2]).length
-                        if dist < 10.0:  # Maximum gap distance threshold
-                            gaps.append({
-                                'start': ep1,
-                                'end': ep2,
-                                'distance': dist
-                            })
-                
-                logger.info(f"Identified {len(gaps)} potential gaps to fill")
-                return sorted(gaps, key=lambda x: x['distance'])
-
-            def join_lines_with_gap(line1_coords, line2_coords, gap_start_pos, gap_end_pos):
-                """Join two lines maintaining correct point order based on gap positions"""
-                if gap_start_pos == 'end' and gap_end_pos == 'start':
-                    # line1 end connects to line2 start
-                    return line1_coords + line2_coords
-                elif gap_start_pos == 'start' and gap_end_pos == 'end':
-                    # line1 start connects to line2 end
-                    return list(reversed(line2_coords)) + line1_coords
-                elif gap_start_pos == 'end' and gap_end_pos == 'end':
-                    # line1 end connects to line2 end
-                    return line1_coords + list(reversed(line2_coords))
-                else:  # start to start
-                    # line1 start connects to line2 start
-                    return list(reversed(line1_coords)) + line2_coords
-
-            # Process gaps and join lines
-            processed_lines = joined_lines.copy()
-            line_groups = [[i] for i in range(len(processed_lines))]
-            gaps = find_gaps(processed_lines)
             
-            filled_gap_count = 0
-            for gap_idx, gap in enumerate(gaps, 1):
-                logger.info(f"Processing gap {gap_idx}/{len(gaps)} (distance: {gap['distance']:.3f})")
-                
-                line1_idx = gap['start']['line_idx']
-                line2_idx = gap['end']['line_idx']
-                
-                # Find the groups containing these lines
-                group1 = next(g for g in line_groups if line1_idx in g)
-                group2 = next(g for g in line_groups if line2_idx in g)
-                
-                # Skip if lines are already in the same group
-                if group1 == group2:
-                    continue
-                
-                # Get the coordinates for both lines
-                line1_coords = gap['start']['coords']
-                line2_coords = gap['end']['coords']
-                
-                # Join the lines in correct order
-                joined_coords = join_lines_with_gap(
-                    line1_coords,
-                    line2_coords,
-                    gap['start']['position'],
-                    gap['end']['position']
-                )
-                
-                # Create new joined line
-                new_line = LineString(joined_coords)
-                
-                # Update processed_lines and line_groups
-                new_idx = len(processed_lines)
-                processed_lines.append(new_line)
-                
-                # Merge groups and remove old ones
-                new_group = group1 + group2
-                line_groups.remove(group1)
-                line_groups.remove(group2)
-                line_groups.append(new_group + [new_idx])
-                
-                filled_gap_count += 1
-                logger.info(f"Successfully joined lines {line1_idx} and {line2_idx}")
+            logger.info(f"Region growing completed in {iteration} iterations.")
             
-            logger.info(f"Gap filling complete. Filled {filled_gap_count} out of {len(gaps)} gaps")
+            # --- 4. Finalization and Dissolving ---
+            # Classify any remaining unclassified (likely isolated) cells as ambiguous
+            classifications[classifications == 'unclassified'] = 'ambiguous'
+
+            logger.info("Merging classifications with cell polygons...")
+            classified_gdf = cell_polygons_gdf.merge(classifications.to_frame(), left_on='cell_id', right_index=True)
             
-            # Get final lines (take the last line from each group)
-            final_lines = [processed_lines[group[-1]] for group in line_groups]
+            logger.info("Dissolving polygons by classification...")
+            final_regions_gdf = classified_gdf.dissolve(by='classification', aggfunc='first').reset_index()
+
+            # --- 5. Minimum Polygon Area Filtering and Merging (if requested) ---
+            if min_polygon_area_acres is not None:
+                logger.info(f"Applying minimum polygon area filter: {min_polygon_area_acres} acres")
+                # Calculate area in acres (1 acre = 4046.8564224 m^2)
+                # If CRS is not projected, warn and skip area filtering
+                if not final_regions_gdf.crs or not final_regions_gdf.crs.is_projected:
+                    logger.warning("CRS is not projected. Area-based filtering skipped.")
+                else:
+                    # Explode to individual polygons for area filtering
+                    exploded = final_regions_gdf.explode(index_parts=False, ignore_index=True)
+                    exploded['area_acres'] = exploded.geometry.area / 4046.8564224
+
+                    # Only consider fluvial and pluvial polygons for area filtering
+                    mask_fluvial = (exploded['classification'] == 'fluvial') & (exploded['area_acres'] < min_polygon_area_acres)
+                    mask_pluvial = (exploded['classification'] == 'pluvial') & (exploded['area_acres'] < min_polygon_area_acres)
+
+                    n_fluvial = mask_fluvial.sum()
+                    n_pluvial = mask_pluvial.sum()
+                    logger.info(f"Found {n_fluvial} small fluvial and {n_pluvial} small pluvial polygons to reclassify.")
+
+                    # Reclassify small fluvial polygons as pluvial, and small pluvial polygons as fluvial
+                    exploded.loc[mask_fluvial, 'classification'] = 'pluvial'
+                    exploded.loc[mask_pluvial, 'classification'] = 'fluvial'
+                    # Ambiguous polygons are not changed
+
+                    # Redissolve by classification to merge with adjacent polygons of the same type
+                    final_regions_gdf = exploded.dissolve(by='classification', aggfunc='first').reset_index()
+                    logger.info("Redissolved polygons after reclassification of small areas.")
+
+            logger.info("Polygon generation completed successfully.")
+            return final_regions_gdf
             
-            logger.info(f"Final cleanup complete. Resulting in {len(final_lines)} line segments")
-            joined_lines = final_lines
-
-            # 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
+            logger.error(f"Error generating fluvial-pluvial polygons: {str(e)}", exc_info=True)
+            return gpd.GeoDataFrame()
         
         
     @staticmethod
     def _process_cell_adjacencies(cell_polygons_gdf: gpd.GeoDataFrame) -> Tuple[Dict[int, List[int]], Dict[int, Dict[int, LineString]]]:
         """
         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.
-
-        Returns:
-            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.
         """
         cell_adjacency = defaultdict(list)
         common_edges = defaultdict(dict)
-
-        # 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():
+        for _, 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)
+            for i in range(len(coords) - 1):
+                key = edge_key(coords[i], coords[i + 1])
                 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
+            cell_list = list(cells)
+            if len(cell_list) >= 2:
+                for i in range(len(cell_list)):
+                    for j in range(i + 1, len(cell_list)):
+                        cell1, cell2 = cell_list[i], cell_list[j]
+                        cell_adjacency[cell1].append(cell2)
+                        cell_adjacency[cell2].append(cell1)
                         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 _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]:
+    def _get_boundary_cell_pairs(
+        cell_adjacency: Dict[int, List[int]], 
+        cell_times: Dict[int, pd.Timestamp], 
+        delta_t: float
+    ) -> List[Tuple[int, int]]:
         """
-        Identify boundary edges between cells with significant time differences.
+        Identifies pairs of adjacent cell IDs that form a boundary.
 
+        A boundary is defined where the difference in max water surface time
+        between two adjacent cells is greater than delta_t.
+        
         Args:
-            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
+            cell_adjacency (Dict[int, List[int]]): Dictionary of cell adjacencies.
+            cell_times (Dict[int, pd.Timestamp]): Dictionary mapping cell IDs to their max WSE times.
+            delta_t (float): Time threshold in hours.
 
         Returns:
-            List[LineString]: List of LineString geometries representing boundaries
+            List[Tuple[int, int]]: A list of tuples, where each tuple contains a pair of
+                                   cell IDs forming a boundary.
         """
-        # Validate cell_times data
-        valid_times = {k: v for k, v in cell_times.items() if pd.notna(v)}
-        if len(valid_times) < len(cell_times):
-            logger.warning(f"Found {len(cell_times) - len(valid_times)} cells with invalid timestamps")
-            cell_times = valid_times
-
-        # Use a set to store processed cell pairs and avoid duplicates
+        boundary_cell_pairs = []
         processed_pairs = set()
-        boundary_edges = []
-        
-        # Track time differences for debugging
-        time_diffs = []
+        delta_t_seconds = delta_t * 3600
 
-        with tqdm(total=len(cell_adjacency), desc="Processing cell adjacencies") as pbar:
-            for cell_id, neighbors in cell_adjacency.items():
-                if cell_id not in cell_times:
-                    logger.debug(f"Skipping cell {cell_id} - no timestamp data")
-                    pbar.update(1)
+        for cell_id, neighbors in cell_adjacency.items():
+            time1 = cell_times.get(cell_id)
+            if not pd.notna(time1):
+                continue
+
+            for neighbor_id in neighbors:
+                pair = tuple(sorted((cell_id, neighbor_id)))
+                if pair in processed_pairs:
                     continue
-                    
-                cell_time = cell_times[cell_id]
 
-                for neighbor_id in neighbors:
-                    if neighbor_id not in cell_times:
-                        logger.debug(f"Skipping neighbor {neighbor_id} of cell {cell_id} - no timestamp data")
-                        continue
-                        
-                    # Create a sorted tuple of the cell pair to ensure uniqueness
-                    cell_pair = tuple(sorted([cell_id, neighbor_id]))
-                    
-                    # Skip if we've already processed this pair
-                    if cell_pair in processed_pairs:
-                        continue
-                        
-                    neighbor_time = cell_times[neighbor_id]
-                    
-                    # Ensure both timestamps are valid
-                    if pd.isna(cell_time) or pd.isna(neighbor_time):
-                        continue
-                    
-                    # Calculate time difference in hours
-                    time_diff = abs((cell_time - neighbor_time).total_seconds() / 3600)
-                    time_diffs.append(time_diff)
-                    
-                    logger.debug(f"Time difference between cells {cell_id} and {neighbor_id}: {time_diff:.2f} hours")
+                time2 = cell_times.get(neighbor_id)
+                if not pd.notna(time2):
+                    continue
+                
+                time_diff = abs((time1 - time2).total_seconds())
 
-                    if time_diff >= delta_t:
-                        logger.debug(f"Found boundary edge between cells {cell_id} and {neighbor_id} "
-                                   f"(time diff: {time_diff:.2f} hours)")
-                        boundary_edges.append(common_edges[cell_id][neighbor_id])
-                    
-                    # Mark this pair as processed
-                    processed_pairs.add(cell_pair)
+                if time_diff >= delta_t_seconds:
+                    boundary_cell_pairs.append(pair)
+                
+                processed_pairs.add(pair)
+        
+        return boundary_cell_pairs
+
+    @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,
+        min_line_length: Optional[float] = None
+    ) -> List[LineString]:
+        """
+        Identify boundary edges between cells with significant time differences.
+        
+        This function now uses the helper `_get_boundary_cell_pairs`.
 
-                pbar.update(1)
+        Args:
+            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.
+            min_line_length (float, optional): Minimum length (in CRS units) for boundary lines to be included.
+                                               Lines shorter than this will be dropped. Default is None (no filtering).
+
+        Returns:
+            List[LineString]: List of LineString geometries representing boundaries.
+        """
+        boundary_pairs = HdfFluvialPluvial._get_boundary_cell_pairs(cell_adjacency, cell_times, delta_t)
+        
+        boundary_edges = [common_edges[c1][c2] for c1, c2 in boundary_pairs]
+        
+        logger.info(f"Identified {len(boundary_edges)} boundary edges using delta_t of {delta_t} hours.")
 
-        # Log summary statistics
-        if time_diffs:
-            logger.info(f"Time difference statistics:")
-            logger.info(f"  Min: {min(time_diffs):.2f} hours")
-            logger.info(f"  Max: {max(time_diffs):.2f} hours")
-            logger.info(f"  Mean: {sum(time_diffs)/len(time_diffs):.2f} hours")
-            logger.info(f"  Number of boundaries found: {len(boundary_edges)}")
-            logger.info(f"  Delta-t threshold: {delta_t} hours")
+        if min_line_length is not None:
+            filtered_edges = [edge for edge in boundary_edges if edge.length >= min_line_length]
+            num_dropped = len(boundary_edges) - len(filtered_edges)
+            if num_dropped > 0:
+                logger.info(f"{num_dropped} boundary line(s) shorter than {min_line_length} units were dropped after filtering.")
+            boundary_edges = filtered_edges
 
-        return boundary_edges
+        return boundary_edges

ras_commander/HdfResultsMesh.py

@@ -42,22 +42,6 @@ HdfUtils for common operations. Methods use @log_call decorator for logging and
 
 
 
-REVISIONS MADE:
-
-Use get_ prefix for functions that return data.  
-BUT, we will never set results data, so we should use get_ for results data.
-
-Renamed functions:
-- mesh_summary_output() to get_mesh_summary()
-- mesh_timeseries_output() to get_mesh_timeseries()
-- mesh_faces_timeseries_output() to get_mesh_faces_timeseries()
-- mesh_cells_timeseries_output() to get_mesh_cells_timeseries()
-- mesh_last_iter() to get_mesh_last_iter()
-- mesh_max_ws() to get_mesh_max_ws()
-
-
-
-
 
 
 

ras_commander/__init__.py

@@ -10,7 +10,7 @@ try:
     __version__ = version("ras-commander")
 except PackageNotFoundError:
     # package is not installed
-    __version__ = "0.77.0"
+    __version__ = "0.79.0"
 
 # Set up logging
 setup_logging()

{ras_commander-0.78.0.dist-info → ras_commander-0.79.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.78.0
+Version: 0.79.0
 Summary: A Python library for automating HEC-RAS 6.x operations
 Home-page: https://github.com/gpt-cmdr/ras-commander
 Author: William M. Katzenmeyer, P.E., C.F.M.

{ras_commander-0.78.0.dist-info → ras_commander-0.79.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 ras_commander/Decorators.py,sha256=oJHZqwhw1H3Gy-m-mT4zyJ-LTH9b4Ick1hzgkMO-MEM,14783
 ras_commander/HdfBase.py,sha256=Jws6Y8JFkharuiM6Br5ivp6MS64X2fL6y87FOpe3FQw,14219
 ras_commander/HdfBndry.py,sha256=FBNFoTz4sXVB-MOsbHJBP8P0dMqJUfBROloKTaxmzCo,16377
-ras_commander/HdfFluvialPluvial.py,sha256=dlqoFX5i7uSA2BvuRNrV-Fg-z2JaeUxY86_fbZAdGqI,25933
+ras_commander/HdfFluvialPluvial.py,sha256=Go-rogUjF0O9Vjbmh7g1bh9QJfIephQD-nHTiDhx9l8,20824
 ras_commander/HdfInfiltration.py,sha256=n42JY__hTLZzEnsf4NDgKXssrNU2zkYzdPAAQ19fWU4,67700
 ras_commander/HdfMesh.py,sha256=zI_4AqxDxb2_31G9RUmWibyld6KDMGhDpI3F8qwzVAw,19139
 ras_commander/HdfPipe.py,sha256=m-yvPL2GIP23NKt2tcwzOlS7khvgcDPGAshlTPMUAeI,32154
 ras_commander/HdfPlan.py,sha256=WINI3lp865cE99QXztgvKKIhVUTOqu4X41ZPBfhYJGU,12145
 ras_commander/HdfPlot.py,sha256=7MNI5T9qIz-Ava1RdlnB6O9oJElE5BEB29QVF5Y2Xuc,3401
 ras_commander/HdfPump.py,sha256=Vc2ff16kRISR7jwtnaAqxI0p-gfBSuZKzR3rQbBLQoE,12951
-ras_commander/HdfResultsMesh.py,sha256=MKnSJxcWVDccHaRRGgAK0szm7B-VtrKBtgL1Uz0kAiw,44662
+ras_commander/HdfResultsMesh.py,sha256=FIUN_yZ6h1XrcaHuOdAQrozOBN_UKNNn3_l8lO703dk,44172
 ras_commander/HdfResultsPlan.py,sha256=gmeAceYHABubv0V8dJL2F5GN4Th7g92E_1y-Hc4JZjg,16626
 ras_commander/HdfResultsPlot.py,sha256=ylzfT78CfgoDO0XAlRwlgMNRzvNQYBMn9eyXyBfjv_w,7660
 ras_commander/HdfResultsXsec.py,sha256=-P7nXnbjOLAeUnrdSC_lJQSfzrlWKmDF9Z5gEjmxbJY,13031
@@ -24,9 +24,9 @@ ras_commander/RasPlan.py,sha256=ogIpLqawXTsjLnKRZTqzZydn_EFVJZFZZGgHvJ_t_-c,6540
 ras_commander/RasPrj.py,sha256=oXPWuNC_403mUfqyysXyBVul0Xtz_0SKDxZdj4fvNYU,63448
 ras_commander/RasUnsteady.py,sha256=TO08CT2GC4G5rcXO_Wbia2t4PhiWRu9-nC9F0IW7Gyo,37187
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
-ras_commander/__init__.py,sha256=byL-4pG2AwLeZXa1nFd3srZe9Pu96V52Y5Dujcu3mM8,2039
-ras_commander-0.78.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.78.0.dist-info/METADATA,sha256=-AIKb7auKcOkGb6vDogfaKr4eCdhFZIrml4kPiZbpcM,27855
-ras_commander-0.78.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ras_commander-0.78.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.78.0.dist-info/RECORD,,
+ras_commander/__init__.py,sha256=sd0ei6EQBUoBKiP8DQZfwhUXY1Wr4r4ubEKKqaCAIlI,2039
+ras_commander-0.79.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.79.0.dist-info/METADATA,sha256=aNL6rjWX_mmG2XIBXLu6QubymBPoXRJPlbwPAP1jT_0,27855
+ras_commander-0.79.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ras_commander-0.79.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.79.0.dist-info/RECORD,,