Compiling OpenEB on Windows
This section describes how to install OpenEB from source code on Windows 10 64-bit.
Note
OpenEB is the open source version of our code base for the modules Base, Core, Core ML, Driver, UI, and HAL (see Metavision modules organization). If you acquired the full source code of the SDK, OpenEB will also be the basis of your installation, but you should rather follow the installation guide of SDK from source.
If you don’t want to go through some compilation steps, you can download pre-built Ubuntu packages of Metavision Intelligence modules by signing-up for SDK. Once you have downloaded this version, follow our specific installation guide.
Table of Contents
Supported Cameras
OpenEB contains the source code of Prophesee camera plugins, enabling to stream data from our event-based cameras and to read recordings of event-based data. The supported cameras are:
EVK1 - Gen3.1 VGA
EVK2 - Gen4.1 HD
EVK3 - Gen 3.1 VGA / Gen4.1 HD
EVK4 - HD
Requirements
Please note the base system requirements for using Metavision:
Operating system: Windows 10 64-bit
Architecture: amd64 (a.k.a. x64)
Graphic card: must support OpenGL 3.0 minimum
CPU: must support AVX2
For Windows, check the page OpenEB installation on Linux.
Warning
Some steps of this procedure don’t work on FAT32 and exFAT file system. Make sure that you are using a NTFS file system before going further.
Prerequisites
Upgrading Metavision
First of all, read carefully the Release Notes as some changes may impact your usage of our SDK (e.g. API updates) and cameras (e.g. firmware update might be necessary).
Then, if you have previously installed any Prophesee’s software, you will need to uninstall it first.
Remove the folders where you installed Metavision artifacts (check both the build
folder of the source code and
C:\Program Files\Prophesee
which is the default install path of the deployment step).
System Settings
You must enable the support for long paths:
Hit the Windows key, type gpedit.msc and press Enter
Navigate to Local Computer Policy > Computer Configuration > Administrative Templates > System > Filesystem
Double-click the “Enable Win32 long paths” option, select the “Enabled” option and click “OK”
Development tools
To compile OpenEB, you will need to install some extra tools:
install cmake
install Microsoft C++ compiler (64-bit). You can choose one of the following solutions:
For building only, you can install MS Build Tools (free, part of Windows 10 SDK package)
Download and run “Build tools for Visual Studio (2019 or newer)” installer
Select “C++ build tools”, make sure Windows 10 SDK is checked, and add English Language Pack
For development, you can also download and install Visual Studio (2019 or newer))
Installing Dependencies
download and extract vcpkg version 2022.03.10 that will be used for installing dependencies
then in a command prompt, navigate to the directory where vcpkg was extracted (called
VCPKG_SRC_DIR
in following sections) and launch the following command:bootstrap-vcpkg.bat
finally, install the following libraries using vcpkg:
vcpkg.exe install --triplet x64-windows libusb eigen3 boost opencv glfw3 glew gtest dirent
Note
To avoid using –triplet x64-windows, which informs vcpkg to install packages for a x64-windows target, you can run
setx VCPKG_DEFAULT_TRIPLET x64-windows
in a console. Then, you need to close the command line and re-open it to ensure that this variable is set.
FFMPEG library is required to write videos:
Add the
bin
directory to yourPATH
Installing pybind
The Python bindings rely on the pybind11 library (version >= 2.6.0).
You should install pybind using vcpkg in order to get the appropriate version:
vcpkg.exe install --triplet x64-windows pybind11
Note
pybind11 is required only if you plan to use the Python API. You can skip compiling these bindings by passing
the argument -DCOMPILE_PYTHON3_BINDINGS=OFF
during compilation (see step 2 in the section “Compilation using CMake”).
This allows you to skip installing pybind11, but you won’t be able to use our Python interface.
Installing Python
Install Python (version 3.7 or 3.8), if not yet available on your machine:
Download “Windows x86-64 executable installer” for one of these Python versions:
Run the installer and follow the prompt
We advise you to check the box to update the
PATH
or update thePATH
manually with the following paths after replacing the Username to your own and using the Python version you installed (here, we assume that the install is limited to the local user and the default install path was used):C:\Users\Username\AppData\Local\Programs\Python\Python37 C:\Users\Username\AppData\Local\Programs\Python\Python37\Scripts
update pip:
python -m pip install pip --upgrade
To use Machine Learning features, you need to install some additional dependencies.
First, if you have some Nvidia hardware with GPUs, install CUDA (10.2, 11.1 or 11.3) and cuDNN to leverage them with pytorch and libtorch. Make sure that you install a version of CUDA that is compatible with your GPUs by checking Nvidia compatibility page.
Note
At the moment, we don’t support OpenCL and AMD GPUs.
Then, install pytorch. Go to pytorch.org to retrieve the pip command for the installation of PyTorch 1.8.2 LTS:

