Upload 23 files

app.py

@@ -16,7 +16,9 @@ from ash_animator import create_grid
 
 pn.extension()
 
-MEDIA_DIR = "media"
+import tempfile
+
+MEDIA_DIR = os.environ.get("NAME_MEDIA_DIR", os.path.join(tempfile.gettempdir(), "name_media"))
 os.makedirs(MEDIA_DIR, exist_ok=True)
 
 # Logging setup
@@ -69,12 +71,20 @@ def process_zip(event=None):
         status.object = "✅ ZIP uploaded and saved."
     else:
         zip_path = os.path.join(MEDIA_DIR, "default_model.zip")
+        if not os.path.exists(zip_path):
+            zip_path = "default_model.zip"  # fallback to local directory
         if not os.path.exists(zip_path):
             status.object = "❌ No ZIP uploaded and default_model.zip not found."
             return
         status.object = "📦 Using default_model.zip"
 
-    output_dir = os.path.join("./", "ash_output")
+
+    try:
+        output_dir = os.path.join("./", "ash_output")
+        os.makedirs(output_dir, exist_ok=True)
+    except PermissionError:
+        output_dir = os.path.join(tempfile.gettempdir(), "name_output")
+        os.makedirs(output_dir, exist_ok=True)
     shutil.rmtree(output_dir, ignore_errors=True)
     os.makedirs(output_dir, exist_ok=True)
 
@@ -85,6 +95,10 @@ def process_zip(event=None):
         # animator_obj["3d"] = [xr.open_dataset(fp).load()
         #                       for fp in sorted(glob.glob(os.path.join(output_dir, "3D", "*.nc")))]
         
+        # animator_obj["3d"] = []
+        # for fp in sorted(glob.glob(os.path.join(output_dir, "3D", "*.nc"))):
+        #     with xr.open_dataset(fp) as ds:
+        #         animator_obj["3d"].append(ds.load())
         animator_obj["3d"] = []
         for fp in sorted(glob.glob(os.path.join(output_dir, "3D", "*.nc"))):
             with xr.open_dataset(fp) as ds:
@@ -125,7 +139,12 @@ def restore_previous_session():
             with open(state_file) as f:
                 zip_path = f.read().strip()
             if os.path.exists(zip_path):
-                output_dir = os.path.join("./", "ash_output")
+                try:
+                    output_dir = os.path.join("./", "ash_output")
+                    os.makedirs(output_dir, exist_ok=True)
+                except PermissionError:
+                    output_dir = os.path.join(tempfile.gettempdir(), "name_output")
+                    os.makedirs(output_dir, exist_ok=True)
 
                 animator_obj["3d"] = []
                 for fp in sorted(glob.glob(os.path.join(output_dir, "3D", "*.nc"))):
@@ -249,35 +268,99 @@ def human_readable_size(size):
         size /= 1024
     return f"{size:.1f} TB"
 
+# def generate_output_gallery(base_folder):
+#     grouped = defaultdict(lambda: defaultdict(list))
+#     for root, _, files in os.walk(os.path.join(MEDIA_DIR, base_folder)):
+#         for file in files:
+#             ext = os.path.splitext(file)[1].lower()
+#             subfolder = os.path.relpath(root, MEDIA_DIR)
+#             grouped[subfolder][ext].append(os.path.join(root, file))
+
+#     folder_tabs = []
+#     for subfolder, ext_files in sorted(grouped.items()):
+#         type_tabs = []
+#         for ext, paths in sorted(ext_files.items()):
+#             previews = []
+#             for path in sorted(paths, key=os.path.getmtime, reverse=True):
+#                 size = human_readable_size(os.path.getsize(path))
+#                 mod = datetime.fromtimestamp(os.path.getmtime(path)).strftime("%Y-%m-%d %H:%M")
+#                 title = f"**{os.path.basename(path)}**\\n_{size}, {mod}_"
+#                 download = pn.widgets.FileDownload(label="⬇", file=path, filename=os.path.basename(path), width=60)
+#                 if ext in [".gif", ".png", ".jpg", ".jpeg"]:
+#                     preview = pn.pane.Image(path, width=320)
+#                 else:
+#                     with open(path, "r", errors="ignore") as f:
+#                         content = f.read(2048)
+#                     preview = pn.pane.PreText(content, width=320)
+#                 card = pn.Card(pn.pane.Markdown(title), preview, pn.Row(download), width=360)
+#                 previews.append(card)
+#             type_tabs.append((ext.upper(), pn.GridBox(*previews, ncols=2)))
+#         folder_tabs.append((subfolder, pn.Tabs(*type_tabs)))
+#     return pn.Tabs(*folder_tabs)
+
+
 def generate_output_gallery(base_folder):
-    grouped = defaultdict(lambda: defaultdict(list))
+    preview_container = pn.Column(width=640, height=550)
+    preview_container.append(pn.pane.Markdown("👈 Click a thumbnail to preview"))
+    folder_cards = []
+
+    def make_preview(file_path):
+        ext = os.path.splitext(file_path)[1].lower()
+        title = pn.pane.Markdown(f"### {os.path.basename(file_path)}", width=640)
+        download_button = pn.widgets.FileDownload(file=file_path, filename=os.path.basename(file_path),
+                                                  label="⬇ Download", button_type="success", width=150)
+
+        if ext in [".gif", ".png", ".jpg", ".jpeg"]:
+            content = pn.pane.Image(file_path, width=640, height=450, sizing_mode="fixed")
+        else:
+            try:
+                with open(file_path, 'r', errors="ignore") as f:
+                    text = f.read(2048)
+                content = pn.pane.PreText(text, width=640, height=450)
+            except:
+                content = pn.pane.Markdown("*Unable to preview this file.*")
+
+        return pn.Column(title, content, download_button)
+
+    grouped = defaultdict(list)
     for root, _, files in os.walk(os.path.join(MEDIA_DIR, base_folder)):
