Install OpenCV 4.2 on Raspberry Pi 4 - Q-engineering
Q-engineering
Q-engineering
Go to content
images/empty-GT_imagea-1-.png
OpenCV on Raspberry Pi

Install OpenCV 4.2.0 on Raspberry Pi 4

Introduction.

This article helps you install OpenCV 4.2.0 on Raspberry Pi 4.
Although written for the Raspberry Pi 4, the guide can also be used without any change for the Raspberry 3 or 2.
Be aware, several versions of C ++ have been released over time. All with little differences and often not fully compatible with previous versions or with the std library. Especially OpenCV, a project with many developers, is sensitive for version diversity. To keep your frustrations to a minimum, use only the most recent version of OpenCV with the most recent compilers. It becomes a whole adventure to install an old OpenCV version on a new Raspbian operating system. Many incompatible template errors have to be solved.
That is why Pythonians love their virtual environment: put all the software and necessary libraries in a separate directory and keep this locked for the future. This technique can result in many identical copies, that is the price to pay.
Operating system.
Use a fast SD memory card for your Raspberry Pi 4. 100MB/s or faster and a capacity of 32 GB is perfect. T
The operating system is installed by NOOBS v3.2.1. It can be downloaded here: https://www.raspberrypi.org/downloads/noobs/
Next, we followed the instructions given by the Raspberry organization: https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up
After successful installing the Raspbian operating system, it is time to update and upgrade your system with the next commands in the terminal.

Terminal

$ sudo apt-get update
$ sudo apt-get upgrade
As explained here, the physical RAM chip is used both by the CPU and the GPU. On a Raspberry Pi 2 or 3 default is 64 Mbyte allocated for the GPU. This can be somewhat small for vision projects. To increase the amount of memory for the GPU, use the following command. On a Raspberry Pi 4, there is 128 Mbyte given to the GPU. It is not necessary to change this at first.
$ sudo raspi-config
Follow the next steps to modify the amount of GPU memory.
After altering the amount to at least 128 the system asks you to reboot, so let's do that.

Cleaning.

The full OpenCV package takes about 5.5 Gbyte on your SD card. Raspbian itself is about 5.4 Gbyte. Time to make some space on your card by simply removing programs you likely not want to use. The most simple and safe way to do this is by the main menu.

Recommended software

We have removed the following software packages: BlueJ, Claws Mail, Greenfoot, LibreOffice, Mathematica, Minecraft, Node-RED, Scratch, Strach2, Sense HAT, SmartSim, and Sonic Pi. This action frees about 2.5 Gbytes. However, leave at any time Mu and Python Games together with Thonny on your system! In the beginning, we deleted them also in the urge for more memory. But somehow too many Python packages are then removed and OpenCV could no longer generate a proper Python library.
Once all the unnecessary packages are removed, two last instructions finish this action.
$ sudo apt-get clean
$ sudo apt-get autoremove

Bad ideas.

Some words of warning. Do not use pip to install OpenCV on your Raspberry Pi. First of all, pip installations don't support C++ due to missing header files. If you want to write code in C++, as we like to do, never use pip. Secondly, at the time of writing (January 2020), the OpenCV 4.1.1 version will be installed by pip. This version depends on an atomic library. Although available, the Raspbian operation system will only use this library when forced to do so. This can be done by the LD_PRELOAD trick. Not a convenient way to have this explicit dependency.
Pip install OpenCV
The same story applies to "sudo apt-get install python3-opencv". The installed version of OpenCV (3.2.0 at the moment) neither supports C++. Another possible pitfall may be the repository. As soon as this ecosystem is updated with a newer version, a simple command like "sudo apt-get upgrade" will automatically install version 4.0.0 or higher which is incompatible with the 3 series. Unless you have isolated your OpenCV in a virtual environment, you are facing some time-consuming repair work on your old projects. On top of this all, and even worse, the installed version is not optimized for the NEON-ARM cores of the Raspberry Pi. So you end up with a library that could be much faster if it was installed manually according to the procedure below.

Sudo install

Dependencies.

