Add IPPE method for planar pose estimation in solvePnP #14362

catree · 2019-04-18T17:31:58Z

Merge with opencv_extra: opencv/opencv_extra#606

This pullrequest changes

@tobycollins This is the (draft) pull request following tobycollins/IPPE#4

Main differences with the original IPPE code:

camera parameters and distortion coefficients are not used since we pass already points in normalized camera frame
add some code to be compatible with CV_32F/CV_64F input types
cosmetic changes, use CV_Assert, ...

Main changes:

add SOLVEPNP_IPPE for planar pose estimation
add SOLVEPNP_IPPE_SQUARE for tag pose estimation (z=0, frame is centered)
add solvePnPGeneric that returns all the solutions and optionally the reprojection error
rewrite tests and add new tests

force_builders=Custom
buildworker:Custom=linux-1,linux-2,linux-4
docker_image:Custom=ubuntu-clang:18.04

catree · 2019-04-18T17:36:36Z

modules/calib3d/include/opencv2/calib3d.hpp

@@ -777,6 +779,14 @@ CV_EXPORTS_W int solveP3P( InputArray objectPoints, InputArray imagePoints,
                           OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
                           int flags );

+//TODO: doc
+CV_EXPORTS_W int solvePnPGeneric( InputArray objectPoints, InputArray imagePoints,


Other possibility could be to return a struct of pose info instead of all the parameters. But I have not seen this yet in OpenCV, due to issue with Python/Java bindings maybe?

Python/Java bindings

I believe, bindings generator should support non-complex structures.

catree · 2019-04-18T17:44:06Z

modules/calib3d/src/solvepnp.cpp

+    //TODO:
+//    else
+//    {
+//        // use CV_32F if all PnP inputs are CV_32F and outputs are empty


use CV_32F if all PnP inputs are CV_32F and outputs are empty

EPnP should return always in double precision:

opencv/modules/calib3d/src/epnp.cpp

Lines 195 to 196 in 1f517b8

Mat(3, 1, CV_64F, ts[N]).copyTo(t);

Mat(3, 3, CV_64F, Rs[N]).copyTo(R);

Same thing with most of the methods, e.g. for P3P:

opencv/modules/calib3d/src/p3p.cpp

Lines 55 to 56 in 1f517b8

cv::Mat(3, 1, CV_64F, translation).copyTo(tvec);

cv::Mat(3, 3, CV_64F, rotation_matrix).copyTo(R);

For iterative:

opencv/modules/calib3d/src/calibration.cpp

Lines 1251 to 1257 in 1f517b8

_r = cvMat( rvec->rows, rvec->cols,

CV_MAKETYPE(CV_64F,CV_MAT_CN(rvec->type)), param );

_t = cvMat( tvec->rows, tvec->cols,

CV_MAKETYPE(CV_64F,CV_MAT_CN(tvec->type)), param + 3 );

cvConvert( &_r, rvec );

cvConvert( &_t, tvec );

For me, even if all the input are in CV_32F, rvec and tvec should be overwritten in double precision.

I have changed the code to return rvec and tvec always in CV_64F depth. Internally, all these methods should use double for calculation.

Documentation should be updated to reflect that.

rvec and tvec should be overwritten in double precision

Not always.
Use this pattern:

if (R.needed()) _R.convertTo(R, R.empty() ? CV_64FC1 : R.type());

(however it is buggy in some cases - doesn't support empty Mat_<float>, but should raise an exception)

Internally, all these methods should use double for calculation.

This is the right way.

This makes sense:

always return in CV_64FC1

except if rvec or tvec is not empty

Need to check that it works properly.

catree · 2019-04-18T17:47:53Z

modules/calib3d/src/solvepnp.cpp

+    else if (flags == SOLVEPNP_IPPE)
+    {
+        double val = 0.0;
+        bool planar = isPlanarObjectPoints(opoints, 1e-5, val);


I have added a method to check that the input points are indeed planar. Otherwise, we return false.

Which threshold to use? Here we have:

opencv/modules/calib3d/src/calibration.cpp

Line 1112 in 1f517b8

if( W[2]/W[1] < 1e-3)

In IPPE there is #define IPPE_SMALL 1e-7

The threshold is a bit arbitrary. To keep consistent with OpenCV 1e-3 should be fine.

I have changed the threshold to use 1e-3 for IPPE_SMALL too.

modules/calib3d/src/solvepnp.cpp

catree · 2019-04-18T17:54:15Z

modules/calib3d/test/test_solvepnp_ransac.cpp

-        Point3f pmin = Point3f(-1, -1, 5),
-        Point3f pmax = Point3f(1, 1, 10))
+                              Point3f pmin = Point3f(-1, -1, 5),
+                              Point3f pmax = Point3f(1, 1, 10))
    {
        RNG rng = cv::theRNG(); // fix the seed to use "fixed" input 3D points


Should we use instead ts->get_rng()?

catree · 2019-04-18T17:55:32Z

modules/calib3d/test/test_solvepnp_ransac.cpp

        for (int i = 0; i < 3; i++)
        {
            rvec.at<double>(i,0) = rng.uniform(minVal, maxVal);
-            tvec.at<double>(i,0) = rng.uniform(minVal, maxVal/10);
+            tvec.at<double>(i,0) = (i == 2) ? rng.uniform(minVal*10, maxVal) : rng.uniform(-maxVal, maxVal);


We need tz>0 but tx and ty can be negative.

catree · 2019-04-18T17:57:24Z

modules/calib3d/test/test_solvepnp_ransac.cpp

        Mat rvec, tvec;
        vector<int> inliers;
        Mat trueRvec, trueTvec;
        Mat intrinsics, distCoeffs;
        generateCameraMatrix(intrinsics, rng);
-        if (method == 4) intrinsics.at<double>(1,1) = intrinsics.at<double>(0,0);
+        //UPnP is mapped to EPnP


I have commented all the specific code for UPnP, DLS? since they are internally remapped to EPnP.
It is misleading to have different results, thresholds between EPnP and UPnP, DLS.

catree · 2019-04-18T17:58:18Z

modules/calib3d/test/test_solvepnp_ransac.cpp

-        //cout << error << " " << inliers.size() << " " << eps[method] << endl;
-        if (error > maxError)
-            maxError = error;
+        isTestSuccess = isTestSuccess && rvecDiff < eps[method] && tvecDiff < eps[method];


Ultimately, I think that we should have different thresholds for translation and rotation. Pratically, we use the same values...

I believe, robust test check should call projectPoints() with estimated rvec/tvec and check relative norm L2.

catree · 2019-04-18T18:04:14Z

modules/calib3d/test/test_solvepnp_ransac.cpp

@@ -455,7 +770,7 @@ TEST(Calib3d_SolvePnPRansac, input_type)
    EXPECT_LE(cvtest::norm(t1, t4, NORM_INF), 1e-6);
 }

-TEST(Calib3d_SolvePnP, double_support)
+TEST(Calib3d_SolvePnPRansac, double_support)


Not sure of the validity of this test (same thing with TEST(Calib3d_SolvePnPRansac, input_type)).
Not sure about how the images points are defined. Since we just check that we got the same results between float and double input, I guess it is more or less OK?

catree · 2019-04-18T18:11:16Z

Tests are tricky. Input are generated randomly but we got lots of bad results even when using image points projected by the ground truth pose. Is there some issue when we generate a camera pose where most of the points are not visible for instance?

We don't test with noise for image points whereas in real life there are many source of uncertainties.

catree · 2019-04-18T18:14:57Z

modules/calib3d/src/ippe.cpp

+            canonicalObjPoints.at<Vec2d>(i)[1] = UZeroAligned.at<double>(1, i);
+            //or
+            //TODO:
+//            CV_DbgAssert(abs(UZeroAligned.at<double>(2, i)) <= IPPE_SMALL);


Should we keep the CV_DbgAssert or maybe find a way to return false to not interrupt the main program?

I believe, CV_Error() with Error::StsNoConv is fine here.

not interrupt the main program

"main program" should expect that OpenCV C++ functions can raise exceptions and handle that cases.

alalek

Thank you!

Please take a look on comments below.

alalek · 2019-04-19T18:08:53Z

modules/calib3d/include/opencv2/calib3d.hpp

@@ -777,6 +779,14 @@ CV_EXPORTS_W int solveP3P( InputArray objectPoints, InputArray imagePoints,
                           OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
                           int flags );

+//TODO: doc
+CV_EXPORTS_W int solvePnPGeneric( InputArray objectPoints, InputArray imagePoints,


Python/Java bindings

I believe, bindings generator should support non-complex structures.

alalek · 2019-04-19T18:11:57Z

modules/calib3d/include/opencv2/calib3d.hpp

-       SOLVEPNP_AP3P      = 5, //!< An Efficient Algebraic Solution to the Perspective-Three-Point Problem @cite Ke17
-       SOLVEPNP_MAX_COUNT      //!< Used for count
+enum { SOLVEPNP_ITERATIVE   = 0,
+       SOLVEPNP_EPNP        = 1, //!< EPnP: Efficient Perspective-n-Point Camera Pose Estimation @cite lepetit2009epnp


Could you please change indentation for 4 spaces here?
It would be nice to add some name for this enum too:

enum SolvePnPMethod { SOLVEPNP_ITERATIVE = 0, ... #ifndef CV_DOXYGEN SOLVEPNP_MAX_COUNT #endif };

modules/calib3d/src/ippe.cpp

alalek · 2019-04-19T18:18:35Z

modules/calib3d/src/ippe.cpp

+
+    Mat pts = _targetPoints.getMat();
+    H_.create(3, 3, CV_64FC1);
+    Mat H = H_.getMat();


Matx33d H; H( , ) = ... H.copyTo(H_); or Mat(H, false).copyTo(H_);

alalek · 2019-04-19T18:33:48Z

modules/calib3d/src/solvepnp.cpp

+    //TODO:
+//    else
+//    {
+//        // use CV_32F if all PnP inputs are CV_32F and outputs are empty


rvec and tvec should be overwritten in double precision

Not always.
Use this pattern:

if (R.needed()) _R.convertTo(R, R.empty() ? CV_64FC1 : R.type());

(however it is buggy in some cases - doesn't support empty Mat_<float>, but should raise an exception)

Internally, all these methods should use double for calculation.

This is the right way.

alalek · 2019-04-19T18:37:06Z

modules/calib3d/src/solvepnp.cpp

+    Mat w, u, vt;
+    SVDecomp(objectPointsCentred, w, u, vt);
+    val = w.at<double>(2)/w.at<double>(1);
+    return (w.at<double>(2)/w.at<double>(1) < threshold);


reuse val?

fabs()?

a / b < c ==> a < c * b?

I have used the multiplication.
I don't know exactly what this quantity represents exactly.
fabs is not used here :

opencv/modules/calib3d/src/calibration.cpp

Line 1112 in d0032b0

if( W[2]/W[1] < 1e-3)

and here
https://github.com/tobycollins/IPPE/blob/3af0127a30fcb0d35fa2a34f4abd93278e631621/cpp/src/IPPE/ippe.cpp#L1037

modules/calib3d/src/solvepnp.cpp

alalek · 2019-04-19T18:45:50Z

modules/calib3d/test/test_solvepnp_ransac.cpp

-        //cout << error << " " << inliers.size() << " " << eps[method] << endl;
-        if (error > maxError)
-            maxError = error;
+        isTestSuccess = isTestSuccess && rvecDiff < eps[method] && tvecDiff < eps[method];


I believe, robust test check should call projectPoints() with estimated rvec/tvec and check relative norm L2.

tobycollins · 2019-04-23T12:01:48Z

This is a great start. I have a couple of comments.

Efficiency: For solvePnPGeneric, maybe there could be an input flag to bypass non-trivial error checks (e.g. that the model is planar). This would allow for faster computation. If error checks are disabled, it is the user's responsibility to ensure the data they pass to solvePnPGeneric is correct.

Generality: solvePnP's iterative solver (SOLVEPNP_ITERATIVE flag) is a bit messy in the way that it handles initialization. The iterative solver requires an initial pose estimate. Currently there are two ways the initial pose estimate is established. The first is by the user setting the flag useExtrinsicGuess=true, in which case the inputted rvec and tvec are used as the initial estimate. The second way is by setting the flag useExtrinsicGuess=false, and then the initial estimate is computed using an existing non-iterative pnp method. Currently, if the model is planar, the non-iterative method used is Zhang's method (calibration.cpp line 1115), which is bad because it can only return one pose solution and can be unstable. If the model is non-planar, the method is the DLT (calibration.cpp line 1171).

I would say that a nice generic interface for pnp would allow the user to specify 1) the pnp method used for initialization (non-iterative - requires no initial solution) and 2) the pnp method used for refining the solution(s) provied by 1). IPPE can then replace Zhang as the default pnp method for 1). For 2), currently the options could be either "none" (no solution refinement) or OpenCV's Levenberg–Marquardt implementation, where each pose solution from 1) should be refined with LM.

catree · 2019-04-25T18:16:45Z

I have added the checks only if defined _DEBUG. This way, only in debug mode the checks should be done. Otherwise, the user needs to understand what he is doing.

See also discussion in #14181 about extrinsic guess.

tobycollins · 2019-05-02T12:39:26Z

Hi! Just wondering if you need me to assist?

catree · 2019-05-06T16:52:15Z

The PR should be ready on my side.
Preview of the doc is here.

Main changes:

solveP3P, solvePnP and solvePnPGeneric return result in double precision unless the parameters are not empty
solveP3P returns solutions sorted by reprojection error (looks like it was already the case implicitly before?)
no input checks in release mode for IPPE flags, only in debug we check that the input points are coplanar and some other checks
RMSE formula is used to return the reprojection error

@tobycollins
There are some reported issues with the planar pose ambiguity, e.g. chili-epfl/chilitags#19 or #8813
I think one workaround is to use methods that return the two solutions and assume the correct current solution is the one that is consistent with the previous ones (closest rotation angle with Rodrigues on R_prev x R^t). Precision in the 2D corners locations matters also.
Feel free to comment if you have some input on this topic.

tobycollins · 2019-05-08T05:48:45Z

For the main changes: solveP3P, all real solutions should have zero reprojection error up to numerical precision, so there's no need to sort them.

catree · 2019-05-09T12:53:13Z

There is something a little bit odd.
For AP3P, it looks like it returns always one duplicate solution (@tonyke1993).

Log

[ RUN      ] Calib3d_SolveP3P.accuracy
P3P: SOLVEPNP_P3P ; mode: no distortion
reproj_errors[0]: 1.97781e-13 ; rvec: [0.0708147132641186, 0.8781573660151019, 0.2062297332702701] ; tvec: [-0.6382628557692769, -0.5230680987847804, 0.8608043184305609]
reproj_errors[1]: 2.65255e-13 ; rvec: [1.072456970328113, 0.2927043313311256, -0.1533584924504722] ; tvec: [3.78751818519377, 7.29785461655783, 1.635197316345136]
reproj_errors[0]: 2.46787e-12 ; rvec: [0.2727173450490416, 0.2242272799432045, 0.2791376172097507] ; tvec: [-0.6953767910063988, -0.02930274646937026, 0.3470193252670954]
reproj_errors[1]: 5.68675e-12 ; rvec: [1.219093476888883, -0.2003887296031083, 0.1882578974091038] ; tvec: [1.772672167638839, 6.322105539107381, 4.542848666342317]
reproj_errors[0]: 2.44922e-12 ; rvec: [0.8375006726335797, 0.07566923504442112, 0.8787026965474921] ; tvec: [-0.9303077437295193, -0.941039029392897, 0.09472979616323318]
reproj_errors[1]: 1.79379e-11 ; rvec: [1.912849703897433, -0.1357163319157718, 0.6929121287896357] ; tvec: [-1.377137235675767, 1.990538033324617, 7.738429970613167]
reproj_errors[0]: 1.44574e-11 ; rvec: [0.5762142980754164, 0.3171156689462074, 0.6890225958046882] ; tvec: [-0.7410543647127392, 0.7997651229759568, 0.8392565005898067]
reproj_errors[1]: 2.96626e-10 ; rvec: [1.316927176115196, 0.1564372264455825, 0.5310053850211202] ; tvec: [-0.5641023939534242, 5.226222213544935, 4.774947854961231]
reproj_errors[0]: 2.34112e-13 ; rvec: [0.07500725692637875, 0.4164051338265355, 0.69333634559029] ; tvec: [0.9818257209371013, -0.7772351094408156, 0.7858196664612045]
reproj_errors[1]: 1.30053e-12 ; rvec: [1.219923802948575, 0.3205549609997766, 0.3719968124979506] ; tvec: [0.2033505807336398, 7.112734554476308, 4.936069851382808]
mode: no distortion, method: SOLVEPNP_P3P -> 100% (maxErrT: 0, maxErrR: 0, meanErrT: 0, meanErrR: 0, medErrT: 0, medErrR: 0)
approximate translation threshold for 0.7: 0, approximate rotation threshold for 0.7: 0
P3P: SOLVEPNP_AP3P ; mode: no distortion
realRoots[0]: 0.18742683274384103
realRoots[1]: -0.11811877872121801
realRoots[2]: -0.02093976579947366
realRoots[3]: -0.02093976579947366
real_roots[0]: -0.020939765799473785
real_roots[1]: -0.020939765799473785
real_roots[2]: -0.11811877872121554
real_roots[3]: 0.18742683274383878
ctheta1p: 0.18742683274383981
ctheta1p: -0.11811877872121668
ctheta1p: -0.1383779629362778
ctheta1p: -0.1383779629362778
reproj_errors[0]: 2.0402480057544015e-13 ; rvec: [1.140233766552894, 0.2018929763773085, 0.652702768767715] ; tvec: [-1.90487968133474, 7.05496085439476, 3.95998654137381]
reproj_errors[1]: 2.0402480251555385e-13 ; rvec: [0.007455122954988631, 0.3526350776899135, 0.8292748524197768] ; tvec: [-0.2573563083189498, -0.6928104110845046, 0.6106145464000958]
reproj_errors[2]: 0.017409484141608554 ; rvec: [0.02650676909235508, 0.3239804444454416, 0.8349315931187546] ; tvec: [-0.08677804586400217, -0.4508693226684723, 0.6267632075158875]
reproj_errors[3]: 0.017409484141608554 ; rvec: [0.02650676909235508, 0.3239804444454416, 0.8349315931187546] ; tvec: [-0.08677804586400217, -0.4508693226684723, 0.6267632075158875]
realRoots[0]: 0.19213418014928946
realRoots[1]: -0.11199646842254483
realRoots[2]: -0.025072788812264907
realRoots[3]: -0.025072788812264907
real_roots[0]: -0.025072788812264907
real_roots[1]: -0.025072788812264907
real_roots[2]: -0.11199646842254472
real_roots[3]: 0.19213418014928935
ctheta1p: 0.19213418014928951
ctheta1p: -0.11199646842254489
ctheta1p: -0.12225737864827568
ctheta1p: -0.12225737864827568
reproj_errors[0]: 1.6967679217074199e-11 ; rvec: [1.328461742503199, 0.6482806668337672, 0.2095366628271217] ; tvec: [0.6274241420066087, 7.19152276739059, 3.673872394207908]
reproj_errors[1]: 1.6967678640845434e-11 ; rvec: [0.274560163757092, 0.9136871966095148, 0.7215152954636539] ; tvec: [-0.6509474212413542, -0.6465846889027019, 0.1367777090326978]
reproj_errors[2]: 0.016150292674458572 ; rvec: [0.2838187647540766, 0.8987670983975816, 0.7210551928857125] ; tvec: [-0.5651621582602422, -0.5341582335471905, 0.09175039866178114]
reproj_errors[3]: 0.016150292674458572 ; rvec: [0.2838187647540766, 0.8987670983975816, 0.7210551928857125] ; tvec: [-0.5651621582602422, -0.5341582335471905, 0.09175039866178114]
realRoots[0]: 0.19143736288064839
realRoots[1]: -0.13975458635807264
realRoots[2]: -0.0090060448458990569
realRoots[3]: -0.0090060448458990569
real_roots[0]: -0.0090060448458986579
real_roots[1]: -0.0090060448458986579
real_roots[2]: -0.13975458635808261
real_roots[3]: 0.19143736288065752
ctheta1p: 0.19143736288065596
ctheta1p: -0.13975458635808091
ctheta1p: -0.25596725516300223
ctheta1p: -0.25596725516300223
reproj_errors[0]: 1.8264502736983503e-13 ; rvec: [1.261837904097473, 0.4816869442764983, 0.3156226004526013] ; tvec: [0.6311228499044503, 6.932076560982423, 4.320278478462822]
reproj_errors[1]: 1.8264502465525626e-13 ; rvec: [0.2362692202487785, 0.6825199129550505, 0.701884034628265] ; tvec: [0.1104331594504506, -0.4262441184182658, 0.5947758500348126]
reproj_errors[2]: 0.013424965354204741 ; rvec: [0.2830524952509881, 0.5325828629882728, 0.7165585898267188] ; tvec: [1.09155124495877, 0.2979195688742576, 0.190535044098457]
reproj_errors[3]: 0.013424965354204741 ; rvec: [0.2830524952509881, 0.5325828629882728, 0.7165585898267188] ; tvec: [1.09155124495877, 0.2979195688742576, 0.190535044098457]
realRoots[0]: 0.18734637339906124
realRoots[1]: -0.11827572567345611
realRoots[2]: -0.017835436493454367
realRoots[3]: -0.017835436493454367
real_roots[0]: -0.017835436493454367
real_roots[1]: -0.017835436493454367
real_roots[2]: -0.11827572567345619
real_roots[3]: 0.18734637339906135
ctheta1p: 0.18734637339906132
ctheta1p: -0.11827572567345618
ctheta1p: -0.14447732572777502
ctheta1p: -0.14447732572777502
reproj_errors[0]: 1.3620592626990925e-13 ; rvec: [1.101424062892398, 0.4885353997457584, -0.1534314142219899] ; tvec: [3.111572477813858, 7.228892108334464, 1.484008410348758]
reproj_errors[1]: 1.3620592729710833e-13 ; rvec: [0.1799762198857404, 0.9463664313197696, 0.2768099055472832] ; tvec: [-0.4799442177348974, -0.1616841303115186, 0.3573567330864469]
reproj_errors[2]: 0.00042989597480071391 ; rvec: [0.1911442828295639, 0.9081391380963951, 0.280277801330669] ; tvec: [-0.2214468872694058, -0.04275031965544507, 0.1720486243963713]
reproj_errors[3]: 0.00042989597480071391 ; rvec: [0.1911442828295639, 0.9081391380963951, 0.280277801330669] ; tvec: [-0.2214468872694058, -0.04275031965544507, 0.1720486243963713]
realRoots[0]: 0.14921972734906358
realRoots[1]: -0.083869421408409375
realRoots[2]: -0.014058537550287886
realRoots[3]: -0.014058537550287886
real_roots[0]: -0.014058537550287962
real_roots[1]: -0.014058537550287962
real_roots[2]: -0.083869421408408418
real_roots[3]: 0.14921972734906275
ctheta1p: 0.14921972734906275
ctheta1p: -0.083869421408408404
ctheta1p: -0.095353037011126199
ctheta1p: -0.095353037011126199
reproj_errors[0]: 3.8882793419704024e-13 ; rvec: [1.138610519960907, 0.1080717762556686, 0.5702706468003939] ; tvec: [-1.009454306565185, 6.138902182431732, 4.074458253337459]
reproj_errors[1]: 3.8882792040199745e-13 ; rvec: [0.3050492921046389, 0.2552960554366994, 0.6944378057265952] ; tvec: [-0.5015468354412544, 0.5465689798424157, 0.6667964825954433]
reproj_errors[2]: 0.0016449001161516433 ; rvec: [0.3104250427856355, 0.2401913784701778, 0.696428496589613] ; tvec: [-0.3984707648174448, 0.6238067995334744, 0.6722332809448455]
reproj_errors[3]: 0.0016449001161516433 ; rvec: [0.3104250427856355, 0.2401913784701778, 0.696428496589613] ; tvec: [-0.3984707648174448, 0.6238067995334744, 0.6722332809448455]
mode: no distortion, method: SOLVEPNP_AP3P -> 100% (maxErrT: 0, maxErrR: 0, meanErrT: 0, meanErrR: 0, medErrT: 0, medErrR: 0)
approximate translation threshold for 0.7: 0, approximate rotation threshold for 0.7: 0
P3P: SOLVEPNP_P3P ; mode: distorsion
reproj_errors[0]: 4.3308543231374402e-10 ; rvec: [0.2392454879533714, 0.8595016281759394, 0.5557005994982921] ; tvec: [-0.5889230342486549, 0.779491352391135, 0.1654015784268585]
reproj_errors[1]: 1.0022875359801636e-08 ; rvec: [1.006432204732819, 0.6452704995693931, 0.2182537484593834] ; tvec: [0.2998332260893681, 7.011268092666432, 1.863272099061181]
reproj_errors[0]: 5.0687748141989688e-13 ; rvec: [0.7930402771606055, 0.3586584795805053, 0.8375000447608292] ; tvec: [-0.5991472353214276, -0.7567927463653272, 0.04449869539930607]
reproj_errors[1]: 1.7730630882837893e-12 ; rvec: [1.88582478465481, 0.1775354501316421, 0.4899535222533138] ; tvec: [0.1882104003741594, 3.166943363222543, 7.508970426062119]
reproj_errors[0]: 2.5532849162652601e-10 ; rvec: [0.700909757931785, 0.1302590861029838, 0.8999998186421653] ; tvec: [0.1524487949784934, -0.3666782398945614, 0.6919016245996259]
reproj_errors[1]: 1.1196336335459374e-09 ; rvec: [1.683773550686821, 0.1340295324656803, 0.6962109169940608] ; tvec: [-1.269240249597094, 3.172334254582268, 7.16926691957342]
reproj_errors[0]: 1.0801300747118943e-11 ; rvec: [0.4164174535951434, 0.6933631319662197, 0.3118386116837504] ; tvec: [-0.7774118922217346, 0.5673635428129791, 0.7651118267088357]
reproj_errors[1]: 1.0470390177008214e-11 ; rvec: [1.206867675457112, 0.270624277157656, 0.04941227239469196] ; tvec: [2.459144145556432, 6.36283476242861, 3.170221957691346]
reproj_errors[0]: 3.8655541789603891e-12 ; rvec: [0.6070836737458155, 0.1993652451125127, 0.5548977046954786] ; tvec: [0.5906006561283887, -0.4242425344927163, 0.2810913528950536]
reproj_errors[1]: 5.2351743598145355e-11 ; rvec: [1.62032516875845, 0.09273675387212998, 0.3033611424546995] ; tvec: [0.9718802662286019, 4.227022965538943, 6.800944966838316]
mode: distorsion, method: SOLVEPNP_P3P -> 40% (maxErrT: 0, maxErrR: 0, meanErrT: 0, meanErrR: 0, medErrT: 0, medErrR: 0)
approximate translation threshold for 0.7: 0, approximate rotation threshold for 0.7: 0
P3P: SOLVEPNP_AP3P ; mode: distorsion
realRoots[0]: 0.16806617510578642
realRoots[1]: -0.10066789901985963
realRoots[2]: -0.015047025468689081
realRoots[3]: -0.015047025468689081
real_roots[0]: -0.015047025468689008
real_roots[1]: -0.015047025468689008
real_roots[2]: -0.10066789901986084
real_roots[3]: 0.16806617510578747
ctheta1p: 0.16806617510578803
ctheta1p: -0.10066789901986151
ctheta1p: -0.1200623766475456
ctheta1p: -0.1200623766475456
reproj_errors[0]: 2.0744090597835004e-11 ; rvec: [1.782135937281458, 0.06970398721577589, 0.4333276239220055] ; tvec: [0.2059837717993407, 3.422927186837333, 6.841071910847001]
reproj_errors[1]: 2.0744089099137719e-11 ; rvec: [0.850570045526181, 0.2362734116350825, 0.6825201455931724] ; tvec: [-0.5029556041340295, 0.1104275666735752, 0.2940142128862258]
reproj_errors[2]: 0.011820062931384767 ; rvec: [0.8601585182334817, 0.2095610174409535, 0.6778250411041281] ; tvec: [-0.3101789435903353, 0.220242876042394, 0.345971186400492]
reproj_errors[3]: 0.011820062931384767 ; rvec: [0.8601585182334817, 0.2095610174409535, 0.6778250411041281] ; tvec: [-0.3101789435903353, 0.220242876042394, 0.345971186400492]
realRoots[0]: 0.040260957398800597
realRoots[1]: 0.040260957398800597
realRoots[2]: 0.23045756572725928
realRoots[3]: -0.25769660628467667
real_roots[0]: -0.25769660628467495
real_roots[1]: 0.23045756572725717
real_roots[2]: 0.040260957398800791
real_roots[3]: 0.040260957398800791
ctheta1p: 0.41094946810441024
ctheta1p: 0.41094946810441024
ctheta1p: 0.23045756572725892
ctheta1p: -0.25769660628467633
reproj_errors[0]: 108.00338257127345 ; rvec: [1.080410411996133, 0.6190276577376989, 0.05849170686895219] ; tvec: [-0.02469202704066653, 4.350300139055126, 4.838012090587048]
reproj_errors[1]: 108.00338257127345 ; rvec: [1.080410411996133, 0.6190276577376989, 0.05849170686895219] ; tvec: [-0.02469202704066653, 4.350300139055126, 4.838012090587048]
reproj_errors[2]: 4.6872442196136698e-12 ; rvec: [1.243689212808564, 0.2263514012956248, 0.0396350043543867] ; tvec: [2.564663019441631, 6.283827393297248, 4.372108093911969]
reproj_errors[3]: 4.6872442179881573e-12 ; rvec: [0.2607710005758258, 0.4197462669162039, 0.3515102448781026] ; tvec: [0.8926240863523995, -0.4478257358076925, 0.2243584531172447]
realRoots[0]: 0.018927278598222984
realRoots[1]: 0.018927278598222984
realRoots[2]: 0.14611479526410182
realRoots[3]: -0.140536485549557
real_roots[0]: -0.14053648554955234
real_roots[1]: 0.1461147952640966
real_roots[2]: 0.018927278598223254
real_roots[3]: 0.018927278598223254
ctheta1p: 0.48074317057108268
ctheta1p: 0.48074317057108268
ctheta1p: 0.14611479526409957
ctheta1p: -0.140536485549555
reproj_errors[0]: 28.50130733021529 ; rvec: [1.039119277538906, 1.348722755824465, 0.490476791885427] ; tvec: [-0.9058177518301944, 1.13016222470003, 5.777292542134577]
reproj_errors[1]: 28.50130733021529 ; rvec: [1.039119277538906, 1.348722755824465, 0.490476791885427] ; tvec: [-0.9058177518301944, 1.13016222470003, 5.777292542134577]
reproj_errors[2]: 9.6591608235938106e-12 ; rvec: [1.37629747426926, 0.7853714946605593, 0.3723848135598632] ; tvec: [0.8709483901622255, 5.185556775498367, 4.750702478450019]
reproj_errors[3]: 9.6591604941946289e-12 ; rvec: [0.69443850055012, 0.7957603068813955, 0.7611348057126406] ; tvec: [0.3268586987048838, 0.9820599168158455, 0.7354329346929855]
realRoots[0]: 0.15421648005578925
realRoots[1]: -0.065472617284811199
realRoots[2]: -0.026436824633040618
realRoots[3]: -0.026436824633040618
real_roots[0]: -0.026436824633040618
real_roots[1]: -0.026436824633040618
real_roots[2]: -0.065472617284811199
real_roots[3]: 0.15421648005578925
ctheta1p: 0.15421648005578917
ctheta1p: -0.06547261728481113
ctheta1p: -0.066026311956725842
ctheta1p: -0.066026311956725842
reproj_errors[0]: 1.1939096374002776e-12 ; rvec: [1.667988078138003, 0.5409209097221942, -0.08850592738089766] ; tvec: [3.604350861282924, 4.557802401305643, 4.744089723111984]
reproj_errors[1]: 1.193909700812467e-12 ; rvec: [0.8979769184947639, 0.8612501319802199, 0.3962751041004497] ; tvec: [-0.3738462063655144, 0.3301459352865055, 0.7615074674216036]
reproj_errors[2]: 1.912599344779778e-06 ; rvec: [0.8982745683497754, 0.8604154125012536, 0.3960577176672958] ; tvec: [-0.3682165849223651, 0.3340994017189152, 0.7594339248899087]
reproj_errors[3]: 1.912599344779778e-06 ; rvec: [0.8982745683497754, 0.8604154125012536, 0.3960577176672958] ; tvec: [-0.3682165849223651, 0.3340994017189152, 0.7594339248899087]
realRoots[0]: 0.16934154393045345
realRoots[1]: -0.097195425157166532
realRoots[2]: -0.020649158049362723
realRoots[3]: -0.020649158049362723
real_roots[0]: -0.020649158049362844
real_roots[1]: -0.020649158049362844
real_roots[2]: -0.097195425157164506
real_roots[3]: 0.16934154393045164
ctheta1p: 0.16934154393045128
ctheta1p: -0.097195425157164075
ctheta1p: -0.10653667440579385
ctheta1p: -0.10653667440579385
reproj_errors[0]: 2.2647038268036867e-12 ; rvec: [1.089469491802452, 0.2820559434580429, 0.569535093432461] ; tvec: [-1.244062293066405, 7.003247982328617, 3.627820577093728]
reproj_errors[1]: 2.264703758041236e-12 ; rvec: [0.08612349477076721, 0.451914285290801, 0.7735817941310125] ; tvec: [-0.3688720281668978, -0.169188114674558, 0.6966380814813418]
reproj_errors[2]: 0.0015998383690725994 ; rvec: [0.09447123212060508, 0.4386830056807877, 0.7757588729462424] ; tvec: [-0.2878379799130379, -0.06628138471260936, 0.6903757168316886]
reproj_errors[3]: 0.0015998383690725994 ; rvec: [0.09447123212060508, 0.4386830056807877, 0.7757588729462424] ; tvec: [-0.2878379799130379, -0.06628138471260936, 0.6903757168316886]
mode: distorsion, method: SOLVEPNP_AP3P -> 100% (maxErrT: 0, maxErrR: 0, meanErrT: 0, meanErrR: 0, medErrT: 0, medErrR: 0)
approximate translation threshold for 0.7: 0, approximate rotation threshold for 0.7: 0

I just did a quick test. realRoots is the OpenCV version and real_roots is the OpenMVG version. They return both approximately the same values.

MathLens · 2019-05-13T18:02:37Z

@catree Sorry for the delayed reply.

Regarding the duplicate solutions, it is because the quartic solver I put here always tries to get four solutions, even if two of them may be complex (and they will share the same real part), so the two duplicate roots are actually the real parts of two conjunctive complex ones.

This may capture some real roots that are computed to be complex numbers with super small imagine part due to numerical errors instead of rejecting them.

I believe it is ok to change the code so that we reject all complex roots (either true ones or the ones caused by numerical errors). P3P is usually used in RANSAC, missing one root in one iteration (which does not happen frequently) is acceptable.

catree · 2019-05-14T10:01:37Z

@tonyke1993
Thanks for the explanations.
I think the code is fine as it is. In the current OpenCV implementations, both solvePnP and solvePnPRansac use 4 input points and return 1 solution.
For solveP3P, the user can easily filter the duplicate poses if he wants or needs it.

alalek

Thank you!

Please check comments below.

alalek · 2019-05-15T12:18:40Z

modules/calib3d/src/ippe.cpp

+// of this distribution and at https://opencv.org/license.html
+
+// This file is based on files from packages softfloat and fdlibm
+// issued with the following licenses:


from packages softfloat and fdlibm

Please remove/replace this.

alalek · 2019-05-15T12:30:47Z

modules/calib3d/src/ippe.cpp

+    ata01 = a00 * a10 + a01 * a11;
+    ata11 = a10 * a10 + a11 * a11;
+
+    gamma = sqrt(0.5 * (ata00 + ata11 + sqrt((ata00 - ata11) * (ata00 - ata11) + 4.0 * ata01 * ata01)));


Should we check?

sqrt() argument is not negative (due rounding errors)

gamma is not close to zero (division is below) or raise CV_Error(Error::StsNoConv, "...");

I have added the two checks with CV_Error.

alalek · 2019-05-15T12:33:26Z

modules/calib3d/src/ippe.cpp

+        {
+            canonicalObjPoints.at<Vec2d>(i)[0] = UZeroAligned.at<double>(0, i);
+            canonicalObjPoints.at<Vec2d>(i)[1] = UZeroAligned.at<double>(1, i);
+//            assert(abs(UZeroAligned.at<double>(2, i)) <= IPPE_SMALL);


alalek · 2019-05-15T12:34:29Z

modules/calib3d/src/ippe.cpp

+    float dx, dy;
+    for (int i = 0; i < n; i++)
+    {
+        if (projectedPoints.depth() == CV_32F)


projectedPoints.depth()

Probably it is better to cache this value into some variable outside of the loop.

alalek · 2019-05-15T12:38:40Z

modules/calib3d/src/ippe.cpp

+
+    double nx = (p1y - p2y)*(p1z - p3z) - (p1y - p3y)*(p1z - p2z);
+    double ny  = (p1x - p3x)*(p1z - p2z) - (p1x - p2x)*(p1z - p3z);
+    double nz = (p1x - p2x)*(p1y - p3y) - (p1x - p3x)*(p1y - p2y);


BTW, there are cross() implementations for Vec3d / Point3d types.

alalek · 2019-05-15T12:40:49Z

modules/calib3d/src/ippe.hpp

+     * @param tvec:             Translation component of pose
+     * @return:                 average depth of the object
+     */
+     double meanSceneDepth(InputArray objectPoints, InputArray rvec, InputArray tvec);


indentation 5->4 spaces

alalek · 2019-05-15T12:41:19Z

modules/calib3d/src/ippe.hpp

+namespace HomographyHO {
+
+    /**
+    * @brief                   Computes the best-fitting homography matrix from source to target points using Harker and O'Leary's method:


Please avoid indentation in namespaces

modules/calib3d/src/p3p.cpp

modules/calib3d/src/solvepnp.cpp

alalek · 2019-05-15T12:52:10Z

modules/calib3d/src/solvepnp.cpp

+            projectedPoints_ = projectedPoints_.reshape(1, static_cast<int>(projectedPoints.size()*2));
+            imagePoints = imagePoints.reshape(1, static_cast<int>(projectedPoints.size()*2));
+            Mat rmse = projectedPoints_ - imagePoints;
+            rmse = rmse.t() * rmse;


Last 4 lines: norm(projectedPoints, imagePoints, NORM_L2);

NORM_L2 | NORM_RELATIVE - for rmse_.

I did not manage to get the same results and I don't think it is the same formula.
For RMSE, I use:

whereas in the doc:

the lines:

Mat rmse = projectedPoints_ - imagePoints; rmse = rmse.t() * rmse;

are misleading - they definitely do not comptue RMSE according to its standard definition

You are right!

rmse_ = norm(projectedPoints_, imagePoints, NORM_L2) / sqrt(projectedPoints_.total());

?

alalek

Thank you for update!

alalek · 2019-05-16T18:57:30Z

modules/calib3d/src/ippe.cpp

+        double rz = R.at<double>(2, 0) * objectPoints.at<Vec2d>(i)(0) + R.at<double>(2, 1) * objectPoints.at<Vec2d>(i)(1);
+
+        double a2 = -imgPoints.at<Vec2d>(i)(0);
+        double b2 = -imgPoints.at<Vec2d>(i)(1);


BTW, We can cache imgPoints.at<Vec2d>(i) in variable (value or "const reference") here and above.

alalek · 2019-05-16T19:03:25Z

modules/calib3d/src/solvepnp.cpp

+            projectedPoints_ = projectedPoints_.reshape(1, static_cast<int>(projectedPoints.size()*2));
+            imagePoints = imagePoints.reshape(1, static_cast<int>(projectedPoints.size()*2));
+            Mat rmse = projectedPoints_ - imagePoints;
+            rmse = rmse.t() * rmse;


You are right!

rmse_ = norm(projectedPoints_, imagePoints, NORM_L2) / sqrt(projectedPoints_.total());

?

catree · 2019-05-17T16:04:02Z

I have reverted from:
ATA02 += a2;

to
ATA12 = ATA12 + b2;

Somehow, with my compiler (GCC 5.4.0 20160609) this does not lead to the same floating point operations order.
I did a quick test and we should get the same results between the OpenCV code and the original one (tested that IPPE_demo_generic_pointset.cpp gives the same results at epsilon precision).

I have captured some data that lead gamma:
gamma = sqrt(0.5 * (ata00 + ata11 + sqrt((ata00 - ata11) * (ata00 - ata11) + 4.0 * ata01 * ata01)));
to be close to zero and thus it throws an exception here.

code

    Matx31d rvec(0.7136616552834075, 0.3059808644026911, 0.7114660999233302);
    Matx31d tvec(-0.6493577793527734, 0.6633761657486326, 0.04733051191856578);
//    Matx33d cameraMatrix(44.63448589236783, 0, 37.87596253836421,
//                         0, 15.90508774946769, 24.92036090687411,
//                         0, 0, 1);
    Matx33d cameraMatrix = Matx33d::eye();
    Matx41d distCoeffs(4.402010239854638e-07, 7.729938301986059e-07, 5.257442644446706e-07, 0);
    std::vector<Point3f> objectPoints;
    objectPoints.push_back(Point3f(-0.0747386, 0.0747386, 0));
    objectPoints.push_back(Point3f(0.0747386, 0.0747386, 0));
    objectPoints.push_back(Point3f(0.0747386, -0.0747386, 0));
    objectPoints.push_back(Point3f(-0.0747386, -0.0747386, 0));
    {
        std::vector<Point2f> imagePoints1, imagePoints2, imagePoints_undist;
        projectPoints(objectPoints, rvec, tvec, cameraMatrix, noArray(), imagePoints1);
        projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints2);
        undistortPoints(imagePoints2, imagePoints_undist, cameraMatrix, distCoeffs);
        for (size_t i = 0; i < imagePoints1.size(); i++) {
            std::cout << i << ") " << imagePoints1[i] << std::endl;
            std::cout << i << ") " << imagePoints2[i] << std::endl;
            std::cout << i << ") " << imagePoints_undist[i] << std::endl;
        }
    }
    {
        Mat R;
        Rodrigues(rvec, R);
        std::cout << std::endl;
        for (size_t i = 0; i < objectPoints.size(); i++) {
            Matx31d obj(objectPoints[i].x, objectPoints[i].y, objectPoints[i].z);
            Mat cameraPoint = R * obj + tvec;
            std::cout << i << ") " << cameraPoint.t() << std::endl;
        }
    }
    std::vector<Point2f> imagePoints;
    projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints);
    IPPE::PoseSolver planePoseSolver;
    Mat rvec1, tvec1, rvec2, tvec2;
    float reprojErr1, reprojErr2;
    planePoseSolver.solveSquare(0.0747386*2, imagePoints, cameraMatrix, distCoeffs, rvec1, tvec1, reprojErr1, rvec2, tvec2, reprojErr2);
    std::cout << "rvec: " << rvec.t() << std::endl;
    std::cout << "rvec1: " << rvec1.t() << std::endl;
    std::cout << "rvec2: " << rvec2.t() << std::endl;
    std::cout << "tvec: " << tvec.t() << std::endl;
    std::cout << "tvec1: " << tvec1.t() << std::endl;
    std::cout << "tvec2: " << tvec2.t() << std::endl;

output

0) [-7.37631, 6.50044]
0) [-7.42996, 6.54776]
0) [-7.37631, 6.50044]
1) [-6.49895, 7.7687]
1) [-6.55217, 7.83237]
1) [-6.49895, 7.7687]
2) [98.4054, -118.826]
2) [43198.8, -52163.4]
2) [2.80155e-09, -3.53119e-09]
3) [266.336, -228.28]
3) [3.11734e+06, -2.67191e+06]
3) [5.40652e-14, -8.66878e-14]
0) [-0.7401207358070793, 0.6522378308313299, 0.1003374897566741]
1) [-0.6314791721351084, 0.7548555043856755, 0.09716626690503738]
2) [-0.5585948228984675, 0.6745145006659352, -0.00567646591954258]
3) [-0.6672363865704384, 0.5718968271115896, -0.002505243067905831]
!!!!!!!!gamma = 0
gamme: 1.0077253436729412e-07
rvec: [0.7136616552834075, 0.3059808644026911, 0.7114660999233302]
rvec1: [1.704411329846153, 0.6396593763041216, -0.588295149917103]
rvec2: [-1.704411318685205, -0.6396593664899685, -0.5882951462729119]
tvec: [-0.6493577793527734, 0.6633761657486326, 0.04733051191856578]
tvec1: [-0.0002003314847303823, -0.001230874564702886, -0.1413944711470152]
tvec2: [-0.0002003314326244324, -0.001230874243820202, 0.1413943734881941]

Looks like the undistortPoints function fails to correctly remove the distortion with these data. I am wondering if this is not the source of some of the poor performance of the test cases?
If it is the case, since we are not testing the accuracy or the correctness of the undistortPoints function, maybe we should discard test data where the undistortPoints gives too bad results?

tobycollins · 2019-05-17T17:01:55Z

Looks like tz is pretty small. Are you sure that the model points in camera coordinates are all in front of the camera?

catree · 2019-05-20T09:02:43Z

@tobycollins
I think this is it. Generated camera pose transforms some object points behind the camera:

[-0.7401207358070793, 0.6522378308313299, 0.1003374897566741]

[-0.6314791721351084, 0.7548555043856755, 0.09716626690503738]

[-0.5585948228984675, 0.6745145006659352, -0.00567646591954258]

[-0.6672363865704384, 0.5718968271115896, -0.002505243067905831]

I have added a check in the test to discard these types of pose.

…ction that returns all the pose solutions and the reprojection errors.

alalek

Well done! Thank you 👍

catree force-pushed the feat_ippe branch from 18b1f0e to 2e32413 Compare April 18, 2019 17:34

catree commented Apr 18, 2019

View reviewed changes

modules/calib3d/src/solvepnp.cpp Show resolved Hide resolved

catree commented Apr 18, 2019

View reviewed changes

modules/calib3d/src/solvepnp.cpp Show resolved Hide resolved

catree commented Apr 18, 2019

View reviewed changes

catree force-pushed the feat_ippe branch 2 times, most recently from a58a857 to 8eeec7e Compare April 19, 2019 14:28

alalek reviewed Apr 19, 2019

View reviewed changes

catree force-pushed the feat_ippe branch from 8eeec7e to b5a5205 Compare April 25, 2019 17:53

catree force-pushed the feat_ippe branch 2 times, most recently from 77548ed to 566c570 Compare April 26, 2019 15:44

catree mentioned this pull request May 6, 2019

Update perf sanity check data for solvePnP opencv/opencv_extra#606

Merged

catree force-pushed the feat_ippe branch 5 times, most recently from 86a65ce to cf0ed60 Compare May 6, 2019 16:30

catree marked this pull request as ready for review May 6, 2019 16:52

catree force-pushed the feat_ippe branch from cf0ed60 to a9695ce Compare May 9, 2019 12:54

catree force-pushed the feat_ippe branch from a9695ce to a715f82 Compare May 15, 2019 08:22

alalek reviewed May 15, 2019

View reviewed changes

catree force-pushed the feat_ippe branch 3 times, most recently from 89711d0 to a06770e Compare May 16, 2019 17:04

alalek reviewed May 16, 2019

View reviewed changes

catree force-pushed the feat_ippe branch 2 times, most recently from 2fe724c to 60636b2 Compare May 17, 2019 15:32

catree force-pushed the feat_ippe branch from 60636b2 to 9acfdac Compare May 20, 2019 08:55

Add SOLVEPNP_IPPE for planar pose estimation. Add solvePnPGeneric fun…

33cb9c5

…ction that returns all the pose solutions and the reprojection errors.

catree force-pushed the feat_ippe branch from 9acfdac to 33cb9c5 Compare May 20, 2019 09:58

alalek approved these changes May 20, 2019

View reviewed changes

opencv-pushbot merged commit 33cb9c5 into opencv:3.4 May 20, 2019

opencv-pushbot pushed a commit that referenced this pull request May 20, 2019

Merge pull request #14362 from catree:feat_ippe

a433394

alalek mentioned this pull request May 23, 2019

Merge 3.4 #14615

Merged

tobycollins mentioned this pull request May 25, 2019

Improper or bad rotation estimation with solvePnP in some cases #8813

Open

tobycollins mentioned this pull request Oct 5, 2019

PnP issue 15647 #15650

Open

	Mat(3, 1, CV_64F, ts[N]).copyTo(t);
	Mat(3, 3, CV_64F, Rs[N]).copyTo(R);

	cv::Mat(3, 1, CV_64F, translation).copyTo(tvec);
	cv::Mat(3, 3, CV_64F, rotation_matrix).copyTo(R);

	_r = cvMat( rvec->rows, rvec->cols,
	CV_MAKETYPE(CV_64F,CV_MAT_CN(rvec->type)), param );
	_t = cvMat( tvec->rows, tvec->cols,
	CV_MAKETYPE(CV_64F,CV_MAT_CN(tvec->type)), param + 3 );

	cvConvert( &_r, rvec );
	cvConvert( &_t, tvec );

Uh oh!

Add IPPE method for planar pose estimation in solvePnP #14362

Add IPPE method for planar pose estimation in solvePnP #14362

Uh oh!

Conversation

catree commented Apr 18, 2019 • edited by alalek Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

This pullrequest changes

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

catree commented Apr 18, 2019

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alalek left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

tobycollins commented Apr 23, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

catree commented Apr 25, 2019

Uh oh!

tobycollins commented May 2, 2019

Uh oh!

catree commented May 6, 2019

Uh oh!

tobycollins commented May 8, 2019

Uh oh!

catree commented May 9, 2019

Uh oh!

MathLens commented May 13, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

catree commented Apr 18, 2019 •

edited by alalek

Loading

tobycollins commented Apr 23, 2019 •

edited

Loading

MathLens commented May 13, 2019 •

edited

Loading