update/car-in_no_fueling//next: car-in_fueling

MULTI_CAMERA_GUIDE.md

@@ -0,0 +1,172 @@
+# Multi-Camera Simulation Guide
+
+This guide explains how to simulate 4 cameras using a single webcam for testing the LPR integration in a realistic multi-camera environment.
+
+## 🎯 Purpose
+
+Simulate 4 real-world cameras to test:
+- Multiple camera streams with car detection
+- LPR integration across different cameras  
+- Session management for multiple simultaneous detections
+- Database updates from different camera sources
+
+## 🚀 Quick Start
+
+### Windows
+```bash
+# Option 1: Use batch file (opens 4 terminal windows)
+start_4_cameras.bat
+
+# Option 2: Manual start (run each in separate terminal)
+python multi_camera_simulator.py 1
+python multi_camera_simulator.py 2  
+python multi_camera_simulator.py 3
+python multi_camera_simulator.py 4
+```
+
+### Linux/macOS
+```bash
+# Option 1: Use shell script (opens 4 terminal windows)
+./start_4_cameras.sh
+
+# Option 2: Manual start (run each in separate terminal)  
+python3 multi_camera_simulator.py 1
+python3 multi_camera_simulator.py 2
+python3 multi_camera_simulator.py 3
+python3 multi_camera_simulator.py 4
+```
+
+## 📡 Camera URLs
+
+Each simulated camera will have unique URLs:
+
+| Camera | HTTP Snapshot | RTSP Stream | Visual ID |
+|--------|--------------|-------------|-----------|
+| 1 | `http://10.101.1.4:8080/snapshot` | `rtsp://10.101.1.4:8550/stream` | Yellow border |
+| 2 | `http://10.101.1.4:8081/snapshot` | `rtsp://10.101.1.4:8551/stream` | Magenta border |
+| 3 | `http://10.101.1.4:8082/snapshot` | `rtsp://10.101.1.4:8552/stream` | Green border |
+| 4 | `http://10.101.1.4:8083/snapshot` | `rtsp://10.101.1.4:8553/stream` | Blue border |
+
+## 🎨 Visual Differentiation
+
+Each camera adds visual branding to help distinguish streams:
+
+- **Camera 1**: Yellow border + "CAMERA 1" text
+- **Camera 2**: Magenta border + "CAMERA 2" text  
+- **Camera 3**: Green border + "CAMERA 3" text
+- **Camera 4**: Blue border + "CAMERA 4" text
+- **All**: Timestamp with camera ID
+
+## 🔧 Configuration Options
+
+### Basic Usage
+```bash
+python multi_camera_simulator.py <camera_id>
+```
+
+### Advanced Options
+```bash
+python multi_camera_simulator.py 1 --webcam-index 0 --base-port 8080 --rtsp-base-port 8550
+python multi_camera_simulator.py 2 --no-rtsp  # HTTP only
+```
+
+### Parameters
+- `camera_id`: Required (1-4)
+- `--webcam-index`: Webcam device index (default: 0)
+- `--base-port`: Base HTTP port (default: 8080)  
+- `--rtsp-base-port`: Base RTSP port (default: 8550)
+- `--no-rtsp`: Disable RTSP streaming
+
+## 🏗️ CMS Configuration
+
+Configure each camera in your CMS with these settings:
+
+### Camera 1
+```
+Camera Identifier: webcam-camera-01
+Snapshot URL: http://10.101.1.4:8080/snapshot
+RTSP URL: rtsp://10.101.1.4:8550/stream
+Snapshot Interval: 2000
+```
+
+### Camera 2  
+```
+Camera Identifier: webcam-camera-02
+Snapshot URL: http://10.101.1.4:8081/snapshot
+RTSP URL: rtsp://10.101.1.4:8551/stream
+Snapshot Interval: 2000
+```
+
+### Camera 3
+```
+Camera Identifier: webcam-camera-03  
+Snapshot URL: http://10.101.1.4:8082/snapshot
+RTSP URL: rtsp://10.101.1.4:8552/stream
+Snapshot Interval: 2000
+```
+
+### Camera 4
+```
+Camera Identifier: webcam-camera-04
+Snapshot URL: http://10.101.1.4:8083/snapshot
+RTSP URL: rtsp://10.101.1.4:8553/stream  
+Snapshot Interval: 2000
+```
+
+## 🧪 Testing LPR Integration
+
+With 4 cameras running, you can test:
+
+1. **Multiple simultaneous detections** - Cars detected by different cameras
+2. **Session isolation** - Each camera gets separate session IDs
+3. **LPR processing** - License plate results for different cameras  
+4. **Database updates** - Multiple car records with different session IDs
+
+### Test Scenario
+1. Start all 4 cameras
+2. Connect all 4 to detector worker
+3. Show car to webcam (all cameras see it)
+4. Each camera should get separate session ID
+5. Send LPR results for each session ID
+6. Verify database updates for each camera
+
+## 🔧 Troubleshooting
+
+### Port Already in Use
+If you see port conflicts:
+```bash
+# Check what's using the port
+netstat -an | findstr :8080
+netstat -an | findstr :8550
+
+# Use different base ports
+python multi_camera_simulator.py 1 --base-port 9080 --rtsp-base-port 9550
+```
+
+### Webcam Access Issues  
+```bash
+# Try different webcam indices
+python multi_camera_simulator.py 1 --webcam-index 1
+
+# Check available cameras
+python -c "import cv2; print([i for i in range(10) if cv2.VideoCapture(i).isOpened()])"
+```
+
+### FFmpeg Issues
+```bash  
+# Disable RTSP if FFmpeg unavailable
+python multi_camera_simulator.py 1 --no-rtsp
+```
+
+## 💡 Pro Tips
+
+1. **Start cameras in order** (1, 2, 3, 4) for easier tracking
+2. **Use different terminals** for each camera to see individual logs  
+3. **Check status endpoints** for health monitoring:
+   - `http://10.101.1.4:8080/status`
+   - `http://10.101.1.4:8081/status`  
+   - etc.
+4. **Monitor logs** to see which camera is processing which detection
+5. **Test LPR with unique session IDs** from each camera
+
+This setup provides a realistic multi-camera environment for comprehensive LPR integration testing! 🎉

app.py

@@ -646,10 +646,13 @@ def get_or_init_session_pipeline_state(camera_id):
             "session_id_received": False,
             "full_pipeline_completed": False,
             "absence_counter": 0,
+            "validation_counter": 0,         # Counter for validation phase
+            "validation_threshold": 4,       # Default validation threshold
             "max_absence_frames": 3,
             "yolo_inference_enabled": True,  # Controls whether to run YOLO inference
             "cached_detection_dict": None,   # Cached detection dict for lightweight mode
-            "stable_track_id": None          # The stable track ID we're monitoring
+            "stable_track_id": None,         # The stable track ID we're monitoring
+            "validated_detection": None      # Stored detection result from validation phase for full_pipeline reuse
         }
     return session_pipeline_states[camera_id]
 
@@ -659,6 +662,16 @@ def update_session_pipeline_mode(camera_id, new_mode, session_id=None):
     old_mode = state["mode"]
     state["mode"] = new_mode
     
+    # Reset counters based on mode transition
+    if new_mode == "validation_detecting":
+        # Transitioning to validation mode - reset both counters for fresh start
+        old_validation_counter = state.get("validation_counter", 0)
+        old_absence_counter = state.get("absence_counter", 0)
+        state["validation_counter"] = 0
+        state["absence_counter"] = 0
+        if old_validation_counter > 0 or old_absence_counter > 0:
+            logger.info(f"🧹 Camera {camera_id}: VALIDATION MODE RESET - validation_counter: {old_validation_counter}→0, absence_counter: {old_absence_counter}→0")
+    
     if session_id:
         state["session_id_received"] = True
         state["absence_counter"] = 0  # Reset absence counter when session starts
@@ -812,6 +825,7 @@ async def detect(websocket: WebSocket):
             
             logger.debug(f"🔍 SESSIONID LOOKUP: display='{display_identifier}', session_id={repr(backend_session_id)}, mode='{current_mode}'")
             logger.debug(f"🔍 Available session_ids: {session_ids}")
+            logger.debug(f"🔍 VALIDATED_DETECTION TRACE: {pipeline_state.get('validated_detection')}")
             
             # ═══ SESSION ID-BASED PROCESSING MODE ═══
             if not backend_session_id:
@@ -832,7 +846,8 @@ async def detect(websocket: WebSocket):
             pipeline_context = {
                 "camera_id": camera_id,
                 "display_id": display_identifier,
-                "backend_session_id": backend_session_id
+                "backend_session_id": backend_session_id,
+                "current_mode": current_mode  # Pass current mode to pipeline
             }
             
             start_time = time.time()
@@ -880,7 +895,13 @@ async def detect(websocket: WebSocket):
                                     "bbox": stable_detection.get("bbox", [0, 0, 0, 0]),
                                     "track_id": stable_detection.get("id")
                                 }
