VIAME is a computer vision application designed for do-it-yourself artificial intelligence including object detection, object tracking, image/video annotation, image/video search, image mosaicing, stereo measurement, rapid model generation, and tools for the evaluation of different algorithms. Originally targetting marine species analytics, it now contains many common algorithms and libraries, and is also useful as a generic computer vision library. The core infrastructure connecting different system components is currently the KWIVER library, which can connect C/C++, python, and matlab nodes together in a graph-like pipeline architecture. Alongside the pipelined image processing system are a number of standalone tools for accomplishing the above. Both a desktop and web version exists for deployments in different types of environments.
The User's Quick-Start Guide, Tutorial Videos, and Developer's Manual are more comprehensive, but select entries are also listed below broken down by individual functionality:
Build and Install Guide <> All Examples <> GUIs for Annotation and Visualization <> Object Detectors <> Object Trackers <> Detector Training API <> Video Search and Rapid Model Generation <> Scoring of Detectors <> Detection File Formats <> Calibration and Image Enhancement <> Image Registration and Mosaicing <> Stereo Measurement and Depth Maps <> KWIVER Overview <> Core Class and Pipelining Info <> Web Interface <> How to Integrate Your Own Plugin <> Example Plugin Templates <> Embedding Detectors in C++ Code
For a full installation guide see the quick-start slide deck above, but in summary, extract the binaries and place them in a directory of your choosing, for example C:\Program Files\VIAME on Windows or /opt/noaa/viame on Linux. If you're using packages built with GPU support, make sure to have sufficient video drivers installed, version 418.39 or higher. The best way to install drivers depends on your operating system, see below. Lastly, run through some of the examples to validate the installation. It is no longer necessary to install any dependencies of VIAME besides video drivers, everything else is packaged inside of it. The binaries are quite large, in terms of disk space, due to the inclusion of multiple default model files and programs, but if just building your desired features from source (e.g. for embedded apps) they are much smaller.
Installation Requirements:
RHEL/CentOS 7 64-Bit, Ubuntu 16.04/18.04 64-Bit, Windows 7, 8, or 10 64-Bit
6 Gb of Disk Space for the Full Installation
Installation Recommendations:
NVIDIA Drivers (Version 418.39+
Windows
[1]
[2]
Ubuntu
[1]
[2]
CentOS
[1]
[2])
A CUDA-enabled GPU with 8 Gb or more VRAM
Windows Desktop Binaries:
VIAME v0.10.10 Windows 7*/8/10, 64-Bit, GPU Enabled, Python 3.6, Mirror1
VIAME v0.10.10 Windows 7*/8/10, 64-Bit, GPU Enabled, Python 3.6, Mirror2
VIAME v0.10.10 Windows 7*/8/10, 64-Bit, CPU Only, Python 3.6, Mirror1
VIAME v0.10.10 Windows 7*/8/10, 64-Bit, CPU Only, Python 3.6, Mirror2
Ubuntu Desktop Binaries:
VIAME v0.10.10 Ubuntu 18.04, 64-Bit, GPU Enabled, Python 3.6, Mirror1
VIAME v0.10.10 Ubuntu 18.04, 64-Bit, GPU Enabled, Python 3.6, Mirror2
VIAME v0.10.10 Ubuntu 16.04, 64-Bit, GPU Enabled, Python 3.6, Mirror1
VIAME v0.10.10 Ubuntu 16.04, 64-Bit, GPU Enabled, Python 3.6, Mirror2
CentOS or Other Linux Desktop Binaries:
VIAME v0.10.10 RHEL/CentOS 7, 64-Bit, GPU Enabled, Python 3.6, Mirror1
VIAME v0.10.10 RHEL/CentOS 7, 64-Bit, GPU Enabled, Python 3.6, Mirror2
VIAME v0.10.10 Generic Linux, 64-Bit, GPU Enabled, Python 3.6, Mirror1
VIAME v0.10.10 Generic Linux, 64-Bit, GPU Enabled, Python 3.6, Mirror2
*Windows 7 requires some updates and service packs installed, e.g. KB2533623.
Web Applications:
VIAME Online Web Annotator and Public Annotations
VIAME Web Source Repository
Optional Patches:
Alternative Generic Detector for IQR Add-On, All OS
Arctic Seals Models Add-On, Windows
Arctic Seals Models Add-On, Linux
HabCam Models (Scallop, Skate, Flatfish) Add-On, Windows
HabCam Models (Scallop, Skate, Flatfish) Add-On, Linux
Low Memory GPU (For 4+ Gb Cards) Add-On, All OS
MOUSS Model Set 1 (Deep 7 Bottomfish) Add-On, All OS
MOUSS Model Set 2 (Deep 7 Bottomfish) Add-On, All OS
MOUSS Sample Project, All Linux
Sea Lion Models Add-On, All OS
Custom Distributions:
Seal Multi-View GUI, Windows 7/8/10, GPU Enabled
Seal Multi-View GUI, Windows 7/8/10, CPU Only
Seal Multi-View GUI, CentOS 7, GPU Enabled
Seal Multi-View GUI, Generic Linux, GPU Enabled
Note: To install Add-Ons and Patches, copy them into an existing VIAME installation folder. To use project files extract them into your working directory of choice. Custom Applications contain a full installation, only with non-default features turned on, and should not be copied into existing installations because they are a full installation and bad things will happen.
Docker images are available on: https://hub.docker.com with the label
kitware/viame:gpu-all-models-latest
This is the image used in the web server, and is compiled every week. Within the container, it contains a VIAME desktop (not web) installation in the folder /opt/noaa/viame with most models turned on (so it is quite large, 10 Gb).
Additional images will be available in the future besides a version with all models.
These instructions are intended for developers or those interested in building the latest master branch. More in-depth build instructions can be found here, but the software can be built either as a super-build, which builds most of its dependencies alongside itself, or standalone. To build VIAME requires, at a minimum, Git, CMake, and a C++ compiler. If using the command line, run the following commands, only replacing [source-directory] and [build-directory] with locations of your choice. While these directories can be the same, it's good practice to have a 'src' checkout then a seperate 'build' directory:
git clone https://github.com/VIAME/VIAME.git [source-directory]
cd [source-directory] && git submodule update --init --recursive
Next, create a build directory and run the following cmake command (or alternatively
use the cmake GUI if you are not using the command line interface):
mkdir [build-directory] && cd [build-directory]
cmake -DCMAKE_BUILD_TYPE:STRING=Release [source-directory]
Once your cmake command has completed, you can configure any build flags you want
using 'ccmake' or the cmake GUI, and then build with the following command on Linux:
make -j8
Or alternatively by building it in Visual Studio or your compiler of choice on Windows. On Linux, '-j8' tells the build to run multi-threaded using 8 threads, this is useful for a faster build though if you get an error it can be difficult to see it, in which case running just 'make' might be more helpful. For Windows, currently VS2017 is the desired compiler, though select versions of 2015 and 2019 also work. If using CUDA, version 9.0 and above, with CUDNN 7.0 and above is desired, in particular we recommend CUDA 10. On both Windows and Linux it can also be beneficial to use Anaconda to get multiple standard python packages. Having numpy installed, at a minimum, is necessary for python.
There are several optional arguments to viame which control which plugins get built, such as those listed below. If a plugin is enabled that depends on another dependency such as OpenCV) then the dependency flag will be forced to on. If uncertain what to turn on, it's best to just leave the default enable and disable flags which will build most (though not all) functionalities. These are core components we recommend leaving turned on:
| Flag | Description |
|---|---|
| VIAME_ENABLE_OPENCV | Builds OpenCV and basic OpenCV processes (video readers, simple GUIs) |
| VIAME_ENABLE_VXL | Builds VXL and basic VXL processes (video readers, image filters) |
| VIAME_ENABLE_PYTHON | Turns on support for using python processes (multiple algorithms) |
| VIAME_ENABLE_PYTORCH | Installs all pytorch processes (detectors, trackers, classifiers) |
And a number of flags which control which system utilities and optimizations are built, e.g.:
| Flag | Description |
|---|---|
| VIAME_ENABLE_CUDA | Enables CUDA (GPU) optimizations across all processes (PyTorch, etc...) |
| VIAME_ENABLE_CUDNN | Enables CUDNN (GPU) optimizations across all processes |
| VIAME_ENABLE_VIVIA | Builds VIVIA GUIs (tools for making annotations and viewing detections) |
| VIAME_ENABLE_KWANT | Builds KWANT detection and track evaluation (scoring) tools |
| VIAME_ENABLE_DOCS | Builds Doxygen class-level documentation for projects (puts in install tree) |
| VIAME_BUILD_DEPENDENCIES | Build VIAME as a super-build, building all dependencies (default behavior) |
| VIAME_INSTALL_EXAMPLES | Installs examples for the above modules into install/examples tree |
| VIAME_DOWNLOAD_MODELS | Downloads pre-trained models for use with the examples and interfaces |
And lastly, a number of flags which build algorithms or interfaces with more specialized functionality:
| Flag | Description |
|---|---|
| VIAME_ENABLE_SMQTK | Builds SMQTK plugins for image/video search |
| VIAME_ENABLE_SCALLOP_TK | Builds Scallop-TK based object detector plugin |
| VIAME_ENABLE_YOLO | Builds YOLO (Darknet) object detector plugin |
| VIAME_ENABLE_BURNOUT | Builds Burn-Out based pixel classifier plugin |
| VIAME_ENABLE_ITK | Builds ITK cross-modality image registration |
| VIAME_ENABLE_UW_CLASSIFIER | Builds UW fish classifier plugin |
| VIAME_ENABLE_TENSORFLOW | Builds TensorFlow object detector plugin |
| VIAME_ENABLE_SEAL_TK | Builds Seal multi-modality GUI |
| VIAME_ENABLE_MATLAB | Turns on support for and installs all matlab processes |
| VIAME_ENABLE_LANL | Builds an additional (Matlab) scallop detector |
VIAME ├── cmake # CMake configuration files for subpackages ├── docs # Documentation files and manual (pre-compilation) ├── configs # All system-runnable config files and models │ ├── pipelines # All processing pipeline configs │ │ └── models # All models, which only get downloaded based on flags │ ├── prj-linux # Default linux project files │ └── prj-windows # Default windows project files ├── examples # All runnable examples and example tutorials ├── packages # External projects used by the system │ ├── kwiver # Processing backend infastructure │ ├── fletch # Dependency builder for things which don't change often │ ├── kwant # Scoring and detector evaluation tools │ ├── vivia # Baseline desktop GUIs (v1.0) │ └── ... # Assorted other packages (typically for algorithms) ├── plugins # Integrated algorithms or wrappers around external projects │ └── ... # Assorted plugins (detectors, depth maps, filters, etc.) ├── tools # Standalone tools or scripts, often building on the above └── README.md # Project introduction page that you are reading └── RELEASE_NOTES.md # A list of the latest updates in the system per version
If you already have a checkout of VIAME and want to switch branches or update your code, it is important to re-run:
git submodule update --init --recursive
After switching branches to ensure that you have on the correct hashes of sub-packages within the build. Very rarely you may also need to run:
git submodule sync
Just in case the address of submodules has changed. You only need to run this command if you get a "cannot fetch hash #hashid" error.
VIAME is released under a BSD-3 license.
A non-exhaustive list of relevant papers used within the project alongside contributors can be found here.
VIAME was developed with funding from multiple sources, with special thanks to those listed here.