Upload 9 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Carson_map[[:space:]](6).png filter=lfs diff=lfs merge=lfs -text

R6_global (3).py

@@ -0,0 +1,11 @@
+
+# R6_global.py
+class SimState:
+    def __init__(self):
+        self.round_counter = 1
+        self.parcel_dict = None
+        self.health_tracking = {}
+    def update_round(self):
+        self.round_counter += 1
+# ✅ Global singleton instance
+sim_state = SimState()

README (2).md

@@ -0,0 +1,12 @@
+---
+title: Cattle-Elk R6 Global
+emoji: 🚀
+colorFrom: blue
+colorTo: red
+sdk: gradio
+sdk_version: 5.25.2
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Sim_Engine (12).py

@@ -0,0 +1,226 @@
+def initialize_parcels(parcel_map, cluster_labels):
+    import numpy as np
+
+    if parcel_map is None or np.size(parcel_map) == 0:
+        raise ValueError("🚨 parcel_map is empty or None — check your input wiring!")
+
+    parcel_map = np.array(parcel_map)
+
+    if parcel_map.ndim != 2:
+        raise ValueError(f"🚨 parcel_map must be 2D — got shape {parcel_map.shape}")
+
+    parcel_dict = {}  # ✅ This is the fix
+
+    for i in range(parcel_map.shape[0]):
+        for j in range(parcel_map.shape[1]):
+            cluster_id = parcel_map[i, j]
+            land_type = cluster_labels.get(cluster_id, "Unknown")
+
+            parcel_dict[(i, j)] = {
+                "land_type": land_type,
+                "forage": None,
+                "health": 1.0,
+                "degraded": False,
+                "cattle_grazing": {
+                    "conservative": land_type == "Productive Grass",
+                    "moderate": land_type in ["Productive Grass", "Pasture/Desert"],
+                    "aggressive": land_type not in ["Water"]
+                },
+                "elk_grazing": {
+                    "default": land_type in ["Riparian Sensitive Zone", "Productive Grass"]
+                }
+            }
+    return parcel_dict
+
+def get_land_forage_rates():
+    return {
+        'Productive Grass': 1.0,
+        'Pasture/Desert': 0.4,
+        'Riparian Sensitive Zone': 1.2,
+        'Rocky Area': 0.2,
+        'Water': 0.0
+    }
+
+
+def assign_initial_forage(parcel_dict, land_forage_rates):
+    for parcel in parcel_dict.values():
+        rate = land_forage_rates.get(parcel["land_type"], 0.0)
+        parcel["forage"] = rate * 100  # initial AUMs
+
+import numpy as np
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import Counter
+from matplotlib.colors import ListedColormap
+import matplotlib.patches as mpatches
+
+def simulate_period(parcel_dict, grazing_strategy="moderate", cattle_stocking_rate=8000, elk_pressure=10000):
+    print(f"\n🟢 Running LP-based simulation using grazing strategy: **{grazing_strategy.upper()}**")
+    print(f"🧠 simulate_period — parcel_dict id = {id(parcel_dict)}")
+
+    for (i, j), parcel in parcel_dict.items():
+        print(f"Parcel ({i},{j}) - forage before grazing : {parcel['forage']:.1f}, health: {parcel['health']:.2f}")
+    
+    import numpy as np
+    from scipy.optimize import linprog
+
+    keys = list(parcel_dict.keys())
+    n_rows = max(i for i, _ in keys) + 1
+    n_cols = max(j for _, j in keys) + 1
+    num_cells = n_rows * n_cols
+
+    # Step 1: Regrowth
+    land_growth_rates = {
+        'Productive Grass': 1.0,
+        'Pasture/Desert': 0.4,
+        'Riparian Sensitive Zone': 1.2,
+        'Rocky Area': 0.2,
+        'Water': 0.0
+    }
+    for parcel in parcel_dict.values():
+        base_growth = land_growth_rates.get(parcel["land_type"], 0.0)
+        weather = np.random.normal(1.0, 0.15)
+        regrowth = base_growth * weather * 1
+        regrowth *= parcel["health"]
+        parcel["forage"] = min(parcel["forage"] + regrowth, 100)
+
+    # Step 2: Subtract uniform elk grazing from all parcels
+    elk_grazing_per_parcel = elk_pressure / num_cells
+    for parcel in parcel_dict.values():
+        parcel["forage"] -= elk_grazing_per_parcel
+        parcel["forage"] = max(parcel["forage"], 0.0)
+
+    # Step 3: LP for cattle
+    cost = []
+    bounds = []
+    eligible_keys = []
+    for i in range(n_rows):
+        for j in range(n_cols):
+            p = parcel_dict[(i, j)]
+            if not p["cattle_grazing"].get(grazing_strategy, False):
+                cost.append(0)
+                bounds.append((0, 0))
+                continue
+            if grazing_strategy in {"conservative", "moderate"} and p["land_type"] == "Riparian Sensitive Zone":
+                cost.append(0)
+                bounds.append((0, 0))
+                continue
+            cost.append((i + j) * 0.02)
+            bounds.append((0, p["forage"]))
+            eligible_keys.append((i, j))
+
+    A_eq = [1.0 if b[1] > 0 else 0.0 for b in bounds]
+    b_eq = [cattle_stocking_rate]
+
+    result = linprog(c=cost, A_eq=[A_eq], b_eq=b_eq, bounds=bounds, method="highs")
+    if not result.success:
+        raise RuntimeError("Grazing LP failed: " + result.message)
+
+    grazing_values = result.x
+
+    # Step 4: Apply grazing and your specified health rule
+    for idx, ((i, j), x) in enumerate(zip(parcel_dict.keys(), grazing_values)):
+        parcel = parcel_dict[(i, j)]
+        parcel["forage"] -= x
+
+        # ✅ Your health rule (fully time-dynamic)
+        if parcel["forage"] <= 0:
+            parcel["health"] = max(parcel["health"] - 0.25, 0.0)
+        elif parcel["forage"] < 20:
+            parcel["health"] = max(parcel["health"] - 0.1, 0.0)
+        else:
+            parcel["health"] = min(parcel["health"] + 0.02, 1.0)
+
+        print("\n🧠 HEALTH + FORAGE SNAPSHOT")
+    for (i, j), parcel in parcel_dict.items():
+        print(f"Parcel ({i},{j}) - forage after grazing : {parcel['forage']:.1f}, health: {parcel['health']:.2f}")
+    
+
+def simulate_periodold(parcel_dict, grazing_strategy="moderate", cattle_stocking_rate=5000, elk_pressure=3000):
+    print(f"\n🟢 Running simulation using cattle grazing strategy: **{grazing_strategy.upper()}**")
+
+    land_growth_rates = {
+        'Productive Grass': 1.0,
+        'Pasture/Desert': 0.4,
+        'Riparian Sensitive Zone': 1.2,
+        'Rocky Area': 0.2,
+        'Water': 0.0
+    }
+
+    # 1. Simulate forage regrowth for 8 months
+    for parcel in parcel_dict.values():
+        base_growth = land_growth_rates.get(parcel["land_type"], 0.0)
+        weather = np.random.normal(1.0, 0.15)
+        regrowth = base_growth * weather * 8  # ← 8 months, as you said
+        regrowth *= parcel["health"]  # degrade means slower regrowth
+        parcel["forage"] = min(parcel["forage"] + regrowth, 100)
+
+    # 2. Count eligible parcels
+    total_grazed_parcels = sum(
+        1 for parcel in parcel_dict.values() if parcel["cattle_grazing"].get(grazing_strategy, False)
+    )
+    if total_grazed_parcels == 0:
+        print("⚠️ No parcels match the selected grazing strategy.")
+        return
+
+    cattle_grazing_per_parcel = cattle_stocking_rate / total_grazed_parcels
+    elk_grazing_per_parcel = elk_pressure / len(parcel_dict)
+
+    # 3. Simulate grazing and degradation
+    for parcel in parcel_dict.values():
+        if not parcel["cattle_grazing"].get(grazing_strategy, False):
+            continue
+
+        total_grazing = cattle_grazing_per_parcel + elk_grazing_per_parcel
+
+        if total_grazing > parcel["forage"]:
+            parcel["degraded"] = True
+            parcel["health"] = max(parcel["health"] - 0.1, 0.0)
+        else:
+            parcel["health"] = min(parcel["health"] + 0.02, 1.0)
+
+        parcel["forage"] = max(parcel["forage"] - total_grazing, 0)
+
+def get_forage_map(parcel_dict, n_rows, n_cols):
+    return np.array([[parcel_dict[(i, j)]["forage"] for j in range(n_cols)] for i in range(n_rows)])
+
+def get_health_map(parcel_dict, n_rows, n_cols):
+    """
+    Returns a 2D numpy array representing the health of each parcel.
+    """
+    return np.array([[parcel_dict[(i, j)]["health"] for j in range(n_cols)] for i in range(n_rows)])
+
+
+def plot_health_map(health_map, title="Parcel Health Levels", save_path=None):
+    """
+    Plots a heatmap of the parcel health values.
+    """
+    import matplotlib.pyplot as plt
+
+    plt.figure(figsize=(8, 6))
+    plt.imshow(health_map, cmap='RdYlGn', origin='upper', vmin=0, vmax=1)
+    plt.colorbar(label="Health Index (0–1)")
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    if save_path:
+        plt.savefig(save_path)
+    plt.show()
+
+
+
+def plot_forage_map(forage_map, title="Parcel Forage Levels"):
+    plt.figure(figsize=(8, 6))
+    plt.imshow(forage_map, cmap='YlGn', origin='upper')
+    plt.colorbar(label="Forage AUMs")
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+def run_full_simulation(parcel_map, cluster_labels, n_rows, n_cols, strategy="moderate"):
+    parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+    land_forage_rates = get_land_forage_rates()
+    assign_initial_forage(parcel_dict, land_forage_rates)
+    simulate_period(parcel_dict, grazing_strategy=strategy)
+    return parcel_dict

