poc

.gitignore

@@ -0,0 +1,57 @@
+# Python
+__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
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+.claude/
+
+# Jupyter
+.ipynb_checkpoints
+
+# Model files (YOLO will download on first run)
+*.pt
+*.onnx
+*.torchscript
+*.tflite
+*.pb
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Logs
+*.log
+
+# Environment
+.env
+.env.local

README.md

@@ -1,14 +1,158 @@
 ---
 title: Murderer Detector
-emoji: ⚡
-colorFrom: indigo
-colorTo: gray
+emoji: 🔪
+colorFrom: red
+colorTo: black
 sdk: gradio
 sdk_version: 6.0.1
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Be safe out there!
+short_description: Detect suspicious individuals lurking behind you with AI!
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔪 Murderer Detector
+
+[![Gradio](https://img.shields.io/badge/Gradio-6.0.1-orange)](https://gradio.app/)
+[![Python](https://img.shields.io/badge/Python-3.10+-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](LICENSE)
+
+> **WARNING:** This app uses HIGHLY ADVANCED AI TECHNOLOGY to detect potential murderers lurking behind you!
+
+## What is This?
+
+A humorous real-time person detection app that detects suspicious individuals lurking **behind** you. Built with Gradio 6.0.1 and YOLOv8.
+
+**This is for funs.** No actual threat detection occurs. Don't call the cops on your roommates.
+
+## Features
+
+- **Real-time webcam streaming** with unified display (no separate input/output)
+- **Smart user detection** - filters out the user (largest person) and only flags people behind them
+- **Person detection** with YOLOv8-nano
+- **Hilarious single-line labels** with emojis and threat percentages:
+  - 🥣 SERIAL BREAKFAST SKIPPER (87%)
+  - 📚 DANGEROUS BOOK READER (92%)
+  - 🛏️ FITTED SHEET FOLDER (76%)
+  - ☕ NOTORIOUS TEA DRINKER (95%)
+  - 🔌 OWNS MULTIPLE USB-C CABLES (83%)
+  - ...and 15 more!
+- **Color-coded threat levels** (red/orange/yellow based on percentage)
+- **Large, readable text** optimized for webcam viewing
+- **Running suspect count** in header
+
+## Quick Start
+
+### Run Locally
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the app (includes share=True for instant public URL)
+python app.py
+```
+
+The app will launch at http://localhost:7860 and provide a public shareable link!
+
+### Deploy to Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Upload these files:
+   - `app.py`
+   - `requirements.txt`
+   - `README.md`
+3. Your app will automatically deploy!
+
+## For Developers
+
+This app is intentionally structured to be easily modified for **serious computer vision applications**. The code is organized into clear modules:
+
+### Architecture
+
+```
+PersonDetector      → Detection Module (swap YOLO for any model)
+MurdererClassifier  → Classification Logic (replace with real ML)
+FrameAnnotator      → Annotation Layer (customize visuals)
+MurdererDetector    → Main Pipeline (orchestrates everything)
+```
+
+### Modify for Serious Use Cases
+
+**Security Monitoring:**
+- Replace `MurdererClassifier` with anomaly detection
+- Add action recognition (violence, falls, intrusions)
+- Integrate alerts and logging
+
+**PPE Detection:**
+- Modify `PersonDetector` to detect helmets, vests, masks
+- Add compliance scoring in `MurdererClassifier`
+- Update annotations to show violations
+
+**Customer Analytics:**
+- Track people counting and dwell time
+- Add age/gender classification
+- Generate heatmaps in `FrameAnnotator`
+
+**Social Distancing:**
+- Calculate distances between detected persons
+- Flag violations with visual warnings
+- Log statistics over time
+
+### Key Components
+
+**app.py:53** - `PersonDetector.detect_persons()` - Swap detection models here
+
+**app.py:127** - `MurdererClassifier.classify()` - Replace with real ML inference
+
+**app.py:183** - `FrameAnnotator.annotate_frame()` - Customize visualization
+
+**app.py:342** - `MurdererDetector._filter_user()` - Logic to exclude the user (largest person)
+
+All classes are well-documented with inline comments explaining modification points.
+
+## Technical Details
+
+- **Detection**: YOLOv8-nano (fast, lightweight, ~6MB model)
+- **Streaming**: Gradio 6.x Image streaming with unified input/output
+- **Processing**: Real-time with OpenCV
+- **User Filtering**: Excludes largest person (assumed to be the user)
+- **Deployment**: Optimized for Hugging Face Spaces with share=True enabled
+
+## How to Use
+
+1. **Run the app** - It launches with a public shareable link
+2. **Enable webcam** - Click the webcam button in the interface
+3. **Position someone behind you** - The app needs at least 2 people (you + someone behind you)
+4. **Watch the detection** - Only people behind you get flagged as "threats"
+5. **Share the link** - Use the Gradio share link to show friends
+
+**Note:** If you're the only person in frame, nothing will be detected (by design!)
+
+## License
+
+Apache 2.0 - Use this code for anything! Education, commercial projects, world domination, etc.
+
+## Credits
+
+Built with:
+- [Gradio 6.0.1](https://gradio.app/) for the UI and streaming
+- [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) for person detection
+- Excessive amounts of coffee and true crime documentaries
+
+## Contributing
+
+Found a funnier label? Want to improve the detection? Open a PR!
+
+Ideas for improvements:
+- More emoji labels (currently 20, could add 50+)
+- Sound effects when new suspects appear
+- Threat level history/tracking
+- Better user filtering (depth detection, face recognition)
+- Multiple webcam angles
+- Export "suspect reports" as PDF
+- Multiple language support
+
+---
+
+**Remember:** The real murderers are the friends we made along the way. Stay safe out there! 🔪

app.py

@@ -0,0 +1,433 @@
+"""
+Murderer Detector - A Humorous Webcam Person Detection Demo
+
+This app demonstrates real-time person detection with humorous labeling.
+It's structured to be easily modified for serious applications like:
+- Security monitoring
+- PPE detection
+- Customer analytics
+- Social distancing monitoring
+
+Architecture:
+1. Detection Module: Uses YOLO for person detection (easily swappable)
+2. Classification Logic: Generates humorous labels (swap for real ML inference)
+3. Annotation Layer: Draws boxes and labels (customize visuals)
+4. Streaming Handler: Processes webcam feed via Gradio
+"""
+
+import gradio as gr
+import cv2
+import numpy as np
+from ultralytics import YOLO
+import random
+from typing import Tuple, List, Dict
+import time
+
+
+# ============================================================================
+# DETECTION MODULE
+# Swap this section for different detection models or backends
+# ============================================================================
+
+class PersonDetector:
+    """
+    Person detection using YOLO.
+
+    For serious applications, modify this to:
+    - Use different models (MediaPipe, custom trained models)
+    - Add specific object detection (weapons, PPE, etc.)
+    - Integrate with cloud APIs (AWS Rekognition, Google Vision)
+    """
+
+    def __init__(self, model_name: str = "yolov8n.pt", confidence: float = 0.5):
+        """
+        Initialize the person detector.
+
+        Args:
+            model_name: YOLO model to use (n=nano, s=small, m=medium, l=large)
+            confidence: Detection confidence threshold
+        """
+        self.model = YOLO(model_name)
+        self.confidence = confidence
+
+    def detect_persons(self, frame: np.ndarray) -> List[Dict]:
+        """
+        Detect persons in a frame.
+
+        Args:
+            frame: Input image as numpy array (BGR format)
+
+        Returns:
+            List of detections with bounding boxes and confidence scores
+        """
+        # Run inference
+        results = self.model(frame, conf=self.confidence,
+                             classes=[0], verbose=False)
+
+        detections = []
+        for result in results:
+            boxes = result.boxes
+            for box in boxes:
+                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                confidence = float(box.conf[0])
+
+                detections.append({
+                    'bbox': (int(x1), int(y1), int(x2), int(y2)),
+                    'confidence': confidence
+                })
+
+        return detections
+
+
+# ============================================================================
+# CLASSIFICATION LOGIC
+# Replace this section for serious applications
+# ============================================================================
+
+class MurdererClassifier:
+    """
+    Humorous 'threat' classification.
+
+    For serious applications, replace with:
+    - Emotion detection models
+    - Action recognition (violence, falls, etc.)
+    - Anomaly detection
+    - Age/gender classification
+    """
+
+    # Short, punchy threat labels
+    LABELS = [
+        "🥣 SERIAL BREAKFAST SKIPPER",
+        "😴 SUSPICIOUSLY WELL-RESTED",
+        "📺 TRUE CRIME WATCHER",
+        "📚 DANGEROUS BOOK READER",
+        "🥄 SERIAL CEREAL KILLER",
+        "😊 TOO POLITE. SUSPICIOUS.",
+        "👀 PROFESSIONAL LURKER",
+        "🪴 PLANT WHISPERER",
+        "🐕 ALLEGED DOG PETTER",
+        "☕ NOTORIOUS TEA DRINKER",
+        "🤔 CONFIRMED OVERTHINKER",
+        "🧍 BACKGROUND STANDER",
+        "💤 GETS 8 HOURS SLEEP",
+        "💧 DRINKS WATER DAILY",
+        "🔌 OWNS MULTIPLE USB-C CABLES",
+        "🎵 CAN WHISTLE & SNAP",
+        "🛏️ FITTED SHEET FOLDER",
+        "📖 READ 3+ BOOKS",
+        "🌿 TALKS TO HOUSEPLANTS",
+        "🎯 UNUSUALLY GOOD AT TRIVIA",
+    ]
+
+    def __init__(self):
+        """Initialize the classifier with tracking for consistent labels."""
+        self.person_history = {}
+        self.next_id = 0
+
+    def classify(self, detection: Dict) -> Dict:
+        """
+        Generate humorous classification for a detected person.
+
+        Args:
+            detection: Detection dict with bbox and confidence
+
+        Returns:
+            Classification dict with label and threat level
+        """
+        # Generate random threat assessment
+        threat_level = random.randint(45, 99)
+        label = random.choice(self.LABELS)
+
+        return {
+            'threat_level': threat_level,
+            'label': label,
+            'confidence': detection['confidence']
+        }
+
+
+# ============================================================================
+# ANNOTATION LAYER
+# Customize this section for different visual styles
+# ============================================================================
+
+class FrameAnnotator:
+    """
+    Draws annotations on frames.
+
+    Modify this to:
+    - Change colors, styles, fonts
+    - Add different visualization modes
+    - Include overlay graphics or warnings
+    - Show statistics or heatmaps
+    """
+
+    def __init__(self):
+        """Initialize annotator with color schemes."""
+        self.colors = {
+            'high_threat': (0, 0, 255),    # Red
+            'medium_threat': (0, 165, 255),  # Orange
+            'low_threat': (0, 255, 255),    # Yellow
+            'text_bg': (0, 0, 0),           # Black
+            'text': (255, 255, 255)         # White
+        }
+
+    def get_threat_color(self, threat_level: int) -> Tuple[int, int, int]:
+        """Get color based on threat level."""
+        if threat_level >= 80:
+            return self.colors['high_threat']
+        elif threat_level >= 60:
+            return self.colors['medium_threat']
+        else:
+            return self.colors['low_threat']
+
+    def annotate_frame(
+        self,
+        frame: np.ndarray,
+        detections: List[Dict],
+        classifications: List[Dict]
+    ) -> np.ndarray:
+        """
+        Draw annotations on frame.
+
+        Args:
+            frame: Input frame
+            detections: List of detection dicts
+            classifications: List of classification dicts
+
+        Returns:
+            Annotated frame
+        """
+        annotated = frame.copy()
+
+        # Draw header
+        self._draw_header(annotated, len(detections))
+
+        # Annotate each detection
+        for detection, classification in zip(detections, classifications):
+            self._draw_detection(annotated, detection, classification)
+
+        return annotated
+
+    def _draw_header(self, frame: np.ndarray, num_suspects: int):
+        """Draw header with suspect count."""
+        header_text = f"🚨 SUSPECTS DETECTED: {num_suspects} 🚨"
+        font = cv2.FONT_HERSHEY_DUPLEX
+        font_scale = 0.8
+        thickness = 2
+
+        # Get text size
+        (text_width, text_height), baseline = cv2.getTextSize(
+            header_text, font, font_scale, thickness
+        )
+
+        # Draw background
+        cv2.rectangle(
+            frame,
+            (0, 0),
+            (frame.shape[1], text_height + baseline + 20),
+            (0, 0, 0),
+            -1
+        )
+
+        # Draw text
+        x = (frame.shape[1] - text_width) // 2
+        y = text_height + 10
+        cv2.putText(
+            frame, header_text, (x, y),
+            font, font_scale, (0, 0, 255), thickness
+        )
+
+    def _draw_detection(
+        self,
+        frame: np.ndarray,
+        detection: Dict,
+        classification: Dict
+    ):
+        """Draw bounding box and labels for a detection."""
+        x1, y1, x2, y2 = detection['bbox']
+        threat_level = classification['threat_level']
+        color = self.get_threat_color(threat_level)
+
+        # Draw bounding box
+        cv2.rectangle(frame, (x1, y1), (x2, y2), color, 3)
+
+        # Create single label with threat level
+        label = f"{classification['label']} ({threat_level}%)"
+
+        # Draw label with larger, more readable text
+        font = cv2.FONT_HERSHEY_DUPLEX
+        font_scale = 0.7
+        thickness = 2
+        padding = 8
+
+        (text_width, text_height), baseline = cv2.getTextSize(
+            label, font, font_scale, thickness
+        )
+
+        # Position label above bounding box, or below if too close to top
+        y_offset = y1 - 10
+        if y_offset - text_height - padding < 0:
+            y_offset = y2 + text_height + padding + 10
+
+        # Draw background rectangle
+        cv2.rectangle(
+            frame,
+            (x1, y_offset - text_height - padding),
+            (x1 + text_width + padding * 2, y_offset + baseline + padding),
+            self.colors['text_bg'],
+            -1
+        )
+
+        # Draw text
+        cv2.putText(
+            frame,
+            label,
+            (x1 + padding, y_offset),
+            font,
+            font_scale,
+            color,
+            thickness
+        )
+
+
+# ============================================================================
+# STREAMING HANDLER
+# Main processing pipeline
+# ============================================================================
+
+class MurdererDetector:
+    """
+    Main application class that combines all modules.
+    """
+
+    def __init__(self):
+        """Initialize all components."""
+        print("🔍 Initializing Murderer Detector...")
+        self.detector = PersonDetector(model_name="yolov8n.pt", confidence=0.5)
+        self.classifier = MurdererClassifier()
+        self.annotator = FrameAnnotator()
+        print("✅ Ready to detect suspicious individuals!")
+
+    def process_frame(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Process a single frame.
+
+        Args:
+            frame: Input frame from webcam
+
+        Returns:
+            Annotated frame
+        """
+        if frame is None:
+            return None
+
+        # Detect all persons
+        all_detections = self.detector.detect_persons(frame)
+
+        # Filter out the user (largest person, presumably closest to camera)
+        # Only flag people behind the user
+        detections = self._filter_user(all_detections)
+
+        # Classify each detection
+        classifications = [
+            self.classifier.classify(det) for det in detections
+        ]
+
+        # Annotate frame
+        annotated = self.annotator.annotate_frame(
+            frame, detections, classifications
+        )
+
+        return annotated
+
+    def _filter_user(self, detections: List[Dict]) -> List[Dict]:
+        """
+        Filter out the user (largest person) from detections.
+
+        The assumption is that the user is sitting in front of the webcam
+        and will be the largest person in the frame. We want to flag only
+        people behind them.
+
+        Args:
+            detections: List of all person detections
+
+        Returns:
+            Filtered detections excluding the user
+        """
+        if len(detections) <= 1:
+            # If only one person or no people, don't flag anyone
+            return []
+
+        # Calculate area for each detection
+        detections_with_area = []
+        for det in detections:
+            x1, y1, x2, y2 = det['bbox']
+            area = (x2 - x1) * (y2 - y1)
+            detections_with_area.append((det, area))
+
+        # Sort by area (largest first)
+        detections_with_area.sort(key=lambda x: x[1], reverse=True)
+
+        # Return all except the largest (the user)
+        return [det for det, _ in detections_with_area[1:]]
+
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+def create_interface():
+    """Create and configure the Gradio interface."""
+
+    # Initialize detector
+    app = MurdererDetector()
+
+    # Create interface
+    with gr.Blocks(title="Murderer Detector 🔪") as demo:
+
+        gr.Markdown("""
+        # 🔪 Murderer Detector 🔍
+
+        **DISCLAIMER:** This is for funs.
+                    """)
+
+        # Unified webcam display (input and output combined)
+        webcam = gr.Image(
+            sources="webcam",
+            streaming=True,
+            label="Murderer Detector (requires webcam on)"
+        )
+
+        gr.Markdown("""
+        # 📊 How It Works
+
+        1. ** Enable your webcam ** - Click the webcam button above
+        2. ** Detects creepers behind you **
+
+        # 🎯 Detection Features
+
+        - Real-time person detection using YOLOv8
+        - Threat level assessment(totally scientific 😅)
+        - Color-coded danger ratings
+        - Running suspect count
+        """)
+
+        # Set up streaming (unified input/output)
+        webcam.stream(
+            fn=app.process_frame,
+            inputs=[webcam],
+            outputs=[webcam],
+            stream_every=0.1,
+            concurrency_limit=30
+        )
+
+    return demo
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,5 @@
+gradio==6.0.1
+opencv-python-headless==4.10.0.84
+numpy==1.26.4
+pillow==10.4.0
+ultralytics>=8.3.0