Darknet Object Detection Framework and YOLO
Downcodes小编 Updated list of public BitTorrent trackers
Lists
These lists are automatically updated every day. Last update 2024/10/31:
Are you having DNS problems? These lists contain the same trackers but with IP addresses instead of domains:
Notes
Contribute
Contact
ngosang [@] hotmail [.es]
Third-party tools
Third-party online tools
example:
Apache-2.0 license
Table of Contents
Darknet Object Detection Framework and YOLO
Papers
General Information
Darknet Version
MSCOCO Pre-trained Weights
Building
Google Colab
Linux CMake Method
Windows CMake Method
Using Darknet
CLI
Training
Other Tools and Links
Roadmap
Short-term goals
Mid-term goals
Long-term goals
Darknet Object Detection Framework and YOLO
Darknet is an open-source neural network framework, primarily written in C, C++, and CUDA.
YOLO (You Only Look Once) is a cutting-edge real-time object detection system operating within the Darknet framework.
Read about how Hank.ai is supporting the Darknet/YOLO community.
Explore the Darknet/YOLO website.
Consult the Darknet/YOLO FAQ for answers to common questions.
Join the Darknet/YOLO Discord server for discussions and assistance.
Papers
1. Paper YOLOv7
2. Paper Scaled-YOLOv4
3. Paper YOLOv4
4. Paper YOLOv3
General Information
The Darknet/YOLO framework consistently outperforms other frameworks and YOLO versions in both speed and accuracy.
This framework is entirely free and open-source. You can integrate Darknet/YOLO into your projects and products, even commercial ones, without needing a license or incurring fees.
Darknet V3 ("Jazz"), released in October 2024, can efficiently run the LEGO dataset videos at up to 1000 FPS using an NVIDIA RTX 3090 GPU. This means Darknet/YOLO can process each video frame (read, resize, and process) in 1 millisecond or less.
Join the Darknet/YOLO Discord server if you require assistance or wish to discuss Darknet/YOLO: https://discord.gg/zSq8rtW
The CPU version of Darknet/YOLO runs on various devices, including Raspberry Pi, cloud and Colab servers, desktops, laptops, and high-end training rigs. The GPU version necessitates a CUDA-capable NVIDIA GPU.
Darknet/YOLO is known to be compatible with Linux, Windows, and Mac. Refer to the building instructions below for details.
Darknet Version
The original Darknet tool developed by Joseph Redmon between 2013 and 2017 lacked a version number. We consider this version 0.x.
The subsequent popular Darknet repository, maintained by Alexey Bochkovskiy from 2017 to 2021, also did not have a version number. We consider this version 1.x.
The Darknet repository sponsored by Hank.ai and maintained by Stéphane Charette since 2023 was the first to include a version command. It returned version 2.x "OAK" from 2023 until late 2024.
The primary aim was to minimize disruption to existing functionality while familiarizing ourselves with the codebase.
Key Changes:
Unified Build: Rewritten build steps to establish a single, consistent method using CMake for both Windows and Linux.
C++ Migration: Converted the codebase to utilize the C++ compiler.
Enhanced Chart: Improved the chart.png visualization during training.
Bug Fixes & Optimizations: Addressed numerous bugs and implemented performance optimizations, primarily focused on reducing training time.
The final branch of this codebase is version 2.1, located in the v2 branch.
The next stage of development commenced in mid-2024 and culminated in the release of version 3.x "JAZZ" in October 2024.
Darknet V3 ("Jazz") Key Improvements:
Performance: Significant performance optimizations during both training and inference.
API Changes: Modified the legacy C API. Applications utilizing the original Darknet API will require minor adjustments. See: https://darknetcv.ai/api/api.html
New API: Introduced a new Darknet V3 C and C++ API: https://darknetcv.ai/api/api.html
Updated Examples: Added new applications and sample code within the src-examples directory: https://darknetcv.ai/api/files.html
You can always revert to the previous v2 branch if you need to execute specific commands. Please inform us if you encounter any missing commands so we can explore incorporating them back.
Darknet V3 ("Jazz") Key Removals:
Outdated Commands: Removed many obsolete and unmaintained commands.
MSCOCO Pre-trained Weights
For convenience, several popular versions of YOLO have been pre-trained on the MSCOCO dataset. This dataset encompasses 80 classes, which can be found in the text file cfg/coco.names.
Beyond MSCOCO, various other simpler datasets and pre-trained weights are available for testing Darknet/YOLO, such as LEGO Gears and Rolodex. Check the Darknet/YOLO FAQ for details.
The MSCOCO pre-trained weights can be downloaded from multiple sources, including this repository:
YOLOv2, November 2016:
YOLOv2-tiny
YOLOv2-full
YOLOv3, May 2018:
YOLOv3-tiny
YOLOv3-full
YOLOv4, May 2020:
YOLOv4-tiny
YOLOv4-full
YOLOv7, August 2022:
YOLOv7-tiny
YOLOv7-full
The MSCOCO pre-trained weights are provided solely for demonstration purposes. The corresponding .cfg and .names files for MSCOCO reside in the cfg directory. Example commands:
`bash
wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights darknet02displayannotatedimages coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
`
Remember, users are encouraged to train their own networks. MSCOCO is primarily used to validate that everything is functioning correctly.
Building
The diverse build methods employed prior to 2023 have been consolidated into a unified solution. Darknet requires C++17 or a newer version, OpenCV, and utilizes CMake to generate the necessary project files.
You do not need C++ proficiency to build, install, or run Darknet/YOLO, just as you don't need to be a mechanic to drive a car.
Google Colab
The Google Colab instructions mirror the Linux instructions. Several Jupyter notebooks demonstrate various tasks, such as training a new network.
Explore the notebooks in the colab subdirectory or follow the Linux instructions provided below.
Linux CMake Method
Darknet build tutorial for Linux
Optional: If you possess a modern NVIDIA GPU, install either CUDA or CUDA+cuDNN at this juncture. If installed, Darknet will leverage your GPU to accelerate image (and video) processing.
You must delete the CMakeCache.txt file from your Darknet build directory to force CMake to rediscover all the required files.
Remember to rebuild Darknet.
Darknet can function without them, but CUDA or CUDA+cuDNN is necessary if you intend to train a custom network.
1. Install CUDA: Visit https://developer.nvidia.com/cuda-downloads to download and install CUDA.
2. Install cuDNN: Visit https://developer.nvidia.com/rdp/cudnn-download or https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview to download and install cuDNN.
After installing CUDA, ensure you can execute nvcc and nvidia-smi. You might need to modify your PATH variable.
If you install CUDA or CUDA+cuDNN later, or if you upgrade to a newer NVIDIA software version:
Upgrade CMake: If your CMake version is outdated, upgrade it using the following commands:
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Restart Shell: If using bash as your command shell, restart your shell. If using fish, the path should be automatically updated.
Building Darknet:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/srccd ~/src
git clone https://github.com/hank-ai/darknetcd darknet
mkdir buildcd build
cmake -DCMAKEBUILDTYPE=Release ..
make -j4
package
sudo dpkg -i darknet-VERSION.deb
`
Advanced Users:
RPM Installation: To create an RPM installation file instead of a DEB file, modify the relevant lines in CM_package.cmake. Before executing make -j4 package, edit these lines:
`cmake
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
`
For distributions like CentOS and OpenSUSE, adjust the lines to:
`cmake
SET (CPACK_GENERATOR "DEB")
SET (CPACK_GENERATOR "RPM")
`
Installation Package: Install the package after it has finished building using your distribution's package manager. For Debian-based systems (e.g., Ubuntu):
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Installing the .deb package will copy the following files:
/usr/bin/darknet: The standard Darknet executable. Run darknet version from the CLI to confirm its correct installation.
/usr/include/darknet.h: The Darknet API for C, C++, and Python developers.
/usr/include/darknet_version.h: Contains version information for developers.
/usr/lib/libdarknet.so: The library for linking in C, C++, and Python development.
/opt/darknet/cfg/...: Stores all .cfg templates.
Congratulations! Darknet has been built and installed in /usr/bin/. Run darknet version to verify.
If you lack /usr/bin/darknet, you have only built Darknet, not installed it. Ensure you install the .deb or .rpm file as outlined above.
Windows CMake Method
These instructions assume a fresh installation of Windows 11 22H2.
1. Install Prerequisites: Open a standard cmd.exe command prompt and execute these commands:
`bash
winget install Git.Git
winget install Kitware.CMake
winget install nsis.nsis
winget install Microsoft.VisualStudio.2022.Community
`
2. Modify Visual Studio: Configure Visual Studio to support C++ applications:
Click the "Windows Start" menu and run "Visual Studio Installer."
Select "Modify."
Choose "Desktop Development With C++."
Click "Modify" in the bottom-right corner, and then click "Yes."
3. Developer Command Prompt: After the installation completes, click the "Windows Start" menu and select "Developer Command Prompt for VS 2022." Do not use PowerShell for these steps, as it may cause issues!
Advanced Users:
Instead of using the Developer Command Prompt, you can opt for a normal command prompt or connect via SSH and manually execute "Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".
4. Install Microsoft VCPKG: Execute the following commands in the Developer Command Prompt (not PowerShell) to install Microsoft VCPKG, which will be used to build OpenCV:
`bash
cd c:
mkdir c:src
cd c:src
git clone https://github.com/microsoft/vcpkg
cd vcpkg
bootstrap-vcpkg.bat
.vcpkg.exe integrate install
.vcpkg.exe integrate powershell.vcpkg.exe install opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
Be patient during the last step as it may take considerable time to complete. It involves downloading and building numerous components.
Advanced Users:
Note that there are many optional modules you can include when building OpenCV. Run .vcpkg.exe search opencv to view the full list.
Optional: If you have a modern NVIDIA GPU, you can install either CUDA or CUDA+cuDNN at this point. If installed, Darknet will use your GPU to speed up image (and video) processing.
You must delete the CMakeCache.txt file from your Darknet build directory to force CMake to re-find all of the necessary files.
Remember to re-build Darknet.
Darknet can run without it, but if you want to train a custom network then either CUDA or CUDA+cuDNN is required.
Visit https://developer.nvidia.com/cuda-downloads to download and install CUDA.
Visit https://developer.nvidia.com/rdp/cudnn-download or https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows to download and install cuDNN.
Once you install CUDA make sure you can run nvcc.exe and nvidia-smi.exe. You may have to modify your PATH variable.
Once you download cuDNN, unzip and copy the bin, include, and lib directories into C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[version]/. You may need to overwrite some files.
If you install CUDA or CUDA+cuDNN at a later time, or you upgrade to a newer version of the NVIDIA software:
CUDA must be installed after Visual Studio. If you upgrade Visual Studio, remember to re-install CUDA.
5. Clone and Build Darknet: Once the previous steps are completed successfully, clone Darknet and build it. During this step, specify the VCPKG location for CMake to locate OpenCV and other dependencies:
`bash
cd c:src
git clone https://github.com/hank-ai/darknet.git
cd darknet
mkdir build
cd build
cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
If you encounter an error about missing CUDA or cuDNN DLLs (e.g., cublas64_12.dll), manually copy the CUDA .dll files to the same output directory as darknet.exe. For example:
`bash
copy "C:Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(This is an example! Verify your running version and use the command appropriate for your installation.)
After copying the files, re-run the last msbuild.exe command to generate the NSIS installation package:
`bash
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Advanced Users:
Note that the output of the cmake command is a standard Visual Studio solution file (Darknet.sln). If you are a software developer who prefers using the Visual Studio GUI instead of msbuild.exe for building projects, you can skip the command-line steps and load the Darknet project in Visual Studio.
You should now have the executable C:srcDarknetbuildsrc-cliReleasedarknet.exe. Run it to test: C:srcDarknetbuildsrc-cliReleasedarknet.exe version.
To properly install Darknet, its libraries, include files, and required DLLs, run the NSIS installation wizard generated in the last step. Find the file darknet-VERSION.exe in the build directory. For example:
`bash
darknet-2.0.31-win64.exe
`
Installing the NSIS installation package will:
Create a directory called Darknet, like C:Program FilesDarknet.
Install the CLI application (darknet.exe) and other sample apps.
Install the necessary 3rd-party .dll files, such as those from OpenCV.
Install the required Darknet .dll, .lib, and .h files for using darknet.dll from another application.
Install the template .cfg files.
You are now finished! After the installation wizard completes, Darknet will be installed in C:Program FilesDarknet. Test it by running: C:Program FilesDarknetbindarknet.exe version.
If C:/Program Files/darknet/bin/darknet.exe is missing, Darknet is only built, not installed. Make sure you complete each panel of the NSIS installation wizard from the previous step.
Using Darknet
CLI
The following is not a comprehensive list of all commands supported by Darknet.
In addition to the Darknet CLI, remember the DarkHelp project CLI, which offers an alternative CLI to Darknet/YOLO. The DarkHelp CLI includes various advanced features not directly accessible in Darknet. You can utilize both the Darknet CLI and the DarkHelp CLI simultaneously; they are not mutually exclusive.
For most commands below, you will need the .weights file along with its corresponding .names and .cfg files. You can either train your own network (highly recommended!) or download a pre-trained neural network that someone has made available for free online. Some pre-trained datasets include:
LEGO Gears (object detection in an image)
Rolodex (text detection in an image)
MSCOCO (standard 80-class object detection)
Commands to run:
List of possible commands and options:
`bash
darknet help
`
Check the version:
`bash
darknet version
`
Prediction using an image:
V2:
`bash
darknet detector test cars.data cars.cfg cars_best.weights image1.jpg
`
V3:
`bash
darknet02displayannotatedimages cars.cfg image1.jpg
`
DarkHelp:
`bash
DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg
`
Output coordinates:
V2:
`bash
darknet detector test animals.data animals.cfg animalsbest.weights -extoutput dog.jpg
`
V3:
`bash
darknet01inference_images animals dog.jpg
`
DarkHelp:
`bash
DarkHelp --json animals.cfg animals.names animals_best.weights dog.jpg
`
Working with videos:
V2:
`bash
darknet detector demo animals.data animals.cfg animalsbest.weights -extoutput test.mp4
`
V3:
`bash
darknet03display_videos animals.cfg test.mp4
`
DarkHelp:
`bash
DarkHelp animals.cfg animals.names animals_best.weights test.mp4
`
Reading from a webcam:
V2:
`bash
darknet detector demo animals.data animals.cfg animals_best.weights -c 0
`
V3:
`bash
darknet08display_webcam animals
`
Saving results to a video:
V2:
`bash
darknet detector demo animals.data animals.cfg animalsbest.weights test.mp4 -outfilename res.avi
`
V3:
`bash
darknet05processvideosmultithreaded animals.cfg animals.names animals_best.weights test.mp4
`
DarkHelp:
`bash
DarkHelp animals.cfg animals.names animals_best.weights test.mp4
`
JSON:
V2:
`bash
darknet detector demo animals.data animals.cfg animalsbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
`
V3:
`bash
darknet06imagestojson animals image1.jpg
`
DarkHelp:
`bash
DarkHelp --json animals.names animals.cfg animals_best.weights image1.jpg
`
Running on a specific GPU:
V2:
`bash
darknet detector demo animals.data animals.cfg animals_best.weights -i 1 test.mp4
`
Checking neural network accuracy:
`bash
darknet detector map driving.data driving.cfg driving_best.weights ...
Id Name AvgPrecision TP FN FP TN Accuracy ErrorRate Precision Recall Specificity FalsePosRate
-- ---- ------------ ------ ------ ------ ------ -------- --------- --------- ------ ----------- ------------
0 vehicle 91.2495 32648 3903 5826 65129 0.9095 0.0905 0.8486 0.8932 0.9179 0.0821
1 motorcycle 80.4499 2936 513 569 5393 0.8850 0.1150 0.8377 0.8513 0.9046 0.0954
2 bicycle 89.0912 570 124 104 3548 0.9475 0.0525 0.8457 0.8213 0.9715 0.0285
3 person 76.7937 7072 1727 2574 27523 0.8894 0.1106 0.7332 0.8037 0.9145 0.0855
4 many vehicles 64.3089 1068 509 733 11288 0.9087 0.0913 0.5930 0.6772 0.9390 0.0610
5 green light 86.8118 1969 239 510 4116 0.8904 0.1096 0.7943 0.8918 0.8898 0.1102
6 yellow light 82.0390 126 38 30 1239 0.9525 0.0475 0.8077 0.7683 0.9764 0.0236
7 red light 94.1033 3449 217 451 4643 0.9237 0.0763 0.8844 0.9408 0.9115 0.0885
`
To check accuracy mAP@IoU=75:
`bash
darknet detector map animals.data animals.cfg animalsbest.weights -iouthresh 0.75
`
Recalculating anchors: Anchor recalculation is best performed in DarkMark, as it will run 100 consecutive times and select the best anchors from all calculated options. However, if you want to use the older Darknet method:
`bash
darknet detector calcanchors animals.data -numof_clusters 6 -width 320 -height 256
`
Training a new network:
`bash
cd ~/nn/animals/
darknet detector -map -dont_show train animals.data animals.cfg
`
(See the training section below for additional details.)
Training
Quick links to relevant sections of the Darknet/YOLO FAQ:
File and Directory Setup: How should I set up my files and directories?
Configuration Files: Which configuration file should I use?
Training Command: What command should I use when training my own network?
The simplest way to annotate and train is with DarkMark. It simplifies the process of creating all the necessary Darknet files. Using DarkMark is strongly recommended for training new neural networks.
If you prefer manual setup of the files for custom network training:
1. Create a Folder: Establish a new folder to store the files. For this example, we'll create a neural network to detect animals; therefore, the following directory is created: ~/nn/animals/.
2. Copy Configuration File: Copy a Darknet configuration file you wish to use as a template. For example, see cfg/yolov4-tiny.cfg. Place it in the created folder. In this example, we now have ~/nn/animals/animals.cfg.
3. Create animals.names: Create a text file named animals.names in the same folder as the configuration file. This example now has ~/nn/animals/animals.names.
4. Edit animals.names: Edit the animals.names file using your text editor. List the classes you intend to use. Each class should occupy a separate line, without any blank lines or comments. In this example, the .names file will contain four lines:
`
dog
cat
bird
horse
`
5. Create animals.data: Create a animals.data text file in the same folder. For this example, the .data file will contain:
`
classes = 4
train = /home/username/nn/animals/animals_train.txt
valid = /home/username/nn/animals/animals_valid.txt
names = /home/username/nn/animals/animals.names
backup = /home/username/nn/animals
`
6. Dataset Folder: Create a folder to store your images and annotations. For instance, this could be ~/nn/animals/dataset. Each image requires a corresponding .txt file describing its annotations. The format of the .txt annotation files is very specific. You cannot manually create these files because each annotation requires precise coordinates. Utilize DarkMark or similar software to annotate your images. The YOLO annotation format is described in the Darknet/YOLO FAQ.
7. "train" and "valid" Files: Create the "train" and "valid" text files mentioned in the .data file. These two files need to individually list all the images that Darknet will use for training and validation when calculating mAP%. Include one image per line. The path and filenames can be relative or absolute.
8. Modify .cfg File: Use a text editor to modify your .cfg file.
Ensure that batch=64.
Observe subdivisions. Based on your network dimensions and GPU memory capacity, you might need to increase subdivisions. The ideal value is 1, so begin with that. See the Darknet/YOLO FAQ if 1 doesn't work for you.
Pay attention to maxbatches=..... A good starting value is 2000 times the number of classes. In this example, we have 4 animals, so 4 * 2000 = 8000, meaning maxbatches=8000.
Note steps=..... Set this to 80% and 90% of maxbatches. In this example, with maxbatches set to 8000, we'd use steps=6400,7200.
Notice width=... and height=..... These are the network dimensions. The Darknet/YOLO FAQ explains how to determine the best size.
Search for all occurrences of the line classes=... and modify it with the number of classes in your .names file. In this example, we'd use classes=4.
Search for all occurrences of the line filters=... in the [convolutional] section preceding each [yolo] section. The value should be (numberofclasses + 5) 3. In this example, (4 + 5) 3 = 27. Therefore, use filters=27 on the appropriate lines.
9. Begin Training: Execute the following commands:
`bash
cd ~/nn/animals/
darknet detector -map -dont_show train animals.data animals.cfg
`
Be patient. The best weights will be saved as animals_best.weights. Training progress can be monitored by viewing the chart.png file. Consult the Darknet/YOLO FAQ for additional parameters that might be useful when training a new network.
To view more training details, add the --verbose parameter. For example:
`bash
darknet detector -map -dont_show --verbose train animals.data animals.cfg
`
Other Tools and Links
For managing your Darknet/YOLO projects, annotating images, verifying annotations, and generating the necessary files for training with Darknet, see DarkMark.
For a robust alternative CLI to Darknet, for utilizing image tiling, object tracking in videos, or a robust C++ API for commercial applications, explore DarkHelp.
Check if the Darknet/YOLO FAQ can address your questions.
View numerous tutorials and example videos on Stéphane's YouTube channel.
If you have a support inquiry or want to interact with other Darknet/YOLO users, join the Darknet/YOLO Discord server.
Roadmap
Last updated 2024-10-30:
Completed:
1. Replaced qsort() with std::sort() during training (some obscure instances remain).
2. Removed check_mistakes, getchar(), and system().
3. Converted Darknet to use the C++ compiler (g++ on Linux, VisualStudio on Windows).
4. Fixed the Windows build.
5. Fixed Python support.
6. Built the Darknet library.
7. Re-enabled labels on predictions ("alphabet" code).
8. Re-enabled CUDA/GPU code.
9. Re-enabled CUDNN.
10. Re-enabled CUDNN half.
11. Avoided hard-coding the CUDA architecture.
12. Enhanced CUDA version information.
13. Re-enabled AVX.
14. Removed old solutions and Makefile.
15. Made OpenCV mandatory.
16. Removed dependency on the old pthread library.
17. Removed STB.
18. Rewritten CMakeLists.txt to incorporate the new CUDA detection.
19. Removed old "alphabet" code and deleted the 700+ images in data/labels.
20. Built out-of-source.
21. Improved version number output.
22. Implemented performance optimizations related to training (ongoing task).
23. Implemented performance optimizations related to inference (ongoing task).
24. Used pass-by-reference wherever possible.
25. Cleaned up .hpp files.
26. Rewritten darknet.h.
27. Avoided casting cv::Mat to void* and used it as a proper C++ object.
28. Fixed or ensured consistency in how the internal image structure is utilized.
29. Fixed build for ARM-based Jetson devices.
30. Original Jetson devices are unlikely to be fixed due to NVIDIA no longer supporting them (no C++17 compiler).
31. New Jetson Orin devices are functional.
32. Fixed the Python API in V3.
Short-term goals:
1. Replace printf() with std::cout (in progress).
2. Revisit old zed camera support.
3. Improve and enhance command line parsing consistency (in progress).
Mid-term goals:
1. Remove all char* code and replace it with std::string.
2. Eliminate hidden warnings and clean up compiler warnings (in progress).
3. Better utilization of cv::Mat instead of the custom image structure in C (in progress).
4. Replace old list functionality with std::vector or std::list.
5. Fix support for 1-channel grayscale images.
6. Add support for N-channel images where N > 3 (e.g., images with an additional depth or thermal channel).
7. Ongoing code cleanup (in progress).
Long-term goals:
1. Resolve CUDA/CUDNN issues across all GPUs.
2. Rewrite the CUDA+cuDNN code.
3. Investigate adding support for non-NVIDIA GPUs.
4. Introduce rotated bounding boxes or some form of "angle" support.
5. Incorporate keypoints/skeletons.
6. Integrate heatmaps (in progress).
7. Implement segmentation.
