fimserve 0.1.2__py3-none-any.whl

fimserve/FIMsubset/__init__.py

@@ -0,0 +1,7 @@
+import warnings
+
+warnings.simplefilter("ignore")
+
+from .xycoord import subsetFIM
+
+__all__ = ["subsetFIM"]

fimserve/FIMsubset/shpsubset.py

@@ -0,0 +1,58 @@
+import os
+import rasterio
+from rasterio.mask import mask
+from pathlib import Path
+import geopandas as gpd
+
+
+def checkSHP(input_file):
+    if isinstance(input_file, Path):
+        input_file = str(input_file)
+
+    if input_file.endswith(".shp"):
+        gdf = gpd.read_file(input_file)
+    elif input_file.endswith(".gpkg"):
+        gdf = gpd.read_file(input_file)
+    elif input_file.endswith(".geojson"):
+        gdf = gpd.read_file(input_file)
+    elif input_file.endswith(".kml"):
+        gdf = gpd.read_file(input_file)
+    else:
+        raise ValueError(
+            "Unsupported file format. Please provide a shapefile GeoPackage, GeoJSON, or KML."
+        )
+    return gdf
+
+
+def clipFIMforboundary(inundation_raster, shapefile_geom, output_directory, huc):
+    with rasterio.open(inundation_raster) as src:
+        geometries = shapefile_geom.geometry.tolist()
+        if src.crs != shapefile_geom.crs:
+            print("CRS mismatch. Reprojecting geometry to match raster.")
+            geometries = [geom.to_crs(src.crs) for geom in geometries]
+
+        out_image, out_transform = mask(src, geometries, crop=True)
+        out_meta = src.meta.copy()
+        out_meta.update(
+            {
+                "driver": "GTiff",
+                "count": 1,
+                "crs": src.crs,
+                "transform": out_transform,
+                "width": out_image.shape[2],
+                "height": out_image.shape[1],
+            }
+        )
+
+        output_directory = os.path.join(output_directory, "subsetFIM")
+        if not os.path.exists(output_directory):
+            os.makedirs(output_directory)
+
+        file_basename = os.path.basename(inundation_raster).split("_")[0]
+        output_file = os.path.join(output_directory, f"{file_basename}_subsetFIM.tif")
+
+        if not os.path.exists(output_directory):
+            os.makedirs(output_directory)
+        with rasterio.open(output_file, "w", **out_meta) as dest:
+            dest.write(out_image)
+        print(f"Clipped raster saved to {output_file}")

fimserve/FIMsubset/xycoord.py

