Merged the trunk r8589:8653 - all changes related to build warnings

3rdparty/libjasper/CMakeLists.txt

@@ -7,10 +7,8 @@ project(${JASPER_LIBRARY})
 
 add_definitions(-DEXCLUDE_MIF_SUPPORT -DEXCLUDE_PNM_SUPPORT -DEXCLUDE_BMP_SUPPORT -DEXCLUDE_RAS_SUPPORT  -DEXCLUDE_JPG_SUPPORT -DEXCLUDE_PGX_SUPPORT)
 
-# List of C++ files:
 ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
-# The .cpp files:
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 file(GLOB lib_ext_hdrs jasper/*.h)
@@ -22,16 +20,11 @@ file(GLOB lib_ext_hdrs jasper/*.h)
 add_library(${JASPER_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})
 
 if(MSVC)
-  if(NOT ENABLE_NOISY_WARNINGS)
-    string(REPLACE "/W3" "/W0" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    string(REPLACE "/W4" "/W0" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  endif()
   add_definitions(-DJAS_WIN_MSVC_BUILD)
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wno-implicit-function-declaration -Wno-uninitialized -Wmissing-prototypes -Wmissing-declarations -Wunused -Wshadow
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-uninitialized")
+                                   /wd4013 /wd4018 /wd4715 /wd4244 /wd4101 /wd4267)
-endif()
 
 if(UNIX)
   if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
@@ -39,10 +32,6 @@ if(UNIX)
   endif()
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX AND NOT ENABLE_NOISY_WARNINGS)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-implicit-function-declaration -Wno-unused")
-endif()
-
 set_target_properties(${JASPER_LIBRARY}
   PROPERTIES
   OUTPUT_NAME ${JASPER_LIBRARY}

3rdparty/libjpeg/CMakeLists.txt

@@ -4,11 +4,8 @@
 # ----------------------------------------------------------------------------
 project(${JPEG_LIBRARY})
 
-# List of C++ files:
-
 ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
-# The .cpp files:
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 
@@ -18,10 +15,6 @@ file(GLOB lib_hdrs *.h)
 
 add_library(${JPEG_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs})
 
-if(MSVC)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
-endif()
-
 if(UNIX)
   if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
@@ -32,6 +25,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
   set_source_files_properties(jcdctmgr.c PROPERTIES COMPILE_FLAGS "-O1")
 endif()
 
+ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align -Wshadow)
+
 set_target_properties(${JPEG_LIBRARY}
   PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}
   DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"

3rdparty/libpng/CMakeLists.txt

@@ -4,8 +4,6 @@
 # ----------------------------------------------------------------------------
 project(${PNG_LIBRARY})
 
-# List of C++ files:
-
 ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" ${ZLIB_INCLUDE_DIR})
 
 file(GLOB lib_srcs *.c)
@@ -17,16 +15,14 @@ file(GLOB lib_hdrs *.h)
 
 add_library(${PNG_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs})
 
-if(MSVC)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
-endif()
-
 if(UNIX)
   if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
   endif()
 endif()
 
+ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align)
+
 set_target_properties(${PNG_LIBRARY}
   PROPERTIES OUTPUT_NAME ${PNG_LIBRARY}
   DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"

3rdparty/libtiff/CMakeLists.txt

@@ -26,7 +26,6 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmakein"
 
 ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIR})
 
-# List of C++ files:
 set(lib_srcs
     tif_aux.c
     tif_close.c
@@ -91,10 +90,9 @@ if(WIN32)
   list(APPEND lib_srcs tif_win32.c)
 endif(WIN32)
 
-if(MSVC AND NOT ENABLE_NOISY_WARNINGS)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef
-  string(REPLACE "/W4" "/W0" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+                                   -Wcast-align -Wshadow -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast)
-  string(REPLACE "/W4" "/W0" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations /wd4100 /wd4244 /wd4706 /wd4127 /wd4701 /wd4018 /wd4267 /wd4306 /wd4305 /wd4312 /wd4311)
-endif()
 
 if(UNIX AND (CMAKE_COMPILER_IS_GNUCXX OR CV_ICC))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")

3rdparty/libtiff/tif_config.h.cmakein

@@ -143,7 +143,7 @@
 
 /* Signed 64-bit type formatter */
 /* Unsigned 64-bit type formatter */
-#ifdef _MSC_VER
+#if defined _MSC_VER || defined __MINGW__ || defined __MINGW32__
 # define TIFF_UINT64_FORMAT "%I64u"
 # define TIFF_SSIZE_FORMAT "%Iu"
 #else

3rdparty/tbb/CMakeLists.txt

@@ -119,7 +119,10 @@ endif()
 add_library(tbb STATIC ${lib_srcs} ${lib_hdrs} "${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h" "${CMAKE_CURRENT_SOURCE_DIR}/${tbb_version_file}")
 target_link_libraries(tbb c m dl)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w -include \"${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h\"")
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations)
+string(REPLACE "-Werror=non-virtual-dtor" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -include \"${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h\"")
 
 set_target_properties(tbb
   PROPERTIES OUTPUT_NAME tbb

3rdparty/tbb/version_string.tmp

@@ -6,4 +6,4 @@
 "TBB: BUILD_GLIBC	Unknown" ENDL \
 "TBB: BUILD_LD		Unknown" ENDL \
 "TBB: BUILD_TARGET	Unknown" ENDL \
-"TBB: BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL \
+"TBB: BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL

3rdparty/tbb/version_string.ver

@@ -6,4 +6,4 @@
 #N": BUILD_GLIBC	Unknown" ENDL \
 #N": BUILD_LD		Unknown" ENDL \
 #N": BUILD_TARGET	Unknown" ENDL \
-#N": BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL \
+#N": BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL

3rdparty/zlib/CMakeLists.txt

@@ -5,19 +5,10 @@
 
 project(${ZLIB_LIBRARY} C)
 
-include(CheckTypeSize)
 include(CheckFunctionExists)
 include(CheckIncludeFile)
 include(CheckCSourceCompiles)
 
-#
-# Check to see if we have large file support
-#
-check_type_size(off64_t OFF64_T)
-if(HAVE_OFF64_T)
-  add_definitions(-D_LARGEFILE64_SOURCE=1)
-endif()
-
 #
 # Check for fseeko
 #
@@ -82,9 +73,7 @@ if(UNIX)
   endif()
 endif()
 
-if(MSVC AND NOT ENABLE_NOISY_WARNINGS)
+ocv_warnings_disable(CMAKE_C_FLAGS /wd4013 -Wattributes -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4013")
-endif()
 
 set_target_properties(${ZLIB_LIBRARY} PROPERTIES
         OUTPUT_NAME ${ZLIB_LIBRARY}

3rdparty/zlib/zconf.h.cmakein

@@ -410,10 +410,18 @@ typedef uLong FAR uLongf;
  * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
  * equivalently requesting no 64-bit operations
  */
-#if -_LARGEFILE64_SOURCE - -1 == 1
+#if defined _LARGEFILE64_SOURCE && -_LARGEFILE64_SOURCE - -1 == 1
 #  undef _LARGEFILE64_SOURCE
 #endif
 
+#ifndef _LFS64_LARGEFILE
+#  define _LFS64_LARGEFILE 0
+#endif
+
+#ifndef _FILE_OFFSET_BITS
+#  define _FILE_OFFSET_BITS 0
+#endif
+
 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
 #  define Z_LARGE
 #endif

CMakeLists.txt

@@ -188,6 +188,8 @@ OCV_OPTION(ENABLE_SSE42               "Enable SSE4.2 instructions"
 OCV_OPTION(ENABLE_NOISY_WARNINGS      "Show all warnings even if they are too noisy"             OFF )
 OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors"                                 OFF )
 
+OCV_OPTION(OPENCV_CAN_BREAK_BINARY_COMPATIBILITY "Allow changes breaking binary compatibility with OpenCV 2.4.0" OFF )
+
 # uncategorized options
 # ===================================================
 OCV_OPTION(CMAKE_VERBOSE "Verbose mode" OFF )
@@ -286,13 +288,13 @@ endif()
 # ----------------------------------------------------------------------------
 # OpenCV compiler and linker options
 # ----------------------------------------------------------------------------
-include(cmake/OpenCVCompilerOptions.cmake REQUIRED)
-
 # In case of Makefiles if the user does not setup CMAKE_BUILD_TYPE, assume it's Release:
 if(CMAKE_GENERATOR MATCHES "Makefiles|Ninja" AND "${CMAKE_BUILD_TYPE}" STREQUAL "")
   set(CMAKE_BUILD_TYPE Release)
 endif()
 
+include(cmake/OpenCVCompilerOptions.cmake REQUIRED)
+
 
 # ----------------------------------------------------------------------------
 # Use statically or dynamically linked CRT?
@@ -328,6 +330,15 @@ if(UNIX)
   endif()
 endif()
 
+#
+# Check to see if we have large file support (needed by zlib)
+#
+include(CheckTypeSize)
+check_type_size(off64_t OFF64_T)
+if(HAVE_OFF64_T)
+  add_definitions(-D_LARGEFILE64_SOURCE=1)
+endif()
+
 include(cmake/OpenCVPCHSupport.cmake REQUIRED)
 include(cmake/OpenCVModule.cmake REQUIRED)
 
@@ -471,6 +482,7 @@ else()
   status("    Linker flags (Release):" ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE})
   status("    Linker flags (Debug):"   ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG})
 endif()
+status("    Precompiled headers:"     PCHSupport_FOUND AND ENABLE_PRECOMPILED_HEADERS THEN YES ELSE NO)
 
 # ========================== OpenCV modules ==========================
 status("")
@@ -560,7 +572,7 @@ if(WITH_TIFF)
   if(TIFF_VERSION_STRING AND TIFF_FOUND)
     status("    TIFF:"     "${TIFF_LIBRARY} (ver ${TIFF_VERSION} - ${TIFF_VERSION_STRING})")
   else()
-    status("    TIFF:"     TIFF_FOUND    THEN "${TIFF_LIBRARY} (ver ${TIFF_VERSION})"            ELSE "build (ver ${TIFF_VERSION})")
+    status("    TIFF:"     TIFF_FOUND    THEN "${TIFF_LIBRARY} (ver ${TIFF_VERSION})"            ELSE "build (ver ${TIFF_VERSION} - ${TIFF_VERSION_STRING})")
   endif()
 else()
   status("    TIFF:"       "NO")

apps/haartraining/_cvcommon.h

@@ -42,6 +42,9 @@
 #ifndef __CVCOMMON_H_
 #define __CVCOMMON_H_
 
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "cxcore.h"
 #include "cv.h"
 #include "cxmisc.h"

apps/haartraining/cvboost.cpp

@@ -80,11 +80,11 @@ typedef struct CvValArray
     ( *( (float*) (aux->data + ((int) (idx1)) * aux->step ) ) <  \
       *( (float*) (aux->data + ((int) (idx2)) * aux->step ) ) )
 
-CV_IMPLEMENT_QSORT_EX( icvSortIndexedValArray_16s, short, CMP_VALUES, CvValArray* )
+static CV_IMPLEMENT_QSORT_EX( icvSortIndexedValArray_16s, short, CMP_VALUES, CvValArray* )
 
-CV_IMPLEMENT_QSORT_EX( icvSortIndexedValArray_32s, int,   CMP_VALUES, CvValArray* )
+static CV_IMPLEMENT_QSORT_EX( icvSortIndexedValArray_32s, int,   CMP_VALUES, CvValArray* )
 
-CV_IMPLEMENT_QSORT_EX( icvSortIndexedValArray_32f, float, CMP_VALUES, CvValArray* )
+static CV_IMPLEMENT_QSORT_EX( icvSortIndexedValArray_32f, float, CMP_VALUES, CvValArray* )
 
 CV_BOOST_IMPL
 void cvGetSortedIndices( CvMat* val, CvMat* idx, int sortcols )
@@ -190,7 +190,7 @@ float cvEvalStumpClassifier( CvClassifier* classifier, CvMat* sample )
 }
 
 #define ICV_DEF_FIND_STUMP_THRESHOLD( suffix, type, error )                              \
-CV_BOOST_IMPL int icvFindStumpThreshold_##suffix(                                              \
+static int icvFindStumpThreshold_##suffix(                                               \
         uchar* data, size_t datastep,                                                    \
         uchar* wdata, size_t wstep,                                                      \
         uchar* ydata, size_t ystep,                                                      \
@@ -213,13 +213,10 @@ CV_BOOST_IMPL int icvFindStumpThreshold_##suffix(
     float* curval  = NULL;                                                               \
     float curlerror = 0.0F;                                                              \
     float currerror = 0.0F;                                                              \
-    float wposl;                                                                         \
-    float wposr;                                                                         \
                                                                                          \
     int i = 0;                                                                           \
     int idx = 0;                                                                         \
                                                                                          \
-    wposl = wposr = 0.0F;                                                                \
     if( *sumw == FLT_MAX )                                                               \
     {                                                                                    \
         /* calculate sums */                                                             \
@@ -298,8 +295,8 @@ CV_BOOST_IMPL int icvFindStumpThreshold_##suffix(
  */
 #define ICV_DEF_FIND_STUMP_THRESHOLD_MISC( suffix, type )                                \
     ICV_DEF_FIND_STUMP_THRESHOLD( misc_##suffix, type,                                   \
-        wposl = 0.5F * ( wl + wyl );                                                     \
+        float wposl = 0.5F * ( wl + wyl );                                               \
-        wposr = 0.5F * ( wr + wyr );                                                     \
+        float wposr = 0.5F * ( wr + wyr );                                               \
         curleft = 0.5F * ( 1.0F + curleft );                                             \
         curright = 0.5F * ( 1.0F + curright );                                           \
         curlerror = MIN( wposl, wl - wposl );                                            \
@@ -311,8 +308,8 @@ CV_BOOST_IMPL int icvFindStumpThreshold_##suffix(
  */
 #define ICV_DEF_FIND_STUMP_THRESHOLD_GINI( suffix, type )                                \
     ICV_DEF_FIND_STUMP_THRESHOLD( gini_##suffix, type,                                   \
-        wposl = 0.5F * ( wl + wyl );                                                     \
+        float wposl = 0.5F * ( wl + wyl );                                               \
-        wposr = 0.5F * ( wr + wyr );                                                     \
+        float wposr = 0.5F * ( wr + wyr );                                               \
         curleft = 0.5F * ( 1.0F + curleft );                                             \
         curright = 0.5F * ( 1.0F + curright );                                           \
         curlerror = 2.0F * wposl * ( 1.0F - curleft );                                   \
@@ -326,8 +323,8 @@ CV_BOOST_IMPL int icvFindStumpThreshold_##suffix(
  */
 #define ICV_DEF_FIND_STUMP_THRESHOLD_ENTROPY( suffix, type )                             \
     ICV_DEF_FIND_STUMP_THRESHOLD( entropy_##suffix, type,                                \
-        wposl = 0.5F * ( wl + wyl );                                                     \
+        float wposl = 0.5F * ( wl + wyl );                                               \
-        wposr = 0.5F * ( wr + wyr );                                                     \
+        float wposr = 0.5F * ( wr + wyr );                                               \
         curleft = 0.5F * ( 1.0F + curleft );                                             \
         curright = 0.5F * ( 1.0F + curright );                                           \
         curlerror = currerror = 0.0F;                                                    \
@@ -1149,7 +1146,7 @@ float cvEvalCARTClassifier( CvClassifier* classifier, CvMat* sample )
     return ((CvCARTClassifier*) classifier)->val[-idx];
 }
 
-CV_BOOST_IMPL
+static
 float cvEvalCARTClassifierIdx( CvClassifier* classifier, CvMat* sample )
 {
     CV_FUNCNAME( "cvEvalCARTClassifierIdx" );
@@ -1209,7 +1206,7 @@ void cvReleaseCARTClassifier( CvClassifier** classifier )
     *classifier = NULL;
 }
 
-void CV_CDECL icvDefaultSplitIdx_R( int compidx, float threshold,
+static void CV_CDECL icvDefaultSplitIdx_R( int compidx, float threshold,
                                     CvMat* idx, CvMat** left, CvMat** right,
                                     void* userdata )
 {
@@ -1258,7 +1255,7 @@ void CV_CDECL icvDefaultSplitIdx_R( int compidx, float threshold,
     }
 }
 
-void CV_CDECL icvDefaultSplitIdx_C( int compidx, float threshold,
+static void CV_CDECL icvDefaultSplitIdx_C( int compidx, float threshold,
                                     CvMat* idx, CvMat** left, CvMat** right,
                                     void* userdata )
 {
@@ -1529,7 +1526,7 @@ typedef struct CvBoostTrainer
  * using ANY appropriate weak classifier
  */
 
-CV_BOOST_IMPL
+static
 CvBoostTrainer* icvBoostStartTraining( CvMat* trainClasses,
                                        CvMat* weakTrainVals,
                                        CvMat* /*weights*/,
@@ -1560,7 +1557,7 @@ CvBoostTrainer* icvBoostStartTraining( CvMat* trainClasses,
     CV_MAT2VEC( *trainClasses, ydata, ystep, m );
     CV_MAT2VEC( *weakTrainVals, traindata, trainstep, trainnum );
 
-    assert( m == trainnum );
+    CV_Assert( m == trainnum );
 
     idxnum = 0;
     idxstep = 0;
@@ -1607,7 +1604,7 @@ CvBoostTrainer* icvBoostStartTraining( CvMat* trainClasses,
  * Discrete AdaBoost functions
  *
  */
-CV_BOOST_IMPL
+static
 float icvBoostNextWeakClassifierDAB( CvMat* weakEvalVals,
                                      CvMat* trainClasses,
                                      CvMat* /*weakTrainVals*/,
@@ -1640,8 +1637,8 @@ float icvBoostNextWeakClassifierDAB( CvMat* weakEvalVals,
     CV_MAT2VEC( *trainClasses, ydata, ystep, ynum );
     CV_MAT2VEC( *weights, wdata, wstep, wnum );
 
-    assert( m == ynum );
+    CV_Assert( m == ynum );
-    assert( m == wnum );
+    CV_Assert( m == wnum );
 
     sumw = 0.0F;
     err = 0.0F;
@@ -1681,7 +1678,7 @@ float icvBoostNextWeakClassifierDAB( CvMat* weakEvalVals,
  * Real AdaBoost functions
  *
  */
-CV_BOOST_IMPL
+static
 float icvBoostNextWeakClassifierRAB( CvMat* weakEvalVals,
                                      CvMat* trainClasses,
                                      CvMat* /*weakTrainVals*/,
@@ -1743,7 +1740,7 @@ float icvBoostNextWeakClassifierRAB( CvMat* weakEvalVals,
 #define CV_LB_PROB_THRESH      0.01F
 #define CV_LB_WEIGHT_THRESHOLD 0.0001F
 
-CV_BOOST_IMPL
+static
 void icvResponsesAndWeightsLB( int num, uchar* wdata, int wstep,
                                uchar* ydata, int ystep,
                                uchar* fdata, int fstep,
@@ -1772,7 +1769,7 @@ void icvResponsesAndWeightsLB( int num, uchar* wdata, int wstep,
     }
 }
 
-CV_BOOST_IMPL
+static
 CvBoostTrainer* icvBoostStartTrainingLB( CvMat* trainClasses,
                                          CvMat* weakTrainVals,
                                          CvMat* weights,
@@ -1808,8 +1805,8 @@ CvBoostTrainer* icvBoostStartTrainingLB( CvMat* trainClasses,
     CV_MAT2VEC( *weakTrainVals, traindata, trainstep, trainnum );
     CV_MAT2VEC( *weights, wdata, wstep, wnum );
 
-    assert( m == trainnum );
+    CV_Assert( m == trainnum );
-    assert( m == wnum );
+    CV_Assert( m == wnum );
 
 
     idxnum = 0;
@@ -1854,7 +1851,7 @@ CvBoostTrainer* icvBoostStartTrainingLB( CvMat* trainClasses,
     return ptr;
 }
 
-CV_BOOST_IMPL
+static
 float icvBoostNextWeakClassifierLB( CvMat* weakEvalVals,
                                     CvMat* trainClasses,
                                     CvMat* weakTrainVals,
@@ -1889,9 +1886,9 @@ float icvBoostNextWeakClassifierLB( CvMat* weakEvalVals,
     CV_MAT2VEC( *weakTrainVals, traindata, trainstep, trainnum );
     CV_MAT2VEC( *weights, wdata, wstep, wnum );
 
-    assert( m == ynum );
+    CV_Assert( m == ynum );
-    assert( m == wnum );
+    CV_Assert( m == wnum );
-    assert( m == trainnum );
+    CV_Assert( m == trainnum );
     //assert( m == trainer->count );
 
     for( i = 0; i < trainer->count; i++ )
@@ -1913,7 +1910,7 @@ float icvBoostNextWeakClassifierLB( CvMat* weakEvalVals,
  * Gentle AdaBoost
  *
  */
-CV_BOOST_IMPL
+static
 float icvBoostNextWeakClassifierGAB( CvMat* weakEvalVals,
                                      CvMat* trainClasses,
                                      CvMat* /*weakTrainVals*/,
@@ -1944,8 +1941,8 @@ float icvBoostNextWeakClassifierGAB( CvMat* weakEvalVals,
     CV_MAT2VEC( *trainClasses, ydata, ystep, ynum );
     CV_MAT2VEC( *weights, wdata, wstep, wnum );
 
-    assert( m == ynum );
+    CV_Assert( m == ynum );
-    assert( m == wnum );
+    CV_Assert( m == wnum );
 
     sumw = 0.0F;
     for( i = 0; i < trainer->count; i++ )
@@ -2071,7 +2068,7 @@ typedef struct CvBtTrainer
 typedef void (*CvZeroApproxFunc)( float* approx, CvBtTrainer* trainer );
 
 /* Mean zero approximation */
-void icvZeroApproxMean( float* approx, CvBtTrainer* trainer )
+static void icvZeroApproxMean( float* approx, CvBtTrainer* trainer )
 {
     int i;
     int idx;
@@ -2088,7 +2085,7 @@ void icvZeroApproxMean( float* approx, CvBtTrainer* trainer )
 /*
  * Median zero approximation
  */
-void icvZeroApproxMed( float* approx, CvBtTrainer* trainer )
+static void icvZeroApproxMed( float* approx, CvBtTrainer* trainer )
 {
     int i;
     int idx;
@@ -2106,7 +2103,7 @@ void icvZeroApproxMed( float* approx, CvBtTrainer* trainer )
 /*
  * 0.5 * log( mean(y) / (1 - mean(y)) ) where y in {0, 1}
  */
-void icvZeroApproxLog( float* approx, CvBtTrainer* trainer )
+static void icvZeroApproxLog( float* approx, CvBtTrainer* trainer )
 {
     float y_mean;
 
@@ -2117,7 +2114,7 @@ void icvZeroApproxLog( float* approx, CvBtTrainer* trainer )
 /*
  * 0 zero approximation
  */
-void icvZeroApprox0( float* approx, CvBtTrainer* trainer )
+static void icvZeroApprox0( float* approx, CvBtTrainer* trainer )
 {
     int i;
 
@@ -2143,7 +2140,7 @@ static CvZeroApproxFunc icvZeroApproxFunc[] =
 CV_BOOST_IMPL
 void cvBtNext( CvCARTClassifier** trees, CvBtTrainer* trainer );
 
-CV_BOOST_IMPL
+static
 CvBtTrainer* cvBtStart( CvCARTClassifier** trees,
                         CvMat* trainData,
                         int flags,
@@ -2270,7 +2267,7 @@ CvBtTrainer* cvBtStart( CvCARTClassifier** trees,
     return ptr;
 }
 
-void icvBtNext_LSREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
+static void icvBtNext_LSREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
 {
     int i;
 
@@ -2288,7 +2285,7 @@ void icvBtNext_LSREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
 }
 
 
-void icvBtNext_LADREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
+static void icvBtNext_LADREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
 {
     CvCARTClassifier* ptr;
     int i, j;
@@ -2361,7 +2358,7 @@ void icvBtNext_LADREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
 }
 
 
-void icvBtNext_MREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
+static void icvBtNext_MREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
 {
     CvCARTClassifier* ptr;
     int i, j;
@@ -2476,7 +2473,7 @@ void icvBtNext_MREG( CvCARTClassifier** trees, CvBtTrainer* trainer )
 
 #define CV_LOG_VAL_MAX 18.0
 
-void icvBtNext_L2CLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
+static void icvBtNext_L2CLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
 {
     CvCARTClassifier* ptr;
     int i, j;
@@ -2617,7 +2614,7 @@ void icvBtNext_L2CLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
     trees[0] = ptr;
 }
 
-void icvBtNext_LKCLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
+static void icvBtNext_LKCLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
 {
     int i, j, k, kk, num;
     CvMat sample;
@@ -2781,7 +2778,7 @@ void icvBtNext_LKCLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
 }
 
 
-void icvBtNext_XXBCLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
+static void icvBtNext_XXBCLASS( CvCARTClassifier** trees, CvBtTrainer* trainer )
 {
     float alpha;
     int i;
@@ -2898,7 +2895,7 @@ void cvBtNext( CvCARTClassifier** trees, CvBtTrainer* trainer )
     }
 }
 
-CV_BOOST_IMPL
+static
 void cvBtEnd( CvBtTrainer** trainer )
 {
     CV_FUNCNAME( "cvBtEnd" );
@@ -2931,7 +2928,7 @@ void cvBtEnd( CvBtTrainer** trainer )
 *                         Boosted tree model as a classifier                             *
 \****************************************************************************************/
 
-CV_BOOST_IMPL
+static
 float cvEvalBtClassifier( CvClassifier* classifier, CvMat* sample )
 {
     float val;
@@ -2972,7 +2969,7 @@ float cvEvalBtClassifier( CvClassifier* classifier, CvMat* sample )
     return val;
 }
 
-CV_BOOST_IMPL
+static
 float cvEvalBtClassifier2( CvClassifier* classifier, CvMat* sample )
 {
     float val;
@@ -2988,7 +2985,7 @@ float cvEvalBtClassifier2( CvClassifier* classifier, CvMat* sample )
     return (float) (val >= 0.0F);
 }
 
-CV_BOOST_IMPL
+static
 float cvEvalBtClassifierK( CvClassifier* classifier, CvMat* sample )
 {
     int cls = 0;
@@ -3072,7 +3069,7 @@ static CvEvalBtClassifier icvEvalBtClassifier[] =
     cvEvalBtClassifier
 };
 
-CV_BOOST_IMPL
+static
 int cvSaveBtClassifier( CvClassifier* classifier, const char* filename )
 {
     CV_FUNCNAME( "cvSaveBtClassifier" );
@@ -3137,7 +3134,7 @@ int cvSaveBtClassifier( CvClassifier* classifier, const char* filename )
 }
 
 
-CV_BOOST_IMPL
+static
 void cvReleaseBtClassifier( CvClassifier** ptr )
 {
     CV_FUNCNAME( "cvReleaseBtClassifier" );
@@ -3183,7 +3180,7 @@ void cvReleaseBtClassifier( CvClassifier** ptr )
     __END__;
 }
 
-void cvTuneBtClassifier( CvClassifier* classifier, CvMat*, int flags,
+static void cvTuneBtClassifier( CvClassifier* classifier, CvMat*, int flags,
                          CvMat*, CvMat* , CvMat*, CvMat*, CvMat* )
 {
     CV_FUNCNAME( "cvTuneBtClassifier" );
@@ -3244,7 +3241,7 @@ void cvTuneBtClassifier( CvClassifier* classifier, CvMat*, int flags,
     __END__;
 }
 
-CvBtClassifier* icvAllocBtClassifier( CvBoostType type, int flags, int numclasses,
+static CvBtClassifier* icvAllocBtClassifier( CvBoostType type, int flags, int numclasses,
                                       int numiter )
 {
     CvBtClassifier* ptr;
@@ -3720,7 +3717,7 @@ void cvWriteTrainData( const char* filename, int flags,
 
 
 #define ICV_RAND_SHUFFLE( suffix, type )                                                 \
-void icvRandShuffle_##suffix( uchar* data, size_t step, int num )                        \
+static void icvRandShuffle_##suffix( uchar* data, size_t step, int num )                 \
 {                                                                                        \
     time_t seed;                                                                         \
     type tmp;                                                                            \

apps/haartraining/cvhaarclassifier.cpp

@@ -394,7 +394,7 @@ void icvSaveStageHaarClassifier( CvIntHaarClassifier* classifier, FILE* file )
 
 
 
-CvIntHaarClassifier* icvLoadCARTStageHaarClassifierF( FILE* file, int step )
+static CvIntHaarClassifier* icvLoadCARTStageHaarClassifierF( FILE* file, int step )
 {
     CvStageHaarClassifier* ptr = NULL;
 
@@ -525,9 +525,9 @@ float icvEvalTreeCascadeClassifierFilter( CvIntHaarClassifier* classifier, sum_t
                                           sum_type* tilted, float normfactor )
 {
     CvTreeCascadeNode* ptr;
-    CvTreeCascadeClassifier* tree;
+    //CvTreeCascadeClassifier* tree;
 
-    tree = (CvTreeCascadeClassifier*) classifier;
+    //tree = (CvTreeCascadeClassifier*) classifier;
 
 
 

apps/haartraining/cvhaartraining.cpp

@@ -169,10 +169,11 @@ CvIntHaarFeatures* icvCreateIntHaarFeatures( CvSize winsize,
     int dx = 0;
     int dy = 0;
 
+#if 0
     float factor = 1.0F;
 
     factor = ((float) winsize.width) * winsize.height / (24 * 24);
-#if 0    
+
     s0 = (int) (s0 * factor);
     s1 = (int) (s1 * factor);
     s2 = (int) (s2 * factor);
@@ -1878,7 +1879,7 @@ int icvGetHaarTraininDataFromVecCallback( CvMat* img, void* userdata )
     return 1;
 }
 
-int icvGetHaarTrainingDataFromBGCallback ( CvMat* img, void* /*userdata*/ )
+static int icvGetHaarTrainingDataFromBGCallback ( CvMat* img, void* /*userdata*/ )
 {
     if (! cvbgdata)
       return 0;
@@ -2190,15 +2191,15 @@ void cvCreateCascadeClassifier( const char* dirname,
         {
             char xml_path[1024];
             int len = (int)strlen(dirname);
-            CvHaarClassifierCascade* cascade = 0;
+            CvHaarClassifierCascade* cascade1 = 0;
             strcpy( xml_path, dirname );
             if( xml_path[len-1] == '\\' || xml_path[len-1] == '/' )
                 len--;
             strcpy( xml_path + len, ".xml" );
-            cascade = cvLoadHaarClassifierCascade( dirname, cvSize(winwidth,winheight) );
+            cascade1 = cvLoadHaarClassifierCascade( dirname, cvSize(winwidth,winheight) );
-            if( cascade )
+            if( cascade1 )
-                cvSave( xml_path, cascade );
+                cvSave( xml_path, cascade1 );
-            cvReleaseHaarClassifierCascade( &cascade );
+            cvReleaseHaarClassifierCascade( &cascade1 );
         }
     }
     else
@@ -2215,7 +2216,7 @@ void cvCreateCascadeClassifier( const char* dirname,
 
 /* tree cascade classifier */
 
-int icvNumSplits( CvStageHaarClassifier* stage )
+static int icvNumSplits( CvStageHaarClassifier* stage )
 {
     int i;
     int num;
@@ -2229,7 +2230,7 @@ int icvNumSplits( CvStageHaarClassifier* stage )
     return num;
 }
 
-void icvSetNumSamples( CvHaarTrainingData* training_data, int num )
+static void icvSetNumSamples( CvHaarTrainingData* training_data, int num )
 {
     assert( num <= training_data->maxnum );
 
@@ -2238,7 +2239,7 @@ void icvSetNumSamples( CvHaarTrainingData* training_data, int num )
     training_data->cls.cols = training_data->weights.cols = num;
 }
 
-void icvSetWeightsAndClasses( CvHaarTrainingData* training_data,
+static void icvSetWeightsAndClasses( CvHaarTrainingData* training_data,
                               int num1, float weight1, float cls1,
                               int num2, float weight2, float cls2 )
 {
@@ -2258,7 +2259,7 @@ void icvSetWeightsAndClasses( CvHaarTrainingData* training_data,
     }
 }
 
-CvMat* icvGetUsedValues( CvHaarTrainingData* training_data,
+static CvMat* icvGetUsedValues( CvHaarTrainingData* training_data,
                          int start, int num,
                          CvIntHaarFeatures* haar_features,
                          CvStageHaarClassifier* stage )
@@ -2501,7 +2502,6 @@ void cvCreateTreeCascadeClassifier( const char* dirname,
                 {
                     CvTreeCascadeNode* single_cluster;
                     CvTreeCascadeNode* multiple_clusters;
-                    CvSplit* cur_split;
                     int single_num;
 
                     icvSetNumSamples( training_data, poscount + negcount );
@@ -2674,18 +2674,19 @@ void cvCreateTreeCascadeClassifier( const char* dirname,
                     } /* try different number of clusters */
                     cvReleaseMat( &vals );
 
-                    CV_CALL( cur_split = (CvSplit*) cvAlloc( sizeof( *cur_split ) ) );
+                    CvSplit* curSplit;
-                    CV_ZERO_OBJ( cur_split );
+                    CV_CALL( curSplit = (CvSplit*) cvAlloc( sizeof( *curSplit ) ) );
+                    CV_ZERO_OBJ( curSplit );
 
-                    if( last_split ) last_split->next = cur_split;
+                    if( last_split ) last_split->next = curSplit;
-                    else first_split = cur_split;
+                    else first_split = curSplit;
-                    last_split = cur_split;
+                    last_split = curSplit;
 
-                    cur_split->single_cluster = single_cluster;
+                    curSplit->single_cluster = single_cluster;
-                    cur_split->multiple_clusters = multiple_clusters;
+                    curSplit->multiple_clusters = multiple_clusters;
-                    cur_split->num_clusters = best_clusters;
+                    curSplit->num_clusters = best_clusters;
-                    cur_split->parent = parent;
+                    curSplit->parent = parent;
-                    cur_split->single_multiple_ratio = (float) single_num / best_num;
+                    curSplit->single_multiple_ratio = (float) single_num / best_num;
                 }
 
                 if( parent ) parent = parent->next_same_level;

apps/haartraining/cvsamples.cpp

@@ -83,7 +83,7 @@
  *        cij - coeffs[i][j], coeffs[2][2] = 1
  *   (ui, vi) - rectangle vertices
  */
-void cvGetPerspectiveTransform( CvSize src_size, double quad[4][2],
+static void cvGetPerspectiveTransform( CvSize src_size, double quad[4][2],
                                 double coeffs[3][3] )
 {
     //CV_FUNCNAME( "cvWarpPerspective" );
@@ -130,7 +130,7 @@ void cvGetPerspectiveTransform( CvSize src_size, double quad[4][2],
 }
 
 /* Warps source into destination by a perspective transform */
-void cvWarpPerspective( CvArr* src, CvArr* dst, double quad[4][2] )
+static void cvWarpPerspective( CvArr* src, CvArr* dst, double quad[4][2] )
 {
     CV_FUNCNAME( "cvWarpPerspective" );
 
@@ -323,8 +323,6 @@ void cvWarpPerspective( CvArr* src, CvArr* dst, double quad[4][2] )
                 int i00, i10, i01, i11;
                 i00 = i10 = i01 = i11 = (int) fill_value;
 
-                double i = fill_value;
-
                 /* linear interpolation using 2x2 neighborhood */
                 if( isrc_x >= 0 && isrc_x <= src_size.width &&
                     isrc_y >= 0 && isrc_y <= src_size.height )
@@ -349,9 +347,8 @@ void cvWarpPerspective( CvArr* src, CvArr* dst, double quad[4][2] )
 
                 double i0 = i00 + (i10 - i00)*delta_x;
                 double i1 = i01 + (i11 - i01)*delta_x;
-                i = i0 + (i1 - i0)*delta_y;
 
-                ((uchar*)(dst_data + y * dst_step))[x] = (uchar) i;
+                ((uchar*)(dst_data + y * dst_step))[x] = (uchar) (i0 + (i1 - i0)*delta_y);
             }
             x_min += k_left;
             x_max += k_right;

apps/haartraining/performance.cpp

@@ -44,6 +44,9 @@
  *
  * Measure performance of classifier
  */
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "cv.h"
 #include "highgui.h"
 
@@ -211,7 +214,7 @@ int main( int argc, char* argv[] )
     totaltime = 0.0;
     if( info != NULL )
     {
-        int x, y, width, height;
+        int x, y;
         IplImage* img;
         int hits, missed, falseAlarms;
         int totalHits, totalMissed, totalFalseAlarms;
@@ -246,11 +249,12 @@ int main( int argc, char* argv[] )
             ref = (ObjectPos*) cvAlloc( refcount * sizeof( *ref ) );
             for( i = 0; i < refcount; i++ )
             {
-                error = (fscanf( info, "%d %d %d %d", &x, &y, &width, &height ) != 4);
+                int w, h;
+                error = (fscanf( info, "%d %d %d %d", &x, &y, &w, &h ) != 4);
                 if( error ) break;
-                ref[i].x = 0.5F * width  + x;
+                ref[i].x = 0.5F * w  + x;
-                ref[i].y = 0.5F * height + y;
+                ref[i].y = 0.5F * h + y;
-                ref[i].width = sqrtf( 0.5F * (width * width + height * height) );
+                ref[i].width = sqrtf( 0.5F * (w * w + h * h) );
                 ref[i].found = 0;
                 ref[i].neghbors = 0;
             }

apps/traincascade/HOGfeatures.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "HOGfeatures.h"
 #include "cascadeclassifier.h"
 

apps/traincascade/boost.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "boost.h"
 #include "cascadeclassifier.h"
 #include <queue>
@@ -1232,7 +1235,7 @@ void CvCascadeBoostTree::split_node_data( CvDTreeNode* node )
     data->free_node_data(node);
 }
 
-void auxMarkFeaturesInMap( const CvDTreeNode* node, Mat& featureMap)
+static void auxMarkFeaturesInMap( const CvDTreeNode* node, Mat& featureMap)
 {
     if ( node && node->split )
     {

apps/traincascade/cascadeclassifier.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "cascadeclassifier.h"
 #include <queue>
 

apps/traincascade/features.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "traincascade_features.h"
 #include "cascadeclassifier.h"
 

apps/traincascade/haarfeatures.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "haarfeatures.h"
 #include "cascadeclassifier.h"
 

apps/traincascade/imagestorage.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "cv.h"
 #include "imagestorage.h"
 #include <stdio.h>

apps/traincascade/lbpfeatures.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "lbpfeatures.h"
 #include "cascadeclassifier.h"
 

apps/traincascade/traincascade.cpp

@@ -1,3 +1,6 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+
 #include "cv.h"
 #include "cascadeclassifier.h"
 

cmake/OpenCVCompilerOptions.cmake

@@ -14,6 +14,8 @@ if(MINGW)
 endif()
 
 if(MSVC)
+  string(REGEX REPLACE "^  *| * $" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  string(REGEX REPLACE "^  *| * $" "" CMAKE_CXX_FLAGS_INIT "${CMAKE_CXX_FLAGS_INIT}")
   if(CMAKE_CXX_FLAGS STREQUAL CMAKE_CXX_FLAGS_INIT)
     # override cmake default exception handling option
     string(REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
@@ -21,73 +23,112 @@ if(MSVC)
   endif()
 endif()
 
+set(OPENCV_EXTRA_FLAGS "")
 set(OPENCV_EXTRA_C_FLAGS "")
-set(OPENCV_EXTRA_C_FLAGS_RELEASE "")
+set(OPENCV_EXTRA_CXX_FLAGS "")
-set(OPENCV_EXTRA_C_FLAGS_DEBUG "")
+set(OPENCV_EXTRA_FLAGS_RELEASE "")
+set(OPENCV_EXTRA_FLAGS_DEBUG "")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS "")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "")
 
+macro(add_extra_compiler_option option)
+  if(CMAKE_BUILD_TYPE)
+    set(CMAKE_TRY_COMPILE_CONFIGURATION ${CMAKE_BUILD_TYPE})
+  endif()
+  ocv_check_flag_support(CXX "${option}" _varname "${OPENCV_EXTRA_CXX_FLAGS} ${ARGN}")
+  if(${_varname})
+    set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS} ${option}")
+  endif()
+
+  ocv_check_flag_support(C "${option}" _varname "${OPENCV_EXTRA_C_FLAGS} ${ARGN}")
+  if(${_varname})
+    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} ${option}")
+  endif()
+endmacro()
+
 if(MINGW)
   # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40838
   # here we are trying to workaround the problem
-  include(CheckCXXCompilerFlag)
+  add_extra_compiler_option(-mstackrealign)
-  CHECK_CXX_COMPILER_FLAG(-mstackrealign HAVE_STACKREALIGN_FLAG)
+  if(NOT HAVE_CXX_MSTACKREALIGN)
-  if(HAVE_STACKREALIGN_FLAG)
+    add_extra_compiler_option(-mpreferred-stack-boundary=2)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mstackrealign")
-  else()
-    CHECK_CXX_COMPILER_FLAG(-mpreferred-stack-boundary=2 HAVE_PREFERRED_STACKBOUNDARY_FLAG)
-    if(HAVE_PREFERRED_STACKBOUNDARY_FLAG)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mstackrealign")
   endif()
 endif()
+
+if(OPENCV_CAN_BREAK_BINARY_COMPATIBILITY)
+  add_definitions(-DOPENCV_CAN_BREAK_BINARY_COMPATIBILITY)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   # High level of warnings.
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Wall")
+  add_extra_compiler_option(-Wall)
+  add_extra_compiler_option(-Werror=return-type)
+  if(OPENCV_CAN_BREAK_BINARY_COMPATIBILITY)
+    add_extra_compiler_option(-Werror=non-virtual-dtor)
+  endif()
+  add_extra_compiler_option(-Werror=address)
+  add_extra_compiler_option(-Werror=sequence-point)
+  add_extra_compiler_option(-Wformat)
+  add_extra_compiler_option(-Werror=format-security -Wformat)
+  add_extra_compiler_option(-Wmissing-declarations)
+  add_extra_compiler_option(-Wmissing-prototypes)
+  add_extra_compiler_option(-Wstrict-prototypes)
+  add_extra_compiler_option(-Wundef)
+  add_extra_compiler_option(-Winit-self)
+  add_extra_compiler_option(-Wpointer-arith)
+  add_extra_compiler_option(-Wshadow)
+
+  if(ENABLE_NOISY_WARNINGS)
+    add_extra_compiler_option(-Wcast-align)
+    add_extra_compiler_option(-Wstrict-aliasing=2)
+  else()
+    add_extra_compiler_option(-Wno-narrowing)
+    add_extra_compiler_option(-Wno-delete-non-virtual-dtor)
+    add_extra_compiler_option(-Wno-unnamed-type-template-args)
+  endif()
 
   # The -Wno-long-long is required in 64bit systems when including sytem headers.
   if(X86_64)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Wno-long-long")
+    add_extra_compiler_option(-Wno-long-long)
   endif()
 
   # We need pthread's
   if(UNIX AND NOT ANDROID)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -pthread")
+    add_extra_compiler_option(-pthread)
   endif()
 
   if(OPENCV_WARNINGS_ARE_ERRORS)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -Werror")
+    add_extra_compiler_option(-Werror)
   endif()
 
   if(X86 AND NOT MINGW64 AND NOT X86_64 AND NOT APPLE)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -march=i686")
+    add_extra_compiler_option(-march=i686)
   endif()
 
   # Other optimizations
   if(ENABLE_OMIT_FRAME_POINTER)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -fomit-frame-pointer")
+    add_extra_compiler_option(-fomit-frame-pointer)
   else()
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -fno-omit-frame-pointer")
+    add_extra_compiler_option(-fno-omit-frame-pointer)
   endif()
   if(ENABLE_FAST_MATH)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -ffast-math")
+    add_extra_compiler_option(-ffast-math)
   endif()
   if(ENABLE_POWERPC)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mcpu=G3 -mtune=G5")
+    add_extra_compiler_option("-mcpu=G3 -mtune=G5")
   endif()
   if(ENABLE_SSE)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse")
+    add_extra_compiler_option(-msse)
   endif()
   if(ENABLE_SSE2)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse2")
+    add_extra_compiler_option(-msse2)
   endif()
 
   # SSE3 and further should be disabled under MingW because it generates compiler errors
   if(NOT MINGW)
     if(ENABLE_SSE3)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse3")
+      add_extra_compiler_option(-msse3)
     endif()
 
     if(${CMAKE_OPENCV_GCC_VERSION_NUM} GREATER 402)
@@ -99,14 +140,14 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 
     if(HAVE_GCC42_OR_NEWER OR APPLE)
       if(ENABLE_SSSE3)
-        set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mssse3")
+        add_extra_compiler_option(-mssse3)
       endif()
       if(HAVE_GCC43_OR_NEWER)
         if(ENABLE_SSE41)
-           set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse4.1")
+           add_extra_compiler_option(-msse4.1)
         endif()
         if(ENABLE_SSE42)
-           set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -msse4.2")
+           add_extra_compiler_option(-msse4.2)
         endif()
       endif()
     endif()
@@ -115,38 +156,39 @@ if(CMAKE_COMPILER_IS_GNUCXX)
   if(X86 OR X86_64)
     if(NOT APPLE AND CMAKE_SIZEOF_VOID_P EQUAL 4)
       if(ENABLE_SSE2)
-         set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mfpmath=sse")# !! important - be on the same wave with x64 compilers
+        add_extra_compiler_option(-mfpmath=sse)# !! important - be on the same wave with x64 compilers
       else()
-         set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -mfpmath=387")
+        add_extra_compiler_option(-mfpmath=387)
       endif()
     endif()
   endif()
 
   # Profiling?
   if(ENABLE_PROFILING)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -pg -g")
+    add_extra_compiler_option("-pg -g")
     # turn off incompatible options
-    foreach(flags CMAKE_CXX_FLAGS CMAKE_C_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_C_FLAGS_DEBUG OPENCV_EXTRA_C_FLAGS_RELEASE)
+    foreach(flags CMAKE_CXX_FLAGS CMAKE_C_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_C_FLAGS_DEBUG
+                  OPENCV_EXTRA_FLAGS_RELEASE OPENCV_EXTRA_FLAGS_DEBUG OPENCV_EXTRA_C_FLAGS OPENCV_EXTRA_CXX_FLAGS)
       string(REPLACE "-fomit-frame-pointer" "" ${flags} "${${flags}}")
       string(REPLACE "-ffunction-sections" "" ${flags} "${${flags}}")
     endforeach()
   elseif(NOT APPLE AND NOT ANDROID)
     # Remove unreferenced functions: function level linking
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -ffunction-sections")
+    add_extra_compiler_option(-ffunction-sections)
   endif()
 
-  set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE} -DNDEBUG")
+  set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} -DNDEBUG")
-  set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
+  set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
   if(BUILD_WITH_DEBUG_INFO)
-    set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG} -ggdb3")
+    set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -ggdb3")
   endif()
 endif()
 
 if(MSVC)
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE /D _SCL_SECURE_NO_WARNINGS")
+  set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE /D _SCL_SECURE_NO_WARNINGS")
   # 64-bit portability warnings, in MSVC80
   if(MSVC80)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /Wp64")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Wp64")
   endif()
 
   if(BUILD_WITH_DEBUG_INFO)
@@ -154,38 +196,38 @@ if(MSVC)
   endif()
 
   # Remove unreferenced functions: function level linking
-  set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /Gy")
+  set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Gy")
   if(NOT MSVC_VERSION LESS 1400)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /bigobj")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /bigobj")
   endif()
   if(BUILD_WITH_DEBUG_INFO)
-    set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE} /Zi")
+    set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} /Zi")
   endif()
 
   if(NOT MSVC64)
     # 64-bit MSVC compiler uses SSE/SSE2 by default
     if(ENABLE_SSE)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE")
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE")
     endif()
     if(ENABLE_SSE2)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE2")
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE2")
     endif()
   endif()
 
   if(ENABLE_SSE3)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE3")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE3")
   endif()
   if(ENABLE_SSE4_1)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /arch:SSE4.1")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE4.1")
   endif()
 
   if(ENABLE_SSE OR ENABLE_SSE2 OR ENABLE_SSE3 OR ENABLE_SSE4_1)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /Oi")
+    set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Oi")
   endif()
 
   if(X86 OR X86_64)
     if(CMAKE_SIZEOF_VOID_P EQUAL 4 AND ENABLE_SSE2)
-      set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} /fp:fast")# !! important - be on the same wave with x64 compilers
+      set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /fp:fast")# !! important - be on the same wave with x64 compilers
     endif()
   endif()
 endif()
@@ -194,25 +236,27 @@ endif()
 if(NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX AND NOT ANDROID)
   # Android does not need these settings because they are already set by toolchain file
   set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++)
-  set(OPENCV_EXTRA_C_FLAGS "-fPIC ${OPENCV_EXTRA_C_FLAGS}")
+  set(OPENCV_EXTRA_FLAGS "-fPIC ${OPENCV_EXTRA_FLAGS}")
 endif()
 
 # Add user supplied extra options (optimization, etc...)
 # ==========================================================
-set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options")
+set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS}" CACHE INTERNAL "Extra compiler options")
-set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build")
+set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options for C sources")
-set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build")
+set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS}" CACHE INTERNAL "Extra compiler options for C++ sources")
+set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build")
+set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS}" CACHE INTERNAL "Extra linker flags")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" CACHE INTERNAL "Extra linker flags for Release build")
 set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Extra linker flags for Debug build")
 
 #combine all "extra" options
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_CXX_FLAGS}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}  ${OPENCV_EXTRA_C_FLAGS_RELEASE}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPENCV_EXTRA_C_FLAGS_RELEASE}")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OPENCV_EXTRA_C_FLAGS_DEBUG}")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${OPENCV_EXTRA_C_FLAGS_DEBUG}")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENCV_EXTRA_EXE_LINKER_FLAGS}")
 set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}")
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}")
@@ -226,6 +270,10 @@ if(MSVC)
   string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
   string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 
+  if(NOT ENABLE_NOISY_WARNINGS AND MSVC_VERSION EQUAL 1400)
+    ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4510 /wd4610 /wd4312 /wd4201 /wd4244 /wd4328 /wd4267)
+  endif()
+
   # allow extern "C" functions throw exceptions
   foreach(flags CMAKE_C_FLAGS CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)
     string(REPLACE "/EHsc-" "/EHs" ${flags} "${${flags}}")

cmake/OpenCVDetectCXXCompiler.cmake

@@ -44,6 +44,12 @@ if(MSVC AND CMAKE_C_COMPILER MATCHES "icc")
     set(CV_ICC   __INTEL_COMPILER_FOR_WINDOWS)
 endif()
 
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR (UNIX AND CV_ICC))
+  set(CV_COMPILER_IS_GNU TRUE)
+else()
+  set(CV_COMPILER_IS_GNU FALSE)
+endif()
+
 # ----------------------------------------------------------------------------
 # Detect GNU version:
 # ----------------------------------------------------------------------------

cmake/OpenCVDetectTBB.cmake

@@ -1,6 +1,6 @@
 if(ANDROID)
   add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/tbb")
-  ocv_include_directories(${TBB_INCLUDE_DIRS})
+  include_directories(SYSTEM ${TBB_INCLUDE_DIRS})
   set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} tbb)
   add_definitions(-DTBB_USE_GCC_BUILTINS=1 -D__TBB_GCC_BUILTIN_ATOMICS_PRESENT=1 -D__TBB_USE_GENERIC_DWORD_LOAD_STORE=1)
   set(HAVE_TBB 1)

cmake/OpenCVFindLibsGrfmt.cmake

@@ -61,6 +61,16 @@ if(TIFF_BIGTIFF_VERSION AND NOT TIFF_VERSION_BIG)
   set(TIFF_VERSION_BIG ${TIFF_BIGTIFF_VERSION})
 endif()
 
+if(NOT TIFF_VERSION_STRING AND TIFF_INCLUDE_DIR)
+  list(GET TIFF_INCLUDE_DIR 0 _TIFF_INCLUDE_DIR)
+  if(EXISTS "${_TIFF_INCLUDE_DIR}/tiffvers.h")
+    file(STRINGS "${_TIFF_INCLUDE_DIR}/tiffvers.h" tiff_version_str REGEX "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version .*")
+    string(REGEX REPLACE "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version +([^ \\n]*).*" "\\1" TIFF_VERSION_STRING "${tiff_version_str}")
+    unset(tiff_version_str)
+  endif()
+  unset(_TIFF_INCLUDE_DIR)
+endif()
+
 # --- libjpeg (optional) ---
 if(WITH_JPEG)
   if(BUILD_JPEG)

cmake/OpenCVFindXimea.cmake

@@ -18,7 +18,7 @@ if(WIN32)
   # Try to find the XIMEA API path in registry.
   GET_FILENAME_COMPONENT(XIMEA_PATH "[HKEY_CURRENT_USER\\Software\\XIMEA\\CamSupport\\API;Path]" ABSOLUTE)
 
-  if(XIMEA_PATH)
+  if(EXISTS XIMEA_PATH)
     set(XIMEA_FOUND 1)
 
     # set LIB folders

cmake/OpenCVGenHeaders.cmake

@@ -20,17 +20,17 @@ set(OPENCV_MOD_LIST ${OPENCV_MODULES_PUBLIC})
 ocv_list_sort(OPENCV_MOD_LIST)
 foreach(m ${OPENCV_MOD_LIST})
   string(TOUPPER "${m}" m)
-  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#define HAVE_${m} 1\n")
+  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#define HAVE_${m}\n")
 endforeach()
 
 set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}\n")
 
-set(OPENCV_MOD_LIST ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MODULES_DISABLED_AUTO})
+#set(OPENCV_MOD_LIST ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MODULES_DISABLED_AUTO} ${OPENCV_MODULES_DISABLED_FORCE})
-ocv_list_sort(OPENCV_MOD_LIST)
+#ocv_list_sort(OPENCV_MOD_LIST)
-foreach(m ${OPENCV_MOD_LIST})
+#foreach(m ${OPENCV_MOD_LIST})
-  string(TOUPPER "${m}" m)
+#  string(TOUPPER "${m}" m)
-  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#undef HAVE_${m}\n")
+#  set(OPENCV_MODULE_DEFINITIONS_CONFIGMAKE "${OPENCV_MODULE_DEFINITIONS_CONFIGMAKE}#undef HAVE_${m}\n")
-endforeach()
+#endforeach()
 
 configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/opencv_modules.hpp.in" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp")
 install(FILES "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp" DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2 COMPONENT main)

cmake/OpenCVModule.cmake

@@ -512,6 +512,8 @@ endmacro()
 macro(ocv_add_precompiled_headers the_target)
     if("${the_target}" MATCHES "^opencv_test_.*$")
         SET(pch_path "test/test_")
+  elseif("${the_target}" MATCHES "opencv_perf_gpu_cpu")
+      SET(pch_path "perf_cpu/perf_cpu_")
     elseif("${the_target}" MATCHES "^opencv_perf_.*$")
         SET(pch_path "perf/perf_")
     else()

cmake/OpenCVPCHSupport.cmake

@@ -24,10 +24,12 @@ IF(CMAKE_COMPILER_IS_GNUCXX)
     ENDIF()
 
     SET(_PCH_include_prefix "-I")
+    SET(_PCH_isystem_prefix "-isystem")
 
 ELSEIF(WIN32)
     SET(PCHSupport_FOUND TRUE) # for experimental msvc support
     SET(_PCH_include_prefix "/I")
+    SET(_PCH_isystem_prefix "/I")
 ELSE()
     SET(PCHSupport_FOUND FALSE)
 ENDIF()
@@ -50,7 +52,11 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
 
     GET_DIRECTORY_PROPERTY(DIRINC 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)
@@ -72,6 +78,7 @@ MACRO(_PCH_WRITE_PCHDEP_CXX _targetName _include_file _dephelp)
         ADD_CUSTOM_COMMAND(
           OUTPUT "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "#include \\\"${_include_file}\\\"" >  "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "int testfunction();"               >> "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "int testfunction()"                >> "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "{"                                 >> "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "    return 0;"                     >> "${${_dephelp}}"
@@ -82,6 +89,7 @@ MACRO(_PCH_WRITE_PCHDEP_CXX _targetName _include_file _dephelp)
         ADD_CUSTOM_COMMAND(
           OUTPUT "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\\"${_include_file}\\\"" >  "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "int testfunction\\(\\)\\;"         >> "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "int testfunction\\(\\)"            >> "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "{"                                 >> "${${_dephelp}}"
           COMMAND ${CMAKE_COMMAND} -E echo "    \\return 0\\;"                 >> "${${_dephelp}}"

cmake/OpenCVUtils.cmake

@@ -19,7 +19,7 @@ function(ocv_include_directories)
     if("${__abs_dir}" MATCHES "^${OpenCV_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${OpenCV_BINARY_DIR}")
       list(APPEND __add_before "${dir}")
     else()
-      include_directories(AFTER "${dir}")
+      include_directories(AFTER SYSTEM "${dir}")
     endif()
   endforeach()
   include_directories(BEFORE ${__add_before})
@@ -32,6 +32,125 @@ macro(ocv_clear_vars)
   endforeach()
 endmacro()
 
+set(OCV_COMPILER_FAIL_REGEX
+    "command line option .* is valid for .* but not for C\\+\\+" # GNU
+    "unrecognized .*option"                     # GNU
+    "unknown .*option"                          # Clang
+    "ignoring unknown option"                   # MSVC
+    "warning D9002"                             # MSVC, any lang
+    "option .*not supported"                    # Intel
+    "[Uu]nknown option"                         # HP
+    "[Ww]arning: [Oo]ption"                     # SunPro
+    "command option .* is not recognized"       # XL
+    "not supported in this configuration; ignored"       # AIX
+    "File with unknown suffix passed to linker" # PGI
+    "WARNING: unknown flag:"                    # Open64
+  )
+
+MACRO(ocv_check_compiler_flag LANG FLAG RESULT)
+  if(NOT DEFINED ${RESULT})
+    if("_${LANG}_" MATCHES "_CXX_")
+      set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx")
+      if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
+        FILE(WRITE "${_fname}" "int main() { return 0; }\n")
+      else()
+        FILE(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n")
+      endif()
+    elseif("_${LANG}_" MATCHES "_C_")
+      set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c")
+      if("${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
+        FILE(WRITE "${_fname}" "int main(void) { return 0; }\n")
+      else()
+        FILE(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n")
+      endif()
+    else()
+      unset(_fname)
+    endif()
+    if(_fname)
+      MESSAGE(STATUS "Performing Test ${RESULT}")
+      TRY_COMPILE(${RESULT}
+        ${CMAKE_BINARY_DIR}
+        "${_fname}"
+        COMPILE_DEFINITIONS "${FLAG}"
+        OUTPUT_VARIABLE OUTPUT)
+
+      FOREACH(_regex ${OCV_COMPILER_FAIL_REGEX})
+        IF("${OUTPUT}" MATCHES "${_regex}")
+          SET(${RESULT} 0)
+          break()
+        ENDIF()
+      ENDFOREACH()
+
+      IF(${RESULT})
+        SET(${RESULT} 1 CACHE INTERNAL "Test ${RESULT}")
+        MESSAGE(STATUS "Performing Test ${RESULT} - Success")
+      ELSE(${RESULT})
+        MESSAGE(STATUS "Performing Test ${RESULT} - Failed")
+        SET(${RESULT} "" CACHE INTERNAL "Test ${RESULT}")
+      ENDIF(${RESULT})
+    else()
+      SET(${RESULT} 0)
+    endif()
+  endif()
+ENDMACRO()
+
+macro(ocv_check_flag_support lang flag varname)
+  if("_${lang}_" MATCHES "_CXX_")
+    set(_lang CXX)
+  elseif("_${lang}_" MATCHES "_C_")
+    set(_lang C)
+  else()
+    set(_lang ${lang})
+  endif()
+
+  string(TOUPPER "${flag}" ${varname})
+  string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}")
+  string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}")
+
+  ocv_check_compiler_flag("${_lang}" "${ARGN} ${flag}" ${${varname}})
+endmacro()
+
+# turns off warnings
+macro(ocv_warnings_disable)
+  if(NOT ENABLE_NOISY_WARNINGS)
+    set(_flag_vars "")
+    set(_msvc_warnings "")
+    set(_gxx_warnings "")
+    foreach(arg ${ARGN})
+      if(arg MATCHES "^CMAKE_")
+        list(APPEND _flag_vars ${arg})
+      elseif(arg MATCHES "^/wd")
+        list(APPEND _msvc_warnings ${arg})
+      elseif(arg MATCHES "^-W")
+        list(APPEND _gxx_warnings ${arg})
+      endif()
+    endforeach()
+    if(MSVC AND _msvc_warnings AND _flag_vars)
+      foreach(var ${_flag_vars})
+        foreach(warning ${_msvc_warnings})
+          set(${var} "${${var}} ${warning}")
+        endforeach()
+      endforeach()
+    elseif(CV_COMPILER_IS_GNU AND _gxx_warnings AND _flag_vars)
+      foreach(var ${_flag_vars})
+        foreach(warning ${_gxx_warnings})
+          if(NOT warning MATCHES "^-Wno-")
+            string(REPLACE "${warning}" "" ${var} "${${var}}")
+            string(REPLACE "-W" "-Wno-" warning "${warning}")
+          endif()
+          ocv_check_flag_support(${var} "${warning}" _varname)
+          if(${_varname})
+            set(${var} "${${var}} ${warning}")
+          endif()
+        endforeach()
+      endforeach()
+    endif()
+    unset(_flag_vars)
+    unset(_msvc_warnings)
+    unset(_gxx_warnings)
+  endif(NOT ENABLE_NOISY_WARNINGS)
+endmacro()
+
 # Provides an option that the user can optionally select.
 # Can accept condition to control when option is available for user.
 # Usage:

modules/calib3d/perf/perf_precomp.hpp

@@ -1,3 +1,7 @@
+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#endif
+
 #ifndef __OPENCV_PERF_PRECOMP_HPP__
 #define __OPENCV_PERF_PRECOMP_HPP__
 
@@ -6,7 +10,7 @@
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 
-#if GTEST_CREATE_SHARED_LIBRARY
+#ifdef GTEST_CREATE_SHARED_LIBRARY
 #error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
 #endif
 

modules/calib3d/src/calibinit.cpp

@@ -255,7 +255,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
 
     IplImage _img;
     int check_chessboard_result;
-    int quad_count = 0, group_idx = 0, i = 0, dilations = 0;
+    int quad_count = 0, group_idx = 0, dilations = 0;
 
     img = cvGetMat( img, &stub );
     //debug_img = img;
@@ -378,7 +378,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
             cvCopy(dbg_img, dbg1_img);
             cvNamedWindow("all_quads", 1);
             // copy corners to temp array
-            for( i = 0; i < quad_count; i++ )
+            for(int i = 0; i < quad_count; i++ )
             {
                 for (int k=0; k<4; k++)
                 {
@@ -432,7 +432,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
                 cvCopy(dbg_img,dbg2_img);
                 cvNamedWindow("connected_group", 1);
                 // copy corners to temp array
-                for( i = 0; i < quad_count; i++ )
+                for(int i = 0; i < quad_count; i++ )
                 {
                     if (quads[i].group_idx == group_idx)
                         for (int k=0; k<4; k++)
@@ -472,7 +472,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
                 float sum_dist = 0;
                 int total = 0;
 
-                for( i = 0; i < n; i++ )
+                for(int i = 0; i < n; i++ )
                 {
                     int ni = 0;
                     float avgi = corner_group[i]->meanDist(&ni);
@@ -484,7 +484,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
                 if( count > 0 || (out_corner_count && -count > *out_corner_count) )
                 {
                     // copy corners to output array
-                    for( i = 0; i < n; i++ )
+                    for(int i = 0; i < n; i++ )
                         out_corners[i] = corner_group[i]->pt;
 
                     if( out_corner_count )
@@ -525,8 +525,8 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
         double dy0 = out_corners[last_row].y - out_corners[0].y;
         if( dy0 < 0 )
         {
-            int i, n = pattern_size.width*pattern_size.height;
+            int n = pattern_size.width*pattern_size.height;
-            for( i = 0; i < n/2; i++ )
+            for(int i = 0; i < n/2; i++ )
             {
                 CvPoint2D32f temp;
                 CV_SWAP(out_corners[i], out_corners[n-i-1], temp);
@@ -627,11 +627,10 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
 {
     cv::Ptr<CvMemStorage> temp_storage = cvCreateChildMemStorage( storage );
     CvSeq* stack = cvCreateSeq( 0, sizeof(*stack), sizeof(void*), temp_storage );
-    int i;
 
     // first find an interior quad
     CvCBQuad *start = NULL;
-    for (i=0; i<quad_count; i++)
+    for (int i=0; i<quad_count; i++)
     {
         if (quads[i]->count == 4)
         {
@@ -700,7 +699,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
         }
     }
 
-    for (i=col_min; i<=col_max; i++)
+    for (int i=col_min; i<=col_max; i++)
         PRINTF("HIST[%d] = %d\n", i, col_hist[i]);
 
     // analyze inner quad structure
@@ -763,7 +762,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
     // if there is an outer quad missing, fill it in
     // first order all inner quads
     int found = 0;
-    for (i=0; i<quad_count; i++)
+    for (int i=0; i<quad_count; i++)
     {
         if (quads[i]->count == 4)
         {   // ok, look at neighbors

modules/calib3d/src/calibration.cpp

@@ -1153,7 +1153,7 @@ CV_IMPL void cvFindExtrinsicCameraParams2( const CvMat* objectPoints,
                   int useExtrinsicGuess )
 {
     const int max_iter = 20;
-    Ptr<CvMat> matM, _Mxy, _m, _mn, matL, matJ;
+    Ptr<CvMat> matM, _Mxy, _m, _mn, matL;
 
     int i, count;
     double a[9], ar[9]={1,0,0,0,1,0,0,0,1}, R[9];

modules/calib3d/src/checkchessboard.cpp

@@ -55,7 +55,7 @@
 #  endif
 #endif
 
-void icvGetQuadrangleHypotheses(CvSeq* contours, std::vector<std::pair<float, int> >& quads, int class_id)
+static void icvGetQuadrangleHypotheses(CvSeq* contours, std::vector<std::pair<float, int> >& quads, int class_id)
 {
     const float min_aspect_ratio = 0.3f;
     const float max_aspect_ratio = 3.0f;
@@ -80,7 +80,7 @@ void icvGetQuadrangleHypotheses(CvSeq* contours, std::vector<std::pair<float, in
     }
 }
 
-void countClasses(const std::vector<std::pair<float, int> >& pairs, size_t idx1, size_t idx2, std::vector<int>& counts)
+static void countClasses(const std::vector<std::pair<float, int> >& pairs, size_t idx1, size_t idx2, std::vector<int>& counts)
 {
     counts.assign(2, 0);
     for(size_t i = idx1; i != idx2; i++)
@@ -89,7 +89,7 @@ void countClasses(const std::vector<std::pair<float, int> >& pairs, size_t idx1,
     }
 }
 
-bool less_pred(const std::pair<float, int>& p1, const std::pair<float, int>& p2)
+inline bool less_pred(const std::pair<float, int>& p1, const std::pair<float, int>& p2)
 {
     return p1.first < p2.first;
 }

modules/calib3d/src/circlesgrid.cpp

@@ -65,14 +65,14 @@ void drawPoints(const vector<Point2f> &points, Mat &outImage, int radius = 2,  S
 }
 #endif
 
-void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> points, const Size &patternSize, vector<Point2f> &patternPoints)
+void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> points, const Size &patternSz, vector<Point2f> &patternPoints)
 {
 #ifdef HAVE_TEGRA_OPTIMIZATION
-    if(tegra::hierarchicalClustering(points, patternSize, patternPoints))
+    if(tegra::hierarchicalClustering(points, patternSz, patternPoints))
         return;
 #endif
-    int i, j, n = (int)points.size();
+    int j, n = (int)points.size();
-    size_t pn = static_cast<size_t>(patternSize.area());
+    size_t pn = static_cast<size_t>(patternSz.area());
 
     patternPoints.clear();
     if (pn >= points.size())
@@ -84,7 +84,7 @@ void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> poin
 
     Mat dists(n, n, CV_32FC1, Scalar(0));
     Mat distsMask(dists.size(), CV_8UC1, Scalar(0));
-    for(i = 0; i < n; i++)
+    for(int i = 0; i < n; i++)
     {
         for(j = i+1; j < n; j++)
         {
@@ -122,7 +122,7 @@ void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> poin
     }
 
     //the largest cluster can have more than pn points -- we need to filter out such situations
-    if(clusters[patternClusterIdx].size() != static_cast<size_t>(patternSize.area()))
+    if(clusters[patternClusterIdx].size() != static_cast<size_t>(patternSz.area()))
     {
       return;
     }
@@ -1223,7 +1223,7 @@ void computePredecessorMatrix(const Mat &dm, int verticesCount, Mat &predecessor
   }
 }
 
-void computeShortestPath(Mat &predecessorMatrix, size_t v1, size_t v2, vector<size_t> &path)
+static void computeShortestPath(Mat &predecessorMatrix, size_t v1, size_t v2, vector<size_t> &path)
 {
   if (predecessorMatrix.at<int> ((int)v1, (int)v2) < 0)
   {
@@ -1403,7 +1403,7 @@ void CirclesGridFinder::getHoles(vector<Point2f> &outHoles) const
   }
 }
 
-bool areIndicesCorrect(Point pos, vector<vector<size_t> > *points)
+static bool areIndicesCorrect(Point pos, vector<vector<size_t> > *points)
 {
   if (pos.y < 0 || pos.x < 0)
     return false;

modules/calib3d/src/epnp.cpp

@@ -500,8 +500,7 @@ void epnp::compute_A_and_b_gauss_newton(const double * l_6x10, const double * rh
   }
 }
 
-void epnp::gauss_newton(const CvMat * L_6x10, const CvMat * Rho,
+void epnp::gauss_newton(const CvMat * L_6x10, const CvMat * Rho, double betas[4])
-			double betas[4])
 {
   const int iterations_number = 5;
 
@@ -510,7 +509,8 @@ void epnp::gauss_newton(const CvMat * L_6x10, const CvMat * Rho,
   CvMat B = cvMat(6, 1, CV_64F, b);
   CvMat X = cvMat(4, 1, CV_64F, x);
 
-  for(int k = 0; k < iterations_number; k++) {
+  for(int k = 0; k < iterations_number; k++)
+  {
     compute_A_and_b_gauss_newton(L_6x10->data.db, Rho->data.db,
     betas, &A, &B);
     qr_solve(&A, &B, &X);
@@ -524,50 +524,61 @@ void epnp::qr_solve(CvMat * A, CvMat * b, CvMat * X)
   const int nr = A->rows;
   const int nc = A->cols;
 
-  if (max_nr != 0 && max_nr < nr) {
+  if (max_nr != 0 && max_nr < nr)
+  {
     delete [] A1;
     delete [] A2;
   }
-  if (max_nr < nr) {
+  if (max_nr < nr)
+  {
     max_nr = nr;
     A1 = new double[nr];
     A2 = new double[nr];
   }
 
   double * pA = A->data.db, * ppAkk = pA;
-  for(int k = 0; k < nc; k++) {
+  for(int k = 0; k < nc; k++)
-    double * ppAik = ppAkk, eta = fabs(*ppAik);
+  {
-    for(int i = k + 1; i < nr; i++) {
+    double * ppAik1 = ppAkk, eta = fabs(*ppAik1);
-      double elt = fabs(*ppAik);
+    for(int i = k + 1; i < nr; i++)
+    {
+      double elt = fabs(*ppAik1);
       if (eta < elt) eta = elt;
-      ppAik += nc;
+      ppAik1 += nc;
     }
-	if (eta == 0) {
+    if (eta == 0)
+    {
       A1[k] = A2[k] = 0.0;
       //cerr << "God damnit, A is singular, this shouldn't happen." << endl;
       return;
-    } else {
-      double * ppAik = ppAkk, sum = 0.0, inv_eta = 1. / eta;
-      for(int i = k; i < nr; i++) {
-	*ppAik *= inv_eta;
-	sum += *ppAik * *ppAik;
-	ppAik += nc;
     }
-      double sigma = sqrt(sum);
+    else
+    {
+      double * ppAik2 = ppAkk, sum2 = 0.0, inv_eta = 1. / eta;
+      for(int i = k; i < nr; i++)
+      {
+        *ppAik2 *= inv_eta;
+        sum2 += *ppAik2 * *ppAik2;
+        ppAik2 += nc;
+      }
+      double sigma = sqrt(sum2);
       if (*ppAkk < 0)
       sigma = -sigma;
       *ppAkk += sigma;
       A1[k] = sigma * *ppAkk;
       A2[k] = -eta * sigma;
-      for(int j = k + 1; j < nc; j++) {
+      for(int j = k + 1; j < nc; j++)
+      {
         double * ppAik = ppAkk, sum = 0;
-	for(int i = k; i < nr; i++) {
+        for(int i = k; i < nr; i++)
+        {
           sum += *ppAik * ppAik[j - k];
           ppAik += nc;
         }
         double tau = sum / A1[k];
         ppAik = ppAkk;
-	for(int i = k; i < nr; i++) {
+        for(int i = k; i < nr; i++)
+        {
           ppAik[j - k] -= tau * *ppAik;
           ppAik += nc;
         }
@@ -578,15 +589,18 @@ void epnp::qr_solve(CvMat * A, CvMat * b, CvMat * X)
 
   // b <- Qt b
   double * ppAjj = pA, * pb = b->data.db;
-  for(int j = 0; j < nc; j++) {
+  for(int j = 0; j < nc; j++)
+  {
     double * ppAij = ppAjj, tau = 0;
-    for(int i = j; i < nr; i++)	{
+    for(int i = j; i < nr; i++)
+    {
       tau += *ppAij * pb[i];
       ppAij += nc;
     }
     tau /= A1[j];
     ppAij = ppAjj;
-    for(int i = j; i < nr; i++) {
+    for(int i = j; i < nr; i++)
+    {
       pb[i] -= tau * *ppAij;
       ppAij += nc;
     }
@@ -596,10 +610,12 @@ void epnp::qr_solve(CvMat * A, CvMat * b, CvMat * X)
   // X = R-1 b
   double * pX = X->data.db;
   pX[nc - 1] = pb[nc - 1] / A2[nc - 1];
-  for(int i = nc - 2; i >= 0; i--) {
+  for(int i = nc - 2; i >= 0; i--)
+  {
     double * ppAij = pA + i * nc + (i + 1), sum = 0;
 
-    for(int j = i + 1; j < nc; j++) {
+    for(int j = i + 1; j < nc; j++)
+    {
       sum += *ppAij * pX[j];
       ppAij++;
     }

modules/calib3d/src/p3p.cpp

@@ -362,20 +362,20 @@ bool p3p::jacobi_4x4(double * A, double * D, double * U)
                 if ( iter > 3 && fabs(D[i]) + eps_machine == fabs(D[i]) && fabs(D[j]) + eps_machine == fabs(D[j]) )
                     *pAij = 0.0;
                 else if (fabs(Aij) > tresh) {
-					double h = D[j] - D[i], t;
+                    double hh = D[j] - D[i], t;
-					if (fabs(h) + eps_machine == fabs(h))
+                    if (fabs(hh) + eps_machine == fabs(hh))
-						t = Aij / h;
+                        t = Aij / hh;
                     else {
-						double theta = 0.5 * h / Aij;
+                        double theta = 0.5 * hh / Aij;
                         t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
                         if (theta < 0.0) t = -t;
                     }
 
-					h = t * Aij;
+                    hh = t * Aij;
-					Z[i] -= h;
+                    Z[i] -= hh;
-					Z[j] += h;
+                    Z[j] += hh;
-					D[i] -= h;
+                    D[i] -= hh;
-					D[j] += h;
+                    D[j] += hh;
                     *pAij = 0.0;
 
                     double c = 1.0 / sqrt(1 + t * t);

modules/calib3d/src/precomp.hpp

@@ -42,10 +42,6 @@
 #ifndef __OPENCV_PRECOMP_H__
 #define __OPENCV_PRECOMP_H__
 
-#if _MSC_VER >= 1200
-#pragma warning( disable: 4251 4710 4711 4514 4996 )
-#endif
-
 #ifdef HAVE_CVCONFIG_H
 #include "cvconfig.h"
 #endif

modules/calib3d/src/quadsubpix.cpp

@@ -54,39 +54,39 @@
 namespace cv {
 
 
-void drawCircles(Mat& img, const vector<Point2f>& corners, const vector<float>& radius)
+// static void drawCircles(Mat& img, const vector<Point2f>& corners, const vector<float>& radius)
-{
+// {
-    for(size_t i = 0; i < corners.size(); i++)
+//     for(size_t i = 0; i < corners.size(); i++)
-    {
+//     {
-        circle(img, corners[i], cvRound(radius[i]), CV_RGB(255, 0, 0));
+//         circle(img, corners[i], cvRound(radius[i]), CV_RGB(255, 0, 0));
-    }
+//     }
-}
+// }
 
-int histQuantile(const Mat& hist, float quantile)
+// static int histQuantile(const Mat& hist, float quantile)
-{
+// {
-    if(hist.dims > 1) return -1; // works for 1D histograms only
+//     if(hist.dims > 1) return -1; // works for 1D histograms only
 
-    float cur_sum = 0;
+//     float cur_sum = 0;
-    float total_sum = (float)sum(hist).val[0];
+//     float total_sum = (float)sum(hist).val[0];
-    float quantile_sum = total_sum*quantile;
+//     float quantile_sum = total_sum*quantile;
-    for(int j = 0; j < hist.size[0]; j++)
+//     for(int j = 0; j < hist.size[0]; j++)
-    {
+//     {
-        cur_sum += (float)hist.at<float>(j);
+//         cur_sum += (float)hist.at<float>(j);
-        if(cur_sum > quantile_sum)
+//         if(cur_sum > quantile_sum)
-        {
+//         {
-            return j;
+//             return j;
-        }
+//         }
-    }
+//     }
 
-    return hist.size[0] - 1;
+//     return hist.size[0] - 1;
-}
+// }
 
-bool is_smaller(const std::pair<int, float>& p1, const std::pair<int, float>& p2)
+inline bool is_smaller(const std::pair<int, float>& p1, const std::pair<int, float>& p2)
 {
     return p1.second < p2.second;
 }
 
-void orderContours(const vector<vector<Point> >& contours, Point2f point, vector<std::pair<int, float> >& order)
+static void orderContours(const vector<vector<Point> >& contours, Point2f point, vector<std::pair<int, float> >& order)
 {
     order.clear();
     size_t i, j, n = contours.size();
@@ -106,16 +106,16 @@ void orderContours(const vector<vector<Point> >& contours, Point2f point, vector
 }
 
 // fit second order curve to a set of 2D points
-void fitCurve2Order(const vector<Point2f>& /*points*/, vector<float>& /*curve*/)
+inline void fitCurve2Order(const vector<Point2f>& /*points*/, vector<float>& /*curve*/)
 {
     // TBD
 }
 
-void findCurvesCross(const vector<float>& /*curve1*/, const vector<float>& /*curve2*/, Point2f& /*cross_point*/)
+inline void findCurvesCross(const vector<float>& /*curve1*/, const vector<float>& /*curve2*/, Point2f& /*cross_point*/)
 {
 }
 
-void findLinesCrossPoint(Point2f origin1, Point2f dir1, Point2f origin2, Point2f dir2, Point2f& cross_point)
+static void findLinesCrossPoint(Point2f origin1, Point2f dir1, Point2f origin2, Point2f dir2, Point2f& cross_point)
 {
     float det = dir2.x*dir1.y - dir2.y*dir1.x;
     Point2f offset = origin2 - origin1;
@@ -124,30 +124,30 @@ void findLinesCrossPoint(Point2f origin1, Point2f dir1, Point2f origin2, Point2f
     cross_point = origin1 + dir1*alpha;
 }
 
-void findCorner(const vector<Point>& contour, Point2f point, Point2f& corner)
+// static void findCorner(const vector<Point>& contour, Point2f point, Point2f& corner)
-{
+// {
-    // find the nearest point
+//     // find the nearest point
-    double min_dist = std::numeric_limits<double>::max();
+//     double min_dist = std::numeric_limits<double>::max();
-    int min_idx = -1;
+//     int min_idx = -1;
 
-    // find corner idx
+//     // find corner idx
-    for(size_t i = 0; i < contour.size(); i++)
+//     for(size_t i = 0; i < contour.size(); i++)
-    {
+//     {
-        double dist = norm(Point2f((float)contour[i].x, (float)contour[i].y) - point);
+//         double dist = norm(Point2f((float)contour[i].x, (float)contour[i].y) - point);
-        if(dist < min_dist)
+//         if(dist < min_dist)
-        {
+//         {
-            min_dist = dist;
+//             min_dist = dist;
-            min_idx = (int)i;
+//             min_idx = (int)i;
-        }
+//         }
-    }
+//     }
-    assert(min_idx >= 0);
+//     assert(min_idx >= 0);
 
-    // temporary solution, have to make something more precise
+//     // temporary solution, have to make something more precise
-    corner = contour[min_idx];
+//     corner = contour[min_idx];
-    return;
+//     return;
-}
+// }
 
-void findCorner(const vector<Point2f>& contour, Point2f point, Point2f& corner)
+static void findCorner(const vector<Point2f>& contour, Point2f point, Point2f& corner)
 {
     // find the nearest point
     double min_dist = std::numeric_limits<double>::max();
@@ -170,7 +170,7 @@ void findCorner(const vector<Point2f>& contour, Point2f point, Point2f& corner)
     return;
 }
 
-int segment_hist_max(const Mat& hist, int& low_thresh, int& high_thresh)
+static int segment_hist_max(const Mat& hist, int& low_thresh, int& high_thresh)
 {
     Mat bw;
     //const double max_bell_width = 20; // we expect two bells with width bounded above
@@ -252,7 +252,7 @@ bool cv::find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size
         int black_thresh = histQuantile(hist, 0.45f);
         int white_thresh = histQuantile(hist, 0.55f);
 #else
-        int black_thresh, white_thresh;
+        int black_thresh = 0, white_thresh = 0;
         segment_hist_max(hist, black_thresh, white_thresh);
 #endif
 

modules/calib3d/src/solvepnp.cpp

@@ -102,7 +102,7 @@ namespace cv
     {
         const int MIN_POINTS_COUNT = 4;
 
-        void project3dPoints(const Mat& points, const Mat& rvec, const Mat& tvec, Mat& modif_points)
+        static void project3dPoints(const Mat& points, const Mat& rvec, const Mat& tvec, Mat& modif_points)
         {
             modif_points.create(1, points.cols, CV_32FC3);
             Mat R(3, 3, CV_64FC1);
@@ -162,7 +162,7 @@ namespace cv
             CameraParameters camera;
         };
 
-        void pnpTask(const vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
+        static void pnpTask(const vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
                      const Parameters& params, vector<int>& inliers, Mat& rvec, Mat& tvec,
                      const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
         {
@@ -253,10 +253,10 @@ namespace cv
                     }
                 }
             }
-            PnPSolver(const Mat& objectPoints, const Mat& imagePoints, const Parameters& parameters,
+            PnPSolver(const Mat& _objectPoints, const Mat& _imagePoints, const Parameters& _parameters,
-                      Mat& rvec, Mat& tvec, vector<int>& inliers):
+                      Mat& _rvec, Mat& _tvec, vector<int>& _inliers):
-            objectPoints(objectPoints), imagePoints(imagePoints), parameters(parameters),
+            objectPoints(_objectPoints), imagePoints(_imagePoints), parameters(_parameters),
-            rvec(rvec), tvec(tvec), inliers(inliers)
+            rvec(_rvec), tvec(_tvec), inliers(_inliers)
             {
                 rvec.copyTo(initRvec);
                 tvec.copyTo(initTvec);

modules/calib3d/src/stereobm.cpp

@@ -336,7 +336,7 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
         short* costptr = cost.data ? (short*)cost.data + lofs + x : &costbuf;
         int x0 = x - wsz2 - 1, x1 = x + wsz2;
         const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
-        uchar* cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
+        cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
         hsad = hsad0 - dy0*ndisp;
         lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep;
         lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep;
@@ -463,7 +463,8 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
                 int thresh = minsad + ((minsad * uniquenessRatio) >> 8);
                 __m128i thresh8 = _mm_set1_epi16((short)(thresh + 1));
                 __m128i d1 = _mm_set1_epi16((short)(mind-1)), d2 = _mm_set1_epi16((short)(mind+1));
-                __m128i dd_16 = _mm_add_epi16(dd_8, dd_8), d8 = _mm_sub_epi16(d0_8, dd_16);
+                __m128i dd_16 = _mm_add_epi16(dd_8, dd_8);
+                 d8 = _mm_sub_epi16(d0_8, dd_16);
 
                 for( d = 0; d < ndisp; d += 16 )
                 {
@@ -492,7 +493,8 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
 
             if( 0 < mind && mind < ndisp - 1 )
             {
-                int p = sad[mind+1], n = sad[mind-1], d = p + n - 2*sad[mind] + std::abs(p - n);
+                int p = sad[mind+1], n = sad[mind-1];
+                d = p + n - 2*sad[mind] + std::abs(p - n);
                 dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*256/d : 0) + 15) >> 4);
             }
             else
@@ -583,7 +585,7 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right,
         int* costptr = cost.data ? (int*)cost.data + lofs + x : &costbuf;
         int x0 = x - wsz2 - 1, x1 = x + wsz2;
         const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
-        uchar* cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
+        cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
         hsad = hsad0 - dy0*ndisp;
         lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep;
         lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep;
@@ -662,7 +664,8 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right,
             {
             sad[-1] = sad[1];
             sad[ndisp] = sad[ndisp-2];
-            int p = sad[mind+1], n = sad[mind-1], d = p + n - 2*sad[mind] + std::abs(p - n);
+            int p = sad[mind+1], n = sad[mind-1];
+            d = p + n - 2*sad[mind] + std::abs(p - n);
             dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*256/d : 0) + 15) >> 4);
             costptr[y*coststep] = sad[mind];
             }

modules/calib3d/src/stereosgbm.cpp

@@ -773,11 +773,11 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
                     if( d < D )
                         continue;
                     d = bestDisp;
-                    int x2 = x + minX1 - d - minD;
+                    int _x2 = x + minX1 - d - minD;
-                    if( disp2cost[x2] > minS )
+                    if( disp2cost[_x2] > minS )
                     {
-                        disp2cost[x2] = (CostType)minS;
+                        disp2cost[_x2] = (CostType)minS;
-                        disp2ptr[x2] = (DispType)(d + minD);
+                        disp2ptr[_x2] = (DispType)(d + minD);
                     }
 
                     if( 0 < d && d < D-1 )
@@ -798,11 +798,11 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
                     // we round the computed disparity both towards -inf and +inf and check
                     // if either of the corresponding disparities in disp2 is consistent.
                     // This is to give the computed disparity a chance to look valid if it is.
-                    int d = disp1ptr[x];
+                    int d1 = disp1ptr[x];
-                    if( d == INVALID_DISP_SCALED )
+                    if( d1 == INVALID_DISP_SCALED )
                         continue;
-                    int _d = d >> DISP_SHIFT;
+                    int _d = d1 >> DISP_SHIFT;
-                    int d_ = (d + DISP_SCALE-1) >> DISP_SHIFT;
+                    int d_ = (d1 + DISP_SCALE-1) >> DISP_SHIFT;
                     int _x = x - _d, x_ = x - d_;
                     if( 0 <= _x && _x < width && disp2ptr[_x] >= minD && std::abs(disp2ptr[_x] - _d) > disp12MaxDiff &&
                        0 <= x_ && x_ < width && disp2ptr[x_] >= minD && std::abs(disp2ptr[x_] - d_) > disp12MaxDiff )

modules/calib3d/test/test_cameracalibration.cpp

@@ -529,14 +529,14 @@ void CV_CameraCalibrationTest::run( int start_from )
         /* ---- Reproject points to the image ---- */
         for( currImage = 0; currImage < numImages; currImage++ )
         {
-            int numPoints = etalonSize.width * etalonSize.height;
+            int nPoints = etalonSize.width * etalonSize.height;
-            project(  numPoints,
+            project(  nPoints,
-                      objectPoints + currImage * numPoints,
+                      objectPoints + currImage * nPoints,
                       rotMatrs + currImage * 9,
                       transVects + currImage * 3,
                       cameraMatrix,
                       distortion,
-                      reprojectPoints + currImage * numPoints);
+                      reprojectPoints + currImage * nPoints);
         }
 
         /* ----- Compute reprojection error ----- */

modules/calib3d/test/test_cameracalibration_artificial.cpp

@@ -221,19 +221,19 @@ protected:
         }
     }
 
-    double reprojectErrorWithoutIntrinsics(const vector<Point3f>& cb3d, const vector<Mat>& rvecs_exp, const vector<Mat>& tvecs_exp,
+    double reprojectErrorWithoutIntrinsics(const vector<Point3f>& cb3d, const vector<Mat>& _rvecs_exp, const vector<Mat>& _tvecs_exp,
         const vector<Mat>& rvecs_est, const vector<Mat>& tvecs_est)
     {
         const static Mat eye33 = Mat::eye(3, 3, CV_64F);
         const static Mat zero15 = Mat::zeros(1, 5, CV_64F);
-        Mat chessboard3D(cb3d);
+        Mat _chessboard3D(cb3d);
         vector<Point2f> uv_exp, uv_est;
         double res = 0;
 
         for(size_t i = 0; i < rvecs_exp.size(); ++i)
         {
-            projectPoints(chessboard3D, rvecs_exp[i], tvecs_exp[i], eye33, zero15, uv_exp);            
+            projectPoints(_chessboard3D, _rvecs_exp[i], _tvecs_exp[i], eye33, zero15, uv_exp);
-            projectPoints(chessboard3D, rvecs_est[i], tvecs_est[i], eye33, zero15, uv_est);
+            projectPoints(_chessboard3D, rvecs_est[i], tvecs_est[i], eye33, zero15, uv_est);
             for(size_t j = 0; j < cb3d.size(); ++j)
                 res += norm(uv_exp[i] - uv_est[i]);
         }

modules/calib3d/test/test_chesscorners.cpp

@@ -137,8 +137,7 @@ const double precise_success_error_level = 2;
 /* ///////////////////// chess_corner_test ///////////////////////// */
 void CV_ChessboardDetectorTest::run( int /*start_from */)
 {
-    cvtest::TS& ts = *this->ts;
+    ts->set_failed_test_info( cvtest::TS::OK );
-    ts.set_failed_test_info( cvtest::TS::OK );
 
     /*if (!checkByGenerator())
         return;*/
@@ -146,19 +145,19 @@ void CV_ChessboardDetectorTest::run( int /*start_from */)
     {
         case CHESSBOARD:
             checkByGenerator();
-            if (ts.get_err_code() != cvtest::TS::OK)
+            if (ts->get_err_code() != cvtest::TS::OK)
             {
                 break;
             }
 
             run_batch("negative_list.dat");
-            if (ts.get_err_code() != cvtest::TS::OK)
+            if (ts->get_err_code() != cvtest::TS::OK)
             {
                 break;
             }
 
             run_batch("chessboard_list.dat");
-            if (ts.get_err_code() != cvtest::TS::OK)
+            if (ts->get_err_code() != cvtest::TS::OK)
             {
                 break;
             }
@@ -176,9 +175,7 @@ void CV_ChessboardDetectorTest::run( int /*start_from */)
 
 void CV_ChessboardDetectorTest::run_batch( const string& filename )
 {
-    cvtest::TS& ts = *this->ts;
+    ts->printf(cvtest::TS::LOG, "\nRunning batch %s\n", filename.c_str());
-
-    ts.printf(cvtest::TS::LOG, "\nRunning batch %s\n", filename.c_str());
 //#define WRITE_POINTS 1
 #ifndef WRITE_POINTS
     double max_rough_error = 0, max_precise_error = 0;
@@ -187,13 +184,13 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
     switch( pattern )
     {
         case CHESSBOARD:
-            folder = string(ts.get_data_path()) + "cameracalibration/";
+            folder = string(ts->get_data_path()) + "cameracalibration/";
             break;
         case CIRCLES_GRID:
-            folder = string(ts.get_data_path()) + "cameracalibration/circles/";
+            folder = string(ts->get_data_path()) + "cameracalibration/circles/";
             break;
         case ASYMMETRIC_CIRCLES_GRID:
-            folder = string(ts.get_data_path()) + "cameracalibration/asymmetric_circles/";
+            folder = string(ts->get_data_path()) + "cameracalibration/asymmetric_circles/";
             break;
     }
 
@@ -202,10 +199,10 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
 
     if( !fs.isOpened() || board_list.empty() || !board_list.isSeq() || board_list.size() % 2 != 0 )
     {
-        ts.printf( cvtest::TS::LOG, "%s can not be readed or is not valid\n", (folder + filename).c_str() );
+        ts->printf( cvtest::TS::LOG, "%s can not be readed or is not valid\n", (folder + filename).c_str() );
-        ts.printf( cvtest::TS::LOG, "fs.isOpened=%d, board_list.empty=%d, board_list.isSeq=%d,board_list.size()%2=%d\n", 
+        ts->printf( cvtest::TS::LOG, "fs.isOpened=%d, board_list.empty=%d, board_list.isSeq=%d,board_list.size()%2=%d\n",
             fs.isOpened(), (int)board_list.empty(), board_list.isSeq(), board_list.size()%2);
-        ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );        
+        ts->set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
         return;
     }
 
@@ -216,7 +213,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
 
     for(int idx = 0; idx < max_idx; ++idx )
     {
-        ts.update_context( this, idx, true );
+        ts->update_context( this, idx, true );
 
         /* read the image */
         string img_file = board_list[idx * 2];
@@ -224,19 +221,19 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
 
         if( gray.empty() )
         {
-            ts.printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", img_file.c_str() );
+            ts->printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", img_file.c_str() );
-            ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
+            ts->set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
             return;
         }
 
-        string filename = folder + (string)board_list[idx * 2 + 1];
+        string _filename = folder + (string)board_list[idx * 2 + 1];
         bool doesContatinChessboard;
         Mat expected;
         {
-            FileStorage fs(filename, FileStorage::READ);
+            FileStorage fs1(_filename, FileStorage::READ);
-            fs["corners"] >> expected;
+            fs1["corners"] >> expected;
-            fs["isFound"] >> doesContatinChessboard;
+            fs1["isFound"] >> doesContatinChessboard;
-            fs.release();
+            fs1.release();
         }
         size_t count_exp = static_cast<size_t>(expected.cols * expected.rows);
         Size pattern_size = expected.size();
@@ -259,8 +256,8 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
 
         if( result ^ doesContatinChessboard || v.size() != count_exp )
         {
-            ts.printf( cvtest::TS::LOG, "chessboard is detected incorrectly in %s\n", img_file.c_str() );
+            ts->printf( cvtest::TS::LOG, "chessboard is detected incorrectly in %s\n", img_file.c_str() );
-            ts.set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
             return;
         }
 
@@ -291,19 +288,19 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
 #if 1
             if( err > precise_success_error_level )
             {
-                ts.printf( cvtest::TS::LOG, "Image %s: bad accuracy of adjusted corners %f\n", img_file.c_str(), err ); 
+                ts->printf( cvtest::TS::LOG, "Image %s: bad accuracy of adjusted corners %f\n", img_file.c_str(), err );
-                ts.set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+                ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
                 return;
             }
 #endif
-            ts.printf(cvtest::TS::LOG, "Error on %s is %f\n", img_file.c_str(), err);
+            ts->printf(cvtest::TS::LOG, "Error on %s is %f\n", img_file.c_str(), err);
             max_precise_error = MAX( max_precise_error, err );
 #endif
         }
 
 #ifdef WRITE_POINTS
         Mat mat_v(pattern_size, CV_32FC2, (void*)&v[0]);
-        FileStorage fs(filename, FileStorage::WRITE);
+        FileStorage fs(_filename, FileStorage::WRITE);
         fs << "isFound" << result;
         fs << "corners" << mat_v;
         fs.release();
@@ -312,7 +309,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
     }
 
     sum_error /= count;
-    ts.printf(cvtest::TS::LOG, "Average error is %f\n", sum_error);
+    ts->printf(cvtest::TS::LOG, "Average error is %f\n", sum_error);
 }
 
 double calcErrorMinError(const Size& cornSz, const vector<Point2f>& corners_found, const vector<Point2f>& corners_generated)

modules/calib3d/test/test_compose_rt.cpp

@@ -139,8 +139,7 @@ protected:
 
     void run(int)
     {
-        cvtest::TS& ts = *this->ts;
+        ts->set_failed_test_info(cvtest::TS::OK);
-        ts.set_failed_test_info(cvtest::TS::OK);
 
         Mat_<double> rvec1(3, 1), tvec1(3, 1), rvec2(3, 1), tvec2(3, 1);
 
@@ -164,7 +163,7 @@ protected:
 
         const double thres = 1e-5;
         if (norm(rvec3_exp, rvec3) > thres ||  norm(tvec3_exp, tvec3) > thres)
-            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
 
         const double eps = 1e-3;
         Differential diff(eps, rvec1, tvec1, rvec2, tvec2);
@@ -179,8 +178,8 @@ protected:
 
         if (norm(dr3_dr1, dr3dr1) > thres || norm(dt3_dr1, dt3dr1) > thres)
         {
-            ts.printf( cvtest::TS::LOG, "Invalid derivates by r1\n" );
+            ts->printf( cvtest::TS::LOG, "Invalid derivates by r1\n" );
-            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
         }
 
         Mat_<double> dr3_dr2, dt3_dr2;
@@ -188,8 +187,8 @@ protected:
 
         if (norm(dr3_dr2, dr3dr2) > thres || norm(dt3_dr2, dt3dr2) > thres)
         {
-            ts.printf( cvtest::TS::LOG, "Invalid derivates by r2\n" );
+            ts->printf( cvtest::TS::LOG, "Invalid derivates by r2\n" );
-            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
         }
 
         Mat_<double> dr3_dt1, dt3_dt1;
@@ -197,8 +196,8 @@ protected:
 
         if (norm(dr3_dt1, dr3dt1) > thres || norm(dt3_dt1, dt3dt1) > thres)
         {
-            ts.printf( cvtest::TS::LOG, "Invalid derivates by t1\n" );
+            ts->printf( cvtest::TS::LOG, "Invalid derivates by t1\n" );
-            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
         }
 
         Mat_<double> dr3_dt2, dt3_dt2;
@@ -206,8 +205,8 @@ protected:
 
         if (norm(dr3_dt2, dr3dt2) > thres || norm(dt3_dt2, dt3dt2) > thres)
         {
-            ts.printf( cvtest::TS::LOG, "Invalid derivates by t2\n" );
+            ts->printf( cvtest::TS::LOG, "Invalid derivates by t2\n" );
-            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
         }
     }
 };

modules/calib3d/test/test_homography.cpp

@@ -138,25 +138,25 @@ int CV_HomographyTest::check_ransac_mask_2(const Mat& original_mask, const Mat&
     return 0;
 }
 
-void CV_HomographyTest::print_information_1(int j, int N, int method, const Mat& H)
+void CV_HomographyTest::print_information_1(int j, int N, int _method, const Mat& H)
 {
     cout << endl; cout << "Checking for homography matrix sizes..." << endl; cout << endl;
     cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else  cout << "vector <Point2f>";
     cout << "   Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
     cout << "Count of points: " << N << endl; cout << endl;
-    cout << "Method: "; if (method == 0) cout << 0; else if (method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl;
+    cout << "Method: "; if (_method == 0) cout << 0; else if (_method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl;
     cout << "Homography matrix:" << endl; cout << endl;
     cout << H << endl; cout << endl;
     cout << "Number of rows: " << H.rows << "   Number of cols: " << H.cols << endl; cout << endl;
 }
 
-void CV_HomographyTest::print_information_2(int j, int N, int method, const Mat& H, const Mat& H_res, int k, double diff)
+void CV_HomographyTest::print_information_2(int j, int N, int _method, const Mat& H, const Mat& H_res, int k, double diff)
 {
     cout << endl; cout << "Checking for accuracy of homography matrix computing..." << endl; cout << endl;
     cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else  cout << "vector <Point2f>";
     cout << "   Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
     cout << "Count of points: " << N << endl; cout << endl;
-    cout << "Method: "; if (method == 0) cout << 0; else if (method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl;
+    cout << "Method: "; if (_method == 0) cout << 0; else if (_method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl;
     cout << "Original matrix:" << endl; cout << endl;
     cout << H << endl; cout << endl;
     cout << "Found matrix:" << endl; cout << endl;
@@ -178,10 +178,10 @@ void CV_HomographyTest::print_information_3(int j, int N, const Mat& mask)
     cout << "Number of rows: " << mask.rows << "   Number of cols: " << mask.cols << endl; cout << endl;
 }
 
-void CV_HomographyTest::print_information_4(int method, int j, int N, int k, int l, double diff)
+void CV_HomographyTest::print_information_4(int _method, int j, int N, int k, int l, double diff)
 {
     cout << endl; cout << "Checking for accuracy of reprojection error computing..." << endl; cout << endl;
-    cout << "Method: "; if (method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl;
+    cout << "Method: "; if (_method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl;
     cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else  cout << "vector <Point2f>";
     cout << "   Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
     cout << "Sigma of normal noise: " << sigma << endl;
@@ -192,10 +192,10 @@ void CV_HomographyTest::print_information_4(int method, int j, int N, int k, int
     cout << "Maxumum allowed difference: " << max_2diff << endl; cout << endl;
 }
 
-void CV_HomographyTest::print_information_5(int method, int j, int N, int l, double diff)
+void CV_HomographyTest::print_information_5(int _method, int j, int N, int l, double diff)
 {
     cout << endl; cout << "Checking for accuracy of reprojection error computing..." << endl; cout << endl;
-    cout << "Method: "; if (method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl;
+    cout << "Method: "; if (_method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl;
     cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else  cout << "vector <Point2f>";
     cout << "   Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
     cout << "Sigma of normal noise: " << sigma << endl;

modules/calib3d/test/test_precomp.hpp

@@ -1,3 +1,7 @@
+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#endif
+
 #ifndef __OPENCV_TEST_PRECOMP_HPP__
 #define __OPENCV_TEST_PRECOMP_HPP__
 

modules/calib3d/test/test_solvepnp_ransac.cpp

@@ -106,7 +106,7 @@ protected:
         }
     }
 
-    virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* eps, double& maxError)
+    virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* epsilon, double& maxError)
     {
         Mat rvec, tvec;
         vector<int> inliers;
@@ -136,7 +136,7 @@ protected:
         bool isTestSuccess = inliers.size() >= points.size()*0.95;
 
         double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec);
-        isTestSuccess = isTestSuccess && rvecDiff < eps[method] && tvecDiff < eps[method];
+        isTestSuccess = isTestSuccess && rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
         double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff;
         //cout << error << " " << inliers.size() << " " << eps[method] << endl;
         if (error > maxError)
@@ -147,8 +147,7 @@ protected:
 
     void run(int)
     {
-        cvtest::TS& ts = *this->ts;
+        ts->set_failed_test_info(cvtest::TS::OK);
-        ts.set_failed_test_info(cvtest::TS::OK);
 
         vector<Point3f> points;
         const int pointsCount = 500;
@@ -157,7 +156,7 @@ protected:
 
 
         const int methodsCount = 3;
-        RNG rng = ts.get_rng();
+        RNG rng = ts->get_rng();
 
 
         for (int mode = 0; mode < 2; mode++)
@@ -174,9 +173,9 @@ protected:
                 //cout <<  maxError << " " << successfulTestsCount << endl;
                 if (successfulTestsCount < 0.7*totalTestsCount)
                 {
-                    ts.printf( cvtest::TS::LOG, "Invalid accuracy for method %d, failed %d tests from %d, maximum error equals %f, distortion mode equals %d\n",
+                    ts->printf( cvtest::TS::LOG, "Invalid accuracy for method %d, failed %d tests from %d, maximum error equals %f, distortion mode equals %d\n",
                         method, totalTestsCount - successfulTestsCount, totalTestsCount, maxError, mode);
-                    ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                    ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
                 }
             }
         }
@@ -198,7 +197,7 @@ public:
 
     ~CV_solvePnP_Test() {}
 protected:
-    virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* eps, double& maxError)
+    virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* epsilon, double& maxError)
     {
         Mat rvec, tvec;
         Mat trueRvec, trueTvec;
@@ -226,7 +225,7 @@ protected:
             false, method);
 
         double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec);
-        bool isTestSuccess = rvecDiff < eps[method] && tvecDiff < eps[method];
+        bool isTestSuccess = rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
 
         double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff;
         if (error > maxError)

modules/calib3d/test/test_stereomatching.cpp

@@ -593,11 +593,11 @@ int CV_StereoMatchingTest::readDatasetsParams( FileStorage& fs )
     assert(fn.isSeq());
     for( int i = 0; i < (int)fn.size(); i+=3 )
     {
-        string name = fn[i];
+        string _name = fn[i];
         DatasetParams params;
         string sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str());
         string uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str());
-        datasetsParams[name] = params;
+        datasetsParams[_name] = params;
     }
     return cvtest::TS::OK;
 }

modules/contrib/include/opencv2/contrib/hybridtracker.hpp

@@ -86,10 +86,10 @@ struct CV_EXPORTS CvMeanShiftTrackerParams
 struct CV_EXPORTS CvFeatureTrackerParams
 {
 	enum {	SIFT = 0, SURF = 1, OPTICAL_FLOW = 2 };
-	CvFeatureTrackerParams(int feature_type = 0, int window_size = 0)
+	CvFeatureTrackerParams(int featureType = 0, int windowSize = 0)
 	{
-		feature_type = 0;
+		featureType = 0;
-		window_size = 0;
+		windowSize = 0;
 	}
 
 	int feature_type; // Feature type to use

modules/contrib/src/ba.cpp

@@ -67,15 +67,15 @@ LevMarqSparse::LevMarqSparse(int npoints, // number of points
            // 1 - point is visible for the camera, 0 - invisible
            Mat& P0, // starting vector of parameters, first cameras then points
            Mat& X_, // measurements, in order of visibility. non visible cases are skipped
-			     TermCriteria criteria, // termination criteria
+           TermCriteria _criteria, // termination criteria
 
            // callback for estimation of Jacobian matrices
-			     void (CV_CDECL * fjac)(int i, int j, Mat& point_params,
+           void (CV_CDECL * _fjac)(int i, int j, Mat& point_params,
                 Mat& cam_params, Mat& A, Mat& B, void* data),
            // callback for estimation of backprojection errors
-			     void (CV_CDECL * func)(int i, int j, Mat& point_params,
+           void (CV_CDECL * _func)(int i, int j, Mat& point_params,
                 Mat& cam_params, Mat& estim, void* data),
-			     void* data, // user-specific data passed to the callbacks
+           void* _data, // user-specific data passed to the callbacks
            BundleAdjustCallback _cb, void* _user_data
            ) {
   Vis_index = X = prevP = P = deltaP = err = JtJ_diag = S = hX = NULL;
@@ -86,7 +86,7 @@ LevMarqSparse::LevMarqSparse(int npoints, // number of points
   user_data = _user_data;
 
   run(npoints, ncameras, nPointParams, nCameraParams, nErrParams, visibility,
-      P0, X_, criteria, fjac, func, data);
+      P0, X_, _criteria, _fjac, _func, _data);
 }
 
 void LevMarqSparse::clear() {
@@ -443,9 +443,11 @@ void LevMarqSparse::optimize(CvMat &_vis) { //main function that runs minimizati
     } //U_j and ea_j computed for all j
 
     //    if (!(iters%100))
+    {
       int nviz = X->rows / num_err_param;
       double e2 = prevErrNorm*prevErrNorm, e2n = e2 / nviz;
       std::cerr<<"Iteration: "<<iters<<", normError: "<<e2<<" ("<<e2n<<")"<<std::endl;
+    }
     if (cb)
       cb(iters, prevErrNorm, user_data);
     //compute V_i  and  eb_i
@@ -676,10 +678,12 @@ void LevMarqSparse::optimize(CvMat &_vis) { //main function that runs minimizati
     errNorm > prevErrNorm )  { //step was not accepted
   //increase lambda and reject change
   lambda *= 10;
+  {
     int nviz = X->rows / num_err_param;
     double e2 = errNorm*errNorm, e2_prev = prevErrNorm*prevErrNorm;
     double e2n = e2/nviz, e2n_prev = e2_prev/nviz;
     std::cerr<<"move failed: lambda = "<<lambda<<", e2 = "<<e2<<" ("<<e2n<<") > "<<e2_prev<<" ("<<e2n_prev<<")"<<std::endl;
+  }
 
   //restore diagonal from backup
   {
@@ -730,7 +734,7 @@ void LevMarqSparse::optimize(CvMat &_vis) { //main function that runs minimizati
 
 //Utilities
 
-void fjac(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* A, CvMat* B, void* /*data*/) {
+static void fjac(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* A, CvMat* B, void* /*data*/) {
   //compute jacobian per camera parameters (i.e. Aij)
   //take i-th point 3D current coordinates
 
@@ -886,9 +890,9 @@ void fjac(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* A
     double c[4] = { g+2*p1*y_strike+4*p2*x_strike,       2*p1*x_strike,
         2*p2*y_strike,                 g+2*p2*x_strike + 4*p1*y_strike };
 
-    CvMat coeffmat = cvMat(2,2,CV_64F, c );
+    CvMat coeffmat2 = cvMat(2,2,CV_64F, c );
 
-    cvMatMul(&coeffmat, dstrike_dbig, dstrike2_dbig );
+    cvMatMul(&coeffmat2, dstrike_dbig, dstrike2_dbig );
 
     cvGEMM( &strike, dg_dbig, 1, NULL, 0, tmp, CV_GEMM_A_T );
     cvAdd( dstrike2_dbig, tmp, dstrike2_dbig );
@@ -935,7 +939,7 @@ void fjac(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* A
 #endif
 
 };
-void func(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* estim, void* /*data*/) {
+static void func(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* estim, void* /*data*/) {
   //just do projections
   CvMat _Mi;
   cvReshape( point_params, &_Mi, 3, 1 );
@@ -975,12 +979,12 @@ void func(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* e
   cvReleaseMat( &_mp2 );
 };
 
-void fjac_new(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data) {
+static void fjac_new(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data) {
   CvMat _point_params = point_params, _cam_params = cam_params, _Al = A, _Bl = B;
   fjac(i,j, &_point_params, &_cam_params, &_Al, &_Bl, data);
 };
 
-void func_new(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data)  {
+static void func_new(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data)  {
   CvMat _point_params = point_params, _cam_params = cam_params, _estim = estim;
   func(i,j,&_point_params,&_cam_params,&_estim,data);
 };

modules/contrib/src/basicretinafilter.cpp

@@ -180,13 +180,13 @@ void BasicRetinaFilter::setLPfilterParameters(const float beta, const float tau,
 	}
 
 	float _temp =  (1.0f+_beta)/(2.0f*_mu*_alpha);
-	float _a = _filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
+	float a = _filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
-	_filteringCoeficientsTable[1+tableOffset]=(1.0f-_a)*(1.0f-_a)*(1.0f-_a)*(1.0f-_a)/(1.0f+_beta);
+	_filteringCoeficientsTable[1+tableOffset]=(1.0f-a)*(1.0f-a)*(1.0f-a)*(1.0f-a)/(1.0f+_beta);
 	_filteringCoeficientsTable[2+tableOffset] =tau;
 
-	//std::cout<<"BasicRetinaFilter::normal:"<<(1.0-_a)*(1.0-_a)*(1.0-_a)*(1.0-_a)/(1.0+_beta)<<" -> old:"<<(1-_a)*(1-_a)*(1-_a)*(1-_a)/(1+_beta)<<std::endl;
+	//std::cout<<"BasicRetinaFilter::normal:"<<(1.0-a)*(1.0-a)*(1.0-a)*(1.0-a)/(1.0+_beta)<<" -> old:"<<(1-a)*(1-a)*(1-a)*(1-a)/(1+_beta)<<std::endl;
 
-	//std::cout<<"BasicRetinaFilter::_a="<<_a<<", gain="<<_filteringCoeficientsTable[1+tableOffset]<<", tau="<<tau<<std::endl;
+	//std::cout<<"BasicRetinaFilter::a="<<a<<", gain="<<_filteringCoeficientsTable[1+tableOffset]<<", tau="<<tau<<std::endl;
 }
 
 void BasicRetinaFilter::setProgressiveFilterConstants_CentredAccuracy(const float beta, const float tau, const float alpha0, const unsigned int filterIndex)
@@ -210,8 +210,8 @@ void BasicRetinaFilter::setProgressiveFilterConstants_CentredAccuracy(const floa
 
 	float _alpha=0.8f;
 	float _temp =  (1.0f+_beta)/(2.0f*_mu*_alpha);
-	float _a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
+	float a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
-	_filteringCoeficientsTable[tableOffset+1]=(1.0f-_a)*(1.0f-_a)*(1.0f-_a)*(1.0f-_a)/(1.0f+_beta);
+	_filteringCoeficientsTable[tableOffset+1]=(1.0f-a)*(1.0f-a)*(1.0f-a)*(1.0f-a)/(1.0f+_beta);
 	_filteringCoeficientsTable[tableOffset+2] =tau;
 
 	float commonFactor=alpha0/(float)sqrt(_halfNBcolumns*_halfNBcolumns+_halfNBrows*_halfNBrows+1.0f);
@@ -266,8 +266,8 @@ void BasicRetinaFilter::setProgressiveFilterConstants_CustomAccuracy(const float
 	}
 	unsigned int tableOffset=filterIndex*3;
 	float _temp =  (1.0f+_beta)/(2.0f*_mu*_alpha);
-	float _a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
+	float a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
-	_filteringCoeficientsTable[tableOffset+1]=(1.0f-_a)*(1.0f-_a)*(1.0f-_a)*(1.0f-_a)/(1.0f+_beta);
+	_filteringCoeficientsTable[tableOffset+1]=(1.0f-a)*(1.0f-a)*(1.0f-a)*(1.0f-a)/(1.0f+_beta);
 	_filteringCoeficientsTable[tableOffset+2] =tau;
 
 	//memset(_progressiveSpatialConstant, 255, _filterOutput.getNBpixels());
@@ -335,7 +335,7 @@ void BasicRetinaFilter::_localLuminanceAdaptation(const float *inputFrame, const
 	{
 		float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
 		// TODO : the following line can lead to a divide by zero ! A small offset is added, take care if the offset is too large in case of High Dynamic Range images which can use very small values...		
-		*(outputFramePTR++) = (_maxInputValue+X0)**inputFramePTR/(*inputFramePTR +X0+0.00000000001);
+		*(outputFramePTR++) = (_maxInputValue+X0)**inputFramePTR/(*inputFramePTR +X0+0.00000000001f);
 		//std::cout<<"BasicRetinaFilter::inputFrame[IDpixel]=%f, X0=%f, outputFrame[IDpixel]=%f\n", inputFrame[IDpixel], X0, outputFrame[IDpixel]);
 	}
 }

modules/contrib/src/chamfermatching.cpp

@@ -81,6 +81,7 @@ private:
     {
     public:
         virtual ImageIterator* iterator() const = 0;
+        virtual ~ImageRange() {}
     };
 
     // Sliding window

modules/contrib/src/colormap.cpp

@@ -18,7 +18,7 @@
 #include "precomp.hpp"
 #include <iostream>
 
-#if defined _MSC_VER && _MSC_VER >= 1400
+#ifdef _MSC_VER
 #pragma warning( disable: 4305 )
 #endif
 
@@ -60,7 +60,7 @@ static Mat sortMatrixRowsByIndices(InputArray src, InputArray indices)
 }
 
 
-Mat argsort(InputArray _src, bool ascending=true)
+static Mat argsort(InputArray _src, bool ascending=true)
 {
     Mat src = _src.getMat();
     if (src.rows != 1 && src.cols != 1)

modules/contrib/src/colortracker.cpp

@@ -68,10 +68,10 @@ void CvMeanShiftTracker::newTrackingWindow(Mat image, Rect selection)
 	mixChannels(&hsv, 1, &hue, 1, channels, 2);
 
 	Mat roi(hue, selection);
-	Mat maskroi(mask, selection);
+	Mat mskroi(mask, selection);
 	int ch[] = {0, 1};
 	int chsize[] = {32, 32};
-	calcHist(&roi, 1, ch, maskroi, hist, 1, chsize, ranges);
+	calcHist(&roi, 1, ch, mskroi, hist, 1, chsize, ranges);
 	normalize(hist, hist, 0, 255, CV_MINMAX);
 
 	prev_trackwindow = selection;

modules/contrib/src/detection_based_tracker.cpp

@@ -3,7 +3,7 @@
 
 #define DEBUGLOGS 1
 
-#if ANDROID
+#ifdef ANDROID
 #include <android/log.h>
 #define LOG_TAG "OBJECT_DETECTOR"
 #define LOGD0(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))

modules/contrib/src/facerec.cpp

@@ -100,15 +100,15 @@ public:
     using FaceRecognizer::load;
 
     // Initializes an empty Eigenfaces model.
-    Eigenfaces(int num_components = 0) :
+    Eigenfaces(int numComponents = 0) :
-        _num_components(num_components) { }
+        _num_components(numComponents) { }
 
     // Initializes and computes an Eigenfaces model with images in src and
     // corresponding labels in labels. num_components will be kept for
     // classification.
     Eigenfaces(InputArray src, InputArray labels,
-            int num_components = 0) :
+            int numComponents = 0) :
-        _num_components(num_components) {
+        _num_components(numComponents) {
         train(src, labels);
     }
 
@@ -157,16 +157,16 @@ public:
     using FaceRecognizer::load;
 
     // Initializes an empty Fisherfaces model.
-    Fisherfaces(int num_components = 0) :
+    Fisherfaces(int numComponents = 0) :
-        _num_components(num_components) {}
+        _num_components(numComponents) {}
 
     // Initializes and computes a Fisherfaces model with images in src and
     // corresponding labels in labels. num_components will be kept for
     // classification.
     Fisherfaces(InputArray src,
             InputArray labels,
-            int num_components = 0) :
+            int numComponents = 0) :
-        _num_components(num_components) {
+        _num_components(numComponents) {
         train(src, labels);
     }
 
@@ -228,11 +228,11 @@ public:
     //
     // radius, neighbors are used in the local binary patterns creation.
     // grid_x, grid_y control the grid size of the spatial histograms.
-    LBPH(int radius=1, int neighbors=8, int grid_x=8, int grid_y=8) :
+    LBPH(int radius_=1, int neighbors_=8, int grid_x_=8, int grid_y_=8) :
-        _grid_x(grid_x),
+        _grid_x(grid_x_),
-        _grid_y(grid_y),
+        _grid_y(grid_y_),
-        _radius(radius),
+        _radius(radius_),
-        _neighbors(neighbors) {}
+        _neighbors(neighbors_) {}
 
     // Initializes and computes this LBPH Model. The current implementation is
     // rather fixed as it uses the Extended Local Binary Patterns per default.
@@ -241,12 +241,12 @@ public:
     // (grid_x=8), (grid_y=8) controls the grid size of the spatial histograms.
     LBPH(InputArray src,
             InputArray labels,
-            int radius=1, int neighbors=8,
+            int radius_=1, int neighbors_=8,
-            int grid_x=8, int grid_y=8) :
+            int grid_x_=8, int grid_y_=8) :
-                _grid_x(grid_x),
+                _grid_x(grid_x_),
-                _grid_y(grid_y),
+                _grid_y(grid_y_),
-                _radius(radius),
+                _radius(radius_),
-                _neighbors(neighbors) {
+                _neighbors(neighbors_) {
         train(src, labels);
     }
 

modules/contrib/src/gencolors.cpp

@@ -46,7 +46,7 @@
 
 using namespace cv;
 
-void downsamplePoints( const Mat& src, Mat& dst, size_t count )
+static void downsamplePoints( const Mat& src, Mat& dst, size_t count )
 {
     CV_Assert( count >= 2 );
     CV_Assert( src.cols == 1 || src.rows == 1 );

modules/contrib/src/lda.cpp

@@ -46,36 +46,54 @@ inline vector<_Tp> remove_dups(const vector<_Tp>& src) {
 static Mat argsort(InputArray _src, bool ascending=true)
 {
     Mat src = _src.getMat();
-    if (src.rows != 1 && src.cols != 1)
+    if (src.rows != 1 && src.cols != 1) {
-        CV_Error(CV_StsBadArg, "cv::argsort only sorts 1D matrices.");
+    	string error_message = "Wrong shape of input matrix! Expected a matrix with one row or column.";
+    	CV_Error(CV_StsBadArg, error_message);
+    }
     int flags = CV_SORT_EVERY_ROW+(ascending ? CV_SORT_ASCENDING : CV_SORT_DESCENDING);
     Mat sorted_indices;
     sortIdx(src.reshape(1,1),sorted_indices,flags);
     return sorted_indices;
 }
 
-static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0)
+static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0) {
-{
+    // make sure the input data is a vector of matrices or vector of vector
+    if(src.kind() != _InputArray::STD_VECTOR_MAT && src.kind() != _InputArray::STD_VECTOR_VECTOR) {
+    	string error_message = "The data is expected as InputArray::STD_VECTOR_MAT (a std::vector<Mat>) or _InputArray::STD_VECTOR_VECTOR (a std::vector< vector<...> >).";
+        CV_Error(CV_StsBadArg, error_message);
+    }
     // number of samples
-    int n = (int) src.total();
+    size_t n = src.total();
-    // return empty matrix if no data given
+    // return empty matrix if no matrices given
     if(n == 0)
         return Mat();
-    // dimensionality of samples
+    // dimensionality of (reshaped) samples
-    int d = (int)src.getMat(0).total();
+    size_t d = src.getMat(0).total();
     // create data matrix
-    Mat data(n, d, rtype);
+    Mat data((int)n, (int)d, rtype);
-    // copy data
+    // now copy data
-    for(int i = 0; i < n; i++) {
+    for(int i = 0; i < (int)n; i++) {
+        // make sure data can be reshaped, throw exception if not!
+        if(src.getMat(i).total() != d) {
+            string error_message = format("Wrong number of elements in matrix #%d! Expected %d was %d.", i, (int)d, (int)src.getMat(i).total());
+            CV_Error(CV_StsBadArg, error_message);
+        }
+        // get a hold of the current row
         Mat xi = data.row(i);
+        // make reshape happy by cloning for non-continuous matrices
+        if(src.getMat(i).isContinuous()) {
             src.getMat(i).reshape(1, 1).convertTo(xi, rtype, alpha, beta);
+        } else {
+            src.getMat(i).clone().reshape(1, 1).convertTo(xi, rtype, alpha, beta);
+        }
     }
     return data;
 }
 
-void sortMatrixColumnsByIndices(InputArray _src, InputArray _indices, OutputArray _dst) {
+static void sortMatrixColumnsByIndices(InputArray _src, InputArray _indices, OutputArray _dst) {
-    if(_indices.getMat().type() != CV_32SC1)
+    if(_indices.getMat().type() != CV_32SC1) {
         CV_Error(CV_StsUnsupportedFormat, "cv::sortColumnsByIndices only works on integer indices!");
+    }
     Mat src = _src.getMat();
     vector<int> indices = _indices.getMat();
     _dst.create(src.rows, src.cols, src.type());
@@ -87,7 +105,7 @@ void sortMatrixColumnsByIndices(InputArray _src, InputArray _indices, OutputArra
     }
 }
 
-Mat sortMatrixColumnsByIndices(InputArray src, InputArray indices) {
+static Mat sortMatrixColumnsByIndices(InputArray src, InputArray indices) {
     Mat dst;
     sortMatrixColumnsByIndices(src, indices, dst);
     return dst;
@@ -153,31 +171,44 @@ static bool isSymmetric(InputArray src, double eps=1e-16)
 
 
 //------------------------------------------------------------------------------
-// subspace::project
+// cv::subspaceProject
 //------------------------------------------------------------------------------
-Mat subspaceProject(InputArray _W, InputArray _mean, InputArray _src)
+Mat subspaceProject(InputArray _W, InputArray _mean, InputArray _src) {
-{
     // get data matrices
     Mat W = _W.getMat();
     Mat mean = _mean.getMat();
     Mat src = _src.getMat();
+    // get number of samples and dimension
+    int n = src.rows;
+    int d = src.cols;
+    // make sure the data has the correct shape
+    if(W.rows != d) {
+        string error_message = format("Wrong shapes for given matrices. Was size(src) = (%d,%d), size(W) = (%d,%d).", src.rows, src.cols, W.rows, W.cols);
+        CV_Error(CV_StsBadArg, error_message);
+    }
+    // make sure mean is correct if not empty
+    if(!mean.empty() && (mean.total() != (size_t) d)) {
+        string error_message = format("Wrong mean shape for the given data matrix. Expected %d, but was %d.", d, mean.total());
+        CV_Error(CV_StsBadArg, error_message);
+    }
     // create temporary matrices
     Mat X, Y;
-    // copy data & make sure we are using the correct type
+    // make sure you operate on correct type
     src.convertTo(X, W.type());
-    // get number of samples and dimension
+    // safe to do, because of above assertion
-    int n = X.rows;
+    if(!mean.empty()) {
-    int d = X.cols;
+    	for(int i=0; i<n; i++) {
-    // center the data if correct aligned sample mean is given
+    		Mat r_i = X.row(i);
-    if(mean.total() == (size_t)d)
+    		subtract(r_i, mean.reshape(1,1), r_i);
-        subtract(X, repeat(mean.reshape(1,1), n, 1), X);
+    	}
+    }
     // finally calculate projection as Y = (X-mean)*W
     gemm(X, W, 1.0, Mat(), 0.0, Y);
     return Y;
 }
 
 //------------------------------------------------------------------------------
-// subspace::reconstruct
+// cv::subspaceReconstruct
 //------------------------------------------------------------------------------
 Mat subspaceReconstruct(InputArray _W, InputArray _mean, InputArray _src)
 {
@@ -185,16 +216,32 @@ Mat subspaceReconstruct(InputArray _W, InputArray _mean, InputArray _src)
     Mat W = _W.getMat();
     Mat mean = _mean.getMat();
     Mat src = _src.getMat();
-    // get number of samples
+    // get number of samples and dimension
     int n = src.rows;
+    int d = src.cols;
+    // make sure the data has the correct shape
+    if(W.cols != d) {
+        string error_message = format("Wrong shapes for given matrices. Was size(src) = (%d,%d), size(W) = (%d,%d).", src.rows, src.cols, W.rows, W.cols);
+        CV_Error(CV_StsBadArg, error_message);
+    }
+    // make sure mean is correct if not empty
+    if(!mean.empty() && (mean.total() != (size_t) W.rows)) {
+        string error_message = format("Wrong mean shape for the given eigenvector matrix. Expected %d, but was %d.", W.cols, mean.total());
+        CV_Error(CV_StsBadArg, error_message);
+    }
     // initalize temporary matrices
     Mat X, Y;
     // copy data & make sure we are using the correct type
     src.convertTo(Y, W.type());
     // calculate the reconstruction
     gemm(Y, W, 1.0, Mat(), 0.0, X, GEMM_2_T);
-    if(mean.total() == (size_t) X.cols)
+    // safe to do because of above assertion
-        add(X, repeat(mean.reshape(1,1), n, 1), X);
+    if(!mean.empty()) {
+    	for(int i=0; i<n; i++) {
+    		Mat r_i = X.row(i);
+    		add(r_i, mean.reshape(1,1), r_i);
+    	}
+    }
     return X;
 }
 
@@ -235,19 +282,19 @@ private:
 
     // Allocates memory.
     template<typename _Tp>
-    _Tp **alloc_2d(int m, int n) {
+    _Tp **alloc_2d(int m, int _n) {
         _Tp **arr = new _Tp*[m];
         for (int i = 0; i < m; i++)
-            arr[i] = new _Tp[n];
+            arr[i] = new _Tp[_n];
         return arr;
     }
 
     // Allocates memory.
     template<typename _Tp>
-    _Tp **alloc_2d(int m, int n, _Tp val) {
+    _Tp **alloc_2d(int m, int _n, _Tp val) {
-        _Tp **arr = alloc_2d<_Tp> (m, n);
+        _Tp **arr = alloc_2d<_Tp> (m, _n);
         for (int i = 0; i < m; i++) {
-            for (int j = 0; j < n; j++) {
+            for (int j = 0; j < _n; j++) {
                 arr[i][j] = val;
             }
         }
@@ -255,17 +302,17 @@ private:
     }
 
     void cdiv(double xr, double xi, double yr, double yi) {
-        double r, d;
+        double r, dv;
         if (std::abs(yr) > std::abs(yi)) {
             r = yi / yr;
-            d = yr + r * yi;
+            dv = yr + r * yi;
-            cdivr = (xr + r * xi) / d;
+            cdivr = (xr + r * xi) / dv;
-            cdivi = (xi - r * xr) / d;
+            cdivi = (xi - r * xr) / dv;
         } else {
             r = yr / yi;
-            d = yi + r * yr;
+            dv = yi + r * yr;
-            cdivr = (r * xr + xi) / d;
+            cdivr = (r * xr + xi) / dv;
-            cdivi = (r * xi - xr) / d;
+            cdivi = (r * xi - xr) / dv;
         }
     }
 
@@ -280,7 +327,7 @@ private:
 
         // Initialize
         int nn = this->n;
-        int n = nn - 1;
+        int n1 = nn - 1;
         int low = 0;
         int high = nn - 1;
         double eps = pow(2.0, -52.0);
@@ -302,10 +349,10 @@ private:
 
         // Outer loop over eigenvalue index
         int iter = 0;
-        while (n >= low) {
+        while (n1 >= low) {
 
             // Look for single small sub-diagonal element
-            int l = n;
+            int l = n1;
             while (l > low) {
                 s = std::abs(H[l - 1][l - 1]) + std::abs(H[l][l]);
                 if (s == 0.0) {
@@ -320,23 +367,23 @@ private:
             // Check for convergence
             // One root found
 
-            if (l == n) {
+            if (l == n1) {
-                H[n][n] = H[n][n] + exshift;
+                H[n1][n1] = H[n1][n1] + exshift;
-                d[n] = H[n][n];
+                d[n1] = H[n1][n1];
-                e[n] = 0.0;
+                e[n1] = 0.0;
-                n--;
+                n1--;
                 iter = 0;
 
                 // Two roots found
 
-            } else if (l == n - 1) {
+            } else if (l == n1 - 1) {
-                w = H[n][n - 1] * H[n - 1][n];
+                w = H[n1][n1 - 1] * H[n1 - 1][n1];
-                p = (H[n - 1][n - 1] - H[n][n]) / 2.0;
+                p = (H[n1 - 1][n1 - 1] - H[n1][n1]) / 2.0;
                 q = p * p + w;
                 z = sqrt(std::abs(q));
-                H[n][n] = H[n][n] + exshift;
+                H[n1][n1] = H[n1][n1] + exshift;
-                H[n - 1][n - 1] = H[n - 1][n - 1] + exshift;
+                H[n1 - 1][n1 - 1] = H[n1 - 1][n1 - 1] + exshift;
-                x = H[n][n];
+                x = H[n1][n1];
 
                 // Real pair
 
@@ -346,14 +393,14 @@ private:
                     } else {
                         z = p - z;
                     }
-                    d[n - 1] = x + z;
+                    d[n1 - 1] = x + z;
-                    d[n] = d[n - 1];
+                    d[n1] = d[n1 - 1];
                     if (z != 0.0) {
-                        d[n] = x - w / z;
+                        d[n1] = x - w / z;
                     }
-                    e[n - 1] = 0.0;
+                    e[n1 - 1] = 0.0;
-                    e[n] = 0.0;
+                    e[n1] = 0.0;
-                    x = H[n][n - 1];
+                    x = H[n1][n1 - 1];
                     s = std::abs(x) + std::abs(z);
                     p = x / s;
                     q = z / s;
@@ -363,37 +410,37 @@ private:
 
                     // Row modification
 
-                    for (int j = n - 1; j < nn; j++) {
+                    for (int j = n1 - 1; j < nn; j++) {
-                        z = H[n - 1][j];
+                        z = H[n1 - 1][j];
-                        H[n - 1][j] = q * z + p * H[n][j];
+                        H[n1 - 1][j] = q * z + p * H[n1][j];
-                        H[n][j] = q * H[n][j] - p * z;
+                        H[n1][j] = q * H[n1][j] - p * z;
                     }
 
                     // Column modification
 
-                    for (int i = 0; i <= n; i++) {
+                    for (int i = 0; i <= n1; i++) {
-                        z = H[i][n - 1];
+                        z = H[i][n1 - 1];
-                        H[i][n - 1] = q * z + p * H[i][n];
+                        H[i][n1 - 1] = q * z + p * H[i][n1];
-                        H[i][n] = q * H[i][n] - p * z;
+                        H[i][n1] = q * H[i][n1] - p * z;
                     }
 
                     // Accumulate transformations
 
                     for (int i = low; i <= high; i++) {
-                        z = V[i][n - 1];
+                        z = V[i][n1 - 1];
-                        V[i][n - 1] = q * z + p * V[i][n];
+                        V[i][n1 - 1] = q * z + p * V[i][n1];
-                        V[i][n] = q * V[i][n] - p * z;
+                        V[i][n1] = q * V[i][n1] - p * z;
                     }
 
                     // Complex pair
 
                 } else {
-                    d[n - 1] = x + p;
+                    d[n1 - 1] = x + p;
-                    d[n] = x + p;
+                    d[n1] = x + p;
-                    e[n - 1] = z;
+                    e[n1 - 1] = z;
-                    e[n] = -z;
+                    e[n1] = -z;
                 }
-                n = n - 2;
+                n1 = n1 - 2;
                 iter = 0;
 
                 // No convergence yet
@@ -402,22 +449,22 @@ private:
 
                 // Form shift
 
-                x = H[n][n];
+                x = H[n1][n1];
                 y = 0.0;
                 w = 0.0;
-                if (l < n) {
+                if (l < n1) {
-                    y = H[n - 1][n - 1];
+                    y = H[n1 - 1][n1 - 1];
-                    w = H[n][n - 1] * H[n - 1][n];
+                    w = H[n1][n1 - 1] * H[n1 - 1][n1];
                 }
 
                 // Wilkinson's original ad hoc shift
 
                 if (iter == 10) {
                     exshift += x;
-                    for (int i = low; i <= n; i++) {
+                    for (int i = low; i <= n1; i++) {
                         H[i][i] -= x;
                     }
-                    s = std::abs(H[n][n - 1]) + std::abs(H[n - 1][n - 2]);
+                    s = std::abs(H[n1][n1 - 1]) + std::abs(H[n1 - 1][n1 - 2]);
                     x = y = 0.75 * s;
                     w = -0.4375 * s * s;
                 }
@@ -433,7 +480,7 @@ private:
                             s = -s;
                         }
                         s = x - w / ((y - x) / 2.0 + s);
-                        for (int i = low; i <= n; i++) {
+                        for (int i = low; i <= n1; i++) {
                             H[i][i] -= s;
                         }
                         exshift += s;
@@ -444,7 +491,7 @@ private:
                 iter = iter + 1; // (Could check iteration count here.)
 
                 // Look for two consecutive small sub-diagonal elements
-                int m = n - 2;
+                int m = n1 - 2;
                 while (m >= l) {
                     z = H[m][m];
                     r = x - z;
@@ -467,7 +514,7 @@ private:
                     m--;
                 }
 
-                for (int i = m + 2; i <= n; i++) {
+                for (int i = m + 2; i <= n1; i++) {
                     H[i][i - 2] = 0.0;
                     if (i > m + 2) {
                         H[i][i - 3] = 0.0;
@@ -476,8 +523,8 @@ private:
 
                 // Double QR step involving rows l:n and columns m:n
 
-                for (int k = m; k <= n - 1; k++) {
+                for (int k = m; k <= n1 - 1; k++) {
-                    bool notlast = (k != n - 1);
+                    bool notlast = (k != n1 - 1);
                     if (k != m) {
                         p = H[k][k - 1];
                         q = H[k + 1][k - 1];
@@ -523,7 +570,7 @@ private:
 
                         // Column modification
 
-                        for (int i = 0; i <= min(n, k + 3); i++) {
+                        for (int i = 0; i <= min(n1, k + 3); i++) {
                             p = x * H[i][k] + y * H[i][k + 1];
                             if (notlast) {
                                 p = p + z * H[i][k + 2];
@@ -547,7 +594,7 @@ private:
                     } // (s != 0)
                 } // k loop
             } // check convergence
-        } // while (n >= low)
+        } // while (n1 >= low)
 
         // Backsubstitute to find vectors of upper triangular form
 
@@ -555,20 +602,20 @@ private:
             return;
         }
 
-        for (n = nn - 1; n >= 0; n--) {
+        for (n1 = nn - 1; n1 >= 0; n1--) {
-            p = d[n];
+            p = d[n1];
-            q = e[n];
+            q = e[n1];
 
             // Real vector
 
             if (q == 0) {
-                int l = n;
+                int l = n1;
-                H[n][n] = 1.0;
+                H[n1][n1] = 1.0;
-                for (int i = n - 1; i >= 0; i--) {
+                for (int i = n1 - 1; i >= 0; i--) {
                     w = H[i][i] - p;
                     r = 0.0;
-                    for (int j = l; j <= n; j++) {
+                    for (int j = l; j <= n1; j++) {
-                        r = r + H[i][j] * H[j][n];
+                        r = r + H[i][j] * H[j][n1];
                     }
                     if (e[i] < 0.0) {
                         z = w;
@@ -577,9 +624,9 @@ private:
                         l = i;
                         if (e[i] == 0.0) {
                             if (w != 0.0) {
-                                H[i][n] = -r / w;
+                                H[i][n1] = -r / w;
                             } else {
-                                H[i][n] = -r / (eps * norm);
+                                H[i][n1] = -r / (eps * norm);
                             }
 
                             // Solve real equations
@@ -589,49 +636,47 @@ private:
                             y = H[i + 1][i];
                             q = (d[i] - p) * (d[i] - p) + e[i] * e[i];
                             t = (x * s - z * r) / q;
-                            H[i][n] = t;
+                            H[i][n1] = t;
                             if (std::abs(x) > std::abs(z)) {
-                                H[i + 1][n] = (-r - w * t) / x;
+                                H[i + 1][n1] = (-r - w * t) / x;
                             } else {
-                                H[i + 1][n] = (-s - y * t) / z;
+                                H[i + 1][n1] = (-s - y * t) / z;
                             }
                         }
 
                         // Overflow control
 
-                        t = std::abs(H[i][n]);
+                        t = std::abs(H[i][n1]);
                         if ((eps * t) * t > 1) {
-                            for (int j = i; j <= n; j++) {
+                            for (int j = i; j <= n1; j++) {
-                                H[j][n] = H[j][n] / t;
+                                H[j][n1] = H[j][n1] / t;
                             }
                         }
                     }
                 }
-                
                 // Complex vector
-                
             } else if (q < 0) {
-                int l = n - 1;
+                int l = n1 - 1;
 
                 // Last vector component imaginary so matrix is triangular
 
-                if (std::abs(H[n][n - 1]) > std::abs(H[n - 1][n])) {
+                if (std::abs(H[n1][n1 - 1]) > std::abs(H[n1 - 1][n1])) {
-                    H[n - 1][n - 1] = q / H[n][n - 1];
+                    H[n1 - 1][n1 - 1] = q / H[n1][n1 - 1];
-                    H[n - 1][n] = -(H[n][n] - p) / H[n][n - 1];
+                    H[n1 - 1][n1] = -(H[n1][n1] - p) / H[n1][n1 - 1];
                 } else {
-                    cdiv(0.0, -H[n - 1][n], H[n - 1][n - 1] - p, q);
+                    cdiv(0.0, -H[n1 - 1][n1], H[n1 - 1][n1 - 1] - p, q);
-                    H[n - 1][n - 1] = cdivr;
+                    H[n1 - 1][n1 - 1] = cdivr;
-                    H[n - 1][n] = cdivi;
+                    H[n1 - 1][n1] = cdivi;
                 }
-                H[n][n - 1] = 0.0;
+                H[n1][n1 - 1] = 0.0;
-                H[n][n] = 1.0;
+                H[n1][n1] = 1.0;
-                for (int i = n - 2; i >= 0; i--) {
+                for (int i = n1 - 2; i >= 0; i--) {
                     double ra, sa, vr, vi;
                     ra = 0.0;
                     sa = 0.0;
-                    for (int j = l; j <= n; j++) {
+                    for (int j = l; j <= n1; j++) {
-                        ra = ra + H[i][j] * H[j][n - 1];
+                        ra = ra + H[i][j] * H[j][n1 - 1];
-                        sa = sa + H[i][j] * H[j][n];
+                        sa = sa + H[i][j] * H[j][n1];
                     }
                     w = H[i][i] - p;
 
@@ -643,8 +688,8 @@ private:
                         l = i;
                         if (e[i] == 0) {
                             cdiv(-ra, -sa, w, q);
-                            H[i][n - 1] = cdivr;
+                            H[i][n1 - 1] = cdivr;
-                            H[i][n] = cdivi;
+                            H[i][n1] = cdivi;
                         } else {
 
                             // Solve complex equations
@@ -659,28 +704,28 @@ private:
                             }
                             cdiv(x * r - z * ra + q * sa,
                                  x * s - z * sa - q * ra, vr, vi);
-                            H[i][n - 1] = cdivr;
+                            H[i][n1 - 1] = cdivr;
-                            H[i][n] = cdivi;
+                            H[i][n1] = cdivi;
                             if (std::abs(x) > (std::abs(z) + std::abs(q))) {
-                                H[i + 1][n - 1] = (-ra - w * H[i][n - 1] + q
+                                H[i + 1][n1 - 1] = (-ra - w * H[i][n1 - 1] + q
-                                                   * H[i][n]) / x;
+                                                   * H[i][n1]) / x;
-                                H[i + 1][n] = (-sa - w * H[i][n] - q * H[i][n
+                                H[i + 1][n1] = (-sa - w * H[i][n1] - q * H[i][n1
                                                                             - 1]) / x;
                             } else {
-                                cdiv(-r - y * H[i][n - 1], -s - y * H[i][n], z,
+                                cdiv(-r - y * H[i][n1 - 1], -s - y * H[i][n1], z,
                                      q);
-                                H[i + 1][n - 1] = cdivr;
+                                H[i + 1][n1 - 1] = cdivr;
-                                H[i + 1][n] = cdivi;
+                                H[i + 1][n1] = cdivi;
                             }
                         }
 
                         // Overflow control
 
-                        t = max(std::abs(H[i][n - 1]), std::abs(H[i][n]));
+                        t = max(std::abs(H[i][n1 - 1]), std::abs(H[i][n1]));
                         if ((eps * t) * t > 1) {
-                            for (int j = i; j <= n; j++) {
+                            for (int j = i; j <= n1; j++) {
-                                H[j][n - 1] = H[j][n - 1] / t;
+                                H[j][n1 - 1] = H[j][n1 - 1] / t;
-                                H[j][n] = H[j][n] / t;
+                                H[j][n1] = H[j][n1] / t;
                             }
                         }
                     }
@@ -898,8 +943,9 @@ public:
 //------------------------------------------------------------------------------
 void LDA::save(const string& filename) const {
     FileStorage fs(filename, FileStorage::WRITE);
-    if (!fs.isOpened())
+    if (!fs.isOpened()) {
         CV_Error(CV_StsError, "File can't be opened for writing!");
+    }
     this->save(fs);
     fs.release();
 }
@@ -941,8 +987,8 @@ void LDA::lda(InputArray _src, InputArray _lbls) {
     vector<int> mapped_labels(labels.size());
     vector<int> num2label = remove_dups(labels);
     map<int, int> label2num;
-    for (size_t i = 0; i < num2label.size(); i++)
+    for (int i = 0; i < (int)num2label.size(); i++)
-        label2num[num2label[i]] = (int)i;
+        label2num[num2label[i]] = i;
     for (size_t i = 0; i < labels.size(); i++)
         mapped_labels[i] = label2num[labels[i]];
     // get sample size, dimension
@@ -950,17 +996,27 @@ void LDA::lda(InputArray _src, InputArray _lbls) {
     int D = data.cols;
     // number of unique labels
     int C = (int)num2label.size();
+    // we can't do a LDA on one class, what do you
+    // want to separate from each other then?
+    if(C == 1) {
+        string error_message = "At least two classes are needed to perform a LDA. Reason: Only one class was given!";
+        CV_Error(CV_StsBadArg, error_message);
+    }
     // throw error if less labels, than samples
-    if (labels.size() != (size_t)N)
+    if (labels.size() != static_cast<size_t>(N)) {
-        CV_Error(CV_StsBadArg, "Error: The number of samples must equal the number of labels.");
+        string error_message = format("The number of samples must equal the number of labels. Given %d labels, %d samples. ", labels.size(), N);
+        CV_Error(CV_StsBadArg, error_message);
+    }
     // warn if within-classes scatter matrix becomes singular
-    if (N < D)
+    if (N < D) {
         cout << "Warning: Less observations than feature dimension given!"
         	 << "Computation will probably fail."
              << endl;
+    }
     // clip number of components to be a valid number
-    if ((_num_components <= 0) || (_num_components > (C - 1)))
+    if ((_num_components <= 0) || (_num_components > (C - 1))) {
         _num_components = (C - 1);
+    }
     // holds the mean over all classes
     Mat meanTotal = Mat::zeros(1, D, data.type());
     // holds the mean for each class
@@ -979,12 +1035,12 @@ void LDA::lda(InputArray _src, InputArray _lbls) {
         add(meanClass[classIdx], instance, meanClass[classIdx]);
         numClass[classIdx]++;
     }
-    // calculate means
+    // calculate total mean
-    meanTotal.convertTo(meanTotal, meanTotal.type(),
+    meanTotal.convertTo(meanTotal, meanTotal.type(), 1.0 / static_cast<double> (N));
-            1.0 / static_cast<double> (N));
+    // calculate class means
-    for (int i = 0; i < C; i++)
+    for (int i = 0; i < C; i++) {
-        meanClass[i].convertTo(meanClass[i], meanClass[i].type(),
+        meanClass[i].convertTo(meanClass[i], meanClass[i].type(), 1.0 / static_cast<double> (numClass[i]));
-                1.0 / static_cast<double> (numClass[i]));
+    }
     // subtract class means
     for (int i = 0; i < N; i++) {
         int classIdx = mapped_labels[i];
@@ -1031,7 +1087,8 @@ void LDA::compute(InputArray _src, InputArray _lbls) {
         lda(_src.getMat(), _lbls);
         break;
     default:
-        CV_Error(CV_StsNotImplemented, "This data type is not supported by subspace::LDA::compute.");
+    	string error_message= format("InputArray Datatype %d is not supported.", _src.kind());
+        CV_Error(CV_StsBadArg, error_message);
         break;
     }
 }

modules/contrib/src/logpolar_bsm.cpp

@@ -62,7 +62,7 @@ namespace cv
 {
 
 //------------------------------------interp-------------------------------------------
-LogPolar_Interp::LogPolar_Interp(int w, int h, Point2i center, int R, double ro0, int interp, int full, int S, int sp)
+LogPolar_Interp::LogPolar_Interp(int w, int h, Point2i center, int _R, double _ro0, int _interp, int full, int _s, int sp)
 {
     if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1;
 
@@ -97,23 +97,23 @@ LogPolar_Interp::LogPolar_Interp(int w, int h, Point2i center, int R, double ro0
 
     if (sp){
         int jc=M/2-1, ic=N/2-1;
-        int romax=min(ic, jc);
+        int _romax=min(ic, jc);
-        double a=exp(log((double)(romax/2-1)/(double)ro0)/(double)R);
+        double _a=exp(log((double)(_romax/2-1)/(double)ro0)/(double)R);
-        S=(int) floor(2*CV_PI/(a-1)+0.5);
+        S=(int) floor(2*CV_PI/(_a-1)+0.5);
     }
 
-    this->interp=interp;
+    interp=_interp;
 
-    create_map(M, N, R, S, ro0);
+    create_map(M, N, _R, _s, _ro0);
 }
 
-void LogPolar_Interp::create_map(int M, int N, int R, int S, double ro0)
+void LogPolar_Interp::create_map(int _M, int _n, int _R, int _s, double _ro0)
 {
-    this->M=M;
+    M=_M;
-    this->N=N;
+    N=_n;
-    this->R=R;
+    R=_R;
-    this->S=S;
+    S=_s;
-    this->ro0=ro0;
+    ro0=_ro0;
 
     int jc=N/2-1, ic=M/2-1;
     romax=min(ic, jc);
@@ -208,7 +208,7 @@ LogPolar_Interp::~LogPolar_Interp()
 
 //------------------------------------overlapping----------------------------------
 
-LogPolar_Overlapping::LogPolar_Overlapping(int w, int h, Point2i center, int R, double ro0, int full, int S, int sp)
+LogPolar_Overlapping::LogPolar_Overlapping(int w, int h, Point2i center, int _R, double _ro0, int full, int _s, int sp)
 {
     if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1;
 
@@ -244,21 +244,21 @@ LogPolar_Overlapping::LogPolar_Overlapping(int w, int h, Point2i center, int R,
 
     if (sp){
         int jc=M/2-1, ic=N/2-1;
-        int romax=min(ic, jc);
+        int _romax=min(ic, jc);
-        double a=exp(log((double)(romax/2-1)/(double)ro0)/(double)R);
+        double _a=exp(log((double)(_romax/2-1)/(double)ro0)/(double)R);
-        S=(int) floor(2*CV_PI/(a-1)+0.5);
+        S=(int) floor(2*CV_PI/(_a-1)+0.5);
     }
 
-    create_map(M, N, R, S, ro0);
+    create_map(M, N, _R, _s, _ro0);
 }
 
-void LogPolar_Overlapping::create_map(int M, int N, int R, int S, double ro0)
+void LogPolar_Overlapping::create_map(int _M, int _n, int _R, int _s, double _ro0)
 {
-    this->M=M;
+    M=_M;
-    this->N=N;
+    N=_n;
-    this->R=R;
+    R=_R;
-    this->S=S;
+    S=_s;
-    this->ro0=ro0;
+    ro0=_ro0;
 
     int jc=N/2-1, ic=M/2-1;
     romax=min(ic, jc);
@@ -433,7 +433,7 @@ LogPolar_Overlapping::~LogPolar_Overlapping()
 
 //----------------------------------------adjacent---------------------------------------
 
-LogPolar_Adjacent::LogPolar_Adjacent(int w, int h, Point2i center, int R, double ro0, double smin, int full, int S, int sp)
+LogPolar_Adjacent::LogPolar_Adjacent(int w, int h, Point2i center, int _R, double _ro0, double smin, int full, int _s, int sp)
 {
     if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1;
 
@@ -468,22 +468,22 @@ LogPolar_Adjacent::LogPolar_Adjacent(int w, int h, Point2i center, int R, double
 
     if (sp){
         int jc=M/2-1, ic=N/2-1;
-        int romax=min(ic, jc);
+        int _romax=min(ic, jc);
-        double a=exp(log((double)(romax/2-1)/(double)ro0)/(double)R);
+        double _a=exp(log((double)(_romax/2-1)/(double)ro0)/(double)R);
-        S=(int) floor(2*CV_PI/(a-1)+0.5);
+        S=(int) floor(2*CV_PI/(_a-1)+0.5);
     }
 
-    create_map(M, N, R, S, ro0, smin);
+    create_map(M, N, _R, _s, _ro0, smin);
 }
 
 
-void LogPolar_Adjacent::create_map(int M, int N, int R, int S, double ro0, double smin)
+void LogPolar_Adjacent::create_map(int _M, int _n, int _R, int _s, double _ro0, double smin)
 {
-    LogPolar_Adjacent::M=M;
+    M=_M;
-    LogPolar_Adjacent::N=N;
+    N=_n;
-    LogPolar_Adjacent::R=R;
+    R=_R;
-    LogPolar_Adjacent::S=S;
+    S=_s;
-    LogPolar_Adjacent::ro0=ro0;
+    ro0=_ro0;
     romax=min(M/2.0, N/2.0);
 
     a=exp(log(romax/ro0)/(double)R);

modules/contrib/src/octree.cpp

@@ -43,8 +43,9 @@
 #include "precomp.hpp"
 #include <limits>
 
-namespace cv
+namespace
 {
+    using namespace cv;
     const size_t MAX_STACK_SIZE = 255;
     const size_t MAX_LEAFS = 8;
 
@@ -159,17 +160,20 @@ namespace cv
             child.x_min = parent.x_min;
     }
 
+}//namespace
+
 ////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////       Octree       //////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////
-
+namespace cv
+{
     Octree::Octree()
     {
     }
 
-    Octree::Octree(const vector<Point3f>& points3d, int maxLevels, int minPoints)
+    Octree::Octree(const vector<Point3f>& points3d, int maxLevels, int _minPoints)
     {
-        buildTree(points3d, maxLevels, minPoints);
+        buildTree(points3d, maxLevels, _minPoints);
     }
 
     Octree::~Octree()
@@ -252,12 +256,12 @@ namespace cv
         }
     }
 
-    void Octree::buildTree(const vector<Point3f>& points3d, int maxLevels, int minPoints)
+    void Octree::buildTree(const vector<Point3f>& points3d, int maxLevels, int _minPoints)
     {
         assert((size_t)maxLevels * 8 < MAX_STACK_SIZE);
         points.resize(points3d.size());
         std::copy(points3d.begin(), points3d.end(), points.begin());
-        this->minPoints = minPoints;
+        minPoints = _minPoints;
 
         nodes.clear();
         nodes.push_back(Node());
@@ -271,7 +275,7 @@ namespace cv
         for (size_t i = 0; i < MAX_LEAFS; i++)
             root.children[i] = 0;
 
-        if (maxLevels != 1 && (root.end - root.begin) > minPoints)
+        if (maxLevels != 1 && (root.end - root.begin) > _minPoints)
         {
             root.isLeaf = false;
             buildNext(0);

modules/contrib/src/precomp.hpp

@@ -43,10 +43,6 @@
 #ifndef __OPENCV_PRECOMP_H__
 #define __OPENCV_PRECOMP_H__
 
-#if _MSC_VER >= 1200
-#pragma warning( disable: 4251 4710 4711 4514 4996 )
-#endif
-
 #ifdef HAVE_CVCONFIG_H
 #include "cvconfig.h"
 #endif

modules/contrib/src/retina.cpp

@@ -75,16 +75,16 @@
 namespace cv
 {
 
-Retina::Retina(const cv::Size inputSize)
+Retina::Retina(const cv::Size inputSz)
 {
     _retinaFilter = 0;
-    _init(inputSize, true, RETINA_COLOR_BAYER, false);
+    _init(inputSz, true, RETINA_COLOR_BAYER, false);
 }
 
-Retina::Retina(const cv::Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
+Retina::Retina(const cv::Size inputSz, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
 {
     _retinaFilter = 0;
-    _init(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
+    _init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
 };
 
 Retina::~Retina()
@@ -342,20 +342,20 @@ const std::valarray<float> & Retina::getMagno() const {return _retinaFilter->get
 const std::valarray<float> & Retina::getParvo() const {if (_retinaFilter->getColorMode())return _retinaFilter->getColorOutput(); /* implicite else */return _retinaFilter->getContours();}
 
 // private method called by constructirs
-void Retina::_init(const cv::Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
+void Retina::_init(const cv::Size inputSz, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
 {
     // basic error check
-	if (inputSize.height*inputSize.width <= 0)
+    if (inputSz.height*inputSz.width <= 0)
         throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "Retina::setup", "Retina.h", 0);
 
-	unsigned int nbPixels=inputSize.height*inputSize.width;
+    unsigned int nbPixels=inputSz.height*inputSz.width;
     // resize buffers if size does not match
     _inputBuffer.resize(nbPixels*3); // buffer supports gray images but also 3 channels color buffers... (larger is better...)
 
     // allocate the retina model
         if (_retinaFilter)
            delete _retinaFilter;
-	_retinaFilter = new RetinaFilter(inputSize.height, inputSize.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
+    _retinaFilter = new RetinaFilter(inputSz.height, inputSz.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
 
     // prepare the default parameter XML file with default setup
         setup(_retinaParameters);
@@ -419,16 +419,17 @@ bool Retina::_convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, std::
     if(imageNumberOfChannels==4)
     {
     // create a cv::Mat table (for RGBA planes)
-            cv::Mat planes[] =
+        cv::Mat planes[4] =
         {
             cv::Mat(inputMatToConvert.size(), dsttype, &outputValarrayMatrix[_retinaFilter->getInputNBpixels()*2]),
             cv::Mat(inputMatToConvert.size(), dsttype, &outputValarrayMatrix[_retinaFilter->getInputNBpixels()]),
-                cv::Mat(inputMatToConvert.size(), dsttype, &outputValarrayMatrix[0]),
+            cv::Mat(inputMatToConvert.size(), dsttype, &outputValarrayMatrix[0])
-                cv::Mat(inputMatToConvert.size(), dsttype)     // last channel (alpha) does not point on the valarray (not usefull in our case)
         };
+        planes[3] = cv::Mat(inputMatToConvert.size(), dsttype);     // last channel (alpha) does not point on the valarray (not usefull in our case)
         // split color cv::Mat in 4 planes... it fills valarray directely
         cv::split(cv::Mat_<Vec<T, 4> >(inputMatToConvert), planes);
-        }else if (imageNumberOfChannels==3)
+    }
+    else if (imageNumberOfChannels==3)
     {
         // create a cv::Mat table (for RGB planes)
         cv::Mat planes[] =
@@ -439,7 +440,8 @@ bool Retina::_convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, std::
         };
         // split color cv::Mat in 3 planes... it fills valarray directely
         cv::split(cv::Mat_<Vec<T, 3> >(inputMatToConvert), planes);
-	}else if(imageNumberOfChannels==1)
+    }
+    else if(imageNumberOfChannels==1)
     {
         // create a cv::Mat header for the valarray
         cv::Mat dst(inputMatToConvert.size(), dsttype, &outputValarrayMatrix[0]);

modules/contrib/src/retinacolor.cpp

@@ -325,15 +325,15 @@ void RetinaColor::runColorDemultiplexing(const std::valarray<float> &multiplexed
 
 	}else
 	{
-		register const float *multiplexedColorFramePTR= get_data(multiplexedColorFrame);
+		register const float *multiplexedColorFramePTR1= get_data(multiplexedColorFrame);
-		for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR)
+		for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR1)
 		{
 			// normalize by photoreceptors density
 			float Cr=*(chrominancePTR)*_colorLocalDensity[indexc];
 			float Cg=*(chrominancePTR+_filterOutput.getNBpixels())*_colorLocalDensity[indexc+_filterOutput.getNBpixels()];
 			float Cb=*(chrominancePTR+_filterOutput.getDoubleNBpixels())*_colorLocalDensity[indexc+_filterOutput.getDoubleNBpixels()];
 			*luminance=(Cr+Cg+Cb)*_pG;
-			_demultiplexedTempBuffer[_colorSampling[indexc]] = *multiplexedColorFramePTR - *luminance;
+			_demultiplexedTempBuffer[_colorSampling[indexc]] = *multiplexedColorFramePTR1 - *luminance;
 
 		}
 

modules/contrib/src/spinimages.cpp

@@ -336,18 +336,18 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
                 __m128 f1f2 = _mm_mul_ps(f1, f2);  // f1 * f2
                 __m128 omf1omf2 = _mm_add_ps(_mm_sub_ps(_mm_sub_ps(one4f, f2), f1), f1f2); // (1-f1) * (1-f2)
 
-                __m128i mask = _mm_and_si128(
+                __m128i _mask = _mm_and_si128(
                     _mm_andnot_si128(_mm_cmpgt_epi32(zero4, n1), _mm_cmpgt_epi32(height4m1, n1)),
                     _mm_andnot_si128(_mm_cmpgt_epi32(zero4, n2), _mm_cmpgt_epi32(width4m1, n2)));
 
-                __m128 maskf = _mm_cmpneq_ps(_mm_cvtepi32_ps(mask), zero4f);
+                __m128 maskf = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mask), zero4f);
 
                 __m128 v00 = _mm_and_ps(        omf1omf2       , maskf); // a00 b00 c00 d00
                 __m128 v01 = _mm_and_ps( _mm_sub_ps( f2, f1f2 ), maskf); // a01 b01 c01 d01
                 __m128 v10 = _mm_and_ps( _mm_sub_ps( f1, f1f2 ), maskf); // a10 b10 c10 d10
                 __m128 v11 = _mm_and_ps(          f1f2         , maskf); // a11 b11 c11 d11
 
-                __m128i ofs4 = _mm_and_si128(_mm_add_epi32(_mm_mullo_epi32_emul(n1, step4), n2), mask);
+                __m128i ofs4 = _mm_and_si128(_mm_add_epi32(_mm_mullo_epi32_emul(n1, step4), n2), _mask);
                 _mm_store_si128((__m128i*)o, ofs4);
 
                 __m128 t0 = _mm_unpacklo_ps(v00, v01); // a00 a01 b00 b01
@@ -808,7 +808,7 @@ void cv::SpinImageModel::selectRandomSubset(float ratio)
         subset.resize(setSize);
         for(size_t i = 0; i < setSize; ++i)
         {
-            int pos = rnd.next() % left.size();
+            int pos = rnd.next() % (int)left.size();
             subset[i] = (int)left[pos];
 
             left[pos] = left.back();
@@ -823,21 +823,21 @@ void cv::SpinImageModel::setSubset(const vector<int>& ss)
     subset = ss;
 }
 
-void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& spinImages, bool reAlloc) const
+void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& _spinImages, bool reAlloc) const
 {
     if (reAlloc)
     {
         size_t spinCount = mask.size() - count(mask.begin(), mask.end(), (uchar)0);
-        Mat newImgs((int)spinCount, spinImages.cols, spinImages.type());    
+        Mat newImgs((int)spinCount, _spinImages.cols, _spinImages.type());
 
         int pos = 0;
         for(size_t t = 0; t < mask.size(); ++t)
             if (mask[t])
             {
                 Mat row = newImgs.row(pos++);
-                spinImages.row((int)t).copyTo(row);
+                _spinImages.row((int)t).copyTo(row);
             }
-        spinImages = newImgs;
+        _spinImages = newImgs;
     }
     else
     {
@@ -851,11 +851,11 @@ void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& spinIm
         for (; first != last; ++first)
             if (mask[first] != 0)
             {
-                Mat row = spinImages.row(dest);
+                Mat row = _spinImages.row(dest);
-                spinImages.row(first).copyTo(row);
+                _spinImages.row(first).copyTo(row);
                 ++dest;
             }
-        spinImages = spinImages.rowRange(0, dest);
+        _spinImages = _spinImages.rowRange(0, dest);
     }
 }
 

modules/contrib/src/stereovar.cpp

@@ -204,10 +204,10 @@ void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
                         break;
                 }
 
-				float fi = Fi;
+                float _fi = Fi;
                 if (maxDisp > minDisp) {
-					if (pU[x] > maxDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(maxDisp * scale);} 
+                    if (pU[x] > maxDisp * scale) {_fi *= 1000; pU[x] = static_cast<float>(maxDisp * scale);}
-					if (pU[x] < minDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(minDisp * scale);} 
+                    if (pU[x] < minDisp * scale) {_fi *= 1000; pU[x] = static_cast<float>(minDisp * scale);}
                 }
 
                 int A = static_cast<int>(pU[x]);
@@ -219,8 +219,8 @@ void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
                     pu[x] = pU[- A + 2];
                 else {
                     pu[x] = A + (pI2x[x + A + neg] * (pI1[x] - pI2[x + A])
-							  + fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A)) 
+                              + _fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A))
-							  / (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * fi) ; 
+                              / (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * _fi) ;
                 }
             }// x
             pu[0] = pu[1];

modules/contrib/test/test_precomp.hpp

@@ -1,3 +1,7 @@
+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#endif
+
 #ifndef __OPENCV_TEST_PRECOMP_HPP__
 #define __OPENCV_TEST_PRECOMP_HPP__
 

modules/core/CMakeLists.txt

@@ -6,8 +6,9 @@ if(HAVE_CUDA)
   file(GLOB lib_cuda "src/cuda/*.cu")
   source_group("Cuda" FILES "${lib_cuda}")
 
-  ocv_include_directories(${CUDA_INCLUDE_DIRS} "${OpenCV_SOURCE_DIR}/modules/gpu/src" "${OpenCV_SOURCE_DIR}/modules/gpu/src/cuda")  
+  ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpu/src" "${OpenCV_SOURCE_DIR}/modules/gpu/src/cuda" ${CUDA_INCLUDE_DIRS})
-  OCV_CUDA_COMPILE(cuda_objs ${lib_cuda})
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
+  ocv_cuda_compile(cuda_objs ${lib_cuda})
 
   set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 else()

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

@@ -1299,6 +1299,7 @@ public:
         GPU_MAT           = 9 << KIND_SHIFT
     };
     _InputArray();
+
     _InputArray(const Mat& m);
     _InputArray(const MatExpr& expr);
     template<typename _Tp> _InputArray(const _Tp* vec, int n);
@@ -1328,6 +1329,10 @@ public:
     virtual int channels(int i=-1) const;
     virtual bool empty() const;
 
+#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
+    virtual ~_InputArray();
+#endif
+
     int flags;
     void* obj;
     Size sz;
@@ -1384,6 +1389,10 @@ public:
     virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
     virtual void release() const;
     virtual void clear() const;
+
+#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
+    virtual ~_OutputArray();
+#endif
 };
 
 typedef const _InputArray& InputArray;

modules/core/include/opencv2/core/core_c.h

@@ -1127,9 +1127,9 @@ CVAPI(void)   cvSetRemove( CvSet* set_header, int index );
 
 /* Returns a set element by index. If the element doesn't belong to the set,
    NULL is returned */
-CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int index )
+CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int idx )
 {
-    CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index );
+    CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, idx );
     return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
 }
 

modules/core/include/opencv2/core/eigen.hpp

@@ -48,6 +48,11 @@
 #include "opencv2/core/core_c.h"
 #include "opencv2/core/core.hpp"
 
+#if defined _MSC_VER && _MSC_VER >= 1200
+#pragma warning( disable: 4714 ) //__forceinline is not inlined
+#pragma warning( disable: 4127 ) //conditional expression is constant
+#endif
+
 namespace cv
 {
 

modules/core/include/opencv2/core/gpumat.hpp

@@ -366,12 +366,12 @@ namespace cv { namespace gpu
         return m;
     }
 
-    inline void GpuMat::assignTo(GpuMat& m, int type) const
+    inline void GpuMat::assignTo(GpuMat& m, int _type) const
     {
-        if (type < 0)
+        if (_type < 0)
             m = *this;
         else
-            convertTo(m, type);
+            convertTo(m, _type);
     }
 
     inline size_t GpuMat::step1() const
@@ -434,9 +434,9 @@ namespace cv { namespace gpu
         create(size_.height, size_.width, type_);
     }
 
-    inline GpuMat GpuMat::operator()(Range rowRange, Range colRange) const
+    inline GpuMat GpuMat::operator()(Range _rowRange, Range _colRange) const
     {
-        return GpuMat(*this, rowRange, colRange);
+        return GpuMat(*this, _rowRange, _colRange);
     }
 
     inline GpuMat GpuMat::operator()(Rect roi) const

modules/core/include/opencv2/core/internal.hpp

@@ -104,17 +104,21 @@ CV_INLINE IppiSize ippiSize(int width, int height)
 }
 #endif
 
-#if defined __SSE2__ || _MSC_VER >= 1300
+#if defined __SSE2__ || (defined _MSC_VER && _MSC_VER >= 1300)
 #  include "emmintrin.h"
 #  define CV_SSE 1
 #  define CV_SSE2 1
-#if defined __SSE3__ || _MSC_VER >= 1500
+#  if defined __SSE3__ || (defined _MSC_VER && _MSC_VER >= 1500)
 #    include "pmmintrin.h"
 #    define CV_SSE3 1
+#  else
+#    define CV_SSE3 0
 #  endif
 #  if defined __SSSE3__
 #    include "tmmintrin.h"
 #    define CV_SSSE3 1
+#  else
+#    define CV_SSSE3 0
 #  endif
 #else
 #  define CV_SSE 0
@@ -123,7 +127,7 @@ CV_INLINE IppiSize ippiSize(int width, int height)
 #  define CV_SSSE3 0
 #endif
 
-#if defined ANDROID && defined __ARM_NEON__ && defined __GNUC__
+#if defined ANDROID && defined __ARM_NEON__
 #  include "arm_neon.h"
 #  define CV_NEON 1
 
@@ -135,12 +139,6 @@ CV_INLINE IppiSize ippiSize(int width, int height)
 #  define CPU_HAS_NEON_FEATURE (false)
 #endif
 
-#ifdef CV_ICC
-#define CV_ENABLE_UNROLLED 0
-#else
-#define CV_ENABLE_UNROLLED 1
-#endif
-
 #ifndef IPPI_CALL
 #  define IPPI_CALL(func) CV_Assert((func) >= 0)
 #endif
@@ -164,9 +162,10 @@ CV_INLINE IppiSize ippiSize(int width, int height)
 
 #ifdef __cplusplus
 
-#ifdef HAVE_TBB
 namespace cv
 {
+#ifdef HAVE_TBB
+
     typedef tbb::blocked_range<int> BlockedRange;
 
     template<typename Body> static inline
@@ -191,10 +190,7 @@ CV_INLINE IppiSize ippiSize(int width, int height)
 
     typedef tbb::concurrent_vector<Rect> ConcurrentRectVector;
     typedef tbb::concurrent_vector<double> ConcurrentDoubleVector;
-    }
 #else
-    namespace cv
-    {
     class BlockedRange
     {
     public:
@@ -230,9 +226,8 @@ CV_INLINE IppiSize ippiSize(int width, int height)
     {
         body(range);
     }
-        
-    }
 #endif
+} //namespace cv
 
 #define CV_INIT_ALGORITHM(classname, algname, memberinit) \
     static Algorithm* create##classname() \
@@ -261,7 +256,7 @@ CV_INLINE IppiSize ippiSize(int width, int height)
         return &classname##_info(); \
     }
 
-#endif
+#endif //__cplusplus
 
 /* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */
 #define  CV_MAX_INLINE_MAT_OP_SIZE  10
@@ -720,8 +715,7 @@ CvFuncTable;
 typedef struct CvBigFuncTable
 {
     void*   fn_2d[CV_DEPTH_MAX*4];
-}
+} CvBigFuncTable;
-CvBigFuncTable;
 
 #define CV_INIT_FUNC_TAB( tab, FUNCNAME, FLAG )         \
     (tab).fn_2d[CV_8U] = (void*)FUNCNAME##_8u##FLAG;    \
@@ -732,6 +726,7 @@ CvBigFuncTable;
     (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG;  \
     (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG
 
+#ifdef __cplusplus
 //! OpenGL extension table
 class CV_EXPORTS CvOpenGlFuncTab
 {
@@ -764,4 +759,6 @@ CV_EXPORTS bool icvCheckGlError(const char* file, const int line, const char* fu
     #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__)) )
 #endif
 
-#endif
+#endif //__cplusplus
+
+#endif // __OPENCV_CORE_INTERNAL_HPP__

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

@@ -336,12 +336,12 @@ inline Mat Mat::clone() const
     return m;
 }
 
-inline void Mat::assignTo( Mat& m, int type ) const
+inline void Mat::assignTo( Mat& m, int _type ) const
 {
-    if( type < 0 )
+    if( _type < 0 )
         m = *this;
     else
-        convertTo(m, type);
+        convertTo(m, _type);
 }
 
 inline void Mat::create(int _rows, int _cols, int _type)
@@ -370,9 +370,9 @@ inline void Mat::release()
     refcount = 0;
 }
 
-inline Mat Mat::operator()( Range rowRange, Range colRange ) const
+inline Mat Mat::operator()( Range _rowRange, Range _colRange ) const
 {
-    return Mat(*this, rowRange, colRange);
+    return Mat(*this, _rowRange, _colRange);
 }
 
 inline Mat Mat::operator()( const Rect& roi ) const
@@ -829,8 +829,8 @@ template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m)
 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp* _data, size_t steps)
     : Mat(_rows, _cols, DataType<_Tp>::type, _data, steps) {}
 
-template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& rowRange, const Range& colRange)
+template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& _rowRange, const Range& _colRange)
-    : Mat(m, rowRange, colRange) {}
+    : Mat(m, _rowRange, _colRange) {}
 
 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Rect& roi)
     : Mat(m, roi) {}
@@ -967,8 +967,8 @@ template<typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const { return step
 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::adjustROI( int dtop, int dbottom, int dleft, int dright )
 { return (Mat_<_Tp>&)(Mat::adjustROI(dtop, dbottom, dleft, dright));  }
 
-template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& rowRange, const Range& colRange ) const
+template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& _rowRange, const Range& _colRange ) const
-{ return Mat_<_Tp>(*this, rowRange, colRange); }
+{ return Mat_<_Tp>(*this, _rowRange, _colRange); }
 
 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Rect& roi ) const
 { return Mat_<_Tp>(*this, roi); }
@@ -2123,12 +2123,12 @@ inline SparseMat SparseMat::clone() const
 }
 
 
-inline void SparseMat::assignTo( SparseMat& m, int type ) const
+inline void SparseMat::assignTo( SparseMat& m, int _type ) const
 {
-    if( type < 0 )
+    if( _type < 0 )
         m = *this;
     else
-        convertTo(m, type);
+        convertTo(m, _type);
 }
 
 inline void SparseMat::addref()

modules/core/include/opencv2/core/opengl_interop.hpp

@@ -70,9 +70,9 @@ namespace cv
     GlBuffer(InputArray mat, Usage usage);
 
     void create(int rows, int cols, int type, Usage usage);
-        inline void create(Size size, int type, Usage usage) { create(size.height, size.width, type, usage); }
+    void create(Size size, int type, Usage usage);
-        inline void create(int rows, int cols, int type) { create(rows, cols, type, usage()); }
+    void create(int rows, int cols, int type);
-        inline void create(Size size, int type) { create(size.height, size.width, type, usage()); }
+    void create(Size size, int type);
 
     void release();
 
@@ -130,7 +130,7 @@ namespace cv
     explicit GlTexture(InputArray mat, bool bgra = true);
 
     void create(int rows, int cols, int type);
-        inline void create(Size size, int type) { create(size.height, size.width, type); }
+    void create(Size size, int type);
     void release();
 
     //! copy from host/device memory
@@ -318,6 +318,11 @@ namespace cv
     bool perspectiveProjection_;
 };
 
+inline void GlBuffer::create(Size _size, int _type, Usage _usage) { create(_size.height, _size.width, _type, _usage); }
+inline void GlBuffer::create(int _rows, int _cols, int _type) { create(_rows, _cols, _type, usage()); }
+inline void GlBuffer::create(Size _size, int _type) { create(_size.height, _size.width, _type, usage()); }
+inline void GlTexture::create(Size _size, int _type) { create(_size.height, _size.width, _type); }
+
 namespace gpu
 {
     //! set a CUDA device to use OpenGL interoperability

modules/core/include/opencv2/core/operations.hpp

@@ -984,13 +984,13 @@ _AccTp normL2Sqr(const _Tp* a, const _Tp* b, int n)
 #if CV_ENABLE_UNROLLED
     for(; i <= n - 4; i += 4 )
     {
-        _AccTp v0 = a[i] - b[i], v1 = a[i+1] - b[i+1], v2 = a[i+2] - b[i+2], v3 = a[i+3] - b[i+3];
+        _AccTp v0 = _AccTp(a[i] - b[i]), v1 = _AccTp(a[i+1] - b[i+1]), v2 = _AccTp(a[i+2] - b[i+2]), v3 = _AccTp(a[i+3] - b[i+3]);
         s += v0*v0 + v1*v1 + v2*v2 + v3*v3;
     }
 #endif
     for( ; i < n; i++ )
     {
-        _AccTp v = (_AccTp)(a[i] - b[i]);
+        _AccTp v = _AccTp(a[i] - b[i]);
         s += v*v;
     }
     return s;
@@ -1024,13 +1024,13 @@ _AccTp normL1(const _Tp* a, const _Tp* b, int n)
 #if CV_ENABLE_UNROLLED
     for(; i <= n - 4; i += 4 )
     {
-        _AccTp v0 = a[i] - b[i], v1 = a[i+1] - b[i+1], v2 = a[i+2] - b[i+2], v3 = a[i+3] - b[i+3];
+        _AccTp v0 = _AccTp(a[i] - b[i]), v1 = _AccTp(a[i+1] - b[i+1]), v2 = _AccTp(a[i+2] - b[i+2]), v3 = _AccTp(a[i+3] - b[i+3]);
         s += std::abs(v0) + std::abs(v1) + std::abs(v2) + std::abs(v3);
     }
 #endif
     for( ; i < n; i++ )
     {
-        _AccTp v = (_AccTp)(a[i] - b[i]);
+        _AccTp v = _AccTp(a[i] - b[i]);
         s += std::abs(v);
     }
     return s;
@@ -2616,20 +2616,20 @@ template<typename _Tp> inline void Ptr<_Tp>::delete_obj()
 
 template<typename _Tp> inline Ptr<_Tp>::~Ptr() { release(); }
 
-template<typename _Tp> inline Ptr<_Tp>::Ptr(const Ptr<_Tp>& ptr)
+template<typename _Tp> inline Ptr<_Tp>::Ptr(const Ptr<_Tp>& _ptr)
 {
-    obj = ptr.obj;
+    obj = _ptr.obj;
-    refcount = ptr.refcount;
+    refcount = _ptr.refcount;
     addref();
 }
 
-template<typename _Tp> inline Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& ptr)
+template<typename _Tp> inline Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& _ptr)
 {
-    int* _refcount = ptr.refcount;
+    int* _refcount = _ptr.refcount;
     if( _refcount )
         CV_XADD(_refcount, 1);
     release();
-    obj = ptr.obj;
+    obj = _ptr.obj;
     refcount = _refcount;
     return *this;
 }
@@ -3593,10 +3593,10 @@ template<typename _Tp> inline Seq<_Tp>::operator vector<_Tp>() const
 template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator()
 { memset(this, 0, sizeof(*this)); }
 
-template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator(const Seq<_Tp>& seq, bool seekEnd)
+template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator(const Seq<_Tp>& _seq, bool seekEnd)
 {
-    cvStartReadSeq(seq.seq, this);
+    cvStartReadSeq(_seq.seq, this);
-    index = seekEnd ? seq.seq->total : 0;
+    index = seekEnd ? _seq.seq->total : 0;
 }
 
 template<typename _Tp> inline void SeqIterator<_Tp>::seek(size_t pos)
@@ -3842,17 +3842,17 @@ template<typename _Tp> inline Ptr<_Tp> Algorithm::create(const string& name)
     return _create(name).ptr<_Tp>();
 }
 
-template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const string& name) const
+template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const string& _name) const
 {
     typename ParamType<_Tp>::member_type value;
-    info()->get(this, name.c_str(), ParamType<_Tp>::type, &value);
+    info()->get(this, _name.c_str(), ParamType<_Tp>::type, &value);
     return value;
 }
 
-template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const char* name) const
+template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const char* _name) const
 {
     typename ParamType<_Tp>::member_type value;
-    info()->get(this, name, ParamType<_Tp>::type, &value);
+    info()->get(this, _name, ParamType<_Tp>::type, &value);
     return value;
 }
 

modules/core/include/opencv2/core/types_c.h

@@ -43,12 +43,15 @@
 #ifndef __OPENCV_CORE_TYPES_H__
 #define __OPENCV_CORE_TYPES_H__
 
-#if !defined _CRT_SECURE_NO_DEPRECATE && _MSC_VER > 1300
+#if !defined _CRT_SECURE_NO_DEPRECATE && defined _MSC_VER
+#  if _MSC_VER > 1300
 #    define _CRT_SECURE_NO_DEPRECATE /* to avoid multiple Visual Studio 2005 warnings */
 #  endif
+#endif
 
 
 #ifndef SKIP_INCLUDES
+
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
@@ -70,7 +73,13 @@
 #  define CV_ICC   __INTEL_COMPILER
 #endif
 
-  #if (_MSC_VER >= 1400 && defined _M_X64) || (__GNUC__ >= 4 && defined __x86_64__)
+#if defined CV_ICC && !defined CV_ENABLE_UNROLLED
+#  define CV_ENABLE_UNROLLED 0
+#else
+#  define CV_ENABLE_UNROLLED 1
+#endif
+
+#if (defined _M_X64 && defined _MSC_VER && _MSC_VER >= 1400) || (__GNUC__ >= 4 && defined __x86_64__)
 #  if defined WIN32
 #    include <intrin.h>
 #  endif
@@ -96,6 +105,7 @@
 #elif defined __IPL_H__
 #  define HAVE_IPL
 #endif
+
 #endif // SKIP_INCLUDES
 
 #if defined WIN32 || defined _WIN32
@@ -1886,6 +1896,6 @@ typedef struct CvModuleInfo
 }
 CvModuleInfo;
 
-#endif /*_CXCORE_TYPES_H_*/
+#endif /*__OPENCV_CORE_TYPES_H__*/
 
 /* End of file. */

modules/core/perf/perf_precomp.hpp

@@ -1,9 +1,13 @@
+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#endif
+
 #ifndef __OPENCV_PERF_PRECOMP_HPP__
 #define __OPENCV_PERF_PRECOMP_HPP__
 
 #include "opencv2/ts/ts.hpp"
 
-#if GTEST_CREATE_SHARED_LIBRARY
+#ifdef GTEST_CREATE_SHARED_LIBRARY
 #error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
 #endif
 

modules/core/src/algorithm.cpp

@@ -181,124 +181,124 @@ string Algorithm::name() const
     return info()->name();
 }
 
-void Algorithm::set(const string& name, int value)
+void Algorithm::set(const string& parameter, int value)
 {
-    info()->set(this, name.c_str(), ParamType<int>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<int>::type, &value);
 }
 
-void Algorithm::set(const string& name, double value)
+void Algorithm::set(const string& parameter, double value)
 {
-    info()->set(this, name.c_str(), ParamType<double>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<double>::type, &value);
 }
 
-void Algorithm::set(const string& name, bool value)
+void Algorithm::set(const string& parameter, bool value)
 {
-    info()->set(this, name.c_str(), ParamType<bool>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<bool>::type, &value);
 }
 
-void Algorithm::set(const string& name, const string& value)
+void Algorithm::set(const string& parameter, const string& value)
 {
-    info()->set(this, name.c_str(), ParamType<string>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<string>::type, &value);
 }
 
-void Algorithm::set(const string& name, const Mat& value)
+void Algorithm::set(const string& parameter, const Mat& value)
 {
-    info()->set(this, name.c_str(), ParamType<Mat>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<Mat>::type, &value);
 }
 
-void Algorithm::set(const string& name, const vector<Mat>& value)
+void Algorithm::set(const string& parameter, const vector<Mat>& value)
 {
-    info()->set(this, name.c_str(), ParamType<vector<Mat> >::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<vector<Mat> >::type, &value);
 }
 
-void Algorithm::set(const string& name, const Ptr<Algorithm>& value)
+void Algorithm::set(const string& parameter, const Ptr<Algorithm>& value)
 {
-    info()->set(this, name.c_str(), ParamType<Algorithm>::type, &value);
+    info()->set(this, parameter.c_str(), ParamType<Algorithm>::type, &value);
 }
 
-void Algorithm::set(const char* name, int value)
+void Algorithm::set(const char* parameter, int value)
 {
-    info()->set(this, name, ParamType<int>::type, &value);
+    info()->set(this, parameter, ParamType<int>::type, &value);
 }
 
-void Algorithm::set(const char* name, double value)
+void Algorithm::set(const char* parameter, double value)
 {
-    info()->set(this, name, ParamType<double>::type, &value);
+    info()->set(this, parameter, ParamType<double>::type, &value);
 }
 
-void Algorithm::set(const char* name, bool value)
+void Algorithm::set(const char* parameter, bool value)
 {
-    info()->set(this, name, ParamType<bool>::type, &value);
+    info()->set(this, parameter, ParamType<bool>::type, &value);
 }
 
-void Algorithm::set(const char* name, const string& value)
+void Algorithm::set(const char* parameter, const string& value)
 {
-    info()->set(this, name, ParamType<string>::type, &value);
+    info()->set(this, parameter, ParamType<string>::type, &value);
 }
 
-void Algorithm::set(const char* name, const Mat& value)
+void Algorithm::set(const char* parameter, const Mat& value)
 {
-    info()->set(this, name, ParamType<Mat>::type, &value);
+    info()->set(this, parameter, ParamType<Mat>::type, &value);
 }
 
-void Algorithm::set(const char* name, const vector<Mat>& value)
+void Algorithm::set(const char* parameter, const vector<Mat>& value)
 {
-    info()->set(this, name, ParamType<vector<Mat> >::type, &value);
+    info()->set(this, parameter, ParamType<vector<Mat> >::type, &value);
 }
 
-void Algorithm::set(const char* name, const Ptr<Algorithm>& value)
+void Algorithm::set(const char* parameter, const Ptr<Algorithm>& value)
 {
-    info()->set(this, name, ParamType<Algorithm>::type, &value);
+    info()->set(this, parameter, ParamType<Algorithm>::type, &value);
 }
 
-int Algorithm::getInt(const string& name) const
+int Algorithm::getInt(const string& parameter) const
 {
-    return get<int>(name);
+    return get<int>(parameter);
 }
 
-double Algorithm::getDouble(const string& name) const
+double Algorithm::getDouble(const string& parameter) const
 {
-    return get<double>(name);
+    return get<double>(parameter);
 }
 
-bool Algorithm::getBool(const string& name) const
+bool Algorithm::getBool(const string& parameter) const
 {
-    return get<bool>(name);
+    return get<bool>(parameter);
 }
 
-string Algorithm::getString(const string& name) const
+string Algorithm::getString(const string& parameter) const
 {
-    return get<string>(name);
+    return get<string>(parameter);
 }
 
-Mat Algorithm::getMat(const string& name) const
+Mat Algorithm::getMat(const string& parameter) const
 {
-    return get<Mat>(name);
+    return get<Mat>(parameter);
 }
 
-vector<Mat> Algorithm::getMatVector(const string& name) const
+vector<Mat> Algorithm::getMatVector(const string& parameter) const
 {
-    return get<vector<Mat> >(name);
+    return get<vector<Mat> >(parameter);
 }
 
-Ptr<Algorithm> Algorithm::getAlgorithm(const string& name) const
+Ptr<Algorithm> Algorithm::getAlgorithm(const string& parameter) const
 {
-    return get<Algorithm>(name);
+    return get<Algorithm>(parameter);
 }
 
-string Algorithm::paramHelp(const string& name) const
+string Algorithm::paramHelp(const string& parameter) const
 {
-    return info()->paramHelp(name.c_str());
+    return info()->paramHelp(parameter.c_str());
 }
 
-int Algorithm::paramType(const string& name) const
+int Algorithm::paramType(const string& parameter) const
 {
-    return info()->paramType(name.c_str());
+    return info()->paramType(parameter.c_str());
 }
 
-int Algorithm::paramType(const char* name) const
+int Algorithm::paramType(const char* parameter) const
 {
-    return info()->paramType(name);
+    return info()->paramType(parameter);
 }
 
 void Algorithm::getParams(vector<string>& names) const
@@ -440,15 +440,15 @@ union GetSetParam
     void (Algorithm::*set_algo)(const Ptr<Algorithm>&);
 };
 
-void AlgorithmInfo::set(Algorithm* algo, const char* name, int argType, const void* value, bool force) const
+void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, const void* value, bool force) const
 {
-    const Param* p = findstr(data->params, name);
+    const Param* p = findstr(data->params, parameter);
 
     if( !p )
-        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") );
+        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
 
     if( !force && p->readonly )
-        CV_Error_( CV_StsError, ("Parameter '%s' is readonly", name));
+        CV_Error_( CV_StsError, ("Parameter '%s' is readonly", parameter));
 
     GetSetParam f;
     f.set_int = p->setter;
@@ -532,11 +532,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* name, int argType, const vo
         CV_Error(CV_StsBadArg, "Unknown/unsupported parameter type");
 }
 
-void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, void* value) const
+void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argType, void* value) const
 {
-    const Param* p = findstr(data->params, name);
+    const Param* p = findstr(data->params, parameter);
     if( !p )
-        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") );
+        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
 
     GetSetParam f;
     f.get_int = p->getter;
@@ -606,20 +606,20 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, vo
 }
 
 
-int AlgorithmInfo::paramType(const char* name) const
+int AlgorithmInfo::paramType(const char* parameter) const
 {
-    const Param* p = findstr(data->params, name);
+    const Param* p = findstr(data->params, parameter);
     if( !p )
-        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") );
+        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
     return p->type;
 }
 
 
-string AlgorithmInfo::paramHelp(const char* name) const
+string AlgorithmInfo::paramHelp(const char* parameter) const
 {
-    const Param* p = findstr(data->params, name);
+    const Param* p = findstr(data->params, parameter);
     if( !p )
-        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") );
+        CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
     return p->help;
 }
 
@@ -630,7 +630,7 @@ void AlgorithmInfo::getParams(vector<string>& names) const
 }
 
 
-void AlgorithmInfo::addParam_(Algorithm& algo, const char* name, int argType,
+void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argType,
                               void* value, bool readOnly,
                               Algorithm::Getter getter, Algorithm::Setter setter,
                               const string& help)
@@ -639,79 +639,79 @@ void AlgorithmInfo::addParam_(Algorithm& algo, const char* name, int argType,
                argType == Param::REAL || argType == Param::STRING ||
                argType == Param::MAT || argType == Param::MAT_VECTOR ||
                argType == Param::ALGORITHM );
-    data->params.add(string(name), Param(argType, readOnly,
+    data->params.add(string(parameter), Param(argType, readOnly,
                      (int)((size_t)value - (size_t)(void*)&algo),
                      getter, setter, help));
 }
 
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              int& value, bool readOnly,
                              int (Algorithm::*getter)(),
                              void (Algorithm::*setter)(int),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<int>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<int>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              bool& value, bool readOnly,
                              int (Algorithm::*getter)(),
                              void (Algorithm::*setter)(int),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<bool>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<bool>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              double& value, bool readOnly,
                              double (Algorithm::*getter)(),
                              void (Algorithm::*setter)(double),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<double>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<double>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              string& value, bool readOnly,
                              string (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const string&),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<string>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<string>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              Mat& value, bool readOnly,
                              Mat (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const Mat&),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<Mat>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<Mat>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              vector<Mat>& value, bool readOnly,
                              vector<Mat> (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const vector<Mat>&),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<vector<Mat> >::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<vector<Mat> >::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 
-void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
                              Ptr<Algorithm>& value, bool readOnly,
                              Ptr<Algorithm> (Algorithm::*getter)(),
                              void (Algorithm::*setter)(const Ptr<Algorithm>&),
                              const string& help)
 {
-    addParam_(algo, name, ParamType<Algorithm>::type, &value, readOnly,
+    addParam_(algo, parameter, ParamType<Algorithm>::type, &value, readOnly,
               (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
 }
 

modules/core/src/alloc.cpp

@@ -55,7 +55,9 @@ static void* OutOfMemoryError(size_t size)
 
 #if CV_USE_SYSTEM_MALLOC
 
+#if defined WIN32 || defined _WIN32
 void deleteThreadAllocData() {}
+#endif
 
 void* fastMalloc( size_t size )
 {

modules/core/src/arithm.cpp

@@ -974,7 +974,7 @@ void convertAndUnrollScalar( const Mat& sc, int buftype, uchar* scbuf, size_t bl
         scbuf[i] = scbuf[i - esz];
 }
 
-void binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
+static void binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
                InputArray _mask, const BinaryFunc* tab, bool bitwise)
 {
     int kind1 = _src1.kind(), kind2 = _src2.kind();
@@ -1216,7 +1216,7 @@ void cv::min(const Mat& src1, double src2, Mat& dst)
 namespace cv
 {
 
-void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
+static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
                InputArray _mask, int dtype, BinaryFunc* tab, bool muldiv=false, void* usrdata=0)
 {
     int kind1 = _src1.kind(), kind2 = _src2.kind();

modules/core/src/cmdparser.cpp

@@ -6,6 +6,7 @@
 using namespace std;
 using namespace cv;
 
+namespace {
 void helpParser()
 {
     printf("\nThe CommandLineParser class is designed for command line arguments parsing\n"
@@ -89,6 +90,8 @@ string del_space(string name)
 	return name;
 }
 
+}//namespace
+
 CommandLineParser::CommandLineParser(int argc, const char* const argv[], const char* keys)
 {
 	std::string keys_buffer;

modules/core/src/convert.cpp

@@ -328,8 +328,8 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
             if( j + blocksize < total )
             {
                 ptrs[0] += bsz*esz;
-                for( int k = 0; k < cn; k++ )
+                for( int t = 0; t < cn; t++ )
-                    ptrs[k+1] += bsz*esz1;
+                    ptrs[t+1] += bsz*esz1;
             }
         }
     }
@@ -480,12 +480,12 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
             dsts[k] = ptrs[tab[k*4+2]] + tab[k*4+3];
         }
 
-        for( int j = 0; j < total; j += blocksize )
+        for( int t = 0; t < total; t += blocksize )
         {
-            int bsz = std::min(total - j, blocksize);
+            int bsz = std::min(total - t, blocksize);
             func( srcs, sdelta, dsts, ddelta, bsz, (int)npairs );
 
-            if( j + blocksize < total )
+            if( t + blocksize < total )
                 for( k = 0; k < npairs; k++ )
                 {
                     srcs[k] += blocksize*sdelta[k]*esz1;

modules/core/src/copy.cpp

@@ -193,10 +193,10 @@ void Mat::copyTo( OutputArray _dst ) const
         const Mat* arrays[] = { this, &dst };
         uchar* ptrs[2];
         NAryMatIterator it(arrays, ptrs, 2);
-        size_t size = it.size*elemSize();
+        size_t sz = it.size*elemSize();
 
         for( size_t i = 0; i < it.nplanes; i++, ++it )
-            memcpy(ptrs[1], ptrs[0], size);
+            memcpy(ptrs[1], ptrs[0], sz);
     }
 }
 
@@ -242,14 +242,14 @@ void Mat::copyTo( OutputArray _dst, InputArray _mask ) const
 Mat& Mat::operator = (const Scalar& s)
 {
     const Mat* arrays[] = { this };
-    uchar* ptr;
+    uchar* dptr;
-    NAryMatIterator it(arrays, &ptr, 1);
+    NAryMatIterator it(arrays, &dptr, 1);
-    size_t size = it.size*elemSize();
+    size_t elsize = it.size*elemSize();
 
     if( s[0] == 0 && s[1] == 0 && s[2] == 0 && s[3] == 0 )
     {
         for( size_t i = 0; i < it.nplanes; i++, ++it )
-            memset( ptr, 0, size );
+            memset( dptr, 0, elsize );
     }
     else
     {
@@ -259,17 +259,17 @@ Mat& Mat::operator = (const Scalar& s)
             scalarToRawData(s, scalar, type(), 12);
             size_t blockSize = 12*elemSize1();
 
-            for( size_t j = 0; j < size; j += blockSize )
+            for( size_t j = 0; j < elsize; j += blockSize )
             {
-                size_t sz = MIN(blockSize, size - j);
+                size_t sz = MIN(blockSize, elsize - j);
-                memcpy( ptr + j, scalar, sz );
+                memcpy( dptr + j, scalar, sz );
             }
         }
 
         for( size_t i = 1; i < it.nplanes; i++ )
         {
             ++it;
-            memcpy( ptr, data, size );
+            memcpy( dptr, data, elsize );
         }
     }
     return *this;
@@ -292,16 +292,16 @@ Mat& Mat::setTo(InputArray _value, InputArray _mask)
     const Mat* arrays[] = { this, !mask.empty() ? &mask : 0, 0 };
     uchar* ptrs[2]={0,0};
     NAryMatIterator it(arrays, ptrs);
-    int total = (int)it.size, blockSize0 = std::min(total, (int)((BLOCK_SIZE + esz-1)/esz));
+    int totalsz = (int)it.size, blockSize0 = std::min(totalsz, (int)((BLOCK_SIZE + esz-1)/esz));
     AutoBuffer<uchar> _scbuf(blockSize0*esz + 32);
     uchar* scbuf = alignPtr((uchar*)_scbuf, (int)sizeof(double));
     convertAndUnrollScalar( value, type(), scbuf, blockSize0 );
 
     for( size_t i = 0; i < it.nplanes; i++, ++it )
     {
-        for( int j = 0; j < total; j += blockSize0 )
+        for( int j = 0; j < totalsz; j += blockSize0 )
         {
-            Size sz(std::min(blockSize0, total - j), 1);
+            Size sz(std::min(blockSize0, totalsz - j), 1);
             size_t blockSize = sz.width*esz;
             if( ptrs[1] )
             {

modules/core/src/datastructs.cpp

@@ -3653,7 +3653,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
         points.create(_points.size(), _points.type());
     }
 
-    int i, j, n = _points.rows, dims = _points.cols, top = 0;
+    int i, j, n = _points.rows, ptdims = _points.cols, top = 0;
     const float* data = _points.ptr<float>(0);
     float* dstdata = points.ptr<float>(0);
     size_t step = _points.step1();
@@ -3669,7 +3669,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
         _labels_data = (const int*)_labels.data;
     }
 
-    Mat sumstack(MAX_TREE_DEPTH*2, dims*2, CV_64F);
+    Mat sumstack(MAX_TREE_DEPTH*2, ptdims*2, CV_64F);
     SubTree stack[MAX_TREE_DEPTH*2];
 
     vector<size_t> _ptofs(n);
@@ -3700,7 +3700,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
             {
                 const float* src = data + ptofs[first];
                 float* dst = dstdata + idx*dstep;
-                for( j = 0; j < dims; j++ )
+                for( j = 0; j < ptdims; j++ )
                     dst[j] = src[j];
             }
             labels[idx] = _labels_data ? _labels_data[idx0] : idx0;
@@ -3709,7 +3709,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
         }
 
         // find the dimensionality with the biggest variance
-        for( j = 0; j < dims; j++ )
+        for( j = 0; j < ptdims; j++ )
         {
             double m = sums[j*2]*invCount;
             double varj = sums[j*2+1]*invCount - m*m;
@@ -3729,9 +3729,9 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
         nodes[nidx].boundary = medianPartition(ptofs, first, last, data + dim);
 
         int middle = (first + last)/2;
-        double *lsums = (double*)sums, *rsums = lsums + dims*2;
+        double *lsums = (double*)sums, *rsums = lsums + ptdims*2;
         computeSums(points, ptofs, middle+1, last, rsums);
-        for( j = 0; j < dims*2; j++ )
+        for( j = 0; j < ptdims*2; j++ )
             lsums[j] = sums[j] - rsums[j];
         stack[top++] = SubTree(first, middle, left, depth+1);
         stack[top++] = SubTree(middle+1, last, right, depth+1);
@@ -3758,7 +3758,7 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
     CV_Assert( vecmat.isContinuous() && vecmat.type() == CV_32F && vecmat.total() == (size_t)points.cols );
     const float* vec = vecmat.ptr<float>();
     K = std::min(K, points.rows);
-    int dims = points.cols;
+    int ptdims = points.cols;
 
     CV_Assert(K > 0 && (normType == NORM_L2 || normType == NORM_L1));
 
@@ -3819,13 +3819,13 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
                 i = ~n.idx;
                 const float* row = points.ptr<float>(i);
                 if( normType == NORM_L2 )
-                    for( j = 0, d = 0.f; j < dims; j++ )
+                    for( j = 0, d = 0.f; j < ptdims; j++ )
                     {
                         float t = vec[j] - row[j];
                         d += t*t;
                     }
                 else
-                    for( j = 0, d = 0.f; j < dims; j++ )
+                    for( j = 0, d = 0.f; j < ptdims; j++ )
                         d += std::abs(vec[j] - row[j]);
 
                 dist[ncount] = d;
@@ -3898,14 +3898,14 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
                             OutputArray _neighbors,
                             OutputArray _labels ) const
 {
-    int dims = points.cols;
+    int ptdims = points.cols;
     Mat lowerBound = _lowerBound.getMat(), upperBound = _upperBound.getMat();
     CV_Assert( lowerBound.size == upperBound.size &&
                lowerBound.isContinuous() &&
                upperBound.isContinuous() &&
                lowerBound.type() == upperBound.type() &&
                lowerBound.type() == CV_32F &&
-               lowerBound.total() == (size_t)dims );
+               lowerBound.total() == (size_t)ptdims );
     const float* L = lowerBound.ptr<float>();
     const float* R = upperBound.ptr<float>();
 
@@ -3926,10 +3926,10 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
         {
             int j, i = ~n.idx;
             const float* row = points.ptr<float>(i);
-            for( j = 0; j < dims; j++ )
+            for( j = 0; j < ptdims; j++ )
                 if( row[j] < L[j] || row[j] >= R[j] )
                     break;
-            if( j == dims )
+            if( j == ptdims )
                 idx.push_back(i);
             continue;
         }
@@ -3957,7 +3957,7 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
     const int* idx = idxmat.ptr<int>();
     int* dstlabels = 0;
 
-    int dims = points.cols;
+    int ptdims = points.cols;
     int i, nidx = (int)idxmat.total();
     if( nidx == 0 )
     {
@@ -3968,7 +3968,7 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
 
     if( _pts.needed() )
     {
-        _pts.create( nidx, dims, points.type());
+        _pts.create( nidx, ptdims, points.type());
         pts = _pts.getMat();
     }
 
@@ -3987,7 +3987,7 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
         CV_Assert( (unsigned)k < (unsigned)points.rows );
         const float* src = points.ptr<float>(k);
         if( pts.data )
-            std::copy(src, src + dims, pts.ptr<float>(i));
+            std::copy(src, src + ptdims, pts.ptr<float>(i));
         if( dstlabels )
             dstlabels[i] = srclabels ? srclabels[k] : k;
     }

modules/core/src/drawing.cpp

@@ -169,7 +169,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
     }
 
     int bt_pix0 = (int)img.elemSize(), bt_pix = bt_pix0;
-    size_t step = img.step;
+    size_t istep = img.step;
 
     int dx = pt2.x - pt1.x;
     int dy = pt2.y - pt1.y;
@@ -188,11 +188,11 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
         bt_pix = (bt_pix ^ s) - s;
     }
 
-    ptr = (uchar*)(img.data + pt1.y * step + pt1.x * bt_pix0);
+    ptr = (uchar*)(img.data + pt1.y * istep + pt1.x * bt_pix0);
 
     s = dy < 0 ? -1 : 0;
     dy = (dy ^ s) - s;
-    step = (step ^ s) - s;
+    istep = (istep ^ s) - s;
 
     s = dy > dx ? -1 : 0;
 
@@ -201,9 +201,9 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
     dy ^= dx & s;
     dx ^= dy & s;
 
-    bt_pix ^= step & s;
+    bt_pix ^= istep & s;
-    step ^= bt_pix & s;
+    istep ^= bt_pix & s;
-    bt_pix ^= step & s;
+    bt_pix ^= istep & s;
 
     if( connectivity == 8 )
     {
@@ -212,7 +212,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
         err = dx - (dy + dy);
         plusDelta = dx + dx;
         minusDelta = -(dy + dy);
-        plusStep = (int)step;
+        plusStep = (int)istep;
         minusStep = bt_pix;
         count = dx + 1;
     }
@@ -223,7 +223,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
         err = 0;
         plusDelta = (dx + dx) + (dy + dy);
         minusDelta = -(dy + dy);
-        plusStep = (int)step - bt_pix;
+        plusStep = (int)istep - bt_pix;
         minusStep = bt_pix;
         count = dx + dy + 1;
     }

modules/core/src/gpumat.cpp

@@ -524,30 +524,30 @@ cv::gpu::GpuMat::GpuMat(Size size_, int type_, void* data_, size_t step_) :
     dataend += step * (rows - 1) + minstep;
 }
 
-cv::gpu::GpuMat::GpuMat(const GpuMat& m, Range rowRange, Range colRange)
+cv::gpu::GpuMat::GpuMat(const GpuMat& m, Range _rowRange, Range _colRange)
 {
     flags = m.flags;
     step = m.step; refcount = m.refcount;
     data = m.data; datastart = m.datastart; dataend = m.dataend;
 
-    if (rowRange == Range::all())
+    if (_rowRange == Range::all())
         rows = m.rows;
     else
     {
-        CV_Assert(0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows);
+        CV_Assert(0 <= _rowRange.start && _rowRange.start <= _rowRange.end && _rowRange.end <= m.rows);
 
-        rows = rowRange.size();
+        rows = _rowRange.size();
-        data += step*rowRange.start;
+        data += step*_rowRange.start;
     }
 
-    if (colRange == Range::all())
+    if (_colRange == Range::all())
         cols = m.cols;
     else
     {
-        CV_Assert(0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols);
+        CV_Assert(0 <= _colRange.start && _colRange.start <= _colRange.end && _colRange.end <= m.cols);
 
-        cols = colRange.size();
+        cols = _colRange.size();
-        data += colRange.start*elemSize();
+        data += _colRange.start*elemSize();
         flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
     }
 

modules/core/src/mathfuncs.cpp

@@ -1845,37 +1845,37 @@ iPow_( const T* src, T* dst, int len, int power )
 }
 
 
-void iPow8u(const uchar* src, uchar* dst, int len, int power)
+static void iPow8u(const uchar* src, uchar* dst, int len, int power)
 {
     iPow_<uchar, int>(src, dst, len, power);
 }
 
-void iPow8s(const schar* src, schar* dst, int len, int power)
+static void iPow8s(const schar* src, schar* dst, int len, int power)
 {
     iPow_<schar, int>(src, dst, len, power);
 }
 
-void iPow16u(const ushort* src, ushort* dst, int len, int power)
+static void iPow16u(const ushort* src, ushort* dst, int len, int power)
 {
     iPow_<ushort, int>(src, dst, len, power);
 }
 
-void iPow16s(const short* src, short* dst, int len, int power)
+static void iPow16s(const short* src, short* dst, int len, int power)
 {
     iPow_<short, int>(src, dst, len, power);
 }
 
-void iPow32s(const int* src, int* dst, int len, int power)
+static void iPow32s(const int* src, int* dst, int len, int power)
 {
     iPow_<int, int>(src, dst, len, power);
 }
 
-void iPow32f(const float* src, float* dst, int len, int power)
+static void iPow32f(const float* src, float* dst, int len, int power)
 {
     iPow_<float, float>(src, dst, len, power);
 }
 
-void iPow64f(const double* src, double* dst, int len, int power)
+static void iPow64f(const double* src, double* dst, int len, int power)
 {
     iPow_<double, double>(src, dst, len, power);
 }

modules/core/src/matmul.cpp

@@ -696,7 +696,7 @@ static void GEMMStore_64fc( const Complexd* c_data, size_t c_step,
 }
 
 void cv::gemm( InputArray matA, InputArray matB, double alpha,
-           InputArray matC, double beta, OutputArray matD, int flags )
+           InputArray matC, double beta, OutputArray _matD, int flags )
 {
     const int block_lin_size = 128;
     const int block_size = block_lin_size * block_lin_size;
@@ -741,8 +741,8 @@ void cv::gemm( InputArray matA, InputArray matB, double alpha,
              ((flags&GEMM_3_T) != 0 && C.rows == d_size.width && C.cols == d_size.height)));
     }
 
-    matD.create( d_size.height, d_size.width, type );
+    _matD.create( d_size.height, d_size.width, type );
-    Mat D = matD.getMat();
+    Mat D = _matD.getMat();
     if( (flags & GEMM_3_T) != 0 && C.data == D.data )
     {
         transpose( C, C );
@@ -2134,12 +2134,12 @@ void cv::calcCovarMatrix( const Mat* data, int nsamples, Mat& covar, Mat& _mean,
         _mean = mean.reshape(1, size.height);
 }
 
-void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray _mean, int flags, int ctype )
+void cv::calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mean, int flags, int ctype )
 {
-    if(_data.kind() == _InputArray::STD_VECTOR_MAT)
+    if(_src.kind() == _InputArray::STD_VECTOR_MAT)
     {
         std::vector<cv::Mat> src;
-        _data.getMatVector(src);
+        _src.getMatVector(src);
 
         CV_Assert( src.size() > 0 );
 
@@ -2185,7 +2185,7 @@ void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray
         return;
     }
 
-    Mat data = _data.getMat(), mean;
+    Mat data = _src.getMat(), mean;
     CV_Assert( ((flags & CV_COVAR_ROWS) != 0) ^ ((flags & CV_COVAR_COLS) != 0) );
     bool takeRows = (flags & CV_COVAR_ROWS) != 0;
     int type = data.type();
@@ -2209,7 +2209,7 @@ void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray
     else
     {
         ctype = std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), CV_32F);
-        reduce( _data, _mean, takeRows ? 0 : 1, CV_REDUCE_AVG, ctype );
+        reduce( _src, _mean, takeRows ? 0 : 1, CV_REDUCE_AVG, ctype );
         mean = _mean.getMat();
     }
 
@@ -2806,9 +2806,9 @@ double Mat::dot(InputArray _mat) const
 
 PCA::PCA() {}
 
-PCA::PCA(InputArray data, InputArray mean, int flags, int maxComponents)
+PCA::PCA(InputArray data, InputArray _mean, int flags, int maxComponents)
 {
-    operator()(data, mean, flags, maxComponents);
+    operator()(data, _mean, flags, maxComponents);
 }
 
 PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComponents)

modules/core/src/matop.cpp

@@ -1181,14 +1181,14 @@ int MatExpr::type() const
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_Identity::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_Identity::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    if( type == -1 || type == e.a.type() )
+    if( _type == -1 || _type == e.a.type() )
         m = e.a;
     else
     {
-        CV_Assert( CV_MAT_CN(type) == e.a.channels() );
+        CV_Assert( CV_MAT_CN(_type) == e.a.channels() );
-        e.a.convertTo(m, type);
+        e.a.convertTo(m, _type);
     }
 }
 
@@ -1199,9 +1199,9 @@ inline void MatOp_Identity::makeExpr(MatExpr& res, const Mat& m)
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || e.a.type() == type ? m : temp;
+    Mat temp, &dst = _type == -1 || e.a.type() == _type ? m : temp;
     if( e.b.data )
     {
         if( e.s == Scalar() || !e.s.isReal() )
@@ -1233,7 +1233,7 @@ void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int type) const
     }
     else if( e.s.isReal() && (dst.data != m.data || fabs(e.alpha) != 1))
     {
-        e.a.convertTo(m, type, e.alpha, e.s[0]);
+        e.a.convertTo(m, _type, e.alpha, e.s[0]);
         return;
     }
     else if( e.alpha == 1 )
@@ -1308,9 +1308,9 @@ inline void MatOp_AddEx::makeExpr(MatExpr& res, const Mat& a, const Mat& b, doub
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_Bin::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_Bin::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || e.a.type() == type ? m : temp;
+    Mat temp, &dst = _type == -1 || e.a.type() == _type ? m : temp;
 
     if( e.flags == '*' )
         cv::multiply(e.a, e.b, dst, e.alpha);
@@ -1348,7 +1348,7 @@ void MatOp_Bin::assign(const MatExpr& e, Mat& m, int type) const
         CV_Error(CV_StsError, "Unknown operation");
 
     if( dst.data != m.data )
-        dst.convertTo(m, type);
+        dst.convertTo(m, _type);
 }
 
 void MatOp_Bin::multiply(const MatExpr& e, double s, MatExpr& res) const
@@ -1382,9 +1382,9 @@ inline void MatOp_Bin::makeExpr(MatExpr& res, char op, const Mat& a, const Scala
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || type == CV_8U ? m : temp;
+    Mat temp, &dst = _type == -1 || _type == CV_8U ? m : temp;
 
     if( e.b.data )
         cv::compare(e.a, e.b, dst, e.flags);
@@ -1392,7 +1392,7 @@ void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int type) const
         cv::compare(e.a, e.alpha, dst, e.flags);
 
     if( dst.data != m.data )
-        dst.convertTo(m, type);
+        dst.convertTo(m, _type);
 }
 
 inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, const Mat& b)
@@ -1407,14 +1407,14 @@ inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, double al
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_T::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_T::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
+    Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
 
     cv::transpose(e.a, dst);
 
     if( dst.data != m.data || e.alpha != 1 )
-        dst.convertTo(m, type, e.alpha);
+        dst.convertTo(m, _type, e.alpha);
 }
 
 void MatOp_T::multiply(const MatExpr& e, double s, MatExpr& res) const
@@ -1438,13 +1438,13 @@ inline void MatOp_T::makeExpr(MatExpr& res, const Mat& a, double alpha)
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_GEMM::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_GEMM::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
+    Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
 
     cv::gemm(e.a, e.b, e.alpha, e.c, e.beta, dst, e.flags);
     if( dst.data != m.data )
-        dst.convertTo(m, type);
+        dst.convertTo(m, _type);
 }
 
 void MatOp_GEMM::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
@@ -1503,13 +1503,13 @@ inline void MatOp_GEMM::makeExpr(MatExpr& res, int flags, const Mat& a, const Ma
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_Invert::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_Invert::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
+    Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
 
     cv::invert(e.a, dst, e.flags);
     if( dst.data != m.data )
-        dst.convertTo(m, type);
+        dst.convertTo(m, _type);
 }
 
 void MatOp_Invert::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
@@ -1529,13 +1529,13 @@ inline void MatOp_Invert::makeExpr(MatExpr& res, int method, const Mat& m)
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_Solve::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_Solve::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
+    Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
 
     cv::solve(e.a, e.b, dst, e.flags);
     if( dst.data != m.data )
-        dst.convertTo(m, type);
+        dst.convertTo(m, _type);
 }
 
 inline void MatOp_Solve::makeExpr(MatExpr& res, int method, const Mat& a, const Mat& b)
@@ -1545,11 +1545,11 @@ inline void MatOp_Solve::makeExpr(MatExpr& res, int method, const Mat& a, const
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void MatOp_Initializer::assign(const MatExpr& e, Mat& m, int type) const
+void MatOp_Initializer::assign(const MatExpr& e, Mat& m, int _type) const
 {
-    if( type == -1 )
+    if( _type == -1 )
-        type = e.a.type();
+        _type = e.a.type();
-    m.create(e.a.size(), type);
+    m.create(e.a.size(), _type);
     if( e.flags == 'I' )
         setIdentity(m, Scalar(e.alpha));
     else if( e.flags == '0' )

modules/core/src/matrix.cpp

@@ -210,9 +210,9 @@ void Mat::create(int d, const int* _sizes, int _type)
 #endif
         if( !allocator )
         {
-            size_t total = alignSize(step.p[0]*size.p[0], (int)sizeof(*refcount));
+            size_t totalsize = alignSize(step.p[0]*size.p[0], (int)sizeof(*refcount));
-            data = datastart = (uchar*)fastMalloc(total + (int)sizeof(*refcount));
+            data = datastart = (uchar*)fastMalloc(totalsize + (int)sizeof(*refcount));
-            refcount = (int*)(data + total);
+            refcount = (int*)(data + totalsize);
             *refcount = 1;
         }
         else
@@ -225,9 +225,9 @@ void Mat::create(int d, const int* _sizes, int _type)
             }catch(...)
             {
                 allocator = 0;
-                size_t total = alignSize(step.p[0]*size.p[0], (int)sizeof(*refcount));
+                size_t totalSize = alignSize(step.p[0]*size.p[0], (int)sizeof(*refcount));
-                data = datastart = (uchar*)fastMalloc(total + (int)sizeof(*refcount));
+                data = datastart = (uchar*)fastMalloc(totalSize + (int)sizeof(*refcount));
-                refcount = (int*)(data + total);
+                refcount = (int*)(data + totalSize);
                 *refcount = 1;
             }
 #else
@@ -262,15 +262,15 @@ void Mat::deallocate()
 }
 
 
-Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) : size(&rows)
+Mat::Mat(const Mat& m, const Range& _rowRange, const Range& _colRange) : size(&rows)
 {
     initEmpty();
     CV_Assert( m.dims >= 2 );
     if( m.dims > 2 )
     {
         AutoBuffer<Range> rs(m.dims);
-        rs[0] = rowRange;
+        rs[0] = _rowRange;
-        rs[1] = colRange;
+        rs[1] = _colRange;
         for( int i = 2; i < m.dims; i++ )
             rs[i] = Range::all();
         *this = m(rs);
@@ -278,19 +278,19 @@ Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) : size(&row
     }
 
     *this = m;
-    if( rowRange != Range::all() && rowRange != Range(0,rows) )
+    if( _rowRange != Range::all() && _rowRange != Range(0,rows) )
     {
-        CV_Assert( 0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows );
+        CV_Assert( 0 <= _rowRange.start && _rowRange.start <= _rowRange.end && _rowRange.end <= m.rows );
-        rows = rowRange.size();
+        rows = _rowRange.size();
-        data += step*rowRange.start;
+        data += step*_rowRange.start;
         flags |= SUBMATRIX_FLAG;
     }
 
-    if( colRange != Range::all() && colRange != Range(0,cols) )
+    if( _colRange != Range::all() && _colRange != Range(0,cols) )
     {
-        CV_Assert( 0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols );
+        CV_Assert( 0 <= _colRange.start && _colRange.start <= _colRange.end && _colRange.end <= m.cols );
-        cols = colRange.size();
+        cols = _colRange.size();
-        data += colRange.start*elemSize();
+        data += _colRange.start*elemSize();
         flags &= cols < m.cols ? ~CONTINUOUS_FLAG : -1;
         flags |= SUBMATRIX_FLAG;
     }
@@ -473,14 +473,14 @@ Mat::Mat(const IplImage* img, bool copyData) : size(&rows)
     dims = 2;
     CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);
 
-    int depth = IPL2CV_DEPTH(img->depth);
+    int imgdepth = IPL2CV_DEPTH(img->depth);
     size_t esz;
     step[0] = img->widthStep;
 
     if(!img->roi)
     {
         CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL);
-        flags = MAGIC_VAL + CV_MAKETYPE(depth, img->nChannels);
+        flags = MAGIC_VAL + CV_MAKETYPE(imgdepth, img->nChannels);
         rows = img->height; cols = img->width;
         datastart = data = (uchar*)img->imageData;
         esz = CV_ELEM_SIZE(flags);
@@ -489,7 +489,7 @@ Mat::Mat(const IplImage* img, bool copyData) : size(&rows)
     {
         CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0);
         bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE;
-        flags = MAGIC_VAL + CV_MAKETYPE(depth, selectedPlane ? 1 : img->nChannels);
+        flags = MAGIC_VAL + CV_MAKETYPE(imgdepth, selectedPlane ? 1 : img->nChannels);
         rows = img->roi->height; cols = img->roi->width;
         esz = CV_ELEM_SIZE(flags);
         data = datastart = (uchar*)img->imageData +
@@ -917,6 +917,9 @@ void scalarToRawData(const Scalar& s, void* _buf, int type, int unroll_to)
 \*************************************************************************************************/
 
 _InputArray::_InputArray() : flags(0), obj(0) {}
+#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
+_InputArray::~_InputArray() {}
+#endif
 _InputArray::_InputArray(const Mat& m) : flags(MAT), obj((void*)&m) {}
 _InputArray::_InputArray(const vector<Mat>& vec) : flags(STD_VECTOR_MAT), obj((void*)&vec) {}
 _InputArray::_InputArray(const double& val) : flags(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F), obj((void*)&val), sz(Size(1,1)) {}
@@ -1280,6 +1283,9 @@ bool _InputArray::empty() const
 
 
 _OutputArray::_OutputArray() {}
+#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
+_OutputArray::~_OutputArray() {}
+#endif
 _OutputArray::_OutputArray(Mat& m) : _InputArray(m) {}
 _OutputArray::_OutputArray(vector<Mat>& vec) : _InputArray(vec) {}
 
@@ -1297,38 +1303,38 @@ bool _OutputArray::fixedType() const
     return (flags & FIXED_TYPE) == FIXED_TYPE;
 }
 
-void _OutputArray::create(Size _sz, int type, int i, bool allowTransposed, int fixedDepthMask) const
+void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, int fixedDepthMask) const
 {
     int k = kind();
     if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 )
     {
         CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == _sz);
-        CV_Assert(!fixedType() || ((Mat*)obj)->type() == type);
+        CV_Assert(!fixedType() || ((Mat*)obj)->type() == mtype);
-        ((Mat*)obj)->create(_sz, type);
+        ((Mat*)obj)->create(_sz, mtype);
         return;
     }
-    int sz[] = {_sz.height, _sz.width};
+    int sizes[] = {_sz.height, _sz.width};
-    create(2, sz, type, i, allowTransposed, fixedDepthMask);
+    create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
 }
 
-void _OutputArray::create(int rows, int cols, int type, int i, bool allowTransposed, int fixedDepthMask) const
+void _OutputArray::create(int rows, int cols, int mtype, int i, bool allowTransposed, int fixedDepthMask) const
 {
     int k = kind();
     if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 )
     {
         CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == Size(cols, rows));
-        CV_Assert(!fixedType() || ((Mat*)obj)->type() == type);
+        CV_Assert(!fixedType() || ((Mat*)obj)->type() == mtype);
-        ((Mat*)obj)->create(rows, cols, type);
+        ((Mat*)obj)->create(rows, cols, mtype);
         return;
     }
-    int sz[] = {rows, cols};
+    int sizes[] = {rows, cols};
-    create(2, sz, type, i, allowTransposed, fixedDepthMask);
+    create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
 }
 
-void _OutputArray::create(int dims, const int* size, int type, int i, bool allowTransposed, int fixedDepthMask) const
+void _OutputArray::create(int dims, const int* sizes, int mtype, int i, bool allowTransposed, int fixedDepthMask) const
 {
     int k = kind();
-    type = CV_MAT_TYPE(type);
+    mtype = CV_MAT_TYPE(mtype);
 
     if( k == MAT )
     {
@@ -1343,24 +1349,24 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
             }
 
             if( dims == 2 && m.dims == 2 && m.data &&
-                m.type() == type && m.rows == size[1] && m.cols == size[0] )
+                m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] )
                 return;
         }
 
         if(fixedType())
         {
-            if(CV_MAT_CN(type) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 )
+            if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 )
-                type = m.type();
+                mtype = m.type();
             else
-                CV_Assert(CV_MAT_TYPE(type) == m.type());
+                CV_Assert(CV_MAT_TYPE(mtype) == m.type());
         }
         if(fixedSize())
         {
             CV_Assert(m.dims == dims);
             for(int j = 0; j < dims; ++j)
-                CV_Assert(m.size[j] == size[j]);
+                CV_Assert(m.size[j] == sizes[j]);
         }
-        m.create(dims, size, type);
+        m.create(dims, sizes, mtype);
         return;
     }
 
@@ -1368,16 +1374,16 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
     {
         CV_Assert( i < 0 );
         int type0 = CV_MAT_TYPE(flags);
-        CV_Assert( type == type0 || (CV_MAT_CN(type) == 1 && ((1 << type0) & fixedDepthMask) != 0) );
+        CV_Assert( mtype == type0 || (CV_MAT_CN(mtype) == 1 && ((1 << type0) & fixedDepthMask) != 0) );
-        CV_Assert( dims == 2 && ((size[0] == sz.height && size[1] == sz.width) ||
+        CV_Assert( dims == 2 && ((sizes[0] == sz.height && sizes[1] == sz.width) ||
-                                 (allowTransposed && size[0] == sz.width && size[1] == sz.height)));
+                                 (allowTransposed && sizes[0] == sz.width && sizes[1] == sz.height)));
         return;
     }
 
     if( k == STD_VECTOR || k == STD_VECTOR_VECTOR )
     {
-        CV_Assert( dims == 2 && (size[0] == 1 || size[1] == 1 || size[0]*size[1] == 0) );
+        CV_Assert( dims == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) );
-        size_t len = size[0]*size[1] > 0 ? size[0] + size[1] - 1 : 0;
+        size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0;
         vector<uchar>* v = (vector<uchar>*)obj;
 
         if( k == STD_VECTOR_VECTOR )
@@ -1396,7 +1402,7 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
             CV_Assert( i < 0 );
 
         int type0 = CV_MAT_TYPE(flags);
-        CV_Assert( type == type0 || (CV_MAT_CN(type) == CV_MAT_CN(type0) && ((1 << type0) & fixedDepthMask) != 0) );
+        CV_Assert( mtype == type0 || (CV_MAT_CN(mtype) == CV_MAT_CN(type0) && ((1 << type0) & fixedDepthMask) != 0) );
 
         int esz = CV_ELEM_SIZE(type0);
         CV_Assert(!fixedSize() || len == ((vector<uchar>*)v)->size() / esz);
@@ -1469,20 +1475,20 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
 
         if( i < 0 )
         {
-            CV_Assert( dims == 2 && (size[0] == 1 || size[1] == 1 || size[0]*size[1] == 0) );
+            CV_Assert( dims == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) );
-            size_t len = size[0]*size[1] > 0 ? size[0] + size[1] - 1 : 0, len0 = v.size();
+            size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0, len0 = v.size();
 
             CV_Assert(!fixedSize() || len == len0);
             v.resize(len);
             if( fixedType() )
             {
-                int type = CV_MAT_TYPE(flags);
+                int _type = CV_MAT_TYPE(flags);
                 for( size_t j = len0; j < len; j++ )
                 {
-                    if( v[i].type() == type )
+                    if( v[i].type() == _type )
                         continue;
                     CV_Assert( v[i].empty() );
-                    v[i].flags = (v[i].flags & ~CV_MAT_TYPE_MASK) | type;
+                    v[i].flags = (v[i].flags & ~CV_MAT_TYPE_MASK) | _type;
                 }
             }
             return;
@@ -1500,25 +1506,25 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
             }
 
             if( dims == 2 && m.dims == 2 && m.data &&
-                m.type() == type && m.rows == size[1] && m.cols == size[0] )
+                m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] )
                 return;
         }
 
         if(fixedType())
         {
-            if(CV_MAT_CN(type) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 )
+            if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 )
-                type = m.type();
+                mtype = m.type();
             else
-                CV_Assert(!fixedType() || (CV_MAT_CN(type) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0));
+                CV_Assert(!fixedType() || (CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0));
         }
         if(fixedSize())
         {
             CV_Assert(m.dims == dims);
             for(int j = 0; j < dims; ++j)
-                CV_Assert(m.size[j] == size[j]);
+                CV_Assert(m.size[j] == sizes[j]);
         }
 
-        m.create(dims, size, type);
+        m.create(dims, sizes, mtype);
     }
 }
 
@@ -1927,10 +1933,10 @@ void cv::completeSymm( InputOutputArray _m, bool LtoR )
 cv::Mat cv::Mat::cross(InputArray _m) const
 {
     Mat m = _m.getMat();
-    int t = type(), d = CV_MAT_DEPTH(t);
+    int tp = type(), d = CV_MAT_DEPTH(tp);
-    CV_Assert( dims <= 2 && m.dims <= 2 && size() == m.size() && t == m.type() &&
+    CV_Assert( dims <= 2 && m.dims <= 2 && size() == m.size() && tp == m.type() &&
         ((rows == 3 && cols == 1) || (cols*channels() == 3 && rows == 1)));
-    Mat result(rows, cols, t);
+    Mat result(rows, cols, tp);
 
     if( d == CV_32F )
     {
@@ -2843,7 +2849,7 @@ cvRange( CvArr* arr, double start, double end )
 CV_IMPL void
 cvSort( const CvArr* _src, CvArr* _dst, CvArr* _idx, int flags )
 {
-    cv::Mat src = cv::cvarrToMat(_src), dst, idx;
+    cv::Mat src = cv::cvarrToMat(_src);
 
     if( _idx )
     {
@@ -3260,7 +3266,7 @@ convertScaleData_(const void* _from, void* _to, int cn, double alpha, double bet
             to[i] = saturate_cast<T2>(from[i]*alpha + beta);
 }
 
-ConvertData getConvertData(int fromType, int toType)
+static ConvertData getConvertData(int fromType, int toType)
 {
     static ConvertData tab[][8] =
     {{ convertData_<uchar, uchar>, convertData_<uchar, schar>,
@@ -3305,7 +3311,7 @@ ConvertData getConvertData(int fromType, int toType)
     return func;
 }
 
-ConvertScaleData getConvertScaleData(int fromType, int toType)
+static ConvertScaleData getConvertScaleData(int fromType, int toType)
 {
     static ConvertScaleData tab[][8] =
     {{ convertScaleData_<uchar, uchar>, convertScaleData_<uchar, schar>,
@@ -3408,22 +3414,22 @@ SparseMat::SparseMat(const Mat& m)
 
     int i, idx[CV_MAX_DIM] = {0}, d = m.dims, lastSize = m.size[d - 1];
     size_t esz = m.elemSize();
-    uchar* ptr = m.data;
+    uchar* dptr = m.data;
 
     for(;;)
     {
-        for( i = 0; i < lastSize; i++, ptr += esz )
+        for( i = 0; i < lastSize; i++, dptr += esz )
         {
-            if( isZeroElem(ptr, esz) )
+            if( isZeroElem(dptr, esz) )
                 continue;
             idx[d-1] = i;
             uchar* to = newNode(idx, hash(idx));
-            copyElem( ptr, to, esz );
+            copyElem( dptr, to, esz );
         }
 
         for( i = d - 2; i >= 0; i-- )
         {
-            ptr += m.step[i] - m.size[i+1]*m.step[i+1];
+            dptr += m.step[i] - m.size[i+1]*m.step[i+1];
             if( ++idx[i] < m.size[i] )
                 break;
             idx[i] = 0;

modules/core/src/opengl_interop.cpp

@@ -484,57 +484,57 @@ inline void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream)
 
 #endif // HAVE_OPENGL
 
-cv::GlBuffer::GlBuffer(Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage)
+cv::GlBuffer::GlBuffer(Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
 {
 #ifndef HAVE_OPENGL
-	(void)usage;
+    (void)_usage;
     throw_nogl;
 #else
     impl_ = Impl::empty();
 #endif
 }
 
-cv::GlBuffer::GlBuffer(int rows, int cols, int type, Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage)
+cv::GlBuffer::GlBuffer(int _rows, int _cols, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
 {
 #ifndef HAVE_OPENGL
-	(void)rows;
+    (void)_rows;
-	(void)cols;
+    (void)_cols;
-	(void)type;
+    (void)_type;
-	(void)usage;
+    (void)_usage;
     throw_nogl;
 #else
-    impl_ = new Impl(rows, cols, type, usage);
+    impl_ = new Impl(_rows, _cols, _type, _usage);
-    rows_ = rows;
+    rows_ = _rows;
-    cols_ = cols;
+    cols_ = _cols;
-    type_ = type;
+    type_ = _type;
 #endif
 }
 
-cv::GlBuffer::GlBuffer(Size size, int type, Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage)
+cv::GlBuffer::GlBuffer(Size _size, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
 {
 #ifndef HAVE_OPENGL
-	(void)size;
+    (void)_size;
-	(void)type;
+    (void)_type;
-	(void)usage;
+    (void)_usage;
     throw_nogl;
 #else
-    impl_ = new Impl(size.height, size.width, type, usage);
+    impl_ = new Impl(_size.height, _size.width, _type, _usage);
-    rows_ = size.height;
+    rows_ = _size.height;
-    cols_ = size.width;
+    cols_ = _size.width;
-    type_ = type;
+    type_ = _type;
 #endif
 }
 
-cv::GlBuffer::GlBuffer(InputArray mat_, Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage)
+cv::GlBuffer::GlBuffer(InputArray mat_, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
 {
 #ifndef HAVE_OPENGL
     (void)mat_;
-	(void)usage;
+    (void)_usage;
     throw_nogl;
 #else
     int kind = mat_.kind();
-    Size size = mat_.size();
+    Size _size = mat_.size();
-    int type = mat_.type();
+    int _type = mat_.type();
 
     if (kind == _InputArray::GPU_MAT)
     {
@@ -542,38 +542,38 @@ cv::GlBuffer::GlBuffer(InputArray mat_, Usage usage) : rows_(0), cols_(0), type_
             throw_nocuda;
         #else
             GpuMat d_mat = mat_.getGpuMat();
-            impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), usage);
+            impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), _usage);
             impl_->copyFrom(d_mat);
         #endif
     }
     else
     {
         Mat mat = mat_.getMat();
-        impl_ = new Impl(mat, usage);
+        impl_ = new Impl(mat, _usage);
     }
 
-    rows_ = size.height;
+    rows_ = _size.height;
-    cols_ = size.width;
+    cols_ = _size.width;
-    type_ = type;
+    type_ = _type;
 #endif
 }
 
-void cv::GlBuffer::create(int rows, int cols, int type, Usage usage)
+void cv::GlBuffer::create(int _rows, int _cols, int _type, Usage _usage)
 {
 #ifndef HAVE_OPENGL
-	(void)rows;
+    (void)_rows;
-	(void)cols;
+    (void)_cols;
-	(void)type;
+    (void)_type;
-	(void)usage;
+    (void)_usage;
     throw_nogl;
 #else
-    if (rows_ != rows || cols_ != cols || type_ != type || usage_ != usage)
+    if (rows_ != _rows || cols_ != _cols || type_ != _type || usage_ != _usage)
     {
-        impl_ = new Impl(rows, cols, type, usage);
+        impl_ = new Impl(_rows, _cols, _type, _usage);
-        rows_ = rows;
+        rows_ = _rows;
-        cols_ = cols;
+        cols_ = _cols;
-        type_ = type;
+        type_ = _type;
-        usage_ = usage;
+        usage_ = _usage;
     }
 #endif
 }
@@ -594,10 +594,10 @@ void cv::GlBuffer::copyFrom(InputArray mat_)
     throw_nogl;
 #else
     int kind = mat_.kind();
-    Size size = mat_.size();
+    Size _size = mat_.size();
-    int type = mat_.type();
+    int _type = mat_.type();
 
-    create(size, type);
+    create(_size, _type);
 
     switch (kind)
     {
@@ -926,32 +926,32 @@ cv::GlTexture::GlTexture() : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTUR
 #endif
 }
 
-cv::GlTexture::GlTexture(int rows, int cols, int type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+cv::GlTexture::GlTexture(int _rows, int _cols, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
 {
 #ifndef HAVE_OPENGL
-	(void)rows;
+    (void)_rows;
-	(void)cols;
+    (void)_cols;
-	(void)type;
+    (void)_type;
     throw_nogl;
 #else
-    impl_ = new Impl(rows, cols, type);
+    impl_ = new Impl(_rows, _cols, _type);
-    rows_ = rows;
+    rows_ = _rows;
-    cols_ = cols;
+    cols_ = _cols;
-    type_ = type;
+    type_ = _type;
 #endif
 }
 
-cv::GlTexture::GlTexture(Size size, int type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+cv::GlTexture::GlTexture(Size _size, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
 {
 #ifndef HAVE_OPENGL
-	(void)size;
+    (void)_size;
-	(void)type;
+    (void)_type;
     throw_nogl;
 #else
-    impl_ = new Impl(size.height, size.width, type);
+    impl_ = new Impl(_size.height, _size.width, _type);
-    rows_ = size.height;
+    rows_ = _size.height;
-    cols_ = size.width;
+    cols_ = _size.width;
-    type_ = type;
+    type_ = _type;
 #endif
 }
 
@@ -963,8 +963,8 @@ cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_
     throw_nogl;
 #else
     int kind = mat_.kind();
-    Size size = mat_.size();
+    Size _size = mat_.size();
-    int type = mat_.type();
+    int _type = mat_.type();
 
     switch (kind)
     {
@@ -994,26 +994,26 @@ cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_
         }
     }
 
-    rows_ = size.height;
+    rows_ = _size.height;
-    cols_ = size.width;
+    cols_ = _size.width;
-    type_ = type;
+    type_ = _type;
 #endif
 }
 
-void cv::GlTexture::create(int rows, int cols, int type)
+void cv::GlTexture::create(int _rows, int _cols, int _type)
 {
 #ifndef HAVE_OPENGL
-	(void)rows;
+    (void)_rows;
-	(void)cols;
+    (void)_cols;
-	(void)type;
+    (void)_type;
     throw_nogl;
 #else
-    if (rows_ != rows || cols_ != cols || type_ != type)
+    if (rows_ != _rows || cols_ != _cols || type_ != _type)
     {
-        impl_ = new Impl(rows, cols, type);
+        impl_ = new Impl(_rows, _cols, _type);
-        rows_ = rows;
+        rows_ = _rows;
-        cols_ = cols;
+        cols_ = _cols;
-        type_ = type;
+        type_ = _type;
     }
 #endif
 }
@@ -1035,10 +1035,10 @@ void cv::GlTexture::copyFrom(InputArray mat_, bool bgra)
     throw_nogl;
 #else
     int kind = mat_.kind();
-    Size size = mat_.size();
+    Size _size = mat_.size();
-    int type = mat_.type();
+    int _type = mat_.type();
 
-    create(size, type);
+    create(_size, _type);
 
     switch(kind)
     {
@@ -1244,8 +1244,8 @@ void cv::GlArrays::unbind() const
 ////////////////////////////////////////////////////////////////////////
 // GlFont
 
-cv::GlFont::GlFont(const string& family, int height, Weight weight, Style style)
+cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _style)
-    : family_(family), height_(height), weight_(weight), style_(style), base_(0)
+    : family_(_family), height_(_height), weight_(_weight), style_(_style), base_(0)
 {
 #ifndef HAVE_OPENGL
     throw_nogl;
@@ -1253,7 +1253,7 @@ cv::GlFont::GlFont(const string& family, int height, Weight weight, Style style)
     base_ = glGenLists(256);
     CV_CheckGlError();
 
-    glFuncTab()->generateBitmapFont(family, height, weight, (style & STYLE_ITALIC) != 0, (style & STYLE_UNDERLINE) != 0, 0, 256, base_);
+    glFuncTab()->generateBitmapFont(family_, height_, weight_, (style_ & STYLE_ITALIC) != 0, (style_ & STYLE_UNDERLINE) != 0, 0, 256, base_);
 #endif
 }
 

modules/core/src/out.cpp

@@ -243,7 +243,7 @@ static CFormatter cFormatter;
 static const Formatter* g_defaultFormatter0 = &matlabFormatter;
 static const Formatter* g_defaultFormatter = &matlabFormatter;
 
-bool my_streq(const char* a, const char* b)
+static bool my_streq(const char* a, const char* b)
 {
     size_t i, alen = strlen(a), blen = strlen(b);
     if( alen != blen )

modules/core/src/precomp.hpp

@@ -43,11 +43,6 @@
 #ifndef __OPENCV_PRECOMP_H__
 #define __OPENCV_PRECOMP_H__
 
-#if defined _MSC_VER && _MSC_VER >= 1200
-    // disable warnings related to inline functions
-    #pragma warning( disable: 4251 4711 4710 4514 )
-#endif
-
 #ifdef HAVE_CVCONFIG_H 
 #include "cvconfig.h"
 #endif

modules/core/src/stat.cpp

@@ -962,7 +962,7 @@ static const uchar popCountTable4[] =
     1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
 };
 
-int normHamming(const uchar* a, int n)
+static int normHamming(const uchar* a, int n)
 {
     int i = 0, result = 0;
 #if CV_NEON
@@ -1020,7 +1020,7 @@ int normHamming(const uchar* a, const uchar* b, int n)
     return result;
 }
 
-int normHamming(const uchar* a, int n, int cellSize)
+static int normHamming(const uchar* a, int n, int cellSize)
 {
     if( cellSize == 1 )
         return normHamming(a, n);