Actualizacion de la interfaz de usuario e implementacion del sistema de etiquetado LOCS III. Arreglo de funcionalidades de borrado y restauracion de transcripcion e implementacion de Dialogos de alerta a las descargas de imagenes incompletas en etiquetado

interface/components/downloader.py

@@ -1,9 +1,12 @@
 """OphthalmoCapture — Download Component
 
 Provides individual and bulk download buttons for the labeling package.
+Uses @st.dialog modals to warn about incomplete labeling before download.
 """
 
 import streamlit as st
+import pandas as pd
+import config
 from services.export_service import (
     export_single_image,
     export_full_session,
@@ -13,69 +16,238 @@ from services.export_service import (
 )
 
 
-def render_downloader(image_id: str):
-    """Render the download panel for the current image + bulk download."""
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+def _get_image_missing_info(img: dict) -> list[str]:
+    """Return a list of human-readable items that are missing for one image."""
+    missing = []
+    if img.get("label") is None:
+        missing.append("Etiqueta categórica")
+    elif img["label"] == "Cataract":
+        locs = img.get("locs_data", {})
+        for field in config.LOCS_FIELDS:
+            fid = field["field_id"]
+            if fid not in locs:
+                missing.append(f"LOCS III – {field['label']}")
+    if not img.get("transcription"):
+        missing.append("Etiquetado por voz")
+    return missing
+
+
+# ── Dialog: individual download with incomplete labeling ─────────────────────
+
+@st.dialog("⚠️ Etiquetado incompleto", dismissible=False)
+def _show_single_incomplete_dialog(image_id: str):
+    """Warn about missing labeling for one image before individual download."""
     img = st.session_state.images.get(image_id)
     if img is None:
+        st.rerun()
         return
 
-    st.subheader("📥 Descarga")
+    missing = _get_image_missing_info(img)
+    if not missing:
+        st.session_state.pop("_pending_single_dl", None)
+        st.rerun()
+        return
 
-    # ── Individual download ──────────────────────────────────────────────
-    st.markdown("**Imagen actual**")
+    st.markdown(
+        f"La imagen **{img['filename']}** tiene campos sin completar:"
+    )
+    for item in missing:
+        st.markdown(f"- {item}")
 
-    can_download = img["label"] is not None
-    if not can_download:
-        st.info("Etiquete la imagen para habilitar la descarga individual.")
-    else:
+    st.divider()
+    c1, c2 = st.columns(2)
+    with c1:
         zip_bytes, zip_name = export_single_image(image_id)
-        st.download_button(
-            label=f"⬇️ Descargar etiquetado — {img['filename']}",
+        if st.download_button(
+            label="⬇️ Descargar igualmente",
             data=zip_bytes,
             file_name=zip_name,
             mime="application/zip",
-            key=f"dl_single_{image_id}",
+            key="_dlg_dl_single_anyway",
             use_container_width=True,
-        )
+        ):
+            st.session_state.pop("_pending_single_dl", None)
+            st.rerun()
+    with c2:
+        if st.button(
+            "🔙 Regresar y terminar",
+            use_container_width=True,
+            type="primary",
+        ):
+            st.session_state.pop("_pending_single_dl", None)
+            st.rerun()
 
-    st.divider()
 
-    # ── Bulk download ────────────────────────────────────────────────────
-    st.markdown("**Toda la sesión**")
+# ── Dialog: bulk download with incomplete images ─────────────────────────────
 
-    summary = get_session_summary()
-    sc1, sc2 = st.columns(2)
-    with sc1:
-        st.metric("Imágenes", summary["total"])
-        st.metric("Con audio", summary["with_audio"])
-    with sc2:
-        st.metric("Etiquetadas", f"{summary['labeled']} / {summary['total']}")
-        st.metric("Con transcripción", summary["with_transcription"])
-
-    if summary["unlabeled"] > 0:
-        st.warning(
-            f"⚠️ {summary['unlabeled']} imagen(es) sin etiquetar. "
-            "Se incluirán en la descarga pero sin etiqueta."
-        )
+@st.dialog("⚠️ Imágenes con etiquetado incompleto", width="large", dismissible=False)
+def _show_bulk_incomplete_dialog():
+    """Table showing per-image what labeling is missing before bulk download."""
+    images = st.session_state.images
+    order = st.session_state.image_order
 
-    if summary["total"] == 0:
-        st.info("No hay imágenes para descargar.")
-    else:
+    # Build table data
+    rows = []
+    for img_id in order:
+        img = images[img_id]
+        has_categorical = img.get("label") is not None
+        needs_locs = img.get("label") == "Cataract"
+        locs = img.get("locs_data", {})
+
+        if needs_locs:
+            locs_filled = all(
+                f["field_id"] in locs for f in config.LOCS_FIELDS
+            )
+        else:
+            locs_filled = True  # Not applicable
+
+        has_voice = bool(img.get("transcription"))
+
+        # Only show images that have something missing
+        if not (has_categorical and locs_filled and has_voice):
+            rows.append({
+                "Imagen": img["filename"],
+                "Categórica": "✅" if has_categorical else "❌",
+                "LOCS III": (
+                    "✅" if locs_filled else "❌"
+                ) if needs_locs else "N/A",
+                "Voz": "✅" if has_voice else "❌",
+            })
+
+    if not rows:
+        st.session_state.pop("_pending_bulk_dl", None)
+        st.rerun()
+        return
+
+    st.markdown(
+        f"**{len(rows)} imagen(es)** tienen etiquetado incompleto:"
+    )
+    df = pd.DataFrame(rows)
+    st.dataframe(df, use_container_width=True, hide_index=True)
+
+    st.divider()
+    c1, c2 = st.columns(2)
+    with c1:
         zip_bytes, zip_name = export_full_session()
         if st.download_button(
-            label="⬇️ Descargar todo el etiquetado (ZIP)",
+            label="⬇️ Descargar igualmente",
             data=zip_bytes,
             file_name=zip_name,
             mime="application/zip",
-            key="dl_bulk",
+            key="_dlg_dl_bulk_anyway",
             use_container_width=True,
-            type="primary",
         ):
             st.session_state.session_downloaded = True
+            st.session_state.pop("_pending_bulk_dl", None)
+            st.rerun()
+    with c2:
+        if st.button(
+            "🔙 Regresar y terminar",
+            use_container_width=True,
+            type="primary",
+        ):
+            st.session_state.pop("_pending_bulk_dl", None)
+            st.rerun()
+
+
+# ── Main downloader ──────────────────────────────────────────────────────────
+
+def render_downloader(image_id: str):
+    """Render the download panel for the current image + bulk download."""
+    img = st.session_state.images.get(image_id)
+    if img is None:
+        return
+
+    # ── Show pending dialogs (survive reruns) ────────────────────────────
+    if "_pending_single_dl" in st.session_state:
+        _show_single_incomplete_dialog(st.session_state["_pending_single_dl"])
+        return
+
+    if "_pending_bulk_dl" in st.session_state:
+        _show_bulk_incomplete_dialog()
+        return
+
+    # ── Two columns: Individual download (left) | Session info (right) ───
+    col_dl, col_info = st.columns(2)
+
+    with col_dl:
+        st.subheader("📥 Descarga individual")
+
+        # Check completeness for individual download
+        missing = _get_image_missing_info(img)
+        if missing:
+            # Show button that triggers the warning dialog
+            if st.button(
+                f"⬇️ Descargar — {img['filename']}",
+                key=f"dl_single_check_{image_id}",
+                use_container_width=True,
+            ):
+                st.session_state["_pending_single_dl"] = image_id
+                st.rerun()
+        else:
+            zip_bytes, zip_name = export_single_image(image_id)
+            st.download_button(
+                label=f"⬇️ Descargar — {img['filename']}",
+                data=zip_bytes,
+                file_name=zip_name,
+                mime="application/zip",
+                key=f"dl_single_{image_id}",
+                use_container_width=True,
+            )
+
+    with col_info:
+        st.subheader("📊 Información de sesión")
+        summary = get_session_summary()
+        sc1, sc2 = st.columns(2)
+        with sc1:
+            st.metric("Imágenes", summary["total"])
+            st.metric("Con audio", summary["with_audio"])
+        with sc2:
+            st.metric("Etiquetadas", f"{summary['labeled']} / {summary['total']}")
+            st.metric("Con transcripción", summary["with_transcription"])
+
+    st.divider()
+
+    # ── Full-width: Bulk download ────────────────────────────────────────
+    st.subheader("📦 Descargar todo el etiquetado")
+
+    summary = get_session_summary()
+
+    if summary["total"] == 0:
+        st.info("No hay imágenes para descargar.")
+    else:
+        # Check if any image has incomplete labeling
+        has_incomplete = any(
+            _get_image_missing_info(st.session_state.images[iid])
+            for iid in st.session_state.image_order
+        )
+
+        if has_incomplete:
+            if st.button(
+                "⬇️ Descargar todo el etiquetado (ZIP)",
+                key="dl_bulk_check",
+                use_container_width=True,
+                type="primary",
+            ):
+                st.session_state["_pending_bulk_dl"] = True
+                st.rerun()
+        else:
+            zip_bytes, zip_name = export_full_session()
+            if st.download_button(
+                label="⬇️ Descargar todo el etiquetado (ZIP)",
+                data=zip_bytes,
+                file_name=zip_name,
+                mime="application/zip",
+                key="dl_bulk",
+                use_container_width=True,
+                type="primary",
+            ):
+                st.session_state.session_downloaded = True
 
     # ── ML-ready formats (Idea F) ────────────────────────────────────────
     if summary["labeled"] > 0:
-        st.divider()
         st.markdown("**Formatos para ML**")
         ml1, ml2 = st.columns(2)
         with ml1:

interface/components/labeler.py

@@ -1,9 +1,14 @@
 """OphthalmoCapture — Labeling Component
 
-Provides the radio-button selector for classifying images (e.g. catarata /
-no catarata) and persists the choice in the ephemeral session.  The label
-list is driven by config.LABEL_OPTIONS so it can be extended without touching
-this component.
+Provides:
+  1. Categorical radio selector: Normal / Cataract / Bad quality / Needs dilation
+  2. LOCS III dropdowns (only when "Cataract" is selected):
+     - Nuclear Opalescence (NO) 0-6
+     - Nuclear Color (NC)       0-6
+     - Cortical Opacity (C)     0-5
+  3. Auto-saves (upsert) to audit DB on every change.
+
+Numeric values are stored for ML; only text labels are shown in the UI.
 """
 
 import streamlit as st
@@ -12,28 +17,69 @@ import database as db
 from services import session_manager as sm
 
 
-def render_labeler(image_id: str):
-    """Render the labeling panel for the given image.
+def _save_to_db(img: dict, image_id: str):
+    """Persist current label + LOCS data to audit DB (non-blocking)."""
+    try:
+        db.save_or_update_annotation(
+            image_filename=img["filename"],
+            label=img["label"],
+            transcription=img.get("transcription", ""),
+            doctor_name=st.session_state.get("doctor_name", ""),
+            session_id=st.session_state.get("session_id", ""),
+            locs_data=img.get("locs_data", {}),
+        )
+    except Exception:
+        pass
+
+
+def _render_locs_dropdown(field: dict, image_id: str, current_locs: dict) -> int | None:
+    """Render a single LOCS dropdown and return the selected numeric value."""
+    field_id = field["field_id"]
+    options = field["options"]
+    display_labels = [opt["display"] for opt in options]
+
+    # Determine current index from stored data
+    stored_value = current_locs.get(field_id)
+    if stored_value is not None:
+        current_index = next(
+            (i for i, opt in enumerate(options) if opt["value"] == stored_value),
+            None,
+        )
+    else:
+        current_index = None
+
+    # Use index=None so nothing is pre-selected until doctor chooses
+    selected_display = st.selectbox(
+        field["label"],
+        display_labels,
+        index=current_index,
+        key=f"locs_{field_id}_{image_id}",
+        placeholder="Seleccionar…",
+    )
 
-    Displays a radio selector, saves the label into session state and
-    optionally persists metadata to the audit database.
-    """
+    if selected_display is not None and selected_display in display_labels:
+        idx = display_labels.index(selected_display)
+        return options[idx]["value"]
+    return None
+
+
+def render_labeler(image_id: str):
+    """Render the full labeling panel for the given image."""
     img = st.session_state.images.get(image_id)
     if img is None:
         return
 
     st.subheader("🏷️ Etiquetado")
 
+    # ── 1. Categorical classification ────────────────────────────────────
     display_options = [opt["display"] for opt in config.LABEL_OPTIONS]
     current_label = img.get("label")
 
-    # Determine current index (None if unlabeled)
     if current_label is not None and current_label in display_options:
         current_index = display_options.index(current_label)
     else:
         current_index = None
 
-    # Styled container with radio buttons
     with st.container(border=True):
         if current_index is None:
             st.caption("⬇️ Seleccione una etiqueta para esta imagen")
@@ -47,36 +93,52 @@ def render_labeler(image_id: str):
             label_visibility="collapsed",
         )
 
