├── .gitignore
├── LICENSE
├── README.md
├── demo.ipynb
├── demo.py
├── pyproject.toml
├── template
    └── demo.py
└── vfnet
    ├── download.py
    └── vfnet_r50_fpn_mstrain_2x_coco.py


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | *.py,cover
 51 | .hypothesis/
 52 | .pytest_cache/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | target/
 76 | 
 77 | # Jupyter Notebook
 78 | .ipynb_checkpoints
 79 | 
 80 | # IPython
 81 | profile_default/
 82 | ipython_config.py
 83 | 
 84 | # pyenv
 85 | .python-version
 86 | 
 87 | # pipenv
 88 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 89 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 90 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 91 | #   install all needed dependencies.
 92 | #Pipfile.lock
 93 | 
 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 95 | __pypackages__/
 96 | 
 97 | # Celery stuff
 98 | celerybeat-schedule
 99 | celerybeat.pid
100 | 
101 | # SageMath parsed files
102 | *.sage.py
103 | 
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 | 
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 | 
117 | # Rope project settings
118 | .ropeproject
119 | 
120 | # mkdocs documentation
121 | /site
122 | 
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 | 
128 | # Pyre type checker
129 | .pyre/
130 | 
131 | # other
132 | *.pth


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 fcakyon
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <div align="center">
 2 | <h1>
 3 |   MMdetection + Tracker
 4 | </h1>
 5 | 
 6 | <h4>
 7 |   Simplest possible example of tracking. Based on <a href="https://github.com/open-mmlab/mmdetection" target="_blank">MMDetection Detector</a>.
 8 | </h4>
 9 | 
10 | <a href="https://colab.research.google.com/github/fcakyon/mmdetection-object-tracker/blob/master/demo.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
11 | 
12 | <img src="https://github.com/fcakyon/public-files/raw/main/mmdetection-object-tracker/vfnet-demo.gif" width="800" >
13 | 
14 | </div>
15 | 
16 | ## <div align="center">Instructions</div>
17 | 
18 | 1. Install Norfair with `pip install norfair[video]`.
19 | 2. Install MMDetection with `pip install torch mmcv-full mmdet`.
20 | 3. Run `python demo.py <video file>`.
21 | 4. Bonus: Use additional arguments `--model_path`, `--config_path`,`--img_scale`, `--conf_thres`, `--max_track_distance`, `--track_points` as you wish.
22 | 
23 | ## <div align="center">Explanation</div>
24 | 
25 | This example tracks objects using a single or double point per detection: the centroid or the two corners of the bounding boxes around objects returned by MMDetection Detector.
26 | 
27 | ### VFNet (MMDetection) tracking demo:
28 | 
29 | <div align="center">
30 | <img src="https://github.com/fcakyon/public-files/raw/main/mmdetection-object-tracker/vfnet-demo.gif" width="800" >
31 | </div>


