rewritten several functions from calib3d: findhomography, findfundamentalmat,…

rewritten several functions from calib3d: findhomography, findfundamentalmat, findessentialmat, estimateaffine3d, computecorrespondepilines, convert points{to/from}homogeneous to C++.

modules/calib3d/src/_modelest.h → modules/calib3d/src/calib3d_init.cpp

@@ -7,10 +7,11 @@
 //  copy or use the software.
 //
 //
-//                        Intel License Agreement
+//                          License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
@@ -23,7 +24,7 @@
 //     this list of conditions and the following disclaimer in the documentation
 //     and/or other materials provided with the distribution.
 //
-//   * The name of Intel Corporation may not be used to endorse or promote products
+//   * The name of the copyright holders may not be used to endorse or promote products
 //     derived from this software without specific prior written permission.
 //
 // This software is provided by the copyright holders and contributors "as is" and
@@ -39,44 +40,27 @@
 //
 //M*/
 
+#include "precomp.hpp"
 
-#ifndef _CV_MODEL_EST_H_
-#define _CV_MODEL_EST_H_
+using namespace cv;
 
-#include "opencv2/calib3d/calib3d.hpp"
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-class CV_EXPORTS CvModelEstimator2
-{
-public:
-    CvModelEstimator2(int _modelPoints, CvSize _modelSize, int _maxBasicSolutions);
-    virtual ~CvModelEstimator2();
 
-    virtual int runKernel( const CvMat* m1, const CvMat* m2, CvMat* model )=0;
-    virtual bool runLMeDS( const CvMat* m1, const CvMat* m2, CvMat* model,
-                           CvMat* mask, double confidence=0.99, int maxIters=2000 );
-    virtual bool runRANSAC( const CvMat* m1, const CvMat* m2, CvMat* model,
-                            CvMat* mask, double threshold,
-                            double confidence=0.99, int maxIters=2000 );
-    virtual bool refine( const CvMat*, const CvMat*, CvMat*, int ) { return true; }
-    virtual void setSeed( int64 seed );
+//////////////////////////////////////////////////////////////////////////////////////////////////////////                  
+
 
-protected:
-    virtual void computeReprojError( const CvMat* m1, const CvMat* m2,
-                                     const CvMat* model, CvMat* error ) = 0;
-    virtual int findInliers( const CvMat* m1, const CvMat* m2,
-                             const CvMat* model, CvMat* error,
-                             CvMat* mask, double threshold );
-    virtual bool getSubset( const CvMat* m1, const CvMat* m2,
-                            CvMat* ms1, CvMat* ms2, int maxAttempts=1000 );
-    virtual bool checkSubset( const CvMat* ms1, int count );
-    virtual bool isMinimalSetConsistent( const CvMat* /*m1*/, const CvMat* /*m2*/ ) { return true; };
 
-    CvRNG rng;
-    int modelPoints;
-    CvSize modelSize;
-    int maxBasicSolutions;
-    bool checkPartialSubsets;
-};
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-#endif // _CV_MODEL_EST_H_
+#if 0
+bool cv::initModule_calib3d(void)
+{
+    bool all = true;
+    all &= !RANSACPointSetRegistrator_info_auto.name().empty();
+    all &= !LMeDSPointSetRegistrator_info_auto.name().empty();
+    all &= !LMSolverImpl_info_auto.name().empty();
 
+    return all;
+}
+#endif

modules/calib3d/src/calibration.cpp

@@ -55,247 +55,6 @@
 
 using namespace cv;
 