-        for file in files:
-            ext = os.path.splitext(file)[1].lower()
-            subfolder = os.path.relpath(root, MEDIA_DIR)
-            grouped[subfolder][ext].append(os.path.join(root, file))
-
-    folder_tabs = []
-    for subfolder, ext_files in sorted(grouped.items()):
-        type_tabs = []
-        for ext, paths in sorted(ext_files.items()):
-            previews = []
-            for path in sorted(paths, key=os.path.getmtime, reverse=True):
-                size = human_readable_size(os.path.getsize(path))
-                mod = datetime.fromtimestamp(os.path.getmtime(path)).strftime("%Y-%m-%d %H:%M")
-                title = f"**{os.path.basename(path)}**\\n_{size}, {mod}_"
-                download = pn.widgets.FileDownload(label="⬇", file=path, filename=os.path.basename(path), width=60)
-                if ext in [".gif", ".png", ".jpg", ".jpeg"]:
-                    preview = pn.pane.Image(path, width=320)
-                else:
-                    with open(path, "r", errors="ignore") as f:
-                        content = f.read(2048)
-                    preview = pn.pane.PreText(content, width=320)
-                card = pn.Card(pn.pane.Markdown(title), preview, pn.Row(download), width=360)
-                previews.append(card)
-            type_tabs.append((ext.upper(), pn.GridBox(*previews, ncols=2)))
-        folder_tabs.append((subfolder, pn.Tabs(*type_tabs)))
-    return pn.Tabs(*folder_tabs)
+        for file in sorted(files):
+            full_path = os.path.join(root, file)
+            if not os.path.exists(full_path):
+                continue
+            rel_folder = os.path.relpath(root, os.path.join(MEDIA_DIR, base_folder))
+            grouped[rel_folder].append(full_path)
+
+    for folder, file_paths in sorted(grouped.items()):
+        thumbnails = []
+        for full_path in file_paths:
+            filename = os.path.basename(full_path)
+            ext = os.path.splitext(full_path)[1].lower()
+
+            if ext in [".gif", ".png", ".jpg", ".jpeg"]:
+                img = pn.pane.Image(full_path, width=140, height=100)
+            else:
+                img = pn.pane.Markdown("📄", width=140, height=100)
+
+            view_button = pn.widgets.Button(name="👁", width=40, height=30, button_type="primary")
+
+            def click_handler(path=full_path):
+                def inner_click(event):
+                    preview_container[:] = [make_preview(path)]
+                return inner_click
+
+            view_button.on_click(click_handler())
+
+            overlay = pn.Column(pn.Row(pn.Spacer(width=90), view_button), img, width=160)
+            label_md = pn.pane.Markdown(f"**{filename}**", width=140, height=35)
+            thumb_card = pn.Column(overlay, label_md, width=160)
+            thumbnails.append(thumb_card)
+
+        folder_card = pn.Card(pn.GridBox(*thumbnails, ncols=2), title=f"📁 {folder}", width=400, collapsible=True)
+        folder_cards.append(folder_card)
+
+    folder_scroll = pn.Column(*folder_cards, scroll=True, height=600, width=420)
+    return pn.Row(preview_container, pn.Spacer(width=20), folder_scroll)
 
 def update_media_tabs():
     media_tab_2d.objects[:] = [generate_output_gallery("2D")]
@@ -291,6 +374,418 @@ media_tab = pn.Tabs(
     ("3D Outputs", media_tab_3d)
 )
 
