Download and install 32-bit Python 2.7.3 from http://www.python.org/ftp/python/2.7.3/python-2.7.3.msi.

Download and install NumPy 1.6.2 from http://sourceforge.net/projects/numpy/files/NumPy/1.6.2/numpy-1.6.2-win32-superpack-python2.7.exe/download.

Download and install SciPy 11.0 from http://sourceforge.net/projects/scipy/files/scipy/0.11.0/scipy-0.11.0-win32-superpack-python2.7.exe/download.

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.

Copy <unzip_destination>\opencv\build\python\2.7\cv2.pyd to C:\Python2.7\Lib\site-packages (assuming we installed Python 2.7 to the default location). Now, the new Python installation can find OpenCV.

A final step is necessary if we want Python scripts to run using the new Python installation by default. Edit the system's Path variable and append ;C:\Python2.7 (assuming we installed Python 2.7 to the default location). Remove any previous Python paths, such as ;C:\Python2.6. Log out and log back in (alternatively, reboot).

Download and install CMake 2.8.9 from http://www.cmake.org/files/v2.8/cmake-2.8.9-win32-x86.exe. When running the installer, select either Add CMake to the system PATH for all users or Add CMake to the system PATH for current user.

Download and install Microsoft Visual Studio 2010, Microsoft Visual C++ Express 2010, or MinGW. Note that OpenCV 2.4.3 cannot be compiled with the more recent versions (Microsoft Visual Studio 2012 and Microsoft Visual Studio Express 2012).

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:

> mkdir<build_folder>

Change directory to the build folder:

> cd <build_folder>

Now, we are ready to configure our build. To understand all the options, we could read the code in <unzip_destination>\opencv\CMakeLists.txt. However, for this book's purposes, we only need to use the options that will give us a release build with Python bindings and, optionally, depth camera support via OpenNI and SensorKinect.

For Visual Studio 2010 or Visual C++ Express 2010, run:

> cmake -D:CMAKE_BUILD_TYPE=RELEASE -D:WITH_OPENNI=ON -G "Visual Studio 10" <unzip_destination>\opencv

Alternatively, for MinGW, run:

> cmake -D:CMAKE_BUILD_TYPE=RELEASE -D:WITH_OPENNI=ON -G "MinGWMakefiles" <unzip_destination>\opencv

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:

> mingw32-make.

Copy <build_folder>\lib\Release\cv2.pyd (from a Visual Studio build) or <build_folder>\lib\cv2.pyd (from a MinGW build) to C:\Python2.7\Lib\site-packages (assuming Python 2.7 is installed to the default location). Now, the Python installation can find part of OpenCV.

Finally, we need to make sure that Python and other processes can find the rest of OpenCV. Edit the system's Path variable and append ;<build_folder>/bin/Release (for a Visual Studio build) or ;<build_folder>/bin (for a MinGW build). Reboot your system.

Download and install MacPorts from http://www.macports.org/install.php.

If we want support for the Kinect depth camera, we need to tell MacPorts where to download some custom Portfiles that I have written. To do so, edit /opt/local/etc/macports/sources.conf (assuming MacPorts is installed to the default location). Just above the line rsync://rsync.macports.org/release/ports/ [default], add the following line:

http://nummist.com/opencv/ports.tar.gz

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:

$ sudo port selfupdate

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:

$ sudo port install opencv +python27 +openni_sensorkinect

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:

$ sudo port install opencv +python27 +openni

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:

$ port variants opencv

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:

$ sudo port install py27-scipy

The Python installation's executable is named python2.7. If we want to link the default python executable to python2.7, let's also run:

$ sudo port install python_select
$ sudo port select python python27

Create a folder somewhere to hold our custom Portfiles. We will refer to this folder as <local_repository>.

Edit the file /opt/local/etc/macports/sources.conf (assuming MacPorts is installed to the default location). Just above the line rsync://rsync.macports.org/release/ports/ [default], add this line:

file://<local_repository>

For example, if <local_repository> is /Users/Joe/Portfiles, add:

file:///Users/Joe/Portfiles

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:

$ sudo port selfupdate

Let's copy the default repository's opencv Portfile as an example. We should also copy the directory structure, which determines how the package is categorized by MacPorts.

$ mkdir <local_repository>/graphics/
$ cp /opt/local/var/macports/sources/rsync.macports.org/release/ports/graphics/opencv <local_repository>/graphics

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>:

$ cp <unzip_destination>/graphics <local_repository>

Edit <local_repository>/graphics/opencv/Portfile. Note that this file specifies CMake configuration flags, dependencies, and variants. For details on Portfile editing, go to http://guide.macports.org/#development.

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:

$ cd <local_repository>
$ portindex

From now on, we can treat our custom opencv just like any other MacPorts package. For example, we can install it as follows:

$ sudo port install opencv +python27 +openni_sensorkinect

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.

Open Terminal and run the following command to install Homebrew:

$ ruby -e "$(curl -fsSkLraw.github.com/mxcl/homebrew/go)"

Unlike MacPorts, Homebrew does not automatically put its executables in PATH. To do so, create or edit the file ~/.profile and add this line at the top:

export PATH=/usr/local/bin:/usr/local/sbin:$PATH

Save the file and run this command to refresh PATH:

$ source ~/.profile

Note that executables installed by Homebrew now take precedence over executables installed by the system.

For Homebrew's self-diagnostic report, run:

$ brew doctor

Follow any troubleshooting advice it gives.

Now, update Homebrew:

$ brew update

Run the following command to install Python 2.7:

$ brew install python

Now, we can install NumPy. Homebrew's selection of Python library packages is limited so we use a separate package management tool called pip , which comes with Homebrew's Python:

$ pip install numpy

SciPy contains some Fortran code, so we need an appropriate compiler. We can use Homebrew to install the gfortran compiler:

$ brew install gfortran

Now, we can install SciPy:

$ pip install scipy

To install OpenCV on a 64-bit system (all new Mac hardware since late 2006), run:

$ brew install opencv

Alternatively, to install OpenCV on a 32-bit system, run:

$ brew install opencv --build32

Open Terminal and run this command to update Apt:

$ sudo apt-get update

Now, run these commands to install NumPy, SciPy, and OpenCV with Python bindings:

$ sudo apt-get install python-numpy
$ sudo apt-get install python-scipy
$ sudo apt-get install libopencv-*
$ sudo apt-get install python-opencv

Enter Y whenever prompted about package installation.

Download my installation script from http://nummist.com/opencv/install_opencv_ubuntu.sh and put it in any destination, say <script_folder>.

Optionally, edit the script to customize OpenCV's build configuration. 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 script, save it.

Open Terminal and run this command to update Apt:

$ sudo apt-get update

Change directory to <script_folder>:

$ cd <script_folder>

Set the script's permissions so that it is executable:

$ chmod +x install_opencv_ubuntu.sh

Execute the script:

$ ./install_opencv_ubuntu.sh

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.