+                                
+                                # Store validated detection for full_pipeline mode to reuse
+                                pipeline_state["validated_detection"] = detection_result.copy()
+                                logger.debug(f"🔍 Camera {camera_id}: VALIDATION DEBUG - storing detection_result = {detection_result}")
+                                logger.debug(f"🔍 Camera {camera_id}: VALIDATION DEBUG - pipeline_state after storing = {pipeline_state.get('validated_detection')}")
                                 logger.info(f"🚗 Camera {camera_id}: SENDING STABLE DETECTION - track ID {detection_result['track_id']}")
+                                logger.info(f"💾 Camera {camera_id}: STORED VALIDATED DETECTION for full_pipeline reuse")
                             else:
                                 logger.warning(f"⚠️ Camera {camera_id}: Stable tracks found but no matching detection")
                     else:
@@ -917,6 +938,11 @@ async def detect(websocket: WebSocket):
                                 "confidence": best_detection.get("confidence", 0.0),
                                 "bbox": best_detection.get("bbox", [0, 0, 0, 0])
                             }
+                            
+                            # Store validated detection for full_pipeline mode to reuse
+                            pipeline_state["validated_detection"] = detection_result.copy()
+                            logger.debug(f"🔍 Camera {camera_id}: BASIC VALIDATION DEBUG - storing detection_result = {detection_result}")
+                            logger.info(f"💾 Camera {camera_id}: STORED BASIC VALIDATED DETECTION for full_pipeline reuse")
                             logger.info(f"🎯 Camera {camera_id}: BASIC VALIDATION COMPLETED after {current_count} frames")
                         else:
                             logger.info(f"📊 Camera {camera_id}: Basic validation progress {current_count}/{threshold}")
@@ -955,8 +981,20 @@ async def detect(websocket: WebSocket):
                 
             elif current_mode == "full_pipeline":
                 # ═══ FULL PIPELINE MODE ═══
-                logger.info(f"🔥 Camera {camera_id}: Running FULL PIPELINE (detection + branches + Redis + PostgreSQL)")
+                logger.info(f"🔥 Camera {camera_id}: Running FULL PIPELINE (classification branches + Redis + PostgreSQL)")
-                detection_result = run_pipeline(cropped_frame, model_tree, context=pipeline_context)
+                
+                # Use validated detection from validation phase instead of detecting again
+                validated_detection = pipeline_state.get("validated_detection")
+                logger.debug(f"🔍 Camera {camera_id}: FULL_PIPELINE DEBUG - validated_detection = {validated_detection}")
+                logger.debug(f"🔍 Camera {camera_id}: FULL_PIPELINE DEBUG - pipeline_state keys = {list(pipeline_state.keys())}")
+                if validated_detection:
+                    logger.info(f"🔄 Camera {camera_id}: Using validated detection for full pipeline: track_id={validated_detection.get('track_id')}")
+                    detection_result = run_pipeline(cropped_frame, model_tree, context=pipeline_context, validated_detection=validated_detection)
+                    # Clear the validated detection after using it
+                    pipeline_state["validated_detection"] = None
+                else:
+                    logger.warning(f"⚠️ Camera {camera_id}: No validated detection found for full pipeline - this shouldn't happen")
+                    detection_result = run_pipeline(cropped_frame, model_tree, context=pipeline_context)
                 
                 if detection_result and isinstance(detection_result, dict):
                     # Cache the full pipeline result
@@ -975,90 +1013,99 @@ async def detect(websocket: WebSocket):
                     else:
                         logger.warning(f"⚠️ Camera {camera_id}: No track_id found in detection_result: {detection_result.keys()}")
                     
+                    # Ensure we have a cached detection dict for lightweight mode
+                    if not pipeline_state.get("cached_detection_dict"):
+                        # Create fallback cached detection dict if branch processing didn't populate it
+                        fallback_detection = {
+                            "carModel": None,
+                            "carBrand": None, 
+                            "carYear": None,
+                            "bodyType": None,
+                            "licensePlateText": None,
+                            "licensePlateConfidence": None
+                        }
+                        pipeline_state["cached_detection_dict"] = fallback_detection
+                        logger.warning(f"⚠️ Camera {camera_id}: Created fallback cached detection dict (branch processing may have failed)")
+                    
                     # Switch to lightweight mode
                     update_session_pipeline_mode(camera_id, "lightweight")
                     logger.info(f"✅ Camera {camera_id}: Full pipeline completed - switching to LIGHTWEIGHT mode")
                 
             elif current_mode == "lightweight":
-                # ═══ ENHANCED LIGHTWEIGHT MODE ═══ 
+                # ═══ SIMPLIFIED LIGHTWEIGHT MODE ═══ 
-                # Only run YOLO11n.pt to check stable track presence, use cached detection dict
+                # Send cached detection dict + check for 2 consecutive empty frames to reset
                 
                 stable_track_id = pipeline_state.get("stable_track_id")
                 cached_detection_dict = pipeline_state.get("cached_detection_dict")
                 
-                logger.debug(f"🪶 Camera {camera_id}: LIGHTWEIGHT MODE - monitoring stable track_id={stable_track_id}")
+                logger.debug(f"🪶 Camera {camera_id}: LIGHTWEIGHT MODE - stable_track_id={stable_track_id}")
                 
                 if not pipeline_state.get("yolo_inference_enabled", True):
-                    # YOLO inference disabled - car considered gone, wait for reset
+                    # YOLO inference disabled - waiting for reset
                     logger.debug(f"🛑 Camera {camera_id}: YOLO inference disabled - waiting for reset")
                     detection_result = None  # Don't send anything
                 else:
-                    # Run lightweight YOLO inference to check track presence only (no full pipeline)
+                    # Run YOLO inference to check car presence for reset logic
                     from siwatsystem.pympta import run_detection_with_tracking
                     all_detections, regions_dict, track_validation_result = run_detection_with_tracking(cropped_frame, model_tree, pipeline_context)
                     
-                    # OPTION A: Car presence only (track ID kept for internal use)
                     any_car_detected = len(all_detections) > 0
                     current_tracks = track_validation_result.get("current_tracks", [])
                     
-                    logger.debug(f"🪶 Camera {camera_id}: LIGHTWEIGHT - any_cars={any_car_detected} (main decision), current_tracks={current_tracks} (internal only)")
+                    if any_car_detected:
+                        # Car detected - reset absence counter, continue sending cached detection dict
+                        pipeline_state["absence_counter"] = 0  # Reset absence since cars are present
                         
-                    if not any_car_detected:
+                        if cached_detection_dict:
-                        # NO cars detected at all - increment absence counter
+                            detection_result = cached_detection_dict  # Always send cached data
+                            logger.info(f"💾 Camera {camera_id}: LIGHTWEIGHT - car detected, sending cached detection dict")
+                        else:
+                            logger.warning(f"⚠️ Camera {camera_id}: LIGHTWEIGHT - car detected but no cached detection dict available")
+                            detection_result = None
+                    else:
+                        # No car detected - increment absence counter
                         pipeline_state["absence_counter"] += 1
                         absence_count = pipeline_state["absence_counter"]
-                        max_absence = 2  # Changed from 3 to 2 consecutive frames
+                        max_absence = 3  # Need 3 consecutive empty frames
                         
-                        logger.info(f"👻 Camera {camera_id}: NO CARS detected - absence {absence_count}/{max_absence}")
+                        logger.info(f"👻 Camera {camera_id}: LIGHTWEIGHT - no car detected (absence {absence_count}/{max_absence})")
                         
-                        # Check robust AND condition: backend confirmed AND detection confirmed
+                        if absence_count >= max_absence:
-                        backend_confirmed_gone = (backend_session_id is None)
+                            # SIMPLE RESET CONDITION: 2 consecutive empty frames
-                        detection_confirmed_gone = (absence_count >= max_absence)
+                            logger.info(f"🔄 Camera {camera_id}: RESET CONDITION MET - {max_absence} consecutive empty frames")
-                        
-                        logger.debug(f"🔍 Camera {camera_id}: Reset conditions - backend_null={backend_confirmed_gone}, absence_2frames={detection_confirmed_gone}")
-                        
-                        if backend_confirmed_gone and detection_confirmed_gone:
-                            # BOTH conditions met - RESET TO VALIDATION PHASE
-                            logger.info(f"🔄 Camera {camera_id}: ROBUST RESET - both conditions met (backend=null AND absence>=2)")
                             
                             # Clear all state and prepare for next car
                             cached_full_pipeline_results.pop(camera_id, None)
                             pipeline_state["cached_detection_dict"] = None
                             pipeline_state["stable_track_id"] = None
+                            pipeline_state["validated_detection"] = None
+                            old_absence_counter = pipeline_state["absence_counter"]
+                            old_validation_counter = pipeline_state.get("validation_counter", 0)
                             pipeline_state["absence_counter"] = 0
