Using Computer Vision to count and analyze how vulnerable road users use streets so that local governments have easy access to data for justifying investment in pedestrian and bike infrastructure.

Developed with the software and tools below.

This repository contains code for an Electron app that processes videos from traffic cameras or portable cameras to count the number of people passing through the video. The user can draw lines on the video to indicate where they want to count people passing by. The app can distinguish between pedestrians, bikes, electric scooter riders, and wheelchairs (coming soon). It provides a frontend Electron interface that connects to a Flask backend to handle the video processing and people counting logic. The app ensures connectivity between the frontend and backend, monitors the backend health, handles reconnections as needed, and enables saving output files. It is designed to provide a seamless user experience for processing videos to count people crossing designated areas.

You can see our report here.

`

└── /
    ├── BWCT_favicon.png
    ├── README.md
    ├── backend
    │   ├── BWCT_app.py
    │   ├── tracking
    │   │   ├── ConfTrack
    │   │   │   ├── basetrack.py
    │   │   │   ├── ConfTrack.py
    │   │   │   ├── kalman_filter.py
    │   │   │   └── matching.py
    │   │   ├── Impr_Assoc_Track
    │   │   │   ├── basetrack.py
    │   │   │   ├── Impr_Assoc_Track.py
    │   │   │   ├── interpolation.py
    │   │   │   ├── kalman_filter.py
    │   │   │   └── matching.py
    │   │   ├── LSTMTrack
    │   │   │   ├── LSTM_predictor.py
    │   │   │   └── LSTMTrack.py
    │   │   ├── YOLOv8_TensorRT
    │   │   ├── color_transfer_cpu.py
    │   │   ├── color_transfer_gpu.py
    │   │   ├── example_count_lines.txt
    │   │   ├── reprocess_tracks.py
    │   │   ├── requirements.txt
    │   │   ├── setup.py
    │   │   └── track.py
    │   └── templates
    ├── index.html
    ├── main.js
    ├── package-lock.json
    ├── package.json
    ├── preload.js
    ├── readme-ai.md
    ├── requirements.txt
    ├── test_main.js
    └── track_logs.txt

System Requirements:

• Python: version 3.10.0

1. Clone the repository:

$ git clone https://github.com/rolson24/BWCT-tracker.git

2. Change to the project directory:

$ cd 

3. Install the dependencies:

3.a

$ pip install -r requirements.txt

3.b Install onnx for your system. Follow these instructions.

3.c Install the correct requirements for your gpu:

If you have an NVIDIA gpu, you can leave the requirements file the same.

If no NVIDIA gpu, then comment out cupy, faiss-gpu, and onnxruntime-gpu from requirements.txt also change BWCT_app.py to set device to "cpu"

If you have an amd gpu, install onnxruntime-directml (First try pip install onnxruntime-directml, and if that doesn't work, then try building from source.)

Depends on FFMPEG: Instructions

4. Install electron:

First install node.js: Instructions

Now install fs-extra:

$ npm install fs-extra

Now install electron:

$ npm install -g electron

5. Start app:

$ cd path/to/BWCT-Tracker
$ npm start

Follow the software portion of these instructions to do the full setup on an Nvidia Jetson (includes instructions for OS install)

Follow the build instructions above to install the project.

1. Follow this Google Colab notebook to train a new YOLOv8 model:
2. Download the trained model weights from the Google Drive folder and place them in the backend/tracking/models directory

2.5. (Optional) If you want the runtime to be fast and you have an NVIDIA GPU or an NVIDIA Jetson, run these commands to convert the model to a TensorRT model (first cd to the BWCT-Tracker repository and ensure you have tensorRT install):
A:
python3 backend/tracking/YOLOv8_TensorRT/export-det.py
--weights {path/to/weights_file}
--iou-thres 0.65
--conf-thres 0.25
--topk {num_of_classes_in_model}
--opset 17
--sim
--input-shape 1 3 640 640
--device cuda:0
B:
/usr/src/tensorrt/bin/trtexec
--onnx={path/to/onnx_export_output}
--saveEngine=yolov8s.engine
--fp16
C:
Move the ".engine" model to the models folder

3. Update the model_path variable in backend/tracking/BWCT_app.py with the path to the new model weights

• ► Expand compatibility to other machines
• ► Add support for other models
• ► Package app into a Docker container

Contributions are welcome! Here are several ways you can contribute:

• Report Issues: Submit bugs found or log feature requests for the `` project.
• Submit Pull Requests: Review open PRs, and submit your own PRs.
• Join the Discussions: Share your insights, provide feedback, or ask questions.

This project is protected under the AGPL-3.0 License. For more details, refer to the LICENSE file.

• The Ultralytics team for all their amazing work developing YOLOv8.
• Daniel Stadler and Jurgen Beyerer for their paper on Improved Association Tracker
• Hyeonchul Jung, Seokjun Kang, Takgen Kim, and HyeongKi Kim for their paper on ConfTrack. (See also their implementation here)
• He, Lingxiao and Liao, Xingyu and Liu, Wu and Liu, Xinchen and Cheng, Peng and Mei, Tao for developing FastReID. (See also their implementation here)
• Adrian Rosebrock, Kumar Ujjawal and Adam Spannbauer for their implementiation of fast color transfer. (See also their implementation here)
• The YOLOv8-TensorRT team for their wonderful work making YOLOv8 fast with tensorRT.
• The Roboflow Supervision team for their amazing work developing the Supervision tool.

Return