rashdf 0.8.4__tar.gz → 0.10.0__tar.gz

{rashdf-0.8.4 → rashdf-0.10.0}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.4
+Version: 0.10.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py

{rashdf-0.8.4 → rashdf-0.10.0}/pyproject.toml

@@ -7,12 +7,12 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
-version = "0.8.4"
+version = "0.10.0"
 dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray<=2025.4.0"]
 
 [project.optional-dependencies]

{rashdf-0.8.4 → rashdf-0.10.0}/src/cli.py

@@ -26,6 +26,7 @@ COMMANDS = [
     "reference_lines",
     "reference_points",
     "structures",
+    "generate_bridge_xs_lines",
 ]
 
 

{rashdf-0.8.4 → rashdf-0.10.0}/src/rashdf/geom.py

@@ -27,6 +27,8 @@ from .utils import (
     convert_ras_hdf_value,
     get_first_hdf_group,
     hdf5_attrs_to_dict,
+    copy_lines_parallel,
+    experimental,
 )
 
 
@@ -474,6 +476,67 @@ class RasGeomHdf(RasHdf):
     def connections(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
+    @experimental
+    def generate_bridge_xs_lines(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """[EXPERIMENTAL] Attempt to return the 2D bridge cross-section lines.
+
+        This method attempts to generate the cross-section lines for bridges modeled
+        within 2D mesh areas. It should be noted that these lines are not explicitly
+        stored within the HEC-RAS Geometry HDF file, and are instead generated based
+        on the bridge attributes and centerline geometry. As such, the accuracy of
+        these lines may vary depending on the complexity of the bridge geometry and
+        output from this method should be reviewed for accuracy.
+
+        Parameters
+        ----------
+        datetime_to_str : bool, optional
+            If True, convert datetime values to string format (default: False).
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D bridge cross-section lines if they exist.
+        """
+        profile_info = self.get(self.GEOM_STRUCTURES_PATH + "/Table Info")
+        structs = self.structures().merge(
+            pd.DataFrame(profile_info[()] if profile_info is not None else None),
+            left_index=True,
+            right_index=True,
+        )
+        if structs.empty:
+            return GeoDataFrame()
+
+        bridges = structs[structs["Mode"] == "Bridge Opening"].copy()
+        if bridges.empty:
+            return GeoDataFrame()
+
+        inside_buffer_widths = bridges["Weir Width"] / 2
+        inside_bridge_xs = copy_lines_parallel(
+            bridges, inside_buffer_widths.values, "struct_id"
+        )
+        inside_bridge_xs["level"] = "inside"
+
+        outside_buffer_widths = inside_buffer_widths + bridges["Upstream Distance"]
+        outside_bridge_xs = copy_lines_parallel(
+            bridges, outside_buffer_widths.values, "struct_id"
+        )
+        outside_bridge_xs["level"] = "outside"
+
+        br_xs = GeoDataFrame(
+            pd.concat([inside_bridge_xs, outside_bridge_xs], ignore_index=True),
+            geometry="geometry",
+        )
+        br_xs.side = br_xs.side.apply(
+            lambda x: "upstream" if x == "right" else "downstream"
+        )
+
+        if datetime_to_str:
+            br_xs[self.LAST_EDITED_COLUMN] = br_xs[self.LAST_EDITED_COLUMN].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+
+        return br_xs
+
     def ic_points(self) -> GeoDataFrame:  # noqa D102
         """Return initial conditions points.
 

{rashdf-0.8.4 → rashdf-0.10.0}/src/rashdf/plan.py

@@ -1178,7 +1178,7 @@ class RasPlanHdf(RasGeomHdf):
         xr.Dataset
             An xarray Dataset with timeseries output data for boundary conditions lines.
         """
-        df_bc_lines = self.bc_lines()
+        df_bc_lines = super().bc_lines()
         bc_lines_names = df_bc_lines["name"]
         datasets = []
         for bc_line_name in bc_lines_names:
@@ -1197,6 +1197,57 @@ class RasPlanHdf(RasGeomHdf):
         )
         return ds
 
+    def bc_lines(
+        self, include_output: bool = True, datetime_to_str: bool = False
+    ) -> GeoDataFrame:
+        """Return the boundary condition lines from a HEC-RAS HDF plan file.
+
+        Optionally include summary output data for each boundary condition line.
+
+        Parameters
+        ----------
+        include_output : bool, optional
+            If True, include summary output data in the GeoDataFrame. (default: True)
+        datetime_to_str : bool, optional
+            If True, convert datetime columns to strings. (default: False)
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame with boundary condition line geometry and summary output data.
+        """
+        gdf = super().bc_lines()
+        if include_output is False:
+            return gdf
+
+        ds = self.bc_lines_timeseries_output()
+        summary = {
+            "bc_line_id": ds.coords["bc_line_id"].values,
+            "name": ds.coords["bc_line_name"].values,
+            "mesh_name": ds.coords["mesh_name"].values,
+            "type": ds.coords["bc_line_type"].values,
+        }
+
+        for var in ds.data_vars:
+            abbrev = "q" if var.lower() == "flow" else "ws"
+            summary[f"max_{abbrev}"] = ds[var].max(dim="time").values
+            summary[f"max_{abbrev}_time"] = (
+                ds[var].time[ds[var].argmax(dim="time")].values
+            )
+            summary[f"min_{abbrev}"] = ds[var].min(dim="time").values
+            summary[f"min_{abbrev}_time"] = (
+                ds[var].time[ds[var].argmin(dim="time")].values
+            )
+
+        gdf_with_output = gdf.merge(
+            pd.DataFrame(summary),
+            on=["bc_line_id", "name", "mesh_name", "type"],
+            how="left",
+        )
+        return (
+            df_datetimes_to_str(gdf_with_output) if datetime_to_str else gdf_with_output
+        )
+
     def observed_timeseries_input(self, vartype: str = "Flow") -> xr.DataArray:
         """Return observed timeseries input data for reference lines and points from a HEC-RAS HDF plan file.
 
@@ -1728,3 +1779,151 @@ class RasPlanHdf(RasGeomHdf):
         """
         ds = self.reference_points_timeseries_output()
         return self._zmeta(ds)
+
+    def reference_lines_flow(self, use_names: bool = False) -> DataFrame:
+        """Return wide-format DataFrame for reference lines timeseries flow data.
+
+        Parameters
+        ----------
+        use_names : bool, optional
+            (Default) If False, use reference line IDs as column headers.
+            If True, use reference line names as column headers.
+
+        Returns
+        -------
+        DataFrame
+            Wide-format DataFrame with time as index and reference line IDs (or names) as columns.
+        """
+        ds = self.reference_lines_timeseries_output()
+        return self._timeseries_to_wide_dataframe(
+            ds=ds,
+            var="Flow",
+            id_column="refln_id",
+            name_column="refln_name",
+            mesh_column="mesh_name",
+            use_names_as_col=use_names,
+        )
+
+    def reference_points_stage(self, use_names: bool = False) -> DataFrame:
+        """Return Wide-format DataFrame for reference points timeseries stage data.
+
+        Parameters
+        ----------
+        use_names : bool, optional
+            (Default) If False, use reference point IDs as column headers.
+            If True, use reference point names as column headers.
+
+        Returns
+        -------
+        DataFrame
+            Wide-format DataFrame with time as index and reference point IDs (or names) as columns.
+        """
+        ds = self.reference_points_timeseries_output()
+        return self._timeseries_to_wide_dataframe(
+            ds=ds,
+            var=WATER_SURFACE,
+            id_column="refpt_id",
+            name_column="refpt_name",
+            mesh_column="mesh_name",
+            use_names_as_col=use_names,
+        )
+
+    def bc_lines_flow(self, use_names: bool = False) -> DataFrame:
+        """Return wide-format DataFrame for boundary condition lines timeseries flow data with.
+
+        Parameters
+        ----------
+        use_names : bool, optional
+            (Default) If False, use BC line IDs as column headers.
+            If True, use BC line names as column headers.
+
+        Returns
+        -------
+        DataFrame
+            Wide-format DataFrame with time as index and BC line IDs (or names) as columns.
+        """
+        ds = self.bc_lines_timeseries_output()
+        return self._timeseries_to_wide_dataframe(
+            ds=ds,
+            var="Flow",
+            id_column="bc_line_id",
+            name_column="bc_line_name",
+            mesh_column="mesh_name",
+            use_names_as_col=use_names,
+        )
+
+    def _timeseries_to_wide_dataframe(
+        self,
+        ds: xr.Dataset,
+        var: str,
+        id_column: str,
+        name_column: str,
+        mesh_column: str,
+        use_names_as_col: bool = False,
+    ) -> DataFrame:
+        """Convert xarray timeseries Dataset to wide-format DataFrame with metadata.
+
+        Parameters
+        ----------
+        ds : xr.Dataset
+            xarray Dataset containing timeseries data
+        var : str
+            Variable name to extract (e.g. "Flow", "Water Surface")
+        id_column : str
+            ID column name for pivoting (e.g. "refln_id", "refpt_id", "bc_line_id")
+        name_column : str
+            Name column for creating readable column names (e.g. "refln_name", "refpt_name")
+        mesh_column : str
+            Mesh column name (e.g. "mesh_name")
+        use_names_as_col : bool, optional
+            (Default) If False, use IDs.
+            If True, use names as column headers.
+
+        Returns
+        -------
+        DataFrame
+            Wide-format DataFrame with time as index and IDs or names as columns.
+            Metadata stored in DataFrame.attrs including name and mesh mappings.
+        """
+        if var not in ds:
+            raise ValueError(f"{var} data not found in timeseries output")
+
+        df = ds[var].to_dataframe().dropna().reset_index()
+
+        # check for duplicate names when using names as columns
+        if use_names_as_col:
+            unique_names = df[name_column].nunique()
+            unique_ids = df[id_column].nunique()
+            if unique_names < unique_ids:  # should have one name for every one id
+                name_counts = (
+                    df[[id_column, name_column]]
+                    .drop_duplicates()[name_column]
+                    .value_counts()
+                )
+                duplicates = name_counts[name_counts > 1].index.tolist()
+                raise ValueError(
+                    f"Cannot use names as columns. The following names are not unique: {duplicates}. "
+                )
+
+        pivot_column = name_column if use_names_as_col else id_column
+        wide_df = df.pivot(index="time", columns=pivot_column, values=var)
+
+        lookup = df[[id_column, name_column, mesh_column]].drop_duplicates()
+        if use_names_as_col:
+            # when using names as columns, key=name -> value=id
+            id_mapping = lookup.set_index(name_column)[id_column].to_dict()
+            mesh_mapping = lookup.set_index(name_column)[mesh_column].to_dict()
+        else:
+            # when using IDs as columns, key=id -> value=name
+            id_mapping = lookup.set_index(id_column)[name_column].to_dict()
+            mesh_mapping = lookup.set_index(id_column)[mesh_column].to_dict()
+
+        wide_df.attrs = {
+            "variable": var,
+            "units": ds[var].attrs.get("units", None),
+            "hdf_path": ds[var].attrs.get("hdf_path", None),
+            "id_mapping": id_mapping,
+            "mesh_mapping": mesh_mapping,
+        }
+
+        return wide_df

{rashdf-0.8.4 → rashdf-0.10.0}/src/rashdf/utils.py

@@ -8,6 +8,38 @@ from datetime import datetime, timedelta
 import re
 from typing import Any, Callable, List, Tuple, Union, Optional
 import warnings
+from shapely import LineString, MultiLineString
+import geopandas as gpd
+
+
+def experimental(func) -> Callable:
+    """
+    Declare a function to be experimental.
+
+    This is a decorator which can be used to mark functions as experimental.
+    It will result in a warning being emitted when the function is used.
+
+    Parameters
+    ----------
+        func: The function to be declared experimental.
+
+    Returns
+    -------
+        The decorated function.
+    """
+
+    def new_func(*args, **kwargs):
+        warnings.warn(
+            f"{func.__name__} is experimental and could change in the future. Please review output carefully.",
+            category=UserWarning,
+            stacklevel=2,
+        )
+        return func(*args, **kwargs)
+
+    new_func.__name__ = func.__name__
+    new_func.__doc__ = func.__doc__
+    new_func.__dict__.update(func.__dict__)
+    return new_func
 
 
 def deprecated(func) -> Callable:
@@ -354,3 +386,131 @@ def ras_timesteps_to_datetimes(
         start_time + pd.Timedelta(timestep, unit=time_unit).round(round_to)
         for timestep in timesteps.astype(np.float64)
     ]
+
+
+def remove_line_ends(
+    geom: Union[LineString, MultiLineString],
+) -> Union[LineString, MultiLineString]:
+    """
+    Remove endpoints from a LineString or each LineString in a MultiLineString if longer than 3 points.
+
+    Parameters
+    ----------
+    geom : LineString or MultiLineString
+        The geometry to trim.
+
+    Returns
+    -------
+    LineString or MultiLineString
+        The trimmed geometry, or original if not enough points to trim.
+    """
+    if isinstance(geom, LineString):
+        coords = list(geom.coords)
+        if len(coords) > 3:
+            return LineString(coords[1:-1])
+        return geom
+    elif isinstance(geom, MultiLineString):
+        trimmed = []
+        for line in geom.geoms:
+            coords = list(line.coords)
+            if len(coords) > 3:
+                trimmed.append(LineString(coords[1:-1]))
+            else:
+                trimmed.append(line)
+        return MultiLineString(trimmed)
+    return geom
+
+
+def reverse_line(
+    line: Union[LineString, MultiLineString],
+) -> Union[LineString, MultiLineString]:
+    """
+    Reverse the order of coordinates in a LineString or each LineString in a MultiLineString.
+
+    Parameters
+    ----------
+    line : LineString or MultiLineString
+        The geometry to reverse.
+
+    Returns
+    -------
+    LineString or MultiLineString
+        The reversed geometry.
+    """
+    return (
+        MultiLineString([LineString(list(line.coords)[::-1]) for line in line.geoms])
+        if isinstance(line, MultiLineString)
+        else LineString(list(line.coords)[::-1])
+    )
+
+
+def copy_lines_parallel(
+    lines: gpd.GeoDataFrame,
+    offset_ft: Union[np.ndarray, float],
+    id_col: str = "id",
+) -> gpd.GeoDataFrame:
+    """
+    Create parallel copies of line geometries offset to the left and right, then trim and erase overlaps.
+
+    Parameters
+    ----------
+    lines : gpd.GeoDataFrame
+        GeoDataFrame containing line geometries.
+    offset_ft : float or np.ndarray
+        Offset distance (in feet) for parallel lines.
+    id_col : str
+        Name of the column containing unique structure IDs. Default is "id".
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame with trimmed, parallel left and right offset lines.
+    """
+    # Offset lines to the left
+    left = lines.copy()
+    offset_ft = offset_ft.astype(float)
+    left.geometry = lines.buffer(
+        offset_ft, cap_style="flat", single_sided=True, resolution=3
+    ).boundary
+    left["side"] = "left"
+
+    # Offset lines to the right (reverse direction first)
+    reversed_lines = lines.copy()
+    reversed_lines.geometry = reversed_lines.geometry.apply(reverse_line)
+    right = lines.copy()
+    right.geometry = reversed_lines.buffer(
+        offset_ft, cap_style="flat", single_sided=True, resolution=3
+    ).boundary.apply(reverse_line)
+    right["side"] = "right"
+
+    # Combine left and right boundaries
+    boundaries = pd.concat([left, right], ignore_index=True)
+    boundaries_gdf = gpd.GeoDataFrame(boundaries, crs=lines.crs, geometry="geometry")
+
+    # Erase buffer caps
+    erase_buffer = 0.1
+    cleaned_list = []
+    eraser = gpd.GeoDataFrame(
+        {
+            id_col: lines[id_col],
+            "geometry": lines.buffer(
+                offset_ft - erase_buffer, cap_style="square", resolution=3
+            ),
+        },
+        crs=lines.crs,
+    )
+    for id in lines[id_col].unique():
+        cleaned_list.append(
+            gpd.overlay(
+                boundaries_gdf[boundaries_gdf[id_col] == id],
+                eraser[eraser[id_col] == id],
+                how="difference",
+            )
+        )
+    cleaned = gpd.GeoDataFrame(
+        pd.concat(cleaned_list, ignore_index=True), crs=lines.crs, geometry="geometry"
+    )
+
+    # trim ends
+    cleaned["geometry"] = cleaned["geometry"].apply(remove_line_ends)
+    return cleaned

{rashdf-0.8.4 → rashdf-0.10.0}/src/rashdf.egg-info/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.4
+Version: 0.10.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py

{rashdf-0.8.4 → rashdf-0.10.0}/tests/test_geom.py

@@ -17,6 +17,7 @@ TEST_JSON = TEST_DATA / "json"
 BALD_EAGLE_P18_REF = TEST_DATA / "ras/BaldEagleDamBrk.reflines-refpts.p18.hdf"
 LOWER_KANAWHA_P01_IC_POINTS = TEST_DATA / "ras/LowerKanawha.p01.icpoints.hdf"
 LOWER_KANAWHA_P01_IC_POINTS_JSON = TEST_JSON / "LowerKanawha.p01.icpoints.geojson"
+ROSEBERRY_G01 = TEST_DATA / "ras/Roseberry_Creek.g01.hdf"
 
 TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
 
@@ -274,3 +275,16 @@ def test_ic_points():
             valid_gdf,
             check_dtype=False,
         )
