moved gtest to modules; added some gtest-based tests

modules/CMakeLists.txt

@@ -13,6 +13,7 @@ if(MSVC OR MINGW)
    endif()
 endif()
 
+add_subdirectory(gtest)
 add_subdirectory(highgui)
 add_subdirectory(imgproc)
 add_subdirectory(legacy)

modules/core/test/precomp.cpp

@@ -0,0 +1 @@
+#include "precomp.hpp"

modules/core/test/precomp.hpp

@@ -0,0 +1,2 @@
+#include "opencv2/gtest/gtestcv.hpp"
+#include "opencv2/core/core.hpp"

modules/core/test/test_arithm.cpp

@@ -0,0 +1,25 @@
+#include "precomp.hpp"
+
+using namespace cv;
+
+TEST(ArithmTest, add)
+{
+    typedef uchar _Tp;
+    
+    Mat A(30,30,DataType<_Tp>::type), B(A.size(), A.type()), C0, C;
+    RNG rng(-1);
+    rng.fill(A, RNG::UNIFORM, Scalar::all(0), Scalar::all(256));
+    rng.fill(B, RNG::UNIFORM, Scalar::all(0), Scalar::all(256));
+    C0.create(A.size(), A.type());
+    int i, j, cols = A.cols*A.channels();
+    for(i = 0; i < A.rows; i++)
+    {
+        const _Tp* aptr = A.ptr<_Tp>(i);
+        const _Tp* bptr = B.ptr<_Tp>(i);
+        _Tp* cptr = C0.ptr<_Tp>(i);
+        for(j = 0; j < cols; j++)
+            cptr[j] = saturate_cast<_Tp>(aptr[j] + bptr[j]);
+    }
+    add(A, B, C);
+    EXPECT_EQ(norm(C, C0, NORM_INF), 0);
+}

modules/core/test/test_main.cpp

@@ -0,0 +1,2 @@
+#include "precomp.hpp"
+#include "opencv2/gtest/gtest_main.hpp"

modules/gtest/CMakeLists.txt

@@ -0,0 +1,4 @@
+if(BUILD_SHARED_LIBS)
+add_definitions(-DGTEST_CREATE_SHARED_LIBRARY=1)
+endif()
+define_opencv_module(gtest opencv_core)

modules/gtest/README

