Skip to content

Latest commit

 

History

History
488 lines (346 loc) · 33.2 KB

installation.md

File metadata and controls

488 lines (346 loc) · 33.2 KB
Raw

OpenPose - Installation

Contents

  1. Windows Portable Demo
  2. Operating Systems
  3. Requirements and Dependencies
  4. Clone OpenPose
  5. Update OpenPose
  6. Installation
  7. Reinstallation
  8. Uninstallation
  9. Optional Settings
    1. Maximum Speed
    2. COCO and MPI Models
    3. Python API
    4. CPU Version
    5. OpenCL Version
    6. Mac OSX Version
    7. 3D Reconstruction Module
    8. Calibration Module
    9. Compiling without cuDNN
    10. Custom Caffe (Ubuntu Only)
    11. Custom OpenCV (Ubuntu Only)
    12. Doxygen Documentation Autogeneration (Ubuntu Only)
    13. CMake Command Line Configuration (Ubuntu Only)

Windows Portable Demo

This installation section is only intended if you plan to modify the OpenPose code or integrate it with another library or project. If you just want to use the OpenPose demo in Windows, simply use the latest version of the OpenPose binaries which you can find in the Releases section.

NOTE: Read the Instructions.txt to learn to download the models required by OpenPose (about 500 Mb).

