fimeval 0.1.50__py3-none-any.whl → 0.1.52__py3-none-any.whl

fimeval/BuildingFootprint/evaluationwithBF.py

@@ -85,6 +85,7 @@ def GetFloodedBuildingCountInfo(
     if "bm" in str(raster1_path).lower():
         count_centroids_in_raster(raster1_path, "Benchmark")
         count_centroids_in_raster(raster2_path, "Candidate")
+        
     elif "candidate" in str(raster2_path).lower():
         count_centroids_in_raster(raster1_path, "Candidate")
         count_centroids_in_raster(raster2_path, "Benchmark")
@@ -105,6 +106,9 @@ def GetFloodedBuildingCountInfo(
     CSI = TP / (TP + FP + FN) if (TP + FP + FN) > 0 else 0
     FAR = FP / (TP + FP) if (TP + FP) > 0 else 0
     POD = TP / (TP + FN) if (TP + FN) > 0 else 0
+    
+    
+    BDR = (centroid_counts["Candidate"]- centroid_counts["Benchmark"])/centroid_counts["Benchmark"]
 
     counts_data = {
         "Category": [
@@ -116,6 +120,7 @@ def GetFloodedBuildingCountInfo(
             "CSI",
             "FAR",
             "POD",
+            "Building Deviation Ratio",
         ],
         "Building Count": [
             centroid_counts["Candidate"],
@@ -126,6 +131,7 @@ def GetFloodedBuildingCountInfo(
             f"{CSI:.3f}",
             f"{FAR:.3f}",
             f"{POD:.3f}",
+            f"{BDR:.3f}",
         ],
     }
 

fimeval/ContingencyMap/evaluationFIM.py

@@ -75,9 +75,6 @@ def evaluateFIM(
     # Save the smallest extent boundary and cliped FIMS
     save_dir = os.path.join(output_dir, os.path.basename(folder), f"{method.__name__}")
     os.makedirs(save_dir, exist_ok=True)
-    
-    #Give the permission to the output directory
-    fix_permissions(save_dir)
 
     # Get the smallest matched raster extent and make a boundary shapefile
     smallest_raster_path = get_smallest_raster_path(benchmark_path, *candidate_paths)
@@ -98,7 +95,6 @@ def evaluateFIM(
                 raise FileNotFoundError(
                     "No shapefile (.shp, .gpkg, .geojson, .kml) found in the folder and none provided. Either provide a shapefile directory or put shapefile inside folder directory."
                 )
-
         # Run AOI with the found or provided shapefile
         bounding_geom = AOI(benchmark_path, shapefile, save_dir)
 
@@ -364,6 +360,7 @@ def evaluateFIM(
 
 #Safely deleting the folder
 def safe_delete_folder(folder_path):
+    fix_permissions(folder_path)
     try:
         shutil.rmtree(folder_path)
     except PermissionError:

fimeval/ContingencyMap/fix_permissions.sh

@@ -6,13 +6,16 @@ if [ -z "$DIR" ]; then
   echo "No directory provided."
   exit 1
 fi
+echo "Fixing permissions for: $DIR"
 
 UNAME=$(uname)
 if [[ "$UNAME" == "Darwin" || "$UNAME" == "Linux" ]]; then
   chmod -R u+rwX "$DIR"
+  echo "Permissions granted for user (u+rwX)"
 
 elif [[ "$UNAME" == *"MINGW"* || "$UNAME" == *"MSYS"* || "$UNAME" == *"CYGWIN"* ]]; then
   icacls "$DIR" /grant Everyone:F /T > /dev/null
+  echo "Permissions granted for working folder"
 
 else
   echo "Unsupported OS: $UNAME"

fimeval/utilis.py

@@ -1,3 +1,4 @@
+import os
 import shutil
 import pyproj
 import rasterio
@@ -70,11 +71,18 @@ def reprojectFIMs(src_path, dst_path, target_crs):
 
 #Resample into the coarser resoution amoung all FIMS within the case
 def resample_to_resolution(src_path, x_resolution, y_resolution):
+    src_path = Path(src_path)
+    print(src_path)
+    temp_path = src_path.with_name(src_path.stem + "_resampled.tif")
+    print(temp_path)
+
     with rasterio.open(src_path) as src:
-        transform = rasterio.transform.from_origin(src.bounds.left, src.bounds.top, x_resolution, y_resolution)
+        transform = rasterio.transform.from_origin(
+            src.bounds.left, src.bounds.top,
+            x_resolution, y_resolution
+        )
         width = int((src.bounds.right - src.bounds.left) / x_resolution)
         height = int((src.bounds.top - src.bounds.bottom) / y_resolution)
-
         kwargs = src.meta.copy()
         kwargs.update({
             'transform': transform,
@@ -82,8 +90,8 @@ def resample_to_resolution(src_path, x_resolution, y_resolution):
             'height': height
         })
 
-        dst_path = src_path
-        with rasterio.open(dst_path, 'w', **kwargs) as dst:
+        # Write to temporary file
+        with rasterio.open(temp_path, 'w', **kwargs) as dst:
             for i in range(1, src.count + 1):
                 reproject(
                     source=rasterio.band(src, i),
@@ -94,7 +102,9 @@ def resample_to_resolution(src_path, x_resolution, y_resolution):
                     dst_crs=src.crs,
                     resampling=Resampling.nearest
                 )
-    # compress_tif_lzw(dst_path)
+
+    os.remove(src_path)        # delete original
+    os.rename(temp_path, src_path)  
 
 #Check if the FIMs are in the same CRS or not else do further operation
 def MakeFIMsUniform(fim_dir, target_crs=None, target_resolution=None):
@@ -103,79 +113,69 @@ def MakeFIMsUniform(fim_dir, target_crs=None, target_resolution=None):
     if not tif_files:
         print(f"No TIFF files found in {fim_dir}")
         return
+
+    # Create processing folder to save standardized files
     processing_folder = fim_dir / 'processing'
     processing_folder.mkdir(exist_ok=True)
 
-    crs_list = []
-    projected_status = []
-    bounds_list = []
-    fims_data = []
-
+    # Collect info about each TIFF
+    crs_list, resolutions, bounds_list, projected_flags = [], [], [], []
     for tif_path in tif_files:
         try:
             with rasterio.open(tif_path) as src:
                 crs_list.append(src.crs)
-                projected_status.append(is_projected_crs(src.crs))
+                resolutions.append(src.res)
                 bounds_list.append(src.bounds)
-                fims_data.append((src.bounds, src.crs))
-        except rasterio.RasterioIOError as e:
+                projected_flags.append(is_projected_crs(src.crs))
+        except Exception as e:
             print(f"Error opening {tif_path}: {e}")
             return
 
-    all_projected = all(projected_status)
-    first_crs = crs_list[0] if crs_list else None
-    all_same_crs = all(crs == first_crs for crs in crs_list)
+    #CRS Check & Reproject if needed
+    all_projected = all(projected_flags)
+    all_same_crs = len(set(crs_list)) == 1
 
     if not all_projected or (all_projected and not all_same_crs):
-        if target_crs:
-            print(f"Reprojecting all FIMs to {target_crs}.")
-            for src_path in tif_files:
-                dst_path = processing_folder / src_path.name
-                reprojectFIMs(str(src_path), str(dst_path), target_crs)
-                compress_tif_lzw(dst_path)
-        else:
-            all_within_conus = all(is_within_conus(bounds_list[i], crs_list[i]) for i in range(len(bounds_list)))
-
-            if all_within_conus:
-                default_target_crs = "EPSG:5070"
-                print(f"FIMs are within CONUS, reprojecting all to {default_target_crs} and saving to {processing_folder}")
-                for src_path in tif_files:
-                    dst_path = processing_folder / src_path.name
-                    reprojectFIMs(str(src_path), str(dst_path), default_target_crs)
+        # Decide CRS to use
+        final_crs = target_crs
+        if not final_crs:
+            if all(is_within_conus(b, c) for b, c in zip(bounds_list, crs_list)):
+                final_crs = "EPSG:5070"
+                print(f"Defaulting to CONUS CRS: {final_crs}")
             else:
-                print("All flood maps are not in the projected CRS or are not in the same projected CRS.\n")
-                print("Please provide a target CRS in EPSG format.")
-    else:
+                print("Mixed or non-CONUS CRS detected. Please provide a valid target CRS.")
+                return
+            
+        print(f"Reprojecting all rasters to {final_crs}")
         for src_path in tif_files:
             dst_path = processing_folder / src_path.name
-            shutil.copy(src_path, dst_path)
-    
-    # Resolution check and resampling
-    processed_tifs = list(processing_folder.glob('*.tif'))
-    if processed_tifs:
-        resolutions = []
-        for tif_path in processed_tifs:
-            try:
-                with rasterio.open(tif_path) as src:
-                    resolutions.append(src.res)
-            except rasterio.RasterioIOError as e:
-                print(f"Error opening {tif_path} in processing folder: {e}")
-                return
-
-        first_resolution = resolutions[0] if resolutions else None
-        all_same_resolution = all(res == first_resolution for res in resolutions)
+            reprojectFIMs(str(src_path), str(dst_path), final_crs)
+            compress_tif_lzw(dst_path) 
+            
+    else:
+        print("All rasters are in the same projected CRS. Copying to processing folder.")
+        for src_path in tif_files:
+            shutil.copy(src_path, processing_folder / src_path.name)
 
-        if not all_same_resolution:
-            if target_resolution is not None:
-                for src_path in processed_tifs:
-                    resample_to_resolution(str(src_path), target_resolution, target_resolution)
-            else:
-                coarser_x = max(res[0] for res in resolutions)
-                coarser_y = max(res[1] for res in resolutions)
-                print(f"Using coarser resolution: X={coarser_x}, Y={coarser_y}. Resampling all FIMS to this resolution.")
-                for src_path in processed_tifs:
-                    resample_to_resolution(str(src_path), coarser_x, coarser_y)
-        else:
-            print("All FIMs in the processing folder have the same resolution.")
+    # Resolution Check & Resample if needed
+    processed_tifs = list(processing_folder.glob('*.tif'))
+    final_resolutions = []
+    for tif_path in processed_tifs:
+        with rasterio.open(tif_path) as src:
+            final_resolutions.append(src.res)
+
+    unique_res = set(final_resolutions)
+    if target_resolution:
+        print(f"Resampling all rasters to target resolution: {target_resolution}m.")
+        for src_path in processed_tifs:
+            resample_to_resolution(str(src_path), target_resolution, target_resolution)
+
+    # Otherwise, only resample if resolutions are inconsistent
+    elif len(unique_res) > 1:
+        coarsest_x = max(res[0] for res in final_resolutions)
+        coarsest_y = max(res[1] for res in final_resolutions)
+        print(f"Using coarsest resolution: X={coarsest_x}, Y={coarsest_y}")
+        for src_path in processed_tifs:
+            resample_to_resolution(str(src_path), coarsest_x, coarsest_y)
     else:
-        print("No TIFF files found in the processing folder after CRS standardization.")
+        print("All rasters already have the same resolution. No resampling needed.")

{fimeval-0.1.50.dist-info → fimeval-0.1.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fimeval
-Version: 0.1.50
+Version: 0.1.52
 Summary: A Framework for Automatic Evaluation of Flood Inundation Mapping Predictions Evaluation
 License: GPLv3
 Author: Surface Dynamics Modeling Lab

{fimeval-0.1.50.dist-info → fimeval-0.1.52.dist-info}/RECORD

@@ -1,16 +1,16 @@
 fimeval/BuildingFootprint/__init__.py,sha256=oP9YWLdo6ANzSQFxYLv7Ku_26AY5NkLNhZLK28ICMLo,109
-fimeval/BuildingFootprint/evaluationwithBF.py,sha256=0jqHbzEhDSouXXBOGHuJ2R4yo1rBKrhiC5mXO8SwJek,14167
+fimeval/BuildingFootprint/evaluationwithBF.py,sha256=mnmcfyNPL_XBg9fIDXJjBWsRDKlCZ8HPjIhzCiFJkb8,14352
 fimeval/ContingencyMap/PWBs3.py,sha256=YAg03jzdplYIstG-pZM1MECse7gYjWrJNKAopjgt3uk,1294
 fimeval/ContingencyMap/__init__.py,sha256=ckps2dyg6aci3TA-3P7oTMcCAcSTz9AA6sndHtZEwdE,259
-fimeval/ContingencyMap/evaluationFIM.py,sha256=UJZCioyczx3CEOwNrqGTMQGX_TfAKjTsvvEDK3WzEuA,16880
-fimeval/ContingencyMap/fix_permissions.sh,sha256=SNmYtVviwAs3_--xEE2pk6Mqyqj3XaImOiJMFK1AkDM,378
+fimeval/ContingencyMap/evaluationFIM.py,sha256=F9hI1N0AhBFZhGIimfkIK4MsbHborAyjmPiZ95mFZZE,16828
+fimeval/ContingencyMap/fix_permissions.sh,sha256=prIeJGXwAUO28nhgtCtvcpOxWK-J75rxN4FQ6QjGET4,508
 fimeval/ContingencyMap/methods.py,sha256=kbutfo9FUH-yjvnOXxwLpdErUuebMJ8NjCroNWIYCjo,3299
 fimeval/ContingencyMap/metrics.py,sha256=eEv1zAfmIjyg9OWM1b6-i25q_3jEBmeLZ7JeuvxS1QI,1070
 fimeval/ContingencyMap/plotevaluationmetrics.py,sha256=3bKfPKZnMR39dA3teDVpQBeTFKnF9v_2Vku0JNVGggs,3921
 fimeval/ContingencyMap/printcontingency.py,sha256=Ef0TlGNxvLlrliM2SCkhusgz9BsEGvVOBHAO62YC_QA,5421
 fimeval/__init__.py,sha256=kN114EvzG_BFjd65fKWXg29TqaWvR173EdCN3yj30oc,433
-fimeval/utilis.py,sha256=KNXcR0RvhT_lPqM_8cuAGXMpRtcLMfb_UDqUiMlDevs,7311
-fimeval-0.1.50.dist-info/LICENSE.txt,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-fimeval-0.1.50.dist-info/METADATA,sha256=bf_oFaXWbJk8gufCpypNxyoldI4t36xQfVg8PuroN9g,14848
-fimeval-0.1.50.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-fimeval-0.1.50.dist-info/RECORD,,
+fimeval/utilis.py,sha256=Cueji5DWGAaXTGCcQmkVaHGpIJeIIMNOuq_1KUKM2oA,6920
+fimeval-0.1.52.dist-info/LICENSE.txt,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+fimeval-0.1.52.dist-info/METADATA,sha256=JojzN5T77mRJveolF1lYAJlnKpqDhieHwbwE-hbWF4I,14848
+fimeval-0.1.52.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+fimeval-0.1.52.dist-info/RECORD,,