Merge branch 2.4

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

@@ -64,7 +64,7 @@
     #endif
   #elif __GNUC__*10 + __GNUC_MINOR__ >= 42
 
-    #if !defined WIN32 && (defined __i486__ || defined __i586__ || \
+    #if !(defined WIN32 || defined _WIN32) && (defined __i486__ || defined __i586__ || \
         defined __i686__ || defined __MMX__ || defined __SSE__  || defined __ppc__)
       #define CV_XADD __sync_fetch_and_add
     #else

modules/core/src/persistence.cpp

@@ -5170,6 +5170,7 @@ void FileStorage::release()
 string FileStorage::releaseAndGetString()
 {
     string buf;
+    buf.reserve(16); // HACK: Work around for compiler bug
     if( fs.obj && fs.obj->outbuf )
         icvClose(fs.obj, &buf);
 

modules/highgui/src/cap_gstreamer.cpp

@@ -399,12 +399,12 @@ bool CvCapture_GStreamer::open( int type, const char* filename )
 
     gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1);
     gst_app_sink_set_drop (GST_APP_SINK(sink), stream);
-
-    gst_app_sink_set_caps(GST_APP_SINK(sink), gst_caps_new_simple("video/x-raw-rgb",
-                                                                  "red_mask",   G_TYPE_INT, 0x0000FF,
-                                                                  "green_mask", G_TYPE_INT, 0x00FF00,
-                                                                  "blue_mask",  G_TYPE_INT, 0xFF0000,
-                                                                  NULL));
+    caps = gst_caps_new_simple("video/x-raw-rgb",
+                               "red_mask",   G_TYPE_INT, 0x0000FF,
+                               "green_mask", G_TYPE_INT, 0x00FF00,
+                               "blue_mask",  G_TYPE_INT, 0xFF0000,
+                               NULL);
+    gst_app_sink_set_caps(GST_APP_SINK(sink), caps);
     gst_caps_unref(caps);
 
     if(gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_READY) ==

modules/imgproc/doc/miscellaneous_transformations.rst

@@ -661,7 +661,7 @@ Applies a fixed-level threshold to each array element.
 
     :param dst: output array of the same size and type as ``src``.
 