@@ -0,0 +1,422 @@
+The new OpenCV test engine is based
+on the Google C++ Testing Framework (GTest).
+Below is the original GTest README.
+-----------------------------------
+
+Google C++ Testing Framework
+============================
+
+http://code.google.com/p/googletest/
+
+Overview
+--------
+
+Google's framework for writing C++ tests on a variety of platforms
+(Linux, Mac OS X, Windows, Windows CE, Symbian, etc).  Based on the
+xUnit architecture.  Supports automatic test discovery, a rich set of
+assertions, user-defined assertions, death tests, fatal and non-fatal
+failures, various options for running the tests, and XML test report
+generation.
+
+Please see the project page above for more information as well as the
+mailing list for questions, discussions, and development.  There is
+also an IRC channel on OFTC (irc.oftc.net) #gtest available.  Please
+join us!
+
+Requirements for End Users
+--------------------------
+
+Google Test is designed to have fairly minimal requirements to build
+and use with your projects, but there are some.  Currently, we support
+Linux, Windows, Mac OS X, and Cygwin.  We will also make our best
+effort to support other platforms (e.g. Solaris, AIX, and z/OS).
+However, since core members of the Google Test project have no access
+to these platforms, Google Test may have outstanding issues there.  If
+you notice any problems on your platform, please notify
+googletestframework@googlegroups.com.  Patches for fixing them are
+even more welcome!
+
+### Linux Requirements ###
+
+These are the base requirements to build and use Google Test from a source
+package (as described below):
+  * GNU-compatible Make or gmake
+  * POSIX-standard shell
+  * POSIX(-2) Regular Expressions (regex.h)
+  * A C++98-standard-compliant compiler
+
+### Windows Requirements ###
+
+  * Microsoft Visual C++ 7.1 or newer
+
+### Cygwin Requirements ###
+
+  * Cygwin 1.5.25-14 or newer
+
+### Mac OS X Requirements ###
+
+  * Mac OS X 10.4 Tiger or newer
+  * Developer Tools Installed
+
+Also, you'll need CMake 2.6.4 or higher if you want to build the
+samples using the provided CMake script, regardless of the platform.
+
+Requirements for Contributors
+-----------------------------
+
+We welcome patches.  If you plan to contribute a patch, you need to
+build Google Test and its own tests from an SVN checkout (described
+below), which has further requirements:
+
+  * Python version 2.3 or newer (for running some of the tests and
+    re-generating certain source files from templates)
+  * CMake 2.6.4 or newer
+
+Getting the Source
+------------------
+
+There are two primary ways of getting Google Test's source code: you
+can download a stable source release in your preferred archive format,
+or directly check out the source from our Subversion (SVN) repositary.
+The SVN checkout requires a few extra steps and some extra software
+packages on your system, but lets you track the latest development and
+make patches much more easily, so we highly encourage it.
+
+### Source Package ###
+
+Google Test is released in versioned source packages which can be
+downloaded from the download page [1].  Several different archive
+formats are provided, but the only difference is the tools used to
+manipulate them, and the size of the resulting file.  Download
+whichever you are most comfortable with.
+
+  [1] http://code.google.com/p/googletest/downloads/list
+
+Once the package is downloaded, expand it using whichever tools you
+prefer for that type.  This will result in a new directory with the
+name "gtest-X.Y.Z" which contains all of the source code.  Here are
+some examples on Linux:
+
+  tar -xvzf gtest-X.Y.Z.tar.gz
+  tar -xvjf gtest-X.Y.Z.tar.bz2
+  unzip gtest-X.Y.Z.zip
+
+### SVN Checkout ###
+
+To check out the main branch (also known as the "trunk") of Google
+Test, run the following Subversion command:
+
+  svn checkout http://googletest.googlecode.com/svn/trunk/ gtest-svn
+
+Setting up the Build
+--------------------
+
+To build Google Test and your tests that use it, you need to tell your
+build system where to find its headers and source files.  The exact
+way to do it depends on which build system you use, and is usually
+straightforward.
+
+### Generic Build Instructions ###
+
+Suppose you put Google Test in directory ${GTEST_DIR}.  To build it,
+create a library build target (or a project as called by Visual Studio
+and Xcode) to compile
+
+  ${GTEST_DIR}/src/gtest-all.cc
+
+with
+
+  ${GTEST_DIR}/include and ${GTEST_DIR}
+
+in the header search path.  Assuming a Linux-like system and gcc,
+something like the following will do:
+
+  g++ -I${GTEST_DIR}/include -I${GTEST_DIR} -c ${GTEST_DIR}/src/gtest-all.cc
+  ar -rv libgtest.a gtest-all.o
+
+Next, you should compile your test source file with
+${GTEST_DIR}/include in the header search path, and link it with gtest
+and any other necessary libraries:
+
+  g++ -I${GTEST_DIR}/include path/to/your_test.cc libgtest.a -o your_test
+
+As an example, the make/ directory contains a Makefile that you can
+use to build Google Test on systems where GNU make is available
+(e.g. Linux, Mac OS X, and Cygwin).  It doesn't try to build Google
+Test's own tests.  Instead, it just builds the Google Test library and
+a sample test.  You can use it as a starting point for your own build
+script.
+
+If the default settings are correct for your environment, the
+following commands should succeed:
+
+  cd ${GTEST_DIR}/make
+  make
+  ./sample1_unittest
+
+If you see errors, try to tweak the contents of make/Makefile to make
+them go away.  There are instructions in make/Makefile on how to do
+it.
+
+### Using CMake ###
+
+Google Test comes with a CMake build script (CMakeLists.txt) that can
+be used on a wide range of platforms ("C" stands for cross-platofrm.).
+If you don't have CMake installed already, you can download it for
+free from http://www.cmake.org/.
+
+CMake works by generating native makefiles or build projects that can
+be used in the compiler environment of your choice.  The typical
+workflow starts with:
+
+  mkdir mybuild       # Create a directory to hold the build output.
+  cd mybuild
+  cmake ${GTEST_DIR}  # Generate native build scripts.
+
+If you want to build Google Test's samples, you should replace the
+last command with
+
+  cmake -Dbuild_gtest_samples=ON ${GTEST_DIR}
+
+If you are on a *nix system, you should now see a Makefile in the
+current directory.  Just type 'make' to build gtest.
+
+If you use Windows and have Vistual Studio installed, a gtest.sln file
+and several .vcproj files will be created.  You can then build them
+using Visual Studio.
+
+On Mac OS X with Xcode installed, a .xcodeproj file will be generated.
+
+### Legacy Build Scripts ###
+
+Before settling on CMake, we have been providing hand-maintained build
+projects/scripts for Visual Studio, Xcode, and Autotools.  While we
+continue to provide them for convenience, they are not actively
+maintained any more.  We highly recommend that you follow the
+instructions in the previous two sections to integrate Google Test
+with your existing build system.
+
+If you still need to use the legacy build scripts, here's how:
+
+The msvc\ folder contains two solutions with Visual C++ projects.
+Open the gtest.sln or gtest-md.sln file using Visual Studio, and you
+are ready to build Google Test the same way you build any Visual
+Studio project.  Files that have names ending with -md use DLL
+versions of Microsoft runtime libraries (the /MD or the /MDd compiler
+option).  Files without that suffix use static versions of the runtime
+libraries (the /MT or the /MTd option).  Please note that one must use
+the same option to compile both gtest and the test code.  If you use
+Visual Studio 2005 or above, we recommend the -md version as /MD is
+the default for new projects in these versions of Visual Studio.
+
+On Mac OS X, open the gtest.xcodeproj in the xcode/ folder using
+Xcode.  Build the "gtest" target.  The universal binary framework will
+end up in your selected build directory (selected in the Xcode
+"Preferences..." -> "Building" pane and defaults to xcode/build).
+Alternatively, at the command line, enter:
+
+  xcodebuild
+
+This will build the "Release" configuration of gtest.framework in your
+default build location.  See the "xcodebuild" man page for more
+information about building different configurations and building in
+different locations.
+
+Tweaking Google Test
+--------------------
+
+Google Test can be used in diverse environments.  The default
+configuration may not work (or may not work well) out of the box in
+some environments.  However, you can easily tweak Google Test by
+defining control macros on the compiler command line.  Generally,
+these macros are named like GTEST_XYZ and you define them to either 1
+or 0 to enable or disable a certain feature.
+
+We list the most frequently used macros below.  For a complete list,
+see file include/gtest/internal/gtest-port.h.
+
+### Choosing a TR1 Tuple Library ###
+
+Some Google Test features require the C++ Technical Report 1 (TR1)
+tuple library, which is not yet available with all compilers.  The
+good news is that Google Test implements a subset of TR1 tuple that's
+enough for its own need, and will automatically use this when the
+compiler doesn't provide TR1 tuple.
+
+Usually you don't need to care about which tuple library Google Test
+uses.  However, if your project already uses TR1 tuple, you need to
+tell Google Test to use the same TR1 tuple library the rest of your
+project uses, or the two tuple implementations will clash.  To do
+that, add
+
+  -DGTEST_USE_OWN_TR1_TUPLE=0
+
+to the compiler flags while compiling Google Test and your tests.  If
+you want to force Google Test to use its own tuple library, just add
+
+  -DGTEST_USE_OWN_TR1_TUPLE=1
+
+to the compiler flags instead.
+
+If you don't want Google Test to use tuple at all, add
+
+  -DGTEST_HAS_TR1_TUPLE=0
+
+and all features using tuple will be disabled.
+
+### Multi-threaded Tests ###
+
+Google Test is thread-safe where the pthread library is available.
+After #include <gtest/gtest.h>, you can check the GTEST_IS_THREADSAFE
+macro to see whether this is the case (yes if the macro is #defined to
+1, no if it's undefined.).
+
+If Google Test doesn't correctly detect whether pthread is available
+in your environment, you can force it with
+
+  -DGTEST_HAS_PTHREAD=1
+
+or
+
+  -DGTEST_HAS_PTHREAD=0
+
+When Google Test uses pthread, you may need to add flags to your
+compiler and/or linker to select the pthread library, or you'll get
+link errors.  If you use the CMake script or the deprecated Autotools
+script, this is taken care of for you.  If you use your own build
+script, you'll need to read your compiler and linker's manual to
+figure out what flags to add.
+
+### As a Shared Library (DLL) ###
+
+Google Test is compact, so most users can build and link it as a
+static library for the simplicity.  You can choose to use Google Test
+as a shared library (known as a DLL on Windows) if you prefer.
+
+To compile gtest as a shared library, add
+
+  -DGTEST_CREATE_SHARED_LIBRARY=1
+
+to the compiler flags.  You'll also need to tell the linker to produce
+a shared library instead - consult your linker's manual for how to do
+it.
+
+To compile your tests that use the gtest shared library, add
+
+  -DGTEST_LINKED_AS_SHARED_LIBRARY=1
+
+to the compiler flags.
+
+### Avoiding Macro Name Clashes ###
+
+In C++, macros don't obey namespaces.  Therefore two libraries that
+both define a macro of the same name will clash if you #include both
+definitions.  In case a Google Test macro clashes with another
+library, you can force Google Test to rename its macro to avoid the
+conflict.
+
+Specifically, if both Google Test and some other code define macro
+FOO, you can add
+
+  -DGTEST_DONT_DEFINE_FOO=1
+
+to the compiler flags to tell Google Test to change the macro's name
+from FOO to GTEST_FOO.  Currently FOO can be FAIL, SUCCEED, or TEST.
+For example, with -DGTEST_DONT_DEFINE_TEST=1, you'll need to write
+
+  GTEST_TEST(SomeTest, DoesThis) { ... }
+
+instead of
+
+  TEST(SomeTest, DoesThis) { ... }
+
+in order to define a test.
+
+Upgrating from an Earlier Version
+---------------------------------
+
+We strive to keep Google Test releases backward compatible.
+Sometimes, though, we have to make some breaking changes for the
+users' long-term benefits.  This section describes what you'll need to
+do if you are upgrading from an earlier version of Google Test.
+
+### Upgrading from 1.3.0 or Earlier ###
+
+You may need to explicitly enable or disable Google Test's own TR1
+tuple library.  See the instructions in section "Choosing a TR1 Tuple
+Library".
+
+### Upgrading from 1.4.0 or Earlier ###
+
+The Autotools build script (configure + make) is no longer officially
+supportted.  You are encouraged to migrate to your own build system or
+use CMake.  If you still need to use Autotools, you can find
+instructions in the README file from Google Test 1.4.0.
+
+On platforms where the pthread library is available, Google Test uses
+it in order to be thread-safe.  See the "Multi-threaded Tests" section
+for what this means to your build script.
+
+If you use Microsoft Visual C++ 7.1 with exceptions disabled, Google
+Test will no longer compile.  This should affect very few people, as a
+large portion of STL (including <string>) doesn't compile in this mode
+anyway.  We decided to stop supporting it in order to greatly simplify
+Google Test's implementation.
+
+Developing Google Test
+----------------------
+
+This section discusses how to make your own changes to Google Test.
+
+### Testing Google Test Itself ###
+
+To make sure your changes work as intended and don't break existing
+functionality, you'll want to compile and run Google Test's own tests.
+For that you can use CMake:
+
+  mkdir mybuild
+  cd mybuild
+  cmake -Dbuild_all_gtest_tests=ON ${GTEST_DIR}
+
+Make sure you have Python installed, as some of Google Test's tests
+are written in Python.  If the cmake command complains about not being
+able to find Python ("Could NOT find PythonInterp (missing:
+PYTHON_EXECUTABLE)"), try telling it explicitly where your Python
+executable can be found:
+
+  cmake -DPYTHON_EXECUTABLE=path/to/python -Dbuild_all_gtest_tests=ON \
+      ${GTEST_DIR}
+
+Next, you can build Google Test and all of its own tests.  On *nix,
+this is usually done by 'make'.  To run the tests, do
+
+  make test
+
+All tests should pass.
+
+### Regenerating Source Files ###
+
+Some of Google Test's source files are generated from templates (not
+in the C++ sense) using a script.  A template file is named FOO.pump,
+where FOO is the name of the file it will generate.  For example, the
+file include/gtest/internal/gtest-type-util.h.pump is used to generate
+gtest-type-util.h in the same directory.
+
+Normally you don't need to worry about regenerating the source files,
+unless you need to modify them.  In that case, you should modify the
+corresponding .pump files instead and run the pump.py Python script to
+regenerate them.  You can find pump.py in the scripts/ directory.
+Read the Pump manual [2] for how to use it.
+
+  [2] http://code.google.com/p/googletest/wiki/PumpManual
+
+### Contributing a Patch ###
+
+We welcome patches.  Please read the Google Test developer's guide [3]
+for how you can contribute.  In particular, make sure you have signed
+the Contributor License Agreement, or we won't be able to accept the
+patch.
+
+  [3] http://code.google.com/p/googletest/wiki/GoogleTestDevGuide
+
+Happy testing!