@@ -0,0 +1,101 @@
+import os
+import glob
+import geopandas as gpd
+from shapely.geometry import Point
+import rasterio
+from rasterio.mask import mask
+
+from ..datadownload import setup_directories
+from .shpsubset import checkSHP, clipFIMforboundary
+
+
+def checkifWGS(x, y):
+    """Check if coordinates are in WGS84 (EPSG:4326) range."""
+    if -180 <= x <= 180 and -90 <= y <= 90:
+        return True
+    else:
+        return False
+
+
+def reproject_coordinates(x, y, target_crs="EPSG:5070"):
+    """Reproject coordinates to target CRS."""
+    if checkifWGS(x, y):
+        from pyproj import CRS, Transformer
+
+        crs_wgs84 = CRS("EPSG:4326")
+        crs_target = CRS(target_crs)
+        transformer = Transformer.from_crs(crs_wgs84, crs_target, always_xy=True)
+        x_new, y_new = transformer.transform(x, y)
+        return x_new, y_new
+    else:
+        return x, y
+
+
+def clipFIM(inundation_raster, shapefile_geom, output_directory, huc):
+    with rasterio.open(inundation_raster) as src:
+        out_image, out_transform = mask(src, [shapefile_geom], crop=True)
+        out_meta = src.meta.copy()
+        out_meta.update(
+            {
+                "driver": "GTiff",
+                "count": 1,
+                "crs": src.crs,
+                "transform": out_transform,
+                "width": out_image.shape[2],
+                "height": out_image.shape[1],
+            }
+        )
+        file_basename = os.path.basename(inundation_raster).split("_")[0]
+        output_file = os.path.join(output_directory, f"{file_basename}_subsetFIM.tif")
+
+        if not os.path.exists(output_directory):
+            os.makedirs(output_directory)
+
+        with rasterio.open(output_file, "w", **out_meta) as dest:
+            dest.write(out_image)
+
+        print(f"Clipped raster saved to {output_file}")
+        return out_image, out_transform
+
+
+def withininWatershed(x, y, geopackage_path, inundation_raster, huc, output_directory):
+    point = Point(x, y)
+    watersheds = gpd.read_file(geopackage_path)
+
+    # Watershed containing the point
+    watershed_containing_point = None
+    for _, watershed in watersheds.iterrows():
+        if watershed["geometry"].contains(point):
+            watershed_containing_point = watershed
+            break
+    output_directory = os.path.join(output_directory, "subsetFIM")
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+
+    if watershed_containing_point is None:
+        raise ValueError(f"Point is not within any watershed boundary for {huc}")
+    return clipFIM(
+        inundation_raster, watershed_containing_point["geometry"], output_directory, huc
+    )
+
+
+def subsetFIM(location, huc, method):
+    code_dir, data_dir, output_dir = setup_directories()
+    gpkg_path = os.path.join(
+        output_dir, f"flood_{huc}", huc, "nwm_catchments_proj_subset.gpkg"
+    )
+    out_dir = os.path.join(output_dir, f"flood_{huc}", f"{huc}_inundation")
+    inundation_rasters = os.path.join(out_dir, "*_inundation.tif")
+    print(inundation_rasters)
+    files = glob.glob(inundation_rasters)
+    if method == "xy":
+        x, y = location
+        print("point", x, y)
+        x, y = reproject_coordinates(x, y)
+        for file in files:
+            print(f"Clipping {file} to watershed containing point {x}, {y}")
+            withininWatershed(x, y, gpkg_path, file, huc, out_dir)
+    elif method == "boundary":
+        shapefile = checkSHP(location)
+        for file in files:
+            clipFIMforboundary(file, shapefile, out_dir, huc)

fimserve/__init__.py

@@ -0,0 +1,87 @@
+import warnings
+
+warnings.simplefilter("ignore")
+
+from .datadownload import DownloadHUC8
+from .streamflowdata.nwmretrospective import getNWMretrospectivedata
+from .runFIM import runOWPHANDFIM
+
+from .streamflowdata.forecasteddata import getNWMForecasteddata
+from .streamflowdata.geoglows import getGEOGLOWSstreamflow
+
+# plots
+from .plot.nwmfid import plotNWMStreamflow
+from .streamflowdata.usgsdata import getUSGSsitedata
+from .plot.comparestreamflow import CompareNWMnUSGSStreamflow
+from .plot.usgs import plotUSGSStreamflow
+from .plot.src import plotSRC
+
+# For table
+from .plot.usgsandfid import GetUSGSIDandCorrFID
+
+# subsetting
+from .FIMsubset.xycoord import subsetFIM
+
+# Fim visualization
+from .vizualizationFIM import vizualizeFIM
+
+# Statistics
+from .statistics.calculatestatistics import CalculateStatistics
+
+# For intersected HUC8 boundary
+from .intersectedHUC import getIntersectedHUC8ID
+
+# evaluation of FIM
+from .fimevaluation.fims_setup import FIMService, fim_lookup
+from .fimevaluation.run_fimeval import run_evaluation
+
+
+# Enhancement using surrogate models [Importing those only if they are called]
+def prepare_FORCINGs(*args, **kwargs):
+    from .enhancement_withSM.preprocessFIM import prepare_FORCINGs as _impl
+
+    return _impl(*args, **kwargs)
+
+
+def enhanceFIM(*args, **kwargs):
+    from .enhancement_withSM.SM_prediction import enhanceFIM as _impl
+
+    return _impl(*args, **kwargs)
+
+
+def getbuilding_exposure(*args, **kwargs):
+    from .enhancement_withSM.building_exposure import getbuilding_exposure as _impl
+
+    return _impl(*args, **kwargs)
+
+
+def getpopulation_exposure(*args, **kwargs):
+    from .enhancement_withSM.pop_exposure import getpopulation_exposure as _impl
+
+    return _impl(*args, **kwargs)
+
+
+__all__ = [
+    "DownloadHUC8",
+    "getNWMretrospectivedata",
+    "runOWPHANDFIM",
+    "getNWMForecasteddata",
+    "getGEOGLOWSstreamflow",
+    "plotNWMStreamflow",
+    "getUSGSsitedata",
+    "CompareNWMnUSGSStreamflow",
+    "plotUSGSStreamflow",
+    "plotSRC",
+    "GetUSGSIDandCorrFID",
+    "subsetFIM",
+    "vizualizeFIM",
+    "CalculateStatistics",
+    "getIntersectedHUC8ID",
+    "FIMService",
+    "fim_lookup",
+    "run_evaluation",
+    "prepare_FORCINGs",
+    "enhanceFIM",
+    "getbuilding_exposure",
+    "getpopulation_exposure",
+]