The OpenCV software uses other third-party software libraries. These have to be installed first. Perhaps there are already installed, but that doesn't matter. Latest versions are always kept by the installation procedure. Install line for line the next packages.
$ sudo apt-get install build-essential cmake git unzip pkg-config
$ sudo apt-get install libjpeg-dev libpng-dev libtiff-dev
$ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev
$ sudo apt-get install libgtk2.0-dev libcanberra-gtk*
$ sudo apt-get install libxvidcore-dev libx264-dev libgtk-3-dev
$ sudo apt-get install python3-dev python3-numpy python3-pip
$ sudo apt-get install python-dev python-numpy
$ sudo apt-get install libtbb2 libtbb-dev libdc1394-22-dev
$ sudo apt-get install libv4l-dev v4l-utils
$ sudo apt-get install libjasper-dev libopenblas-dev libatlas-base-dev libblas-dev
$ sudo apt-get install liblapack-dev gfortran
$ sudo apt-get install gcc-arm*
$ sudo apt-get install protobuf-compiler

Download OpenCV.

When all third-party software is installed, OpenCV itself can be downloaded. There are two packages needed; the basic version and the additional contributions. Check before downloading the latest version at https://opencv.org/releases/. If necessary, change the names of the zip files according to the latest version. After downloading, you can unzip the files. Please be aware of line wrapping in the text boxes. The two commands are starting with wget and ending with zip.
$ cd ~
$ wget -O opencv.zip https://github.com/opencv/opencv/archive/4.2.0.zip
$ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.2.0.zip

$ unzip opencv.zip
$ unzip opencv_contrib.zip
The next step is some administration. Rename your directories with more convenient names like opencv and opencv_contrib. This makes live later on easier.
$ mv opencv-4.2.0 opencv
$ mv opencv_contrib-4.2.0 opencv_contrib

Virtual environment.

Now it is time to decide whether or not to use a virtual environment for your OpenCV installation. One of the main reasons for applying virtual environments is to protect your projects against incompatibility between package versions. Suppose you have OpenCV 2.4.13 and OpenCV 4.2.0 installed on your Raspberry Pi and you give the command >> import cv2 in Python 3. Which version will Python take? Placing the versions in separate environments is the solution to this problem. Now you can activate one environment with the command workon cv2413, do something with the OpenCV 2.4.13 library, leave environment with deactivate, and enter the OpenCV 4.2.0 environment with workon cv420 for instance.

If you stick to one OpenCV version, as many people do, there is no need for a virtual environment. Neither if you program in C++. In this language you must explicitly tell the compiler where the OpenCV folders with the headers and libraries are located. Obvious, you have installed your versions in unique locations. By the way, a bare OpenCV takes up about 1 Gbyte of space on your SD card.
Another way of dealing with versions is by using different micro-SD cards, each with a complete Raspbian OS and a different OpenCV version. Now you don't have different virtual environments, but separate hardware environments. The price of those micro-SD cards is nowadays certainly no obstacle.

Speaking of SD cards. You can back up an image of your SD card before you upgrade to a newer OpenCV version. If you facing incompatibility issues, you can now quickly return to your previous work. By the way, it's always a good idea to make a complete backup of your SD card now and then. With Win32 Disk Imager it is done in no time.

Win32 Disk Imager

Now it is up to you. If you want to install the virtual environment software, follow the next steps. If not, skip this section and go further here.
Install a virtual environment.
Step one is some administration. We only use Python 3 because the support of Python 2.7 has stopped at the beginning of 2020. You have first to determine your Python 3 version and location. This location must be placed in the (hidden) ~/.bashrc file. The easiest way is a direct injection at the end of the file. You don't have to use an editor like nano or leafpad now.
# get version
$ python3 --version
# get location
$ which python 3.7
# merge VIRTUALENVWRAPPER_PYTHON=location/version
$ echo "export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3.7" >> ~/.bashrc
# reload profile
$ source ~/.bashrc
The Python location in the above commands was /usr/bin/python3.7. This location is passed as an argument in the echo command. The next step is installing the virtual environment software. This can be done with the following commands.
$ sudo pip3 install virtualenv
$ sudo pip3 install virtualenvwrapper
The last step is again some administration in the ~/.bashrc file, followed by a re-activation.
With the command mkvirtualenv, a virtual environment is set up for the OpenCV installation.
$ echo "export WORKON_HOME=$HOME/.virtualenvs" >> ~/.bashrc
$ echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.bashrc
$ source ~/.bashrc
$ mkvirtualenv cv420
Your screen will be something like this.

Virtual environment

There is only one dependency for Python with OpenCV in a virtual environment and that is Numpy. Although you have previously installed this package, you must also install it within the environment, otherwise, CMake cannot compile.
# without sudo!!!!
$ pip3 install numpy

Build Make.