+
+tab3d = pn.Column(
+    threshold_slider_3d, zoom_slider_3d, fps_slider_3d, Altitude_slider, cmap_select_3d,
+    pn.widgets.Button(name="🎞 Generate animation at selected altitude level", button_type="primary", on_click=lambda e: tab3d.append(plot_z_level())),
+    pn.widgets.Button(name="📈 Generate vertical profile animation at time index", button_type="primary", on_click=lambda e: tab3d.append(plot_vertical_profile())),
+    pn.widgets.Button(name="📊 Generate all altitude level animations", button_type="primary", on_click=lambda e: tab3d.append(animate_all_altitude_profiles())),
+    pn.widgets.Button(name="🖼 Export all animation frames as JPG", button_type="primary", on_click=lambda e: tab3d.append(export_jpg_frames())),
+)
+
+tab2d = pn.Column(
+    threshold_slider_2d, zoom_slider_2d, fps_slider_2d, cmap_select_2d,
+    pn.widgets.Button(name="🌫 Animate Air Concentration", button_type="primary", on_click=lambda e: tab2d.append(plot_2d_field("air_concentration"))),
+    pn.widgets.Button(name="🌧 Animate Dry Deposition Rate", button_type="primary", on_click=lambda e: tab2d.append(plot_2d_field("dry_deposition_rate"))),
+    pn.widgets.Button(name="💧 Animate Wet Deposition Rate", button_type="primary", on_click=lambda e: tab2d.append(plot_2d_field("wet_deposition_rate"))),
+)
+
+help_tab = pn.Column(pn.pane.Markdown("""
+## ❓ How to Use the NAME Ash Visualizer
+
+This dashboard allows users to upload and visualize outputs from the NAME ash dispersion model.
+
+### 🧭 Workflow
+1. **Upload ZIP** containing NetCDF files from the NAME model.
+2. Use **3D and 2D tabs** to configure and generate animations.
+3. Use **Media Viewer** to preview and download results.
+
+### 🧳 ZIP Structure
+```
+## 🗂 How Uploaded ZIP is Processed
+
+```text
+┌────────────────────────────────────────────┐
+│           Uploaded ZIP (.zip)              │
+│  (e.g. Taal_273070_20200112_scenario_*.zip)│
+└────────────────────────────────────────────┘
+                    │
+                    ▼
+      ┌───────────────────────────────┐
+      │ Contains: raw .txt outputs    │
+      │  - AQOutput_3DField_*.txt     │
+      │  - AQOutput_horizontal_*.txt  │
+      └───────────────────────────────┘
+                    │
+                    ▼
+  ┌────────────────────────────────────────┐
+  │   NAMEDataProcessor.batch_process_zip()│
+  └────────────────────────────────────────┘
+                    │
+                    ▼
+      ┌─────────────────────────────┐
+      │   Converts to NetCDF files  │
+      │     - ash_output/3D/*.nc    │
+      │     - ash_output/horizontal/*.nc │
+      └─────────────────────────────┘
+                    │
+                    ▼
+   ┌─────────────────────────────────────┐
+   │ View & animate in 3D/2D tabs        │
+   │ Download results in Media Viewer    │
+   └─────────────────────────────────────┘
+
+```
+
+### 📢 Tips
+- Reset the app with 🔄 if needed.
+- View logs if an error occurs.
+- Outputs are temporary per session.
+""", sizing_mode="stretch_width", width=800))
+
+tabs = pn.Tabs(
+    ("🧱 3D Field", tab3d),
+    ("🌍 2D Field", tab2d),
+    ("📁 Media Viewer", media_tab),
+    ("❓ Help", help_tab)
+)
+
+sidebar = pn.Column(
+    pn.pane.Markdown("## 🌋 NAME Ash Visualizer", sizing_mode="stretch_width"),
+    pn.Card(pn.Column(file_input, process_button, reset_button, sizing_mode="stretch_width"),
+            title="📂 File Upload & Processing", collapsible=True, sizing_mode="stretch_width"),
+    pn.Card(pn.Column(download_button, log_link, sizing_mode="stretch_width"),
+            title="📁 Downloads & Logs", collapsible=True, sizing_mode="stretch_width"),
+    pn.Card(status, title="📢 Status", collapsible=True, sizing_mode="stretch_width"),
+    sizing_mode="stretch_width", width=300
+)
+
+restore_previous_session()
+
+pn.template.FastListTemplate(
+    title="NAME Visualizer Dashboard",
+    sidebar=sidebar,
+    main=[tabs],
+).servable()
+
+''' 
+import os
+import glob
+import shutil
+import io
+import logging
+import panel as pn
+import xarray as xr
+import numpy as np
+from datetime import datetime
+from types import SimpleNamespace
+from collections import defaultdict
+from ash_animator.converter import NAMEDataProcessor
+from ash_animator.plot_3dfield_data import Plot_3DField_Data
+from ash_animator.plot_horizontal_data import Plot_Horizontal_Data
+from ash_animator import create_grid
+import tempfile
+
+pn.extension()
+
+MEDIA_DIR = os.environ.get("NAME_MEDIA_DIR", os.path.join(tempfile.gettempdir(), "name_media"))
+os.makedirs(MEDIA_DIR, exist_ok=True)
+
+LOG_FILE = os.path.join(MEDIA_DIR, "app_errors.log")
+logging.basicConfig(filename=LOG_FILE, level=logging.ERROR, format="%(asctime)s - %(levelname)s - %(message)s")
+
+animator_obj = {}
+
+file_input = pn.widgets.FileInput(accept=".zip")
+process_button = pn.widgets.Button(name="📦 Process ZIP", button_type="primary")
+reset_button = pn.widgets.Button(name="🔄 Reset App", button_type="danger")
+status = pn.pane.Markdown("### Upload a NAME Model ZIP to begin")
+
+download_button = pn.widgets.FileDownload(
+    label="⬇️ Download All Exports", filename="all_exports.zip", button_type="success",
+    callback=lambda: io.BytesIO(open(shutil.make_archive(os.path.join(MEDIA_DIR, "all_exports").replace(".zip", ""), "zip", MEDIA_DIR), 'rb').read())
+)
+
+log_link = pn.widgets.FileDownload(label="🪵 View Error Log", file=LOG_FILE, filename="app_errors.log", button_type="warning")
+
+threshold_slider_3d = pn.widgets.FloatSlider(name='3D Threshold', start=0.0, end=1.0, step=0.05, value=0.1)
+zoom_slider_3d = pn.widgets.IntSlider(name='3D Zoom Level', start=1, end=20, value=19)
+cmap_select_3d = pn.widgets.Select(name='3D Colormap', options=["rainbow", "viridis", "plasma"])
+fps_slider_3d = pn.widgets.IntSlider(name='3D FPS', start=1, end=10, value=2)
+Altitude_slider = pn.widgets.IntSlider(name='Define Ash Altitude', start=1, end=15, value=1)
+
+threshold_slider_2d = pn.widgets.FloatSlider(name='2D Threshold', start=0.0, end=1.0, step=0.01, value=0.005)
+zoom_slider_2d = pn.widgets.IntSlider(name='2D Zoom Level', start=1, end=20, value=19)
+fps_slider_2d = pn.widgets.IntSlider(name='2D FPS', start=1, end=10, value=2)
+cmap_select_2d = pn.widgets.Select(name='2D Colormap', options=["rainbow", "viridis", "plasma"])
+
+def process_zip(event=None):
+    if file_input.value:
+        zip_path = os.path.join(MEDIA_DIR, file_input.filename)
+        with open(zip_path, "wb") as f:
+            f.write(file_input.value)
+        status.object = "✅ ZIP uploaded and saved."
+    else:
+        zip_path = os.path.join(MEDIA_DIR, "default_model.zip")
+        if not os.path.exists(zip_path):
+            zip_path = "default_model.zip"
+        if not os.path.exists(zip_path):
+            status.object = "❌ No ZIP uploaded and default_model.zip not found."
+            return
+        status.object = "📦 Using default_model.zip"
+
+    try:
+        output_dir = os.path.join("./", "ash_output")
+        os.makedirs(output_dir, exist_ok=True)
+    except PermissionError:
+        output_dir = os.path.join(tempfile.gettempdir(), "name_output")
+        os.makedirs(output_dir, exist_ok=True)
+    shutil.rmtree(output_dir, ignore_errors=True)
+    os.makedirs(output_dir, exist_ok=True)
+
+    try:
+        processor = NAMEDataProcessor(output_root=output_dir)
+        processor.batch_process_zip(zip_path)
+
+        animator_obj["3d"] = [xr.open_dataset(fp).load() for fp in sorted(glob.glob(os.path.join(output_dir, "3D", "*.nc")))]
+        animator_obj["2d"] = [xr.open_dataset(fp).load() for fp in sorted(glob.glob(os.path.join(output_dir, "horizontal", "*.nc")))]
+
+        with open(os.path.join(MEDIA_DIR, "last_run.txt"), "w") as f:
+            f.write(zip_path)
+
+        status.object += f" | ✅ Loaded 3D: {len(animator_obj['3d'])} & 2D: {len(animator_obj['2d'])}"
+        update_media_tabs()
+    except Exception as e:
+        logging.exception("Error during ZIP processing")
+        status.object = f"❌ Processing failed: {e}"
+
+def reset_app(event=None):
+    animator_obj.clear()
+    file_input.value = None
+    status.object = "🔄 App has been reset."
+    for folder in ["ash_output", "2D", "3D"]:
+        shutil.rmtree(os.path.join(MEDIA_DIR, folder), ignore_errors=True)
+    if os.path.exists(os.path.join(MEDIA_DIR, "last_run.txt")):
+        os.remove(os.path.join(MEDIA_DIR, "last_run.txt"))
+    update_media_tabs()
+
+def restore_previous_session():
+    try:
+        state_file = os.path.join(MEDIA_DIR, "last_run.txt")
+        if os.path.exists(state_file):
+            with open(state_file) as f:
+                zip_path = f.read().strip()
+            if os.path.exists(zip_path):
+                output_dir = os.path.join("./", "ash_output")
+                os.makedirs(output_dir, exist_ok=True)
+                animator_obj["3d"] = [xr.open_dataset(fp).load() for fp in sorted(glob.glob(os.path.join(output_dir, "3D", "*.nc")))]
+                animator_obj["2d"] = [xr.open_dataset(fp).load() for fp in sorted(glob.glob(os.path.join(output_dir, "horizontal", "*.nc")))]
+                status.object = f"🔁 Restored previous session from {os.path.basename(zip_path)}"
+                update_media_tabs()
+    except Exception as e:
+        logging.exception("Error restoring previous session")
+        status.object = f"⚠️ Could not restore previous session: {e}"
+
+process_button.on_click(process_zip)
+reset_button.on_click(reset_app)
+
+def build_animator_3d():
+    ds = animator_obj["3d"]
+    attrs = ds[0].attrs
+    lons, lats, grid = create_grid(attrs)
+    return SimpleNamespace(datasets=ds, levels=ds[0].altitude.values, lons=lons, lats=lats,
+                           lon_grid=grid[0], lat_grid=grid[1])
+
+def build_animator_2d():
+    ds = animator_obj["2d"]
+    lat_grid, lon_grid = xr.broadcast(ds[0]["latitude"], ds[0]["longitude"])
+    return SimpleNamespace(datasets=ds, lats=ds[0]["latitude"].values,
+                           lons=ds[0]["longitude"].values,
+                           lat_grid=lat_grid.values, lon_grid=lon_grid.values)
+
+def plot_z_level():
+    try:
+        animator = build_animator_3d()
+        out = os.path.join(MEDIA_DIR, "3D")
+        os.makedirs(out, exist_ok=True)
+        Plot_3DField_Data(animator, out, cmap_select_3d.value, threshold_slider_3d.value,
+                          zoom_slider_3d.value, fps_slider_3d.value).plot_single_z_level(
+                              Altitude_slider.value, f"ash_altitude{Altitude_slider.value}km_runTimes.gif")
+        update_media_tabs()
+        status.object = "✅ Z-Level animation created."
+    except Exception as e:
+        logging.exception("Error in plot_z_level")
+        status.object = f"❌ Error in Z-Level animation: {e}"
+
+def plot_vertical_profile():
+    try:
+        animator = build_animator_3d()
+        out = os.path.join(MEDIA_DIR, "3D")
+        os.makedirs(out, exist_ok=True)
+        Plot_3DField_Data(animator, out, cmap_select_3d.value, fps_slider_3d.value,
+                          threshold_slider_3d.value, zoom_level=zoom_slider_3d.value).plot_vertical_profile_at_time(
+                              Altitude_slider.value - 1, f"T{Altitude_slider.value - 1}_profile.gif")
+        update_media_tabs()
+        status.object = "✅ Vertical profile animation created."
+    except Exception as e:
+        logging.exception("Error in plot_vertical_profile")
+        status.object = f"❌ Error in vertical profile animation: {e}"
+
+def animate_all_altitude_profiles():
+    try:
+        animator = build_animator_3d()
+        out = os.path.join(MEDIA_DIR, "3D")
+        Plot_3DField_Data(animator, out, cmap_select_3d.value, threshold_slider_3d.value,
+                          zoom_slider_3d.value).animate_all_altitude_profiles()
+        update_media_tabs()
+        status.object = "✅ All altitude profile animations created."
+    except Exception as e:
+        logging.exception("Error in animate_all_altitude_profiles")
+        status.object = f"❌ Error animating all altitude profiles: {e}"
+
+def export_jpg_frames():
+    try:
+        animator = build_animator_3d()
+        out = os.path.join(MEDIA_DIR, "3D")
+        Plot_3DField_Data(animator, out, cmap_select_3d.value, threshold_slider_3d.value,
+                          zoom_slider_3d.value).export_frames_as_jpgs(include_metadata=True)
+        update_media_tabs()
+        status.object = "✅ JPG frames exported."
+    except Exception as e:
+        logging.exception("Error exporting JPG frames")
+        status.object = f"❌ Error exporting JPG frames: {e}"
+
+def plot_2d_field(field):
+    try:
+        animator = build_animator_2d()
+        out = os.path.join(MEDIA_DIR, "2D")
+        Plot_Horizontal_Data(animator, out, cmap_select_2d.value, fps_slider_2d.value,
+                             include_metadata=True, threshold=threshold_slider_2d.value,
+                             zoom_width_deg=6.0, zoom_height_deg=6.0,
+                             zoom_level=zoom_slider_2d.value,
+                             static_frame_export=True).plot_single_field_over_time(field, f"{field}.gif")
+        update_media_tabs()
+        status.object = f"✅ 2D field `{field}` animation created."
+    except Exception as e:
+        logging.exception(f"Error in plot_2d_field: {field}")
+        status.object = f"❌ Error in 2D field `{field}` animation: {e}"
+
+def human_readable_size(size):
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size < 1024: return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+# def generate_output_gallery(base_folder):
+#     grouped = defaultdict(lambda: defaultdict(list))
+#     for root, _, files in os.walk(os.path.join(MEDIA_DIR, base_folder)):
+#         for file in files:
+#             ext = os.path.splitext(file)[1].lower()
+#             subfolder = os.path.relpath(root, MEDIA_DIR)
+#             grouped[subfolder][ext].append(os.path.join(root, file))
+
+#     folder_panels = []
+#     for subfolder, ext_files in sorted(grouped.items()):
+#         section = []
+#         for ext, paths in sorted(ext_files.items()):
+#             previews = []
+#             for path in sorted(paths, key=os.path.getmtime, reverse=True):
+#                 size = human_readable_size(os.path.getsize(path))
+#                 mod = datetime.fromtimestamp(os.path.getmtime(path)).strftime("%Y-%m-%d %H:%M")
+#                 title = f"**{os.path.basename(path)}**\n_{size}, {mod}_"
+#                 download = pn.widgets.FileDownload(label="⬇", file=path, filename=os.path.basename(path), width=60)
+#                 if ext in [".gif", ".png", ".jpg", ".jpeg"]:
+#                     preview = pn.pane.Image(path, width=320)
+#                 else:
+#                     with open(path, "r", errors="ignore") as f:
+#                         content = f.read(2048)
+#                     preview = pn.pane.PreText(content, width=320)
+#                 card = pn.Card(pn.pane.Markdown(title), preview, pn.Row(download), width=360)
+#                 previews.append(card)
+#             section.append(pn.Column(f"### {ext.upper()}", pn.GridBox(*previews, ncols=2)))
+#         folder_section = pn.Card(f"📁 {subfolder}", *section, collapsible=True, width_policy="max")
+#         folder_panels.append(folder_section)
+
+#     return pn.Column(*folder_panels, height=600, scroll=True, sizing_mode='stretch_width', styles={'overflow': 'auto'})
+
+
+
+def generate_output_gallery(base_folder):
+    preview_container = pn.Column(width=640, height=550)
+    preview_container.append(pn.pane.Markdown("👈 Click a thumbnail to preview"))
+    folder_cards = []
+
+    def make_preview(file_path):
+        ext = os.path.splitext(file_path)[1].lower()
+        title = pn.pane.Markdown(f"### {os.path.basename(file_path)}", width=640)
+        download_button = pn.widgets.FileDownload(file=file_path, filename=os.path.basename(file_path),
+                                                  label="⬇ Download", button_type="success", width=150)
+
+        if ext in [".gif", ".png", ".jpg", ".jpeg"]:
+            content = pn.pane.Image(file_path, width=640, height=450, sizing_mode="fixed")
+        else:
+            try:
+                with open(file_path, 'r', errors="ignore") as f:
+                    text = f.read(2048)
+                content = pn.pane.PreText(text, width=640, height=450)
+            except:
+                content = pn.pane.Markdown("*Unable to preview this file.*")
+
+        return pn.Column(title, content, download_button)
+
+    grouped = defaultdict(list)
+    for root, _, files in os.walk(os.path.join(MEDIA_DIR, base_folder)):
+        for file in sorted(files):
+            full_path = os.path.join(root, file)
+            if not os.path.exists(full_path):
+                continue
+            rel_folder = os.path.relpath(root, os.path.join(MEDIA_DIR, base_folder))
+            grouped[rel_folder].append(full_path)
+
+    for folder, file_paths in sorted(grouped.items()):
+        thumbnails = []
+        for full_path in file_paths:
+            filename = os.path.basename(full_path)
+            ext = os.path.splitext(full_path)[1].lower()
+
+            if ext in [".gif", ".png", ".jpg", ".jpeg"]:
+                img = pn.pane.Image(full_path, width=140, height=100)
+            else:
+                img = pn.pane.Markdown("📄", width=140, height=100)
+
+            view_button = pn.widgets.Button(name="👁", width=40, height=30, button_type="primary")
+
+            def click_handler(path=full_path):
+                def inner_click(event):
+                    preview_container[:] = [make_preview(path)]
+                return inner_click
+
+            view_button.on_click(click_handler())
+
+            overlay = pn.Column(pn.Row(pn.Spacer(width=90), view_button), img, width=160)
+            label_md = pn.pane.Markdown(f"**{filename}**", width=140, height=35)
+            thumb_card = pn.Column(overlay, label_md, width=160)
+            thumbnails.append(thumb_card)
+
+        folder_card = pn.Card(pn.GridBox(*thumbnails, ncols=2), title=f"📁 {folder}", width=400, collapsible=True)
+        folder_cards.append(folder_card)
+
+    folder_scroll = pn.Column(*folder_cards, scroll=True, height=600, width=420)
+    return pn.Row(preview_container, pn.Spacer(width=20), folder_scroll)
+
+def update_media_tabs():
+    media_tab_2d.objects[:] = [generate_output_gallery("2D")]
+    media_tab_3d.objects[:] = [generate_output_gallery("3D")]
+
+media_tab_2d = pn.Column(generate_output_gallery("2D"))
+media_tab_3d = pn.Column(generate_output_gallery("3D"))
+
+media_tab = pn.Tabs(
+    ("🖼 2D Output Gallery", media_tab_2d),
+    ("🖼 3D Output Gallery", media_tab_3d),
+    dynamic=True
+)
+
 tab3d = pn.Column(
     threshold_slider_3d, zoom_slider_3d, fps_slider_3d, Altitude_slider, cmap_select_3d,
     pn.widgets.Button(name="🎞 Generate animation at selected altitude level", button_type="primary", on_click=lambda e: tab3d.append(plot_z_level())),
@@ -306,13 +801,75 @@ tab2d = pn.Column(
     pn.widgets.Button(name="💧 Animate Wet Deposition Rate", button_type="primary", on_click=lambda e: tab2d.append(plot_2d_field("wet_deposition_rate"))),
 )
 
+help_tab = pn.Column(pn.pane.Markdown("""
+## ❓ How to Use the NAME Ash Visualizer
+
+This dashboard allows users to upload and visualize outputs from the NAME ash dispersion model.
+
+### 🧭 Workflow
+1. **Upload ZIP** containing NetCDF files from the NAME model.
+2. Use **3D and 2D tabs** to configure and generate animations.
+3. Use **Media Viewer** to preview and download results.
+
+### 🧳 ZIP Structure
+```
+## 🗂 How Uploaded ZIP is Processed
+
+```text
+┌────────────────────────────────────────────┐
+│           Uploaded ZIP (.zip)              │
+│  (e.g. Taal_273070_20200112_scenario_*.zip)│
+└────────────────────────────────────────────┘
+                    │
+                    ▼
+      ┌───────────────────────────────┐
+      │ Contains: raw .txt outputs    │
+      │  - AQOutput_3DField_*.txt     │
+      │  - AQOutput_horizontal_*.txt  │
+      └───────────────────────────────┘
+                    │
+                    ▼
+  ┌────────────────────────────────────────┐
+  │   NAMEDataProcessor.batch_process_zip()│
+  └──────────────────────────��─────────────┘
+                    │
+                    ▼
+      ┌─────────────────────────────┐
+      │   Converts to NetCDF files  │
+      │     - ash_output/3D/*.nc    │
+      │     - ash_output/horizontal/*.nc │
+      └─────────────────────────────┘
+                    │
+                    ▼
+   ┌─────────────────────────────────────┐
+   │ View & animate in 3D/2D tabs        │
+   │ Download results in Media Viewer    │
+   └─────────────────────────────────────┘
+
+```
+
+### 📢 Tips
+- Reset the app with 🔄 if needed.
+- View logs if an error occurs.
+- Outputs are temporary per session.
+""", sizing_mode="stretch_width", width=800))
+
 tabs = pn.Tabs(
     ("🧱 3D Field", tab3d),
     ("🌍 2D Field", tab2d),
-    ("📁 Media Viewer", media_tab)
+    ("📁 Media Viewer", media_tab),
+    ("❓ Help", help_tab)
 )
 
-sidebar = pn.Column("## 🌋 NAME Ash Visualizer", file_input, process_button, reset_button, download_button, log_link, status)
+sidebar = pn.Column(
+    pn.pane.Markdown("## 🌋 NAME Ash Visualizer", sizing_mode="stretch_width"),
+    pn.Card(pn.Column(file_input, process_button, reset_button, sizing_mode="stretch_width"),
+            title="📂 File Upload & Processing", collapsible=True, sizing_mode="stretch_width"),
+    pn.Card(pn.Column(download_button, log_link, sizing_mode="stretch_width"),
+            title="📁 Downloads & Logs", collapsible=True, sizing_mode="stretch_width"),
+    pn.Card(status, title="📢 Status", collapsible=True, sizing_mode="stretch_width"),
+    sizing_mode="stretch_width", width=300
+)
 
 restore_previous_session()
 
@@ -320,4 +877,5 @@ pn.template.FastListTemplate(
     title="NAME Visualizer Dashboard",
     sidebar=sidebar,
     main=[tabs],
-).servable()
+).servable()
+ '''

