Having successfully installed opencv 2.0 with python bindings I'm starting to run into trouble and before I go any further I wondered if I should change to another option. As ezod on this post says:
"As a caveat, as of the 2.0 release, the new Python bindings are incomplete: many functions I would consider rather important missing. Meanwhile, the SWIG bindings are nothing short of agonizing to work with. The ctypes-opencv bindings (3rd party project), as of version 0.8.0, do not support OpenCV 2.0."
So, should I soldier on with 2.0 or should I go for ctypes? What am I missing out on either way?
I'm using OSX, python 2.5 and wanting to do tracking in 2d of moving object and neither a python nor machine vision expert!
A late answer. If you do not have to depend on earlier versions, and want to use OpenCV with Python, choose the latest stable version. Today it is OpenCV 2.3.1.
The major benefit of OpenCV ≥ 2.3 for Python users: a new cv2 module in addition to the old (backwards compatible) cv module. New cv2 module is much more pythonic and doesn't require manual memory allocations for intermediate data structures. Old cv module is more like direct translation of the C++ API.
For example, compare the new Python cv2.findContours (OpenCV ≥ 2.3):
findContours(image, mode, method[, contours[, hierarchy[, offset]]]) -> contours, hierarchy
It requires only three parameters, and can handle all memory allocations automatically, returns only the final result. Just one line of the user code.
Vs. the old cv.FindContours:
FindContours(image, storage [, mode [, method [, offset]]]) -> None
It requires the user to explicitly allocate "storage" before the call (+ 1 or 2 lines of code). It doesn't return the result, instead it saves it in the allocated storage (it works like a linked list, and the user has to write some loop to actually extract the data out of storage). Overall, more low-level, and more like C++ than Python. At least 4-5 lines of code in the common use case, instead of just one line with new cv2 module.
I'm using a self-compiled OpenCV 2.0 and it's built-in python binding. Up to now I was missing 2 or 3 functions (e.g. FindFundamentalMat). If you get the source code of OpenCV you find a text file interfaces/python/api that defines the parameter and return types for each OpenCV function that is available from Python. Upon recompilation an automatic generator will parse this file and build the python extension. For all the cases I've been through I found that adding an appropriate definition to the api for the functions I needed, then recompiling opencv, worked quite well.
I'd recommend you use the official Python bindings to OpenCV 2.1 which as far as I've seen has feature parity with the C++ libraries. Most of them have either a pythonic wrapper, or a direct translation from the C++ version.
Python's OpenCV documentation isn't as complete as C++'s, but if you feel that the language advantages for prototyping are worth it, you'll be able to understand the Python usage from the C++ documentation.
Beware that much of the existing example code you'll find is from the previous versions and are incompatible (for example now everything resides under the cv package), but it's not hard to figure out how update it.
Related
I have tried looking around the source code of the Python bindings and haven't been able to find where and how exactly the call is made (where Python connects to C++). I have also searched the web quite a bit, without luck, but it may be that I'm not using the right vocabulary for the search. Using trace in Python was also not as illuminating as I had hoped. Any nudge in the right direction is much appreciated.
Tensorflow used SWIG to do the bindings, but now they are moving into using pybind11.
Inside the code, you can search for PYBIND11_MODULE to find where the new bindings are made. The C++ code compiles to a library file, .so for example on Linux, which can be loaded directly by python.
To learn more about the new and the old method you can check this RFC.
I'm trying to build a minimal Python static library for distribution in an app. This is the C API I need to link to, I believe it may be called CPython as well. I don't need to package actual Python scripts, just link to the library itself.
I've built 3.7.4 by doing:
./configure --disable-shared
make
This does build a library libpython3.7m.a which is 12.4MB. Is it possible to reduce this size at all? I need an absolute barebones distribution without any of the normal packages. Literally this is just for a scripting bridge and doesn't need any of the usual Python functionality.
If you're trying to link to Python's Extension API, you won't find much luck in shaving off size from the libpython shared object. This is because the Extension API uses the same types and headers as the core interpreter (which is why it's called extensions instead of something else like plugins), granting the extensions runtime access to the inner mechanics of the interpreter that normal python scripts wouldn't allow. Basically, the libpython object is just the interpreter compiled without an entry point and an additional frontend so that the expression of simple python operations (e.g. parsing function arguments) stays a clean development experience.
If you're using Python 3.2+, there is offered a "Limited API" for the version of python you are trying to target, but the point of this is to guarantee a stable ABI as the extensions API evolves, not to reduce the size of the compilation unit.
I would also like to mention that the term CPython is just a way to disambiguate the vanilla Python distribution from similar but incompatible interpreters like Pypy.
According to the release docs for OpenCV 3.0.0, it includes an implementation of the Tracking-Detection-Learning algorithm. There's even some very basic docs for the C++ code.
I downloaded and compiled the 3.0.0-beta, including the Python wrapper, and it seems to have succeeded, and although I can run the Python samples, I can't find any way to access and TLD functionality through the Python wrapper. I can't even find references to it in the code.
Is it actually included in the 3.0.0 release, and if so, how do I access it?
From what I find so far there is no instruction, explicitly telling the user how to use TLD. But, you can access TLD tracking modules just by changing the parameter For instance: cv2.Tracker_create("TLD")
For a demo, you can try https://github.com/Itseez/opencv_contrib/blob/master/modules/tracking/samples/tracker.py and change the like cv2.Tracker_create("MIL") to cv2.Tracker_create("TLD")
Note: you must install opencv along with opencv_contrib to make this demo work.
Good Luck
the tld c++ code for opencv3.0 is in the opencv_contrib repo,
unfortunately, atm python or java wrapping is not ready yet.
I'd like to use OpenCV functions, like Hough Transform and Corner Detection, in Sikuli.
I tried the OpenCV installation instructions for CPython on Sikuli and it's a no go.
I understand that Sikuli is Jython and this might be the hard way to do things. What are the easier alternatives?
I'd still like to use Sikuli & Python because the code I write just works; but maybe I'm hitting the limits of Sikuli.
You could use Automa as an alternative to Sikuli. It is a pure Python library (so you can use any other Python library with it) and its image search algorithms are fully compatible with Sikuli. In fact, it uses OpenCV's Python bindings itself, and thus ships with them.
Disclaimer: I'm one of Automa's developers.
Generally spoken: Python modules containing C-based code (which is the case for Python OpenCV) cannot be used in the Sikuli Script (Jython).
The integration of some OpenCV features in Sikuli is realized using the Java-To-C interface (JNI) and the usage of OpenCV features itself is coded in C++.
If you want to use OpenCV features not supported by Sikuli, then you either have to use the above mentioned JNI approach or use the Java implementation of OpenCV (javacv) (Java stuff can be used seamlessly from Jython scripts).
Another option of course is to implement the additional things in plain Python scripts using the Python/OpenCV and call these scripts via the C-Python interpreter in a subprocess.
I'm trying to write some code using OpenCV. My sensor is from Point Grey Systems, and it uses the FlyCapture API to grab images. I'd like to grab those images and do some stuff in OpenCV to them, using Python. FlyCapture is all C/C++, so I'm firing up SWIG to create the bindings. Am I reinventing the wheel? Do python bindings for FlyCapture already exist somewhere that I don't know about?
As of FlyCapture 2.11 there are official Point Grey / FLIR python wrappers. I've used the python 2.7 so far.
the pyflycapture2 is still available as well...
just started using this wrapper last week pyflycapture2
working well so far with my FireFly MV USB
Here's a new Cython wrapper I started for the FlyCapture V1 API:
https://github.com/kbrafford/pyfly1
It also has some wx.Python demos showing it working and allowing you to assess performance.
If the Python language is your only restriction, you may use the wrappers for FlyCapture from the JavaCPP Presets by calling the appropriate functions via Jython.