Fixes: Android NDK r7b, android build warnings, build with Visual Studio 2005.

CMakeLists.txt

@@ -198,6 +198,25 @@ endif()
 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
+set(OPENCV_INCLUDE_PREFIX include)
+if(INSTALL_TO_MANGLED_PATHS)
+  set(OPENCV_INCLUDE_PREFIX include/opencv-${OPENCV_VERSION})
+endif()
+
+if(WIN32)
+  # Postfix of DLLs:
+  set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
+  set(OPENCV_DEBUG_POSTFIX d)
+else()
+  # Postfix of so's:
+  set(OPENCV_DLLVERSION "")
+  set(OPENCV_DEBUG_POSTFIX "")
+endif()
+
+if(NOT "${CMAKE_DEBUG_POSTFIX}" STREQUAL "")
+  set(OPENCV_DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+endif()
+
 
 # ----------------------------------------------------------------------------
 #  Path for build/platform -specific headers

android/android.toolchain.cmake

@@ -163,7 +163,7 @@ set( CMAKE_SYSTEM_NAME Linux )
 #this one not so much
 set( CMAKE_SYSTEM_VERSION 1 )
 
-set( ANDROID_SUPPORTED_NDK_VERSIONS -r7 -r6b -r6 -r5c -r5b -r5 "" )
+set( ANDROID_SUPPORTED_NDK_VERSIONS -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
 if( CMAKE_HOST_WIN32 )
  file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATH )
  set( ANDROID_NDK_SEARCH_PATH "${ANDROID_NDK_SEARCH_PATH}/android-ndk" )
@@ -668,11 +668,11 @@ if( ARMEABI OR ARMEABI_V7A )
  set( CMAKE_CXX_FLAGS "-fPIC -Wno-psabi" )
  set( CMAKE_C_FLAGS "-fPIC -Wno-psabi" )
  if( ANDROID_USE_STLPORT )
-  set( CMAKE_CXX_FLAGS "-fno-rtti -fno-exceptions" )
-  set( CMAKE_C_FLAGS "-fno-rtti -fno-exceptions" )
+  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions" )
+  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-rtti -fno-exceptions" )
  else()
-  set( CMAKE_CXX_FLAGS "-frtti -fexceptions" )
-  set( CMAKE_C_FLAGS "-fexceptions" )
+  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti -fexceptions" )
+  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexceptions" )
  endif()
  remove_definitions( -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ )
  add_definitions( -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ )
@@ -682,11 +682,11 @@ elseif( X86 )
  set( CMAKE_CXX_FLAGS "-ffunction-sections -funwind-tables" )
  set( CMAKE_C_FLAGS "-ffunction-sections -funwind-tables" )
  if( ANDROID_USE_STLPORT )
-  set( CMAKE_CXX_FLAGS "-fno-rtti -fno-exceptions" )
-  set( CMAKE_C_FLAGS "-fno-rtti -fno-exceptions" )
+  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions" )
+  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-rtti -fno-exceptions" )
  else()
-  set( CMAKE_CXX_FLAGS "-frtti -fexceptions" )
-  set( CMAKE_C_FLAGS "-fexceptions" )
+  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti -fexceptions" )
+  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexceptions" )
  endif()
 else()
  set( CMAKE_CXX_FLAGS "" )

cmake/OpenCVGenConfig.cmake

@@ -46,7 +46,7 @@ macro(ocv_generate_dependencies_map_configmake suffix configuration)
     get_filename_component(__libname "${__libname}" NAME)
     
     if(WIN32)
-      string(REGEX REPLACE "[.]dll$" ".lib" __libname "${__libname}")
+      string(REGEX REPLACE "${CMAKE_SHARED_LIBRARY_SUFFIX}$" "${CMAKE_LINK_LIBRARY_SUFFIX}" __libname "${__libname}")
     endif()
   
     set(OPENCV_DEPENDENCIES_MAP_${suffix} "${OPENCV_DEPENDENCIES_MAP_${suffix}}set(OpenCV_${__ocv_lib}_LIBNAME_${suffix} \"${__libname}\")\n")

cmake/OpenCVModule.cmake

@@ -538,7 +538,7 @@ macro(ocv_add_perf_tests)
       endif()
 
       add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES})
