upload labeling tool

.gitignore

@@ -0,0 +1,72 @@
+# =====================
+# macOS
+# =====================
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon?
+._*
+.Spotlight-V100
+.Trashes
+
+# =====================
+# Python
+# =====================
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+venv/
+ENV/
+env/
+pip-wheel-metadata/
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# =====================
+# PyTorch
+# =====================
+*.pt
+*.pth
+*.ckpt
+checkpoints/
+runs/
+lightning_logs/
+
+# =====================
+# Jupyter Notebooks
+# =====================
+.ipynb_checkpoints/
+*.nbconvert.ipynb
+
+# =====================
+# Streamlit
+# =====================
+.streamlit/secrets.toml
+.streamlit/.cache
+.streamlit/cache
+.streamlit/config.toml
+
+# =====================
+# Logs & Temp Files
+# =====================
+*.log
+*.tmp
+*.swp
+
+# =====================
+# Archives (skip zip files)
+# =====================
+*.zip
+*.tar
+*.tar.gz
+*.rar
+
+# =====================
+# IDEs
+# =====================
+.vscode/
+.idea/

README.md

@@ -0,0 +1,59 @@
+# How to Run MedGemma
+
+This guide explains how to set up the environment and run both the Streamlit interface and the Jupyter Notebook for the MedGemma project.
+
+## 1. Prerequisites & Setup
+
+### A. Download the Dataset
+
+The application requires the fundus image dataset to function.
+
+1. **Download:** [**Click here to download full-fundus.zip**](https://upm365-my.sharepoint.com/:u:/g/personal/angelmario_garcia_upm_es/IQCP3cLo1x3tRK_TFCrt2HR0AfSAca5rzHrwaRa4Cm-EfL4?e=UcrIgy)
+2. **Extract:** Unzip the file into the root directory of your project.
+   * **Verify:** Ensure you see a folder named `full-fundus/` in your project folder.
+
+### B. Install Dependencies
+
+Make sure you have Python installed, then run:
+
+```bash
+pip install streamlit notebook torch transformers pillow whisper
+````
+
+-----
+
+## 2. Running the Web Interface (Streamlit)
+
+Use this method for a user-friendly dashboard to analyze images.
+
+1. Open your terminal (Command Prompt or Terminal).
+2. Navigate to your project folder:
+
+    ```bash
+    cd /path/to/your/project
+    ```
+
+3. Run the Streamlit application:
+
+    ```bash
+    streamlit run interface/main.py
+    ```
+
+4. A new tab will open in your browser automatically at `http://localhost:8501`.
+
+-----
+
+## 3\. Running the Notebook (Jupyter)
+
+Use this method to see the code logic, fine-tune the model, or debug.
+
+1. Open your terminal and navigate to the project folder.
+2. Launch Jupyter:
+
+    ```bash
+    jupyter notebook medgemma.ipynb
+    ```
+
+3. The Jupyter interface will open in your browser.
+4. Click on `medgemma.ipynb`.
+5. Run the cells sequentially (Shift + Enter) to execute the model.

interface/database.py

@@ -0,0 +1,169 @@
+import os
+import datetime
+import sqlite3
+import math
+
+# Try importing firebase_admin
+try:
+    import firebase_admin
+    from firebase_admin import credentials, firestore
+    FIREBASE_AVAILABLE = True
+except ImportError:
+    FIREBASE_AVAILABLE = False
+
+DB_TYPE = "SQLITE"
+db_ref = None
+
+def init_db():
+    """Initializes the database connection (Firebase or SQLite)."""
+    global DB_TYPE, db_ref
+    
+    # Try Firebase first
+    if FIREBASE_AVAILABLE and os.path.exists("serviceAccountKey.json"):
+        try:
+            if not firebase_admin._apps:
+                cred = credentials.Certificate("serviceAccountKey.json")
+                firebase_admin.initialize_app(cred)
+            db_ref = firestore.client()
+            DB_TYPE = "FIREBASE"
+            return "FIREBASE"
+        except Exception as e:
+            print(f"Firebase init failed: {e}")
+
+    # Fallback to SQLite
+    try:
+        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        c = conn.cursor()
+        c.execute('''CREATE TABLE IF NOT EXISTS diagnoses
+                     (id INTEGER PRIMARY KEY AUTOINCREMENT, 
+                      image_id TEXT, 
+                      diagnosis_text TEXT, 
+                      timestamp DATETIME)''')
+        c.execute('''CREATE INDEX IF NOT EXISTS idx_image_id ON diagnoses (image_id)''')
+        conn.commit()
+        conn.close()
+        DB_TYPE = "SQLITE"
+        return "SQLITE"
+    except Exception as e:
+        raise Exception(f"Database initialization failed: {e}")
+
+def save_diagnosis(image_id, text, doctor_name="LocalUser"):
+    """Saves the diagnosis to the active database."""
+    timestamp = datetime.datetime.now()
+    
+    if DB_TYPE == "FIREBASE":
+        db_ref.collection("ophthalmo_diagnoses").add({
+            "imageId": image_id,
+            "diagnosisText": text,
+            "createdAt": timestamp,
+            "doctor": doctor_name
+        })
+    else:
+        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        c = conn.cursor()
+        c.execute("INSERT INTO diagnoses (image_id, diagnosis_text, timestamp) VALUES (?, ?, ?)",
+                  (image_id, text, timestamp))
+        conn.commit()
+        conn.close()
+
+def get_latest_diagnosis(image_id):
+    """Retrieves the most recent diagnosis for a specific image ID."""
+    if DB_TYPE == "FIREBASE":
+        docs = db_ref.collection("ophthalmo_diagnoses")\
+            .where("imageId", "==", image_id)\
+            .order_by("createdAt", direction=firestore.Query.DESCENDING)\
+            .limit(1)\
+            .stream()
+        for doc in docs:
+            return doc.to_dict().get("diagnosisText", "")
+    else:
+        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        c = conn.cursor()
+        c.execute("SELECT diagnosis_text FROM diagnoses WHERE image_id = ? ORDER BY id DESC LIMIT 1", (image_id,))
+        row = c.fetchone()
+        conn.close()
+        if row:
+            return row[0]
+    return ""
+
+def get_history_paginated(search_query="", page=1, per_page=10):
+    """
+    Retrieves history with search filtering and pagination.
+    Returns: (list_of_items, total_count)
+    """
+    offset = (page - 1) * per_page
+    history = []
+    total_count = 0
+    
+    if DB_TYPE == "FIREBASE":
+        ref = db_ref.collection("ophthalmo_diagnoses")
+        if search_query:
+            # Prefix search hack for Firestore
+            query = ref.where("imageId", ">=", search_query)\
+                       .where("imageId", "<=", search_query + '\uf8ff')
+        else:
+            query = ref.order_by("createdAt", direction=firestore.Query.DESCENDING)
+        
+        all_docs = list(query.stream())
+        total_count = len(all_docs)
+        
+        # In-memory pagination for Firebase
+        start = offset
+        end = offset + per_page
+        for doc in all_docs[start:end]:
+            history.append(doc.to_dict())
+
+    else:
+        # SQLite Implementation
+        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        c = conn.cursor()
+        
+        # 1. Count
+        if search_query:
+            c.execute("SELECT COUNT(*) FROM diagnoses WHERE image_id LIKE ?", (f"%{search_query}%",))
+        else:
+            c.execute("SELECT COUNT(*) FROM diagnoses")
+        total_count = c.fetchone()[0]
+        
+        # 2. Fetch
+        query_sql = "SELECT image_id, diagnosis_text, timestamp FROM diagnoses"
+        params = []
+        
+        if search_query:
+            query_sql += " WHERE image_id LIKE ?"
+            params.append(f"%{search_query}%")
+            
+        query_sql += " ORDER BY id DESC LIMIT ? OFFSET ?"
+        params.extend([per_page, offset])
+        
+        c.execute(query_sql, params)
+        rows = c.fetchall()
+        for row in rows:
+            history.append({
+                "imageId": row[0],
+                "diagnosisText": row[1],
+                "createdAt": row[2]
+            })
+        conn.close()
+        
+    return history, total_count
+
+def get_last_active_image_id():
+    """Retrieves the image_id of the most recently saved diagnosis."""
+    if DB_TYPE == "FIREBASE":
+        docs = db_ref.collection("ophthalmo_diagnoses")\
+            .order_by("createdAt", direction=firestore.Query.DESCENDING)\
+            .limit(1)\
+            .stream()
+        for doc in docs:
+            return doc.to_dict().get("imageId")
+    else:
+        conn = sqlite3.connect('local_diagnoses.db', check_same_thread=False)
+        c = conn.cursor()
+        # Fetch the most recent entry based on timestamp (or ID if timestamp is unreliable)
+        c.execute("SELECT image_id FROM diagnoses ORDER BY timestamp DESC LIMIT 1")
+        row = c.fetchone()
+        conn.close()
+        if row:
+            return row[0]
+    return None

interface/main.py

@@ -0,0 +1,227 @@
+import os
+# CRITICAL FIX: MUST BE THE FIRST LINE 
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+import streamlit as st
+import tempfile
+import math
+import database as db
+import utils
+
+# CONFIGURATION 
+st.set_page_config(page_title="OphthalmoCapture", layout="wide", page_icon="👁️")
+
+# Change these paths to match your actual folders
+CSV_FILE_PATH = "interface/dataset_fl.csv"  # Your CSV file
+IMAGE_FOLDER = "full-fundus"        # Folder containing your images
+
+# INITIALIZATION 
+utils.setup_env()
+
+try:
+    active_db_type = db.init_db()
+except Exception as e:
+    st.error(f"Critical Database Error: {e}")
+    st.stop()
+
+# LOAD REAL DATASET
+# This replaces the mock data. It runs once per session.
+if 'dataset' not in st.session_state:
+    st.session_state.dataset = utils.load_dataset(CSV_FILE_PATH, IMAGE_FOLDER)
+
+# Helper to access the dataset safely
+DATASET = st.session_state.dataset
+
+if not DATASET:
+    st.error("Please ensure 'dataset.csv' exists and 'images' folder is populated.")
+    st.stop() # Stop execution if no data
+
+# SIDEBAR: SETTINGS & HISTORY 
+with st.sidebar:
+    st.title("⚙️ Settings")
+    
+    # Model Selector
+    model_options = ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large", "turbo"]
+    selected_model = st.selectbox("Whisper Model Size", model_options, index=1)
+    
+    st.divider()
+    
+    # History Section
+    st.header(f"🗄️ History ({active_db_type})")
+    
+    search_input = st.text_input("🔍 Search ID", value=st.session_state.get('history_search', ""))
+    if search_input != st.session_state.get('history_search', ""):
+        st.session_state.history_search = search_input
+        st.session_state.history_page = 1
+        st.rerun()
+
+    if 'history_page' not in st.session_state:
+        st.session_state.history_page = 1
+        
+    ITEMS_PER_PAGE = 5
+    try:
+        history_data, total_items = db.get_history_paginated(
+            st.session_state.get('history_search', ""), 
+            st.session_state.history_page, 
+            ITEMS_PER_PAGE
+        )
+    except Exception as e:
+        st.error(f"Error fetching history: {e}")
+        history_data, total_items = [], 0
+    
+    if not history_data:
+        st.info("No diagnoses found.")
+    else:
+        for item in history_data:
+            ts = str(item.get('createdAt'))[:16]
+            img_id = item.get('imageId', 'N/A')
+            text = item.get('diagnosisText', '')
+            preview = (text[:50] + '..') if len(text) > 50 else text
+            
+            with st.expander(f"{img_id} ({ts})"):
+                st.caption(ts)
+                st.write(f"_{preview}_")
+                
+                if st.button("Load Report", key=f"load_{item.get('createdAt')}_{img_id}"):
+                     # 1. Update the text
+                     st.session_state.current_transcription = text
+                     
+                     # 2. Find and update the image index
+                     found_index = -1
+                     for idx, data_item in enumerate(DATASET):
+                         if str(data_item['id']) == str(img_id):
+                             found_index = idx
+                             break
+                     
+                     if found_index != -1:
+                         st.session_state.img_index = found_index
+                     else:
+                         st.warning(f"Image ID {img_id} not found in current dataset.")
+                     
+                     st.rerun()
+
+    total_pages = math.ceil(total_items / ITEMS_PER_PAGE)
+    if total_pages > 1:
+        st.divider()
+        c1, c2, c3 = st.columns([1, 2, 1])
+        with c1:
+            if st.session_state.history_page > 1:
+                if st.button("◀️"):
+                    st.session_state.history_page -= 1
+                    st.rerun()
+        with c2:
+            st.markdown(f"<div style='text-align: center; padding-top: 5px;'>{st.session_state.history_page} / {total_pages}</div>", unsafe_allow_html=True)
+        with c3:
+            if st.session_state.history_page < total_pages:
+                if st.button("▶️"):
+                    st.session_state.history_page += 1
+                    st.rerun()
+
+# LOAD MODEL 
+with st.spinner(f"Loading Whisper '{selected_model}' model..."):
+    model = utils.load_whisper_model(selected_model)
+
+# SESSION STATE MANAGEMENT 
+if 'img_index' not in st.session_state:
+    # Default to 0
+    start_index = 0
+    
+    # Try to find the last worked-on image from the DB
+    try:
+        last_id = db.get_last_active_image_id()
+        if last_id:
+            # Find the index of this ID in the current DATASET
+            for i, item in enumerate(DATASET):
+                if str(item["id"]) == str(last_id):
+                    start_index = i
+                    break
+    except Exception as e:
+        print(f"Could not restore session: {e}")
+        
+    st.session_state.img_index = start_index
+
+def load_current_image_data():
+    """Updates session state with DB data for the new image."""
+    current_img_id = DATASET[st.session_state.img_index]["id"]
+    try:
+        existing_text = db.get_latest_diagnosis(current_img_id)
+        st.session_state.current_transcription = existing_text if existing_text else ""
+    except Exception as e:
+        st.error(f"Failed to load diagnosis: {e}")
+        st.session_state.current_transcription = ""
+    st.session_state.last_processed_audio = None
+
+if 'current_transcription' not in st.session_state:
+    load_current_image_data()
+if 'last_processed_audio' not in st.session_state:
+    st.session_state.last_processed_audio = None
+
+# MAIN CONTENT 
+st.title("👁️ OphthalmoCapture")
+st.caption(f"Medical Dictation System • Model: {selected_model}")
+
+col_img, col_diag = st.columns([1.5, 1])
+current_img = DATASET[st.session_state.img_index]
+
+with col_img:
+    st.image(current_img["url"], width="stretch")
+    
+    # Navigation
+    c1, c2, c3 = st.columns([1, 2, 1])
+    with c1:
+        if st.button("⬅️ Previous"):
+            st.session_state.img_index = (st.session_state.img_index - 1) % len(DATASET)
+            load_current_image_data()
+            st.rerun()
+    with c2:
+        st.markdown(f"<div style='text-align: center'><b>{current_img['label']}</b><br>(ID: {current_img['id']})</div>", unsafe_allow_html=True)
+    with c3:
+        if st.button("Next ➡️"):
+            st.session_state.img_index = (st.session_state.img_index + 1) % len(DATASET)
+            load_current_image_data()
+            st.rerun()
+
+with col_diag:
+    st.subheader("Dictation & Report")
+    
+    audio_wav = st.audio_input("Record Voice", key=f"audio_{current_img['id']}")
+
+    if audio_wav is not None:
+        if st.session_state.last_processed_audio != audio_wav:
+            with st.spinner("Analyzing audio..."):
+                try:
+                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+                        tmp_file.write(audio_wav.read())
+                        tmp_path = tmp_file.name
+                    
+                    result = model.transcribe(tmp_path, language="es")
+                    new_text = result["text"].strip()
+                    
+                    if st.session_state.current_transcription:
+                        st.session_state.current_transcription += " " + new_text
+                    else:
+                        st.session_state.current_transcription = new_text
+                    
+                    st.session_state.last_processed_audio = audio_wav
+                    os.remove(tmp_path)
+                except Exception as e:
+                    st.error(f"Transcription Error: {e}")
+
+    diagnosis_text = st.text_area(
+        "Findings:", 
+        value=st.session_state.current_transcription,
+        height=300
+    )
+    
+    if diagnosis_text != st.session_state.current_transcription:
+        st.session_state.current_transcription = diagnosis_text
+
+    if st.button("💾 Save to Record", type="primary"):
+        if diagnosis_text.strip():
+            try:
+                db.save_diagnosis(current_img['id'], diagnosis_text)
+                st.success("Successfully saved to database.")
+            except Exception as e:
+                st.error(f"Save failed: {e}")
+        else:
+            st.warning("Cannot save empty diagnosis.")

interface/utils.py

@@ -0,0 +1,67 @@
+import streamlit as st
+import whisper
+import os
+import pandas as pd
+
+
+@st.cache_resource
+def load_whisper_model(model_size):
+    """Loads the Whisper model (Cached)."""
+    print(f"Loading Whisper model: {model_size}...")
+    return whisper.load_model(model_size)
+
+def setup_env():
+    """Sets up environment variables."""
+    os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+def load_dataset(csv_path, image_folder):
+    """
+    Reads a CSV and checks for image existence.
+    Expected CSV columns: 'filename' (required), 'label' (optional).
+    """
+    images_list = []
+    
+    # 1. Check if CSV exists
+    if not os.path.exists(csv_path):
+        st.error(f"⚠️ CSV file not found: {csv_path}")
+        return []
+
+    try:
+        df = pd.read_csv(csv_path)
+    except Exception as e:
+        st.error(f"Error reading CSV: {e}")
+        return []
+
+    # 2. Iterate through CSV
+    # We look for a 'filename' column. If not found, use the first column.
+    filename_col = 'filename'
+    if 'filename' not in df.columns:
+        filename_col = df.columns[0]
+        st.warning(f"Column 'filename' not found. Using '{filename_col}' as filename.")
+
+    for index, row in df.iterrows():
+        base_name = str(row[filename_col]).strip()
+        
+        # Construct full path
+        full_path = os.path.join(image_folder, base_name)
+        
+        # Handle extensions if filename doesn't have them (optional check)
+        if not os.path.exists(full_path):
+            # Try adding common extensions if file not found
+            for ext in ['.jpg', '.png', '.jpeg', '.tif']:
+                if os.path.exists(full_path + ext):
+                    full_path = full_path + ext
+                    break
+        
+        # Only add if file actually exists
+        if os.path.exists(full_path):
+            images_list.append({
+                "id": base_name,
+                "label": row.get('label', base_name), # Use 'label' column or fallback to name
+                "url": full_path # Streamlit accepts local paths here
+            })
+    
+    if not images_list:
+        st.warning(f"No valid images found in '{image_folder}' matching the CSV.")
+        
+    return images_list

medgemma.ipynb

@@ -0,0 +1,110 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8392208-f730-4554-b7ae-6fd7a67bb3ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import csv\n",
+    "import re\n",
+    "import glob\n",
+    "from PIL import Image\n",
+    "import torch\n",
+    "from tqdm import tqdm\n",
+    "from transformers import pipeline\n",
+    "\n",
+    "# CONFIGURATION\n",
+    "MODEL_ID = \"google/medgemma-4b-it\"\n",
+    "\n",
+    "OUTPUT_FILE = \"./results_marisse.csv\"\n",
+    "IMAGE_PATH = \"./full-fundus/*.*\"\n",
+    "\n",
+    "# INITIALIZE PIPELINE\n",
+    "pipe = pipeline(\n",
+    "    \"image-text-to-text\",\n",
+    "    model=MODEL_ID,\n",
+    "    torch_dtype=torch.bfloat16,\n",
+    "    # device_map=\"auto\",\n",
+    "    device=1,\n",
+    ")\n",
+    "\n",
+    "# PROMPT\n",
+    "base_prompt_text = (\n",
+    "    \"You are an expert ophthalmologist. Evaluate this fundus image for signs of glaucoma \"\n",
+    "    \"(optic disc cupping, RNFL loss, peripapillary atrophy). \"\n",
+    "    \"Write your Key Findings. Then provide your Conclusion. Do not include a Disclaimer.\"\n",
+    ")\n",
+    "\n",
+    "# LOAD IMAGES\n",
+    "image_files = sorted(glob.glob(IMAGE_PATH))\n",
+    "print(f\"Found {len(image_files)} images.\")\n",
+    "\n",
+    "# Ensure directory exists\n",
+    "os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)\n",
+    "\n",
+    "# PROCESSING LOOP\n",
+    "with open(OUTPUT_FILE, mode='w', newline='', encoding='utf-8') as csvfile:\n",
+    "    writer = csv.writer(csvfile)\n",
+    "    writer.writerow([\"Image File\", \"Full Reasoning\"])\n",
+    "\n",
+    "    for image_file in tqdm(image_files):\n",
+    "        try:\n",
+    "            image = Image.open(image_file).convert(\"RGB\")  # Ensure consistent color channels\n",
+    "\n",
+    "            messages = [\n",
+    "                {\n",
+    "                    \"role\": \"user\",\n",
+    "                    \"content\": [\n",
+    "                        {\"type\": \"text\", \"text\": base_prompt_text},\n",
+    "                        {\"type\": \"image\", \"image\": image}\n",
+    "                    ]\n",
+    "                }\n",
+    "            ]\n",
+    "\n",
+    "            output = pipe(\n",
+    "                messages,\n",
+    "                max_new_tokens=2048,\n",
+    "                do_sample=False\n",
+    "            )\n",
+    "\n",
+    "            generated_text = output[0][\"generated_text\"]\n",
+    "            if isinstance(generated_text, list):\n",
+    "                raw_response = generated_text[-1][\"content\"].strip()\n",
+    "            else:\n",
+    "                raw_response = generated_text.strip()\n",
+    "\n",
+    "            writer.writerow([os.path.basename(image_file), raw_response])\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error processing {image_file}: {e}\")\n",
+    "            writer.writerow([os.path.basename(image_file), \"ERROR\", str(e)])\n",
+    "\n",
+    "print(\"Processing complete.\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "medgemma",
+   "language": "python",
+   "name": "medgemma"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}