pyreclaim 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

reclaim/static_features/utils/catchment_agreggate.py

@@ -1,11 +1,14 @@
+import os
 import pandas as pd
 import numpy as np
 import xarray as xr
 import rioxarray
 import geopandas as gpd
 import regionmask
+import rasterio.features
 from collections import Counter
 from shapely.geometry import Polygon
+from tqdm import tqdm
 
 
 def compute_catchment_aggregate(
@@ -145,4 +148,208 @@ def compute_catchment_aggregate(
             else:
                 raise ValueError(f"Unknown function type '{func}' for variable '{var}'")
 
-    return pd.DataFrame([results])
+    return pd.DataFrame([results])
+
+def compute_catchment_aggregate_multi_reservoir(
+    netcdf_path,
+    catchments_gdf: gpd.GeoDataFrame,
+    function_type="mean",
+    idx_col: str = "idx",
+) -> pd.DataFrame:
+    """
+    Compute catchment-based aggregated features for MULTIPLE catchments
+    from a single NetCDF file (opened only once).
+
+    Parameters
+    ----------
+    netcdf_path : str or Path
+        Path to the NetCDF file containing raster variables.
+
+    catchments_gdf : geopandas.GeoDataFrame
+        GeoDataFrame containing multiple catchment geometries.
+        Must include:
+            - geometry column
+            - idx_col identifying each reservoir
+
+    function_type : str or dict, default="mean"
+        Aggregation rule(s), same semantics as compute_catchment_aggregate().
+
+    idx_col : str, default="idx"
+        Column identifying reservoir index.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame indexed by idx with aggregated features.
+    """
+
+    ds = xr.open_dataset(netcdf_path, chunks={"x": 200, "y": 200})
+    ds = ds.rio.write_crs("EPSG:4326")
+
+    if "lon" in ds.dims and "lat" in ds.dims:
+        ds = ds.rename({"lon": "x", "lat": "y"})
+
+    variables = list(ds.data_vars)
+
+    if isinstance(function_type, str):
+        apply_func = {v: function_type for v in variables}
+    elif isinstance(function_type, dict):
+        apply_func = function_type
+    else:
+        raise ValueError("function_type must be a string or a dictionary.")
+
+    # Determine coordinate ordering for slicing
+    y_order = "descending" if ds.y[0] > ds.y[-1] else "ascending"
+    x_order = "descending" if ds.x[0] > ds.x[-1] else "ascending"
+
+    results = []
+    
+    # ---- Loop over catchments (cheap loop now)
+    for _, row_gdf in tqdm(
+        catchments_gdf.iterrows(),
+        total=catchments_gdf.shape[0],
+        desc=f"Aggregating static features of catchments related to {os.path.basename(netcdf_path)}",
+        unit="catchment",
+    ):
+        idx = row_gdf[idx_col]
+        geom = row_gdf.geometry
+
+        row = {idx_col: idx}
+
+        if geom is None or geom.is_empty:
+            results.append(row)
+            continue
+
+        # ---- Spatial subset FIRST
+        minx, miny, maxx, maxy = geom.bounds
+        
+        dx = float(abs(ds.x[1] - ds.x[0]))
+        dy = float(abs(ds.y[1] - ds.y[0]))
+        minx -= dx
+        maxx += dx
+        miny -= dy
+        maxy += dy
+        
+        if y_order == "descending":
+            y_slice = slice(maxy, miny)
+        else:
+            y_slice = slice(miny, maxy)
+
+        if x_order == "descending":
+            x_slice = slice(maxx, minx)
+        else:
+            x_slice = slice(minx, maxx)
+
+        subset_ds = ds.sel(x=x_slice, y=y_slice)
+        
+        # -- Skip if empty subset 
+        if subset_ds.x.size == 0 or subset_ds.y.size == 0:
+            print(f"Warning: Subset for catchment idx={idx} is empty. Skipping.")
+            results.append(row)
+            continue
+
+        # ---- Create mask on SUBSET
+        catchment_gdf = gpd.GeoDataFrame(
+            {idx_col: [idx]}, geometry=[geom], crs="EPSG:4326"
+        )
+
+        # mask_from_geopandas = regionmask.mask_geopandas(
+        #     catchment_gdf, subset_ds.x, subset_ds.y
+        # )
+
+        # catchment_mask = mask_from_geopandas == 0
+        
+        # # Skip if no overlap
+        # if mask_from_geopandas.notnull().sum().sum().item() == 0:
+        #     results.append(row)
+        #     continue
+        
+        transform = subset_ds.rio.transform()
+
+        mask = rasterio.features.rasterize(
+            [(geom, 1)],
+            out_shape=(subset_ds.sizes["y"], subset_ds.sizes["x"]),
+            transform=transform,
+            all_touched=True,
+            fill=0,
+            dtype="uint8",
+        )
+        
+        # --- fallback if rasterized mask is empty ---
+        if mask.sum() == 0:
+            # Compute centroid in raster CRS
+            centroid = geom.centroid
+            # Find nearest x, y indices in the subset
+            x_idx = np.argmin(np.abs(subset_ds.x.values - centroid.x))
+            y_idx = np.argmin(np.abs(subset_ds.y.values - centroid.y))
+            
+            # Create a mask with just the centroid pixel
+            mask = np.zeros((subset_ds.sizes["y"], subset_ds.sizes["x"]), dtype=np.uint8)
+            mask[y_idx, x_idx] = 1
+
+        catchment_mask = xr.DataArray(
+            mask,
+            coords={"y": subset_ds.y, "x": subset_ds.x},
+            dims=("y", "x"),
+        )
+
+
+        # ---- Aggregate variables
+        for var, func_list in apply_func.items():
+            data = subset_ds[var]
+
+            masked = data.where(catchment_mask).compute()
+            arr = masked.where(~masked.isnull(), drop=True)
+
+            if arr.size == 0:
+                continue
+
+            func_list = func_list if isinstance(func_list, list) else [func_list]
+
+            for func_info in func_list:
+                if isinstance(func_info, str):
+                    func = func_info
+                    threshold = None
+                    threshold_direction = None
+                elif isinstance(func_info, dict):
+                    func = func_info.get("type")
+                    threshold = func_info.get("threshold", None)
+                    threshold_direction = func_info.get("direction", "greater")
+                else:
+                    raise ValueError(f"Invalid function format for variable {var}")
+
+                if func == "mean":
+                    row[f"{var}_mean"] = float(arr.mean().item())
+
+                elif func == "mode":
+                    vals = arr.values.flatten()
+                    row[f"{var}_mode"] = Counter(vals).most_common(1)[0][0]
+
+                elif func == "std":
+                    row[f"{var}_std"] = float(arr.std().item())
+
+                elif func == "percent":
+                    vals = arr.values.flatten()
+                    total = len(vals)
+                    class_counts = Counter(vals)
+                    for cls, count in class_counts.items():
+                        row[f"{var}_percent_{int(cls)}"] = (count / total) * 100
+
+                elif func == "threshold_percent":
+                    if threshold is None:
+                        raise ValueError(f"Threshold not provided for variable '{var}'")
+                    vals = arr.values.flatten()
+                    valid = vals[~np.isnan(vals)]
+                    if threshold_direction == "greater":
+                        percent = (valid > threshold).sum() / len(valid) * 100
+                        row[f"{var}_percent_above_{threshold}"] = percent
+                    else:
+                        percent = (valid < threshold).sum() / len(valid) * 100
+                        row[f"{var}_percent_below_{threshold}"] = percent
+
+                else:
+                    raise ValueError(f"Unknown function type '{func}' for variable '{var}'")
+
+        results.append(row)
+
+    return pd.DataFrame(results).set_index(idx_col)

reclaim/static_features/utils/flow_length.py

@@ -2,6 +2,9 @@ import numpy as np
 import pandas as pd
 import geopandas as gpd
 import networkx as nx  # NetworkX library import
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+from matplotlib.patches import Patch
 
 from shapely.geometry import shape, Point, LineString, Polygon, GeometryCollection, MultiLineString, MultiPolygon
 from shapely.ops import transform, split, linemerge, unary_union
@@ -452,4 +455,65 @@ def find_actual_flow_path(dam_point, reservoir_polygon, inlet_point=None, resolu
     # Step4: Find the shortest path within geometry between dam_point and far_end_point
     path, graph = create_continuous_linestring(dam_point,far_end_point, simplified_reservoir, optimal_resolution)
 
-    return simplified_reservoir,far_end_point, path, graph
+    return simplified_reservoir,far_end_point, path, graph
+
+def plot_flow_length_with_reservoir(dam, reservoir, farthest_point, actual_flow_path, simplified_reservoir, save_path):
+    fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))
+
+    # Define plot elements
+    geoms = {
+        "Dam Point": {"geometry": dam, "color": "green", "marker": "^"},
+        "Reservoir": {"geometry": reservoir, "color": "aqua", "edgecolor": "#00008B"},
+        "Farthest Point": {"geometry": farthest_point, "color": "red", "marker": "x"},
+        "Flow Path": {"geometry": actual_flow_path, "color": "blue"},
+    }
+
+    geoms_simplified = {
+        "Dam Point": {"geometry": dam, "color": "green", "marker": "^"},
+        "Reservoir (Simplified)": {"geometry": simplified_reservoir, "color": "aqua", "edgecolor": "#00008B"},
+        "Farthest Point": {"geometry": farthest_point, "color": "red", "marker": "x"},
+        "Flow Path": {"geometry": actual_flow_path, "color": "blue"},
+    }
+
+    # Plot original
+    for label, item in geoms.items():
+        gdf = gpd.GeoDataFrame(geometry=[item["geometry"]])
+        if item["geometry"].geom_type == "Point":
+            gdf.plot(ax=ax[0], color=item["color"], marker=item.get("marker", "o"), zorder=3, markersize=90)
+        elif item["geometry"].geom_type == "Polygon" or item["geometry"].geom_type == "MultiPolygon":
+            gdf.plot(ax=ax[0], color=item["color"], edgecolor=item['edgecolor'], zorder=1)
+        else:
+            gdf.plot(ax=ax[0], color=item["color"],zorder=2)
+
+    # Plot simplified
+    for label, item in geoms_simplified.items():
+        gdf = gpd.GeoDataFrame(geometry=[item["geometry"]])
+        if item["geometry"].geom_type == "Point":
+            gdf.plot(ax=ax[1], color=item["color"], marker=item.get("marker", "o"), zorder=3, markersize=90)
+        elif item["geometry"].geom_type == "Polygon" or item["geometry"].geom_type == "MultiPolygon":
+            gdf.plot(ax=ax[1], color=item["color"], edgecolor=item['edgecolor'], zorder=1)
+        else:
+            gdf.plot(ax=ax[1], color=item["color"], zorder=2)
+
+    # Custom handles
+    custom_handles = [
+        Line2D([0], [0], marker='^', color='w', label='Dam', markerfacecolor='green', markersize=12),
+        Patch(facecolor='aqua', edgecolor='#00008B', label='Reservoir'),
+        Line2D([0], [0], marker='x', color='red', label='Reservoir inlet', markersize=8),
+        Line2D([0], [0], color='blue', lw=2, label='Shortest Flow Path')
+    ]
+
+    # Set axis labels and titles
+    for a in ax:
+        a.set_xlabel("Longitude")
+        a.set_ylabel("Latitude")
+    ax[0].set_title('Original Geometry')
+    ax[1].set_title('Simplified Geometry')
+
+    # Add one shared legend
+    fig.legend(handles=custom_handles, loc='lower center', ncol=4, bbox_to_anchor=(0.5, -0.05))
+
+    plt.tight_layout()
+    plt.savefig(save_path, bbox_inches='tight', dpi=300)
+    plt.close()
+    

pyreclaim-0.4.0.dist-info/RECORD

@@ -1,27 +0,0 @@
-pyreclaim-0.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-reclaim/__init__.py,sha256=PnNGOrv5as3H8_WWLE3QqHR2LnqMgutXD8lDA-8PnCE,33
-reclaim/generate_features.py,sha256=yKR-yIySM4wV_vJHTg7L61geh7p-KTKjfQs0hVyF4Ok,6653
-reclaim/reclaim.py,sha256=SqgnChFoOKlhRm6tNnd1MDOOy5QFGQOZixaiJjN4tIA,19983
-reclaim/derived_features/__init__.py,sha256=boN0ilez7nbWdn4RKD4n7whlGrg_X-zxrqMv5RA6cmg,67
-reclaim/derived_features/feature_engineering_and_transformation.py,sha256=01j7XP8ciDQLlPXdpRaUswlpNQDnqfHB-4b7_P4ZrXs,3472
-reclaim/dynamic_features/__init__.py,sha256=gjZmRYl9zCccSenz6f38EKntrV6ueT0_9MHRrjtw2Og,45
-reclaim/dynamic_features/catchment_dynamic.py,sha256=BHRci-Hh4xZ-UviAXKS3oPzGonzw81GQ4DUUOamUF7I,3273
-reclaim/dynamic_features/reservoir_dynamic.py,sha256=4y3agRw0Qwq9k6Qe06upSyCu_TC9kBmy9g-2S8rHLjE,5409
-reclaim/dynamic_features/utils/__init__.py,sha256=_mTSUeDu1jG5oBHvDKkMPx2A3xtIuSCpGpcMIURzmkU,89
-reclaim/dynamic_features/utils/catchment_meteorology.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reclaim/dynamic_features/utils/inflow_outflow.py,sha256=vD5CTAR12gCd56y8zDpzKfzJvG_qU_uJFD5OAajyb-g,2384
-reclaim/dynamic_features/utils/rainfall.py,sha256=oWn1RbeHHmhZ--N7bx9UiJptRrPynYGXe1HTfPjHjWg,1387
-reclaim/dynamic_features/utils/statistical_metrics.py,sha256=qtiLtFCqtOa6sDkpCmZmGsS_kub4rkYqUKgSEODZea4,4881
-reclaim/dynamic_features/utils/ts_aggregate.py,sha256=lv4tIBwCHlmEdaexNEeb2zSvtWo4x4sGTtFZ1KZmZ-4,2469
-reclaim/static_features/__init__.py,sha256=QRDAk3sgrGX-Oq8oRY5RESkWniVhcAPoQUa6jDJ59Zo,44
-reclaim/static_features/catchment_static.py,sha256=vr3ZupzvaEkCn5f7g9AJp5-VfBGv5yPaMnJ33IHP9qU,3790
-reclaim/static_features/reservoir_static.py,sha256=BXdpFO1PAcaEGAgLmorDcPDpuf5Rkr0Xv1UYgyyrV10,3497
-reclaim/static_features/utils/__init__.py,sha256=y-4GVIqARI0g8s2FVlTfx_4XprcPQ9HP_2nbhSw1NVA,88
-reclaim/static_features/utils/aec_shape.py,sha256=Tyew9tvPvNFpMOtPBf2GhdPBXoEjXr-VA2vyfY6ugYk,3270
-reclaim/static_features/utils/area_perimeter.py,sha256=yDLpxjyfGDQdL121w65X5oWLxCSwtSuPvJa7n_mtBl0,1338
-reclaim/static_features/utils/catchment_agreggate.py,sha256=_Pk30g5p7MVg_39R0_zElbkQketNy937WjGa9ugIoOY,5068
-reclaim/static_features/utils/flow_length.py,sha256=VC4rUrmAxrutj4Cj5bTjlH3KXLRmwNjp04FCT74_LUg,16939
-pyreclaim-0.4.0.dist-info/METADATA,sha256=KP_xlJZJpjMtx2-993R4hZXwJpFa5Xy8ixCjYRJ2z2Q,45464
-pyreclaim-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyreclaim-0.4.0.dist-info/top_level.txt,sha256=uO95g-XnD3UQLLqi3q30muhaC9VqO04IqCbwmfsGmW4,8
-pyreclaim-0.4.0.dist-info/RECORD,,