Delete src

src/DEPLOYMENT_GUIDE.md

@@ -1,366 +0,0 @@
-# 🚀 Deployment Guide: Pneumonia Annotation Tool
-
-This guide explains how to deploy the annotation app to **Hugging Face Spaces** (recommended, free) or **Streamlit Community Cloud**.
-
----
-
-## 📋 Prerequisites
-
-1. GitHub account
-2. Hugging Face account (free) — [huggingface.co](https://huggingface.co)
-3. Your annotation app files
-
----
-
-## 📁 Step 1: Prepare Your Project Structure
-
-Create a new folder with the following structure:
-
-```
-pneumonia-annotation-tool/
-├── app.py                    # Your main Streamlit app (renamed)
-├── requirements.txt          # Python dependencies
-├── README.md                 # Project description
-├── .gitignore                # Files to ignore
-├── packages.txt              # System dependencies (optional)
-└── sample_images/            # Sample X-ray images for demo (optional)
-    └── sample_xray.jpg
-```
-
-### 1.1 Copy and rename your app
-
-```bash
-cp annotation_app.py app.py
-```
-
-### 1.2 Create `requirements.txt`
-
-```txt
-streamlit>=1.28.0
-streamlit-drawable-canvas>=0.9.3
-opencv-python-headless>=4.8.0
-numpy>=1.24.0
-pandas>=2.0.0
-Pillow>=10.0.0
-```
-
-> ⚠️ Use `opencv-python-headless` instead of `opencv-python` for cloud deployment!
-
-### 1.3 Create `.gitignore`
-
-```gitignore
-# Python
-__pycache__/
-*.py[cod]
-*.so
-.Python
-env/
-venv/
-.venv/
-
-# IDE
-.vscode/
-.idea/
-
-# Data (don't upload patient data!)
-data/Pacientes/
-*.png
-*.jpg
-!sample_images/*.jpg
-
-# OS
-.DS_Store
-Thumbs.db
-```
-
-### 1.4 Create `README.md`
-
-```markdown
----
-title: Pneumonia Consolidation Annotation Tool
-emoji: 🫁
-colorFrom: blue
-colorTo: green
-sdk: streamlit
-sdk_version: 1.28.0
-app_file: app.py
-pinned: false
----
-
-# 🫁 Pneumonia Consolidation Annotation Tool
-
-A Streamlit application for radiologists to annotate pneumonia consolidations
-on chest X-rays, supporting multilobar annotations with different colors.
-
-## Features
-- 🎨 Draw directly on X-ray images
-- 🫁 Multiple consolidation sites with unique colors
-- 🔍 Zoom & pan for detailed annotation
-- 💾 Save masks and metadata
-- 📊 Inter-rater agreement (Dice, IoU)
-```
-
----
-
-## 🤗 Option A: Deploy to Hugging Face Spaces (Recommended)
-
-### Step 1: Create a Hugging Face Account
-Go to [huggingface.co](https://huggingface.co) and sign up (free).
-
-### Step 2: Create a New Space
-
-1. Click your profile → **New Space**
-2. Fill in:
-   - **Space name**: `pneumonia-annotation-tool`
-   - **License**: Choose one (e.g., MIT)
-   - **SDK**: Select **Streamlit**
-   - **Visibility**: Public or Private
-3. Click **Create Space**
-
-### Step 3: Upload Files
-
-**Option A: Via Web Interface**
-1. Go to your Space → **Files** tab
-2. Click **Add file** → **Upload files**
-3. Upload: `app.py`, `requirements.txt`, `README.md`
-
-**Option B: Via Git (recommended)**
-
-```bash
-# Clone your Space
-git clone https://huggingface.co/spaces/YOUR_USERNAME/pneumonia-annotation-tool
-cd pneumonia-annotation-tool
-
-# Copy your files
-cp /path/to/annotation_app.py app.py
-cp /path/to/requirements.txt .
-cp /path/to/README.md .
-
-# Add and push
-git add .
-git commit -m "Initial deployment"
-git push
-```
-
-### Step 4: Modify App for Cloud
-
-Edit `app.py` to change the default patients path:
-
-```python
-# Change this line in the sidebar:
-patients_path = st.sidebar.text_input(
-    "Patients Folder Path",
-    value="./uploaded_images",  # Changed from ../data/Pacientes
-    help="Upload images or specify folder path",
-)
-```
-
-### Step 5: Add Image Upload Feature
-
-Add this code after the patients_path input to allow users to upload their own images:
-
-```python
-# Add file uploader for cloud deployment
-st.sidebar.header("📤 Upload Images")
-uploaded_files = st.sidebar.file_uploader(
-    "Upload X-ray Images",
-    type=["jpg", "jpeg", "png"],
-    accept_multiple_files=True,
-)
-
-if uploaded_files:
-    upload_dir = Path("./uploaded_images/patient_upload")
-    upload_dir.mkdir(parents=True, exist_ok=True)
-    for uf in uploaded_files:
-        with open(upload_dir / uf.name, "wb") as f:
-            f.write(uf.getbuffer())
-    st.sidebar.success(f"✅ Uploaded {len(uploaded_files)} images!")
-```
-
-### Step 6: Wait for Build
-
-Hugging Face will automatically build and deploy. Check the **Logs** tab if there are errors.
-
-🎉 **Your app will be live at**: `https://huggingface.co/spaces/YOUR_USERNAME/pneumonia-annotation-tool`
-
----
-
-## ☁️ Option B: Deploy to Streamlit Community Cloud
-
-### Step 1: Push to GitHub
-
-```bash
-# Create a new GitHub repository
-# Then push your code:
-git init
-git add .
-git commit -m "Initial commit"
-git branch -M main
-git remote add origin https://github.com/YOUR_USERNAME/pneumonia-annotation-tool.git
-git push -u origin main
-```
-
-### Step 2: Deploy on Streamlit Cloud
-
-1. Go to [share.streamlit.io](https://share.streamlit.io)
-2. Sign in with GitHub
-3. Click **New app**
-4. Select:
-   - Repository: `YOUR_USERNAME/pneumonia-annotation-tool`
-   - Branch: `main`
-   - Main file path: `app.py`
-5. Click **Deploy**
-
-🎉 **Your app will be live at**: `https://your-app-name.streamlit.app`
-
----
-
-## 📤 Handling Patient Images
-
-### For Privacy/HIPAA Compliance:
-
-> ⚠️ **NEVER upload real patient data to public cloud services!**
-
-### Options for Images:
-
-| Method | Best For |
-|--------|----------|
-| **File Upload Widget** | Users upload their own images at runtime |
-| **Private Space** | Hugging Face private Spaces (requires Pro) |
-| **Self-hosted** | Run on your own server with patient data |
-| **Sample Images** | Include anonymized/synthetic samples for demo |
-
-### Adding Sample Images for Demo
-
-1. Create `sample_images/` folder in your repo
-2. Add anonymized or synthetic X-ray images
-3. Update the default path:
-
-```python
-patients_path = st.sidebar.text_input(
-    "Patients Folder Path",
-    value="./sample_images",
-)
-```
-
----
-
-## 🔧 Complete Modified `app.py` for Cloud
-
-Here are the key modifications needed for cloud deployment:
-
-### 1. Add imports at the top:
-```python
-import os
-from pathlib import Path
-```
-
-### 2. Replace the patients path section with:
-```python
-# ── Sidebar: patients path ─────────────────────────────────────────
-st.sidebar.header("📁 Patient Data")
-
-# File uploader for cloud deployment
-st.sidebar.subheader("📤 Upload X-rays")
-uploaded_files = st.sidebar.file_uploader(
-    "Upload chest X-ray images",
-    type=["jpg", "jpeg", "png"],
-    accept_multiple_files=True,
-    help="Upload JPG/PNG chest X-ray images to annotate"
-)
-
-# Create upload directory
-upload_dir = Path("./uploaded_images/uploads")
-upload_dir.mkdir(parents=True, exist_ok=True)
-
-if uploaded_files:
-    for uf in uploaded_files:
-        file_path = upload_dir / uf.name
-        with open(file_path, "wb") as f:
-            f.write(uf.getbuffer())
-    st.sidebar.success(f"✅ {len(uploaded_files)} image(s) ready!")
-
-patients_path = st.sidebar.text_input(
-    "Images Folder Path",
-    value="./uploaded_images",
-    help="Folder containing images (or use uploader above)",
-)
-```
-
-### 3. Update `get_all_patient_images` function:
-
-```python
-def get_all_patient_images(base_path):
-    """Scan folders and collect all JPG/PNG images with annotation status."""
-    base = Path(base_path)
-    patient_images = []
-    if not base.exists():
-        return patient_images
-
-    # Get all subdirectories (including 'uploads')
-    folders = [base] + [f for f in base.iterdir() if f.is_dir()]
-    
-    for folder in folders:
-        img_files = sorted(
-            list(folder.glob("*.jpg")) + 
-            list(folder.glob("*.JPG")) +
-            list(folder.glob("*.jpeg")) +
-            list(folder.glob("*.png"))
-        )
-        for img in img_files:
-            if "_mask" in img.name:  # Skip mask files
-                continue
-            mask_path = img.parent / f"{img.stem}_mask.png"
-            meta_path = img.parent / f"{img.stem}_annotation.json"
-            patient_images.append({
-                "patient_id": folder.name,
-                "image_path": img,
-                "image_name": img.name,
-                "mask_path": mask_path,
-                "metadata_path": meta_path,
-                "annotated": mask_path.exists(),
-            })
-    return patient_images
-```
-
----
-
-## 📝 Quick Deployment Checklist
-
-- [ ] Rename `annotation_app.py` → `app.py`
-- [ ] Create `requirements.txt` with `opencv-python-headless`
-- [ ] Create `README.md` with Hugging Face metadata
-- [ ] Add file upload widget for cloud users
-- [ ] Update default paths for cloud environment
-- [ ] Remove/anonymize any patient data
-- [ ] Test locally with `streamlit run app.py`
-- [ ] Push to GitHub or Hugging Face
-- [ ] Verify deployment and check logs
-
----
-
-## 🆘 Troubleshooting
-
-### "No module named cv2"
-→ Use `opencv-python-headless` in requirements.txt
-
-### "Permission denied" errors
-→ Use relative paths (`./uploaded_images`) not absolute paths
-
-### App crashes on large images
-→ Add memory limit handling or resize images on upload
-
-### Slow startup
-→ Reduce dependencies, use `@st.cache_data` for heavy computations
-
----
-
-## 📞 Support
-
-- **Hugging Face Docs**: [huggingface.co/docs/hub/spaces](https://huggingface.co/docs/hub/spaces)
-- **Streamlit Docs**: [docs.streamlit.io](https://docs.streamlit.io)
-- **Streamlit Community**: [discuss.streamlit.io](https://discuss.streamlit.io)
-
----
-
-*Created for the Pneumonia Consolidation Annotation Tool - Hospital Alma Máter*

src/QUICKSTART.md

@@ -1,220 +0,0 @@
-# Quick Start Guide - Get Started in 5 Minutes! ⚡
-
-## For Immediate Testing (No Installation)
-
-If you just want to see what the Dice calculator does:
-
-### Option 1: Test with Sample Data
-```bash
-cd dice/
-
-# Create a simple test mask
-python3 -c "
-import cv2
-import numpy as np
-
-# Create sample image and masks
-img = np.random.randint(0, 255, (512, 512), dtype=np.uint8)
-mask1 = np.zeros((512, 512), dtype=np.uint8)
-mask2 = np.zeros((512, 512), dtype=np.uint8)
-
-# Draw circles as "consolidations"
-cv2.circle(mask1, (250, 250), 80, 255, -1)
-cv2.circle(mask2, (260, 260), 75, 255, -1)  # Slightly different
-
-# Save
-cv2.imwrite('test_image.jpg', img)
-cv2.imwrite('test_gt.png', mask1)
-cv2.imwrite('test_pred.png', mask2)
-
-print('Test files created!')
-"
-```
-
-### Option 2: Use Your Own Data
-If you already have:
-- Chest X-ray image (JPG/PNG)
-- Ground truth mask (JPG/PNG)
-- Predicted mask (JPG/PNG)
-
-Skip to the "Launch App" section below.
-
----
-
-## Full Setup (Recommended)
-
-### 1. Install Dependencies (2 minutes)
-```bash
-cd dice/
-pip install -r requirements.txt
-```
-
-### 2. Launch the Dice Calculator App (30 seconds)
-```bash
-streamlit run dice_calculator_app.py
-```
-
-The app will open in your browser at `http://localhost:8501`
-
-### 3. Upload Your Images
-1. **Original Image**: Upload your chest X-ray
-2. **Ground Truth Mask**: Upload the expert annotation
-3. **Predicted Mask**: Upload the model/algorithm output
-
-You'll instantly see:
-- ✅ Dice coefficient
-- ✅ IoU score
-- ✅ Precision & Recall
-- ✅ Visual overlays (green=GT, red=prediction, yellow=overlap)
-
----
-
-## Common Use Cases
-
-### Use Case 1: "I want to enhance my X-rays first"
-```bash
-# Single image
-python preprocessing_consolidation.py \
-    --input ../data/Pacientes/7035909/7035909_20240326.jpg \
-    --output enhanced_xray.jpg
-
-# All images in a folder
-python preprocessing_consolidation.py \
-    --input ../data/Pacientes/ \
-    --output ./enhanced_images/ \
-    --batch
-```
-
-### Use Case 2: "I want to compare two annotators"
-```bash
-# Launch app
-streamlit run dice_calculator_app.py
-
-# In the app:
-# 1. Upload X-ray as "Original Image"
-# 2. Upload Annotator 1's mask as "Ground Truth"
-# 3. Upload Annotator 2's mask as "Prediction"
-# 
-# Dice > 0.80 = Good agreement
-```
-
-### Use Case 3: "I want automatic segmentation with SAM"
-```bash
-# First, download SAM checkpoint:
-# wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
-
-# Interactive mode (click on consolidation)
-python sam_integration.py \
-    --checkpoint sam_vit_h_4b8939.pth \
-    --image chest_xray.jpg \
-    --mode interactive
-
-# Automatic batch processing
-python sam_integration.py \
-    --checkpoint sam_vit_h_4b8939.pth \
-    --input_dir ../data/Pacientes/ \
-    --output_dir ./sam_masks/ \
-    --mode auto
-```
-
-### Use Case 4: "I want to calculate Dice for many images"
-```bash
-# Use the Streamlit app's "Batch Processing" tab
-# Upload two ZIP files:
-#   1. images.zip (contains all X-rays)
-#   2. masks.zip (contains corresponding masks)
-# 
-# The app will process all pairs and generate CSV report
-```
-
----
-
-## Interpreting Results
-
-### Dice Coefficient
-| Score | Interpretation |
-|-------|---------------|
-| > 0.85 | **Excellent** - Ready for publication |
-| 0.70 - 0.85 | **Good** - Acceptable for fuzzy boundaries |
-| 0.50 - 0.70 | **Fair** - Needs review, may need re-annotation |
-| < 0.50 | **Poor** - Significant disagreement |
-
-### Visual Overlay Colors
-- 🟢 **Green**: Ground truth only (missed by prediction)
-- 🔴 **Red**: Prediction only (false positive)
-- 🟡 **Yellow**: Overlap (correct prediction) ✓
-
-**Goal**: Maximize yellow, minimize green and red
-
----
-
-## Troubleshooting
-
-### "ModuleNotFoundError: No module named 'streamlit'"
-```bash
-pip install streamlit
-```
-
-### "App won't start"
-```bash
-# Check Python version (need 3.8+)
-python --version
-
-# Reinstall dependencies
-pip install --upgrade -r requirements.txt
-
-# Try with full path
-python -m streamlit run dice_calculator_app.py
-```
-
-### "Images are different sizes"
-Don't worry! The app automatically resizes masks to match the image.
-
-### "SAM is too slow"
-- Use smaller model: `--model_type vit_b` instead of `vit_h`
-- Use GPU if available (automatically detected)
-- Process images in smaller batches
-
----
-
-## Next Steps After Quick Start
-
-1. ✅ **You've tested the app** → Read [example_usage.md](example_usage.md)
-2. ✅ **You've calculated some Dice scores** → Check [TODO.md](TODO.md) for project roadmap
-3. ✅ **You're ready to annotate** → See annotation guidelines in [README.md](README.md)
-4. ✅ **You want to train ML** → Use annotations as training data
-
----
-
-## One-Line Commands for Copy-Paste
-
-```bash
-# Install everything
-cd dice && pip install -r requirements.txt
-
-# Launch app
-streamlit run dice_calculator_app.py
-
-# Enhance single image
-python preprocessing_consolidation.py --input xray.jpg --output enhanced.jpg
-
-# Batch enhance
-python preprocessing_consolidation.py --input ../data/Pacientes/ --output ./enhanced/ --batch
-
-# Test with sample data
-python3 -c "import cv2; import numpy as np; img=np.random.randint(0,255,(512,512),dtype=np.uint8); m1=np.zeros((512,512),dtype=np.uint8); m2=np.zeros((512,512),dtype=np.uint8); cv2.circle(m1,(250,250),80,255,-1); cv2.circle(m2,(260,260),75,255,-1); cv2.imwrite('test_image.jpg',img); cv2.imwrite('test_gt.png',m1); cv2.imwrite('test_pred.png',m2); print('Test files created!')"
-```
-
----
-
-## Support
-
-- 📖 **Full Documentation**: [README.md](README.md)
-- 📝 **Examples**: [example_usage.md](example_usage.md)
-- ✅ **Project Plan**: [TODO.md](TODO.md)
-- 💬 **Questions**: Open an issue or contact project lead
-
-**Ready to start? Run this now:**
-```bash
-streamlit run dice_calculator_app.py
-```

src/README.md

@@ -1,291 +0,0 @@
-# Pneumonia Consolidation Segmentation Tools 🫁
-
-A comprehensive toolkit for segmenting pneumonia consolidation in chest X-rays using machine learning, with tools for preprocessing, annotation, and validation using Dice coefficient metrics.
-
-## 📋 Features
-
-### 1. **Dice Score Calculator (Streamlit App)**
-- Interactive web interface for calculating segmentation metrics
-- Compare ground truth vs predicted masks
-- Metrics: Dice coefficient, IoU, Precision, Recall, F1, Hausdorff distance
-- Visual overlays with color-coded comparisons
-- Batch processing support
-- Built-in annotation guidelines
-
-### 2. **Image Preprocessing**
-- CLAHE enhancement for local contrast
-- Sharpening filters to reveal air bronchograms
-- Edge enhancement for consolidation boundaries
-- Batch processing capabilities
-
-### 3. **SAM Integration**
-- Automatic mask generation using Segment Anything Model
-- Interactive point-based segmentation
-- Bounding box prompts
-- Batch processing support
-
-## 🚀 Quick Start
-
-### Installation
-
-```bash
-# Clone or download this repository
-cd dice/
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Optional: For SAM integration
-# pip install segment-anything torch torchvision
-# Download SAM checkpoint from: https://github.com/facebookresearch/segment-anything
-```
-
-### Running the Dice Calculator App
-
-```bash
-streamlit run dice_calculator_app.py
-```
-
-The app will open in your browser at `http://localhost:8501`
-
-## 📖 Usage Guide
-
-### 1. Preprocessing Images
-
-Enhance chest X-rays to better visualize consolidations:
-
-```bash
-# Single image
-python preprocessing_consolidation.py \
-    --input /path/to/image.jpg \
-    --output /path/to/enhanced.jpg
-
-# Batch processing
-python preprocessing_consolidation.py \
-    --input /path/to/images/ \
-    --output /path/to/enhanced/ \
-    --batch \
-    --extension .jpg
-```
-
-### 2. Calculating Dice Scores
-
-#### Using the Streamlit App:
-1. Start the app: `streamlit run dice_calculator_app.py`
-2. Upload your chest X-ray, ground truth mask, and predicted mask
-3. View metrics and visualizations instantly
-4. Download results as CSV or images
-
-#### Programmatic Usage:
-
-```python
-import cv2
-from dice_calculator_app import calculate_dice_coefficient
-
-# Load masks
-ground_truth = cv2.imread('ground_truth_mask.png', cv2.IMREAD_GRAYSCALE)
-prediction = cv2.imread('predicted_mask.png', cv2.IMREAD_GRAYSCALE)
-
-# Calculate Dice
-dice = calculate_dice_coefficient(ground_truth, prediction)
-print(f"Dice Coefficient: {dice:.4f}")
-```
-
-### 3. Using SAM for Automatic Segmentation
-
-First, download a SAM checkpoint:
-- [ViT-H (Huge)](https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth) - Most accurate
-- [ViT-L (Large)](https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth) - Balanced
-- [ViT-B (Base)](https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth) - Fastest
-
-```bash
-# Interactive mode (click points to guide segmentation)
-python sam_integration.py \
-    --checkpoint sam_vit_h_4b8939.pth \
-    --image chest_xray.jpg \
-    --mode interactive
-
-# Automatic batch processing
-python sam_integration.py \
-    --checkpoint sam_vit_h_4b8939.pth \
-    --input_dir /path/to/images/ \
-    --output_dir /path/to/masks/ \
-    --mode auto
-```
-
-## 📊 Understanding the Metrics
-
-### Dice Coefficient (Main Metric)
-- **Range**: 0 (no overlap) to 1 (perfect overlap)
-- **Formula**: `2 × |A ∩ B| / (|A| + |B|)`
-- **Interpretation**:
-  - **> 0.85**: Excellent segmentation
-  - **0.70-0.85**: Good (acceptable for fuzzy consolidation borders)
-  - **< 0.70**: Needs review
-
-### IoU (Jaccard Index)
-- **Range**: 0 to 1
-- **Formula**: `|A ∩ B| / |A ∪ B|`
-- More strict than Dice coefficient
-
-### Precision & Recall
-- **Precision**: How many predicted pixels are correct
-- **Recall**: How many actual consolidation pixels were found
-
-### Hausdorff Distance
-- Measures maximum distance between mask boundaries
-- Lower is better (masks are closer)
-
-## 🎯 Annotation Guidelines
-
-### Key Radiologic Signs
-
-#### 1. **Air Bronchograms** ✓
-- Dark, branching tubes inside white consolidation
-- **100% diagnostic** for pneumonia
-- Include entire surrounding region in mask
-
-#### 2. **Silhouette Sign**
-- Heart or diaphragm border "disappears" into white area
-- Include boundary in segmentation
-
-#### 3. **Border Characteristics**
-- Fuzzy, poorly defined edges
-- Blend into surrounding tissue
-- Use enhanced preprocessing to see better
-
-### Best Practices
-
-✅ **DO:**
-- Trace through ribs mentally
-- Include full air bronchogram regions
-- Use preprocessing to see subtle borders
-- Label different types: solid, ground-glass, air bronchograms
-
-❌ **DON'T:**
-- Include ribs in masks
-- Over-segment into normal lung
-- Miss subtle ground-glass opacities
-
-## 📁 Project Structure
-
-```
-dice/
-├── dice_calculator_app.py          # Main Streamlit application
-├── preprocessing_consolidation.py  # Image enhancement tools
-├── sam_integration.py              # SAM integration
-├── requirements.txt                # Python dependencies
-├── README.md                       # This file
-├── annotations/                    # Store annotation masks (create)
-│   ├── ground_truth/
-│   └── predictions/
-├── enhanced_images/                # Preprocessed images (create)
-└── results/                        # Dice scores and reports (create)
-```
-
-## 🔧 Advanced Configuration
-
-### Streamlit App Settings
-
-In the sidebar:
-- **Overlay Transparency**: Adjust visualization opacity
-- **Calculate Hausdorff Distance**: Enable for boundary distance metrics (slower)
-
-### Preprocessing Parameters
-
-Edit `preprocessing_consolidation.py` to adjust:
-```python
-clahe = cv2.createCLAHE(
-    clipLimit=3.0,      # Increase for more contrast
-    tileGridSize=(8,8)  # Smaller = more local enhancement
-)
-```
-
-### SAM Parameters
-
-In `sam_integration.py`, adjust:
-```python
-# Confidence threshold for automatic detection
-if scores[0] > 0.8:  # Lower = more permissive
-
-# Grid density for automatic sampling
-grid_size = 5  # Increase for finer sampling
-```
-
-## 🔬 Workflow Recommendations
-
-### For Manual Annotation:
-1. **Preprocess** images with `preprocessing_consolidation.py`
-2. **Annotate** in CVAT or Label Studio
-3. **Validate** with Dice calculator app
-4. **Iterate** until Dice > 0.80
-
-### For ML Training:
-1. **Generate initial masks** with SAM
-2. **Refine manually** in annotation tool
-3. **Calculate metrics** to ensure quality
-4. **Use as training data** for your model
-
-### For Validation Study:
-1. Have multiple annotators segment images
-2. Compare annotations using Dice calculator
-3. Calculate inter-rater agreement
-4. Establish ground truth consensus
-
-## 📚 References
-
-### Tools & Models
-- [CVAT](https://github.com/opencv/cvat) - Computer Vision Annotation Tool
-- [SAM](https://github.com/facebookresearch/segment-anything) - Segment Anything Model
-- [Streamlit](https://streamlit.io/) - Web app framework
-
-### Medical Context
-- Air Bronchograms: Air-filled bronchi visible against consolidated lung
-- Silhouette Sign: Loss of normal boundaries due to adjacent opacity
-- Consolidation: Filling of air spaces with fluid/exudate in pneumonia
-
-## 🐛 Troubleshooting
-
-### App won't start
-```bash
-# Check Streamlit installation
-pip install --upgrade streamlit
-
-# Run with verbose logging
-streamlit run dice_calculator_app.py --logger.level=debug
-```
-
-### SAM errors
-```bash
-# Ensure PyTorch is installed
-pip install torch torchvision
-
-# Download correct checkpoint for model type
-# vit_h, vit_l, or vit_b must match checkpoint
-```
-
-### Image size issues
-Images are automatically resized to match. For best results:
-- Use same resolution for all images in a study
-- Minimum 512x512 recommended
-- Maximum 2048x2048 for performance
-
-## 📝 License
-
-This project is for research and educational purposes related to pneumonia diagnosis and medical image segmentation.
-
-## 🤝 Contributing
-
-Contributions welcome! Areas for improvement:
-- Additional metrics (Surface Dice, Boundary IoU)
-- 3D visualization support
-- Integration with DICOM files
-- Multi-class segmentation support
-
-## 📧 Contact
-
-For questions or issues, please open an issue in the repository.
-
----
-
-**Note**: This tool is for research purposes. Always validate with clinical experts and follow appropriate medical imaging guidelines.

src/TODO.md

@@ -1,181 +0,0 @@
-# 📋 TODO List: Pneumonia Consolidation Segmentation Project
-
-## ✅ Completed
-
-- [x] Analyze project structure and patient data format
-- [x] Create preprocessing script for consolidation enhancement
-- [x] Build Streamlit app for Dice score calculation
-- [x] Implement SAM integration for automatic segmentation
-- [x] Create requirements.txt and documentation
-- [x] Setup folder structure for annotations and results
-
-## 🚀 Next Steps (In Order)
-
-### Phase 1: Setup & Data Preparation (Week 1)
-
-1. **Install Dependencies**
-   - [ ] Run `pip install -r requirements.txt`
-   - [ ] Test Streamlit app: `streamlit run dice_calculator_app.py`
-   - [ ] (Optional) Download SAM checkpoint for automatic segmentation
-
-2. **Preprocess Patient Images**
-   - [ ] Enhance all chest X-rays in `data/Pacientes/` folder
-   - [ ] Save enhanced images to `dice/enhanced_images/`
-   - [ ] Review enhanced images for quality
-   - [ ] Document any images with poor quality
-
-3. **Setup Annotation Tool**
-   - [ ] Install CVAT (recommended) or Label Studio
-   - [ ] Import enhanced images into annotation tool
-   - [ ] Create annotation classes: "consolidation", "ground_glass", "air_bronchogram"
-   - [ ] Setup annotation guidelines document for team
-
-### Phase 2: Annotation (Weeks 2-4)
-
-4. **Create Ground Truth Annotations**
-   - [ ] Have 2-3 radiologists independently annotate same 20 images (pilot)
-   - [ ] Calculate inter-rater agreement using Dice scores
-   - [ ] Resolve disagreements through consensus meeting
-   - [ ] Annotate remaining images (aim for 100+ cases)
-   - [ ] Save masks to `dice/annotations/ground_truth/`
-
-5. **Quality Control**
-   - [ ] Use Dice calculator app to validate annotation consistency
-   - [ ] Flag cases with unclear consolidation boundaries
-   - [ ] Re-annotate cases with Dice < 0.70 between annotators
-   - [ ] Document difficult cases and edge cases
-
-### Phase 3: SAM Integration (Week 5)
-
-6. **Test SAM for Automatic Segmentation**
-   - [ ] Download SAM checkpoint (ViT-H recommended)
-   - [ ] Test SAM on 10 sample images
-   - [ ] Compare SAM predictions vs ground truth
-   - [ ] Adjust SAM parameters for best results
-   - [ ] Document SAM performance metrics
-
-7. **Generate Initial Predictions**
-   - [ ] Use SAM to generate masks for all images
-   - [ ] Save to `dice/annotations/predictions/`
-   - [ ] Calculate Dice scores against ground truth
-   - [ ] Identify patterns in SAM failures
-
-### Phase 4: Analysis & Validation (Week 6)
-
-8. **Calculate Comprehensive Metrics**
-   - [ ] Run batch Dice calculation on all mask pairs
-   - [ ] Generate statistical reports (mean, std, distribution)
-   - [ ] Create visualizations (overlays, comparison grids)
-   - [ ] Save results to `dice/results/`
-
-9. **Quality Assessment**
-   - [ ] Categorize segmentations: Excellent (>0.85), Good (0.70-0.85), Needs Review (<0.70)
-   - [ ] Calculate additional metrics: IoU, Precision, Recall, Hausdorff distance
-   - [ ] Generate quality control report
-   - [ ] Document failure modes and edge cases
-
-### Phase 5: ML Model Development (Weeks 7-10)
-
-10. **Train Segmentation Model**
-    - [ ] Split data: 70% train, 15% validation, 15% test
-    - [ ] Choose architecture: U-Net, Attention U-Net, or nnU-Net
-    - [ ] Implement data augmentation pipeline
-    - [ ] Train model on ground truth annotations
-    - [ ] Monitor validation Dice during training
-
-11. **Model Evaluation**
-    - [ ] Test on held-out test set
-    - [ ] Calculate Dice, IoU, and clinical metrics
-    - [ ] Compare to SAM baseline
-    - [ ] Generate prediction visualizations
-    - [ ] Save model checkpoints
-
-### Phase 6: Clinical Validation (Weeks 11-12)
-
-12. **Expert Review**
-    - [ ] Have radiologists review model predictions
-    - [ ] Collect feedback on clinically acceptable performance
-    - [ ] Test on external validation set (if available)
-    - [ ] Document cases where model fails
-
-13. **Final Report**
-    - [ ] Compile all metrics and visualizations
-    - [ ] Write methods section describing workflow
-    - [ ] Create supplemental figures
-    - [ ] Prepare manuscript or technical report
-
-## 🔧 Technical Debt & Improvements
-
-### High Priority
-- [ ] Add DICOM file support (many medical images are DICOM)
-- [ ] Implement multi-class segmentation (consolidation types)
-- [ ] Add data versioning (DVC or similar)
-- [ ] Create automated testing suite
-
-### Medium Priority
-- [ ] Add boundary-based metrics (Surface Dice, Normalized Surface Distance)
-- [ ] Implement active learning workflow
-- [ ] Add export to COCO format for model training
-- [ ] Create Docker container for reproducibility
-
-### Low Priority
-- [ ] Add 3D visualization support
-- [ ] Implement web-based annotation tool
-- [ ] Add integration with PACS systems
-- [ ] Create mobile app for review
-
-## 📊 Success Metrics
-
-### Annotation Phase
-- **Target**: 100+ annotated cases
-- **Quality**: Mean inter-rater Dice > 0.80
-- **Efficiency**: < 5 minutes per case
-
-### ML Model Phase
-- **Performance**: Mean Dice > 0.75 on test set
-- **Comparison**: Better than SAM baseline
-- **Clinical**: 90% of predictions acceptable to radiologists
-
-### Publication
-- **Timeline**: Submit manuscript within 6 months
-- **Target**: Radiology, European Radiology, or similar
-- **Impact**: Tool shared publicly for research use
-
-## 🐛 Known Issues
-
-- [ ] Large images (>2048x2048) may cause memory issues in Streamlit app
-- [ ] SAM requires significant GPU memory (12GB+ recommended)
-- [ ] Batch processing doesn't support progress resumption
-- [ ] Hausdorff distance calculation is slow for large masks
-
-## 📚 Learning Resources Needed
-
-- [ ] CVAT tutorial videos for team
-- [ ] Radiologic signs of pneumonia refresher
-- [ ] SAM usage best practices
-- [ ] Medical image segmentation literature review
-- [ ] Dice coefficient vs IoU interpretation
-
-## 🤝 Team Assignments
-
-- **Radiologist 1**: Lead annotator, quality control
-- **Radiologist 2**: Second annotator, validation
-- **ML Engineer**: Preprocessing, model development
-- **Data Manager**: File organization, data versioning
-- **Project Lead**: Coordination, reporting
-
-## 📅 Timeline Summary
-
-- **Week 1**: Setup and preprocessing
-- **Weeks 2-4**: Ground truth annotation
-- **Week 5**: SAM integration and testing
-- **Week 6**: Metrics and analysis
-- **Weeks 7-10**: ML model development
-- **Weeks 11-12**: Clinical validation
-- **Month 4-6**: Manuscript preparation
-
----
-
-**Last Updated**: February 6, 2026
-**Project Status**: Phase 1 - Setup Complete
-**Next Action**: Install dependencies and test Streamlit app

src/check_mask.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-"""Analyze saved annotation mask for area calculation verification."""
-
-import cv2
-import numpy as np
-from pathlib import Path
-
-mask_path = Path("/Users/alejo/Library/CloudStorage/OneDrive-HospitalAlmaMáter/Validación Humath/data/Pacientes/7035909/7035909_20240326_mask.png")
-orig_path = Path("/Users/alejo/Library/CloudStorage/OneDrive-HospitalAlmaMáter/Validación Humath/data/Pacientes/7035909/7035909_20240326.jpg")
-
-# Load mask
-mask = cv2.imread(str(mask_path), cv2.IMREAD_UNCHANGED)
-orig = cv2.imread(str(orig_path))
-
-print("=" * 50)
-print("MASK ANALYSIS")
-print("=" * 50)
-print(f"Mask shape: {mask.shape}")
-print(f"Mask dtype: {mask.dtype}")
-print(f"Mask min: {mask.min()}, max: {mask.max()}")
-print(f"Unique values (first 10): {np.unique(mask)[:10]}")
-
-print("\n" + "=" * 50)
-print("ORIGINAL IMAGE")
-print("=" * 50)
-print(f"Original shape: {orig.shape}")
-print(f"Dimensions match: {mask.shape[:2] == orig.shape[:2]}")
-
-print("\n" + "=" * 50)
-print("AREA STATISTICS")
-print("=" * 50)
-total_pixels = mask.shape[0] * mask.shape[1]
-annotated_pixels = int(np.sum(mask > 0))
-area_percent = (annotated_pixels / total_pixels) * 100
-
-print(f"Image dimensions: {mask.shape[1]} x {mask.shape[0]} px")
-print(f"Total pixels: {total_pixels:,}")
-print(f"Annotated pixels: {annotated_pixels:,}")
-print(f"Annotated area: {area_percent:.2f}%")
-
-print("\n" + "=" * 50)
-print("VERDICT")
-print("=" * 50)
-if mask.shape[:2] == orig.shape[:2] and annotated_pixels > 0:
-    print("✅ Mask is CORRECT for area calculation!")
-    print("   - Resized to original image dimensions")
-    print("   - Contains valid annotation data")
-else:
-    print("❌ Issues found:")
-    if mask.shape[:2] != orig.shape[:2]:
-        print("   - Mask dimensions don't match original")
-    if annotated_pixels == 0:
-        print("   - No annotated pixels found")

src/dice_calculator_app.py

@@ -1,692 +0,0 @@
-"""
-Streamlit App for Pneumonia Consolidation Ground Truth Annotation
-
-This app allows radiologists to:
-1. Load and view chest X-ray images with enhancement
-2. Create segmentation masks using drawing tools
-3. Save ground truth annotations
-4. Compare annotations between radiologists (inter-rater agreement)
-5. Export annotations for ML training
-"""
-
-import streamlit as st
-import cv2
-import numpy as np
-from PIL import Image
-import pandas as pd
-from pathlib import Path
-import io
-import zipfile
-import json
-from datetime import datetime
-from streamlit_drawable_canvas import st_canvas
-
-
-def calculate_dice_coefficient(mask1, mask2):
-    """
-    Calculate Dice coefficient between two binary masks.
-    
-    Dice = 2 * |A ∩ B| / (|A| + |B|)
-    
-    Args:
-        mask1: First binary mask (numpy array)
-        mask2: Second binary mask (numpy array)
-        
-    Returns:
-        Dice coefficient (float between 0 and 1)
-    """
-    # Ensure masks are binary
-    mask1 = (mask1 > 0).astype(np.uint8)
-    mask2 = (mask2 > 0).astype(np.uint8)
-    
-    # Calculate intersection and union
-    intersection = np.sum(mask1 * mask2)
-    mask1_sum = np.sum(mask1)
-    mask2_sum = np.sum(mask2)
-    
-    # Handle edge case where both masks are empty
-    if mask1_sum + mask2_sum == 0:
-        return 1.0
-    
-    dice = (2.0 * intersection) / (mask1_sum + mask2_sum)
-    return dice
-
-
-def calculate_iou(mask1, mask2):
-    """
-    Calculate Intersection over Union (IoU / Jaccard Index).
-    
-    IoU = |A ∩ B| / |A ∪ B|
-    """
-    mask1 = (mask1 > 0).astype(np.uint8)
-    mask2 = (mask2 > 0).astype(np.uint8)
-    
-    intersection = np.sum(mask1 * mask2)
-    union = np.sum(mask1) + np.sum(mask2) - intersection
-    
-    if union == 0:
-        return 1.0
-    
-    return intersection / union
-
-
-def calculate_precision_recall(ground_truth, prediction):
-    """
-    Calculate precision and recall for segmentation.
-    
-    Precision = TP / (TP + FP)
-    Recall = TP / (TP + FN)
-    """
-    gt = (ground_truth > 0).astype(np.uint8)
-    pred = (prediction > 0).astype(np.uint8)
-    
-    tp = np.sum(gt * pred)
-    fp = np.sum((1 - gt) * pred)
-    fn = np.sum(gt * (1 - pred))
-    
-    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
-    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
-    
-    return precision, recall
-
-
-def calculate_hausdorff_distance(mask1, mask2):
-    """
-    Calculate Hausdorff distance between two masks.
-    Measures the maximum distance from a point in one set to the closest point in the other set.
-    """
-    from scipy.spatial.distance import directed_hausdorff
-    
-    # Get coordinates of mask pixels
-    coords1 = np.argwhere(mask1 > 0)
-    coords2 = np.argwhere(mask2 > 0)
-    
-    if len(coords1) == 0 or len(coords2) == 0:
-        return float('inf')
-    
-    # Calculate directed Hausdorff distances
-    d1 = directed_hausdorff(coords1, coords2)[0]
-    d2 = directed_hausdorff(coords2, coords1)[0]
-    
-    # Return maximum
-    return max(d1, d2)
-
-
-def create_overlay_visualization(image, ground_truth, prediction, alpha=0.5):
-    """
-    Create visualization with ground truth (green) and prediction (red) overlaid.
-    Overlap areas appear in yellow.
-    """
-    # Convert to RGB if grayscale
-    if len(image.shape) == 2:
-        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    
-    # Normalize image to 0-255 range
-    if image.dtype != np.uint8:
-        image = ((image - image.min()) / (image.max() - image.min()) * 255).astype(np.uint8)
-    
-    # Create colored masks
-    overlay = image.copy()
-    
-    # Ground truth in green
-    gt_mask = (ground_truth > 0)
-    overlay[gt_mask] = overlay[gt_mask] * (1 - alpha) + np.array([0, 255, 0]) * alpha
-    
-    # Prediction in red
-    pred_mask = (prediction > 0)
-    overlay[pred_mask] = overlay[pred_mask] * (1 - alpha) + np.array([255, 0, 0]) * alpha
-    
-    # Overlap in yellow (green + red)
-    overlap = gt_mask & pred_mask
-    overlay[overlap] = overlay[overlap] * (1 - alpha) + np.array([255, 255, 0]) * alpha
-    
-    return overlay.astype(np.uint8)
-
-
-def create_comparison_grid(image, ground_truth, prediction, overlay):
-    """
-    Create a 2x2 grid showing all visualizations.
-    """
-    # Ensure all images are the same size and RGB
-    h, w = image.shape[:2]
-    
-    # Convert masks to RGB
-    gt_rgb = cv2.cvtColor((ground_truth * 255).astype(np.uint8), cv2.COLOR_GRAY2RGB)
-    pred_rgb = cv2.cvtColor((prediction * 255).astype(np.uint8), cv2.COLOR_GRAY2RGB)
-    
-    if len(image.shape) == 2:
-        image_rgb = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    else:
-        image_rgb = image
-    
-    # Create grid
-    top_row = np.hstack([image_rgb, gt_rgb])
-    bottom_row = np.hstack([pred_rgb, overlay])
-    grid = np.vstack([top_row, bottom_row])
-    
-    # Add labels
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    font_scale = 0.7
-    thickness = 2
-    color = (255, 255, 255)
-    
-    cv2.putText(grid, 'Original', (10, 30), font, font_scale, color, thickness)
-    cv2.putText(grid, 'Ground Truth', (w + 10, 30), font, font_scale, color, thickness)
-    cv2.putText(grid, 'Prediction', (10, h + 30), font, font_scale, color, thickness)
-    cv2.putText(grid, 'Overlay', (w + 10, h + 30), font, font_scale, color, thickness)
-    
-    return grid
-
-
-def load_image(uploaded_file):
-    """Load and convert uploaded image to numpy array."""
-    image = Image.open(uploaded_file)
-    load_and_enhance_image(uploaded_file, enhance=True):
-    """Load image and optionally apply enhancement for better visualization."""
-    image = Image.open(uploaded_file)
-    img_array = np.array(image)
-    
-    # Convert to grayscale if needed
-    if len(img_array.shape) == 3:
-        img_gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-    else:
-        img_gray = img_array
-    
-    if enhance:
-        # Apply CLAHE enhancement
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
-        enhanced = clahe.apply(img_gray)
-        
-        # Sharpening
-        kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
-        enhanced = cv2.filter2D(enhanced, -1, kernel)
-        
-        return enhanced
-    
-    return img_gray
-
-
-def save_annotation(image_name, mask, annotator_name, notes=""):
-    """Save annotation with metadata."""
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    # Create annotations directory
-    annotations_dir = Path("annotations/ground_truth")
-    annotations_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Save mask
-    mask_filename = f"{Path(image_name).stem}_{annotator_name}_{timestamp}.png"
-    mask_path = annotations_dir / mask_filename
-    cv2.imwrite(str(mask_path), mask)
-    
-    # Save metadata
-    metadata = {
-        "image_name": image_name,
-        "annotator": annotator_name,
-        "timestamp": timestamp,
-        "notes": notes,
-        "mask_file": mask_filename
-    }
-    
-    metadata_path = annotations_dir / f"{Path(image_name).stem}_{annotator_name}_{timestamp}.json"
-    with open(metadata_path, 'w') as f:
-        json.dump(metadata, f, indent=2)
-    
-    return mask_path, metadata_path
-
-
-def load_existing_annotations(image_name):
-    """Load all existing annotations for an image."""
-    annotations_dir = Path("annotations/ground_truth")
-    if not annotations_dir.exists():
-        return []
-    
-    image_stem = Path(image_name).stem
-    annotations = []
-    
-    for mask_file in annotations_dir.glob(f"{image_stem}_*.png"):
-        # Find corresponding metadata
-        json_file = mask_file.with_suffix('.json')
-        if json_file.exists():
-            with open(json_file, 'r') as f:
-                metadata = json.load(f)
-                mask = cv2.imread(str(mask_file), cv2.IMREAD_GRAYSCALE)
-                annotations.append({
-                    'mask': mask,
-                    'metadata': metadata,
-                    'file': mask_file
-                })
-    
-    return annotations
-
-
-def main():
-    st.set_page_config(
-        page_title="Ground Truth Annotation Tool - Pneumonia",
-        page_icon="🫁",
-        layout="wide"
-    )
-    
-    st.title("🫁 Pneumonia Consolidation Ground Truth Annotation Tool")
-    st.markdown("""
-    ### For Radiologists - Create Expert Annotations
-    
-    This tool helps you create high-quality ground truth segmentation masks for pneumonia consolidation.
-    
-    **Workflow:**
-    1. 📁 Load a chest X-ray image
-    2. 🎨 Draw consolidation masks using the annotation tools
-    3. 💾 Save your annotation with notes
-    4. 🔄 Compare with other radiologists' annotations (optional
-    - 🟢 Green: Ground Truth
-    - 🔴 Red: Prediction
-    - 🟡 Yellow: Overlap (correct prediction)
-    """)
-    
-    # Sidebar for settings
-    st.sidebar.header("👤 Annotator Information")
-    annotator_name = st.sidebar.text_input("Your Name/ID", value="Radiologist1", 
-                                           help="Enter your name or ID for tracking")
-    
-    st.sidebar.header("🎨 Annotation Settings")
-    stroke_width = st.sidebar.slider("Brush Size", 1, 50, 10)
-    stroke_color = st.sidebar.color_picker("Drawing Color", "#FFFF00")
-    
-    st.sidebar.header("🖼️ Display Settings")
-    enhast.header("📋 Create New Annotation")
-        
-        # File upload
-        uploaded_file = st.file_uploader(
-            "Upload Chest X-ray Image (JPG/PNG)", 
-            type=['jpg', 'jpeg', 'png'],
-            key='xray_upload'
-        )
-        
-        with col3:
-            st.subheader("Predicted Mask")
-            prediction_file = st.file_uploader(
-                "Upload Prediction Mask", 
-                type=['jpg', 'jpeg', 'png'],
-                key='prediction'
-            )
-        
-        if original_file and ground_truth_file and prediction_file:
-            # Load and process image
-            img_array = load_and_enhance_image(uploaded_file, enhance=enhance_image)
-            
-            # Display image info
-            st.info(f"📸 Image: {uploaded_file.name} | Size: {img_array.shape[1]}x{img_array.shape[0]} pixels")
-            
-            # Check for existing annotations
-            existing_annotations = load_existing_annotations(uploaded_file.name)
-            if existing_annotations:
-                st.warning(f"⚠️ Found {len(existing_annotations)} existing annotation(s) for this image")
-                if st.checkbox("Load previous annotation to edit"):
-                    selected_annotation = st.selectbox(
-                        "Select annotation to load",
-                        range(len(existing_annotations)),
-                        format_func=lambda i: f"{existing_annotations[i]['metadata']['annotator']} - {existing_annotations[i]['metadata']['timestamp']}"
-                    )
-                    # Load the selected mask as initial drawing
-                    initial_mask = existing_annotations[selected_annotation]['mask']
-                else:
-                    initial_mask = None
-            else:
-                initial_mask = None
-            
-            # Annotation interface
-            col1, col2 = st.columns([2, 1])
-            
-            with col1:
-                st.subheader("🎨 Draw Consolidation Mask")
-                
-                if show_guidelines:
-                    st.info("""
-                    **Quick Tips:**
-                    - ✅ Include air bronchograms (dark tubes in white area)
-                    - ✅ Trace where heart/diaphragm border disappears
-                    - ❌ Don't include ribs in mask
-                    - Use eraser to refine fuzzy borders
-                    """)
-                
-                # Convert image to RGB for canvas
-                img_rgb = cv2.cvtColor(img_array, cv2.COLOR_GRAY2RGB)
-                
-                # Drawing canvas
-                canvas_result = st_canvas(
-                    fill_color="rgba(255, 255, 0, 0.3)",
-                    stroke_width=stroke_width,
-                    stroke_color=stroke_color,
-                    background_image=Image.fromarray(img_rgb),
-                    update_streamlit=True,
-                    height=img_array.shape[0],
-                    width=img_array.shape[1],
-                    drawing_mode="freedraw",
-                    initial_drawing=initial_mask,
-                    key="canvas",
-                )
-            
-            with col2:
-                st.subheader("📝 Annotation Details")
-                
-                # Consolidation characteristics
-                st.write("**Consolidation Type:**")
-                consolidation_type = st.multiselect(
-                    "Select all that apply",
-                    ["Solid Consolidation", "Ground Glass Opacity", "Air Bronchograms", "Pleural Effusion"],
-                    default=["Solid Consolidation"]
-                )
-                
-                # Location
-                location = st.selectbox(
-                    "Location",
-                    ["Right Upper Lobe", "Right Middle Lobe", "Right Lower Lobe",
-                     "Left Upper Lobe", "Left Lower Lobe", "Bilateral", "Other"]
-                )
-                
-                # Confidence
-                confidence = st.slider("Annotation Confidence", 1, 5, 5,
-                                     help="How confident are you in this segmentation?")
-                
-                # Notes
-                notes = st.text_area(
-                    "Clinical Notes (optional)",
-                    placeholder="E.g., 'Silhouette sign present with right heart border'"
-                )
-                
-                # Statistics
-                if canvas_result.image_data is not None:
-                    mask = canvas_result.image_data[:, :, 3] > 0
-                    mask_area = np.sum(mask)
-                    total_area = mask.shape[0] * mask.shape[1]
-                    percentage = (mask_area / total_area) * 100
-                    
-                    st.metric("Annotated Area", f"{mask_area} px²")
-                    st.metric("Coverage", f"{percentage:.2f}%")
-            
-            # Save annotation
-            st.divider()
-            
-            col1, col2, col3 = st.columns([1, 1, 2])
-            
-            with col1:
-                if st.button("💾 Save Annotation", type="primary", use_container_width=True):
-                    if canvas_result.image_data is not None:
-                        # Extract mask from canvas
-                        mask = canvas_result.image_data[:, :, 3]
-                        
-                        # Create metadata
-                        full_notes = {
-                            "consolidation_type": consolidation_type,
-                            "location": location,
-                            "confidence": confidence,
-                            "clinical_notes": notes
-                        }
-                        
-                        # Save
-                        mask_path, metadata_path = save_annotation(
-                            uploaded_file.name,
-                            mask,
-                            annotator_name,
-                            json.dumps(full_notes)
-                        )
-                        
-                        st.success(f"✅ Annotation saved!\n- Mask: {mask_path.name}\n- Metadata: {metadata_path.name}")
-                    else:
-                        st.error("❌ No annotation drawn yet!")
-            
-            with col2:
-                if st.button("🗑️ Clear Canvas", use_container_width=True):
-                    st.rerun()
-            
-            with col3:
-                if canvas_result.image_data is not None:
-                    # Download current mask
-                    mask = canvas_result.image_data[:, :, 3]
-                    mask_pil = Image.fromarray(mask)
-                    buf = io.BytesIO()
-                    mask_pil.save(buf, format='PNG')
-                    
-                    st.download_button(
-                        label="⬇️ Download Current Mask",
-                        data=buf.getvalue(),
-                        file_name=f"{Path(uploaded_file.name).stem}_mask_{annotator_name}.png",
-                        mime="image/png",
-                        use_container_width=True
-                    )
-    
-    with tab2:
-        st.header("🔄 Compare Annotations Between Radiologists")
-        st.markdown("Calculate inter-rater agreement (Dice coefficient) between two radiologists' annotations of the same image.")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.subheader("Radiologist 1 Annotation")
-            mask1_file = st.file_uploader("Upload Mask 1", type=['png', 'jpg'], key='compare_mask1')
-            annotator1 = st.text_input("Annotator 1 Name", value="Radiologist 1")
-        
-        with col2:
-            st.subheader("Radiologist 2 Annotation")
-            mask2_file = st.file_uploader("Upload Mask 2", type=['png', 'jpg'], key='compare_mask2')
-            annotator2 = st.text_input("Annotator 2 Name", value="Radiologist 2")
-        
-        if mask1_file and mask2_file:
-            mask1 = cv2.imread(io.BytesIO(mask1_file.read()), cv2.IMREAD_GRAYSCALE) if isinstance(mask1_file, st.runtime.uploaded_file_manager.UploadedFile) else cv2.imdecode(np.frombuffer(mask1_file.read(), np.uint8), cv2.IMREAD_GRAYSCALE)
-            mask2 = cv2.imread(io.BytesIO(mask2_file.read()), cv2.IMREAD_GRAYSCALE) if isinstance(mask2_file, st.runtime.uploaded_file_manager.UploadedFile) else cv2.imdecode(np.frombuffer(mask2_file.read(), np.uint8), cv2.IMREAD_GRAYSCALE)
-            
-            mask1_file.seek(0)
-            mask2_file.seek(0)
-            mask1 = cv2.imdecode(np.frombuffer(mask1_file.read(), np.uint8), cv2.IMREAD_GRAYSCALE)
-            mask1_file.seek(0)
-            mask2_file.seek(0)
-            mask2 = cv2.imdecode(np.frombuffer(mask2_file.read(), np.uint8), cv2.IMREAD_GRAYSCALE)
-            mask2_file.seek(0)
-            
-            # Resize if needed
-            if mask1.shape != mask2.shape:
-                mask2 = cv2.resize(mask2, (mask1.shape[1], mask1.shape[0]))
-            
-            # Calculate agreement metrics
-            dice = calculate_dice_coefficient(mask1, mask2)
-            iou = calculate_iou(mask1, mask2)
-            precision, recall = calculate_precision_recall(mask1, mask2)
-            
-            # Display metrics
-            st.subheader("📊 Inter-Rater Agreement")
-            
-            cols = st.columns(4)
-            with cols[0]:
-                st.metric("Dice Coefficient", f"{dice:.4f}")
-            with cols[1]:
-                st.metric("IoU", f"{iou:.4f}")
-            with cols[2]:
-                st.metric("Precision", f"{precision:.4f}")
-            with cols[3]:
-                st.metric("Recall", f"{recall:.4f}")
-            
-            # Interpretation
-            if dice >= 0.80:
-                st.success("✅ **Excellent Agreement** - Annotations are highly consistent")
-            elif dice >= 0.70:
-                st.info("ℹ️ **Good Agreement** - Acceptable consistency, may need minor discussion")
-            elif dice >= 0.50:
-                st.warning("⚠️ **Fair Agreement** - Significant differences, recommend consensus review")
-            else:
-                st.error("❌ **Poor Agreement** - Major differences, requires discussion and re-annotation")
-            
-            # Visual comparison
-            st.subheader("🖼️ Visual Comparison")
-            
-            # Create overlay: Annotator1=green, Annotator2=red, Overlap=yellow
-            overlay = np.zeros((mask1.shape[0], mask1.shape[1], 3), dtype=np.uint8)
-            overlay[mask1 > 0] = [0, 255, 0]  # Green for annotator 1
-            overlap = (mask1 > 0) & (mask2 > 0)
-            overlay[mask2 > 0] = [255, 0, 0]  # Red for annotator 2
-            overlay[overlap] = [255, 255, 0]  # Yellow for agreement
-            
-            st.image(overlay, caption=f"Green: {annotator1} only | Red: {annotator2} only | Yellow: Agreement", use_container_width=True)
-            
-            # Area statistics
-            st.subheader("📐 Area Statistics")
-            area1 = np.sum(mask1 > 0)
-            area2 = np.sum(mask2 > 0)
-            overlap_area = np.sum(overlap)
-            
-            data = {
-                'Annotator': [annotator1, annotator2, 'Overlap'],
-                'Area (pixels)': [area1, area2, overlap_area],
-                'Percentage': [100, (area2/area1)*100, (overlap_area/area1)*100]
-            }
-            df = pd.DataFrame(data)
-            st.dataframe(df, use_container_width=True)
-    
-    with tab3:
-        st.header("📚 Browse Existing Annotations")
-        
-        annotations_dir = Path("annotations/ground_truth")
-        if annotations_dir.exists():
-            all_annotations = list(annotations_dir.glob("*.json"))
-            
-            if all_annotations:
-                st.info(f"Found {len(all_annotations)} annotation(s)")
-                
-                # Group by image
-                annotations_by_image = {}
-                for json_file in all_annotations:
-                    with open(json_file, 'r') as f:
-                        metadata = json.load(f)
-                        image_name = metadata['image_name']
-                        if image_name not in annotations_by_image:
-                            annotations_by_image[image_name] = []
-                        annotations_by_image[image_name].append(metadata)
-                
-                # Display selector
-                selected_image = st.selectbox("Select Image", list(annotations_by_image.keys()))
-                
-                if selected_image:
-                    st.subheader(f"Annotations for: {selected_image}")
-                    
-                    annotations = annotations_by_image[selected_image]
-                    
-                    # Display as table
-                    df_data = []
-                    for ann in annotations:
-                        df_data.append({
-                            'Annotator': ann['annotator'],
-                            'Timestamp': ann['timestamp'],
-                            'Mask File': ann['mask_file']
-                        })
-                    
-                    df = pd.DataFrame(df_data)
-                    st.dataframe(df, use_container_width=True)
-                    
-                    # Show masks
-                    cols = st.columns(min(len(annotations), 3))
-                    for idx, ann in enumerate(annotations):
-                        mask_path = annotations_dir / ann['mask_file']
-                        if mask_path.exists():
-                            mask = cv2.imread(str(mask_path), cv2.IMREAD_GRAYSCALE)
-                            with cols[idx % 3]:
-                                st.image(mask, caption=f"{ann['annotator']}", use_container_width=True)
-                    
-                    # Export options
-                    st.divider()
-                    st.subheader("📦 Export Annotations")
-                    
-                    if st.button("Export All Annotations as ZIP"):
-                        # Create ZIP file
-                        zip_buffer = io.BytesIO()
-                        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-                            for ann in annotations:
-                                mask_file = annotations_dir / ann['mask_file']
-                                json_file = annotations_dir / f"{Path(ann['mask_file']).stem}.json"
-                                
-                                if mask_file.exists():
-                                    zip_file.write(mask_file, mask_file.name)
-                                if json_file.exists():
-                                    zip_file.write(json_file, json_file.name)
-                        
-                        st.download_button(
-                            label="⬇️ Download ZIP",
-                            data=zip_buffer.getvalue(),
-                            file_name=f"annotations_{selected_image.replace('.', '_')}.zip",
-                            mime="application/zip"
-                        )
-            else:
-                st.warning("No annotations found. Create your first annotation in the 'Annotate' tab!")
-        else:
-            st.warning("Annotations directory not found. Create your first annotation to get started!")
-    
-    with tab4:
-        st.markdown("""
-        ## 📋 Annotation Guidelines for Pneumonia Consolidation
-        
-        ### What is Pneumonia Consolidation?
-        Pneumonia consolidation appears as white/opaque areas in the lung fields on chest X-rays. 
-        It represents areas where the air spaces are filled with fluid, pus, or cellular debris.
-        
-        ### Key Radiologic Signs to Look For:
-        
-        #### 1. **Air Bronchograms** ✓
-        - Dark, branching tubes visible inside white consolidation
-        - **100% diagnostic for consolidation**
-        - Include entire region surrounding these patterns in your mask
-        
-        #### 2. **Silhouette Sign**
-        - Heart or diaphragm border "disappears" into white area
-        - Indicates consolidation is touching that structure
-        - Include this boundary in your segmentation
-        
-        #### 3. **Border Characteristics**
-        - Consolidations have "fuzzy" or poorly defined borders
-        - Often blend into surrounding lung tissue
-        - Use the enhanced preprocessing images to see borders better
-        
-        ### Annotation Best Practices:
-        
-        1. **Use Polygon Tool First**
-           - Trace rough outline of consolidation
-           - Don't worry about perfect edges initially
-        
-        2. **Refine with Brush Tool**
-           - Clean up edges where consolidation fades
-           - Use eraser for areas that are too included
-        
-        3. **Avoid Common Mistakes**
-           - ❌ Don't include ribs in the mask
-           - ❌ Don't over-segment into normal lung
-           - ❌ Don't miss subtle ground-glass opacities at edges
-           - ✓ Do trace "through" ribs mentally
-           - ✓ Do include the full air bronchogram region
-        
-        4. **Different Types to Label**
-           - **Solid Consolidation**: Dense white areas
-           - **Ground Glass Opacity**: Subtle hazy areas
-           - **Air Bronchograms**: The pattern itself confirms consolidation
-        
-        ### Quality Metrics Interpretation:
-        
-        - **Dice > 0.85**: Excellent segmentation
-        - **Dice 0.70-0.85**: Good segmentation (acceptable for fuzzy borders)
-        - **Dice < 0.70**: Needs review (may have missed area or over-segmented)
-        
-        ### Tips for Difficult Cases:
-        
-        1. **Behind Ribs**: Mentally interpolate the consolidation boundary through rib shadows
-        2. **Near Heart**: Use silhouette sign - if heart border disappears, include that area
-        3. **Multiple Patches**: Each separate consolidation should be in the same mask
-        4. **Pleural Effusion vs Consolidation**: Effusion is smooth with meniscus; consolidation is irregular
-        """)
-        
-        st.info("""
-        **Recommended Workflow:**
-        1. Preprocess image with enhancement script
-        2. Annotate in CVAT or similar tool
-        3. Use this app to validate against expert annotations
-        4. Iterate until Dice > 0.80
-        """)
-
-
-if __name__ == "__main__":
-    main()

src/example_usage.md

@@ -1,389 +0,0 @@
-# Example Usage - Pneumonia Consolidation Segmentation
-
-This notebook demonstrates how to use the pneumonia consolidation segmentation tools.
-
-## Setup
-
-```python
-import sys
-import cv2
-import numpy as np
-from pathlib import Path
-import matplotlib.pyplot as plt
-
-# Add parent directory to path
-sys.path.append('..')
-
-# Import our modules
-from preprocessing_consolidation import enhance_consolidation
-from dice_calculator_app import (
-    calculate_dice_coefficient, 
-    calculate_iou,
-    calculate_precision_recall,
-    create_overlay_visualization
-)
-```
-
-## 1. Preprocessing Images
-
-### Enhance a single image to see consolidation better
-
-```python
-# Path to your chest X-ray
-input_image = "../data/Pacientes/7035909/7035909_20240326.jpg"
-output_image = "../dice/enhanced_images/7035909_enhanced.jpg"
-
-# Enhance the image
-enhanced = enhance_consolidation(input_image, output_image)
-
-# Visualize comparison
-fig, axes = plt.subplots(1, 2, figsize=(12, 6))
-
-original = cv2.imread(input_image, cv2.IMREAD_GRAYSCALE)
-axes[0].imshow(original, cmap='gray')
-axes[0].set_title('Original X-ray')
-axes[0].axis('off')
-
-axes[1].imshow(enhanced, cmap='gray')
-axes[1].set_title('Enhanced (CLAHE + Sharpening)')
-axes[1].axis('off')
-
-plt.tight_layout()
-plt.show()
-```
-
-### Batch process multiple images
-
-```python
-from preprocessing_consolidation import batch_enhance_consolidation
-
-# Process all patient images
-input_dir = "../data/Pacientes/"
-output_dir = "../dice/enhanced_images/"
-
-batch_enhance_consolidation(input_dir, output_dir, image_extension='.jpg')
-```
-
-## 2. Create Sample Masks for Testing
-
-Let's create some sample masks to demonstrate the Dice calculation.
-
-```python
-def create_sample_masks(image_path):
-    """Create sample ground truth and prediction masks for demo."""
-    
-    # Load image
-    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
-    h, w = img.shape
-    
-    # Create ground truth mask (simulated consolidation in lower right lung)
-    ground_truth = np.zeros((h, w), dtype=np.uint8)
-    center_y, center_x = int(h * 0.6), int(w * 0.7)
-    
-    # Create irregular shape for consolidation
-    for i in range(h):
-        for j in range(w):
-            dist = np.sqrt((i - center_y)**2 + (j - center_x)**2)
-            noise = np.random.randn() * 20
-            if dist + noise < 80:
-                ground_truth[i, j] = 255
-    
-    # Create predicted mask (similar but slightly different)
-    prediction = np.zeros((h, w), dtype=np.uint8)
-    center_y_pred = int(h * 0.58)  # Slightly shifted
-    center_x_pred = int(w * 0.72)
-    
-    for i in range(h):
-        for j in range(w):
-            dist = np.sqrt((i - center_y_pred)**2 + (j - center_x_pred)**2)
-            noise = np.random.randn() * 25
-            if dist + noise < 75:  # Slightly smaller
-                prediction[i, j] = 255
-    
-    return ground_truth, prediction
-
-# Create sample masks
-image_path = "../data/Pacientes/7035909/7035909_20240326.jpg"
-gt_mask, pred_mask = create_sample_masks(image_path)
-
-# Save masks
-cv2.imwrite("../dice/annotations/ground_truth/sample_gt.png", gt_mask)
-cv2.imwrite("../dice/annotations/predictions/sample_pred.png", pred_mask)
-
-print("Sample masks created!")
-```
-
-## 3. Calculate Dice Coefficient
-
-```python
-# Load masks
-ground_truth = cv2.imread("../dice/annotations/ground_truth/sample_gt.png", cv2.IMREAD_GRAYSCALE)
-prediction = cv2.imread("../dice/annotations/predictions/sample_pred.png", cv2.IMREAD_GRAYSCALE)
-
-# Calculate metrics
-dice = calculate_dice_coefficient(ground_truth, prediction)
-iou = calculate_iou(ground_truth, prediction)
-precision, recall = calculate_precision_recall(ground_truth, prediction)
-f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
-
-print("Segmentation Metrics:")
-print(f"  Dice Coefficient: {dice:.4f}")
-print(f"  IoU (Jaccard):    {iou:.4f}")
-print(f"  Precision:        {precision:.4f}")
-print(f"  Recall:           {recall:.4f}")
-print(f"  F1 Score:         {f1:.4f}")
-
-# Interpretation
-if dice > 0.85:
-    quality = "Excellent ✓"
-elif dice > 0.70:
-    quality = "Good (acceptable for fuzzy borders)"
-else:
-    quality = "Needs review"
-    
-print(f"\nQuality Assessment: {quality}")
-```
-
-## 4. Visualize Results
-
-```python
-# Load original image
-original = cv2.imread(image_path)
-
-# Create overlay visualization
-overlay = create_overlay_visualization(original, ground_truth, prediction, alpha=0.5)
-
-# Display all views
-fig, axes = plt.subplots(2, 2, figsize=(12, 12))
-
-axes[0, 0].imshow(cv2.cvtColor(original, cv2.COLOR_BGR2RGB))
-axes[0, 0].set_title('Original X-ray')
-axes[0, 0].axis('off')
-
-axes[0, 1].imshow(ground_truth, cmap='Greens')
-axes[0, 1].set_title('Ground Truth Mask')
-axes[0, 1].axis('off')
-
-axes[1, 0].imshow(prediction, cmap='Reds')
-axes[1, 0].set_title('Predicted Mask')
-axes[1, 0].axis('off')
-
-axes[1, 1].imshow(overlay)
-axes[1, 1].set_title(f'Overlay (Dice: {dice:.3f})')
-axes[1, 1].axis('off')
-
-# Add legend
-legend_elements = [
-    plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='g', markersize=10, label='Ground Truth'),
-    plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='r', markersize=10, label='Prediction'),
-    plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='y', markersize=10, label='Overlap')
-]
-axes[1, 1].legend(handles=legend_elements, loc='upper right')
-
-plt.tight_layout()
-plt.savefig('../dice/results/example_visualization.png', dpi=150, bbox_inches='tight')
-plt.show()
-
-print("Visualization saved to: dice/results/example_visualization.png")
-```
-
-## 5. Batch Calculate Dice Scores
-
-Process multiple mask pairs and generate report.
-
-```python
-import pandas as pd
-from pathlib import Path
-
-def batch_calculate_dice(gt_dir, pred_dir, results_file):
-    """Calculate Dice for all mask pairs in directories."""
-    
-    gt_dir = Path(gt_dir)
-    pred_dir = Path(pred_dir)
-    
-    results = []
-    
-    # Find all ground truth masks
-    gt_masks = list(gt_dir.glob("*.png")) + list(gt_dir.glob("*.jpg"))
-    
-    for gt_path in gt_masks:
-        # Find corresponding prediction
-        pred_path = pred_dir / gt_path.name
-        
-        if not pred_path.exists():
-            print(f"Warning: No prediction found for {gt_path.name}")
-            continue
-        
-        # Load masks
-        gt = cv2.imread(str(gt_path), cv2.IMREAD_GRAYSCALE)
-        pred = cv2.imread(str(pred_path), cv2.IMREAD_GRAYSCALE)
-        
-        # Calculate metrics
-        dice = calculate_dice_coefficient(gt, pred)
-        iou = calculate_iou(gt, pred)
-        precision, recall = calculate_precision_recall(gt, pred)
-        f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
-        
-        results.append({
-            'Image': gt_path.name,
-            'Dice': dice,
-            'IoU': iou,
-            'Precision': precision,
-            'Recall': recall,
-            'F1': f1
-        })
-        
-        print(f"Processed: {gt_path.name} - Dice: {dice:.4f}")
-    
-    # Create DataFrame
-    df = pd.DataFrame(results)
-    
-    # Calculate summary statistics
-    summary = {
-        'Metric': ['Mean', 'Std', 'Min', 'Max', 'Median'],
-        'Dice': [
-            df['Dice'].mean(),
-            df['Dice'].std(),
-            df['Dice'].min(),
-            df['Dice'].max(),
-            df['Dice'].median()
-        ]
-    }
-    
-    summary_df = pd.DataFrame(summary)
-    
-    # Save results
-    with pd.ExcelWriter(results_file, engine='openpyxl') as writer:
-        df.to_excel(writer, sheet_name='Individual Results', index=False)
-        summary_df.to_excel(writer, sheet_name='Summary', index=False)
-    
-    print(f"\nResults saved to: {results_file}")
-    print("\nSummary Statistics:")
-    print(summary_df.to_string(index=False))
-    
-    return df, summary_df
-
-# Run batch processing
-gt_directory = "../dice/annotations/ground_truth/"
-pred_directory = "../dice/annotations/predictions/"
-results_excel = "../dice/results/dice_scores_report.xlsx"
-
-df_results, df_summary = batch_calculate_dice(gt_directory, pred_directory, results_excel)
-```
-
-## 6. Working with Real Patient Data
-
-Example of processing actual patient X-rays from your dataset.
-
-```python
-# Get list of patient directories
-patients_dir = Path("../data/Pacientes/")
-patient_folders = [d for d in patients_dir.iterdir() if d.is_dir() and d.name.isdigit()]
-
-print(f"Found {len(patient_folders)} patient folders")
-
-# Process first 5 patients as example
-for patient_dir in patient_folders[:5]:
-    patient_id = patient_dir.name
-    print(f"\nProcessing Patient: {patient_id}")
-    
-    # Find X-ray image
-    images = list(patient_dir.glob("*.jpg"))
-    
-    if images:
-        xray_path = images[0]
-        print(f"  X-ray: {xray_path.name}")
-        
-        # Enhance image
-        output_path = f"../dice/enhanced_images/{patient_id}_enhanced.jpg"
-        enhanced = enhance_consolidation(str(xray_path), output_path)
-        
-        print(f"  Enhanced image saved: {output_path}")
-        
-        # Here you would:
-        # 1. Load or create annotations
-        # 2. Calculate Dice if annotations exist
-        # 3. Generate reports
-    else:
-        print(f"  No images found")
-```
-
-## 7. Quality Control Report
-
-Generate a comprehensive quality control report.
-
-```python
-def generate_qc_report(results_df, output_path):
-    """Generate quality control report with visualizations."""
-    
-    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
-    
-    # 1. Dice score distribution
-    axes[0, 0].hist(results_df['Dice'], bins=20, color='steelblue', edgecolor='black')
-    axes[0, 0].axvline(0.7, color='orange', linestyle='--', label='Good threshold')
-    axes[0, 0].axvline(0.85, color='green', linestyle='--', label='Excellent threshold')
-    axes[0, 0].set_xlabel('Dice Coefficient')
-    axes[0, 0].set_ylabel('Frequency')
-    axes[0, 0].set_title('Distribution of Dice Scores')
-    axes[0, 0].legend()
-    
-    # 2. Dice vs IoU scatter
-    axes[0, 1].scatter(results_df['Dice'], results_df['IoU'], alpha=0.6)
-    axes[0, 1].plot([0, 1], [0, 1], 'r--', label='Perfect correlation')
-    axes[0, 1].set_xlabel('Dice Coefficient')
-    axes[0, 1].set_ylabel('IoU')
-    axes[0, 1].set_title('Dice vs IoU Correlation')
-    axes[0, 1].legend()
-    
-    # 3. Precision-Recall scatter
-    axes[1, 0].scatter(results_df['Recall'], results_df['Precision'], 
-                       c=results_df['Dice'], cmap='viridis', alpha=0.6)
-    axes[1, 0].set_xlabel('Recall')
-    axes[1, 0].set_ylabel('Precision')
-    axes[1, 0].set_title('Precision vs Recall (colored by Dice)')
-    plt.colorbar(axes[1, 0].collections[0], ax=axes[1, 0], label='Dice')
-    
-    # 4. Quality categories
-    categories = pd.cut(results_df['Dice'], 
-                       bins=[0, 0.7, 0.85, 1.0],
-                       labels=['Needs Review', 'Good', 'Excellent'])
-    category_counts = categories.value_counts()
-    
-    axes[1, 1].bar(range(len(category_counts)), category_counts.values, 
-                   color=['red', 'orange', 'green'])
-    axes[1, 1].set_xticks(range(len(category_counts)))
-    axes[1, 1].set_xticklabels(category_counts.index, rotation=45)
-    axes[1, 1].set_ylabel('Count')
-    axes[1, 1].set_title('Segmentation Quality Distribution')
-    
-    plt.tight_layout()
-    plt.savefig(output_path, dpi=150, bbox_inches='tight')
-    plt.show()
-    
-    print(f"Quality control report saved: {output_path}")
-    
-    # Print summary
-    print("\n=== Quality Control Summary ===")
-    print(f"Total cases: {len(results_df)}")
-    print(f"\nQuality breakdown:")
-    for cat, count in category_counts.items():
-        pct = (count / len(results_df)) * 100
-        print(f"  {cat}: {count} ({pct:.1f}%)")
-
-# Generate report if we have results
-if len(df_results) > 0:
-    generate_qc_report(df_results, '../dice/results/quality_control_report.png')
-```
-
-## Next Steps
-
-1. **Annotate Real Data**: Use CVAT or Label Studio to create ground truth masks
-2. **Train ML Model**: Use annotated data to train segmentation model
-3. **Validate**: Use this toolkit to validate model predictions
-4. **Iterate**: Refine annotations and model based on Dice scores
-
-## Resources
-
-- [CVAT Installation](https://opencv.github.io/cvat/docs/)
-- [SAM Download](https://github.com/facebookresearch/segment-anything)
-- [Medical Image Segmentation Best Practices](https://arxiv.org/abs/1904.03882)

src/preprocessing_consolidation.py

@@ -1,156 +0,0 @@
-"""
-Preprocessing script for pneumonia consolidation enhancement.
-This script enhances chest X-ray images to better visualize consolidations,
-air bronchograms, and subtle patterns necessary for accurate segmentation.
-"""
-
-import cv2
-import numpy as np
-from pathlib import Path
-import argparse
-
-
-def enhance_consolidation(img_path, output_path=None):
-    """
-    Enhance chest X-ray image to better visualize pneumonia consolidation.
-    
-    Args:
-        img_path: Path to the input image (JPG/PNG)
-        output_path: Path to save the enhanced image (optional)
-        
-    Returns:
-        Enhanced image as numpy array
-    """
-    # Read image in grayscale
-    img = cv2.imread(str(img_path), cv2.IMREAD_GRAYSCALE)
-    
-    if img is None:
-        raise ValueError(f"Could not read image from {img_path}")
-    
-    # 1. CLAHE (Contrast Limited Adaptive Histogram Equalization)
-    # Enhances local contrast to see subtle consolidations
-    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
-    enhanced = clahe.apply(img)
-    
-    # 2. Sharpening filter to reveal air bronchograms
-    # Air bronchograms are dark branch-like patterns inside consolidation
-    kernel = np.array([[-1, -1, -1], 
-                       [-1,  9, -1], 
-                       [-1, -1, -1]])
-    sharpened = cv2.filter2D(enhanced, -1, kernel)
-    
-    # 3. Optional: Edge enhancement to see consolidation boundaries
-    # Using Laplacian for edge detection
-    laplacian = cv2.Laplacian(sharpened, cv2.CV_64F)
-    laplacian = np.uint8(np.absolute(laplacian))
-    
-    # Combine sharpened image with edge information
-    alpha = 0.8  # Weight for sharpened image
-    beta = 0.2   # Weight for edge information
-    result = cv2.addWeighted(sharpened, alpha, laplacian, beta, 0)
-    
-    # Save if output path provided
-    if output_path:
-        cv2.imwrite(str(output_path), result)
-        print(f"Enhanced image saved to: {output_path}")
-    
-    return result
-
-
-def batch_enhance_consolidation(input_dir, output_dir, image_extension='.jpg'):
-    """
-    Process multiple images in a directory.
-    
-    Args:
-        input_dir: Directory containing input images
-        output_dir: Directory to save enhanced images
-        image_extension: File extension to process (default: .jpg)
-    """
-    input_path = Path(input_dir)
-    output_path = Path(output_dir)
-    output_path.mkdir(parents=True, exist_ok=True)
-    
-    # Find all images with specified extension
-    images = list(input_path.rglob(f"*{image_extension}"))
-    
-    print(f"Found {len(images)} images to process")
-    
-    for img_path in images:
-        try:
-            # Create output path maintaining relative structure
-            rel_path = img_path.relative_to(input_path)
-            out_path = output_path / rel_path
-            out_path.parent.mkdir(parents=True, exist_ok=True)
-            
-            # Process image
-            enhance_consolidation(img_path, out_path)
-            print(f"Processed: {img_path.name}")
-            
-        except Exception as e:
-            print(f"Error processing {img_path}: {e}")
-    
-    print(f"\nProcessing complete! Enhanced images saved to: {output_path}")
-
-
-def create_visualization_comparison(original_path, enhanced_path, output_path):
-    """
-    Create a side-by-side comparison of original and enhanced images.
-    
-    Args:
-        original_path: Path to original image
-        enhanced_path: Path to enhanced image
-        output_path: Path to save comparison image
-    """
-    original = cv2.imread(str(original_path), cv2.IMREAD_GRAYSCALE)
-    enhanced = cv2.imread(str(enhanced_path), cv2.IMREAD_GRAYSCALE)
-    
-    # Resize if needed to match dimensions
-    if original.shape != enhanced.shape:
-        enhanced = cv2.resize(enhanced, (original.shape[1], original.shape[0]))
-    
-    # Create side-by-side comparison
-    comparison = np.hstack([original, enhanced])
-    
-    # Add labels
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    cv2.putText(comparison, 'Original', (10, 30), font, 1, (255, 255, 255), 2)
-    cv2.putText(comparison, 'Enhanced', (original.shape[1] + 10, 30), font, 1, (255, 255, 255), 2)
-    
-    cv2.imwrite(str(output_path), comparison)
-    print(f"Comparison saved to: {output_path}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Enhance chest X-ray images for pneumonia consolidation segmentation"
-    )
-    parser.add_argument(
-        '--input', 
-        type=str, 
-        required=True,
-        help='Input image file or directory'
-    )
-    parser.add_argument(
-        '--output', 
-        type=str, 
-        required=True,
-        help='Output file or directory'
-    )
-    parser.add_argument(
-        '--batch', 
-        action='store_true',
-        help='Process entire directory (batch mode)'
-    )
-    parser.add_argument(
-        '--extension', 
-        type=str, 
-        default='.jpg',
-        help='Image file extension for batch processing (default: .jpg)'
-    )
-    
-    args = parser.parse_args()
-    
-    if args.batch:
-        batch_enhance_consolidation(args.input, args.output, args.extension)
-    else:
-        enhance_consolidation(args.input, args.output)

src/quickstart.sh

@@ -1,88 +0,0 @@
-#!/bin/bash
-
-# Quick Start Script for Pneumonia Consolidation Segmentation
-# This script sets up the environment and runs initial tests
-
-echo "🫁 Pneumonia Consolidation Segmentation - Quick Start"
-echo "======================================================"
-echo ""
-
-# Check if we're in the right directory
-if [ ! -f "dice_calculator_app.py" ]; then
-    echo "❌ Error: Please run this script from the dice/ directory"
-    exit 1
-fi
-
-echo "✓ Directory check passed"
-echo ""
-
-# Step 1: Install dependencies
-echo "📦 Step 1: Installing dependencies..."
-echo "Command: pip install -r requirements.txt"
-echo ""
-read -p "Press Enter to continue or Ctrl+C to cancel..."
-pip install -r requirements.txt
-
-if [ $? -eq 0 ]; then
-    echo "✓ Dependencies installed successfully"
-else
-    echo "❌ Error installing dependencies"
-    exit 1
-fi
-echo ""
-
-# Step 2: Test Streamlit installation
-echo "🧪 Step 2: Testing Streamlit installation..."
-streamlit --version
-if [ $? -eq 0 ]; then
-    echo "✓ Streamlit is working"
-else
-    echo "❌ Streamlit test failed"
-    exit 1
-fi
-echo ""
-
-# Step 3: Create sample test images (optional)
-echo "📸 Step 3: Would you like to preprocess sample images now?"
-echo "This will enhance chest X-rays for better consolidation visibility."
-echo ""
-read -p "Enter 'y' to preprocess images, or 'n' to skip: " preprocess
-
-if [ "$preprocess" = "y" ]; then
-    echo ""
-    echo "Enter the path to your input directory (e.g., ../data/Pacientes/):"
-    read input_dir
-    
-    if [ -d "$input_dir" ]; then
-        echo "Processing images from: $input_dir"
-        echo "Output will be saved to: ./enhanced_images/"
-        python preprocessing_consolidation.py \
-            --input "$input_dir" \
-            --output ./enhanced_images/ \
-            --batch \
-            --extension .jpg
-        
-        echo "✓ Preprocessing complete"
-    else
-        echo "❌ Directory not found: $input_dir"
-    fi
-fi
-echo ""
-
-# Step 4: Launch Streamlit app
-echo "🚀 Step 4: Launch Dice Calculator App"
-echo ""
-echo "The Streamlit app will open in your browser."
-echo "You can then upload images and masks to calculate Dice scores."
-echo ""
-read -p "Press Enter to launch the app, or Ctrl+C to exit..."
-
-streamlit run dice_calculator_app.py
-
-echo ""
-echo "✓ Setup complete!"
-echo ""
-echo "Next steps:"
-echo "1. Annotate your images using CVAT or Label Studio"
-echo "2. Use the Dice Calculator to validate annotations"
-echo "3. See TODO.md for complete project roadmap"

src/requirements.txt

@@ -1,31 +0,0 @@
-# Requirements for Pneumonia Consolidation Annotation Tool
-# For cloud deployment (Hugging Face Spaces / Streamlit Cloud)
-
-# Core dependencies
-numpy>=1.24.0
-opencv-python-headless>=4.8.0  # Use headless for cloud deployment!
-Pillow>=10.0.0
-pandas>=2.0.0
-matplotlib>=3.7.0
-
-# Streamlit app
-streamlit==1.29.0
-streamlit-drawable-canvas==0.9.3
-altair<5
-
-
-# Optional: SAM (Segment Anything Model)
-# Uncomment to use SAM integration
-# segment-anything
-# torch>=1.7.0
-# torchvision>=0.8.0
-
-# Optional: For Hausdorff distance calculation
-scipy>=1.7.0
-
-# Optional: For advanced image processing
-scikit-image>=0.18.0
-
-# Development
-jupyter>=1.0.0
-ipykernel>=6.0.0

src/sam_integration.py

@@ -1,395 +0,0 @@
-"""
-SAM (Segment Anything Model) Integration for Pneumonia Consolidation
-This script uses Meta's Segment Anything Model to generate initial segmentation masks
-that can be refined manually.
-"""
-
-import numpy as np
-import cv2
-from pathlib import Path
-import matplotlib.pyplot as plt
-import argparse
-
-
-def setup_sam():
-    """
-    Setup SAM model. Install with:
-    pip install segment-anything
-    
-    Download checkpoint from:
-    https://github.com/facebookresearch/segment-anything#model-checkpoints
-    """
-    try:
-        from segment_anything import sam_model_registry, SamPredictor
-        return sam_model_registry, SamPredictor
-    except ImportError:
-        print("Error: segment-anything not installed.")
-        print("Install with: pip install segment-anything")
-        print("Then download a model checkpoint from:")
-        print("https://github.com/facebookresearch/segment-anything#model-checkpoints")
-        return None, None
-
-
-def initialize_sam_predictor(checkpoint_path, model_type="vit_h"):
-    """
-    Initialize SAM predictor.
-    
-    Args:
-        checkpoint_path: Path to SAM checkpoint (.pth file)
-        model_type: Model type ('vit_h', 'vit_l', or 'vit_b')
-    
-    Returns:
-        SAM predictor object
-    """
-    sam_model_registry, SamPredictor = setup_sam()
-    if sam_model_registry is None:
-        return None
-    
-    sam = sam_model_registry[model_type](checkpoint=checkpoint_path)
-    predictor = SamPredictor(sam)
-    
-    return predictor
-
-
-def predict_consolidation_with_points(image_path, predictor, point_coords, point_labels):
-    """
-    Generate segmentation mask using point prompts.
-    
-    Args:
-        image_path: Path to chest X-ray image
-        predictor: SAM predictor object
-        point_coords: Array of [x, y] coordinates for prompts
-        point_labels: Array of labels (1 for positive/include, 0 for negative/exclude)
-    
-    Returns:
-        mask: Binary segmentation mask
-        scores: Confidence scores for each mask
-    """
-    # Load image
-    image = cv2.imread(str(image_path))
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    
-    # Set image in predictor
-    predictor.set_image(image)
-    
-    # Convert points to numpy array
-    point_coords = np.array(point_coords)
-    point_labels = np.array(point_labels)
-    
-    # Predict
-    masks, scores, logits = predictor.predict(
-        point_coords=point_coords,
-        point_labels=point_labels,
-        multimask_output=True
-    )
-    
-    return masks, scores, image
-
-
-def predict_consolidation_with_box(image_path, predictor, box_coords):
-    """
-    Generate segmentation mask using bounding box prompt.
-    
-    Args:
-        image_path: Path to chest X-ray image
-        predictor: SAM predictor object
-        box_coords: [x1, y1, x2, y2] bounding box coordinates
-    
-    Returns:
-        mask: Binary segmentation mask
-    """
-    # Load image
-    image = cv2.imread(str(image_path))
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    
-    # Set image in predictor
-    predictor.set_image(image)
-    
-    # Convert box to numpy array
-    box = np.array(box_coords)
-    
-    # Predict
-    masks, scores, logits = predictor.predict(
-        box=box,
-        multimask_output=True
-    )
-    
-    return masks, scores, image
-
-
-def automatic_consolidation_detection(image_path, predictor, grid_size=5):
-    """
-    Automatically detect potential consolidation regions using grid-based sampling.
-    
-    Args:
-        image_path: Path to chest X-ray image
-        predictor: SAM predictor object
-        grid_size: Number of points in grid (grid_size x grid_size)
-    
-    Returns:
-        Combined mask from multiple detections
-    """
-    # Load image
-    image = cv2.imread(str(image_path))
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    h, w = image.shape[:2]
-    
-    # Set image in predictor
-    predictor.set_image(image)
-    
-    # Create grid of points in lung region (avoid edges)
-    margin_h = int(h * 0.1)
-    margin_w = int(w * 0.2)
-    
-    x_coords = np.linspace(margin_w, w - margin_w, grid_size)
-    y_coords = np.linspace(margin_h, h - margin_h, grid_size)
-    
-    all_masks = []
-    
-    for x in x_coords:
-        for y in y_coords:
-            point = np.array([[x, y]])
-            label = np.array([1])
-            
-            try:
-                masks, scores, _ = predictor.predict(
-                    point_coords=point,
-                    point_labels=label,
-                    multimask_output=False
-                )
-                
-                # Only keep masks with high confidence
-                if scores[0] > 0.8:
-                    all_masks.append(masks[0])
-            except Exception as e:
-                continue
-    
-    if not all_masks:
-        return None, image
-    
-    # Combine masks
-    combined_mask = np.any(all_masks, axis=0).astype(np.uint8)
-    
-    return combined_mask, image
-
-
-def visualize_sam_results(image, masks, scores, point_coords=None, save_path=None):
-    """
-    Visualize SAM segmentation results.
-    
-    Args:
-        image: Original image
-        masks: Array of masks
-        scores: Confidence scores
-        point_coords: Optional point prompts to display
-        save_path: Optional path to save visualization
-    """
-    fig, axes = plt.subplots(1, len(masks) + 1, figsize=(15, 5))
-    
-    # Show original image
-    axes[0].imshow(image)
-    axes[0].set_title('Original')
-    axes[0].axis('off')
-    
-    if point_coords is not None:
-        axes[0].scatter(point_coords[:, 0], point_coords[:, 1], 
-                       c='red', s=100, marker='*')
-    
-    # Show each mask
-    for idx, (mask, score) in enumerate(zip(masks, scores)):
-        axes[idx + 1].imshow(image)
-        axes[idx + 1].imshow(mask, alpha=0.5, cmap='jet')
-        axes[idx + 1].set_title(f'Mask {idx + 1}\nScore: {score:.3f}')
-        axes[idx + 1].axis('off')
-    
-    plt.tight_layout()
-    
-    if save_path:
-        plt.savefig(save_path, dpi=150, bbox_inches='tight')
-        print(f"Visualization saved to: {save_path}")
-    
-    plt.show()
-
-
-def save_mask(mask, output_path):
-    """Save binary mask as image."""
-    mask_uint8 = (mask * 255).astype(np.uint8)
-    cv2.imwrite(str(output_path), mask_uint8)
-    print(f"Mask saved to: {output_path}")
-
-
-def interactive_sam_segmentation(image_path, checkpoint_path):
-    """
-    Interactive segmentation where user clicks points to guide SAM.
-    This is a simple CLI version - for GUI, integrate with Streamlit.
-    """
-    print("Initializing SAM...")
-    predictor = initialize_sam_predictor(checkpoint_path)
-    
-    if predictor is None:
-        return
-    
-    # Load and display image
-    image = cv2.imread(str(image_path))
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    
-    print("\nInstructions:")
-    print("1. The image will be displayed")
-    print("2. Click on consolidation areas (left click)")
-    print("3. Click on background areas to exclude (right click)")
-    print("4. Press 'q' when done")
-    print("5. Choose best mask from results")
-    
-    point_coords = []
-    point_labels = []
-    
-    def mouse_callback(event, x, y, flags, param):
-        if event == cv2.EVENT_LBUTTONDOWN:
-            point_coords.append([x, y])
-            point_labels.append(1)
-            print(f"Added positive point at ({x}, {y})")
-        elif event == cv2.EVENT_RBUTTONDOWN:
-            point_coords.append([x, y])
-            point_labels.append(0)
-            print(f"Added negative point at ({x}, {y})")
-    
-    # Convert for OpenCV display
-    display_img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    cv2.namedWindow('Image')
-    cv2.setMouseCallback('Image', mouse_callback)
-    
-    while True:
-        display = display_img.copy()
-        
-        # Draw points
-        for coord, label in zip(point_coords, point_labels):
-            color = (0, 255, 0) if label == 1 else (0, 0, 255)
-            cv2.circle(display, tuple(coord), 5, color, -1)
-        
-        cv2.imshow('Image', display)
-        
-        key = cv2.waitKey(1) & 0xFF
-        if key == ord('q'):
-            break
-    
-    cv2.destroyAllWindows()
-    
-    if point_coords:
-        print("\nGenerating masks...")
-        masks, scores, _ = predict_consolidation_with_points(
-            image_path, predictor, point_coords, point_labels
-        )
-        
-        # Visualize results
-        visualize_sam_results(image, masks, scores, np.array(point_coords))
-        
-        # Save best mask
-        best_idx = np.argmax(scores)
-        output_path = Path(image_path).parent / f"{Path(image_path).stem}_sam_mask.png"
-        save_mask(masks[best_idx], output_path)
-        
-        return masks[best_idx]
-    
-    return None
-
-
-def batch_process_with_sam(input_dir, output_dir, checkpoint_path, mode='auto'):
-    """
-    Batch process images with SAM.
-    
-    Args:
-        input_dir: Directory with chest X-ray images
-        output_dir: Directory to save masks
-        checkpoint_path: Path to SAM checkpoint
-        mode: 'auto' for automatic or 'center' for single center point
-    """
-    input_path = Path(input_dir)
-    output_path = Path(output_dir)
-    output_path.mkdir(parents=True, exist_ok=True)
-    
-    print("Initializing SAM...")
-    predictor = initialize_sam_predictor(checkpoint_path)
-    
-    if predictor is None:
-        return
-    
-    images = list(input_path.glob("*.jpg")) + list(input_path.glob("*.png"))
-    print(f"Found {len(images)} images to process")
-    
-    for img_path in images:
-        print(f"\nProcessing: {img_path.name}")
-        
-        try:
-            if mode == 'auto':
-                mask, image = automatic_consolidation_detection(img_path, predictor)
-            else:
-                # Use center point as prompt
-                image = cv2.imread(str(img_path))
-                h, w = image.shape[:2]
-                center_point = [[w // 2, h // 2]]
-                masks, scores, image = predict_consolidation_with_points(
-                    img_path, predictor, center_point, [1]
-                )
-                mask = masks[np.argmax(scores)]
-            
-            if mask is not None:
-                output_file = output_path / f"{img_path.stem}_mask.png"
-                save_mask(mask, output_file)
-            else:
-                print(f"No mask generated for {img_path.name}")
-                
-        except Exception as e:
-            print(f"Error processing {img_path.name}: {e}")
-    
-    print(f"\nBatch processing complete! Masks saved to: {output_path}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Generate pneumonia consolidation masks using SAM"
-    )
-    parser.add_argument(
-        '--checkpoint',
-        type=str,
-        required=True,
-        help='Path to SAM checkpoint file (.pth)'
-    )
-    parser.add_argument(
-        '--image',
-        type=str,
-        help='Path to single image (for interactive mode)'
-    )
-    parser.add_argument(
-        '--input_dir',
-        type=str,
-        help='Input directory for batch processing'
-    )
-    parser.add_argument(
-        '--output_dir',
-        type=str,
-        help='Output directory for batch processing'
-    )
-    parser.add_argument(
-        '--mode',
-        type=str,
-        default='interactive',
-        choices=['interactive', 'auto', 'center'],
-        help='Processing mode'
-    )
-    parser.add_argument(
-        '--model_type',
-        type=str,
-        default='vit_h',
-        choices=['vit_h', 'vit_l', 'vit_b'],
-        help='SAM model type'
-    )
-    
-    args = parser.parse_args()
-    
-    if args.mode == 'interactive' and args.image:
-        interactive_sam_segmentation(args.image, args.checkpoint)
-    elif args.input_dir and args.output_dir:
-        batch_process_with_sam(args.input_dir, args.output_dir, 
-                              args.checkpoint, args.mode)
-    else:
-        parser.print_help()

src/streamlit_app.py

@@ -1,1207 +0,0 @@
-"""
-Ground Truth Annotation Tool for Radiologists - Pneumonia Consolidation
-
-Features:
-1. Browse patient X-ray images from Pacientes folder automatically
-2. Annotate consolidation directly in the browser (no external tools)
-3. Multiple consolidation entries for multilobar pneumonia
-4. Save mask + metadata JSON in the same patient folder
-5. Progress tracking, inter-rater comparison, zoom, dark theme
-"""
-
-import sys
-import streamlit as st
-import cv2
-import numpy as np
-from PIL import Image
-import pandas as pd
-from pathlib import Path
-import json
-import io
-from datetime import datetime
-from streamlit_drawable_canvas import st_canvas
-import hashlib
-
-# ============================================================================
-# AUTHENTICATION
-# ============================================================================
-
-# User credentials (username: hashed_password)
-# To add users: hash their password with hashlib.sha256("password".encode()).hexdigest()
-USERS = {
-    "admin": "6ef53576c614c35328ec86075d78cde376aa6b87504b39798d2ce4962a5a621a",
-    "daniel": "dcabf0e5cfa74308f61ed0bcb7bd5565cfe6d890bb3e2ff7528d588da6f9c623",
-}
-
-
-def hash_password(password: str) -> str:
-    """Hash a password using SHA-256."""
-    return hashlib.sha256(password.encode()).hexdigest()
-
-
-def check_credentials(username: str, password: str) -> bool:
-    """Verify username and password."""
-    if username in USERS:
-        return USERS[username] == hash_password(password)
-    return False
-
-
-def login_form():
-    """Display login form and handle authentication."""
-    st.set_page_config(
-        page_title="Login - Annotation Tool",
-        page_icon="🔐",
-        layout="centered",
-    )
-    
-    st.title("🔐 Login")
-    st.markdown("### Pneumonia Consolidation Annotation Tool")
-    st.markdown("---")
-    
-    with st.form("login_form"):
-        username = st.text_input("👤 Username", placeholder="Enter your username")
-        password = st.text_input("🔑 Password", type="password", placeholder="Enter your password")
-        submit = st.form_submit_button("🚀 Login", use_container_width=True)
-        
-        if submit:
-            if check_credentials(username, password):
-                st.session_state.authenticated = True
-                st.session_state.username = username
-                st.rerun()
-            else:
-                st.error("❌ Invalid username or password")
-    
-    st.markdown("---")
-    st.caption("Contact administrator for access credentials.")
-
-
-def logout_button():
-    """Display logout button in sidebar."""
-    st.sidebar.markdown("---")
-    st.sidebar.markdown(f"👤 Logged in as: **{st.session_state.username}**")
-    if st.sidebar.button("🚪 Logout", use_container_width=True):
-        st.session_state.authenticated = False
-        st.session_state.username = None
-        st.rerun()
-
-# ============================================================================
-# CONSOLIDATION COLOR PALETTE (one distinct color per site)
-# ============================================================================
-
-CONSOLIDATION_COLORS = [
-    ("#00FF00", "Lime"),
-    ("#FF4444", "Red"),
-    ("#4488FF", "Blue"),
-    ("#FFD700", "Gold"),
-    ("#FF69B4", "Pink"),
-    ("#00FFFF", "Cyan"),
-    ("#FF8C00", "Orange"),
-    ("#9370DB", "Purple"),
-    ("#32CD32", "Green2"),
-    ("#FF1493", "DeepPink"),
-]
-
-
-def get_color_for_index(idx: int) -> tuple:
-    """Return (hex_color, label) for a given consolidation index."""
-    return CONSOLIDATION_COLORS[idx % len(CONSOLIDATION_COLORS)]
-
-
-# ============================================================================
-# METRIC FUNCTIONS
-# ============================================================================
-
-def calculate_dice_coefficient(mask1, mask2):
-    m1 = (mask1 > 0).astype(np.uint8)
-    m2 = (mask2 > 0).astype(np.uint8)
-    intersection = np.sum(m1 * m2)
-    total = np.sum(m1) + np.sum(m2)
-    if total == 0:
-        return 1.0
-    return (2.0 * intersection) / total
-
-
-def calculate_iou(mask1, mask2):
-    m1 = (mask1 > 0).astype(np.uint8)
-    m2 = (mask2 > 0).astype(np.uint8)
-    intersection = np.sum(m1 * m2)
-    union = np.sum(m1) + np.sum(m2) - intersection
-    if union == 0:
-        return 1.0
-    return intersection / union
-
-
-def calculate_precision_recall(ground_truth, prediction):
-    gt = (ground_truth > 0).astype(np.uint8)
-    pred = (prediction > 0).astype(np.uint8)
-    tp = np.sum(gt * pred)
-    fp = np.sum((1 - gt) * pred)
-    fn = np.sum(gt * (1 - pred))
-    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
-    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
-    return precision, recall
-
-
-# ============================================================================
-# IMAGE & DATA HELPERS
-# ============================================================================
-
-def load_image_from_path(image_path):
-    """Load image as RGB numpy array (original, no CLAHE).
-    
-    Uses PIL as primary method for better cloud compatibility,
-    with cv2 as fallback for edge cases.
-    """
-    image_path = Path(image_path)
-    
-    # Method 1: Use PIL (more reliable for cloud/uploaded files)
-    try:
-        with Image.open(image_path) as pil_img:
-            # Convert to RGB if necessary (handles grayscale, RGBA, etc.)
-            if pil_img.mode != 'RGB':
-                pil_img = pil_img.convert('RGB')
-            img = np.array(pil_img)
-            return img
-    except Exception as e:
-        pass  # Fall through to cv2 method
-    
-    # Method 2: Fallback to OpenCV
-    try:
-        img = cv2.imread(str(image_path))
-        if img is not None:
-            return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    except Exception:
-        pass
-    
-    # Method 3: Read bytes directly (for cloud file systems)
-    try:
-        with open(image_path, 'rb') as f:
-            file_bytes = f.read()
-        nparr = np.frombuffer(file_bytes, np.uint8)
-        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        if img is not None:
-            return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    except Exception:
-        pass
-    
-    return None
-
-
-def scale_image_preserve_ratio(img, target_width=900):
-    """Scale image so width = target_width, preserving aspect ratio."""
-    h, w = img.shape[:2]
-    ratio = target_width / w
-    new_h = int(h * ratio)
-    new_w = target_width
-    scaled = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_AREA)
-    return scaled, ratio
-
-
-def get_all_patient_images(base_path):
-    """Scan patient folders and collect all JPG/PNG images with annotation status."""
-    base = Path(base_path)
-    patient_images = []
-    if not base.exists():
-        return patient_images
-
-    # Get all subdirectories (including 'uploads' folder for cloud mode)
-    folders = [base] + [f for f in base.iterdir() if f.is_dir()]
-    
-    for folder in folders:
-        img_files = sorted(
-            list(folder.glob("*.jpg")) + 
-            list(folder.glob("*.JPG")) +
-            list(folder.glob("*.jpeg")) +
-            list(folder.glob("*.png"))
-        )
-        for img in img_files:
-            # Skip mask files
-            if "_mask" in img.name:
-                continue
-            mask_path = img.parent / f"{img.stem}_mask.png"
-            meta_path = img.parent / f"{img.stem}_annotation.json"
-            # Use folder name as patient_id, or 'uploaded' for root
-            patient_id = folder.name if folder != base else "uploaded"
-            patient_images.append({
-                "patient_id": patient_id,
-                "image_path": img,
-                "image_name": img.name,
-                "mask_path": mask_path,
-                "metadata_path": meta_path,
-                "annotated": mask_path.exists(),
-            })
-    return patient_images
-
-
-def get_annotation_progress(patient_images):
-    total = len(patient_images)
-    done = sum(1 for img in patient_images if img["annotated"])
-    pct = (done / total * 100) if total > 0 else 0
-    return done, total, pct
-
-
-def save_annotation_in_patient_folder(
-    image_path, mask_array, annotator_name, metadata_dict, original_shape
-):
-    """Save mask (rescaled to original size) + metadata JSON in patient folder."""
-    image_path = Path(image_path)
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-
-    # Resize mask back to original image dimensions
-    orig_h, orig_w = original_shape[:2]
-    mask_resized = cv2.resize(
-        mask_array, (orig_w, orig_h), interpolation=cv2.INTER_NEAREST
-    )
-
-    mask_filename = f"{image_path.stem}_mask.png"
-    mask_path = image_path.parent / mask_filename
-    cv2.imwrite(str(mask_path), mask_resized)
-
-    metadata = {
-        "image_name": image_path.name,
-        "patient_id": image_path.parent.name,
-        "annotator": annotator_name,
-        "timestamp": timestamp,
-        "mask_file": mask_filename,
-        **metadata_dict,
-    }
-    meta_path = image_path.parent / f"{image_path.stem}_annotation.json"
-    with open(meta_path, "w") as f:
-        json.dump(metadata, f, indent=2)
-
-    return mask_path, meta_path
-
-
-# ============================================================================
-# MAIN APP
-# ============================================================================
-
-def main():
-    # ── Authentication Check ───────────────────────────────────────────
-    if "authenticated" not in st.session_state:
-        st.session_state.authenticated = False
-    
-    if not st.session_state.authenticated:
-        login_form()
-        return
-    
-    # ── Authenticated: Show main app ───────────────────────────────────
-    st.set_page_config(
-        page_title="Ground Truth Annotation Tool",
-        page_icon="🫁",
-        layout="wide",
-    )
-
-    st.title("🫁 Pneumonia Consolidation — Ground Truth Annotation")
-    
-    # Show logout button
-    logout_button()
-
-    # ── Sidebar: annotator ─────────────────────────────────────────────
-    st.sidebar.header("👤 Annotator")
-    annotator_name = st.sidebar.text_input("Your Name / ID", value="Radiologist1")
-
-    # ── Sidebar: patients path ─────────────────────────────────────────
-    st.sidebar.header("📁 Patient Data")
-    
-    # Image upload for cloud deployment
-    st.sidebar.subheader("📤 Upload X-rays")
-    uploaded_files = st.sidebar.file_uploader(
-        "Upload chest X-ray images",
-        type=["jpg", "jpeg", "png"],
-        accept_multiple_files=True,
-        help="Upload JPG/PNG chest X-ray images to annotate",
-    )
-    
-    # Create upload directory
-    upload_dir = Path("./uploaded_images")
-    upload_dir.mkdir(parents=True, exist_ok=True)
-    
-    if uploaded_files:
-        for uf in uploaded_files:
-            # Use filename (without extension) as patient ID
-            file_path = upload_dir / uf.name
-            with open(file_path, "wb") as f:
-                f.write(uf.getbuffer())
-        st.sidebar.success(f"✅ {len(uploaded_files)} image(s) uploaded!")
-    
-    st.sidebar.divider()
-    
-    patients_path = st.sidebar.text_input(
-        "Images Folder Path",
-        value="./uploaded_images",
-        help="Folder with images (use uploader above for cloud, or local path)",
-    )
-
-    # ── Load images ────────────────────────────────────────────────────
-    patient_images = get_all_patient_images(patients_path)
-
-    if not patient_images:
-        st.error(
-            f"No JPG images found under **{patients_path}**. "
-            "Check the path and ensure folders contain .jpg files."
-        )
-        return
-
-    # ── Sidebar: progress ──────────────────────────────────────────────
-    annotated_count, total_count, progress_pct = get_annotation_progress(
-        patient_images
-    )
-    st.sidebar.header("📊 Progress")
-    st.sidebar.progress(progress_pct / 100)
-    st.sidebar.metric("Annotated", f"{annotated_count} / {total_count}")
-    st.sidebar.metric("Completion", f"{progress_pct:.1f}%")
-
-    # ── Sidebar: filter ────────────────────────────────────────────────
-    st.sidebar.header("🔍 Filter")
-    show_filter = st.sidebar.radio(
-        "Show",
-        ["All Images", "Not Annotated", "Annotated"],
-        index=1,
-    )
-    if show_filter == "Not Annotated":
-        filtered_images = [i for i in patient_images if not i["annotated"]]
-    elif show_filter == "Annotated":
-        filtered_images = [i for i in patient_images if i["annotated"]]
-    else:
-        filtered_images = patient_images
-
-    if not filtered_images:
-        st.warning(f"No images match filter **{show_filter}**.")
-        return
-
-    # ── Navigation state ───────────────────────────────────────────────
-    if "current_index" not in st.session_state:
-        st.session_state.current_index = 0
-    if st.session_state.current_index >= len(filtered_images):
-        st.session_state.current_index = 0
-    current_image = filtered_images[st.session_state.current_index]
-
-    # ── Sidebar: drawing settings ──────────────────────────────────────
-    st.sidebar.header("🎨 Drawing Settings")
-    stroke_width = st.sidebar.slider("Brush Size", 1, 50, 15)
-
-    drawing_mode = st.sidebar.selectbox(
-        "Drawing Tool",
-        ["freedraw", "rect", "circle", "line"],
-        index=0,
-        help="freedraw: freehand brush · rect/circle/line: shapes",
-    )
-
-    canvas_width = st.sidebar.slider(
-        "Canvas Width (px)", 600, 1400, 900, step=50,
-        help="Adjust to fit your screen. Aspect ratio is always preserved.",
-    )
-
-    # ── Sidebar: zoom controls ─────────────────────────────────────────
-    st.sidebar.header("🔍 Zoom & Pan")
-
-    # Initialise zoom state
-    if "zoom_level" not in st.session_state:
-        st.session_state.zoom_level = 1.0
-    if "zoom_pan_x" not in st.session_state:
-        st.session_state.zoom_pan_x = 0.5
-    if "zoom_pan_y" not in st.session_state:
-        st.session_state.zoom_pan_y = 0.5
-
-    # Quick zoom buttons
-    zb1, zb2, zb3, zb4 = st.sidebar.columns(4)
-    with zb1:
-        if st.button("➖", key="zoom_out", help="Zoom out",
-                     use_container_width=True):
-            st.session_state.zoom_level = max(
-                1.0, round(st.session_state.zoom_level - 0.25, 2)
-            )
-            st.rerun()
-    with zb2:
-        if st.button("➕", key="zoom_in", help="Zoom in",
-                     use_container_width=True):
-            st.session_state.zoom_level = min(
-                5.0, round(st.session_state.zoom_level + 0.25, 2)
-            )
-            st.rerun()
-    with zb3:
-        if st.button("🔄", key="zoom_reset", help="Reset zoom",
-                     use_container_width=True):
-            st.session_state.zoom_level = 1.0
-            st.session_state.zoom_pan_x = 0.5
-            st.session_state.zoom_pan_y = 0.5
-            st.rerun()
-    with zb4:
-        st.write(f"**{st.session_state.zoom_level:.1f}x**")
-
-    zoom_level = st.sidebar.slider(
-        "Zoom Level", 1.0, 5.0, st.session_state.zoom_level, step=0.25,
-        help="Drag or use ➕/➖ buttons above.",
-        key="zoom_slider",
-    )
-    if zoom_level != st.session_state.zoom_level:
-        st.session_state.zoom_level = zoom_level
-
-    if st.session_state.zoom_level > 1.0:
-        # Pan controls — arrows + sliders
-        st.sidebar.caption("**Pan (arrow buttons or sliders)**")
-        pa1, pa2, pa3 = st.sidebar.columns([1, 1, 1])
-        pan_step = 0.08
-        with pa1:
-            if st.button("⬅️", key="pan_left", use_container_width=True):
-                st.session_state.zoom_pan_x = max(
-                    0.0, round(st.session_state.zoom_pan_x - pan_step, 2)
-                )
-                st.rerun()
-            if st.button("⬆️", key="pan_up", use_container_width=True):
-                st.session_state.zoom_pan_y = max(
-                    0.0, round(st.session_state.zoom_pan_y - pan_step, 2)
-                )
-                st.rerun()
-        with pa2:
-            if st.button("➡️", key="pan_right", use_container_width=True):
-                st.session_state.zoom_pan_x = min(
-                    1.0, round(st.session_state.zoom_pan_x + pan_step, 2)
-                )
-                st.rerun()
-            if st.button("⬇️", key="pan_down", use_container_width=True):
-                st.session_state.zoom_pan_y = min(
-                    1.0, round(st.session_state.zoom_pan_y + pan_step, 2)
-                )
-                st.rerun()
-        with pa3:
-            st.write(
-                f"x={st.session_state.zoom_pan_x:.2f}\n"
-                f"y={st.session_state.zoom_pan_y:.2f}"
-            )
-
-        zoom_pan_x = st.sidebar.slider(
-            "Pan H", 0.0, 1.0, st.session_state.zoom_pan_x, step=0.05,
-            key="pan_h_slider",
-        )
-        zoom_pan_y = st.sidebar.slider(
-            "Pan V", 0.0, 1.0, st.session_state.zoom_pan_y, step=0.05,
-            key="pan_v_slider",
-        )
-        if zoom_pan_x != st.session_state.zoom_pan_x:
-            st.session_state.zoom_pan_x = zoom_pan_x
-        if zoom_pan_y != st.session_state.zoom_pan_y:
-            st.session_state.zoom_pan_y = zoom_pan_y
-    else:
-        st.session_state.zoom_pan_x = 0.5
-        st.session_state.zoom_pan_y = 0.5
-
-    zoom_pan_x = st.session_state.zoom_pan_x
-    zoom_pan_y = st.session_state.zoom_pan_y
-    zoom_level = st.session_state.zoom_level
-
-    # ── Tabs ───────────────────────────────────────────────────────────
-    tab1, tab2, tab3 = st.tabs(["📋 Annotate", "🔄 Compare", "📖 Guidelines"])
-
-    # ================================================================
-    # TAB 1 — ANNOTATE
-    # ================================================================
-    with tab1:
-        # Navigation bar
-        nav1, nav2, nav3, nav4, nav5 = st.columns([1, 1, 3, 1, 1])
-
-        with nav1:
-            if st.button("⬅️ Previous", use_container_width=True):
-                if st.session_state.current_index > 0:
-                    st.session_state.current_index -= 1
-                    st.rerun()
-        with nav2:
-            if st.button("Next ➡️", use_container_width=True):
-                if st.session_state.current_index < len(filtered_images) - 1:
-                    st.session_state.current_index += 1
-                    st.rerun()
-        with nav3:
-            st.info(
-                f"Image **{st.session_state.current_index + 1}** of "
-                f"**{len(filtered_images)}** · Patient "
-                f"**{current_image['patient_id']}**"
-            )
-        with nav4:
-            jump_to = st.number_input(
-                "Go to #",
-                min_value=1,
-                max_value=len(filtered_images),
-                value=st.session_state.current_index + 1,
-                key="jump",
-            )
-            if jump_to - 1 != st.session_state.current_index:
-                st.session_state.current_index = jump_to - 1
-                st.rerun()
-        with nav5:
-            if current_image["annotated"]:
-                st.success("✅ Done")
-            else:
-                st.warning("⏳ Pending")
-
-        st.divider()
-
-        # Load original image (NO CLAHE)
-        img_rgb = load_image_from_path(current_image["image_path"])
-        if img_rgb is None:
-            st.error(f"Cannot load image: {current_image['image_path']}")
-            # Debug info for cloud troubleshooting
-            with st.expander("🔧 Debug Info"):
-                st.write(f"**Path:** `{current_image['image_path']}`")
-                st.write(f"**Exists:** {Path(current_image['image_path']).exists()}")
-                if Path(current_image['image_path']).exists():
-                    st.write(f"**Size:** {Path(current_image['image_path']).stat().st_size} bytes")
-                st.write(f"**Python:** {sys.version}")
-                st.write(f"**OpenCV:** {cv2.__version__}")
-                import PIL
-                st.write(f"**Pillow:** {PIL.__version__}")
-            return
-
-        # Debug: Show image info (can be removed in production)
-        # st.caption(f"Image loaded: {img_rgb.shape}, dtype={img_rgb.dtype}")
-
-        # Scale image to canvas_width preserving aspect ratio
-        img_scaled, scale_ratio = scale_image_preserve_ratio(img_rgb, canvas_width)
-
-        # Apply zoom: crop a region of the scaled image and enlarge it
-        if zoom_level > 1.0:
-            zh, zw = img_scaled.shape[:2]
-            crop_h = int(zh / zoom_level)
-            crop_w = int(zw / zoom_level)
-            # Calculate crop origin from pan sliders
-            max_y = zh - crop_h
-            max_x = zw - crop_w
-            start_y = int(zoom_pan_y * max_y)
-            start_x = int(zoom_pan_x * max_x)
-            img_cropped = img_scaled[
-                start_y : start_y + crop_h,
-                start_x : start_x + crop_w,
-            ]
-            # Resize cropped region back to canvas dimensions
-            img_for_canvas = cv2.resize(
-                img_cropped, (zw, zh), interpolation=cv2.INTER_LINEAR
-            )
-        else:
-            img_for_canvas = img_scaled
-            start_x, start_y, crop_w, crop_h = (
-                0, 0, img_scaled.shape[1], img_scaled.shape[0]
-            )
-
-        canvas_h, canvas_w = img_for_canvas.shape[:2]
-
-        # Ensure image is in correct format for PIL/canvas (uint8 RGB)
-        if img_for_canvas.dtype != np.uint8:
-            img_for_canvas = img_for_canvas.astype(np.uint8)
-        if len(img_for_canvas.shape) == 2:  # Grayscale
-            img_for_canvas = cv2.cvtColor(img_for_canvas, cv2.COLOR_GRAY2RGB)
-        elif img_for_canvas.shape[2] == 4:  # RGBA
-            img_for_canvas = cv2.cvtColor(img_for_canvas, cv2.COLOR_RGBA2RGB)
-        
-        # Create PIL Image for canvas background
-        pil_background = Image.fromarray(img_for_canvas, mode='RGB')
-
-        st.subheader(
-            f"Patient {current_image['patient_id']} — "
-            f"{current_image['image_name']}"
-        )
-
-        col_canvas, col_meta = st.columns([3, 1])
-
-        # ── Canvas ─────────────────────────────────────────────────────
-        with col_canvas:
-            # How many consolidation sites exist?
-            state_key_preview = (
-                f"consol_{current_image['patient_id']}_"
-                f"{current_image['image_name']}"
-            )
-            n_sites = 1
-            if state_key_preview in st.session_state:
-                n_sites = max(1, len(st.session_state[state_key_preview]))
-
-            # ── Site picker (controls stroke colour only) ──────────────
-            # Always render the selectbox (even with 1 site) so
-            # that the widget tree structure stays stable and the
-            # canvas below never gets remounted / loses drawings.
-            if "active_site" not in st.session_state:
-                st.session_state.active_site = 0
-
-            active_site = st.selectbox(
-                "🫁 Active Consolidation Site (pick colour to draw)",
-                list(range(n_sites)),
-                format_func=lambda i: (
-                    f"Site {i + 1} — {get_color_for_index(i)[1]}"
-                ),
-                index=min(
-                    st.session_state.active_site, n_sites - 1
-                ),
-                key="site_picker",
-            )
-            st.session_state.active_site = active_site
-
-            # Active site colour
-            active_hex, active_label = get_color_for_index(active_site)
-            r_c = int(active_hex[1:3], 16)
-            g_c = int(active_hex[3:5], 16)
-            b_c = int(active_hex[5:7], 16)
-            fill_rgba = f"rgba({r_c}, {g_c}, {b_c}, 0.3)"
-
-            # Build colour legend
-            color_legend_parts = []
-            for ci in range(n_sites):
-                hex_c, label = get_color_for_index(ci)
-                marker = "▶" if ci == active_site else "⬤"
-                color_legend_parts.append(
-                    f'<span style="color:{hex_c};font-weight:bold;">'
-                    f'{marker} Site {ci + 1}</span>'
-                )
-            st.markdown(
-                " &nbsp; ".join(color_legend_parts),
-                unsafe_allow_html=True,
-            )
-
-            if zoom_level > 1.0:
-                st.write(
-                    f"**🎨 Drawing with {active_label} colour** "
-                    f"(🔍 {zoom_level:.1f}x — Scroll ↕ to zoom, "
-                    f"use arrow buttons to pan)"
-                )
-            else:
-                st.write(
-                    f"**🎨 Drawing with {active_label} colour** "
-                    f"(Scroll ↕ over image to zoom)"
-                )
-
-            # ONE canvas per image — all sites draw here.
-            # Only zoom/pan changes the key; switching active site
-            # just changes the stroke colour, keeping all drawings.
-            canvas_result = st_canvas(
-                fill_color=fill_rgba,
-                stroke_width=stroke_width,
-                stroke_color=active_hex,
-                background_image=pil_background,
-                background_color="#000000",
-                update_streamlit=True,
-                height=canvas_h,
-                width=canvas_w,
-                drawing_mode=drawing_mode,
-                key=f"canvas_{current_image['patient_id']}_"
-                    f"{current_image['image_name']}_z{zoom_level}_"
-                    f"x{zoom_pan_x}_y{zoom_pan_y}",
-            )
-
-            # --- Mouse-wheel zoom via JS injection ------------------
-            import streamlit.components.v1 as components
-            components.html(
-                """
-                <script>
-                (function() {
-                    // Find the Streamlit canvas elements
-                    const doc = window.parent.document;
-                    const canvases = doc.querySelectorAll(
-                        'canvas[id*="canvas"]'
-                    );
-                    // Also listen on the overall app container
-                    const appContainer = doc.querySelector(
-                        '[data-testid="stAppViewContainer"]'
-                    ) || doc.body;
-
-                    function handleWheel(e) {
-                        // Only act when scrolling over the canvas area
-                        const target = e.target;
-                        const isCanvas = (
-                            target.tagName === 'CANVAS' ||
-                            target.closest('.stCanvasContainer') ||
-                            target.closest('[data-testid="stImage"]')
-                        );
-                        if (!isCanvas) return;
-
-                        e.preventDefault();
-                        e.stopPropagation();
-
-                        // deltaY > 0 = scroll down = zoom out
-                        const direction = e.deltaY > 0 ? 'out' : 'in';
-
-                        // Find the zoom +/- buttons
-                        const buttons = doc.querySelectorAll('button');
-                        let targetBtn = null;
-                        for (const btn of buttons) {
-                            const txt = btn.textContent.trim();
-                            if (direction === 'in' && txt === '➕') {
-                                targetBtn = btn;
-                                break;
-                            }
-                            if (direction === 'out' && txt === '➖') {
-                                targetBtn = btn;
-                                break;
-                            }
-                        }
-                        if (targetBtn) {
-                            targetBtn.click();
-                        }
-                    }
-
-                    // Attach with capture to intercept before scroll
-                    appContainer.addEventListener(
-                        'wheel', handleWheel, {passive: false, capture: true}
-                    );
-                })();
-                </script>
-                """,
-                height=0,
-            )
-
-            # Show thumbnail with zoom rectangle when zoomed in
-            if zoom_level > 1.0:
-                st.caption("📍 Overview — red box shows current zoom region")
-                thumb_w = 250
-                thumb, _ = scale_image_preserve_ratio(img_scaled, thumb_w)
-                thumb_h_actual = thumb.shape[0]
-                # Draw rectangle on thumbnail showing zoomed area
-                th_ratio = thumb_w / img_scaled.shape[1]
-                rx1 = int(start_x * th_ratio)
-                ry1 = int(start_y * th_ratio)
-                rx2 = int((start_x + crop_w) * th_ratio)
-                ry2 = int((start_y + crop_h) * th_ratio)
-                thumb_copy = thumb.copy()
-                cv2.rectangle(thumb_copy, (rx1, ry1), (rx2, ry2),
-                              (255, 0, 0), 2)
-                st.image(thumb_copy, width=thumb_w)
-
-        # ── Metadata column ─────���─────────────────────────────────────
-        with col_meta:
-            st.write("**📝 Annotation Metadata**")
-
-            # Load existing metadata if any
-            existing_metadata = {}
-            if current_image["metadata_path"].exists():
-                try:
-                    with open(current_image["metadata_path"], "r") as f:
-                        existing_metadata = json.load(f)
-                except Exception:
-                    pass
-
-            # ── Multilobar consolidations ──────────────────────────────
-            st.write("**🫁 Consolidation Sites**")
-
-            location_options = [
-                "Right Upper Lobe",
-                "Right Middle Lobe",
-                "Right Lower Lobe",
-                "Left Upper Lobe",
-                "Left Lower Lobe",
-                "Lingula",
-            ]
-            type_options = [
-                "Solid Consolidation",
-                "Ground Glass Opacity",
-                "Air Bronchograms",
-                "Pleural Effusion",
-                "Mixed",
-            ]
-
-            # Initialise session-state list for consolidations
-            state_key = (
-                f"consol_{current_image['patient_id']}_"
-                f"{current_image['image_name']}"
-            )
-            if state_key not in st.session_state:
-                # Pre-fill from existing metadata
-                saved = existing_metadata.get("consolidations", [])
-                if saved:
-                    st.session_state[state_key] = saved
-                else:
-                    st.session_state[state_key] = [
-                        {"location": "Right Lower Lobe",
-                         "type": "Solid Consolidation"}
-                    ]
-
-            consolidations = st.session_state[state_key]
-
-            # Render each consolidation entry
-            for idx, entry in enumerate(consolidations):
-                site_hex, site_label = get_color_for_index(idx)
-                with st.expander(
-                    f"⬤ Site {idx + 1}: {entry['location']}  "
-                    f"({site_label})",
-                    expanded=True,
-                ):
-                    loc = st.selectbox(
-                        "Location",
-                        location_options,
-                        index=(
-                            location_options.index(entry["location"])
-                            if entry["location"] in location_options
-                            else 0
-                        ),
-                        key=f"loc_{state_key}_{idx}",
-                    )
-                    ctype = st.selectbox(
-                        "Type",
-                        type_options,
-                        index=(
-                            type_options.index(entry["type"])
-                            if entry["type"] in type_options
-                            else 0
-                        ),
-                        key=f"type_{state_key}_{idx}",
-                    )
-                    consolidations[idx] = {"location": loc, "type": ctype}
-
-                    if len(consolidations) > 1:
-                        if st.button(
-                            "🗑️ Remove", key=f"rm_{state_key}_{idx}",
-                            use_container_width=True,
-                        ):
-                            consolidations.pop(idx)
-                            st.rerun()
-
-            if st.button("➕ Add Another Consolidation Site",
-                         use_container_width=True):
-                consolidations.append(
-                    {"location": "Left Lower Lobe",
-                     "type": "Solid Consolidation"}
-                )
-                # Auto-switch to the new site so the next strokes
-                # use the new colour immediately
-                st.session_state.active_site = len(consolidations) - 1
-                st.rerun()
-
-            st.divider()
-
-            # Pattern summary
-            involved_lobes = list({c["location"] for c in consolidations})
-            if len(involved_lobes) >= 2:
-                st.info(
-                    f"🔴 **Multilobar** pneumonia — "
-                    f"{len(involved_lobes)} lobes involved"
-                )
-            else:
-                st.info(f"🟡 **Unilobar** — {involved_lobes[0]}")
-
-            confidence = st.slider(
-                "Confidence",
-                min_value=1,
-                max_value=5,
-                value=existing_metadata.get("confidence", 5),
-            )
-            notes = st.text_area(
-                "Clinical Notes",
-                value=existing_metadata.get("clinical_notes", ""),
-                placeholder="E.g., Silhouette sign present, bilateral involvement",
-            )
-
-            # Drawn area stats
-            if canvas_result.image_data is not None:
-                alpha = canvas_result.image_data[:, :, 3]
-                drawn_px = int(np.sum(alpha > 0))
-                total_px = alpha.shape[0] * alpha.shape[1]
-                if drawn_px > 0:
-                    st.metric(
-                        "Drawn Area",
-                        f"{(drawn_px / total_px) * 100:.2f}%",
-                    )
-                    st.metric("Pixels", f"{drawn_px:,}")
-
-            st.divider()
-
-            # ── Save / Delete ──────────────────────────────────────────
-            b1, b2 = st.columns(2)
-
-            def _build_metadata():
-                return {
-                    "consolidations": consolidations,
-                    "involved_lobes": involved_lobes,
-                    "multilobar": len(involved_lobes) >= 2,
-                    "confidence": confidence,
-                    "clinical_notes": notes,
-                }
-
-            with b1:
-                if st.button(
-                    "💾 Save & Next", type="primary",
-                    use_container_width=True,
-                ):
-                    if (
-                        canvas_result.image_data is not None
-                        and np.sum(canvas_result.image_data[:, :, 3] > 0) > 0
-                    ):
-                        mask = canvas_result.image_data[:, :, 3]
-                        save_annotation_in_patient_folder(
-                            current_image["image_path"],
-                            mask,
-                            annotator_name,
-                            _build_metadata(),
-                            img_rgb.shape,
-                        )
-                        st.success("✅ Saved!")
-                        if (
-                            st.session_state.current_index
-                            < len(filtered_images) - 1
-                        ):
-                            st.session_state.current_index += 1
-                        st.rerun()
-                    else:
-                        st.error("Please draw an annotation first!")
-
-            with b2:
-                if st.button("💾 Save Only", use_container_width=True):
-                    if (
-                        canvas_result.image_data is not None
-                        and np.sum(canvas_result.image_data[:, :, 3] > 0) > 0
-                    ):
-                        mask = canvas_result.image_data[:, :, 3]
-                        save_annotation_in_patient_folder(
-                            current_image["image_path"],
-                            mask,
-                            annotator_name,
-                            _build_metadata(),
-                            img_rgb.shape,
-                        )
-                        st.success("✅ Saved!")
-                    else:
-                        st.error("Please draw an annotation first!")
-
-            if current_image["annotated"]:
-                if st.button("🗑️ Delete Annotation",
-                             use_container_width=True):
-                    if current_image["mask_path"].exists():
-                        current_image["mask_path"].unlink()
-                    if current_image["metadata_path"].exists():
-                        current_image["metadata_path"].unlink()
-                    st.success("Annotation deleted!")
-                    st.rerun()
-
-            # ── Download Buttons ───────────────────────────────────────
-            st.divider()
-            st.write("**📥 Download Annotation**")
-            
-            # Generate file ID from patient_id and image name
-            file_id = f"{current_image['patient_id']}_{current_image['image_path'].stem}"
-            
-            # Download mask
-            if (
-                canvas_result.image_data is not None
-                and np.sum(canvas_result.image_data[:, :, 3] > 0) > 0
-            ):
-                # Create mask from current canvas
-                mask_data = canvas_result.image_data[:, :, 3]
-                # Resize to original image dimensions
-                orig_h, orig_w = img_rgb.shape[:2]
-                mask_resized = cv2.resize(
-                    mask_data, (orig_w, orig_h), interpolation=cv2.INTER_NEAREST
-                )
-                
-                # Encode mask as PNG
-                _, mask_buffer = cv2.imencode(".png", mask_resized)
-                mask_bytes = mask_buffer.tobytes()
-                
-                # Create JSON metadata
-                metadata_download = {
-                    "image_id": file_id,
-                    "image_name": current_image["image_name"],
-                    "patient_id": current_image["patient_id"],
-                    "annotator": annotator_name,
-                    "timestamp": datetime.now().strftime("%Y%m%d_%H%M%S"),
-                    "consolidations": consolidations,
-                    "involved_lobes": involved_lobes,
-                    "multilobar": len(involved_lobes) >= 2,
-                    "confidence": confidence,
-                    "clinical_notes": notes,
-                    "mask_dimensions": {"width": orig_w, "height": orig_h},
-                    "annotated_pixels": int(np.sum(mask_resized > 0)),
-                    "annotated_area_percent": float(
-                        np.sum(mask_resized > 0) / (orig_w * orig_h) * 100
-                    ),
-                }
-                json_bytes = json.dumps(metadata_download, indent=2).encode("utf-8")
-                
-                dl1, dl2 = st.columns(2)
-                with dl1:
-                    st.download_button(
-                        label="📥 Download Mask (PNG)",
-                        data=mask_bytes,
-                        file_name=f"{file_id}_mask.png",
-                        mime="image/png",
-                        use_container_width=True,
-                    )
-                with dl2:
-                    st.download_button(
-                        label="📥 Download JSON",
-                        data=json_bytes,
-                        file_name=f"{file_id}_annotation.json",
-                        mime="application/json",
-                        use_container_width=True,
-                    )
-                
-                st.caption(f"Files will be named: `{file_id}_mask.png` and `{file_id}_annotation.json`")
-            
-            elif current_image["annotated"] and current_image["mask_path"].exists():
-                # Load existing saved annotation for download
-                existing_mask = cv2.imread(
-                    str(current_image["mask_path"]), cv2.IMREAD_GRAYSCALE
-                )
-                if existing_mask is not None:
-                    _, mask_buffer = cv2.imencode(".png", existing_mask)
-                    mask_bytes = mask_buffer.tobytes()
-                    
-                    # Load existing JSON
-                    if current_image["metadata_path"].exists():
-                        with open(current_image["metadata_path"], "r") as f:
-                            existing_json = json.load(f)
-                        json_bytes = json.dumps(existing_json, indent=2).encode("utf-8")
-                    else:
-                        json_bytes = b"{}"
-                    
-                    dl1, dl2 = st.columns(2)
-                    with dl1:
-                        st.download_button(
-                            label="📥 Download Saved Mask",
-                            data=mask_bytes,
-                            file_name=f"{file_id}_mask.png",
-                            mime="image/png",
-                            use_container_width=True,
-                        )
-                    with dl2:
-                        st.download_button(
-                            label="📥 Download Saved JSON",
-                            data=json_bytes,
-                            file_name=f"{file_id}_annotation.json",
-                            mime="application/json",
-                            use_container_width=True,
-                        )
-                    st.caption(f"Files: `{file_id}_mask.png` / `{file_id}_annotation.json`")
-            else:
-                st.info("Draw an annotation to enable downloads")
-
-    # ================================================================
-    # TAB 2 — COMPARE
-    # ================================================================
-    with tab2:
-        st.header("Compare Annotations Between Radiologists")
-
-        cmp1, cmp2 = st.columns(2)
-        with cmp1:
-            st.subheader("Radiologist 1")
-            mask1_file = st.file_uploader(
-                "Upload Mask 1", type=["png"], key="comp1"
-            )
-            name1 = st.text_input("Name", value="Radiologist 1", key="name1")
-        with cmp2:
-            st.subheader("Radiologist 2")
-            mask2_file = st.file_uploader(
-                "Upload Mask 2", type=["png"], key="comp2"
-            )
-            name2 = st.text_input("Name", value="Radiologist 2", key="name2")
-
-        if mask1_file and mask2_file:
-            mask1 = cv2.imdecode(
-                np.frombuffer(mask1_file.read(), np.uint8),
-                cv2.IMREAD_GRAYSCALE,
-            )
-            mask1_file.seek(0)
-            mask2 = cv2.imdecode(
-                np.frombuffer(mask2_file.read(), np.uint8),
-                cv2.IMREAD_GRAYSCALE,
-            )
-            mask2_file.seek(0)
-
-            if mask1.shape != mask2.shape:
-                mask2 = cv2.resize(mask2, (mask1.shape[1], mask1.shape[0]))
-
-            dice = calculate_dice_coefficient(mask1, mask2)
-            iou = calculate_iou(mask1, mask2)
-            precision, recall = calculate_precision_recall(mask1, mask2)
-
-            st.subheader("📊 Inter-Rater Agreement")
-            m1, m2, m3, m4 = st.columns(4)
-            m1.metric("Dice", f"{dice:.4f}")
-            m2.metric("IoU", f"{iou:.4f}")
-            m3.metric("Precision", f"{precision:.4f}")
-            m4.metric("Recall", f"{recall:.4f}")
-
-            if dice >= 0.80:
-                st.success("✅ Excellent Agreement")
-            elif dice >= 0.70:
-                st.info("ℹ️ Good Agreement")
-            elif dice >= 0.50:
-                st.warning("⚠️ Fair Agreement — Review recommended")
-            else:
-                st.error("❌ Poor Agreement — Consensus needed")
-
-            st.subheader("Visual Comparison")
-            overlay = np.zeros(
-                (mask1.shape[0], mask1.shape[1], 3), dtype=np.uint8
-            )
-            overlay[mask1 > 0] = [0, 255, 0]
-            overlap = (mask1 > 0) & (mask2 > 0)
-            overlay[mask2 > 0] = [255, 0, 0]
-            overlay[overlap] = [255, 255, 0]
-            st.image(
-                overlay,
-                caption=(
-                    f"Green: {name1} | Red: {name2} | Yellow: Agreement"
-                ),
-                use_column_width=True,
-            )
-
-    # ================================================================
-    # TAB 3 — GUIDELINES
-    # ================================================================
-    with tab3:
-        st.header("📖 Annotation Guidelines")
-        st.markdown(
-            """
-### What to Annotate
-
-**Pneumonia consolidation** appears as white / opaque areas where air
-spaces are filled with fluid.
-
-### Multilobar Pneumonia
-
-When consolidation is present in **more than one lobe**, add a separate
-consolidation entry for each affected site using the **"➕ Add Another
-Consolidation Site"** button. This lets us track multilobar involvement
-accurately.
-
-### Key Radiologic Signs
-
-#### ✅ Include in Your Mask
-1. **Air Bronchograms** — Dark branching tubes inside consolidation
-2. **Silhouette Sign** — Heart / diaphragm border lost in consolidation
-3. **Solid Consolidation** — Dense white opaque areas
-4. **Ground Glass Opacity** — Subtle hazy areas at edges
-
-#### ❌ Exclude from Your Mask
-1. **Ribs** — Trace "through" rib shadows
-2. **Normal lung tissue** — Don't over-segment
-3. **Pleural effusion** (unless asked) — Smooth meniscus sign
-
-### Drawing Tools
-| Tool | Use for |
-|---|---|
-| **freedraw** | Freehand tracing of consolidation borders |
-| **rect** | Quick rectangular ROI |
-| **circle** | Circular / oval regions |
-| **line** | Straight edge tracing |
-
-### Colors
-Each consolidation site is automatically assigned a **unique colour**
-(Lime, Red, Blue, Gold, …). Select the active site before drawing
-so annotations are visually distinguishable.
-
-### Tips
-1. **Draw directly** on the canvas — no external tools needed
-2. **Adjust brush size** with the sidebar slider
-3. **Zoom**: scroll ↕ your mouse wheel over the image, or use the
-   ➕ / ➖ buttons in the sidebar
-4. **Pan**: when zoomed in, use the arrow buttons (⬅️➡️⬆️⬇️) or
-   sliders to navigate
-5. **Be consistent** — same criteria for every image
-
-### Quality Metrics
-| Dice Score | Interpretation |
-|---|---|
-| > 0.80 | ✅ Excellent agreement |
-| 0.70 – 0.80 | Good agreement |
-| < 0.70 | ⚠️ Needs review / consensus |
-"""
-        )
-
-
-if __name__ == "__main__":
-    main()

src/test_image_loading.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify image loading works correctly.
-Run this to diagnose JPG rendering issues.
-"""
-
-import sys
-from pathlib import Path
-
-# Check Python version
-print(f"Python version: {sys.version}")
-print(f"Python executable: {sys.executable}")
-print("-" * 50)
-
-# Test imports
-print("Testing imports...")
-try:
-    import numpy as np
-    print(f"✅ numpy: {np.__version__}")
-except ImportError as e:
-    print(f"❌ numpy: {e}")
-
-try:
-    import cv2
-    print(f"✅ opencv: {cv2.__version__}")
-except ImportError as e:
-    print(f"❌ opencv: {e}")
-
-try:
-    from PIL import Image
-    import PIL
-    print(f"✅ Pillow: {PIL.__version__}")
-except ImportError as e:
-    print(f"❌ Pillow: {e}")
-
-try:
-    import streamlit as st
-    print(f"✅ streamlit: {st.__version__}")
-except ImportError as e:
-    print(f"❌ streamlit: {e}")
-
-print("-" * 50)
-
-# Test image loading functions
-def test_load_image(image_path):
-    """Test different methods of loading an image."""
-    image_path = Path(image_path)
-    print(f"\nTesting: {image_path}")
-    print(f"  Exists: {image_path.exists()}")
-    
-    if not image_path.exists():
-        print("  ❌ File not found!")
-        return None
-    
-    # Method 1: PIL
-    try:
-        with Image.open(image_path) as pil_img:
-            if pil_img.mode != 'RGB':
-                pil_img = pil_img.convert('RGB')
-            img = np.array(pil_img)
-            print(f"  ✅ PIL loaded: shape={img.shape}, dtype={img.dtype}")
-    except Exception as e:
-        print(f"  ❌ PIL failed: {e}")
-    
-    # Method 2: cv2.imread
-    try:
-        img = cv2.imread(str(image_path))
-        if img is not None:
-            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            print(f"  ✅ cv2.imread loaded: shape={img_rgb.shape}, dtype={img_rgb.dtype}")
-        else:
-            print(f"  ❌ cv2.imread returned None")
-    except Exception as e:
-        print(f"  ❌ cv2.imread failed: {e}")
-    
-    # Method 3: cv2.imdecode (bytes)
-    try:
-        with open(image_path, 'rb') as f:
-            file_bytes = f.read()
-        nparr = np.frombuffer(file_bytes, np.uint8)
-        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        if img is not None:
-            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            print(f"  ✅ cv2.imdecode loaded: shape={img_rgb.shape}, dtype={img_rgb.dtype}")
-        else:
-            print(f"  ❌ cv2.imdecode returned None")
-    except Exception as e:
-        print(f"  ❌ cv2.imdecode failed: {e}")
-    
-    return img
-
-# Find and test images
-print("\nSearching for test images...")
-base_dirs = [
-    Path("./uploaded_images"),
-    Path("./Pacientes"),
-    Path("."),
-]
-
-test_images = []
-for base in base_dirs:
-    if base.exists():
-        for ext in ["*.jpg", "*.JPG", "*.jpeg", "*.png"]:
-            test_images.extend(list(base.glob(f"**/{ext}"))[:2])
-
-if test_images:
-    print(f"Found {len(test_images)} images to test")
-    for img_path in test_images[:5]:  # Test up to 5 images
-        test_load_image(img_path)
-else:
-    print("No images found. Creating a test image...")
-    # Create a simple test image
-    test_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
-    test_path = Path("./test_image.jpg")
-    cv2.imwrite(str(test_path), test_img)
-    print(f"Created test image: {test_path}")
-    test_load_image(test_path)
-
-print("\n" + "=" * 50)
-print("Test complete!")
-print("=" * 50)