Before we begin with the actual build of the library, there is one small step to go. You have to make a directory where all the build files can be located.
$ cd ~/opencv/
$ mkdir build
$ cd build
Now it is time for an important step. Here you tell CMake what, where and how to make OpenCV on your Raspberry. There are many flags involved. The most you will recognize. We save space by excluding any (Python) examples or tests.
There are only bare spaces before the -D flags, not tabs. Keep also a single space between the -D and the argument. Otherwise, CMake will misinterpreter the command. By the way, the two last dots are no typo. It tells CMake where it can find its CMakeLists.txt (the large recipe file); one directory up.
$ cmake -D CMAKE_BUILD_TYPE=RELEASE \
        -D CMAKE_INSTALL_PREFIX=/usr/local \
        -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib/modules \
        -D ENABLE_NEON=ON \
        -D ENABLE_VFPV3=ON \
        -D WITH_OPENMP=ON \
        -D BUILD_TIFF=ON \
        -D WITH_FFMPEG=ON \
        -D WITH_GSTREAMER=ON \
        -D WITH_TBB=ON \
        -D BUILD_TBB=ON \
        -D BUILD_TESTS=OFF \
        -D WITH_EIGEN=OFF \
        -D WITH_V4L=ON \
        -D WITH_LIBV4L=ON \
        -D WITH_VTK=OFF \
        -D OPENCV_EXTRA_EXE_LINKER_FLAGS=-latomic \
        -D OPENCV_ENABLE_NONFREE=ON \
        -D INSTALL_C_EXAMPLES=OFF \
        -D INSTALL_PYTHON_EXAMPLES=OFF \
        -D BUILD_NEW_PYTHON_SUPPORT=ON \
        -D BUILD_opencv_python3=TRUE \
        -D OPENCV_GENERATE_PKGCONFIG=ON \
        -D BUILD_EXAMPLES=OFF ..
If everything went well, CMake generates a report that looks something like this (for readability purposes we omitted most lines). Very crucial are the Python sections. If these are missing, OpenCV will not install proper Python libraries. In that case, usually CMake could not find the Python folders, or in the case of a virtual environment, a dependency such as numpy is probably not installed within the environment. We are experiencing these issues when removing too many packages from the operating system, as mentioned earlier. NEON and VFPV3 support must also be enabled. Certainly if you intend to build our deep learning examples. Check if v4l/v4l2 is available if your planning to use the Raspicam.
-- General configuration for OpenCV 4.2.0 =====================================
--   Version control:               unknown
--
--   Extra modules:
--     Location (extra):            /home/pi/opencv_contrib/modules
--     Version control (extra):     unknown
--
--   Platform:
--     Timestamp:                   2020-01-06T18:01:01Z
--     Host:                        Linux 4.19.75-v7l+ armv7l
--     CMake:                       3.13.4
--     CMake generator:             Unix Makefiles
--     CMake build tool:            /usr/bin/make
--     Configuration:               RELEASE
--
--   CPU/HW features:
--     Baseline:                    VFPV3 NEON
--       requested:                 DETECT
--       required:                  VFPV3 NEON
--
--   C/C++:
--     Built as dynamic libs?:      YES
--     C++ Compiler:                /usr/bin/c++  (ver 8.3.0)
***********************
--     C Compiler:                  /usr/bin/cc
***********************
--     Documentation:               NO
--     Non-free algorithms:         YES
***********************
--   Video I/O:
--   DC1394:                      YES (2.2.5)
--   FFMPEG:                      YES
--     avcodec:                   YES (58.35.100)
--     avformat:                  YES (58.20.100)
--     avutil:                    YES (56.22.100)
--     swscale:                   YES (5.3.100)
--     avresample:                NO
--   GStreamer:                   NO
--   v4l/v4l2:                    YES (linux/videodev2.h)
***********************
--   Python 2:
--     Interpreter:                 /usr/bin/python2.7 (ver 2.7.16)
--     Libraries:                   /usr/lib/arm-linux-gnueabihf/libpython2.7.so (ver 2.7.16)
--     numpy:                       /usr/lib/python2.7/dist-packages/numpy/core/include (ver 1.16.2)
--     install path:                lib/python2.7/dist-packages/cv2/python-2.7
--
--   Python 3:
--     Interpreter:                 /usr/bin/python3 (ver 3.7.3)
--     Libraries:                   /usr/lib/arm-linux-gnueabihf/libpython3.7m.so (ver 3.7.3)
--     numpy:                       /usr/lib/python3/dist-packages/numpy/core/include (ver 1.16.2)
--     install path:                lib/python3.7/dist-packages/cv2/python-3.7
--
--   Python (for build):            /usr/bin/python2.7
***********************
--   Install to:                    /usr/local
-- -----------------------------------------------------------------
Another issue we came across was the missing of the c++ compiler. CMake generated the screen dump below. By simply giving the Cmake command a second time, the problem was solved. In rare occasions, we had to sudo apt-get update and upgrade the system before CMake could find the c++ compiler.
-- The CXX compiler identification is GNU 8.3.0
-- The C compiler identification is GNU 8.3.0
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- broken
CMake Error at /usr/share/cmake-3.13/Modules/CMakeTestCXXCompiler.cmake:45 (message):
 The C++ compiler

   "/usr/bin/c++"

 is not able to compile a simple test program.