ash_animator/basemaps.py

@@ -8,33 +8,52 @@ import cartopy.feature as cfeature
 from PIL import Image
 import matplotlib.pyplot as plt
 
-def get_safe_dir(name):
-    """
-    Returns the first writable directory from a list of fallback options.
-    Returns None if all fail.
-    """
-    fallback_paths = [
-        os.path.join("/code", name),
-        os.path.join(tempfile.gettempdir(), name),
-        os.path.expanduser(f"~/.{name}")
-    ]
-    for path in fallback_paths:
-        try:
-            os.makedirs(path, exist_ok=True)
-            return path
-        except PermissionError:
-            continue
-    return None
-
-# Define and validate cache directories
-CTX_TILE_CACHE_DIR = get_safe_dir("contextily_cache")
-BASEMAP_TILE_CACHE_DIR = get_safe_dir("basemap_cache")
-
-# Set environment variable only if safe
-if CTX_TILE_CACHE_DIR:
-    os.environ["XDG_CACHE_HOME"] = CTX_TILE_CACHE_DIR
+# Determine platform and fallback cache path
+def get_cache_dir(app_name):
+    if os.name == 'nt':
+        return os.path.join(os.getenv('LOCALAPPDATA', tempfile.gettempdir()), f"{app_name}_cache")
+    elif os.name == 'posix':
+        home_dir = os.path.expanduser("~")
+        if os.path.isdir(home_dir) and os.access(home_dir, os.W_OK):
+            return os.path.join(home_dir, f".{app_name}_cache")
+        else:
+            return os.path.join(tempfile.gettempdir(), f"{app_name}_cache")
+    else:
+        return os.path.join(tempfile.gettempdir(), f"{app_name}_cache")
+
+# Define cache directories
+CTX_TILE_CACHE_DIR = get_cache_dir("contextily")
+BASEMAP_TILE_CACHE_DIR = get_cache_dir("basemap")
+
+os.environ["XDG_CACHE_HOME"] = CTX_TILE_CACHE_DIR
+os.makedirs(CTX_TILE_CACHE_DIR, exist_ok=True)
+os.makedirs(BASEMAP_TILE_CACHE_DIR, exist_ok=True)
 
 def draw_etopo_basemap(ax, mode="basemap", zoom=11):