-CvLevMarq::CvLevMarq()
-{
-    mask = prevParam = param = J = err = JtJ = JtJN = JtErr = JtJV = JtJW = Ptr<CvMat>();
-    lambdaLg10 = 0; state = DONE;
-    criteria = cvTermCriteria(0,0,0);
-    iters = 0;
-    completeSymmFlag = false;
-}
-
-CvLevMarq::CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria0, bool _completeSymmFlag )
-{
-    mask = prevParam = param = J = err = JtJ = JtJN = JtErr = JtJV = JtJW = Ptr<CvMat>();
-    init(nparams, nerrs, criteria0, _completeSymmFlag);
-}
-
-void CvLevMarq::clear()
-{
-    mask.release();
-    prevParam.release();
-    param.release();
-    J.release();
-    err.release();
-    JtJ.release();
-    JtJN.release();
-    JtErr.release();
-    JtJV.release();
-    JtJW.release();
-}
-
-CvLevMarq::~CvLevMarq()
-{
-    clear();
-}
-
-void CvLevMarq::init( int nparams, int nerrs, CvTermCriteria criteria0, bool _completeSymmFlag )
-{
-    if( !param || param->rows != nparams || nerrs != (err ? err->rows : 0) )
-        clear();
-    mask = cvCreateMat( nparams, 1, CV_8U );
-    cvSet(mask, cvScalarAll(1));
-    prevParam = cvCreateMat( nparams, 1, CV_64F );
-    param = cvCreateMat( nparams, 1, CV_64F );
-    JtJ = cvCreateMat( nparams, nparams, CV_64F );
-    JtJN = cvCreateMat( nparams, nparams, CV_64F );
-    JtJV = cvCreateMat( nparams, nparams, CV_64F );
-    JtJW = cvCreateMat( nparams, 1, CV_64F );
-    JtErr = cvCreateMat( nparams, 1, CV_64F );
-    if( nerrs > 0 )
-    {
-        J = cvCreateMat( nerrs, nparams, CV_64F );
-        err = cvCreateMat( nerrs, 1, CV_64F );
-    }
-    prevErrNorm = DBL_MAX;
-    lambdaLg10 = -3;
-    criteria = criteria0;
-    if( criteria.type & CV_TERMCRIT_ITER )
-        criteria.max_iter = MIN(MAX(criteria.max_iter,1),1000);
-    else
-        criteria.max_iter = 30;
-    if( criteria.type & CV_TERMCRIT_EPS )
-        criteria.epsilon = MAX(criteria.epsilon, 0);
-    else
-        criteria.epsilon = DBL_EPSILON;
-    state = STARTED;
-    iters = 0;
-    completeSymmFlag = _completeSymmFlag;
-}
-
-bool CvLevMarq::update( const CvMat*& _param, CvMat*& matJ, CvMat*& _err )
-{
-    double change;
-
-    matJ = _err = 0;
-
-    assert( !err.empty() );
-    if( state == DONE )
-    {
-        _param = param;
-        return false;
-    }
-
-    if( state == STARTED )
-    {
-        _param = param;
-        cvZero( J );
-        cvZero( err );
-        matJ = J;
-        _err = err;
-        state = CALC_J;
-        return true;
-    }
-
-    if( state == CALC_J )
-    {
-        cvMulTransposed( J, JtJ, 1 );
-        cvGEMM( J, err, 1, 0, 0, JtErr, CV_GEMM_A_T );
-        cvCopy( param, prevParam );
-        step();
-        if( iters == 0 )
-            prevErrNorm = cvNorm(err, 0, CV_L2);
-        _param = param;
-        cvZero( err );
-        _err = err;
-        state = CHECK_ERR;
-        return true;
-    }
-
-    assert( state == CHECK_ERR );
-    errNorm = cvNorm( err, 0, CV_L2 );
-    if( errNorm > prevErrNorm )
-    {
-        if( ++lambdaLg10 <= 16 )
-        {
-            step();
-            _param = param;
-            cvZero( err );
-            _err = err;
-            state = CHECK_ERR;
-            return true;
-        }
-    }
-
-    lambdaLg10 = MAX(lambdaLg10-1, -16);
-    if( ++iters >= criteria.max_iter ||
-        (change = cvNorm(param, prevParam, CV_RELATIVE_L2)) < criteria.epsilon )
-    {
-        _param = param;
-        state = DONE;
-        return true;
-    }
-
-    prevErrNorm = errNorm;
-    _param = param;
-    cvZero(J);
-    matJ = J;
-    _err = err;
-    state = CALC_J;
-    return true;
-}
-
-
-bool CvLevMarq::updateAlt( const CvMat*& _param, CvMat*& _JtJ, CvMat*& _JtErr, double*& _errNorm )
-{
-    double change;
-
-    CV_Assert( err.empty() );
-    if( state == DONE )
-    {
-        _param = param;
-        return false;
-    }
-
-    if( state == STARTED )
-    {
-        _param = param;
-        cvZero( JtJ );
-        cvZero( JtErr );
-        errNorm = 0;
-        _JtJ = JtJ;
-        _JtErr = JtErr;
-        _errNorm = &errNorm;
-        state = CALC_J;
-        return true;
-    }
-
-    if( state == CALC_J )
-    {
-        cvCopy( param, prevParam );
-        step();
-        _param = param;
-        prevErrNorm = errNorm;
-        errNorm = 0;
-        _errNorm = &errNorm;
-        state = CHECK_ERR;
-        return true;
-    }
-
-    assert( state == CHECK_ERR );
-    if( errNorm > prevErrNorm )
-    {
-        if( ++lambdaLg10 <= 16 )
-        {
-            step();
-            _param = param;
-            errNorm = 0;
-            _errNorm = &errNorm;
-            state = CHECK_ERR;
-            return true;
-        }
-    }
-
-    lambdaLg10 = MAX(lambdaLg10-1, -16);
-    if( ++iters >= criteria.max_iter ||
-        (change = cvNorm(param, prevParam, CV_RELATIVE_L2)) < criteria.epsilon )
-    {
-        _param = param;
-        state = DONE;
-        return false;
-    }
-
-    prevErrNorm = errNorm;
-    cvZero( JtJ );
-    cvZero( JtErr );
-    _param = param;
-    _JtJ = JtJ;
-    _JtErr = JtErr;
-    state = CALC_J;
-    return true;
-}
-
-void CvLevMarq::step()
-{
-    const double LOG10 = log(10.);
-    double lambda = exp(lambdaLg10*LOG10);
-    int i, j, nparams = param->rows;
-
-    for( i = 0; i < nparams; i++ )
-        if( mask->data.ptr[i] == 0 )
-        {
-            double *row = JtJ->data.db + i*nparams, *col = JtJ->data.db + i;
-            for( j = 0; j < nparams; j++ )
-                row[j] = col[j*nparams] = 0;
-            JtErr->data.db[i] = 0;
-        }
-
-    if( !err )
-        cvCompleteSymm( JtJ, completeSymmFlag );
-#if 1
-    cvCopy( JtJ, JtJN );
-    for( i = 0; i < nparams; i++ )
-        JtJN->data.db[(nparams+1)*i] *= 1. + lambda;
-#else
-    cvSetIdentity(JtJN, cvRealScalar(lambda));
-    cvAdd( JtJ, JtJN, JtJN );
-#endif
-    cvSVD( JtJN, JtJW, 0, JtJV, CV_SVD_MODIFY_A + CV_SVD_U_T + CV_SVD_V_T );
-    cvSVBkSb( JtJW, JtJV, JtJV, JtErr, param, CV_SVD_U_T + CV_SVD_V_T );
-    for( i = 0; i < nparams; i++ )
-        param->data.db[i] = prevParam->data.db[i] - (mask->data.ptr[i] ? param->data.db[i] : 0);
-}
-
 // reimplementation of dAB.m
 CV_IMPL void cvCalcMatMulDeriv( const CvMat* A, const CvMat* B, CvMat* dABdA, CvMat* dABdB )
 {

modules/calib3d/src/circlesgrid.cpp

@@ -402,14 +402,16 @@ void CirclesGridClusterFinder::parsePatternPoints(const std::vector<cv::Point2f>
       else
         idealPt = Point2f(j*squareSize, i*squareSize);
 
-      std::vector<float> query = Mat(idealPt);
+      Mat query(1, 2, CV_32F, &idealPt);
       int knn = 1;
-      std::vector<int> indices(knn);
-      std::vector<float> dists(knn);
+      int indicesbuf = 0;
+      float distsbuf = 0.f;
+      Mat indices(1, knn, CV_32S, &indicesbuf);
+      Mat dists(1, knn, CV_32F, &distsbuf);
       flannIndex.knnSearch(query, indices, dists, knn, flann::SearchParams());
-      centers.push_back(patternPoints.at(indices[0]));
+      centers.push_back(patternPoints.at(indicesbuf));
 
-      if(dists[0] > maxRectifiedDistance)
+      if(distsbuf > maxRectifiedDistance)
       {
 #ifdef DEBUG_CIRCLES
         cout << "Pattern not detected: too large rectified distance" << endl;

modules/calib3d/src/levmarq.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <stdio.h>
+
+/*
+   This is translation to C++ of the Matlab's LMSolve package by Miroslav Balda.
+   Here is the original copyright:
+   ============================================================================
+   
+   Copyright (c) 2007, Miroslav Balda
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met:
+
+       * Redistributions of source code must retain the above copyright 
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright 
+         notice, this list of conditions and the following disclaimer in 
+         the documentation and/or other materials provided with the distribution
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+   POSSIBILITY OF SUCH DAMAGE.
+*/
+
+namespace cv
+{
+
+class LMSolverImpl : public LMSolver
+{
+public:
+    LMSolverImpl() : maxIters(100) { init(); };
+    LMSolverImpl(const Ptr<LMSolver::Callback>& _cb, int _maxIters) : cb(_cb), maxIters(_maxIters) { init(); }
+
+    void init()
+    {
+        epsx = epsf = FLT_EPSILON;
+        printInterval = 0;
+    }
+
+    int run(InputOutputArray _param0) const
+    {
+        Mat param0 = _param0.getMat(), x, xd, r, rd, J, A, Ap, v, temp_d, d;
+        int ptype = param0.type();
+
+        CV_Assert( (param0.cols == 1 || param0.rows == 1) && (ptype == CV_32F || ptype == CV_64F));
+        CV_Assert( !cb.empty() );
+
+        int lx = param0.rows + param0.cols - 1;
+        param0.convertTo(x, CV_64F);
+
+        if( x.cols != 1 )
+            transpose(x, x);
+
+        if( !cb->compute(x, r, J) )
+            return -1;
+        double S = norm(r, NORM_L2SQR);
+        int nfJ = 2;
+
+        mulTransposed(J, A, true);
+        gemm(J, r, 1, noArray(), 0, v, GEMM_1_T);
+
+        Mat D = A.diag().clone();
+        
+        const double Rlo = 0.25, Rhi = 0.75;
+        double lambda = 1, lc = 0.75;
+        int i, iter = 0;
+
+        if( printInterval != 0 )
+        {
+            printf("************************************************************************************\n");
+            printf("\titr\tnfJ\t\tSUM(r^2)\t\tx\t\tdx\t\tl\t\tlc\n");
+            printf("************************************************************************************\n");
+        }
+
+        for( ;; )
+        {
+            CV_Assert( A.type() == CV_64F && A.rows == lx );
+            A.copyTo(Ap);
+            for( i = 0; i < lx; i++ )
+                Ap.at<double>(i, i) += lambda*D.at<double>(i);
+            solve(Ap, v, d, DECOMP_EIG);
+            subtract(x, d, xd);
+            if( !cb->compute(xd, rd, noArray()) )
+                return -1;
+            nfJ++;
+            double Sd = norm(rd, NORM_L2SQR);
+            gemm(A, d, -1, v, 2, temp_d);
+            double dS = d.dot(temp_d);
+            double R = (S - Sd)/(fabs(dS) > DBL_EPSILON ? dS : 1);
+
+            if( R > Rhi )
+            {
+                lambda *= 0.5;
+                if( lambda < lc )
+                    lambda = 0;
+            }
+            else if( R < Rlo )
+            {
+                // find new nu if R too low
+                double t = d.dot(v);
+                double nu = (Sd - S)/(fabs(t) > DBL_EPSILON ? t : 1) + 2;
+                nu = std::min(std::max(nu, 2.), 10.);
+                if( lambda == 0 )
+                {
+                    invert(A, Ap, DECOMP_EIG);
+                    double maxval = DBL_EPSILON;
+                    for( i = 0; i < lx; i++ )
+                        maxval = std::max(maxval, std::abs(Ap.at<double>(i,i)));
+                    lambda = lc = 1./maxval;
+                    nu *= 0.5;
+                }
+                lambda *= nu;
+            }
+
+            if( Sd < S )
+            {
+                nfJ++;
+                S = Sd;
+                std::swap(x, xd);
+                if( !cb->compute(x, r, J) )
+                    return -1;
+                mulTransposed(J, A, true);
+                gemm(J, r, 1, noArray(), 0, v, GEMM_1_T);
+            }
+
+            iter++;
+            bool proceed = iter < maxIters && norm(d, NORM_INF) >= epsx && norm(r, NORM_INF) >= epsf;
+
+            if( printInterval != 0 && (iter % printInterval == 0 || iter == 1 || !proceed) )
+            {
+                printf("%c%10d %10d %15.4e %16.4e %17.4e %16.4e %17.4e\n",
+                       (proceed ? ' ' : '*'), iter, nfJ, S, x.at<double>(0), d.at<double>(0), lambda, lc);
+            }
+
+            if(!proceed)
+                break;
+        }
+
+        if( param0.size != x.size )
+            transpose(x, x);
+
+        x.convertTo(param0, ptype);
+        if( iter == maxIters )
+            iter = -iter;
+
+        return iter;
+    }
+
+    void setCallback(const Ptr<LMSolver::Callback>& _cb) { cb = _cb; }
+
+    AlgorithmInfo* info() const;
+
+    Ptr<LMSolver::Callback> cb;
+
+    double epsx;
+    double epsf;
+    int maxIters;
+    int printInterval;
+};
+
+
+CV_INIT_ALGORITHM(LMSolverImpl, "LMSolver",
+                  obj.info()->addParam(obj, "epsx", obj.epsx);
+                  obj.info()->addParam(obj, "epsf", obj.epsf);
+                  obj.info()->addParam(obj, "maxIters", obj.maxIters);
+                  obj.info()->addParam(obj, "printInterval", obj.printInterval));
+
+CV_EXPORTS Ptr<LMSolver> createLMSolver(const Ptr<LMSolver::Callback>& cb, int maxIters)
+{
+    CV_Assert( !LMSolverImpl_info_auto.name().empty() );
+    return new LMSolverImpl(cb, maxIters);
+}
+    
+}

modules/calib3d/src/precomp.hpp

@@ -59,4 +59,51 @@
 #define GET_OPTIMIZED(func) (func)
 #endif
 
+
+namespace cv
+{
+
+int RANSACUpdateNumIters( double p, double ep, int modelPoints, int maxIters );
+
+class CV_EXPORTS LMSolver : public Algorithm
+{
+public:
+    class CV_EXPORTS Callback
+    {
+    public:
+        virtual ~Callback() {}
+        virtual bool compute(InputArray param, OutputArray err, OutputArray J) const = 0;
+    };
+
+    virtual void setCallback(const Ptr<LMSolver::Callback>& cb) = 0;
+    virtual int run(InputOutputArray _param0) const = 0;
+};
+
+CV_EXPORTS Ptr<LMSolver> createLMSolver(const Ptr<LMSolver::Callback>& cb, int maxIters);
+
+class PointSetRegistrator : public Algorithm
+{
+public:
+    class CV_EXPORTS Callback
+    {
+    public:
+        virtual ~Callback() {}
+        virtual int runKernel(InputArray m1, InputArray m2, OutputArray model) const = 0;
+        virtual void computeError(InputArray m1, InputArray m2, InputArray model, OutputArray err) const = 0;
+        virtual bool checkSubset(InputArray, InputArray, int) const { return true; }
+    };
+
+    virtual void setCallback(const Ptr<PointSetRegistrator::Callback>& cb) = 0;
+    virtual bool run(InputArray m1, InputArray m2, OutputArray model, OutputArray mask) const = 0;
+};
+
+CV_EXPORTS Ptr<PointSetRegistrator> createRANSACPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
+                                                                    int modelPoints, double threshold,
+                                                                    double confidence=0.99, int maxIters=1000 );
+
+CV_EXPORTS Ptr<PointSetRegistrator> createLMeDSPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
+                                                                   int modelPoints, double confidence=0.99, int maxIters=1000 );
+
+}
+
 #endif

modules/calib3d/test/test_affine3d_estimator.cpp

@@ -163,6 +163,8 @@ bool CV_Affine3D_EstTest::testNPoints()
     const double thres = 1e-4;
     if (norm(aff_est, aff, NORM_INF) > thres)
     {
+        cout << "aff est: " << aff_est << endl;
+        cout << "aff ref: " << aff << endl;
         ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
         return false;
     }

modules/calib3d/test/test_fundam.cpp

@@ -1020,7 +1020,7 @@ void CV_FundamentalMatTest::prepare_to_validation( int test_case_idx )
     F0 *= 1./f0[8];
 
     uchar* status = test_mat[TEMP][1].data;
-    double err_level = get_success_error_level( test_case_idx, OUTPUT, 1 );
+    double err_level = method <= CV_FM_8POINT ? 1 : get_success_error_level( test_case_idx, OUTPUT, 1 );
     uchar* mtfm1 = test_mat[REF_OUTPUT][1].data;
     uchar* mtfm2 = test_mat[OUTPUT][1].data;
     double* f_prop1 = (double*)test_mat[REF_OUTPUT][0].data;

modules/calib3d/test/test_modelest.cpp

@@ -40,6 +40,8 @@
 //M*/
 
 #include "test_precomp.hpp"
+
+#if 0
 #include "_modelest.h"
 
 using namespace std;
@@ -225,3 +227,6 @@ void CV_ModelEstimator2_Test::run_func()
 }
 
 TEST(Calib3d_ModelEstimator2, accuracy) { CV_ModelEstimator2_Test test; test.safe_run(); }