Operating Systems

  • Ubuntu 14, 16, 18.
  • Windows 7, 8, 10. Note: Only CUDA 8 and graphic cards up to 10XX series. 20XX series and V100 graphic cards are not compatible yet (check GitHub issue #996 for updates).
  • Mac OSX Mavericks and above.
  • Nvidia Jetson TX2 (for JetPack 3.1 or 3.3), installation instructions in doc/installation_jetson_tx2_jetpack3.1.md and doc/installation_jetson_tx2_jetpack3.3.md respectively.
  • OpenPose has also been used on Windows 7, CentOS, and Nvidia Jetson (TK1 and TX1) embedded systems. However, we do not officially support them at the moment.

Requirements and Dependencies

  • Requirements for the default configuration (you might need more resources with a greater --net_resolution and/or scale_number or less resources by reducing the net resolution and/or using the MPI and MPI_4 models):
    • CUDA (Nvidia GPU) version:
      • NVIDIA graphics card with at least 1.6 GB available (the nvidia-smi command checks the available GPU memory in Ubuntu).
      • At least 2.5 GB of free RAM memory for BODY_25 model or 2 GB for COCO model (assuming cuDNN installed).
      • Highly recommended: cuDNN.
    • OpenCL (AMD GPU) version:
      • Vega series graphics card
      • At least 2 GB of free RAM memory.
    • CPU-only (no GPU) version:
      • Around 8GB of free RAM memory.
    • Highly recommended: a CPU with at least 8 cores.
  • Dependencies:
    • OpenCV (all 2.X and 3.X versions are compatible).
    • Caffe and all its dependencies. Interesting in porting OpenPose to other DL frameworks (Tensorflow, Caffe2, Pytorch, ...)?. Email us (gines@cmu.edu) if you are interesting in joining the OpenPose team to do so or feel free to make a pull request if you implement any of those!
    • The demo and tutorials additionally use GFlags.

Clone OpenPose

The first step is to clone the OpenPose repository.

  1. Windows: You might use GitHub Desktop.
  2. Ubuntu:
git clone https://github.com/CMU-Perceptual-Computing-Lab/openpose

Update OpenPose

OpenPose can be easily updated by:

  1. Download the latest changes:
    1. Windows: Clicking the synchronization button at the top-right part in GitHub Desktop in Windows.
    2. Ubuntu: running git pull origin master.
  2. Perform the Reinstallation section described below.

Installation

The instructions in this section describe the steps to build OpenPose using CMake (GUI). There are 3 main steps:

  1. Problems and Errors Installing
  2. Prerequisites
  3. OpenPose Configuration
  4. OpenPose Building
  5. Run OpenPose
  6. OpenPose from other Projects (Ubuntu and Mac)

Problems and Errors Installing

Any problem installing OpenPose? Check doc/faq.md and/or post a GitHub issue. We will not respond more GitHub issues about Caffe, OpenCV or CUDA errors.

Prerequisites

Very important: New Nvidia model GPUs (e.g., Nvidia V, GTX 2080, v100, any Nvidia with Volta or Turing architecture, etc.) require (at least) CUDA 10. CUDA 8 would fail!

In addition, CMake automatically downloads all the OpenPose models. However, some firewall or company networks block these downloads. You might prefer to download them manually: - BODY_25 model: download in models/pose/body_25/. - COCO model: download in models/pose/coco/. - MPI model: download in models/pose/mpi/. - Face model: download in models/face/. - Hands model: download in models/hand/.

Ubuntu Prerequisites

  1. Ubuntu - Anaconda should not be installed on your system. Anaconda includes a Protobuf version that is incompatible with Caffe. Either you uninstall anaconda and install protobuf via apt-get, or you compile your own Caffe and link it to OpenPose.
  2. Install CMake GUI:
    • Ubuntu 14 or 16: run the command sudo apt-get install cmake-qt-gui. Note: If you prefer to use CMake through the command line, see CMake Command Line Configuration (Ubuntu Only).
    • Ubuntu 18: Download and compile CMake-gui from source. The default CMake-gui version (3.10) installed via sudo apt-get install cmake-qt-gui provokes some compiling errors. Required CMake version >= 3.12.
      • Uninstall your current Cmake-gui version by running sudo apt purge cmake-qt-gui.
      • Run sudo apt-get install qtbase5-dev.
      • Download the Latest Release of CMake Unix/Linux Source from the CMake download website, called cmake-X.X.X.tar.gz.
      • Unzip it and go inside that folder from the terminal.
      • Run ./configure --qt-gui. Make sure no error occurred.
      • Run ./bootstrap && make -j8 && make install -j8. Make sure no error occurred.
      • Assuming your CMake downloaded folder is in {CMAKE_FOLDER_PATH}, everytime these instructions mentions cmake-gui, you will have to replace that line by {CMAKE_FOLDER_PATH}/bin/cmake-gui.
  3. Nvidia GPU version prerequisites:
    1. Note: OpenPose has been tested extensively with CUDA 8.0 (cuDNN 5.1) and CUDA 10.0 (cuDNN 7.2). We highly recommend using those versions to minimize potential installation issues. Other versions should also work, but we do not provide support about any CUDA/cuDNN installation/compilation issue, as well as problems relate dto their integration into OpenPose.
    2. CUDA:
      • Ubuntu 14 or 16 (CUDA 8 or 10): Run sudo ./scripts/ubuntu/install_cuda.sh (if Ubuntu 16 or 14 and for Graphic cards up to 10XX) or alternatively download and install it from their website.
      • Ubuntu 18 (CUDA 10): Download the latest Nvidia CUDA version from their official website.
        • Select "Linux" -> "x86_64" -> "Ubuntu" -> "18.04" -> "runtime (local)", and download it.
        • Follow the Nvidia website installation instructions. Make sure to enable the symbolic link in usr/local/cuda to minimize potential future errors.
    3. cuDNN:
      • Ubuntu 14 or 16 (cuDNN 5.1 or 7.2): Run sudo ./scripts/ubuntu/install_cudnn.sh (if Ubuntu 16 or 14 and for Graphic cards up to 10XX) or alternatively download and install it from their website.
      • Ubuntu 18 (cuDNN 7.2): Download and install it from the Nvidia website.
  4. AMD GPU version prerequisites:
    1. Ubuntu 14 or 16:
      1. Download 3rd party ROCM driver for Ubuntu from AMD - OpenCL.
      2. Install sudo apt-get install libviennacl-dev.
    2. Ubuntu 18: Not tested and not officially supported. Try at your risk.
  5. Install Caffe, OpenCV, and Caffe prerequisites:
    • Caffe prerequisites: By default, OpenPose uses Caffe under the hood. If you have not used Caffe previously, install its dependencies by running sudo bash ./scripts/ubuntu/install_deps_and_cuda.sh (if Ubuntu 16 or 14 and for Graphic cards up to 10XX) or run sudo bash ./scripts/ubuntu/install_deps.sh after installing your desired CUDA and cuDNN versions.
    • OpenCV must be already installed on your machine. It can be installed with apt-get install libopencv-dev. You can also use your own compiled OpenCV version.
  6. Eigen prerequisite (optional, only required for some specific extra functionality, such as extrinsic camera calibration):
    • If you enable the WITH_EIGEN flag when running CMake. You can either:
      1. Do not do anything if you set the WITH_EIGEN flag to BUILD, CMake will automatically download Eigen. Alternatively, you might prefer to download it manually:
        • Eigen3: Unzip as 3rdparty/eigen/.
      2. Run sudo apt-get install libeigen3-dev if you prefer to set WITH_EIGEN to APT_GET.
      3. Use your own version of Eigen by setting WITH_EIGEN to BUILD, run CMake so that OpenPose downloads the zip file, and then replace the contents of 3rdparty/eigen/ by your own version.

Mac OS Prerequisites

  1. If you don't have brew, install it by running bash scripts/osx/install_brew.sh on your terminal.
  2. Install CMake GUI: Run the command brew cask install cmake.
  3. Install Caffe, OpenCV, and Caffe prerequisites: Run bash scripts/osx/install_deps.sh.
  4. Eigen prerequisite (optional, only required for some specific extra functionality, such as extrinsic camera calibration):
    • Enable the WITH_EIGEN flag when running CMake, and set it to BUILD.
    • CMake will automatically download Eigen.
    • Alternatively, you can manually download it from the Eigen3 website, and unzip as 3rdparty/eigen/.

Windows Prerequisites

NOTE: These instructions are only required when compiling OpenPose brom source. If you simply wanna use the OpenPose binaries for Windows, skip this step.

  1. Install CMake GUI: Download and install the Latest Release of CMake Windows win64-x64 Installer from the CMake download website, called cmake-X.X.X-win64-x64.msi.
  2. Install Microsoft Visual Studio (VS) 2015 Enterprise Update 3:
    • IMPORTANT: Enable all C++-related flags when selecting the components to install.
    • Different VS versions:
      • If Visual Studio 2017 Community is desired, we do not officially support it, but it might be compiled by firstly enabling CUDA 8.0 in VS2017 or use VS2017 with CUDA 9 by checking the .vcxproj file and changing the necessary paths from CUDA 8 to 9.
      • VS 2015 Enterprise Update 1 will give some compiler errors.
      • VS 2015 Community has not been tested.
  3. Nvidia GPU version prerequisites:
    1. Note: OpenPose has been tested extensively with CUDA 8.0 and cuDNN 5.1. We highly recommend using those versions to minimize potential installation issues. Other versions should also work, but we do not provide support about any CUDA/cuDNN installation/compilation issue, as well as problems related to their integration into OpenPose.
    2. CUDA 8:
      • Ubuntu: Run sudo ./scripts/ubuntu/install_cuda.sh (if Ubuntu 16 or 14 and for Graphic cards up to 10XX) or alternatively download and install it from their website.
      • Windows: Install CUDA 8.0 after Visual Studio 2015 is installed to assure that the CUDA installation will generate all necessary files for VS. If CUDA was already installed, re-install it.
      • Important installation tips:
        • (Windows issue, reported Sep 2018): If your computer hangs when installing CUDA drivers, try installing first the Nvidia drivers, and then installing CUDA without the Graphics Driver flag.
        • If CMake returns and error message similar to CUDA_TOOLKIT_ROOT_DIR not found or specified or any other CUDA component missing, then: 1) Re-install Visual Studio 2015; 2) Reboot your PC; 3) Re-install CUDA (in this order!).
    3. cuDNN 5.1:
      • Ubuntu: Run sudo ./scripts/ubuntu/install_cudnn.sh (if Ubuntu 16 or 14 and for Graphic cards up to 10XX) or alternatively download and install it from their website.
      • Windows (and Ubuntu if manual installation): In order to manually install it, just unzip it and copy (merge) the contents on the CUDA folder, usually /usr/local/cuda/ in Ubuntu and C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0 in Windows.
  4. AMD GPU version prerequisites:
    1. Download official AMD drivers for Windows from AMD - Windows.
    2. The libviennacl package comes packaged inside OpenPose for Windows (i.e., no further action required).
  5. Caffe, OpenCV, and Caffe prerequisites:
    • CMake automatically downloads all the Windows DLLs. Alternatively, you might prefer to download them manually:
      • Dependencies:
        • Note: Leave the zip files in 3rdparty/windows/ so that CMake does not try to download them again.
        • Caffe: Unzip as 3rdparty/windows/caffe/.
        • Caffe dependencies: Unzip as 3rdparty/windows/caffe3rdparty/.
        • OpenCV 3.1: Unzip as 3rdparty/windows/opencv/.
  6. Eigen prerequisite (optional, only required for some specific extra functionality, such as extrinsic camera calibration):
    • Enable the WITH_EIGEN flag when running CMake, and set it to BUILD.
    • CMake will automatically download Eigen.
    • Alternatively, you can manually download it from the Eigen3 website, run CMake so that OpenPose downloads the zip file, and then replace the contents of 3rdparty/eigen/ by your own version.