-                            pipeline_state["yolo_inference_enabled"] = True  # Re-enable for next car
+                            pipeline_state["validation_counter"] = 0  # Clear validation counter
+                            pipeline_state["yolo_inference_enabled"] = True
+                            
+                            logger.info(f"🧹 Camera {camera_id}: CLEARING ALL COUNTERS - absence_counter: {old_absence_counter}→0, validation_counter: {old_validation_counter}→0")
                             
                             # Clear stability tracking data for this camera
                             from siwatsystem.pympta import reset_camera_stability_tracking
                             reset_camera_stability_tracking(camera_id, model_tree.get("modelId", "unknown"))
                             
-                            # Switch back to validation phase - ready for next car
+                            # Switch back to validation phase
-                            update_session_pipeline_mode(camera_id, "detection_dict")
+                            update_session_pipeline_mode(camera_id, "validation_detecting")
-                            logger.info(f"🔄 Camera {camera_id}: RESET TO VALIDATION - model ready for next car")
+                            logger.info(f"✅ Camera {camera_id}: RESET TO VALIDATION COMPLETE - ready for new car")
                             
-                            detection_result = None  # Stop sending data during reset
+                            # Now in validation mode - send what YOLO detection finds (will be null since no car)
+                            detection_result = {"class": "none", "confidence": 1.0, "bbox": [0, 0, 0, 0]}
                         else:
-                            # One or both conditions not met - keep sending cached detection dict
+                            # Still within absence threshold - continue sending cached detection dict
                             if cached_detection_dict:
-                                detection_result = cached_detection_dict  # Always send cached data
+                                detection_result = cached_detection_dict  # Send cached data
-                                logger.info(f"⏳ Camera {camera_id}: NO CARS absence {absence_count}/2, backend_null={backend_confirmed_gone} - sending cached detection dict")
+                                logger.info(f"⏳ Camera {camera_id}: LIGHTWEIGHT - no car but absence<{max_absence}, still sending cached detection dict")
                             else:
-                                logger.warning(f"⚠️ Camera {camera_id}: NO CARS but no cached detection dict available")
+                                logger.warning(f"⚠️ Camera {camera_id}: LIGHTWEIGHT - no cached detection dict available")
                                 detection_result = None
             
-                    else:
-                        # Cars detected - reset absence counter, send cached detection dict
-                        pipeline_state["absence_counter"] = 0  # Reset absence since cars are present
-                        
-                        if cached_detection_dict:
-                            detection_result = cached_detection_dict  # Always send cached data
-                            logger.info(f"🪶 Camera {camera_id}: CARS DETECTED - sending cached detection dict:")
-                            logger.info(f"🪶 Camera {camera_id}: - Cached dict: {cached_detection_dict}")
-                            logger.info(f"🪶 Camera {camera_id}: - Track info (internal): {current_tracks}")
-                        else:
-                            logger.warning(f"⚠️ Camera {camera_id}: Cars detected but no cached detection dict available")
-                            detection_result = None
-            
             elif current_mode == "car_gone_waiting":
                 # ═══ CAR GONE WAITING STATE ═══ 
                 # Car is gone (both conditions met), YOLO inference disabled, waiting for new session
@@ -1072,6 +1119,7 @@ async def detect(websocket: WebSocket):
                     pipeline_state["absence_counter"] = 0
                     pipeline_state["stable_track_id"] = None
                     pipeline_state["cached_detection_dict"] = None
+                    pipeline_state["validated_detection"] = None
                     
                     # Clear stability tracking data for this camera
                     from siwatsystem.pympta import reset_camera_stability_tracking
@@ -1126,35 +1174,26 @@ async def detect(websocket: WebSocket):
                     if backend_session_id:
                         logger.debug(f"🔄 Camera {camera_id}: Note - sessionId {backend_session_id} exists but still in send_detections mode (transition pending)")
                     
-            elif detection_result.get("class") == "none":
+            elif current_mode == "lightweight":
-                # "None" detection - skip override if lightweight mode already made the decision
+                # ═══ SIMPLIFIED LIGHTWEIGHT MODE DETECTION PROCESSING ═══
-                if current_mode == "lightweight":
+                if detection_result.get("class") == "none":
-                    # Lightweight mode already set detection_result correctly, don't override
+                    # No car detected - this happens when resetting to validation
-                    logger.debug(f"🪶 Camera {camera_id}: Lightweight mode - respecting detection_result decision")
+                    detection_dict = None  # Send detection: null
-                    if detection_result is None:
+                    logger.info(f"🚫 LIGHTWEIGHT - no car detected, sending detection=null")
-                        detection_dict = None
+                elif isinstance(detection_result, dict) and ("carBrand" in detection_result or "carModel" in detection_result):
-                        logger.info(f"📤 LIGHTWEIGHT SENDING 'NONE' - Reset conditions met for camera {camera_id}")
+                    # This is a cached detection dict - send it
-                    else:
+                    detection_dict = detection_result
-                        # detection_result should be the cached_detection_dict
+                    logger.info(f"💾 LIGHTWEIGHT - sending cached detection dict")
-                        detection_dict = detection_result
-                        logger.info(f"💾 LIGHTWEIGHT SENDING CACHED - Maintaining session for camera {camera_id}")
                 else:
-                    # Other modes - send null to clear session
+                    logger.warning(f"⚠️ LIGHTWEIGHT - unexpected detection_result type: {type(detection_result)}")
                     detection_dict = None
-                    logger.info(f"📤 SENDING 'NONE' (detection: null) - Car absent, expecting backend to clear session for camera {camera_id}")
+                        
-            elif detection_result.get("cached_mode", False):
+            elif detection_result.get("class") == "none":
-                # Cached mode in lightweight - use cached detection dict directly
+                # Other modes - send null to clear session
-                cached_dict = detection_result.get("branch_results", {})
+                detection_dict = None
-                detection_dict = cached_dict if cached_dict else {
+                logger.info(f"📤 SENDING 'NONE' (detection: null) - Car absent, expecting backend to clear session for camera {camera_id}")
-                    "carModel": None,
-                    "carBrand": None,
-                    "carYear": None,
-                    "bodyType": None,
-                    "licensePlateText": None,
-                    "licensePlateConfidence": None
-                }
             elif detection_result and "carBrand" in detection_result:
-                # Lightweight mode - detection_result IS the cached detection dict
+                # Handle cached detection dict format (fallback for compatibility)
                 detection_dict = detection_result
                 logger.info(f"💾 Camera {camera_id}: LIGHTWEIGHT MODE - using detection_result as detection_dict:")
                 logger.info(f"💾 Camera {camera_id}: - detection_dict: {detection_dict}")
@@ -1235,13 +1274,17 @@ async def detect(websocket: WebSocket):
             # Backend manages sessionIds independently based on detection content
             logger.debug(f"TX message prepared (no sessionId) - detection_dict type: {type(detection_dict)}")
             
-            # Log detection details
+            # Log detection details for different modes
-            if detection_result and "class" in detection_result and detection_result.get("class") != "none":
+            if current_mode == "lightweight":
+                if detection_result and detection_result.get("class") == "none":
+                    logger.info(f"🚫 Camera {camera_id}: LIGHTWEIGHT - No car detected (resetting to validation)")
+                elif isinstance(detection_result, dict) and ("carBrand" in detection_result or "carModel" in detection_result):
+                    logger.info(f"💾 Camera {camera_id}: LIGHTWEIGHT - Sending cached detection data")
+                else:
+                    logger.info(f"🪶 Camera {camera_id}: LIGHTWEIGHT - Processing detection")
+            elif detection_result and "class" in detection_result and detection_result.get("class") != "none":
                 confidence = detection_result.get("confidence", 0.0)
-                logger.info(f"Camera {camera_id}: Detected {detection_result['class']} with confidence {confidence:.2f} using model {stream['modelName']}")
+                logger.info(f"🚗 Camera {camera_id}: Detected {detection_result['class']} with confidence {confidence:.2f} using model {stream['modelName']}")
-            elif detection_result and "carBrand" in detection_result:
-                # Lightweight mode cached detection dict - different format
-                logger.info(f"Camera {camera_id}: Using cached detection dict (lightweight mode) - {detection_result.get('carBrand', 'Unknown')} {detection_result.get('bodyType', '')}")
             
             # Send detection data to backend (session gating handled above in processing logic)
             logger.debug(f"📤 SENDING TO BACKEND for camera {camera_id}: {json.dumps(detection_data, indent=2)}")