+
+
+def test_generate_bridge_xs_lines():
+    bridge_xs_json = TEST_JSON / "bridge_xs_lines.json"
+    with RasGeomHdf(ROSEBERRY_G01) as ghdf:
+        assert _gdf_matches_json(
+            ghdf.generate_bridge_xs_lines(datetime_to_str=True), bridge_xs_json
+        )
+
+
+def test_generate_bridge_xs_lines_not_found():
+    with RasGeomHdf(MUNCIE_G05) as ghdf:
+        assert ghdf.generate_bridge_xs_lines().empty

{rashdf-0.8.4 → rashdf-0.10.0}/tests/test_plan.py

@@ -733,3 +733,104 @@ def test_invalid_group_reference_summary_output():
     with RasPlanHdf(BALD_EAGLE_P18) as phdf:
         with pytest.raises(ValueError):
             phdf.reference_summary_output(reftype="Not supported type")
+
+
+def test_bc_lines_include_output_false():
+    bc_lines_json = TEST_JSON / "bc_lines.json"
+    with RasPlanHdf(MUNCIE_G05) as plan_hdf:
+        assert _gdf_matches_json(plan_hdf.bc_lines(include_output=False), bc_lines_json)
+
+
+def test_bc_lines_include_output_true():
+    bc_lines_with_output_json = TEST_JSON / "bc_lines_with_output.json"
+    with RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES) as plan_hdf:
+        assert _gdf_matches_json(
+            plan_hdf.bc_lines(include_output=True, datetime_to_str=True),
+            bc_lines_with_output_json,
+        )
+
+
+def test_reference_lines_flow(tmp_path: Path):
+    plan_hdf = RasPlanHdf(BALD_EAGLE_P18_REF)
+    df = plan_hdf.reference_lines_flow()
+
+    assert df.index.name == "time"
+    assert df.shape == (37, 4)
+    assert list(df.columns) == [0, 1, 2, 3]
+
+    # Check metadata
+    assert df.attrs["variable"] == "Flow"
+    assert df.attrs["units"] == "cfs"
+
+    # Check mappings
+    assert "id_mapping" in df.attrs
+    assert len(df.attrs["id_mapping"]) == 4
+    assert "mesh_mapping" in df.attrs
+    assert len(df.attrs["mesh_mapping"]) == 4
+
+    df_refln2 = df[2].to_frame(name="Flow")
+    valid_df = pd.read_csv(
+        TEST_CSV / "BaldEagleDamBrk.reflines.2.csv",
+        index_col="time",
+        parse_dates=True,
+        usecols=["time", "Flow"],
+        dtype={"Flow": np.float32},
+    )
+    assert_frame_equal(df_refln2, valid_df, check_dtype=False)
+
+
+def test_reference_points_stage(tmp_path: Path):
+    plan_hdf = RasPlanHdf(BALD_EAGLE_P18_REF)
+    df = plan_hdf.reference_points_stage()
+
+    assert df.index.name == "time"
+    assert df.shape == (37, 3)
+    assert list(df.columns) == [0, 1, 2]
+
+    # Check metadata
+    assert df.attrs["variable"] == "Water Surface"
+    assert df.attrs["units"] == "ft"
+
+    # Check mappings
+    assert "id_mapping" in df.attrs
+    assert len(df.attrs["id_mapping"]) == 3
+    assert "mesh_mapping" in df.attrs
+    assert len(df.attrs["mesh_mapping"]) == 3
+
+    df_refpt1 = df[1].to_frame(name="Water Surface")
+    valid_df = pd.read_csv(
+        TEST_CSV / "BaldEagleDamBrk.refpoints.1.csv",
+        index_col="time",
+        parse_dates=True,
+        usecols=["time", "Water Surface"],
+        dtype={"Water Surface": np.float32},
+    )
+    assert_frame_equal(df_refpt1, valid_df, check_dtype=False)
+
+
+def test_bc_lines_flow(tmp_path: Path):
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    df = plan_hdf.bc_lines_flow()
+
+    assert df.index.name == "time"
+    assert df.shape == (577, 10)
+
+    # Check metadata
+    assert df.attrs["variable"] == "Flow"
+    assert df.attrs["units"] == "cfs"
+
+    # Check mappings
+    assert "id_mapping" in df.attrs
+    assert len(df.attrs["id_mapping"]) == 10
+    assert "mesh_mapping" in df.attrs
+    assert len(df.attrs["mesh_mapping"]) == 10
+
+    df_bcline7 = df[7].to_frame(name="Flow")
+    valid_df = pd.read_csv(
+        TEST_CSV / "LowerKanawha.p01.bclines.7.csv",
+        index_col="time",
+        parse_dates=True,
+        usecols=["time", "Flow"],
+        dtype={"Flow": np.float32},
+    )
+    assert_frame_equal(df_bcline7, valid_df, check_dtype=False)

