rashdf 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

cli.py

@@ -1,6 +1,6 @@
 """rashdf CLI."""
 
-from rashdf import RasGeomHdf
+from rashdf import RasGeomHdf, RasPlanHdf
 from rashdf.utils import df_datetimes_to_str
 
 import fiona
@@ -10,6 +10,7 @@ import argparse
 from ast import literal_eval
 from pathlib import Path
 import sys
+import re
 from typing import List, Optional
 import warnings
 
@@ -108,17 +109,22 @@ def export(args: argparse.Namespace) -> Optional[str]:
         for driver in fiona_supported_drivers():
             print(driver)
         return
-    if "://" in args.hdf_file:
-        geom_hdf = RasGeomHdf.open_uri(args.hdf_file)
+    if re.match(r"^.*\.p\d\d\.hdf$", args.hdf_file):
+        ras_hdf_class = RasPlanHdf
     else:
-        geom_hdf = RasGeomHdf(args.hdf_file)
+        ras_hdf_class = RasGeomHdf
+    if re.match(r"^\w+://", args.hdf_file):
+        geom_hdf = ras_hdf_class.open_uri(args.hdf_file)
+    else:
+        geom_hdf = ras_hdf_class(args.hdf_file)
     func = getattr(geom_hdf, args.func)
     gdf: GeoDataFrame = func()
     kwargs = literal_eval(args.kwargs) if args.kwargs else {}
     if args.to_crs:
         gdf = gdf.to_crs(args.to_crs)
     if not args.output_file:
-        # convert any datetime columns to strings
+        # If an output file path isn't provided, write the GeoDataFrame to stdout
+        # as GeoJSON. Convert any datetime columns to strings.
         gdf = df_datetimes_to_str(gdf)
         with warnings.catch_warnings():
             # Squash warnings about converting the CRS to OGC URN format.
@@ -143,9 +149,9 @@ def export(args: argparse.Namespace) -> Optional[str]:
     output_file_path = Path(args.output_file)
     output_file_ext = output_file_path.suffix
     if output_file_ext not in [".gpkg"]:
-        # unless the user specifies a format that supports datetime,
-        # convert any datetime columns to string
-        # TODO: besides Geopackage, which of the standard Fiona formats allow datetime?
+        # Unless the user specifies a format that supports datetime,
+        # convert any datetime columns to string.
+        # TODO: besides Geopackage, which of the standard Fiona drivers allow datetime?
         gdf = df_datetimes_to_str(gdf)
     gdf.to_file(args.output_file, **kwargs)
 

rashdf/geom.py

@@ -1,27 +1,27 @@
 """HEC-RAS Geometry HDF class."""
 
-from .base import RasHdf
-from .utils import (
-    convert_ras_hdf_string,
-    get_first_hdf_group,
-    hdf5_attrs_to_dict,
-    convert_ras_hdf_value,
-)
+from typing import Dict, List, Optional
 
 import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from pyproj import CRS
 from shapely import (
-    Polygon,
-    Point,
     LineString,
     MultiLineString,
     MultiPolygon,
+    Point,
+    Polygon,
     polygonize_full,
 )
 
-from typing import Dict, List, Optional
+from .base import RasHdf
+from .utils import (
+    convert_ras_hdf_string,
+    convert_ras_hdf_value,
+    get_first_hdf_group,
+    hdf5_attrs_to_dict,
+)
 
 
 class RasGeomHdf(RasHdf):