OpenPose Configuration

  1. Open CMake GUI and select the OpenPose directory as project source directory, and a non-existing or empty sub-directory (e.g., build) where the Makefile files (Ubuntu) or Visual Studio solution (Windows) will be generated. If build does not exist, it will ask you whether to create it. Press Yes.

  1. Press the Configure button, keep the generator in Unix Makefile (Ubuntu) or set it to Visual Studio 14 2015 Win64 (Windows), and press Finish.

  1. If this step is successful, the Configuring done text will appear in the bottom box in the last line. Otherwise, some red text will appear in that same bottom box.

  1. Press the Generate button and proceed to OpenPose Building. You can now close CMake.

Note: If you prefer to use your own custom Caffe or OpenCV versions, see Custom Caffe or Custom OpenCV respectively.

OpenPose Building

Ubuntu and Mac

Finally, build the project by running the following commands.

cd build/
make -j`nproc`

Windows

In order to build the project, open the Visual Studio solution (Windows), called build/OpenPose.sln. Then, set the configuration from Debug to Release and press the green triangle icon (alternatively press F5).

VERY IMPORTANT NOTE: In order to use OpenPose outside Visual Studio, and assuming you have not unchecked the BUILD_BIN_FOLDER flag in CMake, copy all DLLs from {build_directory}/bin into the folder where the generated openpose.dll and *.exe demos are, e.g., {build_directory}x64/Release for the 64-bit release version.