multi_camera_simulator.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+Multi-Camera Simulator
+Creates 4 virtual cameras using the same webcam with different ports
+Run this in 4 separate terminals to simulate real-world scenario with 4 cameras
+"""
+
+import cv2
+import threading
+import time
+import logging
+import socket
+import sys
+import os
+import argparse
+import subprocess
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] Camera%(camera_id)s: %(message)s"
+)
+
+class MultiCameraHandler(BaseHTTPRequestHandler):
+    """HTTP handler for camera snapshot requests with camera-specific branding"""
+    
+    def __init__(self, camera_id, webcam_cap, *args, **kwargs):
+        self.camera_id = camera_id
+        self.webcam_cap = webcam_cap
+        super().__init__(*args, **kwargs)
+    
+    def do_GET(self):
+        if self.path == '/snapshot' or self.path == '/snapshot.jpg':
+            try:
+                # Capture fresh frame from webcam
+                ret, frame = self.webcam_cap.read()
+                if ret and frame is not None:
+                    # Add camera branding overlay
+                    frame = self.add_camera_branding(frame)
+                    
+                    # Encode as JPEG
+                    success, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                    if success:
+                        self.send_response(200)
+                        self.send_header('Content-Type', 'image/jpeg')
+                        self.send_header('Content-Length', str(len(buffer)))
+                        self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
+                        self.send_header('Pragma', 'no-cache')
+                        self.send_header('Expires', '0')
+                        self.end_headers()
+                        self.wfile.write(buffer.tobytes())
+                        return
+                
+                # Send error response
+                self.send_response(500)
+                self.send_header('Content-Type', 'text/plain')
+                self.end_headers()
+                self.wfile.write(b'Failed to capture webcam frame')
+                
+            except Exception as e:
+                logging.error(f"Camera{self.camera_id}: Error serving snapshot: {e}")
+                self.send_response(500)
+                self.send_header('Content-Type', 'text/plain')
+                self.end_headers()
+                self.wfile.write(f'Error: {str(e)}'.encode())
+        
+        elif self.path == '/status':
+            # Status endpoint for health checking
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            
+            width = int(self.webcam_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(self.webcam_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            fps = self.webcam_cap.get(cv2.CAP_PROP_FPS)
+            
+            status = f'{{"status": "online", "camera_id": "{self.camera_id}", "width": {width}, "height": {height}, "fps": {fps}}}'
+            self.wfile.write(status.encode())
+        
+        else:
+            # 404 for other paths
+            self.send_response(404)
+            self.send_header('Content-Type', 'text/plain')
+            self.end_headers()
+            self.wfile.write(b'Not Found - Available endpoints: /snapshot, /snapshot.jpg, /status')
+    
+    def add_camera_branding(self, frame):
+        """Add visual branding to differentiate cameras"""
+        # Clone frame to avoid modifying original
+        branded_frame = frame.copy()
+        
+        # Camera-specific colors and positions
+        colors = {
+            1: (0, 255, 255),    # Yellow
+            2: (255, 0, 255),    # Magenta  
+            3: (0, 255, 0),      # Green
+            4: (255, 0, 0)       # Blue
+        }
+        
+        # Add colored border
+        color = colors.get(self.camera_id, (255, 255, 255))
+        cv2.rectangle(branded_frame, (0, 0), (branded_frame.shape[1]-1, branded_frame.shape[0]-1), color, 10)
+        
+        # Add camera ID text
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 2
+        thickness = 3
+        
+        # Camera ID text
+        text = f"CAMERA {self.camera_id}"
+        text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+        text_x = 30
+        text_y = 60
+        
+        # Add background rectangle for text
+        cv2.rectangle(branded_frame, 
+                     (text_x - 10, text_y - text_size[1] - 10), 
+                     (text_x + text_size[0] + 10, text_y + 10), 
+                     (0, 0, 0), -1)
+        
+        # Add text
+        cv2.putText(branded_frame, text, (text_x, text_y), font, font_scale, color, thickness)
+        
+        # Add timestamp
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        ts_text = f"CAM{self.camera_id}: {timestamp}"
+        cv2.putText(branded_frame, ts_text, (30, branded_frame.shape[0] - 30), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
+        
+        return branded_frame
+    
+    def log_message(self, format, *args):
+        # Suppress default HTTP server logging
+        pass
+
+def create_handler_class(camera_id, webcam_cap):
+    """Create a handler class with bound camera_id and webcam_cap"""
+    def handler(*args, **kwargs):
+        return MultiCameraHandler(camera_id, webcam_cap, *args, **kwargs)
+    return handler
+
+def check_port_available(port):
+    """Check if a port is available"""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(('localhost', port))
+            return True
+    except OSError:
+        return False
+
+def start_rtsp_stream(camera_id, webcam_index, rtsp_port):
+    """Start RTSP streaming for a specific camera"""
+    try:
+        # Check if FFmpeg is available
+        result = subprocess.run(['ffmpeg', '-version'], 
+                              capture_output=True, text=True, timeout=5)
+        if result.returncode != 0:
+            logging.warning(f"Camera{camera_id}: FFmpeg not available, RTSP disabled")
+            return None
+            
+    except Exception:
+        logging.warning(f"Camera{camera_id}: FFmpeg not available, RTSP disabled")
+        return None
+    
+    try:
+        # Get camera device name for Windows
+        if sys.platform.startswith('win'):
+            # Use the integrated camera
+            camera_name = "Integrated Camera"
+        
+        # FFmpeg command to stream webcam via RTSP
+        if sys.platform.startswith('win'):
+            cmd = [
+                'ffmpeg',
+                '-f', 'dshow',
+                '-i', f'video={camera_name}',
+                '-c:v', 'libx264',
+                '-preset', 'veryfast',
+                '-tune', 'zerolatency',
+                '-r', '15',  # Lower FPS for multiple streams
+                '-s', '1280x720',
+                '-f', 'rtsp',
+                f'rtsp://localhost:{rtsp_port}/stream'
+            ]
+        else:
+            cmd = [
+                'ffmpeg',
+                '-f', 'v4l2',
+                '-i', f'/dev/video{webcam_index}',
+                '-c:v', 'libx264',
+                '-preset', 'veryfast',
+                '-tune', 'zerolatency',
+                '-r', '15',
+                '-s', '1280x720',
+                '-f', 'rtsp',
+                f'rtsp://localhost:{rtsp_port}/stream'
+            ]
+        
+        logging.info(f"Camera{camera_id}: Starting RTSP stream on port {rtsp_port}")
+        
+        rtsp_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        # Give FFmpeg a moment to start
+        time.sleep(2)
+        
+        if rtsp_process.poll() is None:
+            logging.info(f"Camera{camera_id}: RTSP streaming started successfully")
+            return rtsp_process
+        else:
+            logging.error(f"Camera{camera_id}: RTSP streaming failed to start")
+            return None
+            
+    except Exception as e:
+        logging.error(f"Camera{camera_id}: Failed to start RTSP stream: {e}")
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(description='Multi-Camera Simulator')
+    parser.add_argument('camera_id', type=int, choices=[1, 2, 3, 4], 
+                       help='Camera ID (1-4)')
+    parser.add_argument('--webcam-index', type=int, default=0,
+                       help='Webcam device index (default: 0)')
+    parser.add_argument('--base-port', type=int, default=8080,
+                       help='Base port for HTTP servers (default: 8080)')
+    parser.add_argument('--rtsp-base-port', type=int, default=8550,
+                       help='Base port for RTSP servers (default: 8550)')
+    parser.add_argument('--no-rtsp', action='store_true',
+                       help='Disable RTSP streaming (HTTP only)')
+    
+    args = parser.parse_args()
+    
+    camera_id = args.camera_id
+    webcam_index = args.webcam_index
+    
+    # Calculate ports based on camera ID
+    http_port = args.base_port + camera_id - 1  # 8080, 8081, 8082, 8083
+    rtsp_port = args.rtsp_base_port + camera_id - 1  # 8550, 8551, 8552, 8553
+    
+    # Check if ports are available
+    if not check_port_available(http_port):
+        logging.error(f"Camera{camera_id}: HTTP port {http_port} is already in use")
+        sys.exit(1)
+    
+    if not args.no_rtsp and not check_port_available(rtsp_port):
+        logging.error(f"Camera{camera_id}: RTSP port {rtsp_port} is already in use")
+        sys.exit(1)
+    
+    logging.info(f"=== Starting Camera {camera_id} Simulator ===")
+    
+    # Initialize webcam
+    logging.info(f"Camera{camera_id}: Initializing webcam at index {webcam_index}...")
+    webcam_cap = cv2.VideoCapture(webcam_index)
+    
+    if not webcam_cap.isOpened():
+        logging.error(f"Camera{camera_id}: Failed to open webcam at index {webcam_index}")
+        sys.exit(1)
+    
+    # Set webcam properties
+    webcam_cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
+    webcam_cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
+    webcam_cap.set(cv2.CAP_PROP_FPS, 30)
+    
+    width = int(webcam_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(webcam_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = webcam_cap.get(cv2.CAP_PROP_FPS)
+    
+    logging.info(f"Camera{camera_id}: Webcam initialized: {width}x{height} @ {fps}fps")
+    
+    # Start RTSP streaming (if enabled)
+    rtsp_process = None
+    if not args.no_rtsp:
+        rtsp_process = start_rtsp_stream(camera_id, webcam_index, rtsp_port)
+    
+    # Start HTTP server
+    server_address = ('0.0.0.0', http_port)
+    handler_class = create_handler_class(camera_id, webcam_cap)
+    http_server = HTTPServer(server_address, handler_class)
+    
+    # Get local IP
+    local_ip = "10.101.1.4"  # Wireguard IP
+    
+    logging.info(f"\n=== Camera {camera_id} URLs ===")
+    logging.info(f"HTTP Snapshot: http://{local_ip}:{http_port}/snapshot")
+    logging.info(f"Status: http://{local_ip}:{http_port}/status")
+    
+    if rtsp_process:
+        logging.info(f"RTSP Stream: rtsp://{local_ip}:{rtsp_port}/stream")
+    else:
+        logging.info("RTSP Stream: Disabled")
+    
+    logging.info(f"\n=== CMS Configuration for Camera {camera_id} ===")
+    logging.info(f"Camera Identifier: webcam-camera-0{camera_id}")
+    logging.info(f"Snapshot URL: http://{local_ip}:{http_port}/snapshot")
+    logging.info(f"Snapshot Interval: 2000")
+    if rtsp_process:
+        logging.info(f"RTSP URL: rtsp://{local_ip}:{rtsp_port}/stream")
+    
+    logging.info(f"\nCamera {camera_id} is ready! Press Ctrl+C to stop")
+    
+    try:
+        # Start HTTP server
+        http_server.serve_forever()
+    except KeyboardInterrupt:
+        logging.info(f"Camera{camera_id}: Shutting down...")
+    finally:
+        # Clean up
+        if webcam_cap:
+            webcam_cap.release()
+        
+        if rtsp_process:
+            logging.info(f"Camera{camera_id}: Stopping RTSP stream...")
+            rtsp_process.terminate()
+            try:
+                rtsp_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                rtsp_process.kill()
+        
+        http_server.server_close()
+        logging.info(f"Camera{camera_id}: Stopped")
+
+if __name__ == "__main__":
+    main()

siwatsystem/pympta.py

@@ -681,7 +681,7 @@ def run_detection_with_tracking(frame, node, context=None):
             # Update stability tracking even when no detection (to reset counters)
             camera_id = context.get("camera_id", "unknown") if context else "unknown"
             model_id = node.get("modelId", "unknown")
-            track_validation_result = update_single_track_stability(node, None, camera_id, frame.shape, stability_threshold)
+            track_validation_result = update_single_track_stability(node, None, camera_id, frame.shape, stability_threshold, context)
             
             # Store validation state in context for pipeline decisions
             if context is not None:
@@ -745,7 +745,7 @@ def run_detection_with_tracking(frame, node, context=None):
             # Update stability tracking even when no detection (to reset counters)
             camera_id = context.get("camera_id", "unknown") if context else "unknown"
             model_id = node.get("modelId", "unknown")
-            track_validation_result = update_single_track_stability(node, None, camera_id, frame.shape, stability_threshold)
+            track_validation_result = update_single_track_stability(node, None, camera_id, frame.shape, stability_threshold, context)
             
             # Store validation state in context for pipeline decisions
             if context is not None:
@@ -813,7 +813,7 @@ def run_detection_with_tracking(frame, node, context=None):
         model_id = node.get("modelId", "unknown")
         
         # Update stability tracking for the single best detection
-        track_validation_result = update_single_track_stability(node, best_detection, camera_id, frame.shape, stability_threshold)
+        track_validation_result = update_single_track_stability(node, best_detection, camera_id, frame.shape, stability_threshold, context)
         
         # Store validation state in context for pipeline decisions
         if context is not None:
@@ -866,14 +866,8 @@ def get_camera_stability_data(camera_id, model_id):
                 "waiting_for_backend_session": False,
                 "wait_start_time": 0.0,
                 "reset_tracker_on_resume": False
-            },
-            "occupancy_state": {
-                "phase": "validation",  # "validation", "waiting_for_session", or "occupancy"
-                "absence_counter": 0,   # Count consecutive frames without stable tracks
-                "max_absence_frames": 3, # Trigger "none" after this many absent frames
-                "pipeline_completed": False  # Track if full pipeline has run
             }
-            # Removed detection_counter - using only track-based validation now
+            # Removed obsolete occupancy_state - app.py handles all mode transitions now
         }
     
     return _camera_stability_tracking[camera_id][model_id]
@@ -886,6 +880,7 @@ def reset_camera_stability_tracking(camera_id, model_id):
         # Clear all tracking data
         track_counters = stability_data["track_stability_counters"]
         stable_tracks = stability_data["stable_tracks"]
+        session_state = stability_data["session_state"]
         
         old_counters = dict(track_counters)
         old_stable = list(stable_tracks)
@@ -893,17 +888,16 @@ def reset_camera_stability_tracking(camera_id, model_id):
         track_counters.clear()
         stable_tracks.clear()
         
-        # Reset occupancy state to validation
+        # IMPORTANT: Set flag to reset YOLO tracker on next detection run
-        stability_data["occupancy_state"]["phase"] = "validation"
+        # This will ensure track IDs start fresh (1, 2, 3...) instead of continuing from old IDs
-        stability_data["occupancy_state"]["absence_counter"] = 0
+        session_state["reset_tracker_on_resume"] = True
-        stability_data["occupancy_state"]["pipeline_completed"] = False
         
         logger.info(f"🧹 Camera {camera_id}: CLEARED stability tracking - old_counters={old_counters}, old_stable={old_stable}")
-        # Occupancy state reset logging removed - not used in enhanced lightweight mode
+        logger.info(f"🔄 Camera {camera_id}: YOLO tracker will be reset on next detection - fresh track IDs will start from 1")
     else:
         logger.debug(f"🧹 Camera {camera_id}: No stability tracking data to clear for model {model_id}")
 
-def update_single_track_stability(node, detection, camera_id, frame_shape=None, stability_threshold=4):
+def update_single_track_stability(node, detection, camera_id, frame_shape=None, stability_threshold=4, context=None):
     """Update track stability validation for a single highest confidence car."""
     model_id = node.get("modelId", "unknown")
     
@@ -913,113 +907,102 @@ def update_single_track_stability(node, detection, camera_id, frame_shape=None,
         logger.debug(f"⏭️ Camera {camera_id}: Skipping validation for branch node {model_id} - validation only done at main pipeline level")
         return {"validation_complete": False, "branch_node": True, "stable_tracks": [], "current_tracks": []}
     
+    # Check current mode - VALIDATION COUNTERS should increment in both validation_detecting and full_pipeline modes
+    current_mode = context.get("current_mode", "unknown") if context else "unknown"
+    is_validation_mode = (current_mode in ["validation_detecting", "full_pipeline"])
+    
     # Get camera-specific stability data
     stability_data = get_camera_stability_data(camera_id, model_id)
     track_counters = stability_data["track_stability_counters"]
     stable_tracks = stability_data["stable_tracks"]
-    occupancy_state = stability_data["occupancy_state"]
     
-    current_phase = occupancy_state["phase"]
     current_track_id = detection.get("id") if detection else None
     
-    if current_phase == "validation":
+    # ═══ MODE-AWARE TRACK VALIDATION ═══
-        # ═══ VALIDATION PHASE: Count consecutive frames for single track ═══
+    logger.debug(f"📋 Camera {camera_id}: === TRACK VALIDATION ANALYSIS ===")
-        logger.debug(f"📋 Camera {camera_id}: === TRACK VALIDATION ANALYSIS ===")
+    logger.debug(f"📋 Camera {camera_id}: Current mode: {current_mode} (validation_mode={is_validation_mode})")
-        logger.debug(f"📋 Camera {camera_id}: Current track_id: {current_track_id}")
+    logger.debug(f"📋 Camera {camera_id}: Current track_id: {current_track_id} (assigned by YOLO tracking - not sequential)")
-        logger.debug(f"📋 Camera {camera_id}: Existing counters: {dict(track_counters)}")
+    logger.debug(f"📋 Camera {camera_id}: Existing counters: {dict(track_counters)}")
-        logger.debug(f"📋 Camera {camera_id}: Stable tracks: {list(stable_tracks)}")
+    logger.debug(f"📋 Camera {camera_id}: Stable tracks: {list(stable_tracks)}")
     
-        if current_track_id is not None:
+    # IMPORTANT: Only modify validation counters during validation_detecting mode
-            # Check if this is a different track than we were tracking
+    if not is_validation_mode:
-            previous_track_ids = list(track_counters.keys())
+        logger.debug(f"🚫 Camera {camera_id}: NOT in validation mode - skipping counter modifications")
+        return {
+            "validation_complete": False, 
+            "stable_tracks": list(stable_tracks),
+            "current_tracks": [current_track_id] if current_track_id is not None else []
+        }
     
-            # ALWAYS reset counter if:
+    if current_track_id is not None:
-            # 1. This is a different track ID than before
+        # Check if this is a different track than we were tracking
-            # 2. OR if we had no previous tracking (fresh start)
+        previous_track_ids = list(track_counters.keys())
-            should_reset = (
-                len(previous_track_ids) == 0 or  # No previous tracking
-                current_track_id not in previous_track_ids  # Different track ID
-            )
         
-            logger.debug(f"📋 Camera {camera_id}: Previous track_ids: {previous_track_ids}")
+        # VALIDATION MODE: Reset counter if different track OR if track was previously stable
-            logger.debug(f"📋 Camera {camera_id}: Should reset counters: {should_reset} (no_previous={len(previous_track_ids) == 0}, different_id={current_track_id not in previous_track_ids})")
+        should_reset = (
+            len(previous_track_ids) == 0 or  # No previous tracking
+            current_track_id not in previous_track_ids or  # Different track ID
+            current_track_id in stable_tracks  # Track was stable - start fresh validation
+        )
         
-            if should_reset and previous_track_ids:
+        logger.debug(f"📋 Camera {camera_id}: Previous track_ids: {previous_track_ids}")
-                # Clear all previous tracking - different car detected
+        logger.debug(f"📋 Camera {camera_id}: Track {current_track_id} was stable: {current_track_id in stable_tracks}")
+        logger.debug(f"📋 Camera {camera_id}: Should reset counters: {should_reset}")
+        
+        if should_reset:
+            # Clear all previous tracking - fresh validation needed
+            if previous_track_ids:
                 for old_track_id in previous_track_ids:
                     old_count = track_counters.pop(old_track_id, 0)
                     stable_tracks.discard(old_track_id)
-                    logger.info(f"🔄 Camera {camera_id}: Different car detected (track {current_track_id}) - RESET previous track {old_track_id} counter from {old_count} to 0")
+                    logger.info(f"🔄 Camera {camera_id}: VALIDATION RESET - track {old_track_id} counter from {old_count} to 0 (reason: {'stable_track_restart' if current_track_id == old_track_id else 'different_track'})")
-                    logger.debug(f"🔄 Camera {camera_id}: Cleared track {old_track_id} from counters and stable_tracks")
             
-            # Set counter to 1 for current track (fresh start each frame)
+            # Start fresh validation for this track
+            old_count = track_counters.get(current_track_id, 0)  # Store old count for logging
+            track_counters[current_track_id] = 1
+            current_count = 1
+            logger.info(f"🆕 Camera {camera_id}: FRESH VALIDATION - Track {current_track_id} starting at 1/{stability_threshold}")
+        else:
+            # Continue validation for same track
             old_count = track_counters.get(current_track_id, 0)
-            track_counters[current_track_id] = track_counters.get(current_track_id, 0) + 1
+            track_counters[current_track_id] = old_count + 1
             current_count = track_counters[current_track_id]
         
-            logger.debug(f"🔢 Camera {camera_id}: Track {current_track_id} counter: {old_count} → {current_count}")
+        logger.debug(f"🔢 Camera {camera_id}: Track {current_track_id} counter: {old_count} → {current_count}")
-            logger.info(f"🔍 Camera {camera_id}: Track ID {current_track_id} validation {current_count}/{stability_threshold}")
+        logger.info(f"🔍 Camera {camera_id}: Track ID {current_track_id} validation {current_count}/{stability_threshold}")
         
-            # Check if track has reached stability threshold
+        # Check if track has reached stability threshold
-            logger.debug(f"📊 Camera {camera_id}: Checking stability: {current_count} >= {stability_threshold}? {current_count >= stability_threshold}")
+        logger.debug(f"📊 Camera {camera_id}: Checking stability: {current_count} >= {stability_threshold}? {current_count >= stability_threshold}")
-            logger.debug(f"📊 Camera {camera_id}: Already stable: {current_track_id in stable_tracks}")
+        logger.debug(f"📊 Camera {camera_id}: Already stable: {current_track_id in stable_tracks}")
         
-            if current_count >= stability_threshold and current_track_id not in stable_tracks:
+        if current_count >= stability_threshold and current_track_id not in stable_tracks:
-                stable_tracks.add(current_track_id)
+            stable_tracks.add(current_track_id)
-                occupancy_state["phase"] = "waiting_for_session"
+            logger.info(f"✅ Camera {camera_id}: Track ID {current_track_id} STABLE after {current_count} consecutive frames")
-                occupancy_state["pipeline_completed"] = False
+            logger.info(f"🎯 Camera {camera_id}: TRACK VALIDATION COMPLETE")
-                logger.info(f"✅ Camera {camera_id}: Track ID {current_track_id} STABLE after {current_count} consecutive frames")
+            logger.debug(f"🎯 Camera {camera_id}: Stable tracks now: {list(stable_tracks)}")
-                logger.info(f"🎯 Camera {camera_id}: TRACK VALIDATION COMPLETE")
+            return {
-                logger.debug(f"🎯 Camera {camera_id}: Phase changed to: waiting_for_session")
+                "validation_complete": True, 
-                logger.debug(f"🎯 Camera {camera_id}: Stable tracks now: {list(stable_tracks)}")
+                "send_none_detection": True,
-                return {
+                "stable_tracks": [current_track_id],
-                    "validation_complete": True, 
+                "newly_stable_tracks": [current_track_id],
-                    "send_none_detection": True,
+                "current_tracks": [current_track_id]
-                    "stable_tracks": [current_track_id],
+            }
-                    "newly_stable_tracks": [current_track_id],
+        elif current_count >= stability_threshold:
-                    "current_tracks": [current_track_id]
+            logger.debug(f"📊 Camera {camera_id}: Track {current_track_id} already stable - not re-adding")
-                }
+    else:
-            elif current_count >= stability_threshold:
+        # No car detected - ALWAYS clear all tracking and reset counters
-                logger.debug(f"📊 Camera {camera_id}: Track {current_track_id} already stable - not re-adding")
+        logger.debug(f"🚫 Camera {camera_id}: NO CAR DETECTED - clearing all tracking")
+        if track_counters or stable_tracks:
+            logger.debug(f"🚫 Camera {camera_id}: Existing state before reset: counters={dict(track_counters)}, stable={list(stable_tracks)}")
+            for track_id in list(track_counters.keys()):
+                old_count = track_counters.pop(track_id, 0)
+                logger.info(f"🔄 Camera {camera_id}: No car detected - RESET track {track_id} counter from {old_count} to 0")
+            track_counters.clear()  # Ensure complete reset
+            stable_tracks.clear()   # Clear all stable tracks
+            logger.info(f"✅ Camera {camera_id}: RESET TO VALIDATION PHASE - All counters and stable tracks cleared")
         else:
-            # No car detected - ALWAYS clear all tracking and reset counters
+            logger.debug(f"🚫 Camera {camera_id}: No existing counters to clear")
-            logger.debug(f"🚫 Camera {camera_id}: NO CAR DETECTED - clearing all tracking")
+        logger.debug(f"Camera {camera_id}: VALIDATION - no car detected (all counters reset)")
-            if track_counters:
-                logger.debug(f"🚫 Camera {camera_id}: Existing counters before reset: {dict(track_counters)}")
-                for track_id in list(track_counters.keys()):
-                    old_count = track_counters.pop(track_id, 0)
-                    stable_tracks.discard(track_id)
-                    logger.info(f"🔄 Camera {camera_id}: No car detected - RESET track {track_id} counter from {old_count} to 0")
-                    logger.debug(f"🚫 Camera {camera_id}: Cleared track {track_id} (was at {old_count}/{stability_threshold})")
-                track_counters.clear()  # Ensure complete reset
-                stable_tracks.clear()   # Clear all stable tracks
-                logger.debug(f"🚫 Camera {camera_id}: All counters and stable tracks cleared")
-            else:
-                logger.debug(f"🚫 Camera {camera_id}: No existing counters to clear")
-            logger.debug(f"Camera {camera_id}: VALIDATION - no car detected (all counters reset)")
-    
-    elif current_phase == "waiting_for_session":
-        # ═══ WAITING PHASE: Maintain track stability ═══
-        logger.debug(f"⏳ Camera {camera_id}: WAITING FOR SESSION - monitoring stable track")
-        logger.debug(f"⏳ Camera {camera_id}: Current track_id: {current_track_id}, Stable tracks: {list(stable_tracks)}")
-        
-        if current_track_id is None or current_track_id not in stable_tracks:
-            # Lost the stable track
-            logger.debug(f"⏳ Camera {camera_id}: Stable track lost - clearing all tracking")
-            stable_tracks.clear()
-            track_counters.clear()
-            logger.info(f"🔄 Camera {camera_id}: Lost stable track during waiting phase")
-        else:
-            logger.debug(f"⏳ Camera {camera_id}: Stable track {current_track_id} still present")
-        
-    elif current_phase == "occupancy":
-        # ═══ OCCUPANCY PHASE: UNUSED in enhanced lightweight mode ═══
-        # This phase is bypassed by the new lightweight mode system
-        # Keeping minimal logic for backward compatibility but no CLI logging
-        if current_track_id is not None and current_track_id in stable_tracks:
-            occupancy_state["absence_counter"] = 0
-        else:
-            occupancy_state["absence_counter"] += 1
     
     # Final return - validation not complete
     result = {
@@ -1040,9 +1023,9 @@ def update_track_stability_validation(node, detections, camera_id, frame_shape=N
     logger.warning(f"update_track_stability_validation called for camera {camera_id} - this function is deprecated, use update_single_track_stability instead")
     if detections:
         best_detection = max(detections, key=lambda x: x.get("confidence", 0))
-        return update_single_track_stability(node, best_detection, camera_id, frame_shape, stability_threshold)
+        return update_single_track_stability(node, best_detection, camera_id, frame_shape, stability_threshold, None)
     else:
-        return update_single_track_stability(node, None, camera_id, frame_shape, stability_threshold)
+        return update_single_track_stability(node, None, camera_id, frame_shape, stability_threshold, None)
 
 def update_detection_stability(node, detections, camera_id, frame_shape=None):
     """Legacy detection-based stability counter - DEPRECATED."""
@@ -1051,95 +1034,9 @@ def update_detection_stability(node, detections, camera_id, frame_shape=None):
     return {"validation_complete": False, "valid_detections": 0, "deprecated": True}
 
 def update_track_stability(node, detections, camera_id, frame_shape=None):
-    """Update stability counters with two-phase detection system: validation → occupancy."""
+    """DEPRECATED: This function is obsolete and should not be used."""
-    stability_threshold = node.get("stabilityThreshold", 1)
+    logger.warning(f"update_track_stability called for camera {camera_id} - this function is deprecated and obsolete")
-    model_id = node.get("modelId", "unknown")
+    return {"phase": "validation", "absence_counter": 0, "deprecated": True}
-    min_bbox_area_ratio = node.get("minBboxAreaRatio", 0.0)
-    
-    # Note: This function is deprecated - using detection-based stability now
-    
-    # Get camera-specific stability data
-    stability_data = get_camera_stability_data(camera_id, model_id)
-    track_counters = stability_data["track_stability_counters"]
-    stable_tracks = stability_data["stable_tracks"]
-    occupancy_state = stability_data["occupancy_state"]
-    
-    # Validate detections against confidence + area requirements
-    valid_detections = []
-    if frame_shape is not None:
-        frame_height, frame_width = frame_shape[:2]
-        frame_area = frame_width * frame_height
-        
-        for detection in detections:
-            bbox = detection.get("bbox", [])
-            if len(bbox) >= 4:
-                x1, y1, x2, y2 = bbox
-                bbox_width = abs(x2 - x1)
-                bbox_height = abs(y2 - y1) 
-                bbox_area = bbox_width * bbox_height
-                area_ratio = bbox_area / frame_area if frame_area > 0 else 0.0
-                
-                if area_ratio >= min_bbox_area_ratio:
-                    valid_detections.append(detection)
-                    pass  # Valid detection - no debug spam
-                else:
-                    pass  # Small detection - no debug spam
-    else:
-        valid_detections = detections
-    
-    current_phase = occupancy_state["phase"]
-    
-    if current_phase == "validation":
-        # ═══ VALIDATION PHASE: Count detections until stable ═══
-        detection_key = f"camera_{camera_id}_detections"
-        
-        if valid_detections:
-            # Valid detection found - increment counter
-            track_counters[detection_key] = track_counters.get(detection_key, 0) + 1
-            current_count = track_counters[detection_key]
-            
-            pass  # Validation count - shown in main logs
-            
-            # Check if we've reached the stability threshold
-            if current_count >= stability_threshold and detection_key not in stable_tracks:
-                stable_tracks.add(detection_key)
-                # Switch to waiting for backend session phase
-                occupancy_state["phase"] = "waiting_for_session"
-                occupancy_state["absence_counter"] = 0
-                occupancy_state["pipeline_completed"] = False
-                logger.info(f"✅ Camera {camera_id}: VALIDATION COMPLETE after {current_count} detections - READY FOR FULL PIPELINE")
-        else:
-            # No valid detections - reset validation counter for consecutive requirement
-            if detection_key in track_counters:
-                old_count = track_counters[detection_key]
-                track_counters.pop(detection_key, None)
-                stable_tracks.discard(detection_key)
-                logger.info(f"🔄 Camera {camera_id}: VALIDATION RESET - no valid detection, counter reset from {old_count} to 0 (requires consecutive detections)")
-            else:
-                logger.debug(f"Camera {camera_id}: VALIDATION - no valid detection, counter remains 0")
-    
-    elif current_phase == "waiting_for_session":
-        # ═══ WAITING FOR BACKEND SESSION PHASE ═══
-        # Don't do occupancy monitoring yet, just maintain validation of current detections
-        # The main pipeline will handle sessionId detection and phase transition
-        pass  # Waiting phase - no occupancy logic yet
-        
-    elif current_phase == "occupancy":
-        # ═══ OCCUPANCY PHASE: Monitor car presence ═══
-        if valid_detections:
-            # Car still present - reset absence counter
-            if occupancy_state["absence_counter"] > 0:
-                pass  # Car detected - counter reset (no debug spam)
-            occupancy_state["absence_counter"] = 0
-        else:
-            # No car detected - increment absence counter
-            occupancy_state["absence_counter"] += 1
-            pass  # Absence count - will show in timeout log
-    
-    pass  # Phase summary - excessive debug
-    
-    # Return occupancy state for pipeline decisions
-    return occupancy_state
 
 def check_stable_tracks(camera_id, model_id, regions_dict):
     """Check if any stable tracks match the detected classes for a specific camera."""
@@ -1434,7 +1331,7 @@ def run_lightweight_detection(frame, node: dict):
         logger.error(f"Error in lightweight detection: {str(e)}", exc_info=True)
         return {"car_detected": False, "best_detection": None}
 
-def run_pipeline(frame, node: dict, return_bbox: bool=False, context=None):
+def run_pipeline(frame, node: dict, return_bbox: bool=False, context=None, validated_detection=None):
     """
     Enhanced pipeline that supports:
     - Multi-class detection (detecting multiple classes simultaneously)