***********************
-- Configuring incomplete, errors occurred!
See also "/home/pi/opencv/build/CMakeFiles/CMakeOutput.log".
See also "/home/pi/opencv/build/CMakeFiles/CMakeError.log".

Before we can start the actual build, the memory swap space needs to be enlarged. For daily use a swap memory of 100 Mbyte is sufficient. However, with the massive build ahead of use, extra memory space is crucial. Enlarge the swap space with the following command.
$ sudo nano /etc/dphys-swapfile
This command opens Nano, a very lightweight text editor, with the system file dphys-swapfile. With the arrow keys, you can move the cursor to the CONF_SWAPSIZE line where the new value 4096 can be entered. Next, close the session with the <Ctrl+X> key combination. With <Y> and <Enter> changes are being saved in the same file.

Two additional commands are required before the new enlarge swap space is active.
$ sudo /etc/init.d/dphys-swapfile stop
$ sudo /etc/init.d/dphys-swapfile start

Make.

Now everything is ready for the great build. This takes a lot of time. Be very patient is the only advice here. Don't be surprised if at 99% your build seems to be crashed. That is 'normal' behaviour. Even when your CPU Usage Monitor gives very low ratings like 7%. In reality, your CPU is working so hard it has not enough time to update these usage numbers correctly.
You can speed things up with four cores working simultaneously (make -j4). On a Raspberry Pi 4, it takes just over an hour to build the whole library. Sometimes the system crashes for no apparent reason at all at 99% or even 100%. In that case, restart all over again, as explained at the end of this page, and rebuild with make -j1.
Probably you get a whole bunch of warnings during the make. Don't pay to much attention to it. They are generated by subtle differences in template overload functions due to little version differences. So take coffee and a good book for reading, and start building with the next command.
$ make -j4
make -j4
Time (HH:MM)
Raspberry Pi 2 (900 MHz - 1 MB)5:15
Raspberry Pi 3 (1400 MHz - 1 MB)
3:30
Raspberry Pi 4 (1500 MHz - 2 MB)
1:05
The times above are indications. No other processes were running like VNC or SSH. The memory swap was 4096 and there was no throttling (automatic lowering of the clock speed to prevent overheating). Hopefully, your build was as successful as the one below.

Successful build

Now to complete, install all the generated packages to the database of your system with the next commands.
$ sudo make install
$ sudo ldconfig
$ sudo apt-get update
There is one thing left to do before the installation of OpenCV 4.1 on your Raspberry Pi 4 is completed. That is resetting the swap space back to its original 100 Mbyte. Flash memory can only write a limited number of cycles. In the end, it will wear your SD card out. It is therefore wise to keep memory swapping to a minimum. Besides, it also slows down your application. The final commands are deleting the now useless zip files and rebooting your system so that all changes are implemented..
$ sudo nano /etc/dphys-swapfile

set CONF_SWAPSIZE=100 with the Nano text editor

$ cd ~
$ rm opencv.zip
$ rm opencv_contrib.zip
$ reboot
If you have installed OpenCV in a virtual environment, you need to make a symbolic link to the library. Without this link, OpenCV will not be found by python and the import fails. You can skip these steps if you have installed OpenCV without a virtual environment.
$ cd ~/.virtualenvs/cv420/lib/python3.7/site-packages
$ ln -s /usr/local/lib/python3.7/site-packages/cv2/python-3.7/cv2.cpython-37m-arm-linux-gnueabihf.so
$ cd ~

Checking.