Run OpenPose

Check OpenPose was properly installed by running it on the default images, video, or webcam: doc/quick_start.md#quick-start.

OpenPose from other Projects (Ubuntu and Mac)

If you only intend to use the OpenPose demo, you might skip this step. This step is only recommended if you plan to use the OpenPose API from other projects.

To install the OpenPose headers and libraries into the system environment path (e.g., /usr/local/ or /usr/), run the following command.

cd build/
sudo make install

Once the installation is completed, you can use OpenPose in your other project using the find_package cmake command. Below, is a small example CMakeLists.txt. In order to use this script, you also need to copy FindGFlags.cmake and FindGlog.cmake into your <project_root_directory>/cmake/Modules/ (create the directory if necessary).

cmake_minimum_required(VERSION 2.8.7)

add_definitions(-std=c++11)

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")

find_package(GFlags)
find_package(Glog)
find_package(OpenCV)
find_package(OpenPose REQUIRED)

include_directories(${OpenPose_INCLUDE_DIRS} ${GFLAGS_INCLUDE_DIR} ${GLOG_INCLUDE_DIR} ${OpenCV_INCLUDE_DIRS})

add_executable(example.bin example.cpp)

target_link_libraries(example.bin ${OpenPose_LIBS} ${GFLAGS_LIBRARY} ${GLOG_LIBRARY} ${OpenCV_LIBS})

If Caffe was built with OpenPose, it will automatically find it. Otherwise, you will need to link Caffe again as shown below (otherwise, you might get an error like /usr/bin/ld: cannot find -lcaffe).

link_directories(<path_to_caffe_installation>/caffe/build/install/lib)

Reinstallation

In order to re-install OpenPose:

  1. (Ubuntu and Mac) If you ran sudo make install, then run sudo make uninstall in build/.
  2. Delete the build/ folder.
  3. In CMake GUI, click on File --> Delete Cache.
  4. Follow the Installation steps again.

Uninstallation