--------------------------------------------------------------------------------
/demo.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {
  6 |     "colab_type": "text",
  7 |     "id": "view-in-github"
  8 |    },
  9 |    "source": [
 10 |     "<a href=\"https://colab.research.google.com/github/fcakyon/mmdetection-object-tracker/blob/master/demo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "markdown",
 15 |    "metadata": {
 16 |     "id": "OMsRlH8QwFQd"
 17 |    },
 18 |    "source": [
 19 |     "# Simple object tracker\n",
 20 |     "\n",
 21 |     "Run a very simple car tracker on any Youtube video. This notebook is designed to run [mmdetection-object-tracker/demo.py](https://github.com/fcakyon/mmdetection-object-tracker/blob/master/demo.py) on Google Colabratory.\n",
 22 |     "\n",
 23 |     "The demo will use the following video by default, but you can change which video you use by changing the youtube link in [this cell](#Download-Video-and-Preprocessing). We trim the video to only a few seconds due to limitations with video playback in Google Colab, but you can play with these limitations and see what you get.\n",
 24 |     "\n",
 25 |     "[![](https://img.youtube.com/vi/aio9g9_xVio/0.jpg)](https://www.youtube.com/watch?v=aio9g9_xVio)\n",
 26 |     "\n",
 27 |     "**Note**\n",
 28 |     "- Set the hardware accelerator setting of Colaboratory to **GPU** and execute it.\n",
 29 |     "(Runtime -> Change Runtime Type -> GPU)\n"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "markdown",
 34 |    "metadata": {
 35 |     "id": "b9vEmKjb2SnV"
 36 |    },
 37 |    "source": [
 38 |     "# Install the required libraries"
 39 |    ]
 40 |   },
 41 |   {
 42 |    "cell_type": "code",
 43 |    "execution_count": null,
 44 |    "metadata": {
 45 |     "id": "-TosvQp8qFcW"
 46 |    },
 47 |    "outputs": [],
 48 |    "source": [
 49 |     "!pip install -q norfair youtube_dl"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "markdown",
 54 |    "metadata": {},
 55 |    "source": [
 56 |     "# Download [Video](https://www.youtube.com/watch?v=aio9g9_xVio) and Preprocessing\n",
 57 |     "We cut the video short because it's too long to play in Google Colabratory."
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "code",
 62 |    "execution_count": null,
 63 |    "metadata": {},
 64 |    "outputs": [],
 65 |    "source": [
 66 |     "!youtube-dl https://www.youtube.com/watch?v=aio9g9_xVio -f mp4 --output sample.mp4\n",
 67 |     "!ffmpeg -i sample.mp4 -ss 7 -t 10 sample_10s.mp4"
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "markdown",
 72 |    "metadata": {
 73 |     "id": "-jZnwvD92hCA"
 74 |    },
 75 |    "source": [
 76 |     "# [MMDetection](https://github.com/open-mmlab/mmdetection) Installation"
 77 |    ]
 78 |   },
 79 |   {
 80 |    "cell_type": "code",
 81 |    "execution_count": null,
 82 |    "metadata": {
 83 |     "id": "_pVfjd672Q5o"
 84 |    },
 85 |    "outputs": [],
 86 |    "source": [
 87 |     "!pip install torch==1.8.1 mmdet==2.13.0 mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8.0/index.html"
 88 |    ]
 89 |   },
 90 |   {
 91 |    "cell_type": "markdown",
 92 |    "metadata": {
 93 |     "id": "_pVfjd672Q5o"
 94 |    },
 95 |    "source": [
 96 |     "# Download [mmdetection vfnet model](https://github.com/open-mmlab/mmdetection/tree/master/configs/vfnet) to vfnet/ folder"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "code",
101 |    "execution_count": 3,
102 |    "metadata": {
103 |     "id": "_pVfjd672Q5o"
104 |    },
105 |    "outputs": [],
106 |    "source": [
107 |     "!wget https://raw.githubusercontent.com/fcakyon/mmdetection-object-tracker/main/vfnet/download.py -o download.py\n",
108 |     "!wget https://raw.githubusercontent.com/fcakyon/mmdetection-object-tracker/main/vfnet/vfnet_r50_fpn_mstrain_2x_coco.py -o vfnet_r50_fpn_mstrain_2x_coco.py\n",
109 |     "!python download.py"
110 |    ]
111 |   },
112 |   {
113 |    "cell_type": "markdown",
114 |    "metadata": {
115 |     "id": "yyRxBpno3Tf4"
116 |    },
117 |    "source": [
118 |     "# Run demo.py"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "code",
123 |    "execution_count": null,
124 |    "metadata": {
125 |     "id": "Os2xvnOI3S_R"
126 |    },
127 |    "outputs": [],
128 |    "source": [
129 |     "!wget https://raw.githubusercontent.com/fcakyon/mmdetection-object-tracker/main/demo.py -o demo.py\n",
130 |     "!python demo.py sample_10s.mp4 \\\n",
131 |     "                --model_path vfnet_r50_fpn_mstrain_2x_coco_20201027-7cc75bd2.pth \\\n",
132 |     "                --model_config vfnet_r50_fpn_mstrain_2x_coco.py \\\n",
133 |     "                --img_scale 1280 \\\n",
134 |     "                --conf_thresh 0.35 \\\n",
135 |     "                --max_track_distance 30"
136 |    ]
137 |   },
138 |   {
139 |    "cell_type": "markdown",
140 |    "metadata": {
141 |     "id": "gkQIIlYN4Mha"
142 |    },
143 |    "source": [
144 |     "# Convert mp4 to webm\n",
145 |     "Reference: [StackOverflow - python-opencv-video-format-play-in-browser](https://stackoverflow.com/questions/49530857/python-opencv-video-format-play-in-browser)"
146 |    ]
147 |   },
148 |   {
149 |    "cell_type": "code",
150 |    "execution_count": null,
151 |    "metadata": {
152 |     "id": "wsJUOKOD7mT7"
153 |    },
154 |    "outputs": [],
155 |    "source": [
156 |     "!ffmpeg -i ./sample_10s_out.mp4 -vcodec vp9 ./sample_10s.webm"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "markdown",
161 |    "metadata": {
162 |     "id": "tJHAEirK4LtQ"
163 |    },
164 |    "source": [
165 |     "# Displaying the Drawing Result"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": null,
171 |    "metadata": {
172 |     "id": "zKN1li519ns4"
173 |    },
174 |    "outputs": [],
175 |    "source": [
176 |     "import io\n",
177 |     "from base64 import b64encode\n",
178 |     "from IPython.display import HTML\n",
179 |     "\n",
180 |     "with  io.open('sample_10s.webm','r+b') as f:\n",
181 |     "    mp4 = f.read()\n",
182 |     "data_url = \"data:video/webm;base64,\" + b64encode(mp4).decode()\n",
183 |     "HTML(\"\"\"\n",
184 |     "<video width=800 controls>\n",
185 |     "      <source src=\"%s\" type=\"video/webm\">\n",
186 |     "</video>\n",
187 |     "\"\"\" % data_url)"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "markdown",
192 |    "metadata": {},
193 |    "source": [
194 |     "# Convert mp4 to gif"
195 |    ]
196 |   },
197 |   {
198 |    "cell_type": "code",
199 |    "execution_count": null,
200 |    "metadata": {},
201 |    "outputs": [],
202 |    "source": [
203 |     "!ffmpeg -ss 5 -i ./sample_10s_out.mp4 -filter_complex \"[0:v] fps=10,scale=1280:-1,split [a][b];[a] palettegen [p];[b][p] paletteuse\" output.gif -y"
204 |    ]
205 |   },
206 |   {
207 |    "cell_type": "code",
208 |    "execution_count": null,
209 |    "metadata": {},
210 |    "outputs": [],
211 |    "source": []
212 |   }
213 |  ],
214 |  "metadata": {
215 |   "accelerator": "GPU",
216 |   "colab": {
217 |    "authorship_tag": "ABX9TyO4qLzod40698nm7MS6o+W8",
218 |    "include_colab_link": true,
219 |    "name": "yolov4_demo.ipynb",
220 |    "provenance": []
221 |   },
222 |   "kernelspec": {
223 |    "display_name": "Python3.8 (drone)",
224 |    "language": "python",
225 |    "name": "drone"
226 |   },
227 |   "language_info": {
228 |    "codemirror_mode": {
229 |     "name": "ipython",
230 |     "version": 3
231 |    },
232 |    "file_extension": ".py",
233 |    "mimetype": "text/x-python",
234 |    "name": "python",
235 |    "nbconvert_exporter": "python",
236 |    "pygments_lexer": "ipython3",
237 |    "version": "3.8.5"
238 |   }
239 |  },
240 |  "nbformat": 4,
241 |  "nbformat_minor": 4
242 | }
243 | 


--------------------------------------------------------------------------------
/demo.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | from typing import List, Optional
  3 | from pathlib import Path
  4 | 
  5 | import numpy as np
  6 | import torch
  7 | import norfair
  8 | from norfair import Detection, Tracker, Video
  9 | from mmdet.apis import init_detector, inference_detector
 10 | 
 11 | 
 12 | class Detector:
 13 |     def __init__(self, model_path: str, config_path: str, device: Optional[str] = None, track_points: str = "bbox"):
 14 |         if device is not None and "cuda" in device and not torch.cuda.is_available():
 15 |             raise Exception("Selected device='cuda', but cuda is not available to Pytorch.")
 16 |         # automatically set device if its None
 17 |         elif device is None:
 18 |             device = "cuda:0" if torch.cuda.is_available() else "cpu"
 19 |         # set properties
 20 |         self.model_path = model_path
 21 |         self.config_path = config_path
 22 |         self.device = device
 23 |         self.track_points = track_points
 24 |         # load model
 25 |         self.model = self.load_model()
 26 | 
 27 |     def load_model(self):
 28 |         assert Path(self.model_path).is_file(), TypeError(f"{self.model_path} should be a checkpoint file.")
 29 |         assert Path(self.config_path).is_file(), TypeError(f"{self.config_path} should be a config file.")
 30 | 
 31 |         if not Path(self.model_path).exists():
 32 |             FileNotFoundError(f"{self.model_path} is not present.")
 33 | 
 34 |         model = init_detector(config=self.config_path, checkpoint=self.model_path, device=self.device)
 35 |         return model
 36 | 
 37 |     def _mmdet_result_to_norfair_detections(self, result, conf_thresh: float = 0.35):
 38 |         # parse bbox/labels from result
 39 |         if isinstance(result, tuple):
 40 |             bbox_result, segm_result = result
 41 |             if isinstance(segm_result, tuple):
 42 |                 segm_result = segm_result[0]  # ms rcnn
 43 |         else:
 44 |             bbox_result, segm_result = result, None
 45 |         bboxes = np.vstack(bbox_result)
 46 |         labels = [np.full(bbox.shape[0], i, dtype=np.int32) for i, bbox in enumerate(bbox_result)]
 47 |         labels = np.concatenate(labels)
 48 | 
 49 |         # init norfair detections
 50 |         norfair_detections: List[Detection] = []
 51 | 
 52 |         # convert model detections to norfiar detections
 53 |         for i, (bbox, label) in enumerate(zip(bboxes, labels)):
 54 |             score = bbox[4]
 55 |             if score > conf_thresh:
 56 |                 bbox = bbox[:4].astype(np.int32)
 57 | 
 58 |                 if self.track_points == "centroid":
 59 |                     centroid = np.array([(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2])
 60 |                     scores = np.array([score])
 61 |                     norfair_detections.append(Detection(points=centroid, scores=scores))
 62 |                 elif self.track_points == "bbox":
 63 |                     bbox = np.array([[bbox[0], bbox[1]], [bbox[2], bbox[3]]])
 64 |                     scores = np.array([score, score])
 65 |                     norfair_detections.append(Detection(points=bbox, scores=scores))
 66 | 
 67 |         return norfair_detections
 68 | 
 69 |     def __call__(self, image, img_scale: int = 720, conf_thresh: float = 0.35) -> List[Detection]:
 70 |         self.model.cfg.data.test.pipeline[1]["img_scale"] = (img_scale,)
 71 |         result = inference_detector(self.model, image)
 72 |         detections = self._mmdet_result_to_norfair_detections(result, conf_thresh)
 73 |         return detections
 74 | 
 75 | 
 76 | def euclidean_distance(detection, tracked_object):
 77 |     return np.linalg.norm(detection.points - tracked_object.estimate)
 78 | 
 79 | 
 80 | parser = argparse.ArgumentParser(description="Track objects in a video.")
 81 | parser.add_argument("files", type=str, nargs="+", help="Video files to process")
 82 | parser.add_argument(
 83 |     "--model_path",
 84 |     type=str,
 85 |     default="",
 86 |     help="MMDetection model checkpoint path",
 87 | )
 88 | parser.add_argument("--config_path", type=str, default="", help="MMDetection model config path")
 89 | parser.add_argument("--device", type=str, default=None, help="Inference device: 'cpu' or 'cuda'")
 90 | parser.add_argument("--max_track_distance", type=int, default="30", help="Maximum tracker point distance")
 91 | parser.add_argument("--track_points", type=str, default="bbox", help="Track points: 'centroid' or 'bbox'")
 92 | parser.add_argument("--img_scale", type=int, default="720", help="MMDetection inference size (pixels)")
 93 | parser.add_argument("--conf_thresh", type=float, default="0.35", help="MMDetection inference confidence threshold")
 94 | args = parser.parse_args()
 95 | 
 96 | detector = Detector(
 97 |     model_path=args.model_path, config_path=args.config_path, device=args.device, track_points=args.track_points
 98 | )
 99 | 
100 | for input_path in args.files:
101 |     video = Video(input_path=input_path)
102 |     tracker = Tracker(
103 |         distance_function=euclidean_distance,
104 |         distance_threshold=args.max_track_distance,
105 |     )
106 | 
107 |     for frame in video:
108 |         detections = detector(frame, img_scale=args.img_scale, conf_thresh=args.conf_thresh)
109 |         tracked_objects = tracker.update(detections=detections)
110 |         if args.track_points == "centroid":
111 |             norfair.draw_points(frame, detections)
112 |         elif args.track_points == "bbox":
113 |             norfair.draw_boxes(frame, detections)
114 |         norfair.draw_tracked_objects(frame, tracked_objects)
115 |         video.write(frame)
116 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [tool.black]
 2 | line-length = 119
 3 | exclude = '''
 4 | (
 5 |   /(
 6 |       \.git
 7 |     | \.venv
 8 |     | data
 9 |   )/
10 | )
11 | '''
12 | 


--------------------------------------------------------------------------------
/template/demo.py:
--------------------------------------------------------------------------------
 1 | import argparse
 2 | 
 3 | import numpy as np
 4 | import torch
 5 | from typing import List, Optional
 6 | 
 7 | import norfair
 8 | from norfair import Detection, Tracker, Video
 9 | 
10 | 
11 | class Detector:
12 |     def __init__(self, model_path: str, config_path: str, device: Optional[str] = None):
13 |         if device is not None and "cuda" in device and not torch.cuda.is_available():
14 |             raise Exception(
15 |                 "Selected device='cuda', but cuda is not available to Pytorch."
16 |             )
17 |         # automatically set device if its None
18 |         elif device is None:
19 |             device = "cuda:0" if torch.cuda.is_available() else "cpu"
20 |         # set properties
21 |         self.model_path = model_path
22 |         self.config_path = config_path
23 |         self.device = device
24 |         # load model
25 |         self.model = self.load_model()
26 | 
27 |     def load_model(self):
28 |         NotImplementedError()
29 | 
30 |     def __call__(self, frame) -> List[Detection]:
31 |         NotImplementedError()
32 | 
33 | 
34 | def euclidean_distance(detection, tracked_object):
35 |     return np.linalg.norm(detection.points - tracked_object.estimate)
36 | 
37 | 
38 | parser = argparse.ArgumentParser(description="Track objects in a video.")
39 | parser.add_argument("files", type=str, nargs="+", help="Video files to process")
40 | parser.add_argument(
41 |     "--max_track_distance", type=str, default="30", help="Maximum tracker distance"
42 | )
43 | parser.add_argument("--model_path", type=str, default="", help="Detector model path")
44 | parser.add_argument("--config_path", type=str, default="", help="Detector model path")
45 | parser.add_argument(
46 |     "--device", type=str, default=None, help="Inference device: 'cpu' or 'cuda'"
47 | )
48 | parser.add_argument(
49 |     "--track_points",
50 |     type=str,
51 |     default="centroid",
52 |     help="Track points: 'centroid' or 'bbox'",
53 | )
54 | args = parser.parse_args()
55 | 
56 | detector = Detector(
57 |     model_path=args.model_path,
58 |     config_path=args.config_path,
59 |     device=args.device,
60 |     track_points=args.track_points,
61 | )
62 | 
63 | for input_path in args.files:
64 |     video = Video(input_path=input_path)
65 |     tracker = Tracker(
66 |         distance_function=euclidean_distance,
67 |         distance_threshold=args.max_track_distance,
68 |     )
69 | 
70 |     for frame in video:
71 |         detections = detector(frame)
72 |         tracked_objects = tracker.update(detections=detections)
73 |         if args.track_points == "centroid":
74 |             norfair.draw_points(frame, detections)
75 |         elif args.track_points == "bbox":
76 |             norfair.draw_boxes(frame, detections)
77 |         norfair.draw_tracked_objects(frame, tracked_objects)
78 |         video.write(frame)
79 | 


--------------------------------------------------------------------------------
/vfnet/download.py:
--------------------------------------------------------------------------------
 1 | import urllib.request
 2 | from pathlib import Path
 3 | 
 4 | FILE = Path(__file__).parent.absolute()
 5 | 
 6 | 
 7 | def run():
 8 |     urllib.request.urlretrieve(
 9 |         "https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mstrain_2x_coco/vfnet_r50_fpn_mstrain_2x_coco_20201027-7cc75bd2.pth",
10 |         str(FILE / "vfnet_r50_fpn_mstrain_2x_coco_20201027-7cc75bd2.pth"),
11 |     )
12 |     urllib.request.urlretrieve(
13 |         "https://raw.githubusercontent.com/fcakyon/mmdetection-object-tracker/master/vfnet/vfnet_r50_fpn_mstrain_2x_coco.py",
14 |         str(FILE / "vfnet_r50_fpn_mstrain_2x_coco.py"),
15 |     )
16 | 
17 | 
18 | if __name__ == "__main__":
19 |     run()
20 | 


--------------------------------------------------------------------------------
/vfnet/vfnet_r50_fpn_mstrain_2x_coco.py:
--------------------------------------------------------------------------------
  1 | dataset_type = 'CocoDataset'
  2 | data_root = 'data/coco/'
  3 | img_norm_cfg = dict(
  4 |     mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
  5 | train_pipeline = [
  6 |     dict(type='LoadImageFromFile'),
  7 |     dict(type='LoadAnnotations', with_bbox=True),
  8 |     dict(
  9 |         type='Resize',
 10 |         img_scale=[(1333, 480), (1333, 960)],
 11 |         multiscale_mode='range',
 12 |         keep_ratio=True),
 13 |     dict(type='RandomFlip', flip_ratio=0.5),
 14 |     dict(
 15 |         type='Normalize',
 16 |         mean=[123.675, 116.28, 103.53],
 17 |         std=[58.395, 57.12, 57.375],
 18 |         to_rgb=True),
 19 |     dict(type='Pad', size_divisor=32),
 20 |     dict(type='DefaultFormatBundle'),
 21 |     dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
 22 | ]
 23 | test_pipeline = [
 24 |     dict(type='LoadImageFromFile'),
 25 |     dict(
 26 |         type='MultiScaleFlipAug',
 27 |         img_scale=(1333, 800),
 28 |         flip=False,
 29 |         transforms=[
 30 |             dict(type='Resize', keep_ratio=True),
 31 |             dict(type='RandomFlip'),
 32 |             dict(
 33 |                 type='Normalize',
 34 |                 mean=[123.675, 116.28, 103.53],
 35 |                 std=[58.395, 57.12, 57.375],
 36 |                 to_rgb=True),
 37 |             dict(type='Pad', size_divisor=32),
 38 |             dict(type='DefaultFormatBundle'),
 39 |             dict(type='Collect', keys=['img'])
 40 |         ])
 41 | ]
 42 | data = dict(
 43 |     samples_per_gpu=2,
 44 |     workers_per_gpu=2,
 45 |     train=dict(
 46 |         type='CocoDataset',
 47 |         ann_file='data/coco/annotations/instances_train2017.json',
 48 |         img_prefix='data/coco/train2017/',
 49 |         pipeline=[
 50 |             dict(type='LoadImageFromFile'),
 51 |             dict(type='LoadAnnotations', with_bbox=True),
 52 |             dict(
 53 |                 type='Resize',
 54 |                 img_scale=[(1333, 480), (1333, 960)],
 55 |                 multiscale_mode='range',
 56 |                 keep_ratio=True),
 57 |             dict(type='RandomFlip', flip_ratio=0.5),
 58 |             dict(
 59 |                 type='Normalize',
 60 |                 mean=[123.675, 116.28, 103.53],
 61 |                 std=[58.395, 57.12, 57.375],
 62 |                 to_rgb=True),
 63 |             dict(type='Pad', size_divisor=32),
 64 |             dict(type='DefaultFormatBundle'),
 65 |             dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
 66 |         ]),
 67 |     val=dict(
 68 |         type='CocoDataset',
 69 |         ann_file='data/coco/annotations/instances_val2017.json',
 70 |         img_prefix='data/coco/val2017/',
 71 |         pipeline=[
 72 |             dict(type='LoadImageFromFile'),
 73 |             dict(
 74 |                 type='MultiScaleFlipAug',
 75 |                 img_scale=(1333, 800),
 76 |                 flip=False,
 77 |                 transforms=[
 78 |                     dict(type='Resize', keep_ratio=True),
 79 |                     dict(type='RandomFlip'),
 80 |                     dict(
 81 |                         type='Normalize',
 82 |                         mean=[123.675, 116.28, 103.53],
 83 |                         std=[58.395, 57.12, 57.375],
 84 |                         to_rgb=True),
 85 |                     dict(type='Pad', size_divisor=32),
 86 |                     dict(type='DefaultFormatBundle'),
 87 |                     dict(type='Collect', keys=['img'])
 88 |                 ])
 89 |         ]),
 90 |     test=dict(
 91 |         type='CocoDataset',
 92 |         ann_file='data/coco/annotations/instances_val2017.json',
 93 |         img_prefix='data/coco/val2017/',
 94 |         pipeline=[
 95 |             dict(type='LoadImageFromFile'),
 96 |             dict(
 97 |                 type='MultiScaleFlipAug',
 98 |                 img_scale=(1333, 800),
 99 |                 flip=False,
100 |                 transforms=[
101 |                     dict(type='Resize', keep_ratio=True),
102 |                     dict(type='RandomFlip'),
103 |                     dict(
104 |                         type='Normalize',
105 |                         mean=[123.675, 116.28, 103.53],
106 |                         std=[58.395, 57.12, 57.375],
107 |                         to_rgb=True),
108 |                     dict(type='Pad', size_divisor=32),
109 |                     dict(type='DefaultFormatBundle'),
110 |                     dict(type='Collect', keys=['img'])
111 |                 ])
112 |         ]))
113 | evaluation = dict(interval=1, metric='bbox')
114 | optimizer = dict(
115 |     type='SGD',
116 |     lr=0.01,
117 |     momentum=0.9,
118 |     weight_decay=0.0001,
119 |     paramwise_cfg=dict(bias_lr_mult=2.0, bias_decay_mult=0.0))
120 | optimizer_config = dict(grad_clip=None)
121 | lr_config = dict(
122 |     policy='step',
123 |     warmup='linear',
124 |     warmup_iters=500,
125 |     warmup_ratio=0.1,
126 |     step=[16, 22])
127 | runner = dict(type='EpochBasedRunner', max_epochs=24)
128 | checkpoint_config = dict(interval=1)
129 | log_config = dict(interval=50, hooks=[dict(type='TextLoggerHook')])
130 | custom_hooks = [dict(type='NumClassCheckHook')]
131 | dist_params = dict(backend='nccl')
132 | log_level = 'INFO'
133 | load_from = None
134 | resume_from = None
135 | workflow = [('train', 1)]
136 | model = dict(
137 |     type='VFNet',
138 |     backbone=dict(
139 |         type='ResNet',
140 |         depth=50,
141 |         num_stages=4,
142 |         out_indices=(0, 1, 2, 3),
143 |         frozen_stages=1,
144 |         norm_cfg=dict(type='BN', requires_grad=True),
145 |         norm_eval=True,
146 |         style='pytorch',
147 |         init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
148 |     neck=dict(
149 |         type='FPN',
150 |         in_channels=[256, 512, 1024, 2048],
151 |         out_channels=256,
152 |         start_level=1,
153 |         add_extra_convs='on_output',
154 |         num_outs=5,
155 |         relu_before_extra_convs=True),
156 |     bbox_head=dict(
157 |         type='VFNetHead',
158 |         num_classes=80,
159 |         in_channels=256,
160 |         stacked_convs=3,
161 |         feat_channels=256,
162 |         strides=[8, 16, 32, 64, 128],
163 |         center_sampling=False,
164 |         dcn_on_last_conv=False,
165 |         use_atss=True,
166 |         use_vfl=True,
167 |         loss_cls=dict(
168 |             type='VarifocalLoss',
169 |             use_sigmoid=True,
170 |             alpha=0.75,
171 |             gamma=2.0,
172 |             iou_weighted=True,
173 |             loss_weight=1.0),
174 |         loss_bbox=dict(type='GIoULoss', loss_weight=1.5),
175 |         loss_bbox_refine=dict(type='GIoULoss', loss_weight=2.0)),
176 |     train_cfg=dict(
177 |         assigner=dict(type='ATSSAssigner', topk=9),
178 |         allowed_border=-1,
179 |         pos_weight=-1,
180 |         debug=False),
181 |     test_cfg=dict(
182 |         nms_pre=1000,
183 |         min_bbox_size=0,
184 |         score_thr=0.05,
185 |         nms=dict(type='nms', iou_threshold=0.6),
186 |         max_per_img=100))
187 | 


--------------------------------------------------------------------------------