Deploy VREyeSAM

.dockerignore

@@ -0,0 +1,60 @@
+# Git
+.git
+.gitignore
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+vreyesam_env/
+venv/
+env/
+ENV/
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# Data and models (downloaded during build)
+VRBiomSegM/
+segment-anything-2/
+
+# Outputs
+*.jpg
+*.png
+*.jpeg
+loss_plots/
+predictions/
+results/
+output/
+VREyeSAM_results/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+docs/`
+*.md
+!README.md
+
+# Training scripts (not needed for deployment)
+Training.py
+Test.py
+Inference.py

.gitignore

@@ -0,0 +1,62 @@
+# Virtual Environment
+vreyesam_env/
+venv/
+env/
+ENV/
+
+# Python cache and compiled files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Large external directories
+segment-anything-2/
+
+# Model checkpoints and weights
+*.torch
+*.pth
+*.pt
+
+# Data directories
+VRBiomSegM/
+
+# Output files
+*.jpg
+*.png
+*.jpeg
+loss_plots/
+predictions/
+results/
+output/
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+*.ipynb
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

Dockerfile

@@ -1,20 +1,49 @@
-FROM python:3.13.5-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
     git \
+    wget \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy requirements first for better caching
+COPY requirements_deploy.txt .
 
-RUN pip3 install -r requirements.txt
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements_deploy.txt
 
-EXPOSE 8501
+# Clone SAM2 repository
+RUN git clone https://github.com/facebookresearch/segment-anything-2.git && \
+    cd segment-anything-2 && \
+    pip install --no-cache-dir -e .
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Download SAM2 checkpoint
+RUN mkdir -p segment-anything-2/checkpoints && \
+    cd segment-anything-2/checkpoints && \
+    wget https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Download VREyeSAM fine-tuned weights from Hugging Face
+RUN pip install --no-cache-dir huggingface-hub && \
+    huggingface-cli download devnagaich/VREyeSAM VREyeSAM_uncertainity_best.torch \
+    --local-dir segment-anything-2/checkpoints/
+
+# Copy application files
+COPY app.py .
+
+# Expose Streamlit port
+EXPOSE 7860
+
+# Set environment variables
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+ENV STREAMLIT_SERVER_HEADLESS=true
+
+# Run the application
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,20 +1,122 @@
 ---
-title: VREyeSAM
-emoji: 🚀
-colorFrom: red
-colorTo: red
+title: VREyeSAM - Iris Segmentation
+emoji: 👁️
+colorFrom: blue
+colorTo: green
 sdk: docker
-app_port: 8501
-tags:
-- streamlit
 pinned: false
-short_description: Streamlit template space
 license: mit
 ---
 
-# Welcome to Streamlit!
+# VREyeSAM: Virtual Reality Non-Frontal Iris Segmentation
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+![VREyeSAM Demo](https://img.shields.io/badge/Status-Active-success)
+![Python](https://img.shields.io/badge/Python-3.11+-blue)
+![PyTorch](https://img.shields.io/badge/PyTorch-2.0+-red)
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## 🎯 Overview
+
+VREyeSAM is a robust iris segmentation framework designed specifically for non-frontal iris images captured in virtual reality and head-mounted device environments. Built on Meta's Segment Anything Model 2 (SAM2) with a novel uncertainty-weighted loss function, VREyeSAM achieves state-of-the-art performance on challenging VR/AR iris segmentation tasks.
+
+## 🚀 Features
+
+- **Upload & Segment**: Upload any non-frontal iris image for instant segmentation
+- **Binary Mask Generation**: Get precise binary segmentation masks
+- **Iris Extraction**: Automatically extract and display the iris region as a rectangular strip
+- **Visualization Options**: View overlay masks and probabilistic confidence maps
+- **Download Results**: Save all segmentation outputs with one click
+
+## 📊 Performance Metrics
+
+- **Precision**: 0.751
+- **Recall**: 0.870
+- **F1-Score**: 0.806
+- **Mean IoU**: 0.647
+
+Evaluated on the VRBiom dataset, VREyeSAM significantly outperforms existing segmentation methods.
+
+## 🔬 Technical Details
+
+### Architecture
+VREyeSAM leverages:
+- **Base Model**: SAM2 (Segment Anything Model 2) with Hiera-Small backbone
+- **Fine-tuning**: Custom uncertainty-weighted hybrid loss function
+- **Training Data**: VRBiomSegM dataset with non-frontal iris images
+- **Inference**: Point-prompt based segmentation with ensemble predictions
+
+### Key Innovations
+1. **Quality-aware Pre-processing**: Automatically filters partially/fully closed eyes
+2. **Uncertainty-weighted Loss**: Adaptively balances multiple learning objectives
+3. **Multi-point Sampling**: Uses 30 random points for robust predictions
+4. **Probabilistic Masking**: Generates confidence-weighted segmentation
+
+## 🎓 Citation
+
+If you use VREyeSAM in your research, please cite:
+
+```bibtex
+@article{sharma2025vreyesam,
+  title={VREyeSAM: Virtual Reality Non-Frontal Iris Segmentation using Foundational Model with Uncertainty Weighted Loss},
+  author={Sharma, Geetanjali and Nagaich, Dev and Jaswal, Gaurav and Nigam, Aditya and Ramachandra, Raghavendra},
+  conference={IJCB},
+  year={2025}
+}
+```
+
+## 👥 Authors
+
+- **Geetanjali Sharma** - Indian Institute of Technology Mandi, India
+- **Dev Nagaich** - Indian Institute of Technology Mandi, India
+- **Gaurav Jaswal** - Division of Digital Forensics, Directorate of Forensic Services, Shimla, India
+- **Aditya Nigam** - Indian Institute of Technology Mandi, India
+- **Raghavendra Ramachandra** - Norwegian University of Science and Technology (NTNU), Norway
+
+## 📧 Contact
+
+For dataset access or questions:
+- **Email**: geetanjalisharma546@gmail.com
+- **GitHub**: [VREyeSAM Repository](https://github.com/GeetanjaliGTZ/VREyeSAM)
+
+## 🔗 Resources
+
+- [Paper on ResearchGate](https://www.researchgate.net/publication/400248367_VREyeSAM_Virtual_Reality_Non-Frontal_Iris_Segmentation_using_Foundational_Model_with_uncertainty_weighted_loss)
+- [GitHub Repository](https://github.com/GeetanjaliGTZ/VREyeSAM)
+- [Model Weights on Hugging Face](https://huggingface.co/devnagaich/VREyeSAM)
+
+## 📝 License
+
+This project is licensed under the MIT License.
+
+## 🙏 Acknowledgments
+
+- Meta AI for the Segment Anything Model 2 (SAM2)
+- VRBiom dataset contributors
+- Indian Institute of Technology Mandi
+- Norwegian University of Science and Technology
+
+## 🛠️ Usage Instructions
+
+1. **Upload Image**: Click on the upload button and select a non-frontal iris image
+2. **Segment**: Click the "Segment Iris" button to process the image
+3. **View Results**: Explore the binary mask, overlay, and extracted iris strip
+4. **Download**: Save any of the results using the download buttons
+
+## ⚙️ Model Details
+
+- **Model Type**: Image Segmentation
+- **Base Architecture**: SAM2 (Hiera-Small)
+- **Training Dataset**: VRBiomSegM (contact for access)
+- **Input Size**: Up to 1024px (auto-resized)
+- **Output**: Binary mask + Probabilistic confidence map
+- **Device**: CUDA GPU (falls back to CPU if unavailable)
+
+## 🔍 Use Cases
+
+- **Biometric Authentication**: Secure iris recognition in VR/AR environments
+- **Medical Applications**: Iris analysis in non-ideal capture conditions
+- **Research**: Benchmark for non-frontal iris segmentation
+- **VR/AR Development**: Integration into head-mounted devices
+
+---
+
+**Note**: This is a research prototype. For production use, please contact the authors.

app.py

@@ -0,0 +1,326 @@
+import streamlit as st
+import cv2
+import torch
+import numpy as np
+from PIL import Image
+import io
+import sys
+import os
+
+# Add segment-anything-2 to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "segment-anything-2"))
+
+from sam2.build_sam import build_sam2
+from sam2.sam2_image_predictor import SAM2ImagePredictor
+
+# Page config
+st.set_page_config(
+    page_title="VREyeSAM - Non-frontal Iris Segmentation",
+    page_icon="👁️",
+    layout="wide"
+)
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .main {
+        padding: 2rem;
+    }
+    .stButton>button {
+        width: 100%;
+        background-color: #4CAF50;
+        color: white;
+        padding: 0.5rem;
+        font-size: 16px;
+    }
+    .result-box {
+        border: 2px solid #ddd;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+@st.cache_resource
+def load_model():
+    """Load the VREyeSAM model"""
+    try:
+        model_cfg = "configs/sam2/sam2_hiera_s.yaml"
+        sam2_checkpoint = "segment-anything-2/checkpoints/sam2_hiera_small.pt"
+        fine_tuned_weights = "segment-anything-2/checkpoints/VREyeSAM_uncertainity_best.torch"
+        
+        sam2_model = build_sam2(model_cfg, sam2_checkpoint, device="cuda" if torch.cuda.is_available() else "cpu")
+        predictor = SAM2ImagePredictor(sam2_model)
+        predictor.model.load_state_dict(torch.load(fine_tuned_weights, map_location="cuda" if torch.cuda.is_available() else "cpu"))
+        
+        return predictor
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
+        return None
+
+def read_and_resize_image(image):
+    """Read and resize image for processing"""
+    img = np.array(image)
+    if len(img.shape) == 2:  # Grayscale
+        img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+    elif img.shape[2] == 4:  # RGBA
+        img = cv2.cvtColor(img, cv2.COLOR_RGBA2RGB)
+    
+    # Resize if needed
+    r = np.min([1024 / img.shape[1], 1024 / img.shape[0]])
+    if r < 1:
+        img = cv2.resize(img, (int(img.shape[1] * r), int(img.shape[0] * r)))
+    
+    return img
+
+def segment_iris(predictor, image):
+    """Perform iris segmentation"""
+    # Generate random points for inference
+    num_samples = 30
+    input_points = np.random.randint(0, min(image.shape[:2]), (num_samples, 1, 2))
+    
+    # Inference
+    with torch.no_grad():
+        predictor.set_image(image)
+        masks, scores, _ = predictor.predict(
+            point_coords=input_points,
+            point_labels=np.ones([input_points.shape[0], 1])
+        )
+    
+    # Convert to numpy
+    np_masks = np.array(masks[:, 0]).astype(np.float32)
+    np_scores = scores[:, 0]
+    
+    # Normalize scores
+    score_sum = np.sum(np_scores)
+    if score_sum > 0:
+        normalized_scores = np_scores / score_sum
+    else:
+        normalized_scores = np.ones_like(np_scores) / len(np_scores)
+    
+    # Generate probabilistic mask
+    prob_mask = np.sum(np_masks * normalized_scores[:, None, None], axis=0)
+    prob_mask = np.clip(prob_mask, 0, 1)
+    
+    # Threshold to get binary mask
+    binary_mask = (prob_mask > 0.2).astype(np.uint8)
+    
+    return binary_mask, prob_mask
+
+def extract_iris_strip(image, binary_mask):
+    """Extract iris region and create a rectangular strip"""
+    # Find contours in binary mask
+    contours, _ = cv2.findContours(binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    if len(contours) == 0:
+        return None
+    
+    # Get the largest contour (assumed to be the iris)
+    largest_contour = max(contours, key=cv2.contourArea)
+    x, y, w, h = cv2.boundingRect(largest_contour)
+    
+    # Add some padding
+    padding = 10
+    x = max(0, x - padding)
+    y = max(0, y - padding)
+    w = min(image.shape[1] - x, w + 2 * padding)
+    h = min(image.shape[0] - y, h + 2 * padding)
+    
+    # Extract the iris region
+    iris_region = image[y:y+h, x:x+w]
+    
+    # Create a rectangular strip (normalize height)
+    strip_height = 150
+    aspect_ratio = w / h
+    strip_width = int(strip_height * aspect_ratio)
+    
+    iris_strip = cv2.resize(iris_region, (strip_width, strip_height))
+    
+    return iris_strip
+
+def overlay_mask_on_image(image, binary_mask, color=(0, 255, 0), alpha=0.5):
+    """Overlay binary mask on original image"""
+    overlay = image.copy()
+    mask_colored = np.zeros_like(image)
+    mask_colored[binary_mask > 0] = color
+    
+    # Blend
+    result = cv2.addWeighted(overlay, 1-alpha, mask_colored, alpha, 0)
+    
+    return result
+
+# Main App
+def main():
+    st.title("👁️ VREyeSAM: Non-Frontal Iris Segmentation")
+    st.markdown("""
+    Upload a non-frontal iris image captured in VR/AR environments, and VREyeSAM will segment the iris region 
+    using a fine-tuned SAM2 model with uncertainty-weighted loss.
+    """)
+    
+    # Sidebar
+    with st.sidebar:
+        st.header("About VREyeSAM")
+        st.markdown("""
+        **VREyeSAM** is a robust iris segmentation framework designed for images captured under:
+        - Varying gaze directions
+        - Partial occlusions
+        - Inconsistent lighting conditions
+        
+        **Model Performance:**
+        - Precision: 0.751
+        - Recall: 0.870
+        - F1-Score: 0.806
+        - Mean IoU: 0.647
+        
+        
+        """)
+        
+        st.header("Settings")
+        show_overlay = st.checkbox("Show mask overlay", value=True)
+        show_probabilistic = st.checkbox("Show probabilistic mask", value=False)
+    
+    # Load model
+    with st.spinner("Loading VREyeSAM model..."):
+        predictor = load_model()
+    
+    if predictor is None:
+        st.error("Failed to load model. Please check the setup.")
+        return
+    
+    st.success("✅ Model loaded successfully!")
+    
+    # File uploader
+    uploaded_file = st.file_uploader(
+        "Upload an iris image (JPG, PNG, JPEG)",
+        type=["jpg", "png", "jpeg"],
+        help="Upload a non-frontal iris image for segmentation"
+    )
+    
+    if uploaded_file is not None:
+        # Display original image
+        image = Image.open(uploaded_file)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("📷 Original Image")
+            st.image(image, use_container_width=True)
+        
+        # Process button
+        if st.button("🔍 Segment Iris", type="primary"):
+            with st.spinner("Segmenting iris..."):
+                # Prepare image
+                img_array = read_and_resize_image(image)
+                
+                # Perform segmentation
+                binary_mask, prob_mask = segment_iris(predictor, img_array)
+                
+                # Extract iris strip
+                 ## iris_strip = extract_iris_strip(img_array, binary_mask)
+                
+                with col2:
+                    st.subheader("🎯 Binary Mask")
+                    binary_mask_img = (binary_mask * 255).astype(np.uint8)
+                    st.image(binary_mask_img, use_container_width=True)
+                
+                # Additional results
+                st.markdown("---")
+                st.subheader("📊 Segmentation Results")
+                
+                result_cols = st.columns(3)
+                
+                with result_cols[0]:
+                    if show_overlay:
+                        st.markdown("**Overlay View**")
+                        overlay = overlay_mask_on_image(img_array, binary_mask)
+                        st.image(overlay, use_container_width=True)
+                
+                with result_cols[1]:
+                    if show_probabilistic:
+                        st.markdown("**Probabilistic Mask**")
+                        prob_mask_img = (prob_mask * 255).astype(np.uint8)
+                        st.image(prob_mask_img, use_container_width=True)
+                
+        #        with result_cols[2]:
+        #           if iris_strip is not None:
+        #                st.markdown("**Extracted Iris Strip**")
+        #                st.image(iris_strip, use_container_width=True)
+        #           else:
+        #                st.warning("No iris region detected")
+                
+                # Download options
+                st.markdown("---")
+                st.subheader("💾 Download Results")
+                
+                download_cols = st.columns(3)
+                
+                with download_cols[0]:
+                    # Binary mask download
+                    binary_pil = Image.fromarray(binary_mask_img)
+                    buf = io.BytesIO()
+                    binary_pil.save(buf, format="PNG")
+                    st.download_button(
+                        label="Download Binary Mask",
+                        data=buf.getvalue(),
+                        file_name="binary_mask.png",
+                        mime="image/png"
+                    )
+                
+                with download_cols[1]:
+                    if show_overlay:
+                        # Overlay download
+                        overlay_pil = Image.fromarray(cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB))
+                        buf = io.BytesIO()
+                        overlay_pil.save(buf, format="PNG")
+                        st.download_button(
+                            label="Download Overlay",
+                            data=buf.getvalue(),
+                            file_name="overlay.png",
+                            mime="image/png"
+                        )
+                
+        #        with download_cols[2]:
+        #           if iris_strip is not None:
+        #                # Iris strip download
+        #                strip_pil = Image.fromarray(cv2.cvtColor(iris_strip, cv2.COLOR_BGR2RGB))
+        #                buf = io.BytesIO()
+        #                strip_pil.save(buf, format="PNG")
+        #                st.download_button(
+        #                    label="Download Iris Strip",
+        #                    data=buf.getvalue(),
+        #                    file_name="iris_strip.png",
+        #                    mime="image/png"
+        #                )
+                
+                # Statistics
+                st.markdown("---")
+                st.subheader("📈 Segmentation Statistics")
+                stats_cols = st.columns(4)
+                
+                mask_area = np.sum(binary_mask > 0)
+                total_area = binary_mask.shape[0] * binary_mask.shape[1]
+                coverage = (mask_area / total_area) * 100
+                
+                with stats_cols[0]:
+                    st.metric("Mask Coverage", f"{coverage:.2f}%")
+                with stats_cols[1]:
+                    st.metric("Image Size", f"{img_array.shape[1]}x{img_array.shape[0]}")
+                with stats_cols[2]:
+                    st.metric("Mask Area (pixels)", f"{mask_area:,}")
+        #        with stats_cols[3]:
+        #            if iris_strip is not None:
+        #                st.metric("Strip Size", f"{iris_strip.shape[1]}x{iris_strip.shape[0]}")
+
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center'>
+        <p><strong>VREyeSAM</strong> - Virtual Reality Non-Frontal Iris Segmentation</p>
+        <p>🔗 <a href='https://github.com/GeetanjaliGTZ/VREyeSAM'>GitHub</a> | 
+        📧 <a href='mailto:geetanjalisharma546@gmail.com'>Contact</a></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,39 @@
-altair
-pandas
-streamlit
+# VREyeSAM Requirements - Fixed Version Constraints
+# Compatible with Python 3.11+
+# This version resolves NumPy conflicts with gensim and numba
+
+# Web Interface
+streamlit>=1.28.0,<2.0.0
+
+# Core ML and Deep Learning - COMPATIBLE VERSIONS
+torch==2.3.0
+torchvision==0.18.0
+numpy>=1.22.0,<2.0.0
+
+# Computer Vision
+opencv-python-headless>=4.5.0,<5.0.0
+Pillow>=8.0.0,<11.0.0
+
+# Data Processing and ML
+pandas>=1.3.0,<3.0.0
+scikit-learn>=1.0.0,<2.0.0
+
+# Visualization
+matplotlib>=3.5.0,<4.0.0
+
+# Utility
+tqdm>=4.62.0,<5.0.0
+hydra-core>=1.1.0,<2.0.0
+omegaconf>=2.1.0,<3.0.0
+
+# For downloading model weights
+huggingface-hub>=0.19.0,<1.0.0
+
+# Note: Install PyTorch with CUDA support separately if needed:
+# For CUDA 11.8: pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cu118
+# For CUDA 12.1: pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cu121
+# For CPU only: pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cpu
+
+# SAM2 will be installed separately from git:
+# git clone https://github.com/facebookresearch/segment-anything-2
+# cd segment-anything-2 && pip install -e . && cd ..

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

test_app_local.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Local Testing Script for VREyeSAM Streamlit App
+
+Run this script to test the app locally before deploying to Hugging Face Spaces.
+Usage: python test_app_local.py
+"""
+
+import subprocess
+import sys
+import os
+import time
+
+def check_dependencies():
+    """Check if all required dependencies are installed"""
+    print("🔍 Checking dependencies...")
+    
+    required_packages = [
+        'streamlit',
+        'torch',
+        'torchvision',
+        'opencv-python',
+        'numpy',
+        'PIL'
+    ]
+    
+    missing = []
+    for package in required_packages:
+        try:
+            __import__(package.replace('-', '_'))
+            print(f"   ✅ {package}")
+        except ImportError:
+            print(f"   ❌ {package}")
+            missing.append(package)
+    
+    if missing:
+        print(f"\n⚠️  Missing packages: {', '.join(missing)}")
+        print("Install them with: pip install -r requirements_deploy.txt")
+        return False
+    
+    print("✅ All dependencies installed\n")
+    return True
+
+def check_model_files():
+    """Check if model files exist"""
+    print("🔍 Checking model files...")
+    
+    files_to_check = [
+        "segment-anything-2/checkpoints/sam2_hiera_small.pt",
+        "segment-anything-2/checkpoints/VREyeSAM_uncertainity_best.torch"
+    ]
+    
+    all_exist = True
+    for file_path in files_to_check:
+        if os.path.exists(file_path):
+            size_mb = os.path.getsize(file_path) / (1024 * 1024)
+            print(f"   ✅ {file_path} ({size_mb:.1f} MB)")
+        else:
+            print(f"   ❌ {file_path} - NOT FOUND")
+            all_exist = False
+    
+    if not all_exist:
+        print("\n⚠️  Some model files are missing!")
+        print("Please run the setup instructions from README.md")
+        return False
+    
+    print("✅ All model files present\n")
+    return True
+
+def check_sam2_installation():
+    """Check if SAM2 is properly installed"""
+    print("🔍 Checking SAM2 installation...")
+    
+    try:
+        sys.path.insert(0, "segment-anything-2")
+        from sam2.build_sam import build_sam2
+        from sam2.sam2_image_predictor import SAM2ImagePredictor
+        print("   ✅ SAM2 modules can be imported")
+        print("✅ SAM2 properly installed\n")
+        return True
+    except ImportError as e:
+        print(f"   ❌ SAM2 import failed: {e}")
+        print("\n⚠️  SAM2 not properly installed!")
+        print("Install with:")
+        print("  git clone https://github.com/facebookresearch/segment-anything-2")
+        print("  cd segment-anything-2")
+        print("  pip install -e .")
+        return False
+
+def test_app_syntax():
+    """Check if app.py has syntax errors"""
+    print("🔍 Checking app.py syntax...")
+    
+    try:
+        with open('app.py', 'r', encoding='utf-8') as f:
+            code = f.read()
+            compile(code, 'app.py', 'exec')
+        print("   ✅ No syntax errors")
+        print("✅ app.py syntax valid\n")
+        return True
+    except SyntaxError as e:
+        print(f"   ❌ Syntax error in app.py: {e}")
+        return False
+    except UnicodeDecodeError as e:
+        print(f"   ⚠️  Unicode encoding issue: {e}")
+        print("   Trying with different encoding...")
+        try:
+            with open('app.py', 'r', encoding='latin-1') as f:
+                code = f.read()
+                compile(code, 'app.py', 'exec')
+            print("   ✅ No syntax errors (latin-1 encoding)")
+            print("✅ app.py syntax valid\n")
+            return True
+        except Exception as e2:
+            print(f"   ❌ Still failed: {e2}")
+            return False
+
+def run_streamlit_app():
+    """Launch the Streamlit app"""
+    print("🚀 Launching Streamlit app...")
+    print("=" * 60)
+    print("The app will open in your browser at http://localhost:8501")
+    print("Press Ctrl+C to stop the app")
+    print("=" * 60)
+    print()
+    
+    try:
+        subprocess.run(['streamlit', 'run', 'app.py'], check=True)
+    except KeyboardInterrupt:
+        print("\n\n✅ App stopped by user")
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ Error running app: {e}")
+        return False
+    
+    return True
+
+def create_test_image():
+    """Create a simple test image if none exists"""
+    print("🔍 Checking for test images...")
+    
+    test_dir = "test_images"
+    if not os.path.exists(test_dir):
+        os.makedirs(test_dir)
+        print(f"   📁 Created {test_dir} directory")
+    
+    # Check if there are any test images
+    image_files = [f for f in os.listdir(test_dir) if f.endswith(('.jpg', '.png', '.jpeg'))]
+    
+    if image_files:
+        print(f"   ✅ Found {len(image_files)} test image(s)")
+        print(f"   📂 Test images in: {test_dir}/")
+        for img in image_files:
+            print(f"      - {img}")
+    else:
+        print(f"   ℹ️  No test images found in {test_dir}/")
+        print(f"   💡 Add some iris images to {test_dir}/ for testing")
+    
+    print()
+
+def main():
+    """Main testing function"""
+    print("\n" + "=" * 60)
+    print("VREyeSAM Local Testing Suite")
+    print("=" * 60 + "\n")
+    
+    # Run all checks
+    checks = [
+        ("Dependencies", check_dependencies),
+        ("Model Files", check_model_files),
+        ("SAM2 Installation", check_sam2_installation),
+        ("App Syntax", test_app_syntax),
+    ]
+    
+    all_passed = True
+    for name, check_func in checks:
+        if not check_func():
+            all_passed = False
+            print(f"❌ {name} check failed\n")
+    
+    # Create test image directory
+    create_test_image()
+    
+    if not all_passed:
+        print("=" * 60)
+        print("⚠️  Some checks failed. Please fix the issues above.")
+        print("=" * 60)
+        sys.exit(1)
+    
+    print("=" * 60)
+    print("✅ All checks passed! Ready to run the app.")
+    print("=" * 60)
+    print()
+    
+    # Ask user if they want to run the app
+    response = input("Do you want to launch the app now? (y/n): ").strip().lower()
+    
+    if response == 'y':
+        run_streamlit_app()
+    else:
+        print("\n✅ Testing complete!")
+        print("To run the app manually, execute: streamlit run app.py")
+        print()
+
+if __name__ == "__main__":
+    main()

windows.bat

@@ -0,0 +1,91 @@
+@echo off
+REM VREyeSAM Setup Script for Windows
+REM This script sets up the environment and downloads required files
+
+echo ============================================================
+echo VREyeSAM Windows Setup Script
+echo ============================================================
+echo.
+
+REM Check if Python is installed
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo [ERROR] Python is not installed or not in PATH
+    echo Please install Python 3.11 from https://www.python.org/
+    pause
+    exit /b 1
+)
+
+echo [1/6] Creating virtual environment...
+if exist vreyesam_env (
+    echo Virtual environment already exists, skipping...
+) else (
+    python -m venv vreyesam_env
+    echo Done!
+)
+echo.
+
+echo [2/6] Activating virtual environment...
+call vreyesam_env\Scripts\activate.bat
+echo Done!
+echo.
+
+echo [3/6] Installing dependencies...
+echo This may take a few minutes...
+python -m pip install --upgrade pip
+pip install streamlit
+pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cu118
+pip install "numpy<2.0.0"
+pip install opencv-python-headless pillow pandas scikit-learn matplotlib tqdm hydra-core
+echo Done!
+echo.
+
+echo [4/6] Cloning SAM2 repository...
+if exist segment-anything-2 (
+    echo SAM2 repository already exists, skipping...
+) else (
+    git clone https://github.com/facebookresearch/segment-anything-2
+    echo Done!
+)
+echo.
+
+echo [5/6] Installing SAM2...
+cd segment-anything-2
+pip install -e .
+cd ..
+echo Done!
+echo.
+
+echo [6/6] Downloading model checkpoints...
+if not exist segment-anything-2\checkpoints mkdir segment-anything-2\checkpoints
+
+REM Download SAM2 base checkpoint
+if exist segment-anything-2\checkpoints\sam2_hiera_small.pt (
+    echo SAM2 checkpoint already exists, skipping...
+) else (
+    echo Downloading SAM2 checkpoint (this may take a few minutes)...
+    powershell -Command "Invoke-WebRequest -Uri 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt' -OutFile 'segment-anything-2\checkpoints\sam2_hiera_small.pt'"
+    echo Done!
+)
+
+REM Download VREyeSAM weights
+if exist segment-anything-2\checkpoints\VREyeSAM_uncertainity_best.torch (
+    echo VREyeSAM weights already exist, skipping...
+) else (
+    echo Downloading VREyeSAM weights...
+    pip install huggingface-hub
+    huggingface-cli download devnagaich/VREyeSAM VREyeSAM_uncertainity_best.torch --local-dir segment-anything-2\checkpoints\
+    echo Done!
+)
+echo.
+
+echo ============================================================
+echo Setup Complete!
+echo ============================================================
+echo.
+echo To run the app:
+echo   1. Activate the environment: vreyesam_env\Scripts\activate.bat
+echo   2. Run: streamlit run app.py
+echo.
+echo Press any key to exit...
+pause >nul