11 KiB
11 KiB
🚦 Qt Traffic Monitoring Application - PySide6 Implementation Guide
📋 Project Overview
Location: D:\Downloads\finale6\khatam\qt_app_pyside\
Framework: PySide6 (Qt6) with OpenCV and OpenVINO
Architecture: Model-View-Controller (MVC) Pattern
Purpose: Real-time traffic violation detection desktop application
🚀 Application Entry Points
main.py (52 lines) - Primary Launcher
def main():
app = QApplication.instance() or QApplication(sys.argv)
# Show splash screen
splash = show_splash(app)
time.sleep(1)
# Load main window
from ui.main_window import MainWindow
window = MainWindow()
window.show()
return app.exec()
launch.py (44 lines) - Subprocess Launcher
- Purpose: Encoding-safe application launching using subprocess
- Features: Path validation, cross-platform compatibility, error handling
- Usage: Alternative launcher to avoid Python encoding issues
run_app.py (115 lines) - Environment Setup
- Purpose: Dynamic import path fixing and dependency validation
- Features: Automatic init.py creation, fallback import handling
- Functionality: Ensures all required modules are available before launch
🖥️ User Interface Components (ui/ Directory)
main_window.py (641 lines) - Primary Window
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.settings = QSettings("OpenVINO", "TrafficMonitoring")
self.setup_ui()
self.setup_controllers()
self.connect_signals()
def setup_ui(self):
# Create tab widget
self.tab_widget = QTabWidget()
# Add tabs
self.live_tab = LiveTab()
self.analytics_tab = AnalyticsTab()
self.violations_tab = ViolationsTab()
self.export_tab = ExportTab()
self.config_panel = ConfigPanel()
# Setup menus and toolbars
self.create_menus()
self.create_toolbars()
live_tab.py - Real-time Video Display
class LiveTab(QWidget):
def __init__(self):
super().__init__()
self.video_display = QLabel() # Main video display
self.control_panel = self.create_controls()
self.status_panel = self.create_status_display()
def create_controls(self):
# Play/Pause/Stop buttons
# Source selection (camera/file)
# Recording controls
def update_frame(self, pixmap):
# Thread-safe frame updates
self.video_display.setPixmap(pixmap.scaled(
self.video_display.size(),
Qt.KeepAspectRatio,
Qt.SmoothTransformation
))
analytics_tab.py - Data Visualization
- Purpose: Violation analytics dashboard with charts and graphs
- Components: Real-time charts, historical data, trend analysis
- Features: Interactive visualization, export capabilities
violations_tab.py - Violation Management
- Purpose: Browse and manage detected violations
- Features: Search, filter, detailed view, evidence export
- Implementation: Model-view architecture with custom delegates
export_tab.py - Data Export Interface
- Purpose: Report generation and data export functionality
- Formats: PDF reports, CSV data, video clips, JSON logs
- Features: Scheduled exports, custom report templates
config_panel.py - Settings Interface
- Purpose: Application configuration and camera settings
- Features: Real-time parameter adjustment, profile management
- Implementation: Form-based configuration with validation
🎮 Controllers (controllers/ Directory)
enhanced_video_controller.py (687 lines) - Main Processing Engine
class EnhancedVideoController(QObject):
# Signals for UI updates
frame_ready = Signal(QPixmap)
stats_updated = Signal(dict)
violation_detected = Signal(dict)
def __init__(self):
super().__init__()
self.detector = OpenVINOVehicleDetector()
self.processing_thread = QThread()
self.frame_queue = deque(maxlen=30)
def process_frame_async(self, frame):
"""Async frame processing with OpenVINO"""
detections = self.detector.detect(frame)
annotated_frame = self.annotate_frame(frame, detections)
violations = self.check_violations(detections)
# Emit signals
self.frame_ready.emit(self.cv_to_qpixmap(annotated_frame))
self.stats_updated.emit(self.get_performance_stats())
if violations:
self.violation_detected.emit(violations)
model_manager.py (400 lines) - AI Model Management
class ModelManager:
def __init__(self, config_file=None):
self.config = self.load_config(config_file)
self.vehicle_detector = OpenVINOVehicleDetector()
self.tracker = DeepSORTTracker()
def detect(self, frame):
"""Run object detection"""
detections = self.vehicle_detector.infer(frame)
processed = self.post_process(detections)
return self.filter_by_confidence(processed)
def track_objects(self, detections, frame):
"""Multi-object tracking"""
tracks = self.tracker.update(detections, frame)
return self.format_tracking_results(tracks)
video_controller_new.py - Standard Video Processing
- Purpose: Basic video processing without enhanced features
- Features: Video capture, basic detection, simple tracking
- Usage: Fallback when enhanced controller unavailable
analytics_controller.py - Data Analysis
- Purpose: Process violation data for analytics dashboard
- Features: Statistical analysis, trend calculation, reporting
- Implementation: Real-time data aggregation and visualization
performance_overlay.py - System Monitoring
- Purpose: Real-time performance metrics display
- Metrics: FPS, inference time, memory usage, detection counts
- Visualization: Overlay on video frames, separate monitoring panel
🛠️ Utility Modules (utils/ Directory)
traffic_light_utils.py (569 lines) - Traffic Light Detection
def detect_traffic_light_color(frame, bbox):
"""Advanced traffic light color detection"""
x1, y1, x2, y2 = bbox
roi = frame[y1:y2, x1:x2]
# Convert to HSV for better color detection
hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
# Define HSV ranges for each color
red_mask1 = cv2.inRange(hsv, (0, 40, 40), (15, 255, 255))
red_mask2 = cv2.inRange(hsv, (160, 40, 40), (180, 255, 255))
yellow_mask = cv2.inRange(hsv, (15, 50, 50), (40, 255, 255))
green_mask = cv2.inRange(hsv, (35, 25, 25), (95, 255, 255))
# Calculate color areas
red_area = cv2.countNonZero(red_mask1) + cv2.countNonZero(red_mask2)
yellow_area = cv2.countNonZero(yellow_mask)
green_area = cv2.countNonZero(green_mask)
# Determine dominant color
areas = {"red": red_area, "yellow": yellow_area, "green": green_area}
dominant_color = max(areas, key=areas.get)
confidence = areas[dominant_color] / (roi.shape[0] * roi.shape[1])
return {"color": dominant_color, "confidence": confidence}
enhanced_annotation_utils.py - Advanced Visualization
def enhanced_draw_detections(frame, detections):
"""Draw enhanced detection overlays"""
for detection in detections:
bbox = detection['bbox']
class_name = detection['class']
confidence = detection['confidence']
track_id = detection.get('track_id', -1)
# Color coding by object type
colors = {
'car': (0, 255, 0), # Green
'truck': (255, 165, 0), # Orange
'person': (255, 0, 255), # Magenta
'traffic_light': (0, 0, 255) # Red
}
color = colors.get(class_name, (255, 255, 255))
# Draw bounding box
cv2.rectangle(frame, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color, 2)
# Draw label with confidence
label = f"{class_name}: {confidence:.2f}"
if track_id >= 0:
label += f" ID:{track_id}"
cv2.putText(frame, label, (bbox[0], bbox[1]-10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
return frame
crosswalk_utils.py - Crosswalk Detection
- Purpose: Detect crosswalks and stop lines using computer vision
- Methods: Edge detection, line clustering, pattern recognition
- Features: Multi-scale detection, confidence scoring
helpers.py - Common Utilities
- Purpose: Configuration management, file operations, data conversion
- Functions:
load_configuration(),save_snapshot(),format_timestamp()
⚙️ Configuration and Resources
config.json - Application Settings
{
"video_sources": {
"default_camera": 0,
"resolution": [1920, 1080],
"fps": 30
},
"detection": {
"confidence_threshold": 0.5,
"nms_threshold": 0.4,
"model_path": "models/yolo11x_openvino_model/"
},
"ui": {
"theme": "dark",
"show_fps": true,
"show_performance": true
}
}
resources/ - UI Assets
splash.png # Application startup screen
style.qss # Qt stylesheet for theming
icons/ # UI icons (play, pause, stop, settings)
themes/ # Color schemes (dark.qss, light.qss)
requirements.txt - Dependencies
PySide6>=6.4.0 # Qt6 GUI framework
opencv-python>=4.7.0 # Computer vision
numpy>=1.21.0 # Numerical computing
openvino>=2023.0 # Intel OpenVINO runtime
🔄 Application Flow
Startup Sequence
- main.py → Initialize QApplication
- splash.py → Show startup screen
- main_window.py → Create main interface
- Controllers → Initialize video processing
- UI Tabs → Setup user interface components
Runtime Processing
- Video Input → Camera/file capture
- Model Manager → Object detection
- Traffic Light Utils → Color classification
- Enhanced Controller → Frame processing
- UI Updates → Real-time display
- Analytics → Data collection and analysis
Data Flow
Video Frame → Detection → Tracking → Violation Check → UI Display
↓
Analytics → Statistics → Reports → Export
📊 Performance Specifications
System Requirements
- OS: Windows 10/11, Linux, macOS
- RAM: 8GB minimum, 16GB recommended
- GPU: Optional (Intel GPU, NVIDIA, AMD)
- Storage: 2GB for models and dependencies
Performance Metrics
- Frame Rate: 30 FPS (1080p), 60 FPS (720p)
- Latency: <100ms processing delay
- Accuracy: 95%+ detection accuracy
- Memory: <2GB RAM usage during operation
Scalability
- Concurrent Streams: Up to 4 cameras simultaneously
- Resolution Support: 480p to 4K
- Model Flexibility: Supports multiple AI model formats
- Export Capacity: Unlimited violation storage
Total Implementation: 3,000+ lines of PySide6 application code with real-time video processing, AI integration, and comprehensive user interface.