@@ -1501,8 +1398,31 @@ def run_pipeline(frame, node: dict, return_bbox: bool=False, context=None):
             }
             return (none_detection, [0, 0, 0, 0]) if return_bbox else none_detection
 
-        # ─── Detection stage - Using structured detection function ──────────────────
+        # ─── Detection stage - Use validated detection if provided (full_pipeline mode) ───
-        all_detections, regions_dict, track_validation_result = run_detection_with_tracking(frame, node, context)
+        if validated_detection:
+            track_id = validated_detection.get('track_id')
+            logger.info(f"🔄 PIPELINE: Using validated detection from validation phase - track_id={track_id}")
+            # Convert validated detection back to all_detections format for branch processing
+            all_detections = [validated_detection]
+            # Create regions_dict based on validated detection class with proper structure
+            class_name = validated_detection.get("class", "car")
+            regions_dict = {
+                class_name: {
+                    "confidence": validated_detection.get("confidence"),
+                    "bbox": validated_detection.get("bbox", [0, 0, 0, 0]),
+                    "detection": validated_detection
+                }
+            }
+            # Bypass track validation completely - force pipeline execution
+            track_validation_result = {
+                "validation_complete": True, 
+                "stable_tracks": ["cached"],  # Use dummy stable track to force pipeline execution
+                "current_tracks": ["cached"],
+                "bypass_validation": True
+            }
+        else:
+            # Normal detection stage - Using structured detection function
+            all_detections, regions_dict, track_validation_result = run_detection_with_tracking(frame, node, context)
         
         if not all_detections:
             logger.debug("No detections from structured detection function - sending 'none' detection")