Sim_Setup_Fcns (8).py

@@ -0,0 +1,83 @@
+from PIL import Image
+
+def load_and_crop_image(path="Carson_map.png", crop_box=(15, 15, 1000, 950)):
+    img = Image.open(path).convert("RGB")
+    cropped_img = img.crop(crop_box)
+    return cropped_img
+
+
+from sklearn.cluster import KMeans
+import numpy as np
+
+def cluster_image(cropped_img, n_clusters=6):
+    img_array = np.array(cropped_img)
+    pixels = img_array.reshape(-1, 3)
+    kmeans = KMeans(n_clusters=n_clusters, random_state=42).fit(pixels)
+    labels = kmeans.labels_.reshape(img_array.shape[:2])
+    return labels
+
+
+from collections import Counter
+import numpy as np
+
+def build_parcel_map(clustered_img, grid_size=20):
+    height, width = clustered_img.shape
+    n_rows = height // grid_size
+    n_cols = width // grid_size
+    parcel_map = np.zeros((n_rows, n_cols), dtype=int)
+
+    for i in range(n_rows):
+        for j in range(n_cols):
+            patch = clustered_img[i*grid_size:(i+1)*grid_size, j*grid_size:(j+1)*grid_size].flatten()
+            dominant = Counter(patch).most_common(1)[0][0]
+            parcel_map[i, j] = dominant
+
+    return parcel_map, n_rows, n_cols
+
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.colors import ListedColormap
+
+def plot_parcel_map(parcel_map, cluster_labels, land_colors, title="25×25 Land Parcels by Land Type"):
+    cmap = ListedColormap(land_colors)
+    plt.figure(figsize=(10, 8))
+    plt.imshow(parcel_map, cmap=cmap, origin='upper')
+    legend_patches = [mpatches.Patch(color=land_colors[i], label=cluster_labels[i]) for i in cluster_labels]
+    plt.legend(handles=legend_patches, bbox_to_anchor=(1.05, 1), loc='upper left', title="Land Type")
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+def plot_parcel_map_to_file(parcel_map, cluster_labels, land_colors, save_path="clustered_map.png", title="25×25 Land Parcels by Land Type"):
+    cmap = ListedColormap(land_colors)
+    fig, ax = plt.subplots(figsize=(10, 8))
+    cax = ax.imshow(parcel_map, cmap=cmap, origin='upper')
+    legend_patches = [mpatches.Patch(color=land_colors[i], label=cluster_labels[i]) for i in cluster_labels]
+    ax.legend(handles=legend_patches, bbox_to_anchor=(1.05, 1), loc='upper left', title="Land Type")
+    ax.set_title(title)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+
+def get_cluster_labels():
+    return {
+        0: 'Pasture/Desert',
+        1: 'Productive Grass',
+        2: 'Pasture/Desert',
+        3: 'Riparian Sensitive Zone',
+        4: 'Rocky Area',
+        5: 'Water'
+    }
+
+
+def get_land_colors():
+    return ['#dfb867', '#a0ca76', '#dfb867', '#5b8558', '#888888', '#3a75a8']
+
+
+
+
+

