OpenCV Changelog

What's new in OpenCV 4.9.0

Dec 28, 2023
  • Core Module:
  • TBD
  • DNN module patches:
  • Experimental transformers support
  • ONNX attention layer support
  • ONNX Einsum layer support
  • OpenVINO backend for INT8 models
  • ONNX Gather Elements layer
  • ONNX InstanceNorm layer
  • Improved DNN graph fusion with shared nodes and commutative operations
  • New fastGEMM implementation and several layers on top of it.
  • Winograd fp16 optimizations on ARM
  • Tests and multiple fixes for Yolo family models support
  • New layers support and bug fixes in CUDA backend: GEMM, Gelu, Add

New in OpenCV 4.8.0 (Jun 28, 2023)

  • DNN module patches:
  • #23161, #23409 TFLite models support, including int8 quantized models.
  • #23604 Enabled DNN module build without Protobuf dependency.
  • Improved layers / supported more models:
  • ONNX: #23047 Layer normalization, #23219 GELU and #23655 QLinearSoftmax.
  • Fixes in CANN backend:
  • #23319 support ONNX Split, Slice, Clip (Relu6) and Conv with auto_pad.
  • #23401 support ONNX Sub, PRelu, ConvTranspose.
  • #23613 Reduce Refactor for robustness and potential follow-up improvements.
  • #23491 Fixes for Segment Anything Model by Meta.
  • Fixes in nary element wise layer about broadcast:
  • #23557 Fixes in CPU.
  • #23528 and #23560 Fixes in CUDA backend.
  • Improve DNN speed on ARM and X86, add Winograd branch for Convolution layer.
  • Add full FP16 computation branch on ARMv8 platform, twice faster than before.
  • #22957 Modern OpenVINO support.
  • G-API module:
  • TBD
  • Objdetect module:
  • #23020 FaceDetectorYN upgrade for better performance, accuracy and facial landmarks support.
  • #23264 New QR code detection algorithm based on ArUco code.
  • #23666 Bar code detector and decoder moved from Contrib to main repository.
  • #23758 Introduced common API for all graphical codes like bar codes and QR codes.
  • #23153 Added flag for legacy pre-4.6.0 ChAruco boards support.
  • Multiple bug fixes and improvements in QR code detection and decoding pipelines.
  • Multiple bug fixes and improvements in ArUco based pipelines.
  • Calibration module:
  • #23078 USAC framework improvements.
  • #23025 Fixed stddev estimation in camera calibration pipelines.
  • #23305 Fixed incorrect pixel grid generation in icvGetRectangles that improves accuracy of getOptimalNewCameraMatrix, stereoRectify and some other calibration functions.
  • Charuco board support in patterns generator, interactive calibration tool and calibration samples.
  • Image processing module:
  • #23210, #23388 Various fixes in line segments detector.
  • #23634 Fixed even input dimensions for INTER_NEAREST_EXACT in resize.
  • #21959 Optimise local cost computation in IntelligentScissorsMB::buildMap.
  • Keep inliers for linear remap with BORDER_TRANSPARENT #23754
  • #22798 Fix distransform to work with large images.
  • Feature2d module:
  • #23124 SIFT accuracy improvements.
  • Core module:
  • #13879 Added REDUCE_SUM2 option to cv::reduce.
  • #22947 Introduced cv::hasNonZero function.
  • #23443 Update IPP binaries update to version 20230330.
  • Improved RISC-V RVV vector extensions support.
  • Several OpenCL vendor and version handling improvements.
  • Multimedia:
  • #23596 Added AVIF support through libavif.
  • #23237 Orbbec Femto Mega cameras support.
  • #23172 HEVC/H265 support in VideoWriter with MS Media Foundation backend.
  • #23692 Fixed FPS computation on some videos for FFmpeg backend.
  • #23300 Added support for VideoCapture CAP_PROP_AUTO_WB and CV_CAP_PROP_WHITE_BALANCE_BLUE_U for DShow backend.
  • #23460, #23469 Fixes OBS Virtual Camera capture.
  • #23433 CV_32S encoding support with tiff.
  • #3486, #3453 More strict decoder checks and dynamic resolution support in cudacodec module (opencv_contrib).
  • #3485 Added basic VideoCapture properties support to cudacodec module (opencv_conrib).
  • Python Bindings:
  • #20370 Python typing stubs.
  • #23350 Fix reference counting errors in registerNewType.
  • #23399, #23436, #23138 Fixed ChAruco and diamond boards detector bindings.
  • #23371 Added bindings to allow GpuMat and Stream objects to be initialized from memory initialized in other libraries
  • #23691 np.float16 support.
  • Python bindings for RotatedRect, CV_MAKETYPE, CV_8UC(n).
  • JavaScript bindings:
  • #23344 Added possibility for disabling inlining wasm in opencv.js
  • Extended JS bindings for Aruco, Charuco, QR codes and bar codes.
  • Platforms:
  • #21736 Android: don't require deprecated tools.
  • #23768 iOS: Fixed framework build issues with CMake 3.25.1+.
  • Other:
  • Several critical issue fixes in wechat_qrcode module (opencv_contrib)

