Upload 24 files

.gitattributes

@@ -33,3 +33,17 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+demo_videos/Abuse.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Arrest.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Arson.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Assault.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Burglary.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Explosion.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Fighting.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Normal.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/RoadAccidents.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Robbery.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Shooting.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Shoplifting.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Stealing.mp4 filter=lfs diff=lfs merge=lfs -text
+demo_videos/Vandalism.mp4 filter=lfs diff=lfs merge=lfs -text

demo_videos/Abuse.mp4

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

demo_videos/Arrest.mp4

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

demo_videos/Arson.mp4

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

demo_videos/Assault.mp4

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

demo_videos/Burglary.mp4

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

demo_videos/Explosion.mp4

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

demo_videos/Fighting.mp4

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

demo_videos/Normal.mp4

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

demo_videos/RoadAccidents.mp4

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

demo_videos/Robbery.mp4

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

demo_videos/Shooting.mp4

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

demo_videos/Shoplifting.mp4

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

demo_videos/Stealing.mp4

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

demo_videos/Vandalism.mp4

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

load_model.py

@@ -0,0 +1,114 @@
+"""This module contains functions for loading models."""
+
+import logging
+from os import path
+from typing import Tuple
+
+import torch
+
+from network.anomaly_detector_model import AnomalyDetector
+from network.c3d import C3D
+from network.MFNET import MFNET_3D
+from network.resnet import generate_model
+from network.TorchUtils import TorchModel
+from utils.types import Device, FeatureExtractor
+
+
+def load_feature_extractor(
+    features_method: str, feature_extractor_path: str, device: Device
+) -> FeatureExtractor:
+    """Load feature extractor from given path.
+
+    Args:
+        features_method (str): The feature extractor model type to use. Either c3d | mfnet | r3d101 | r3d152.
+        feature_extractor_path (str): Path to the feature extractor model.
+        device (Union[torch.device, str]): Device to use for the model.
+
+    Raises:
+        FileNotFoundError: The path to the model does not exist.
+        NotImplementedError: The provided feature extractor method is not implemented.
+
+    Returns:
+        FeatureExtractor
+    """
+    if not path.exists(feature_extractor_path):
+        raise FileNotFoundError(
+            f"Couldn't find feature extractor {feature_extractor_path}.\n"
+            + r"If you are using resnet, download it first from:\n"
+            + r"r3d101: https://drive.google.com/file/d/1p80RJsghFIKBSLKgtRG94LE38OGY5h4y/view?usp=share_link"
+            + "\n"
+            + r"r3d152: https://drive.google.com/file/d/1irIdC_v7wa-sBpTiBlsMlS7BYNdj4Gr7/view?usp=share_link"
+        )
+    logging.info(f"Loading feature extractor from {feature_extractor_path}")
+
+    model: FeatureExtractor
+
+    if features_method == "c3d":
+        model = C3D(pretrained=feature_extractor_path)
+    elif features_method == "mfnet":
+        model = MFNET_3D()
+        model.load_state(state_dict=feature_extractor_path)
+    elif features_method == "r3d101":
+        model = generate_model(model_depth=101)
+        param_dict = torch.load(feature_extractor_path)["state_dict"]
+        param_dict.pop("fc.weight")
+        param_dict.pop("fc.bias")
+        model.load_state_dict(param_dict)
+    elif features_method == "r3d152":
+        model = generate_model(model_depth=152)
+        param_dict = torch.load(feature_extractor_path)["state_dict"]
+        param_dict.pop("fc.weight")
+        param_dict.pop("fc.bias")
+        model.load_state_dict(param_dict)
+    else:
+        raise NotImplementedError(
+            f"Features extraction method {features_method} not implemented"
+        )
+
+    return model.to(device).eval()
+
+
+def load_anomaly_detector(ad_model_path: str, device: Device) -> AnomalyDetector:
+    """Load anomaly detection model from given path.
+
+    Args:
+        ad_model_path (str): Path to the anomaly detection model.
+        device (Device): Device to use for the model.
+
+    Raises:
+        FileNotFoundError: The path to the model does not exist.
+
+    Returns:
+        AnomalyDetector
+    """
+    if not path.exists(ad_model_path):
+        raise FileNotFoundError(f"Couldn't find anomaly detector {ad_model_path}.")
+    logging.info(f"Loading anomaly detector from {ad_model_path}")
+
+    anomaly_detector = TorchModel.load_model(ad_model_path).to(device)
+    return anomaly_detector.eval()
+
+
+def load_models(
+    feature_extractor_path: str,
+    ad_model_path: str,
+    features_method: str = "c3d",
+    device: Device = "cuda",
+) -> Tuple[AnomalyDetector, FeatureExtractor]:
+    """Loads both feature extractor and anomaly detector from the given paths.
+
+    Args:
+        feature_extractor_path (str): Path of the features extractor weights to load.
+        ad_model_path (str): Path of the anomaly detector weights to load.
+        features_method (str, optional): Name of the model to use for features extraction.
+            Defaults to "c3d".
+        device (str, optional): Device to use for the models. Defaults to "cuda".
+
+    Returns:
+        Tuple[nn.Module, nn.Module]
+    """
+    feature_extractor = load_feature_extractor(
+        features_method, feature_extractor_path, device
+    )
+    anomaly_detector = load_anomaly_detector(ad_model_path, device)
+    return anomaly_detector, feature_extractor

