CI: deploy Docker/PDM Space

demo media/Bushland Beacon 1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8aadc5547f57edf2bfcf17c4d89095d62ae4646f9aaa40675068d0a3c585c49e
+size 34102597

services/app_service/app.py

@@ -29,7 +29,7 @@ def main() -> None:
         st.page_link("pages/task_drone.py", label="Task Drone")
         
 
-    bg_image = local_image_to_data_url("resources/images/rescue.jpg")
+    bg_image = local_image_to_data_url("resources/images/rescue3.jpg")
     hide_default_css = """
     <style>
     #MainMenu {visibility: hidden;}
@@ -129,12 +129,12 @@ def main() -> None:
         <section class="hero">
             <div class="content">
                 <h1>SAR-X<sup>ai</h1>
-                <h2>NATSAR Detection Hub</h2>
+                <h2>Detection Hub</h2>
                 <div class="subtitle">
                     AI-powered person and vessel recognition
                 </div>
                 <div class="disclaimer">
-                    Note: this is a mock-up of a potential app
+                    (application mock-up)
                 </divd>
             </div>
         </section>

services/app_service/pages/bushland_beacon.py

@@ -1,26 +1,60 @@
 # pages/bushland_beacon.py
+
+
 import io
-import tempfile
 import time
+import queue
+import threading
+import tempfile
 from pathlib import Path
+from contextlib import contextmanager
 
 import cv2
 import numpy as np
 import streamlit as st
 from PIL import Image
+
+# Torch (optional)
+try:
+    import torch
+except Exception:
+    torch = None
+
 from utils.model_manager import get_model_manager, load_model
 
-# =============== Page setup ===============
-st.set_page_config(
-    page_title="Bushland Beacon ", layout="wide", initial_sidebar_state="expanded"
-)
+
+# ================== CONFIG ==================
+# --- User-tunable parameters ---
+DEFAULT_CONF_THRESHOLD = 0.30            # Detection confidence
+DEFAULT_TARGET_SHORT_SIDE = 960         # Resize short edge (px)
+DEFAULT_MAX_PREVIEW_FPS = 30             # Limit UI update frequency
+DEFAULT_DROP_IF_BEHIND = False            # Drop frames if lagging
+DEFAULT_PROCESS_STRIDE = 1               # Process every Nth frame (1=all)
+DEFAULT_QUEUE_SIZE = 24                  # Frame queue length
+DEFAULT_WRITER_CODEC = "mp4v"            # Codec to avoid OpenH264 issue
+DEFAULT_TMP_EXT = ".mp4"                 # Temp file extension
+DEFAULT_MAX_SLIDER_SHORT_SIDE = 1080     # Max short side slider
+DEFAULT_MIN_SLIDER_SHORT_SIDE = 256      # Min short side slider
+DEFAULT_MIN_FPS_SLIDER = 1               # Min preview FPS slider
+DEFAULT_MAX_FPS_SLIDER = 30              # Max preview FPS slider
+# ============================================
+
+
+# ============== Session state (stop flag) ==============
+if "stop_video" not in st.session_state:
+    st.session_state["stop_video"] = False
+
+
+# ================== Page setup ==================
+st.set_page_config(page_title="Bushland Beacon", layout="wide", initial_sidebar_state="expanded")
 
 st.markdown(
     "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</sup></h2>"
     "<h2 style='text-align:center;margin-top:0'>Bushland Beacon 🚨 </h2>",
     unsafe_allow_html=True,
 )
-# =============== Sidebar: custom menu + cards ===============
+
+# ================== Sidebar ==================
 with st.sidebar:
     st.page_link("app.py", label="Home")
     st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
@@ -29,55 +63,278 @@ with st.sidebar:
     st.markdown("---")
     st.page_link("pages/task_satellite.py", label="Task Satellite")
     st.page_link("pages/task_drone.py", label="Task Drone")
-
     st.markdown("---")
 
-    # Simple "card" styling in the sidebar
-    st.markdown(
-        """
-    <style>
-    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
-    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
-    </style>
-    """,
-        unsafe_allow_html=True,
-    )
-
-    # Image Detection card
     st.sidebar.header("Image Detection")
-    img_file = st.file_uploader(
-        "Upload an image", type=["jpg", "jpeg", "png"], key="img_up"
-    )
+    img_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"], key="img_up")
     run_img = st.button("🔍 Run Image Detection", use_container_width=True)
 
-    # Video Detection card
-    st.sidebar.header("Video Detection")
-    vid_file = st.file_uploader(
-        "Upload a video", type=["mp4", "mov", "avi", "mkv"], key="vid_up"
-    )
-    run_vid = st.button("🎥 Run Video Detection", use_container_width=True)
+    st.sidebar.header("Video")
+    vid_file = st.file_uploader("Upload a video", type=["mp4", "mov", "avi", "mkv"], key="vid_up")
+
+    # New buttons
+    run_vid_plain = st.button("Play Video", use_container_width=True)
+    run_vid = st.button("🎥 Run Detection", use_container_width=True)
+    stop_vid = st.button("Stop", use_container_width=True)
+
+    if stop_vid:
+        st.session_state["stop_video"] = True
 
     st.sidebar.markdown("---")
-    # Parameters card (shared)
     st.sidebar.header("Parameters")
-    conf_thr = st.slider("Minimum confidence threshold", 0.05, 0.95, 0.50, 0.01)
 
-    st.sidebar.markdown("---")
+    conf_thr = st.slider("Minimum confidence threshold", 0.05, 0.95, DEFAULT_CONF_THRESHOLD, 0.01)
 
-    # Get model manager instance
-    model_manager = get_model_manager()
+    target_short_side = st.select_slider(
+        "Target short-side (downscale)",
+        options=[256, 320, 384, 448, 512, 640, 720, 800, 864, 960, 1080],
+        value=DEFAULT_TARGET_SHORT_SIDE,
+        help="Resize so the shorter edge equals this value. Smaller = faster."
+    )
 
-    # Render model selection UI
-    model_label, model_key = model_manager.render_model_selection(
-        key_prefix="bushland_beacon"
+    max_preview_fps = st.slider(
+        "Max preview FPS",
+        min_value=DEFAULT_MIN_FPS_SLIDER,
+        max_value=DEFAULT_MAX_FPS_SLIDER,
+        value=DEFAULT_MAX_PREVIEW_FPS,
+        help="Throttles UI updates for smoother preview."
+    )
+
+    drop_if_behind = st.toggle(
+        "Drop frames if behind",
+        value=DEFAULT_DROP_IF_BEHIND,
+        help="Drop frames to maintain smooth preview."
+    )
+
+    process_stride = st.slider(
+        "Process every Nth frame",
+        min_value=1,
+        max_value=5,
+        value=DEFAULT_PROCESS_STRIDE,
+        help="1 = every frame; higher values reuse last result."
     )
-    st.sidebar.markdown("---")
 
-    # Render device information
+    st.sidebar.markdown("---")
+    model_manager = get_model_manager()
+    model_label, model_key = model_manager.render_model_selection(key_prefix="bushland_beacon")
+    st.sidebar.markdown("---")
     model_manager.render_device_info()
 
 
-# =============== Detection helpers ===============
+# ================== Perf knobs for OpenCV ==================
+try:
+    cv2.setNumThreads(1)
+except Exception:
+    pass
+try:
+    cv2.ocl.setUseOpenCL(False)
+except Exception:
+    pass
+
+
+# ================== Helper functions ==================
+def _resize_keep_aspect(img_bgr: np.ndarray, short_side: int) -> np.ndarray:
+    h, w = img_bgr.shape[:2]
+    if min(h, w) == short_side:
+        return img_bgr
+    if h < w:
+        new_h = short_side
+        new_w = int(round(w * (short_side / h)))
+    else:
+        new_w = short_side
+        new_h = int(round(h * (short_side / w)))
+    return cv2.resize(img_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+
+def _should_force_cpu_for_model(model_key: str) -> bool:
+    return (model_key or "").lower() == "deim"
+
+
+def _choose_device(model_key: str) -> str:
+    if _should_force_cpu_for_model(model_key):
+        return "cpu"
+    if torch is not None and torch.cuda.is_available():
+        return "cuda"
+    return "cpu"
+
+
+def _warmup_model(model, model_key: str, shape=(720, 1280, 3), conf: float = 0.25):
+    dummy = np.zeros(shape, dtype=np.uint8)
+    try:
+        if (model_key or "").lower() == "deim":
+            pil = Image.fromarray(cv2.cvtColor(dummy, cv2.COLOR_BGR2RGB))
+            model.predict_image(pil, min_confidence=conf)
+        else:
+            model.predict_and_visualize(dummy, min_confidence=conf, show_score=False)
+    except Exception:
+        pass
+
+
+@contextmanager
+def maybe_autocast(enabled: bool):
+    if enabled and torch is not None and torch.cuda.is_available():
+        with torch.cuda.amp.autocast():
+            yield
+    else:
+        yield
+
+
+def _device_hint() -> str:
+    if torch is None:
+        return "cpu"
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+# ================== Passthrough (no model, no boxes) ==================
+def run_video_passthrough(
+    vid_bytes: bytes,
+    target_short_side: int = DEFAULT_TARGET_SHORT_SIDE,
+    max_preview_fps: int = DEFAULT_MAX_PREVIEW_FPS,
+    drop_if_behind: bool = DEFAULT_DROP_IF_BEHIND,
+):
+    """Play the uploaded video with scaling & pacing only (no inference, no overlays)."""
+    ts = int(time.time() * 1000)
+    tmp_in = Path(tempfile.gettempdir()) / f"in_{ts}{DEFAULT_TMP_EXT}"
+    with open(tmp_in, "wb") as f:
+        f.write(vid_bytes)
+
+    cap = cv2.VideoCapture(str(tmp_in), cv2.CAP_FFMPEG)
+    if not cap.isOpened():
+        st.error("Failed to open the uploaded video.")
+        return
+
+    try:
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 2)
+    except Exception:
+        pass
+
+    src_fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+
+    # UI placeholders
+    frame_ph = st.empty()
+    info_ph = st.empty()
+    prog = st.progress(0.0, text="Preparing…")
+
+    # Reader thread -> queue
+    q: "queue.Queue[tuple[int, np.ndarray] | None]" = queue.Queue(maxsize=DEFAULT_QUEUE_SIZE)
+
+    def reader():
+        idx = 0
+        while True:
+            if st.session_state.get("stop_video", False):
+                break
+            ok, frm = cap.read()
+            if not ok:
+                break
+            if drop_if_behind and q.full():
+                try:
+                    q.get_nowait()
+                except queue.Empty:
+                    pass
+            try:
+                q.put((idx, frm), timeout=0.05)
+            except queue.Full:
+                pass
+            idx += 1
+        q.put(None)
+
+    reader_th = threading.Thread(target=reader, daemon=True)
+    reader_th.start()
+
+    # Writer (optional export)
+    tmp_out = Path(tempfile.gettempdir()) / f"out_{ts}{DEFAULT_TMP_EXT}"
+    writer = None
+
+    # Pacing and preview throttle
+    min_preview_interval = 1.0 / float(max_preview_fps)
+    last_preview_ts = 0.0
+    frame_interval = 1.0 / float(src_fps if src_fps > 0 else 25.0)
+    next_write_ts = time.perf_counter() + frame_interval
+
+    frames_done = 0
+    t0 = time.perf_counter()
+
+    try:
+        with st.spinner("Playing video…"):
+            while True:
+                if st.session_state.get("stop_video", False):
+                    break
+
+                item = q.get()
+                if item is None:
+                    break
+                idx, frame_bgr = item
+
+                # Downscale for speed/preview
+                vis_bgr = _resize_keep_aspect(frame_bgr, short_side=target_short_side)
+
+                # Init writer lazily
+                if writer is None:
+                    H, W = vis_bgr.shape[:2]
+                    fourcc = cv2.VideoWriter_fourcc(*DEFAULT_WRITER_CODEC)
+                    writer = cv2.VideoWriter(str(tmp_out), fourcc, src_fps, (W, H))
+
+                # Pace writing to match source
+                now = time.perf_counter()
+                if now < next_write_ts:
+                    time.sleep(max(0.0, next_write_ts - now))
+                writer.write(vis_bgr)
+                next_write_ts += frame_interval
+
+                frames_done += 1
+
+                # UI updates (throttled)
+                now = time.perf_counter()
+                if (now - last_preview_ts) >= min_preview_interval:
+                    frame_ph.image(
+                        cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB),
+                        use_container_width=True,
+                        output_format="JPEG",
+                        channels="RGB",
+                    )
+                    elapsed = now - t0
+                    fps_est = frames_done / max(elapsed, 1e-6)
+                    info_ph.info(
+                        f"Frames: {frames_done}/{total_frames or '?'}  •  "
+                        f"Throughput: {fps_est:.1f} FPS  •  Source FPS: {src_fps:.1f}  •  "
+                        f"Mode: Passthrough"
+                    )
+                    last_preview_ts = now
+
+                # Progress
+                progress = ((idx + 1) / total_frames) if total_frames > 0 else min(frames_done / (frames_done + 30), 0.99)
+                prog.progress(progress, text=f"Playing frame {idx + 1}{'/' + str(total_frames) if total_frames>0 else ''}…")
+
+    except Exception as exc:
+        st.error(f"Video playback failed: {exc}")
+        return
+    finally:
+        try:
+            cap.release()
+            if writer is not None:
+                writer.release()
+        except Exception:
+            pass
+
+    # Reset stop flag after finishing
+    st.session_state["stop_video"] = False
+
+    st.success("Done!")
+    if tmp_out.exists():
+        st.video(str(tmp_out))
+        with open(tmp_out, "rb") as f:
+            st.download_button(
+                "Download video",
+                data=f.read(),
+                file_name=tmp_out.name,
+                mime="video/mp4",
+            )
+    else:
+        st.error("Playback completed but output file was not created.")
+
+
+# ================== Detection routines ==================
 def run_image_detection(uploaded_file, conf_thr: float = 0.5, model_key: str = "deim"):
     try:
         data = uploaded_file.getvalue()
@@ -89,95 +346,225 @@ def run_image_detection(uploaded_file, conf_thr: float = 0.5, model_key: str = "
 
     try:
         model = load_model(model_key)
-        with st.spinner("Running detection..."):
-            annotated = model.predict_image(img, min_confidence=conf_thr)
+        device = _choose_device(model_key)
+        if torch is not None:
+            try:
+                model.to(device)
+            except Exception:
+                pass
+
+        _warmup_model(model, model_key=model_key, shape=(img.height, img.width, 3), conf=conf_thr)
+        use_amp = (device == "cuda") and not _should_force_cpu_for_model(model_key)
+
+        with st.spinner(f"Running detection on {device.upper()}…"):
+            with maybe_autocast(use_amp):
+                if (model_key or "").lower() == "deim":
+                    annotated = model.predict_image(img, min_confidence=conf_thr)
+                else:
+                    try:
+                        annotated = model.predict_image(img, min_confidence=conf_thr)
+                    except Exception:
+                        np_bgr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+                        _, vis = model.predict_and_visualize(np_bgr, min_confidence=conf_thr, show_score=True)
+                        annotated = Image.fromarray(cv2.cvtColor(vis, cv2.COLOR_BGR2RGB))
 
         st.subheader("🎯 Detection Results")
-        st.image(annotated, caption="Detections", width="stretch")
+        st.image(annotated, caption="Detections", use_container_width=True)
+
+        if _should_force_cpu_for_model(model_key):
+            st.info("DEIM runs on CPU to avoid TorchScript device mismatch.")
+
     except Exception as e:
         st.error(f"Error during detection: {e}")
 
 
-def run_video_detection(vid_bytes, conf_thr: float = 0.5, model_key: str = "deim"):
-    tmp_in = Path(tempfile.gettempdir()) / f"in_{int(time.time())}.mp4"
+def run_video_detection(
+    vid_bytes: bytes,
+    conf_thr: float = 0.5,
+    model_key: str = "deim",
+    target_short_side: int = DEFAULT_TARGET_SHORT_SIDE,
+    max_preview_fps: int = DEFAULT_MAX_PREVIEW_FPS,
+    drop_if_behind: bool = DEFAULT_DROP_IF_BEHIND,
+    process_stride: int = DEFAULT_PROCESS_STRIDE,
+):
+    # Save upload to a temp file
+    ts = int(time.time() * 1000)
+    tmp_in = Path(tempfile.gettempdir()) / f"in_{ts}{DEFAULT_TMP_EXT}"
     with open(tmp_in, "wb") as f:
         f.write(vid_bytes)
 
+    # Load model & choose device
     model = load_model(model_key)
-
-    # Set up video capture for preview
-    cap = cv2.VideoCapture(str(tmp_in))
+    device = _choose_device(model_key)
+    if torch is not None:
+        try:
+            model.to(device)
+        except Exception:
+            pass
+
+    # Capture
+    cap = cv2.VideoCapture(str(tmp_in), cv2.CAP_FFMPEG)
     if not cap.isOpened():
         st.error("Failed to open the uploaded video.")
         return
 
-    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    try:
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 2)
+    except Exception:
+        pass
+
+    src_fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+    src_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    src_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-    # Set up preview and progress
     frame_ph = st.empty()
-    prog = st.progress(0.0, text="Processing…")
-
-    # Set up video writer for output
-    W = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    H = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    tmp_out = Path(tempfile.gettempdir()) / f"out_{int(time.time())}.mp4"
-    writer = cv2.VideoWriter(str(tmp_out), cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H))
-
-    frame_count = 0
-    last_preview_update = 0
-    preview_update_interval = 5  # Update preview every 5 frames
+    info_ph = st.empty()
+    prog = st.progress(0.0, text="Preparing…")
+
+    _warmup_model(model, model_key=model_key, shape=(min(src_h, src_w), max(src_h, src_w), 3), conf=conf_thr)
+
+    # Reader thread -> bounded queue
+    q: "queue.Queue[tuple[int, np.ndarray] | None]" = queue.Queue(maxsize=DEFAULT_QUEUE_SIZE)
+
+    def reader():
+        idx = 0
+        while True:
+            if st.session_state.get("stop_video", False):
+                break
+            ok, frm = cap.read()
+            if not ok:
+                break
+            if drop_if_behind and q.full():
+                # drop the oldest frame to keep things moving
+                try:
+                    q.get_nowait()
+                except queue.Empty:
+                    pass
+            try:
+                q.put((idx, frm), timeout=0.05)
+            except queue.Full:
+                pass
+            idx += 1
+        q.put(None)
+
+    reader_th = threading.Thread(target=reader, daemon=True)
+    reader_th.start()
+
+    tmp_out = Path(tempfile.gettempdir()) / f"out_{ts}{DEFAULT_TMP_EXT}"
+    writer = None
+
+    # Preview throttle
+    min_preview_interval = 1.0 / float(max_preview_fps)
+    last_preview_ts = 0.0
+
+    # Source pacing
+    frame_interval = 1.0 / float(src_fps if src_fps > 0 else 25.0)
+    next_write_ts = time.perf_counter() + frame_interval
+
+    frames_done = 0
+    t0 = time.perf_counter()
+    use_amp = (device == "cuda") and not _should_force_cpu_for_model(model_key)
+
+    last_vis_bgr = None  # for stride reuse
 
     try:
-        with st.spinner("Processing video with live preview…"):
+        with st.spinner(f"Processing video on {device.upper()} with live preview…"):
             while True:
-                ok, frame = cap.read()
-                if not ok:
+                if st.session_state.get("stop_video", False):
                     break
 
-                # Process frame with model
-                if model_key == "deim":
-                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    annotated_pil = model.predict_image(
-                        Image.fromarray(frame_rgb), min_confidence=conf_thr
-                    )
-                    vis = cv2.cvtColor(np.array(annotated_pil), cv2.COLOR_RGB2BGR)
+                item = q.get()
+                if item is None:
+                    break
+                idx, frame_bgr = item
+
+                # Downscale for speed
+                proc_bgr = _resize_keep_aspect(frame_bgr, short_side=target_short_side)
+
+                run_infer = (process_stride <= 1) or ((idx % process_stride) == 0)
+
+                if run_infer:
+                    # Run model
+                    if (model_key or "").lower() == "deim":
+                        img_rgb = cv2.cvtColor(proc_bgr, cv2.COLOR_BGR2RGB)
+                        pil_img = Image.fromarray(img_rgb)
+                        annotated_pil = model.predict_image(pil_img, min_confidence=conf_thr)
+                        vis_bgr = cv2.cvtColor(np.array(annotated_pil), cv2.COLOR_RGB2BGR)
+                    else:
+                        with maybe_autocast(use_amp):
+                            try:
+                                _, vis_bgr = model.predict_and_visualize(
+                                    proc_bgr, min_confidence=conf_thr, show_score=True
+                                )
+                            except Exception:
+                                pil = Image.fromarray(cv2.cvtColor(proc_bgr, cv2.COLOR_BGR2RGB))
+                                annotated = model.predict_image(pil, min_confidence=conf_thr)
+                                vis_bgr = cv2.cvtColor(np.array(annotated), cv2.COLOR_RGB2BGR)
+                    last_vis_bgr = vis_bgr
                 else:
-                    _, vis = model.predict_and_visualize(
-                        frame, min_confidence=conf_thr, show_score=True
-                    )
-
-                # Update progress
-                progress = frame_count / total_frames if total_frames > 0 else 0
-                prog.progress(
-                    progress,
-                    text=f"Processing frame {frame_count + 1}/{total_frames}...",
-                )
-
-                # Update preview (throttled to prevent freezing)
-                if (frame_count - last_preview_update) >= preview_update_interval:
+                    # Reuse last visualised frame to avoid visible “skips”
+                    vis_bgr = last_vis_bgr if last_vis_bgr is not None else proc_bgr
+
+                # Init writer when first output frame is ready
+                if writer is None:
+                    H, W = vis_bgr.shape[:2]
+                    fourcc = cv2.VideoWriter_fourcc(*DEFAULT_WRITER_CODEC)  # avoids OpenH264 issues
+                    out_fps = src_fps  # preserve source FPS in output
+                    writer = cv2.VideoWriter(str(tmp_out), fourcc, out_fps, (W, H))
+
+                # Pace writing to match the source timeline
+                now = time.perf_counter()
+                if now < next_write_ts:
+                    time.sleep(max(0.0, next_write_ts - now))
+                writer.write(vis_bgr)
+                next_write_ts += frame_interval
+
+                frames_done += 1
+
+                # UI updates (throttled)
+                now = time.perf_counter()
+                if (now - last_preview_ts) >= min_preview_interval:
                     frame_ph.image(
-                        cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                        cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB),
                         use_container_width=True,
                         output_format="JPEG",
                         channels="RGB",
                     )
-                    last_preview_update = frame_count
+                    elapsed = now - t0
+                    fps_est = frames_done / max(elapsed, 1e-6)
+                    device_msg = f"{device.upper()}" if device != "cuda" else f"{device.upper()} ({_device_hint().upper()})"
+                    info_text = (
+                        f"Processed: {frames_done} / {total_frames if total_frames>0 else '?'}  •  "
+                        f"Throughput: {fps_est:.1f} FPS  •  "
+                        f"Source FPS: {src_fps:.1f}  •  Device: {device_msg}  •  "
+                        f"Stride: {process_stride}x"
+                    )
+                    if _should_force_cpu_for_model(model_key):
+                        info_text += "  •  Note: DEIM forced to CPU."
+                    info_ph.info(info_text)
+                    last_preview_ts = now
 
-                # Write frame to output video
-                writer.write(vis)
-                frame_count += 1
+                # Progress bar
+                progress = ((idx + 1) / total_frames) if total_frames > 0 else min(frames_done / (frames_done + 30), 0.99)
+                prog.progress(progress, text=f"Processing frame {idx + 1}{'/' + str(total_frames) if total_frames>0 else ''}…")
 
     except Exception as exc:
         st.error(f"Video detection failed: {exc}")
         return
     finally:
-        cap.release()
-        writer.release()
+        try:
+            cap.release()
+            if writer is not None:
+                writer.release()
+        except Exception:
+            pass
+
+    # Reset stop flag after finishing
+    st.session_state["stop_video"] = False
 
     st.success("Done!")
 
-    # Check if output file exists before trying to display it
     if tmp_out.exists():
         st.video(str(tmp_out))
         with open(tmp_out, "rb") as f:
@@ -191,17 +578,38 @@ def run_video_detection(vid_bytes, conf_thr: float = 0.5, model_key: str = "deim
         st.error("Video processing completed but output file was not created.")
 
 
-# =============== Main: hook up actions ===============
+# ================== Main Actions ==================
 if run_img:
     if img_file is None:
         st.warning("Please upload an image first.")
     else:
         run_image_detection(img_file, conf_thr=conf_thr, model_key=model_key)
 
+# New: Passthrough mode
+if run_vid_plain:
+    if vid_file is None:
+        st.warning("Please upload a video first.")
+    else:
+        st.session_state["stop_video"] = False
+        run_video_passthrough(
+            vid_bytes=vid_file.read(),
+            target_short_side=target_short_side,
+            max_preview_fps=max_preview_fps,
+            drop_if_behind=drop_if_behind,
+        )
+
+# Original: Detection mode
 if run_vid:
     if vid_file is None:
         st.warning("Please upload a video first.")
     else:
+        st.session_state["stop_video"] = False
         run_video_detection(
-            vid_bytes=vid_file.read(), conf_thr=conf_thr, model_key=model_key
+            vid_bytes=vid_file.read(),
+            conf_thr=conf_thr,
+            model_key=model_key,
+            target_short_side=target_short_side,
+            max_preview_fps=max_preview_fps,
+            drop_if_behind=drop_if_behind,
+            process_stride=process_stride,
         )

services/app_service/pages/bushland_beacon_KY.py

@@ -0,0 +1,207 @@
+# pages/bushland_beacon.py
+import io
+import tempfile
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+import streamlit as st
+from PIL import Image
+from utils.model_manager import get_model_manager, load_model
+
+# =============== Page setup ===============
+st.set_page_config(
+    page_title="Bushland Beacon ", layout="wide", initial_sidebar_state="expanded"
+)
+
+st.markdown(
+    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</sup></h2>"
+    "<h2 style='text-align:center;margin-top:0'>Bushland Beacon 🚨 </h2>",
+    unsafe_allow_html=True,
+)
+# =============== Sidebar: custom menu + cards ===============
+with st.sidebar:
+    st.page_link("app.py", label="Home")
+    st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
+    st.page_link("pages/lost_at_sea.py", label="Lost at Sea")
+    st.page_link("pages/signal_watch.py", label="Signal Watch")
+    st.markdown("---")
+    st.page_link("pages/task_satellite.py", label="Task Satellite")
+    st.page_link("pages/task_drone.py", label="Task Drone")
+
+    st.markdown("---")
+
+    # Simple "card" styling in the sidebar
+    st.markdown(
+        """
+    <style>
+    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
+    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
+    </style>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Image Detection card
+    st.sidebar.header("Image Detection")
+    img_file = st.file_uploader(
+        "Upload an image", type=["jpg", "jpeg", "png"], key="img_up"
+    )
+    run_img = st.button("🔍 Run Image Detection", use_container_width=True)
+
+    # Video Detection card
+    st.sidebar.header("Video Detection")
+    vid_file = st.file_uploader(
+        "Upload a video", type=["mp4", "mov", "avi", "mkv"], key="vid_up"
+    )
+    run_vid = st.button("🎥 Run Video Detection", use_container_width=True)
+
+    st.sidebar.markdown("---")
+    # Parameters card (shared)
+    st.sidebar.header("Parameters")
+    conf_thr = st.slider("Minimum confidence threshold", 0.05, 0.95, 0.50, 0.01)
+
+    st.sidebar.markdown("---")
+
+    # Get model manager instance
+    model_manager = get_model_manager()
+
+    # Render model selection UI
+    model_label, model_key = model_manager.render_model_selection(
+        key_prefix="bushland_beacon"
+    )
+    st.sidebar.markdown("---")
+
+    # Render device information
+    model_manager.render_device_info()
+
+
+# =============== Detection helpers ===============
+def run_image_detection(uploaded_file, conf_thr: float = 0.5, model_key: str = "deim"):
+    try:
+        data = uploaded_file.getvalue()
+        img = Image.open(io.BytesIO(data)).convert("RGB")
+        st.image(img, caption="Uploaded Image", use_container_width=True)
+    except Exception as e:
+        st.error(f"Error loading image: {e}")
+        return
+
+    try:
+        model = load_model(model_key)
+        with st.spinner("Running detection..."):
+            annotated = model.predict_image(img, min_confidence=conf_thr)
+
+        st.subheader("🎯 Detection Results")
+        st.image(annotated, caption="Detections", width="stretch")
+    except Exception as e:
+        st.error(f"Error during detection: {e}")
+
+
+def run_video_detection(vid_bytes, conf_thr: float = 0.5, model_key: str = "deim"):
+    tmp_in = Path(tempfile.gettempdir()) / f"in_{int(time.time())}.mp4"
+    with open(tmp_in, "wb") as f:
+        f.write(vid_bytes)
+
+    model = load_model(model_key)
+
+    # Set up video capture for preview
+    cap = cv2.VideoCapture(str(tmp_in))
+    if not cap.isOpened():
+        st.error("Failed to open the uploaded video.")
+        return
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+
+    # Set up preview and progress
+    frame_ph = st.empty()
+    prog = st.progress(0.0, text="Processing…")
+
+    # Set up video writer for output
+    W = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    H = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    tmp_out = Path(tempfile.gettempdir()) / f"out_{int(time.time())}.mp4"
+    writer = cv2.VideoWriter(str(tmp_out), cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H))
+
+    frame_count = 0
+    last_preview_update = 0
+    preview_update_interval = 1  # Update preview every 5 frames
+
+    try:
+        with st.spinner("Processing video with live preview…"):
+            while True:
+                ok, frame = cap.read()
+                if not ok:
+                    break
+
+                # Process frame with model
+                if model_key == "deim":
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    annotated_pil = model.predict_image(
+                        Image.fromarray(frame_rgb), min_confidence=conf_thr
+                    )
+                    vis = cv2.cvtColor(np.array(annotated_pil), cv2.COLOR_RGB2BGR)
+                else:
+                    _, vis = model.predict_and_visualize(
+                        frame, min_confidence=conf_thr, show_score=True
+                    )
+
+                # Update progress
+                progress = frame_count / total_frames if total_frames > 0 else 0
+                prog.progress(
+                    progress,
+                    text=f"Processing frame {frame_count + 1}/{total_frames}...",
+                )
+
+                # Update preview (throttled to prevent freezing)
+                if (frame_count - last_preview_update) >= preview_update_interval:
+                    frame_ph.image(
+                        cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                        use_container_width=True,
+                        output_format="JPEG",
+                        channels="RGB",
+                    )
+                    last_preview_update = frame_count
+
+                # Write frame to output video
+                writer.write(vis)
+                frame_count += 1
+
+    except Exception as exc:
+        st.error(f"Video detection failed: {exc}")
+        return
+    finally:
+        cap.release()
+        writer.release()
+
+    st.success("Done!")
+
+    # Check if output file exists before trying to display it
+    if tmp_out.exists():
+        st.video(str(tmp_out))
+        with open(tmp_out, "rb") as f:
+            st.download_button(
+                "Download processed video",
+                data=f.read(),
+                file_name=tmp_out.name,
+                mime="video/mp4",
+            )
+    else:
+        st.error("Video processing completed but output file was not created.")
+
+
+# =============== Main: hook up actions ===============
+if run_img:
+    if img_file is None:
+        st.warning("Please upload an image first.")
+    else:
+        run_image_detection(img_file, conf_thr=conf_thr, model_key=model_key)
+
+if run_vid:
+    if vid_file is None:
+        st.warning("Please upload a video first.")
+    else:
+        run_video_detection(
+            vid_bytes=vid_file.read(), conf_thr=conf_thr, model_key=model_key
+        )