-    # Map selection
     new_label = selected if selected in display_options else None
 
-    # Detect change, update session and auto-save to DB
-    if new_label is not None and new_label != current_label:
-        st.session_state.images[image_id]["label"] = new_label
-        st.session_state.images[image_id]["labeled_by"] = st.session_state.get(
-            "doctor_name", ""
-        )
+    # Detect categorical change
+    label_changed = new_label is not None and new_label != current_label
+    if label_changed:
+        img["label"] = new_label
+        img["labeled_by"] = st.session_state.get("doctor_name", "")
+        # If switching away from Cataract, clear LOCS data
+        if new_label != "Cataract":
+            img["locs_data"] = {}
         sm.update_activity()
+        _save_to_db(img, image_id)
+
+    # ── 2. LOCS III Classification (only for "Cataract") ─────────────────
+    effective_label = new_label or current_label
+    if effective_label == "Cataract":
+        st.markdown("---")
+        st.markdown("**LOCS III Classification**")
+
+        current_locs = img.get("locs_data", {})
+        locs_changed = False
+
+        with st.container(border=True):
+            for field_def in config.LOCS_FIELDS:
+                value = _render_locs_dropdown(field_def, image_id, current_locs)
+                field_id = field_def["field_id"]
+                if value is not None and value != current_locs.get(field_id):
+                    current_locs[field_id] = value
+                    locs_changed = True
+
+        img["locs_data"] = current_locs
+
+        if locs_changed:
+            sm.update_activity()
+            _save_to_db(img, image_id)
+
+        # LOCS summary
+        filled = sum(1 for f in config.LOCS_FIELDS if f["field_id"] in current_locs)
+        total_fields = len(config.LOCS_FIELDS)
+        if filled < total_fields:
+            st.info(f"📋 LOCS: {filled}/{total_fields} campos completados")
+        else:
+            st.success(f"✅ LOCS: {filled}/{total_fields} campos completados")
 
