Merge remote-tracking branch 'origin/2.4' into merge-2.4

Conflicts:
	modules/core/include/opencv2/core/internal.hpp
	modules/core/src/arithm.cpp
	modules/imgproc/src/imgwarp.cpp
	modules/objdetect/src/hog.cpp

doc/tutorials/introduction/windows_install/windows_install.rst

@@ -55,7 +55,7 @@ Building the OpenCV library from scratch requires a couple of tools installed be
 .. |TortoiseGit| replace:: TortoiseGit
 .. _TortoiseGit: http://code.google.com/p/tortoisegit/wiki/Download
 .. |Python_Libraries| replace:: Python libraries
-.. _Python_Libraries: http://www.python.org/getit/
+.. _Python_Libraries: http://www.python.org/downloads/
 .. |Numpy| replace:: Numpy
 .. _Numpy: http://numpy.scipy.org/
 .. |IntelTBB| replace:: Intel |copy| Threading Building Blocks (*TBB*)

doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst

@@ -90,17 +90,25 @@ A full list, for the latest version would contain:
 
 .. code-block:: bash
 
-   opencv_core231d.lib
+   opencv_calib3d249d.lib
-   opencv_imgproc231d.lib
+   opencv_contrib249d.lib
-   opencv_highgui231d.lib
+   opencv_core249d.lib
-   opencv_ml231d.lib
+   opencv_features2d249d.lib
-   opencv_video231d.lib
+   opencv_flann249d.lib
-   opencv_features2d231d.lib
+   opencv_gpu249d.lib
-   opencv_calib3d231d.lib
+   opencv_highgui249d.lib
-   opencv_objdetect231d.lib
+   opencv_imgproc249d.lib
-   opencv_contrib231d.lib
+   opencv_legacy249d.lib
-   opencv_legacy231d.lib
+   opencv_ml249d.lib
-   opencv_flann231d.lib
+   opencv_nonfree249d.lib
+   opencv_objdetect249d.lib
+   opencv_ocl249d.lib
+   opencv_photo249d.lib
+   opencv_stitching249d.lib
+   opencv_superres249d.lib
+   opencv_ts249d.lib
+   opencv_video249d.lib
+   opencv_videostab249d.lib
 
 The letter *d* at the end just indicates that these are the libraries required for the debug. Now click ok to save and do the same with a new property inside the Release rule section. Make sure to omit the *d* letters from the library names and to save the property sheets with the save icon above them.
 

modules/core/src/arithm.cpp

@@ -1813,39 +1813,60 @@ void cv::add( InputArray src1, InputArray src2, OutputArray dst,
     arithm_op(src1, src2, dst, mask, dtype, getAddTab(), false, 0, OCL_OP_ADD );
 }
 