-      target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${perf_deps})
+      target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
 
       # Additional target properties
       set_target_properties(${the_target} PROPERTIES
@@ -588,7 +588,7 @@ macro(ocv_add_accuracy_tests)
       endif()
     
       add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES})
-      target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${test_deps})
+      target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
 
       # Additional target properties
       set_target_properties(${the_target} PROPERTIES

cmake/OpenCVVersion.cmake

 SET(OPENCV_VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/modules/core/include/opencv2/core/version.hpp")
 FILE(STRINGS "${OPENCV_VERSION_FILE}" OPENCV_VERSION_PARTS REGEX "#define CV_.+OR_VERSION[ ]+[0-9]+" )
+
 string(REGEX REPLACE ".+CV_MAJOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MAJOR "${OPENCV_VERSION_PARTS}")
 string(REGEX REPLACE ".+CV_MINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MINOR "${OPENCV_VERSION_PARTS}")
 string(REGEX REPLACE ".+CV_SUBMINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_PATCH "${OPENCV_VERSION_PARTS}")
-set(OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
 
+set(OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
 set(OPENCV_SOVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}")
 
 # create a dependency on version file
 # we never use output of the following command but cmake will rerun automatically if the version file changes
 configure_file("${OPENCV_VERSION_FILE}" "${CMAKE_BINARY_DIR}/junk/version.junk" COPYONLY)
-
-if(WIN32)
-  # Postfix of DLLs:
-  set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
-  set(OPENCV_DEBUG_POSTFIX d)
-else()
-  # Postfix of so's:
-  set(OPENCV_DLLVERSION "")
-  set(OPENCV_DEBUG_POSTFIX)
-endif()
-
-#name mangling
-set(OPENCV_INCLUDE_PREFIX include)
-if(INSTALL_TO_MANGLED_PATHS)
-  set(OPENCV_INCLUDE_PREFIX include/opencv-${OPENCV_VERSION})
-endif()

modules/core/src/persistence.cpp

@@ -852,12 +852,14 @@ icvProcessSpecialDouble( CvFileStorage* fs, char* buf, double* value, char** end
     if( c != '.' )
         CV_PARSE_ERROR( "Bad format of floating-point constant" );
 
+    union{double d; uint64 i;} v;
     if( toupper(buf[1]) == 'I' && toupper(buf[2]) == 'N' && toupper(buf[3]) == 'F' )
-        *(uint64*)value = ((uint64)inf_hi << 32);
+        v.i = (uint64)inf_hi << 32;
     else if( toupper(buf[1]) == 'N' && toupper(buf[2]) == 'A' && toupper(buf[3]) == 'N' )
-        *(uint64*)value = (uint64)-1;
+        v.i = (uint64)-1;
     else
         CV_PARSE_ERROR( "Bad format of floating-point constant" );
+    *value = v.d;
 
     *endptr = buf + 4;
 }

modules/core/test/test_arithm.cpp

@@ -517,7 +517,7 @@ inRangeS_(const _Tp* src, const _WTp* a, const _WTp* b, uchar* dst, size_t total
     for( i = 0; i < total; i++ )
     {
         _Tp val = src[i*cn];
-        dst[i] = a[0] <= val && val <= b[0] ? 255 : 0;
+        dst[i] = (a[0] <= val && val <= b[0]) ? uchar(255) : 0;
     }
     for( c = 1; c < cn; c++ )
     {
@@ -609,10 +609,10 @@ static void inRangeS(const Mat& src, const Scalar& lb, const Scalar& rb, Mat& ds
     size_t total = planes[0].total();
     size_t i, nplanes = it.nplanes;
 	int depth = src.depth(), cn = src.channels();
-    double lbuf[4], rbuf[4];
+    union { double d[4]; float f[4]; int i[4];} lbuf, rbuf;
     int wtype = CV_MAKETYPE(depth <= CV_32S ? CV_32S : depth, cn);
-    scalarToRawData(lb, lbuf, wtype, cn);
-    scalarToRawData(rb, rbuf, wtype, cn);
+    scalarToRawData(lb, lbuf.d, wtype, cn);
+    scalarToRawData(rb, rbuf.d, wtype, cn);
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -622,25 +622,25 @@ static void inRangeS(const Mat& src, const Scalar& lb, const Scalar& rb, Mat& ds
         switch( depth )
         {
         case CV_8U:
-            inRangeS_((const uchar*)sptr, (const int*)lbuf, (const int*)rbuf, dptr, total, cn);
+            inRangeS_((const uchar*)sptr, lbuf.i, rbuf.i, dptr, total, cn);
             break;
         case CV_8S:
-            inRangeS_((const schar*)sptr, (const int*)lbuf, (const int*)rbuf, dptr, total, cn);
+            inRangeS_((const schar*)sptr, lbuf.i, rbuf.i, dptr, total, cn);
             break;
         case CV_16U:
-            inRangeS_((const ushort*)sptr, (const int*)lbuf, (const int*)rbuf, dptr, total, cn);
+            inRangeS_((const ushort*)sptr, lbuf.i, rbuf.i, dptr, total, cn);
             break;
         case CV_16S:
-            inRangeS_((const short*)sptr, (const int*)lbuf, (const int*)rbuf, dptr, total, cn);
+            inRangeS_((const short*)sptr, lbuf.i, rbuf.i, dptr, total, cn);
             break;
         case CV_32S:
-            inRangeS_((const int*)sptr, (const int*)lbuf, (const int*)rbuf, dptr, total, cn);
+            inRangeS_((const int*)sptr, lbuf.i, rbuf.i, dptr, total, cn);
             break;
         case CV_32F:
-            inRangeS_((const float*)sptr, (const float*)lbuf, (const float*)rbuf, dptr, total, cn);
+            inRangeS_((const float*)sptr, lbuf.f, rbuf.f, dptr, total, cn);
             break;
         case CV_64F:
-            inRangeS_((const double*)sptr, (const double*)lbuf, (const double*)rbuf, dptr, total, cn);
+            inRangeS_((const double*)sptr, lbuf.d, rbuf.d, dptr, total, cn);
             break;
         default:
             CV_Error(CV_StsUnsupportedFormat, "");

modules/features2d/src/surf.cpp

@@ -124,6 +124,7 @@ struct CvSurfHF
 {
     int p0, p1, p2, p3;
     float w;
+	CvSurfHF(): p0(0),p1(0),p2(0),p3(0),w(0) {}
 };
 
 CV_INLINE float

modules/highgui/CMakeLists.txt

@@ -244,7 +244,7 @@ if(IOS)
   set(HIGHGUI_LIBRARIES ${HIGHGUI_LIBRARIES} bz2 "-framework QuartzCore" "-framework CoreFoundation" "-framework ImageIO" "-framework CoreGraphics" "-framework AVFoundation")
 endif()
 
-if(MINGW)
+if(WIN32)
   link_directories("${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/lib")
   include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/include")#for directshow
 endif()
@@ -270,5 +270,5 @@ set_target_properties(${the_module} PROPERTIES LINK_INTERFACE_LIBRARIES "")
 
 ocv_add_precompiled_headers(${the_module})
 
-ocv_add_accuracy_tests(highgui opencv_imgproc)
+ocv_add_accuracy_tests()
 ocv_add_perf_tests()

modules/legacy/src/contourtree.cpp

@@ -586,7 +586,7 @@ icvCreateContourTree( const CvSeq * contour, CvMemStorage * storage,
 /*    CV_WRITE_SEQ_ELEM (tree_one, start_writer);   */
     i_tree++;
 /*  create Sequence hearder     */
-    *((CvSeq **) tree) = cvEndWriteSeq( &writer );
+    *tree = (CvContourTree*)cvEndWriteSeq( &writer );
 /*   write points for the main segment into sequence header   */
     (*tree)->p1 = pt1[0];
 

modules/legacy/src/epilines.cpp

@@ -332,7 +332,6 @@ int icvComputeCoeffForStereo(  CvStereoCamera* stereoCamera)
 }
 
 
-
 /*--------------------------------------------------------------------------------------*/
 int icvComCoeffForLine(   CvPoint2D64d point1,
                             CvPoint2D64d point2,
@@ -350,33 +349,33 @@ int icvComCoeffForLine(   CvPoint2D64d point1,
     /* Get direction for all points */
     /* Direction for camera 1 */
     
-    double direct1[3];
-    double direct2[3];
-    double camPoint1[3];
+    CvPoint3D64f direct1;
+    CvPoint3D64f direct2;
+    CvPoint3D64f camPoint1;
     
-    double directS3[3];
-    double directS4[3];
-    double direct3[3];
-    double direct4[3];
-    double camPoint2[3];
+    CvPoint3D64f directS3;
+    CvPoint3D64f directS4;
+    CvPoint3D64f direct3;
+    CvPoint3D64f direct4;
+    CvPoint3D64f camPoint2;
     
     icvGetDirectionForPoint(   point1,
                             camMatr1,
-                            (CvPoint3D64d*)direct1);
+                            &direct1);
     
     icvGetDirectionForPoint(   point2,
                             camMatr1,
-                            (CvPoint3D64d*)direct2);
+                            &direct2);
 
     /* Direction for camera 2 */
 
     icvGetDirectionForPoint(   point3,
                             camMatr2,
-                            (CvPoint3D64d*)directS3);
+                            &directS3);
     
     icvGetDirectionForPoint(   point4,
                             camMatr2,
-                            (CvPoint3D64d*)directS4);
+                            &directS4);
 
     /* Create convertion for camera 2: two direction and camera point */
     
@@ -390,30 +389,30 @@ int icvComCoeffForLine(   CvPoint2D64d point1,
                             convRotMatr,
                             convTransVect);
 
-    double zeroVect[3];
-    zeroVect[0] = zeroVect[1] = zeroVect[2] = 0.0;
-    camPoint1[0] = camPoint1[1] = camPoint1[2] = 0.0;
+    CvPoint3D64f zeroVect;
+    zeroVect.x = zeroVect.y = zeroVect.z = 0.0;
+    camPoint1.x = camPoint1.y = camPoint1.z = 0.0;
     
-    icvConvertPointSystem(*((CvPoint3D64d*)directS3),(CvPoint3D64d*)direct3,convRotMatr,convTransVect);
-    icvConvertPointSystem(*((CvPoint3D64d*)directS4),(CvPoint3D64d*)direct4,convRotMatr,convTransVect);
-    icvConvertPointSystem(*((CvPoint3D64d*)zeroVect),(CvPoint3D64d*)camPoint2,convRotMatr,convTransVect);
+    icvConvertPointSystem(directS3,&direct3,convRotMatr,convTransVect);
+    icvConvertPointSystem(directS4,&direct4,convRotMatr,convTransVect);
+    icvConvertPointSystem(zeroVect,&camPoint2,convRotMatr,convTransVect);
 
-    double pointB[3];
+    CvPoint3D64f pointB;
         
     int postype = 0;
     
     /* Changed order */
     /* Compute point B: xB,yB,zB */
-    icvGetCrossLines(*((CvPoint3D64d*)camPoint1),*((CvPoint3D64d*)direct2),
-                  *((CvPoint3D64d*)camPoint2),*((CvPoint3D64d*)direct3),
-                  (CvPoint3D64d*)pointB);
+    icvGetCrossLines(camPoint1,direct2,
+                  camPoint2,direct3,
+                  &pointB);
 
-    if( pointB[2] < 0 )/* If negative use other lines for cross */
+    if( pointB.z < 0 )/* If negative use other lines for cross */
     {
         postype = 1;
-        icvGetCrossLines(*((CvPoint3D64d*)camPoint1),*((CvPoint3D64d*)direct1),
-                      *((CvPoint3D64d*)camPoint2),*((CvPoint3D64d*)direct4),
-                      (CvPoint3D64d*)pointB);
+        icvGetCrossLines(camPoint1,direct1,
+                      camPoint2,direct4,
+                      &pointB);
     }
 
     CvPoint3D64d pointNewA;
@@ -424,27 +423,27 @@ int icvComCoeffForLine(   CvPoint2D64d point1,
 
     if( postype == 0 )
     {
-        icvGetSymPoint3D(   *((CvPoint3D64d*)camPoint1),
-                            *((CvPoint3D64d*)direct1),
-                            *((CvPoint3D64d*)pointB),
+        icvGetSymPoint3D(   camPoint1,
+                            direct1,
+                            pointB,
                             &pointNewA);
 
-        icvGetSymPoint3D(   *((CvPoint3D64d*)camPoint2),
-                            *((CvPoint3D64d*)direct4),
-                            *((CvPoint3D64d*)pointB),
+        icvGetSymPoint3D(   camPoint2,
+                            direct4,
+                            pointB,
                             &pointNewC);
     }
     else
     {/* In this case we must change cameras */
         *needSwapCamera = 1;
-        icvGetSymPoint3D(   *((CvPoint3D64d*)camPoint2),
-                            *((CvPoint3D64d*)direct3),
-                            *((CvPoint3D64d*)pointB),
+        icvGetSymPoint3D(   camPoint2,
+                            direct3,
+                            pointB,
                             &pointNewA);
 
-        icvGetSymPoint3D(   *((CvPoint3D64d*)camPoint1),
-                            *((CvPoint3D64d*)direct2),
-                            *((CvPoint3D64d*)pointB),
+        icvGetSymPoint3D(   camPoint1,
+                            direct2,
+                            pointB,
                             &pointNewC);
     }
 
@@ -453,9 +452,9 @@ int icvComCoeffForLine(   CvPoint2D64d point1,
     
     double x1,y1,z1;
 
-    x1 = camPoint1[0];
-    y1 = camPoint1[1];
-    z1 = camPoint1[2];
+    x1 = camPoint1.x;
+    y1 = camPoint1.y;
+    z1 = camPoint1.z;
 
     double xA,yA,zA;
     double xB,yB,zB;
@@ -465,9 +464,9 @@ int icvComCoeffForLine(   CvPoint2D64d point1,
     yA = pointNewA.y;
     zA = pointNewA.z;
 
-    xB = pointB[0];
-    yB = pointB[1];
-    zB = pointB[2];
+    xB = pointB.x;
+    yB = pointB.y;
+    zB = pointB.z;
 
     xC = pointNewC.x;
     yC = pointNewC.y;
@@ -479,8 +478,8 @@ int icvComCoeffForLine(   CvPoint2D64d point1,
     gamma = len2 / len1;
 
     icvComputeStereoLineCoeffs( pointNewA,
-                                *((CvPoint3D64d*)pointB),
-                                *((CvPoint3D64d*)camPoint1),
+                                pointB,
+                                camPoint1,
                                 gamma,
                                 coeffs);
     

modules/ts/src/ts_perf.cpp

@@ -834,8 +834,8 @@ void TestBase::reportMetrics(bool toJUnitXML)
             break;
         };
 
-        LOGD("bytesIn   =%11lu", m.bytesIn);
-        LOGD("bytesOut  =%11lu", m.bytesOut);
+        LOGD("bytesIn   =%11lu", (unsigned long)m.bytesIn);
+        LOGD("bytesOut  =%11lu", (unsigned long)m.bytesOut);
         if (nIters == (unsigned int)-1 || m.terminationReason == performance_metrics::TERM_ITERATIONS)
             LOGD("samples   =%11u",  m.samples);
         else