Sync crowd-detection from metro-analytics-catalog

.gitattributes

@@ -33,3 +33,5 @@ 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
+expected_output_dlstreamer.gif filter=lfs diff=lfs merge=lfs -text
+expected_output_openvino.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,10 +1,9 @@
 # Crowd Detection
 
-> **Validated with:** OpenVINO 2026.1.0, NNCF 3.0.0, DLStreamer 2026.0, Ultralytics 8.4.46, Python 3.11+
-
 | Property | Value |
 |---|---|
 | **Category** | Object Detection (Crowd / Person Counting) |
+| **Base Model** | [YOLO26](https://docs.ultralytics.com/models/yolo26/) (Ultralytics) |
 | **Source Framework** | PyTorch (Ultralytics) |
 | **Supported Precisions** | FP32, FP16, INT8 (mixed-precision) |
 | **Inference Engine** | OpenVINO |
@@ -16,7 +15,7 @@
 ## Overview
 
 Crowd Detection is a Metro Analytics use case that detects and counts people in video streams to estimate occupancy and identify crowd build-up.
-It is built on [YOLO26](https://docs.ultralytics.com/models/yolo26/), a real-time object detector trained on the COCO dataset, filtered at runtime to the `person` class.
+It is built on [YOLO26](https://docs.ultralytics.com/models/yolo26/), a state-of-the-art real-time object detector trained on the COCO dataset, quantized to INT8 and filtered at runtime to the `person` class.
 Typical Metro deployments include:
 
 - **Platform Occupancy** -- count waiting passengers on station platforms.
@@ -75,7 +74,7 @@ The second argument selects the precision (`FP32`, `FP16`, `INT8`); the default
 The script performs the following steps:
 
 1. Installs dependencies (`openvino`, `ultralytics`; adds `nncf` for INT8).
-2. Downloads a sample test image (`test.jpg`).
+2. Downloads a sample test image (`test.jpg`) and a sample test video (`test_video.mp4`).
 3. Downloads the PyTorch weights and exports to OpenVINO IR.
 4. *(INT8 only)* Quantizes the model using NNCF post-training quantization.
 
@@ -143,14 +142,14 @@ cv2.putText(
     image, f"Crowd count: {crowd_count}", (10, 30),
     cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2,
 )
-cv2.imwrite("output.jpg", image)
+cv2.imwrite("output_openvino.jpg", image)
 ```
 
 ### Try It on a Sample Image
 
 The `export_and_quantize.sh` script downloads `test.jpg` automatically.
 Re-run the OpenVINO sample above.
-The script reads `test.jpg`, prints the crowd count to the console, and writes the annotated frame to `output.jpg`.
+The script reads `test.jpg`, prints the crowd count to the console, and writes the annotated frame to `output_openvino.jpg`.
 
 Expected console output:
 
@@ -158,17 +157,22 @@ Expected console output:
 Detected persons: 4
 ```
 
-`output.jpg` is the same image with a green bounding box drawn around each detected person and the text `Crowd count: 4` overlaid in the top-left corner.
+`output_openvino.jpg` is the same image with a green bounding box drawn around each detected person and the text `Crowd count: 4` overlaid in the top-left corner.
 
 > **Tip:** For production testing, replace the bundled `test.jpg` with an image
 > from your target deployment site showing a representative crowd density.
 
+#### Expected Output
+
+![OpenVINO expected output](expected_output_openvino.jpg)
+
 ### DLStreamer Sample
 
-The pipeline below runs the FP16 YOLO26 detector on a test image via
+The pipeline below runs the FP16 YOLO26 detector on the sample video via
 `gvadetect`, filters detections to the `person` class in a buffer probe using
 the DLStreamer Python bindings (`gstgva.VideoFrame`), overlays bounding boxes,
-saves the annotated result to `output.jpg`, and prints the crowd count.
+saves the annotated result to `output_dlstreamer.mp4`, and prints the crowd count per
+frame.
 
 > **Notes on running this sample:**
 >
@@ -201,13 +205,19 @@ from gstgva import VideoFrame
 
 Gst.init(None)
 
+INPUT_VIDEO = "test_video.mp4"
+
+# For CPU: change device=GPU to device=CPU.
+# For NPU: change device=GPU to device=NPU (batch-size=1, nireq=4 recommended).
 pipeline_str = (
-    "filesrc location=test.jpg ! jpegdec ! videoconvert ! "
-    "video/x-raw,format=BGR ! "
+    f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
+    "videoconvert ! "
     "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
-    "device=CPU threshold=0.4 ! queue ! "
-    "gvawatermark ! videoconvert ! jpegenc ! "
-    "filesink name=sink location=output.jpg"
+    "device=GPU "
+    "threshold=0.4 ! queue ! "
+    "gvawatermark ! videoconvert ! video/x-raw,format=I420 ! "
+    "openh264enc ! h264parse ! "
+    "mp4mux ! filesink name=sink location=output_dlstreamer.mp4"
 )
 pipeline = Gst.parse_launch(pipeline_str)
 
@@ -236,10 +246,15 @@ bus.timed_pop_filtered(
 pipeline.set_state(Gst.State.NULL)
 ```
 
-To run on integrated GPU, change `device=CPU` to `device=GPU`, add
-`vapostproc ! video/x-raw(memory:VASurface)` after `jpegdec`, and set
-`pre-process-backend=vaapi-surface-sharing` on `gvadetect`.
-For NPU, change `device=CPU` to `device=NPU`.
+#### Expected Output
+
+![DLStreamer expected output](expected_output_dlstreamer.gif)
+
+**Device targets:**
+
+- `device=GPU` -- default in the sample code.
+- `device=CPU` -- change `device=GPU` to `device=CPU`.
+- `device=NPU` -- change `device=GPU` to `device=NPU`; use `batch-size=1` and `nireq=4` for best NPU utilization.
 
 ---
 

export_and_quantize.sh

@@ -44,6 +44,15 @@ else
     echo "Already present: test.jpg"
 fi
 
+echo "--- Downloading sample test video ---"
+if [[ ! -f test_video.mp4 ]]; then
+    wget -q -O test_video.mp4 \
+        https://github.com/open-edge-platform/edge-ai-resources/raw/main/videos/VIRAT_S_000101.mp4
+    echo "Downloaded: test_video.mp4"
+else
+    echo "Already present: test_video.mp4"
+fi
+
 if [[ "${PRECISION}" == "FP32" ]]; then
     HALF_FLAG="False"
     EXPORT_LABEL="FP32"