Now it is time to check your installation in Python. You can use the commands as shown is the screen dump below. It all speaks for itself. Obvious, if you have installed OpenCV in a virtual environment, you need to activate this environment first with the command workon.

Checking OpenCV

In rare occasions, Python can not find the OpenCV package. It comes with the message: “No module named cv2”.



There are many possible reasons, but most likely you started your build with the wrong version number of the library name in the CMake command (libpython3.7m.so). Another common cause is CMake not finding both Python versions. See your CMake rapport for this. You can also take a look at your OpenCV directory and copy the file manually to the correct location.

$ cd ~/opencv/build/lib/python3
$ sudo cp cv2.cpython-37m-arm-linux-gnueabihf.so \
 /usr/local/lib/python3.7/dist-packages/cv2.so
It is always possible to alter some -D switch in CMake and rebuild the package. The already build modules are kept, only the new ones are generated. Of course, in the end, you may be facing still the long wait when everything must be linked into one large Python file. If you want a clean build, remove the complete build directory with all its subdirectories by the single command below. Next, make a new directory with the same name and start all over again.
$ cd ~/opencv
$ rm -r build

Build information.

If you want to know in the future which software modules are included in your OpenCV build, you can always find the answer with the following Python command.
$ python
>>> import cv2
>>> print cv2.getBuildInformation()
Or use the following C++ code example.

						
						#include <opencv2/opencv.hpp>
						 
						int main(void)
						{
						    std::cout << "OpenCV version : " << cv::CV_VERSION << endl;
						    std::cout << "Major version : " << cv::CV_MAJOR_VERSION << endl;
						    std::cout << "Minor version : " << cv::CV_MINOR_VERSION << endl;
						    std::cout << "Subminor version : " << cv::CV_SUBMINOR_VERSION << endl;
						    std::cout << cv::getBuildInformation() << std::endl;
						}
						
						
