Merge remote-tracking branch 'master' into stitch-fix

* 'master' of github.com:itseez/opencv: (82 commits)
  moved part of video to contrib/{outflow, bgsegm}; moved matlab to contrib
  added some basic functionality needed by the new face module (moved from the old "contrib")
  moved to the new opencv_contrib/face module
  fixed various warnings and obvious errors reported by clang compiler and the coverity tool.
  Fixed review comment from Vadim Pisarevsky
  modified farneback sample to use T-API
  ECC patch by the author (G. Evangelidis); fixed some OCL Farneback optical flow test failures on Mac
  small fix for GaussianBlur ocl test
  fix binary package build
  small fix for ocl_resize
  fix IOS framework
  fixed test ocl_MatchTemplate for sparse matrix
  Fixed typos
  fixing error, wrong template method param.
  fixing Mac build
  some formal changes (generally adding constness)
  Fixed choice of kercn and rowsPerWI for non-Intel device.
  fixed nDiffs for CalcBackProject
  fixed tests for ocl_filter2d, ocl_matchTemplate, ocl_histogram.cpp
  Fixed issue: Mat::copyTo(UMat) if device copy is obsolete. Added test.
  ...

Conflicts:
	modules/core/include/opencv2/core/mat.inl.hpp

CMakeLists.txt

@@ -337,6 +337,9 @@ if(DEFINED CMAKE_DEBUG_POSTFIX)
   set(OPENCV_DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
 endif()
 
+if(INSTALL_CREATE_DISTRIB AND BUILD_SHARED_LIBS AND NOT DEFINED BUILD_opencv_world)
+  set(BUILD_opencv_world ON CACHE INTERNAL "")
+endif()
 
 # ----------------------------------------------------------------------------
 #  Path for build/platform -specific headers
@@ -554,7 +557,6 @@ endif()
 # ----------------------------------------------------------------------------
 # Finalization: generate configuration-based files
 # ----------------------------------------------------------------------------
-ocv_track_build_dependencies()
 
 # Generate platform-dependent and configuration-dependent headers
 include(cmake/OpenCVGenHeaders.cmake)
@@ -999,18 +1001,34 @@ endif()
 
 # ========================== python ==========================
 status("")
-status("  Python:")
-status("    Interpreter:"     PYTHONINTERP_FOUND  THEN "${PYTHON_EXECUTABLE} (ver ${PYTHON_VERSION_STRING})"       ELSE NO)
-if(BUILD_opencv_python)
-  if(PYTHONLIBS_VERSION_STRING)
-    status("    Libraries:"   HAVE_opencv_python  THEN  "${PYTHON_LIBRARIES} (ver ${PYTHONLIBS_VERSION_STRING})"   ELSE NO)
+status("  Python 2:")
+status("    Interpreter:"     PYTHON2INTERP_FOUND  THEN "${PYTHON2_EXECUTABLE} (ver ${PYTHON2_VERSION_STRING})"       ELSE NO)
+if(BUILD_opencv_python2)
+  if(PYTHON2LIBS_VERSION_STRING)
+    status("    Libraries:"   HAVE_opencv_python2  THEN  "${PYTHON2_LIBRARIES} (ver ${PYTHON2LIBS_VERSION_STRING})"   ELSE NO)
+  else()
+    status("    Libraries:"   HAVE_opencv_python2  THEN  "${PYTHON2_LIBRARIES}"                                      ELSE NO)
+  endif()
+  status("    numpy:"         PYTHON2_NUMPY_INCLUDE_DIRS THEN "${PYTHON2_NUMPY_INCLUDE_DIRS} (ver ${PYTHON2_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
+  status("    packages path:" PYTHON2_EXECUTABLE         THEN "${PYTHON2_PACKAGES_PATH}"                                    ELSE "-")
+endif()
+
+status("")
+status("  Python 3:")
+status("    Interpreter:"     PYTHON3INTERP_FOUND  THEN "${PYTHON3_EXECUTABLE} (ver ${PYTHON3_VERSION_STRING})"       ELSE NO)
+if(BUILD_opencv_python3)
+  if(PYTHON3LIBS_VERSION_STRING)
+    status("    Libraries:"   HAVE_opencv_python3  THEN  "${PYTHON3_LIBRARIES} (ver ${PYTHON3LIBS_VERSION_STRING})"   ELSE NO)
   else()
-    status("    Libraries:"   HAVE_opencv_python  THEN  "${PYTHON_LIBRARIES}"                                      ELSE NO)
+    status("    Libraries:"   HAVE_opencv_python3  THEN  "${PYTHON3_LIBRARIES}"                                      ELSE NO)
   endif()
-  status("    numpy:"         PYTHON_NUMPY_INCLUDE_DIRS THEN "${PYTHON_NUMPY_INCLUDE_DIRS} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
-  status("    packages path:" PYTHON_EXECUTABLE         THEN "${PYTHON_PACKAGES_PATH}"                                    ELSE "-")
+  status("    numpy:"         PYTHON3_NUMPY_INCLUDE_DIRS THEN "${PYTHON3_NUMPY_INCLUDE_DIRS} (ver ${PYTHON3_NUMPY_VERSION})" ELSE "NO (Python3 wrappers can not be generated)")
+  status("    packages path:" PYTHON3_EXECUTABLE         THEN "${PYTHON3_PACKAGES_PATH}"                                    ELSE "-")
 endif()
 
+status("")
+status("  Python (for build):"  PYTHON_DEFAULT_AVAILABLE THEN "${PYTHON_DEFAULT_EXECUTABLE}" ELSE NO)
+
 # ========================== java ==========================
 status("")
 status("  Java:")

apps/traincascade/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_ml opencv_imgproc opencv_photo opencv_objdetect opencv_imgcodecs opencv_videoio opencv_highgui opencv_calib3d opencv_video opencv_features2d)
+set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_imgproc opencv_objdetect opencv_imgcodecs opencv_highgui opencv_calib3d opencv_features2d)
 ocv_check_dependencies(${OPENCV_TRAINCASCADE_DEPS})
 
 if(NOT OCV_DEPENDENCIES_FOUND)
@@ -6,21 +6,18 @@ if(NOT OCV_DEPENDENCIES_FOUND)
 endif()
 
 project(traincascade)
+set(the_target opencv_traincascade)
 
-ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
-ocv_include_modules(${OPENCV_TRAINCASCADE_DEPS})
+ocv_target_include_directories(${the_target} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
+ocv_target_include_modules(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
 
-set(traincascade_files traincascade.cpp
-  cascadeclassifier.cpp cascadeclassifier.h
-  boost.cpp boost.h features.cpp traincascade_features.h
-  haarfeatures.cpp haarfeatures.h
-  lbpfeatures.cpp lbpfeatures.h
-  HOGfeatures.cpp HOGfeatures.h
-  imagestorage.cpp imagestorage.h)
+file(GLOB SRCS *.cpp)
+file(GLOB HDRS *.h*)
 
-set(the_target opencv_traincascade)
-add_executable(${the_target} ${traincascade_files})
-target_link_libraries(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
+set(traincascade_files ${SRCS} ${HDRS})
+
+ocv_add_executable(${the_target} ${traincascade_files})
+ocv_target_link_libraries(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
 
 set_target_properties(${the_target} PROPERTIES
                       DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"

apps/traincascade/boost.h

@@ -2,7 +2,7 @@
 #define _OPENCV_BOOST_H_
 
 #include "traincascade_features.h"
-#include "ml.h"
+#include "old_ml.hpp"
 
 struct CvCascadeBoostParams : CvBoostParams
 {

apps/traincascade/cascadeclassifier.h

@@ -7,8 +7,6 @@
 #include "lbpfeatures.h"
 #include "HOGfeatures.h" //new
 #include "boost.h"
-#include "cv.h"
-#include "cxcore.h"
 
 #define CC_CASCADE_FILENAME "cascade.xml"
 #define CC_PARAMS_FILENAME "params.xml"

apps/traincascade/old_ml_data.cpp

@@ -0,0 +1,792 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "old_ml_precomp.hpp"
+#include <ctype.h>
+
+#define MISS_VAL    FLT_MAX
+#define CV_VAR_MISS    0
+
+CvTrainTestSplit::CvTrainTestSplit()
+{
+    train_sample_part_mode = CV_COUNT;
+    train_sample_part.count = -1;
+    mix = false;
+}
+
+CvTrainTestSplit::CvTrainTestSplit( int _train_sample_count, bool _mix )
+{
+    train_sample_part_mode = CV_COUNT;
+    train_sample_part.count = _train_sample_count;
+    mix = _mix;
+}
+
+CvTrainTestSplit::CvTrainTestSplit( float _train_sample_portion, bool _mix )
+{
+    train_sample_part_mode = CV_PORTION;
+    train_sample_part.portion = _train_sample_portion;
+    mix = _mix;
+}
+
+////////////////
+
+CvMLData::CvMLData()
+{
+    values = missing = var_types = var_idx_mask = response_out = var_idx_out = var_types_out = 0;
+    train_sample_idx = test_sample_idx = 0;
+    header_lines_number = 0;
+    sample_idx = 0;
+    response_idx = -1;
+
+    train_sample_count = -1;
+
+    delimiter = ',';
+    miss_ch = '?';
+    //flt_separator = '.';
+
+    rng = &cv::theRNG();
+}
+
+CvMLData::~CvMLData()
+{
+    clear();
+}
+
+void CvMLData::free_train_test_idx()
+{
+    cvReleaseMat( &train_sample_idx );
+    cvReleaseMat( &test_sample_idx );
+    sample_idx = 0;
+}
+
+void CvMLData::clear()
+{
+    class_map.clear();
+
+    cvReleaseMat( &values );
+    cvReleaseMat( &missing );
+    cvReleaseMat( &var_types );
+    cvReleaseMat( &var_idx_mask );
+
+    cvReleaseMat( &response_out );
+    cvReleaseMat( &var_idx_out );
+    cvReleaseMat( &var_types_out );
+
+    free_train_test_idx();
+
+    total_class_count = 0;
+
+    response_idx = -1;
+
+    train_sample_count = -1;
+}
+
+
+void CvMLData::set_header_lines_number( int idx )
+{
+    header_lines_number = std::max(0, idx);
+}
+
+int CvMLData::get_header_lines_number() const
+{
+    return header_lines_number;
+}
+
+static char *fgets_chomp(char *str, int n, FILE *stream)
+{
+    char *head = fgets(str, n, stream);
+    if( head )
+    {
+        for(char *tail = head + strlen(head) - 1; tail >= head; --tail)
+        {
+            if( *tail != '\r'  && *tail != '\n' )
+                break;
+            *tail = '\0';
+        }
+    }
+    return head;
+}
+
+
+int CvMLData::read_csv(const char* filename)
+{
+    const int M = 1000000;
+    const char str_delimiter[3] = { ' ', delimiter, '\0' };
+    FILE* file = 0;
+    CvMemStorage* storage;
+    CvSeq* seq;
+    char *ptr;
+    float* el_ptr;
+    CvSeqReader reader;
+    int cols_count = 0;
+    uchar *var_types_ptr = 0;
+
+    clear();
+
+    file = fopen( filename, "rt" );
+
+    if( !file )
+        return -1;
+
+    std::vector<char> _buf(M);
+    char* buf = &_buf[0];
+
+    // skip header lines
+    for( int i = 0; i < header_lines_number; i++ )
+    {
+        if( fgets( buf, M, file ) == 0 )
+        {
+            fclose(file);
+            return -1;
+        }
+    }
+
+    // read the first data line and determine the number of variables
+    if( !fgets_chomp( buf, M, file ))
+    {
+        fclose(file);
+        return -1;
+    }
+
+    ptr = buf;
+    while( *ptr == ' ' )
+        ptr++;
+    for( ; *ptr != '\0'; )
+    {
+        if(*ptr == delimiter || *ptr == ' ')
+        {
+            cols_count++;
+            ptr++;
+            while( *ptr == ' ' ) ptr++;
+        }
+        else
+            ptr++;
+    }
+
+    cols_count++;
+
+    if ( cols_count == 0)
+    {
+        fclose(file);
+        return -1;
+    }
+
+    // create temporary memory storage to store the whole database
+    el_ptr = new float[cols_count];
+    storage = cvCreateMemStorage();
+    seq = cvCreateSeq( 0, sizeof(*seq), cols_count*sizeof(float), storage );
+
+    var_types = cvCreateMat( 1, cols_count, CV_8U );
+    cvZero( var_types );
+    var_types_ptr = var_types->data.ptr;
+
+    for(;;)
+    {
+        char *token = NULL;
+        int type;
+        token = strtok(buf, str_delimiter);
+        if (!token)
+            break;
+        for (int i = 0; i < cols_count-1; i++)
+        {
+            str_to_flt_elem( token, el_ptr[i], type);
+            var_types_ptr[i] |= type;
+            token = strtok(NULL, str_delimiter);
+            if (!token)
+            {
+                fclose(file);
+                delete [] el_ptr;
+                return -1;
+            }
+        }
+        str_to_flt_elem( token, el_ptr[cols_count-1], type);
+        var_types_ptr[cols_count-1] |= type;
+        cvSeqPush( seq, el_ptr );
+        if( !fgets_chomp( buf, M, file ) )
+            break;
+    }
+    fclose(file);
+
+    values = cvCreateMat( seq->total, cols_count, CV_32FC1 );
+    missing = cvCreateMat( seq->total, cols_count, CV_8U );
+    var_idx_mask = cvCreateMat( 1, values->cols, CV_8UC1 );
+    cvSet( var_idx_mask, cvRealScalar(1) );
+    train_sample_count = seq->total;
+
+    cvStartReadSeq( seq, &reader );
+    for(int i = 0; i < seq->total; i++ )
+    {
+        const float* sdata = (float*)reader.ptr;
+        float* ddata = values->data.fl + cols_count*i;
+        uchar* dm = missing->data.ptr + cols_count*i;
+
+        for( int j = 0; j < cols_count; j++ )
+        {
+            ddata[j] = sdata[j];
+            dm[j] = ( fabs( MISS_VAL - sdata[j] ) <= FLT_EPSILON );
+        }
+        CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
+    }
+
+    if ( cvNorm( missing, 0, CV_L1 ) <= FLT_EPSILON )
+        cvReleaseMat( &missing );
+
+    cvReleaseMemStorage( &storage );
+    delete []el_ptr;
+    return 0;
+}
+
+const CvMat* CvMLData::get_values() const
+{
+    return values;
+}
+
+const CvMat* CvMLData::get_missing() const
+{
+    CV_FUNCNAME( "CvMLData::get_missing" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    __END__;
+
+    return missing;
+}
+
+const std::map<cv::String, int>& CvMLData::get_class_labels_map() const
+{
+    return class_map;
+}
+
+void CvMLData::str_to_flt_elem( const char* token, float& flt_elem, int& type)
+{
+
+    char* stopstring = NULL;
+    flt_elem = (float)strtod( token, &stopstring );
+    assert( stopstring );
+    type = CV_VAR_ORDERED;
+    if ( *stopstring == miss_ch && strlen(stopstring) == 1 ) // missed value
+    {
+        flt_elem = MISS_VAL;
+        type = CV_VAR_MISS;
+    }
+    else
+    {
+        if ( (*stopstring != 0) && (*stopstring != '\n') && (strcmp(stopstring, "\r\n") != 0) ) // class label
+        {
+            int idx = class_map[token];
+            if ( idx == 0)
+            {
+                total_class_count++;
+                idx = total_class_count;
+                class_map[token] = idx;
+            }
+            flt_elem = (float)idx;
+            type = CV_VAR_CATEGORICAL;
+        }
+    }
+}
+
+void CvMLData::set_delimiter(char ch)
+{
+    CV_FUNCNAME( "CvMLData::set_delimited" );
+    __BEGIN__;
+
+    if (ch == miss_ch /*|| ch == flt_separator*/)
+        CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
+
+    delimiter = ch;
+
+    __END__;
+}
+
+char CvMLData::get_delimiter() const
+{
+    return delimiter;
+}
+
+void CvMLData::set_miss_ch(char ch)
+{
+    CV_FUNCNAME( "CvMLData::set_miss_ch" );
+    __BEGIN__;
+
+    if (ch == delimiter/* || ch == flt_separator*/)
+        CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
+
+    miss_ch = ch;
+
+    __END__;
+}
+
+char CvMLData::get_miss_ch() const
+{
+    return miss_ch;
+}
+
+void CvMLData::set_response_idx( int idx )
+{
+    CV_FUNCNAME( "CvMLData::set_response_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    if ( idx >= values->cols)
+        CV_ERROR( CV_StsBadArg, "idx value is not correct" );
+
+    if ( response_idx >= 0 )
+        chahge_var_idx( response_idx, true );
+    if ( idx >= 0 )
+        chahge_var_idx( idx, false );
+    response_idx = idx;
+
+    __END__;
+}
+
+int CvMLData::get_response_idx() const
+{
+    CV_FUNCNAME( "CvMLData::get_response_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+     __END__;
+    return response_idx;
+}
+
+void CvMLData::change_var_type( int var_idx, int type )
+{
+    CV_FUNCNAME( "CvMLData::change_var_type" );
+    __BEGIN__;
+
+    int var_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+     var_count = values->cols;
+
+    if ( var_idx < 0 || var_idx >= var_count)
+        CV_ERROR( CV_StsBadArg, "var_idx is not correct" );
+
+    if ( type != CV_VAR_ORDERED && type != CV_VAR_CATEGORICAL)
+         CV_ERROR( CV_StsBadArg, "type is not correct" );
+
+    assert( var_types );
+    if ( var_types->data.ptr[var_idx] == CV_VAR_CATEGORICAL && type == CV_VAR_ORDERED)
+        CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
+    var_types->data.ptr[var_idx] = (uchar)type;
+
+    __END__;
+
+    return;
+}
+
+void CvMLData::set_var_types( const char* str )
+{
+    CV_FUNCNAME( "CvMLData::set_var_types" );
+    __BEGIN__;
+
+    const char* ord = 0, *cat = 0;
+    int var_count = 0, set_var_type_count = 0;
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    var_count = values->cols;
+
+    assert( var_types );
+
+    ord = strstr( str, "ord" );
+    cat = strstr( str, "cat" );
+    if ( !ord && !cat )
+        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+    if ( !ord && strlen(cat) == 3 ) // str == "cat"
+    {
+        cvSet( var_types, cvScalarAll(CV_VAR_CATEGORICAL) );
+        return;
+    }
+
+    if ( !cat && strlen(ord) == 3 ) // str == "ord"
+    {
+        cvSet( var_types, cvScalarAll(CV_VAR_ORDERED) );
+        return;
+    }
+
+    if ( ord ) // parse ord str
+    {
+        char* stopstring = NULL;
+        if ( ord[3] != '[')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+        ord += 4; // pass "ord["
+        do
+        {
+            int b1 = (int)strtod( ord, &stopstring );
+            if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
+                CV_ERROR( CV_StsBadArg, "types string is not correct" );
+            ord = stopstring + 1;
+            if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
+            {
+                if ( var_types->data.ptr[b1] == CV_VAR_CATEGORICAL)
+                    CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
+                var_types->data.ptr[b1] = CV_VAR_ORDERED;
+                set_var_type_count++;
+            }
+            else
+            {
+                if ( stopstring[0] == '-')
+                {
+                    int b2 = (int)strtod( ord, &stopstring);
+                    if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
+                        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+                    ord = stopstring + 1;
+                    for (int i = b1; i <= b2; i++)
+                    {
+                        if ( var_types->data.ptr[i] == CV_VAR_CATEGORICAL)
+                            CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
+                        var_types->data.ptr[i] = CV_VAR_ORDERED;
+                    }
+                    set_var_type_count += b2 - b1 + 1;
+                }
+                else
+                    CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+            }
+        }
+        while (*stopstring != ']');
+
+        if ( stopstring[1] != '\0' && stopstring[1] != ',')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+    }
+
+    if ( cat ) // parse cat str
+    {
+        char* stopstring = NULL;
+        if ( cat[3] != '[')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+        cat += 4; // pass "cat["
+        do
+        {
+            int b1 = (int)strtod( cat, &stopstring );
+            if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
+                CV_ERROR( CV_StsBadArg, "types string is not correct" );
+            cat = stopstring + 1;
+            if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
+            {
+                var_types->data.ptr[b1] = CV_VAR_CATEGORICAL;
+                set_var_type_count++;
+            }
+            else
+            {
+                if ( stopstring[0] == '-')
+                {
+                    int b2 = (int)strtod( cat, &stopstring);
+                    if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
+                        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+                    cat = stopstring + 1;
+                    for (int i = b1; i <= b2; i++)
+                        var_types->data.ptr[i] = CV_VAR_CATEGORICAL;
+                    set_var_type_count += b2 - b1 + 1;
+                }
+                else
+                    CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+            }
+        }
+        while (*stopstring != ']');
+
+        if ( stopstring[1] != '\0' && stopstring[1] != ',')
+            CV_ERROR( CV_StsBadArg, "types string is not correct" );
+    }
+
+    if (set_var_type_count != var_count)
+        CV_ERROR( CV_StsBadArg, "types string is not correct" );
+
+     __END__;
+}
+
+const CvMat* CvMLData::get_var_types()
+{
+    CV_FUNCNAME( "CvMLData::get_var_types" );
+    __BEGIN__;
+
+    uchar *var_types_out_ptr = 0;
+    int avcount, vt_size;
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    assert( var_idx_mask );
+
+    avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
+    vt_size = avcount + (response_idx >= 0);
+
+    if ( avcount == values->cols || (avcount == values->cols-1 && response_idx == values->cols-1) )
+        return var_types;
+
+    if ( !var_types_out || ( var_types_out && var_types_out->cols != vt_size ) )
+    {
+        cvReleaseMat( &var_types_out );
+        var_types_out = cvCreateMat( 1, vt_size, CV_8UC1 );
+    }
+
+    var_types_out_ptr = var_types_out->data.ptr;
+    for( int i = 0; i < var_types->cols; i++)
+    {
+        if (i == response_idx || !var_idx_mask->data.ptr[i]) continue;
+        *var_types_out_ptr = var_types->data.ptr[i];
+        var_types_out_ptr++;
+    }
+    if ( response_idx >= 0 )
+        *var_types_out_ptr = var_types->data.ptr[response_idx];
+
+    __END__;
+
+    return var_types_out;
+}
+
+int CvMLData::get_var_type( int var_idx ) const
+{
+    return var_types->data.ptr[var_idx];
+}
+
+const CvMat* CvMLData::get_responses()
+{
+    CV_FUNCNAME( "CvMLData::get_responses_ptr" );
+    __BEGIN__;
+
+    int var_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    var_count = values->cols;
+
+    if ( response_idx < 0 || response_idx >= var_count )
+       return 0;
+    if ( !response_out )
+        response_out = cvCreateMatHeader( values->rows, 1, CV_32FC1 );
+    else
+        cvInitMatHeader( response_out, values->rows, 1, CV_32FC1);
+    cvGetCol( values, response_out, response_idx );
+
+    __END__;
+
+    return response_out;
+}
+
+void CvMLData::set_train_test_split( const CvTrainTestSplit * spl)
+{
+    CV_FUNCNAME( "CvMLData::set_division" );
+    __BEGIN__;
+
+    int sample_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    sample_count = values->rows;
+
+    float train_sample_portion;
+
+    if (spl->train_sample_part_mode == CV_COUNT)
+    {
+        train_sample_count = spl->train_sample_part.count;
+        if (train_sample_count > sample_count)
+            CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
+        train_sample_count = train_sample_count<=0 ? sample_count : train_sample_count;
+    }
+    else // dtype.train_sample_part_mode == CV_PORTION
+    {
+        train_sample_portion = spl->train_sample_part.portion;
+        if ( train_sample_portion > 1)
+            CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
+        train_sample_portion = train_sample_portion <= FLT_EPSILON ||
+            1 - train_sample_portion <= FLT_EPSILON ? 1 : train_sample_portion;
+        train_sample_count = std::max(1, cvFloor( train_sample_portion * sample_count ));
+    }
+
+    if ( train_sample_count == sample_count )
+    {
+        free_train_test_idx();
+        return;
+    }
+
+    if ( train_sample_idx && train_sample_idx->cols != train_sample_count )
+        free_train_test_idx();
+
+    if ( !sample_idx)
+    {
+        int test_sample_count = sample_count- train_sample_count;
+        sample_idx = (int*)cvAlloc( sample_count * sizeof(sample_idx[0]) );
+        for (int i = 0; i < sample_count; i++ )
+            sample_idx[i] = i;
+        train_sample_idx = cvCreateMatHeader( 1, train_sample_count, CV_32SC1 );
+        *train_sample_idx = cvMat( 1, train_sample_count, CV_32SC1, &sample_idx[0] );
+
+        CV_Assert(test_sample_count > 0);
+        test_sample_idx = cvCreateMatHeader( 1, test_sample_count, CV_32SC1 );
+        *test_sample_idx = cvMat( 1, test_sample_count, CV_32SC1, &sample_idx[train_sample_count] );
+    }
+
+    mix = spl->mix;
+    if ( mix )
+        mix_train_and_test_idx();
+
+    __END__;
+}
+
+const CvMat* CvMLData::get_train_sample_idx() const
+{
+    CV_FUNCNAME( "CvMLData::get_train_sample_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    __END__;
+
+    return train_sample_idx;
+}
+
+const CvMat* CvMLData::get_test_sample_idx() const
+{
+    CV_FUNCNAME( "CvMLData::get_test_sample_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    __END__;
+
+    return test_sample_idx;
+}
+
+void CvMLData::mix_train_and_test_idx()
+{
+    CV_FUNCNAME( "CvMLData::mix_train_and_test_idx" );
+    __BEGIN__;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+    __END__;
+
+    if ( !sample_idx)
+        return;
+
+    if ( train_sample_count > 0 && train_sample_count < values->rows )
+    {
+        int n = values->rows;
+        for (int i = 0; i < n; i++)
+        {
+            int a = (*rng)(n);
+            int b = (*rng)(n);
+            int t;
+            CV_SWAP( sample_idx[a], sample_idx[b], t );
+        }
+    }
+}
+
+const CvMat* CvMLData::get_var_idx()
+{
+     CV_FUNCNAME( "CvMLData::get_var_idx" );
+    __BEGIN__;
+
+    int avcount = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    assert( var_idx_mask );
+
+    avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
+    int* vidx;
+
+    if ( avcount == values->cols )
+        return 0;
+
+    if ( !var_idx_out || ( var_idx_out && var_idx_out->cols != avcount ) )
+    {
+        cvReleaseMat( &var_idx_out );
+        var_idx_out = cvCreateMat( 1, avcount, CV_32SC1);
+        if ( response_idx >=0 )
+            var_idx_mask->data.ptr[response_idx] = 0;
+    }
+
+    vidx = var_idx_out->data.i;
+
+    for(int i = 0; i < var_idx_mask->cols; i++)
+        if ( var_idx_mask->data.ptr[i] )
+        {
+            *vidx = i;
+            vidx++;
+        }
+
+    __END__;
+
+    return var_idx_out;
+}
+
+void CvMLData::chahge_var_idx( int vi, bool state )
+{
+    change_var_idx( vi, state );
+}
+
+void CvMLData::change_var_idx( int vi, bool state )
+{
+     CV_FUNCNAME( "CvMLData::change_var_idx" );
+    __BEGIN__;
+
+    int var_count = 0;
+
+    if ( !values )
+        CV_ERROR( CV_StsInternal, "data is empty" );
+
+    var_count = values->cols;
+
+    if ( vi < 0 || vi >= var_count)
+        CV_ERROR( CV_StsBadArg, "variable index is not correct" );
+
+    assert( var_idx_mask );
+    var_idx_mask->data.ptr[vi] = state;
+
+    __END__;
+}
+
+/* End of file. */

apps/traincascade/old_ml_precomp.hpp

@@ -0,0 +1,376 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core.hpp"
+#include "old_ml.hpp"
+#include "opencv2/core/core_c.h"
+#include "opencv2/core/utility.hpp"
+
+#include "opencv2/core/private.hpp"
+
+#include <assert.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#define ML_IMPL CV_IMPL
+#define __BEGIN__ __CV_BEGIN__
+#define __END__ __CV_END__
+#define EXIT __CV_EXIT__
+
+#define CV_MAT_ELEM_FLAG( mat, type, comp, vect, tflag )    \
+    (( tflag == CV_ROW_SAMPLE )                             \
+    ? (CV_MAT_ELEM( mat, type, comp, vect ))                \
+    : (CV_MAT_ELEM( mat, type, vect, comp )))
+
+/* Convert matrix to vector */
+#define ICV_MAT2VEC( mat, vdata, vstep, num )      \
+    if( MIN( (mat).rows, (mat).cols ) != 1 )       \
+        CV_ERROR( CV_StsBadArg, "" );              \
+    (vdata) = ((mat).data.ptr);                    \
+    if( (mat).rows == 1 )                          \
+    {                                              \
+        (vstep) = CV_ELEM_SIZE( (mat).type );      \
+        (num) = (mat).cols;                        \
+    }                                              \
+    else                                           \
+    {                                              \
+        (vstep) = (mat).step;                      \
+        (num) = (mat).rows;                        \
+    }
+
+/* get raw data */
+#define ICV_RAWDATA( mat, flags, rdata, sstep, cstep, m, n )         \
+    (rdata) = (mat).data.ptr;                                        \
+    if( CV_IS_ROW_SAMPLE( flags ) )                                  \
+    {                                                                \
+        (sstep) = (mat).step;                                        \
+        (cstep) = CV_ELEM_SIZE( (mat).type );                        \
+        (m) = (mat).rows;                                            \
+        (n) = (mat).cols;                                            \
+    }                                                                \
+    else                                                             \
+    {                                                                \
+        (cstep) = (mat).step;                                        \
+        (sstep) = CV_ELEM_SIZE( (mat).type );                        \
+        (n) = (mat).rows;                                            \
+        (m) = (mat).cols;                                            \
+    }
+
+#define ICV_IS_MAT_OF_TYPE( mat, mat_type) \
+    (CV_IS_MAT( mat ) && CV_MAT_TYPE( mat->type ) == (mat_type) &&   \
+    (mat)->cols > 0 && (mat)->rows > 0)
+
+/*
+    uchar* data; int sstep, cstep;      - trainData->data
+    uchar* classes; int clstep; int ncl;- trainClasses
+    uchar* tmask; int tmstep; int ntm;  - typeMask
+    uchar* missed;int msstep, mcstep;   -missedMeasurements...
+    int mm, mn;                         == m,n == size,dim
+    uchar* sidx;int sistep;             - sampleIdx
+    uchar* cidx;int cistep;             - compIdx
+    int k, l;                           == n,m == dim,size (length of cidx, sidx)
+    int m, n;                           == size,dim
+*/
+#define ICV_DECLARE_TRAIN_ARGS()                                                    \
+    uchar* data;                                                                    \
+    int sstep, cstep;                                                               \
+    uchar* classes;                                                                 \
+    int clstep;                                                                     \
+    int ncl;                                                                        \
+    uchar* tmask;                                                                   \
+    int tmstep;                                                                     \
+    int ntm;                                                                        \
+    uchar* missed;                                                                  \
+    int msstep, mcstep;                                                             \
+    int mm, mn;                                                                     \
+    uchar* sidx;                                                                    \
+    int sistep;                                                                     \
+    uchar* cidx;                                                                    \
+    int cistep;                                                                     \
+    int k, l;                                                                       \
+    int m, n;                                                                       \
+                                                                                    \
+    data = classes = tmask = missed = sidx = cidx = NULL;                           \
+    sstep = cstep = clstep = ncl = tmstep = ntm = msstep = mcstep = mm = mn = 0;    \
+    sistep = cistep = k = l = m = n = 0;
+
+#define ICV_TRAIN_DATA_REQUIRED( param, flags )                                     \
+    if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) )                                  \
+    {                                                                               \
+        CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );                   \
+    }                                                                               \
+    else                                                                            \
+    {                                                                               \
+        ICV_RAWDATA( *(param), (flags), data, sstep, cstep, m, n );                 \
+        k = n;                                                                      \
+        l = m;                                                                      \
+    }
+
+#define ICV_TRAIN_CLASSES_REQUIRED( param )                                         \
+    if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) )                                  \
+    {                                                                               \
+        CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );                   \
+    }                                                                               \
+    else                                                                            \
+    {                                                                               \
+        ICV_MAT2VEC( *(param), classes, clstep, ncl );                              \
+        if( m != ncl )                                                              \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Unmatched sizes" );                            \
+        }                                                                           \
+    }
+
+#define ICV_ARG_NULL( param )                                                       \
+    if( (param) != NULL )                                                           \
+    {                                                                               \
+        CV_ERROR( CV_StsBadArg, #param " parameter must be NULL" );                 \
+    }
+
+#define ICV_MISSED_MEASUREMENTS_OPTIONAL( param, flags )                            \
+    if( param )                                                                     \
+    {                                                                               \
+        if( !ICV_IS_MAT_OF_TYPE( param, CV_8UC1 ) )                                 \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );               \
+        }                                                                           \
+        else                                                                        \
+        {                                                                           \
+            ICV_RAWDATA( *(param), (flags), missed, msstep, mcstep, mm, mn );       \
+            if( mm != m || mn != n )                                                \
+            {                                                                       \
+                CV_ERROR( CV_StsBadArg, "Unmatched sizes" );                        \
+            }                                                                       \
+        }                                                                           \
+    }
+
+#define ICV_COMP_IDX_OPTIONAL( param )                                              \
+    if( param )                                                                     \
+    {                                                                               \
+        if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) )                                \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );               \
+        }                                                                           \
+        else                                                                        \
+        {                                                                           \
+            ICV_MAT2VEC( *(param), cidx, cistep, k );                               \
+            if( k > n )                                                             \
+                CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );           \
+        }                                                                           \
+    }
+
+#define ICV_SAMPLE_IDX_OPTIONAL( param )                                            \
+    if( param )                                                                     \
+    {                                                                               \
+        if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) )                                \
+        {                                                                           \
+            CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );               \
+        }                                                                           \
+        else                                                                        \
+        {                                                                           \
+            ICV_MAT2VEC( *sampleIdx, sidx, sistep, l );                             \
+            if( l > m )                                                             \
+                CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" );           \
+        }                                                                           \
+    }
+
+/****************************************************************************************/
+#define ICV_CONVERT_FLOAT_ARRAY_TO_MATRICE( array, matrice )        \
+{                                                                   \
+    CvMat a, b;                                                     \
+    int dims = (matrice)->cols;                                     \
+    int nsamples = (matrice)->rows;                                 \
+    int type = CV_MAT_TYPE((matrice)->type);                        \
+    int i, offset = dims;                                           \
+                                                                    \
+    CV_ASSERT( type == CV_32FC1 || type == CV_64FC1 );              \
+    offset *= ((type == CV_32FC1) ? sizeof(float) : sizeof(double));\
+                                                                    \
+    b = cvMat( 1, dims, CV_32FC1 );                                 \
+    cvGetRow( matrice, &a, 0 );                                     \
+    for( i = 0; i < nsamples; i++, a.data.ptr += offset )           \
+    {                                                               \
+        b.data.fl = (float*)array[i];                               \
+        CV_CALL( cvConvert( &b, &a ) );                             \
+    }                                                               \
+}
+
+/****************************************************************************************\
+*                       Auxiliary functions declarations                                 *
+\****************************************************************************************/
+
+/* Generates a set of classes centers in quantity <num_of_clusters> that are generated as
+   uniform random vectors in parallelepiped, where <data> is concentrated. Vectors in
+   <data> should have horizontal orientation. If <centers> != NULL, the function doesn't
+   allocate any memory and stores generated centers in <centers>, returns <centers>.
+   If <centers> == NULL, the function allocates memory and creates the matrice. Centers
+   are supposed to be oriented horizontally. */
+CvMat* icvGenerateRandomClusterCenters( int seed,
+                                        const CvMat* data,
+                                        int num_of_clusters,
+                                        CvMat* centers CV_DEFAULT(0));
+
+/* Fills the <labels> using <probs> by choosing the maximal probability. Outliers are
+   fixed by <oulier_tresh> and have cluster label (-1). Function also controls that there
+   weren't "empty" clusters by filling empty clusters with the maximal probability vector.
+   If probs_sums != NULL, filles it with the sums of probabilities for each sample (it is
+   useful for normalizing probabilities' matrice of FCM) */
+void icvFindClusterLabels( const CvMat* probs, float outlier_thresh, float r,
+                           const CvMat* labels );
+
+typedef struct CvSparseVecElem32f
+{
+    int idx;
+    float val;
+}
+CvSparseVecElem32f;
+
+/* Prepare training data and related parameters */
+#define CV_TRAIN_STATMODEL_DEFRAGMENT_TRAIN_DATA    1
+#define CV_TRAIN_STATMODEL_SAMPLES_AS_ROWS          2
+#define CV_TRAIN_STATMODEL_SAMPLES_AS_COLUMNS       4
+#define CV_TRAIN_STATMODEL_CATEGORICAL_RESPONSE     8
+#define CV_TRAIN_STATMODEL_ORDERED_RESPONSE         16
+#define CV_TRAIN_STATMODEL_RESPONSES_ON_OUTPUT      32
+#define CV_TRAIN_STATMODEL_ALWAYS_COPY_TRAIN_DATA   64
+#define CV_TRAIN_STATMODEL_SPARSE_AS_SPARSE         128
+
+int
+cvPrepareTrainData( const char* /*funcname*/,
+                    const CvMat* train_data, int tflag,
+                    const CvMat* responses, int response_type,
+                    const CvMat* var_idx,
+                    const CvMat* sample_idx,
+                    bool always_copy_data,
+                    const float*** out_train_samples,
+                    int* _sample_count,
+                    int* _var_count,
+                    int* _var_all,
+                    CvMat** out_responses,
+                    CvMat** out_response_map,
+                    CvMat** out_var_idx,
+                    CvMat** out_sample_idx=0 );
+
+void
+cvSortSamplesByClasses( const float** samples, const CvMat* classes,
+                        int* class_ranges, const uchar** mask CV_DEFAULT(0) );
+
+void
+cvCombineResponseMaps (CvMat*  _responses,
+                 const CvMat*  old_response_map,
+                       CvMat*  new_response_map,
+                       CvMat** out_response_map);
+
+void
+cvPreparePredictData( const CvArr* sample, int dims_all, const CvMat* comp_idx,
+                      int class_count, const CvMat* prob, float** row_sample,
+                      int as_sparse CV_DEFAULT(0) );
+
+/* copies clustering [or batch "predict"] results
+   (labels and/or centers and/or probs) back to the output arrays */
+void
+cvWritebackLabels( const CvMat* labels, CvMat* dst_labels,
+                   const CvMat* centers, CvMat* dst_centers,
+                   const CvMat* probs, CvMat* dst_probs,
+                   const CvMat* sample_idx, int samples_all,
+                   const CvMat* comp_idx, int dims_all );
+#define cvWritebackResponses cvWritebackLabels
+
+#define XML_FIELD_NAME "_name"
+CvFileNode* icvFileNodeGetChild(CvFileNode* father, const char* name);
+CvFileNode* icvFileNodeGetChildArrayElem(CvFileNode* father, const char* name,int index);
+CvFileNode* icvFileNodeGetNext(CvFileNode* n, const char* name);
+
+
+void cvCheckTrainData( const CvMat* train_data, int tflag,
+                       const CvMat* missing_mask,
+                       int* var_all, int* sample_all );
+
+CvMat* cvPreprocessIndexArray( const CvMat* idx_arr, int data_arr_size, bool check_for_duplicates=false );
+
+CvMat* cvPreprocessVarType( const CvMat* type_mask, const CvMat* var_idx,
+                            int var_all, int* response_type );
+
+CvMat* cvPreprocessOrderedResponses( const CvMat* responses,
+                const CvMat* sample_idx, int sample_all );
+
+CvMat* cvPreprocessCategoricalResponses( const CvMat* responses,
+                const CvMat* sample_idx, int sample_all,
+                CvMat** out_response_map, CvMat** class_counts=0 );
+
+const float** cvGetTrainSamples( const CvMat* train_data, int tflag,
+                   const CvMat* var_idx, const CvMat* sample_idx,
+                   int* _var_count, int* _sample_count,
+                   bool always_copy_data=false );
+
+namespace cv
+{
+    struct DTreeBestSplitFinder
+    {
+        DTreeBestSplitFinder(){ splitSize = 0, tree = 0; node = 0; }
+        DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node);
+        DTreeBestSplitFinder( const DTreeBestSplitFinder& finder, Split );
+        virtual ~DTreeBestSplitFinder() {}
+        virtual void operator()(const BlockedRange& range);
+        void join( DTreeBestSplitFinder& rhs );
+        Ptr<CvDTreeSplit> bestSplit;
+        Ptr<CvDTreeSplit> split;
+        int splitSize;
+        CvDTree* tree;
+        CvDTreeNode* node;
+    };
+
+    struct ForestTreeBestSplitFinder : DTreeBestSplitFinder
+    {
+        ForestTreeBestSplitFinder() : DTreeBestSplitFinder() {}
+        ForestTreeBestSplitFinder( CvForestTree* _tree, CvDTreeNode* _node );
+        ForestTreeBestSplitFinder( const ForestTreeBestSplitFinder& finder, Split );
+        virtual void operator()(const BlockedRange& range);
+    };
+}
+
+#endif /* __ML_H__ */