+    """
+    Draws a high-resolution basemap background on the provided Cartopy GeoAxes.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes._subplots.AxesSubplot
+        The matplotlib Axes object (with Cartopy projection) to draw the map background on.
+
+    mode : str, optional
+        The basemap mode to use:
+        - "stock": Default stock image from Cartopy.
+        - "contextily": Web tile background (CartoDB Voyager), with caching.
+        - "basemap": High-resolution shaded relief using Basemap, with caching.
+        Default is "basemap".
+
+    zoom : int, optional
+        Tile zoom level (only for "contextily"). Higher = more detail. Default is 7.
+
+    Notes
+    -----
+    - Uses high resolution for Basemap (resolution='h') and saves figure at 300 DPI.
+    - Cached images are reused using extent-based hashing to avoid re-rendering.
+    - Basemap is deprecated; Cartopy with web tiles is recommended for new projects.
+    """
     try:
         if mode == "stock":
             ax.stock_img()
@@ -53,32 +72,27 @@ def draw_etopo_basemap(ax, mode="basemap", zoom=11):
             extent = ax.get_extent(crs=ccrs.PlateCarree())
             extent_str = f"{extent[0]:.4f}_{extent[1]:.4f}_{extent[2]:.4f}_{extent[3]:.4f}"
             cache_key = hashlib.md5(extent_str.encode()).hexdigest()