-        # Auto-save to audit DB (upsert — one record per image per session)
-        try:
-            db.save_or_update_annotation(
-                image_filename=img["filename"],
-                label=new_label,
-                transcription=img.get("transcription", ""),
-                doctor_name=st.session_state.get("doctor_name", ""),
-                session_id=st.session_state.get("session_id", ""),
-            )
-        except Exception:
-            pass  # Non-blocking: audit DB failure should not break labeling
-
-    # ── Visual feedback ──────────────────────────────────────────────────
-    if new_label is None:
+    # ── 3. Visual feedback ───────────────────────────────────────────────
+    if effective_label is None:
         st.warning("🔴 Sin etiquetar")
     else:
-        code = "—"
-        for opt in config.LABEL_OPTIONS:
-            if opt["display"] == new_label:
-                code = opt["code"]
-                break
-        st.success(f"🟢 Etiqueta: **{new_label}** (código: {code})")
+        st.success(f"🟢 Etiqueta: **{effective_label}**")

interface/components/recorder.py

@@ -91,6 +91,7 @@ def render_recorder(image_id: str, model, language: str):
                         transcription=img["transcription"],
                         doctor_name=st.session_state.get("doctor_name", ""),
                         session_id=st.session_state.get("session_id", ""),
+                        locs_data=img.get("locs_data", {}),
                     )
                 except Exception:
                     pass