Then install some extra Python libraries:
python -m pip install "opencv-python>=4.5.5.64" "sk-video==1.1.10" "fire==0.4.0" "numpy<=1.21" pandas scipy numba h5py profilehooks pytest
python -m pip install jupyter jupyterlab matplotlib "ipywidgets==7.6.5"
python -m pip install "pytorch_lightning==1.5.10" "tqdm==4.63.0" "kornia==0.6.1"
Compilation
First, retrieve the source code of OpenEB
git clone https://github.com/prophesee-ai/openeb.git
Compilation using CMake
Open a command prompt inside the extracted openeb
folder (absolute path to this directory is called OPENEB_SRC_DIR in next sections) and follow the steps:
Create and open the build directory where temporary files will be created:
mkdir build && cd build
Generate the makefiles using CMake (note that -DCMAKE_TOOLCHAIN_FILE must be absolute path, not a relative one):
cmake .. -A x64 -DCMAKE_TOOLCHAIN_FILE=<OPENEB_SRC_DIR>\cmake\toolchains\vcpkg.cmake -DVCPKG_DIRECTORY=<VCPKG_SRC_DIR> -DBUILD_TESTING=OFF
Compile:
cmake --build . --config Release --parallel 4
To use Metavision Intelligence directly from the
build
folder, you need to update some environment variables using this script:
utils\scripts\setup_env.bat
Optionally, you can deploy the OpenEB files (applications, samples, libraries etc.) in a directory of your choice.
To do so, configure the target folder (OPENEB_INSTALL_DIR
) with CMAKE_INSTALL_PREFIX
variable.
when generating the makefiles in step 2:
cmake .. -A x64 -DCMAKE_TOOLCHAIN_FILE=<OPENEB_SRC_DIR>\cmake\toolchains\vcpkg.cmake -DVCPKG_DIRECTORY=<VCPKG_SRC_DIR> -DCMAKE_INSTALL_PREFIX=<OPENEB_INSTALL_DIR> -DBUILD_TESTING=OFF
You can also configure the directory where the Python packages will be deployed using the PYTHON3_SITE_PACKAGES
variable
(note that in that case, you will also need to edit your environment variable PYTHONPATH
and append the <PYTHON3_PACKAGES_INSTALL_DIR>
path):
cmake -A x64 -DCMAKE_TOOLCHAIN_FILE=<OPENEB_SRC_DIR>\cmake\toolchains\vcpkg.cmake -DVCPKG_DIRECTORY=<VCPKG_SRC_DIR> -DCMAKE_INSTALL_PREFIX=<OPENEB_INSTALL_DIR> -DPYTHON3_SITE_PACKAGES=<PYTHON3_PACKAGES_INSTALL_DIR> -DBUILD_TESTING=OFF ..
If you did not customize the install folders with the previous commands, the default path will be C:\Program Files\Prophesee
.
you can now launch the actual compilation and installation of the OpenEB files:
Compilation using MS Visual Studio
Open a command prompt inside the extracted openeb
folder and follow the steps:
Create and open the build directory where temporary file will be created:
mkdir build && cd build
Generate the Visual Studio files using CMake (adapt the command to your Visual Studio version):
cmake .. -G "Visual Studio 16 2019" -A x64 -DCMAKE_TOOLCHAIN_FILE=<OPENEB_SRC_DIR>\cmake\toolchains\vcpkg.cmake -DVCPKG_DIRECTORY=<VCPKG_SRC_DIR> -DBUILD_TESTING=OFF
Note
The value passed to the parameter -DCMAKE_TOOLCHAIN_FILE must be an absolute path, not a relative one.
Open the solution file metavision.sln, select the Release configuration and build the ALL_BUILD project.
Note
Since OpenEB 3.0.0, Prophesee camera plugins are included in OpenEB, so you don’t need to perform any extra step to install them. After the compilation described above, you are ready to stream from Prophesee-compatible event-based devices and read RAW files.
Compiling and running tests
Running the test suite is a sure-fire way to ensure you did everything well with your compilation and installation process.
Go to this page to download the files necessary to run the tests. Click the
Download
button on the top right of the page. The obtained archive weighs around 500 Mb.Extract and put the contents of this archive into
<OPENEB_SRC_DIR>/
. For instance, the correct path of sequence gen31_timer.raw should be <OPENEB_SRC_DIR>/datasets/openeb/gen31_timer.raw.To run the test suite you need to reconfigure your build environment using CMake and to recompile.
Compilation using only CMake
Regenerate the build using CMake (note that -DCMAKE_TOOLCHAIN_FILE must be absolute path, not a relative one):
cd <OPENEB_SRC_DIR>/build cmake -A x64 -DCMAKE_TOOLCHAIN_FILE=<OPENEB_SRC_DIR>\cmake\toolchains\vcpkg.cmake -DVCPKG_DIRECTORY=<VCPKG_SRC_DIR> -DBUILD_TESTING=ON ..
Compile:
cmake --build . --config Release --parallel 4
Compilation using CMake and MS Visual Studio
Generate the Visual Studio files using CMake (adapt the command to your Visual Studio version):
cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_TOOLCHAIN_FILE=<OPENEB_SRC_DIR>\cmake\toolchains\vcpkg.cmake -DVCPKG_DIRECTORY=<VCPKG_SRC_DIR> -DBUILD_TESTING=ON ..
Note
The value passed to the parameter -DCMAKE_TOOLCHAIN_FILE must be an absolute path, not a relative one.
Open the solution file metavision.sln, select the Release configuration and build the ALL_BUILD project.
Running the test suite (after making sure you launched the script
utils\scripts\setup_env.bat
mentioned before):ctest -C Release
Get started!
You are now ready to use Metavision Intelligence. The best way to start getting familiar with the event-based technology is to open an event-based camera with Metavision Viewer to begin data collection and visualization. You can choose to dive directly in the SDK by following a Tutorial or looking at a Code Sample.