Upload 4 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 GAP_Large_project-fea-ui/focus_guard.db filter=lfs diff=lfs merge=lfs -text
+focus_guard.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies for OpenCV
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgthread-2.0-0 \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,8 +1,7 @@
 ---
-title: FGtest
-emoji: 🐢
-colorFrom: indigo
-colorTo: green
+title: FOCUS GUARD
+colorFrom: green
+colorTo: red
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,649 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List
+import base64
+import cv2
+import numpy as np
+import aiosqlite
+import json
+from datetime import datetime, timedelta
+import math
+import os
+from pathlib import Path
+
+# Initialize FastAPI app
+app = FastAPI(title="Focus Guard API")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables
+model = None
+db_path = "focus_guard.db"
+
+# ================ DATABASE MODELS ================
+
+async def init_database():
+    """Initialize SQLite database with required tables"""
+    async with aiosqlite.connect(db_path) as db:
+        # FocusSessions table
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS focus_sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                start_time TIMESTAMP NOT NULL,
+                end_time TIMESTAMP,
+                duration_seconds INTEGER DEFAULT 0,
+                focus_score REAL DEFAULT 0.0,
+                total_frames INTEGER DEFAULT 0,
+                focused_frames INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+
+        # FocusEvents table
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS focus_events (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id INTEGER NOT NULL,
+                timestamp TIMESTAMP NOT NULL,
+                is_focused BOOLEAN NOT NULL,
+                confidence REAL NOT NULL,
+                detection_data TEXT,
+                FOREIGN KEY (session_id) REFERENCES focus_sessions (id)
+            )
+        """)
+
+        # UserSettings table
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS user_settings (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                sensitivity INTEGER DEFAULT 6,
+                notification_enabled BOOLEAN DEFAULT 1,
+                notification_threshold INTEGER DEFAULT 30,
+                frame_rate INTEGER DEFAULT 30,
+                model_name TEXT DEFAULT 'yolov8n.pt'
+            )
+        """)
+
+        # Insert default settings if not exists
+        await db.execute("""
+            INSERT OR IGNORE INTO user_settings (id, sensitivity, notification_enabled, notification_threshold, frame_rate, model_name)
+            VALUES (1, 6, 1, 30, 30, 'yolov8n.pt')
+        """)
+
+        await db.commit()
+
+# ================ PYDANTIC MODELS ================
+
+class SessionCreate(BaseModel):
+    pass
+
+class SessionEnd(BaseModel):
+    session_id: int
+
+class SettingsUpdate(BaseModel):
+    sensitivity: Optional[int] = None
+    notification_enabled: Optional[bool] = None
+    notification_threshold: Optional[int] = None
+    frame_rate: Optional[int] = None
+
+# ================ YOLO MODEL LOADING ================
+
+def load_yolo_model():
+    """Load YOLOv8 model with optimizations for CPU"""
+    global model
+    try:
+        # Fix PyTorch 2.6+ weights_only issue
+        # Set environment variable to allow loading YOLO weights
+        os.environ['TORCH_LOAD_WEIGHTS_ONLY'] = '0'
+
+        import torch
+        if hasattr(torch.serialization, 'add_safe_globals'):
+            # PyTorch 2.6+ compatibility - add required classes
+            try:
+                from ultralytics.nn.tasks import DetectionModel
+                import torch.nn as nn
+                torch.serialization.add_safe_globals([
+                    DetectionModel,
+                    nn.modules.container.Sequential,
+                ])
+            except Exception as e:
+                print(f"  Safe globals setup: {e}")
+
+        from ultralytics import YOLO
+
+        model_path = "models/yolov8n.pt"
+
+        # Check if model file exists, if not use yolov8n (will download)
+        if not os.path.exists(model_path):
+            print(f"Model file {model_path} not found, downloading yolov8n.pt...")
+            model_path = "yolov8n.pt"  # This will trigger auto-download
+
+        # Load model (ultralytics handles weights_only internally in newer versions)
+        model = YOLO(model_path)
+
+        # Optimize for CPU
+        try:
+            model.fuse()  # Fuse Conv2d + BatchNorm layers
+            print("[OK] Model layers fused for optimization")
+        except Exception as e:
+            print(f"  Model fusion skipped: {e}")
+
+        # Warm up model with dummy inference
+        print("Warming up model...")
+        dummy_img = np.zeros((416, 416, 3), dtype=np.uint8)
+        model(dummy_img, imgsz=416, conf=0.4, iou=0.45, max_det=5, classes=[0], verbose=False)
+
+        print("[OK] YOLOv8 model loaded and warmed up successfully")
+        return True
+    except Exception as e:
+        print(f"[ERROR] Failed to load YOLOv8 model: {e}")
+        print("  The app will run without detection features")
+        import traceback
+        traceback.print_exc()
+        return False
+
+# ================ FOCUS DETECTION ALGORITHM ================
+
+def is_user_focused(detections, frame_shape, sensitivity=6):
+    """
+    Determine if user is focused based on YOLOv8 detections
+
+    Simple logic: Detects person with confidence >= 80% (0.8)
+
+    Args:
+        detections: List of detection dictionaries
+        frame_shape: Tuple of (height, width, channels)
+        sensitivity: Integer 1-10, higher = stricter criteria (adjusts confidence threshold)
+
+    Returns:
+        Tuple of (is_focused: bool, confidence: float, metadata: dict)
+    """
+    # Filter person detections (class 0 in COCO dataset)
+    persons = [d for d in detections if d.get('class') == 0]
+
+    if not persons:
+        return False, 0.0, {'reason': 'no_person', 'count': 0}
+
+    # Find person with highest confidence
+    best_person = max(persons, key=lambda x: x.get('confidence', 0))
+    bbox = best_person['bbox']  # [x1, y1, x2, y2]
+    conf = best_person['confidence']
+
+    # Calculate confidence threshold based on sensitivity
+    # sensitivity 6 (default) = 0.8 threshold
+    # sensitivity 1 (lowest) = 0.5 threshold
+    # sensitivity 10 (highest) = 0.9 threshold
+    base_threshold = 0.8
+    sensitivity_adjustment = (sensitivity - 6) * 0.02  # ±0.08 range
+    confidence_threshold = base_threshold + sensitivity_adjustment
+    confidence_threshold = max(0.5, min(0.95, confidence_threshold))  # Clamp to 0.5-0.95
+
+    # Simple focus determination: confidence >= threshold
+    is_focused = conf >= confidence_threshold
+
+    # Optional: Check if person is somewhat centered (loose requirement)
+    h, w = frame_shape[0], frame_shape[1]
+    bbox_center_x = (bbox[0] + bbox[2]) / 2
+    bbox_center_y = (bbox[1] + bbox[3]) / 2
+
+    # Normalize to 0-1 range
+    center_x_norm = bbox_center_x / w if w > 0 else 0.5
+    center_y_norm = bbox_center_y / h if h > 0 else 0.5
+
+    # Check if person is in frame (not at extreme edges)
+    # Allow very loose centering: 20%-80% horizontal, 15%-85% vertical
+    in_frame = (0.2 <= center_x_norm <= 0.8) and (0.15 <= center_y_norm <= 0.85)
+
+    # Reduce focus score if person is at extreme edge
+    position_factor = 1.0 if in_frame else 0.7
+    final_score = conf * position_factor
+
+    # Also reduce if multiple persons detected
+    if len(persons) > 1:
+        final_score *= 0.9
+        reason = f"person_detected_multi_{len(persons)}"
+    else:
+        reason = "person_detected" if is_focused else "low_confidence"
+
+    metadata = {
+        'bbox': bbox,
+        'detection_confidence': round(conf, 3),
+        'confidence_threshold': round(confidence_threshold, 3),
+        'center_position': [round(center_x_norm, 3), round(center_y_norm, 3)],
+        'in_frame': in_frame,
+        'person_count': len(persons),
+        'reason': reason
+    }
+
+    return is_focused and in_frame, final_score, metadata
+
+def parse_yolo_results(results):
+    """Parse YOLOv8 results into a list of detections"""
+    detections = []
+
+    if results and len(results) > 0:
+        result = results[0]
+        boxes = result.boxes
+
+        if boxes is not None and len(boxes) > 0:
+            for box in boxes:
+                # Get box coordinates
+                xyxy = box.xyxy[0].cpu().numpy()
+                conf = float(box.conf[0].cpu().numpy())
+                cls = int(box.cls[0].cpu().numpy())
+
+                detection = {
+                    'bbox': [float(x) for x in xyxy],
+                    'confidence': conf,
+                    'class': cls,
+                    'class_name': result.names[cls] if hasattr(result, 'names') else str(cls)
+                }
+                detections.append(detection)
+
+    return detections
+
+# ================ DATABASE OPERATIONS ================
+
+async def create_session():
+    """Create a new focus session"""
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute(
+            "INSERT INTO focus_sessions (start_time) VALUES (?)",
+            (datetime.now().isoformat(),)
+        )
+        await db.commit()
+        return cursor.lastrowid
+
+async def end_session(session_id: int):
+    """End a focus session and calculate statistics"""
+    async with aiosqlite.connect(db_path) as db:
+        # Get session data
+        cursor = await db.execute(
+            "SELECT start_time, total_frames, focused_frames FROM focus_sessions WHERE id = ?",
+            (session_id,)
+        )
+        row = await cursor.fetchone()
+
+        if not row:
+            return None
+
+        start_time_str, total_frames, focused_frames = row
+        start_time = datetime.fromisoformat(start_time_str)
+        end_time = datetime.now()
+        duration = (end_time - start_time).total_seconds()
+
+        # Calculate focus score
+        focus_score = focused_frames / total_frames if total_frames > 0 else 0.0
+
+        # Update session
+        await db.execute("""
+            UPDATE focus_sessions
+            SET end_time = ?, duration_seconds = ?, focus_score = ?
+            WHERE id = ?
+        """, (end_time.isoformat(), int(duration), focus_score, session_id))
+
+        await db.commit()
+
+        return {
+            'session_id': session_id,
+            'start_time': start_time_str,
+            'end_time': end_time.isoformat(),
+            'duration_seconds': int(duration),
+            'focus_score': round(focus_score, 3),
+            'total_frames': total_frames,
+            'focused_frames': focused_frames
+        }
+
+async def store_focus_event(session_id: int, is_focused: bool, confidence: float, metadata: dict):
+    """Store a focus detection event"""
+    async with aiosqlite.connect(db_path) as db:
+        await db.execute("""
+            INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
+            VALUES (?, ?, ?, ?, ?)
+        """, (session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
+
+        # Update session frame counts
+        await db.execute(f"""
+            UPDATE focus_sessions
+            SET total_frames = total_frames + 1,
+                focused_frames = focused_frames + {1 if is_focused else 0}
+            WHERE id = ?
+        """, (session_id,))
+
+        await db.commit()
+
+# ================ STARTUP/SHUTDOWN EVENTS ================
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize database and load model on startup"""
+    print(" Starting Focus Guard API...")
+    await init_database()
+    print("[OK] Database initialized")
+    load_yolo_model()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    print(" Shutting down Focus Guard API...")
+
+# ================ STATIC FILES ================
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+@app.get("/")
+async def read_index():
+    return FileResponse("static/index.html")
+
+# ================ WEBSOCKET ENDPOINT ================
+
+@app.websocket("/ws/video")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    session_id = None
+    frame_count = 0
+    last_inference_time = 0
+    min_inference_interval = 0.1  # Max 10 FPS server-side
+
+    try:
+        # Get user settings
+        async with aiosqlite.connect(db_path) as db:
+            cursor = await db.execute("SELECT sensitivity FROM user_settings WHERE id = 1")
+            row = await cursor.fetchone()
+            sensitivity = row[0] if row else 6
+
+        while True:
+            # Receive data from client
+            data = await websocket.receive_json()
+
+            if data['type'] == 'frame':
+                from time import time
+                current_time = time()
+
+                # Rate limiting
+                if current_time - last_inference_time < min_inference_interval:
+                    # Skip inference, just acknowledge
+                    await websocket.send_json({
+                        'type': 'ack',
+                        'frame_count': frame_count
+                    })
+                    continue
+
+                last_inference_time = current_time
+
+                try:
+                    # Decode base64 image
+                    img_data = base64.b64decode(data['image'])
+                    nparr = np.frombuffer(img_data, np.uint8)
+                    frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+                    if frame is None:
+                        continue
+
+                    # Resize for faster inference
+                    frame = cv2.resize(frame, (640, 480))
+
+                    # YOLOv8 inference
+                    if model is not None:
+                        results = model(
+                            frame,
+                            imgsz=416,
+                            conf=0.4,
+                            iou=0.45,
+                            max_det=5,
+                            classes=[0],  # Only person class
+                            verbose=False
+                        )
+                        detections = parse_yolo_results(results)
+                    else:
+                        # Fallback if model not loaded
+                        detections = []
+
+                    # Determine focus status
+                    is_focused, confidence, metadata = is_user_focused(
+                        detections, frame.shape, sensitivity
+                    )
+
+                    # Store event in database if session active
+                    if session_id:
+                        await store_focus_event(session_id, is_focused, confidence, metadata)
+
+                    # Send results back to client
+                    response = {
+                        'type': 'detection',
+                        'focused': is_focused,
+                        'confidence': round(confidence, 3),
+                        'detections': detections,
+                        'frame_count': frame_count
+                    }
+
+                    await websocket.send_json(response)
+                    frame_count += 1
+
+                except Exception as e:
+                    print(f"Error processing frame: {e}")
+                    await websocket.send_json({
+                        'type': 'error',
+                        'message': str(e)
+                    })
+
+            elif data['type'] == 'start_session':
+                session_id = await create_session()
+                await websocket.send_json({
+                    'type': 'session_started',
+                    'session_id': session_id
+                })
+
+            elif data['type'] == 'end_session':
+                if session_id:
+                    summary = await end_session(session_id)
+                    await websocket.send_json({
+                        'type': 'session_ended',
+                        'summary': summary
+                    })
+                    session_id = None
+
+    except WebSocketDisconnect:
+        if session_id:
+            await end_session(session_id)
+        print(f"WebSocket disconnected (session: {session_id})")
+    except Exception as e:
+        print(f"WebSocket error: {e}")
+        if websocket.client_state.value == 1:  # CONNECTED
+            await websocket.close()
+
+# ================ REST API ENDPOINTS ================
+
+@app.post("/api/sessions/start")
+async def api_start_session():
+    """Start a new focus session"""
+    session_id = await create_session()
+    return {"session_id": session_id}
+
+@app.post("/api/sessions/end")
+async def api_end_session(data: SessionEnd):
+    """End a focus session"""
+    summary = await end_session(data.session_id)
+    if not summary:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return summary
+
+@app.get("/api/sessions")
+async def get_sessions(filter: str = "all", limit: int = 50, offset: int = 0):
+    """Get focus sessions with optional filtering"""
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+
+        # Build query based on filter
+        if filter == "today":
+            date_filter = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+            query = "SELECT * FROM focus_sessions WHERE start_time >= ? ORDER BY start_time DESC LIMIT ? OFFSET ?"
+            params = (date_filter.isoformat(), limit, offset)
+        elif filter == "week":
+            date_filter = datetime.now() - timedelta(days=7)
+            query = "SELECT * FROM focus_sessions WHERE start_time >= ? ORDER BY start_time DESC LIMIT ? OFFSET ?"
+            params = (date_filter.isoformat(), limit, offset)
+        elif filter == "month":
+            date_filter = datetime.now() - timedelta(days=30)
+            query = "SELECT * FROM focus_sessions WHERE start_time >= ? ORDER BY start_time DESC LIMIT ? OFFSET ?"
+            params = (date_filter.isoformat(), limit, offset)
+        else:
+            query = "SELECT * FROM focus_sessions WHERE end_time IS NOT NULL ORDER BY start_time DESC LIMIT ? OFFSET ?"
+            params = (limit, offset)
+
+        cursor = await db.execute(query, params)
+        rows = await cursor.fetchall()
+
+        sessions = [dict(row) for row in rows]
+        return sessions
+
+@app.get("/api/sessions/{session_id}")
+async def get_session(session_id: int):
+    """Get detailed session information"""
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute("SELECT * FROM focus_sessions WHERE id = ?", (session_id,))
+        row = await cursor.fetchone()
+
+        if not row:
+            raise HTTPException(status_code=404, detail="Session not found")
+
+        session = dict(row)
+
+        # Get events
+        cursor = await db.execute(
+            "SELECT * FROM focus_events WHERE session_id = ? ORDER BY timestamp",
+            (session_id,)
+        )
+        events = [dict(r) for r in await cursor.fetchall()]
+        session['events'] = events
+
+        return session
+
+@app.get("/api/settings")
+async def get_settings():
+    """Get user settings"""
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute("SELECT * FROM user_settings WHERE id = 1")
+        row = await cursor.fetchone()
+
+        if row:
+            return dict(row)
+        else:
+            return {
+                'sensitivity': 6,
+                'notification_enabled': True,
+                'notification_threshold': 30,
+                'frame_rate': 30,
+                'model_name': 'yolov8n.pt'
+            }
+
+@app.put("/api/settings")
+async def update_settings(settings: SettingsUpdate):
+    """Update user settings"""
+    async with aiosqlite.connect(db_path) as db:
+        # First ensure the record exists
+        cursor = await db.execute("SELECT id FROM user_settings WHERE id = 1")
+        exists = await cursor.fetchone()
+
+        if not exists:
+            # Insert default record if it doesn't exist
+            await db.execute("""
+                INSERT INTO user_settings (id, sensitivity, notification_enabled, notification_threshold, frame_rate, model_name)
+                VALUES (1, 6, 1, 30, 30, 'yolov8n.pt')
+            """)
+            await db.commit()
+            print("[OK] Created default user_settings record")
+
+        # Now update with provided values
+        updates = []
+        params = []
+
+        if settings.sensitivity is not None:
+            updates.append("sensitivity = ?")
+            params.append(max(1, min(10, settings.sensitivity)))
+
+        if settings.notification_enabled is not None:
+            updates.append("notification_enabled = ?")
+            params.append(settings.notification_enabled)
+
+        if settings.notification_threshold is not None:
+            updates.append("notification_threshold = ?")
+            params.append(max(5, min(300, settings.notification_threshold)))
+
+        if settings.frame_rate is not None:
+            updates.append("frame_rate = ?")
+            params.append(max(5, min(60, settings.frame_rate)))
+
+        if updates:
+            query = f"UPDATE user_settings SET {', '.join(updates)} WHERE id = 1"
+            await db.execute(query, params)
+            await db.commit()
+            print(f"[OK] Settings updated: {settings.model_dump(exclude_none=True)}")
+
+        return {"status": "success", "updated": len(updates) > 0}
+
+@app.get("/api/stats/summary")
+async def get_stats_summary():
+    """Get overall statistics summary"""
+    async with aiosqlite.connect(db_path) as db:
+        # Total sessions
+        cursor = await db.execute("SELECT COUNT(*) FROM focus_sessions WHERE end_time IS NOT NULL")
+        total_sessions = (await cursor.fetchone())[0]
+
+        # Total focus time
+        cursor = await db.execute("SELECT SUM(duration_seconds) FROM focus_sessions WHERE end_time IS NOT NULL")
+        total_focus_time = (await cursor.fetchone())[0] or 0
+
+        # Average focus score
+        cursor = await db.execute("SELECT AVG(focus_score) FROM focus_sessions WHERE end_time IS NOT NULL")
+        avg_focus_score = (await cursor.fetchone())[0] or 0.0
+
+        # Streak calculation (consecutive days with sessions)
+        cursor = await db.execute("""
+            SELECT DISTINCT DATE(start_time) as session_date
+            FROM focus_sessions
+            WHERE end_time IS NOT NULL
+            ORDER BY session_date DESC
+        """)
+        dates = [row[0] for row in await cursor.fetchall()]
+
+        streak_days = 0
+        if dates:
+            current_date = datetime.now().date()
+            for i, date_str in enumerate(dates):
+                session_date = datetime.fromisoformat(date_str).date()
+                expected_date = current_date - timedelta(days=i)
+                if session_date == expected_date:
+                    streak_days += 1
+                else:
+                    break
+
+        return {
+            'total_sessions': total_sessions,
+            'total_focus_time': int(total_focus_time),
+            'avg_focus_score': round(avg_focus_score, 3),
+            'streak_days': streak_days
+        }
+
+# ================ HEALTH CHECK ================
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "database": os.path.exists(db_path)
+    }

focus_guard.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb042116505f0019d73e87a8262be3ef313b2b1f1471c3fd9bd1d61ee34d73ea
+size 1105920