In order to uninstall OpenPose:

  1. (Ubuntu and Mac) If you ran sudo make install, then run sudo make uninstall in build/.
  2. Remove the OpenPose folder.

Optional Settings

Maximum Speed

Check the OpenPose Benchmark as well as some hints to speed up and/or reduce the memory requirements for OpenPose on doc/speed_up_openpose.md.

COCO and MPI Models

By default, the body COCO and MPI models are not downloaded. You can download them by turning on the DOWNLOAD_BODY_COCO_MODEL or DOWNLOAD_BODY_MPI_MODEL flags. It's slightly faster but less accurate and has less keypoints than the COCO body model.

Note: Check the differences between these models in doc/faq.md#difference-between-body_25-vs.-coco-vs.-mpi.

Python API

To install the Python API, ensure that the BUILD_PYTHON flag is turned on while running CMake GUI and follow the standard installation steps. After the installation, check doc/modules/python_module.md for further details.

CPU Version

To manually select the CPU Version, open CMake GUI mentioned above, and set the GPU_MODE flag to CPU_ONLY. NOTE: Accuracy of the CPU version is ~1% higher than CUDA version, so the results will vary.

  • On Ubuntu, OpenPose will link against the Intel MKL version (Math Kernel Library) of Caffe. Alternatively, the user can choose his own Caffe version, by unselecting USE_MKL and selecting his own Caffe path.
  • On Windows, it will use the default version of Caffe or one provided by the user on the CPU.

The default CPU version takes ~0.2 images per second on Ubuntu (~50x slower than GPU) while the MKL version provides a roughly 2x speedup at ~0.4 images per second. As of now OpenPose does not support MKL on Windows but will at a later date. Also, MKL version does not support unfixed resolution. So a folder of images of different resolutions requires a fixed net resolution (e.g., --net_resolution 656x368).

The user can configure the environmental variables MKL_NUM_THREADS and OMP_NUM_THREADS. They are set at an optimum parameter level by default (i.e., to the number of threads of the machine). However, they can be tweak by running the following commands into the terminal window, right before running any OpenPose application. Eg:

# Optimal number = Number of threads (used by default)
export MKL_NUM_THREADS="8"
export OMP_NUM_THREADS="8"

Do note that increasing the number of threads results in more memory use. You can check the doc/speed_up_openpose.md for more information about speed and memory requirements in several CPUs and GPUs.

OpenCL Version

If you have an AMD graphics card, you can compile OpenPose with the OpenCL option. To manually select the OpenCL Version, open CMake GUI mentioned above, and set the GPU_MODE flag to OPENCL. Very important: If you compiled previously the CPU-only or CUDA versions on that same OpenPose folder, you will have to manually delete the build directory and run the installation steps from scratch. Otherwise, many weird errors will appear.

The OpenCL version has been tested on Ubuntu, Windows and OSX. This has been tested only on AMD Vega series and NVIDIA 10 series graphics cards. Please email us if you have issues with other operating systems or graphics cards. Running on OSX on a Mac with an AMD graphics card requires special instructions which can be seen in the section below.

Lastly, OpenCL version does not support unfixed --net_resolution. So a folder of images of different resolutions with OpenPose, requires the --net_resolution 656x368 flag for example. This should be fixed by the Caffe author in a future patch.

Mac OSX Version

Mac OSX Version compiles similarly to the Ubuntu version. Take a look at the prerequisites section. For GPU acceleration, OpenPose may be built with OpenCL support (check OpenCL Version or add in CMakeGPU_MODE=OPENCL). If you have a Mac with an inbuilt AMD graphics card, you have to manually select your AMD GPU. To do that, first note which device your Graphics card is set under:

clinfo

Most likely, your AMD device will be under device 2. Then run openpose with the following options to use youe AMD card for acceleration.

build/examples/openpose/openpose.bin --num_gpu 1 --num_gpu_start 2

If you only have an integrated Intel Graphics card, then it will most probably be the device 1:

build/examples/openpose/openpose.bin --num_gpu 1 --num_gpu_start 1

