67,19 €
Mehr erfahren.
- Herausgeber: Packt Publishing
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Englisch
Get savvy with OpenCV and actualize cool computer vision applications
About This Book
- Use OpenCV's Python bindings to capture video, manipulate images, and track objects
- Learn about the different functions of OpenCV and their actual implementations.
- Develop a series of intermediate to advanced projects using OpenCV and Python
Who This Book Is For
This learning path is for someone who has a working knowledge of Python and wants to try out OpenCV. This Learning Path will take you from a beginner to an expert in computer vision applications using OpenCV. OpenCV's application are humongous and this Learning Path is the best resource to get yourself acquainted thoroughly with OpenCV.
What You Will Learn
- Install OpenCV and related software such as Python, NumPy, SciPy, OpenNI, and SensorKinect - all on Windows, Mac or Ubuntu
- Apply "curves" and other color transformations to simulate the look of old photos, movies, or video games
- Apply geometric transformations to images, perform image filtering, and convert an image into a cartoon-like image
- Recognize hand gestures in real time and perform hand-shape analysis based on the output of a Microsoft Kinect sensor
- Reconstruct a 3D real-world scene from 2D camera motion and common camera reprojection techniques
- Detect and recognize street signs using a cascade classifier and support vector machines (SVMs)
- Identify emotional expressions in human faces using convolutional neural networks (CNNs) and SVMs
- Strengthen your OpenCV2 skills and learn how to use new OpenCV3 features
In Detail
OpenCV is a state-of-art computer vision library that allows a great variety of image and video processing operations. OpenCV for Python enables us to run computer vision algorithms in real time. This learning path proposes to teach the following topics. First, we will learn how to get started with OpenCV and OpenCV3's Python API, and develop a computer vision application that tracks body parts. Then, we will build amazing intermediate-level computer vision applications such as making an object disappear from an image, identifying different shapes, reconstructing a 3D map from images , and building an augmented reality application, Finally, we'll move to more advanced projects such as hand gesture recognition, tracking visually salient objects, as well as recognizing traffic signs and emotions on faces using support vector machines and multi-layer perceptrons respectively.
This Learning Path combines some of the best that Packt has to offer in one complete, curated package. It includes content from the following Packt products:
- OpenCV Computer Vision with Python by Joseph Howse
- OpenCV with Python By Example by Prateek Joshi
- OpenCV with Python Blueprints by Michael Beyeler
Style and approach
This course aims to create a smooth learning path that will teach you how to get started with will learn how to get started with OpenCV and OpenCV 3's Python API, and develop superb computer vision applications. Through this comprehensive course, you'll learn to create computer vision applications from scratch to finish and more!.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 571
Veröffentlichungsjahr: 2016
Ähnliche
Table of Contents
OpenCV: Computer Vision Projects with Python
OpenCV: Computer Vision Projects with Python
Get savvy with OpenCV and actualize cool computer vision applications
A course in three modules
BIRMINGHAM - MUMBAI
OpenCV: Computer Vision Projects with Python
Copyright © 2016 Packt Publishing
All rights reserved. No part of this course may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this course to ensure the accuracy of the information presented. However, the information contained in this course is sold without warranty, either express or implied. Neither the authors, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this course.
Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this course by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
Published on: October 2016
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham B3 2PB, UK.
ISBN 978-1-78712-549-0
www.packtpub.com
Credits
Authors
Joseph Howse
Prateek Joshi
Michael Beyeler
Reviewers
David Millán Escrivá
Abid K.
Will Brennan
Gabriel Garrido Calvo
Pavan Kumar Pavagada Nagaraja
Marvin Smith
Jia-Shen Boon
Florian LE BOURDAIS
Steve Goldsmith
Rahul Kavi
Scott Lobdell
Vipul Sharma
Content Development Editor
Mayur Pawanikar
Production Coordinator
Nilesh Mohite
Preface
OpenCV is an open-source, cross-platform library that provides building blocks for computer vision experiments and applications. It provides high-level interfaces for capturing, processing, and presenting image data. For example, it abstracts details about camera hardware and array allocation. OpenCV is widely used in both academia and industry. Today, computer vision can reach consumers in many contexts via webcams, camera phones, and gaming sensors such as the Kinect. For better or worse, people love to be on camera, and as developers, we face a demand for applications that capture images, change their appearance, and extract information from them. OpenCV's Python bindings can help us explore solutions to these requirements in a high-level language and in a standardized data format that is interoperable with scientific libraries such as NumPy and SciPy.
Computer vision is found everywhere in modern technology. OpenCV for Python enables us to run computer vision algorithms in real time. With the advent of powerful machines, we are getting more processing power to work with. Using this technology, we can seamlessly integrate our computer vision applications into the cloud. Web developers can develop complex applications without having to reinvent the wheel.
This course is specifically designed to teach the following topics. First, we will learn how to get started with OpenCV and OpenCV 3's Python API, and develop a computer vision application that tracks body parts. Then, we will build amazing intermediate-level computer vision applications such as making an object disappear from an image, identifying different shapes, reconstructing a 3D map from images, and building an augmented reality application. Finally, we'll move to more advanced projects such as hand gesture recognition, tracking visually salient objects, as well as recognizing traffic signs and emotions on faces using support vector machines and multi-layer perceptron respectively.
What this learning path covers
Module 1, OpenCV Computer Vision with Python, in this module you can have a development environment that links Python, OpenCV, depth camera libraries (OpenNI, SensorKinect), and general-purpose scientific libraries (NumPy, SciPy).
Module 2, OpenCV with Python By Example, this module covers various examples at different levels, teaching you about the different functions of OpenCV, and their actual implementations.
Module 3, OpenCV with Python Blueprints, this module intends to give the tools, knowledge, and skills you need to be OpenCV experts and this newly gained experience will allow you to develop your own advanced computer vision applications.
What you need for this learning path
This course provides setup instructions for all the relevant software, including package managers, build tools, Python, NumPy, SciPy, OpenCV, OpenNI, and SensorKinect. The setup instructions are tailored for Windows XP or later versions, Mac OS 10.6 (Snow Leopard) or later versions, and Ubuntu 12.04 or later versions. Other Unix-like operating systems should work too if you are willing to do your own tailoring of the setup steps. You need a webcam for the projects described in the course. For additional features, some variants of the project use a second webcam or even an OpenNI-compatible depth camera such as Microsoft Kinect or Asus Xtion PRO.
The hardware requirement being a webcam (or camera device), except for Chapter 2, Hand Gesture Recognition Using a Kinect Depth Sensor , of the 3rd Module which instead requires access to a Microsoft Kinect 3D Sensor or an Asus Xtion.
The course contains projects with the following requirements.
All projects can run on any of Windows, Mac, or Linux, and they require the following software packages:
wxPython 2.8 or later: This GUI programming toolkit can be obtained from http://www.wxpython.org/download.php. Its installation instructions are given at http://wxpython.org/builddoc.php.
In addition, some chapters require the following free Python modules:
Furthermore, the use of iPython (http://ipython.org/install.html) is highly recommended as it provides a flexible, interactive console interface.
Finally, if you are looking for help or get stuck along the way, you can go for several websites that provide excellent help, documentation, and tutorials:
The official OpenCV forum: http://www.answers.opencv.org/questions
OpenCV-Python tutorials by Alexander Mordvintsev and Abid Rahman K: http://opencv-python-tutroals.readthedocs.org/en/latest
Who this learning path is for
This Learning Path is for someone who has a working knowledge of Python and wants to try out OpenCV. This Learning Path will take you from a beginner to an expert in computer vision applications using OpenCV.
OpenCV's applications are humongous and this Learning Path is the best resource to get yourself acquainted thoroughly with OpenCV.
Reader feedback
Feedback from our readers is always welcome. Let us know what you think about this course—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.
To send us general feedback, simply e-mail <[email protected]>, and mention the course's title in the subject of your message.
If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.
Customer support
Now that you are the proud owner of a Packt course, we have a number of things to help you to get the most from your purchase.
Downloading the example code
You can download the example code files for this course from your account at http://www.packtpub.com. If you purchased this course elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.
You can download the code files by following these steps:
You can also download the code files by clicking on the Code Files button on the course's webpage at the Packt Publishing website. This page can be accessed by entering the course's name in the Search box. Please note that you need to be logged in to your Packt account.
Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:
The code bundle for the course is also hosted on GitHub at https://github.com/PacktPublishing/OpenCV-Computer-Vision-Projects-with-Python. We also have other code bundles from our rich catalog of books, videos, and courses available at https://github.com/PacktPublishing/. Check them out!
Errata
Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our courses—maybe a mistake in the text or the code—we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this course. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your course, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.
To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the course in the search field. The required information will appear under the Errata section.
Piracy
Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.
Please contact us at <[email protected]> with a link to the suspected pirated material.
We appreciate your help in protecting our authors and our ability to bring you valuable content.
Questions
If you have a problem with any aspect of this course, you can contact us at <[email protected]>, and we will do our best to address the problem.
Part 1. Module 1
OpenCV Computer Vision with Python
Learn to capture videos, manipulate images, and track objects with Python using the OpenCV Library
Chapter 1. Setting up OpenCV
This chapter is a quick guide to setting up Python 2.7, OpenCV, and related libraries. After setup, we also look at OpenCV's Python sample scripts and documentation.
The following related libraries are covered:
For this book's purposes, OpenNI and SensorKinect can be considered optional. They are used throughout Chapter 5, Separating Foreground/Background Regions Depth, but are not used in the other chapters or appendices.
At the time of writing, OpenCV 2.4.3 is the latest version. On some operating systems, it is easier to set up an earlier version (2.3.1). The differences between these versions should not affect the project that we are going to build in this book.
Some additional information, particularly about OpenCV's build options and their dependencies, is available in the OpenCV wiki at http://opencv.willowgarage.com/wiki/InstallGuide. However, at the time of writing, the wiki is not up-to-date with OpenCV 2.4.3.
Choosing and using the right setup tools
We are free to choose among various setup tools, depending on our operating system and how much configuration we want to do. Let's take an overview of the tools for Windows, Mac, Ubuntu, and other Unix-like systems.
Making the choice on Windows XP, Windows Vista, Windows 7, or Windows 8
Windows does not come with Python preinstalled. However, installation wizards are available for precompiled Python, NumPy, SciPy, and OpenCV. Alternatively, we can build from source. OpenCV's build system uses CMake for configuration and either Visual Studio or MinGW for compilation.
If we want support for depth cameras including Kinect, we should first install OpenNI and SensorKinect, which are available as precompiled binaries with installation wizards. Then, we must build OpenCV from source.
Note
The precompiled version of OpenCV does not offer support for depth cameras.
On Windows, OpenCV offers better support for 32-bit Python than 64-bit Python. Even if we are building from source, I recommend using 32-bit Python. Fortunately, 32-bit Python works fine on either 32-bit or 64-bit editions of Windows.
Note
Some of the following steps refer to editing the system's Path variable. This task can be done in the Environment Variables window of Control Panel.
On Windows Vista/Windows 7/Windows 8, open the Start menu and launch Control Panel. Now, go to System and Security | System | Advanced system settings. Click on the Environment Variables button.
On Windows XP, open the Start menu and go to Control Panel | System. Select the Advanced tab. Click on the Environment Variables button.
Now, under System variables, select Path and click on the Edit button. Make changes as directed. To apply the changes, click on all the OK buttons (until we are back in the main window of Control Panel). Then, log out and log back in (alternatively, reboot).
Using binary installers (no support for depth cameras)
Here are the steps to set up 32-bit Python 2.7, NumPy, and OpenCV:
Using CMake and compilers
Windows does not come with any compilers or CMake. We need to install them. If we want support for depth cameras, including Kinect, we also need to install OpenNI and SensorKinect.
Let's assume that we have already installed 32-bit Python 2.7, NumPy, and SciPy either from binaries (as described previously) or from source. Now, we can proceed with installing compilers and CMake, optionally installing OpenNI and SensorKinect, and then building OpenCV from source:
For Microsoft Visual Studio 2010, use any installation media you purchased. During installation, include any optional C++ components. Reboot after installation is complete.
For Microsoft Visual C++ Express 2010, get the installer from http://www.microsoft.com/visualstudio/eng/downloads. Reboot after installation is complete.
For MinGW get the installer from http://sourceforge.net/projects/mingw/files/Installer/mingw-get-inst/mingw-get-inst-20120426/mingw-get-inst-20120426.exe/download. When running the installer, make sure that the destination path does not contain spaces and that the optional C++ compiler is included. Edit the system's Path variable and append ;C:\MinGW\bin (assuming MinGW is installed to the default location.) Reboot the system.
Optionally, download and install OpenNI 1.5.4.0 from http://www.openni.org/wp-content/uploads/2012/12/OpenNI-Win32-1.5.4.0-Dev1.zip (32 bit). Alternatively, for 64-bit Python, use http://www.openni.org/wp-content/uploads/2012/12/OpenNI-Win64-1.5.4.0-Dev.zip (64 bit).Optionally, download and install SensorKinect 0.93 from https://github.com/avin2/SensorKinect/blob/unstable/Bin/SensorKinect093-Bin-Win32-v5.1.2.1.msi?raw=true (32 bit). Alternatively, for 64-bit Python, use https://github.com/avin2/SensorKinect/blob/unstable/Bin/SensorKinect093-Bin-Win64-v5.1.2.1.msi?raw=true (64 bit).Download the self-extracting ZIP of OpenCV 2.4.3 from http://sourceforge.net/projects/opencvlibrary/files/opencv-win/2.4.3/OpenCV-2.4.3.exe/download. Run the self-extracting ZIP and, when prompted, enter any destination folder, which we will refer to as <unzip_destination>. A subfolder, <unzip_destination>\opencv, is created.Open Command Prompt and make another folder where our build will go:Change directory to the build folder:
For Visual Studio 2010 or Visual C++ Express 2010, run:
Alternatively, for MinGW, run:
If OpenNI is not installed, omit -D:WITH_OPENNI=ON. (In this case, depth cameras will not be supported.) If OpenNI and SensorKinect are installed to non-default locations, modify the command to include -D:OPENNI_LIB_DIR=<openni_install_destination>\Lib -D:OPENNI_INCLUDE_DIR=<openni_install_destination>\Include -D:OPENNI_PRIME_SENSOR_MODULE_BIN_DIR=<sensorkinect_install_destination>\Sensor\Bin.
CMake might report that it has failed to find some dependencies. Many of OpenCV's dependencies are optional; so, do not be too concerned yet. If the build fails to complete or you run into problems later, try installing missing dependencies (often available as prebuilt binaries) and then rebuild OpenCV from this step.
Having configured our build system, we are ready to compile.For Visual Studio or Visual C++ Express, open <build_folder>/OpenCV.sln. Select Release configuration and build. If you get build errors, double-check that Release configuration is selected.
Alternatively, for MinGW, run:
Making the choice on Mac OS X Snow Leopard, Mac OS X Lion, or Mac OS X Mountain Lion
Some versions of Mac come with Python 2.7 preinstalled. However, the preinstalled Python is customized by Apple for the system's internal needs. Normally, we should not install any libraries atop Apple's Python. If we do, our libraries might break during system updates or, worse, might conflict with preinstalled libraries that the system requires. Instead, we should install standard Python 2.7 and then install our libraries atop it.
For Mac, there are several possible approaches to obtaining standard Python 2.7, NumPy, SciPy, and OpenCV. All approaches ultimately require OpenCV to be compiled from source using Xcode Developer Tools. However, depending on the approach, this task is automated for us by third-party tools in various ways. We will look at approaches using MacPorts or Homebrew. These tools can potentially do everything that CMake can do, plus they help us resolve dependencies and separate our development libraries from the system libraries.
Tip
I recommend MacPorts, especially if you want to compile OpenCV with depth camera support via OpenNI and SensorKinect. Relevant patches and build scripts, including some that I maintain, are ready-made for MacPorts. By contrast, Homebrew does not currently provide a ready-made solution for compiling OpenCV with depth camera support.
Before proceeding, let's make sure that the Xcode Developer Tools are properly set up:
Now we have the required compilers for any approach.
Using MacPorts with ready-made packages
We can use the MacPorts package manager to help us set up Python 2.7, NumPy, and OpenCV. MacPorts provides Terminal commands that automate the process of downloading, compiling, and installing various pieces of open source software (OSS). MacPorts also installs dependencies as needed. For each piece of software, the dependencies and build recipe are defined in a configuration file called a Portfile. A MacPorts repository is a collection of Portfiles.
Starting from a system where Xcode and its Command Line Tools are already set up, the following steps will give us an OpenCV installation via MacPorts:
Save the file. Now, MacPorts knows to search for Portfiles in my online repository first and, then, the default online repository.
Open Terminal and run the following command to update MacPorts:When prompted, enter your password.
Now (if we are using my repository), run the following command to install OpenCV with Python 2.7 bindings and support for depth cameras including Kinect:Alternatively (with or without my repository), run the following command to install OpenCV with Python 2.7 bindings and support for depth cameras excluding Kinect:
Dependencies, including Python 2.7, NumPy, OpenNI, and (in the first example) SensorKinect, are automatically installed as well.
By adding +python27 to the command, we are specifying that we want the opencv variant (build configuration) with Python 2.7 bindings. Similarly, +openni_sensorkinect specifies the variant with the broadest possible support for depth cameras via OpenNI and SensorKinect. You may omit +openni_sensorkinect if you do not intend to use depth cameras or you may replace it with +openni if you do intend to use OpenNI-compatible depth cameras but just not Kinect. To see the full list of available variants before installing, we can enter:
Depending on our customization needs, we can add other variants to the install command. For even more flexibility, we can write our own variants (as described in the next section).
Also, run the following command to install SciPy:Using MacPorts with your own custom packages
With a few extra steps, we can change the way that MacPorts compiles OpenCV or any other piece of software. As previously mentioned, MacPorts' build recipes are defined in configuration files called Portfiles. By creating or editing Portfiles, we can access highly configurable build tools, such as CMake, while also benefitting from MacPorts' features, such as dependency resolution.
Let's assume that we already have MacPorts installed. Now, we can configure MacPorts to use custom Portfiles that we write:
For example, if <local_repository> is /Users/Joe/Portfiles, add:
Note the triple slashes.
Save the file. Now, MacPorts knows to search for Portfiles in <local_repository> first and, then, its default online repository.
Open Terminal and update MacPorts to ensure that we have the latest Portfiles from the default repository:Alternatively, for an example that includes Kinect support, we could download my online repository from http://nummist.com/opencv/ports.tar.gz, unzip it and copy its entire graphics folder into <local_repository>:
To see which CMake configuration flags are relevant to OpenCV, we need to look at its source code. Download the source code archive from http://sourceforge.net/projects/opencvlibrary/files/opencv-unix/2.4.3/OpenCV-2.4.3.tar.bz2/download, unzip it to any location, and read <unzip_destination>/OpenCV-2.4.3/CMakeLists.txt.
After making any edits to the Portfile, save it.
Now, we need to generate an index file in our local repository so that MacPorts can find the new Portfile:Note that our local repository's Portfile takes precedence over the default repository's Portfile because of the order in which they are listed in /opt/local/etc/macports/sources.conf.
Using Homebrew with ready-made packages (no support for depth cameras)
Homebrew is another package manager that can help us. Normally, MacPorts and Homebrew should not be installed on the same machine.
Starting from a system where Xcode and its Command Line Tools are already set up, the following steps will give us an OpenCV installation via Homebrew:
Save the file and run this command to refresh PATH:
Note that executables installed by Homebrew now take precedence over executables installed by the system.
For Homebrew's self-diagnostic report, run:Follow any troubleshooting advice it gives.
Now, update Homebrew:Now, we can install SciPy:
Alternatively, to install OpenCV on a 32-bit system, run:
Tip
Downloading the example code
You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.
Using Homebrew with your own custom packages
Homebrew makes it easy to edit existing package definitions:
The package definitions are actually scripts in the Ruby programming language. Tips on editing them can be found in the Homebrew wiki at https://github.com/mxcl/homebrew/wiki/Formula-Cookbook. A script may specify Make or CMake configuration flags, among other things.
To see which CMake configuration flags are relevant to OpenCV, we need to look at its source code. Download the source code archive from http://sourceforge.net/projects/opencvlibrary/files/opencv-unix/2.4.3/OpenCV-2.4.3.tar.bz2/download, unzip it to any location, and read <unzip_destination>/OpenCV-2.4.3/CMakeLists.txt.
After making any edits to the Ruby script, save it.
The customized package can be treated as normal. For example, it can be installed as follows:
Making the choice on Ubuntu 12.04 LTS or Ubuntu 12.10
Ubuntu comes with Python 2.7 preinstalled. The standard Ubuntu repository contains OpenCV 2.3.1 packages without support for depth cameras. Alternatively, OpenCV 2.4.3 can be built from source using CMake and GCC. When built from source, OpenCV can support depth cameras via OpenNI and SensorKinect, which are available as precompiled binaries with installation scripts.
Using the Ubuntu repository (no support for depth cameras)
We can install OpenCV 2.3.1 and its dependencies using the Apt package manager:
Enter Y whenever prompted about package installation.
Equivalently, we could have used Ubuntu Software Center, which is Apt's graphical frontend.
Using CMake via a ready-made script that you may customize
Ubuntu comes with the GCC compilers preinstalled. However, we need to install the CMake build system. We also need to install or reinstall various other libraries, some of which need to be specially configured for compatibility with OpenCV. Because the dependencies are complex, I have written a script that downloads, configures, and builds OpenCV and related libraries so that the resulting OpenCV installation has support for depth cameras including Kinect:
After making any edits to the script, save it.
Open Terminal and run this command to update Apt:Set the script's permissions so that it is executable:
Execute the script:
When prompted, enter your password. Enter Y whenever prompted about package installation.
The installation script creates a folder, <script_folder>/opencv, which contains downloads and built files that are temporarily used by the script. After the installation script terminates, <script_folder>/opencv may safely be deleted; although, first, you might want to look at OpenCV's Python samples in <script_folder>/opencv/samples/python and <script_folder>/opencv/samples/python2.Making the choice on other Unix-like systems
The approaches for Ubuntu (as described previously) are likely to work on any Linux distribution derived from Ubuntu 12.04 LTS or Ubuntu 12.10, such as:
On Debian Linux and its derivatives, the Apt package manager works the same as on Ubuntu, though the available packages may differ.
On Gentoo Linux and its derivatives, the Portage package manager is similar to MacPorts (as described previously), though the available packages may differ.
On other Unix-like systems, the package manager and available packages may differ. Consult your package manager's documentation and search for any packages with opencv in their names. Remember that OpenCV and its Python bindings might be split into multiple packages.
Also, look for any installation notes published by the system provider, the repository maintainer, or the community. Because OpenCV uses camera drivers and media codecs, getting all of its functionality to work can be tricky on systems with poor multimedia support. Under some circumstances, system packages might need to be reconfigured or reinstalled for compatibility.
If packages are available for OpenCV, check their version number. OpenCV 2.3.1 or greater is recommended for this book's purposes. Also check whether the packages offer Python bindings and whether they offer depth camera support via OpenNI and SensorKinect. Finally, check whether anyone in the developer community has reported success or failure in using the packages.
If instead we want to do a custom build of OpenCV from source, it might be helpful to refer to the installation script for Ubuntu (discussed previously) and adapt it to the package manager and packages that are present on another system.
Running samples
Running a few sample scripts is a good way to test that OpenCV is correctly set up. The samples are included in OpenCV's source code archive.
On Windows, we should have already downloaded and unzipped OpenCV's self-extracting ZIP. Find the samples in <unzip_destination>/opencv/samples.
On Unix-like systems, including Mac, download the source code archive from http://sourceforge.net/projects/opencvlibrary/files/opencv-unix/2.4.3/OpenCV-2.4.3.tar.bz2/download and unzip it to any location (if we have not already done so). Find the samples in <unzip_destination>/OpenCV-2.4.3/samples.
Some of the sample scripts require command-line arguments. However, the following scripts (among others) should work without any arguments:
To exit a script, press Esc (not the window's close button).
If we encounter the message, ImportError: No module named cv2.cv, then we are running the script from a Python installation that does not know anything about OpenCV. There are two possible explanations:
You can also use the following command:
As another possible means of selecting a different Python installation, try editing the sample script to remove #! lines. These lines might explicitly associate the script with the wrong Python installation (for our particular setup).
Finding documentation, help, and updates
OpenCV's documentation is online at http://docs.opencv.org/. The documentation includes a combined API reference for OpenCV's new C++ API, its new Python API (which is based on the C++ API), its old C API, and its old Python API (which is based on the C API). When looking up a class or function, be sure to read the section about the new Python API (cv2 module), not the old Python API (cv module).
Note
The documentation entitled OpenCV 2.1 Python Reference (http://opencv.willowgarage.com/documentation/python/) might show up in Google searches for OpenCV Python API. Avoid this documentation, since it is out-of-date and covers only the old (C-like) Python API.
The documentation is also available as several downloadable PDF files:
If you write code on airplanes or other places without Internet access, you will definitely want to keep offline copies of the documentation.
If the documentation does not seem to answer your question, try talking to the OpenCV community. Here are some sites where you will find helpful people:
Last, if you are an advanced user who wants to try new features, bug-fixes, and sample scripts from the latest (unstable) OpenCV source code, have a look at the project's repository at https://github.com/Itseez/opencv/.
Summary
By now, we should have an OpenCV installation that can do everything we need for the project described in this book. Depending on which approach we took, we might also have a set of tools and scripts that are usable to reconfigure and rebuild OpenCV for our future needs.
We know where to find OpenCV's Python samples. These samples cover a different range of functionality than this book's project, but they are useful as additional learning aids.
Project concept
OpenCV is often studied through a cookbook approach that covers a lot of algorithms but nothing about high-level application development. To an extent, this approach is understandable because OpenCV's potential applications are so diverse. For example, we could use it in a photo/video editor, a motion-controlled game, a robot's AI, or a psychology experiment where we log participants' eye movements. Across such different use cases, can we truly study a useful set of abstractions?
I believe we can and the sooner we start creating abstractions, the better. We will structure our study of OpenCV around a single application, but, at each step, we will design a component of this application to be extensible and reusable.