main.js

@@ -0,0 +1,108 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const socket = io();
+
+    const videoPlayer = document.getElementById('videoPlayer');
+    const yoloTextLabel = document.getElementById('yoloTextLabel');
+    const yoloImageFrame = document.getElementById('yoloImageFrame');
+    const statusLabel = document.getElementById('statusLabel');
+    const resetButton = document.getElementById('resetButton');
+    const videoUploadInput = document.getElementById('videoUpload');
+    const uploadButton = document.getElementById('uploadButton');
+    
+    // CHANGED: Get the new dropdown selector
+    const anomalySelector = document.getElementById('anomalySelector');
+
+    let chart;
+
+    function initializeChart() {
+        const ctx = document.getElementById('anomalyChart').getContext('2d');
+        if (chart) { chart.destroy(); }
+        chart = new Chart(ctx, {
+            type: 'line', data: { labels: [], datasets: [{ label: 'Anomaly Score', data: [], borderColor: 'rgba(255, 99, 132, 1)', backgroundColor: 'rgba(255, 99, 132, 0.2)', borderWidth: 2, tension: 0.4, pointRadius: 0 }] }, options: { scales: { y: { beginAtZero: true, max: 1.0, ticks: { color: '#e0e0e0' }}, x: { ticks: { color: '#e0e0e0' }}}, plugins: { legend: { labels: { color: '#e0e0e0' }}}}
+        });
+    }
+
+    function resetUI() {
+        videoPlayer.pause();
+        videoPlayer.removeAttribute('src');
+        videoPlayer.load();
+        initializeChart();
+        yoloTextLabel.textContent = 'Waiting for anomaly...';
+        yoloImageFrame.src = '';
+        statusLabel.textContent = 'System reset. Select a video to begin.';
+        videoUploadInput.value = '';
+        anomalySelector.selectedIndex = 0; // Reset dropdown to the default option
+    }
+
+    // --- WebSocket Event Listeners (unchanged) ---
+    socket.on('connect', () => { statusLabel.textContent = 'Connected. Please select a video to start processing.'; });
+    socket.on('update_graph', (data) => {
+        const { score } = data;
+        if (!chart) return;
+        const newLabel = chart.data.labels.length + 1;
+        chart.data.labels.push(newLabel);
+        chart.data.datasets[0].data.push(score);
+        if (chart.data.labels.length > 100) { chart.data.labels.shift(); chart.data.datasets[0].data.shift(); }
+        chart.update();
+    });
+    socket.on('update_yolo_text', (data) => { yoloTextLabel.textContent = data.text; });
+    socket.on('update_yolo_image', (data) => { yoloImageFrame.src = `data:image/jpeg;base64,${data.image_data}`; });
+    socket.on('update_status', (data) => { statusLabel.textContent = data.status; });
+    socket.on('processing_error', (data) => { statusLabel.textContent = `Error: ${data.error}`; });
+    socket.on('processing_finished', (data) => { statusLabel.textContent = data.message; });
+    socket.on('system_reset_confirm', () => { resetUI(); });
+
+    // --- User Interaction ---
+
+    // CHANGED: Replaced the old event listener for links with one for the dropdown
+    anomalySelector.addEventListener('change', (event) => {
+        const anomalyName = event.target.value;
+        if (!anomalyName) return; // Do nothing if the default option is selected
+
+        resetUI();
+        statusLabel.textContent = `Requesting to process ${anomalyName}...`;
+        
+        videoPlayer.src = `/video_stream/demo/${anomalyName}`;
+        videoPlayer.play();
+        
+        socket.emit('start_processing', { 'source': 'demo', 'filename': anomalyName });
+    });
+
+    resetButton.addEventListener('click', () => { socket.emit('reset_system'); });
+
+    // Upload button logic (unchanged)
+    uploadButton.addEventListener('click', () => {
+        const file = videoUploadInput.files[0];
+        if (!file) {
+            alert('Please select a video file first!');
+            return;
+        }
+        
+        resetUI();
+        statusLabel.textContent = 'Uploading video...';
+        
+        const formData = new FormData();
+        formData.append('video', file);
+
+        fetch('/upload', { method: 'POST', body: formData })
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                const uploadedFilename = data.filename;
+                statusLabel.textContent = `Upload successful. Starting analysis...`;
+                videoPlayer.src = `/video_stream/upload/${uploadedFilename}`;
+                videoPlayer.play();
+                socket.emit('start_processing', { 'source': 'upload', 'filename': uploadedFilename });
+            } else {
+                statusLabel.textContent = `Error: ${data.error}`;
+                alert(`Upload failed: ${data.error}`);
+            }
+        })
+        .catch(error => {
+            statusLabel.textContent = 'An error occurred during upload.';
+            console.error('Upload error:', error);
+        });
+    });
+
+    initializeChart();
+});