services/app_service/pages/lost_at_sea.py

@@ -1,83 +1,340 @@
 # pages/lost_at_sea.py
+
 import io
-import tempfile
 import time
+import queue
+import threading
+import tempfile
 from pathlib import Path
+from contextlib import contextmanager
 
 import cv2
 import numpy as np
 import streamlit as st
 from PIL import Image
+
+# Torch (optional)
+try:
+    import torch
+except Exception:
+    torch = None
+
 from utils.model_manager import get_model_manager, load_model
 
-# =============== Page setup ===============
-st.set_page_config(
-    page_title="Lost at Sea", layout="wide", initial_sidebar_state="expanded"
-)
+
+# ================== CONFIG ==================
+# --- User-tunable parameters ---
+DEFAULT_CONF_THRESHOLD = 0.30            # Detection confidence
+DEFAULT_TARGET_SHORT_SIDE = 960          # Resize short edge (px)
+DEFAULT_MAX_PREVIEW_FPS = 30             # Limit UI update frequency
+DEFAULT_DROP_IF_BEHIND = False           # Drop frames if lagging
+DEFAULT_PROCESS_STRIDE = 1               # Process every Nth frame (1=all)
+DEFAULT_QUEUE_SIZE = 24                  # Frame queue length
+DEFAULT_WRITER_CODEC = "mp4v"            # Codec to avoid OpenH264 issue
+DEFAULT_TMP_EXT = ".mp4"                 # Temp file extension
+DEFAULT_MAX_SLIDER_SHORT_SIDE = 1080     # Max short side slider
+DEFAULT_MIN_SLIDER_SHORT_SIDE = 256      # Min short side slider
+DEFAULT_MIN_FPS_SLIDER = 1               # Min preview FPS slider
+DEFAULT_MAX_FPS_SLIDER = 30              # Max preview FPS slider
+# ============================================
+
+
+# ============== Session state (stop flag) ==============
+if "stop_video" not in st.session_state:
+    st.session_state["stop_video"] = False
+
+
+# ================== Page setup ==================
+st.set_page_config(page_title="Lost At Sea", layout="wide", initial_sidebar_state="expanded")
 
 st.markdown(
-    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</h2>"
-    "<h2 style='text-align:center;margin-top:0'>Lost at Sea 🌊</h2>",
+    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</sup></h2>"
+    "<h2 style='text-align:center;margin-top:0'>Lost At Sea 🌊</h2>",
     unsafe_allow_html=True,
 )
 