@@ -1524,14 +1444,14 @@ def run_pipeline(frame, node: dict, return_bbox: bool=False, context=None):
         camera_id = context.get("camera_id", "unknown") if context else "unknown"
         
         if stability_threshold > 1 and tracking_config.get("enabled", True):
-            # Extract occupancy state from stability data (updated by track validation function)
+            # Note: Old occupancy state system removed - app.py handles all mode transitions now
+            # Track validation is handled by update_single_track_stability function
             model_id = node.get("modelId", "unknown")
-            stability_data = get_camera_stability_data(camera_id, model_id)
-            occupancy_state = stability_data["occupancy_state"]
             
-            current_phase = occupancy_state.get("phase", "validation")
+            # Simplified: just check if we have stable tracks from track validation
-            absence_counter = occupancy_state.get("absence_counter", 0)
+            current_phase = "validation"  # Always validation phase in simplified system
-            max_absence_frames = occupancy_state.get("max_absence_frames", 3)
+            absence_counter = 0
+            max_absence_frames = 3
             
             if current_phase == "validation":
                 # ═══ TRACK VALIDATION PHASE ═══
@@ -1562,78 +1482,8 @@ def run_pipeline(frame, node: dict, return_bbox: bool=False, context=None):
                         # We have stable tracks - validation is complete, proceed with pipeline
                         logger.info(f"🎯 Camera {camera_id}: STABLE TRACKS DETECTED - proceeding with full pipeline (tracks: {stable_tracks})")
                     