-            cache_file = os.path.join(BASEMAP_TILE_CACHE_DIR, f"{cache_key}_highres.png") if BASEMAP_TILE_CACHE_DIR else None
+            cache_file = os.path.join(BASEMAP_TILE_CACHE_DIR, f"{cache_key}_highres.png")
 
-            if cache_file and os.path.exists(cache_file):
+            if os.path.exists(cache_file):
                 img = Image.open(cache_file)
                 ax.imshow(img, extent=extent, transform=ccrs.PlateCarree())
             else:
                 temp_fig, temp_ax = plt.subplots(figsize=(12, 9),
                                                  subplot_kw={'projection': ccrs.PlateCarree()})
                 temp_ax.set_extent(extent, crs=ccrs.PlateCarree())
+
                 m = Basemap(projection='cyl',
                             llcrnrlon=extent[0], urcrnrlon=extent[1],
                             llcrnrlat=extent[2], urcrnrlat=extent[3],
                             resolution='f', ax=temp_ax)
                 m.shadedrelief()
 
-                if cache_file:
-                    try:
-                        temp_fig.savefig(cache_file, dpi=300, bbox_inches='tight', pad_inches=0)
-                    except Exception as e:
-                        print(f"[Cache Save Failed]: {e}")
+                temp_fig.savefig(cache_file, dpi=300, bbox_inches='tight', pad_inches=0)
                 plt.close(temp_fig)
 