-# =============== Sidebar: custom menu + cards ===============
+# ================== Sidebar ==================
 with st.sidebar:
     st.page_link("app.py", label="Home")
     st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
-    st.page_link("pages/lost_at_sea.py", label="Lost at Sea")
+    st.page_link("pages/lost_at_sea.py", label="Lost At Sea")
     st.page_link("pages/signal_watch.py", label="Signal Watch")
     st.markdown("---")
     st.page_link("pages/task_satellite.py", label="Task Satellite")
     st.page_link("pages/task_drone.py", label="Task Drone")
+    st.markdown("---")
 
-    # Simple "card" styling in the sidebar
-    st.markdown(
-        """
-    <style>
-    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
-    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
-    </style>
-    """,
-        unsafe_allow_html=True,
-    )
-
-    # Image Detection card
     st.sidebar.header("Image Detection")
-    img_file = st.file_uploader(
-        "Upload an image", type=["jpg", "jpeg", "png"], key="img_up"
-    )
+    img_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"], key="img_up")
     run_img = st.button("🔍 Run Image Detection", use_container_width=True)
 
-    # Video Detection card
-    st.sidebar.header("Video Detection")
-    vid_file = st.file_uploader(
-        "Upload a video", type=["mp4", "mov", "avi", "mkv"], key="vid_up"
-    )
-    run_vid = st.button("🎥 Run Video Detection", use_container_width=True)
+    st.sidebar.header("Video")
+    vid_file = st.file_uploader("Upload a video", type=["mp4", "mov", "avi", "mkv"], key="vid_up")
+
+    # New buttons
+    run_vid_plain = st.button("Play Video", use_container_width=True)
+    run_vid = st.button("🎥 Run Detection", use_container_width=True)
+    stop_vid = st.button("Stop", use_container_width=True)
+
+    if stop_vid:
+        st.session_state["stop_video"] = True
 
     st.sidebar.markdown("---")