modules/gtest/include/opencv2/gtest/gtest_main.hpp

@@ -0,0 +1,5 @@
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

modules/gtest/include/opencv2/gtest/gtestcv.hpp

@@ -0,0 +1,60 @@
+#ifndef __OPENCV_GTESTCV_HPP__
+#define __OPENCV_GTESTCV_HPP__
+
+#include "opencv2/gtest/gtest.h"
+#include "opencv2/core/core.hpp"
+
+namespace cvtest
+{
+
+using std::vector;
+using cv::RNG;
+using cv::Mat;
+using cv::Scalar;
+using cv::Size;
+using cv::Point;
+using cv::Rect;
+
+enum
+{
+    TYPE_MASK_8U = 1 << CV_8U,
+    TYPE_MASK_8S = 1 << CV_8S,
+    TYPE_MASK_16U = 1 << CV_16U,
+    TYPE_MASK_16S = 1 << CV_16S,
+    TYPE_MASK_32S = 1 << CV_32S,
+    TYPE_MASK_32F = 1 << CV_32F,
+    TYPE_MASK_64F = 1 << CV_64F,
+    TYPE_MASK_ALL = (TYPE_MASK_64F<<1)-1,
+    TYPE_MASK_ALL_BUT_8S = TYPE_MASK_ALL & ~TYPE_MASK_8S
+};
+    
+CV_EXPORTS Size randomSize(RNG& rng, double maxSizeLog);
+CV_EXPORTS void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz);    
+CV_EXPORTS int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels);
+CV_EXPORTS Mat randomMat(RNG& rng, Size size, int type, bool useRoi);
+CV_EXPORTS Mat randomMat(RNG& rng, const vector<int>& size, int type, bool useRoi);
+CV_EXPORTS Mat add(const Mat& a, double alpha, const Mat& b, double beta,
+                      Scalar gamma, Mat& c, int ctype, bool calcAbs);
+CV_EXPORTS void convert(const Mat& src, Mat& dst, int dtype, double alpha, double beta);
+CV_EXPORTS void copy(const Mat& src, Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
+CV_EXPORTS void minMaxFilter(const Mat& a, Mat& maxresult, const Mat& minresult, const Mat& kernel, Point anchor);
+CV_EXPORTS void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel, Point anchor, double delta, int borderType);
+CV_EXPORTS void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar borderValue);
+CV_EXPORTS void minMaxLoc(const Mat& src, double* maxval, double* minval,
+                          vector<int>* maxloc, vector<int>* minloc, const Mat& mask=Mat());
+CV_EXPORTS double norm(const Mat& src, int normType, const Mat& mask=Mat());
+CV_EXPORTS double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask=Mat());
+CV_EXPORTS bool cmpEps(const Mat& src1, const Mat& src2, double maxDiff, vector<int>* loc);
+CV_EXPORTS void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
+CV_EXPORTS void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
+CV_EXPORTS void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
+CV_EXPORTS void compare(const Mat& src, const Scalar& s, Mat& dst, int cmpop);    
+CV_EXPORTS void gemm(const Mat& src1, const Mat& src2, double alpha,
+                     const Mat& src3, double beta, Mat& dst, int flags);
+CV_EXPORTS void crosscorr(const Mat& src1, const Mat& src2, Mat& dst, int dtype);
+
+}
+
+#endif
+

