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

reclaim/static_features/utils/basin_names.py

@@ -0,0 +1,78 @@
+ID_to_BASIN = {1030008110: 'RUFIJI',
+ 1030011660: 'ZAMBEZI',
+ 1030012590: 'LIMPOPO',
+ 1030012600: 'GOURITZ',
+ 1030015850: 'ORANGE',
+ 1030022420: 'NIGER',
+ 1030022430: 'OUEME',
+ 1030023300: 'VOLTA',
+ 1030023310: 'BANDAMA',
+ 1030027430: 'DRAA',
+ 1030029810: 'MOULOUYA',
+ 1030034260: 'NILE',
+ 1030040260: 'LAKE TURKANA',
+ 1030040300: 'MELRHIR',
+ 4030003020: 'LIAO HE',
+ 4030006940: 'HAI HE',
+ 4030007850: 'YELLOW RIVER',
+ 4030009880: 'YANGTZE',
+ 4030017020: 'MEKONG',
+ 4030017030: 'CHAO PHRAYA',
+ 4030018350: 'MAE KLONG',
+ 4030022790: 'IRRAWADDY',
+ 4030024190: 'KARNAPHULI',
+ 4030025450: 'GANGES',
+ 4030025460: 'GODAVARI',
+ 4030029530: 'NARMADA',
+ 4030031750: 'KUTCH',
+ 4030033640: 'INDUS',
+ 4030039450: 'TONE',
+ 4030046370: 'TAIWAN',
+ 4030048900: 'SRI LANKA',
+ 4030050220: 'UPPER ARAL SEA',
+ 4030050240: 'LOWER ARAL SEA',
+ 5030007690: 'BENGAWAN SOLO',
+ 5030015660: 'KAPUAS',
+ 5030031240: 'INDONESIA',
+ 5030055010: 'MARIANA_ISLANDS',
+ 5030067860: 'FITZROY',
+ 2030000010: 'ORONTES',
+ 2030003440: 'KIZILIRMAK',
+ 2030008490: 'DANUBE',
+ 2030009230: 'MARITSA RIVER',
+ 2030012730: 'PO',
+ 2030014550: 'TEVERE',
+ 2030016230: 'RHONE',
+ 2030020320: 'RHINE',
+ 2030026030: 'VISTULA',
+ 2030046500: 'SICILY',
+ 2030047500: 'SARDINIA_CORSICA',
+ 2030068690: 'KURA',
+ 2030073570: 'SHATT AL ARAB',
+ 2030085720: 'DEAD SEA',
+ 7030000010: 'SANTIAGO',
+ 7030008710: 'COLORADO (also COLORADO RIVER)',
+ 7030008720: 'SAN JOAQUIN',
+ 7030014250: 'ROGUE',
+ 7030014930: 'COLUMBIA',
+ 7030022240: 'NELSON',
+ 7030034520: 'SAINT LAWRENCE (also SAINT-LAURENT)',
+ 7030038340: 'SUSQUEHANNA',
+ 7030042040: 'MOBILE RIVER',
+ 7030047060: 'MISSISSIPPI',
+ 7030047840: 'BRAZOS',
+ 7030049270: 'RIO GRANDE (also BRAVO)',
+ 7030049280: 'USUMACINTA',
+ 7030073620: 'GREAT SALT LAKE',
+ 6030000010: 'ATRATO',
+ 6030004470: 'ORINOCO',
+ 6030007000: 'AMAZON (also AMAZONAS)',
+ 6030009770: 'JAGUARIBE',
+ 6030011780: 'SAO FRANCISCO',
+ 6030011790: 'DOCE',
+ 6030016970: 'PARANA',
+ 6030029280: 'CHIRA',
+ 6030032290: 'GUAYAS'}
+
+def get_basin_name(basin_id):
+    return ID_to_BASIN[basin_id]

reclaim/static_features/utils/catchment_agreggate.py

@@ -1,10 +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(
@@ -144,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.3.0.dist-info/RECORD

@@ -1,27 +0,0 @@
-pyreclaim-0.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-reclaim/__init__.py,sha256=PnNGOrv5as3H8_WWLE3QqHR2LnqMgutXD8lDA-8PnCE,33
-reclaim/generate_features.py,sha256=MsHC9POhji9zMAr-OIbaDrIkYiIlO2D5z3hQmRN2BcY,6164
-reclaim/reclaim.py,sha256=RVaEmnojfJm6iS8kfxXfxD4SefSDcbC1QlarbSWCtuo,19815
-reclaim/derived_features/__init__.py,sha256=boN0ilez7nbWdn4RKD4n7whlGrg_X-zxrqMv5RA6cmg,67
-reclaim/derived_features/feature_engineering_and_transformation.py,sha256=E7hzrrWgYYtzCv6S1EWi-bBQdxF52sB26v13XVnq8qU,3234
-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=YMd2aiSZEhAk5-qPzLK4Ondpm5Hi6tcAeM_nc4dW-fo,5318
-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=4qDLgViE51ppyrxzXIh5GQ_z94liHZcfBSNADiUGnGk,2208
-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=BNtZOeLHdT324K0VsduATnTLvcYkdTcV1TZjizkkQ9g,3188
-reclaim/static_features/utils/__init__.py,sha256=y-4GVIqARI0g8s2FVlTfx_4XprcPQ9HP_2nbhSw1NVA,88
-reclaim/static_features/utils/aec_shape.py,sha256=6N0MbbEpVJLQ6AD_LE0sbxuaUTm7Ul9bK2-Ml_krA7Q,3262
-reclaim/static_features/utils/area_perimeter.py,sha256=AJlTQ2NZbIfTOSYTG01UdwksutkT9IykA-4uvn4w8Qg,1341
-reclaim/static_features/utils/catchment_agreggate.py,sha256=tooDg_-vA6eamUR3iR4g-NcQGnsQYfSE4kH8iyjK9Xo,5051
-reclaim/static_features/utils/flow_length.py,sha256=VC4rUrmAxrutj4Cj5bTjlH3KXLRmwNjp04FCT74_LUg,16939
-pyreclaim-0.3.0.dist-info/METADATA,sha256=aHqNiLOVfkRWCYxBYvunXr0MNpX4vunewa4-Rl4yt_0,45381
-pyreclaim-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyreclaim-0.3.0.dist-info/top_level.txt,sha256=uO95g-XnD3UQLLqi3q30muhaC9VqO04IqCbwmfsGmW4,8
-pyreclaim-0.3.0.dist-info/RECORD,,