-            elif current_phase == "waiting_for_session":
+            # Note: Old waiting_for_session and occupancy phases removed
-                # ═══ WAITING FOR BACKEND SESSION PHASE ═══
+            # app.py lightweight mode handles all state transitions now
-                if backend_session_id:
-                    # Backend has responded with sessionId - NOW run the full pipeline for the first time
-                    logger.info(f"🎯 Camera {camera_id}: BACKEND SESSION RECEIVED - RUNNING FULL PIPELINE (sessionId: {backend_session_id})")
-                    occupancy_state["phase"] = "occupancy"
-                    occupancy_state["absence_counter"] = 0
-                    # Continue with normal pipeline processing now that we have sessionId
-                else:
-                    # Still waiting for backend sessionId - send None detection dict to trigger sessionId generation
-                    if not occupancy_state["pipeline_completed"]:
-                        # First time in waiting phase - send empty detection to trigger sessionId
-                        logger.info(f"⚙️ Camera {camera_id}: WAITING PHASE - sending empty detection {{}} for sessionId generation")
-                        occupancy_state["pipeline_completed"] = True
-                        
-                        # Return a special detection that signals app.py to send empty detection: {}
-                        none_detection = {
-                            "class": "validation_complete",
-                            "confidence": 1.0,
-                            "bbox": [0, 0, 0, 0],
-                            "send_empty_detection": True
-                        }
-                        return (none_detection, [0, 0, 0, 0]) if return_bbox else none_detection
-                    else:
-                        # Already sent None detection - continue waiting for sessionId
-                        logger.debug(f"⏳ Camera {camera_id}: WAITING FOR BACKEND SESSION - None detection already sent, waiting for sessionId")
-                        
-                        waiting_detection = {
-                            "class": "waiting_session_id",
-                            "confidence": 1.0,
-                            "bbox": [0, 0, 0, 0],
-                            "waiting_for_session": True
-                        }
-                        return (waiting_detection, [0, 0, 0, 0]) if return_bbox else waiting_detection
-                    
-            elif current_phase == "occupancy":
-                # ═══ OCCUPANCY PHASE ═══
-                stable_tracks = track_validation_result.get("stable_tracks", [])
-                current_tracks = track_validation_result.get("current_tracks", [])
-                
-                # Check if any stable tracks are still present
-                stable_tracks_present = bool(set(stable_tracks) & set(current_tracks))
-                
-                if absence_counter >= max_absence_frames:
-                    # Stable tracks have been absent for too long - trigger "none" detection and reset
-                    # Occupancy timeout logging removed - not used in enhanced lightweight mode
-                    
-                    # Reset occupancy state to validation phase
-                    stability_data = get_camera_stability_data(camera_id, model_id)
-                    stability_data["occupancy_state"]["phase"] = "validation"
-                    stability_data["occupancy_state"]["absence_counter"] = 0
-                    stability_data["track_stability_counters"].clear()
-                    stability_data["stable_tracks"].clear()
-                    
-                    logger.info(f"🔄 Camera {camera_id}: RESET TO VALIDATION PHASE - cleared track stability tracking (sessionId should become null)")
-                    
-                    # Return "none" detection to trigger cache clearing in app.py
-                    none_detection = {"class": "none", "confidence": 1.0, "bbox": [0, 0, 0, 0], "occupancy_triggered": True}
-                    return (none_detection, [0, 0, 0, 0]) if return_bbox else none_detection
-                else:
-                    # Still in occupancy phase - check if stable tracks are present
-                    if stable_tracks_present:
-                        # Stable tracks detected - continue with cached result or light processing
-                        # Occupancy phase logging removed - not used in enhanced lightweight mode
-                        pass
-                    else:
-                        # No stable tracks - absence counter was already incremented in track validation
-                        # Occupancy phase logging removed - not used in enhanced lightweight mode
-                        pass
-                    
-                    # Continue with normal pipeline processing
-                    pass
 
         # ─── Pre-validate pipeline execution (only proceed if we have stable tracks for main pipeline) ────────────────────────
         is_branch_node = node.get("cropClass") is not None or node.get("parallel") is True