app (26).py

@@ -0,0 +1,186 @@
+import os
+import gradio as gr
+import numpy as np
+from openai import OpenAI
+from Sim_Setup_Fcns import (
+    load_and_crop_image, cluster_image, build_parcel_map,
+    get_cluster_labels, get_land_colors, plot_parcel_map_to_file
+)
+from Sim_Engine import run_full_simulation
+from feedback_fcns import (
+    summarize_initial_conditions, plot_forage_map_to_file,
+    elk_feedback, usfs_feedback, simulate_and_summarize, full_response
+)
+
+from zone_utils import (
+    identify_zones, plot_labeled_zones,
+    assign_zone_labels, save_zone_info_to_excel,override_zone_id_and_label
+)
+from R6_global import sim_state
+#sim_state = SimState()  # ✅ Create it ONCE here, globally
+#if sim_state.parcel_dict is None:
+#    from Sim_Engine import initialize_parcels, assign_initial_forage, get_land_forage_rates
+#    sim_state.parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+#    assign_initial_forage(sim_state.parcel_dict, get_land_forage_rates())
+
+# === Setup on Launch ===
+img = load_and_crop_image("Carson_map.png")
+clustered_img = cluster_image(img)
+parcel_map, n_rows, n_cols = build_parcel_map(clustered_img)
+cluster_labels = get_cluster_labels()
+land_colors = get_land_colors()
+plot_parcel_map_to_file(parcel_map, cluster_labels, land_colors, save_path="clustered_map.png")
+
+# === Zoning ===
+
+# 1. Identify contiguous zones
+zone_map, zone_to_cluster = identify_zones(parcel_map, connectivity="queen")
+
+# 2. Assign human-readable labels (before override)
+zone_labels = assign_zone_labels(zone_to_cluster)
+# === Manual override for mislabeled riparian zone ===
+# First, update the zone label once
+for zid, lbl in zone_labels.items():
+    if lbl == "A" and zone_to_cluster[zid] == 1:
+        zone_labels[zid] = "Riparian A1"
+    if lbl == "M" and zone_to_cluster[zid] == 1:
+         zone_labels[zid] = "Riparian A2"
+# Then update all matching parcels
+for i in range(n_rows):
+    for j in range(n_cols):
+        zone_id = zone_map[i, j]
+        if zone_labels.get(zone_id) == "Riparian A1":
+            parcel_map[i, j] = 2
+        if zone_labels.get(zone_id) == "Riparian A2":
+            parcel_map[i, j] = 2
+
+#       
+
+
+# ⬇️ Add this block right after the override
+zone_to_cluster = {}
+for zone_id in np.unique(zone_map):
+    indices = np.argwhere(zone_map == zone_id)
+    if len(indices) > 0:
+        i, j = indices[0]
+        zone_to_cluster[zone_id] = parcel_map[i, j]
+
+# 6. Plot labeled zones after override and mapping
+plot_labeled_zones(zone_map, zone_labels, zone_to_cluster, save_path="zones_labeled.png")
+
+# 5. Define cluster-to-class mapping (should stay after override)
+cluster_to_class = {
+    0: "desert",
+    1: "pasture",
+    2: "riparain",
+    3: "sensitive riparian",
+    4: "wetland",
+    5: "water"
+}
+
+# 7. Save zone info to Excel
+zone_excel_path = "zone_info.xlsx"
+save_zone_info_to_excel(
+    parcel_map, zone_map, zone_labels, zone_to_cluster, cluster_to_class,
+    save_path=zone_excel_path
+)
+
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+# === Gradio App ===
+with gr.Blocks() as demo:
+    gr.Markdown("# AGEC 3052 — Grazing Strategy Simulation")
+    gr.Image(value="clustered_map.png", label="Initial 25×25 Parcel Layout")
+    gr.Image(value="zones_labeled.png", label="Labeled Pasture & Riparian Zones")
+    # ✅ Downloadable Excel
+    gr.File(value=zone_excel_path, label="Download Zone Info (Excel)")
+    
+    plan = gr.Radio(["Conservative", "Normal", "Aggressive"], label="Grazing Plan")
+    essay = gr.Textbox(lines=8, label="Your Essay Justifying the Plan")
+
+    elk_output = gr.Textbox(label="Elk Stakeholder Feedback")
+    usfs_output = gr.Textbox(label="USFS Feedback")
+    sim_output = gr.Textbox(label="Simulation Results", lines=2)
+    sim_image = gr.Image(label="Forage Map After Simulation", type="filepath")
+    health_image = gr.Image(label="Health Map After Simulation", type="filepath")
+
+    round_counter = gr.State(value=1)
+    history = gr.State(value=[summarize_initial_conditions(n_rows, n_cols)])
+
+    from R6_global import sim_state
+#   sim_state = SimState()  # ✅ Define this at the top of app.py
+
+    parcel_map_state = gr.State(value=parcel_map)
+    cluster_labels_state = gr.State(value=cluster_labels)
+    n_rows_state = gr.State(value=n_rows)
+    n_cols_state = gr.State(value=n_cols)
+
+    def submit_handler(plan_choice, essay_text, parcel_map, cluster_labels, n_rows, n_cols, history_val):
+        from R6_global import sim_state
+        if sim_state.parcel_dict is None:
+            from Sim_Engine import initialize_parcels, assign_initial_forage, get_land_forage_rates
+            sim_state.parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+            assign_initial_forage(sim_state.parcel_dict, get_land_forage_rates())
+
+        parcel_dict = sim_state.parcel_dict
+        round_counter = sim_state.round_counter
+
+        return full_response(plan_choice, essay_text, history_val[-1])
+
+
+#    def sim_handler(plan_choice, round_val, history_val):
+#        summary, map_path, health_path, new_round = simulate_and_summarize(
+#            plan_choice, round_val, parcel_map, cluster_labels, n_rows, n_cols,
+#            run_full_simulation, history_val
+#        )
+#        history_val.append(summary)
+    def sim_handler(plan_choice, round_val, history_val):
+        from R6_global import sim_state
+#        sim_state = SimState()
+
+        print(f"DEBUG: sim_state.parcel_dict is {type(sim_state.parcel_dict)}")
+
+        # Step 1: Initialize parcel_dict if it's missing
+        if sim_state.parcel_dict is None:
+                from Sim_Engine import initialize_parcels, assign_initial_forage, get_land_forage_rates
+                print("DEBUG: Initializing parcel_dict inside sim_handler")
+
+                sim_state.parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+                assign_initial_forage(
+                        sim_state.parcel_dict,
+                        get_land_forage_rates()
+                )
+
+        # Ensure it's initialized
+        assert sim_state.parcel_dict is not None, "🚨 sim_handler: parcel_dict is STILL None after attempted init"
+
+        # Step 2: Run the simulation
+        summary, map_path, health_path, new_round, updated_parcel_dict = simulate_and_summarize(
+            plan_choice, round_val, parcel_map, cluster_labels, n_rows, n_cols,
+            run_full_simulation, history_val
+        )
+        sim_state.parcel_dict = updated_parcel_dict  # ✅ Store the updated parcel dict
+
+
+        # Step 3: Manually increment round and return
+        sim_state.round_counter += 1
+        print(f"DEBUG: Updated round = {sim_state.round_counter}")
+        history_val.append(summary)
+        return summary, map_path, health_path, sim_state.round_counter, history_val
+
+    
+    submit_btn = gr.Button("Submit Grazing Plan")
+    sim_btn = gr.Button("Run Simulation")
+
+#    submit_btn.click(fn=submit_handler, inputs=[plan, essay, history], outputs=[elk_output, usfs_output])
+    submit_btn.click(
+        fn=submit_handler,
+        inputs=[plan, essay, parcel_map_state, cluster_labels_state, n_rows_state, n_cols_state, history],
+        outputs=[elk_output, usfs_output]
+    )
+
+
+    sim_btn.click(fn=sim_handler, inputs=[plan, round_counter, history], outputs=[sim_output, sim_image, health_image, round_counter, history])
+
+demo.launch()