{rashdf-0.8.4 → rashdf-0.10.0}/tests/test_utils.py

@@ -5,6 +5,14 @@ import pandas as pd
 import pytest
 
 from datetime import datetime, timedelta
+from shapely.geometry import LineString, MultiLineString
+import geopandas as gpd
+from pathlib import Path
+
+from . import _assert_geodataframes_close
+
+TEST_DATA = Path("./tests/data")
+TEST_JSON = TEST_DATA / "json"
 
 
 def test_convert_ras_hdf_value():
@@ -117,3 +125,107 @@ def test_parse_ras_datetime_ms():
     assert utils.parse_ras_datetime_ms("15Mar2024 24:00:00.000") == datetime(
         2024, 3, 16, 0, 0, 0, 0
     )
+
+
+def test_trim_line():
+    gdf = gpd.GeoDataFrame(
+        {
+            "id": [1, 2, 3],
+            "geometry": [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString([(0, 0), (5, 5), (10, 10), (15, 15)]),
+                MultiLineString(
+                    [
+                        [(0, 0), (3, 3)],
+                        [(3, 3), (6, 6), (9, 9)],
+                        [(3, 3), (6, 6), (9, 9), (12, 12), (15, 15)],
+                    ]
+                ),
+            ],
+        },
+    )
+    assert gdf.geometry.apply(utils.remove_line_ends).equals(
+        gpd.GeoSeries(
+            [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString(
+                    [
+                        (5, 5),
+                        (10, 10),
+                    ]
+                ),
+                MultiLineString(
+                    [
+                        [(0, 0), (3, 3)],
+                        [(3, 3), (6, 6), (9, 9)],
+                        [(6, 6), (9, 9), (12, 12)],
+                    ]
+                ),
+            ]
+        )
+    )
+
+
+def test_reverse_line():
+    gdf = gpd.GeoDataFrame(
+        {
+            "id": [1, 2, 3],
+            "geometry": [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString([(0, 0), (5, 5), (10, 10), (15, 15)]),
+                MultiLineString(
+                    [
+                        [(0, 0), (3, 3)],
+                        [(3, 3), (6, 6), (9, 9)],
+                        [(3, 3), (6, 6), (9, 9), (12, 12), (15, 15)],
+                    ]
+                ),
+            ],
+        },
+    )
+    assert gdf.geometry.apply(utils.reverse_line).equals(
+        gpd.GeoSeries(
+            [
+                LineString([(10, 10), (5, 5), (0, 0)]),
+                LineString([(15, 15), (10, 10), (5, 5), (0, 0)]),
+                MultiLineString(
+                    [
+                        [(3, 3), (0, 0)],
+                        [(9, 9), (6, 6), (3, 3)],
+                        [(15, 15), (12, 12), (9, 9), (6, 6), (3, 3)],
+                    ]
+                ),
+            ]
+        )
+    )
+
+
+def test_copy_lines_parallel():
+    gdf = gpd.GeoDataFrame(
+        {
+            "id": [1, 2, 3],
+            "geometry": [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString([(20, 20), (30, 30), (40, 40), (50, 50)]),
+                MultiLineString(
+                    [
+                        [(100.0, 100.0), (103.0, 103.0)],
+                        [(103.0, 103.0), (106.0, 106.0), (109.0, 109.0)],
+                        [
+                            (103.0, 103.0),
+                            (106.0, 106.0),
+                            (109.0, 109.0),
+                            (112.0, 112.0),
+                            (115.0, 115.0),
+                        ],
+                    ]
+                ),
+            ],
+        },
+    )
+    offsets = np.array([1, 2, 3])
+    copied = utils.copy_lines_parallel(gdf, offsets)
+    expected = gpd.read_file(TEST_JSON / "copy_lines_parallel.json").set_crs(
+        None, allow_override=True
+    )
+    _assert_geodataframes_close(copied, expected, tol=1e-3)