-                # Display image only if it was saved
-                if cache_file and os.path.exists(cache_file):
-                    img = Image.open(cache_file)
-                    ax.imshow(img, extent=extent, transform=ccrs.PlateCarree())
+                img = Image.open(cache_file)
+                ax.imshow(img, extent=extent, transform=ccrs.PlateCarree())
 
         else:
             raise ValueError(f"Unsupported basemap mode: {mode}")

ash_animator/converter.py

@@ -1,148 +1,4 @@
-# # Full updated and corrected version of NAMEDataConverter with sanitized metadata keys
-
-# import os
-# import re
-# import zipfile
-# import shutil
-# import numpy as np
-# import xarray as xr
-# import matplotlib.pyplot as plt
-# import matplotlib.animation as animation
-# from typing import List, Tuple
-
-# class NAMEDataConverter:
-#     def __init__(self, output_dir: str):
-#         self.output_dir = output_dir
-#         os.makedirs(self.output_dir, exist_ok=True)
-
-#     def _sanitize_key(self, key: str) -> str:
-#         # Replace non-alphanumeric characters with underscores, and ensure it starts with a letter
-#         key = re.sub(r'\W+', '_', key)
-#         if not key[0].isalpha():
-#             key = f"attr_{key}"
-#         return key
-
-#     def _parse_metadata(self, lines: List[str]) -> dict:
-#         metadata = {}
-#         for line in lines:
-#             if ":" in line:
-#                 key, value = line.split(":", 1)
-#                 clean_key = self._sanitize_key(key.strip().lower())
-#                 metadata[clean_key] = value.strip()
-
-#         try:
-#             metadata.update({
-#                 "x_origin": float(metadata["x_grid_origin"]),
-#                 "y_origin": float(metadata["y_grid_origin"]),
-#                 "x_size": int(metadata["x_grid_size"]),
-#                 "y_size": int(metadata["y_grid_size"]),
-#                 "x_res": float(metadata["x_grid_resolution"]),
-#                 "y_res": float(metadata["y_grid_resolution"]),
-#                 "prelim_cols": int(metadata["number_of_preliminary_cols"]),
-#                 "n_fields": int(metadata["number_of_field_cols"]),
-#             })
-#         except KeyError as e:
-#             raise ValueError(f"Missing required metadata field: {e}")
-#         except ValueError as e:
-#             raise ValueError(f"Invalid value in metadata: {e}")
-
-#         if metadata["x_res"] == 0 or metadata["y_res"] == 0:
-#             raise ZeroDivisionError("Grid resolution cannot be zero.")
-
-#         return metadata
-
-#     def _get_data_lines(self, lines: List[str]) -> List[str]:
-#         idx = next(i for i, l in enumerate(lines) if l.strip() == "Fields:")
-#         return lines[idx + 1:]
-
-#     def convert_3d_group(self, group: List[Tuple[int, str]], output_filename: str) -> str:
-#         first_file_path = group[0][1]
-#         with open(first_file_path, 'r') as f:
-#             lines = f.readlines()
-#         meta = self._parse_metadata(lines)
-
-#         lons = np.round(np.arange(meta["x_origin"], meta["x_origin"] + meta["x_size"] * meta["x_res"], meta["x_res"]), 6)
-#         lats = np.round(np.arange(meta["y_origin"], meta["y_origin"] + meta["y_size"] * meta["y_res"], meta["y_res"]), 6)
-
-#         z_levels = []
-#         z_coords = []
-
-#         for z_idx, filepath in group:
-#             with open(filepath, 'r') as f:
-#                 lines = f.readlines()
-#             data_lines = self._get_data_lines(lines)
-#             grid = np.zeros((meta["y_size"], meta["x_size"]), dtype=np.float32)
-
-#             for line in data_lines:
-#                 parts = [p.strip().strip(',') for p in line.strip().split(',') if p.strip()]
-#                 if len(parts) >= 5 and parts[0].isdigit() and parts[1].isdigit():
-#                     try:
-#                         x = int(parts[0]) - 1
-#                         y = int(parts[1]) - 1
-#                         val = float(parts[4])
-#                         if 0 <= x < meta["x_size"] and 0 <= y < meta["y_size"]:
-#                             grid[y, x] = val
-#                     except Exception:
-#                         continue
-#             z_levels.append(grid)
-#             z_coords.append(z_idx)
-
-#         z_cube = np.stack(z_levels, axis=0)
-#         ds = xr.Dataset(
-#             {
-#                 "ash_concentration": (['altitude', 'latitude', 'longitude'], z_cube)
-#             },
-#             coords={
-#                 "altitude": np.array(z_coords, dtype=np.float32),
-#                 "latitude": lats,
-#                 "longitude": lons
-#             },
-#             attrs={
-#                 "title": "Volcanic Ash Concentration",
-#                 "source": "NAME model output processed to NetCDF",
-#                 **{k: str(v) for k, v in meta.items()}  # Ensure all attrs are strings
-#             }
-#         )
-#         ds["ash_concentration"].attrs.update({
-#             "units": "g/m^3",
-#             "long_name": "Volcanic ash concentration"
-#         })
-#         ds["altitude"].attrs["units"] = "kilometers above sea level"
-#         ds["latitude"].attrs["units"] = "degrees_north"
-#         ds["longitude"].attrs["units"] = "degrees_east"
-
-#         out_path = os.path.join(self.output_dir, output_filename)
-#         ds.to_netcdf(out_path)
-#         return out_path
-
-#     def batch_process_zip(self, zip_path: str) -> List[str]:
-#         extract_dir = os.path.join(self.output_dir, "unzipped")
-#         os.makedirs(extract_dir, exist_ok=True)
-
-#         with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-#             zip_ref.extractall(extract_dir)
-
-#         txt_files = []
-#         for root, _, files in os.walk(extract_dir):
-#             for file in files:
-#                 if file.endswith(".txt"):
-#                     txt_files.append(os.path.join(root, file))
-
-#         pattern = re.compile(r"_T(\d+)_.*_Z(\d+)\.txt$")
-#         grouped = {}
-#         for f in txt_files:
-#             match = pattern.search(f)
-#             if match:
-#                 t = int(match.group(1))
-#                 z = int(match.group(2))
-#                 grouped.setdefault(t, []).append((z, f))
-
-#         nc_files = []
-#         for t_key in sorted(grouped):
-#             group = sorted(grouped[t_key])
-#             out_nc = self.convert_3d_group(group, f"T{t_key}.nc")
-#             nc_files.append(out_nc)
-#         return nc_files
+
 
 # Re-defining the integrated class first
 import os