@@ -66,12 +66,12 @@ class RasGeomHdf(RasHdf):
         List[str]
             A list of the 2D mesh area names (str) within the RAS geometry if 2D areas exist.
         """
-        if "/Geometry/2D Flow Areas" not in self:
+        if self.FLOW_AREA_2D_PATH not in self:
             return list()
         return list(
             [
                 convert_ras_hdf_string(n)
-                for n in self["/Geometry/2D Flow Areas/Attributes"][()]["Name"]
+                for n in self[f"{self.FLOW_AREA_2D_PATH}/Attributes"][()]["Name"]
             ]
         )
 
@@ -87,7 +87,7 @@ class RasGeomHdf(RasHdf):
         if not mesh_area_names:
             return GeoDataFrame()
         mesh_area_polygons = [
-            Polygon(self[f"/Geometry/2D Flow Areas/{n}/Perimeter"][()])
+            Polygon(self[f"{self.FLOW_AREA_2D_PATH}/{n}/Perimeter"][()])
             for n in mesh_area_names
         ]
         return GeoDataFrame(
@@ -112,13 +112,13 @@ class RasGeomHdf(RasHdf):
 
         cell_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
         for i, mesh_name in enumerate(mesh_area_names):
-            cell_cnt = self["/Geometry/2D Flow Areas/Cell Info"][()][i][1]
+            cell_cnt = self[f"{self.FLOW_AREA_2D_PATH}/Cell Info"][()][i][1]
             cell_ids = list(range(cell_cnt))
             cell_face_info = self[
-                f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Info"
+                f"{self.FLOW_AREA_2D_PATH}/{mesh_name}/Cells Face and Orientation Info"
             ][()]
             cell_face_values = self[
-                f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Values"
+                f"{self.FLOW_AREA_2D_PATH}/{mesh_name}/Cells Face and Orientation Values"
             ][()][:, 0]
             face_id_lists = list(
                 np.vectorize(
@@ -169,8 +169,8 @@ class RasGeomHdf(RasHdf):
             return GeoDataFrame()
         pnt_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
         for i, mesh_name in enumerate(mesh_area_names):
-            starting_row, count = self["/Geometry/2D Flow Areas/Cell Info"][()][i]
-            cell_pnt_coords = self["/Geometry/2D Flow Areas/Cell Points"][()][
+            starting_row, count = self[f"{self.FLOW_AREA_2D_PATH}/Cell Info"][()][i]
+            cell_pnt_coords = self[f"{self.FLOW_AREA_2D_PATH}/Cell Points"][()][
                 starting_row : starting_row + count
             ]
             pnt_dict["mesh_name"] += [mesh_name] * cell_pnt_coords.shape[0]
@@ -196,16 +196,16 @@ class RasGeomHdf(RasHdf):
         face_dict = {"mesh_name": [], "face_id": [], "geometry": []}
         for mesh_name in mesh_area_names:
             facepoints_index = self[
-                f"/Geometry/2D Flow Areas/{mesh_name}/Faces FacePoint Indexes"
+                f"{self.FLOW_AREA_2D_PATH}/{mesh_name}/Faces FacePoint Indexes"
             ][()]
             facepoints_coordinates = self[
-                f"/Geometry/2D Flow Areas/{mesh_name}/FacePoints Coordinate"
+                f"{self.FLOW_AREA_2D_PATH}/{mesh_name}/FacePoints Coordinate"
             ][()]
             faces_perimeter_info = self[
-                f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Info"
+                f"{self.FLOW_AREA_2D_PATH}/{mesh_name}/Faces Perimeter Info"
             ][()]
             faces_perimeter_values = self[
-                f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Values"
+                f"{self.FLOW_AREA_2D_PATH}/{mesh_name}/Faces Perimeter Values"
             ][()]
             face_id = -1
             for pnt_a_index, pnt_b_index in facepoints_index:
@@ -465,11 +465,97 @@ class RasGeomHdf(RasHdf):
     def terrain_modifications(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
-    def cross_sections(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+    def cross_sections(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """Return the model 1D cross sections.
 