+
+#endif
+

modules/core/src/matrix.cpp

@@ -1145,7 +1145,7 @@ Size _InputArray::size(int i) const
         const std::vector<uchar>& v = *(const std::vector<uchar>*)obj;
         const std::vector<int>& iv = *(const std::vector<int>*)obj;
         size_t szb = v.size(), szi = iv.size();
-        return szb == szi ? Size((int)szb, 1) : Size((int)(szb/CV_ELEM_SIZE(flags)), 1);
+        return szb == szi ? Size(1, (int)szb) : Size(1, (int)(szb/CV_ELEM_SIZE(flags)));
     }
 
     if( k == NONE )
@@ -1155,19 +1155,19 @@ Size _InputArray::size(int i) const
     {
         const std::vector<std::vector<uchar> >& vv = *(const std::vector<std::vector<uchar> >*)obj;
         if( i < 0 )
-            return vv.empty() ? Size() : Size((int)vv.size(), 1);
+            return vv.empty() ? Size() : Size(1, (int)vv.size());
         CV_Assert( i < (int)vv.size() );
         const std::vector<std::vector<int> >& ivv = *(const std::vector<std::vector<int> >*)obj;
 
         size_t szb = vv[i].size(), szi = ivv[i].size();
-        return szb == szi ? Size((int)szb, 1) : Size((int)(szb/CV_ELEM_SIZE(flags)), 1);
+        return szb == szi ? Size(1, (int)szb) : Size(1, (int)(szb/CV_ELEM_SIZE(flags)));
     }
 
     if( k == STD_VECTOR_MAT )
     {
         const std::vector<Mat>& vv = *(const std::vector<Mat>*)obj;
         if( i < 0 )
-            return vv.empty() ? Size() : Size((int)vv.size(), 1);
+            return vv.empty() ? Size() : Size(1, (int)vv.size());
         CV_Assert( i < (int)vv.size() );
 
         return vv[i].size();

modules/core/test/test_operations.cpp

@@ -487,7 +487,7 @@ bool CV_OperationsTest::TestSubMatAccess()
             coords.push_back(T_bs(i));
             //std::cout << T_bs1(i) << std::endl;
         }
-        CV_Assert( norm(coords, T_bs.reshape(1,1), NORM_INF) == 0 );
+        CV_Assert( norm(coords, T_bs.reshape(1,1).t(), NORM_INF) == 0 );
     }
     catch (const test_excep& e)
     {