CVS log for pkgsrc/graphics/opencv/distinfo

Up to [cvs.NetBSD.org] / pkgsrc / graphics / opencv

Request diff between arbitrary revisions

Keyword substitution: kv
Default branch: MAIN

opencv: Avoid ambiguous function call.

opencv: fix for Numpy 1.26 and Pyton 3.12; fix testing

opencv opencv-contrib-face: updated to 3.4.20

3.4.20
Bug fixes

graphics/opencv: avoid name-clash of complex macro for gcc<4.8

This adds #undef complex explicitly, to fix the build for older gccs that
don't have that in their headers for C++ code.

opencv: version 3.4.17 with proper explicit BLAS (CBLAS + LAPACKE) usage

This does the small bugfix update from 3.4.16 to 3.4.17 and adds proper usage
of BLAS stuff. There was linkage to BLAS before via numpy, but the internal
explicit BLAS-using code was not built, as the CMake machinery did not find it.

This commit drops an actually counterproductive patch and adds pkg-config
calls to find the BLAS-related libraries. Note that vor opencv-contrib-face,
the BLAS choice during its build doesn't really enter the result, apparently,
but the build process does use it and it would not help to confuse matters there.

I am not sure if the buildlink3.mk should also add blas.buildlink3.mk now. It
does not feature numpy right now. Should it?

Next step should be move towards 4.x at least.

Upstream:

December, 2021

OpenCV 3.4.17 has been released. Bug fixes, optimizations and other enhancements
are propagated into OpenCV 4.5.5.

Long-lived OpenCV 3.x release series is here since 2015. We are going to reduce
support of 3.x branch in the future to move forward to OpenCV 5.0.

graphics: Replace RMD160 checksums with BLAKE2s checksums

All checksums have been double-checked against existing RMD160 and
SHA512 hashes

opencv: Explicitly use std::ceil.

opencv: one more guard for V4L2_PIX_FMT_Y16

opencv opencv-contrib-face: updated to 3.4.16

OpenCV 3.4.16 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.5.4.

graphics: Remove SHA1 hashes for distfiles

opencv opencv-contrib-face: updated to 3.4.15

OpenCV 3.4.15 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.5.3.

Long-lived OpenCV 3.x release series is here since 2015. We are going to reduce support of 3.x branch in the future to move forward to OpenCV 5.0.

opencv: Fix netbsd-8 build failure. Still does not link, due to libstdc++

opencv: build with openexr3

opencv: Include arm_neon.h before NEON'ing

opencv: avoid non-standard integer types in v4l module

Fix build on Illumos.

Fix missing includes.

opencv: updated to 3.4.9

version:3.4.9
OpenCV 3.4.9 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.2.0.

opencv: switch to ffmpeg4.  Don't pick up stray packages.

opencv: updated to 3.4.8

version:3.4.8
OpenCV 3.4.8 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.1.2.

version:3.4.7
OpenCV 3.4.7 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.1.1.

opencv: add new patch to distinfo

opencv: updated to 3.4.6

version:3.4.6
OpenCV 3.4.6 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.1.0.

version:3.4.5
OpenCV 3.4.5 has been released. Bug fixes, optimizations and other enhancements are propagated into OpenCV 4.0.1.

version:3.4.4
OpenCV 3.4.4 has been released. This is a mantenance release. New features are landed in OpenCV 4.0.

version:3.4.3
OpenCV 3.4.3 has been released, with further extended dnn module, documentation improvements, some other new functionality and bug fixes.

version:3.4.2
OpenCV 3.4.2 has been released, with further extended dnn module, documentation improvements, some other new functionality and bug fixes.
OpenCV 3.4.x development is switched from "master" to "3.4" branch. "master" branch is used for development of upcoming OpenCV 4.x releases.
Bugfixes / optimizations / small improvemets should go into "3.4" branch. We will merge changes from "3.4" into "master" regularly (weekly/bi-weekly).

Fix opencv build with PYTHON_VERSION_DEFAULT=37

graphics/opencv: Update to 3.4.1.

== OpenCV 3.4.1

dnn
- Added support for quantized TensorFlow networks
- OpenCV is now able to use Intel DL inference engine as DNN
  acceleration backend
- Added AVX-512 acceleration to the performance-critical kernels, such
  as convolution and fully-connected layers
- SSD-based models trained and retrained in TensorFlow Object
  Detection API can be easier imported by a single invocation of
  python script making a text graph representation
- Performance of pthreads backend of cv::parallel_for_() has been
  greatly improved on many core machines
- OpenCL backend has been expanded to cover more layers
- Several bugs in various layers have been fixed

OpenCL
- On-disk caching of precompiled OpenCL kernels has been fixed to
  comply with OpenCL standard
- Certain cases with UMat deadlock when copying UMats in different
  threads has been fixed

Android
- Supported Android NDK16
- Added build.gradle into OpenCV 4 Android SDK
- Added initial support of Camera2 API via JavaCamera2View interface

C++
- C++11: added support of multi-dimentional cv::Mat creation via C++
  initializers lists
- C++17: OpenCV source code and tests comply C++17 standard

Misc
- opencv_contrib: added GMS matching
- opencv_contrib: added CSR-DCF tracker
- opencv_contrib: several improvements in OVIS module


== OpenCV 3.4

- New background subtraction algorithms have been integrated.

dnn
- Added faster R-CNN support
- Javascript bindings have been extended to cover DNN module
- DNN has been further accelerated for iGPU using OpenCL

OpenCL
- On-disk caching of precompiled OpenCL kernels has been finally
  implemented
- It's now possible to load and run pre-compiled OpenCL kernels via
  T-API
- Bit-exact 8-bit and 16-bit resize has been implemented

Update graphics/opencv to 3.3.0.
Sync opencv-contrib-face too.

Main changes:

- DNN module from opencv_contrib was promoted to the main repository,
  improved and accelerated it a lot. An external BLAS implementation is
  not needed anymore. For GPU there is experimental DNN acceleration using
  Halide (http://halide-lang.org).
- OpenCV can now be built as C++ 11 library using the flag ENABLE_CXX11.
  Some cool features for C++ 11 programmers have been added.
- We've also enabled quite a few AVX/AVX2 and SSE4.x optimizations in
  the default build of OpenCV thanks to the feature called 'dynamic
  dispatching'. The DNN module also has some AVX/AVX2 optimizations.
- Intel Media SDK can now be utilized by our videoio module to do
  hardware-accelerated video encoding/decoding. MPEG1/2, as well as
  H.264 are supported.
- Embedded into OpenCV Intel IPP subset has been upgraded from 2015.12
  to 2017.2 version, resulting in ~15% speed improvement in our core &
  imgproc perf tests.

Full release notes:

  https://github.com/opencv/opencv/wiki/ChangeLog

Update opencv to 3.2

Many Darwin library handling patches removed because of commit 912592de4ce
  Remove "INSTALL_NAME_DIR lib" target property

Full changelog at

https://github.com/opencv/opencv/wiki/ChangeLog

Highlights:

     * Results from 11 GSoC 2016 projects have been submitted to the
       library, 9 of them have been integrated already, 2 still pending
       (the numbers below are the id's of the Pull Requests in opencv or
       opencv_contrib repository):
          + Ambroise Moreau (Delia Passalacqua) - sinusoidal patterns for
            structured light and phase unwrapping module (711)
          + Alexander Bokov (Maksim Shabunin) - DIS optical flow
            (excellent dense optical flow algorithm that is both
            significantly better and significantly faster than Farneback's
            algorithm - our baseline), and learning-based color constancy
            algorithms implementation (689, 708, 722, 736, 745, 747)
          + Tyan Vladimir (Antonella Cascitelli) - CNN based tracking
            algorithm (GOTURN) (718, 899)
          + Vladislav Samsonov (Ethan Rublee) - PCAFlow and Global Patch
            Collider algorithms implementation (710, 752)
          + Jo o Cartucho (Vincent Rabaud) - Multi-language OpenCV
            Tutorials in Python, C++ and Java (7041)
          + Jiri Horner (Bo Li) - New camera model and parallel processing
            for stitching pipeline (6933)
          + Vitaliy Lyudvichenko (Anatoly Baksheev) - Optimizations and
            improvements of dnn module (707, 750)
          + Iric Wu (Vadim Pisarevsky) - Base64 and JSON support for file
            storage (6697, 6949, 7088). Use names like
            `"myfilestorage.xml?base64"` when writing file storage to
            store big chunks of numerical data in base64-encoded form.
          + Edgar Riba (Manuele Tamburrano, Stefano Fabri) - tiny_dnn
            improvements and integration (720: pending)
          + Yida Wang (Manuele Tamburrano, Stefano Fabri) - Quantization
            and semantic saliency detection with tiny_dnn
          + Anguelos Nicolaou (Lluis Gomez) - Word-spotting CNN based
            algorithm (761: pending)

gcc6 build fix

NetBSD's v4l2 emulation doesn't currently have focus-related settings,
so conditionalize parts.

Update graphics/opencv to 3.1.0.

* A lot of new functionality has been introduced during GSoC 2015:
  - "Omnidirectional Cameras Calibration and Stereo 3D Reconstruction"
    opencv_contrib/ccalib module
  - "Structure From Motion" - opencv_contrib/sfm module
  - "Improved Deformable Part-based Models" - opencv_contrib/dpm module
  - "Real-time Multi-object Tracking using Kernelized Correlation Filter"
    - opencv_contrib/tracking module
  - "Improved and expanded Scene Text Detection" - opencv_contrib/text
    module
  - "Stereo correspondence improvements" - opencv_contrib/stereo module
  - "Structured-Light System Calibration" - opencv_contrib/structured_light
  - "Chessboard+ArUco for camera calibration" - opencv_contrib/aruco
  - "Implementation of universal interface for deep neural network
    frameworks" - opencv_contrib/dnn module
  - "Recent advances in edge-aware filtering, improved SGBM stereo
    algorithm" - opencv/calib3d and opencv_contrib/ximgproc
  - "Improved ICF detector, waldboost implementation"
    - opencv_contrib/xobjdetect
  - "Multi-target TLD tracking" - opencv_contrib/tracking module
  - "3D pose estimation using CNNs" - opencv_contrib/cnn_3dobj

* Many great contributions made by the community, such as:
  - Support for HDF5 format
  - New/Improved optical flow algorithms
  - Multiple new image processing algorithms for filtering, segmentation
    and feature detection
  - Superpixel segmentation

* IPPICV is now based on IPP 9.0.1, which should make OpenCV even faster
  on modern Intel chips
* opencv_contrib modules can now be included into the opencv2.framework
  for iOS
* Newest operating systems are supported: Windows 10 and OSX 10.11
  (Visual Studio 2015 and XCode 7.1.1)
* Interoperability between T-API and OpenCL, OpenGL, DirectX and Video
  Acceleration API on Linux, as well as Android 5 camera.
* HAL (Hardware Acceleration Layer) module functionality has been moved
  into corresponding basic modules; the HAL replacement mechanism has
  been implemented along with the examples

See full changelog:

  https://github.com/Itseez/opencv/wiki/ChangeLog

fix broken dynamic library handling on Darwin

Add SHA512 digests for distfiles for graphics category

Problems found with existing digests:
	Package fotoxx distfile fotoxx-14.03.1.tar.gz
	ac2033f87de2c23941261f7c50160cddf872c110 [recorded]
	118e98a8cc0414676b3c4d37b8df407c28a1407c [calculated]
	Package ploticus-examples distfile ploticus-2.00/plnode200.tar.gz
	34274a03d0c41fae5690633663e3d4114b9d7a6d [recorded]
	da39a3ee5e6b4b0d3255bfef95601890afd80709 [calculated]

Problems found locating distfiles:
	Package AfterShotPro: missing distfile AfterShotPro-1.1.0.30/AfterShotPro_i386.deb
	Package pgraf: missing distfile pgraf-20010131.tar.gz
	Package qvplay: missing distfile qvplay-0.95.tar.gz

Otherwise, existing SHA1 digests verified and found to be the same on
the machine holding the existing distfiles (morden).  All existing
SHA1 digests retained for now as an audit trail.

Don't fetch 3rd party modules during build from the Internet.
Don't require C++14 for no obvious reason.

Update graphics/opencv to 3.0.0.

Major changes (besides bugfixes):
- opencv_contrib (http://github.com/itseez/opencv_contrib) repository
  has been added.
- a subset of Intel IPP (IPPCV) is given to us and our users free
  of charge, free of licensing fees, for commercial and non-commerical
  use.
- T-API (transparent API) has been introduced, this is transparent GPU
  acceleration layer using OpenCL. It does not add any compile-time or
  runtime dependency of OpenCL. When OpenCL is available, it's detected
  and used, but it can be disabled at compile time or at runtime.
- ~40 OpenCV functions have been accelerated using NEON intrinsics and
  because these are mostly basic functions, some higher-level functions
  got accelerated as well.
- There is also new OpenCV HAL layer that will simplifies creation
  of NEON-optimized code and that should form a base for the open-source
  and proprietary OpenCV accelerators.
- The documentation is now in Doxygen: http://docs.opencv.org/master/
- We cleaned up API of many high-level algorithms from features2d, calib3d,
  objdetect etc. They now follow the uniform "abstract interface - hidden
  implementation" pattern and make extensive use of smart pointers (Ptr<>).
- Greatly improved and extended Python & Java bindings (also, see below on
  the Python bindings), newly introduced Matlab bindings
- Improved Android support - now OpenCV Manager is in Java and supports
  both 2.4 and 3.0.
- Greatly improved WinRT support, including video capturing and
  multi-threading capabilities. Thanks for Microsoft team for this!
- Big thanks to Google who funded several successive GSoC programs and
  let OpenCV in. The results of many successful GSoC 2013 and 2014 projects
  have been integrated in opencv 3.0 and opencv_contrib (earlier results
  are also available in OpenCV 2.4.x). We can name:
  - text detection
  - many computational photography algorithms (HDR, inpainting, edge-aware
    filters, superpixels,...)
  - tracking and optical flow algorithms
  - new features, including line descriptors, KAZE/AKAZE
  - general use optimization (hill climbing, linear programming)
  - greatly improved Python support, including Python 3.0 support, many new
    tutorials & samples on how to use OpenCV with Python.
  - 2d shape matching module and 3d surface matching module
  - RGB-D module
  - VTK-based 3D visualization module

For full changelog see:

  http://code.opencv.org/projects/opencv/wiki/ChangeLog

For 2.4 to 3.0 transition, see the transition guide:

  http://docs.opencv.org/master/db/dfa/tutorial_transition_guide.html

graphics/opencv: fix build on fbsd + clang

* under clang, C-style cast from nullptr_t to enum are not allowed.

Ok@ wiz

OSX ffmpeg option build fixes adapted from upstream 2.4 branch.
From Mansour Moufid in private mail.

Avoid GS define from sys/regset.h on SunOS.

Update to 2.4.9

Changelog:
2.4.9

April, 2014

    Several improvements in OpenCL optimizations (ocl::sum, ocl::countNonZero, ocl::minMax, bitwise operationss, Haar face detector, etc)

    Multiple fixes in Naitve Camera (NativeCameraView, cv::VideoCapture);
    Improved CUDA support for all CUDA-enabled SoCs.

    New VTK-based 3D visualization module viz stabilized and back-ported to 2.4 branch.
    The module provides a very convenient way to display and position clouds, meshes, cameras and trajectories, and simple widgets (cube, line, circle, etc.).
    Full demo video can be found at Itseez Youtube channel

    Numerous bugfixes in code and docs from community

    156 pull requests have been merged since 2.4.8

    55 reported bugs have been closed since 2.4.8


2.4.8

December, 2013

    User provided OpenCL context can be used by OpenCV ( ocl::initializeContext )
    A separate OpenCL command queue is created for every CPU thread (allows concurrent kernels execution)
    Some new OpenCL optimizations and bug-fixes

    NVidia CUDA support on CUDA capable SoCs;
    Android 4.4 support, including native camera;
    Java wrappers for GPU-detection functions from core module were added;
    New sample with CUDA on Android was added;
    OpenCV Manager and apps hanging were fixed on Samsung devices with Android 4.3 (#3368, #3372, #3403, #3414, #3436).

    Static linkage support for native C++ libraries;

    139 pull requests have been merged since version:2.4.7!

    32 reported bugs have been closed since version:2.4.7


2.4.7

November, 2013

    Now 'ocl' module can be built without installing OpenCL SDK (Khronos headers in OpenCV tree);
    Dynamic dependency on OpenCL runtime (allows run-time branching between OCL and non-OCL implementation);
    Changing default OpenCL device via OPENCV_OPENCL_DEVICE environment variable (without app re-build);
    Refactoring/extending/bug-fixing of existing OpenCL optimizations, updated documentation;
    New OpenCL optimizations of SVM, MOG/MOG2, KalmanFilter and more;

    New optimization for histograms, TV-L1 optical flow and resize;
    Updated multi gpu sample for stereo matching;
    Fixed BGR<->YUV color conversion and bitwize operations;
    Fixed several build issues;

    Android NDK-r9 (x86, x86_64) support;
    Android 4.3 support: hardware detector (Bugs #3124, #3265, #3270) and native camera (Bug #3185);
    MediaRecorder hint enabled for all Android devices with API level 14 and above;
    Fixed JavaCameraView slowdown (Bugs #3033, #3238);

    Fixed MS Certification test issues for all algorithmical modules and highgui, except OpenEXR and Media Foundation code for camera;
    Implemented XAML-based sample for video processing using OpenCV;
    Fixed issue in Media Foundation back-end for VideoCapture (#3189);

    382 pull requests have been merged since 2.4.6!

    54 reported bugs have been fixed since 2.4.6 (issue tracker query).

Avoid two tautological checks.

Fix bad patch file.

Update opencv to 2.4.6.1

Changes in 2.4.6.1:
* Hotfix for camera pipeline for Linux (V4L).

Changes in 2.4.6:
* Windows RT: added video file i/o and sample application using camera,
  enabled parallelization with TBB or MS Concurrency
* CUDA 5.5: added support for desktop and ARM
* Added Qt 5 support
* Binary compatiblility with both OpenCL 1.1/1.2 platforms. Now the binaries
  compiled with any of AMD/Intel/Nvidia's SDK can run on all other platforms.
* New functions ported, CLAHE, GoodFeaturesToTrack, TVL1 optical flow and more
* Performance optimizations, HOG and more.
* More kernel binary cache options though setBinaryDiskCache interface.
* OpenCL binaries are now included into the superpack for Windows (for VS2010
  and VS2012 only)
* Switched all the remaining parallel loops from TBB-only
  'tbb::parallel_for()' to universal 'cv::parallel_for_()' with many possible
  backends (MS Concurrency, Apple's GDC, OpenMP, Intel TBB etc.)
* iOS build scripts (together with Android ones) moved to 'opencv/platforms'
  directory
* Fixed bug with incorrect saved video from camera through CvVideoCamera
* Added 'rotateVideo' flag to the CvVideoCamera class to control camera
  preview rotation on device rotation
* Added functions to convert between UIImage and cv::Mat (just include
  opencv2/highgui/ios.h)
* Numerous bug-fixes across all the library

Fix build with SunOS and GCC 4.7.

Update to 2.4.5:

2.4.5

April, 2013

    Experimental WinRT support (build for WindowsRT guide)

    the new video super-resolution module has been added that
    implements the following papers:

    - S. Farsiu, D. Robinson, M. Elad, P. Milanfar. Fast and robust
    Super-Resolution. Proc 2003 IEEE Int Conf on Image Process,
    pp. 291â294, 2003.
    - D. Mitzel, T. Pock, T. Schoenemann, D. Cremers. Video super
    resolution using duality based TV-L1 optical flow. DAGM, 2009.

    CLAHE (adaptive histogram equalization) algorithm has been
    implemented, both CPU and GPU-accelerated versions (in imgproc
    and gpu modules, respectively)

    there are further improvements and extensions in ocl module:
    - 2 stereo correspondence algorithms: stereobm (block matching)
    and stereobp (belief propagation) have been added
    - many bugs fixed, including some crashes on Intel HD4000

    The tutorial on displaying cv::Mat inside Visual Studio 2012
    debugger has been contributed by Wolf Kienzle from Microsoft
    Research. See
    http://opencv.org/image-debugger-plug-in-for-visual-studio.html

    78 pull requests have been merged. Big thanks to everybody who
    contributed!

    At least 25 bugs have been fixed since 2.4.4 (see
    http://code.opencv.org/projects/opencv/issues select closed
    issues with target version set to "2.4.5").

2.4.4

March, 2013

    This is the biggest news in 2.4.4 - we've got full-featured
    OpenCV Java bindings on a desktop, not only Android! In fact
    you can use any JVM language, including functional Java or
    handy Groovy. Big thanks to Eric Christiansen for the contribution!
    Check the tutorial for details and code samples.

    Android application framework, samples, tutorials, OpenCV
    Manager are updated, see Android Release Notes for details.

    Numerous improvements in gpu module and the following new
    functionality & optimizations:
	Optimizations for the NVIDIA Kepler architecture
	NVIDIA CARMA platform support
	HoughLinesP for line segments detection
	Lab/Luv <-> RGB conversions

    Let us be more verbose here. The openCL-based hardware acceleration
    (ocl) module is now mature, and, with numerous bug fixes, it
    is largely bug-free. Correct operation has been verified on
    all tested platforms, including discrete GPUs (tested on NVIDIA
    and AMD boards), as well as integrated GPUs (AMD APUs as well
    as Intel Ivy Bridge iGPUs). On the host side, there has been
    exhaustive testing on 32/64 bit, Windows/Linux systems, making
    the ocl module a very serious and robust cross-platform GPU
    hardware acceleration solution. While we currently do not test
    on other devices that implement OpenCL (e.g. FPGA, ARM or other
    processors), it is expected that the ocl module will work well
    on such devices as well (provided the minimum requirements
    explained in the user guide are met).
    Here are specific highlights of the 2.4.4 release:
	The ocl::Mat can now use âspecialâ memory (e.g. pinned
	memory, host-local or device-local).
	The ocl module can detect if the underlying hardware supports
	âintegrated memory,â and if so use âdevice-localâ memory
	by default for all operations.
	New arithmetic operations for ocl::Mat, providing significant
	ease of use for simple numerical manipulations.
	Interop with OpenCL enables very easy integration of OpenCV
	in existing OpenCL applications, and vice versa.
	New algorithms include Hough circles, more color conversions
	(including YUV, YCrCb), and Hu Moments.
	Numerous bug fixes, and optimizations, including in:
	blendLinear, square samples, erode/dilate, Canny, convolution
	fixes with AMD FFT library, mean shift filtering, Stereo
	BM.
	Platform specific bug fixes: PyrLK, bruteForceMatcher,
	faceDetect now works also on Intel Ivy Bridge chips (as
	well as on AMD APUs/GPUs and NVIDIA GPUs); erode/dilate
	also works on NVIDIA GPUs (as well as AMD APUs/GPUs and
	Intel iGPUs).

    Many people contributed their code in the form of pull requests.
    Here are some of the most interesting contributions, that were
    included into 2.4 branch:
	>100 reported problems have been resolved since 2.4.3
	Oscar Deniz submitted smile detector and sample.
	Alexander Smorkalov created a tutorial on cross-compilation
	of OpenCV for Linux on ARM platforms.

Add patches required for SunOS support.

Add missing include. Require C++11 when building with Clang.

Add a number of includes hidden by libstdc++'s name space pollution.

Honor sequence point rules.

Fix oversaturated int type compilation error for programs depending on opencv

Update to 2.4.3

Changelog:
* Add universal parallell mechianism support
* Add sample codes
* Add some new algorithms
* Many improvements in GPU support
* Many bugfixes

Update OpenCV to 2.4.2, highlights include:
- New keypoint descriptor FREAK contributed by EPFL group
- Improved face recognizer class and tutorial added by Philipp Wagner

adam reports that OS X 10.6 patch is not needed any longer, remove it.

Add upstream bug report URLs.

Update to 2.4.1. Now builds with clang. Python option
not tested. New ffmpeg support not enabled in package.

2.4.1

June, 2012

The changes since 2.4.0

    The GPU module now supports CUDA 4.1 and CUDA 4.2 and can be
    compiled with CUDA 5.0 preview.

    Added API for storing OpenCV data structures to text string
    and reading them back:

    cv::calcOpticalFlowPyrLK now supports precomputed pyramids as
    input.

    Function signatures in documentation are made consistent with
    source code.

    Restored python wrappers for SURF and MSER.

    45 more bugs in our bug tracker have been fixed

2.4.0

May, 2012

The major changes since 2.4 beta

    OpenCV now provides pretty complete build information via
    (surprise) cv::getBuildInformation().

    reading/writing video via ffmpeg finally works and it's now
    available on MacOSX too.
    note 1: we now demand reasonably fresh versions of ffmpeg/libav
    with libswscale included.
    note 2: if possible, do not read or write more than 1 video
    simultaneously (even within a single thread) with ffmpeg 0.7.x
    or earlier versions, since they seem to use some global structures
    that are destroyed by simultaneously executed codecs. Either
    build and install a newer ffmpeg (0.10.x is recommended), or
    serialize your video i/o, or use parallel processes instead of
    threads.

    MOG2 background subtraction by Zoran Zivkovic was optimized
    using TBB.

    The reference manual has been updated to match OpenCV 2.4.0
    better (though, not perfectly).

    >20 more bugs in our bug tracker have been closed
    (http://code.opencv.org/projects/opencv/roadmap).

    Asus Xtion is now properly supported for HighGUI. For now, you
    have to manually specify this device by using
    VideoCapture(CV_CAP_OPENNI_ASUS) instead of
    VideoCapture(CV_CAP_OPENNI).

2.4 beta

April, 2012

As usual, we created 2.4 branch in our repository
(http://code.opencv.org/svn/opencv/branches/2.4), where we will
further stabilize the code. You can check this branch periodically,
before as well as after 2.4 release.

Common changes

    At the age of 12, OpenCV got its own home! http://code.opencv.org
    is now the primary site for OpenCV development and http://opencv.org
    (to be launched soon) will be the official OpenCV user site.

    Some of the old functionality from the modules imgproc, video,
    calib3d, features2d, objdetect has been moved to legacy.

    CMake scripts have been substantially modified. Now it's very
    easy to add new modules - just put the directory with include,
    src, doc and test sub-directories to the modules directory,
    create a very simple CMakeLists.txt and your module will be
    built as a part of OpenCV. Also, it's possible to exclude
    certain modules from build (the CMake variables
    "BUILD_opencv_<modulename>" control that).

New functionality

    The new very base cv::Algorithm class has been introduced. It's
    planned to be the base of all the "non-trivial" OpenCV
    functionality. All Algorithm-based classes have the following
    features:
        "virtual constructor", i.e. an algorithm instance can be created by name;
        there is a list of available algorithms;
        one can retrieve and set algorithm parameters by name;
        one can save algorithm parameters to XML/YAML file and then load them.

    A new ffmpeg wrapper has been created that features multi-threaded
    decoding, more robust video positioning etc. It's used with
    ffmpeg starting with 0.7.x versions.

    features2d API has been cleaned up. There are no more numerous
    classes with duplicated functionality. The base classes
    FeatureDetector and DescriptorExtractor are now derivatives of
    cv::Algorithm. There is also the base Feature2D, using which
    you can detect keypoints and compute the descriptors in a single
    call. This is also more efficient.

    SIFT and SURF have been moved to a separate module named nonfree
    to indicate possible legal issues of using those algorithms in
    user applications. Also, SIFT performance has been substantially
    improved (by factor of 3-4x).

    The current state-of-art textureless detection algorithm,
    Line-Mod by S. Hinterstoisser, has been contributed by Patrick
    Mihelich. See objdetect/objdetect.hpp, class Detector.

    3 face recognition algorithms have been contributed by Philipp
    Wagner. Please, check opencv/contrib/contrib.hpp, FaceRecognizer
    class, and opencv/samples/cpp/facerec_demo.cpp.

    2 algorithms for solving PnP problem have been added. Please,
    check flags parameter in solvePnP and solvePnPRansac functions.

    Enhanced LogPolar implementation (that uses Blind-Spot model)
    has been contributed by Fabio Solari and Manuela Chessa, see
    opencv/contrib/contrib.hpp, LogPolar_* classes and
    opencv/samples/cpp/logpolar_bsm.cpp sample.

    A stub module photo has been created to support a quickly
    growing "computational photography" area. Currently, it only
    contains inpainting algorithm, moved from imgproc, but it's
    planned to add much more functionality.

    Another module videostab (beta version) has been added that
    solves a specific yet very important task of video stabiliion.
    The module is under active development. Please, check
    opencv/samples/cpp/videostab.cpp sample.

    findContours can now find contours on a 32-bit integer image
    of labels (not only on a black-and-white 8-bit image). This is
    a step towards more convenhich results in better edge maps

    Python bindings can now be used within python threads, so one
    can write multi-threaded computer vision applications in Python.

OpenCV on GPU

    Different Optical Flow algorithms have been added:
        Brox (contrtions;
        Improved performance.

    pyrUp/pyrDown implementations.

    Matrix multiplication on GPU (wrapper for the CUBLAS library).
    This is optional, user need to compile OpenCV with CUBLAS
    support.

    OpenGL back-end has been implemented for highgui module, that
    allows to display GpuMat directly without downloading them to
    CPU.

Performance

    A few OpenCV functions, like color conversion, morphology, data
    type conversions, brute-force feature mer have been optimized
    using TBB and/or SSE intrinisics.

    Along with regression tests, now many OpenCV functions have
    got performance tests. Now for most modules one can build
    opencv_perf_<modulename> executables that run various functions
    from the particular module and produce a XML file. Note that
    if you want to run those tests, as well as the normal regression
    tests, you will need to get (a rather big)
    http://code.opencv.org/svn/opencv/trunk/opencv_extra directory
    and set environment variable OPENCV_TEST_DATA_PATH to
    "<your_copy_of_opencv_extra>/testdata".

Bug fixes

    In this version we fixed literally hundreds of bugs. Please,
    check http://code.opencv.org/projects/opencv/versions/1 for a
    list of fixed bugs.

Known issues

    When OpenCV is built statically, dynamically created classes
    (via Algorithm::create) can fail because linker excludes the
    "unused" object files. To avoid this problem, create classes
    explicitly, e.g

    1 Ptr<DescriptorExtractor> d = new BriefDescriptorExtractor;

Update to 2.3.1

Add a python option (off by default).

2.3.1
(August, 2011)
New Functionality and Features
* Retina module has been contributed by Alexandre Benoit (in opencv_contrib
  module).
* Planar subdivisions construction (Delaunay triangulation and Voronoi
  tesselation) have been ported to C++. See the new delaunay2.cpp sample.
* Several new Python samples have been added.
* FLANN in OpenCV has been upgraded to v1.6. Also, added Python bindings
  for FLANN.
* We now support the latest FFMPEG (0.8.x) that features multi-threaded
  decoding. Reading videos in OpenCV has never been that fast.
* Over 100 issues have been resolved since 2.3 release.

2.3
(July, 2011)
Modifications and Improvements since 2.3rc
* A few more bugs reported in the OpenCV bug tracker have been fixed.
* Documentation has been improved a lot!

2.3rc
(June, 2011)
New Functionality, Features
* Many functions and methods now take InputArray/OutputArray instead of
  "cv::Mat" references. It retains compatibility with the existing code and
  yet brings more natural support for STL vectors and potentially other
  "foreign" data structures to OpenCV.
core:
* LAPACK is not used by OpenCV anymore.
* Arithmetic operations now support mixed-type operands and arbitrary number
  of channels.
features2d:
* Completely new patent-free BRIEF and ORB feature descriptors have been
  added.
* Very fast LSH matcher for BRIEF and ORB descriptors will be added in 2.3.1.
calib3d:
* calibration.cpp sample. With the new pattern calibration accuracy is
  usually much higher.
stitching:
* opencv_stitching is a beta version of new application that makes a panorama
  out of a set of photos taken from the same point.
python:
* Now there are 2 extension modules: cv and cv2. cv2 includes wrappers for
  OpenCV 2.x functionality. opencv/samples/python2 contain a few samples
  demonstrating cv2 in use.
* Over 250 issues have been resolved.

Fix building on Mac OS X (PR#46117)

graphics/opencv: Add support for DragonFly

Add upstream bug report.

Fix build with png-1.5.

Add upstream bug report URL.

Update to 2.2.0.

2.2

   (December, 2010)

   General Modifications and Improvements
     * The library has been reorganized. Instead of cxcore, cv, cvaux,
       highgui and ml we now have several smaller modules:
          * opencv_core - core functionality (basic structures, arithmetics
            and linear algebra, dft, XML and YAML I/O ...).
          * opencv_imgproc - image processing (filter, GaussianBlur, erode,
            dilate, resize, remap, cvtColor, calcHist etc.)
          * opencv_highgui - GUI and image & video I/O
          * opencv_ml - statistical machine learning models (SVM, Decision
            Trees, Boosting etc.)
          * opencv_features2d - 2D feature detectors and descriptors (SURF,
            FAST etc.,
               * including the new feature detectors-descriptor-matcher
                 framework)
          * opencv_video - motion analysis and object tracking (optical flow,
            motion templates, background subtraction)
          * opencv_objdetect - object detection in images (Haar & LBP face
            detectors, HOG people detector etc.)
          * opencv_calib3d - camera calibration, stereo correspondence and
            elements of 3D data processing
          * opencv_flann - the Fast Library for Approximate Nearest Neighbors
            (FLANN 1.5) and the OpenCV wrappers
          * opencv_contrib - contributed code that is not mature enough
          * opencv_legacy - obsolete code, preserved for backward
            compatibility
          * opencv_gpu - acceleration of some OpenCV functionality using CUDA
            (relatively unstable, yet very actively developed part of OpenCV)
     * If you detected OpenCV and configured your make scripts using CMake or
       pkg-config tool, your code will likely build fine without any changes.
       Otherwise, you will need to modify linker parameters (change the
       library names) and update the include paths.
     * It is still possible to use #include <cv.h> etc. but the recommended
       notation is:
          * #include "opencv2/imgproc/imgproc.hpp"
          * ..
     * Please, check the new C and C++ samples
       (https://code.ros.org/svn/opencv/trunk/opencv/samples), which now
       include the new-style headers.
     * The new-style wrappers now cover much more of OpenCV 2.x API. The
       documentation and samples are to be added later. You will need numpy
       in order to use the extra added functionality.
          * SWIG-based Python wrappers are not included anymore.
     * OpenCV can now be built for Android (GSoC 2010 project), thanks to
       Ethan Rublee; and there are some samples too. Please, check
       http://opencv.willowgarage.com/wiki/Android
     * The completely new opencv_gpu acceleration module has been created
       with support by NVidia. See below for details.

   New Functionality, Features
     * core:
          * The new cv::Matx<T, m, n> type for fixed-type fixed-size matrices
            has been added. Vec<T, n> is now derived from Matx<T, n, 1>. The
            class can be used for very small matrices, where cv::Mat use
            implies too much overhead. The operators to convert Matx to Mat
            and backwards are available.
          * cv::Mat and cv::MatND are made the same type: typedef cv::Mat
            cv::MatND. Note that many functions do not check the matrix
            dimensionality yet, so be careful when processing 3-, 4- ...
            dimensional matrices using OpenCV.
          * Experimental support for Eigen 2.x/3.x is added (WITH_EIGEN2
            option in CMake). Again, there are convertors from Eigen2
            matrices to cv::Mat and backwards. See
            modules/core/include/opencv2/core/eigen.hpp.
          * cv::Mat can now be print with "<<" operator. See
            opencv/samples/cpp/cout_mat.cpp.
          * cv::exp and cv::log are now much faster thanks to SSE2
            optimization.
     * imgproc:
          * color conversion functions have been rewritten;
               * RGB->Lab & RGB->Luv performance has been noticeably
                 improved. Now the functions assume sRGB input color space
                 (e.g. gamma=2.2). If you want the original linear RGB->L**
                 conversion (i.e. with gamma=1), use CV_LBGR2LAB etc.
               * VNG algorithm for Bayer->RGB conversion has been added. It's
                 much slower than the simple interpolation algorithm, but
                 returns significantly more detailed images
               * The new flavors of RGB->HSV/HLS conversion functions have
                 been added for 8-bit images. They use the whole 0..255 range
                 for the H channel instead of 0..179. The conversion codes
                 are CV_RGB2HSV_FULL etc.

          * special variant of initUndistortRectifyMap for wide-angle cameras
            has been added: initWideAngleProjMap()
     * features2d:
          * the unified framework for keypoint extraction, computing the
            descriptors and matching them has been introduced. The previously
            available and some new detectors and descriptors, like SURF,
            Fast, StarDetector etc. have been wrapped to be used through the
            framework. The key advantage of the new framework (besides the
            uniform API for different detectors and descriptors) is that it
            also provides high-level tools for image matching and textured
            object detection. Please, see documentation
            http://opencv.willowgarage.com/documentation/cpp/features2d_common_interfaces_of_feature_detectors.html
               * and the C++ samples:
                    * descriptor_extractor_matcher.cpp - finding object in a
                      scene using keypoints and their descriptors.
                    * generic_descriptor_matcher.cpp - variation of the above
                      sample where the descriptors do not have to be computed
                      explicitly.
                    * bagofwords_classification.cpp - example of extending
                      the framework and using it to process data from the VOC
                      databases:
                         * http://pascallin.ecs.soton.ac.uk/challenges/VOC/

          * the newest super-fast keypoint descriptor BRIEF by Michael
            Calonder has been integrated by Ethan Rublee. See the sample
            opencv/samples/cpp/video_homography.cpp
          * SURF keypoint detector has been parallelized using TBB (the patch
            is by imahon and yvo2m)
     * objdetect:
          * LatentSVM object detector, implementing P. Felzenszwalb
            algorithm, has been contributed by Nizhniy Novgorod State
            University (NNSU) team. See
               * opencv/samples/c/latentsvmdetect.cpp
     * calib3d:
          * The new rational distortion model:
               * x' = x*(1 + k1*r2 + k2*r4 + k3*r6)/(1 + k4*r2 + k5*r4 +
                 k6*r6) + <tangential_distortion for x>,

                 y' = y*(1 + k1*r2 + k2*r4 + k3*r6)/(1 + k4*r2 + k5*r4 +
                 k6*r6) + <tangential_distortion for y>

               * has been introduced. It is useful for calibration of cameras
                 with wide-angle lenses. Because of the increased number of
                 parameters to optimize you need to supply more data to
                 robustly estimate all of them. Or, simply initialize the
                 distortion vectors with zeros and pass

                 CV_CALIB_RATIONAL_MODEL to enable the new model +
                 CV_CALIB_FIX_K3 + CV_CALIB_FIX_K4 + CV_CALIB_FIX_K5 or other
                 such combinations to selectively enable or disable certain
                 coefficients.

          * rectification of trinocular camera setup, where all 3 heads are
            on the same line, is added. see samples/cpp/3calibration.cpp
     * ml:
          * Gradient boosting trees model has been contributed by NNSU team.
     * highgui:
          * Experimental Qt backend for OpenCV has been added as a result of
            GSoC 2010 project, completed by Yannick Verdie. The backend has a
            few extra features, not present in the other backends, like text
            rendering using TTF fonts, separate "control panel" with sliders,
            push-buttons, checkboxes and radio buttons, interactive zooming,
            panning of the images displayed in highgui windows, "save as"
            etc. Please, check the youtube videos where Yannick demonstrates
            the new features: http://www.youtube.com/user/MrFrenchCookie#p/u
               * The new API is described here:
                 http://opencv.willowgarage.com/documentation/cpp/highgui_qt_new_functions.html
                 To make use of the new API, you need to have Qt SDK (or
                 libqt4 with development packages) installed on your machine,
                 and build OpenCV with Qt support (pass -DWITH_QT=ON to
                 CMake; watch the output, make sure Qt is used as GUI
                 backend)

          * 16-bit and LZW-compressed TIFFs are now supported.
          * You can now set the mode for IEEE1394 cameras on Linux.
     * contrib:
          * Chamfer matching algorithm has been contributed by Marius Muja,
            Antonella Cascitelli, Marco Di Stefano and Stefano Fabri. See
            samples/cpp/chamfer.cpp
     * gpu:
          * This is completely new part of OpenCV, created with the support
            by NVidia. Note that the package is at alpha, probably early beta
            state, so use it with care and check OpenCV SVN for updates.

            In order to use it, you need to have the latest NVidia CUDA SDK
            installed, and build OpenCV with CUDA support (-DWITH_CUDA=ON
            CMake flag). All the functionality is put to cv::gpu namespace.
            The full list of functions and classes can be found at
            opencv/modules/gpu/include/opencv2/gpu/gpu.hpp, and here are some
            major components of the API:
               * image arithmetics, filtering operations, morphology,
                 geometrical transformations, histograms
               * 3 stereo correspondence algorithms: Block Matching, Belief
                 Propagation and Constant-Space Belief Propagation.
               * HOG-based object detector. It runs more than order of
                 magnitude faster than the CPU version!
                    * See opencv/samples/cpp/

     * python bindings:
          * A lot more of OpenCV 2.x functionality is now covered by Python
            bindings.

   Documentation, Samples
     * Links to wiki pages (mostly empty) have been added to each function
       description, see http://opencv.willowgarage.com
     * All the samples have been documented; most samples have been converted
       to C++ to use the new OpenCV API.

   Bug Fixes
     * Over 300 issues have been resolved. Most of the issues (closed and
       still open) are listed at https://code.ros.org/trac/opencv/report/6.

Update to 2.1. Changelog of most insteresting changes:

2.1

   (April, 2010)

   General Modifications
       - The whole OpenCV is now using exceptions instead of the old
       libc-style mechanism.
          * That is, instead of checking error code with cvGetErrStatus()
            (which currently always returns 0) you can now just call OpenCV
            functions inside C++ try-catch statements, cv::Exception is now
            derived from std::exception.
       - All the parallel loops in OpenCV have been converted from OpenMP
          * to Intel TBB (http://www.threadingbuildingblocks.org/). Thus
            parallel version of OpenCV can now be built using MSVC 2008
            Express Edition or using earlier than 4.2 versions of GCC.

       - SWIG-based Python wrappers are still included,
          * but they are not built by default and it's generally preferable
            to use the new wrappers. The python samples have been rewritten
            by James Bowman to use the new-style Python wrappers, which have
            been also created by James.
       - OpenCV can now be built and run in 64-bit mode on MacOSX 10.6 and
       Windows (see HighGUI and known problems below).
          * On Windows both MSVC 2008 and mingw64 are known to work.
       - In theory OpenCV is now able to determine the host CPU on-fly and
       make use of SSE/SSE2/... instructions,
          * if they are available. That is, it should be more safe to use
            WITH_SSE* flags in CMake. However, if you want maximum
            portability, it's recommended to turn on just WITH_SSE and
            WITH_SSE2 and leave other SSE* turned off, as we found that using
            WITH_SSE3, WITH_SSSE3 and WITH_SSE4_1 can yield the code
            incompatible with Intel's pre-Penryn or AMD chips.
       - Experimental "static" OpenCV configuration in CMake was contributed
       by Jose Luis Blanco.
          * Pass "BUILD_SHARED_LIBS=OFF" to CMake to build OpenCV statically.

   New Functionality, Features
     * - cxcore, cv, cvaux:
          * Grabcut (http://en.wikipedia.org/wiki/GrabCut) image segmentation
            algorithm has been implemented.
               * See opencv/samples/c/grabcut.cpp
          * new improved version of one-way descriptor is added. See
            opencv/samples/c/one_way_sample.cpp
          * modified version of H. Hirschmuller semi-global stereo matching
            algorithm that we call SGBM
               * (semi-global block matching) has been created. It is much
                 faster than Kolmogorov's graph cuts-based algorithm and yet
                 it's usually better than the block matching StereoBM
                 algorithm. See opencv/samples/c/stereo_matching.cpp.
          * existing StereoBM stereo correspondence algorithm by K. Konolige
            was noticeably improved:
               * added the optional left-right consistency check and speckle
                 filtering, improved performance (by ~20%).
          * User can now control the image areas visible after the stereo
            rectification
               * (see the extended stereoRectify/cvStereoRectify), and also
                 limit the region where the disparity is computed (see
                 CvStereoBMState::roi1, roi2; getValidDisparityROI).
          * Mixture-of-Gaussian based background subtraction algorithm has
            been rewritten for better performance
               * and better accuracy. Alternative C++ interface
                 BackgroundSubtractor has been provided, along with the
                 possibility to use the trained background model to segment
                 the foreground without updating the model. See
                 opencv/samples/c/bgfg_segm.cpp.

       - highgui:
          * MacOSX: OpenCV now includes Cocoa and QTKit backends, in addition
            to Carbon and Quicktime.
               * Therefore you can build OpenCV as 64-bit library. Thanks to
                 Andre Cohen and Nicolas Butko, which components Note however
                 that the backend are now in the alpha state, they can crash
                 or leak memory, so for anything more serious than quick
                 experiments you may prefer to use Carbon and Quicktime. To
                 do that, pass USE_CARBON=ON and USE_QUICKTIME=ON to CMake
                 and build OpenCV in 32-bit mode (i.e. select i386
                 architecture in Xcode).
          * Windows. OpenCV can now be built in 64-bit mode with MSVC 2008
            and also mingw64.
          * Fullscreen has been added (thanks to Yannick Verdie).
               * Call cvSetWindowProperty(window_name, CV_WINDOW_FULLSCREEN,
                 1) to make the particular window to fill the whole screen.
                 This feature is not supported in the Cocoa bindings yet.
          * gstreamer backend has been improved a lot (thanks to Stefano
            Fabri)

   Bug Fixes
     * - about 200 bugs have been fixed

2.0

   (September, 2009)

   New functionality, features:
     * - General:
          * New Python interface officially in.
       - MLL:
          * The new-style class aliases (e.g. cv::SVM ~ CvSVM) and the
            train/predict methods, taking cv::Mat in addition to CvMat, have
            been added. So now MLL can be used more seamlesly with the rest
            of the restyled OpenCV.

2.0 beta

   (September, 2009)

   New functionality, features:
     * General:
          * The brand-new C++ interface for most of OpenCV functionality
            (cxcore, cv, highgui) has been introduced. Generally it means
            that you will need to do less coding to achieve the same results;
            it brings automatic memory management and many other advantages.
               * See the C++ Reference section in opencv/doc/opencv.pdf and
                 opencv/include/opencv/*.hpp.
                    * The previous interface is retained and still supported.
          * The source directory structure has been reorganized; now all the
            external headers are placed in the single directory on all
            platforms.
          * The primary build system is CMake,

     * CXCORE, CV, CVAUX:
          * CXCORE now uses Lapack (CLapack 3.1.1.1 in OpenCV 2.0) in its
            various linear algebra functions (such as solve, invert, SVD,
            determinant, eigen etc.) and the corresponding old-style
            functions (cvSolve, cvInvert etc.
          * Lots of new feature and object detectors and descriptors have
            been added (there is no documentation on them yet), see cv.hpp
            and cvaux.hpp:
               * FAST - the fast corner detector, submitted by Edward Rosten
               * MSER - maximally stable extremal regions, submitted by Liu
                 Liu
               * LDetector - fast circle-based feature detector
                    * by V. Lepetit (a.k.a. YAPE)

               * Fern-based point classifier and the planar object detector -
                    * based on the works by M. Ozuysal and V. Lepetit

               * One-way descriptor - a powerful PCA-based feature
                 descriptor,
                    * S. Hinterstoisser, O. Kutter, N. Navab, P. Fua, and V.
                      Lepetit, "Real-Time Learning of Accurate Patch
                      Rectification". Contributed by Victor Eruhimov

               * Spin Images 3D feature descriptor
                    * based on the A. Johnson PhD thesis; implemented by
                      Anatoly Baksheev

               * Self-similarity features - contributed by Rainer Leinhar
               * HOG people and object detector - the reimplementation of
                 Navneet Dalal framework
                    * (http://pascal.inrialpes.fr/soft/olt/). Currently, only
                      the detection part is ported, but it is fully
                      compatible with the original training code.
                    * See cvaux.hpp and opencv/samples/c/peopledetect.cpp.
               * LBP (Local Binary Pattern) features
               * Extended variant of the Haar feature-based object detector -
                 implemented by Maria Dimashova. It now supports Haar
                 features and LBPs, other features can be added in the same
                 way.
               * Adaptive skin detector and the fuzzy meanshift tracker -
                 contributed by Farhad Dadgostar, see cvaux.hpp and
                 opencv/samples/c/adaptiveskindetector.cpp

          * The new traincascade application complementing the new-style
            HAAR+LBP object detector has been added. See
            opencv/apps/traincascade.
          * The powerful library for approximate nearest neighbor search
            FLANN by Marius Muja is now shipped with OpenCV, and the
            OpenCV-style interface to the library is included into cxcore.
            See cxcore.hpp and opencv/samples/c/find_obj.cpp
          * The bundle adjustment engine has been contributed by PhaseSpace;
            see cvaux.hp
          * Added dense optical flow estimation function based on the paper
               * "Two-Frame Motion Estimation Based on Polynomial Expansion"
                 by G. Farnerback.
               * See cv::calcOpticalFlowFarneback and the C++ documentation
          * Image warping operations (resize, remap, warpAffine,
            warpPerspective) now all support bicubic and Lanczos
            interpolation.
          * Most of the new linear and non-linear filtering operations
            (filter2D, sepFilter2D, erode, dilate ...) support arbitrary
            border modes and can use the valid image pixels outside of the
            ROI (i.e. the ROIs are not "isolated" anymore), see the C++
            documentation.
          * The data can now be saved to and loaded from GZIP-compressed
            XML/YML files, e.g.: cvSave("a.xml.gz", my_huge_matrix);
     * MLL:
          * Added the Extremely Random Trees that train super-fast, comparing
            to Boosting or Random Trees (by Maria Dimashova).
          * The decision tree engine and based on it classes (Decision Tree
            itself, Boost, Random Trees) have been reworked and now:
               * they consume much less memory (up to 200% savings)
               * the training can be run in multiple threads (when OpenCV is
                 built with OpenMP support)
               * the boosting classification on numerical variables is
                 especially fast because of the specialized low-overhead
                 branch.
          * mltest has been added. While far from being complete, it contains
            correctness tests for some of the MLL classes.
     * HighGUI:
          * [Linux] The support for stereo cameras (currently Videre only)
            has been added.
          * There is now uniform interface for capturing video from two-,
            three- ... n-head cameras.
          * Images can now be compressed to or decompressed from buffers in
            the memory, see the C++ HighGUI reference manual
     * Documentation:
          * The reference manual has been converted from HTML to LaTeX (by
            James Bowman and Caroline Pantofaru)

     * Samples, misc.:
          * Better eye detector has been contributed by Shiqi Yu, see
            opencv/data/haarcascades/*[lefteye|righteye]*.xml
          * sample LBP (Local Binary Pattern) cascade for the frontal face
            detection has been created by Maria Dimashova, see
            opencv/data/lbpcascades/lbpcascade_frontalface.xml
          * Several high-quality body parts and facial feature detectors have
            been
               * contributed by Modesto Castrillon-Santana,
               * see opencv/data/haarcascades/haarcascade_mcs*.xml

   Optimization:
     * Many of the basic functions and the image processing operations(like
       arithmetic operations, geometric image transformations, filtering
       etc.) have got SSE2 optimization, so they are several times faster.
     * The model of IPP support has been changed. Now IPP is supposed to be
       detected by CMake at the configuration stage and linked against
       OpenCV. (In the beta it is not implemented yet though).
     * PNG encoder performance improved by factor of 4 by tuning the
       parameters

1.1pre1

   (October, 2008)

   New functionality/features:
     * General:
          * Octave bindings have been added. See interfaces/swig/octave (for
            now, Linux only)
     * CXCORE, CV, CVAUX:
          * Speeded-up Robust Features (SURF), contributed by Liu Liu. see
            samples/c/find_obj.cpp and the documentation opencvref_cv.htm
          * Many improvements in camera calibration:
               * Added stereo camera calibration: cvStereoCalibrate,
                 cvStereoRectify etc.
               * Single camera calibration now uses Levenberg-Marquardt
                 method and supports extra flags to switch on/off
                 optimization of individual camera parameters
               * The optional 3rd radial distortion parameter (k3*r^6) is now
                 supported in every calibration-related function
          * 2 stereo correspondence algorithms:
               * very fast block matching method by Kurt Konolige (processes
                 the Tsukuba stereo pair in <10ms on Core2Duo laptop)
               * slow but more accurate graph-cut based algorithm by
                 Kolmogorov and Zabin
          * Better homography estimation algorithms (RANSAC and LMEDs)
          * new C++ template image classes contributed by Daniel Filip
            (Google inc.). see opencv/cxcore/include/cvwimage.h
          * Fast approximate nearest neighbor search (by Xavier Delacour)
          * Codebook method for background/foreground segmentation (by Gary
            Bradski)
          * Sort function (contributed by Shiqi Yu)
          * [OpenCV+IPP] Face Detection (cvHaarDetectObjects) now runs much
            faster (up to 2x faster) when using IPP 5.3 or higher.
          * Much faster (~4x faster) fixed-point variant of cvRemap has been
            added
     * MLL:
          * Python bindings for MLL have been added. There are no samples
            yet.
     * HighGUI:
          * [Windows, 32bit] Added support for videoInput library. Hence,
            cvcam is [almost] not needed anymore
          * [Windows, 32bit] FFMPEG can now be used for video
            decoding/encoding via ffopencv*.dll
          * [Linux] Added unicap support
          * Improved internal video capturing and video encoding APIs
     * Documentation:
          * OpenCV book has been published (sold separately :) see
            docs/index.htm)

     * New samples (opencv/samples):
          * Many Octave samples
          * find_obj.cpp (SURF), bgfg_codebook.cpp (Codebook BG/FG
            segmentation),
               * stereo_calib.cpp (Stereo calibration and stereo
                 correspondence)

Fixed "test ==" and the path to the Python interpreter, but did not add
a dependency.

PKGREVISION++

Import OpenCV 1.0.0, pkg/34655 from Anthony Mallet.

OpenCV means Intel(R) Open Source Computer Vision Library. It is a
collection of C functions and a few C++ classes that implement many
popular Image Processing and Computer Vision algorithms.

OpenCV provides cross-platform middle-to-high level API that includes
about 300 C functions and a few C++ classes. Also there are Python
bindings to OpenCV. OpenCV has no strict dependencies on external
libraries, though it can use some (such as libjpeg, ffmpeg, GTK+ etc.)

OpenCV provides transparent interface to Intel(R) Integrated Performance
Primitives (IPP). That is, it loads automatically IPP libraries optimized
for specific processor at runtime, if they are available.

Initial revision