apps/traincascade/traincascade.cpp

@@ -1,6 +1,4 @@
 #include "opencv2/core.hpp"
-
-#include "cv.h"
 #include "cascadeclassifier.h"
 
 using namespace std;

apps/traincascade/traincascade_features.h

@@ -2,9 +2,6 @@
 #define _OPENCV_FEATURES_H_
 
 #include "imagestorage.h"
-#include "cxcore.h"
-#include "cv.h"
-#include "ml.h"
 #include <stdio.h>
 
 #define FEATURES "features"

cmake/OpenCVDetectAndroidSDK.cmake

@@ -280,9 +280,6 @@ macro(add_android_project target path)
       string(REGEX REPLACE "LOCAL_MODULE[ ]*:=[ ]*([a-zA-Z_][a-zA-Z_0-9]*)[ ]*" "\\1" JNI_LIB_NAME "${JNI_LIB_NAME}")
 
       if(JNI_LIB_NAME)
-        ocv_include_modules_recurse(${android_proj_NATIVE_DEPS})
-        ocv_include_directories("${path}/jni")
-
         if(NATIVE_APP_GLUE)
           include_directories(${ANDROID_NDK}/sources/android/native_app_glue)
           list(APPEND android_proj_jni_files ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c)
@@ -291,7 +288,9 @@ macro(add_android_project target path)
         endif()
 
         add_library(${JNI_LIB_NAME} MODULE ${android_proj_jni_files})