feedback_fcns (11).py

@@ -0,0 +1,241 @@
+import os
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+from openai import OpenAI
+from Sim_Engine import simulate_period
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+def summarize_initial_conditions(n_rows, n_cols):
+    from R6_global import sim_state
+#    sim_state = SimState()
+    num_parcels = n_rows * n_cols
+    avg_forage = round(random.uniform(6.5, 8.0), 1)
+    degraded_pct = round(random.uniform(0.0, 2.0), 1)
+    riparian_health = random.choice(["excellent", "moderate", "fragile"])
+    elk_corridor_status = random.choice([
+        "completely intact and lightly used",
+        "intact but under slight pressure from cattle movement",
+        "showing signs of fragmentation near key crossings"
+    ])
+    rainfall_outlook = random.choice(["normal", "below average", "above average"])
+
+    return (
+        f"There are {num_parcels} parcels in total. Grazing has not yet occurred.\n"
+        f"Average forage availability is {avg_forage} AUMs per parcel, with about {degraded_pct}% of land already degraded due to prior conditions.\n"
+        f"Riparian zone condition is {riparian_health}, and the elk movement corridor is {elk_corridor_status}.\n"
+        f"The seasonal rainfall outlook is {rainfall_outlook}."
+    )
+
+def plot_forage_map_to_file(parcel_dict, n_rows, n_cols, title="Forage Map", save_path="forage_map.png"):
+    forage_map = np.array([
+        [parcel_dict[(i, j)]["forage"] for j in range(n_cols)]
+        for i in range(n_rows)
+    ])
+    fig, ax = plt.subplots(figsize=(8, 6))
+    cax = ax.imshow(forage_map, cmap='YlGn', origin='upper')
+    fig.colorbar(cax, label="Forage AUMs")
+    ax.set_title(title)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+def elk_feedback(plan_choice, current_summary):
+    prompt = f"""
+You represent a coalition of elk-related interests: conservationists, hunting advocates, and the hospitality/lodging industry.
+A student has selected the **'{plan_choice}'** cattle grazing strategy. Below are the current ecological conditions:
+-----
+{current_summary}
+-----
+Please do the following:
+- Explicitly choose **one elk management strategy** from the list:
+  - **Preserve**: strict elk protections, no hunting, unrestricted movement
+  - **Cooperate**: shared use corridor, some riparian restrictions, sustainable elk population
+  - **Exploit**: prioritize hunting/tourism, tolerate reduced elk numbers and access
+- Reflect each group's view briefly, but unify the final position.
+- Justify your strategy choice based on the above ecological indicators.
+"""
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.8
+    )
+    return response.choices[0].message.content
+
+def usfs_feedback(plan_choice, student_essay, current_summary):
+    # Extract the AUM line from the summary
+    aum_line = ""
+    for line in current_summary.split("\n"):
+        if "Average forage availability" in line:
+            aum_line = line.strip()
+            break
+
+    prompt = f"""
+You are a USFS land management agent evaluating a student’s cattle grazing proposal.
+
+The student selected the **'{plan_choice}'** strategy and submitted this justification:
+-----
+{student_essay}
+-----
+
+Here are the current rangeland conditions:
+-----
+{current_summary}
+-----
+
+🚨 **Must Include Block**:
+You must include this sentence exactly in your response:
+→ "{aum_line}"
+
+Then provide your evaluation:
+- Comment on forage, degradation, riparian and corridor health
+- State whether the plan is ecologically sound
+- Suggest improvements if needed
+- Keep the tone professional, clear, and grounded in the data
+"""
+
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.7
+    )
+    return response.choices[0].message.content
+
+def simulate_and_summarizeold(plan_choice, round_counter, parcel_dict, parcel_map, cluster_labels, n_rows, n_cols, elk_pressure):
+    # Interpret strategy
+    strategy_map = {
+        "conservative": "conservative",
+        "normal": "moderate",
+        "aggressive": "aggressive"
+    }
+    strategy = strategy_map.get(plan_choice.lower(), "moderate")
+
+    # ✅ Reuse incoming parcel_dict — do not reset
+    print(f"🔁 simulate_and_summarize — calling simulate_period on id={id(parcel_dict)}")
+    simulate_period(parcel_dict, grazing_strategy=strategy, elk_pressure=elk_pressure)
+
+    # Extract summary
+    forage_vals = [p["forage"] for p in parcel_dict.values()]
+    avg_forage = sum(forage_vals) / len(forage_vals)
+    degraded_pct = 100 * sum(p["health"] < 0.5 for p in parcel_dict.values()) / len(parcel_dict)
+
+    summary = (
+        f"After Round {round_counter} with the '{plan_choice}' plan:\n"
+        f"Avg forage: {avg_forage:.1f} AUMs, Parcels with low health (<0.5): {degraded_pct:.1f}%"
+    )
+
+    # Generate map visuals
+    from Sim_Engine import get_forage_map, get_health_map, plot_forage_map, plot_health_map
+    forage_map = get_forage_map(parcel_dict, n_rows, n_cols)
+    health_map = get_health_map(parcel_dict, n_rows, n_cols)
+    plot_forage_map(forage_map, title=f"Forage Map (Round {round_counter})", save_path="forage_map.png")
+    plot_health_map(health_map, title=f"Health Map (Round {round_counter})", save_path="health_map.png")
+
+    return summary, "forage_map.png", "health_map.png", round_counter + 1, parcel_dict
+from R6_global import SimState
+from Sim_Engine import initialize_parcels, assign_initial_forage, get_land_forage_rates
+
+def simulate_and_summarize(plan_choice, round_counter, parcel_map, cluster_labels, n_rows, n_cols, run_full_simulation, history):
+        from R6_global import sim_state
+        from Sim_Engine import initialize_parcels, assign_initial_forage, get_land_forage_rates, simulate_period, get_health_map, plot_health_map
+        from feedback_fcns import plot_forage_map_to_file
+
+        if sim_state.parcel_dict is None:
+                print("🛠 simulate_and_summarize: initializing parcel_dict inside feedback_fcns.py")
+                sim_state.parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+                assign_initial_forage(sim_state.parcel_dict, get_land_forage_rates())
+
+        parcel_dict = sim_state.parcel_dict
+        round_counter = sim_state.round_counter
+
+        if parcel_dict is None:
+                raise ValueError("❌ parcel_dict is None — it must be initialized before calling simulate_and_summarize.")
+
+        strategy_map = {
+                "conservative": "conservative",
+                "normal": "moderate",
+                "aggressive": "aggressive"
+        }
+        strategy = strategy_map.get(plan_choice.lower())
+
+        # ✅ Run the simulation and print parcel_dict ID
+        print(f"🔁 simulate_and_summarize — calling simulate_period on id={id(parcel_dict)}")
+        simulate_period(parcel_dict, grazing_strategy=strategy)
+
+        # ✅ Plot updated forage and health maps
+        plot_forage_map_to_file(parcel_dict, n_rows, n_cols, title=f"Round {round_counter} Forage Map")
+        health_map = get_health_map(parcel_dict, n_rows, n_cols)
+        plot_health_map(health_map, title=f"Round {round_counter} Health Map", save_path="health_map.png")
+
+        # ✅ Calculate summary
+        forage_vals = [p["forage"] for p in parcel_dict.values()]
+        avg_forage = sum(forage_vals) / len(forage_vals)
+        degraded_pct = 100 * sum(p["degraded"] for p in parcel_dict.values()) / len(parcel_dict)
+
+        summary = (
+                f"After Round {round_counter} with the '{plan_choice}' plan:\n"
+                f"Avg forage: {avg_forage:.1f} AUMs, Degraded parcels: {degraded_pct:.1f}%"
+        )
+
+        # ✅ Save state for next round
+        sim_state.parcel_dict = parcel_dict
+
+        return summary, "forage_map.png", "health_map.png", sim_state.round_counter, sim_state.parcel_dict
+
+
+def simulate_and_summarizeoldapr19(plan_choice, round_counter, parcel_map, cluster_labels, n_rows, n_cols, run_full_simulation, history):
+    from R6_global import sim_state
+    from Sim_Engine import initialize_parcels, assign_initial_forage, get_land_forage_rates
+
+#    sim_state = SimState()
+
+    if sim_state.parcel_dict is None:
+        print("🛠 simulate_and_summarize: initializing parcel_dict inside feedback_fcns.py")
+        sim_state.parcel_dict = initialize_parcels(parcel_map, cluster_labels)
+        assign_initial_forage(sim_state.parcel_dict, get_land_forage_rates())
+
+    parcel_dict = sim_state.parcel_dict
+    round_counter = sim_state.round_counter
+
+    if parcel_dict is None:
+        raise ValueError("❌ parcel_dict is None — it must be initialized before calling simulate_and_summarize.")
+    strategy_map = {
+        "conservative": "conservative",
+        "normal": "moderate",
+        "aggressive": "aggressive"
+    }
+    strategy = strategy_map.get(plan_choice.lower())
+#    parcel_dict = run_full_simulation(parcel_map, cluster_labels, n_rows, n_cols, strategy=strategy)
+
+    plot_forage_map_to_file(parcel_dict, n_rows, n_cols, title=f"Round {round_counter} Forage Map")
+
+    # ✅ ADD THIS BLOCK
+    from Sim_Engine import get_health_map, plot_health_map
+    health_map = get_health_map(parcel_dict, n_rows, n_cols)
+    plot_health_map(health_map, title=f"Round {round_counter} Health Map", save_path="health_map.png")
+
+    
+    forage_vals = [p["forage"] for p in parcel_dict.values()]
+    avg_forage = sum(forage_vals) / len(forage_vals)
+    degraded_pct = 100 * sum(p["degraded"] for p in parcel_dict.values()) / len(parcel_dict)
+
+    summary = (
+        f"After Round {round_counter} with the '{plan_choice}' plan:\n"
+        f"Avg forage: {avg_forage:.1f} AUMs, Degraded parcels: {degraded_pct:.1f}%"
+    )
+#    sim_state.round_counter += 1
+#    return summary, "forage_map.png", "health_map.png", sim_state.round_counter
+#    return summary, "forage_map.png", "health_map.png", sim_state.round_counter, sim_state.parcel_dict
+    from R6_global import sim_state
+    sim_state.parcel_dict = parcel_dict  # ✅ Save it
+
+    return summary, "forage_map.png", "health_map.png", sim_state.round_counter, sim_state.parcel_dict
+
+
+
+def full_response(plan_choice, essay_text, current_summary):
+    elk_resp = elk_feedback(plan_choice, current_summary)
+    usfs_resp = usfs_feedback(plan_choice, essay_text, current_summary)
+    return elk_resp, usfs_resp