-    # Parameters card (shared)
     st.sidebar.header("Parameters")
-    conf_thr = st.slider("Minimum confidence threshold", 0.05, 0.95, 0.50, 0.01)
 
-    st.sidebar.markdown("---")
+    conf_thr = st.slider("Minimum confidence threshold", 0.05, 0.95, DEFAULT_CONF_THRESHOLD, 0.01)
 
-    # Get model manager instance
-    model_manager = get_model_manager()
+    target_short_side = st.select_slider(
+        "Target short-side (downscale)",
+        options=[256, 320, 384, 448, 512, 640, 720, 800, 864, 960, 1080],
+        value=DEFAULT_TARGET_SHORT_SIDE,
+        help="Resize so the shorter edge equals this value. Smaller = faster."
+    )
 
-    # Render model selection UI
-    model_label, model_key = model_manager.render_model_selection(
-        key_prefix="lost_at_sea"
+    max_preview_fps = st.slider(
+        "Max preview FPS",
+        min_value=DEFAULT_MIN_FPS_SLIDER,
+        max_value=DEFAULT_MAX_FPS_SLIDER,
+        value=DEFAULT_MAX_PREVIEW_FPS,
+        help="Throttles UI updates for smoother preview."
+    )
+
+    drop_if_behind = st.toggle(
+        "Drop frames if behind",
+        value=DEFAULT_DROP_IF_BEHIND,
+        help="Drop frames to maintain smooth preview."
     )
-    st.sidebar.markdown("---")
 
-    # Render device information
+    process_stride = st.slider(
+        "Process every Nth frame",
+        min_value=1,
+        max_value=5,
+        value=DEFAULT_PROCESS_STRIDE,
+        help="1 = every frame; higher values reuse last result."
+    )
+
+    st.sidebar.markdown("---")
+    model_manager = get_model_manager()
+    model_label, model_key = model_manager.render_model_selection(key_prefix="lost_at_sea")
+    st.sidebar.markdown("---")
     model_manager.render_device_info()
 
 
-# =============== Detection helpers ===============
-def run_image_detection(uploaded_file, conf_thr: float = 0.5):
+# ================== Perf knobs for OpenCV ==================
+try:
+    cv2.setNumThreads(1)
+except Exception:
+    pass
+try:
+    cv2.ocl.setUseOpenCL(False)
+except Exception:
+    pass
+
+
+# ================== Helper functions ==================
+def _resize_keep_aspect(img_bgr: np.ndarray, short_side: int) -> np.ndarray:
+    h, w = img_bgr.shape[:2]
+    if min(h, w) == short_side:
+        return img_bgr
+    if h < w:
+        new_h = short_side
+        new_w = int(round(w * (short_side / h)))
+    else:
+        new_w = short_side
+        new_h = int(round(h * (short_side / w)))
+    return cv2.resize(img_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+
+def _should_force_cpu_for_model(model_key: str) -> bool:
+    return (model_key or "").lower() == "deim"
+
+
+def _choose_device(model_key: str) -> str:
+    if _should_force_cpu_for_model(model_key):
+        return "cpu"
+    if torch is not None and torch.cuda.is_available():
+        return "cuda"
+    return "cpu"
+
+
+def _warmup_model(model, model_key: str, shape=(720, 1280, 3), conf: float = 0.25):
+    dummy = np.zeros(shape, dtype=np.uint8)
+    try:
+        if (model_key or "").lower() == "deim":
+            pil = Image.fromarray(cv2.cvtColor(dummy, cv2.COLOR_BGR2RGB))
+            model.predict_image(pil, min_confidence=conf)
+        else:
+            model.predict_and_visualize(dummy, min_confidence=conf, show_score=False)
+    except Exception:
+        pass
+
+
+@contextmanager
+def maybe_autocast(enabled: bool):
+    if enabled and torch is not None and torch.cuda.is_available():
+        with torch.cuda.amp.autocast():
+            yield
+    else:
+        yield
+
+
+def _device_hint() -> str:
+    if torch is None:
+        return "cpu"
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+# ================== Passthrough (no model, no boxes) ==================
+def run_video_passthrough(
+    vid_bytes: bytes,
+    target_short_side: int = DEFAULT_TARGET_SHORT_SIDE,
+    max_preview_fps: int = DEFAULT_MAX_PREVIEW_FPS,
+    drop_if_behind: bool = DEFAULT_DROP_IF_BEHIND,
+):
+    """Play the uploaded video with scaling & pacing only (no inference, no overlays)."""
+    ts = int(time.time() * 1000)
+    tmp_in = Path(tempfile.gettempdir()) / f"in_{ts}{DEFAULT_TMP_EXT}"
+    with open(tmp_in, "wb") as f:
+        f.write(vid_bytes)
+
+    cap = cv2.VideoCapture(str(tmp_in), cv2.CAP_FFMPEG)
+    if not cap.isOpened():
+        st.error("Failed to open the uploaded video.")
+        return
+
+    try:
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 2)
+    except Exception:
+        pass
+
+    src_fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+
+    # UI placeholders
+    frame_ph = st.empty()
+    info_ph = st.empty()
+    prog = st.progress(0.0, text="Preparing…")
+
+    # Reader thread -> queue
+    q: "queue.Queue[tuple[int, np.ndarray] | None]" = queue.Queue(maxsize=DEFAULT_QUEUE_SIZE)
+
+    def reader():
+        idx = 0
+        while True:
+            if st.session_state.get("stop_video", False):
+                break
+            ok, frm = cap.read()
+            if not ok:
+                break
+            if drop_if_behind and q.full():
+                try:
+                    q.get_nowait()
+                except queue.Empty:
+                    pass
+            try:
+                q.put((idx, frm), timeout=0.05)
+            except queue.Full:
+                pass
+            idx += 1
+        q.put(None)
+
+    reader_th = threading.Thread(target=reader, daemon=True)
+    reader_th.start()
+
+    # Writer (optional export)
+    tmp_out = Path(tempfile.gettempdir()) / f"out_{ts}{DEFAULT_TMP_EXT}"
+    writer = None
+
+    # Pacing and preview throttle
+    min_preview_interval = 1.0 / float(max_preview_fps)
+    last_preview_ts = 0.0
+    frame_interval = 1.0 / float(src_fps if src_fps > 0 else 25.0)
+    next_write_ts = time.perf_counter() + frame_interval
+
+    frames_done = 0
+    t0 = time.perf_counter()
+
+    try:
+        with st.spinner("Playing video…"):
+            while True:
+                if st.session_state.get("stop_video", False):
+                    break
+
+                item = q.get()
+                if item is None:
+                    break
+                idx, frame_bgr = item
+
+                # Downscale for speed/preview
+                vis_bgr = _resize_keep_aspect(frame_bgr, short_side=target_short_side)
+
+                # Init writer lazily
+                if writer is None:
+                    H, W = vis_bgr.shape[:2]
+                    fourcc = cv2.VideoWriter_fourcc(*DEFAULT_WRITER_CODEC)
+                    writer = cv2.VideoWriter(str(tmp_out), fourcc, src_fps, (W, H))
+
+                # Pace writing to match source
+                now = time.perf_counter()
+                if now < next_write_ts:
+                    time.sleep(max(0.0, next_write_ts - now))
+                writer.write(vis_bgr)
+                next_write_ts += frame_interval
+
+                frames_done += 1
+
+                # UI updates (throttled)
+                now = time.perf_counter()
+                if (now - last_preview_ts) >= min_preview_interval:
+                    frame_ph.image(
+                        cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB),
+                        use_container_width=True,
+                        output_format="JPEG",
+                        channels="RGB",
+                    )
+                    elapsed = now - t0
+                    fps_est = frames_done / max(elapsed, 1e-6)
+                    info_ph.info(
+                        f"Frames: {frames_done}/{total_frames or '?'}  •  "
+                        f"Throughput: {fps_est:.1f} FPS  •  Source FPS: {src_fps:.1f}  •  "
+                        f"Mode: Passthrough"
+                    )
+                    last_preview_ts = now
+
+                # Progress
+                progress = ((idx + 1) / total_frames) if total_frames > 0 else min(frames_done / (frames_done + 30), 0.99)
+                prog.progress(progress, text=f"Playing frame {idx + 1}{'/' + str(total_frames) if total_frames>0 else ''}…")
+
+    except Exception as exc:
+        st.error(f"Video playback failed: {exc}")
+        return
+    finally:
+        try:
+            cap.release()
+            if writer is not None:
+                writer.release()
+        except Exception:
+            pass
+
+    # Reset stop flag after finishing
+    st.session_state["stop_video"] = False
+
+    st.success("Done!")
+    if tmp_out.exists():
+        st.video(str(tmp_out))
+        with open(tmp_out, "rb") as f:
+            st.download_button(
+                "Download video",
+                data=f.read(),
+                file_name=tmp_out.name,
+                mime="video/mp4",
+            )
+    else:
+        st.error("Playback completed but output file was not created.")
+
+
+# ================== Detection routines ==================
+def run_image_detection(uploaded_file, conf_thr: float = 0.5, model_key: str = "deim"):
     try:
         data = uploaded_file.getvalue()
         img = Image.open(io.BytesIO(data)).convert("RGB")