@@ -140,8 +141,8 @@ def render_recorder(image_id: str, model, language: str):
             img["transcription_original"] = ""
             st.session_state.pop(segments_key, None)
             st.session_state.pop(processed_key, None)
-            st.session_state.pop(f"transcription_area_{image_id}", None)
-            # Clear the audio_input widget state to reset the recorder
+            # Clear both text_area and audio_input widget states
+            st.session_state[f"transcription_area_{image_id}"] = ""
             st.session_state.pop(f"audio_input_{image_id}", None)
             sm.update_activity()
             st.rerun()
@@ -157,6 +158,7 @@ def render_recorder(image_id: str, model, language: str):
             use_container_width=True,
         ):
             img["transcription"] = img["transcription_original"]
+            st.session_state[f"transcription_area_{image_id}"] = img["transcription_original"]
             sm.update_activity()
             st.rerun()
 
@@ -169,6 +171,7 @@ def render_recorder(image_id: str, model, language: str):
             use_container_width=True,
         ):
             img["transcription"] = ""
+            st.session_state[f"transcription_area_{image_id}"] = ""
             sm.update_activity()
             st.rerun()
 

interface/config.py

@@ -1,12 +1,64 @@
 """OphthalmoCapture — Configuration Constants."""
 
-# ── Label Options ────────────────────────────────────────────────────────────
-# Designed as a configurable list for easy extension (e.g. glaucoma, DR, AMD).
+# ── Categorical Label Options ────────────────────────────────────────────────
+# Primary classification (radio buttons).
 LABEL_OPTIONS = [
-    {"key": "catarata",    "display": "Catarata",    "code": 1},
-    {"key": "no_catarata", "display": "No Catarata", "code": 0},
+    {"key": "normal",          "display": "Normal",          "code": 0},
+    {"key": "cataract",        "display": "Cataract",        "code": 1},
+    {"key": "bad_quality",     "display": "Bad quality",     "code": 2},
+    {"key": "needs_dilation",  "display": "Needs dilation",  "code": 3},
 ]
 