Also as a side note, if the default installation fails (i.e., the one explained above), instal Caffe separately and set BUILD_CAFFE to false in the CMake config. Steps:

  • Re-create the build folder: rm -rf build; mkdir build; cd build.
  • brew uninstall caffe to remove the version of Caffe previously installed via cmake.
  • brew install caffe to install Caffe separately.
  • Run cmake-gui and make the following adjustments to the cmake config:
    1. BUILD_CAFFE set to false.
    2. Caffe_INCLUDE_DIRS set to /usr/local/include/caffe.
    3. Caffe_LIBS set to /usr/local/lib/libcaffe.dylib.
    4. Run Configure and Generate from CMake GUI.

You may also have to apply the following patch if you have the latest OSX 10.14. It can be done as follows:

cd 3rdparty/caffe; git apply ../../scripts/osx/mac_opencl_patch.txt

3D Reconstruction Module

You can include the 3D reconstruction module by:

  1. Install the FLIR camera software, Spinnaker SDK. It is a propietary software, so we cannot provide direct download link. Note: You might skip this step if you intend to use the 3-D OpenPose module with a different camera brand.
    1. Ubuntu: Get and install the latest Spinnaker SKD version in their default path. OpenPose will automatically find it. Otherwise, set the right path with CMake.
    2. Windows: Donwload the latest Spinnaker SKD version from https://www.ptgrey.com/support/downloads.
      • Copy {PointGreyParentDirectory}\Point Grey Research\Spinnaker\bin64\vs2015\ as {OpenPoseDirectory}\3rdparty\windows\spinnaker\bin\. You can remove all the *.exe files.
      • Copy {PointGreyParentDirectory}\Point Grey Research\Spinnaker\include\ as {OpenPoseDirectory}\3rdparty\windows\spinnaker\include\.
      • Copy Spinnaker_v140.lib and Spinnakerd_v140.lib from {PointGreyParentDirectory}\Point Grey Research\Spinnaker\lib64\vs2015\ into {OpenPoseDirectory}\3rdparty\windows\spinnaker\lib\.
      • (Optional) Spinnaker SDK overview: https://www.ptgrey.com/spinnaker-sdk.
  2. Install the 3D visualizer, FreeGLUT:
    1. Ubuntu: run sudo apt-get update && sudo apt-get install build-essential freeglut3 freeglut3-dev libxmu-dev libxi-dev and reboot your PC.
    2. Windows:
      1. It is automatically downloaded by the CMake installer.
      2. Alternatively, if you prefer to download it yourself, you could either:
        1. Double click on 3rdparty\windows\getFreeglut.bat.
        2. Download this version from our server and unzip it in {OpenPoseDirectory}\3rdparty\windows\freeglut\.
        3. Download the latest MSVC Package from http://www.transmissionzero.co.uk/software/freeglut-devel/.
          • Copy {freeglutParentDirectory}\freeglut\bin\x64\ as {OpenPoseDirectory}\3rdparty\windows\freeglut\bin\.
          • Copy {freeglutParentDirectory}\freeglut\include\ as {OpenPoseDirectory}\3rdparty\windows\freeglut\include\.
          • Copy {freeglutParentDirectory}\freeglut\lib\x64\ as {OpenPoseDirectory}\3rdparty\windows\freeglut\lib\.
  3. Follow the CMake installation steps. In addition, set the WITH_FLIR_CAMERA (only if Spinnaker was installed) and WITH_3D_RENDERER options.
  4. Increased accuracy with Ceres solver (Ubuntu only): For extra 3-D reconstruction accuracy, run sudo apt-get install libeigen3-dev, install Ceres solver, and enable WITH_CERES in CMake when installing OpenPose. Ceres is harder to install in Windows, so we have not tested it so far in there. Feel free to make a pull request if you do.

After installation, check the doc/modules/3d_reconstruction_module.md instructions.

Calibration Module

The calibration module is included by default, but you must also enable WITH_EIGEN if you intend to use the extrinsic camera parameter estimation tool. You can set that flag to 2 different values: APT_GET or BUILD, check Requirements and Dependencies for more information.

After installation, check the doc/modules/calibration_module.md instructions.

Compiling without cuDNN

The cuDNN library is not mandatory, but required for full keypoint detection accuracy. In case your graphics card is not compatible with cuDNN, you can disable it by unchecking USE_CUDNN in CMake.

