kwiver 1.4.2

Kitware Image and Video Exploitation and Retrieval

The KWIVER toolkit is a collection of software tools designed to tackle challenging image and video analysis problems and other related challenges. Recently started by Kitware’s Computer Vision and Scientific Visualization teams, KWIVER is an ongoing effort to transition technology developed over multiple years to the open source domain to further research, collaboration, and product development. KWIVER is a collection of C++ libraries with C and Python bindings and uses an permissive BSD License.

One of the primary design goals of KWIVER is to make it easier to pull together algorithms from a wide variety of third-party, open source image and video processing projects and integrate them into highly modular, run-time configurable systems.

For more information on how KWIVER achieves this goal, and how to use KWIVER visit our documentation site

Directory Structure and Provided Functionality

Below is a summary of the key directories in KWIVER and a brief summary of the content they contain.

KWIVER Docker Image

Kitware maintains a Docker image with KWIVER prebuilt. The Dockerfile used to build the image can be found here.

Pull the image from Dockerhub:

"docker pull kitware/kwiver:master" (latest master)

"docker pull kitware/kwiver:release" (latest release)

"docker pull kitware/kwiver:1.4.0" (static release)

(https://hub.docker.com/r/kitware/kwiver)

or build the KWIVER image using the dockerfile:

"docker build -t kwiver:tagname ."

Building KWIVER

Running CMake

You may run cmake directly from a shell or cmd window. On unix systems, the ccmake tool allows for interactive selection of CMake options. Available for all platforms, the CMake GUI can set the source and build directories, options, “Configure” and “Generate” the build files all with the click of a few button.

We recommend building KWIVER out of the source directory to prevent mixing source files with compiled products. Create a build directory in parallel with the KWIVER source directory for each desired configuration. For example :

\kwiver\src	contains the code from the git repository
\kwiver\build\release	contains the built files for the release configuration
\kwiver\build\debug	contains the built files for the debug configuration

The following are the most important CMake configuration options for KWIVER.

CMAKE_BUILD_TYPE	The compiler mode, usually Debug or Release
CMAKE_INSTALL_PREFIX	The path to where you want the kwiver build products to install
KWIVER_ENABLE_ARROWS	Enable algorithm implementation plugins
KWIVER_ENABLE_C_BINDINGS	Whether to build the Vital C bindings
KWIVER_ENABLE_DOCS	Turn on building the Doxygen documentation
KWIVER_ENABLE_LOG4CPLUS	Enable log4cplus logger back end
KWIVER_ENABLE_PYTHON	Enable the Vital Python bindings (requires KWIVER_ENABLE_C_BINDINGS)
KWIVER_ENABLE_SPROKIT	Enable the Stream Processing Toolkit
KWIVER_ENABLE_TESTS	Build the unit tests (requires Google Test)
KWIVER_ENABLE_TOOLS	Build the command line tools (e.g. plugin_explorer)
fletch_DIR	Install directory of a Fletch build.

There are many more options. Specifically, there are numerous options for third-party projects prefixed with KWIVER_ENABLE_ that enable building the Arrows plugins that depend on those projects. When building with the support of Fletch (set fletch_DIR) the enable options for packages built by Fletch should be turned on by default. The fletch_DIR is the fletch build directory root, which contains the fletchConfig.cmake file.

The following sections will walk you through the basic options for a minimal kwiver build.

Basic CMake generation via command line

Note, This assumes your fletch was built with python support (Turn OFF if not)

You will also need to replace the fletch path with your own:

$ cmake </path/to/kwiver/source> -DCMAKE_BUILD_TYPE=Release \
        -Dfletch_DIR:PATH=<path/to/fletch/build/dir> \
        -DKWIVER_ENABLE_ARROWS:BOOL=ON -DKWIVER_ENABLE_C_BINDINGS:BOOL=ON \
        -DKWIVER_ENABLE_EXTRAS:BOOL=ON -DKWIVER_ENABLE_LOG4CPLUS:BOOL=ON \
        -DKWIVER_ENABLE_PROCESSES:BOOL=ON -DKWIVER_ENABLE_PYTHON:BOOL=ON \
        -DKWIVER_ENABLE_SPROKIT:BOOL=ON -DKWIVER_ENABLE_TOOLS:BOOL=ON \
        -DKWIVER_ENABLE_EXAMPLES:BOOL=ON -DKWIVER_USE_BUILD_TREE:BOOL=ON

Basic CMake generation using ccmake

When first configuring a kwiver build with ccmake it is preferable to set the build configuration and fletch_DIR on the command line like this:

$ ccmake /path/to/kwiver/source -DCMAKE_BUILD_TYPE=Release -Dfletch_DIR=/path/to/fletch/install

Other CMake options can also be passed on the command line in this way if desired. Follow the recommended option setup using the cmake GUI.

Basic CMake generation using the CMake GUI

When running the cmake gui, we recommend selecting the ‘Grouped’ and ‘Advanced’ options to better organize the options available. Note, after clicking the configuration button, new options will be highlighted in the red sections.

1. Once the source code and build directories are set, press the ‘Configuration’ button and select your compiler.

   1. Configuration will fail, but now we can set option values

2. Set the fletch_DIR, the CMAKE_BUILD_TYPE, and these KWIVER options, and press the ‘Configuration’ button

   1. Note, if compiling with MSVC, you will not have a CMAKE_BUILD_TYPE option

3. Select these new options, and click ‘Generate’

   1. This assumes your fletch was build with python support, if not, do not check that option

Running KWIVER

Once you’ve built KWIVER, you’ll want to test that it’s working on your system. Change your terminal/command prompt to the KWIVER CMake build directory. From a command prompt execute the following command:

# via a bash shell
$ cd <path/to/kwiver/build>
$ source setup_KWIVER.sh
#
# via a windows cmd prompt
> cd <path/to/kwiver/build>
> setup_KWIVER.bat

This will set up your PATH, PYTHONPATH and other environment variables to allow KWIVER to work conveniently within in the shell/cmd window.

You can run this simple pipeline to ensure your system is configured properly:

# via a bash shell
$ cd bin
$ kwiver runner ../examples/pipelines/number_flow.pipe
#
# on windows, you will need to also be in the configuration folder
> cd bin\release
> kwiver runner ..\..\examples\pipelines\number_flow.pipe

This will generate a ‘numbers.txt’ file in the </path/to/kwiver/build>/examples/pipelines/output directory.

More examples can be found in our tutorials

KWIVER Users

Here are some applications using kwiver that serve as an example of how to leverage kwiver for a specific application

Testing

Continuous integration testing is provided by CDash. Our KWIVER dashboard hosts nightly build and test results across multiple platforms including Windows, Mac, and Linux.

Anyone can contribute a build to this dashboard using the dashboard script provided. Follow the instructions in the comments.

Contributing

For details on how to contribute to KWIVER, including code style and branch naming conventions, please read CONTRIBUTING.rst.

Getting Help

Please join the kwiver-users mailing list to discuss KWIVER or to ask for help with using KWIVER. For less frequent announcements about KWIVER and projects built on KWIVER, please join the kwiver-announce mailing list.

Acknowledgements

The authors would like to thank AFRL/Sensors Directorate for their support of this work via SBIR Contract FA8650-14-C-1820. The portions of this work funded by the above contract are approved for public release via case number 88ABW-2017-2725.

The authors would like to thank IARPA for their support of this work via the DIVA program.

The authors would like to thank NOAA for their support of this work via the NOAA Fisheries Strategic Initiative on Automated Image Analysis.