models/c3d.pickle

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

models/epoch_80000.pt

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

models/yolo_my_model.pt

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

outputs/anomaly_clip_img.zip

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

requirements.txt

@@ -0,0 +1,19 @@
+typing
+matplotlib==3.7.2
+torch
+torchvision==0.15.2
+pandas==2.0.3
+tqdm==4.65.0
+pyyaml==6.0.1
+scipy==1.10.1
+scikit-learn==1.3.0
+av==11.0.0
+opencv-python
+pre-commit==3.4.0
+PyQt5
+tensorboard==2.10.0
+ruff==0.11.2
+flask
+flask-socketio
+eventlet
+numpy

style.css

@@ -0,0 +1,112 @@
+body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    background-color: #121212;
+    color: #e0e0e0;
+    margin: 0;
+    padding: 20px;
+    display: flex;
+    justify-content: center;
+}
+
+.container {
+    display: flex;
+    width: 100%;
+    max-width: 1600px;
+    gap: 20px;
+}
+
+/* CHANGED: Main content takes more space, sidebar takes less */
+.main-content {
+    flex: 4; /* Increased from 3 */
+    display: flex;
+    flex-direction: column;
+}
+
+.sidebar {
+    flex: 1; /* Stays at 1, making it proportionally smaller */
+    background-color: #1e1e1e;
+    padding: 20px;
+    border-radius: 8px;
+    height: fit-content;
+}
+
+.header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+h1 { border-bottom: none; padding-bottom: 0; }
+h2, h3 { color: #ffffff; border-bottom: 2px solid #333; padding-bottom: 10px; }
+
+/* CHANGED: Grid ratio adjusted to make the graph wider */
+.dashboard-grid {
+    display: grid;
+    grid-template-columns: 1.8fr 1.5fr; /* Video area vs Graph area */
+    gap: 20px;
+    align-items: flex-start;
+}
+
+.video-area {
+    display: flex;
+    flex-direction: column;
+}
+
+.video-wrapper {
+    width: 100%;
+    margin-bottom: 10px; /* Space between video and status label */
+}
+
+#videoPlayer {
+    background-color: #000;
+    border-radius: 8px;
+}
+
+/* CHANGED: Status label is now positioned under the video */
+#statusLabel {
+    margin-top: 0; /* Resets previous margin */
+    font-style: italic;
+    color: #f44336;
+    text-align: center; /* Center the text under the video */
+    min-height: 24px; /* Prevents layout shifts */
+}
+
+/* The chart and yolo containers are now styled independently */
+.chart-container {
+    background-color: #1e1e1e;
+    padding: 20px;
+    border-radius: 8px;
+}
+
+.yolo-container {
+    background-color: #1e1e1e;
+    padding: 20px;
+    border-radius: 8px;
+}
+
+#yoloTextLabel { font-size: 1.2em; font-weight: bold; color: #4CAF50; min-height: 25px; }
+#yoloImageFrame { width: 100%; height: auto; border-radius: 4px; background-color: #333; min-height: 150px; margin-top: 10px; }
+
+/* Styles for controls in the sidebar */
+.custom-select {
+    width: 100%;
+    padding: 12px 15px;
+    background-color: #3a3a3a;
+    color: #e0e0e0;
+    border: 1px solid #bb86fc;
+    border-radius: 4px;
+    font-size: 1em;
+    cursor: pointer;
+}
+.custom-select:hover { background-color: #4a4a4a; }
+
+.separator { border: none; border-top: 1px solid #333; margin: 20px 0; }
+.upload-section { display: flex; flex-direction: column; gap: 10px; }
+#videoUpload { color: #e0e0e0; }
+#videoUpload::file-selector-button { font-weight: bold; color: #bb86fc; background-color: #3a3a3a; padding: 8px 12px; border: 1px solid #bb86fc; border-radius: 4px; cursor: pointer; transition: background-color 0.2s; }
+#videoUpload::file-selector-button:hover { background-color: #4a4a4a; }
+#uploadButton { padding: 10px 20px; font-size: 16px; font-weight: bold; color: white; background-color: #03dac6; border: none; border-radius: 5px; cursor: pointer; transition: background-color 0.2s; }
+#uploadButton:hover { background-color: #018786; }
+#resetButton { padding: 10px 20px; font-size: 16px; font-weight: bold; color: white; background-color: #f44336; border: none; border-radius: 5px; cursor: pointer; transition: background-color 0.2s; }
+#resetButton:hover { background-color: #d32f2f; }

utils.py

@@ -0,0 +1,87 @@
+"""This module contains utilities for anomaly detection."""
+
+import logging
+import sys
+from typing import List, Optional, Union
+
+from torchvision.transforms import transforms
+
+from . import transforms_video
+
+
+def register_logger(log_file: Optional[str] = None, stdout: bool = True) -> None:
+    """Register a logger.
+
+    Args:
+        log_file (str, optional): Path to the file where log should be written.
+            If `None`, log wouldn't be written to any file. Defaults to None.
+        stdout (bool, optional): If `True`, the log would be printed to stdout. Defaults to True.
+    """
+    log = logging.getLogger()  # root logger
+    for hdlr in log.handlers[:]:  # remove all old handlers
+        log.removeHandler(hdlr)
+
+    handlers: List[Union[logging.FileHandler, logging.StreamHandler]] = []
+
+    if stdout:
+        handlers.append(logging.StreamHandler(stream=sys.stdout))
+
+    if log_file is not None:
+        handlers.append(logging.FileHandler(log_file))
+
+    logging.basicConfig(
+        format="%(asctime)s %(message)s",
+        handlers=handlers,
+        level=logging.INFO,
+    )
+    logging.root.setLevel(logging.INFO)
+
+
+def build_transforms(mode: str = "c3d") -> transforms.Compose:
+    """Build transforms to use for training an anomaly detection model.
+
+    Args:
+        mode (str, optional): Mode for which transforms should be constructed.
+        Either c3d | i3d | mfnet | 3dResNet. Defaults to "c3d".
+
+    Raises:
+        NotImplementedError: The provided mode is not implemented.
+
+    Returns:
+        transforms.Compose
+    """
+    if mode == "c3d":
+        mean = [124 / 255, 117 / 255, 104 / 255]
+        std = [1 / (0.0167 * 255)] * 3
+        resize = 128, 171
+        crop = 112
+    elif mode == "i3d":
+        mean = [0, 0, 0]
+        std = [1, 1, 1]
+    elif mode == "mfnet":
+        mean = [0.485, 0.456, 0.406]
+        std = [0.229, 0.224, 0.225]
+    elif mode == "3dResNet":
+        mean = [0.4345, 0.4051, 0.3775]
+        std = [0.2768, 0.2713, 0.2737]
+    else:
+        raise NotImplementedError(f"Mode {mode} not implemented")
+
+    if mode == "c3d":
+        res = transforms.Compose(
+            [
+                transforms_video.ToTensorVideo(),
+                transforms_video.ResizeVideo(resize),
+                transforms_video.CenterCropVideo(crop),
+                transforms_video.NormalizeVideo(mean=mean, std=std),
+            ]
+        )
+    else:
+        res = transforms.Compose(
+            [
+                transforms_video.ToTensorVideo(),
+                transforms_video.NormalizeVideo(mean=mean, std=std),
+            ]
+        )
+
+    return res

yolo_detection.py

@@ -0,0 +1,123 @@
+import argparse
+import os
+import sys
+import cv2
+from ultralytics import YOLO
+import numpy as np
+
+# --- Configuration ---
+# Set the path for the YOLO model weights
+YOLO_MODEL_PATH = r"S:\ano_dec_pro\AnomalyDetectionCVPR2018-Pytorch\yolo_my_model.pt"
+
+# --- Main Detection Function ---
+def analyze_video_with_yolo(video_path: str, model_path: str = YOLO_MODEL_PATH, conf_threshold: float = 0.5,return_class=False):
+    """
+    Analyzes a video using a pre-trained YOLO model for object detection 
+    and prints the predicted anomaly class for frames with detections.
+
+    :param video_path: Path to the input video file.
+    :param model_path: Path to the trained YOLO model weights.
+    :param conf_threshold: Minimum confidence score required for a detection.
+    """
+    if not os.path.exists(video_path):
+        print(f"[ERROR] Video file not found at: {video_path}")
+        return
+
+    if not os.path.exists(model_path):
+        print(f"[ERROR] YOLO model not found at: {model_path}")
+        return
+
+    try:
+        # Load the YOLO model (Assumes it's trained for your 14 anomaly classes)
+        model = YOLO(model_path, task='detect')
+        labels = model.names
+        print(f"[INFO] YOLO Model loaded successfully with {len(labels)} classes.")
+    except Exception as e:
+        print(f"[FATAL] Failed to load YOLO model: {e}")
+        return
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print(f"[ERROR] Could not open video stream for: {video_path}")
+        return
+
+    frame_num = 0
+    detections_found = 0
+
+    print("-" * 50)
+    print(f"Starting analysis of: {os.path.basename(video_path)}")
+    print("-" * 50)
+
+
+    detected_class = "None"
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if frame_num % 10 == 0:
+            results = model(frame, conf=conf_threshold, verbose=False)
+            if results and len(results[0].boxes) > 0:
+                detections = results[0].boxes
+                best_detection = detections[detections.conf.argmax()]
+                class_idx = int(best_detection.cls.item())
+                class_name = labels.get(class_idx, "Unknown Class")
+                detected_class = class_name
+        frame_num += 1
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+    if return_class:
+        return detected_class
+
+
+
+
+
+    # while cap.isOpened():
+    #     ret, frame = cap.read()
+    #     if not ret:
+    #         break
+
+    #     # Analyze every 10th frame to speed up testing and reduce redundancy
+    #     if frame_num % 10 == 0:
+            
+    #         # Run inference (set verbose=False to keep the output clean)
+    #         results = model(frame, conf=conf_threshold, verbose=False)
+            
+    #         # Process results
+    #         if results and len(results[0].boxes) > 0:
+    #             detections = results[0].boxes
+                
+    #             # We'll take the highest confidence detection in the frame
+    #             best_detection = detections[detections.conf.argmax()]
+                
+    #             class_idx = int(best_detection.cls.item())
+    #             class_name = labels.get(class_idx, "Unknown Class")
+    #             confidence = best_detection.conf.item()
+                
+    #             print(f"Frame {frame_num:05d}: DETECTED -> {class_name} ({confidence:.2f})")
+    #             detections_found += 1
+
+    #     frame_num += 1
+
+    # cap.release()
+    # cv2.destroyAllWindows()
+    
+    print("-" * 50)
+    print(f"Analysis complete. Total detections reported: {detections_found}")
+    print("-" * 50)
+
+
+# if __name__ == '__main__':
+#     # --- Example Usage (Run this command in your environment) ---
+#     # Change the video path to a file you want to test!
+#     example_video = r"S:\ano_dec_pro\dataset\Abuse\Abuse002_x264.mp4"
+    
+#     # NOTE: In a shell/CLI environment (like VS Code or PowerShell), you typically
+#     # run this by executing the script and passing arguments:
+#     # python yolo_detection.py --video_path "S:\ano_dec_pro\dataset\Abuse\Abuse002_x264.mp4" 
+    
+#     # We call the function directly for simple execution in Python interpreter
+#     print("NOTE: Running the detection script. Please change 'example_video' to your actual file path.")
+#     analyze_video_with_yolo(example_video)