@@ -88,95 +345,225 @@ def run_image_detection(uploaded_file, conf_thr: float = 0.5):
 
     try:
         model = load_model(model_key)
-        with st.spinner("Running detection..."):
-            annotated = model.predict_image(img, min_confidence=conf_thr)
+        device = _choose_device(model_key)
+        if torch is not None:
+            try:
+                model.to(device)
+            except Exception:
+                pass
+
+        _warmup_model(model, model_key=model_key, shape=(img.height, img.width, 3), conf=conf_thr)
+        use_amp = (device == "cuda") and not _should_force_cpu_for_model(model_key)
+
+        with st.spinner(f"Running detection on {device.upper()}…"):
+            with maybe_autocast(use_amp):
+                if (model_key or "").lower() == "deim":
+                    annotated = model.predict_image(img, min_confidence=conf_thr)
+                else:
+                    try:
+                        annotated = model.predict_image(img, min_confidence=conf_thr)
+                    except Exception:
+                        np_bgr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+                        _, vis = model.predict_and_visualize(np_bgr, min_confidence=conf_thr, show_score=True)
+                        annotated = Image.fromarray(cv2.cvtColor(vis, cv2.COLOR_BGR2RGB))
 
         st.subheader("🎯 Detection Results")
-        st.image(annotated, caption="Detections", width="stretch")
+        st.image(annotated, caption="Detections", use_container_width=True)
+
+        if _should_force_cpu_for_model(model_key):
+            st.info("DEIM runs on CPU to avoid TorchScript device mismatch.")
+
     except Exception as e:
         st.error(f"Error during detection: {e}")
 
 
-def run_video_detection(vid_bytes, conf_thr: float = 0.5, model_key: str = "deim"):
-    tmp_in = Path(tempfile.gettempdir()) / f"in_{int(time.time())}.mp4"
+def run_video_detection(
+    vid_bytes: bytes,
+    conf_thr: float = 0.5,
+    model_key: str = "deim",
+    target_short_side: int = DEFAULT_TARGET_SHORT_SIDE,
+    max_preview_fps: int = DEFAULT_MAX_PREVIEW_FPS,
+    drop_if_behind: bool = DEFAULT_DROP_IF_BEHIND,
+    process_stride: int = DEFAULT_PROCESS_STRIDE,
+):
+    # Save upload to a temp file
+    ts = int(time.time() * 1000)
+    tmp_in = Path(tempfile.gettempdir()) / f"in_{ts}{DEFAULT_TMP_EXT}"
     with open(tmp_in, "wb") as f:
         f.write(vid_bytes)
 
+    # Load model & choose device
     model = load_model(model_key)
-
-    # Set up video capture for preview
-    cap = cv2.VideoCapture(str(tmp_in))
+    device = _choose_device(model_key)
+    if torch is not None:
+        try:
+            model.to(device)
+        except Exception:
+            pass
+
+    # Capture
+    cap = cv2.VideoCapture(str(tmp_in), cv2.CAP_FFMPEG)
     if not cap.isOpened():
         st.error("Failed to open the uploaded video.")
         return
 
-    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    try:
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 2)
+    except Exception:
+        pass
+
+    src_fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+    src_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    src_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-    # Set up preview and progress
     frame_ph = st.empty()
-    prog = st.progress(0.0, text="Processing…")
-
-    # Set up video writer for output
-    W = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    H = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    tmp_out = Path(tempfile.gettempdir()) / f"out_{int(time.time())}.mp4"
-    writer = cv2.VideoWriter(str(tmp_out), cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H))
-
-    frame_count = 0
-    last_preview_update = 0
-    preview_update_interval = 5  # Update preview every 5 frames
+    info_ph = st.empty()
+    prog = st.progress(0.0, text="Preparing…")
+
+    _warmup_model(model, model_key=model_key, shape=(min(src_h, src_w), max(src_h, src_w), 3), conf=conf_thr)
+
+    # Reader thread -> bounded queue
+    q: "queue.Queue[tuple[int, np.ndarray] | None]" = queue.Queue(maxsize=DEFAULT_QUEUE_SIZE)
+
+    def reader():
+        idx = 0
+        while True:
+            if st.session_state.get("stop_video", False):
+                break
+            ok, frm = cap.read()
+            if not ok:
+                break
+            if drop_if_behind and q.full():
+                # drop the oldest frame to keep things moving
+                try:
+                    q.get_nowait()
+                except queue.Empty:
+                    pass
+            try:
+                q.put((idx, frm), timeout=0.05)
+            except queue.Full:
+                pass
+            idx += 1
+        q.put(None)
+
+    reader_th = threading.Thread(target=reader, daemon=True)
+    reader_th.start()
+
+    tmp_out = Path(tempfile.gettempdir()) / f"out_{ts}{DEFAULT_TMP_EXT}"
+    writer = None
+
+    # Preview throttle
+    min_preview_interval = 1.0 / float(max_preview_fps)
+    last_preview_ts = 0.0
+
+    # Source pacing
+    frame_interval = 1.0 / float(src_fps if src_fps > 0 else 25.0)
+    next_write_ts = time.perf_counter() + frame_interval
+
+    frames_done = 0
+    t0 = time.perf_counter()
+    use_amp = (device == "cuda") and not _should_force_cpu_for_model(model_key)
+
+    last_vis_bgr = None  # for stride reuse
 
     try:
-        with st.spinner("Processing video with live preview…"):
+        with st.spinner(f"Processing video on {device.upper()} with live preview…"):
             while True:
-                ok, frame = cap.read()
-                if not ok:
+                if st.session_state.get("stop_video", False):
                     break
 
-                # Process frame with model
-                if model_key == "deim":
-                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    annotated_pil = model.predict_image(
-                        Image.fromarray(frame_rgb), min_confidence=conf_thr
-                    )
-                    vis = cv2.cvtColor(np.array(annotated_pil), cv2.COLOR_RGB2BGR)
+                item = q.get()
+                if item is None:
+                    break
+                idx, frame_bgr = item
+
+                # Downscale for speed
+                proc_bgr = _resize_keep_aspect(frame_bgr, short_side=target_short_side)
+
+                run_infer = (process_stride <= 1) or ((idx % process_stride) == 0)
+
+                if run_infer:
+                    # Run model
+                    if (model_key or "").lower() == "deim":
+                        img_rgb = cv2.cvtColor(proc_bgr, cv2.COLOR_BGR2RGB)
+                        pil_img = Image.fromarray(img_rgb)
+                        annotated_pil = model.predict_image(pil_img, min_confidence=conf_thr)
+                        vis_bgr = cv2.cvtColor(np.array(annotated_pil), cv2.COLOR_RGB2BGR)
+                    else:
+                        with maybe_autocast(use_amp):
+                            try:
+                                _, vis_bgr = model.predict_and_visualize(
+                                    proc_bgr, min_confidence=conf_thr, show_score=True
+                                )
+                            except Exception:
+                                pil = Image.fromarray(cv2.cvtColor(proc_bgr, cv2.COLOR_BGR2RGB))
+                                annotated = model.predict_image(pil, min_confidence=conf_thr)
+                                vis_bgr = cv2.cvtColor(np.array(annotated), cv2.COLOR_RGB2BGR)
+                    last_vis_bgr = vis_bgr
                 else:
-                    _, vis = model.predict_and_visualize(
-                        frame, min_confidence=conf_thr, show_score=True
-                    )
-
-                # Update progress
-                progress = frame_count / total_frames if total_frames > 0 else 0
-                prog.progress(
-                    progress,
-                    text=f"Processing frame {frame_count + 1}/{total_frames}...",
-                )
-
-                # Update preview (throttled to prevent freezing)
-                if (frame_count - last_preview_update) >= preview_update_interval:
+                    # Reuse last visualised frame to avoid visible “skips”
+                    vis_bgr = last_vis_bgr if last_vis_bgr is not None else proc_bgr
+
+                # Init writer when first output frame is ready
+                if writer is None:
+                    H, W = vis_bgr.shape[:2]
+                    fourcc = cv2.VideoWriter_fourcc(*DEFAULT_WRITER_CODEC)  # avoids OpenH264 issues
+                    out_fps = src_fps  # preserve source FPS in output
+                    writer = cv2.VideoWriter(str(tmp_out), fourcc, out_fps, (W, H))
+
+                # Pace writing to match the source timeline
+                now = time.perf_counter()
+                if now < next_write_ts:
+                    time.sleep(max(0.0, next_write_ts - now))
+                writer.write(vis_bgr)
+                next_write_ts += frame_interval
+
+                frames_done += 1
+
+                # UI updates (throttled)
+                now = time.perf_counter()
+                if (now - last_preview_ts) >= min_preview_interval:
                     frame_ph.image(
-                        cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                        cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB),
                         use_container_width=True,
                         output_format="JPEG",
                         channels="RGB",
                     )
-                    last_preview_update = frame_count
+                    elapsed = now - t0
+                    fps_est = frames_done / max(elapsed, 1e-6)
+                    device_msg = f"{device.upper()}" if device != "cuda" else f"{device.upper()} ({_device_hint().upper()})"
+                    info_text = (
+                        f"Processed: {frames_done} / {total_frames if total_frames>0 else '?'}  •  "
+                        f"Throughput: {fps_est:.1f} FPS  •  "
+                        f"Source FPS: {src_fps:.1f}  •  Device: {device_msg}  •  "
+                        f"Stride: {process_stride}x"
+                    )
+                    if _should_force_cpu_for_model(model_key):
+                        info_text += "  •  Note: DEIM forced to CPU."
+                    info_ph.info(info_text)
+                    last_preview_ts = now
 
-                # Write frame to output video
-                writer.write(vis)
-                frame_count += 1
+                # Progress bar
+                progress = ((idx + 1) / total_frames) if total_frames > 0 else min(frames_done / (frames_done + 30), 0.99)
+                prog.progress(progress, text=f"Processing frame {idx + 1}{'/' + str(total_frames) if total_frames>0 else ''}…")
 
     except Exception as exc:
         st.error(f"Video detection failed: {exc}")
         return
     finally:
-        cap.release()
-        writer.release()
+        try:
+            cap.release()
+            if writer is not None:
+                writer.release()
+        except Exception:
+            pass
+
+    # Reset stop flag after finishing
+    st.session_state["stop_video"] = False
 
     st.success("Done!")
 
