Update streamlit app

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.13.5-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY src/ ./src/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,10 @@
+title: Processing Image
+emoji: 🚀
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+  - streamlit
+pinned: false
+short_description: Streamlit template space

requirements.txt

@@ -0,0 +1,14 @@
+altair
+pandas
+streamlit
+torch
+torchvision
+opencv-python-headless
+Pillow
+numpy
+plotly
+matplotlib
+seaborn
+ultralytics
+av
+aiortc

src/streamlit_app.py

@@ -0,0 +1,647 @@
+import streamlit as st
+import torch
+import cv2
+import numpy as np
+from PIL import Image
+import io
+import time
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+from pathlib import Path
+import tempfile
+import os
+import logging
+import warnings
+
+# Suppress WebRTC/asyncio warnings and errors
+logging.getLogger('aioice').setLevel(logging.CRITICAL)
+logging.getLogger('asyncio').setLevel(logging.CRITICAL)
+logging.getLogger('streamlit_webrtc').setLevel(logging.ERROR)
+warnings.filterwarnings('ignore', category=DeprecationWarning)
+warnings.filterwarnings('ignore', category=FutureWarning)
+
+# Page config
+st.set_page_config(
+    page_title="🦽 AI Wheelchair Navigation System",
+    page_icon="🦽",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for wheelchair theme
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #2E86AB 0%, #A23B72 50%, #F18F01 100%);
+        color: white;
+        padding: 2rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        text-align: center;
+    }
+    
+    .metric-card {
+        background: #f8f9fa;
+        padding: 1rem;
+        border-radius: 10px;
+        border-left: 4px solid #2E86AB;
+        margin: 0.5rem 0;
+    }
+    
+    .detection-box {
+        background: #e8f4f8;
+        padding: 1rem;
+        border-radius: 8px;
+        border: 1px solid #2E86AB;
+        margin: 0.5rem 0;
+    }
+    
+    .safety-alert {
+        background: #fff3cd;
+        color: #856404;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #ffc107;
+        margin: 1rem 0;
+    }
+    
+    .success-alert {
+        background: #d4edda;
+        color: #155724;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #28a745;
+        margin: 1rem 0;
+    }
+    
+    .wheelchair-icon {
+        font-size: 2rem;
+        color: #2E86AB;
+    }
+    
+    .stButton > button {
+        background: linear-gradient(90deg, #2E86AB, #A23B72);
+        color: white;
+        border-radius: 20px;
+        border: none;
+        padding: 0.5rem 2rem;
+        font-weight: bold;
+    }
+    
+    .stSelectbox > div > div {
+        border-radius: 10px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'model' not in st.session_state:
+    st.session_state.model = None
+if 'detection_history' not in st.session_state:
+    st.session_state.detection_history = []
+
+# Wheelchair-relevant classes from COCO
+WHEELCHAIR_CLASSES = {
+    0: 'person',           # People to avoid/navigate around
+    1: 'bicycle',          # Other mobility devices
+    2: 'car',              # Vehicles to avoid
+    3: 'motorcycle',       # Vehicles to avoid
+    5: 'bus',              # Large vehicles
+    7: 'truck',            # Large vehicles
+    9: 'traffic light',    # Navigation signals
+    11: 'stop sign',       # Navigation signals
+    24: 'backpack',        # Personal items/obstacles
+    26: 'handbag',         # Personal items/obstacles
+    56: 'chair',           # Furniture/obstacles
+    58: 'potted plant'     # Environmental obstacles
+}
+
+CLASS_COLORS = {
+    'person': '#FF6B6B',
+    'bicycle': '#4ECDC4',
+    'car': '#45B7D1',
+    'motorcycle': '#96CEB4',
+    'bus': '#FECA57',
+    'truck': '#FF9F43',
+    'traffic light': '#6C5CE7',
+    'stop sign': '#FD79A8',
+    'chair': '#A0E7E5',
+    'backpack': '#DDA0DD',
+    'handbag': '#F7DC6F',
+    'potted plant': '#82E0AA'
+}
+
+@st.cache_resource
+def load_model(confidence_threshold=0.5):
+    """Load YOLOv5 model with caching"""
+    try:
+        # Try to load from local path first (for development)
+        model_paths = [
+            "wheelchair_runs/wheelchair_exp5/weights/best.pt",
+            "wheelchair_runs/wheelchair_exp/weights/best.pt",
+            "best.pt"  # Fallback
+        ]
+        
+        model = None
+        for path in model_paths:
+            if os.path.exists(path):
+                model = torch.hub.load('ultralytics/yolov5', 'custom', path=path, trust_repo=True)
+                break
+        
+        # If no local model, load pretrained YOLOv5s
+        if model is None:
+            model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True, trust_repo=True)
+            st.warning("⚠️ Using pretrained YOLOv5s model. For best wheelchair navigation, upload your trained model.")
+        
+        model.conf = confidence_threshold
+        model.iou = 0.45
+        return model
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None
+
+def get_navigation_advice(detections, image_width=640):
+    """Generate navigation advice based on detections"""
+    advice = []
+    safety_level = "🟢 SAFE"
+    
+    if detections is None or len(detections) == 0:
+        return ["✅ Clear path ahead"], safety_level
+    
+    critical_detections = 0
+    
+    for _, detection in detections.iterrows():
+        class_id = int(detection['class'])
+        class_name = detection['name']
+        confidence = detection['confidence']
+        x_center = (detection['xmin'] + detection['xmax']) / 2
+        y_center = (detection['ymin'] + detection['ymax']) / 2
+        
+        # Determine position relative to wheelchair
+        if x_center < image_width * 0.33:
+            position = "left"
+        elif x_center > image_width * 0.67:
+            position = "right"
+        else:
+            position = "ahead"
+            critical_detections += 1
+        
+        # Generate specific advice based on object type and position
+        if class_name == 'person':
+            if position == "ahead":
+                advice.append(f"⚠️ PERSON DETECTED AHEAD - STOP and wait for clear path")
+                safety_level = "🔴 CRITICAL"
+            else:
+                advice.append(f"👤 Person on {position} (conf: {confidence:.0%})")
+                if safety_level == "🟢 SAFE":
+                    safety_level = "🟡 CAUTION"
+                    
+        elif class_name in ['car', 'truck', 'bus', 'motorcycle']:
+            advice.append(f"🚗 {class_name.title()} {position} - proceed with extreme caution")
+            safety_level = "🔴 CRITICAL" if position == "ahead" else "🟡 CAUTION"
+            
+        elif class_name in ['traffic light', 'stop sign']:
+            advice.append(f"🚦 {class_name.replace('_', ' ').title()} detected - follow traffic rules")
+            
+        elif class_name == 'chair':
+            advice.append(f"🪑 Chair detected on {position} - navigate around")
+            if position == "ahead":
+                safety_level = "🟡 CAUTION"
+                
+        elif class_name in ['backpack', 'handbag']:
+            advice.append(f"🎒 Personal item on {position} - person nearby")
+            
+        elif class_name == 'potted plant':
+            advice.append(f"🪴 Obstacle on {position} - adjust path")
+    
+    if critical_detections > 2:
+        safety_level = "🔴 CRITICAL"
+        advice.insert(0, "⚠️ MULTIPLE OBSTACLES AHEAD - STOP AND REASSESS")
+    
+    return advice[:5], safety_level  # Limit to top 5 pieces of advice
+
+def process_image(image, model, conf_threshold):
+    """Process image and return results"""
+    if model is None:
+        return None, None, []
+    
+    # Run inference
+    results = model(image)
+    
+    # Get detections
+    detections = results.pandas().xyxy[0]
+    
+    # Filter to wheelchair-relevant classes
+    relevant_detections = detections[detections['name'].isin(WHEELCHAIR_CLASSES.values())]
+    
+    # Get rendered image
+    rendered_img = results.render()[0]
+    rendered_img = cv2.cvtColor(rendered_img, cv2.COLOR_BGR2RGB)
+    
+    return rendered_img, relevant_detections, results
+
+def create_detection_chart(detections):
+    """Create a bar chart of detections"""
+    if detections is None or len(detections) == 0:
+        return None
+    
+    detection_counts = detections['name'].value_counts()
+    
+    fig = px.bar(
+        x=detection_counts.index,
+        y=detection_counts.values,
+        color=detection_counts.index,
+        color_discrete_map=CLASS_COLORS,
+        title="📊 Detected Objects Count",
+        labels={'x': 'Object Type', 'y': 'Count'}
+    )
+    
+    fig.update_layout(
+        showlegend=False,
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font=dict(size=12),
+        title_font=dict(size=16, color='#2E86AB')
+    )
+    
+    return fig
+
+def create_confidence_chart(detections):
+    """Create a confidence score visualization"""
+    if detections is None or len(detections) == 0:
+        return None
+    
+    fig = px.scatter(
+        detections,
+        x='name',
+        y='confidence',
+        size='confidence',
+        color='name',
+        color_discrete_map=CLASS_COLORS,
+        title="🎯 Detection Confidence Scores",
+        labels={'confidence': 'Confidence Score', 'name': 'Object Type'}
+    )
+    
+    fig.update_layout(
+        showlegend=False,
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font=dict(size=12),
+        title_font=dict(size=16, color='#2E86AB')
+    )
+    
+    return fig
+
+# Main app
+def main():
+    # Header
+    st.markdown("""
+    <div class="main-header">
+        <h1>🦽 AI Wheelchair Navigation System</h1>
+        <p>Intelligent Computer Vision for Safe Wheelchair Navigation</p>
+        <p><strong>Graduation Project</strong> | YOLOv5 Object Detection | Raspberry Pi Optimized</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Sidebar
+    with st.sidebar:
+        st.markdown("### 🔧 Model Configuration")
+        
+        # Model settings
+        conf_threshold = st.slider(
+            "Confidence Threshold",
+            min_value=0.1,
+            max_value=1.0,
+            value=0.5,
+            step=0.1,
+            help="Minimum confidence for object detection"
+        )
+        
+        st.markdown("### 📊 Model Performance")
+        st.markdown("""
+        <div class="metric-card">
+            <strong>🎯 Overall Accuracy:</strong> 87.5% mAP@0.5<br>
+            <strong>👤 Person Detection:</strong> 84.4%<br>
+            <strong>🪑 Chair Detection:</strong> 93.9%<br>
+            <strong>🚗 Vehicle Detection:</strong> 56.3%<br>
+            <strong>⚖️ Model Size:</strong> 14.7 MB
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("### 🎯 Wheelchair-Relevant Objects")
+        for class_id, class_name in WHEELCHAIR_CLASSES.items():
+            color = CLASS_COLORS.get(class_name, '#808080')
+            st.markdown(f'<span style="color: {color}; font-weight: bold;">●</span> {class_name.title()}', unsafe_allow_html=True)
+    
+    # Main content tabs
+    tab1, tab2, tab3, tab4 = st.tabs(["📸 Live Detection", "📊 Analytics", "ℹ️ About", "🚀 Deployment"])
+    
+    with tab1:
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            st.markdown("### 📷 Upload Image for Detection")
+            uploaded_file = st.file_uploader(
+                "Choose an image...",
+                type=['jpg', 'jpeg', 'png'],
+                help="Upload an image to test wheelchair navigation detection"
+            )
+            
+            # Demo images
+            st.markdown("### 🎬 Try Demo Images")
+            demo_col1, demo_col2, demo_col3 = st.columns(3)
+            
+            with demo_col1:
+                if st.button("🏪 Indoor Scene"):
+                    # You would replace this with actual demo images
+                    st.info("Demo: Indoor navigation scenario")
+            
+            with demo_col2:
+                if st.button("🏙️ Outdoor Scene"):
+                    st.info("Demo: Outdoor navigation scenario")
+            
+            with demo_col3:
+                if st.button("🚶 Crowded Area"):
+                    st.info("Demo: Crowded area navigation")
+        
+        with col2:
+            st.markdown("### 🛡️ Safety Status")
+            safety_placeholder = st.empty()
+            
+            st.markdown("### 🧭 Navigation Advice")
+            advice_placeholder = st.empty()
+        
+        # Process uploaded image
+        if uploaded_file is not None:
+            # Load and display original image
+            image = Image.open(uploaded_file)
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("#### 📸 Original Image")
+                st.image(image, use_column_width=True)
+            
+            # Load model
+            if st.session_state.model is None:
+                with st.spinner("🤖 Loading AI model..."):
+                    st.session_state.model = load_model(conf_threshold)
+            
+            if st.session_state.model is not None:
+                # Process image
+                with st.spinner("🔍 Analyzing image for obstacles..."):
+                    start_time = time.time()
+                    rendered_img, detections, results = process_image(image, st.session_state.model, conf_threshold)
+                    processing_time = time.time() - start_time
+                
+                with col2:
+                    st.markdown("#### 🎯 Detection Results")
+                    if rendered_img is not None:
+                        st.image(rendered_img, use_column_width=True)
+                
+                # Generate navigation advice
+                advice, safety_level = get_navigation_advice(detections, image.width)
+                
+                # Update safety status
+                with safety_placeholder.container():
+                    if "CRITICAL" in safety_level:
+                        st.markdown(f'<div class="safety-alert"><strong>{safety_level}</strong></div>', unsafe_allow_html=True)
+                    elif "CAUTION" in safety_level:
+                        st.markdown(f'<div style="background: #fff3cd; color: #856404; padding: 1rem; border-radius: 8px; border-left: 4px solid #ffc107;"><strong>{safety_level}</strong></div>', unsafe_allow_html=True)
+                    else:
+                        st.markdown(f'<div class="success-alert"><strong>{safety_level}</strong></div>', unsafe_allow_html=True)
+                
+                # Display navigation advice
+                with advice_placeholder.container():
+                    for advice_text in advice:
+                        st.markdown(f'<div class="detection-box">{advice_text}</div>', unsafe_allow_html=True)
+                
+                # Performance metrics
+                st.markdown("### ⚡ Performance Metrics")
+                perf_col1, perf_col2, perf_col3, perf_col4 = st.columns(4)
+                
+                with perf_col1:
+                    st.metric("⏱️ Processing Time", f"{processing_time:.2f}s")
+                
+                with perf_col2:
+                    fps = 1 / processing_time if processing_time > 0 else 0
+                    st.metric("🎬 Estimated FPS", f"{fps:.1f}")
+                
+                with perf_col3:
+                    total_detections = len(detections) if detections is not None else 0
+                    st.metric("🔍 Objects Detected", total_detections)
+                
+                with perf_col4:
+                    relevant_count = len(detections) if detections is not None else 0
+                    st.metric("🎯 Relevant Objects", relevant_count)
+                
+                # Detailed detection results
+                if detections is not None and len(detections) > 0:
+                    st.markdown("### 📋 Detailed Detection Results")
+                    
+                    # Create a formatted dataframe
+                    display_df = detections[['name', 'confidence', 'xmin', 'ymin', 'xmax', 'ymax']].copy()
+                    display_df['confidence'] = display_df['confidence'].apply(lambda x: f"{x:.1%}")
+                    display_df.columns = ['Object', 'Confidence', 'X Min', 'Y Min', 'X Max', 'Y Max']
+                    
+                    st.dataframe(display_df, use_container_width=True)
+    
+    with tab2:
+        st.markdown("### 📊 Detection Analytics")
+        
+        if uploaded_file is not None and 'detections' in locals() and detections is not None:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                chart1 = create_detection_chart(detections)
+                if chart1:
+                    st.plotly_chart(chart1, use_container_width=True)
+            
+            with col2:
+                chart2 = create_confidence_chart(detections)
+                if chart2:
+                    st.plotly_chart(chart2, use_container_width=True)
+            
+            # Detection statistics
+            st.markdown("### 📈 Statistics")
+            if len(detections) > 0:
+                stats_col1, stats_col2, stats_col3 = st.columns(3)
+                
+                with stats_col1:
+                    avg_conf = detections['confidence'].mean()
+                    st.metric("📊 Average Confidence", f"{avg_conf:.1%}")
+                
+                with stats_col2:
+                    max_conf = detections['confidence'].max()
+                    st.metric("🎯 Highest Confidence", f"{max_conf:.1%}")
+                
+                with stats_col3:
+                    unique_classes = detections['name'].nunique()
+                    st.metric("🏷️ Unique Object Types", unique_classes)
+        else:
+            st.info("📸 Upload an image in the 'Live Detection' tab to see analytics")
+    
+    with tab3:
+        st.markdown("### ℹ️ About This System")
+        
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            st.markdown("""
+            #### 🦽 AI Wheelchair Navigation System
+            
+            This intelligent computer vision system is designed to assist wheelchair users with safe navigation by detecting and identifying potential obstacles, people, vehicles, and navigation signals in real-time.
+            
+            **🎯 Key Features:**
+            - **Real-time Object Detection**: Identifies 12 wheelchair-relevant object types
+            - **Safety Warnings**: Provides immediate alerts for potential hazards
+            - **Navigation Guidance**: Offers contextual advice for safe path planning
+            - **Raspberry Pi Optimized**: Lightweight model for edge deployment
+            - **High Accuracy**: 87.5% mAP@0.5 overall accuracy
+            
+            **🔧 Technical Specifications:**
+            - **Model**: YOLOv5s (Small) - optimized for speed and accuracy
+            - **Input Size**: 416x416 pixels
+            - **Model Size**: 14.7 MB (perfect for embedded systems)
+            - **Target Platform**: Raspberry Pi 4
+            - **Processing Speed**: 5-10 FPS on Raspberry Pi
+            
+            **🎓 Graduation Project Context:**
+            This system represents a comprehensive computer vision solution for assistive technology, demonstrating:
+            - Advanced deep learning implementation
+            - Edge computing optimization
+            - Real-world application development
+            - Safety-critical system design
+            """)
+        
+        with col2:
+            st.markdown("""
+            #### 🏆 Model Performance
+            
+            **Overall Metrics:**
+            - mAP@0.5: 87.5%
+            - mAP@0.5:0.95: 63.6%
+            - Precision: 88.6%
+            - Recall: 80.8%
+            
+            **Class-Specific Performance:**
+            - Person: 84.4% mAP
+            - Chair: 93.9% mAP
+            - Vehicle: 56.3% mAP
+            - Bicycle: 80.9% mAP
+            
+            **🔒 Safety Features:**
+            - Emergency obstacle detection
+            - Multi-level alert system
+            - Contextual navigation advice
+            - Real-time processing
+            """)
+        
+        st.markdown("### 🛠️ Technology Stack")
+        
+        tech_col1, tech_col2, tech_col3, tech_col4 = st.columns(4)
+        
+        with tech_col1:
+            st.markdown("""
+            **🧠 AI/ML**
+            - YOLOv5
+            - PyTorch
+            - OpenCV
+            - NumPy
+            """)
+        
+        with tech_col2:
+            st.markdown("""
+            **🌐 Web App**
+            - Streamlit
+            - Plotly
+            - PIL/Pillow
+            - Pandas
+            """)
+        
+        with tech_col3:
+            st.markdown("""
+            **⚡ Deployment**
+            - Hugging Face Spaces
+            - Docker
+            - Git LFS
+            - ONNX (optional)
+            """)
+        
+        with tech_col4:
+            st.markdown("""
+            **🔧 Hardware**
+            - Raspberry Pi 4
+            - USB/Pi Camera
+            - MicroSD Storage
+            - Power Supply
+            """)
+    
+    with tab4:
+        st.markdown("### 🚀 Deployment Information")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("""
+            #### 📦 Hugging Face Spaces Deployment
+            
+            This application is deployed on Hugging Face Spaces, providing:
+            - **Free hosting** for demonstration purposes
+            - **Easy sharing** with project evaluators
+            - **Scalable infrastructure** for multiple users
+            - **Integrated CI/CD** for automatic updates
+            
+            **🔗 Deployment Features:**
+            - Real-time inference on uploaded images
+            - Interactive web interface
+            - Performance analytics and visualization
+            - Mobile-responsive design
+            """)
+        
+        with col2:
+            st.markdown("""
+            #### 🏠 Local/Raspberry Pi Deployment
+            
+            For real wheelchair deployment:
+            
+            1. **Download the deployment package**
+            2. **Transfer to Raspberry Pi**
+            3. **Install dependencies**
+            4. **Connect camera**
+            5. **Run inference script**
+            
+            **📋 Requirements:**
+            - Raspberry Pi 4 (4GB RAM recommended)
+            - Python 3.7+
+            - PyTorch (CPU version)
+            - USB Camera or Pi Camera
+            """)
+        
+        st.markdown("### 💻 Code Repository")
+        st.markdown("""
+        **📁 Project Structure:**
+        ```
+        wheelchair_deployment/
+        ├── wheelchair_model.pt       # Trained model weights
+        ├── wheelchair_inference.py   # Raspberry Pi inference script
+        ├── requirements_rpi.txt      # Dependencies
+        ├── README_deployment.md      # Setup instructions
+        └── wheelchair_config.yaml   # Model configuration
+        ```
+        """)
+        
+        st.markdown("### 🤝 Integration Guidelines")
+        st.markdown("""
+        **For Wheelchair Integration:**
+        
+        1. **Motor Control Interface**: Connect detection results to wheelchair motor control system
+        2. **Safety Protocols**: Implement emergency stop and collision avoidance
+        3. **User Interface**: Add audio/visual feedback for navigation guidance
+        4. **Sensor Fusion**: Combine with ultrasonic/LiDAR sensors for enhanced safety
+        5. **Custom Training**: Collect and label wheelchair-specific navigation data
+        """)
+
+if __name__ == "__main__":
+    main()