+# ── LOCS III Classification (shown only when label == "Cataract") ────────────
+# Values are integer bins mapped from LOCS III continuous scales:
+#   NO/NC (0.1–6.9) → 0–6
+#   C     (0.1–5.9) → 0–5
+# We store the numeric value for ML and display only the text label.
+
+LOCS_NUCLEAR_OPALESCENCE = {
+    "field_id": "nuclear_opalescence",
+    "label": "Nuclear Cataract – Opalescence (NO)",
+    "options": [
+        {"value": 0, "display": "None / Clear"},
+        {"value": 1, "display": "Very mild"},
+        {"value": 2, "display": "Mild"},
+        {"value": 3, "display": "Mild–moderate"},
+        {"value": 4, "display": "Moderate"},
+        {"value": 5, "display": "Moderate–severe"},
+        {"value": 6, "display": "Severe"},
+    ],
+}
+
+LOCS_NUCLEAR_COLOR = {
+    "field_id": "nuclear_color",
+    "label": "Nuclear Cataract – Color (NC)",
+    "options": [
+        {"value": 0, "display": "None / Clear"},
+        {"value": 1, "display": "Very mild yellowing"},
+        {"value": 2, "display": "Mild yellowing"},
+        {"value": 3, "display": "Moderate yellow"},
+        {"value": 4, "display": "Yellow–brown"},
+        {"value": 5, "display": "Brown"},
+        {"value": 6, "display": "Dark brown"},
+    ],
+}
+
+LOCS_CORTICAL = {
+    "field_id": "cortical_opacity",
+    "label": "Cortical Cataract (C)",
+    "options": [
+        {"value": 0, "display": "None"},
+        {"value": 1, "display": "Peripheral spokes only"},
+        {"value": 2, "display": "Mild peripheral involvement"},
+        {"value": 3, "display": "Moderate spokes approaching center"},
+        {"value": 4, "display": "Central involvement"},
+        {"value": 5, "display": "Severe / dense central spokes"},
+    ],
+}
+
+# Convenience list of all LOCS dropdowns
+LOCS_FIELDS = [LOCS_NUCLEAR_OPALESCENCE, LOCS_NUCLEAR_COLOR, LOCS_CORTICAL]
+
 # ── Session Settings ─────────────────────────────────────────────────────────
 SESSION_TIMEOUT_MINUTES = 30
 

interface/database.py

@@ -56,6 +56,11 @@ def init_db():
             c.execute("ALTER TABLE annotations ADD COLUMN session_id TEXT DEFAULT ''")
         except sqlite3.OperationalError:
             pass  # column already exists
+        # Migration: add locs_data column (JSON string)
+        try:
+            c.execute("ALTER TABLE annotations ADD COLUMN locs_data TEXT DEFAULT ''")
+        except sqlite3.OperationalError:
+            pass  # column already exists
         c.execute('''CREATE INDEX IF NOT EXISTS idx_ann_session
                       ON annotations (image_filename, session_id)''')
         conn.commit()
@@ -92,14 +97,17 @@ def save_annotation(image_filename, label, transcription, doctor_name=""):
 
 
 def save_or_update_annotation(
-    image_filename, label, transcription, doctor_name="", session_id=""
+    image_filename, label, transcription, doctor_name="", session_id="",
+    locs_data=None,
 ):
     """Upsert: within the same session, keep only ONE record per image.
 
     If a record for (image_filename, session_id) already exists → UPDATE it.
     Otherwise → INSERT a new one.
     """