modules/gtest/src/gtestcv.cpp

@@ -0,0 +1,319 @@
+#include "precomp.hpp"
+
+using namespace cv;
+
+namespace cvtest
+{
+
+Size randomSize(RNG& rng, double maxSizeLog)
+{
+    double width_log = rng.uniform(0., maxSizeLog);
+    double height_log = rng.uniform(0., maxSizeLog - width_log);
+    if( (unsigned)rng % 2 != 0 )
+        std::swap(width_log, height_log);
+    Size sz;
+    sz.width = cvRound(exp(width_log));
+    sz.height = cvRound(exp(height_log));
+    return sz;
+}
+
+void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz)
+{
+    int i, dims = rng.uniform(minDims, maxDims+1);
+    sz.resize(dims);
+    for( i = 0; i < dims; i++ )
+    {
+        double v = rng.uniform(0., maxSizeLog);
+        maxSizeLog -= v;
+        sz[i] = cvRound(exp(v));
+    }
+    for( i = 0; i < dims; i++ )
+    {
+        int j = rng.uniform(0, dims);
+        int k = rng.uniform(0, dims);
+        std::swap(sz[j], sz[k]);
+    }
+}
+
+int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels)
+{
+    int channels = rng.uniform(minChannels, maxChannels+1);
+    int depth = 0;
+    CV_Assert((typeMask & TYPE_MASK_ALL) != 0);
+    for(;;)
+    {
+        depth = rng.uniform(CV_8U, CV_64F+1);
+        if( ((1 << depth) & typeMask) != 0 )
+            break;
+    }
+    return CV_MAKETYPE(depth, channels);
+}
+
+Mat randomMat(RNG& rng, Size size, int type, bool useRoi)
+{
+    
+}
+
+Mat randomMat(RNG& rng, const vector<int>& size, int type, bool useRoi)
+{
+}
+    
+Mat add(const Mat& _a, double alpha, const Mat& _b, double beta,
+        Scalar gamma, Mat& c, int ctype, bool calcAbs)
+{
+    Mat a = _a, b = _b;
+    if( a.empty() || alpha == 0 )
+    {
+        // both alpha and beta can be 0, but at least one of a and b must be non-empty array,
+        // otherwise we do not know the size of the output (and may be type of the output, when ctype<0)
+        CV_Assert( !a.empty() || !b.empty() );
+        if( !b.empty() )
+        {
+            a = b;
+            alpha = beta;
+            b = Mat();
+            beta = 0;
+        }
+    }
+    if( b.empty() || beta == 0 )
+    {
+        b = Mat();
+        beta = 0;
+    }
+    else
+        CV_Assert(a.size == b.size);
+    
+    if( ctype < 0 )
+        ctype = a.depth();
+    ctype = CV_MAKETYPE(CV_MAT_DEPTH(ctype), a.channels());
+    c.create(a.dims, &a.size[0], ctype);
+    const Mat *arrays[3];
+    Mat planes[3], buf[3];
+    arrays[0] = &a;
+    arrays[1] = b.empty() ? 0 : &b;
+    arrays[2] = &c;
+    
+    NAryMatIterator it(arrays, planes, 3);
+    int i, nplanes = it.nplanes, cn=a.channels();
+    size_t total = planes[0].total(), maxsize = min(12*12*max(12/cn, 1), total);
+    
+    CV_Assert(planes[0].rows == 1);
+    buf[0].create(1, (int)maxsize, CV_64FC(cn));
+    if(!b.empty())
+        buf[1].create(1, maxsize, CV_64FC(cn));
+    buf[2].create(1, maxsize, CV_64FC(cn));
+    scalarToRawData(gamma, buf[2].data, CV_64FC(cn), (int)(maxsize*cn));
+    
+    for( i = 0; i < nplanes; i++, ++it)
+    {
+        for( size_t j = 0; j < total; j += maxsize )
+        {
+            size_t j2 = min(j + maxsize, total);
+            Mat apart0 = planes[0].colRange((int)j, (int)j2);
+            Mat cpart0 = planes[2].colRange((int)j, (int)j2);
+            Mat apart = buf[0].colRange(0, (int)(j2 - j));
+            
+            apart0.convertTo(apart, apart.type(), alpha);
+            size_t k, n = (j2 - j)*cn;
+            double* aptr = (double*)apart.data;
+            const double* gptr = (const double*)buf[2].data;
+            
+            if( b.empty() )
+            {
+                for( k = 0; k < n; k++ )
+                    aptr[k] += gptr[k];
+            }
+            else
+            {
+                Mat bpart0 = planes[1].colRange((int)j, (int)j2);
+                Mat bpart = buf[1].colRange(0, (int)(j2 - j));
+                bpart0.convertTo(bpart, bpart.type(), beta);
+                const double* bptr = (const double*)bpart.data;
+                
+                for( k = 0; k < n; k++ )
+                    aptr[k] += bptr[k] + gptr[k];
+            }
+            if( calcAbs )
+                for( k = 0; k < n; k++ )
+                    aptr[k] = fabs(aptr[k]);
+            apart.convertTo(cpart0, cpart0.type(), 1, 0);
+        }
+    }
+}
+
+
+static template<typename _Tp1, typename _Tp2> inline void
+convert(const _Tp1* src, _Tp2* dst, size_t total, double alpha, double beta)
+{
+    size_t i;
+    if( alpha == 1 && beta == 0 )
+        for( i = 0; i < total; i++ )
+            dst[i] = saturate_cast<_Tp2>(src[i]);
+    else if( beta == 0 )
+        for( i = 0; i < total; i++ )
+            dst[i] = saturate_cast<_Tp2>(src[i]*alpha);
+    else
+        for( i = 0; i < total; i++ )
+            dst[i] = saturate_cast<_Tp2>(src[i]*alpha + beta);
+}
+    
+void convert(const Mat& src, Mat& dst, int dtype, double alpha, double beta)
+{
+    dtype = CV_MAKETYPE(CV_MAT_DEPTH(dtype), src.channels());
+    dst.create(src.dims, &src.size[0], dtype);
+    if( alpha == 0 )
+    {
+        set( dst, Scalar::all(beta) );
+        return;
+    }
+    if( dtype == src.type() && alpha == 1 && beta == 0 )
+    {
+        copy( src, dst );
+        return;
+    }
+    
+    const Mat *arrays[]={&src, &dst};
+    Mat planes[2];
+    
+    NAryMatIterator it(arrays, planes, 2);
+    size_t j, total = total = planes[0].total()*planes[0].channels();
+    int i, nplanes = it.nplanes;
+    
+    for( i = 0; i < nplanes; i++, ++it)
+    {
+        const uchar* sptr = planes[0].data;
+        uchar* dptr = planes[1].data;
+        
+        switch( src.depth() )
+        {
+        case 
+        
+        }
+        
+        for( j = 0; j < total; j++, sptr += elemSize, dptr += elemSize )
+        {
+            if( mptr[j] )
+                for( k = 0; k < elemSize; k++ )
+                    dptr[k] = sptr[k];
+        }
+    }
+}
+    
+     
+void copy(const Mat& src, Mat& dst, const Mat& mask)
+{
+    dst.create(src.dims, &src.size[0], src.type());
+    
+    if(mask.empty())
+    {
+        const Mat* arrays[] = {&src, &dst};
+        Mat planes[2];
+        NAryMatIterator it(arrays, planes, 2);
+        int i, nplanes = it.nplanes;
+        size_t planeSize = planes[0].total()*src.elemSize();
+        
+        for( i = 0; i < nplanes; i++, ++it )
+            memcpy(planes[1].data, planes[0].data, planeSize);
+        
+        return;
+    }
+    
+    CV_Assert( src.size == mask.size && mask.type() == CV_8U );
+    
+    const Mat *arrays[3]={&src, &dst, &mask};
+    Mat planes[3];
+    
+    NAryMatIterator it(arrays, planes, 3);
+    size_t j, k, elemSize = src.elemSize(), total = planes[0].total();
+    int i, nplanes = it.nplanes;
+    
+    for( i = 0; i < nplanes; i++, ++it)
+    {
+        const uchar* sptr = planes[0].data;
+        uchar* dptr = planes[1].data;
+        const uchar* mptr = planes[2].data;
+        
+        for( j = 0; j < total; j++, sptr += elemSize, dptr += elemSize )
+        {
+            if( mptr[j] )
+                for( k = 0; k < elemSize; k++ )
+                    dptr[k] = sptr[k];
+        }
+    }
+}
+
+    
+void set(Mat& dst, const Scalar& gamma, const Mat& mask)
+{
+    double buf[12];
+    scalarToRawData(gama, &buf, dst.type(), dst.channels());
+    const uchar* gptr = (const uchar*)&buf[0];
+    
+    if(mask.empty())
+    {
+        const Mat* arrays[] = {&dst};
+        Mat plane;
+        NAryMatIterator it(arrays, &plane, 1);
+        int i, nplanes = it.nplanes;
+        size_t j, k, elemSize = dst.elemSize(), planeSize = planes[0].total()*elemSize;
+        
+        for( k = 1; k < elemSize; k++ )
+            if( gptr[k] != gptr[0] )
+                break;
+        bool uniform = k >= elemSize;
+        
+        for( i = 0; i < nplanes; i++, ++it )
+        {
+            uchar* dptr = plane.data;
+            if( uniform )
+                memset( dptr, gptr[0], planeSize );
+            else if( i == 0 )
+            {
+                for( j = 0; j < planeSize; j += elemSize, dptr += elemSize )
+                    for( k = 0; k < elemSize; k++ )
+                        dptr[k] = gptr[k];
+            }
+            else
+                memcpy(dtr, dst.data, planeSize);
+        }
+        return;
+    }
+    
+    CV_Assert( dst.size == mask.size && mask.type() == CV_8U );
+    
+    const Mat *arrays[2]={&dst, &mask};
+    Mat planes[2];
+    
+    NAryMatIterator it(arrays, planes, 2);
+    size_t j, k, elemSize = src.elemSize(), total = planes[0].total();
+    int i, nplanes = it.nplanes;
+    
+    for( i = 0; i < nplanes; i++, ++it)
+    {
+        uchar* dptr = planes[0].data;
+        const uchar* mptr = planes[1].data;
+        
+        for( j = 0; j < total; j++, dptr += elemSize )
+        {
+            if( mptr[j] )
+                for( k = 0; k < elemSize; k++ )
+                    dptr[k] = gptr[k];
+        }
+    }
+}
+    
+    
+void minMaxFilter(const Mat& a, Mat& maxresult, const Mat& minresult, const Mat& kernel, Point anchor);
+void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel, Point anchor, double delta, int borderType);
+void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar borderValue);
+void minMaxLoc(const Mat& src, double* maxval, double* minval,
+               vector<int>* maxloc, vector<int>* minloc, const Mat& mask=Mat());
+double norm(const Mat& src, int normType, const Mat& mask=Mat());
+double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask=Mat());
+bool cmpEps(const Mat& src1, const Mat& src2, int int_maxdiff, int flt_maxulp, vector<int>* loc);
+void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
+void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
+void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
+void compare(const Mat& src, const Scalar& s, Mat& dst, int cmpop);    
+
+}

modules/gtest/src/precomp.cpp

@@ -0,0 +1 @@
+#include "precomp.hpp"

modules/gtest/src/precomp.hpp

@@ -0,0 +1 @@
+#include "opencv2/gtest/gtestcv.hpp"