-    def river_reaches(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the model 1D cross sections if they exist.
+        """
+        if "/Geometry/Cross Sections" not in self:
+            return GeoDataFrame()
+
+        xs_data = self["/Geometry/Cross Sections"]
+        v_conv_val = np.vectorize(convert_ras_hdf_value)
+        xs_attrs = xs_data["Attributes"][()]
+        xs_dict = {"xs_id": range(xs_attrs.shape[0])}
+        xs_dict.update(
+            {name: v_conv_val(xs_attrs[name]) for name in xs_attrs.dtype.names}
+        )
+        geoms = list()
+        for pnt_start, pnt_cnt, part_start, part_cnt in xs_data["Polyline Info"][()]:
+            points = xs_data["Polyline Points"][()][pnt_start : pnt_start + pnt_cnt]
+            if part_cnt == 1:
+                geoms.append(LineString(points))
+            else:
+                parts = xs_data["Polyline Parts"][()][
+                    part_start : part_start + part_cnt
+                ]
+                geoms.append(
+                    MultiLineString(
+                        list(
+                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                            for part_pnt_start, part_pnt_cnt in parts
+                        )
+                    )
+                )
+        xs_gdf = GeoDataFrame(
+            xs_dict,
+            geometry=geoms,
+            crs=self.projection(),
+        )
+        if datetime_to_str:
+            xs_gdf["Last Edited"] = xs_gdf["Last Edited"].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+        return xs_gdf
+
+    def river_reaches(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """Return the model 1D river reach lines.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the model 1D river reach lines if they exist.
+        """
+        if "/Geometry/River Centerlines" not in self:
+            return GeoDataFrame()
+
+        river_data = self["/Geometry/River Centerlines"]
+        v_conv_val = np.vectorize(convert_ras_hdf_value)
+        river_attrs = river_data["Attributes"][()]
+        river_dict = {"river_id": range(river_attrs.shape[0])}
+        river_dict.update(
+            {name: v_conv_val(river_attrs[name]) for name in river_attrs.dtype.names}
+        )
+        geoms = list()
+        for pnt_start, pnt_cnt, part_start, part_cnt in river_data["Polyline Info"][()]:
+            points = river_data["Polyline Points"][()][pnt_start : pnt_start + pnt_cnt]
+            if part_cnt == 1:
+                geoms.append(LineString(points))
+            else:
+                parts = river_data["Polyline Parts"][()][
+                    part_start : part_start + part_cnt
+                ]
+                geoms.append(
+                    MultiLineString(
+                        list(
+                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                            for part_pnt_start, part_pnt_cnt in parts
+                        )
+                    )
+                )
+        river_gdf = GeoDataFrame(
+            river_dict,
+            geometry=geoms,
+            crs=self.projection(),
+        )
+        if datetime_to_str:
+            river_gdf["Last Edited"] = river_gdf["Last Edited"].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+        return river_gdf
 
     def flowpaths(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
@@ -488,3 +574,33 @@ class RasGeomHdf(RasHdf):
 
     def blocked_obstructions(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
+
+    def cross_sections_elevations(self, round_to: int = 2) -> pd.DataFrame:
+        """Return the model cross section elevation information.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the model cross section elevation information if they exist.
+        """
+        path = "/Geometry/Cross Sections"
+        if path not in self:
+            return pd.DataFrame()
+
+        xselev_data = self[path]
+        xs_df = self.cross_sections()
+        elevations = list()
+        for part_start, part_cnt in xselev_data["Station Elevation Info"][()]:
+            xzdata = xselev_data["Station Elevation Values"][()][
+                part_start : part_start + part_cnt
+            ]
+            elevations.append(xzdata)
+
+        xs_elev_df = xs_df[
+            ["xs_id", "River", "Reach", "RS", "Left Bank", "Right Bank"]
+        ].copy()
+        xs_elev_df["Left Bank"] = xs_elev_df["Left Bank"].round(round_to).astype(str)
+        xs_elev_df["Right Bank"] = xs_elev_df["Right Bank"].round(round_to).astype(str)
+        xs_elev_df["elevation info"] = elevations
+
+        return xs_elev_df