And you get the next outcome.
General configuration for OpenCV 4.2.0 =====================================
 Version control:               unknown

 Extra modules:
   Location (extra):            /home/pi/opencv_contrib/modules
   Version control (extra):     unknown

 Platform:
   Timestamp:                   2020-01-07T18:01:01Z
   Host:                        Linux 4.19.75-v7l+ armv7l
   CMake:                       3.13.4
   CMake generator:             Unix Makefiles
   CMake build tool:            /usr/bin/make
   Configuration:               RELEASE

 CPU/HW features:
   Baseline:                    VFPV3 NEON
     requested:                 DETECT
     required:                  VFPV3 NEON

 C/C++:
   Built as dynamic libs?:      YES
   C++ Compiler:                /usr/bin/c++  (ver 8.3.0)
   C++ flags (Release):         -fsigned-char -W -Wall -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wundef -Winit-self -Wpointer-arith -Wshadow -Wsign-promo -Wuninitialized -Winit-self -Wsuggest-override -Wno-delete-non-virtual-dtor -Wno-comment -Wimplicit-fallthrough=3 -Wno-strict-overflow -fdiagnostics-show-option -pthread -fomit-frame-pointer -ffunction-sections -fdata-sections  -mfpu=neon -fvisibility=hidden -fvisibility-inlines-hidden -fopenmp -O3 -DNDEBUG  -DNDEBUG
   C++ flags (Debug):           -fsigned-char -W -Wall -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wundef -Winit-self -Wpointer-arith -Wshadow -Wsign-promo -Wuninitialized -Winit-self -Wsuggest-override -Wno-delete-non-virtual-dtor -Wno-comment -Wimplicit-fallthrough=3 -Wno-strict-overflow -fdiagnostics-show-option -pthread -fomit-frame-pointer -ffunction-sections -fdata-sections  -mfpu=neon -fvisibility=hidden -fvisibility-inlines-hidden -fopenmp -g  -O0 -DDEBUG -D_DEBUG
   C Compiler:                  /usr/bin/cc
   C flags (Release):           -fsigned-char -W -Wall -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wundef -Winit-self -Wpointer-arith -Wshadow -Wuninitialized -Winit-self -Wno-comment -Wimplicit-fallthrough=3 -Wno-strict-overflow -fdiagnostics-show-option -pthread -fomit-frame-pointer -ffunction-sections -fdata-sections  -mfpu=neon -fvisibility=hidden -fopenmp -O3 -DNDEBUG  -DNDEBUG
   C flags (Debug):             -fsigned-char -W -Wall -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wundef -Winit-self -Wpointer-arith -Wshadow -Wuninitialized -Winit-self -Wno-comment -Wimplicit-fallthrough=3 -Wno-strict-overflow -fdiagnostics-show-option -pthread -fomit-frame-pointer -ffunction-sections -fdata-sections  -mfpu=neon -fvisibility=hidden -fopenmp -g  -O0 -DDEBUG -D_DEBUG
   Linker flags (Release):      -Wl,--gc-sections  
   Linker flags (Debug):        -Wl,--gc-sections  
   ccache:                      NO
   Precompiled headers:         NO
   Extra dependencies:          atomic dl m pthread rt
   3rdparty dependencies:

 OpenCV modules:
   To be built:                 aruco bgsegm bioinspired calib3d ccalib core datasets dnn dnn_objdetect dnn_superres dpm face features2d flann freetype fuzzy gapi hfs highgui img_hash imgcodecs imgproc line_descriptor ml objdetect optflow phase_unwrapping photo plot python2 python3 quality reg rgbd saliency shape stereo stitching structured_light superres surface_matching text tracking ts video videoio videostab xfeatures2d ximgproc xobjdetect xphoto
   Disabled:                    world
   Disabled by dependency:      -
   Unavailable:                 cnn_3dobj cudaarithm cudabgsegm cudacodec cudafeatures2d cudafilters cudaimgproc cudalegacy cudaobjdetect cudaoptflow cudastereo cudawarping cudev cvv hdf java js matlab ovis sfm viz
   Applications:                perf_tests apps
   Documentation:               NO
   Non-free algorithms:         YES

 GUI:
   GTK+:                        YES (ver 3.24.5)
     GThread :                  YES (ver 2.58.3)
     GtkGlExt:                  NO

 Media I/O:
   ZLib:                        /usr/lib/arm-linux-gnueabihf/libz.so (ver 1.2.11)
   JPEG:                        /usr/lib/arm-linux-gnueabihf/libjpeg.so (ver 62)
   WEBP:                        build (ver encoder: 0x020e)
   PNG:                         /usr/lib/arm-linux-gnueabihf/libpng.so (ver 1.6.36)
   TIFF:                        build (ver 42 - 4.0.10)
   JPEG 2000:                   /usr/lib/arm-linux-gnueabihf/libjasper.so (ver 1.900.1)
   OpenEXR:                     build (ver 2.3.0)
   HDR:                         YES
   SUNRASTER:                   YES
   PXM:                         YES
   PFM:                         YES

 Video I/O:
   DC1394:                      YES (2.2.5)
   FFMPEG:                      YES
     avcodec:                   YES (58.35.100)
     avformat:                  YES (58.20.100)
     avutil:                    YES (56.22.100)
     swscale:                   YES (5.3.100)
     avresample:                NO
   GStreamer:                   NO
   v4l/v4l2:                    YES (linux/videodev2.h)

 Parallel framework:            TBB (ver 2020.0 interface 11100)

 Trace:                         YES (with Intel ITT)

 Other third-party libraries:
   Lapack:                      NO
   Custom HAL:                  YES (carotene (ver 0.0.1))
   Protobuf:                    build (3.5.1)

 OpenCL:                        YES (no extra features)
   Include path:                /home/pi/opencv/3rdparty/include/opencl/1.2
   Link libraries:              Dynamic load

 Python 2:
   Interpreter:                 /usr/bin/python2.7 (ver 2.7.16)
   Libraries:                   /usr/lib/arm-linux-gnueabihf/libpython2.7.so (ver 2.7.16)
   numpy:                       /usr/lib/python2.7/dist-packages/numpy/core/include (ver 1.16.2)
   install path:                lib/python2.7/dist-packages/cv2/python-2.7

 Python 3:
   Interpreter:                 /usr/bin/python3 (ver 3.7.3)
   Libraries:                   /usr/lib/arm-linux-gnueabihf/libpython3.7m.so (ver 3.7.3)
   numpy:                       /usr/lib/python3/dist-packages/numpy/core/include (ver 1.16.2)
   install path:                lib/python3.7/dist-packages/cv2/python-3.7

 Python (for build):            /usr/bin/python2.7

 Java:                          
   ant:                         NO
   JNI:                         NO
   Java wrappers:               NO
   Java tests:                  NO

 Install to:                    /usr/local
-----------------------------------------------------------------

Camera OpenCV C++ examples
Deep learning OpenCV C++ examples
Raspberry and alt
Info
Raspberry Pi 4
Back to content