-void cv::subtract( InputArray src1, InputArray src2, OutputArray dst,
+void cv::subtract( InputArray _src1, InputArray _src2, OutputArray _dst,
                InputArray mask, int dtype )
 {
 #ifdef HAVE_TEGRA_OPTIMIZATION
-    if (mask.empty() && src1.depth() == CV_8U && src2.depth() == CV_8U)
+    int kind1 = _src1.kind(), kind2 = _src2.kind();
-    {
+    Mat src1 = _src1.getMat(), src2 = _src2.getMat();
-        if (dtype == -1 && dst.fixedType())
+    bool src1Scalar = checkScalar(src1, _src2.type(), kind1, kind2);
-            dtype = dst.depth();
+    bool src2Scalar = checkScalar(src2, _src1.type(), kind2, kind1);
 
-        if (!dst.fixedType() || dtype == dst.depth())
+    if (!src1Scalar && !src2Scalar &&
+        src1.depth() == CV_8U && src2.type() == src1.type() &&
+        src1.dims == 2 && src2.size() == src1.size() &&
+        mask.empty())
+    {
+        if (dtype < 0)
         {
+            if (_dst.fixedType())
+            {
+                dtype = _dst.depth();
+            }
+            else
+            {
+                dtype = src1.depth();
+            }
+        }
+
+        dtype = CV_MAT_DEPTH(dtype);
+
+        if (!_dst.fixedType() || dtype == _dst.depth())
+        {
+            _dst.create(src1.size(), CV_MAKE_TYPE(dtype, src1.channels()));
+
             if (dtype == CV_16S)
             {
-                Mat _dst = dst.getMat();
+                Mat dst = _dst.getMat();
-                if(tegra::subtract_8u8u16s(src1.getMat(), src2.getMat(), _dst))
+                if(tegra::subtract_8u8u16s(src1, src2, dst))
                     return;
             }
             else if (dtype == CV_32F)
             {
-                Mat _dst = dst.getMat();
+                Mat dst = _dst.getMat();
-                if(tegra::subtract_8u8u32f(src1.getMat(), src2.getMat(), _dst))
+                if(tegra::subtract_8u8u32f(src1, src2, dst))
                     return;
             }
             else if (dtype == CV_8S)
             {
-                Mat _dst = dst.getMat();
+                Mat dst = _dst.getMat();
-                if(tegra::subtract_8u8u8s(src1.getMat(), src2.getMat(), _dst))
+                if(tegra::subtract_8u8u8s(src1, src2, dst))
                     return;
             }
         }
     }
 #endif
-    arithm_op(src1, src2, dst, mask, dtype, getSubTab(), false, 0, OCL_OP_SUB );
+    arithm_op(_src1, _src2, _dst, mask, dtype, getSubTab(), false, 0, OCL_OP_SUB );
 }
 
 void cv::absdiff( InputArray src1, InputArray src2, OutputArray dst )

modules/core/test/test_arithm.cpp

@@ -1578,3 +1578,216 @@ TEST_P(Mul1, One)
 }
 
 INSTANTIATE_TEST_CASE_P(Arithm, Mul1, testing::Values(Size(2, 2), Size(1, 1)));
+
+class SubtractOutputMatNotEmpty : public testing::TestWithParam< std::tr1::tuple<cv::Size, perf::MatType, perf::MatDepth, bool> >
+{
+public:
+    cv::Size size;
+    int src_type;
+    int dst_depth;
+    bool fixed;
+
+    void SetUp()
+    {
+        size = std::tr1::get<0>(GetParam());
+        src_type = std::tr1::get<1>(GetParam());
+        dst_depth = std::tr1::get<2>(GetParam());
+        fixed = std::tr1::get<3>(GetParam());
+    }
+};
+
+TEST_P(SubtractOutputMatNotEmpty, Mat_Mat)
+{
+    cv::Mat src1(size, src_type, cv::Scalar::all(16));
+    cv::Mat src2(size, src_type, cv::Scalar::all(16));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(src1, src2, dst, cv::noArray(), dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(size, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src1.channels()));
+        cv::subtract(src1, src2, fixed_dst, cv::noArray(), dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src1.size(), dst.size());
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src1.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Mat_Mat_WithMask)
+{
+    cv::Mat src1(size, src_type, cv::Scalar::all(16));
+    cv::Mat src2(size, src_type, cv::Scalar::all(16));
+    cv::Mat mask(size, CV_8UC1, cv::Scalar::all(255));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(src1, src2, dst, mask, dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(size, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src1.channels()));
+        cv::subtract(src1, src2, fixed_dst, mask, dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src1.size(), dst.size());
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src1.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Mat_Mat_Expr)
+{
+    cv::Mat src1(size, src_type, cv::Scalar::all(16));
+    cv::Mat src2(size, src_type, cv::Scalar::all(16));
+
+    cv::Mat dst = src1 - src2;
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src1.size(), dst.size());
+    ASSERT_EQ(src1.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Mat_Scalar)
+{
+    cv::Mat src(size, src_type, cv::Scalar::all(16));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(src, cv::Scalar::all(16), dst, cv::noArray(), dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(size, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src.channels()));
+        cv::subtract(src, cv::Scalar::all(16), fixed_dst, cv::noArray(), dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Mat_Scalar_WithMask)
+{
+    cv::Mat src(size, src_type, cv::Scalar::all(16));
+    cv::Mat mask(size, CV_8UC1, cv::Scalar::all(255));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(src, cv::Scalar::all(16), dst, mask, dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(size, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src.channels()));
+        cv::subtract(src, cv::Scalar::all(16), fixed_dst, mask, dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Scalar_Mat)
+{
+    cv::Mat src(size, src_type, cv::Scalar::all(16));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(cv::Scalar::all(16), src, dst, cv::noArray(), dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(size, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src.channels()));
+        cv::subtract(cv::Scalar::all(16), src, fixed_dst, cv::noArray(), dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Scalar_Mat_WithMask)
+{
+    cv::Mat src(size, src_type, cv::Scalar::all(16));
+    cv::Mat mask(size, CV_8UC1, cv::Scalar::all(255));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(cv::Scalar::all(16), src, dst, mask, dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(size, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src.channels()));
+        cv::subtract(cv::Scalar::all(16), src, fixed_dst, mask, dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+TEST_P(SubtractOutputMatNotEmpty, Mat_Mat_3d)
+{
+    int dims[] = {5, size.height, size.width};
+
+    cv::Mat src1(3, dims, src_type, cv::Scalar::all(16));
+    cv::Mat src2(3, dims, src_type, cv::Scalar::all(16));
+
+    cv::Mat dst;
+
+    if (!fixed)
+    {
+        cv::subtract(src1, src2, dst, cv::noArray(), dst_depth);
+    }
+    else
+    {
+        const cv::Mat fixed_dst(3, dims, CV_MAKE_TYPE((dst_depth > 0 ? dst_depth : CV_16S), src1.channels()));
+        cv::subtract(src1, src2, fixed_dst, cv::noArray(), dst_depth);
+        dst = fixed_dst;
+        dst_depth = fixed_dst.depth();
+    }
+
+    ASSERT_FALSE(dst.empty());
+    ASSERT_EQ(src1.dims, dst.dims);
+    ASSERT_EQ(src1.size, dst.size);
+    ASSERT_EQ(dst_depth > 0 ? dst_depth : src1.depth(), dst.depth());
+    ASSERT_EQ(0, cv::countNonZero(dst.reshape(1)));
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, SubtractOutputMatNotEmpty, testing::Combine(
+    testing::Values(cv::Size(16, 16), cv::Size(13, 13), cv::Size(16, 13), cv::Size(13, 16)),
+    testing::Values(perf::MatType(CV_8UC1), CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3),
+    testing::Values(-1, CV_16S, CV_32S, CV_32F),
+    testing::Bool()));

modules/imgproc/src/imgwarp.cpp

@@ -4385,7 +4385,6 @@ class WarpPerspectiveInvoker :
     public ParallelLoopBody
 {
 public:
-
     WarpPerspectiveInvoker(const Mat &_src, Mat &_dst, double *_M, int _interpolation,
                            int _borderType, const Scalar &_borderValue) :
         ParallelLoopBody(), src(_src), dst(_dst), M(_M), interpolation(_interpolation),
@@ -4479,7 +4478,7 @@ class IPPWarpPerspectiveInvoker :
 {
 public:
     IPPWarpPerspectiveInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[3][3], int &_interpolation,
-        int &_borderType, const Scalar &_borderValue, ippiWarpPerspectiveFunc _func, bool *_ok) :
+                              int &_borderType, const Scalar &_borderValue, ippiWarpPerspectiveFunc _func, bool *_ok) :
         ParallelLoopBody(), src(_src), dst(_dst), mode(_interpolation), coeffs(_coeffs),
         borderType(_borderType), borderValue(_borderValue), func(_func), ok(_ok)
     {

modules/imgproc/src/morph.cpp

@@ -1288,7 +1288,7 @@ static bool IPPMorphOp(int op, InputArray _src, OutputArray _dst,
                     return false;
             }
         }
-        for( x = 0; y < kernel.cols; x++ )
+        for( x = 0; x < kernel.cols; x++ )
         {
             if( kernel.at<uchar>(anchor.y, x) != 0 )
                 continue;

modules/world/CMakeLists.txt

@@ -103,6 +103,7 @@ macro(ios_include_3party_libs)
       list(APPEND objlist "\"${objpath3}\"")
     endforeach() # (srcname ${sources})
   endforeach()
+  ocv_list_filterout(objlist jmemansi) # <<= dirty fix
 endmacro()
 
 if(IOS AND WITH_PNG)

platforms/ios/build_framework.py

@@ -40,6 +40,7 @@ def build_opencv(srcroot, buildroot, target, arch):
                 "-DCMAKE_BUILD_TYPE=Release " +
                 "-DCMAKE_TOOLCHAIN_FILE=%s/platforms/ios/cmake/Toolchains/Toolchain-%s_Xcode.cmake " +
                 "-DBUILD_opencv_world=ON " +
+                "-DCMAKE_C_FLAGS=\"-Wno-implicit-function-declaration\" " +
                 "-DCMAKE_INSTALL_PREFIX=install") % (srcroot, target)
     # if cmake cache exists, just rerun cmake to update OpenCV.xproj if necessary
     if os.path.isfile(os.path.join(builddir, "CMakeCache.txt")):