fimserve/datadownload.py

@@ -0,0 +1,163 @@
+import os
+import csv
+import pandas as pd
+import subprocess
+
+
+def setup_directories():
+    parent_dir = os.getcwd()
+    code_dir = os.path.join(parent_dir, "code", "inundation-mapping")
+    data_dir = os.path.join(parent_dir, "data", "inputs")
+    output_dir = os.path.join(parent_dir, "output")
+
+    # Create the directories if not exist
+    os.makedirs(code_dir, exist_ok=True)
+    os.makedirs(data_dir, exist_ok=True)
+    os.makedirs(output_dir, exist_ok=True)
+
+    return code_dir, data_dir, output_dir
+
+
+def clone_repository(code_dir, version=None):
+    repo_path = os.path.join(code_dir)
+    repo_url = "https://github.com/NOAA-OWP/inundation-mapping.git"
+
+    # Map version strings to git tags
+    version_tag_map = {
+        "4.5": "v4.6.1.4",
+        "default": "main",
+    }
+
+    # Determine tag to checkout
+    version_tag = version_tag_map.get(version, version_tag_map["default"])
+    if os.path.exists(repo_path) and os.listdir(repo_path):
+        print(f"Repository already exists at {repo_path}. Skipping clone.")
+        return
+
+    # Clone repo
+    subprocess.run(["git", "clone", repo_url, repo_path], check=True)
+
+    # Checkout specific version/tag (only if not main)
+    if version_tag != "main":
+        try:
+            subprocess.run(["git", "checkout", version_tag], cwd=repo_path, check=True)
+        except subprocess.CalledProcessError:
+            subprocess.run(["git", "tag"], cwd=repo_path)  # List available tags
+            raise
+    print(f"Repository cloned into: {repo_path} (version: {version_tag})")
+
+
+def download_data(huc_number, base_dir, version=None):
+    output_dir = os.path.join(base_dir, f"flood_{huc_number}", str(huc_number))
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Determine S3 path based on version — default to 4.9
+    if version == "4.5":
+        s3_path = f"s3://ciroh-owp-hand-fim/hand_fim_4_5_2_11/{huc_number}/"
+    elif version == "4.8":
+        s3_path = f"s3://ciroh-owp-hand-fim/hand_fim_4_8_7_2/{huc_number}/"
+    else:
+        s3_path = f"s3://ciroh-owp-hand-fim/hand_fim_4_9_9_0/{huc_number}/"
+
+    # Run the AWS CLI command with no-sign-request
+    cmd = f"aws s3 sync {s3_path} {output_dir} --no-sign-request"
+    os.system(cmd)
+    print(f"Data for HUC {huc_number} downloaded to {output_dir}")
+
+    # Copy branch_ids.csv to fim_inputs.csv
+    hydrotable_path = os.path.join(output_dir, "branch_ids.csv")
+    fim_inputs_path = os.path.join(base_dir, f"flood_{huc_number}", "fim_inputs.csv")
+
+    with (
+        open(hydrotable_path, "r") as infile,
+        open(fim_inputs_path, "w", newline="") as outfile,
+    ):
+        reader = csv.reader(infile)
+        writer = csv.writer(outfile)
+        for row in reader:
+            writer.writerow(row)
+
+    print(f"Copied {hydrotable_path} to {fim_inputs_path} as fim_inputs.csv.")
+
+
+def uniqueFID(hydrotable, fid_dir, stream_order=None):
+    hydrotable_df = pd.read_csv(hydrotable)
+
+    if stream_order:
+        if isinstance(stream_order, str) and (
+            ">=" in stream_order
+            or "<=" in stream_order
+            or ">" in stream_order
+            or "<" in stream_order
+        ):
+            # Handle conditions like ">=3", "<=4", etc.
+            operator, value = None, None
+            if ">=" in stream_order:
+                operator, value = ">=", int(stream_order.split(">=")[1])
+            elif "<=" in stream_order:
+                operator, value = "<=", int(stream_order.split("<=")[1])
+            elif ">" in stream_order:
+                operator, value = ">", int(stream_order.split(">")[1])
+            elif "<" in stream_order:
+                operator, value = "<", int(stream_order.split("<")[1])
+
+            hydrotable_df["order_"] = hydrotable_df["order_"].astype(int)
+            if operator == ">=":
+                hydrotable_df_filtered = hydrotable_df[hydrotable_df["order_"] >= value]
+            elif operator == "<=":
+                hydrotable_df_filtered = hydrotable_df[hydrotable_df["order_"] <= value]
+            elif operator == ">":
+                hydrotable_df_filtered = hydrotable_df[hydrotable_df["order_"] > value]
+            elif operator == "<":
+                hydrotable_df_filtered = hydrotable_df[hydrotable_df["order_"] < value]
+
+        elif isinstance(stream_order, (list, int)):
+            if isinstance(stream_order, int):
+                stream_order = [stream_order]
+            stream_order = [str(order) for order in stream_order]
+            hydrotable_df["order_"] = hydrotable_df["order_"].astype(str)
+            hydrotable_df_filtered = hydrotable_df[
+                hydrotable_df["order_"].isin(stream_order)
+            ]
+        else:
+            raise ValueError(
+                "Invalid stream_order format. Use a list of values, a single value, or a condition like '>=3'."
+            )
+    else:
+        # No filter, use the whole dataset
+        hydrotable_df_filtered = hydrotable_df
+
+    unique_FIDs = hydrotable_df_filtered["feature_id"].drop_duplicates()
+    unique_FIDs_df = pd.DataFrame(unique_FIDs, columns=["feature_id"])
+    unique_FIDs_df.to_csv(fid_dir, index=False)
+    print(f"Unique feature IDs saved to {fid_dir}.")
+
+
+# IN the replacement of Docker, the environement variables are set in the .env file
+def EnvFile(code_dir):
+    env_dir = os.path.join(code_dir, ".env")
+    env_content = """
+    inputsDir=inputs
+    outputsDir=output
+    """
+    os.makedirs(os.path.dirname(env_dir), exist_ok=True)
+
+    with open(env_dir, "w") as f:
+        f.write(env_content)
+
+
+def DownloadHUC8(huc, stream_order=None, version=None):
+    code_dir, data_dir, output_dir = setup_directories()
+    clone_repository(code_dir, version)
+
+    # if huc is not str:
+    huc = str(huc)
+    download_data(huc, output_dir, version)
+    EnvFile(code_dir)
+    HUC_dir = os.path.join(output_dir, f"flood_{huc}")
+    hydrotable_dir = os.path.join(HUC_dir, str(huc), "hydrotable.csv")
+    featureID_dir = os.path.join(HUC_dir, "feature_IDs.csv")
+    if stream_order is None:
+        uniqueFID(hydrotable_dir, featureID_dir)
+    else:
+        uniqueFID(hydrotable_dir, featureID_dir, stream_order)