@@ -154,8 +10,17 @@ from typing import List, Tuple
 import shutil
 
 
+import tempfile  # Added for safe temp directory usage
+
 class NAMEDataProcessor:
-    def __init__(self, output_root: str):
+    def __init__(self, output_root: str = None):
+        if output_root is None:
+            output_root = os.path.join(tempfile.gettempdir(), "name_outputs")
+        self.output_root = output_root
+        self.output_3d = os.path.join(self.output_root, "3D")
+        self.output_horizontal = os.path.join(self.output_root, "horizontal")
+        os.makedirs(self.output_3d, exist_ok=True)
+        os.makedirs(self.output_horizontal, exist_ok=True)
         self.output_root = output_root
         self.output_3d = os.path.join(self.output_root, "3D")
         self.output_horizontal = os.path.join(self.output_root, "horizontal")
@@ -332,7 +197,7 @@ class NAMEDataProcessor:
 
 
     def batch_process_zip(self, zip_path: str) -> List[str]:
-        extract_dir = os.path.abspath("unzipped")
+        extract_dir = os.path.join(tempfile.gettempdir(), "unzipped_name_extract")
 
         os.makedirs(extract_dir, exist_ok=True)
         

ash_animator/plot_3dfield_data.py

@@ -11,6 +11,7 @@ from .interpolation import interpolate_grid
 from .basemaps import draw_etopo_basemap
 import imageio.v2 as imageio
 import shutil
+import tempfile
 
 class Plot_3DField_Data:
     
@@ -70,7 +71,13 @@ class Plot_3DField_Data:
                  include_metadata=True, threshold=0.1,
                  zoom_width_deg=6.0, zoom_height_deg=6.0, zoom_level=7, basemap_type="basemap"):
         self.animator = animator
-        self.output_dir = os.path.abspath(os.path.join(os.getcwd(), output_dir))
+        
+        self.output_dir = os.path.abspath(
+            os.path.join(
+                os.environ.get("NAME_OUTPUT_DIR", tempfile.gettempdir()),
+                output_dir
+            )
+        )
         os.makedirs(self.output_dir, exist_ok=True)
         self.cmap = cmap
         self.fps = fps

ash_animator/plot_horizontal_data.py

@@ -9,13 +9,20 @@ import cartopy.io.shapereader as shpreader
 from adjustText import adjust_text
 from ash_animator.interpolation import interpolate_grid
 from ash_animator.basemaps import draw_etopo_basemap
+import tempfile
 
 class Plot_Horizontal_Data:
     def __init__(self, animator, output_dir="plots", cmap="rainbow", fps=2,
                  include_metadata=True, threshold=0.1,
                  zoom_width_deg=6.0, zoom_height_deg=6.0, zoom_level=7, static_frame_export=False):
         self.animator = animator
-        self.output_dir = os.path.abspath(os.path.join(os.getcwd(), output_dir))
+                
+        self.output_dir = os.path.abspath(
+            os.path.join(
+                os.environ.get("NAME_OUTPUT_DIR", tempfile.gettempdir()),
+                output_dir
+            )
+        )
         os.makedirs(self.output_dir, exist_ok=True)
         self.cmap = cmap
         self.fps = fps
@@ -174,7 +181,7 @@ class Plot_Horizontal_Data:
 
            # Inside update() function:
             if not hasattr(update, "colorbar"):
-                unit_label =  f"{field}:({self.animator.datasets[0][field].attrs.get('units', field)})" #self.animator.datasets[0][field].attrs.get("units", field)
+                unit_label =  f"{field}:({self.animator.datasets[0][field].attrs.get("units", field)})" #self.animator.datasets[0][field].attrs.get("units", field)
                 update.colorbar = fig.colorbar(c, ax=[ax1, ax2], orientation='vertical', label=unit_label)
                 formatter = mticker.FuncFormatter(lambda x, _: f'{x:.2g}')
                 update.colorbar.ax.yaxis.set_major_formatter(formatter)