fimeval 0.1.53__py3-none-any.whl → 0.1.55__py3-none-any.whl

fimeval/BuildingFootprint/evaluationwithBF.py

@@ -6,6 +6,8 @@ import pandas as pd
 from pathlib import Path
 from plotly.subplots import make_subplots
 import plotly.graph_objects as go
+import seaborn as sns
+import matplotlib.pyplot as plt
 
 
 def Changeintogpkg(input_path, output_dir, layer_name):
@@ -19,8 +21,8 @@ def Changeintogpkg(input_path, output_dir, layer_name):
         output_gpkg = os.path.join(output_dir, f"{layer_name}.gpkg")
         gdf.to_file(output_gpkg, driver="GPKG")
         return output_gpkg
-
-
+    
+    
 def GetFloodedBuildingCountInfo(
     building_fp_path,
     study_area_path,
@@ -31,7 +33,6 @@ def GetFloodedBuildingCountInfo(
     basename,
 ):
     output_dir = os.path.dirname(building_fp_path)
-
     building_fp_gpkg = Changeintogpkg(
         building_fp_path, output_dir, "building_footprint"
     )
@@ -42,7 +43,6 @@ def GetFloodedBuildingCountInfo(
     with rasterio.open(raster1_path) as src:
         target_crs = str(src.crs)
 
-    # Reproject all GeoDataFrames to the target CRS
     if building_gdf.crs != target_crs:
         building_gdf = building_gdf.to_crs(target_crs)
         print("reproject building_gdf")
@@ -55,43 +55,29 @@ def GetFloodedBuildingCountInfo(
     clipped_buildings["centroid"] = clipped_buildings.geometry.centroid
 
     centroid_counts = {
-        "Benchmark": 0,
-        "Candidate": 0,
         "False Positive": 0,
         "False Negative": 0,
         "True Positive": 0,
     }
 
-    def count_centroids_in_raster(raster_path, label):
+    def count_centroids_in_contingency(raster_path):
         with rasterio.open(raster_path) as src:
             raster_data = src.read(1)
-            transform = src.transform
-
             for centroid in clipped_buildings["centroid"]:
                 row, col = src.index(centroid.x, centroid.y)
                 if 0 <= row < raster_data.shape[0] and 0 <= col < raster_data.shape[1]:
                     pixel_value = raster_data[row, col]
-                    if label in ["Benchmark", "Candidate"]:
-                        if pixel_value == 2:  # False Positive
-                            centroid_counts[label] += 1
-                    else:
-                        if pixel_value == 2:
-                            centroid_counts["False Positive"] += 1
-                        elif pixel_value == 3:
-                            centroid_counts["False Negative"] += 1
-                        elif pixel_value == 4:
-                            centroid_counts["True Positive"] += 1
-
-    if "bm" in str(raster1_path).lower():
-        count_centroids_in_raster(raster1_path, "Benchmark")
-        count_centroids_in_raster(raster2_path, "Candidate")
+                    if pixel_value == 2:
+                        centroid_counts["False Positive"] += 1
+                    elif pixel_value == 3:
+                        centroid_counts["False Negative"] += 1
+                    elif pixel_value == 4:
+                        centroid_counts["True Positive"] += 1
 
-    elif "candidate" in str(raster2_path).lower():
-        count_centroids_in_raster(raster1_path, "Candidate")
-        count_centroids_in_raster(raster2_path, "Benchmark")
+    count_centroids_in_contingency(contingency_map)
 
-    if "contingency" in str(contingency_map).lower():
-        count_centroids_in_raster(contingency_map, "Contingency")
+    centroid_counts["Candidate"] = centroid_counts["True Positive"] + centroid_counts["False Positive"]
+    centroid_counts["Benchmark"] = centroid_counts["True Positive"] + centroid_counts["False Negative"]
 
     total_buildings = len(clipped_buildings)
     percentages = {
@@ -106,10 +92,10 @@ 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"]
+    if centroid_counts["Benchmark"] > 0:
+        BDR = (centroid_counts["Candidate"] - centroid_counts["Benchmark"]) / centroid_counts["Benchmark"]
+    else:
+        BDR = 0
 
     counts_data = {
         "Category": [
@@ -135,13 +121,12 @@ def GetFloodedBuildingCountInfo(
             f"{BDR:.3f}",
         ],
     }
-
     counts_df = pd.DataFrame(counts_data)
-    csv_file_path = os.path.join(
-        save_dir, "EvaluationMetrics", f"BuildingCounts_{basename}.csv"
-    )
+    csv_file_path = os.path.join(save_dir, "EvaluationMetrics", f"BuildingCounts_{basename}.csv")
+    os.makedirs(os.path.dirname(csv_file_path), exist_ok=True)
     counts_df.to_csv(csv_file_path, index=False)
 
+    # Plotly interactive visualization only
     third_raster_labels = ["False Positive", "False Negative", "True Positive"]
     third_raster_counts = [
         centroid_counts["False Positive"],
@@ -150,81 +135,109 @@ def GetFloodedBuildingCountInfo(
     ]
 
     fig = make_subplots(
-        rows=1,
-        cols=2,
-        subplot_titles=(
-            "Building Counts on Different FIMs",
-            "Contingency Flooded Building Counts",
-        ),
+        rows=1, cols=2,
+        subplot_titles=("Building Counts on Different FIMs", "Contingency Flooded Building Counts"),
     )
 
     fig.add_trace(
         go.Bar(
-            x=["Candidate"],
-            y=[centroid_counts["Candidate"]],
-            text=[f"{centroid_counts['Candidate']}"],
-            textposition="auto",
-            marker_color="#1c83eb",
-            marker_line_color="black",
-            marker_line_width=1,
+            x=["Candidate"], y=[centroid_counts["Candidate"]],
+            text=[f"{centroid_counts['Candidate']}"], textposition="auto",
+            marker_color="#1c83eb", marker_line_color="black", marker_line_width=1,
             name=f"Candidate ({percentages['Candidate']:.2f}%)",
         ),
-        row=1,
-        col=1,
+        row=1, col=1,
     )
-
     fig.add_trace(
         go.Bar(
-            x=["Benchmark"],
-            y=[centroid_counts["Benchmark"]],
-            text=[f"{centroid_counts['Benchmark']}"],
-            textposition="auto",
-            marker_color="#a4490e",
-            marker_line_color="black",
-            marker_line_width=1,
+            x=["Benchmark"], y=[centroid_counts["Benchmark"]],
+            text=[f"{centroid_counts['Benchmark']}"], textposition="auto",
+            marker_color="#a4490e", marker_line_color="black", marker_line_width=1,
             name=f"Benchmark ({percentages['Benchmark']:.2f}%)",
         ),
-        row=1,
-        col=1,
+        row=1, col=1,
     )
 
-    for i in range(len(third_raster_labels)):
+    for i, label in enumerate(third_raster_labels):
         fig.add_trace(
             go.Bar(
-                x=[third_raster_labels[i]],
-                y=[third_raster_counts[i]],
-                text=[f"{third_raster_counts[i]}"],
-                textposition="auto",
+                x=[label], y=[third_raster_counts[i]],
+                text=[f"{third_raster_counts[i]}"], textposition="auto",
                 marker_color=["#ff5733", "#ffc300", "#28a745"][i],
-                marker_line_color="black",
-                marker_line_width=1,
-                name=f"{third_raster_labels[i]} ({percentages[third_raster_labels[i]]:.2f}%)",
+                marker_line_color="black", marker_line_width=1,
+                name=f"{label} ({percentages[label]:.2f}%)",
             ),
-            row=1,
-            col=2,
+            row=1, col=2,
         )
 
     fig.update_layout(
         title="Flooded Building Counts",
         xaxis_title="Inundation Surface",
         yaxis_title="Flooded Building Counts",
-        width=1100,
-        height=400,
-        plot_bgcolor="rgba(0, 0, 0, 0)",
-        paper_bgcolor="rgba(0, 0, 0, 0)",
-        showlegend=True,
-        font=dict(family="Arial", size=18, color="black"),
+        width=1100, height=400,
+        plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
+        showlegend=True, font=dict(family="Arial", size=18, color="black"),
     )
+    fig.show()
+
+    # Seaborn for static PNG saving only
+    df_left = pd.DataFrame({
+        "Category": ["Candidate", "Benchmark"],
+        "Count": [centroid_counts["Candidate"], centroid_counts["Benchmark"]],
+    })
+    df_right = pd.DataFrame({
+        "Category": third_raster_labels,
+        "Count": third_raster_counts,
+    })
+
+    sns.set_theme(style="whitegrid")
+    fig_sb, axes = plt.subplots(1, 2, figsize=(8, 3), constrained_layout=True)
+
+    def style_axes(ax, title_text, xlab, show_ylabel: bool):
+        # Adding a bit of padding so bar labels don’t overlap with the title
+        ax.set_title(title_text, fontsize=16, pad=20)
+        ax.set_xlabel(xlab, fontsize=14, color="black")
+        if show_ylabel:
+            ax.set_ylabel("Flooded Building Counts", fontsize=14, color="black")
+        else:
+            ax.set_ylabel("")
+
+        # Thicker black left/bottom spines
+        for spine in ("left", "bottom"):
+            ax.spines[spine].set_linewidth(1.5)
+            ax.spines[spine].set_color("black")
+
+        sns.despine(ax=ax, right=True, top=True)
+        ax.tick_params(axis="x", labelsize=12, colors="black")
+        ax.tick_params(axis="y", labelsize=12, colors="black")
+
+    # Left panel
+    ax0 = axes[0]
+    sns.barplot(data=df_left, x="Category", y="Count", ax=ax0,
+                palette=["#1c83eb", "#a4490e"])
+    style_axes(ax0, "Building Counts on Different FIMs", "Inundation Surface", show_ylabel=True)
+    for c in ax0.containers:
+        ax0.bar_label(c, fmt="%.0f", label_type="edge", padding=3, fontsize=14, color="black")
+
+    # Right panel
+    ax1 = axes[1]
+    sns.barplot(data=df_right, x="Category", y="Count", ax=ax1,
+                palette=["#ff5733", "#ffc300", "#28a745"])
+    style_axes(ax1, "Contingency Flooded Building Counts", "Category", show_ylabel=False)
+    for c in ax1.containers:
+        ax1.bar_label(c, fmt="%.0f", label_type="edge", padding=3, fontsize=14, color="black")
 
     plot_dir = os.path.join(save_dir, "FinalPlots")
-    if not os.path.exists(plot_dir):
-        os.makedirs(plot_dir)
+    os.makedirs(plot_dir, exist_ok=True)
     output_path = os.path.join(plot_dir, f"BuildingCounts_{basename}.png")
-    fig.write_image(output_path, scale=500 / 96, engine="kaleido")
-    print(f"Performance metrics chart is saved as PNG at {output_path}")
-    fig.show()
+    fig_sb.savefig(output_path, dpi=400)
+    plt.close(fig_sb)
+
+    print(f"PNG were saved in : {output_path}")
 
 
+    
+
 def process_TIFF(
     tif_files, contingency_files, building_footprint, boundary, method_path
 ):
@@ -290,15 +303,19 @@ def detect_shapefile(folder):
 def ensure_pyspark(version: str | None = "3.5.4") -> None:
     """Install pyspark at runtime via `uv pip` into this env (no-op if present)."""
     import importlib, shutil, subprocess, sys, re
+
     try:
         import importlib.util
+
         if importlib.util.find_spec("pyspark"):
             return
     except Exception:
         pass
     uv = shutil.which("uv")
     if not uv:
-        raise RuntimeError("`uv` not found on PATH. Please install uv or add it to PATH.")
+        raise RuntimeError(
+            "`uv` not found on PATH. Please install uv or add it to PATH."
+        )
     if version is None:
         spec = "pyspark"
     else:
@@ -307,7 +324,6 @@ def ensure_pyspark(version: str | None = "3.5.4") -> None:
     subprocess.check_call([uv, "pip", "install", "--python", sys.executable, spec])
 
 
-
 def EvaluationWithBuildingFootprint(
     main_dir,
     method_name,
@@ -338,11 +354,11 @@ def EvaluationWithBuildingFootprint(
                     boundary = detect_shapefile(main_dir)
 
                 building_footprintMS = building_footprint
-                
+
                 if building_footprintMS is None:
                     ensure_pyspark()
                     from .microsoftBF import BuildingFootprintwithISO
-                    
+
                     out_dir = os.path.join(method_path, "BuildingFootprint")
                     if not os.path.exists(out_dir):
                         os.makedirs(out_dir)
@@ -398,11 +414,11 @@ def EvaluationWithBuildingFootprint(
                             boundary = detect_shapefile(os.path.join(main_dir, folder))
 
                         building_footprintMS = building_footprint
-                        
+
                         if building_footprintMS is None:
                             ensure_pyspark()
                             from .microsoftBF import BuildingFootprintwithISO
-                            
+
                             out_dir = os.path.join(method_path, "BuildingFootprint")
                             if not os.path.exists(out_dir):
                                 os.makedirs(out_dir)

fimeval/BuildingFootprint/microsoftBF.py

@@ -18,6 +18,7 @@ warnings.filterwarnings("ignore")
 # Authenticate and initialize Earth Engine
 ee.Authenticate()
 
+
 # %%
 def split_into_tiles(boundary, tile_size=0.1):
     bounds = boundary.total_bounds

fimeval/ContingencyMap/evaluationFIM.py

@@ -31,24 +31,35 @@ def is_writable(path):
 
 def fix_permissions(path):
     path = Path(path).resolve()
-    script_path = Path(__file__).parent / "fix_permissions.sh"
-
-    if not script_path.exists():
-        raise FileNotFoundError(f"Shell script not found: {script_path}")
 
     if is_writable(path):
         return
 
+    uname = platform.system()
+
     try:
-        result = subprocess.run(
-            ["bash", str(script_path), str(path)],
-            check=True,
-            capture_output=True,
-            text=True,
-        )
-        print(result.stdout)
+        if uname in ["Darwin", "Linux"]:
+            subprocess.run(
+                ["chmod", "-R", "u+rwX", str(path)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            print(f"Permissions granted for user (u+rwX): {path}")
+
+        elif "MINGW" in uname or "MSYS" in uname or "CYGWIN" in uname:
+            subprocess.run(
+                ["icacls", str(path), "/grant", "Everyone:F", "/T"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            print(f"Permissions granted for working folder: {path}")
+
+        else:
+            print(f"Unsupported OS: {uname}")
     except subprocess.CalledProcessError as e:
-        print(f"Shell script failed:\n{e.stderr}")
+        print(f"Failed to fix permissions for {path}:\n{e.stderr}")
 
 
 # Function for the evalution of the model
@@ -105,7 +116,7 @@ def evaluateFIM(
         bounding_geom = AOI(benchmark_path, shapefile, save_dir)
 
     else:
-        print(f"--- {method.__name__} is processing ---")
+        print(f"**{method.__name__} is processing**")
         bounding_geom = method(smallest_raster_path, save_dir=save_dir)
 
     # Read and process benchmark raster
@@ -395,7 +406,6 @@ def EvaluateFIM(
         gdf = gpd.read_file(PWB_dir)
 
     # Grant the permission to the main directory
-    print(f"Fixing permissions for {main_dir}...")
     fix_permissions(main_dir)
 
     # runt the process
@@ -414,12 +424,11 @@ def EvaluateFIM(
             for tif_file in tif_files:
                 if "benchmark" in tif_file.name.lower() or "BM" in tif_file.name:
                     benchmark_path = tif_file
-                    print(f"---Benchmark: {tif_file.name}---")
                 else:
                     candidate_path.append(tif_file)
 
         if benchmark_path and candidate_path:
-            print(f"---Flood Inundation Evaluation of {folder_dir.name}---")
+            print(f"**Flood Inundation Evaluation of {folder_dir.name}**")
             Metrics = evaluateFIM(
                 benchmark_path,
                 candidate_path,

fimeval/ContingencyMap/plotevaluationmetrics.py

@@ -2,75 +2,108 @@ import os
 import glob
 import pandas as pd
 import plotly.express as px
+import seaborn as sns
+import matplotlib.pyplot as plt
 
 
 # Function to plot individual metric scores
 def PlotMetrics(csv_path, method_path):
     metrics_df = pd.read_csv(csv_path)
-    # Extract relevant metrics
+
+    # Keep only the desired metrics
     metrics = metrics_df.loc[
-        metrics_df["Metrics"].isin(
-            ["CSI_values", "POD_values", "Acc_values", "Prec_values", "F1_values"]
-        )
+        metrics_df["Metrics"].isin([
+            "CSI_values", "POD_values", "Acc_values", "Prec_values", "F1_values"
+        ])
     ].copy()
 
-    metrics.loc[:, "Metrics"] = metrics["Metrics"].replace(
-        {
-            "CSI_values": "CSI",
-            "POD_values": "POD",
-            "Acc_values": "Accuracy",
-            "Prec_values": "Precision",
-            "F1_values": "F1 Score",
-        }
-    )
+    # Rename for presentation
+    metrics["Metrics"] = metrics["Metrics"].replace({
+        "CSI_values": "CSI",
+        "POD_values": "POD",
+        "Acc_values": "Accuracy",
+        "Prec_values": "Precision",
+        "F1_values": "F1 Score",
+    })
+
     value_columns = metrics.select_dtypes(include="number").columns
 
+    # Output directory
+    plot_dir = os.path.join(method_path, "FinalPlots")
+    os.makedirs(plot_dir, exist_ok=True)
+
     for value_column in value_columns:
         metrics[value_column] = metrics[value_column].round(2)
 
-        # Create the bar plot
-        fig = px.bar(
+        # Showing with Plotly
+        fig_plotly = px.bar(
             metrics,
             x=value_column,
             y="Metrics",
-            title=f"Performance Metrics",
-            labels={value_column: "Score"},
             text=value_column,
             color="Metrics",
+            orientation="h",
             color_discrete_sequence=px.colors.qualitative.Set2,
+            title=f"Performance Metrics"
         )
-        fig.update_traces(texttemplate="%{text:.2f}", textposition="outside")
-        fig.update_layout(
-            yaxis_title="Metrics",
-            xaxis_title="Score",
+        fig_plotly.update_traces(texttemplate="%{text:.2f}", textposition="outside")
+        fig_plotly.update_layout(
             showlegend=False,
-            plot_bgcolor="rgba(0, 0, 0, 0)",
-            paper_bgcolor="rgba(0, 0, 0, 0)",
-            margin=dict(l=10, r=10, t=40, b=10),
-            xaxis=dict(showline=True, linewidth=2, linecolor="black"),
-            yaxis=dict(showline=True, linewidth=2, linecolor="black"),
+            plot_bgcolor="rgba(0,0,0,0)",
+            paper_bgcolor="rgba(0,0,0,0)",
             height=350,
             width=900,
+            xaxis=dict(showline=True, linewidth=2, linecolor="black", title="Score"),
+            yaxis=dict(showline=True, linewidth=2, linecolor="black"),
             title_font=dict(family="Arial", size=24, color="black"),
-            xaxis_title_font=dict(family="Arial", size=20, color="black"),
-            yaxis_title_font=dict(family="Arial", size=20, color="black"),
             font=dict(family="Arial", size=18, color="black"),
         )
+        fig_plotly.show()
 
-        # Save each plot as a PNG, using the column name as the filename
-        plot_dir = os.path.join(method_path, "FinalPlots")
-        if not os.path.exists(plot_dir):
-            os.makedirs(plot_dir)
+        # Save with Seaborn
+        sns.set_theme(style="whitegrid")
+        fig, ax = plt.subplots(figsize=(8, 3))
+        sns.barplot(
+            data=metrics,
+            x=value_column,
+            y="Metrics",
+            hue="Metrics", 
+            palette="Set2",
+            ax=ax,
+            dodge=False,
+            legend=False
+        )
 
-        output_filename = f"EvaluationMetrics_{value_column}.png"
-        output_path = os.path.join(plot_dir, output_filename)
+        # Annotate bars
+        for container in ax.containers:
+            ax.bar_label(container, fmt='%.2f', label_type='edge', fontsize=14)
 
-        # Save the plot as PNG
-        fig.write_image(output_path, engine="kaleido", scale=500 / 96)
-        print(
-            f"Performance metrics chart ({value_column}) saved as PNG at {output_path}"
-        )
-        fig.show()
+        # Styling
+        ax.set_title("Performance Metrics", fontsize=16)
+        ax.set_xlabel("Score", fontsize=16, color="black")   # just bigger, not bold
+        ax.set_ylabel("Metrics", fontsize=16, color="black")
+
+        ax.set_xticks([i/10 for i in range(0, 11, 2)])
+        ax.set_xticklabels([f"{i/10:.1f}" for i in range(0, 11, 2)], fontsize=14, color="black")
+
+        # Increase y-tick label font size
+        ax.tick_params(axis="y", labelsize=12, colors="black")
+        ax.tick_params(axis="x", labelsize=14, colors="black")
+
+        # Force spines black + thicker
+        ax.spines['left'].set_linewidth(1.5)
+        ax.spines['bottom'].set_linewidth(1.5)
+        ax.spines['left'].set_color("black")
+        ax.spines['bottom'].set_color("black")
+
+        sns.despine(right=True, top=True)
+
+        # Save to file
+        save_path = os.path.join(plot_dir, f"EvaluationMetrics_{value_column}.png")
+        plt.tight_layout()
+        fig.savefig(save_path, dpi=400)
+        plt.close(fig)
+        print(f"PNG saved at: {save_path}")
 
 
 def PlotEvaluationMetrics(main_dir, method_name, out_dir):

fimeval/utilis.py

@@ -71,7 +71,6 @@ def reprojectFIMs(src_path, dst_path, target_crs):
                         resampling=Resampling.nearest,
                     )
         else:
-            print(f"Source raster is already in {target_crs}. No reprojection needed.")
             shutil.copy(src_path, dst_path)
         compress_tif_lzw(dst_path)
 
@@ -79,9 +78,7 @@ 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(
@@ -144,14 +141,13 @@ def MakeFIMsUniform(fim_dir, target_crs=None, target_resolution=None):
         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}")
+                print(f"Defaulting to CONUS CRS: {final_crs}, Reprojecting.")
             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
             reprojectFIMs(str(src_path), str(dst_path), final_crs)