requirements (11).txt

@@ -0,0 +1,13 @@
+huggingface_hub==0.25.2
+gradio
+numpy
+pandas
+gradio==4.14.0
+openai>=1.0.0
+scikit-learn
+matplotlib
+numpy
+pillow
+pydantic==2.10.6
+openpyxl
+

zone_utils (6).py

@@ -0,0 +1,432 @@
+cluster_to_class = {
+    0: "desert",
+    1: "pasture",
+    2: "riaprain",
+    3: "sensitive riparian",
+    4: "wetland",
+    5: "water"
+}
+
+
+import numpy as np
+from collections import deque
+
+def identify_zones(parcel_map, connectivity="queen"):
+    """
+    Identifies contiguous zones in a 2D parcel map using connected component labeling.
+
+    Parameters:
+        parcel_map (np.ndarray): 2D array where each value is a cluster ID (e.g., land type).
+        connectivity (str): "rook" (4-way) or "queen" (8-way) connectivity.
+
+    Returns:
+        zone_map (np.ndarray): Same shape as parcel_map, each zone gets a unique integer ID.
+        zone_to_cluster (dict): Maps each zone ID to its underlying cluster ID.
+    """
+    n_rows, n_cols = parcel_map.shape
+    zone_map = -1 * np.ones_like(parcel_map, dtype=int)
+    visited = np.zeros_like(parcel_map, dtype=bool)
+    zone_id = 0
+
+    if connectivity == "queen":
+        directions = [(-1, -1), (-1, 0), (-1, 1),
+                      (0, -1),          (0, 1),
+                      (1, -1),  (1, 0), (1, 1)]
+    else:  # "rook"
+        directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+    for i in range(n_rows):
+        for j in range(n_cols):
+            if visited[i, j]:
+                continue
+            cluster_id = parcel_map[i, j]
+            queue = deque([(i, j)])
+            while queue:
+                x, y = queue.popleft()
+                if visited[x, y] or parcel_map[x, y] != cluster_id:
+                    continue
+                visited[x, y] = True
+                zone_map[x, y] = zone_id
+                for dx, dy in directions:
+                    nx, ny = x + dx, y + dy
+                    if 0 <= nx < n_rows and 0 <= ny < n_cols and not visited[nx, ny]:
+                        if parcel_map[nx, ny] == cluster_id:
+                            queue.append((nx, ny))
+            zone_id += 1
+
+    # Optional: Map zone_id → cluster_id
+    zone_to_cluster = {}
+    for zid in range(zone_id):
+        indices = np.argwhere(zone_map == zid)
+        if len(indices) > 0:
+            i, j = indices[0]
+            zone_to_cluster[zid] = parcel_map[i, j]
+
+    return zone_map, zone_to_cluster
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_labeled_zones(zone_map, zone_labels, zone_to_cluster, save_path="labeled_zones.png"):
+    """
+    Plots a zone map with human-readable labels and cluster-based custom colors.
+
+    Colors (by cluster ID):
+        0: tan
+        1: green
+        2: rose
+        3: red
+        4: purple
+        5: blue
+    """
+    # Custom color map for cluster IDs (NOT zone IDs)
+    cluster_colors = {
+        0: "#D2B48C",  # tan
+        1: "#228B22",  # green
+        2: "#FF66CC",  # rose
+        3: "#FF0000",  # red
+        4: "#800080",  # purple
+        5: "#1E90FF",  # blue
+    }
+
+    n_rows, n_cols = zone_map.shape
+    rgb_map = np.zeros((n_rows, n_cols, 3))
+
+    # Map each parcel to its cluster color
+    for i in range(n_rows):
+        for j in range(n_cols):
+            zone_id = zone_map[i, j]
+            cluster_id = zone_to_cluster.get(zone_id, 0)
+            hex_color = cluster_colors.get(cluster_id, "#AAAAAA")  # fallback = gray
+            rgb = tuple(int(hex_color.lstrip('#')[k:k+2], 16)/255 for k in (0, 2, 4))
+            rgb_map[i, j] = rgb
+
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.imshow(rgb_map)
+
+    for zone_id, label in zone_labels.items():
+        positions = np.argwhere(zone_map == zone_id)
+        if len(positions) == 0:
+            continue
+        center_i, center_j = positions.mean(axis=0)
+        cluster = zone_to_cluster.get(zone_id, "?")
+        label_text = f"{label} ({cluster})"
+        ax.text(center_j, center_i, label_text, color="white", ha="center", va="center",
+                fontsize=9, fontweight="bold",
+                bbox=dict(facecolor="black", alpha=0.5, boxstyle="round,pad=0.3"))
+
+    ax.set_title("Labeled Grazing & Riparian Zones (Custom Colors)")
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_labeled_zonesold3am(zone_map, zone_labels, zone_to_cluster, save_path="labeled_zones.png"):
+    """
+    Plots a zone map with fixed colors based on cluster class (e.g., pasture = green, desert = tan),
+    and appends the cluster ID to each label (e.g., "A (1)").
+    
+    Parameters:
+        zone_map (np.ndarray): 2D array of zone IDs (integers).
+        zone_labels (dict): Mapping from zone_id to human-readable label (str).
+        zone_to_cluster (dict): Mapping from zone_id to cluster/group ID (int).
+        save_path (str): File path to save the plotted image.
+    """
+
+    # === Fixed colors by cluster ID ===
+    cluster_color_map = {
+        0: "#d2b48c",  # Desert – tan
+        1: "#228B22",  # Pasture – green
+        2: "#87CEEB",  # Water – light blue
+        3: "#FF69B4",  # Riparian – pink
+        4: "#8B0000",  # Sensitive riparian – dark red
+        5: "#9370DB",  # Town – purple
+    }
+
+    # === Build a color image based on cluster color ===
+    rows, cols = zone_map.shape
+    color_image = np.zeros((rows, cols, 3))
+
+    for i in range(rows):
+        for j in range(cols):
+            zone_id = zone_map[i, j]
+            cluster_id = zone_to_cluster.get(zone_id, 0)
+            hex_color = cluster_color_map.get(cluster_id, "#888888")  # default gray
+            rgb = tuple(int(hex_color.lstrip("#")[k:k+2], 16)/255.0 for k in (0, 2, 4))
+            color_image[i, j] = rgb
+
+    # === Plot map ===
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.imshow(color_image)
+
+    for zone_id in sorted(np.unique(zone_map)):
+        if zone_id not in zone_labels:
+            continue
+        label = zone_labels[zone_id]
+        group = zone_to_cluster.get(zone_id, "?")
+        label_text = f"{label} ({group})"
+        positions = np.argwhere(zone_map == zone_id)
+        if len(positions) == 0:
+            continue
+        center_i, center_j = positions.mean(axis=0)
+        ax.text(center_j, center_i, label_text, color="white", ha="center", va="center",
+                fontsize=9, fontweight="bold",
+                bbox=dict(facecolor="black", alpha=0.5, boxstyle="round,pad=0.3"))
+
+    ax.set_title("Labeled Grazing & Riparian Zones")
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_labeled_zonesold(zone_map, zone_labels, zone_to_cluster, save_path="labeled_zones.png"):
+    """
+    Plots a zone map with human-readable labels (e.g., "A", "B", "Riparian A"),
+    and appends the cluster ID to each label (e.g., "A (0)").
+    
+    Parameters:
+        zone_map (np.ndarray): 2D array of zone IDs (integers).
+        zone_labels (dict): Mapping from zone_id to human-readable label (str).
+        zone_to_cluster (dict): Mapping from zone_id to cluster/group ID (int).
+        save_path (str): File path to save the plotted image.
+    """
+    unique_ids = sorted(np.unique(zone_map))
+    color_map = plt.get_cmap('tab20', len(unique_ids))
+
+    fig, ax = plt.subplots(figsize=(8, 6))
+    cax = ax.imshow(zone_map, cmap=color_map, vmin=0, vmax=len(unique_ids) - 1)
+
+    # Add label with group ID
+    for zone_id in unique_ids:
+        if zone_id not in zone_labels:
+            continue
+        label = zone_labels[zone_id]
+        group = zone_to_cluster.get(zone_id, "?")
+        label_text = f"{label} ({group})"  # append group ID
+
+        positions = np.argwhere(zone_map == zone_id)
+        if len(positions) == 0:
+            continue
+        center_i, center_j = positions.mean(axis=0)
+        ax.text(center_j, center_i, label_text, color="white", ha="center", va="center",
+                fontsize=9, fontweight="bold",
+                bbox=dict(facecolor="black", alpha=0.5, boxstyle="round,pad=0.3"))
+
+    ax.set_title("Labeled Grazing & Riparian Zones")
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+
+def assign_zone_labels(zone_to_cluster):
+    """
+    Assigns human-readable labels to each zone based on its cluster type.
+    Riparian zones are labeled like 'Riparian A', 'Riparian B', etc.
+    Other zones are labeled 'A', 'B', etc. by group type.
+
+    Returns:
+        zone_labels (dict): zone_id → label string
+    """
+    label_counts = {}  # track how many zones per type
+    zone_labels = {}
+
+    for zone_id, cluster_id in zone_to_cluster.items():
+        land_class = cluster_to_class.get(cluster_id, f"cluster{cluster_id}")
+        count = label_counts.get(land_class, 0)
+        suffix = chr(65 + count)  # A, B, C...
+        if "riparian" in land_class:
+            label = f"{land_class.title()} {suffix}"
+        else:
+            label = f"{suffix}"
+        zone_labels[zone_id] = label
+        label_counts[land_class] = count + 1
+
+    return zone_labels
+
+
+def assign_zone_labels_old(zone_to_cluster, cluster_to_class):
+    """
+    Creates a dictionary mapping zone_id → human-readable labels (e.g., "A", "Riparian B").
+
+    Parameters:
+        zone_to_cluster (dict): zone_id → cluster ID
+        cluster_to_class (dict): cluster ID → class name (e.g., "pasture", "riparian")
+    
+    Returns:
+        dict: zone_id → human-friendly label
+    """
+    label_counts = {}  # Track how many zones per class
+    zone_labels = {}
+
+    for zone_id, cluster_id in zone_to_cluster.items():
+        zone_class = cluster_to_class.get(cluster_id, "Unknown")
+        count = label_counts.get(zone_class, 0)
+
+        # Generate a label like "Riparian A", "Pasture B", etc.
+        letter = chr(ord('A') + count)
+        label = f"{zone_class.capitalize()} {letter}" if zone_class != "Unknown" else f"Zone {zone_id}"
+
+        zone_labels[zone_id] = label
+        label_counts[zone_class] = count + 1
+
+    return zone_labels
+
+import numpy as np
+import pandas as pd
+
+def save_zone_info_to_excel(parcel_map, zone_map, zone_labels, zone_to_cluster, cluster_to_class, save_path="zone_details.xlsx"):
+    """
+    Save detailed zone information to an Excel file.
+
+    Parameters:
+        parcel_map (np.ndarray): 2D array with cluster IDs.
+        zone_map (np.ndarray): 2D array with zone IDs.
+        zone_labels (dict): zone_id → human-friendly label (e.g., "A", "Riparian B")
+        zone_to_cluster (dict): zone_id → cluster ID
+        cluster_to_class (dict): cluster ID → land class string (e.g., "pasture", "riparian")
+        save_path (str): File path to save Excel.
+    """
+    rows, cols = parcel_map.shape
+    data = []
+
+    for i in range(rows):
+        for j in range(cols):
+            zone_id = zone_map[i, j]
+            cluster_id = parcel_map[i, j]
+            label = zone_labels.get(zone_id, "Unknown")
+            zone_class = cluster_to_class.get(cluster_id, "Unknown")
+            data.append({
+                "Row": i,
+                "Col": j,
+                "Zone ID": zone_id,
+                "Zone Label": label,
+                "Cluster ID": cluster_id,
+                "Zone Class": zone_class
+            })
+
+    df = pd.DataFrame(data)
+    df.to_excel(save_path, index=False)
+    print(f"✅ Zone info saved to {save_path}")
+
+
+def override_zone_id_and_label(zone_map, zone_labels, from_id, from_label, to_id, to_label):
+    """
+    Reassigns all parcels with a given zone ID and label to a new zone ID and label.
+    
+    Parameters:
+        zone_map (np.ndarray): 2D array with zone IDs.
+        zone_labels (dict): zone_id → label.
+        from_id (int): Zone ID to search for.
+        from_label (str): Must match the current label for that zone.
+        to_id (int): Zone ID to assign.
+        to_label (str): New label for the new zone ID.
+    
+    Returns:
+        zone_map (np.ndarray): Updated zone map.
+        zone_labels (dict): Updated labels.
+    """
+    # Step 1: Confirm the label matches
+    if zone_labels.get(from_id) != from_label:
+        print(f"❌ Mismatch: Zone {from_id} label is '{zone_labels.get(from_id)}', not '{from_label}'")
+        return zone_map, zone_labels
+
+    # Step 2: Loop through all parcels
+    for i in range(zone_map.shape[0]):
+        for j in range(zone_map.shape[1]):
+            if zone_map[i, j] == from_id:
+                zone_map[i, j] = to_id  # Override ID
+
+    # Step 3: Update label dictionary
+    zone_labels[to_id] = to_label
+    if from_id not in zone_map:
+        zone_labels.pop(from_id, None)
+
+    print(f"✅ Overrode zone {from_id} ('{from_label}') → zone {to_id} ('{to_label}')")
+    return zone_map, zone_labels
+
+
+
+def remap_zone_id_and_label(zone_map, zone_labels, old_zone_id, old_label, new_zone_id, new_label):
+    """
+    For all parcels where zone_id == old_zone_id and label == old_label:
+    → Change zone_id to new_zone_id and label to new_label.
+
+    Args:
+        zone_map (np.ndarray): 2D map of zone IDs.
+        zone_labels (dict): zone_id → label.
+        old_zone_id (int)
+        old_label (str)
+        new_zone_id (int)
+        new_label (str)
+
+    Returns:
+        zone_map, zone_labels
+    """
+    # Only proceed if the label for old_zone_id matches
+    if zone_labels.get(old_zone_id) != old_label:
+        print(f"❌ Skipping: Label mismatch for zone {old_zone_id}")
+        return zone_map, zone_labels
+
+    # Go through every (i,j) and remap matching zones
+    rows, cols = zone_map.shape
+    for i in range(rows):
+        for j in range(cols):
+            if zone_map[i, j] == old_zone_id:
+                zone_map[i, j] = new_zone_id
+
+    # Update the label dictionary
+    zone_labels[new_zone_id] = new_label
+    if old_zone_id in zone_labels:
+        del zone_labels[old_zone_id]
+
+    print(f"✅ Reassigned zone {old_zone_id} ('{old_label}') → {new_zone_id} ('{new_label}')")
+    return zone_map, zone_labels
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_labeled_zones_old(zone_map, zone_labels, save_path="labeled_zones.png"):
+    """
+    Plots a zone map with human-readable labels (e.g., "A", "B", "Riparian A").
+    
+    Parameters:
+        zone_map (np.ndarray): 2D array of integers where each unique int is a zone ID.
+        zone_labels (dict): Mapping from zone_id (int) to human label (str).
+        save_path (str): File path to save the plotted image.
+    """
+    unique_ids = sorted(np.unique(zone_map))
+    color_map = plt.get_cmap('tab20', len(unique_ids))
+
+    fig, ax = plt.subplots(figsize=(8, 6))
+    cax = ax.imshow(zone_map, cmap=color_map, vmin=0, vmax=len(unique_ids) - 1)
+
+    # Add human-readable labels at zone centers
+    for zone_id in unique_ids:
+        if zone_id not in zone_labels:
+            continue
+        label = zone_labels[zone_id]
+        positions = np.argwhere(zone_map == zone_id)
+        if len(positions) == 0:
+            continue
+        center_i, center_j = positions.mean(axis=0)
+        ax.text(center_j, center_i, label, color="white", ha="center", va="center",
+                fontsize=9, fontweight="bold", bbox=dict(facecolor="black", alpha=0.5, boxstyle="round,pad=0.3"))
+
+    ax.set_title("Labeled Grazing & Riparian Zones")
+    ax.axis('off')
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close(fig)
+
+