-        target_link_libraries(${JNI_LIB_NAME} ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
+        ocv_target_include_modules_recurse(${JNI_LIB_NAME} ${android_proj_NATIVE_DEPS})
+        ocv_target_include_directories(${JNI_LIB_NAME} "${path}/jni")
+        ocv_target_link_libraries(${JNI_LIB_NAME} ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
 
         set_target_properties(${JNI_LIB_NAME} PROPERTIES
             OUTPUT_NAME "${JNI_LIB_NAME}"

cmake/OpenCVDetectPython.cmake

@@ -1,101 +1,240 @@
-if(WIN32 AND NOT PYTHON_EXECUTABLE)
-  # search for executable with the same bitness as resulting binaries
-  # standard FindPythonInterp always prefers executable from system path
-  # this is really important because we are using the interpreter for numpy search and for choosing the install location
-  foreach(_CURRENT_VERSION ${Python_ADDITIONAL_VERSIONS} 2.7 "${MIN_VER_PYTHON}")
-    find_host_program(PYTHON_EXECUTABLE
-      NAMES python${_CURRENT_VERSION} python
-      PATHS
-        [HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
-        [HKEY_CURRENT_USER\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
-      NO_SYSTEM_ENVIRONMENT_PATH
-    )
-  endforeach()
-endif()
-find_host_package(PythonInterp 2.7)
-if(NOT PYTHONINTERP_FOUND)
-find_host_package(PythonInterp "${MIN_VER_PYTHON}")
-endif()
+# Find specified Python version
+# Arguments:
+#   preferred_version (value): Version to check for first
+#   min_version (value): Minimum supported version
+#   library_env (value): Name of Python library ENV variable to check
+#   include_dir_env (value): Name of Python include directory ENV variable to check
+#   found (variable): Set if interpreter found
+#   executable (variable): Output of executable found
+#   version_string (variable): Output of found version
+#   version_major (variable): Output of found major version
+#   version_minor (variable): Output of found minor version
+#   libs_found (variable): Set if libs found
+#   libs_version_string (variable): Output of found libs version
+#   libraries (variable): Output of found Python libraries
+#   library (variable): Output of found Python library
+#   debug_libraries (variable): Output of found Python debug libraries
+#   debug_library (variable): Output of found Python debug library
+#   include_path (variable): Output of found Python include path
+#   include_dir (variable): Output of found Python include dir
+#   include_dir2 (variable): Output of found Python include dir2
+#   packages_path (variable): Output of found Python packages path
+#   numpy_include_dirs (variable): Output of found Python Numpy include dirs
+#   numpy_version (variable): Output of found Python Numpy version
+function(find_python preferred_version min_version library_env include_dir_env
+         found executable version_string version_major version_minor
+         libs_found libs_version_string libraries library debug_libraries
+         debug_library include_path include_dir include_dir2 packages_path
+         numpy_include_dirs numpy_version)
 
-unset(HAVE_SPHINX CACHE)
+  ocv_check_environment_variables(${executable})
+  if(${executable})
+    set(PYTHON_EXECUTABLE "${${executable}}")
+  endif()
 
-if(PYTHONINTERP_FOUND)
-  set(PYTHON_VERSION_MAJOR_MINOR "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
+  if(WIN32 AND NOT ${executable})
+    # search for executable with the same bitness as resulting binaries
+    # standard FindPythonInterp always prefers executable from system path
+    # this is really important because we are using the interpreter for numpy search and for choosing the install location
+    foreach(_CURRENT_VERSION ${Python_ADDITIONAL_VERSIONS} "${preferred_version}" "${min_version}")
+      find_host_program(executable
+        NAMES python${_CURRENT_VERSION} python
+        PATHS
+          [HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
+          [HKEY_CURRENT_USER\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
+        NO_SYSTEM_ENVIRONMENT_PATH
+      )
+    endforeach()
+  endif()
 
-  if(NOT ANDROID AND NOT IOS)
-    ocv_check_environment_variables(PYTHON_LIBRARY PYTHON_INCLUDE_DIR)
-    # not using PYTHON_VERSION_STRING here, because it might not conform to the CMake version format
-    find_host_package(PythonLibs "${PYTHON_VERSION_MAJOR_MINOR}.${PYTHON_VERSION_PATCH}" EXACT)
+  find_host_package(PythonInterp "${preferred_version}")
+  if(NOT PYTHONINTERP_FOUND)
+    find_host_package(PythonInterp "${min_version}")
   endif()
 
-  if(NOT ANDROID AND NOT IOS)
-    if(CMAKE_HOST_UNIX)
-      execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import *; print(get_python_lib())"
-                      RESULT_VARIABLE PYTHON_CVPY_PROCESS
-                      OUTPUT_VARIABLE PYTHON_STD_PACKAGES_PATH
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      if("${PYTHON_STD_PACKAGES_PATH}" MATCHES "site-packages")
-        set(_PYTHON_PACKAGES_PATH "python${PYTHON_VERSION_MAJOR_MINOR}/site-packages")
-      else() #debian based assumed, install to the dist-packages.
-        set(_PYTHON_PACKAGES_PATH "python${PYTHON_VERSION_MAJOR_MINOR}/dist-packages")
+  if(PYTHONINTERP_FOUND)
+    # Copy outputs
+    set(_found ${PYTHONINTERP_FOUND})
+    set(_executable ${PYTHON_EXECUTABLE})
+    set(_version_string ${PYTHON_VERSION_STRING})
+    set(_version_major ${PYTHON_VERSION_MAJOR})
+    set(_version_minor ${PYTHON_VERSION_MINOR})
+    set(_version_patch ${PYTHON_VERSION_PATCH})
+
+    # Clear find_host_package side effects
+    unset(PYTHONINTERP_FOUND)
+    unset(PYTHON_EXECUTABLE CACHE)
+    unset(PYTHON_VERSION_STRING)
+    unset(PYTHON_VERSION_MAJOR)
+    unset(PYTHON_VERSION_MINOR)
+    unset(PYTHON_VERSION_PATCH)
+  endif()
+
+  if(_found)
+    set(_version_major_minor "${_version_major}.${_version_minor}")
+
+    if(NOT ANDROID AND NOT IOS)
+      ocv_check_environment_variables(${library_env} ${include_dir_env})
+      if(${library})
+          set(PYTHON_LIBRARY "${${library_env}}")
       endif()
-      if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${PYTHON_PACKAGES_PATH}")
-        set(_PYTHON_PACKAGES_PATH "lib${LIB_SUFFIX}/${_PYTHON_PACKAGES_PATH}")
-      else()
-        set(_PYTHON_PACKAGES_PATH "lib/${_PYTHON_PACKAGES_PATH}")
+      if(${include_dir})
+          set(PYTHON_INCLUDE_DIR "${${include_dir_env}}")
       endif()
-    elseif(CMAKE_HOST_WIN32)
-      get_filename_component(PYTHON_PATH "${PYTHON_EXECUTABLE}" PATH)
-      file(TO_CMAKE_PATH "${PYTHON_PATH}" PYTHON_PATH)
-      if(NOT EXISTS "${PYTHON_PATH}/Lib/site-packages")
-        unset(PYTHON_PATH)
-        get_filename_component(PYTHON_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${PYTHON_VERSION_MAJOR_MINOR}\\InstallPath]" ABSOLUTE)
-        if(NOT PYTHON_PATH)
-           get_filename_component(PYTHON_PATH "[HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${PYTHON_VERSION_MAJOR_MINOR}\\InstallPath]" ABSOLUTE)
-        endif()
-        file(TO_CMAKE_PATH "${PYTHON_PATH}" PYTHON_PATH)
+
+      # not using _version_string here, because it might not conform to the CMake version format
+      find_host_package(PythonLibs "${_version_major_minor}.${_version_patch}" EXACT)
+
+      if(PYTHONLIBS_FOUND)
+        # Copy outputs
+        set(_libs_found ${PYTHONLIBS_FOUND})
+        set(_libraries ${PYTHON_LIBRARIES})
+        set(_include_path ${PYTHON_INCLUDE_PATH})
+        set(_include_dirs ${PYTHON_INCLUDE_DIRS})
+        set(_debug_libraries ${PYTHON_DEBUG_LIBRARIES})
+        set(_libs_version_string ${PYTHONLIBS_VERSION_STRING})
+        set(_debug_library ${PYTHON_DEBUG_LIBRARY})
+        set(_library ${PYTHON_LIBRARY})
+        set(_library_debug ${PYTHON_LIBRARY_DEBUG})
+        set(_library_release ${PYTHON_LIBRARY_RELEASE})
+        set(_include_dir ${PYTHON_INCLUDE_DIR})
+        set(_include_dir2 ${PYTHON_INCLUDE_DIR2})
+
+        # Clear find_host_package side effects
+        unset(PYTHONLIBS_FOUND)
+        unset(PYTHON_LIBRARIES)
+        unset(PYTHON_INCLUDE_PATH)
+        unset(PYTHON_INCLUDE_DIRS)
+        unset(PYTHON_DEBUG_LIBRARIES)
+        unset(PYTHONLIBS_VERSION_STRING)
+        unset(PYTHON_DEBUG_LIBRARY CACHE)
+        unset(PYTHON_LIBRARY)
+        unset(PYTHON_LIBRARY_DEBUG)
+        unset(PYTHON_LIBRARY_RELEASE)
+        unset(PYTHON_LIBRARY CACHE)
+        unset(PYTHON_LIBRARY_DEBUG CACHE)
+        unset(PYTHON_LIBRARY_RELEASE CACHE)
+        unset(PYTHON_INCLUDE_DIR CACHE)
+        unset(PYTHON_INCLUDE_DIR2 CACHE)
       endif()
-      set(_PYTHON_PACKAGES_PATH "${PYTHON_PATH}/Lib/site-packages")
     endif()
-    SET(PYTHON_PACKAGES_PATH "${_PYTHON_PACKAGES_PATH}" CACHE PATH "Where to install the python packages.")
-
-    if(NOT PYTHON_NUMPY_INCLUDE_DIRS)
-      if(CMAKE_CROSSCOMPILING)
-        message(STATUS "Cannot probe for Python/Numpy support (because we are cross-compiling OpenCV)")
-        message(STATUS "If you want to enable Python/Numpy support, set the following variables:")
-        message(STATUS "  PYTHON_INCLUDE_PATH")
-        message(STATUS "  PYTHON_LIBRARIES")
-        message(STATUS "  PYTHON_NUMPY_INCLUDE_DIRS")
-      else()
-        # Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
-        execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print(os.pathsep.join(numpy.distutils.misc_util.get_numpy_include_dirs()))"
-                        RESULT_VARIABLE PYTHON_NUMPY_PROCESS
-                        OUTPUT_VARIABLE PYTHON_NUMPY_INCLUDE_DIRS
+
+    if(NOT ANDROID AND NOT IOS)
+      if(CMAKE_HOST_UNIX)
+        execute_process(COMMAND ${_executable} -c "from distutils.sysconfig import *; print(get_python_lib())"
+                        RESULT_VARIABLE _cvpy_process
+                        OUTPUT_VARIABLE _std_packages_path
                         OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if("${_std_packages_path}" MATCHES "site-packages")
+          set(_packages_path "python${_version_major_minor}/site-packages")
+        else() #debian based assumed, install to the dist-packages.
+          set(_packages_path "python${_version_major_minor}/dist-packages")
+        endif()
+        if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${${packages_path}}")
+          set(_packages_path "lib${LIB_SUFFIX}/${_packages_path}")
+        else()
+          set(_packages_path "lib/${_packages_path}")
+        endif()
+      elseif(CMAKE_HOST_WIN32)
+        get_filename_component(_path "${_executable}" PATH)
+        file(TO_CMAKE_PATH "${_path}" _path)
+        if(NOT EXISTS "${_path}/Lib/site-packages")
+          unset(_path)
+          get_filename_component(_path "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_version_major_minor}\\InstallPath]" ABSOLUTE)
+          if(NOT _path)
+             get_filename_component(_path "[HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_version_major_minor}\\InstallPath]" ABSOLUTE)
+          endif()
+          file(TO_CMAKE_PATH "${_path}" _path)
+        endif()
+        set(_packages_path "${_path}/Lib/site-packages")
+        unset(_path)
+      endif()
+
+      set(_numpy_include_dirs ${${numpy_include_dirs}})
 
-        if(NOT PYTHON_NUMPY_PROCESS EQUAL 0)
-          unset(PYTHON_NUMPY_INCLUDE_DIRS)
+      if(NOT _numpy_include_dirs)
+        if(CMAKE_CROSSCOMPILING)
+          message(STATUS "Cannot probe for Python/Numpy support (because we are cross-compiling OpenCV)")
+          message(STATUS "If you want to enable Python/Numpy support, set the following variables:")
+          message(STATUS "  PYTHON2_INCLUDE_PATH")
+          message(STATUS "  PYTHON2_LIBRARIES")
+          message(STATUS "  PYTHON2_NUMPY_INCLUDE_DIRS")
+          message(STATUS "  PYTHON3_INCLUDE_PATH")
+          message(STATUS "  PYTHON3_LIBRARIES")
+          message(STATUS "  PYTHON3_NUMPY_INCLUDE_DIRS")
+        else()
+          # Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
+          execute_process(COMMAND "${_executable}" -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print(os.pathsep.join(numpy.distutils.misc_util.get_numpy_include_dirs()))"
+                          RESULT_VARIABLE _numpy_process
+                          OUTPUT_VARIABLE _numpy_include_dirs
+                          OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+          if(NOT _numpy_process EQUAL 0)
+              unset(_numpy_include_dirs)
+          endif()
         endif()
       endif()
-    endif()
 
-    if(PYTHON_NUMPY_INCLUDE_DIRS)
-      file(TO_CMAKE_PATH "${PYTHON_NUMPY_INCLUDE_DIRS}" _PYTHON_NUMPY_INCLUDE_DIRS)
-      set(PYTHON_NUMPY_INCLUDE_DIRS ${_PYTHON_NUMPY_INCLUDE_DIRS} CACHE PATH "Path to numpy headers")
-      if(CMAKE_CROSSCOMPILING)
-        if(NOT PYTHON_NUMPY_VERSION)
-          set(PYTHON_NUMPY_VERSION "undefined - cannot be probed because of the cross-compilation")
+      if(_numpy_include_dirs)
+        file(TO_CMAKE_PATH "${_numpy_include_dirs}" _numpy_include_dirs)
+        if(CMAKE_CROSSCOMPILING)
+          if(NOT _numpy_version)
+            set(_numpy_version "undefined - cannot be probed because of the cross-compilation")
+          endif()
+        else()
+          execute_process(COMMAND "${_executable}" -c "import numpy; print(numpy.version.version)"
+                          RESULT_VARIABLE _numpy_process
+                          OUTPUT_VARIABLE _numpy_version
+                          OUTPUT_STRIP_TRAILING_WHITESPACE)
         endif()
-      else()
-        execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import numpy; print(numpy.version.version)"
-                        RESULT_VARIABLE PYTHON_NUMPY_PROCESS
-                        OUTPUT_VARIABLE PYTHON_NUMPY_VERSION
-                        OUTPUT_STRIP_TRAILING_WHITESPACE)
       endif()
-    endif()
-  endif(NOT ANDROID AND NOT IOS)
+    endif(NOT ANDROID AND NOT IOS)
+  endif()
+
+  # Export return values
+  set(${found} "${_found}" PARENT_SCOPE)
+  set(${executable} "${_executable}" CACHE FILEPATH "Path to Python interpretor")
+  set(${version_string} "${_version_string}" PARENT_SCOPE)
+  set(${version_major} "${_version_major}" PARENT_SCOPE)
+  set(${version_minor} "${_version_minor}" PARENT_SCOPE)
+  set(${libs_found} "${_libs_found}" PARENT_SCOPE)
+  set(${libs_version_string} "${_libs_version_string}" PARENT_SCOPE)
+  set(${libraries} "${_libraries}" PARENT_SCOPE)
+  set(${library} "${_library}" CACHE FILEPATH "Path to Python library")
+  set(${debug_libraries} "${_debug_libraries}" PARENT_SCOPE)
+  set(${debug_library} "${_debug_library}" CACHE FILEPATH "Path to Python debug")
+  set(${include_path} "${_include_path}" PARENT_SCOPE)
+  set(${include_dir} "${_include_dir}" CACHE PATH "Python include dir")
+  set(${include_dir2} "${_include_dir2}" CACHE PATH "Python include dir 2")
+  set(${packages_path} "${_packages_path}" CACHE PATH "Where to install the python packages.")
+  set(${numpy_include_dirs} ${_numpy_include_dirs} CACHE PATH "Path to numpy headers")
+  set(${numpy_version} "${_numpy_version}" PARENT_SCOPE)
+endfunction(find_python)
+
+find_python(2.7 "${MIN_VER_PYTHON2}" PYTHON2_LIBRARY PYTHON2_INCLUDE_DIR
+    PYTHON2INTERP_FOUND PYTHON2_EXECUTABLE PYTHON2_VERSION_STRING
+    PYTHON2_VERSION_MAJOR PYTHON2_VERSION_MINOR PYTHON2LIBS_FOUND
+    PYTHON2LIBS_VERSION_STRING PYTHON2_LIBRARIES PYTHON2_LIBRARY
+    PYTHON2_DEBUG_LIBRARIES PYTHON2_LIBRARY_DEBUG PYTHON2_INCLUDE_PATH
+    PYTHON2_INCLUDE_DIR PYTHON2_INCLUDE_DIR2 PYTHON2_PACKAGES_PATH
+    PYTHON2_NUMPY_INCLUDE_DIRS PYTHON2_NUMPY_VERSION)
+
+find_python(3.4 "${MIN_VER_PYTHON3}" PYTHON3_LIBRARY PYTHON3_INCLUDE_DIR
+    PYTHON3INTERP_FOUND PYTHON3_EXECUTABLE PYTHON3_VERSION_STRING
+    PYTHON3_VERSION_MAJOR PYTHON3_VERSION_MINOR PYTHON3LIBS_FOUND
+    PYTHON3LIBS_VERSION_STRING PYTHON3_LIBRARIES PYTHON3_LIBRARY
+    PYTHON3_DEBUG_LIBRARIES PYTHON3_LIBRARY_DEBUG PYTHON3_INCLUDE_PATH
+    PYTHON3_INCLUDE_DIR PYTHON3_INCLUDE_DIR2 PYTHON3_PACKAGES_PATH
+    PYTHON3_NUMPY_INCLUDE_DIRS PYTHON3_NUMPY_VERSION)
+
+# Use Python 2 as default Python interpreter
+if(PYTHON2LIBS_FOUND)
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+    set(PYTHON_DEFAULT_EXECUTABLE "${PYTHON2_EXECUTABLE}")
 endif()
 
+unset(HAVE_SPHINX CACHE)
+
 if(BUILD_DOCS)
   find_host_program(SPHINX_BUILD sphinx-build)
   find_host_program(PLANTUML plantuml)

cmake/OpenCVMinDepVersions.cmake

@@ -1,5 +1,6 @@
 set(MIN_VER_CMAKE 2.8.7)
 set(MIN_VER_CUDA 4.2)
-set(MIN_VER_PYTHON 2.6)
+set(MIN_VER_PYTHON2 2.6)
+set(MIN_VER_PYTHON3 3.2)
 set(MIN_VER_ZLIB 1.2.3)
 set(MIN_VER_GTK 2.18.0)

cmake/OpenCVModule.cmake

@@ -6,16 +6,19 @@
 # Global variables:
 #
 # OPENCV_MODULE_${the_module}_LOCATION
+# OPENCV_MODULE_${the_module}_BINARY_DIR
 # OPENCV_MODULE_${the_module}_DESCRIPTION
 # OPENCV_MODULE_${the_module}_CLASS - PUBLIC|INTERNAL|BINDINGS
 # OPENCV_MODULE_${the_module}_HEADERS
 # OPENCV_MODULE_${the_module}_SOURCES
 # OPENCV_MODULE_${the_module}_DEPS - final flattened set of module dependencies
+# OPENCV_MODULE_${the_module}_DEPS_TO_LINK - differs from above for world build only
 # OPENCV_MODULE_${the_module}_DEPS_EXT - non-module dependencies
 # OPENCV_MODULE_${the_module}_REQ_DEPS
 # OPENCV_MODULE_${the_module}_OPT_DEPS
 # OPENCV_MODULE_${the_module}_PRIVATE_REQ_DEPS
 # OPENCV_MODULE_${the_module}_PRIVATE_OPT_DEPS
+# OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD
 # HAVE_${the_module} - for fast check of module availability
 
 # To control the setup of the module you could also set:
@@ -53,6 +56,7 @@ foreach(mod ${OPENCV_MODULES_BUILD} ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MOD
   unset(OPENCV_MODULE_${mod}_OPT_DEPS CACHE)
   unset(OPENCV_MODULE_${mod}_PRIVATE_REQ_DEPS CACHE)
   unset(OPENCV_MODULE_${mod}_PRIVATE_OPT_DEPS CACHE)
+  unset(OPENCV_MODULE_${mod}_LINK_DEPS CACHE)
 endforeach()
 
 # clean modules info which needs to be recalculated
@@ -61,6 +65,7 @@ set(OPENCV_MODULES_BUILD          "" CACHE INTERNAL "List of OpenCV modules incl
 set(OPENCV_MODULES_DISABLED_USER  "" CACHE INTERNAL "List of OpenCV modules explicitly disabled by user")
 set(OPENCV_MODULES_DISABLED_AUTO  "" CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
 set(OPENCV_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")
+unset(OPENCV_WORLD_MODULES CACHE)
 
 # adds dependencies to OpenCV module
 # Usage:
@@ -68,6 +73,7 @@ set(OPENCV_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of OpenCV modules whic
 # Notes:
 # * <list of dependencies> - can include full names of modules or full pathes to shared/static libraries or cmake targets
 macro(ocv_add_dependencies full_modname)
+  ocv_debug_message("ocv_add_dependencies(" ${full_modname} ${ARGN} ")")
   #we don't clean the dependencies here to allow this macro several times for every module
   foreach(d "REQUIRED" ${ARGN})
     if(d STREQUAL "REQUIRED")
@@ -105,6 +111,7 @@ endmacro()
 # Example:
 #   ocv_add_module(yaom INTERNAL opencv_core opencv_highgui opencv_flann OPTIONAL opencv_cuda)
 macro(ocv_add_module _name)
+  ocv_debug_message("ocv_add_module(" ${_name} ${ARGN} ")")
   string(TOLOWER "${_name}" name)
   string(REGEX REPLACE "^opencv_" "" ${name} "${name}")
   set(the_module opencv_${name})
@@ -134,6 +141,8 @@ macro(ocv_add_module _name)
     set(OPENCV_MODULE_${the_module}_DESCRIPTION "${the_description}" CACHE INTERNAL "Brief description of ${the_module} module")
     set(OPENCV_MODULE_${the_module}_LOCATION    "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${the_module} module sources")
 
+    set(OPENCV_MODULE_${the_module}_LINK_DEPS "" CACHE INTERNAL "")
+
     # parse list of dependencies
     if("${ARGV1}" STREQUAL "INTERNAL" OR "${ARGV1}" STREQUAL "BINDINGS")
       set(OPENCV_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The category of the module")
@@ -150,8 +159,14 @@ macro(ocv_add_module _name)
     endif()
 
     # add self to the world dependencies
-    if(NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS" OR OPENCV_MODULE_IS_PART_OF_WORLD)
+    if((NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS"
+        AND NOT OPENCV_PROCESSING_EXTRA_MODULES)
+        OR OPENCV_MODULE_IS_PART_OF_WORLD
+        )
+      set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD ON CACHE INTERNAL "")
       ocv_add_dependencies(opencv_world OPTIONAL ${the_module})
+    else()
+      set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD OFF CACHE INTERNAL "")
     endif()
 
     if(BUILD_${the_module})
@@ -164,12 +179,15 @@ macro(ocv_add_module _name)
 
     # stop processing of current file
     return()
-  else(OPENCV_INITIAL_PASS)
+  else()
+    set(OPENCV_MODULE_${the_module}_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "")
     if(NOT BUILD_${the_module})
       return() # extra protection from redefinition
     endif()
-    project(${the_module})
-  endif(OPENCV_INITIAL_PASS)
+    if((NOT OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD AND NOT ${the_module} STREQUAL opencv_world) OR NOT ${BUILD_opencv_world})
+      project(${the_module})
+    endif()
+  endif()
 endmacro()
 
 # excludes module from current configuration
@@ -200,7 +218,11 @@ macro(ocv_glob_modules)
 
   # collect modules
   set(OPENCV_INITIAL_PASS ON)
+  set(OPENCV_PROCESSING_EXTRA_MODULES 0)
   foreach(__path ${ARGN})
+    if("${__path}" STREQUAL "EXTRA")
+      set(OPENCV_PROCESSING_EXTRA_MODULES 1)
+    endif()
     get_filename_component(__path "${__path}" ABSOLUTE)
 
     list(FIND __directories_observed "${__path}" __pathIdx)
@@ -222,16 +244,7 @@ macro(ocv_glob_modules)
           endif()
           list(APPEND __directories_observed "${__modpath}")
 
-          if(OCV_MODULE_RELOCATE_ON_INITIAL_PASS)
-            file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
-            file(COPY "${__modpath}/CMakeLists.txt" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
-            add_subdirectory("${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
-            if("${OPENCV_MODULE_opencv_${mod}_LOCATION}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
-              set(OPENCV_MODULE_opencv_${mod}_LOCATION "${__modpath}" CACHE PATH "" FORCE)
-            endif()
-          else()
-            add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
-          endif()
+          add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
         endif()
       endforeach()
     endif()
@@ -244,15 +257,31 @@ macro(ocv_glob_modules)
   # create modules
   set(OPENCV_INITIAL_PASS OFF PARENT_SCOPE)
   set(OPENCV_INITIAL_PASS OFF)
-  foreach(m ${OPENCV_MODULES_BUILD})
-    if(m MATCHES "^opencv_")
-      string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
-      add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
-    else()
-      message(WARNING "Check module name: ${m}")
-      add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
-    endif()
-  endforeach()
+  if(${BUILD_opencv_world})
+    add_subdirectory("${OPENCV_MODULE_opencv_world_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/world")
+    foreach(m ${OPENCV_MODULES_BUILD})
+      if(NOT OPENCV_MODULE_${m}_IS_PART_OF_WORLD AND NOT ${m} STREQUAL opencv_world)
+        message(STATUS "Processing module ${m}...")
+        if(m MATCHES "^opencv_")
+          string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
+          add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
+        else()
+          message(WARNING "Check module name: ${m}")
+          add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
+        endif()
+      endif()
+    endforeach()
+  else()
+    foreach(m ${OPENCV_MODULES_BUILD})
+      if(m MATCHES "^opencv_")
+        string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
+        add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
+      else()
+        message(WARNING "Check module name: ${m}")
+        add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
+      endif()
+    endforeach()
+  endif()
   unset(__shortname)
 endmacro()
 
@@ -394,11 +423,36 @@ function(__ocv_resolve_dependencies)
     __ocv_sort_modules_by_deps(OPENCV_MODULE_${m}_DEPS)
     ocv_list_sort(OPENCV_MODULE_${m}_DEPS_EXT)
 
+    set(LINK_DEPS ${OPENCV_MODULE_${m}_DEPS})
+
+    # process world
+    if(BUILD_opencv_world)
+      if(OPENCV_MODULE_${m}_IS_PART_OF_WORLD)
+        list(APPEND OPENCV_WORLD_MODULES ${m})
+      endif()
+      foreach(m2 ${OPENCV_MODULES_BUILD})
+        if(OPENCV_MODULE_${m2}_IS_PART_OF_WORLD)
+          if(";${LINK_DEPS};" MATCHES ";${m2};")
+            list(REMOVE_ITEM LINK_DEPS ${m2})
+            if(NOT (";${LINK_DEPS};" MATCHES ";opencv_world;") AND NOT (${m} STREQUAL opencv_world))
+              list(APPEND LINK_DEPS opencv_world)
+            endif()
+          endif()
+          if(${m} STREQUAL opencv_world)
+            list(APPEND OPENCV_MODULE_opencv_world_DEPS_EXT ${OPENCV_MODULE_${m2}_DEPS_EXT})
+          endif()
+        endif()
+      endforeach()
+    endif()
+
     set(OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module")
     set(OPENCV_MODULE_${m}_DEPS_EXT ${OPENCV_MODULE_${m}_DEPS_EXT} CACHE INTERNAL "Extra dependencies of ${m} module")
+    set(OPENCV_MODULE_${m}_DEPS_TO_LINK ${LINK_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module (for linker)")
 
-#    message(STATUS "  module deps: ${OPENCV_MODULE_${m}_DEPS}")
-#    message(STATUS "  extra deps: ${OPENCV_MODULE_${m}_DEPS_EXT}")
+#    message(STATUS "  module deps of ${m}: ${OPENCV_MODULE_${m}_DEPS}")
+#    message(STATUS "  module link deps of ${m}: ${OPENCV_MODULE_${m}_DEPS_TO_LINK}")
+#    message(STATUS "  extra deps of ${m}: ${OPENCV_MODULE_${m}_DEPS_EXT}")
+#    message(STATUS "")
   endforeach()
 
   __ocv_sort_modules_by_deps(OPENCV_MODULES_BUILD)
@@ -406,6 +460,7 @@ function(__ocv_resolve_dependencies)
   set(OPENCV_MODULES_PUBLIC        ${OPENCV_MODULES_PUBLIC}        CACHE INTERNAL "List of OpenCV modules marked for export")
   set(OPENCV_MODULES_BUILD         ${OPENCV_MODULES_BUILD}         CACHE INTERNAL "List of OpenCV modules included into the build")
   set(OPENCV_MODULES_DISABLED_AUTO ${OPENCV_MODULES_DISABLED_AUTO} CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
+  set(OPENCV_WORLD_MODULES         ${OPENCV_WORLD_MODULES}         CACHE INTERNAL "List of OpenCV modules included into the world")
 endfunction()
 
 
@@ -422,18 +477,31 @@ macro(ocv_include_modules)
   endforeach()
 endmacro()
 
+# setup include paths for the list of passed modules
+macro(ocv_target_include_modules target)
+  foreach(d ${ARGN})
+    if(d MATCHES "^opencv_" AND HAVE_${d})
+      if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
+        ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")
+      endif()
+    elseif(EXISTS "${d}")
+      ocv_target_include_directories(${target} "${d}")
+    endif()
+  endforeach()
+endmacro()
+
 # setup include paths for the list of passed modules and recursively add dependent modules
-macro(ocv_include_modules_recurse)
+macro(ocv_target_include_modules_recurse target)
   foreach(d ${ARGN})
     if(d MATCHES "^opencv_" AND HAVE_${d})
       if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
-        ocv_include_directories("${OPENCV_MODULE_${d}_LOCATION}/include")
+        ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")
       endif()
       if(OPENCV_MODULE_${d}_DEPS)
-        ocv_include_modules(${OPENCV_MODULE_${d}_DEPS})
+        ocv_target_include_modules(${target} ${OPENCV_MODULE_${d}_DEPS})
       endif()
     elseif(EXISTS "${d}")
-      ocv_include_directories("${d}")
+      ocv_target_include_directories(${target} "${d}")
     endif()
   endforeach()
 endmacro()
@@ -441,11 +509,12 @@ endmacro()
 # setup include path for OpenCV headers for specified module
 # ocv_module_include_directories(<extra include directories/extra include modules>)
 macro(ocv_module_include_directories)
-  ocv_include_directories("${OPENCV_MODULE_${the_module}_LOCATION}/include"
-                          "${OPENCV_MODULE_${the_module}_LOCATION}/src"
-                          "${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers
-                          )
-  ocv_include_modules(${OPENCV_MODULE_${the_module}_DEPS} ${ARGN})
+  ocv_target_include_directories(${the_module}
+      "${OPENCV_MODULE_${the_module}_LOCATION}/include"
+      "${OPENCV_MODULE_${the_module}_LOCATION}/src"
+      "${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers
+      )
+  ocv_target_include_modules(${the_module} ${OPENCV_MODULE_${the_module}_DEPS} ${ARGN})
 endmacro()
 
 
@@ -454,6 +523,8 @@ endmacro()
 # Usage:
 # ocv_set_module_sources([HEADERS] <list of files> [SOURCES] <list of files>)
 macro(ocv_set_module_sources)
+  ocv_debug_message("ocv_set_module_sources(" ${ARGN} ")")
+
   set(OPENCV_MODULE_${the_module}_HEADERS "")
   set(OPENCV_MODULE_${the_module}_SOURCES "")
 
@@ -481,31 +552,50 @@ endmacro()
 # Usage:
 # ocv_glob_module_sources([EXCLUDE_CUDA] <extra sources&headers in the same format as used in ocv_set_module_sources>)
 macro(ocv_glob_module_sources)
+  ocv_debug_message("ocv_glob_module_sources(" ${ARGN} ")")
   set(_argn ${ARGN})
   list(FIND _argn "EXCLUDE_CUDA" exclude_cuda)
   if(NOT exclude_cuda EQUAL -1)
     list(REMOVE_AT _argn ${exclude_cuda})
   endif()
 
-  file(GLOB_RECURSE lib_srcs "src/*.cpp")
-  file(GLOB_RECURSE lib_int_hdrs "src/*.hpp" "src/*.h")
-  file(GLOB lib_hdrs     "include/opencv2/*.hpp" "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
-  file(GLOB lib_hdrs_detail "include/opencv2/${name}/detail/*.hpp" "include/opencv2/${name}/detail/*.h")
-  file(GLOB_RECURSE lib_srcs_apple "src/*.mm")
+  file(GLOB_RECURSE lib_srcs
+       "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp"
+  )
+  file(GLOB_RECURSE lib_int_hdrs
+       "${CMAKE_CURRENT_LIST_DIR}/src/*.hpp"
+       "${CMAKE_CURRENT_LIST_DIR}/src/*.h"
+  )
+  file(GLOB lib_hdrs
+       "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/*.hpp"
+       "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.hpp"
+       "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.h"
+  )
+  file(GLOB lib_hdrs_detail
+       "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.hpp"
+       "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.h"
+  )
   if (APPLE)
+    file(GLOB_RECURSE lib_srcs_apple
+         "${CMAKE_CURRENT_LIST_DIR}/src/*.mm"
+    )
     list(APPEND lib_srcs ${lib_srcs_apple})
   endif()
 
-  ocv_source_group("Src" DIRBASE "${CMAKE_CURRENT_SOURCE_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs})
-  ocv_source_group("Include" DIRBASE "${CMAKE_CURRENT_SOURCE_DIR}/include" FILES ${lib_hdrs} ${lib_hdrs_detail})
+  ocv_source_group("Src" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs})
+  ocv_source_group("Include" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/include" FILES ${lib_hdrs} ${lib_hdrs_detail})
 
   if (exclude_cuda EQUAL -1)
-    file(GLOB lib_cuda_srcs "src/cuda/*.cu")
+    file(GLOB lib_cuda_srcs
+         "${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.cu"
+    )
     set(cuda_objs "")
     set(lib_cuda_hdrs "")
     if(HAVE_CUDA)
       ocv_include_directories(${CUDA_INCLUDE_DIRS})
-      file(GLOB lib_cuda_hdrs "src/cuda/*.hpp")
+      file(GLOB lib_cuda_hdrs
+           "${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.hpp"
+      )
 
       ocv_cuda_compile(cuda_objs ${lib_cuda_srcs} ${lib_cuda_hdrs})
       source_group("Src\\Cuda"      FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})
@@ -516,17 +606,19 @@ macro(ocv_glob_module_sources)
     set(lib_cuda_hdrs "")
   endif()
 
-  file(GLOB cl_kernels "src/opencl/*.cl")
+  file(GLOB cl_kernels
+       "${CMAKE_CURRENT_LIST_DIR}/src/opencl/*.cl"
+  )
   if(cl_kernels)
+    set(OCL_NAME opencl_kernels_${name})
     ocv_include_directories(${OPENCL_INCLUDE_DIRS})
-    string(REGEX REPLACE "opencv_" "" the_module_barename "${the_module}")
     add_custom_command(
-      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.hpp"
-      COMMAND ${CMAKE_COMMAND} -DMODULE_NAME="${the_module_barename}" -DCL_DIR="${CMAKE_CURRENT_SOURCE_DIR}/src/opencl" -DOUTPUT="${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" -P "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake"
+      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp"
+      COMMAND ${CMAKE_COMMAND} -DMODULE_NAME="${name}" -DCL_DIR="${CMAKE_CURRENT_LIST_DIR}/src/opencl" -DOUTPUT="${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" -P "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake"
       DEPENDS ${cl_kernels} "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake")
     ocv_source_group("Src\\opencl\\kernels" FILES ${cl_kernels})
-    ocv_source_group("Src\\opencl\\kernels\\autogenerated" FILES "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.hpp")
-    list(APPEND lib_srcs ${cl_kernels} "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.hpp")
+    ocv_source_group("Src\\opencl\\kernels\\autogenerated" FILES "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")
+    list(APPEND lib_srcs ${cl_kernels} "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")
   endif()
 
   ocv_set_module_sources(${_argn} HEADERS ${lib_hdrs} ${lib_hdrs_detail}
@@ -537,29 +629,39 @@ endmacro()
 # creates new target, configures standard dependencies, compilers flags, install rules
 # Usage:
 #   ocv_create_module(<extra link dependencies>)
-#   ocv_create_module(SKIP_LINK)
+#   ocv_create_module()
 macro(ocv_create_module)
+  ocv_debug_message("ocv_create_module(" ${ARGN} ")")
+  set(OPENCV_MODULE_${the_module}_LINK_DEPS "${OPENCV_MODULE_${the_module}_LINK_DEPS};${ARGN}" CACHE INTERNAL "")
+  if(${BUILD_opencv_world} AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
+    # nothing
+    set(the_module_target opencv_world)
+  else()
+    _ocv_create_module(${ARGN})
+    set(the_module_target ${the_module})
+  endif()
+endmacro()
+
+macro(_ocv_create_module)
   # The condition we ought to be testing here is whether ocv_add_precompiled_headers will
   # be called at some point in the future. We can't look into the future, though,
   # so this will have to do.
-  if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp")
+  if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp" AND NOT ${the_module} STREQUAL opencv_world)
     get_native_precompiled_header(${the_module} precomp.hpp)
   endif()
 
-  add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}
+  ocv_add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}
     "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp"
     ${${the_module}_pch})
   if(NOT the_module STREQUAL opencv_ts)
     set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL)
   endif()
 
-  if(NOT "${ARGN}" STREQUAL "SKIP_LINK")
-    target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS})
-    target_link_libraries(${the_module} LINK_INTERFACE_LIBRARIES ${OPENCV_MODULE_${the_module}_DEPS})
-    target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
-    if (HAVE_CUDA)
-      target_link_libraries(${the_module} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
-    endif()
+  ocv_target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
+  ocv_target_link_libraries(${the_module} LINK_INTERFACE_LIBRARIES ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
+  ocv_target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
+  if (HAVE_CUDA)
+    ocv_target_link_libraries(${the_module} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
   endif()
 
   add_dependencies(opencv_modules ${the_module})
@@ -614,13 +716,16 @@ macro(ocv_create_module)
       endif()
     endforeach()
   endif()
+  _ocv_add_precompiled_headers(${the_module})
 endmacro()
 
 # opencv precompiled headers macro (can add pch to modules and tests)
 # this macro must be called after any "add_definitions" commands, otherwise precompiled headers will not work
 # Usage:
 # ocv_add_precompiled_headers(${the_module})
-macro(ocv_add_precompiled_headers the_target)
+macro(_ocv_add_precompiled_headers the_target)
+  ocv_debug_message("ocv_add_precompiled_headers(" ${the_target} ${ARGN} ")")
+
   if("${the_target}" MATCHES "^opencv_test_.*$")
     SET(pch_path "test/test_")
   elseif("${the_target}" MATCHES "^opencv_perf_.*$")
@@ -637,6 +742,7 @@ endmacro()
 # Usage:
 # ocv_define_module(module_name  [INTERNAL] [EXCLUDE_CUDA] [REQUIRED] [<list of dependencies>] [OPTIONAL <list of optional dependencies>])
 macro(ocv_define_module module_name)
+  ocv_debug_message("ocv_define_module(" ${module_name} ${ARGN} ")")
   set(_argn ${ARGN})
   set(exclude_cuda "")
   foreach(arg ${_argn})
@@ -647,10 +753,9 @@ macro(ocv_define_module module_name)
   endforeach()
 
   ocv_add_module(${module_name} ${_argn})
-  ocv_module_include_directories()
   ocv_glob_module_sources(${exclude_cuda})
+  ocv_module_include_directories()
   ocv_create_module()
-  ocv_add_precompiled_headers(${the_module})
 
   ocv_add_accuracy_tests()
   ocv_add_perf_tests()
@@ -685,7 +790,7 @@ macro(__ocv_parse_test_sources tests_type)
       set(__file_group_name "")
       set(__file_group_sources "")
     elseif(arg STREQUAL "DEPENDS_ON")
-      set(__currentvar "OPENCV_TEST_${the_module}_DEPS")
+      set(__currentvar "OPENCV_${tests_type}_${the_module}_DEPS")
     elseif("${__currentvar}" STREQUAL "__file_group_sources" AND NOT __file_group_name)
       set(__file_group_name "${arg}")
     else()
@@ -700,20 +805,20 @@ endmacro()
 # this is a command for adding OpenCV performance tests to the module
 # ocv_add_perf_tests(<extra_dependencies>)
 function(ocv_add_perf_tests)
-  set(perf_path "${CMAKE_CURRENT_SOURCE_DIR}/perf")
+  ocv_debug_message("ocv_add_perf_tests(" ${ARGN} ")")
+
+  set(perf_path "${CMAKE_CURRENT_LIST_DIR}/perf")
   if(BUILD_PERF_TESTS AND EXISTS "${perf_path}")
     __ocv_parse_test_sources(PERF ${ARGN})
 
     # opencv_imgcodecs is required for imread/imwrite
-    set(perf_deps ${the_module} opencv_ts opencv_imgcodecs ${OPENCV_PERF_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
+    set(perf_deps ${the_module} opencv_ts opencv_imgcodecs ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
     ocv_check_dependencies(${perf_deps})
 
     if(OCV_DEPENDENCIES_FOUND)
       set(the_target "opencv_perf_${name}")
       # project(${the_target})
 
-      ocv_module_include_directories(${perf_deps} "${perf_path}")
-
       if(NOT OPENCV_PERF_${the_module}_SOURCES)
         file(GLOB_RECURSE perf_srcs "${perf_path}/*.cpp")
         file(GLOB_RECURSE perf_hdrs "${perf_path}/*.hpp" "${perf_path}/*.h")
@@ -722,10 +827,13 @@ function(ocv_add_perf_tests)
         set(OPENCV_PERF_${the_module}_SOURCES ${perf_srcs} ${perf_hdrs})
       endif()
 
-      get_native_precompiled_header(${the_target} perf_precomp.hpp)
+      if(NOT BUILD_opencv_world)
+        get_native_precompiled_header(${the_target} perf_precomp.hpp)
+      endif()
 
-      add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch})
-      target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
+      ocv_add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch})
+      ocv_target_include_modules(${the_target} ${perf_deps} "${perf_path}")
+      ocv_target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
       add_dependencies(opencv_perf_tests ${the_target})
 
       # Additional target properties
@@ -738,8 +846,9 @@ function(ocv_add_perf_tests)
         set_target_properties(${the_target} PROPERTIES FOLDER "tests performance")
       endif()
 
-      ocv_add_precompiled_headers(${the_target})
-
+      if(NOT BUILD_opencv_world)
+        _ocv_add_precompiled_headers(${the_target})
+      endif()
     else(OCV_DEPENDENCIES_FOUND)
       # TODO: warn about unsatisfied dependencies
     endif(OCV_DEPENDENCIES_FOUND)
@@ -752,21 +861,19 @@ endfunction()
 # this is a command for adding OpenCV accuracy/regression tests to the module
 # ocv_add_accuracy_tests([FILES <source group name> <list of sources>] [DEPENDS_ON] <list of extra dependencies>)
 function(ocv_add_accuracy_tests)
-  set(test_path "${CMAKE_CURRENT_SOURCE_DIR}/test")
-  ocv_check_dependencies(${test_deps})
+  ocv_debug_message("ocv_add_accuracy_tests(" ${ARGN} ")")
+
+  set(test_path "${CMAKE_CURRENT_LIST_DIR}/test")
   if(BUILD_TESTS AND EXISTS "${test_path}")
     __ocv_parse_test_sources(TEST ${ARGN})
 
     # opencv_imgcodecs is required for imread/imwrite
-    set(test_deps ${the_module} opencv_ts opencv_imgcodecs opencv_videoio ${OPENCV_TEST_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
+    set(test_deps ${the_module} opencv_ts opencv_imgcodecs opencv_videoio ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
     ocv_check_dependencies(${test_deps})
-
     if(OCV_DEPENDENCIES_FOUND)
       set(the_target "opencv_test_${name}")
       # project(${the_target})
 
-      ocv_module_include_directories(${test_deps} "${test_path}")
-
       if(NOT OPENCV_TEST_${the_module}_SOURCES)
         file(GLOB_RECURSE test_srcs "${test_path}/*.cpp")
         file(GLOB_RECURSE test_hdrs "${test_path}/*.hpp" "${test_path}/*.h")
@@ -775,10 +882,13 @@ function(ocv_add_accuracy_tests)
         set(OPENCV_TEST_${the_module}_SOURCES ${test_srcs} ${test_hdrs})
       endif()
 
-      get_native_precompiled_header(${the_target} test_precomp.hpp)
-      add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})
+      if(NOT BUILD_opencv_world)
+        get_native_precompiled_header(${the_target} test_precomp.hpp)
+      endif()
 
-      target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
+      ocv_add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})
+      ocv_target_include_modules(${the_target} ${test_deps} "${test_path}")
+      ocv_target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
       add_dependencies(opencv_tests ${the_target})
 
       # Additional target properties
@@ -795,7 +905,9 @@ function(ocv_add_accuracy_tests)
       get_target_property(LOC ${the_target} LOCATION)
       add_test(${the_target} "${LOC}")
 
-      ocv_add_precompiled_headers(${the_target})
+      if(NOT BUILD_opencv_world)
+        _ocv_add_precompiled_headers(${the_target})
+      endif()
     else(OCV_DEPENDENCIES_FOUND)
       # TODO: warn about unsatisfied dependencies
     endif(OCV_DEPENDENCIES_FOUND)
@@ -807,6 +919,8 @@ function(ocv_add_accuracy_tests)
 endfunction()
 
 function(ocv_add_samples)
+  ocv_debug_message("ocv_add_samples(" ${ARGN} ")")
+
   set(samples_path "${CMAKE_CURRENT_SOURCE_DIR}/samples")
   string(REGEX REPLACE "^opencv_" "" module_id ${the_module})
 
@@ -816,15 +930,14 @@ function(ocv_add_samples)
 
     if(OCV_DEPENDENCIES_FOUND)
       file(GLOB sample_sources "${samples_path}/*.cpp")
-      ocv_include_modules(${OPENCV_MODULE_${the_module}_DEPS})
 
       foreach(source ${sample_sources})
         get_filename_component(name "${source}" NAME_WE)
         set(the_target "example_${module_id}_${name}")
 
-        add_executable(${the_target} "${source}")
-        target_link_libraries(${the_target} ${samples_deps})
-
+        ocv_add_executable(${the_target} "${source}")
+        ocv_target_include_modules(${the_target} ${samples_deps})
+        ocv_target_link_libraries(${the_target} ${samples_deps})
         set_target_properties(${the_target} PROPERTIES PROJECT_LABEL "(sample) ${name}")
 
         if(ENABLE_SOLUTION_FOLDERS)
@@ -847,82 +960,3 @@ function(ocv_add_samples)
             PERMISSIONS OWNER_READ GROUP_READ WORLD_READ COMPONENT samples)
   endif()
 endfunction()
-
-# internal macro; finds all link dependencies of the module
-# should be used at the end of CMake processing
-macro(__ocv_track_module_link_dependencies the_module optkind)
-  set(${the_module}_MODULE_DEPS_${optkind}   "")
-  set(${the_module}_EXTRA_DEPS_${optkind}    "")
-
-  get_target_property(__module_type ${the_module} TYPE)
-  if(__module_type STREQUAL "STATIC_LIBRARY")
-    #in case of static library we have to inherit its dependencies (in right order!!!)
-    if(NOT DEFINED ${the_module}_LIB_DEPENDS_${optkind})
-      ocv_split_libs_list(${the_module}_LIB_DEPENDS ${the_module}_LIB_DEPENDS_DBG ${the_module}_LIB_DEPENDS_OPT)
-    endif()
-
-    set(__resolved_deps "")
-    set(__mod_depends ${${the_module}_LIB_DEPENDS_${optkind}})
-    set(__has_cycle FALSE)
-
-    while(__mod_depends)
-      list(GET __mod_depends 0 __dep)
-      list(REMOVE_AT __mod_depends 0)
-      if(__dep STREQUAL the_module)
-        set(__has_cycle TRUE)
-      else()#if("${OPENCV_MODULES_BUILD}" MATCHES "(^|;)${__dep}(;|$)")
-        ocv_regex_escape(__rdep "${__dep}")
-        if(__resolved_deps MATCHES "(^|;)${__rdep}(;|$)")
-          #all dependencies of this module are already resolved
-          list(APPEND ${the_module}_MODULE_DEPS_${optkind} "${__dep}")
-        else()
-          get_target_property(__module_type ${__dep} TYPE)
-          if(__module_type STREQUAL "STATIC_LIBRARY")
-            if(NOT DEFINED ${__dep}_LIB_DEPENDS_${optkind})
-              ocv_split_libs_list(${__dep}_LIB_DEPENDS ${__dep}_LIB_DEPENDS_DBG ${__dep}_LIB_DEPENDS_OPT)
-            endif()
-            list(INSERT __mod_depends 0 ${${__dep}_LIB_DEPENDS_${optkind}} ${__dep})
-            list(APPEND __resolved_deps "${__dep}")
-          elseif(NOT __module_type)
-            list(APPEND  ${the_module}_EXTRA_DEPS_${optkind} "${__dep}")
-          endif()
-        endif()
-      #else()
-       # get_target_property(__dep_location "${__dep}" LOCATION)
-      endif()
-    endwhile()
-
-    ocv_list_unique(${the_module}_MODULE_DEPS_${optkind})
-    #ocv_list_reverse(${the_module}_MODULE_DEPS_${optkind})
-    ocv_list_unique(${the_module}_EXTRA_DEPS_${optkind})
-    #ocv_list_reverse(${the_module}_EXTRA_DEPS_${optkind})
-
-    if(__has_cycle)
-      # not sure if it can work
-      list(APPEND ${the_module}_MODULE_DEPS_${optkind} "${the_module}")
-    endif()
-
-    unset(__dep_location)
-    unset(__mod_depends)
-    unset(__resolved_deps)
-    unset(__has_cycle)
-    unset(__rdep)
-  endif()#STATIC_LIBRARY
-  unset(__module_type)
-
-  #message("${the_module}_MODULE_DEPS_${optkind}")
-  #message("       ${${the_module}_MODULE_DEPS_${optkind}}")
-  #message("       ${OPENCV_MODULE_${the_module}_DEPS}")
-  #message("")
-  #message("${the_module}_EXTRA_DEPS_${optkind}")
-  #message("       ${${the_module}_EXTRA_DEPS_${optkind}}")
-  #message("")
-endmacro()
-
-# creates lists of build dependencies needed for external projects
-macro(ocv_track_build_dependencies)
-  foreach(m ${OPENCV_MODULES_BUILD})
-    __ocv_track_module_link_dependencies("${m}" OPT)
-    __ocv_track_module_link_dependencies("${m}" DBG)
-  endforeach()
-endmacro()

cmake/OpenCVPCHSupport.cmake

@@ -68,6 +68,15 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
         endif()
     ENDFOREACH(item)
 
+    get_target_property(DIRINC ${_PCH_current_target} INCLUDE_DIRECTORIES )
+    FOREACH(item ${DIRINC})
+        if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
+          LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
+        else()
+          LIST(APPEND ${_out_compile_flags} "${_PCH_isystem_prefix}\"${item}\"")
+        endif()
+    ENDFOREACH(item)
+
     GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)
     GET_DIRECTORY_PROPERTY(_global_definitions DIRECTORY ${OpenCV_SOURCE_DIR} DEFINITIONS)
     #MESSAGE("_directory_flags ${_directory_flags} ${_global_definitions}" )
@@ -254,6 +263,9 @@ MACRO(ADD_PRECOMPILED_HEADER _targetName _input)
         endif()
     endif()
 
+    get_target_property(DIRINC ${_targetName} INCLUDE_DIRECTORIES)
+    set_target_properties(${_targetName}_pch_dephelp PROPERTIES INCLUDE_DIRECTORIES "${DIRINC}")
+
     #MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")
     #message("COMMAND ${CMAKE_CXX_COMPILER}	${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")
 

cmake/OpenCVUtils.cmake

@@ -42,6 +42,11 @@ macro(ocv_assert)
   endif()
 endmacro()
 
+macro(ocv_debug_message)
+#  string(REPLACE ";" " " __msg "${ARGN}")
+#  message(STATUS "${__msg}")
+endmacro()
+
 macro(ocv_check_environment_variables)
   foreach(_var ${ARGN})
     if(NOT DEFINED ${_var} AND DEFINED ENV{${_var}})
@@ -53,8 +58,18 @@ macro(ocv_check_environment_variables)
   endforeach()
 endmacro()
 
+# rename modules target to world if needed
+macro(_ocv_fix_target target_var)
+  if(BUILD_opencv_world)
+    if(OPENCV_MODULE_${${target_var}}_IS_PART_OF_WORLD)
+      set(${target_var} opencv_world)
+    endif()
+  endif()
+endmacro()
+
 # adds include directories in such way that directories from the OpenCV source tree go first
 function(ocv_include_directories)
+  ocv_debug_message("ocv_include_directories( ${ARGN} )")
   set(__add_before "")
   foreach(dir ${ARGN})
     get_filename_component(__abs_dir "${dir}" ABSOLUTE)
@@ -67,6 +82,30 @@ function(ocv_include_directories)
   include_directories(BEFORE ${__add_before})
 endfunction()
 
+# adds include directories in such way that directories from the OpenCV source tree go first
+function(ocv_target_include_directories target)
+  _ocv_fix_target(target)
+  set(__params "")
+  foreach(dir ${ARGN})
+    get_filename_component(__abs_dir "${dir}" ABSOLUTE)
+    if("${__abs_dir}" MATCHES "^${OpenCV_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${OpenCV_BINARY_DIR}")
+      list(APPEND __params "${__abs_dir}")
+    else()
+      list(APPEND __params "${dir}")
+    endif()
+  endforeach()
+  if(CMAKE_VERSION VERSION_LESS 2.8.11)
+    include_directories(${__params})
+  else()
+    if(TARGET ${target})
+      target_include_directories(${target} PRIVATE ${__params})
+    else()
+      set(__new_inc "${OCV_TARGET_INCLUDE_DIRS_${target}};${__params}")
+      set(OCV_TARGET_INCLUDE_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
+    endif()
+  endif()
+endfunction()
+
 # clears all passed variables
 macro(ocv_clear_vars)
   foreach(_var ${ARGN})
@@ -295,8 +334,8 @@ endfunction()
 
 macro(ocv_finalize_status)
   if(NOT OPENCV_SKIP_STATUS_FINALIZATION)
-    if(TARGET opencv_core)
-      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
+    if(DEFINED OPENCV_MODULE_opencv_core_BINARY_DIR)
+      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${OPENCV_MODULE_opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
     endif()
   endif()
 endmacro()
@@ -533,16 +572,20 @@ function(ocv_install_target)
 
 #      message(STATUS "Process ${__target} dst=${__dst}...")
       if(DEFINED __dst)
-        get_target_property(fname ${__target} LOCATION_DEBUG)
-        if(fname MATCHES "\\.lib$")
-          string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
-          install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
-        endif()
+        if(CMAKE_VERSION VERSION_LESS 2.8.12)
+          get_target_property(fname ${__target} LOCATION_DEBUG)
+          if(fname MATCHES "\\.lib$")
+            string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
+            install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
+          endif()
 
-        get_target_property(fname ${__target} LOCATION_RELEASE)
-        if(fname MATCHES "\\.lib$")
-          string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
-          install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
+          get_target_property(fname ${__target} LOCATION_RELEASE)
+          if(fname MATCHES "\\.lib$")
+            string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
+            install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
+          endif()
+        else()
+          # CMake 2.8.12 brokes PDB support in STATIC libraries for MSVS
         endif()
       endif()
     endif()
@@ -637,6 +680,9 @@ endmacro()
 ################################################################################################
 # short command to setup source group
 function(ocv_source_group group)
+  if(BUILD_opencv_world AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
+    set(group "${the_module}\\${group}")
+  endif()
   cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN})
   set(files "")
   if(SG_FILES)
@@ -669,3 +715,39 @@ function(ocv_source_group group)
     source_group(${group} FILES ${files})
   endif()
 endfunction()
+
+function(ocv_target_link_libraries target)
+  _ocv_fix_target(target)
+  set(LINK_DEPS ${ARGN})
+  # process world
+  if(BUILD_opencv_world)
+    foreach(m ${OPENCV_MODULES_BUILD})
+      if(OPENCV_MODULE_${m}_IS_PART_OF_WORLD)
+        if(";${LINK_DEPS};" MATCHES ";${m};")
+          list(REMOVE_ITEM LINK_DEPS ${m})
+          if(NOT (";${LINK_DEPS};" MATCHES ";opencv_world;"))
+            list(APPEND LINK_DEPS opencv_world)
+          endif()
+        endif()
+      endif()
+    endforeach()
+  endif()
+  target_link_libraries(${target} ${LINK_DEPS})
+endfunction()
+
+function(_ocv_append_target_includes target)
+  if(DEFINED OCV_TARGET_INCLUDE_DIRS_${target})
+    target_include_directories(${target} PRIVATE ${OCV_TARGET_INCLUDE_DIRS_${target}})
+    unset(OCV_TARGET_INCLUDE_DIRS_${target} CACHE)
+  endif()
+endfunction()
+
+function(ocv_add_executable target)
+  add_executable(${target} ${ARGN})
+  _ocv_append_target_includes(${target})
+endfunction()
+
+function(ocv_add_library target)
+  add_library(${target} ${ARGN})
+  _ocv_append_target_includes(${target})
+endfunction()

cmake/templates/OpenCVConfig.cmake.in

@@ -141,6 +141,7 @@ SET(OpenCV_VERSION_STATUS "@OPENCV_VERSION_STATUS@")
 # ====================================================================
 
 SET(OpenCV_LIB_COMPONENTS @OPENCV_MODULES_CONFIGCMAKE@)
+SET(OpenCV_WORLD_COMPONENTS @OPENCV_WORLD_MODULES@)
 
 # ==============================================================
 #  Extra include directories, needed by OpenCV 2 new structure
@@ -200,8 +201,8 @@ foreach(__cvcomponent ${OpenCV_FIND_COMPONENTS})
       message(WARNING "${__cvcomponent} is required but was not found")
     endif()
     #indicate that module is NOT found
-    string(TOUPPER "${__cvcomponent}" __cvcomponent)
-    set(${__cvcomponent}_FOUND "${__cvcomponent}_FOUND-NOTFOUND")
+    string(TOUPPER "${__cvcomponent}" __cvcomponentUP)
+    set(${__cvcomponentUP}_FOUND "${__cvcomponentUP}_FOUND-NOTFOUND")
   else()
     list(APPEND OpenCV_FIND_COMPONENTS_ ${__cvcomponent})
     # Not using list(APPEND) here, because OpenCV_LIBS may not exist yet.
@@ -209,8 +210,31 @@ foreach(__cvcomponent ${OpenCV_FIND_COMPONENTS})
     # to find_package(OpenCV) with different component lists add up.
     set(OpenCV_LIBS ${OpenCV_LIBS} "${__cvcomponent}")
     #indicate that module is found
-    string(TOUPPER "${__cvcomponent}" __cvcomponent)
-    set(${__cvcomponent}_FOUND 1)
+    string(TOUPPER "${__cvcomponent}" __cvcomponentUP)
+    set(${__cvcomponentUP}_FOUND 1)
+  endif()
+  if(OpenCV_SHARED AND ";${OpenCV_WORLD_COMPONENTS};" MATCHES ";${__cvcomponent};" AND NOT TARGET ${__cvcomponent})
+    get_target_property(__implib_dbg opencv_world IMPORTED_IMPLIB_DEBUG)
+    get_target_property(__implib_release opencv_world  IMPORTED_IMPLIB_RELEASE)
+    get_target_property(__location_dbg opencv_world IMPORTED_LOCATION_DEBUG)
+    get_target_property(__location_release opencv_world  IMPORTED_LOCATION_RELEASE)
+    add_library(${__cvcomponent} SHARED IMPORTED)
+    if(__location_dbg)
+      set_property(TARGET ${__cvcomponent} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(${__cvcomponent} PROPERTIES
+        IMPORTED_IMPLIB_DEBUG "${__implib_dbg}"
+        IMPORTED_LINK_INTERFACE_LIBRARIES_DEBUG ""
+        IMPORTED_LOCATION_DEBUG "${__location_dbg}"
+      )
+    endif()
+    if(__location_release)
+      set_property(TARGET ${__cvcomponent} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(${__cvcomponent} PROPERTIES
+        IMPORTED_IMPLIB_RELEASE "${__implib_release}"
+        IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ""
+        IMPORTED_LOCATION_RELEASE "${__location_release}"
+      )
+    endif()
   endif()
 endforeach()
 set(OpenCV_FIND_COMPONENTS ${OpenCV_FIND_COMPONENTS_})
@@ -321,6 +345,7 @@ macro(ocv_check_dependencies)
   set(OCV_DEPENDENCIES_FOUND TRUE)
   foreach(d ${ARGN})
     if(NOT TARGET ${d})
+      message(WARNING "OpenCV: Can't resolve dependency: ${d}")
       set(OCV_DEPENDENCIES_FOUND FALSE)
       break()
     endif()
@@ -346,6 +371,10 @@ macro(ocv_include_modules)
   include_directories(BEFORE "${OpenCV_INCLUDE_DIRS}")
 endmacro()
 
+macro(ocv_target_link_libraries)
+  target_link_libraries(${ARGN})
+endmacro()
+
 # remove all matching elements from the list
 macro(ocv_list_filterout lst regex)
   foreach(item ${${lst}})

doc/CMakeLists.txt

@@ -105,8 +105,8 @@ if(BUILD_DOCS AND HAVE_SPHINX)
       COMMAND ${SPHINX_BUILD} ${BUILD_PLANTUML} -b latex -c "${CMAKE_CURRENT_SOURCE_DIR}" "${DOC_FAKE_ROOT}" .
       COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/pics ${CMAKE_CURRENT_BINARY_DIR}/doc/opencv1/pics
       COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/mymath.sty ${CMAKE_CURRENT_BINARY_DIR}
-      COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2refman.tex
-      COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2manager.tex
+      COMMAND ${PYTHON_DEFAULT_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2refman.tex
+      COMMAND ${PYTHON_DEFAULT_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2manager.tex
       COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv2refman.pdf"
       COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2refman.tex
       COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2refman.tex

modules/CMakeLists.txt

@@ -4,4 +4,4 @@ if(NOT OPENCV_MODULES_PATH)
   set(OPENCV_MODULES_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
 endif()
 
-ocv_glob_modules(${OPENCV_MODULES_PATH} ${OPENCV_EXTRA_MODULES_PATH})
+ocv_glob_modules(${OPENCV_MODULES_PATH} EXTRA ${OPENCV_EXTRA_MODULES_PATH})

modules/androidcamera/camera_wrapper/CMakeLists.txt

@@ -46,7 +46,7 @@ ADD_LIBRARY(${the_target} SHARED camera_wrapper.h camera_wrapper.cpp)
 string(REGEX REPLACE "[.]" "_" LIBRARY_DEF ${ANDROID_VERSION})
 add_definitions(-DANDROID_r${LIBRARY_DEF})
 
-target_link_libraries(${the_target} c m dl utils camera_client binder log)
+ocv_target_link_libraries(${the_target} c m dl utils camera_client binder log)
 
 if(NOT ANDROID_VERSION VERSION_LESS "3.0.0")
     target_link_libraries(${the_target} gui )

modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst

@@ -760,6 +760,27 @@ They are
 :math:`[R_2, -t]`.
 By decomposing ``E``, you can only get the direction of the translation, so the function returns unit ``t``.
 
+decomposeHomographyMat
+--------------------------
+Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
+
+.. ocv:function:: int decomposeHomographyMat( InputArray H,  InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals)
+
+    :param H: The input homography matrix between two images.
+
+    :param K: The input intrinsic camera calibration matrix.
+
+    :param rotations: Array of rotation matrices.
+
+    :param translations: Array of translation matrices.
+
+    :param normals: Array of plane normal matrices.
+
+This function extracts relative camera motion between two views observing a planar object from the homography ``H`` induced by the plane.
+The intrinsic camera matrix ``K`` must also be provided. The function may return up to four mathematical solution sets. At least two of the
+solutions may further be invalidated if point correspondences are available by applying positive depth constraint (all points must be in front of the camera).
+The decomposition method is described in detail in [Malis]_.
+
 
 recoverPose
 ---------------
@@ -1876,3 +1897,5 @@ Performs stereo calibration
 .. [Slabaugh] Slabaugh, G.G. Computing Euler angles from a rotation matrix. http://www.soi.city.ac.uk/~sbbh653/publications/euler.pdf (verified: 2013-04-15)
 
 .. [Zhang2000] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
+
+.. [Malis] Malis, E. and Vargas, M. Deeper understanding of the homography decomposition for vision-based control, Research Report 6303, INRIA (2007)

modules/calib3d/include/opencv2/calib3d.hpp

@@ -315,6 +315,11 @@ CV_EXPORTS_W  int estimateAffine3D(InputArray src, InputArray dst,
                                    double ransacThreshold = 3, double confidence = 0.99);
 
 
+CV_EXPORTS_W int decomposeHomographyMat(InputArray H,
+                                        InputArray K,
+                                        OutputArrayOfArrays rotations,
+                                        OutputArrayOfArrays translations,
+                                        OutputArrayOfArrays normals);
 
 class CV_EXPORTS_W StereoMatcher : public Algorithm
 {

modules/calib3d/perf/opencl/perf_stereobm.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/calib3d/src/circlesgrid.cpp

@@ -40,6 +40,7 @@
  //
  //M*/
 
+#include "precomp.hpp"
 #include "circlesgrid.hpp"
 #include <limits>
 //#define DEBUG_CIRCLES

modules/calib3d/src/homography_decomp.cpp

@@ -0,0 +1,482 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // This is a homography decomposition implementation contributed to OpenCV
+ // by Samson Yilma. It implements the homography decomposition algorithm
+ // descriped in the research report:
+ // Malis, E and Vargas, M, "Deeper understanding of the homography decomposition
+ // for vision-based control", Research Report 6303, INRIA (2007)
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2014, Samson Yilma¸ (samson_yilma@yahoo.com), all rights reserved.
+ //
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include <memory>
+
+namespace cv
+{
+
+namespace HomographyDecomposition
+{
+
+//struct to hold solutions of homography decomposition
+typedef struct _CameraMotion {
+    cv::Matx33d R; //!< rotation matrix
+    cv::Vec3d n; //!< normal of the plane the camera is looking at
+    cv::Vec3d t; //!< translation vector
+} CameraMotion;
+
+inline int signd(const double x)
+{
+    return ( x >= 0 ? 1 : -1 );
+}
+
+class HomographyDecomp {
+
+public:
+    HomographyDecomp() {}
+    virtual ~HomographyDecomp() {}
+    virtual void decomposeHomography(const cv::Matx33d& H, const cv::Matx33d& K,
+                                     std::vector<CameraMotion>& camMotions);
+    bool isRotationValid(const cv::Matx33d& R,  const double epsilon=0.01);
+
+protected:
+    bool passesSameSideOfPlaneConstraint(CameraMotion& motion);
+    virtual void decompose(std::vector<CameraMotion>& camMotions) = 0;
+    const cv::Matx33d& getHnorm() const {
+        return _Hnorm;
+    }
+
+private:
+    cv::Matx33d normalize(const cv::Matx33d& H, const cv::Matx33d& K);
+    void removeScale();
+    cv::Matx33d _Hnorm;
+};
+
+class HomographyDecompZhang : public HomographyDecomp {
+
+public:
+    HomographyDecompZhang():HomographyDecomp() {}
+    virtual ~HomographyDecompZhang() {}
+
+private:
+    virtual void decompose(std::vector<CameraMotion>& camMotions);
+    bool findMotionFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, CameraMotion& motion);
+};
+
+class HomographyDecompInria : public HomographyDecomp {
+
+public:
+    HomographyDecompInria():HomographyDecomp() {}
+    virtual ~HomographyDecompInria() {}
+
+private:
+    virtual void decompose(std::vector<CameraMotion>& camMotions);
+    double oppositeOfMinor(const cv::Matx33d& M, const int row, const int col);
+    void findRmatFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, const double v, cv::Matx33d& R);
+};
+
+// normalizes homography with intrinsic camera parameters
+Matx33d HomographyDecomp::normalize(const Matx33d& H, const Matx33d& K)
+{
+    return K.inv() * H * K;
+}
+
+void HomographyDecomp::removeScale()
+{
+    Mat W;
+    SVD::compute(_Hnorm, W);
+    _Hnorm = _Hnorm * (1.0/W.at<double>(1));
+}
+
+/*! This checks that the input is a pure rotation matrix 'm'.
+ * The conditions for this are: R' * R = I and det(R) = 1 (proper rotation matrix)
+ */
+bool HomographyDecomp::isRotationValid(const Matx33d& R, const double epsilon)
+{
+    Matx33d RtR = R.t() * R;
+    Matx33d I(1,0,0, 0,1,0, 0,0,1);
+    if (norm(RtR, I, NORM_INF) > epsilon)
+        return false;
+    return (fabs(determinant(R) - 1.0) < epsilon);
+}
+
+bool HomographyDecomp::passesSameSideOfPlaneConstraint(CameraMotion& motion)
+{
+    typedef Matx<double, 1, 1> Matx11d;
+    Matx31d t = Matx31d(motion.t);
+    Matx31d n = Matx31d(motion.n);
+    Matx11d proj = n.t() * motion.R.t() * t;
+    if ( (1 + proj(0, 0) ) <= 0 )
+        return false;
+    return true;
+}
+
+//!main routine to decompose homography
+void HomographyDecomp::decomposeHomography(const Matx33d& H, const cv::Matx33d& K,
+                                           std::vector<CameraMotion>& camMotions)
+{
+    //normalize homography matrix with intrinsic camera matrix
+    _Hnorm = normalize(H, K);
+    //remove scale of the normalized homography
+    removeScale();
+    //apply decomposition
+    decompose(camMotions);
+}
+
+/* function computes R&t from tstar, and plane normal(n) using
+ R = H * inv(I + tstar*transpose(n) );
+ t = R * tstar;
+ returns true if computed R&t is a valid solution
+ */
+bool HomographyDecompZhang::findMotionFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, CameraMotion& motion)
+{
+    Matx31d tstar_m = Mat(tstar);
+    Matx31d n_m = Mat(n);
+    Matx33d temp = tstar_m * n_m.t();
+    temp(0, 0) += 1.0;
+    temp(1, 1) += 1.0;
+    temp(2, 2) += 1.0;
+    motion.R = getHnorm() * temp.inv();
+    motion.t = motion.R * tstar;
+    motion.n = n;
+    return passesSameSideOfPlaneConstraint(motion);
+}
+
+void HomographyDecompZhang::decompose(std::vector<CameraMotion>& camMotions)
+{
+    Mat W, U, Vt;
+    SVD::compute(getHnorm(), W, U, Vt);
+    double lambda1=W.at<double>(0);
+    double lambda3=W.at<double>(2);
+    double lambda1m3 =  (lambda1-lambda3);
+    double lambda1m3_2 = lambda1m3*lambda1m3;
+    double lambda1t3 = lambda1*lambda3;
+
+    double t1 = 1.0/(2.0*lambda1t3);
+    double t2 = sqrt(1.0+4.0*lambda1t3/lambda1m3_2);
+    double t12 = t1*t2;
+
+    double e1 = -t1 + t12; //t1*(-1.0f + t2 );
+    double e3 = -t1 - t12; //t1*(-1.0f - t2);
+    double e1_2 = e1*e1;
+    double e3_2 = e3*e3;
+
+    double nv1p = sqrt(e1_2*lambda1m3_2 + 2*e1*(lambda1t3-1) + 1.0);
+    double nv3p = sqrt(e3_2*lambda1m3_2 + 2*e3*(lambda1t3-1) + 1.0);
+    double v1p[3], v3p[3];
+
+    v1p[0]=Vt.at<double>(0)*nv1p, v1p[1]=Vt.at<double>(1)*nv1p, v1p[2]=Vt.at<double>(2)*nv1p;
+    v3p[0]=Vt.at<double>(6)*nv3p, v3p[1]=Vt.at<double>(7)*nv3p, v3p[2]=Vt.at<double>(8)*nv3p;
+
+    /*The eight solutions are
+     (A): tstar = +- (v1p - v3p)/(e1 -e3), n = +- (e1*v3p - e3*v1p)/(e1-e3)
+     (B): tstar = +- (v1p + v3p)/(e1 -e3), n = +- (e1*v3p + e3*v1p)/(e1-e3)
+     */
+    double v1pmv3p[3], v1ppv3p[3];
+    double e1v3me3v1[3], e1v3pe3v1[3];
+    double inv_e1me3 = 1.0/(e1-e3);
+
+    for(int kk=0;kk<3;++kk){
+        v1pmv3p[kk] = v1p[kk]-v3p[kk];
+        v1ppv3p[kk] = v1p[kk]+v3p[kk];
+    }
+
+    for(int kk=0; kk<3; ++kk){
+        double e1v3 = e1*v3p[kk];
+        double e3v1=e3*v1p[kk];
+        e1v3me3v1[kk] = e1v3-e3v1;
+        e1v3pe3v1[kk] = e1v3+e3v1;
+    }
+
+    Vec3d tstar_p, tstar_n;
+    Vec3d n_p, n_n;
+
+    ///Solution group A
+    for(int kk=0; kk<3; ++kk) {
+        tstar_p[kk] = v1pmv3p[kk]*inv_e1me3;
+        tstar_n[kk] = -tstar_p[kk];
+        n_p[kk] = e1v3me3v1[kk]*inv_e1me3;
+        n_n[kk] = -n_p[kk];
+    }
+
+    CameraMotion cmotion;
+    //(A) Four different combinations for solution A
+    // (i)  (+, +)
+    if (findMotionFrom_tstar_n(tstar_p, n_p, cmotion))
+        camMotions.push_back(cmotion);
+
+    // (ii)  (+, -)
+    if (findMotionFrom_tstar_n(tstar_p, n_n, cmotion))
+        camMotions.push_back(cmotion);
+
+    // (iii)  (-, +)
+    if (findMotionFrom_tstar_n(tstar_n, n_p, cmotion))
+        camMotions.push_back(cmotion);
+
+    // (iv)  (-, -)
+    if (findMotionFrom_tstar_n(tstar_n, n_n, cmotion))
+        camMotions.push_back(cmotion);
+    //////////////////////////////////////////////////////////////////
+    ///Solution group B
+    for(int kk=0;kk<3;++kk){
+        tstar_p[kk] = v1ppv3p[kk]*inv_e1me3;
+        tstar_n[kk] = -tstar_p[kk];
+        n_p[kk] = e1v3pe3v1[kk]*inv_e1me3;
+        n_n[kk] = -n_p[kk];
+    }
+
+    //(B) Four different combinations for solution B
+    // (i)  (+, +)
+    if (findMotionFrom_tstar_n(tstar_p, n_p, cmotion))
+        camMotions.push_back(cmotion);
+
+    // (ii)  (+, -)
+    if (findMotionFrom_tstar_n(tstar_p, n_n, cmotion))
+        camMotions.push_back(cmotion);
+
+    // (iii)  (-, +)
+    if (findMotionFrom_tstar_n(tstar_n, n_p, cmotion))
+        camMotions.push_back(cmotion);
+
+    // (iv)  (-, -)
+    if (findMotionFrom_tstar_n(tstar_n, n_n, cmotion))
+        camMotions.push_back(cmotion);
+}
+
+double HomographyDecompInria::oppositeOfMinor(const Matx33d& M, const int row, const int col)
+{
+    int x1 = col == 0 ? 1 : 0;
+    int x2 = col == 2 ? 1 : 2;
+    int y1 = row == 0 ? 1 : 0;
+    int y2 = row == 2 ? 1 : 2;
+
+    return (M(y1, x2) * M(y2, x1) - M(y1, x1) * M(y2, x2));
+}
+
+//computes R = H( I - (2/v)*te_star*ne_t )
+void HomographyDecompInria::findRmatFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, const double v, cv::Matx33d& R)
+{
+    Matx31d tstar_m = Matx31d(tstar);
+    Matx31d n_m = Matx31d(n);
+    Matx33d I(1.0, 0.0, 0.0,
+              0.0, 1.0, 0.0,
+              0.0, 0.0, 1.0);
+
+    R = getHnorm() * (I - (2/v) * tstar_m * n_m.t() );
+}
+
+void HomographyDecompInria::decompose(std::vector<CameraMotion>& camMotions)
+{
+    const double epsilon = 0.001;
+    Matx33d S;
+
+    //S = H'H - I
+    S = getHnorm().t() * getHnorm();
+    S(0, 0) -= 1.0;
+    S(1, 1) -= 1.0;
+    S(2, 2) -= 1.0;
+
+    //check if H is rotation matrix
+    if( norm(S, NORM_INF) < epsilon) {
+        CameraMotion motion;
+        motion.R = Matx33d(getHnorm());
+        motion.t = Vec3d(0, 0, 0);
+        motion.n = Vec3d(0, 0, 0);
+        camMotions.push_back(motion);
+        return;
+    }
+
+    //! Compute nvectors
+    Vec3d npa, npb;
+
+    double M00 = oppositeOfMinor(S, 0, 0);
+    double M11 = oppositeOfMinor(S, 1, 1);
+    double M22 = oppositeOfMinor(S, 2, 2);
+
+    double rtM00 = sqrt(M00);
+    double rtM11 = sqrt(M11);
+    double rtM22 = sqrt(M22);
+
+    double M01 = oppositeOfMinor(S, 0, 1);
+    double M12 = oppositeOfMinor(S, 1, 2);
+    double M02 = oppositeOfMinor(S, 0, 2);
+
+    int e12 = signd(M12);
+    int e02 = signd(M02);
+    int e01 = signd(M01);
+
+    double nS00 = abs(S(0, 0));
+    double nS11 = abs(S(1, 1));
+    double nS22 = abs(S(2, 2));
+
+    //find max( |Sii| ), i=0, 1, 2
+    int indx = 0;
+    if(nS00 < nS11){
+        indx = 1;
+        if( nS11 < nS22 )
+            indx = 2;
+    }
+    else {
+        if(nS00 < nS22 )
+            indx = 2;
+    }
+
+    switch (indx) {
+        case 0:
+            npa[0] = S(0, 0),               npb[0] = S(0, 0);
+            npa[1] = S(0, 1) + rtM22,       npb[1] = S(0, 1) - rtM22;
+            npa[2] = S(0, 2) + e12 * rtM11, npb[2] = S(0, 2) - e12 * rtM11;
+            break;
+        case 1:
+            npa[0] = S(0, 1) + rtM22,       npb[0] = S(0, 1) - rtM22;
+            npa[1] = S(1, 1),               npb[1] = S(1, 1);
+            npa[2] = S(1, 2) - e02 * rtM00, npb[2] = S(1, 2) + e02 * rtM00;
+            break;
+        case 2:
+            npa[0] = S(0, 2) + e01 * rtM11, npb[0] = S(0, 2) - e01 * rtM11;
+            npa[1] = S(1, 2) + rtM00,       npb[1] = S(1, 2) - rtM00;
+            npa[2] = S(2, 2),               npb[2] = S(2, 2);
+            break;
+        default:
+            break;
+    }
+
+    double traceS = S(0, 0) + S(1, 1) + S(2, 2);
+    double v = 2.0 * sqrt(1 + traceS - M00 - M11 - M22);
+
+    double ESii = signd(S(indx, indx)) ;
+    double r_2 = 2 + traceS + v;
+    double nt_2 = 2 + traceS - v;
+
+    double r = sqrt(r_2);
+    double n_t = sqrt(nt_2);
+
+    Vec3d na = npa / norm(npa);
+    Vec3d nb = npb / norm(npb);
+
+    double half_nt = 0.5 * n_t;
+    double esii_t_r = ESii * r;
+
+    Vec3d ta_star = half_nt * (esii_t_r * nb - n_t * na);
+    Vec3d tb_star = half_nt * (esii_t_r * na - n_t * nb);
+
+    camMotions.resize(4);
+
+    Matx33d Ra, Rb;
+    Vec3d ta, tb;
+
+    //Ra, ta, na
+    findRmatFrom_tstar_n(ta_star, na, v, Ra);
+    ta = Ra * ta_star;
+
+    camMotions[0].R = Ra;
+    camMotions[0].t = ta;
+    camMotions[0].n = na;
+
+    //Ra, -ta, -na
+    camMotions[1].R = Ra;
+    camMotions[1].t = -ta;
+    camMotions[1].n = -na;
+
+    //Rb, tb, nb
+    findRmatFrom_tstar_n(tb_star, nb, v, Rb);
+    tb = Rb * tb_star;
+
+    camMotions[2].R = Rb;
+    camMotions[2].t = tb;
+    camMotions[2].n = nb;
+
+    //Rb, -tb, -nb
+    camMotions[3].R = Rb;
+    camMotions[3].t = -tb;
+    camMotions[3].n = -nb;
+}
+
+} //namespace HomographyDecomposition
+
+// function decomposes image-to-image homography to rotation and translation matrices
+int decomposeHomographyMat(InputArray _H,
+                       InputArray _K,
+                       OutputArrayOfArrays _rotations,
+                       OutputArrayOfArrays _translations,
+                       OutputArrayOfArrays _normals)
+{
+    using namespace std;
+    using namespace HomographyDecomposition;
+
+    Mat H = _H.getMat().reshape(1, 3);
+    CV_Assert(H.cols == 3 && H.rows == 3);
+
+    Mat K = _K.getMat().reshape(1, 3);
+    CV_Assert(K.cols == 3 && K.rows == 3);
+
+    auto_ptr<HomographyDecomp> hdecomp(new HomographyDecompInria);
+
+    vector<CameraMotion> motions;
+    hdecomp->decomposeHomography(H, K, motions);
+
+    int nsols = static_cast<int>(motions.size());
+    int depth = CV_64F; //double precision matrices used in CameraMotion struct
+
+    if (_rotations.needed()) {
+        _rotations.create(nsols, 1, depth);
+        for (int k = 0; k < nsols; ++k ) {
+            _rotations.getMatRef(k) = Mat(motions[k].R);
+        }
+    }
+
+    if (_translations.needed()) {
+        _translations.create(nsols, 1, depth);
+        for (int k = 0; k < nsols; ++k ) {
+            _translations.getMatRef(k) = Mat(motions[k].t);
+        }
+    }
+
+    if (_normals.needed()) {
+        _normals.create(nsols, 1, depth);
+        for (int k = 0; k < nsols; ++k ) {
+            _normals.getMatRef(k) = Mat(motions[k].n);
+        }
+    }
+
+    return nsols;
+}
+
+} //namespace cv

modules/calib3d/src/solvepnp.cpp

@@ -139,11 +139,13 @@ namespace cv
             CameraParameters camera;
         };
 
+        template <typename OpointType, typename IpointType>
         static void pnpTask(const std::vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
                      const Parameters& params, std::vector<int>& inliers, Mat& rvec, Mat& tvec,
                      const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
         {
-            Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_32FC3), modelImagePoints(1, MIN_POINTS_COUNT, CV_32FC2);
+            Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_MAKETYPE(DataDepth<OpointType>::value, 3));
+            Mat modelImagePoints(1, MIN_POINTS_COUNT, CV_MAKETYPE(DataDepth<IpointType>::value, 2));
             for (int i = 0, colIndex = 0; i < (int)pointsMask.size(); i++)
             {
                 if (pointsMask[i])
@@ -162,7 +164,7 @@ namespace cv
             for (int i = 0; i < MIN_POINTS_COUNT; i++)
                 for (int j = i + 1; j < MIN_POINTS_COUNT; j++)
                 {
-                    if (norm(modelObjectPoints.at<Vec3f>(0, i) - modelObjectPoints.at<Vec3f>(0, j)) < eps)
+                    if (norm(modelObjectPoints.at<Vec<OpointType,3> >(0, i) - modelObjectPoints.at<Vec<OpointType,3> >(0, j)) < eps)
                         num_same_points++;
                 }
             if (num_same_points > 0)
@@ -176,7 +178,7 @@ namespace cv
                      params.useExtrinsicGuess, params.flags);
 
 
-            std::vector<Point2f> projected_points;
+            std::vector<Point_<OpointType> > projected_points;
             projected_points.resize(objectPoints.cols);
             projectPoints(objectPoints, localRvec, localTvec, params.camera.intrinsics, params.camera.distortion, projected_points);
 
@@ -186,9 +188,11 @@ namespace cv
             std::vector<int> localInliers;
             for (int i = 0; i < objectPoints.cols; i++)
             {
-                Point2f p(imagePoints.at<Vec2f>(0, i)[0], imagePoints.at<Vec2f>(0, i)[1]);
+                //Although p is a 2D point it needs the same type as the object points to enable the norm calculation
+                Point_<OpointType> p((OpointType)imagePoints.at<Vec<IpointType,2> >(0, i)[0],
+                                     (OpointType)imagePoints.at<Vec<IpointType,2> >(0, i)[1]);
                 if ((norm(p - projected_points[i]) < params.reprojectionError)
-                    && (rotatedPoints.at<Vec3f>(0, i)[2] > 0)) //hack
+                    && (rotatedPoints.at<Vec<OpointType,3> >(0, i)[2] > 0)) //hack
                 {
                     localInliers.push_back(i);
                 }
@@ -208,6 +212,30 @@ namespace cv
             }
         }
 
+        static void pnpTask(const std::vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
+            const Parameters& params, std::vector<int>& inliers, Mat& rvec, Mat& tvec,
+            const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
+        {
+            CV_Assert(objectPoints.depth() == CV_64F ||  objectPoints.depth() == CV_32F);
+            CV_Assert(imagePoints.depth() == CV_64F ||  imagePoints.depth() == CV_32F);
+            const bool objectDoublePrecision = objectPoints.depth() == CV_64F;
+            const bool imageDoublePrecision = imagePoints.depth() == CV_64F;
+            if(objectDoublePrecision)
+            {
+                if(imageDoublePrecision)
+                    pnpTask<double, double>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
+                else
+                    pnpTask<double, float>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
+            }
+            else
+            {
+                if(imageDoublePrecision)
+                    pnpTask<float, double>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
+                else
+                    pnpTask<float, float>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
+            }
+        }
+
         class PnPSolver
         {
         public:
@@ -283,10 +311,10 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
     Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat();
 
     CV_Assert(opoints.isContinuous());
-    CV_Assert(opoints.depth() == CV_32F);
+    CV_Assert(opoints.depth() == CV_32F || opoints.depth() == CV_64F);
     CV_Assert((opoints.rows == 1 && opoints.channels() == 3) || opoints.cols*opoints.channels() == 3);
     CV_Assert(ipoints.isContinuous());
-    CV_Assert(ipoints.depth() == CV_32F);
+    CV_Assert(ipoints.depth() == CV_32F || ipoints.depth() == CV_64F);
     CV_Assert((ipoints.rows == 1 && ipoints.channels() == 2) || ipoints.cols*ipoints.channels() == 2);
 
     _rvec.create(3, 1, CV_64FC1);
@@ -322,7 +350,7 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
         if (flags != P3P)
         {
             int i, pointsCount = (int)localInliers.size();
-            Mat inlierObjectPoints(1, pointsCount, CV_32FC3), inlierImagePoints(1, pointsCount, CV_32FC2);
+            Mat inlierObjectPoints(1, pointsCount, CV_MAKE_TYPE(opoints.depth(), 3)), inlierImagePoints(1, pointsCount, CV_MAKE_TYPE(ipoints.depth(), 2));
             for (i = 0; i < pointsCount; i++)
             {
                 int index = localInliers[i];

modules/calib3d/src/stereobm.cpp

@@ -48,7 +48,7 @@
 #include "precomp.hpp"
 #include <stdio.h>
 #include <limits>
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_calib3d.hpp"
 
 namespace cv
 {

modules/calib3d/test/opencl/test_stereobm.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "cvconfig.h"
 #include "opencv2/ts/ocl_test.hpp"
 

modules/calib3d/test/test_homography_decomp.cpp

@@ -0,0 +1,138 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ // This is a test file for the function decomposeHomography contributed to OpenCV
+ // by Samson Yilma.
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2014, Samson Yilma¸ (samson_yilma@yahoo.com), all rights reserved.
+ //
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "test_precomp.hpp"
+#include "opencv2/calib3d.hpp"
+#include <vector>
+
+using namespace cv;
+using namespace std;
+
+class CV_HomographyDecompTest: public cvtest::BaseTest {
+
+public:
+    CV_HomographyDecompTest()
+    {
+        buildTestDataSet();
+    }
+
+protected:
+    void run(int)
+    {
+        vector<Mat> rotations;
+        vector<Mat> translations;
+        vector<Mat> normals;
+
+        decomposeHomographyMat(_H, _K, rotations, translations, normals);
+
+        //there should be at least 1 solution
+        ASSERT_GT(static_cast<int>(rotations.size()), 0);
+        ASSERT_GT(static_cast<int>(translations.size()), 0);
+        ASSERT_GT(static_cast<int>(normals.size()), 0);
+
+        ASSERT_EQ(rotations.size(), normals.size());
+        ASSERT_EQ(translations.size(), normals.size());
+
+        ASSERT_TRUE(containsValidMotion(rotations, translations, normals));
+
+        decomposeHomographyMat(_H, _K, rotations, noArray(), noArray());
+        ASSERT_GT(static_cast<int>(rotations.size()), 0);
+    }
+
+private:
+
+    void buildTestDataSet()
+    {
+        _K = Matx33d(640, 0.0,  320,
+                      0,    640, 240,
+                      0,    0,   1);
+
+         _H = Matx33d(2.649157564634028,  4.583875997496426,  70.694447785121326,
+                     -1.072756858861583,  3.533262150437228,  1513.656999614321649,
+                      0.001303887589576,  0.003042206876298,  1.000000000000000
+                      );
+
+        //expected solution for the given homography and intrinsic matrices
+         _R = Matx33d(0.43307983549125, 0.545749113549648, -0.717356090899523,
+                     -0.85630229674426, 0.497582023798831, -0.138414255706431,
+                      0.281404038139784, 0.67421809131173, 0.682818960388909);
+
+         _t = Vec3d(1.826751712278038,  1.264718492450820,  0.195080809998819);
+         _n = Vec3d(0.244875830334816, 0.480857890778889, 0.841909446789566);
+    }
+
+    bool containsValidMotion(std::vector<Mat>& rotations,
+                             std::vector<Mat>& translations,
+                             std::vector<Mat>& normals
+                             )
+    {
+        double max_error = 1.0e-3;
+
+        vector<Mat>::iterator riter = rotations.begin();
+        vector<Mat>::iterator titer = translations.begin();
+        vector<Mat>::iterator niter = normals.begin();
+
+        for (;
+             riter != rotations.end() && titer != translations.end() && niter != normals.end();
+             ++riter, ++titer, ++niter) {
+
+            double rdist = norm(*riter, _R, NORM_INF);
+            double tdist = norm(*titer, _t, NORM_INF);
+            double ndist = norm(*niter, _n, NORM_INF);
+
+            if (   rdist < max_error
+                && tdist < max_error
+                && ndist < max_error )
+                return true;
+        }
+
+        return false;
+    }
+
+    Matx33d _R, _K, _H;
+    Vec3d _t, _n;
+};
+
+TEST(Calib3d_DecomposeHomography, regression) { CV_HomographyDecompTest test; test.safe_run(); }

modules/core/CMakeLists.txt

@@ -1,6 +1,5 @@
 set(the_description "The Core Functionality")
 ocv_add_module(core PRIVATE_REQUIRED ${ZLIB_LIBRARIES} "${OPENCL_LIBRARIES}" OPTIONAL opencv_cudev)
-ocv_module_include_directories(${ZLIB_INCLUDE_DIRS})
 
 if(HAVE_WINRT_CX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /ZW")
@@ -19,11 +18,11 @@ file(GLOB lib_cuda_hdrs_detail "include/opencv2/${name}/cuda/detail/*.hpp" "incl
 source_group("Cuda Headers"         FILES ${lib_cuda_hdrs})
 source_group("Cuda Headers\\Detail" FILES ${lib_cuda_hdrs_detail})
 
-ocv_glob_module_sources(SOURCES "${opencv_core_BINARY_DIR}/version_string.inc"
+ocv_glob_module_sources(SOURCES "${OPENCV_MODULE_opencv_core_BINARY_DIR}/version_string.inc"
                         HEADERS ${lib_cuda_hdrs} ${lib_cuda_hdrs_detail})
 
+ocv_module_include_directories(${the_module} ${ZLIB_INCLUDE_DIRS})
 ocv_create_module()
-ocv_add_precompiled_headers(${the_module})
 
 ocv_add_accuracy_tests()
 ocv_add_perf_tests()

modules/core/doc/basic_structures.rst

@@ -845,7 +845,6 @@ For convenience, the following types from the OpenCV C API already have such a s
 that calls the appropriate release function:
 
 * ``CvCapture``
-* :ocv:struct:`CvDTreeSplit`
 * :ocv:struct:`CvFileStorage`
 * ``CvHaarClassifierCascade``
 * :ocv:struct:`CvMat`
@@ -2326,6 +2325,69 @@ Returns the matrix iterator and sets it to the after-last matrix element.
 
 The methods return the matrix read-only or read-write iterators, set to the point following the last matrix element.
 
+
+Mat::forEach
+------------
+Invoke with arguments functor, and runs the functor over all matrix element.
+
+.. ocv:function:: template<typename _Tp, typename Functor> void Mat::forEach(Functor operation)
+
+.. ocv:function:: template<typename _Tp, typename Functor> void Mat::forEach(Functor operation) const
+
+The methos runs operation in parallel. Operation is passed by arguments. Operation have to be a function pointer, a function object or a lambda(C++11).
+
+All of below operation is equal. Put 0xFF to first channel of all matrix elements. ::
+
+    Mat image(1920, 1080, CV_8UC3);
+    typedef cv::Point3_<uint8_t> Pixel;
+
+    // first. raw pointer access.
+    for (int r = 0; r < image.rows; ++r) {
+        Pixel* ptr = image.ptr<Pixel>(0, r);
+        const Pixel* ptr_end = ptr + image.cols;
+        for (; ptr != ptr_end; ++ptr) {
+            ptr->x = 255;
+        }
+    }
+
+
+    // Using MatIterator. (Simple but there are a Iterator's overhead)
+    for (Pixel &p : cv::Mat_<Pixel>(image)) {
+        p.x = 255;
+    }
+
+
+    // Parallel execution with function object.
+    struct Operator {
+        void operator ()(Pixel &pixel, const int * position) {
+            pixel.x = 255;
+        }
+    };
+    image.forEach<Pixel>(Operator());
+
+
+    // Parallel execution using C++11 lambda.
+    image.forEach<Pixel>([](Pixel &p, const int * position) -> void {
+        p.x = 255;
+    });
+
+position parameter is index of current pixel. ::
+
+    // Creating 3D matrix (255 x 255 x 255) typed uint8_t,
+    //  and initialize all elements by the value which equals elements position.
+    //  i.e. pixels (x,y,z) = (1,2,3) is (b,g,r) = (1,2,3).
+
+    int sizes[] = { 255, 255, 255 };
+    typedef cv::Point3_<uint8_t> Pixel;
+
+    Mat_<Pixel> image = Mat::zeros(3, sizes, CV_8UC3);
+
+    image.forEachWithPosition([&](Pixel& pixel, const int position[]) -> void{
+        pixel.x = position[0];
+        pixel.y = position[1];
+        pixel.z = position[2];
+    });
+
 Mat\_
 -----
 .. ocv:class:: Mat_

modules/core/include/opencv2/core.hpp

@@ -690,7 +690,61 @@ public:
     Mat mean; //!< mean value subtracted before the projection and added after the back projection
 };
 
+// Linear Discriminant Analysis
+class CV_EXPORTS LDA
+{
+public:
+    // Initializes a LDA with num_components (default 0) and specifies how
+    // samples are aligned (default dataAsRow=true).
+    explicit LDA(int num_components = 0);
+
+    // Initializes and performs a Discriminant Analysis with Fisher's
+    // Optimization Criterion on given data in src and corresponding labels
+    // in labels. If 0 (or less) number of components are given, they are
+    // automatically determined for given data in computation.
+    LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0);
+
+    // Serializes this object to a given filename.
+    void save(const String& filename) const;
+
+    // Deserializes this object from a given filename.
+    void load(const String& filename);
+
+    // Serializes this object to a given cv::FileStorage.
+    void save(FileStorage& fs) const;
+
+        // Deserializes this object from a given cv::FileStorage.
+    void load(const FileStorage& node);
+
+    // Destructor.
+    ~LDA();
+
+    //! Compute the discriminants for data in src and labels.
+    void compute(InputArrayOfArrays src, InputArray labels);
 
+    // Projects samples into the LDA subspace.
+    Mat project(InputArray src);
+
+    // Reconstructs projections from the LDA subspace.
+    Mat reconstruct(InputArray src);
+
+    // Returns the eigenvectors of this LDA.
+    Mat eigenvectors() const { return _eigenvectors; }
+
+    // Returns the eigenvalues of this LDA.
+    Mat eigenvalues() const { return _eigenvalues; }
+
+    static Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
+    static Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
+
+protected:
+    bool _dataAsRow;
+    int _num_components;
+    Mat _eigenvectors;
+    Mat _eigenvalues;
+
+    void lda(InputArrayOfArrays src, InputArray labels);
+};
 
 /*!
     Singular Value Decomposition class

modules/core/include/opencv2/core/cuda.hpp

@@ -261,8 +261,8 @@ public:
     int* refcount;
 
     //! helper fields used in locateROI and adjustROI
-    uchar* datastart;
-    uchar* dataend;
+    const uchar* datastart;
+    const uchar* dataend;
 
     //! allocator
     Allocator* allocator;
@@ -349,8 +349,8 @@ public:
     uchar* data;
     int* refcount;
 
-    uchar* datastart;
-    uchar* dataend;
+    const uchar* datastart;
+    const uchar* dataend;
 
     AllocType alloc_type;
 };

modules/core/include/opencv2/core/mat.hpp

@@ -395,7 +395,7 @@ struct CV_EXPORTS UMatData
 
 struct CV_EXPORTS UMatDataAutoLock
 {
-    UMatDataAutoLock(UMatData* u);
+    explicit UMatDataAutoLock(UMatData* u);
     ~UMatDataAutoLock();
     UMatData* u;
 };
@@ -403,7 +403,7 @@ struct CV_EXPORTS UMatDataAutoLock
 
 struct CV_EXPORTS MatSize
 {
-    MatSize(int* _p);
+    explicit MatSize(int* _p);
     Size operator()() const;
     const int& operator[](int i) const;
     int& operator[](int i);
@@ -417,7 +417,7 @@ struct CV_EXPORTS MatSize
 struct CV_EXPORTS MatStep
 {
     MatStep();
-    MatStep(size_t s);
+    explicit MatStep(size_t s);
     const size_t& operator[](int i) const;
     size_t& operator[](int i);
     operator size_t() const;
@@ -900,6 +900,11 @@ public:
     template<typename _Tp> MatConstIterator_<_Tp> begin() const;
     template<typename _Tp> MatConstIterator_<_Tp> end() const;
 
+    //! template methods for for operation over all matrix elements.
+    // the operations take care of skipping gaps in the end of rows (if any)
+    template<typename _Tp, typename Functor> void forEach(const Functor& operation);
+    template<typename _Tp, typename Functor> void forEach(const Functor& operation) const;
+
     enum { MAGIC_VAL  = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
     enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
 
@@ -918,9 +923,9 @@ public:
     uchar* data;
 
     //! helper fields used in locateROI and adjustROI
-    uchar* datastart;
-    uchar* dataend;
-    uchar* datalimit;
+    const uchar* datastart;
+    const uchar* dataend;
+    const uchar* datalimit;
 
     //! custom allocator
     MatAllocator* allocator;
@@ -934,6 +939,7 @@ public:
     MatStep step;
 
 protected:
+    template<typename _Tp, typename Functor> void forEach_impl(const Functor& operation);
 };
 
 
@@ -1043,6 +1049,11 @@ public:
     const_iterator begin() const;
     const_iterator end() const;
 
+    //! template methods for for operation over all matrix elements.
+    // the operations take care of skipping gaps in the end of rows (if any)
+    template<typename Functor> void forEach(const Functor& operation);
+    template<typename Functor> void forEach(const Functor& operation) const;
+
     //! equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
     void create(int _rows, int _cols);
     //! equivalent to Mat::create(_size, DataType<_Tp>::type)
@@ -1804,9 +1815,9 @@ public:
     //! copy operator
     MatConstIterator& operator = (const MatConstIterator& it);
     //! returns the current matrix element
-    uchar* operator *() const;
+    const uchar* operator *() const;
     //! returns the i-th matrix element, relative to the current
-    uchar* operator [](ptrdiff_t i) const;
+    const uchar* operator [](ptrdiff_t i) const;
 
     //! shifts the iterator forward by the specified number of elements
     MatConstIterator& operator += (ptrdiff_t ofs);
@@ -1831,9 +1842,9 @@ public:
 
     const Mat* m;
     size_t elemSize;
-    uchar* ptr;
-    uchar* sliceStart;
-    uchar* sliceEnd;
+    const uchar* ptr;
+    const uchar* sliceStart;
+    const uchar* sliceEnd;
 };
 
 
@@ -1917,9 +1928,9 @@ public:
     //! constructor that sets the iterator to the specified element of the matrix
     MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
     //! constructor that sets the iterator to the specified element of the matrix
-    MatIterator_(const Mat_<_Tp>* _m, Point _pt);
+    MatIterator_(Mat_<_Tp>* _m, Point _pt);
     //! constructor that sets the iterator to the specified element of the matrix
-    MatIterator_(const Mat_<_Tp>* _m, const int* _idx);
+    MatIterator_(Mat_<_Tp>* _m, const int* _idx);
     //! copy constructor
     MatIterator_(const MatIterator_& it);
     //! copy operator

modules/core/include/opencv2/core/mat.inl.hpp

@@ -438,7 +438,7 @@ Mat::Mat(const std::vector<_Tp>& vec, bool copyData)
     if( !copyData )
     {
         step[0] = step[1] = sizeof(_Tp);
-        data = datastart = (uchar*)&vec[0];
+        datastart = data = (uchar*)&vec[0];
         datalimit = dataend = datastart + rows * step[0];
     }
     else
@@ -453,7 +453,7 @@ Mat::Mat(const Vec<_Tp, n>& vec, bool copyData)
     if( !copyData )
     {
         step[0] = step[1] = sizeof(_Tp);
-        data = datastart = (uchar*)vec.val;
+        datastart = data = (uchar*)vec.val;
         datalimit = dataend = datastart + rows * step[0];
     }
     else
@@ -470,7 +470,7 @@ Mat::Mat(const Matx<_Tp,m,n>& M, bool copyData)
     {
         step[0] = cols * sizeof(_Tp);
         step[1] = sizeof(_Tp);
-        data = datastart = (uchar*)M.val;
+        datastart = data = (uchar*)M.val;
         datalimit = dataend = datastart + rows * step[0];
     }
     else
@@ -485,7 +485,7 @@ Mat::Mat(const Point_<_Tp>& pt, bool copyData)
     if( !copyData )
     {
         step[0] = step[1] = sizeof(_Tp);
-        data = datastart = (uchar*)&pt.x;
+        datastart = data = (uchar*)&pt.x;
         datalimit = dataend = datastart + rows * step[0];
     }
     else
@@ -504,7 +504,7 @@ Mat::Mat(const Point3_<_Tp>& pt, bool copyData)
     if( !copyData )
     {
         step[0] = step[1] = sizeof(_Tp);
-        data = datastart = (uchar*)&pt.x;
+        datastart = data = (uchar*)&pt.x;
         datalimit = dataend = datastart + rows * step[0];
     }
     else
@@ -642,7 +642,7 @@ inline void Mat::release()
     if( u && CV_XADD(&u->refcount, -1) == 1 )
         deallocate();
     u = NULL;
-    data = datastart = dataend = datalimit = 0;
+    datastart = dataend = datalimit = data = 0;
     for(int i = 0; i < dims; i++)
         size.p[i] = 0;
 }
@@ -1000,6 +1000,17 @@ MatIterator_<_Tp> Mat::end()
     return it;
 }
 
+template<typename _Tp, typename Functor> inline
+void Mat::forEach(const Functor& operation) {
+    this->forEach_impl<_Tp>(operation);
+};
+
+template<typename _Tp, typename Functor> inline
+void Mat::forEach(const Functor& operation) const {
+    // call as not const
+    (const_cast<Mat*>(this))->forEach<const _Tp>(operation);
+};
+
 template<typename _Tp> inline
 Mat::operator std::vector<_Tp>() const
 {
@@ -1045,7 +1056,7 @@ void Mat::push_back(const _Tp& elem)
     }
     CV_Assert(DataType<_Tp>::type == type() && cols == 1
               /* && dims == 2 (cols == 1 implies dims == 2) */);
-    uchar* tmp = dataend + step[0];
+    const uchar* tmp = dataend + step[0];
     if( !isSubmatrix() && isContinuous() && tmp <= datalimit )
     {
         *(_Tp*)(data + (size.p[0]++) * step.p[0]) = elem;
@@ -1585,6 +1596,15 @@ MatIterator_<_Tp> Mat_<_Tp>::end()
     return Mat::end<_Tp>();
 }
 
+template<typename _Tp> template<typename Functor> inline
+void Mat_<_Tp>::forEach(const Functor& operation) {
+    Mat::forEach<_Tp, Functor>(operation);
+}
+
+template<typename _Tp> template<typename Functor> inline
+void Mat_<_Tp>::forEach(const Functor& operation) const {
+    Mat::forEach<_Tp, Functor>(operation);
+}
 
 ///////////////////////////// SparseMat /////////////////////////////
 
@@ -2149,7 +2169,7 @@ MatConstIterator& MatConstIterator::operator = (const MatConstIterator& it )
 }
 
 inline
-uchar* MatConstIterator::operator *() const
+const uchar* MatConstIterator::operator *() const
 {
     return ptr;
 }
@@ -2282,7 +2302,7 @@ MatConstIterator operator - (const MatConstIterator& a, ptrdiff_t ofs)
 
 
 inline
-uchar* MatConstIterator::operator [](ptrdiff_t i) const
+const uchar* MatConstIterator::operator [](ptrdiff_t i) const
 {
     return *(*this + i);
 }
@@ -2454,12 +2474,12 @@ MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, int _row, int _col)
 {}
 
 template<typename _Tp> inline
-MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, Point _pt)
+MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, Point _pt)
     : MatConstIterator_<_Tp>(_m, _pt)
 {}
 
 template<typename _Tp> inline
-MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, const int* _idx)
+MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, const int* _idx)
     : MatConstIterator_<_Tp>(_m, _idx)
 {}
 
@@ -2593,7 +2613,7 @@ inline SparseMatConstIterator& SparseMatConstIterator::operator = (const SparseM
 template<typename _Tp> inline
 const _Tp& SparseMatConstIterator::value() const
 {
-    return *(_Tp*)ptr;
+    return *(const _Tp*)ptr;
 }
 
 inline

modules/core/include/opencv2/core/ocl.hpp

@@ -636,6 +636,9 @@ protected:
 
 CV_EXPORTS MatAllocator* getOpenCLAllocator();
 
+CV_EXPORTS_W bool isPerformanceCheckBypassed();
+#define OCL_PERFORMANCE_CHECK(condition) (cv::ocl::isPerformanceCheckBypassed() || (condition))
+
 }}
 
 #endif

modules/core/include/opencv2/core/utility.hpp

@@ -274,6 +274,102 @@ public:
 
 CV_EXPORTS void parallel_for_(const Range& range, const ParallelLoopBody& body, double nstripes=-1.);
 
+/////////////////////////////// forEach method of cv::Mat ////////////////////////////
+template<typename _Tp, typename Functor> inline
+void Mat::forEach_impl(const Functor& operation) {
+    if (false) {
+        operation(*reinterpret_cast<_Tp*>(0), reinterpret_cast<int*>(NULL));
+        // If your compiler fail in this line.
+        // Please check that your functor signature is
+        //     (_Tp&, const int*)   <- multidimential
+        //  or (_Tp&, void*)        <- in case of you don't need current idx.
+    }
+
+    CV_Assert(this->total() / this->size[this->dims - 1] <= INT_MAX);
+    const int LINES = static_cast<int>(this->total() / this->size[this->dims - 1]);
+
+    class PixelOperationWrapper :public ParallelLoopBody
+    {
+    public:
+        PixelOperationWrapper(Mat_<_Tp>* const frame, const Functor& _operation)
+            : mat(frame), op(_operation) {};
+        virtual ~PixelOperationWrapper(){};
+        // ! Overloaded virtual operator
+        // convert range call to row call.
+        virtual void operator()(const Range &range) const {
+            const int DIMS = mat->dims;
+            const int COLS = mat->size[DIMS - 1];
+            if (DIMS <= 2) {
+                for (int row = range.start; row < range.end; ++row) {
+                    this->rowCall2(row, COLS);
+                }
+            } else {
+                std::vector<int> idx(COLS); /// idx is modified in this->rowCall
+                idx[DIMS - 2] = range.start - 1;
+
+                for (int line_num = range.start; line_num < range.end; ++line_num) {
+                    idx[DIMS - 2]++;
+                    for (int i = DIMS - 2; i >= 0; --i) {
+                        if (idx[i] >= mat->size[i]) {
+                            idx[i - 1] += idx[i] / mat->size[i];
+                            idx[i] %= mat->size[i];
+                            continue; // carry-over;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    this->rowCall(&idx[0], COLS, DIMS);
+                }
+            }
+        };
+    private:
+        Mat_<_Tp>* const mat;
+        const Functor op;
+        // ! Call operator for each elements in this row.
+        inline void rowCall(int* const idx, const int COLS, const int DIMS) const {
+            int &col = idx[DIMS - 1];
+            col = 0;
+            _Tp* pixel = &(mat->template at<_Tp>(idx));
+
+            while (col < COLS) {
+                op(*pixel, const_cast<const int*>(idx));
+                pixel++; col++;
+            }
+            col = 0;
+        }
+        // ! Call operator for each elements in this row. 2d mat special version.
+        inline void rowCall2(const int row, const int COLS) const {
+            union Index{
+                int body[2];
+                operator const int*() const {
+                    return reinterpret_cast<const int*>(this);
+                }
+                int& operator[](const int i) {
+                    return body[i];
+                }
+            } idx = {{row, 0}};
+            // Special union is needed to avoid
+            // "error: array subscript is above array bounds [-Werror=array-bounds]"
+            // when call the functor `op` such that access idx[3].
+
+            _Tp* pixel = &(mat->template at<_Tp>(idx));
+            const _Tp* const pixel_end = pixel + COLS;
+            while(pixel < pixel_end) {
+                op(*pixel++, static_cast<const int*>(idx));
+                idx[1]++;
+            }
+        };
+        PixelOperationWrapper& operator=(const PixelOperationWrapper &) {
+            CV_Assert(false);
+            // We can not remove this implementation because Visual Studio warning C4822.
+            return *this;
+        };
+    };
+
+    parallel_for_(cv::Range(0, LINES), PixelOperationWrapper(reinterpret_cast<Mat_<_Tp>*>(this), operation));
+};
+
 /////////////////////////// Synchronization Primitives ///////////////////////////////
 
 class CV_EXPORTS Mutex

modules/core/perf/opencl/perf_arithm.cpp

@@ -39,7 +39,7 @@
 //
 //M*/
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/perf/opencl/perf_bufferpool.cpp

@@ -4,7 +4,7 @@
 //
 // Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/perf/opencl/perf_channels.cpp

@@ -44,7 +44,7 @@
 //
 //M*/
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/perf/opencl/perf_dxt.cpp

@@ -44,7 +44,7 @@
 //
 //M*/
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/perf/opencl/perf_gemm.cpp

@@ -44,7 +44,7 @@
 //
 //M*/
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/perf/opencl/perf_matop.cpp

@@ -5,7 +5,7 @@
 // Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
 // Third party copyrights are property of their respective owners.
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/perf/opencl/perf_usage_flags.cpp

@@ -4,7 +4,7 @@
 //
 // Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
 
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/src/arithm.cpp

@@ -47,7 +47,7 @@
 // */
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 namespace cv
 {
@@ -1607,7 +1607,7 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
     Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
     Size sz2 = dims2 <= 2 ? psrc2->size() : Size();
 #ifdef HAVE_OPENCL
-    bool use_opencl = _dst.isUMat() && dims1 <= 2 && dims2 <= 2;
+    bool use_opencl = OCL_PERFORMANCE_CHECK(_dst.isUMat()) && dims1 <= 2 && dims2 <= 2;
 #endif
     bool src1Scalar = checkScalar(*psrc1, type2, kind1, kind2);
     bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1);
@@ -2440,6 +2440,34 @@ addWeighted8u( const uchar* src1, size_t step1,
                 _mm_storel_epi64((__m128i*)(dst + x), u);
             }
         }
+#elif CV_NEON
+        float32x4_t g = vdupq_n_f32 (gamma);
+
+        for( ; x <= size.width - 8; x += 8 )
+        {
+            uint8x8_t in1 = vld1_u8(src1+x);
+            uint16x8_t in1_16 = vmovl_u8(in1);
+            float32x4_t in1_f_l = vcvtq_f32_u32(vmovl_u16(vget_low_u16(in1_16)));
+            float32x4_t in1_f_h = vcvtq_f32_u32(vmovl_u16(vget_high_u16(in1_16)));
+
+            uint8x8_t in2 = vld1_u8(src2+x);
+            uint16x8_t in2_16 = vmovl_u8(in2);
+            float32x4_t in2_f_l = vcvtq_f32_u32(vmovl_u16(vget_low_u16(in2_16)));
+            float32x4_t in2_f_h = vcvtq_f32_u32(vmovl_u16(vget_high_u16(in2_16)));
+
+            float32x4_t out_f_l = vaddq_f32(vmulq_n_f32(in1_f_l, alpha), vmulq_n_f32(in2_f_l, beta));
+            float32x4_t out_f_h = vaddq_f32(vmulq_n_f32(in1_f_h, alpha), vmulq_n_f32(in2_f_h, beta));
+            out_f_l = vaddq_f32(out_f_l, g);
+            out_f_h = vaddq_f32(out_f_h, g);
+
+            uint16x4_t out_16_l = vqmovun_s32(vcvtq_s32_f32(out_f_l));
+            uint16x4_t out_16_h = vqmovun_s32(vcvtq_s32_f32(out_f_h));
+
+            uint16x8_t out_16 = vcombine_u16(out_16_l, out_16_h);
+            uint8x8_t out = vqmovn_u16(out_16);
+
+            vst1_u8(dst+x, out);
+        }
 #endif
         #if CV_ENABLE_UNROLLED
         for( ; x <= size.width - 4; x += 4 )
@@ -2650,6 +2678,14 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste
 
                 }
             }
+           #elif CV_NEON
+            uint8x16_t mask = code == CMP_GT ? vdupq_n_u8(0) : vdupq_n_u8(255);
+
+            for( ; x <= size.width - 16; x += 16 )
+            {
+                vst1q_u8(dst+x, veorq_u8(vcgtq_u8(vld1q_u8(src1+x), vld1q_u8(src2+x)), mask));
+            }
+
            #endif
 
             for( ; x < size.width; x++ ){
@@ -2674,6 +2710,13 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste
                     _mm_storeu_si128((__m128i*)(dst + x), r00);
                 }
             }
+           #elif CV_NEON
+            uint8x16_t mask = code == CMP_EQ ? vdupq_n_u8(0) : vdupq_n_u8(255);
+
+            for( ; x <= size.width - 16; x += 16 )
+            {
+                vst1q_u8(dst+x, veorq_u8(vceqq_u8(vld1q_u8(src1+x), vld1q_u8(src2+x)), mask));
+            }
            #endif
            for( ; x < size.width; x++ )
                 dst[x] = (uchar)(-(src1[x] == src2[x]) ^ m);
@@ -2759,6 +2802,22 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st
                     x += 8;
                 }
             }
+           #elif CV_NEON
+            uint8x16_t mask = code == CMP_GT ? vdupq_n_u8(0) : vdupq_n_u8(255);
+
+            for( ; x <= size.width - 16; x += 16 )
+            {
+                int16x8_t in1 = vld1q_s16(src1 + x);
+                int16x8_t in2 = vld1q_s16(src2 + x);
+                uint8x8_t t1 = vmovn_u16(vcgtq_s16(in1, in2));
+
+                in1 = vld1q_s16(src1 + x + 8);
+                in2 = vld1q_s16(src2 + x + 8);
+                uint8x8_t t2 = vmovn_u16(vcgtq_s16(in1, in2));
+
+                vst1q_u8(dst+x, veorq_u8(vcombine_u8(t1, t2), mask));
+            }
+
            #endif
 
             for( ; x < size.width; x++ ){
@@ -2797,6 +2856,21 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st
                     x += 8;
                 }
             }
+           #elif CV_NEON
+            uint8x16_t mask = code == CMP_EQ ? vdupq_n_u8(0) : vdupq_n_u8(255);
+
+            for( ; x <= size.width - 16; x += 16 )
+            {
+                int16x8_t in1 = vld1q_s16(src1 + x);
+                int16x8_t in2 = vld1q_s16(src2 + x);
+                uint8x8_t t1 = vmovn_u16(vceqq_s16(in1, in2));
+
+                in1 = vld1q_s16(src1 + x + 8);
+                in2 = vld1q_s16(src2 + x + 8);
+                uint8x8_t t2 = vmovn_u16(vceqq_s16(in1, in2));
+
+                vst1q_u8(dst+x, veorq_u8(vcombine_u8(t1, t2), mask));
+            }
            #endif
            for( ; x < size.width; x++ )
                 dst[x] = (uchar)(-(src1[x] == src2[x]) ^ m);
@@ -2982,7 +3056,7 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
         haveScalar = true;
     }
 
-    CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat(),
+    CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && OCL_PERFORMANCE_CHECK(_dst.isUMat()),
                ocl_compare(_src1, _src2, _dst, op, haveScalar))
 
     int kind1 = _src1.kind(), kind2 = _src2.kind();
@@ -3085,7 +3159,7 @@ namespace cv
 {
 
 template <typename T>
-struct InRange_SSE
+struct InRange_SIMD
 {
     int operator () (const T *, const T *, const T *, uchar *, int) const
     {
@@ -3096,7 +3170,7 @@ struct InRange_SSE
 #if CV_SSE2
 
 template <>
-struct InRange_SSE<uchar>
+struct InRange_SIMD<uchar>
 {
     int operator () (const uchar * src1, const uchar * src2, const uchar * src3,
                      uchar * dst, int len) const
@@ -3121,7 +3195,7 @@ struct InRange_SSE<uchar>
 };
 
 template <>
-struct InRange_SSE<schar>
+struct InRange_SIMD<schar>
 {
     int operator () (const schar * src1, const schar * src2, const schar * src3,
                      uchar * dst, int len) const
@@ -3146,7 +3220,7 @@ struct InRange_SSE<schar>
 };
 
 template <>
-struct InRange_SSE<ushort>
+struct InRange_SIMD<ushort>
 {
     int operator () (const ushort * src1, const ushort * src2, const ushort * src3,
                      uchar * dst, int len) const
@@ -3172,7 +3246,7 @@ struct InRange_SSE<ushort>
 };
 
 template <>
-struct InRange_SSE<short>
+struct InRange_SIMD<short>
 {
     int operator () (const short * src1, const short * src2, const short * src3,
                      uchar * dst, int len) const
@@ -3198,7 +3272,7 @@ struct InRange_SSE<short>
 };
 
 template <>
-struct InRange_SSE<int>
+struct InRange_SIMD<int>
 {
     int operator () (const int * src1, const int * src2, const int * src3,
                      uchar * dst, int len) const
@@ -3230,7 +3304,7 @@ struct InRange_SSE<int>
 };
 
 template <>
-struct InRange_SSE<float>
+struct InRange_SIMD<float>
 {
     int operator () (const float * src1, const float * src2, const float * src3,
                      uchar * dst, int len) const
@@ -3261,6 +3335,160 @@ struct InRange_SSE<float>
     }
 };
 
+#elif CV_NEON
+
+template <>
+struct InRange_SIMD<uchar>
+{
+    int operator () (const uchar * src1, const uchar * src2, const uchar * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        for ( ; x <= len - 16; x += 16 )
+        {
+            uint8x16_t values = vld1q_u8(src1 + x);
+            uint8x16_t low = vld1q_u8(src2 + x);
+            uint8x16_t high = vld1q_u8(src3 + x);
+
+            vst1q_u8(dst + x, vandq_u8(vcgeq_u8(values, low), vcgeq_u8(high, values)));
+        }
+        return x;
+    }
+};
+
+template <>
+struct InRange_SIMD<schar>
+{
+    int operator () (const schar * src1, const schar * src2, const schar * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        for ( ; x <= len - 16; x += 16 )
+        {
+            int8x16_t values = vld1q_s8(src1 + x);
+            int8x16_t low = vld1q_s8(src2 + x);
+            int8x16_t high = vld1q_s8(src3 + x);
+
+            vst1q_u8(dst + x, vandq_u8(vcgeq_s8(values, low), vcgeq_s8(high, values)));
+        }
+        return x;
+    }
+};
+
+template <>
+struct InRange_SIMD<ushort>
+{
+    int operator () (const ushort * src1, const ushort * src2, const ushort * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        for ( ; x <= len - 16; x += 16 )
+        {
+            uint16x8_t values = vld1q_u16((const uint16_t*)(src1 + x));
+            uint16x8_t low = vld1q_u16((const uint16_t*)(src2 + x));
+            uint16x8_t high = vld1q_u16((const uint16_t*)(src3 + x));
+            uint8x8_t  r1 = vmovn_u16(vandq_u16(vcgeq_u16(values, low), vcgeq_u16(high, values)));
+
+            values = vld1q_u16((const uint16_t*)(src1 + x + 8));
+            low = vld1q_u16((const uint16_t*)(src2 + x + 8));
+            high = vld1q_u16((const uint16_t*)(src3 + x + 8));
+            uint8x8_t  r2 = vmovn_u16(vandq_u16(vcgeq_u16(values, low), vcgeq_u16(high, values)));
+
+            vst1q_u8(dst + x, vcombine_u8(r1, r2));
+        }
+        return x;
+    }
+};
+
+template <>
+struct InRange_SIMD<short>
+{
+    int operator () (const short * src1, const short * src2, const short * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        for ( ; x <= len - 16; x += 16 )
+        {
+            int16x8_t values = vld1q_s16((const int16_t*)(src1 + x));
+            int16x8_t low = vld1q_s16((const int16_t*)(src2 + x));
+            int16x8_t high = vld1q_s16((const int16_t*)(src3 + x));
+            uint8x8_t r1 = vmovn_u16(vandq_u16(vcgeq_s16(values, low), vcgeq_s16(high, values)));
+
+            values = vld1q_s16((const int16_t*)(src1 + x + 8));
+            low = vld1q_s16((const int16_t*)(src2 + x + 8));
+            high = vld1q_s16((const int16_t*)(src3 + x + 8));
+            uint8x8_t r2 = vmovn_u16(vandq_u16(vcgeq_s16(values, low), vcgeq_s16(high, values)));
+
+            vst1q_u8(dst + x, vcombine_u8(r1, r2));
+        }
+        return x;
+    }
+};
+
+template <>
+struct InRange_SIMD<int>
+{
+    int operator () (const int * src1, const int * src2, const int * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        for ( ; x <= len - 8; x += 8 )
+        {
+            int32x4_t values = vld1q_s32((const int32_t*)(src1 + x));
+            int32x4_t low = vld1q_s32((const int32_t*)(src2 + x));
+            int32x4_t high = vld1q_s32((const int32_t*)(src3 + x));
+
+            uint16x4_t r1 = vmovn_u32(vandq_u32(vcgeq_s32(values, low), vcgeq_s32(high, values)));
+
+            values = vld1q_s32((const int32_t*)(src1 + x + 4));
+            low = vld1q_s32((const int32_t*)(src2 + x + 4));
+            high = vld1q_s32((const int32_t*)(src3 + x + 4));
+
+            uint16x4_t r2 = vmovn_u32(vandq_u32(vcgeq_s32(values, low), vcgeq_s32(high, values)));
+
+            uint16x8_t res_16 = vcombine_u16(r1, r2);
+
+            vst1_u8(dst + x, vmovn_u16(res_16));
+        }
+        return x;
+    }
+};
+
+template <>
+struct InRange_SIMD<float>
+{
+    int operator () (const float * src1, const float * src2, const float * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        for ( ; x <= len - 8; x += 8 )
+        {
+            float32x4_t values = vld1q_f32((const float32_t*)(src1 + x));
+            float32x4_t low = vld1q_f32((const float32_t*)(src2 + x));
+            float32x4_t high = vld1q_f32((const float32_t*)(src3 + x));
+
+            uint16x4_t r1 = vmovn_u32(vandq_u32(vcgeq_f32(values, low), vcgeq_f32(high, values)));
+
+            values = vld1q_f32((const float32_t*)(src1 + x + 4));
+            low = vld1q_f32((const float32_t*)(src2 + x + 4));
+            high = vld1q_f32((const float32_t*)(src3 + x + 4));
+
+            uint16x4_t r2 = vmovn_u32(vandq_u32(vcgeq_f32(values, low), vcgeq_f32(high, values)));
+
+            uint16x8_t res_16 = vcombine_u16(r1, r2);
+
+            vst1_u8(dst + x, vmovn_u16(res_16));
+        }
+        return x;
+    }
+};
+
 #endif
 
 template <typename T>
@@ -3272,7 +3500,7 @@ static void inRange_(const T* src1, size_t step1, const T* src2, size_t step2,
     step2 /= sizeof(src2[0]);
     step3 /= sizeof(src3[0]);
 
-    InRange_SSE<T> vop;
+    InRange_SIMD<T> vop;
 
     for( ; size.height--; src1 += step1, src2 += step2, src3 += step3, dst += step )
     {
@@ -3500,7 +3728,7 @@ void cv::inRange(InputArray _src, InputArray _lowerb,
                  InputArray _upperb, OutputArray _dst)
 {
     CV_OCL_RUN(_src.dims() <= 2 && _lowerb.dims() <= 2 &&
-               _upperb.dims() <= 2 && _dst.isUMat(),
+               _upperb.dims() <= 2 && OCL_PERFORMANCE_CHECK(_dst.isUMat()),
                ocl_inRange(_src, _lowerb, _upperb, _dst))
 
     int skind = _src.kind(), lkind = _lowerb.kind(), ukind = _upperb.kind();

modules/core/src/convert.cpp

@@ -41,7 +41,7 @@
 //M*/
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 namespace cv
 {
@@ -50,6 +50,71 @@ namespace cv
 *                                       split & merge                                    *
 \****************************************************************************************/
 
+#if CV_NEON
+template<typename T> struct VSplit2;
+template<typename T> struct VSplit3;
+template<typename T> struct VSplit4;
+
+#define SPLIT2_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
+    template<>                                                                    \
+    struct name<data_type>{                                                       \
+        void operator()(const data_type* src, data_type* dst0, data_type* dst1){  \
+            reg_type r = load_func(src);                                          \
+            store_func(dst0, r.val[0]);                                           \
+            store_func(dst1, r.val[1]);                                           \
+        }                                                                         \
+    }
+
+#define SPLIT3_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
+    template<>                                                                    \
+    struct name<data_type>{                                                       \
+        void operator()(const data_type* src, data_type* dst0, data_type* dst1,   \
+                        data_type* dst2){                                         \
+            reg_type r = load_func(src);                                          \
+            store_func(dst0, r.val[0]);                                           \
+            store_func(dst1, r.val[1]);                                           \
+            store_func(dst2, r.val[2]);                                           \
+        }                                                                         \
+    }
+
+#define SPLIT4_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
+    template<>                                                                    \
+    struct name<data_type>{                                                       \
+        void operator()(const data_type* src, data_type* dst0, data_type* dst1,   \
+                        data_type* dst2, data_type* dst3){                        \
+            reg_type r = load_func(src);                                          \
+            store_func(dst0, r.val[0]);                                           \
+            store_func(dst1, r.val[1]);                                           \
+            store_func(dst2, r.val[2]);                                           \
+            store_func(dst3, r.val[3]);                                           \
+        }                                                                         \
+    }
+
+SPLIT2_KERNEL_TEMPLATE(VSplit2, uchar ,  uint8x16x2_t, vld2q_u8 , vst1q_u8 );
+SPLIT2_KERNEL_TEMPLATE(VSplit2, schar ,   int8x16x2_t, vld2q_s8 , vst1q_s8 );
+SPLIT2_KERNEL_TEMPLATE(VSplit2, ushort,  uint16x8x2_t, vld2q_u16, vst1q_u16);
+SPLIT2_KERNEL_TEMPLATE(VSplit2, short ,   int16x8x2_t, vld2q_s16, vst1q_s16);
+SPLIT2_KERNEL_TEMPLATE(VSplit2, int   ,   int32x4x2_t, vld2q_s32, vst1q_s32);
+SPLIT2_KERNEL_TEMPLATE(VSplit2, float , float32x4x2_t, vld2q_f32, vst1q_f32);
+SPLIT2_KERNEL_TEMPLATE(VSplit2, int64 ,   int64x1x2_t, vld2_s64 , vst1_s64 );
+
+SPLIT3_KERNEL_TEMPLATE(VSplit3, uchar ,  uint8x16x3_t, vld3q_u8 , vst1q_u8 );
+SPLIT3_KERNEL_TEMPLATE(VSplit3, schar ,   int8x16x3_t, vld3q_s8 , vst1q_s8 );
+SPLIT3_KERNEL_TEMPLATE(VSplit3, ushort,  uint16x8x3_t, vld3q_u16, vst1q_u16);
+SPLIT3_KERNEL_TEMPLATE(VSplit3, short ,   int16x8x3_t, vld3q_s16, vst1q_s16);
+SPLIT3_KERNEL_TEMPLATE(VSplit3, int   ,   int32x4x3_t, vld3q_s32, vst1q_s32);
+SPLIT3_KERNEL_TEMPLATE(VSplit3, float , float32x4x3_t, vld3q_f32, vst1q_f32);
+SPLIT3_KERNEL_TEMPLATE(VSplit3, int64 ,   int64x1x3_t, vld3_s64 , vst1_s64 );
+
+SPLIT4_KERNEL_TEMPLATE(VSplit4, uchar ,  uint8x16x4_t, vld4q_u8 , vst1q_u8 );
+SPLIT4_KERNEL_TEMPLATE(VSplit4, schar ,   int8x16x4_t, vld4q_s8 , vst1q_s8 );
+SPLIT4_KERNEL_TEMPLATE(VSplit4, ushort,  uint16x8x4_t, vld4q_u16, vst1q_u16);
+SPLIT4_KERNEL_TEMPLATE(VSplit4, short ,   int16x8x4_t, vld4q_s16, vst1q_s16);
+SPLIT4_KERNEL_TEMPLATE(VSplit4, int   ,   int32x4x4_t, vld4q_s32, vst1q_s32);
+SPLIT4_KERNEL_TEMPLATE(VSplit4, float , float32x4x4_t, vld4q_f32, vst1q_f32);
+SPLIT4_KERNEL_TEMPLATE(VSplit4, int64 ,   int64x1x4_t, vld4_s64 , vst1_s64 );
+#endif
+
 template<typename T> static void
 split_( const T* src, T** dst, int len, int cn )
 {
@@ -58,13 +123,34 @@ split_( const T* src, T** dst, int len, int cn )
     if( k == 1 )
     {
         T* dst0 = dst[0];
-        for( i = j = 0; i < len; i++, j += cn )
-            dst0[i] = src[j];
+
+        if(cn == 1)
+        {
+            memcpy(dst0, src, len * sizeof(T));
+        }
+        else
+        {
+            for( i = 0, j = 0 ; i < len; i++, j += cn )
+                dst0[i] = src[j];
+        }
     }
     else if( k == 2 )
     {
         T *dst0 = dst[0], *dst1 = dst[1];
-        for( i = j = 0; i < len; i++, j += cn )
+        i = j = 0;
+
+#if CV_NEON
+        if(cn == 2)
+        {
+            int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
+            int inc_j = 2 * inc_i;
+
+            VSplit2<T> vsplit;
+            for( ; i < len - inc_i; i += inc_i, j += inc_j)
+                vsplit(src + j, dst0 + i, dst1 + i);
+        }
+#endif
+        for( ; i < len; i++, j += cn )
         {
             dst0[i] = src[j];
             dst1[i] = src[j+1];
@@ -73,7 +159,20 @@ split_( const T* src, T** dst, int len, int cn )
     else if( k == 3 )
     {
         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2];
-        for( i = j = 0; i < len; i++, j += cn )
+        i = j = 0;
+
+#if CV_NEON
+        if(cn == 3)
+        {
+            int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
+            int inc_j = 3 * inc_i;
+
+            VSplit3<T> vsplit;
+            for( ; i < len - inc_i; i += inc_i, j += inc_j)
+                vsplit(src + j, dst0 + i, dst1 + i, dst2 + i);
+        }
+#endif
+        for( ; i < len; i++, j += cn )
         {
             dst0[i] = src[j];
             dst1[i] = src[j+1];
@@ -83,7 +182,20 @@ split_( const T* src, T** dst, int len, int cn )
     else
     {
         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3];
-        for( i = j = 0; i < len; i++, j += cn )
+        i = j = 0;
+
+#if CV_NEON
+        if(cn == 4)
+        {
+            int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
+            int inc_j = 4 * inc_i;
+
+            VSplit4<T> vsplit;
+            for( ; i < len - inc_i; i += inc_i, j += inc_j)
+                vsplit(src + j, dst0 + i, dst1 + i, dst2 + i, dst3 + i);
+        }
+#endif
+        for( ; i < len; i++, j += cn )
         {
             dst0[i] = src[j]; dst1[i] = src[j+1];
             dst2[i] = src[j+2]; dst3[i] = src[j+3];
@@ -101,6 +213,77 @@ split_( const T* src, T** dst, int len, int cn )
     }
 }
 
+
+#if CV_NEON
+template<typename T> struct VMerge2;
+template<typename T> struct VMerge3;
+template<typename T> struct VMerge4;
+
+#define MERGE2_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
+    template<>                                                                    \
+    struct name<data_type>{                                                       \
+        void operator()(const data_type* src0, const data_type* src1,             \
+                        data_type* dst){                                          \
+            reg_type r;                                                           \
+            r.val[0] = load_func(src0);                                           \
+            r.val[1] = load_func(src1);                                           \
+            store_func(dst, r);                                                   \
+        }                                                                         \
+    }
+
+#define MERGE3_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
+    template<>                                                                    \
+    struct name<data_type>{                                                       \
+        void operator()(const data_type* src0, const data_type* src1,             \
+                        const data_type* src2, data_type* dst){                   \
+            reg_type r;                                                           \
+            r.val[0] = load_func(src0);                                           \
+            r.val[1] = load_func(src1);                                           \
+            r.val[2] = load_func(src2);                                           \
+            store_func(dst, r);                                                   \
+        }                                                                         \
+    }
+
+#define MERGE4_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
+    template<>                                                                    \
+    struct name<data_type>{                                                       \
+        void operator()(const data_type* src0, const data_type* src1,             \
+                        const data_type* src2, const data_type* src3,             \
+                        data_type* dst){                                          \
+            reg_type r;                                                           \
+            r.val[0] = load_func(src0);                                           \
+            r.val[1] = load_func(src1);                                           \
+            r.val[2] = load_func(src2);                                           \
+            r.val[3] = load_func(src3);                                           \
+            store_func(dst, r);                                                   \
+        }                                                                         \
+    }
+
+MERGE2_KERNEL_TEMPLATE(VMerge2, uchar ,  uint8x16x2_t, vld1q_u8 , vst2q_u8 );
+MERGE2_KERNEL_TEMPLATE(VMerge2, schar ,   int8x16x2_t, vld1q_s8 , vst2q_s8 );
+MERGE2_KERNEL_TEMPLATE(VMerge2, ushort,  uint16x8x2_t, vld1q_u16, vst2q_u16);
+MERGE2_KERNEL_TEMPLATE(VMerge2, short ,   int16x8x2_t, vld1q_s16, vst2q_s16);
+MERGE2_KERNEL_TEMPLATE(VMerge2, int   ,   int32x4x2_t, vld1q_s32, vst2q_s32);
+MERGE2_KERNEL_TEMPLATE(VMerge2, float , float32x4x2_t, vld1q_f32, vst2q_f32);
+MERGE2_KERNEL_TEMPLATE(VMerge2, int64 ,   int64x1x2_t, vld1_s64 , vst2_s64 );
+
+MERGE3_KERNEL_TEMPLATE(VMerge3, uchar ,  uint8x16x3_t, vld1q_u8 , vst3q_u8 );
+MERGE3_KERNEL_TEMPLATE(VMerge3, schar ,   int8x16x3_t, vld1q_s8 , vst3q_s8 );
+MERGE3_KERNEL_TEMPLATE(VMerge3, ushort,  uint16x8x3_t, vld1q_u16, vst3q_u16);
+MERGE3_KERNEL_TEMPLATE(VMerge3, short ,   int16x8x3_t, vld1q_s16, vst3q_s16);
+MERGE3_KERNEL_TEMPLATE(VMerge3, int   ,   int32x4x3_t, vld1q_s32, vst3q_s32);
+MERGE3_KERNEL_TEMPLATE(VMerge3, float , float32x4x3_t, vld1q_f32, vst3q_f32);
+MERGE3_KERNEL_TEMPLATE(VMerge3, int64 ,   int64x1x3_t, vld1_s64 , vst3_s64 );
+
+MERGE4_KERNEL_TEMPLATE(VMerge4, uchar ,  uint8x16x4_t, vld1q_u8 , vst4q_u8 );
+MERGE4_KERNEL_TEMPLATE(VMerge4, schar ,   int8x16x4_t, vld1q_s8 , vst4q_s8 );
+MERGE4_KERNEL_TEMPLATE(VMerge4, ushort,  uint16x8x4_t, vld1q_u16, vst4q_u16);
+MERGE4_KERNEL_TEMPLATE(VMerge4, short ,   int16x8x4_t, vld1q_s16, vst4q_s16);
+MERGE4_KERNEL_TEMPLATE(VMerge4, int   ,   int32x4x4_t, vld1q_s32, vst4q_s32);
+MERGE4_KERNEL_TEMPLATE(VMerge4, float , float32x4x4_t, vld1q_f32, vst4q_f32);
+MERGE4_KERNEL_TEMPLATE(VMerge4, int64 ,   int64x1x4_t, vld1_s64 , vst4_s64 );
+#endif
+
 template<typename T> static void
 merge_( const T** src, T* dst, int len, int cn )
 {
@@ -115,7 +298,19 @@ merge_( const T** src, T* dst, int len, int cn )
     else if( k == 2 )
     {
         const T *src0 = src[0], *src1 = src[1];
-        for( i = j = 0; i < len; i++, j += cn )
+        i = j = 0;
+#if CV_NEON
+        if(cn == 2)
+        {
+            int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
+            int inc_j = 2 * inc_i;
+
+            VMerge2<T> vmerge;
+            for( ; i < len - inc_i; i += inc_i, j += inc_j)
+                vmerge(src0 + i, src1 + i, dst + j);
+        }
+#endif
+        for( ; i < len; i++, j += cn )
         {
             dst[j] = src0[i];
             dst[j+1] = src1[i];
@@ -124,7 +319,19 @@ merge_( const T** src, T* dst, int len, int cn )
     else if( k == 3 )
     {
         const T *src0 = src[0], *src1 = src[1], *src2 = src[2];
-        for( i = j = 0; i < len; i++, j += cn )
+        i = j = 0;
+#if CV_NEON
+        if(cn == 3)
+        {
+            int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
+            int inc_j = 3 * inc_i;
+
+            VMerge3<T> vmerge;
+            for( ; i < len - inc_i; i += inc_i, j += inc_j)
+                vmerge(src0 + i, src1 + i, src2 + i, dst + j);
+        }
+#endif
+        for( ; i < len; i++, j += cn )
         {
             dst[j] = src0[i];
             dst[j+1] = src1[i];
@@ -134,7 +341,19 @@ merge_( const T** src, T* dst, int len, int cn )
     else
     {
         const T *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
-        for( i = j = 0; i < len; i++, j += cn )
+        i = j = 0;
+#if CV_NEON
+        if(cn == 4)
+        {
+            int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
+            int inc_j = 4 * inc_i;
+
+            VMerge4<T> vmerge;
+            for( ; i < len - inc_i; i += inc_i, j += inc_j)
+                vmerge(src0 + i, src1 + i, src2 + i, src3 + i, dst + j);
+        }
+#endif
+        for( ; i < len; i++, j += cn )
         {
             dst[j] = src0[i]; dst[j+1] = src1[i];
             dst[j+2] = src2[i]; dst[j+3] = src3[i];

modules/core/src/copy.cpp

@@ -46,7 +46,7 @@
 // */
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 namespace cv
 {

modules/core/src/dxt.cpp

@@ -42,7 +42,7 @@
 #include "precomp.hpp"
 #include "opencv2/core/opencl/runtime/opencl_clamdfft.hpp"
 #include "opencv2/core/opencl/runtime/opencl_core.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 #include <map>
 
 namespace cv
@@ -1801,11 +1801,11 @@ private:
     UMat twiddles;
     String buildOptions;
     int thread_count;
-    bool status;
     int dft_size;
+    bool status;
 
 public:
-    OCL_FftPlan(int _size): dft_size(_size), status(true)
+    OCL_FftPlan(int _size) : dft_size(_size), status(true)
     {
         int min_radix;
         std::vector<int> radixes, blocks;
@@ -2635,8 +2635,8 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
 
             for( i = 0; i < nonzero_rows; i++ )
             {
-                uchar* sptr = src.data + i*src.step;
-                uchar* dptr0 = dst.data + i*dst.step;
+                const uchar* sptr = src.ptr(i);
+                uchar* dptr0 = dst.ptr(i);
                 uchar* dptr = dptr0;
 
                 if( tmp_buf )
@@ -2649,7 +2649,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
 
             for( ; i < count; i++ )
             {
-                uchar* dptr0 = dst.data + i*dst.step;
+                uchar* dptr0 = dst.ptr(i);
                 memset( dptr0, 0, dst_full_len );
             }
 
@@ -2661,7 +2661,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
         {
             int a = 0, b = count;
             uchar *buf0, *buf1, *dbuf0, *dbuf1;
-            uchar* sptr0 = src.data;
+            const uchar* sptr0 = src.data;
             uchar* dptr0 = dst.data;
             buf0 = ptr;
             ptr += len*complex_elem_size;
@@ -2800,7 +2800,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
                     int n = dst.cols;
                     if( elem_size == (int)sizeof(float) )
                     {
-                        float* p0 = (float*)dst.data;
+                        float* p0 = dst.ptr<float>();
                         size_t dstep = dst.step/sizeof(p0[0]);
                         for( i = 0; i < len; i++ )
                         {
@@ -2816,7 +2816,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
                     }
                     else
                     {
-                        double* p0 = (double*)dst.data;
+                        double* p0 = dst.ptr<double>();
                         size_t dstep = dst.step/sizeof(p0[0]);
                         for( i = 0; i < len; i++ )
                         {

modules/core/src/lapack.cpp

@@ -955,10 +955,10 @@ double cv::invert( InputArray _src, OutputArray _dst, int method )
         SVD::compute(src, w, u, vt);
         SVD::backSubst(w, u, vt, Mat(), _dst);
         return type == CV_32F ?
-            (((float*)w.data)[0] >= FLT_EPSILON ?
-             ((float*)w.data)[n-1]/((float*)w.data)[0] : 0) :
-            (((double*)w.data)[0] >= DBL_EPSILON ?
-             ((double*)w.data)[n-1]/((double*)w.data)[0] : 0);
+            (w.ptr<float>()[0] >= FLT_EPSILON ?
+             w.ptr<float>()[n-1]/w.ptr<float>()[0] : 0) :
+            (w.ptr<double>()[0] >= DBL_EPSILON ?
+             w.ptr<double>()[n-1]/w.ptr<double>()[0] : 0);
     }
 
     CV_Assert( m == n );
@@ -975,10 +975,10 @@ double cv::invert( InputArray _src, OutputArray _dst, int method )
         transpose(vt, u);
         SVD::backSubst(w, u, vt, Mat(), _dst);
         return type == CV_32F ?
-        (((float*)w.data)[0] >= FLT_EPSILON ?
-         ((float*)w.data)[n-1]/((float*)w.data)[0] : 0) :
-        (((double*)w.data)[0] >= DBL_EPSILON ?
-         ((double*)w.data)[n-1]/((double*)w.data)[0] : 0);
+        (w.ptr<float>()[0] >= FLT_EPSILON ?
+         w.ptr<float>()[n-1]/w.ptr<float>()[0] : 0) :
+        (w.ptr<double>()[0] >= DBL_EPSILON ?
+         w.ptr<double>()[n-1]/w.ptr<double>()[0] : 0);
     }
 
     CV_Assert( method == DECOMP_LU || method == DECOMP_CHOLESKY );
@@ -988,7 +988,7 @@ double cv::invert( InputArray _src, OutputArray _dst, int method )
 
     if( n <= 3 )
     {
-        uchar* srcdata = src.data;
+        const uchar* srcdata = src.data;
         uchar* dstdata = dst.data;
         size_t srcstep = src.step;
         size_t dststep = dst.step;
@@ -1212,8 +1212,8 @@ bool cv::solve( InputArray _src, InputArray _src2arg, OutputArray _dst, int meth
         #define bf(y) ((float*)(bdata + y*src2step))[0]
         #define bd(y) ((double*)(bdata + y*src2step))[0]
 
-        uchar* srcdata = src.data;
-        uchar* bdata = _src2.data;
+        const uchar* srcdata = src.data;
+        const uchar* bdata = _src2.data;
         uchar* dstdata = dst.data;
         size_t srcstep = src.step;
         size_t src2step = _src2.step;
@@ -1557,13 +1557,17 @@ static void _SVDcompute( InputArray _aarr, OutputArray _w,
     {
         if( !at )
         {
-            transpose(temp_u, _u);
-            temp_v.copyTo(_vt);
+            if( _u.needed() )
+                transpose(temp_u, _u);
+            if( _vt.needed() )
+                temp_v.copyTo(_vt);
         }
         else
         {
-            transpose(temp_v, _u);
-            temp_u.copyTo(_vt);
+            if( _u.needed() )
+                transpose(temp_v, _u);
+            if( _vt.needed() )
+                temp_u.copyTo(_vt);
         }
     }
 }
@@ -1705,7 +1709,7 @@ cvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double,
         eigen(src, evals, evects);
         if( evects0.data != evects.data )
         {
-            uchar* p = evects0.data;
+            const uchar* p = evects0.data;
             evects.convertTo(evects0, evects0.type());
             CV_Assert( p == evects0.data );
         }
@@ -1714,7 +1718,7 @@ cvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double,
         eigen(src, evals);
     if( evals0.data != evals.data )
     {
-        uchar* p = evals0.data;
+        const uchar* p = evals0.data;
         if( evals0.size() == evals.size() )
             evals.convertTo(evals0, evals0.type());
         else if( evals0.type() == evals.type() )

modules/core/src/mathfuncs.cpp

@@ -41,7 +41,7 @@
 //M*/
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 namespace cv
 {

modules/core/src/matmul.cpp

@@ -41,7 +41,7 @@
 //M*/
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 #include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp"
 
 namespace cv
@@ -3295,7 +3295,6 @@ void cv::PCABackProject(InputArray data, InputArray mean,
     pca.backProject(data, result);
 }
 
-
 /****************************************************************************************\
 *                                    Earlier API                                         *
 \****************************************************************************************/

modules/core/src/matrix.cpp

@@ -41,7 +41,7 @@
 //M*/
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 #include "bufferpool.impl.hpp"
 
@@ -346,7 +346,7 @@ static void finalizeHdr(Mat& m)
     if( d > 2 )
         m.rows = m.cols = -1;
     if(m.u)
-        m.data = m.datastart = m.u->data;
+        m.datastart = m.data = m.u->data;
     if( m.data )
     {
         m.datalimit = m.datastart + m.size[0]*m.step[0];
@@ -510,7 +510,7 @@ Mat::Mat(int _dims, const int* _sizes, int _type, void* _data, const size_t* _st
       datalimit(0), allocator(0), u(0), size(&rows)
 {
     flags |= CV_MAT_TYPE(_type);
-    data = datastart = (uchar*)_data;
+    datastart = data = (uchar*)_data;
     setSize(*this, _dims, _sizes, _steps, true);
     finalizeHdr(*this);
 }
@@ -549,7 +549,7 @@ static Mat cvMatNDToMat(const CvMatND* m, bool copyData)
 
     if( !m )
         return thiz;
-    thiz.data = thiz.datastart = m->data.ptr;
+    thiz.datastart = thiz.data = m->data.ptr;
     thiz.flags |= CV_MAT_TYPE(m->type);
     int _sizes[CV_MAX_DIM];
     size_t _steps[CV_MAX_DIM];
@@ -587,7 +587,7 @@ static Mat cvMatToMat(const CvMat* m, bool copyData)
         thiz.dims = 2;
         thiz.rows = m->rows;
         thiz.cols = m->cols;
-        thiz.data = thiz.datastart = m->data.ptr;
+        thiz.datastart = thiz.data = m->data.ptr;
         size_t esz = CV_ELEM_SIZE(m->type), minstep = thiz.cols*esz, _step = m->step;
         if( _step == 0 )
             _step = minstep;
@@ -597,7 +597,7 @@ static Mat cvMatToMat(const CvMat* m, bool copyData)
     }
     else
     {
-        thiz.data = thiz.datastart = thiz.dataend = 0;
+        thiz.datastart = thiz.dataend = thiz.data = 0;
         Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(thiz);
     }
 
@@ -636,7 +636,7 @@ static Mat iplImageToMat(const IplImage* img, bool copyData)
         m.rows = img->roi->height;
         m.cols = img->roi->width;
         esz = CV_ELEM_SIZE(m.flags);
-        m.data = m.datastart = (uchar*)img->imageData +
+        m.datastart = m.data = (uchar*)img->imageData +
             (selectedPlane ? (img->roi->coi - 1)*m.step*img->height : 0) +
             img->roi->yOffset*m.step[0] + img->roi->xOffset*esz;
     }
@@ -2758,15 +2758,18 @@ namespace cv {
 
 static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s )
 {
-    int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), kercn = cn;
-    if (cn == 1)
+    int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), kercn = cn, rowsPerWI = 1;
+    int sctype = CV_MAKE_TYPE(depth, cn == 3 ? 4 : cn);
+    if (ocl::Device::getDefault().isIntel())
     {
-        kercn = std::min(ocl::predictOptimalVectorWidth(_m), 4);
-        if (kercn != 4)
-            kercn = 1;
+        rowsPerWI = 4;
+        if (cn == 1)
+        {
+            kercn = std::min(ocl::predictOptimalVectorWidth(_m), 4);
+            if (kercn != 4)
+                kercn = 1;
+        }
     }
-    int sctype = CV_MAKE_TYPE(depth, cn == 3 ? 4 : cn),
-            rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
 
     ocl::Kernel k("setIdentity", ocl::core::set_identity_oclsrc,
                   format("-D T=%s -D T1=%s -D cn=%d -D ST=%s -D kercn=%d -D rowsPerWI=%d",
@@ -5529,14 +5532,14 @@ double norm( const SparseMat& src, int normType )
     {
         if( normType == NORM_INF )
             for( i = 0; i < N; i++, ++it )
-                result = std::max(result, std::abs((double)*(const float*)it.ptr));
+                result = std::max(result, std::abs((double)it.value<float>()));
         else if( normType == NORM_L1 )
             for( i = 0; i < N; i++, ++it )
-                result += std::abs(*(const float*)it.ptr);
+                result += std::abs(it.value<float>());
         else
             for( i = 0; i < N; i++, ++it )
             {
-                double v = *(const float*)it.ptr;
+                double v = it.value<float>();
                 result += v*v;
             }
     }
@@ -5544,14 +5547,14 @@ double norm( const SparseMat& src, int normType )
     {
         if( normType == NORM_INF )
             for( i = 0; i < N; i++, ++it )
-                result = std::max(result, std::abs(*(const double*)it.ptr));
+                result = std::max(result, std::abs(it.value<double>()));
         else if( normType == NORM_L1 )
             for( i = 0; i < N; i++, ++it )
-                result += std::abs(*(const double*)it.ptr);
+                result += std::abs(it.value<double>());
         else
             for( i = 0; i < N; i++, ++it )
             {
-                double v = *(const double*)it.ptr;
+                double v = it.value<double>();
                 result += v*v;
             }
     }
@@ -5575,7 +5578,7 @@ void minMaxLoc( const SparseMat& src, double* _minval, double* _maxval, int* _mi
         float minval = FLT_MAX, maxval = -FLT_MAX;
         for( i = 0; i < N; i++, ++it )
         {
-            float v = *(const float*)it.ptr;
+            float v = it.value<float>();
             if( v < minval )
             {
                 minval = v;
@@ -5597,7 +5600,7 @@ void minMaxLoc( const SparseMat& src, double* _minval, double* _maxval, int* _mi
         double minval = DBL_MAX, maxval = -DBL_MAX;
         for( i = 0; i < N; i++, ++it )
         {
-            double v = *(const double*)it.ptr;
+            double v = it.value<double>();
             if( v < minval )
             {
                 minval = v;

modules/core/src/ocl.cpp

@@ -57,6 +57,28 @@
 # endif
 #endif
 
+
+// TODO Move to some common place
+static bool getBoolParameter(const char* name, bool defaultValue)
+{
+    const char* envValue = getenv(name);
+    if (envValue == NULL)
+    {
+        return defaultValue;
+    }
+    cv::String value = envValue;
+    if (value == "1" || value == "True" || value == "true" || value == "TRUE")
+    {
+        return true;
+    }
+    if (value == "0" || value == "False" || value == "false" || value == "FALSE")
+    {
+        return false;
+    }
+    CV_ErrorNoReturn(cv::Error::StsBadArg, cv::format("Invalid value for %s parameter: %s", name, value.c_str()));
+}
+
+
 // TODO Move to some common place
 static size_t getConfigurationParameterForSize(const char* name, size_t defaultValue)
 {
@@ -1305,7 +1327,18 @@ OCL_FUNC(cl_int, clReleaseEvent, (cl_event event), (event))
 #ifdef _DEBUG
 #define CV_OclDbgAssert CV_DbgAssert
 #else
-#define CV_OclDbgAssert(expr) (void)(expr)
+static bool isRaiseError()
+{
+    static bool initialized = false;
+    static bool value = false;
+    if (!initialized)
+    {
+        value = getBoolParameter("OPENCV_OPENCL_RAISE_ERROR", false);
+        initialized = true;
+    }
+    return value;
+}
+#define CV_OclDbgAssert(expr) do { if (isRaiseError()) { CV_Assert(expr); } else { (void)(expr); } } while ((void)0, 0)
 #endif
 
 namespace cv { namespace ocl {
@@ -4711,4 +4744,16 @@ void* Image2D::ptr() const
     return p ? p->handle : 0;
 }
 
+bool isPerformanceCheckBypassed()
+{
+    static bool initialized = false;
+    static bool value = false;
+    if (!initialized)
+    {
+        value = getBoolParameter("OPENCV_OPENCL_PERF_CHECK_BYPASS", false);
+        initialized = true;
+    }
+    return value;
+}
+
 }}

modules/core/src/opencl/fft.cl

@@ -424,7 +424,7 @@ void fft_radix3_B3(__local float2* smem, __global const float2* twiddles, const
     const int x3 = x2 + t/3;
     float2 a0, a1, a2, a3, a4, a5, a6, a7, a8;
 
-    if (x1 < t/2)
+    if (x1 < t/3)
     {
         a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];
         a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];
@@ -433,7 +433,7 @@ void fft_radix3_B3(__local float2* smem, __global const float2* twiddles, const
 
     barrier(CLK_LOCAL_MEM_FENCE);
 
-    if (x1 < t/2)
+    if (x1 < t/3)
     {
         butterfly3(a0, a1, a2, smem, twiddles, x1, block_size);
         butterfly3(a3, a4, a5, smem, twiddles, x2, block_size);

modules/core/src/opencl/meanstddev.cl

@@ -59,7 +59,7 @@ __kernel void meanStdDev(__global const uchar * srcptr, int src_step, int src_of
     for (int grain = groups * WGS; id < total; id += grain)
     {
 #ifdef HAVE_MASK
-#ifdef HAVE_SRC_CONT
+#ifdef HAVE_MASK_CONT
         int mask_index = id;
 #else
         int mask_index = mad24(id / cols, mask_step, id % cols);

modules/core/src/opencl/runtime/opencl_clamdblas.cpp

@@ -39,7 +39,7 @@
 //
 //M*/
 
-#include "precomp.hpp"
+#include "../../precomp.hpp"
 
 #ifdef HAVE_CLAMDBLAS
 

modules/core/src/opencl/runtime/opencl_clamdfft.cpp

@@ -39,7 +39,7 @@
 //
 //M*/
 
-#include "precomp.hpp"
+#include "../../precomp.hpp"
 
 #ifdef HAVE_CLAMDFFT
 

modules/core/src/opencl/runtime/opencl_core.cpp

@@ -39,7 +39,7 @@
 //
 //M*/
 
-#include "precomp.hpp"
+#include "../../precomp.hpp"
 
 #if defined(HAVE_OPENCL) && !defined(HAVE_OPENCL_STATIC)
 

modules/core/src/stat.cpp

@@ -44,7 +44,7 @@
 #include <climits>
 #include <limits>
 
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 namespace cv
 {
@@ -568,7 +568,7 @@ cv::Scalar cv::sum( InputArray _src )
 {
 #ifdef HAVE_OPENCL
     Scalar _res;
-    CV_OCL_RUN_(_src.isUMat() && _src.dims() <= 2,
+    CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
                 ocl_sum(_src, _res, OCL_OP_SUM),
                 _res)
 #endif
@@ -719,7 +719,7 @@ int cv::countNonZero( InputArray _src )
 
 #ifdef HAVE_OPENCL
     int res = -1;
-    CV_OCL_RUN_(_src.isUMat() && _src.dims() <= 2,
+    CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
                 ocl_countNonZero(_src, res),
                 res)
 #endif
@@ -782,7 +782,7 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
         int type = src.type();
         if( !mask.empty() )
         {
-            typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *);
+            typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *);
             ippiMaskMeanFuncC1 ippFuncC1 =
             type == CV_8UC1 ? (ippiMaskMeanFuncC1)ippiMean_8u_C1MR :
             type == CV_16UC1 ? (ippiMaskMeanFuncC1)ippiMean_16u_C1MR :
@@ -795,7 +795,7 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
                     return Scalar(res);
                 setIppErrorStatus();
             }
-            typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *);
+            typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *);
             ippiMaskMeanFuncC3 ippFuncC3 =
             type == CV_8UC3 ? (ippiMaskMeanFuncC3)ippiMean_8u_C3CMR :
             type == CV_16UC3 ? (ippiMaskMeanFuncC3)ippiMean_16u_C3CMR :
@@ -918,7 +918,8 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
     {
         int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
         bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0,
-                isContinuous = _src.isContinuous();
+                isContinuous = _src.isContinuous(),
+                isMaskContinuous = _mask.isContinuous();
         const ocl::Device &defDev = ocl::Device::getDefault();
         int groups = defDev.maxComputeUnits();
         if (defDev.isIntel())
@@ -943,13 +944,14 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
 
         char cvt[2][40];
         String opts = format("-D srcT=%s -D srcT1=%s -D dstT=%s -D dstT1=%s -D sqddepth=%d"
-                             " -D sqdstT=%s -D sqdstT1=%s -D convertToSDT=%s -D cn=%d%s"
+                             " -D sqdstT=%s -D sqdstT1=%s -D convertToSDT=%s -D cn=%d%s%s"
                              " -D convertToDT=%s -D WGS=%d -D WGS2_ALIGNED=%d%s%s",
                              ocl::typeToStr(type), ocl::typeToStr(depth),
                              ocl::typeToStr(dtype), ocl::typeToStr(ddepth), sqddepth,
                              ocl::typeToStr(sqdtype), ocl::typeToStr(sqddepth),
                              ocl::convertTypeStr(depth, sqddepth, cn, cvt[0]),
                              cn, isContinuous ? " -D HAVE_SRC_CONT" : "",
+                             isMaskContinuous ? " -D HAVE_MASK_CONT" : "",
                              ocl::convertTypeStr(depth, ddepth, cn, cvt[1]),
                              (int)wgs, wgs2_aligned, haveMask ? " -D HAVE_MASK" : "",
                              doubleSupport ? " -D DOUBLE_SUPPORT" : "");
@@ -1025,7 +1027,7 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
 
 void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask )
 {
-    CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2,
+    CV_OCL_RUN(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
                ocl_meanStdDev(_src, _mean, _sdv, _mask))
 
     Mat src = _src.getMat(), mask = _mask.getMat();
@@ -1069,7 +1071,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
         int type = src.type();
         if( !mask.empty() )
         {
-            typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *, Ipp64f *);
+            typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *, Ipp64f *);
             ippiMaskMeanStdDevFuncC1 ippFuncC1 =
             type == CV_8UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_8u_C1MR :
             type == CV_16UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_16u_C1MR :
@@ -1081,7 +1083,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
                     return;
                 setIppErrorStatus();
             }
-            typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *, Ipp64f *);
+            typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *, Ipp64f *);
             ippiMaskMeanStdDevFuncC3 ippFuncC3 =
             type == CV_8UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_8u_C3CMR :
             type == CV_16UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_16u_C3CMR :
@@ -1571,7 +1573,7 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
     CV_Assert( (cn == 1 && (_mask.empty() || _mask.type() == CV_8U)) ||
         (cn > 1 && _mask.empty() && !minIdx && !maxIdx) );
 
-    CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2  && (_mask.empty() || _src.size() == _mask.size()),
+    CV_OCL_RUN(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2  && (_mask.empty() || _src.size() == _mask.size()),
                ocl_minMaxIdx(_src, minVal, maxVal, minIdx, maxIdx, _mask))
 
     Mat src = _src.getMat(), mask = _mask.getMat();
@@ -2234,7 +2236,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
 
 #ifdef HAVE_OPENCL
     double _result = 0;
-    CV_OCL_RUN_(_src.isUMat() && _src.dims() <= 2,
+    CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
                 ocl_norm(_src, normType, _mask, _result),
                 _result)
 #endif
@@ -2594,7 +2596,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
 
 #ifdef HAVE_OPENCL
     double _result = 0;
-    CV_OCL_RUN_(_src1.isUMat(),
+    CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src1.isUMat()),
                 ocl_norm(_src1, _src2, normType, _mask, _result),
                 _result)
 #endif

modules/core/src/umatrix.cpp

@@ -41,7 +41,7 @@
 //M*/
 
 #include "precomp.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_core.hpp"
 
 ///////////////////////////////// UMat implementation ///////////////////////////////
 
@@ -582,7 +582,7 @@ Mat UMat::getMat(int accessFlags) const
     hdr.flags = flags;
     hdr.u = u;
     hdr.datastart = u->data;
-    hdr.data = hdr.datastart + offset;
+    hdr.data = u->data + offset;
     hdr.datalimit = hdr.dataend = u->data + u->size;
     CV_XADD(&hdr.u->refcount, 1);
     return hdr;
@@ -593,15 +593,16 @@ void* UMat::handle(int accessFlags) const
     if( !u )
         return 0;
 
-    if ((accessFlags & ACCESS_WRITE) != 0)
-        u->markHostCopyObsolete(true);
-
     // check flags: if CPU copy is newer, copy it back to GPU.
     if( u->deviceCopyObsolete() )
     {
         CV_Assert(u->refcount == 0);
         u->currAllocator->unmap(u);
     }
+
+    if ((accessFlags & ACCESS_WRITE) != 0)
+        u->markHostCopyObsolete(true);
+
     return u->handle;
 }
 

modules/core/test/ocl/test_arithm.cpp

@@ -39,7 +39,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "opencv2/ts/ocl_test.hpp"
 
 #include <cmath>
@@ -157,6 +157,7 @@ PARAM_TEST_CASE(ArithmTestBase, MatDepth, Channels, bool)
         Border maskBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
         randomSubMat(mask, mask_roi, roiSize, maskBorder, CV_8UC1, 0, 2);
         cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
+        *mask.ptr(0) = 255; // prevent test case with mask filled 0 only
 
         val = cv::Scalar(rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0),
                          rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0));
@@ -1419,7 +1420,7 @@ OCL_TEST_P(UMatDot, Mat)
         OCL_OFF(const double cpuRes = src1_roi.dot(src2_roi));
         OCL_ON(const double gpuRes = usrc1_roi.dot(usrc2_roi));
 
-        EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
+        EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-5);
     }
 }
 
@@ -1749,7 +1750,7 @@ OCL_TEST_P(ReduceAvg, Mat)
         OCL_OFF(cv::reduce(src_roi, dst_roi, dim, CV_REDUCE_AVG, dtype));
         OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, CV_REDUCE_AVG, dtype));
 
-        double eps = ddepth <= CV_32S ? 1 : 5e-6;
+        double eps = ddepth <= CV_32S ? 1 : 6e-6;
         OCL_EXPECT_MATS_NEAR(dst, eps);
     }
 }

modules/core/test/ocl/test_channels.cpp

@@ -44,7 +44,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "opencv2/ts/ocl_test.hpp"
 
 #ifdef HAVE_OPENCL
@@ -105,6 +105,7 @@ PARAM_TEST_CASE(Merge, MatDepth, int, bool)
         UMAT_UPLOAD_INPUT_PARAMETER(src3);
         UMAT_UPLOAD_INPUT_PARAMETER(src4);
 
+        src_roi.clear(); usrc_roi.clear(); // for test_loop_times > 1
         src_roi.push_back(src1_roi), usrc_roi.push_back(usrc1_roi);
         if (nsrc >= 2)
             src_roi.push_back(src2_roi), usrc_roi.push_back(usrc2_roi);

modules/core/test/ocl/test_dft.cpp

@@ -43,7 +43,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "opencv2/ts/ocl_test.hpp"
 
 #ifdef HAVE_OPENCL
@@ -108,7 +108,7 @@ OCL_TEST_P(Dft, Mat)
 {
     generateTestData();
 
-    int nonzero_rows = hint ? src.cols - randomInt(1, src.rows-1) : 0;
+    int nonzero_rows = hint ? src.rows - randomInt(1, src.rows-1) : 0;
     OCL_OFF(cv::dft(src, dst, dft_flags, nonzero_rows));
     OCL_ON(cv::dft(usrc, udst, dft_flags, nonzero_rows));
 
@@ -175,7 +175,7 @@ OCL_TEST_P(MulSpectrums, Mat)
 
 OCL_INSTANTIATE_TEST_CASE_P(OCL_ImgProc, MulSpectrums, testing::Combine(Bool(), Bool()));
 
-OCL_INSTANTIATE_TEST_CASE_P(Core, Dft, Combine(Values(cv::Size(10, 10), cv::Size(36, 36), cv::Size(512, 1), cv::Size(1280, 768)),
+OCL_INSTANTIATE_TEST_CASE_P(Core, Dft, Combine(Values(cv::Size(45, 72), cv::Size(36, 36), cv::Size(512, 1), cv::Size(1280, 768)),
                                                Values((OCL_FFT_TYPE) R2C, (OCL_FFT_TYPE) C2C, (OCL_FFT_TYPE) R2R, (OCL_FFT_TYPE) C2R),
                                                Bool(), // DFT_INVERSE
                                                Bool(), // DFT_ROWS

modules/core/test/ocl/test_gemm.cpp

@@ -42,7 +42,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "opencv2/ts/ocl_test.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/test/ocl/test_matrix_expr.cpp

@@ -5,7 +5,7 @@
 // Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
 // Third party copyrights are property of their respective owners.
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "opencv2/ts/ocl_test.hpp"
 
 #ifdef HAVE_OPENCL

modules/core/test/ocl/test_matrix_operation.cpp

@@ -44,7 +44,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include "../test_precomp.hpp"
 #include "opencv2/ts/ocl_test.hpp"
 
 #ifdef HAVE_OPENCL
@@ -96,7 +96,7 @@ OCL_TEST_P(ConvertTo, Accuracy)
         OCL_OFF(src_roi.convertTo(dst_roi, dstType, alpha, beta));
         OCL_ON(usrc_roi.convertTo(udst_roi, dstType, alpha, beta));
 
-        double eps = src_depth >= CV_32F || CV_MAT_DEPTH(dstType) >= CV_32F ? 1e-4 : 1;
+        double eps = CV_MAT_DEPTH(dstType) >= CV_32F ? 2e-4 : 1;
         OCL_EXPECT_MATS_NEAR(dst, eps);
     }
 }
@@ -121,7 +121,7 @@ PARAM_TEST_CASE(CopyTo, MatDepth, Channels, bool, bool)
         use_mask = GET_PARAM(3);
     }
 
-    void generateTestData()
+    void generateTestData(bool one_cn_mask = false)
     {
         const int type = CV_MAKE_TYPE(depth, cn);
 
@@ -132,9 +132,11 @@ PARAM_TEST_CASE(CopyTo, MatDepth, Channels, bool, bool)
         if (use_mask)
         {
             Border maskBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
-            int mask_cn = randomDouble(0.0, 2.0) > 1.0 ? cn : 1;
+            int mask_cn = 1;
+            if (!one_cn_mask && randomDouble(0.0, 2.0) > 1.0)
+                mask_cn = cn;
             randomSubMat(mask, mask_roi, roiSize, maskBorder, CV_8UC(mask_cn), 0, 2);
-            cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
+            cv::threshold(mask, mask, 0.5, 255., THRESH_BINARY);
         }
 
         Border dstBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
@@ -177,7 +179,7 @@ OCL_TEST_P(SetTo, Accuracy)
 {
     for (int j = 0; j < test_loop_times; j++)
     {
-        generateTestData();
+        generateTestData(true); // see modules/core/src/umatrix.cpp Ln:791 => CV_Assert( mask.size() == size() && mask.type() == CV_8UC1 );
 
         if (use_mask)
         {

modules/core/test/test_mat.cpp

@@ -649,6 +649,16 @@ static void setValue(SparseMat& M, const int* idx, double value, RNG& rng)
         CV_Error(CV_StsUnsupportedFormat, "");
 }
 
+template<typename Pixel>
+struct InitializerFunctor{
+    /// Initializer for cv::Mat::forEach test
+    void operator()(Pixel & pixel, const int * idx) const {
+        pixel.x = idx[0];
+        pixel.y = idx[1];
+        pixel.z = idx[2];
+    }
+};
+
 void Core_ArrayOpTest::run( int /* start_from */)
 {
     int errcount = 0;
@@ -686,6 +696,45 @@ void Core_ArrayOpTest::run( int /* start_from */)
             errcount++;
         }
     }
+    // test cv::Mat::forEach
+    {
+        const int dims[3] = { 101, 107, 7 };
+        typedef cv::Point3i Pixel;
+
+        cv::Mat a = cv::Mat::zeros(3, dims, CV_32SC3);
+        InitializerFunctor<Pixel> initializer;
+
+        a.forEach<Pixel>(initializer);
+
+        uint64 total = 0;
+        bool error_reported = false;
+        for (int i0 = 0; i0 < dims[0]; ++i0) {
+            for (int i1 = 0; i1 < dims[1]; ++i1) {
+                for (int i2 = 0; i2 < dims[2]; ++i2) {
+                    Pixel& pixel = a.at<Pixel>(i0, i1, i2);
+                    if (pixel.x != i0 || pixel.y != i1 || pixel.z != i2) {
+                        if (!error_reported) {
+                            ts->printf(cvtest::TS::LOG, "forEach is not correct.\n"
+                                "First error detected at (%d, %d, %d).\n", pixel.x, pixel.y, pixel.z);
+                            error_reported = true;
+                        }
+                        errcount++;
+                    }
+                    total += pixel.x;
+                    total += pixel.y;
+                    total += pixel.z;
+                }
+            }
+        }
+        uint64 total2 = 0;
+        for (size_t i = 0; i < sizeof(dims) / sizeof(dims[0]); ++i) {
+            total2 += ((dims[i] - 1) * dims[i] / 2) * dims[0] * dims[1] * dims[2] / dims[i];
+        }
+        if (total != total2) {
+            ts->printf(cvtest::TS::LOG, "forEach is not correct because total is invalid.\n");
+            errcount++;
+        }
+    }
 
     RNG rng;
     const int MAX_DIM = 5, MAX_DIM_SZ = 10;

modules/core/test/test_umat.cpp

@@ -745,6 +745,24 @@ TEST(UMat, Sync)
     EXPECT_EQ(0, cvtest::norm(um.getMat(ACCESS_READ), cv::Mat(um.size(), um.type(), 19), NORM_INF));
 }
 
+TEST(UMat, CopyToIfDeviceCopyIsObsolete)
+{
+    UMat um(7, 2, CV_8UC1);
+    Mat m(um.size(), um.type());
+    m.setTo(Scalar::all(0));
+
+    {
+        // make obsolete device copy of UMat
+        Mat temp = um.getMat(ACCESS_WRITE);
+        temp.setTo(Scalar::all(10));
+    }
+
+    m.copyTo(um);
+    um.setTo(Scalar::all(17));
+
+    EXPECT_EQ(0, cvtest::norm(um.getMat(ACCESS_READ), Mat(um.size(), um.type(), 17), NORM_INF));
+}
+
 TEST(UMat, setOpenCL)
 {
     // save the current state

modules/cudaarithm/CMakeLists.txt

@@ -23,7 +23,5 @@ endif()
 
 ocv_create_module(${extra_libs})
 
-ocv_add_precompiled_headers(${the_module})
-
 ocv_add_accuracy_tests(DEPENDS_ON opencv_imgproc)
 ocv_add_perf_tests(DEPENDS_ON opencv_imgproc)

modules/cudacodec/CMakeLists.txt

@@ -23,7 +23,5 @@ endif()
 
 ocv_create_module(${extra_libs})
 
-ocv_add_precompiled_headers(${the_module})
-
 ocv_add_accuracy_tests()
 ocv_add_perf_tests()

modules/cudaoptflow/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "CUDA-accelerated Optical Flow")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
 
-ocv_define_module(cudaoptflow opencv_video opencv_legacy opencv_cudaarithm opencv_cudawarping opencv_cudaimgproc OPTIONAL opencv_cudalegacy)
+ocv_define_module(cudaoptflow opencv_video opencv_cudaarithm opencv_cudawarping opencv_cudaimgproc OPTIONAL opencv_cudalegacy)

modules/cudaoptflow/perf/perf_optflow.cpp

@@ -41,7 +41,6 @@
 //M*/
 
 #include "perf_precomp.hpp"
-#include "opencv2/legacy.hpp"
 
 using namespace std;
 using namespace testing;
@@ -389,24 +388,6 @@ PERF_TEST_P(ImagePair, OpticalFlowDual_TVL1,
 //////////////////////////////////////////////////////
 // OpticalFlowBM
 
-void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
-                       cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
-                       cv::Mat& velx, cv::Mat& vely)
-{
-    cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
-
-    velx.create(sz, CV_32FC1);
-    vely.create(sz, CV_32FC1);
-
-    CvMat cvprev = prev;
-    CvMat cvcurr = curr;
-
-    CvMat cvvelx = velx;
-    CvMat cvvely = vely;
-
-    cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
-}
-
 PERF_TEST_P(ImagePair, OpticalFlowBM,
             Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
 {
@@ -435,12 +416,7 @@ PERF_TEST_P(ImagePair, OpticalFlowBM,
     }
     else
     {
-        cv::Mat u, v;
-
-        TEST_CYCLE() calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, u, v);
-
-        CPU_SANITY_CHECK(u);
-        CPU_SANITY_CHECK(v);
+        FAIL_NO_CPU();
     }
 }
 

modules/cudaoptflow/test/test_optflow.cpp

@@ -41,7 +41,6 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include "opencv2/legacy.hpp"
 
 #ifdef HAVE_CUDA
 
@@ -370,65 +369,6 @@ INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, OpticalFlowDual_TVL1, testing::Combine(
     ALL_DEVICES,
     WHOLE_SUBMAT));
 
-//////////////////////////////////////////////////////
-// OpticalFlowBM
-
-namespace
-{
-    void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
-                           cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
-                           cv::Mat& velx, cv::Mat& vely)
-    {
-        cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
-
-        velx.create(sz, CV_32FC1);
-        vely.create(sz, CV_32FC1);
-
-        CvMat cvprev = prev;
-        CvMat cvcurr = curr;
-
-        CvMat cvvelx = velx;
-        CvMat cvvely = vely;
-
-        cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
-    }
-}
-
-struct OpticalFlowBM : testing::TestWithParam<cv::cuda::DeviceInfo>
-{
-};
-
-CUDA_TEST_P(OpticalFlowBM, Accuracy)
-{
-    cv::cuda::DeviceInfo devInfo = GetParam();
-    cv::cuda::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-    cv::resize(frame0, frame0, cv::Size(), 0.5, 0.5);
-
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-    cv::resize(frame1, frame1, cv::Size(), 0.5, 0.5);
-
-    cv::Size block_size(8, 8);
-    cv::Size shift_size(1, 1);
-    cv::Size max_range(8, 8);
-
-    cv::cuda::GpuMat d_velx, d_vely, buf;
-    cv::cuda::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
-                               block_size, shift_size, max_range, false,
-                               d_velx, d_vely, buf);
-
-    cv::Mat velx, vely;
-    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
-
-    EXPECT_MAT_NEAR(velx, d_velx, 0);
-    EXPECT_MAT_NEAR(vely, d_vely, 0);
-}
-
-INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, OpticalFlowBM, ALL_DEVICES);
-
 //////////////////////////////////////////////////////
 // FastOpticalFlowBM
 

modules/cudev/test/CMakeLists.txt

@@ -29,7 +29,7 @@ if(OCV_DEPENDENCIES_FOUND)
   endforeach()
 
   CUDA_ADD_EXECUTABLE(${the_target} ${OPENCV_TEST_${the_module}_SOURCES})
-  target_link_libraries(${the_target} ${test_deps} ${OPENCV_LINKER_LIBS} ${CUDA_LIBRARIES})
+  ocv_target_link_libraries(${the_target} ${test_deps} ${OPENCV_LINKER_LIBS} ${CUDA_LIBRARIES})
   add_dependencies(opencv_tests ${the_target})
 
   # Additional target properties

modules/features2d/perf/opencl/perf_brute_force_matcher.cpp

@@ -43,7 +43,7 @@
 // the use of this software, even if advised of the possibility of such damage.
 //
 //M*/
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/features2d/perf/opencl/perf_fast.cpp

@@ -1,4 +1,4 @@
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/features2d/perf/opencl/perf_orb.cpp

@@ -1,4 +1,4 @@
-#include "perf_precomp.hpp"
+#include "../perf_precomp.hpp"
 #include "opencv2/ts/ocl_perf.hpp"
 
 #ifdef HAVE_OPENCL

modules/features2d/src/brisk.cpp

@@ -427,7 +427,7 @@ BRISK::smoothedIntensity(const cv::Mat& image, const cv::Mat& integral, const fl
   if (dx + dy > 2)
   {
     // now the calculation:
-    uchar* ptr = image.data + x_left + imagecols * y_top;
+    const uchar* ptr = image.data + x_left + imagecols * y_top;
     // first the corners:
     ret_val = A * int(*ptr);
     ptr += dx + 1;
@@ -475,7 +475,7 @@ BRISK::smoothedIntensity(const cv::Mat& image, const cv::Mat& integral, const fl
   }
 
   // now the calculation:
-  uchar* ptr = image.data + x_left + imagecols * y_top;
+  const uchar* ptr = image.data + x_left + imagecols * y_top;
   // first row:
   ret_val = A * int(*ptr);
   ptr++;
@@ -487,7 +487,7 @@ BRISK::smoothedIntensity(const cv::Mat& image, const cv::Mat& integral, const fl
   ret_val += B * int(*ptr);
   // middle ones:
   ptr += imagecols - dx - 1;
-  uchar* end_j = ptr + dy * imagecols;
+  const uchar* end_j = ptr + dy * imagecols;
   for (; ptr < end_j; ptr += imagecols - dx - 1)
   {
     ret_val += r_x_1_i * int(*ptr);
@@ -607,7 +607,7 @@ BRISK::computeDescriptorsAndOrOrientation(InputArray _image, InputArray _mask, s
   int t2;
 
   // the feature orientation
-  uchar* ptr = descriptors.data;
+  const uchar* ptr = descriptors.data;
   for (size_t k = 0; k < ksize; k++)
   {
     cv::KeyPoint& kp = keypoints[k];
@@ -1070,7 +1070,7 @@ BriskScaleSpace::isMax2D(const int layer, const int x_layer, const int y_layer)
 {
   const cv::Mat& scores = pyramid_[layer].scores();
   const int scorescols = scores.cols;
-  uchar* data = scores.data + y_layer * scorescols + x_layer;
+  const uchar* data = scores.data + y_layer * scorescols + x_layer;
   // decision tree:
   const uchar center = (*data);
   data--;
@@ -2140,7 +2140,7 @@ BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
     const int r_y = (int)((yf - y) * 1024);
     const int r_x_1 = (1024 - r_x);
     const int r_y_1 = (1024 - r_y);
-    uchar* ptr = image.data + x + y * imagecols;
+    const uchar* ptr = image.data + x + y * imagecols;
     // just interpolate:
     ret_val = (r_x_1 * r_y_1 * int(*ptr));
     ptr++;
@@ -2186,7 +2186,7 @@ BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
   const int r_y1_i = (int)(r_y1 * scaling);
 
   // now the calculation:
-  uchar* ptr = image.data + x_left + imagecols * y_top;
+  const uchar* ptr = image.data + x_left + imagecols * y_top;
   // first row:
   ret_val = A * int(*ptr);
   ptr++;
@@ -2198,7 +2198,7 @@ BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
   ret_val += B * int(*ptr);
   // middle ones:
   ptr += imagecols - dx - 1;
-  uchar* end_j = ptr + dy * imagecols;
+  const uchar* end_j = ptr + dy * imagecols;
   for (; ptr < end_j; ptr += imagecols - dx - 1)
   {
     ret_val += r_x_1_i * int(*ptr);

modules/features2d/src/fast.cpp

@@ -43,7 +43,7 @@ The references are:
 
 #include "precomp.hpp"
 #include "fast_score.hpp"
-#include "opencl_kernels.hpp"
+#include "opencl_kernels_features2d.hpp"
 
 #if defined _MSC_VER
 # pragma warning( disable : 4127)

modules/features2d/src/freak.cpp

@@ -45,7 +45,6 @@ namespace cv
 {
 
 static const double FREAK_SQRT2 = 1.4142135623731;
-static const double FREAK_INV_SQRT2 = 1.0 / FREAK_SQRT2;
 static const double FREAK_LOG2 = 0.693147180559945;
 static const int FREAK_NB_ORIENTATION = 256;
 static const int FREAK_NB_POINTS = 43;

modules/features2d/src/kaze/AKAZEConfig.h

@@ -10,7 +10,7 @@
 
 /* ************************************************************************* */
 // OpenCV
-#include "precomp.hpp"
+#include "../precomp.hpp"
 #include <opencv2/features2d.hpp>
 
 /* ************************************************************************* */

modules/features2d/src/kaze/AKAZEFeatures.h

@@ -11,7 +11,7 @@
 
 /* ************************************************************************* */
 // Includes
-#include "precomp.hpp"
+#include "../precomp.hpp"
 #include "AKAZEConfig.h"
 #include "TEvolution.h"
 

modules/features2d/src/kaze/KAZEConfig.h

@@ -9,7 +9,7 @@
 #define __OPENCV_FEATURES_2D_AKAZE_CONFIG_H__
 
 // OpenCV Includes
-#include "precomp.hpp"
+#include "../precomp.hpp"
 #include <opencv2/features2d.hpp>
 
 //*************************************************************************************

modules/features2d/src/kaze/fed.cpp

@@ -28,7 +28,7 @@
  * DAGM, 2010
  *
 */
-#include "precomp.hpp"
+#include "../precomp.hpp"
 #include "fed.h"
 
 using namespace std;