New in OpenCV 4.7.0 (Dec 28, 2022)

  • DNN:
  • New ONNX layers: TBD
  • Signinficant performance optimization for convolutions. Winograd algoritm implementation.
  • TBD - Broadcasting.
  • OpenVino 2022.1 support.
  • Algorithms:
  • ArUco markers and April tags support including ChAruco and diamond boards detection and calibration.
  • QR code detection and decoding quality imrovement. Alignment markers support. Benchmark for QR codes: link
  • Nanotrack v2 tracker based on neural networks.
  • Stackblur algoruthm implementation.
  • Multimedia:
  • FFmpeg 5.x support.
  • CUDA 12.0 support. Hardware accelerated video codecs support on NVIDIA platforms with modern Video Codec SDK (NVCUVID and NVENCODEAPI).
  • CV_16UC1 read/write video support with FFmpeg.
  • Orientation meta support on Mac with native media API.
  • New iterator-based API for multi-page image formats.
  • LibSPNG support for PNG format.
  • SIMD acceleration for self-built libJPEG-Turbo
  • H264/H265 support on Android. Multiple fixes for video decoder, endcoder and camera memory layout.
  • G-API:
  • Exposed all core APIs to Python, including stateful kernels.
  • Optimization:
  • New universal intrinsics backend for scalable vector instructions. The first scalable implementation for RISC-V RVV 1.0.
  • DNN module patches:
  • Improved layers / supported more models:
  • Scatter and ScatterND #22529, Tile #22809
  • Fixes in Slice (support negative step #22898)
  • Support some reduce layers of ONNX #21601
  • Added CANN backend support #22634. Link to the manual: https://github.com/opencv/opencv/wiki/Huawei-CANN-Backend.
  • Added bacthed NMS for multi-class object detection #22857
  • Accelerating convolution, especially for ARM CPU. #21910 and #22905
  • Winograd's convolution optimization

New in OpenCV 4.6.0 (Jun 7, 2022)

  • Highlights of this release:
  • OpenCV project infrastructure migrating on GitHub Actions workflows for CI and release purposes
  • Added support for GCC 12, Clang 15
  • Added support for FFmpeg 5.0
  • DNN module patches:
  • Improved layers / activations / supported more models:
  • LSTM (+CUDA), resize (+ONNX13), Sign, Shrink, Reciprocal, depth2space, space2depth
  • fixes in Reduce, Slice, Expand
  • Disabled floating-point denormals processing #21521
  • Changed layer names in ONNX importer to support "output" entities properly
  • Added TIM-VX NPU backend support: https://github.com/opencv/opencv/wiki/TIM-VX-Backend-For-Running-OpenCV-On-NPU
  • Added Softmax parameter to ClassificationModel
  • Added audio speech recognition sample (C++) #21458
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • added initial support for OpenVINO 2022.1 release
  • removed support of legacy API (dropped since 2020.3)
  • G-API module:
  • G-API framework:
  • Introduced a Grayscale image format support for cv::MediaFrame: #21511;
  • Enabeled .reshape() support in the CPU backend: #21669;
  • Fixed possible hang in streaming execution mode with constant inputs: #21567;
  • Introduced proper error/exception propagation in the asynchronous streaming execution mode: #21660;
  • Fixed new stream event handling: #21731.
  • Fluid backend:
  • Fixed horizontal pass in the Resize kernel, fixed Valgrind issues: #21144;
  • Extended Resize kernel with F32 version: #21678, added AVX: #21728.
  • Enabled dynamic dispatch for Split4 kernel: #21520;
  • Enabled dynamic dispatch for Merge3 kernel: #21529;
  • Added a SIMD version for DivC kernel: #21474;
  • Added a SIMD version for DivRC kernel: #21530;
  • Enabled dynamic dispatch for Add kernel: #21686;
  • Enabled dynamic dispatch for Sub kernel: #21746;
  • Added a SIMD version for ConvertTo kernel: #21777;
  • Fixed kernel matrix size for Sobel kernel: #21613.
  • OpenCL backend:
  • Intel® OpenVINO™ inference backend:
  • Fixed NV12 format support for remote memory when OpenVINO™ remote context is used: #21424.
  • Implemented correct error handling in the backend: #21579.
  • Fixed ngraph warnings #21362.
  • OpenCV AI Kit backend:
  • Introduced a new backend to program OpenCV AI Kit boards via G-API. Currently the backend is in experimental state, but allows to build Camera+NN pipeline and supports heterogeneity (mixing with host-side code): #20785, #21504.
  • Media integration:
  • Enabled GPU inference with oneVPL and DirectX11 on Windows in Intel® OpenVINO™ inference backend: #21232, #21618, #21658, #21687, #21688. Now GPU textures decoded by oneVPL decoder can be preprocessed and inferred on GPU with no extra host processing.
  • Enabled oneVPL support on Linux: #21883.
  • Extended GStreamer pipeline source with Grayscale image format support: #21560.
  • Python bindings:
  • Exposed GStreamer pipeline source in Python bindings: #20832.
  • Fixed Python bindings for CudaBufferPool, cudacodec and cudastereo modules in OpenCV Contrib.
  • Samples:
  • Introduced a pipeline modelling tool for cascaded model benchmarking: #21477, #21636, #21719. The tool supports a declarative YAML-based config to describe pipelines with simulated pre-/post-processing. The tool collects and reports latency and throughput information for the modelled pipeline.
  • Other changes and fixes:
  • Moved GKernelPackage into cv:: namespace by default, its cv::gapi:: alias remain for compatibility: #21318;
  • Moved Resize kernel from core to imgproc kernel packages for CPU, OpenCL, and Fluid backends: #21157. Also moved tests appropriately: #21475;
  • Avoided sporadic test failures in DivC: #21626;
  • Fixed 1D Mat handling in the framework: #21782;
  • Reduced the number of G-API generated accuracy tests: #21909.
  • And many other contributions:
  • Support downloading 3rdparty resources from Gitcode & Gitlab-style mirrors #21531
  • Added NEON support in builds for Windows on ARM #21630
  • Add n-dimensional transpose to core #21703
  • (opencv_contrib) Add Connected Components Labeling in CUDA #3153

New in OpenCV 4.5.5 (Dec 26, 2021)

  • Highlights of this release:
  • Audio support as part of VideoCapture API: MSMF #19721 + GStreamer #21264
  • Updated SOVERSION handling rules: #21178
  • DNN module patches:
  • Added tests to cover ONNX conformance test suite: #21088
  • Improved layers / activations / supported more models
  • Upgraded builtin protobuf from 3.5.2 to 3.19.1
  • More optimizations for RISC-V platform
  • Intel® Inference Engine backend ( OpenVINO ):
  • added support for OpenVINO 2021.4.2 LTS release
  • G-API module:
  • G-API framework:
  • Fixed issue with accessing 1D data from cv::RMat: #21103;
  • Restricted passing the G-API types to graph inputs/outputs for execution: #21041;
  • Various fixes in G-API Doxygen reference: #20924;
  • Renamed various internal structures for consistency #20836 #21040;
  • Fluid backend:
  • Introduced a better vectorized version of Resize: #20664.
  • Added vectorized version of Multiply kernel: #21024;
  • Added vectorized version of Divide kernel: #20914;
  • Added vectorized version of AddC kernel: #21119;
  • Added vectorized version of SubC kernel: #21158;
  • Added vectorized version of MulC kernel: #21177;
  • Added vectorized version of SubRC kernel: #21231;
  • Enabled SIMD dispatching for AbsDiffC: #21204;
  • OpenCL backend:
  • Fixed sporadic test failures in Multiply kernel running on GPU: #21205;
  • Intel OpenVINO inference backend:
  • Extended ie::Params to support static batch size as input to inference: #20856;
  • Enabled 2D input tensor support in IE backend: #20925;
  • Fixed various issues with imported (pre-compiled) networks: #20918;
  • Media integration:
  • Introduced a GStreamer-based pipeline source for G-API: #20709;
  • Completed the integration of Intel® oneVPL as a pipeline source for G-API #20773 with device selection #20738, asynchronous execution #20901, intial demux support #21022, and GPU-side memory allocation via DirectX 11 #21049.
  • Samples:
  • Replaced custom kernels with now-standard G-API operations in several samples #21106;
  • Moved API snippets from G-API samples to a dedicated place #20857;
  • Other changes and fixes:
  • Fixed various static analysis issues for OpenVINO 2021.4 release: #21083 and #21212;
  • Fixed various build warnings introduced after OpenVINO update: #20937;
  • Continued clean-up in the G-API test suite on GTest macros #20922 and test data #20995;
  • Added custom accuracy comparison functions to Fluid performance tests: #21150.
  • And many other contributions:
  • Added QRcode encoder: #17889
  • GSoC - OpenCV.js: Accelerate OpenCV.js DNN via WebNN: #20406
  • Add conventional Bayer naming: #20970
  • (opencv_contrib) Add Radon transform function to ximgproc: #3090
  • (opencv_contrib) New superpixel algorithm (F-DBSCAN): #3093
  • Created Stitching Tool: #21020
  • Improve CCL with new algorithms and tests: #21275
  • (opencv_contrib) Update ArUco tutorial: #3126

New in OpenCV 4.5.4 (Oct 10, 2021)

  • Highlights of this release:
  • GSoC 2021 is over. 11 projects are successful, and most of the results are already merged into OpenCV tree and available in 4.5.4 (in the main repository or in opencv_contrib). Here is the list of merged functionality:
  • 8-bit quantization in DNN Module: #20228 + onnx importer #20535
  • Improved OpenCV bindings for Julia: opencv_contib#3009
  • Speech recognition sample: #20291
  • Optimizing OpenCV DNN for RISC-V: #20287 + #20521
  • Tutorial for Universal Intrinsics and parallel_for_ for efficient cross-platform algorithm implementation: #20361
  • DNN module patches:
  • Improved layers / activations / supported more models:
  • GRU, CumSum, Max, Min, ExpandDims
  • Fixed convolution with asymmetric padding
  • Fixed Unsqueeze (ONNX opset 13)
  • Fixed several memory access issues in OpenCL kernels
  • Implement CTC prefix beam search decode for TextRecognitionModel: #20524
  • Added SoftNMS implementation: #20813
  • Intel Inference Engine backend ( OpenVINO ):
  • added support for OpenVINO 2021.4.1 LTS release
  • added support for models with non-FP32 outputs or for outputs with 1D layout
  • G-API module:
  • TBD
  • And many other contributions:
  • Add DNN-based face detection and face recognition into modules/objdetect: #20422
  • Restore LineSegmentDetector (LSD) implementation
  • Python: cv.Mat wrapper over numpy.ndarray is introduced to handle issues with passing of 3D arrays into C++ algorithms: #19091
  • Python: support OpenCV extension with pure Python modules: #20611
  • Debugging: Add gdb pretty printer for cv::Mat: #20547
  • Add Quicklook for Mat on iOS and macOS: #20457
  • Add generation of new type of radon checkerboard: #20735

New in OpenCV 4.5.3 (Jul 6, 2021)

  • Highlights of this release:
  • highgui: added support for UI backends. Special OpenCV builds allow to select UI backend and/or load it dynamically through plugins.
  • videoio: supported UMat/OpenCL hardware-accelerated video decoding/encoding through FFmpeg backend.
  • video: DaSiamRPN tracker is implemented as OpenCV algorithm.
  • DNN module:
  • Improved layers / activations / supported more models:
  • optimized: MatMul support in CUDA backend (#20138)
  • fixed: BatchNorm reinitialization (#20283)
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • added support for OpenVINO 2021.4 LTS release
  • enabled OpenCL kernels cache in IE clDNN plugin (#20006)
  • G-API module:
  • Python support:
  • Introduced a new Python Operation API: now G-API can be extended with new graph operations in Python directly: #19982;
  • Extended Python bindings with more G-API confuration options: specifying arbitrary number of NN models for the pipeline (#20157), graph compile arguments (#20196).
  • Exposed more G-API operations in Python bindings: parseSSD, parseYolo, copy, timestamp, seq_id (#20271).
  • Inference support:
  • Added FP16 data type handling in the OpenVINO™ inference backend;
  • Introduced inference with remote context in the OpenVINO™ inference backend (#20156), also extended cv::MediaFrame data structure to carry extra information about remote memory when possible (20151);
  • Operations:
  • Added Transpose operation (#20107);
  • Fixed a possible ambiguous overload problem in parseSSD operation.
  • Demos:
  • Introduced a MTCNN object detection demo. This demo highlights how to combine Deep Learning with a non-trivial user-defined pre- and post-processing in G-API: #19923;
  • Other changes:
  • Added a new graph compile option to specify the internal queue capacity in the Streaming mode -- this option may be used to fine-tune the execution behavior from a throughput-oriented (default) to a latency oriented mode: #20119;
  • Added ITT instrumentation in the Streaming executor -- now different parts of the pipeline execution can be highlited in the Intel® VTune™ Profiler.
  • Fixed issue with passing empty data inputs to the graph: #20184.
  • Documentation:
  • Extended the Doxygen reference with new structures/method description for Generic inference (#20169), OpenVINO™ inference parameters (#20112), Stereo, cv::MediaFrame (#20238), and other API parts.
  • Documentation:
  • Updated documentation to address plugin support modes / build options: #20194
  • And many other great contributions from OpenCV community:
  • samples: added PaddlePaddle classification model conversion case: #19976
  • core: fix dynamic loading of clBLAS and clFFT: #20203
  • imgproc: improved implementation of rotatedRectangleIntersection: #19842
  • (opencv_contrib) 1D Barcode support: #2757

New in OpenCV 4.5.2 (Apr 3, 2021)

  • core: added support for parallel backends. Special OpenCV builds allow to select parallel backend and/or load it dynamically through plugins
  • imgproc: added IntelligentScissors implementation (JS demo). The feature is integrated into CVAT annotation tool and you can try it online on https://cvat.org
  • videoio: improved hardware-accelerated video decoding/encoding tasks. Wiki page
  • DNN module:
  • Improved debugging of TensorFlow parsing errors: #19220
  • Improved layers / activations / supported more models:
  • optimized: NMS processing, DetectionOutput
  • fixed: Div with constant, MatMul, Reshape (TensorFlow behaviour)
  • added support: Mish ONNX subgraph, NormalizeL2 (ONNX), LeakyReLU (TensorFlow), TanH (Darknet), SAM (Darknet), Exp
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • added support for OpenVINO 2021.3 release
  • G-API module:
  • Python support:
  • Introduced a new Python backend - now G-API can run custom kernels written in Python as part of the pipeline: #19351;
  • Extended Inference support in the G-API Python bindings: #19318;
  • Added more graph data types support in the G-API Python bindings: #19319;
  • Python support:
  • Introduced a new Python backend - now G-API can run custom kernels written in Python as part of the pipeline: #19351;
  • Extended Inference support in the G-API Python bindings: #19318;
  • Added more graph data types support in the G-API Python bindings: #19319;
  • Inference support:
  • Introduced dynamic input / CNN reshape functionality in the OpenVINO inference backend #18240;
  • Introduced asynchronous execution support in the OpenVINO inference backend, now inference can run in multiple requests in parallel to increase stream density/throughput: #19487, #19425;
  • Extended supported data types with INT64/INT32 in ONNX inference backend and with INT32 in the OpenVINO inference backend #19792;
  • Introduced cv::GFrame / cv::MediaFrame and constant support in the ONNX backend: #19070;
  • Media support:
  • Introduced cv::GFrame / cv::MediaFrame support in the drawing/rendering interface: #19516;
  • Introduced multi-stream input support in Streaming mode and frame synchronization policies to support cases like Stereo: #19731;
  • Added Y and UV operations to access NV12 data of cv::GFrame at the graph level; conversions are done on-the-fly if the media format is different: #19325;
  • Operations and kernels:
  • Added performance tests for new operations (MorphologyEx, BoundingRect, FitLine, FindContours, KMeans, Kalman, BackgroundSubtractor);
  • Fixed RMat input support in the PlaidML backend: #19782;
  • Added ARM NEON optimizations for Fluid AbsDiffC, AddWeighted, and bitwise operations: #18466, #19233;
  • Other various static analysis and warning fixes;
  • Documentation:
  • [GSoC] Added TF and PyTorch classification conversion cases: #17604
  • [GSoC] Added TF and PyTorch segmentation conversion cases: #17801
  • [GSoC] Added TF and PyTorch detection model conversion cases: #18237
  • Updated documentation to address Wide Universal Intrinsics (WUI) SIMD API: #18952
  • And many other great contributions from OpenCV community:
  • core: add cuda::Stream constructor with cuda stream flags: #19286
  • highgui: expose VSYNC window property for OpenGL on Win32: #19408
  • highgui: pollKey() implementation for w32 backend: #19411
  • imgcodecs: Added Exif parsing for PNG: #19439
  • imgcodecs: OpenEXR compression options: #19540
  • imgproc: connectedComponents optimizations: (Spaghetti Labeling): #19631
  • videoio: Android NDK camera support #19597
  • (opencv_contrib) WeChat QRCode module open source: #2821
  • (opencv_contrib) Implemented cv::cuda::inRange(): #2803
  • (opencv_contrib) Added algorithms from Edge Drawing Library: #2313
  • (opencv_contrib) Added Python bindings for Viz module: #2882

New in OpenCV 4.5.1 (Dec 22, 2020)

  • Highlights of this release:
  • OpenCV repository reached over 50k stars on GitHub: Thank you to all for your contribution in this great project!
  • Continued merging of GSoC 2020 results
  • Develop OpenCV.js DNN modules for promising web use cases together with their tutorials (#18064)
  • OpenCV.js: WASM SIMD optimization 2.0 (#18068)
  • High Level API and Samples for Scene Text Detection and Recognition (#17570)
  • SIFT: SIMD optimization of GaussianBlur 16U (#18983)
  • DNN module:
  • Improved layers / activations / supported more models
  • Optimized - 1D convolution, 1D pool
  • Fixed - Resize, ReduceMean, Gather with multiple outputs, importing of Faster RCNN ONNX model
  • Added support: INT32 ONNX tensors
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • Added support for OpenVINO 2021.2 release
  • Added preview support for HDDL
  • Fixes and optimizations in DNN CUDA backend (thanks to @YashasSamaga): PRs
  • G-API module:
  • G-API Framework
  • Introduced serialization for cv::RMat, including serialization for user-defined memory adapters (#18584);
  • Introduced desync, a new Operation for in-graph asynchronous execution - to allow different parts of the graph run with a different latency (#18673);
  • Introduced a notion of "in-graph metadata" (#18793), now various media-related information can be accessed in graph directly (currently only limited to timestamps and frame IDs);
  • Introduced a new generic task-based executor, based on Threading Building Blocks (TBB) (#17851);
  • Extended infer<>() API to accept a new cv::GFrame data structure to allow handling of various media formats without changes in the graph structure (#19002);
  • Made copy() an intrinsic where real copy may not happen (optimized out) based on graph structure, extended it to support cv::GFrame (#19009), (#19112);
  • Various fixes, including addressig static analysis, documentation, and test issues;
  • G-API Operations:
  • Introduced new operations morphologyEx (#18652), boundingRect (#18510), fitLine (#18790), kmeans (#18857), Background Subtractor (#18674), Kalman filter (#18869);
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • Extended cv::gapi::ie::Params<> to import CNN networks (e.g. pre-compiled ones) instead of passing .XML and .BIN files (#18542); also enabled configuring Inference Engine plugins via this structure (#18701);
  • Added a new overload to infer<>() to run inference over a single region of interest (#18673);
  • Added support for cv::MediaFrame input data type (projected from cv::GFrame) and handling for NV12 input image format (#19002);
  • Microsoft® ONNX Runtime backend:
  • Introduced a new inference backend, powered by Microsoft ONNX Runtime (#18716), follow this instruction to enable ONNX Runtime support in G-API;
  • Python bindings:
  • Exposed G-API's Inference (#18491) and Streaming (#18493) APIs in the OpenCV Python bindings;
  • Added initial Python support for cv::GArray data structure (#18762);

New in OpenCV 4.5.0 (Oct 12, 2020)

  • Highlights of this release:
  • OpenCV 4.5.0 licence has been changed to Apache 2: OE-32 - Change OpenCV License to Apache 2
  • OpenJPEG replaces Jasper in distributed Windows packages: #18194
  • Added support for OpenCL multiple contexts
  • DNN module:
  • Improved layers / activations / supported more models:
  • ONNX: ReduceSum, Gather, improved Reshape
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • added support for OpenVINO 2021.1 release
  • Fixes and optimizations in DNN CUDA backend (thanks to @YashasSamaga): PRs
  • G-API module:
  • Added Python bindings for the general G-API (#17493), inference and streaming support are currently in progress.
  • Introduced serialization API, currently limited. A graph can be serialized to a byte stream (std::vector) and then reconstructed back to a cv::GComputation object.
  • OpenVINO NN backend has been moved to the latest OpenVINO "Core" APIs.
  • Now it is easier to declare a graph with a dynamic number of inputs or outputs (GIn() / GOut() support operator+=).
  • Added "mask", extended "convertTo" with 16S, also added performance tests on Core kernels for the Fluid backend.
  • Added standard NN post-processing operations like parseYolo and parseSSD to turn NN results into a structured graph-based data format (e.g. GArray<Rect>).
  • Added value initialization for GArray<T> so now one can write:
  • cv::GArray<int> arr = std::vector<int> { 1, 2, 3 };
  • to associate a cv::GArray<> with a value at graph construction stage.
  • cv::GMat bitwise operators are extended with a cv::GScalar operand.
  • Introduced a new graph data type cv::GFrame and its data storage type cv::MediaFrame to start handling media-oriented formats (like NV12 or YUV images with external memory) in the graph.
  • And many other great contributions from OpenCV community:
  • flann module fixes / improvements by @pemmanuelviel: PRs
  • Add Robot-World/Hand-Eye calibration function: #18203
  • GSoC 2020 merged projects:
  • GSoC: Better SIFT in the main repository
  • GSoC: Improvement of Random Sample Consensus in OpenCV #17683
  • GSoC: Real-time Single Object Tracking using Deep Learning: #17647
  • GSoC: Revise/improve Text and Digit Recognition Samples: #17675
  • GSoC: Optimize OpenCV for RISC-V: #17922
  • GSoC (opencv_contrib): OpenCV bindings for Julia
  • GSoC (opencv_contrib): Implement Macbeth Chart detector and AprilTag3: #2532
  • GSoC (opencv_contrib): Depth Fusion for large scale environments #2566

New in OpenCV 4.4.0 (Jul 18, 2020)

  • Highlights of this release:
  • SIFT (Scale-Invariant Feature Transform) algorithm has been moved to the main repository (patent on SIFT is expired)
  • DNN module:
  • Improved layers / activations / supported more models
  • State-of-art Yolo v4 Detector: #17148. Disabled per-layer NMS for [yolo] layers (Yolo v3 and Yolo v4) as incorrect - use cv::dnn::NMSBoxes over all the detections.
  • ONNX: Add support for Resnet_backbone (Torchvision) #16887
  • EfficientDet models support: #17384
  • New samples / demos
  • add text recognition sample: C++ / Python
  • FlowNet2 optical flow: #16575
  • Intel Inference Engine backend ( OpenVINO)
  • added support for OpenVINO 2020.3 LTS / 2020.4 releases
  • support of NN Builder API is planned for removal in the next release
  • Many fixes and optimizations in CUDA backend (thanks to @YashasSamaga): PRs
  • G-API module:
  • Introduced a new API for stateful kernels in OpenCV backend: GAPI_OCV_KERNEL_ST. Stateful kernels preserve their state among the individual graph executions (in the standard more) or among the video frames of the stream (in the streaming mode).
  • Introduced more video-oriented operations in G-API: goodFeaturesToTrack, buildOpticalFlowPyramid, calcOpicalFlowPyrLK.
  • Added few more image processing kernels: Laplacian and bilateral filters.
  • Fixed a potential crash in G-API's OpenCL backend.
  • And many other great contributions from OpenCV community:
  • Obj-C / Swift bindings: #17165
  • (opencv_contrib) Julia bindings as part of ongoing GSoC project: #2547
  • (opencv_contrib) BIMEF: A Bio-Inspired Multi-Exposure Fusion Framework for Low-light Image Enhancement: #2448
  • Enable Otsu thresholding for CV_16UC1 images: #16640
  • Add Stroke Width Transform algorithm for Text Detection: #2464
  • Planned migration on Apache 2 license for next releases OE-32 #17491

New in OpenCV 4.3.0 (Apr 4, 2020)

  • DNN module:
  • Improved layers / activations / supported more models:
  • ONNX: LSTM, Broadcasting, Algebra over constants, Slice with multiple inputs
  • DarkNet: grouped convolutions, sigmoid, swish, scale_channels
  • MobileNet-SSD v3: #16760
  • New samples / demos:
  • Clothes parts segmentation and CP-VTON
  • DaSiamRPN tracker
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • added support for custom layers through nGraph OpenVINO API: #16628
  • nGraph OpenVINO API is used by default: #16746
  • Many fixes and optimizations in CUDA backend (thanks to @YashasSamaga): PRs
  • OPEN AI LAB team submitted the patch that accelerates OpenCV DNN on ARM using their Tengine library:

New in OpenCV 4.2.0 (Dec 21, 2019)

  • Highlights of this release:
  • DNN module:
  • Integrated GSoC project with CUDA backend: #14827
  • Intel® Inference Engine backend ( OpenVINO™ ):
  • support for nGraph OpenVINO API (preview / experimental): #15537
  • Performance improvements:
  • SIMD intrinsics: StereoBM/StereoSGBM algorithms, resize, integral, flip, accumulate with mask, HOG, demosaic, moments
  • Muti-threading: pyrDown
  • And many other great patches from OpenCV community:
  • VideoCapture: video stream extraction (demuxing) through FFmpeg backend.
  • VideoCapture: waitAny() API for camera input multiplexing (Video4Linux through poll() calls).
  • (opencv_contrib) new algorithm Rapid Frequency Selective Reconstruction (FSR): #2296 + tutorial.
  • (opencv_contrib) RIC method for sparse match interpolation: #2367.
  • (opencv_contrib) LOGOS features matching strategy: #2383.
  • Breaking changes:
  • Disabled constructors for legacy C API structures.
  • Implementation of Thread Local Storage (TLS) has been improved to release data from terminated threads. API has been changed.
  • Don't define unsafe CV_XADD implementation by default.
  • Python conversion rules of passed arguments will be updated in next releases: #15915.

New in OpenCV 4.1.2 (Oct 10, 2019)

  • DNN module:
  • Intel(R) Inference Engine backend (OpenVINO(TM)):
  • 2019R3 has been supported
  • Support modern IE Core API
  • New approach for unsupported layers management. Now all the OpenCV layers fallbacks are implemented as IE custom layers which helps to improve efficiency due less graph partitioning.
  • High-level API which introduces dnn::Model class and set of task-specific classes such dnn::ClassificationModel, dnn::DetectionModel, dnn::SegmentationModel. It supports automatic pre- and post-processing for deep learning networks.
  • Performance improvements and platforms support:
  • MSA SIMD implementation has been contributed for MIPS platforms: https://github.com/opencv/opencv/pull/15422
  • OpenCV.js optimization (threading and SIMD as part of GSoC project): https://github.com/opencv/opencv/pull/15371
  • More optimizations using SIMD intrinsics: dotProd, FAST corners, HOG, LK pyramid (VSX), norm, warpPerspective, etc
  • Fixed detection of Cascade Lake
  • And many other great patches from OpenCV community:
  • GUI: support topmost window mode (Win32/COCOA): https://github.com/opencv/opencv/pull/14872
  • Java: fix Mat.toString() for higher dimensions: https://github.com/opencv/opencv/pull/15181
  • Implementation of colormap "Turbo" https://github.com/opencv/opencv/pull/15388
  • QR-Code detection accuracy improvement: https://github.com/opencv/opencv/pull/15356
  • GSoC: Add learning-based super-resolution module: https://github.com/opencv/opencv_contrib/pull/2229 and https://github.com/opencv/opencv_contrib/pull/2231
  • Detection accuracy improvement of the white marker aruco corners: https://github.com/opencv/opencv_contrib/pull/2236
  • Added pattern generator tool for aruco: https://github.com/opencv/opencv_contrib/pull/2250
  • and special thanks to @sturkmen72 for improvind and cleaning up code of samples/tutorials
  • Breaking changes:
  • fixed values thresholding accuracy in calcHist()

New in OpenCV 4.1.1 (Jul 26, 2019)

  • DNN module:
  • TBD
  • Performance improvements:
  • AVX512 SIMD backend for wide universal intrinsics (w.u.i.)
  • More optimizations using wide universal intrinsics
  • Android support:
  • Added CameraActivity utility class to automate Camera permission handling on Android
  • Changed default C++ runtime: c++_static -> c++_shared
  • Unified code for frame size selection between JavaCamera2View / JavaCameraView
  • And many other great patches from OpenCV community:
  • Added IPPE method for planar pose estimation in solvePnP ( https://github.com/opencv/opencv/pull/14362 )
  • Added solvePnPRefineLM and solvePnPRefineVVS ( https://github.com/opencv/opencv/pull/14431 )
  • Logging revamp ( https://github.com/opencv/opencv/pull/13909 by @kinchungwong )
  • opencv_contrib: Tracking-by-Matching approach
  • opencv_contrib: added AR samples into ovis module
  • Breaking changes:
  • solveP3P, solvePnP and solvePnPGeneric return result in double precision unless the parameters are not empty

New in OpenCV 4.1.0 (Apr 8, 2019)

  • DNN module:
  • Reduced peak memory consumption for some models up to 30%.
  • Inference Engine
  • Inference Engine 2018R3 is now a minimal supported version of IE.
  • Myriad X (Intel® Neural Compute Stick 2) is now supported and tested.
  • Automatic IR network reshaping for different inputs.
  • Improved samples to work with models from OpenVINO Open Model Zoo
  • New networks from TensorFlow Object Detection API: Faster-RCNNs, SSDs and Mask-RCNN with dilated convolutions, FPN SSD
  • Performance improvements:
  • More optimization using AVX2 instruction set.
  • Automatic runtime dispatching is available for large set of functions from core and imgproc modules.
  • Android support:
  • VideoCapture C++ interface supports Android Media NDK (21+) video I/O file capture back-end

New in OpenCV 3.4.4 (Nov 20, 2018)

  • What's new:
  • Further improvements in the DNN module include faster R-CNN support, Javascript bindings and acceleration of OpenCL implementation.
  • We've implemented a disk cache and manual loading for precompiled OpenCL kernel binaries, it can greatly reduce initialization time of many applications and allow to run OpenCL implementations on embedded platforms without JIT compiler.
  • One more bit-exact algorithm has been implemented. New 8-bit bilinear resize will lay stable base for complex computer vision pipelines across variety of platforms.
  • One more GSoC project has been integrated - it adds implementations of new background subtraction algorithms.
  • 250 patches have been merged since OpenCV 3.3.1 and over 200 issues have been closed

New in OpenCV 4.0.0 Alpha (Oct 16, 2018)

  • OpenCV is now C++11 library and requires C++11-compliant compiler. Note that OpenCV 3.x can also be built as C++11 library by passing -DENABLE_CXX11=ON flag to CMake. Now this is the only option so the flag is not needed and is not available anymore.
  • Thanks to the extended C++11 standard library, we could get rid of hand-crafted cv::String and cv::Ptr. Now cv::String == std::string and cv::Ptr is a thin wrapper on top of std::shared_ptr. Also, on Linux/BSD for cv::parallel_for_ we now use std::thread's instead of pthreads
  • Added support for Mask-RCNN model. Follow a guide and use a python sample.
  • Integrated ONNX parser. We now support many popular classification networks. YOLO object detection network in partially supported as well (ONNX version of YOLO lacks some final layers that actually give you the list of rectangles). Thanks to Lubov Batanina for her first-time contribution to OpenCV!
  • Further improved performance of DNN module when it's built with Intel DLDT support by utilizing more layers from DLDT.
  • API changes: by default, blobFromImage methods family do not swap red and blue channels and do not crop the input image. Beware that this API change has also been propagated to OpenCV 3.4 branch.
  • Added shortcuts for the most popular deep learning networks supported by OpenCV. You may specify an alias name of model to skip pre-processing parameters and even paths to models!
  • Fixed OpenCL target for AMD and NVIDIA GPUs. Now you may enable DNN_TARGET_OPENCL for your model without extra environment variables. Please note that DNN_TARGET_OPENCL_FP16 is tested on Intel GPUs only so it still requires additional flags.
  • Performance improvements:
  • A few hundreds of basic kernels in OpenCV have been rewritten using so-called "wide universal intrinsics". Those intrinsics map to SSE2, SSE4, AVX2, NEON or VSX intrinsics, depending on the target platform and the compile flags. It should translate to noticeably better performance, even for some already optimized functions. For example, if you configure and compile OpenCV with CPU_BASELINE=AVX2 CMake flag, you can get extra 15-30% speed improvement for certain image processing operations. By OpenCV 4.0 gold we plan to translate many more kernels to such intrinsics and also employ our dynamic dispatching mechanism, so that on x64 platform AVX2-optimized kernels are always built-in and could be selected on-fly if the actual hardware supports such instructions (without having to change CPU_BASELINE). Big thanks to Sayed Adel for VSX backend and the initial (but rather complete!) AVX2 backend of the wide universal intrinsics! Big thanks to Vitaly Tuzov for conversion of many functions in OpenCV to wide universal intrinsics.
  • QR code detector and decoder have been added to opencv/objdetect module together with live sample. Currently, the decoder is built on top of QUirc library (which snapshot we put into opencv). Thanks to our intern Alexander Nesterov for this important contribution!
  • The popular Kinect Fusion algorithm has been implemented, optimized for CPU and GPU (OpenCL), and integrated into opencv_contrib/rgbd module. To make the live sample work, we updated our Kinect 2 support in opencv/videoio module. In 4.0 beta the code has been accelerated for iGPU, which resulted in 3x performance boost in the high-resolution case (512x512x512 integration volume). Thanks to Rostislav Vasilikhin for the excellent work!

New in OpenCV 3.4.3 (Aug 29, 2018)

  • Further extended dnn module, documentation improvements, some other new functionality and bug fixes.

New in OpenCV 3.4.2 (Aug 29, 2018)

  • OpenCV 3.4.2 has been released, with further extended dnn module, documentation improvements, some other new functionality and bug fixes.
  • DNN improvements:
  • Added a new computational target DNN_TARGET_OPENCL_FP16 for half-precision floating point arithmetic of deep learning networks using OpenCL. Just use net.setPreferableTarget(DNN_TARGET_OPENCL_FP16).
  • Extended support of Intel's Inference Engine backend to run models on GPU (OpenCL FP32/FP16) and VPU (Myriad 2, FP16) devices. See an installation guide for details.
  • Enabled import of Intel's OpenVINO pre-trained networks from intermediate representation (IR).
  • Introduced custom layers support which let you define unimplemented layers or override existing ones. Learn more in a corresponding tutorial.
  • Implemented a new deep learning sample inspired by EAST: An Efficient and Accurate Scene Text Detector.
  • Added a support of YOLOv3 and image classification models from Darknet framework.
  • Reduced top DNN's memory consumption and improvements in support of networks from TensorFlow and Keras.
  • RTFM:
  • Excellent tutorials improvements. Python / Java examples are merged into C++ tutorials. Big thanks to Catree.
  • Windows 10:
  • Video I/O: improved support of Microsoft Media Foundation (MSMF)

New in OpenCV 3.4.1 (Feb 28, 2018)

  • Added support for quantized TensorFlow networks. We are now able to load 8-bit matrices of weights. The computations are still done in FP32 (with plans to add FP16 path), but even now it's possible to compress the networks so that they consume less disk space. For example, our face detector can be modified to read and use our 8-bit quantized ResNet-based face detection network (pass it and this description file into cv::dnn::readNetFromTensorFlow()). And the face detection network takes just 2.7Mb.
  • OpenCV is now able to use Intel DL inference engine as DNN acceleration backend. It gives quite noticeable performance boost on many models
  • Added AVX-512 acceleration to the performance-critical kernels, such as convolution and fully-connected layers. Some networks, such as SSD object detection and ENet semantical segmentation, have been accelerated by ~20%.
  • 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. Read a wiki page for details.
  • Performance of pthreads backend of cv::parallel_for_() (which is used by default on Linux/Android, unless you installed TBB or chose OpenMP) has been greatly improved on many core machines, in particular 10-core Core i9. That let us to increase performance of DNN inference quite significantly (up to 6x) on such machines.
  • OpenCL backend has been expanded to cover more layers. The layer fusion has also been improved to increase the speed even further. It shall be reminded that in order to enable OpenCL backend (if it's available on the host machine) one should call the method my_dnn_net.setPreferableTarget(cv::dnn::DNN_TARGET_OPENCL) before the inference, where my_dnn_net is the network loaded using cv::dnn::readNetFromCaffe(), cv::dnn::readNetFromTensorFlow() etc.
  • Several bugs in various layers have been fixed; in particular, SSD priors are now computed slightly differently so that we can more accurate bounding boxes when running SSD on variable-size images.
  • On-disk caching of precompiled OpenCL kernels has been fixed to comply with OpenCL standard. Correspondingly, it now works well with the new Intel OpenCL (NEO) drivers.
  • Certain cases with UMat deadlock when copying UMats in different threads has been fixed.
  • Supported Android NDK16
  • Added build.gradle into OpenCV 4 Android SDK
  • Added initial support of Camera2 API via JavaCamera2View interface
  • 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
  • opencv_contrib: added GMS matching
  • opencv_contrib: added CSR-DCF tracker
  • opencv_contrib: several improvements in OVIS module (OGRE 3D based visualizer)
  • ~248 patches have been merged since OpenCV 3.4.0
  • 203 issues have been closed

New in OpenCV 3.4.0 (Dec 27, 2017)

  • Further improvements in the DNN module include faster R-CNN support, Javascript bindings and acceleration of OpenCL implementation.
  • We've implemented a disk cache and manual loading for precompiled OpenCL kernel binaries, it can greatly reduce initialization time of many applications and allow to run OpenCL implementations on embedded platforms without JIT compiler.
  • One more bit-exact algorithm has been implemented. New 8-bit bilinear resize will lay stable base for complex computer vision pipelines across variety of platforms.
  • One more GSoC project has been integrated - it adds implementations of new background subtraction algorithms.
  • ~250 patches have been merged since OpenCV 3.3.1 and over 200 issues have been closed

New in OpenCV 3.3.1 (Oct 25, 2017)

  • Changes:
  • The main news is that we promoted DNN module from opencv_contrib 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). The detailed information about the module can be found in our wiki: Deep Learning in OpenCV.
  • 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.
  • 716 Pull Requests have been merged and 588 Issues in our bug tracker have been closed since OpenCV 3.2. Additionally, we've run OpenCV through some strict static analyser tools and fixed the detected problems. So, OpenCV 3.3 should hopefully be very stable and dependable release.

New in OpenCV 3.1.0 (Dec 21, 2015)

  • There have been many successful projects this year (student and mentor(s) are listed after the project name), and the results are available as a part of OpenCV 3.1 (partially in the main repository, but mostly opencv_contrib):
  • Omnidirectional Cameras Calibration and Stereo 3D Reconstruction - opencv_contrib/ccalib module (Baisheng Lai, Bo Li)
  • Structure From Motion - opencv_contrib/sfm module (Edgar Riba, Vincent Rabaud)
  • Improved Deformable Part-based Models - opencv_contrib/dpm module (Jiaolong Xu, Bence Magyar)
  • Real-time Multi-object Tracking using Kernelized Correlation Filter - opencv_contrib/tracking module (Laksono Kurnianggoro, Fernando J. Iglesias Garcia)
  • Improved and expanded Scene Text Detection - opencv_contrib/text module (Lluis Gomez, Vadim Pisarevsky)
  • Stereo correspondence improvements - opencv_contrib/stereo module (Mircea Paul Muresan, Sergei Nosov)
  • Structured-Light System Calibration - opencv_contrib/structured_light (Roberta Ravanelli, Delia, Stefano Fabri, Claudia Rapuano)
  • Chessboard+ArUco for camera calibration - opencv_contrib/aruco (Sergio Garrido, Prasanna, Gary Bradski)
  • Implementation of universal interface for deep neural network frameworks - opencv_contrib/dnn module (Vitaliy Lyudvichenko, Anatoly Baksheev)
  • Recent advances in edge-aware filtering, improved SGBM stereo algorithm - opencv/calib3d and opencv_contrib/ximgproc (Alexander Bokov, Maksim Shabunin)
  • Improved ICF detector, waldboost implementation - opencv_contrib/xobjdetect (Vlad Shakhuro, Alexander Bovyrin)
  • Multi-target TLD tracking - opencv_contrib/tracking module (Vladimir Tyan, Antonella Cascitelli)
  • 3D pose estimation using CNNs - opencv_contrib/cnn_3dobj (Yida Wang, Manuele Tamburrano, Stefano Fabri)

New in OpenCV 3.0.0 (Jun 22, 2015)

  • Over 200 bugs reported at http://code.opencv.org/projects/opencv/issues have been resolved/closed. It includes many fixes in docs, build scripts, python wrappers, core, imgproc, photo, features2d, objdetect, contrib modules, as well as some performance improvements etc.
  • Added pthreads-based backend for cv::parallel_for_. It means that all the parallel processing should be available out-of-the-box on any POSIX-compatible OS, including QNX and such. You are welcome to try it out.
  • OpenCV Manager on Android has been completely rewritten in Java and now supports both OpenCV 2.4 and 3.0. After a bit more testing we will put it to Google Play.
  • The other, a bit sad but inevitable news - we had to drop support for nativecamera on Android. It used some undocumented API and never worked stable.
  • Many excellent contributions in opencv_contrib/xfeatures2d:
  • DAISY features
  • Improved version of rotation-invariant BRISK descriptor by Gil Levi
  • LATCH binary descriptor that outperforms all presently available in OpenCV binary descriptors (ORB, BRIEF, AKAZE etc.) and is comparable with heavier and slower SURF.

New in OpenCV 3.0.0 RC (Apr 25, 2015)

  • Improved compatibility with OpenCV 2.4:
  • 2.4.11 now includes "opencv2/core.hpp" and other such headers in addition to standard "opencv2/core/core.hpp".
  • smart pointers (Ptr) can now be created in both 2.4 and 3.0 style (new ClassName(params) vs makePtr(params))
  • trained and stored stat models from opencv_ml 2.4 can now be loaded and used by opencv_ml 3.0 as-is.
  • the 2.4=>3.0 transition guide has been sketched: http://docs.opencv.org/master/db/dfa/tutorial_transition_guide.html
  • We did not put OpenCV 3 to Google Play yet, but we prepared installable OpenCV 3.0 Manager for Android, which can be installed and tried on your device. It can co-exist with OpenCV 2.4 Manager on the same device.
  • There are multiple improvements and bug-fixes for WinRT port (as well as Windows 8.x port) of OpenCV by Microsoft guys.
  • In particular, parallel_for is enabled on WinRT, so the code should run much faster on multi-core devices
  • Also, the WMF video capturing backend has been greatly improved.
  • Standalone motion jpeg codec has been added to opencv_videoio. It does not need ffmpeg or any other 3rd-party lib. According to our measurements, it's also much faster than ffmpeg, especially on ARM. For the decoder you should have JPEG support enabled (through built-in or external libjpeg). How to use it? To encode motion jpeg video, use .avi file extension and CV_FOURCC('M', 'J', 'P', 'G'). The decoder part has been verified on such streams (avi files with index, where each frame is encoded using baseline jpeg) and few random motion jpeg clips from net, but we have not tested it thoroughly.
  • Preliminary version of OpenCV HAL, low-level acceleration API beneath OpenCV, has been introduced. Currently it includes just a few math functions, but will grow soon. It also includes so-called "universal intrinsics", inspired by NEON=>SSE conversion header by Victoria Zhislina from Intel: https://software.intel.com/en-us/blogs/2012/12/12/from-arm-neon-to-intel-mmxsse-automatic-porting-solution-tips-and-tricks. The idea is that one can use a single SIMD code branch that will compile to either SSE or NEON instructions depending on the target platform.
  • Over 500 pull requests have been merged in since 3.0 beta. Big thanks to all the people who submitted bug fixes, new functionality and other small and big improvements!

New in OpenCV 3.0.0 Beta (Nov 10, 2014)

  • Performance of OpenCL-accelerated code on Iris and Iris Pro GPUs has been improved by 30%. That includes faster Canny edge detector, HoughLinesP (OpenCL-accelerated in beta), StereoBM, BruteForceMatcher etc.
  • About 40 commonly used image processing functions have been optimized using vector NEON instructions, so OpenCV 3.0 beta should run noticeably faster on modern ARM chips.
  • Java bindings have been substantially improved. We now have bindings for the updated features2d, background subtractor classes, a part of opencv_contrib etc.
  • Over 200 pull requests have been merged in since 3.0 alpha. Big thanks to all the people who submitted bug fixes, new functionality and other small and big improvements! OpenCV becomes more and more a community-driven project and we are pleased to see that!

New in OpenCV 3.0.0 Alpha (Aug 19, 2014)

  • OpenCV 3.0 brings more GPU accelerated functions and makes it in much more convenient form than OpenCV 2.4.
  • The new technology is nick-named "Transparent API" and, in brief, is extension of classical OpenCV functions, such as cv::resize(), to use OpenCL underneath. See more details about here: T-API.
  • Along with OpenCL code refactoring and Transparent API implementation OpenCL kernels were optimized for mainstream platforms, most notably for modern Intel chips (including Iris and Iris Pro) and AMD chips (such as Kaveri). More detailed results are to be provided later.
  • On x86 and x64 platforms OpenCV binaries include and use a subset of Intel Integrated Performance Primitives (Intel IPP) by default. Intel Corporation granted OpenCV Foundation and all our users the right to use those functions free of charge for both non-commercial and commercial use.
  • Documentation for the contributed modules is integrated into OpenCV doc tree
  • We completely revised our QA infrastructure (big thanks to Alexander Alekhin), which now covers not only the main repository, but also the contrib repository as well.
  • its contribution repository feature a lot of new functionality created by our GSoC students during the past 2 years, namely:
  • Text detection and recognition
  • HDR
  • KAZE/A-KAZE by Eugene Khvedchenya
  • Smart segmentation and edge-aware filters
  • Car detection using Waldboost, ACF
  • TLD tracker and several common-use optimization algorithms
  • Matlab bindings
  • Greatly extended Python bindings, including Python 3 support, and several OpenCV+Python tutorials
  • 3D Visualization using VTK
  • RGBD module
  • Line Segment Detector
  • Many useful Computational Photography algorithms
  • Shape descriptors, matching and morphing shapes (shape module)
  • Long-term tracking + saliency-based improvements (tracking module)
  • Another good pose estimation algorithm and the tutorial on pose estimation
  • Line descriptors and matchers

New in OpenCV 2.4.4 (Apr 6, 2013)

  • OpenCV Java bindings are ported from Android to desktop Java!
  • Android application framework, samples, tutorials, and OpenCV Manager are improved.
  • Optimizations for the new NVIDIA Kepler architecture, CARMA platform support and other new optimizations in CUDA.
  • OpenCL module now builds successfully with various SDKs (from AMD, NVIDIA, Intel and Apple) and runs well on different GPUs (AMD, NVidia, Intel HD4000). A lot of new functionality has been added, tons of bugs fixed, performance of many functions has been significantly improved.
  • 100+ reported problems have been resolved since 2.4.3

New in OpenCV 2.3.1 (Aug 18, 2011)

  • Android port:
  • OpenCV Java bindings for Android platform are released in Beta 2 quality. A lot of work is done to make them more stable and easier to use. Currently Java API has about 700 different OpenCV functions and covers 8 OpenCV modules including full port of features2d. See OpenCV for Android release notes for detailed information about Android-specific changes made for this release.
  • And follow the instructions from Android page for getting started with OpenCV for Android.
  • Other New Functionality and Features:
  • Retina module has been contributed by Alexandre Benoit (in opencv_contrib module). See the new retina sample and https://sites.google.com/site/benoitalexandrevision/.
  • Support for Ximea cameras (http://www.ximea.com/) in HighGUI has been contributed by Ximea developers.
  • 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.
  • Documentation
  • Quite a few new tutorials have been added. Check http://opencv.itseez.com/trunk for the up-to-date documentation.
  • Optimization:
  • Performance of the sparse Lucas-Kanade optical flow has been greatly improved. On 4-core machine it is now 9x faster than the previous version.
  • Bug Fixes:
  • Over 100 issues have been resolved since 2.3 release. Most of the issues (closed and still open) are listed at https://code.ros.org/trac/opencv/report/6.

New in OpenCV 2.3 (Aug 10, 2011)

  • A few more bugs reported in the OpenCV bug tracker have been fixed.
  • Documentation has been improved a lot! The new reference manual combines information for C++ and C interfaces,
  • the OpenCV 1.x-style Python bindings and the new C++-style Python bindings. It has also been thoroughly checked for grammar, style and completeness. Besides, there are new and updated tutorials.
  • The up-to-date online documentation is available at http://opencv.itseez.com.
  • [Windows] The new binary package includes various pre-compiled libs:
  • https://sourceforge.net/projects/opencvlibrary/files/opencv-win/2.3/ Unfortunately, it's not a full-scale installation package, but simply a self-extracting archive with a readme.txt supplied. The installation package is probably to come in the next version.
  • [Windows] VS2005 should build OpenCV 2.3 out of the box, including DirectShow support.
  • [Windows] ffmpeg bindings are now available for all Windows users via compiler- and configuration- and
  • version-independent opencv_ffmpeg.dll (for 32-bit compilers) and opencv_ffmpeg_64.dll (for 64-bit compilers).

New in OpenCV 2.3 RC (Aug 10, 2011)

  • Buildbot-based Continuous Integration system is now continuously testing OpenCV snapshots. The status is available at http://buildbot.itseez.com
  • OpenCV switched to Google Test (http://code.google.com/p/googletest/) engine for regression and correctness tests. Each module now has test subdirectory with the tests.
  • 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. See http://opencv.itseez.com/modules/core/doc/intro.html#inputarray-and-outputarray for details.
  • core:
  • LAPACK is not used by OpenCV anymore. The change decreased the library footprint and the compile time. We now use our own implementation of Jacobi SVD. SVD performance on small matrices (2x2 to 10x10) has been greatly improved; on larger matrices it is still pretty good. SVD accuracy on poorly-conditioned matrices has also been improved.
  • 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:
  • A new calibration pattern, "circles grid" (circles grid image), has been added. See findCirclesGrid() function and the updated calibration.cpp sample. With the new pattern calibration accuracy is usually much higher.
  • highgui:
  • [Windows] videoInput is now a part of highgui. If there are any problems with compiling highgui, set "WITH_VIDEOINPUT=OFF" in CMake.
  • 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.
  • contrib:
  • A new experimental variational stereo correspondence algorithm StereoVar has been added.
  • gpu:
  • the module now requires CUDA 4.0 or later; Many improvements and bug fixes have been made.
  • Android port
  • With support from NVidia, OpenCV Android port (which is actually not a separate branch of OpenCV, it's the same code tree with additional build scripts) has been greatly improved, a few demos developed. Camera support has been added as well. See http://opencv.willowgarage.com/wiki/Android for details.
  • Documentation:
  • OpenCV documentation is now written in ReStructured Text and built using Sphinx (http://sphinx.pocoo.org).
  • It's not a single reference manual now, it's 4 reference manuals (OpenCV 2.x C++ API, OpenCV 2.x Python API, OpenCV 1.x C API, OpenCV 1.x Python API), the emerging user guide and a set of tutorials for beginners.
  • Style and grammar of the main reference manual (OpenCV 2.x C++ API) have been thoroughly checked and fixed.
  • Online up-to-date version of the manual is available at http://opencv.itseez.com
  • Samples:
  • Several samples using the new Python bindings (cv2 module) have been added: https://code.ros.org/svn/opencv/branches/2.3/opencv/samples/python2
  • Optimization
  • Several ML algorithms have been threaded using TBB.
  • Bug Fixes:
  • Over 250 issues have been resolved.

New in OpenCV 2.2 (Aug 10, 2011)

  • 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 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 type for fixed-type fixed-size matrices has been added. Vec is now derived from Matx. 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 "

New in OpenCV 2.1 (Aug 10, 2011)

  • General Modifications:
  • SVN repository has been migrated from SourceForge to https://code.ros.org/svn/opencv.
  • The bug tracker has been moved to https://code.ros.org/trac/opencv/. And we also have OpenCV twitter! http://twitter.com/opencvlibrary
  • 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.
  • OpenCV does not support autotools-based build scripts,
  • CMake (www.cmake.org) is the only way to build OpenCV on any OS.
  • See http://opencv.willowgarage.com/wiki/InstallGuide.
  • 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.
  • 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
  • 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:
  • 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. 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
  • 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
  • New Tests:
  • A few dozens of new tests have been written and many existing tests have been extended
  • to verify OpenCV correctness thoroughly. As a result, we brought the test coverage from rather mediocre numbers to pretty impressive ones
  • Many new regression tests have been written in Python that check both OpenCV and the new-style bindings.
  • The test data moved to the separate repository: https://code.ros.org/svn/opencv/trunk/opencv_extra/testdata.
  • And it is not included into the package, thus some tests from the cvtest and mltest will report about the missing data. You can download the directory to your hard drive and run cvtest like:
  • ./cvtest -d /testdata/cv
  • ./mltest -d /testdata/ml
  • The test engine has been improved:
  • added flags -tn, -seed, -r the detailed information about failed tests is displayed right in the console.
  • Bug Fixes
  • about 200 bugs have been fixed. For the list of closed and still open bugs, please look at

New in OpenCV 2.0 (Aug 10, 2011)

  • General:
  • Installation package on Windows has been fixed, MinGW is used for precompiled binaries (see the release notes on the SourceForge site)
  • autotools-based build has been repaired
  • 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.
  • Bug fixes:
  • Thanks to everybody who submitted bug reports and/or patches!

New in OpenCV 2.0 Beta (Aug 10, 2011)

  • 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,
  • http://www.cmake.org (2.6.x is the preferable version).
  • In Windows package the project files for Visual Studio, makefiles for MSVC, Borland C++ or MinGW are not supplied anymore; please, generate them using CMake.
  • In MacOSX the users can generate project files for Xcode.
  • In Linux and any other platform the users can generate project files for cross-platform IDEs, such as Eclipse or Code Blocks, or makefiles for building OpenCV from a command line.
  • OpenCV repository has been converted to Subversion, hosted at SourceForge:
  • http://opencvlibrary.svn.sourceforge.net/svnroot/opencvlibrary
  • where the very latest snapshot is at
  • http://opencvlibrary.svn.sourceforge.net/svnroot/opencvlibrary/trunk,
  • and the more or less stable version can be found at
  • http://opencvlibrary.svn.sourceforge.net/svnroot/opencvlibrary/tags/latest_tested_snapshot
  • 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
  • MSER - maximally stable extremal regions, submitted
  • LDetector - fast circle-based feature detector
  • Fern-based point classifier and the planar object detector -
  • based on the works
  • One-way descriptor - a powerful PCA-based feature descriptor
  • Learning of Accurate Patch Rectification".
  • 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
  • (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"
  • 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
  • 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), so there is now:
  • opencv.pdf for reading offline
  • and the online up-to-date documentation (as the result of LaTeX->Sphinx->HTML conversion) available at
  • http://opencv.willowgarage.com/documentation/index.html
  • Samples, misc.:
  • Better eye detector - 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
  • 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
  • Bug fixes:
  • Many thanks to everybody who submitted bug reports and/or provided the patches!

New in OpenCV 1.1pre1 (Aug 10, 2011)

  • General:
  • Octave bindings have been added. See interfaces/swig/octave (for now, Linux only)
  • [Windows] OpenCV is now built with VS2005 with SSE2 and OpenMP support included (if you want to rebuild OpenCV using Express or Standard Edition of VS, use _make\opencv.vs2005.no_openmp.sln).
  • [Windows] Python bindings have been updated to use Python 2.6
  • [Windows] cvcam has been removed (as videoInput is now supported by highgui)
  • 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
  • slow but more accurate graph-cut based algorithm
  • Better homography estimation algorithms
  • new C++ template image classes contributed by Daniel Filip (Google inc.). see opencv/cxcore/include/cvwimage.h
  • Fast approximate nearest neighbor search
  • Codebook method for background/foreground segmentation
  • 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)
  • Bug fixes:
  • Many thanks to everybody who submitted bug reports and/or provided the patches!
  • added dma_unlisten to icvCloseCAM_DC1394
  • LMEDs algorithm for cvFindFundamentalMat estimation has been fixed
  • Broken debug build of highgui in VS2005/2008 (SF #2056185, SF #1709435)
  • cvFindChessboardCorners memory leak and incorrect size checks (SF #1972896, SF #1910323)
  • disabling GTK causes v4l runtime error (SF #2088102)
  • cvsetmousecallback bug (SF #2053529)
  • libhighgui needed deprecated "img_convert" replacement (SF #2011753)
  • Segfault in createsamples caused by uninitialized variable (SF #1977989)
  • Data Alignment Issue in bgfg_gaussmix (SF #1961755)
  • libpng need to be updated (SF #1952793)
  • cvCreateVideoWriter_Win32 - identifier not found (SF #1944254)
  • Bug in cvmorph.cpp (SF #1908844)
  • dilate (cvDilate) works bogus with default kernel (SF #1887130)
  • CvEM non-default constructor declared but not defined (SF #1830346)
  • cvFloodFill (in ver 1.0) Hangs (SF #1790565)
  • double delete in CvImage (SF #1733437)
  • cvFilter2D anchor default value is not working properly (SF #1713779)
  • cvCvtColor - Bug? in converting HSV2RGB (SF #1676344)
  • Invalid selection of the MKL-dll version in cvUseOptimized() (SF #1633017)

New in OpenCV 1.0 (Aug 10, 2011)

  • General:
  • Windows installation package now includes precompiled Python module
  • Borland C++ (v5.6+) makefiles re-added (see _make\make_all_bc.mak)
  • CV:
  • Inpainting was added, see samples/c/inpaint.cpp (thanks to Alexander Kibkalo and Alexey Kalinichenko)
  • MLL:
  • Boosted tree classifiers added, see MLL reference manual
  • HighGUI:
  • Jpeg2000 and EXR support in highgui using JasPer and OpenEXR (thanks to Nils Hasler) OpenEXR is not built-in to highgui on Windows by default. See otherlibs/_graphics/readme.txt.
  • >8-bit image input/output for PNG, Jpeg2000 and OpenEXR (thanks to Nils Hasler)
  • Updated CMUcamera wrapper.
  • Several V4L2 improvements and fixes
  • New samples (opencv/samples):
  • Camera calibration sample: calibrate.cpp
  • Inpainting sample: inpaint.cpp
  • Letter recognition using the existing database with random trees/boosted trees/neural nets: leter_recog.cpp
  • A few new Python samples.
  • Tests:
  • Most old cv tests have been rewritten/converted to use cxts instead of trs. TRS is not used by the tests anymore.
  • Bug fixes:
  • Many thanks to everybody who submitted bug reports and/or provided the patches!
  • Incorrect normalization in cvFindFundamentalMat (SF #1550855)
  • Occasional cvGetQuadrangleSubPix crashes (SF #1549168)
  • Occasional cvCalcOpticalFlowPyrLK crashes
  • Internal GCC 3.x error in cvFloor/cvCeil (SF #1546657)
  • Several Python-related bugs (SF #1570109, SF #1572800, SF #1543593)
  • Bugs in contour processing/rendering (SF #1550889,
  • x86-64 related bugs (SF #1526133, SF #1527997)
  • OpenCV dispatcher tried to load old versions of IPP (pre 4.x) that caused many failures (see SF #1555093, for example)
  • Inaccurate results in some cases in cvFitEllipse, cvFitLine, cvHoughCircles.
  • Severe bug in Bayesian classifier, broken regression tree in MLL
  • Overflow in blurring filter
  • cvSaveImage() modified saved images leading to potential problems in threaded apps.
  • Numeric values in XML/YAML were emitted/parsed incorrectly on some non-US locales in Linux
  • VS2005 Express/Standard Editions could not build OpenCV (due to missing OpenMP support)
  • ...
  • Known issues:
  • Certain tests may fail on IA64 (Itanium), e.g.
  • gaussian filter, fundamental matrix estimation, chessboard detector.