-    :param thresh: treshold value.
+    :param thresh: threshold value.
 
     :param maxval: maximum value to use with the ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` thresholding types.
 

modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst

@@ -137,7 +137,7 @@ Finds contours in a binary image.
 
     :param contours: Detected contours. Each contour is stored as a vector of points.
 
-    :param hierarchy: Optional output vector containing information about the image topology. It has as many elements as the number of contours. For each contour  ``contours[i]`` , the elements  ``hierarchy[i][0]`` ,  ``hiearchy[i][1]`` ,  ``hiearchy[i][2]`` , and  ``hiearchy[i][3]``  are set to 0-based indices in  ``contours``  of the next and previous contours at the same hierarchical level: the first child contour and the parent contour, respectively. If for a contour  ``i``  there are no next, previous, parent, or nested contours, the corresponding elements of  ``hierarchy[i]``  will be negative.
+    :param hierarchy: Optional output vector, containing information about the image topology. It has as many elements as the number of contours. For each i-th contour  ``contours[i]`` , the elements  ``hierarchy[i][0]`` ,  ``hiearchy[i][1]`` ,  ``hiearchy[i][2]`` , and  ``hiearchy[i][3]``  are set to 0-based indices in  ``contours``  of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour  ``i``  there are no next, previous, parent, or nested contours, the corresponding elements of  ``hierarchy[i]``  will be negative.
 
     :param mode: Contour retrieval mode (if you use Python see also a note below).
 

modules/imgproc/perf/perf_histogram.cpp

@@ -9,14 +9,14 @@ using std::tr1::get;
 
 typedef tr1::tuple<Size, MatType> Size_Source_t;
 typedef TestBaseWithParam<Size_Source_t> Size_Source;
-
 typedef TestBaseWithParam<Size> MatSize;
 
+static const float rangeHight = 256.0f;
+static const float rangeLow = 0.0f;
 
-PERF_TEST_P(Size_Source, calcHist,
-            testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
-                             testing::Values(CV_8U, CV_32F)
-                             )
+PERF_TEST_P(Size_Source, calcHist1d,
+            testing::Combine(testing::Values(sz3MP, sz5MP),
+                             testing::Values(CV_8U, CV_16U, CV_32F) )
             )
 {
     Size size = get<0>(GetParam());
@@ -28,10 +28,69 @@ PERF_TEST_P(Size_Source, calcHist,
     int dims = 1;
     int numberOfImages = 1;
 
-    const float r[] = {0.0f, 256.0f};
+    const float r[] = {rangeLow, rangeHight};
     const float* ranges[] = {r};
 
-    declare.in(source, WARMUP_RNG).time(20).iterations(1000);
+    randu(source, rangeLow, rangeHight);
+
+    declare.in(source);
+
+    TEST_CYCLE()
+    {
+        calcHist(&source, numberOfImages, channels, Mat(), hist, dims, histSize, ranges);
+    }
+
+    SANITY_CHECK(hist);
+}
+
+PERF_TEST_P(Size_Source, calcHist2d,
+            testing::Combine(testing::Values(sz3MP, sz5MP),
+                             testing::Values(CV_8UC2, CV_16UC2, CV_32FC2) )
+            )
+{
+    Size size = get<0>(GetParam());
+    MatType type = get<1>(GetParam());
+    Mat source(size.height, size.width, type);
+    Mat hist;
+    int channels [] = {0, 1};
+    int histSize [] = {256, 256};
+    int dims = 2;
+    int numberOfImages = 1;
+
+    const float r[] = {rangeLow, rangeHight};
+    const float* ranges[] = {r, r};
+
+    randu(source, rangeLow, rangeHight);
+
+    declare.in(source);
+    TEST_CYCLE()
+    {
+        calcHist(&source, numberOfImages, channels, Mat(), hist, dims, histSize, ranges);
+    }
+
+    SANITY_CHECK(hist);
+}
+
+PERF_TEST_P(Size_Source, calcHist3d,
+            testing::Combine(testing::Values(sz3MP, sz5MP),
+                             testing::Values(CV_8UC3, CV_16UC3, CV_32FC3) )
+            )
+{
+    Size size = get<0>(GetParam());
+    MatType type = get<1>(GetParam());
+    Mat hist;
+    int channels [] = {0, 1, 2};
+    int histSize [] = {32, 32, 32};
+    int dims = 3;
+    int numberOfImages = 1;
+    Mat source(size.height, size.width, type);
+
+    const float r[] = {rangeLow, rangeHight};
+    const float* ranges[] = {r, r, r};
+
+    randu(source, rangeLow, rangeHight);
+
+    declare.in(source);
     TEST_CYCLE()
     {
         calcHist(&source, numberOfImages, channels, Mat(), hist, dims, histSize, ranges);

modules/imgproc/src/histogram.cpp

@@ -165,11 +165,13 @@ static void histPrepareImages( const Mat* images, int nimages, const int* channe
         deltas[dims*2 + 1] = (int)(mask.step/mask.elemSize1());
     }
 
+#ifndef HAVE_TBB
     if( isContinuous )
     {
         imsize.width *= imsize.height;
         imsize.height = 1;
     }
+#endif
 
     if( !ranges )
     {
@@ -207,6 +209,538 @@ static void histPrepareImages( const Mat* images, int nimages, const int* channe
 
 
 ////////////////////////////////// C A L C U L A T E    H I S T O G R A M ////////////////////////////////////
+#ifdef HAVE_TBB
+enum {one = 1, two, three}; // array elements number
+
+template<typename T>
+class calcHist1D_Invoker
+{
+public:
+    calcHist1D_Invoker( const vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                        Mat& hist, const double* _uniranges, int sz, int dims,
+                        Size& imageSize )
+        : mask_(_ptrs[dims]),
+          mstep_(_deltas[dims*2 + 1]),
+          imageWidth_(imageSize.width),
+          histogramSize_(hist.size()), histogramType_(hist.type()),
+          globalHistogram_((tbb::atomic<int>*)hist.data)
+    {
+        p_[0] = ((T**)&_ptrs[0])[0];
+        step_[0] = (&_deltas[0])[1];
+        d_[0] = (&_deltas[0])[0];
+        a_[0] = (&_uniranges[0])[0];
+        b_[0] = (&_uniranges[0])[1];
+        size_[0] = sz;
+    }
+
+    void operator()( const BlockedRange& range ) const
+    {
+        T* p0 = p_[0] + range.begin() * (step_[0] + imageWidth_*d_[0]);
+        uchar* mask = mask_ + range.begin()*mstep_;
+
+        for( int row = range.begin(); row < range.end(); row++, p0 += step_[0] )
+        {
+            if( !mask_ )
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0] )
+                {
+                    int idx = cvFloor(*p0*a_[0] + b_[0]);
+                    if( (unsigned)idx < (unsigned)size_[0] )
+                    {
+                        globalHistogram_[idx].fetch_and_add(1);
+                    }
+                }
+            }
+            else
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0] )
+                {
+                    if( mask[x] )
+                    {
+                        int idx = cvFloor(*p0*a_[0] + b_[0]);
+                        if( (unsigned)idx < (unsigned)size_[0] )
+                        {
+                            globalHistogram_[idx].fetch_and_add(1);
+                        }
+                    }
+                }
+                mask += mstep_;
+            }
+        }
+    }
+
+private:
+    T* p_[one];
+    uchar* mask_;
+    int step_[one];
+    int d_[one];
+    int mstep_;
+    double a_[one];
+    double b_[one];
+    int size_[one];
+    int imageWidth_;
+    Size histogramSize_;
+    int histogramType_;
+    tbb::atomic<int>* globalHistogram_;
+};
+
+template<typename T>
+class calcHist2D_Invoker
+{
+public:
+    calcHist2D_Invoker( const vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                        Mat& hist, const double* _uniranges, const int* size,
+                        int dims, Size& imageSize, size_t* hstep )
+        : mask_(_ptrs[dims]),
+          mstep_(_deltas[dims*2 + 1]),
+          imageWidth_(imageSize.width),
+          histogramSize_(hist.size()), histogramType_(hist.type()),
+          globalHistogram_(hist.data)
+    {
+        p_[0] = ((T**)&_ptrs[0])[0]; p_[1] = ((T**)&_ptrs[0])[1];
+        step_[0] = (&_deltas[0])[1]; step_[1] = (&_deltas[0])[3];
+        d_[0] = (&_deltas[0])[0];    d_[1] = (&_deltas[0])[2];
+        a_[0] = (&_uniranges[0])[0]; a_[1] = (&_uniranges[0])[2];
+        b_[0] = (&_uniranges[0])[1]; b_[1] = (&_uniranges[0])[3];
+        size_[0] = size[0];          size_[1] = size[1];
+        hstep_[0] = hstep[0];
+    }
+
+    void operator()(const BlockedRange& range) const
+    {
+        T* p0 = p_[0] + range.begin()*(step_[0] + imageWidth_*d_[0]);
+        T* p1 = p_[1] + range.begin()*(step_[1] + imageWidth_*d_[1]);
+        uchar* mask = mask_ + range.begin()*mstep_;
+
+        for( int row = range.begin(); row < range.end(); row++, p0 += step_[0], p1 += step_[1] )
+        {
+            if( !mask_ )
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1] )
+                {
+                    int idx0 = cvFloor(*p0*a_[0] + b_[0]);
+                    int idx1 = cvFloor(*p1*a_[1] + b_[1]);
+                    if( (unsigned)idx0 < (unsigned)size_[0] && (unsigned)idx1 < (unsigned)size_[1] )
+                        ( (tbb::atomic<int>*)(globalHistogram_ + hstep_[0]*idx0) )[idx1].fetch_and_add(1);
+                }
+            }
+            else
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1] )
+                {
+                    if( mask[x] )
+                    {
+                        int idx0 = cvFloor(*p0*a_[0] + b_[0]);
+                        int idx1 = cvFloor(*p1*a_[1] + b_[1]);
+                        if( (unsigned)idx0 < (unsigned)size_[0] && (unsigned)idx1 < (unsigned)size_[1] )
+                            ((tbb::atomic<int>*)(globalHistogram_ + hstep_[0]*idx0))[idx1].fetch_and_add(1);
+                    }
+                }
+                mask += mstep_;
+            }
+        }
+    }
+
+private:
+    T* p_[two];
+    uchar* mask_;
+    int step_[two];
+    int d_[two];
+    int mstep_;
+    double a_[two];
+    double b_[two];
+    int size_[two];
+    const int imageWidth_;
+    size_t hstep_[one];
+    Size histogramSize_;
+    int histogramType_;
+    uchar* globalHistogram_;
+};
+
+
+template<typename T>
+class calcHist3D_Invoker
+{
+public:
+    calcHist3D_Invoker( const vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                        Size imsize, Mat& hist, const double* uniranges, int _dims,
+                        size_t* hstep, int* size )
+        : mask_(_ptrs[_dims]),
+          mstep_(_deltas[_dims*2 + 1]),
+          imageWidth_(imsize.width),
+          globalHistogram_(hist.data)
+    {
+        p_[0] = ((T**)&_ptrs[0])[0]; p_[1] = ((T**)&_ptrs[0])[1]; p_[2] = ((T**)&_ptrs[0])[2];
+        step_[0] = (&_deltas[0])[1]; step_[1] = (&_deltas[0])[3]; step_[2] = (&_deltas[0])[5];
+        d_[0] = (&_deltas[0])[0];    d_[1] = (&_deltas[0])[2];    d_[2] = (&_deltas[0])[4];
+        a_[0] = uniranges[0];        a_[1] = uniranges[2];        a_[2] = uniranges[4];
+        b_[0] = uniranges[1];        b_[1] = uniranges[3];        b_[2] = uniranges[5];
+        size_[0] = size[0];          size_[1] = size[1];          size_[2] = size[2];
+        hstep_[0] = hstep[0];        hstep_[1] = hstep[1];
+    }
+
+    void operator()( const BlockedRange& range ) const
+    {
+        T* p0 = p_[0] + range.begin()*(imageWidth_*d_[0] + step_[0]);
+        T* p1 = p_[1] + range.begin()*(imageWidth_*d_[1] + step_[1]);
+        T* p2 = p_[2] + range.begin()*(imageWidth_*d_[2] + step_[2]);
+        uchar* mask = mask_ + range.begin()*mstep_;
+
+        for( int i = range.begin(); i < range.end(); i++, p0 += step_[0], p1 += step_[1], p2 += step_[2] )
+        {
+            if( !mask_ )
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1], p2 += d_[2] )
+                {
+                    int idx0 = cvFloor(*p0*a_[0] + b_[0]);
+                    int idx1 = cvFloor(*p1*a_[1] + b_[1]);
+                    int idx2 = cvFloor(*p2*a_[2] + b_[2]);
+                    if( (unsigned)idx0 < (unsigned)size_[0] &&
+                            (unsigned)idx1 < (unsigned)size_[1] &&
+                            (unsigned)idx2 < (unsigned)size_[2] )
+                    {
+                        ( (tbb::atomic<int>*)(globalHistogram_ + hstep_[0]*idx0 + hstep_[1]*idx1) )[idx2].fetch_and_add(1);
+                    }
+                }
+            }
+            else
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1], p2 += d_[2] )
+                {
+                    if( mask[x] )
+                    {
+                        int idx0 = cvFloor(*p0*a_[0] + b_[0]);
+                        int idx1 = cvFloor(*p1*a_[1] + b_[1]);
+                        int idx2 = cvFloor(*p2*a_[2] + b_[2]);
+                        if( (unsigned)idx0 < (unsigned)size_[0] &&
+                                (unsigned)idx1 < (unsigned)size_[1] &&
+                                (unsigned)idx2 < (unsigned)size_[2] )
+                        {
+                            ( (tbb::atomic<int>*)(globalHistogram_ + hstep_[0]*idx0 + hstep_[1]*idx1) )[idx2].fetch_and_add(1);
+                        }
+                    }
+                }
+                mask += mstep_;
+            }
+        }
+    }
+
+    static bool isFit( const Mat& histogram, const Size imageSize )
+    {
+        return ( imageSize.width * imageSize.height >= 320*240
+                 && histogram.total() >= 8*8*8 );
+    }
+
+private:
+    T* p_[three];
+    uchar* mask_;
+    int step_[three];
+    int d_[three];
+    const int mstep_;
+    double a_[three];
+    double b_[three];
+    int size_[three];
+    int imageWidth_;
+    size_t hstep_[two];
+    uchar* globalHistogram_;
+};
+
+class CalcHist1D_8uInvoker
+{
+public:
+    CalcHist1D_8uInvoker( const vector<uchar*>& ptrs, const vector<int>& deltas,
+                          Size imsize, Mat& hist, int dims, const vector<size_t>& tab,
+                          tbb::mutex* lock )
+        : mask_(ptrs[dims]),
+          mstep_(deltas[dims*2 + 1]),
+          imageWidth_(imsize.width),
+          imageSize_(imsize),
+          histSize_(hist.size()), histType_(hist.type()),
+          tab_((size_t*)&tab[0]),
+          histogramWriteLock_(lock),
+          globalHistogram_(hist.data)
+    {
+        p_[0] = (&ptrs[0])[0];
+        step_[0] = (&deltas[0])[1];
+        d_[0] = (&deltas[0])[0];
+    }
+
+    void operator()( const BlockedRange& range ) const
+    {
+        int localHistogram[256] = { 0, };
+        uchar* mask = mask_;
+        uchar* p0 = p_[0];
+        int x;
+        tbb::mutex::scoped_lock lock;
+
+        if( !mask_ )
+        {
+            int n = (imageWidth_ - 4) / 4 + 1;
+            int tail = imageWidth_ - n*4;
+
+            int xN = 4*n;
+            p0 += (xN*d_[0] + tail*d_[0] + step_[0]) * range.begin();
+        }
+        else
+        {
+            p0 += (imageWidth_*d_[0] + step_[0]) * range.begin();
+            mask += mstep_*range.begin();
+        }
+
+        for( int i = range.begin(); i < range.end(); i++, p0 += step_[0] )
+        {
+            if( !mask_ )
+            {
+                if( d_[0] == 1 )
+                {
+                    for( x = 0; x <= imageWidth_ - 4; x += 4 )
+                    {
+                        int t0 = p0[x], t1 = p0[x+1];
+                        localHistogram[t0]++; localHistogram[t1]++;
+                        t0 = p0[x+2]; t1 = p0[x+3];
+                        localHistogram[t0]++; localHistogram[t1]++;
+                    }
+                    p0 += x;
+                }
+                else
+                {
+                    for( x = 0; x <= imageWidth_ - 4; x += 4 )
+                    {
+                        int t0 = p0[0], t1 = p0[d_[0]];
+                        localHistogram[t0]++; localHistogram[t1]++;
+                        p0 += d_[0]*2;
+                        t0 = p0[0]; t1 = p0[d_[0]];
+                        localHistogram[t0]++; localHistogram[t1]++;
+                        p0 += d_[0]*2;
+                    }
+                }
+
+                for( ; x < imageWidth_; x++, p0 += d_[0] )
+                {
+                    localHistogram[*p0]++;
+                }
+            }
+            else
+            {
+                for( x = 0; x < imageWidth_; x++, p0 += d_[0] )
+                {
+                    if( mask[x] )
+                    {
+                        localHistogram[*p0]++;
+                    }
+                }
+                mask += mstep_;
+            }
+        }
+
+        lock.acquire(*histogramWriteLock_);
+        for(int i = 0; i < 256; i++ )
+        {
+            size_t hidx = tab_[i];
+            if( hidx < OUT_OF_RANGE )
+            {
+                *(int*)((globalHistogram_ + hidx)) += localHistogram[i];
+            }
+        }
+        lock.release();
+    }
+
+    static bool isFit( const Mat& histogram, const Size imageSize )
+    {
+        return ( histogram.total() >= 8
+                && imageSize.width * imageSize.height >= 160*120 );
+    }
+
+private:
+    uchar* p_[one];
+    uchar* mask_;
+    int mstep_;
+    int step_[one];
+    int d_[one];
+    int imageWidth_;
+    Size imageSize_;
+    Size histSize_;
+    int histType_;
+    size_t* tab_;
+    tbb::mutex* histogramWriteLock_;
+    uchar* globalHistogram_;
+};
+
+class CalcHist2D_8uInvoker
+{
+public:
+    CalcHist2D_8uInvoker( const vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                          Size imsize, Mat& hist, int dims, const vector<size_t>& _tab,
+                          tbb::mutex* lock )
+        : mask_(_ptrs[dims]),
+          mstep_(_deltas[dims*2 + 1]),
+          imageWidth_(imsize.width),
+          histSize_(hist.size()), histType_(hist.type()),
+          tab_((size_t*)&_tab[0]),
+          histogramWriteLock_(lock),
+          globalHistogram_(hist.data)
+    {
+        p_[0] = (uchar*)(&_ptrs[0])[0]; p_[1] = (uchar*)(&_ptrs[0])[1];
+        step_[0] = (&_deltas[0])[1];    step_[1] = (&_deltas[0])[3];
+        d_[0] = (&_deltas[0])[0];       d_[1] = (&_deltas[0])[2];
+    }
+
+    void operator()( const BlockedRange& range ) const
+    {
+        uchar* p0 = p_[0] + range.begin()*(step_[0] + imageWidth_*d_[0]);
+        uchar* p1 = p_[1] + range.begin()*(step_[1] + imageWidth_*d_[1]);
+        uchar* mask = mask_ + range.begin()*mstep_;
+
+        Mat localHist = Mat::zeros(histSize_, histType_);
+        uchar* localHistData = localHist.data;
+        tbb::mutex::scoped_lock lock;
+
+        for(int i = range.begin(); i < range.end(); i++, p0 += step_[0], p1 += step_[1])
+        {
+            if( !mask_ )
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1] )
+                {
+                    size_t idx = tab_[*p0] + tab_[*p1 + 256];
+                    if( idx < OUT_OF_RANGE )
+                    {
+                        ++*(int*)(localHistData + idx);
+                    }
+                }
+            }
+            else
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1] )
+                {
+                    size_t idx;
+                    if( mask[x] && (idx = tab_[*p0] + tab_[*p1 + 256]) < OUT_OF_RANGE )
+                    {
+                        ++*(int*)(localHistData + idx);
+                    }
+                }
+                mask += mstep_;
+            }
+        }
+
+        lock.acquire(*histogramWriteLock_);
+        for(int i = 0; i < histSize_.width*histSize_.height; i++)
+        {
+            ((int*)globalHistogram_)[i] += ((int*)localHistData)[i];
+        }
+        lock.release();
+    }
+
+    static bool isFit( const Mat& histogram, const Size imageSize )
+    {
+        return ( (histogram.total() > 4*4 &&  histogram.total() <= 116*116
+                  && imageSize.width * imageSize.height >= 320*240)
+                 || (histogram.total() > 116*116 && imageSize.width * imageSize.height >= 1280*720) );
+    }
+
+private:
+    uchar* p_[two];
+    uchar* mask_;
+    int step_[two];
+    int d_[two];
+    int mstep_;
+    int imageWidth_;
+    Size histSize_;
+    int histType_;
+    size_t* tab_;
+    tbb::mutex* histogramWriteLock_;
+    uchar* globalHistogram_;
+};
+
+class CalcHist3D_8uInvoker
+{
+public:
+    CalcHist3D_8uInvoker( const vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                          Size imsize, Mat& hist, int dims, const vector<size_t>& tab )
+        : mask_(_ptrs[dims]),
+          mstep_(_deltas[dims*2 + 1]),
+          histogramSize_(hist.size.p), histogramType_(hist.type()),
+          imageWidth_(imsize.width),
+          tab_((size_t*)&tab[0]),
+          globalHistogram_(hist.data)
+    {
+        p_[0] = (uchar*)(&_ptrs[0])[0]; p_[1] = (uchar*)(&_ptrs[0])[1]; p_[2] = (uchar*)(&_ptrs[0])[2];
+        step_[0] = (&_deltas[0])[1];    step_[1] = (&_deltas[0])[3];    step_[2] = (&_deltas[0])[5];
+        d_[0] = (&_deltas[0])[0];       d_[1] = (&_deltas[0])[2];       d_[2] = (&_deltas[0])[4];
+    }
+
+    void operator()( const BlockedRange& range ) const
+    {
+        uchar* p0 = p_[0] + range.begin()*(step_[0] + imageWidth_*d_[0]);
+        uchar* p1 = p_[1] + range.begin()*(step_[1] + imageWidth_*d_[1]);
+        uchar* p2 = p_[2] + range.begin()*(step_[2] + imageWidth_*d_[2]);
+        uchar* mask = mask_ + range.begin()*mstep_;
+
+        for(int i = range.begin(); i < range.end(); i++, p0 += step_[0], p1 += step_[1], p2 += step_[2] )
+        {
+            if( !mask_ )
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1], p2 += d_[2] )
+                {
+                    size_t idx = tab_[*p0] + tab_[*p1 + 256] + tab_[*p2 + 512];
+                    if( idx < OUT_OF_RANGE )
+                    {
+                        ( *(tbb::atomic<int>*)(globalHistogram_ + idx) ).fetch_and_add(1);
+                    }
+                }
+            }
+            else
+            {
+                for( int x = 0; x < imageWidth_; x++, p0 += d_[0], p1 += d_[1], p2 += d_[2] )
+                {
+                    size_t idx;
+                    if( mask[x] && (idx = tab_[*p0] + tab_[*p1 + 256] + tab_[*p2 + 512]) < OUT_OF_RANGE )
+                    {
+                        (*(tbb::atomic<int>*)(globalHistogram_ + idx)).fetch_and_add(1);
+                    }
+                }
+                mask += mstep_;
+            }
+        }
+    }
+
+    static bool isFit( const Mat& histogram, const Size imageSize )
+    {
+        return ( histogram.total() >= 128*128*128
+                 && imageSize.width * imageSize.width >= 320*240 );
+    }
+
+private:
+    uchar* p_[three];
+    uchar* mask_;
+    int mstep_;
+    int step_[three];
+    int d_[three];
+    int* histogramSize_;
+    int histogramType_;
+    int imageWidth_;
+    size_t* tab_;
+    uchar* globalHistogram_;
+};
+
+static void
+callCalcHist2D_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                   Size imsize, Mat& hist, int dims,  vector<size_t>& _tab )
+{
+    int grainSize = imsize.height / tbb::task_scheduler_init::default_num_threads();
+    tbb::mutex histogramWriteLock;
+
+    CalcHist2D_8uInvoker body(_ptrs, _deltas, imsize, hist, dims, _tab, &histogramWriteLock);
+    parallel_for(BlockedRange(0, imsize.height, grainSize), body);
+}
+
+static void
+callCalcHist3D_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
+                   Size imsize, Mat& hist, int dims,  vector<size_t>& _tab )
+{
+    CalcHist3D_8uInvoker body(_ptrs, _deltas, imsize, hist, dims, _tab);
+    parallel_for(BlockedRange(0, imsize.height), body);
+}
+#endif
 
 template<typename T> static void
 calcHist_( vector<uchar*>& _ptrs, const vector<int>& _deltas,
@@ -234,6 +768,11 @@ calcHist_( vector<uchar*>& _ptrs, const vector<int>& _deltas,
 
         if( dims == 1 )
         {
+#ifdef HAVE_TBB
+            calcHist1D_Invoker<T> body(_ptrs, _deltas, hist, _uniranges, size[0], dims, imsize);
+            parallel_for(BlockedRange(0, imsize.height), body);
+            return;
+#endif
             double a = uniranges[0], b = uniranges[1];
             int sz = size[0], d0 = deltas[0], step0 = deltas[1];
             const T* p0 = (const T*)ptrs[0];
@@ -259,6 +798,11 @@ calcHist_( vector<uchar*>& _ptrs, const vector<int>& _deltas,
         }
         else if( dims == 2 )
         {
+#ifdef HAVE_TBB
+            calcHist2D_Invoker<T> body(_ptrs, _deltas, hist, _uniranges, size, dims, imsize, hstep);
+            parallel_for(BlockedRange(0, imsize.height), body);
+            return;
+#endif
             double a0 = uniranges[0], b0 = uniranges[1], a1 = uniranges[2], b1 = uniranges[3];
             int sz0 = size[0], sz1 = size[1];
             int d0 = deltas[0], step0 = deltas[1],
@@ -290,6 +834,14 @@ calcHist_( vector<uchar*>& _ptrs, const vector<int>& _deltas,
         }
         else if( dims == 3 )
         {
+#ifdef HAVE_TBB
+            if( calcHist3D_Invoker<T>::isFit(hist, imsize) )
+            {
+                calcHist3D_Invoker<T> body(_ptrs, _deltas, imsize, hist, uniranges, dims, hstep, size);
+                parallel_for(BlockedRange(0, imsize.height), body);
+                return;
+            }
+#endif
             double a0 = uniranges[0], b0 = uniranges[1],
                    a1 = uniranges[2], b1 = uniranges[3],
                    a2 = uniranges[4], b2 = uniranges[5];
@@ -441,8 +993,20 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
 
     if( dims == 1 )
     {
+#ifdef HAVE_TBB
+        if( CalcHist1D_8uInvoker::isFit(hist, imsize) )
+        {
+            int treadsNumber = tbb::task_scheduler_init::default_num_threads();
+            int grainSize = imsize.height/treadsNumber;
+            tbb::mutex histogramWriteLock;
+
+            CalcHist1D_8uInvoker body(_ptrs, _deltas, imsize, hist, dims, _tab, &histogramWriteLock);
+            parallel_for(BlockedRange(0, imsize.height, grainSize), body);
+            return;
+        }
+#endif
         int d0 = deltas[0], step0 = deltas[1];
-        int matH[256] = {0};
+        int matH[256] = { 0, };
         const uchar* p0 = (const uchar*)ptrs[0];
 
         for( ; imsize.height--; p0 += step0, mask += mstep )
@@ -489,6 +1053,13 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
     }
     else if( dims == 2 )
     {
+#ifdef HAVE_TBB
+        if( CalcHist2D_8uInvoker::isFit(hist, imsize) )
+        {
+            callCalcHist2D_8u(_ptrs, _deltas, imsize, hist, dims, _tab);
+            return;
+        }
+#endif
         int d0 = deltas[0], step0 = deltas[1],
             d1 = deltas[2], step1 = deltas[3];
         const uchar* p0 = (const uchar*)ptrs[0];
@@ -514,6 +1085,13 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
     }
     else if( dims == 3 )
     {
+#ifdef HAVE_TBB
+        if( CalcHist3D_8uInvoker::isFit(hist, imsize) )
+        {
+            callCalcHist3D_8u(_ptrs, _deltas, imsize, hist, dims, _tab);
+            return;
+        }
+#endif
         int d0 = deltas[0], step0 = deltas[1],
             d1 = deltas[2], step1 = deltas[3],
             d2 = deltas[4], step2 = deltas[5];
@@ -2404,61 +2982,206 @@ cvCalcProbDensity( const CvHistogram* hist, const CvHistogram* hist_mask,
     }
 }
 
+class EqualizeHistCalcHist_Invoker
+{
+public:
+    enum {HIST_SZ = 256};
+
+#ifdef HAVE_TBB
+    typedef tbb::mutex* MutextPtr;
+#else
+    typedef void* MutextPtr;
+#endif
+
+    EqualizeHistCalcHist_Invoker(cv::Mat& src, int* histogram, MutextPtr histogramLock)
+        : src_(src), globalHistogram_(histogram), histogramLock_(histogramLock)
+    { }
+
+    void operator()( const cv::BlockedRange& rowRange ) const
+    {
+        int localHistogram[HIST_SZ] = {0, };
+
+        const size_t sstep = src_.step;
+
+        int width = src_.cols;
+        int height = rowRange.end() - rowRange.begin();
+
+        if (src_.isContinuous())
+        {
+            width *= height;
+            height = 1;
+        }
+
+        for (const uchar* ptr = src_.ptr<uchar>(rowRange.begin()); height--; ptr += sstep)
+        {
+            int x = 0;
+            for (; x <= width - 4; x += 4)
+            {
+                int t0 = ptr[x], t1 = ptr[x+1];
+                localHistogram[t0]++; localHistogram[t1]++;
+                t0 = ptr[x+2]; t1 = ptr[x+3];
+                localHistogram[t0]++; localHistogram[t1]++;
+            }
+
+            for (; x < width; ++x, ++ptr)
+                localHistogram[ptr[x]]++;
+        }
+
+#ifdef HAVE_TBB
+        tbb::mutex::scoped_lock lock(*histogramLock_);
+#endif
+
+        for( int i = 0; i < HIST_SZ; i++ )
+            globalHistogram_[i] += localHistogram[i];
+    }
+
+    static bool isWorthParallel( const cv::Mat& src )
+    {
+#ifdef HAVE_TBB
+        return ( src.total() >= 640*480 );
+#else
+        (void)src;
+        return false;
+#endif
+    }
+
+private:
+    EqualizeHistCalcHist_Invoker& operator=(const EqualizeHistCalcHist_Invoker&);
+
+    cv::Mat& src_;
+    int* globalHistogram_;
+    MutextPtr histogramLock_;
+};
+
+class EqualizeHistLut_Invoker
+{
+public:
+    EqualizeHistLut_Invoker( cv::Mat& src, cv::Mat& dst, int* lut )
+        : src_(src),
+          dst_(dst),
+          lut_(lut)
+    { }
+
+    void operator()( const cv::BlockedRange& rowRange ) const
+    {
+        const size_t sstep = src_.step;
+        const size_t dstep = dst_.step;
+
+        int width = src_.cols;
+        int height = rowRange.end() - rowRange.begin();
+        int* lut = lut_;
+
+        if (src_.isContinuous() && dst_.isContinuous())
+        {
+            width *= height;
+            height = 1;
+        }
+
+        const uchar* sptr = src_.ptr<uchar>(rowRange.begin());
+        uchar* dptr = dst_.ptr<uchar>(rowRange.begin());
+
+        for (; height--; sptr += sstep, dptr += dstep)
+        {
+            int x = 0;
+            for (; x <= width - 4; x += 4)
+            {
+                int v0 = sptr[x];
+                int v1 = sptr[x+1];
+                int x0 = lut[v0];
+                int x1 = lut[v1];
+                dptr[x] = (uchar)x0;
+                dptr[x+1] = (uchar)x1;
+
+                v0 = sptr[x+2];
+                v1 = sptr[x+3];
+                x0 = lut[v0];
+                x1 = lut[v1];
+                dptr[x+2] = (uchar)x0;
+                dptr[x+3] = (uchar)x1;
+            }
+
+            for (; x < width; ++x)
+                dptr[x] = (uchar)lut[sptr[x]];
+        }
+    }
+
+    static bool isWorthParallel( const cv::Mat& src )
+    {
+#ifdef HAVE_TBB
+        return ( src.total() >= 640*480 );
+#else
+        (void)src;
+        return false;
+#endif
+    }
+
+private:
+    EqualizeHistLut_Invoker& operator=(const EqualizeHistLut_Invoker&);
+
+    cv::Mat& src_;
+    cv::Mat& dst_;
+    int* lut_;
+};
 
 CV_IMPL void cvEqualizeHist( const CvArr* srcarr, CvArr* dstarr )
 {
-    CvMat sstub, *src = cvGetMat(srcarr, &sstub);
-    CvMat dstub, *dst = cvGetMat(dstarr, &dstub);
-
-    CV_Assert( CV_ARE_SIZES_EQ(src, dst) && CV_ARE_TYPES_EQ(src, dst) &&
-               CV_MAT_TYPE(src->type) == CV_8UC1 );
-    CvSize size = cvGetMatSize(src);
-    if( CV_IS_MAT_CONT(src->type & dst->type) )
-    {
-        size.width *= size.height;
-        size.height = 1;
-    }
-    int x, y;
-    const int hist_sz = 256;
-    int hist[hist_sz];
-    memset(hist, 0, sizeof(hist));
-
-    for( y = 0; y < size.height; y++ )
-    {
-        const uchar* sptr = src->data.ptr + src->step*y;
-        for( x = 0; x < size.width; x++ )
-            hist[sptr[x]]++;
-    }
-
-    float scale = 255.f/(size.width*size.height);
-    int sum = 0;
-    uchar lut[hist_sz+1];
-
-    for( int i = 0; i < hist_sz; i++ )
-    {
-        sum += hist[i];
-        int val = cvRound(sum*scale);
-        lut[i] = CV_CAST_8U(val);
-    }
-
-    lut[0] = 0;
-    for( y = 0; y < size.height; y++ )
-    {
-        const uchar* sptr = src->data.ptr + src->step*y;
-        uchar* dptr = dst->data.ptr + dst->step*y;
-        for( x = 0; x < size.width; x++ )
-            dptr[x] = lut[sptr[x]];
-    }
+    cv::equalizeHist(cv::cvarrToMat(srcarr), cv::cvarrToMat(dstarr));
 }
 
-
 void cv::equalizeHist( InputArray _src, OutputArray _dst )
 {
     Mat src = _src.getMat();
+    CV_Assert( src.type() == CV_8UC1 );
+
     _dst.create( src.size(), src.type() );
     Mat dst = _dst.getMat();
-    CvMat _csrc = src, _cdst = dst;
-    cvEqualizeHist( &_csrc, &_cdst );
+
+    if(src.empty())
+        return;
+
+#ifdef HAVE_TBB
+    tbb::mutex histogramLockInstance;
+    EqualizeHistCalcHist_Invoker::MutextPtr histogramLock = &histogramLockInstance;
+#else
+    EqualizeHistCalcHist_Invoker::MutextPtr histogramLock = 0;
+#endif
+
+    const int hist_sz = EqualizeHistCalcHist_Invoker::HIST_SZ;
+    int hist[hist_sz] = {0,};
+    int lut[hist_sz];
+
+    EqualizeHistCalcHist_Invoker calcBody(src, hist, histogramLock);
+    EqualizeHistLut_Invoker      lutBody(src, dst, lut);
+    cv::BlockedRange heightRange(0, src.rows);
+
+    if(EqualizeHistCalcHist_Invoker::isWorthParallel(src))
+        parallel_for(heightRange, calcBody);
+    else
+        calcBody(heightRange);
+
+    int i = 0;
+    while (!hist[i]) ++i;
+
+    int total = (int)src.total();
+    if (hist[i] == total)
+    {
+        dst.setTo(i);
+        return;
+    }
+
+    float scale = (hist_sz - 1.f)/(total - hist[i]);
+    int sum = 0;
+
+    for (lut[i++] = 0; i < hist_sz; ++i)
+    {
+        sum += hist[i];
+        lut[i] = saturate_cast<uchar>(sum * scale);
+    }
+
+    if(EqualizeHistLut_Invoker::isWorthParallel(src))
+        parallel_for(heightRange, lutBody);
+    else
+        lutBody(heightRange);
 }
 
 /* Implementation of RTTI and Generic Functions for CvHistogram */

modules/java/generator/gen_javadoc.py

@@ -3,6 +3,19 @@
 import os, sys, re, string, glob
 from optparse import OptionParser
 
+# Black list for classes and methods that does not implemented in Java API
+# Created to exclude referencies to them in @see tag
+JAVADOC_ENTITY_BLACK_LIST = set(["org.opencv.core.Core#abs", \
+                                 "org.opencv.core.Core#theRNG", \
+                                 "org.opencv.core.Core#extractImageCOI", \
+                                 "org.opencv.core.PCA", \
+                                 "org.opencv.core.SVD", \
+                                 "org.opencv.core.RNG", \
+                                 "org.opencv.imgproc.Imgproc#createMorphologyFilter", \
+                                 "org.opencv.imgproc.Imgproc#createLinearFilter", \
+                                 "org.opencv.imgproc.Imgproc#createSeparableLinearFilter", \
+                                 "org.opencv.imgproc.FilterEngine"])
+
 class JavadocGenerator(object):
     def __init__(self, definitions = {}, modules= [], javadoc_marker = "//javadoc:"):
         self.definitions = definitions
@@ -214,9 +227,9 @@ class JavadocGenerator(object):
             for see in decl["seealso"]:
                 seedecl = self.definitions.get(see,None)
                 if seedecl:
-                    doc += prefix + " * @see " + self.getJavaName(seedecl, "#") + "\n"
-                else:
-                    doc += prefix + " * @see " + see.replace("::",".") + "\n"
+                    javadoc_name = self.getJavaName(seedecl, "#")
+                    if (javadoc_name not in JAVADOC_ENTITY_BLACK_LIST):
+                        doc += prefix + " * @see " + javadoc_name + "\n"
         prefix = " *\n"
 
         #doc += prefix + " * File: " + decl["file"] + " (line " + str(decl["line"]) + ")\n"

modules/java/generator/src/java/android+CameraBridgeViewBase.java

@@ -344,7 +344,7 @@ public abstract class CameraBridgeViewBase extends SurfaceView implements Surfac
      * @param supportedSizes
      * @param surfaceWidth
      * @param surfaceHeight
-     * @return
+     * @return optimal frame size
      */
     protected Size calculateCameraFrameSize(List<?> supportedSizes, ListItemAccessor accessor, int surfaceWidth, int surfaceHeight) {
         int calcWidth = 0;

modules/java/generator/src/java/android+OpenCVLoader.java

@@ -31,7 +31,7 @@ public class OpenCVLoader
      * @param Version OpenCV library version.
      * @param AppContext application context for connecting to the service.
      * @param Callback object, that implements LoaderCallbackInterface for handling the connection status.
-     * @return Returns true if initialization of OpenCV is successful.
+     * @return Returns true if initialization of OpenCV is successful.
      */
     public static boolean initAsync(String Version, Context AppContext,
             LoaderCallbackInterface Callback)

modules/ml/test/test_save_load.cpp

@@ -64,11 +64,11 @@ int CV_SLMLTest::run_test_case( int testCaseIdx )
             if( code == cvtest::TS::OK )
             {
                 get_error( testCaseIdx, CV_TEST_ERROR, &test_resps1 );
-                fname1 = tempfile();
+                fname1 = tempfile(".yml.gz");
                 save( fname1.c_str() );
                 load( fname1.c_str() );
                 get_error( testCaseIdx, CV_TEST_ERROR, &test_resps2 );
-                fname2 = tempfile();
+                fname2 = tempfile(".yml.gz");
                 save( fname2.c_str() );
             }
             else

modules/objdetect/perf/perf_cascadeclassifier.cpp

@@ -14,11 +14,7 @@ PERF_TEST_P(ImageName_MinSize, CascadeClassifierLBPFrontalFace,
             testing::Combine(testing::Values( std::string("cv/shared/lena.png"),
                                               std::string("cv/shared/1_itseez-0000289.png"),
                                               std::string("cv/shared/1_itseez-0000492.png"),
-                                              std::string("cv/shared/1_itseez-0000573.png"),
-                                              std::string("cv/shared/1_itseez-0000892.png"),
-                                              std::string("cv/shared/1_itseez-0001238.png"),
-                                              std::string("cv/shared/1_itseez-0001438.png"),
-                                              std::string("cv/shared/1_itseez-0002524.png")),
+                                              std::string("cv/shared/1_itseez-0000573.png")),
                              testing::Values(24, 30, 40, 50, 60, 70, 80, 90)
                              )
             )

modules/ts/include/opencv2/ts/ts_gtest.h

@@ -433,8 +433,8 @@
 // Defines this to true iff Google Test can use POSIX regular expressions.
 #ifndef GTEST_HAS_POSIX_RE
 # if GTEST_OS_LINUX_ANDROID
-// On Android, <regex.h> is only available starting with Gingerbread.
-#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+// On Android, <regex.h> is only available starting with Froyo.
+#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 8)
 # else
 # define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
 #endif

modules/ts/src/ts_gtest.cpp

@@ -1340,6 +1340,7 @@ GTEST_API_ bool IsAsciiWhiteSpace(char ch);
 GTEST_API_ bool IsAsciiWordChar(char ch);
 GTEST_API_ bool IsValidEscape(char ch);
 GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
+GTEST_API_ std::string FormatRegexSyntaxError(const char* regex, int index);
 GTEST_API_ bool ValidateRegex(const char* regex);
 GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
 GTEST_API_ bool MatchRepetitionAndRegexAtHead(

modules/ts/src/ts_perf.cpp

@@ -305,23 +305,25 @@ double Regression::getElem(cv::Mat& m, int y, int x, int cn)
 
 void Regression::write(cv::Mat m)
 {
+    if (!m.empty() && m.dims < 2) return;
+
     double min, max;
-    cv::minMaxLoc(m, &min, &max);
+    cv::minMaxIdx(m, &min, &max);
     write() << "min" << min << "max" << max;
 
-    write() << "last" << "{" << "x" << m.cols-1 << "y" << m.rows-1
-        << "val" << getElem(m, m.rows-1, m.cols-1, m.channels()-1) << "}";
+    write() << "last" << "{" << "x" << m.size.p[1] - 1 << "y" << m.size.p[0] - 1
+        << "val" << getElem(m, m.size.p[0] - 1, m.size.p[1] - 1, m.channels() - 1) << "}";
 
     int x, y, cn;
-    x = regRNG.uniform(0, m.cols);
-    y = regRNG.uniform(0, m.rows);
+    x = regRNG.uniform(0, m.size.p[1]);
+    y = regRNG.uniform(0, m.size.p[0]);
     cn = regRNG.uniform(0, m.channels());
     write() << "rng1" << "{" << "x" << x << "y" << y;
     if(cn > 0) write() << "cn" << cn;
     write() << "val" << getElem(m, y, x, cn) << "}";
 
-    x = regRNG.uniform(0, m.cols);
-    y = regRNG.uniform(0, m.rows);
+    x = regRNG.uniform(0, m.size.p[1]);
+    y = regRNG.uniform(0, m.size.p[0]);
     cn = regRNG.uniform(0, m.channels());
     write() << "rng2" << "{" << "x" << x << "y" << y;
     if (cn > 0) write() << "cn" << cn;
@@ -339,8 +341,10 @@ static double evalEps(double expected, double actual, double _eps, ERROR_TYPE er
 
 void Regression::verify(cv::FileNode node, cv::Mat actual, double _eps, std::string argname, ERROR_TYPE err)
 {
+    if (!actual.empty() && actual.dims < 2) return;
+
     double actual_min, actual_max;
-    cv::minMaxLoc(actual, &actual_min, &actual_max);
+    cv::minMaxIdx(actual, &actual_min, &actual_max);
 
     double expect_min = (double)node["min"];
     double eps = evalEps(expect_min, actual_min, _eps, err);
@@ -353,12 +357,12 @@ void Regression::verify(cv::FileNode node, cv::Mat actual, double _eps, std::str
             << argname << " has unexpected maximal value" << std::endl;
 
     cv::FileNode last = node["last"];
-    double actual_last = getElem(actual, actual.rows - 1, actual.cols - 1, actual.channels() - 1);
+    double actual_last = getElem(actual, actual.size.p[0] - 1, actual.size.p[1] - 1, actual.channels() - 1);
     int expect_cols = (int)last["x"] + 1;
     int expect_rows = (int)last["y"] + 1;
-    ASSERT_EQ(expect_cols, actual.cols)
+    ASSERT_EQ(expect_cols, actual.size.p[1])
             << argname << " has unexpected number of columns" << std::endl;
-    ASSERT_EQ(expect_rows, actual.rows)
+    ASSERT_EQ(expect_rows, actual.size.p[0])
             << argname << " has unexpected number of rows" << std::endl;
 
     double expect_last = (double)last["val"];
@@ -372,6 +376,8 @@ void Regression::verify(cv::FileNode node, cv::Mat actual, double _eps, std::str
     int cn1 = rng1["cn"];
 
     double expect_rng1 = (double)rng1["val"];
+    // it is safe to use x1 and y1 without checks here because we have already
+    // verified that mat size is the same as recorded
     double actual_rng1 = getElem(actual, y1, x1, cn1);
 
     eps = evalEps(expect_rng1, actual_rng1, _eps, err);
@@ -490,7 +496,7 @@ void Regression::verify(cv::FileNode node, cv::InputArray array, double eps, ERR
                             std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;
 
                         double max;
-                        cv::minMaxLoc(diff.reshape(1), 0, &max);
+                        cv::minMaxIdx(diff.reshape(1), 0, &max);
 
                         FAIL() << "  Absolute difference (=" << max << ") between argument \""
                                << node.name() << "[" <<  idx << "]\" and expected value is greater than " << eps;
@@ -544,7 +550,7 @@ void Regression::verify(cv::FileNode node, cv::InputArray array, double eps, ERR
                             std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;
 
                         double max;
-                        cv::minMaxLoc(diff.reshape(1), 0, &max);
+                        cv::minMaxIdx(diff.reshape(1), 0, &max);
 
                         FAIL() << "  Difference (=" << max << ") between argument1 \"" << node.name()
                                << "\" and expected value is greater than " << eps;
@@ -1153,12 +1159,17 @@ void TestBase::RunPerfTestBody()
     catch(cv::Exception e)
     {
         metrics.terminationReason = performance_metrics::TERM_EXCEPTION;
-        FAIL() << "Expected: PerfTestBody() doesn't throw an exception.\n  Actual: it throws:\n  " << e.what();
+        FAIL() << "Expected: PerfTestBody() doesn't throw an exception.\n  Actual: it throws cv::Exception:\n  " << e.what();
+    }
+    catch(std::exception e)
+    {
+        metrics.terminationReason = performance_metrics::TERM_EXCEPTION;
+        FAIL() << "Expected: PerfTestBody() doesn't throw an exception.\n  Actual: it throws std::exception:\n  " << e.what();
     }
     catch(...)
     {
         metrics.terminationReason = performance_metrics::TERM_EXCEPTION;
-        FAIL() << "Expected: PerfTestBody() doesn't throw an exception.\n  Actual: it throws.";
+        FAIL() << "Expected: PerfTestBody() doesn't throw an exception.\n  Actual: it throws...";
     }
 }