+    import json as _json
     timestamp = datetime.datetime.now()
+    locs_json = _json.dumps(locs_data or {}, ensure_ascii=False)
 
     if DB_TYPE == "FIREBASE":
         # Query for existing doc with matching filename + session
@@ -115,6 +123,7 @@ def save_or_update_annotation(
                 "label": label,
                 "transcription": transcription,
                 "doctorName": doctor_name,
+                "locsData": locs_data or {},
                 "createdAt": timestamp,
             })
         else:
@@ -124,6 +133,7 @@ def save_or_update_annotation(
                 "transcription": transcription,
                 "doctorName": doctor_name,
                 "sessionId": session_id,
+                "locsData": locs_data or {},
                 "createdAt": timestamp,
             })
     else:
@@ -139,16 +149,19 @@ def save_or_update_annotation(
         if row:
             c.execute(
                 "UPDATE annotations "
-                "SET label = ?, transcription = ?, doctor_name = ?, created_at = ? "
+                "SET label = ?, transcription = ?, doctor_name = ?, "
+                "created_at = ?, locs_data = ? "
                 "WHERE id = ?",
-                (label, transcription, doctor_name, timestamp, row[0]),
+                (label, transcription, doctor_name, timestamp, locs_json, row[0]),
             )
         else:
             c.execute(
                 "INSERT INTO annotations "
-                "(image_filename, label, transcription, doctor_name, created_at, session_id) "
-                "VALUES (?, ?, ?, ?, ?, ?)",
-                (image_filename, label, transcription, doctor_name, timestamp, session_id),
+                "(image_filename, label, transcription, doctor_name, "
+                "created_at, session_id, locs_data) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (image_filename, label, transcription, doctor_name,
+                 timestamp, session_id, locs_json),
             )
         conn.commit()
         conn.close()

interface/main.py

@@ -280,50 +280,51 @@ current_img = sm.get_current_image()
 order = st.session_state.image_order
 current_idx = order.index(current_id)
 
-# ── Two-column layout: Image | Tools ─────────────────────────────────────────
-col_img, col_tools = st.columns([1.5, 1])
-
-with col_img:
-    st.image(
-        current_img["bytes"],
-        caption=current_img["filename"],
-        use_container_width=True,
-    )
+# ── Single-column layout ─────────────────────────────────────────────────────
 
-    # Navigation
-    c1, c2, c3 = st.columns([1, 2, 1])
-    with c1:
-        if st.button("⬅️ Anterior", disabled=(len(order) <= 1)):
-            new_idx = (current_idx - 1) % len(order)
-            st.session_state.current_image_id = order[new_idx]
-            sm.update_activity()
-            st.rerun()
-    with c2:
-        st.markdown(
-            f"<div style='text-align:center'><b>{current_img['filename']}</b>"
-            f"<br>({current_idx + 1} de {len(order)})</div>",
-            unsafe_allow_html=True,
-        )
-    with c3:
-        if st.button("Siguiente ➡️", disabled=(len(order) <= 1)):
-            new_idx = (current_idx + 1) % len(order)
-            st.session_state.current_image_id = order[new_idx]
-            sm.update_activity()
-            st.rerun()
+# 1️⃣ LABELER — radio buttons at full width
+render_labeler(current_id)
+
+st.divider()
+
+# 2️⃣ IMAGE — with navigation and delete
+st.image(
+    current_img["bytes"],
+    caption=current_img["filename"],
+    use_container_width=True,
+)
 
-    # Delete image from session
-    if st.button("🗑️ Eliminar esta imagen", key="delete_img"):
-        sm.remove_image(current_id)
+c1, c2, c3 = st.columns([1, 2, 1])
+with c1:
+    if st.button("⬅️ Anterior", disabled=(len(order) <= 1)):
+        new_idx = (current_idx - 1) % len(order)
+        st.session_state.current_image_id = order[new_idx]
+        sm.update_activity()
+        st.rerun()
+with c2:
+    st.markdown(
+        f"<div style='text-align:center'><b>{current_img['filename']}</b>"
+        f"<br>({current_idx + 1} de {len(order)})</div>",
+        unsafe_allow_html=True,
+    )
+with c3:
+    if st.button("Siguiente ➡️", disabled=(len(order) <= 1)):
+        new_idx = (current_idx + 1) % len(order)
+        st.session_state.current_image_id = order[new_idx]
         sm.update_activity()
         st.rerun()
 