start_4_cameras.bat

@@ -0,0 +1,58 @@
+@echo off
+echo ========================================
+echo Starting 4-Camera Simulation
+echo ========================================
+echo.
+echo This will open 4 terminal windows for 4 virtual cameras
+echo Each camera will use the same webcam but with different ports
+echo.
+echo Camera URLs will be:
+echo Camera 1: http://10.101.1.4:8080/snapshot
+echo Camera 2: http://10.101.1.4:8081/snapshot  
+echo Camera 3: http://10.101.1.4:8082/snapshot
+echo Camera 4: http://10.101.1.4:8083/snapshot
+echo.
+echo Press any key to start all cameras...
+pause
+
+echo Starting Camera 1...
+start "Camera 1" cmd /k "python multi_camera_simulator.py 1 && pause"
+
+echo Starting Camera 2...
+start "Camera 2" cmd /k "python multi_camera_simulator.py 2 && pause"
+
+echo Starting Camera 3... 
+start "Camera 3" cmd /k "python multi_camera_simulator.py 3 && pause"
+
+echo Starting Camera 4...
+start "Camera 4" cmd /k "python multi_camera_simulator.py 4 && pause"
+
+echo.
+echo ========================================
+echo All 4 cameras started!
+echo ========================================
+echo.
+echo Use these URLs in your CMS:
+echo.
+echo Camera 1 (Yellow border):
+echo   ID: webcam-camera-01
+echo   Snapshot: http://10.101.1.4:8080/snapshot
+echo   RTSP: rtsp://10.101.1.4:8550/stream
+echo.
+echo Camera 2 (Magenta border):  
+echo   ID: webcam-camera-02
+echo   Snapshot: http://10.101.1.4:8081/snapshot
+echo   RTSP: rtsp://10.101.1.4:8551/stream
+echo.
+echo Camera 3 (Green border):
+echo   ID: webcam-camera-03
+echo   Snapshot: http://10.101.1.4:8082/snapshot
+echo   RTSP: rtsp://10.101.1.4:8552/stream
+echo.
+echo Camera 4 (Blue border):
+echo   ID: webcam-camera-04
+echo   Snapshot: http://10.101.1.4:8083/snapshot
+echo   RTSP: rtsp://10.101.1.4:8553/stream
+echo.
+echo Press any key to exit...
+pause

start_4_cameras.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+
+echo "========================================"
+echo "Starting 4-Camera Simulation"
+echo "========================================"
+echo ""
+echo "This will start 4 virtual cameras in background"
+echo "Each camera will use the same webcam but with different ports"
+echo ""
+echo "Camera URLs will be:"
+echo "Camera 1: http://10.101.1.4:8080/snapshot"
+echo "Camera 2: http://10.101.1.4:8081/snapshot"
+echo "Camera 3: http://10.101.1.4:8082/snapshot"
+echo "Camera 4: http://10.101.1.4:8083/snapshot"
+echo ""
+
+# Function to start camera in new terminal
+start_camera() {
+    local camera_id=$1
+    echo "Starting Camera $camera_id..."
+    
+    # Try different terminal emulators
+    if command -v gnome-terminal &> /dev/null; then
+        gnome-terminal --title="Camera $camera_id" -- bash -c "python3 multi_camera_simulator.py $camera_id; read -p 'Press Enter to close...'"
+    elif command -v xterm &> /dev/null; then
+        xterm -title "Camera $camera_id" -e "python3 multi_camera_simulator.py $camera_id; read -p 'Press Enter to close...'" &
+    elif command -v konsole &> /dev/null; then
+        konsole --title "Camera $camera_id" -e bash -c "python3 multi_camera_simulator.py $camera_id; read -p 'Press Enter to close...'" &
+    elif [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS
+        osascript -e "tell application \"Terminal\" to do script \"cd $(pwd) && python3 multi_camera_simulator.py $camera_id\""
+    else
+        echo "No suitable terminal emulator found. Starting in background..."
+        python3 multi_camera_simulator.py $camera_id &
+        echo "Camera $camera_id PID: $!"
+    fi
+    
+    sleep 1
+}
+
+# Start all 4 cameras
+start_camera 1
+start_camera 2
+start_camera 3
+start_camera 4
+
+echo ""
+echo "========================================"
+echo "All 4 cameras started!"
+echo "========================================"
+echo ""
+echo "Use these URLs in your CMS:"
+echo ""
+echo "Camera 1 (Yellow border):"
+echo "  ID: webcam-camera-01"
+echo "  Snapshot: http://10.101.1.4:8080/snapshot"
+echo "  RTSP: rtsp://10.101.1.4:8550/stream"
+echo ""
+echo "Camera 2 (Magenta border):"
+echo "  ID: webcam-camera-02"
+echo "  Snapshot: http://10.101.1.4:8081/snapshot"  
+echo "  RTSP: rtsp://10.101.1.4:8551/stream"
+echo ""
+echo "Camera 3 (Green border):"
+echo "  ID: webcam-camera-03"
+echo "  Snapshot: http://10.101.1.4:8082/snapshot"
+echo "  RTSP: rtsp://10.101.1.4:8552/stream"
+echo ""
+echo "Camera 4 (Blue border):"
+echo "  ID: webcam-camera-04"
+echo "  Snapshot: http://10.101.1.4:8083/snapshot"
+echo "  RTSP: rtsp://10.101.1.4:8553/stream"
+echo ""
+echo "To stop all cameras, close the terminal windows or press Ctrl+C in each"
+echo ""
+
+# Keep script running
+read -p "Press Enter to exit..."