Does performance differ between Python or C++ coding of OpenCV?

As mentioned in earlier answers, Python is slower compared to C++ or C. Python is built for its simplicity, portability and moreover, creativity where users need to worry only about their algorithm, not programming troubles.

But here in OpenCV, there is something different. Python-OpenCV is just a wrapper around the original C/C++ code. It is normally used for combining best features of both the languages, Performance of C/C++ & Simplicity of Python.

So when you call a function in OpenCV from Python, what actually run is underlying C/C++ source. So there won't be much difference in performance.( I remember I read somewhere that performance penalty is <1%, don't remember where. A rough estimate with some basic functions in OpenCV shows a worst-case penalty of <4%. ie penalty = [maximum time taken in Python - minimum time taken in C++]/minimum time taken in C++ ).

The problem arises when your code has a lot of native python codes.For eg, if you are making your own functions that are not available in OpenCV, things get worse. Such codes are ran natively in Python, which reduces the performance considerably.

But new OpenCV-Python interface has full support to Numpy. Numpy is a package for scientific computing in Python. It is also a wrapper around native C code. It is a highly optimized library which supports a wide variety of matrix operations, highly suitable for image processing. So if you can combine both OpenCV functions and Numpy functions correctly, you will get a very high speed code.

Thing to remember is, always try to avoid loops and iterations in Python. Instead, use array manipulation facilities available in Numpy (and OpenCV). Simply adding two numpy arrays using C = A+B is a lot times faster than using double loops.

For eg, you can check these articles :

1. Fast Array Manipulation in Python
2. Performance comparison of OpenCV-Python interfaces, cv and cv2

All google results for openCV state the same: that python will only be slightly slower. But not once have I seen any profiling on that. So I decided to do some and discovered:

Python is significantly slower than C++ with opencv, even for trivial programs.

The most simple example I could think of was to display the output of a webcam on-screen and display the number of frames per second. With python, I achieved 50FPS (on an Intel atom). With C++, I got 65FPS, an increase of 25%. In both cases, the CPU usage was using a single core, and to the best of my knowledge, was bound by the performance of the CPU. Additionally this test case about aligns with what I have seen in projects I've ported from one to the other in the past.

Where does this difference come from? In python, all of the openCV functions return new copies of the image matrices. Whenever you capture an image, or if you resize it - in C++ you can re-use existing memory. In python you cannot. I suspect this time spent allocating memory is the major difference, because as others have said: the underlying code of openCV is C++.

Before you throw python out the window: python is much faster to develop in, and if long as you aren't running into hardware-constraints, or if development speed it more important than performance, then use python. In many applications I've done with openCV, I've started in python and later converted only the computer vision components to C++ (eg using python's ctype module and compiling the CV code into a shared library).

Python Code:

import cv2import timeFPS_SMOOTHING = 0.9cap = cv2.VideoCapture(2)fps = 0.0prev = time.time()while True:    now = time.time()    fps = (fps*FPS_SMOOTHING + (1/(now - prev))*(1.0 - FPS_SMOOTHING))    prev = now    print("fps: {:.1f}".format(fps))    got, frame = cap.read()    if got:        cv2.imshow("asdf", frame)    if (cv2.waitKey(2) == 27):        break

C++ Code:

#include <opencv2/opencv.hpp>#include <stdint.h>using namespace std;using namespace cv;#define FPS_SMOOTHING 0.9int main(int argc, char** argv){    VideoCapture cap(2);    Mat frame;    float fps = 0.0;    double prev = clock();     while (true){        double now = (clock()/(double)CLOCKS_PER_SEC);        fps = (fps*FPS_SMOOTHING + (1/(now - prev))*(1.0 - FPS_SMOOTHING));        prev = now;        printf("fps: %.1f\n", fps);        if (cap.isOpened()){            cap.read(frame);        }        imshow("asdf", frame);        if (waitKey(2) == 27){            break;        }    }}

Possible benchmark limitations:

• Camera frame rate
• Timer measuring precision
• Time spent in print formatting

The answer from sdfgeoff is missing the fact that you can reuse arrays in Python. Preallocate them and pass them in, and they will get used. So:

    image = numpy.zeros(shape=(height, width, 3), dtype=numpy.uint8)    #....    retval, _ = cv.VideoCapture.read(image)