Then, you would have to reduce the --net_resolution flag to fit the model into the GPU memory. You can try values like 640x320, 320x240, 320x160, or 160x80 to see your GPU memory capabilities. After finding the maximum approximate resolution that your GPU can handle without throwing an out-of-memory error, adjust the net_resolution ratio to your image or video to be processed (see the --net_resolution explanation from doc/demo_overview.md), or use -1 (e.g., --net_resolution -1x320).

Custom Caffe (Ubuntu Only)

Note that OpenPose uses a custom fork of Caffe (rather than the official Caffe master). Our custom fork is only updated if it works on our machines, but we try to keep it updated with the latest Caffe version. This version works on a newly formatted machine (Ubuntu 16.04 LTS) and in all our machines (CUDA 8 and 10 tested). The default GPU version is the master branch, which it is also compatible with CUDA 10 without changes (official Caffe version might require some changes for it). We also use the OpenCL and CPU tags if their CMake flags are selected.

We only modified some Caffe compilation flags and minor details. You can use your own Caffe distribution, simply specify the Caffe include path and the library as shown below. You will also need to turn off the BUILD_CAFFE variable. Note that cuDNN is required in order to get the maximum possible accuracy in OpenPose.

Custom OpenCV (Ubuntu Only)

If you have built OpenCV from source and OpenPose cannot find it automatically, you can set the OPENCV_DIR variable to the directory where you build OpenCV.

Doxygen Documentation Autogeneration (Ubuntu Only)

You can generate the documentation by setting the BUILD_DOCS flag. The documentation will be generated in doc/doxygen/html/index.html. You can simply open it with double-click (your default browser should automatically display it).

CMake Command Line Configuration (Ubuntu Only)

Note that this step is unnecessary if you already used the CMake GUI alternative.

Create a build folder in the root OpenPose folder, where you will build the library --

cd openpose
mkdir build
cd build

The next step is to generate the Makefiles. Now there can be multiple scenarios based on what the user already has e.x. Caffe might be already installed and the user might be interested in building OpenPose against that version of Caffe instead of requiring OpenPose to build Caffe from scratch.

SCENARIO 1 -- Caffe not installed and OpenCV installed using apt-get

In the build directory, run the below command --

cmake ..
SCENARIO 2 -- Caffe installed and OpenCV build from source

In this example, we assume that Caffe and OpenCV are already present. The user needs to supply the paths of the libraries and the include directories to CMake. For OpenCV, specify the include directories and the libraries directory using OpenCV_INCLUDE_DIRS and OpenCV_LIBS_DIR variables respectively. Alternatively, the user can also specify the path to the OpenCVConfig.cmake file by setting the OpenCV_CONFIG_FILE variable. For Caffe, specify the include directory and library using the Caffe_INCLUDE_DIRS and Caffe_LIBS variables. This will be where you installed Caffe. Below is an example of the same.

cmake -DOpenCV_INCLUDE_DIRS=/home/"${USER}"/softwares/opencv/build/install/include \
  -DOpenCV_LIBS_DIR=/home/"${USER}"/softwares/opencv/build/install/lib \
  -DCaffe_INCLUDE_DIRS=/home/"${USER}"/softwares/caffe/build/install/include \
  -DCaffe_LIBS=/home/"${USER}"/softwares/caffe/build/install/lib/libcaffe.so -DBUILD_CAFFE=OFF ..
cmake -DOpenCV_CONFIG_FILE=/home/"${USER}"/softwares/opencv/build/install/share/OpenCV/OpenCVConfig.cmake \
  -DCaffe_INCLUDE_DIRS=/home/"${USER}"/softwares/caffe/build/install/include \
  -DCaffe_LIBS=/home/"${USER}"/softwares/caffe/build/install/lib/libcaffe.so -DBUILD_CAFFE=OFF ..
SCENARIO 3 -- OpenCV already installed

If Caffe is not already present but OpenCV is, then use the below command.

cmake -DOpenCV_INCLUDE_DIRS=/home/"${USER}"/softwares/opencv/build/install/include \
  -DOpenCV_LIBS_DIR=/home/"${USER}"/softwares/opencv/build/install/lib ..
cmake -DOpenCV_CONFIG_FILE=/home/"${USER}"/softwares/opencv/build/install/share/OpenCV/OpenCVConfig.cmake ..