-    # Check if output file exists before trying to display it
     if tmp_out.exists():
         st.video(str(tmp_out))
         with open(tmp_out, "rb") as f:
@@ -190,17 +577,38 @@ def run_video_detection(vid_bytes, conf_thr: float = 0.5, model_key: str = "deim
         st.error("Video processing completed but output file was not created.")
 
 
-# =============== Main: hook up actions ===============
+# ================== Main Actions ==================
 if run_img:
     if img_file is None:
         st.warning("Please upload an image first.")
     else:
-        run_image_detection(img_file, conf_thr=conf_thr)
+        run_image_detection(img_file, conf_thr=conf_thr, model_key=model_key)
+
+# New: Passthrough mode
+if run_vid_plain:
+    if vid_file is None:
+        st.warning("Please upload a video first.")
+    else:
+        st.session_state["stop_video"] = False
+        run_video_passthrough(
+            vid_bytes=vid_file.read(),
+            target_short_side=target_short_side,
+            max_preview_fps=max_preview_fps,
+            drop_if_behind=drop_if_behind,
+        )
 
+# Original: Detection mode
 if run_vid:
     if vid_file is None:
         st.warning("Please upload a video first.")
     else:
+        st.session_state["stop_video"] = False
         run_video_detection(
-            vid_bytes=vid_file.read(), conf_thr=conf_thr, model_key=model_key
+            vid_bytes=vid_file.read(),
+            conf_thr=conf_thr,
+            model_key=model_key,
+            target_short_side=target_short_side,
+            max_preview_fps=max_preview_fps,
+            drop_if_behind=drop_if_behind,
+            process_stride=process_stride,
         )

services/app_service/pages/lost_at_sea_KY.py

@@ -0,0 +1,206 @@
+# pages/lost_at_sea.py
+import io
+import tempfile
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+import streamlit as st
+from PIL import Image
+from utils.model_manager import get_model_manager, load_model
+
+# =============== Page setup ===============
+st.set_page_config(
+    page_title="Lost at Sea", layout="wide", initial_sidebar_state="expanded"
+)
+
+st.markdown(
+    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</h2>"
+    "<h2 style='text-align:center;margin-top:0'>Lost at Sea 🌊</h2>",
+    unsafe_allow_html=True,
+)
+
+# =============== Sidebar: custom menu + cards ===============
+with st.sidebar:
+    st.page_link("app.py", label="Home")
+    st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
+    st.page_link("pages/lost_at_sea.py", label="Lost at Sea")
+    st.page_link("pages/signal_watch.py", label="Signal Watch")
+    st.markdown("---")
+    st.page_link("pages/task_satellite.py", label="Task Satellite")
+    st.page_link("pages/task_drone.py", label="Task Drone")
+
+    # Simple "card" styling in the sidebar
+    st.markdown(
+        """
+    <style>
+    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
+    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
+    </style>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Image Detection card
+    st.sidebar.header("Image Detection")
+    img_file = st.file_uploader(
+        "Upload an image", type=["jpg", "jpeg", "png"], key="img_up"
+    )
+    run_img = st.button("🔍 Run Image Detection", use_container_width=True)
+
+    # Video Detection card
+    st.sidebar.header("Video Detection")
+    vid_file = st.file_uploader(
+        "Upload a video", type=["mp4", "mov", "avi", "mkv"], key="vid_up"
+    )
+    run_vid = st.button("🎥 Run Video Detection", use_container_width=True)
+
+    st.sidebar.markdown("---")
+    # Parameters card (shared)
+    st.sidebar.header("Parameters")
+    conf_thr = st.slider("Minimum confidence threshold", 0.05, 0.95, 0.50, 0.01)
+
+    st.sidebar.markdown("---")
+
+    # Get model manager instance
+    model_manager = get_model_manager()
+
+    # Render model selection UI
+    model_label, model_key = model_manager.render_model_selection(
+        key_prefix="lost_at_sea"
+    )
+    st.sidebar.markdown("---")
+
+    # Render device information
+    model_manager.render_device_info()
+
+
+# =============== Detection helpers ===============
+def run_image_detection(uploaded_file, conf_thr: float = 0.5):
+    try:
+        data = uploaded_file.getvalue()
+        img = Image.open(io.BytesIO(data)).convert("RGB")
+        st.image(img, caption="Uploaded Image", use_container_width=True)
+    except Exception as e:
+        st.error(f"Error loading image: {e}")
+        return
+
+    try:
+        model = load_model(model_key)
+        with st.spinner("Running detection..."):
+            annotated = model.predict_image(img, min_confidence=conf_thr)
+
+        st.subheader("🎯 Detection Results")
+        st.image(annotated, caption="Detections", width="stretch")
+    except Exception as e:
+        st.error(f"Error during detection: {e}")
+
+
+def run_video_detection(vid_bytes, conf_thr: float = 0.5, model_key: str = "deim"):
+    tmp_in = Path(tempfile.gettempdir()) / f"in_{int(time.time())}.mp4"
+    with open(tmp_in, "wb") as f:
+        f.write(vid_bytes)
+
+    model = load_model(model_key)
+
+    # Set up video capture for preview
+    cap = cv2.VideoCapture(str(tmp_in))
+    if not cap.isOpened():
+        st.error("Failed to open the uploaded video.")
+        return
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+
+    # Set up preview and progress
+    frame_ph = st.empty()
+    prog = st.progress(0.0, text="Processing…")
+
+    # Set up video writer for output
+    W = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    H = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    tmp_out = Path(tempfile.gettempdir()) / f"out_{int(time.time())}.mp4"
+    writer = cv2.VideoWriter(str(tmp_out), cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H))
+
+    frame_count = 0
+    last_preview_update = 0
+    preview_update_interval = 5  # Update preview every 5 frames
+
+    try:
+        with st.spinner("Processing video with live preview…"):
+            while True:
+                ok, frame = cap.read()
+                if not ok:
+                    break
+
+                # Process frame with model
+                if model_key == "deim":
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    annotated_pil = model.predict_image(
+                        Image.fromarray(frame_rgb), min_confidence=conf_thr
+                    )
+                    vis = cv2.cvtColor(np.array(annotated_pil), cv2.COLOR_RGB2BGR)
+                else:
+                    _, vis = model.predict_and_visualize(
+                        frame, min_confidence=conf_thr, show_score=True
+                    )
+
+                # Update progress
+                progress = frame_count / total_frames if total_frames > 0 else 0
+                prog.progress(
+                    progress,
+                    text=f"Processing frame {frame_count + 1}/{total_frames}...",
+                )
+
+                # Update preview (throttled to prevent freezing)
+                if (frame_count - last_preview_update) >= preview_update_interval:
+                    frame_ph.image(
+                        cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                        use_container_width=True,
+                        output_format="JPEG",
+                        channels="RGB",
+                    )
+                    last_preview_update = frame_count
+
+                # Write frame to output video
+                writer.write(vis)
+                frame_count += 1
+
+    except Exception as exc:
+        st.error(f"Video detection failed: {exc}")
+        return
+    finally:
+        cap.release()
+        writer.release()
+
+    st.success("Done!")
+
+    # Check if output file exists before trying to display it
+    if tmp_out.exists():
+        st.video(str(tmp_out))
+        with open(tmp_out, "rb") as f:
+            st.download_button(
+                "Download processed video",
+                data=f.read(),
+                file_name=tmp_out.name,
+                mime="video/mp4",
+            )
+    else:
+        st.error("Video processing completed but output file was not created.")
+
+
+# =============== Main: hook up actions ===============
+if run_img:
+    if img_file is None:
+        st.warning("Please upload an image first.")
+    else:
+        run_image_detection(img_file, conf_thr=conf_thr)
+
+if run_vid:
+    if vid_file is None:
+        st.warning("Please upload a video first.")
+    else:
+        run_video_detection(
+            vid_bytes=vid_file.read(), conf_thr=conf_thr, model_key=model_key
+        )

services/app_service/pages/signal_watch.py

@@ -91,7 +91,7 @@ with st.sidebar:
 
     col1, col2 = st.columns(2)
     with col1:
-        run_detection = st.button("🎥 Run Detection", use_container_width=True)
+        run_detection = st.button("🎥 Run", use_container_width=True)
     with col2:
         stop_detection = st.button(
             "⏹️ Stop", use_container_width=True, help="Stop current detection"

services/app_service/pages/task_drone DD.py

@@ -0,0 +1,53 @@
+# pages/lost_at_sea.py
+import io
+import tempfile
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+import streamlit as st
+from PIL import Image
+from utils.model_manager import get_model_manager, load_model
+from urllib.parse import quote_plus
+
+# =============== Page setup ===============
+st.set_page_config(
+    page_title="Lost at Sea", layout="wide", initial_sidebar_state="expanded"
+)
+
+st.markdown(
+    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</h2>"
+    "<h2 style='text-align:center;margin-top:0'>Task Drone(s) 🛸</h2>",
+    unsafe_allow_html=True,
+)
+
+# =============== Sidebar: custom menu + cards ===============
+with st.sidebar:
+    st.page_link("app.py", label="Home")
+    st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
+    st.page_link("pages/lost_at_sea.py", label="Lost at Sea")
+    st.page_link("pages/signal_watch.py", label="Signal Watch")
+    st.markdown("---")
+    st.page_link("pages/task_satellite.py", label="Task Satellite")
+    st.page_link("pages/task_drone.py", label="Task Drone")
+
+    st.markdown("---")
+
+    # Simple "card" styling in the sidebar
+    st.markdown(
+        """
+    <style>
+    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
+    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
+    </style>
+    """,
+        unsafe_allow_html=True,
+    )
+
+st.set_page_config(page_title="Map demo", layout="wide")
+
+place = "Adelaide, South Australia"
+embed_url = f"https://www.google.com/maps?q={quote_plus(place)}&output=embed"
+
+st.components.v1.iframe(embed_url, height=500)

services/app_service/pages/task_drone.py

@@ -1,28 +1,17 @@
-# pages/lost_at_sea.py
-import io
-import tempfile
-import time
-from pathlib import Path
-
-import cv2
-import numpy as np
+# pages/task_drone.py
 import streamlit as st
-from PIL import Image
-from utils.model_manager import get_model_manager, load_model
 from urllib.parse import quote_plus
 
 # =============== Page setup ===============
-st.set_page_config(
-    page_title="Lost at Sea", layout="wide", initial_sidebar_state="expanded"
-)
+st.set_page_config(page_title="Task Drone – Map", layout="wide", initial_sidebar_state="expanded")
 
 st.markdown(
-    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</h2>"
+    "<h2 style='text-align:center;margin-top:0'>SAR-X<sup>ai</sup></h2>"
     "<h2 style='text-align:center;margin-top:0'>Task Drone(s) 🛸</h2>",
     unsafe_allow_html=True,
 )
 
-# =============== Sidebar: custom menu + cards ===============
+# =============== Sidebar navigation ===============
 with st.sidebar:
     st.page_link("app.py", label="Home")
     st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
@@ -31,23 +20,119 @@ with st.sidebar:
     st.markdown("---")
     st.page_link("pages/task_satellite.py", label="Task Satellite")
     st.page_link("pages/task_drone.py", label="Task Drone")
-
     st.markdown("---")
 
-    # Simple "card" styling in the sidebar
-    st.markdown(
-        """
+# =============== Helpers & state ===============
+DEFAULT_PLACE = "Adelaide, South Australia"
+
+def make_embed_url(address: str | None, lat: float | None, lon: float | None) -> str:
+    """Build a Google Maps embed URL using either an address or lat/lon."""
+    if address and address.strip():
+        q = quote_plus(address.strip())
+    elif lat is not None and lon is not None:
+        q = quote_plus(f"{lat},{lon}")
+    else:
+        q = quote_plus(DEFAULT_PLACE)
+    return f"https://www.google.com/maps?q={q}&output=embed"
+
+# --- State management ---
+if "address" not in st.session_state:
+    st.session_state.address = ""
+if "lat" not in st.session_state:
+    st.session_state.lat = None
+if "lon" not in st.session_state:
+    st.session_state.lon = None
+if "embed_url" not in st.session_state:
+    st.session_state.embed_url = make_embed_url(None, None, None)
+
+# =============== Input row with aligned bottom buttons ===============
+# Add spacing instead of header
+st.markdown("<br><br>", unsafe_allow_html=True)
+
+# Columns: Address | Lat | Lon | Update | Task Drone
+c1, c2, c3, c4, c5 = st.columns([3, 1.2, 1.2, 1.1, 1.1])
+
+with c1:
+    st.session_state.address = st.text_input(
+        "Address (optional)",
+        value=st.session_state.address,
+        placeholder="e.g., 25 Grenfell St, Adelaide SA",
+        help="Enter a full street address, suburb, or landmark."
+    )
+
+with c2:
+    st.session_state.lat = st.number_input(
+        "Latitude (optional)",
+        value=st.session_state.lat if st.session_state.lat is not None else -34.9285,
+        format="%.8f"
+    )
+
+with c3:
+    st.session_state.lon = st.number_input(
+        "Longitude (optional)",
+        value=st.session_state.lon if st.session_state.lon is not None else 138.6007,
+        format="%.8f"
+    )
+
+# --- Custom button styles ---
+st.markdown(
+    """
     <style>
-    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
-    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
+    div.stButton > button {
+        height: 2.8em;
+        border-radius: 6px;
+        font-weight: 600;
+    }
+    div.stButton > button.task-drone-btn {
+        background-color: #A7C7E7 !important;  /* Pastel Blue */
+        color: black !important;
+        font-weight: 700 !important;
+        border: 1px solid rgba(0,0,0,0.15);
+    }
     </style>
     """,
+    unsafe_allow_html=True,
+)
+
+# --- Bottom-aligned buttons ---
+with c4:
+    st.markdown("<div style='height:1.8em'></div>", unsafe_allow_html=True)
+    if st.button("Update Map", use_container_width=True):
+        addr = st.session_state.address.strip() if st.session_state.address else ""
+        lat = st.session_state.lat
+        lon = st.session_state.lon
+        addr = addr if addr else None
+        if (lat is None) or (lon is None):
+            lat, lon = None, None
+        st.session_state.embed_url = make_embed_url(addr, lat, lon)
+
+with c5:
+    st.markdown("<div style='height:1.8em'></div>", unsafe_allow_html=True)
+    st.button("Task Drone", key="task_drone", use_container_width=True, type="secondary")
+
+    # Apply pastel blue style dynamically
+    st.markdown(
+        """
+        <script>
+        const interval = setInterval(() => {
+            const btns = window.parent.document.querySelectorAll('button[kind="secondary"]');
+            btns.forEach(b => {
+                if (b.innerText.includes('Task Drone')) {
+                    b.classList.add('task-drone-btn');
+                    clearInterval(interval);
+                }
+            });
+        }, 100);
+        </script>
+        """,
         unsafe_allow_html=True,
     )
 
-st.set_page_config(page_title="Map demo", layout="wide")
+# =============== Map embed ===============
+st.components.v1.iframe(st.session_state.embed_url, height=520)
 
-place = "Adelaide, South Australia"
-embed_url = f"https://www.google.com/maps?q={quote_plus(place)}&output=embed"
-
-st.components.v1.iframe(embed_url, height=500)
+# Optional: link to open directly in Google Maps
+st.markdown(
+    f"[Open in Google Maps]({st.session_state.embed_url.replace('output=embed', '')})",
+    help="Opens the current view in a new browser tab."
+)

services/app_service/pages/task_satellite copy.py

@@ -0,0 +1,55 @@
+# pages/lost_at_sea.py
+import io
+import tempfile
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+import streamlit as st
+from PIL import Image
+from utils.model_manager import get_model_manager, load_model
+from urllib.parse import quote_plus
+
+# =============== Page setup ===============
+st.set_page_config(
+    page_title="Task Satellite", layout="wide", initial_sidebar_state="expanded"
+)
+
+st.markdown(
+    "<h2 style='text-align:center;margin-top:0'>S A R - X ai\u200b</h2>"
+    "<h2 style='text-align:center;margin-top:0'>Task Satellite 🛰️</h2>",
+    unsafe_allow_html=True,
+)
+
+# =============== Sidebar: custom menu + cards ===============
+with st.sidebar:
+    st.page_link("app.py", label="Home")
+    st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
+    st.page_link("pages/lost_at_sea.py", label="Lost at Sea")
+    st.page_link("pages/signal_watch.py", label="Signal Watch")
+    st.markdown("---")
+    st.page_link("pages/task_satellite.py", label="Task Satellite")
+    st.page_link("pages/task_drone.py", label="Task Drone")
+
+    st.markdown("---")
+
+    # Simple "card" styling in the sidebar
+    st.markdown(
+        """
+    <style>
+    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
+    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
+    </style>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+st.set_page_config(page_title="Map demo", layout="wide")
+
+place = "Yunta, South Australia"
+embed_url = f"https://www.google.com/maps?q={quote_plus(place)}&output=embed"
+
+st.components.v1.iframe(embed_url, height=500)
+

services/app_service/pages/task_satellite.py

@@ -1,28 +1,29 @@
-# pages/lost_at_sea.py
-import io
-import tempfile
-import time
-from pathlib import Path
-
-import cv2
-import numpy as np
 import streamlit as st
-from PIL import Image
-from utils.model_manager import get_model_manager, load_model
-from urllib.parse import quote_plus
+from datetime import datetime, timedelta
+import time
+import random
 
 # =============== Page setup ===============
 st.set_page_config(
-    page_title="Task Satellite", layout="wide", initial_sidebar_state="expanded"
+    page_title="Task Satellite",
+    layout="wide",
+    initial_sidebar_state="expanded",  # keep sidebar open
 )
 
-st.markdown(
-    "<h2 style='text-align:center;margin-top:0'>S A R - X ai\u200b</h2>"
-    "<h2 style='text-align:center;margin-top:0'>Task Satellite 🛰️</h2>",
-    unsafe_allow_html=True,
-)
+# =============== Compact styling & header spacing (avoid cropping) ===============
+st.markdown("""
+<style>
+.block-container { padding-top: 1.2rem; padding-bottom: 0.6rem; max-width: 1400px; }
+h2, h3, h4 { margin: 0.4rem 0; }
+textarea { min-height: 70px !important; }
+/* Light outline on inputs */
+.stSelectbox > div, .stTextInput > div, .stNumberInput > div, .stDateInput > div, .stTextArea > div {
+  border: 1px solid #D0D0D0; border-radius: 6px;
+}
+</style>
+""", unsafe_allow_html=True)
 
-# =============== Sidebar: custom menu + cards ===============
+# =============== Sidebar navigation ===============
 with st.sidebar:
     st.page_link("app.py", label="Home")
     st.page_link("pages/bushland_beacon.py", label="Bushland Beacon")
@@ -31,25 +32,190 @@ with st.sidebar:
     st.markdown("---")
     st.page_link("pages/task_satellite.py", label="Task Satellite")
     st.page_link("pages/task_drone.py", label="Task Drone")
-
     st.markdown("---")
+    st.caption("SAR-X AI • Satellite Tasking Module")
+
+# =============== Header ===============
+st.markdown(
+    "<h2 style='text-align:center;'>SAR-X<sup>ai</sup></h2>"
+    "<h2 style='text-align:center;margin-top:0.2rem;'>Task Satellite 🛰️</h2>",
+    unsafe_allow_html=True,
+)
+
+# =============== Top Row: Provider & Notes (single row) ===============
+satellite_providers = [
+    "Auto Select Lowest Cost",
+    "Auto Select Fastest Turnaround",
+    "BlackSky",
+    "Planet Labs",
+    "Maxar Technologies",
+    "Airbus Defence and Space",
+    "ICEYE",
+    "Capella Space",
+    "Satellogic",
+    "Earth-i",
+    "Umbra Space",
+    "Spire Global"
+]
+
+# Metadata for cost/turnaround heuristics
+provider_cost_multiplier = {
+    "BlackSky": 1.00, "Planet Labs": 0.85, "Maxar Technologies": 1.40,
+    "Airbus Defence and Space": 1.25, "ICEYE": 1.10, "Capella Space": 1.15,
+    "Satellogic": 0.80, "Earth-i": 0.95, "Umbra Space": 1.05, "Spire Global": 0.90
+}
+provider_turnaround_hours = {
+    "BlackSky": 6, "Planet Labs": 8, "Maxar Technologies": 6,
+    "Airbus Defence and Space": 7, "ICEYE": 5, "Capella Space": 5,
+    "Satellogic": 7, "Earth-i": 8, "Umbra Space": 6, "Spire Global": 8
+}
+
+# ===== Utility Functions =====
+def resolve_provider(choice: str) -> str:
+    if choice == "Auto Select Lowest Cost":
+        return min(provider_cost_multiplier, key=provider_cost_multiplier.get)
+    if choice == "Auto Select Fastest Turnaround":
+        return min(provider_turnaround_hours, key=provider_turnaround_hours.get)
+    return choice
+
+def estimate_cost(resolution: str, capture_type: str, priority: str, provider_choice: str) -> float:
+    base_by_res = {"0.3 m": 3500, "0.5 m": 2500, "1 m": 1500, "3 m": 800, "10 m": 300}
+    type_add = {"Optical": 0, "SAR (Radar)": 600, "Multispectral": 400, "Infrared": 500}
+    priority_mult = {"Low": 1.00, "Medium": 1.10, "High": 1.25}
+    prov = resolve_provider(provider_choice)
+    prov_mult = provider_cost_multiplier.get(prov, 1.0)
+    cost = (base_by_res[resolution] + type_add[capture_type]) * priority_mult[priority] * prov_mult
+    return round(cost, 2)
+
+# ACST utilities
+def now_acst() -> datetime:
+    return datetime.utcnow() + timedelta(hours=9, minutes=30)
+
+def eta_time_acst(hours_from_now: int) -> datetime:
+    return now_acst() + timedelta(hours=hours_from_now)
 
-    # Simple "card" styling in the sidebar
-    st.markdown(
-        """
-    <style>
-    .sb-card {border:1px solid rgba(255,255,255,0.15); padding:14px; border-radius:8px; margin-bottom:16px;}
-    .sb-card h4 {margin:0 0 10px 0; font-weight:700;}
-    </style>
-    """,
-        unsafe_allow_html=True,
+# =============== Provider & Notes Row ===============
+top_left, top_right = st.columns([0.32, 0.68])
+with top_left:
+    selected_provider = st.selectbox("Satellite Provider", satellite_providers, index=0)
+with top_right:
+    additional_notes = st.text_area(
+        "Provider Notes / Special Instructions",
+        placeholder="Any special imaging parameters or constraints…"
     )
 
+st.markdown("---")
+
+# =============== Bottom: Left (Form) / Right (Response) ===============
+left_col, right_col = st.columns(2)
+
+with left_col:
+    st.subheader("Tasking Parameters", divider=False)
+
+    # ---- FORM with specific row layout order ----
+    with st.form("task_satellite_form", clear_on_submit=False):
+        # Row 1: Target area name
+        target_name = st.text_input("Target Area Name", placeholder="e.g., Yunta, South Australia")
+
+        # Row 2: Latitude & Longitude
+        r2c1, r2c2 = st.columns(2)
+        with r2c1:
+            latitude = st.number_input("Latitude", format="%.6f", value=0.0)
+        with r2c2:
+            longitude = st.number_input("Longitude", format="%.6f", value=0.0)
+
+        # Row 3: Capture Type & Resolution
+        r3c1, r3c2 = st.columns(2)
+        with r3c1:
+            capture_type = st.selectbox("Capture Type", ["Optical", "SAR (Radar)", "Multispectral", "Infrared"])
+        with r3c2:
+            resolution = st.selectbox("Desired Resolution", ["0.3 m", "0.5 m", "1 m", "3 m", "10 m"], index=1)
+
+        # Row 4: Capture Date & Priority Level
+        r4c1, r4c2 = st.columns(2)
+        with r4c1:
+            request_date = st.date_input("Preferred Capture Date", datetime.now().date())
+        with r4c2:
+            priority = st.select_slider("Priority Level", ["Low", "Medium", "High"], value="Medium")
+
+        # Row 5: Buttons
+        b_l, b_r = st.columns([0.5, 0.5])
+        with b_l:
+            estimate_clicked = st.form_submit_button("Estimate Cost", use_container_width=True)
+        with b_r:
+            submitted = st.form_submit_button("Submit Satellite Task", use_container_width=True)
+
+# =============== Right Side: Response Section ===============
+with right_col:
+    st.subheader("Tasking Information Response", divider=False)
+
+    # --- Estimate Cost ---
+    if 'estimate_clicked' in locals() and estimate_clicked and not submitted:
+        resolved = resolve_provider(selected_provider)
+        est = estimate_cost(resolution, capture_type, priority, selected_provider)
+        indicative_hours = provider_turnaround_hours.get(resolved, 6)
+        indicative_eta = eta_time_acst(indicative_hours).strftime("%Y-%m-%d %H:%M")
+
+        st.info(
+            f"💰 Estimated cost with **{resolved}**: **${est:,.2f}**  \n"
+            f"⏱️ Indicative delivery by **{indicative_eta} ACST (UTC+9:30)** "
+            f"(**+{indicative_hours} hours**)."
+        )
+
+        a, b = st.columns(2)
+        with a:
+            st.markdown(f"**Target:** {target_name or '—'}")
+            st.markdown(f"**Resolution:** {resolution}")
+            st.markdown(f"**Type:** {capture_type}")
+        with b:
+            st.markdown(f"**Priority:** {priority}")
+            st.markdown(f"**Provider Choice:** {selected_provider} → **{resolved}**")
+        if additional_notes.strip():
+            st.markdown("**Notes:**")
+            st.caption(additional_notes)
+
+    # --- Submit Task ---
+    if 'submitted' in locals() and submitted:
+        resolved = resolve_provider(selected_provider)
+        st.success(f"✅ Task submitted to **{resolved}**")
+
+        a, b = st.columns(2)
+        with a:
+            st.markdown(f"**Target:** {target_name or '—'}")
+            st.markdown(f"**Date:** {request_date.strftime('%Y-%m-%d')}")
+            st.markdown(f"**Coordinates:** ({latitude:.6f}, {longitude:.6f})")
+        with b:
+            st.markdown(f"**Resolution:** {resolution}")
+            st.markdown(f"**Type:** {capture_type}")
+            st.markdown(f"**Priority:** {priority}")
+
+        if additional_notes.strip():
+            st.markdown("**Notes:**")
+            st.caption(additional_notes)
+
+        est = estimate_cost(resolution, capture_type, priority, selected_provider)
+        st.markdown(f"**Estimated Cost:** ${est:,.2f}")
+
+        with st.spinner("Contacting satellite provider…"):
+            time.sleep(3)
 
-st.set_page_config(page_title="Map demo", layout="wide")
+        # Calculate ETA hours and timestamp
+        if selected_provider == "Auto Select Fastest Turnaround":
+            eta_hours = provider_turnaround_hours.get(resolved, 4)
+        else:
+            eta_hours = random.randint(4, 8)
 
-place = "Yunta, South Australia"
-embed_url = f"https://www.google.com/maps?q={quote_plus(place)}&output=embed"
+        eta_local = eta_time_acst(eta_hours).strftime("%Y-%m-%d %H:%M")
 
-st.components.v1.iframe(embed_url, height=500)
+        st.info(
+            f"📩 {resolved} advises an ETA on image delivery **within {eta_hours} hours** — "
+            f"approximately **{eta_local} ACST (UTC+9:30)** "
+            f"(**+{eta_hours} hours**).  \n"
+            f"🕒 Current time (ACST): **{now_acst().strftime('%Y-%m-%d %H:%M')}**."
+        )
+    elif not ('estimate_clicked' in locals() and estimate_clicked):
+        st.caption("Use **Estimate Cost** to preview pricing or **Submit** to create the task and get an ETA here (shown in **ACST**).")
 
+# =============== Footer ===============
+st.markdown("---")
+st.caption("Task Satellite • SAR-X AI Satellite Imagery Request Interface · Times shown in **ACST (UTC+9:30)**")

services/app_service/resources/cookies/www.youtube.com_cookies (1).txt

@@ -14,13 +14,13 @@
 .youtube.com	TRUE	/	TRUE	1795860052	__Secure-1PSID	g.a0002wgrpcW9K-QNYioDxFejw3GZD9efUs0mRhFq3acAXjra01COElc9yIf8E5lZjcmehkOAoAACgYKATYSARUSFQHGX2MiWlVwx7WCXoMqEpE8OPe6uBoVAUF8yKoNXCEYEM1OaXvtmwgRgVk50076
 .youtube.com	TRUE	/	TRUE	1795860052	__Secure-3PSID	g.a0002wgrpcW9K-QNYioDxFejw3GZD9efUs0mRhFq3acAXjra01COIiAEqiDC2XZPFcs_RH2U7AACgYKAfYSARUSFQHGX2Mi0KLOQQs0Au5u5xYXwmfaBhoVAUF8yKqN132DDK9He9JDLUX1bEz10076
 .youtube.com	TRUE	/	TRUE	1795860053	LOGIN_INFO	AFmmF2swRAIgRKXvUyDr8P18ZQwmyUgxyKGvHjNBMkeIsGSaWm76WDACIG2OvtxNgjffm-ENPsSwdsv6sn1Rv3OLmUXY8uVhCzEF:QUQ3MjNmeWxRMkNvOEtZejh3VEVRRGxlazNMY3hEa0Zhc0dUcl9vTlVFZWtDdk5PX2laWWpvLWE0WngxbW9oYlNQRzFackoxeUpmTkx5SGtsWW9kUXl4eFo1ZUphTVFiYkhlRGxsTksyUUZkRnBBbTNDWWFVLUdlS09QaUVyUU1SVEtVOVNaOElJSFl5X2JPS09TT2JSQkswelFSaW43TVln
-.youtube.com	TRUE	/	FALSE	1793366586	SIDCC	AKEyXzXCMOfvp8uO-J6COrOilaKcYtanBJUZCq0yJ5dX2AkhCKEaNIxKgblRFRR0AORNnTMwVA
-.youtube.com	TRUE	/	TRUE	1793366586	__Secure-1PSIDCC	AKEyXzWk2DwWgxLBLJ0HGYGlI1VNotnmdJ1Dv6qAUeoaPeSrLgEDJ4RerINu_Hjh0KPWqYS9
-.youtube.com	TRUE	/	TRUE	1793366586	__Secure-3PSIDCC	AKEyXzXF2OBd90Rh50Ct6Nwb2rChQY7FacAqWvrsAay3KmEKXObSNiCcnG4-AZTYECnjoz-fSw
+.youtube.com	TRUE	/	FALSE	1793698107	SIDCC	AKEyXzVAVwXKFd43pkOzcTiH8vfheMtilO22HqJv1v45HW7UjAA_Sly1FSTIk42AKdYYdUPUEg
+.youtube.com	TRUE	/	TRUE	1793698107	__Secure-1PSIDCC	AKEyXzWYtNMieN0NnU8kxj9pm92taAEtt8L6g9z1Zp7cQ0eNL5rS-VOEqZ6XPcKjFoCFpkwg
+.youtube.com	TRUE	/	TRUE	1793698107	__Secure-3PSIDCC	AKEyXzUr4JbwQQ3NQrl0BpGuofBrSW25fotVKT5RbHdauHq8lZvOw_Knp--RaXDxygvJu3ZZ1Q
 .youtube.com	TRUE	/	TRUE	0	YSC	JNOzy0pmT_0
-.youtube.com	TRUE	/	TRUE	1777382586	VISITOR_INFO1_LIVE	y1BPxdbbDNs
-.youtube.com	TRUE	/	TRUE	1777382586	VISITOR_PRIVACY_METADATA	CgJBVRIEGgAgJw%3D%3D
-.youtube.com	TRUE	/	TRUE	1777352393	__Secure-ROLLOUT_TOKEN	CMDh2N6P_q_XIBDpoLH5yLyQAxiel4z1kcuQAw%3D%3D
-.youtube.com	TRUE	/	TRUE	1824902586	__Secure-YT_TVFAS	t=489249&s=2
-.youtube.com	TRUE	/	TRUE	1777382586	DEVICE_INFO	ChxOelUyTlRBNE56VXlNek0xTnpBek16QTVOdz09ELrNjcgGGIWu8scG
-.youtube.com	TRUE	/tv	TRUE	1794662586	__Secure-YT_DERP	CPjNrY5_
+.youtube.com	TRUE	/	TRUE	1777714107	VISITOR_INFO1_LIVE	y1BPxdbbDNs
+.youtube.com	TRUE	/	TRUE	1777714107	VISITOR_PRIVACY_METADATA	CgJBVRIEGgAgJw%3D%3D
+.youtube.com	TRUE	/	TRUE	1777706424	__Secure-ROLLOUT_TOKEN	CMDh2N6P_q_XIBDpoLH5yLyQAxjNjY3kuNWQAw%3D%3D
+.youtube.com	TRUE	/	TRUE	1825234107	__Secure-YT_TVFAS	t=489249&s=2
+.youtube.com	TRUE	/	TRUE	1777714107	DEVICE_INFO	ChxOelUyTlRBNE56VXlNek0xTnpBek16QTVOdz09ELvrocgGGIWu8scG
+.youtube.com	TRUE	/tv	TRUE	1794994107	__Secure-YT_DERP	CPjNrY5_