-with col_tools:
-    render_labeler(current_id)
+if st.button("🗑️ Eliminar esta imagen", key="delete_img"):
+    sm.remove_image(current_id)
+    sm.update_activity()
+    st.rerun()
 
-    st.divider()
+st.divider()
 
-    render_recorder(current_id, model, selected_language)
+# 3️⃣ RECORDER — dictation and transcription
+render_recorder(current_id, model, selected_language)
 
-    st.divider()
+st.divider()
 
-    render_downloader(current_id)
+# 4️⃣ DOWNLOAD (individual) + SESSION INFO — two columns
+render_downloader(current_id)

interface/services/export_service.py

@@ -23,6 +23,7 @@ def _image_metadata(img: dict) -> dict:
     return {
         "filename": img["filename"],
         "label": img["label"],
+        "locs_data": img.get("locs_data", {}),
         "transcription": img["transcription"],
         "transcription_original": img["transcription_original"],
         "doctor": img.get("labeled_by", ""),
@@ -76,12 +77,18 @@ def export_full_session() -> tuple[bytes, str]:
         # ── Summary CSV ──────────────────────────────────────────────────
         csv_buf = io.StringIO()
         writer = csv.writer(csv_buf)
-        writer.writerow(["filename", "label", "has_audio", "has_transcription", "doctor"])
+        writer.writerow(["filename", "label", "nuclear_opalescence",
+                         "nuclear_color", "cortical_opacity",
+                         "has_audio", "has_transcription", "doctor"])
         for img_id in order:
             img = images[img_id]
+            locs = img.get("locs_data", {})
             writer.writerow([
                 img["filename"],
                 img["label"] or "",
+                locs.get("nuclear_opalescence", ""),
+                locs.get("nuclear_color", ""),
+                locs.get("cortical_opacity", ""),
                 "yes" if img["audio_bytes"] else "no",
                 "yes" if img["transcription"] else "no",
                 img.get("labeled_by", ""),
@@ -150,16 +157,22 @@ def export_huggingface_csv() -> tuple[bytes, str]:
 
     buf = io.StringIO()
     writer = csv.writer(buf)
-    writer.writerow(["filename", "label", "label_code", "transcription", "doctor"])
+    writer.writerow(["filename", "label", "label_code",
+                     "nuclear_opalescence", "nuclear_color", "cortical_opacity",
+                     "transcription", "doctor"])
 
     for img_id in order:
         img = images[img_id]
         if img["label"] is None:
             continue
+        locs = img.get("locs_data", {})
         writer.writerow([
             img["filename"],
             img["label"],
             label_map.get(img["label"], ""),
+            locs.get("nuclear_opalescence", ""),
+            locs.get("nuclear_color", ""),
+            locs.get("cortical_opacity", ""),
             img["transcription"],
             img.get("labeled_by", ""),
         ])
@@ -188,10 +201,14 @@ def export_jsonl() -> tuple[bytes, str]:
         img = images[img_id]
         if img["label"] is None:
             continue
+        locs = img.get("locs_data", {})
         obj = {
             "filename": img["filename"],
             "label": img["label"],
             "label_code": label_map.get(img["label"], ""),
+            "nuclear_opalescence": locs.get("nuclear_opalescence"),
+            "nuclear_color": locs.get("nuclear_color"),
+            "cortical_opacity": locs.get("cortical_opacity"),
             "transcription": img["transcription"],
             "doctor": img.get("labeled_by", ""),
         }

interface/services/session_manager.py

@@ -34,7 +34,8 @@ def add_image(filename: str, image_bytes: bytes) -> str:
     st.session_state.images[img_id] = {
         "filename": filename,
         "bytes": image_bytes,
-        "label": None,                 # Set during labeling (Phase 3)
+        "label": None,                 # Categorical: Normal/Cataract/Bad quality/Needs dilation
+        "locs_data": {},               # LOCS III: {"nuclear_opalescence": int, "nuclear_color": int, "cortical_opacity": int}
         "audio_bytes": None,           # WAV from recording (Phase 4)
         "transcription": "",           # Editable transcription text
         "transcription_original": "",  # Original Whisper output (read-only)