EstervQrCode 2.0.0
Library for qr code manipulation
Loading...
Searching...
No Matches
calib3d.hpp
1/*M///////////////////////////////////////////////////////////////////////////////////////
2//
3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4//
5// By downloading, copying, installing or using the software you agree to this license.
6// If you do not agree to this license, do not download, install,
7// copy or use the software.
8//
9//
10// License Agreement
11// For Open Source Computer Vision Library
12//
13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
16// Third party copyrights are property of their respective owners.
17//
18// Redistribution and use in source and binary forms, with or without modification,
19// are permitted provided that the following conditions are met:
20//
21// * Redistribution's of source code must retain the above copyright notice,
22// this list of conditions and the following disclaimer.
23//
24// * Redistribution's in binary form must reproduce the above copyright notice,
25// this list of conditions and the following disclaimer in the documentation
26// and/or other materials provided with the distribution.
27//
28// * The name of the copyright holders may not be used to endorse or promote products
29// derived from this software without specific prior written permission.
30//
31// This software is provided by the copyright holders and contributors "as is" and
32// any express or implied warranties, including, but not limited to, the implied
33// warranties of merchantability and fitness for a particular purpose are disclaimed.
34// In no event shall the Intel Corporation or contributors be liable for any direct,
35// indirect, incidental, special, exemplary, or consequential damages
36// (including, but not limited to, procurement of substitute goods or services;
37// loss of use, data, or profits; or business interruption) however caused
38// and on any theory of liability, whether in contract, strict liability,
39// or tort (including negligence or otherwise) arising in any way out of
40// the use of this software, even if advised of the possibility of such damage.
41//
42//M*/
43
44#ifndef OPENCV_CALIB3D_HPP
45#define OPENCV_CALIB3D_HPP
46
47#include "opencv2/core.hpp"
48#include "opencv2/core/types.hpp"
49#include "opencv2/features2d.hpp"
50#include "opencv2/core/affine.hpp"
51#include "opencv2/core/utils/logger.hpp"
52
440namespace cv
441{
442
445
447enum { LMEDS = 4,
448 RANSAC = 8,
449 RHO = 16,
456 USAC_MAGSAC = 38
457 };
458
484
493 CALIB_CB_PLAIN = 256
494 };
495
499 };
500
507 CALIB_FIX_K1 = 0x00020,
508 CALIB_FIX_K2 = 0x00040,
509 CALIB_FIX_K3 = 0x00080,
510 CALIB_FIX_K4 = 0x00800,
511 CALIB_FIX_K5 = 0x01000,
512 CALIB_FIX_K6 = 0x02000,
518 CALIB_USE_QR = 0x100000,
520 // only for stereo
523 // for stereo rectification
525 CALIB_USE_LU = (1 << 17),
526 CALIB_USE_EXTRINSIC_GUESS = (1 << 22)
527 };
528
530enum { FM_7POINT = 1,
533 FM_RANSAC = 8
534 };
535
544
550
558
576
604
605
606
614{
615public:
617 {
618 public:
619 virtual ~Callback() {}
632 virtual bool compute(InputArray param, OutputArray err, OutputArray J) const = 0;
633 };
634
647 virtual int run(InputOutputArray param) const = 0;
648
653 virtual void setMaxIters(int maxIters) = 0;
657 virtual int getMaxIters() const = 0;
658
666 static Ptr<LMSolver> create(const Ptr<LMSolver::Callback>& cb, int maxIters);
667 static Ptr<LMSolver> create(const Ptr<LMSolver::Callback>& cb, int maxIters, double eps);
668};
669
670
671
738 int method = 0, double ransacReprojThreshold = 3,
739 OutputArray mask=noArray(), const int maxIters = 2000,
740 const double confidence = 0.995);
741
744 OutputArray mask, int method = 0, double ransacReprojThreshold = 3 );
745
746
748 const UsacParams &params);
749
770 OutputArray Qx = noArray(),
771 OutputArray Qy = noArray(),
772 OutputArray Qz = noArray());
773
797 OutputArray rotMatrix, OutputArray transVect,
798 OutputArray rotMatrixX = noArray(),
799 OutputArray rotMatrixY = noArray(),
800 OutputArray rotMatrixZ = noArray(),
801 OutputArray eulerAngles =noArray() );
802
817
848 InputArray rvec2, InputArray tvec2,
849 OutputArray rvec3, OutputArray tvec3,
850 OutputArray dr3dr1 = noArray(), OutputArray dr3dt1 = noArray(),
851 OutputArray dr3dr2 = noArray(), OutputArray dr3dt2 = noArray(),
852 OutputArray dt3dr1 = noArray(), OutputArray dt3dt1 = noArray(),
853 OutputArray dt3dr2 = noArray(), OutputArray dt3dt2 = noArray() );
854
889 InputArray rvec, InputArray tvec,
892 OutputArray jacobian = noArray(),
893 double aspectRatio = 0 );
894
968 OutputArray rvec, OutputArray tvec,
969 bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE );
970
1016 OutputArray rvec, OutputArray tvec,
1017 bool useExtrinsicGuess = false, int iterationsCount = 100,
1018 float reprojectionError = 8.0, double confidence = 0.99,
1019 OutputArray inliers = noArray(), int flags = SOLVEPNP_ITERATIVE );
1020
1021
1022/*
1023Finds rotation and translation vector.
1024If cameraMatrix is given then run P3P. Otherwise run linear P6P and output cameraMatrix too.
1025*/
1028 OutputArray rvec, OutputArray tvec, OutputArray inliers,
1029 const UsacParams &params=UsacParams());
1030
1061 int flags );
1062
1091
1122 double VVSlambda = 1);
1123
1199 bool useExtrinsicGuess = false, SolvePnPMethod flags = SOLVEPNP_ITERATIVE,
1200 InputArray rvec = noArray(), InputArray tvec = noArray(),
1201 OutputArray reprojectionError = noArray() );
1202
1220 Size imageSize, double aspectRatio = 1.0 );
1221
1279
1280/*
1281 Checks whether the image contains chessboard of the specific size or not.
1282 If yes, nonzero value is returned.
1283*/
1285
1336CV_EXPORTS_AS(findChessboardCornersSBWithMeta)
1338 int flags,OutputArray meta);
1340CV_EXPORTS_W inline
1342 int flags = 0)
1343{
1344 return findChessboardCornersSB(image, patternSize, corners, flags, noArray());
1345}
1346
1375 float rise_distance=0.8F,bool vertical=false,
1376 OutputArray sharpness=noArray());
1377
1378
1381
1395 InputArray corners, bool patternWasFound );
1396
1414 InputArray rvec, InputArray tvec, float length, int thickness=3);
1415
1442
1443#ifndef DISABLE_OPENCV_3_COMPATIBILITY
1445#endif
1446
1481 OutputArray centers, int flags,
1482 const Ptr<FeatureDetector> &blobDetector,
1483 const CirclesGridFinderParameters& parameters);
1484
1488 const Ptr<FeatureDetector> &blobDetector = SimpleBlobDetector::create());
1489
1610CV_EXPORTS_AS(calibrateCameraExtended) double calibrateCamera( InputArrayOfArrays objectPoints,
1618 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1619
1626 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1627
1685CV_EXPORTS_AS(calibrateCameraROExtended) double calibrateCameraRO( InputArrayOfArrays objectPoints,
1695 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1696
1704 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1705
1727 double apertureWidth, double apertureHeight,
1728 CV_OUT double& fovx, CV_OUT double& fovy,
1729 CV_OUT double& focalLength, CV_OUT Point2d& principalPoint,
1730 CV_OUT double& aspectRatio );
1731
1863CV_EXPORTS_AS(stereoCalibrateExtended) double stereoCalibrate( InputArrayOfArrays objectPoints,
1870
1879
1888
2011 OutputArray R1, OutputArray R2,
2012 OutputArray P1, OutputArray P2,
2014 double alpha = -1, Size newImageSize = Size(),
2015 CV_OUT Rect* validPixROI1 = 0, CV_OUT Rect* validPixROI2 = 0 );
2016
2047 InputArray F, Size imgSize,
2048 OutputArray H1, OutputArray H2,
2049 double threshold = 5 );
2050
2054 InputArray cameraMatrix3, InputArray distCoeffs3,
2057 InputArray R13, InputArray T13,
2060 OutputArray Q, double alpha, Size newImgSize,
2061 CV_OUT Rect* roi1, CV_OUT Rect* roi2, int flags );
2062
2090 Size imageSize, double alpha, Size newImgSize = Size(),
2091 CV_OUT Rect* validPixROI = 0,
2092 bool centerPrincipalPoint = false);
2093
2241 InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam,
2242 OutputArray R_cam2gripper, OutputArray t_cam2gripper,
2244
2384 InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper,
2385 OutputArray R_base2world, OutputArray t_base2world,
2386 OutputArray R_gripper2cam, OutputArray t_gripper2cam,
2388
2398
2409
2421
2474 int method, double ransacReprojThreshold, double confidence,
2475 int maxIters, OutputArray mask = noArray() );
2476
2479 int method = FM_RANSAC,
2480 double ransacReprojThreshold = 3., double confidence = 0.99,
2481 OutputArray mask = noArray() );
2482
2486 double ransacReprojThreshold = 3., double confidence = 0.99 );
2487
2488
2490 OutputArray mask, const UsacParams &params);
2491
2527 InputArray points1, InputArray points2,
2529 double prob = 0.999, double threshold = 1.0,
2530 int maxIters = 1000, OutputArray mask = noArray()
2531);
2532
2536 InputArray points1, InputArray points2,
2538 double prob, double threshold,
2540); // TODO remove from OpenCV 5.0
2541
2574 InputArray points1, InputArray points2,
2575 double focal = 1.0, Point2d pp = Point2d(0, 0),
2576 int method = RANSAC, double prob = 0.999,
2577 double threshold = 1.0, int maxIters = 1000,
2579);
2580
2584 InputArray points1, InputArray points2,
2585 double focal, Point2d pp,
2586 int method, double prob,
2587 double threshold, OutputArray mask
2588); // TODO remove from OpenCV 5.0
2589
2627 int method = RANSAC,
2628 double prob = 0.999, double threshold = 1.0,
2629 OutputArray mask = noArray() );
2630
2631
2634 InputArray dist_coeff1, InputArray dist_coeff2, OutputArray mask,
2635 const UsacParams &params);
2636
2656
2724 int method = cv::RANSAC, double prob = 0.999, double threshold = 1.0,
2726
2780
2812 double focal = 1.0, Point2d pp = Point2d(0, 0),
2814
2842 OutputArray triangulatedPoints = noArray());
2843
2868 InputArray F, OutputArray lines );
2869
2895 InputArray projPoints1, InputArray projPoints2,
2896 OutputArray points4D );
2897
2914 OutputArray newPoints1, OutputArray newPoints2 );
2915
2929 int maxSpeckleSize, double maxDiff,
2930 InputOutputArray buf = noArray() );
2931
2934 int minDisparity, int numberOfDisparities,
2935 int blockSize );
2936
2939 int minDisparity, int numberOfDisparities,
2940 int disp12MaxDisp = 1 );
2941
2982 OutputArray _3dImage, InputArray Q,
2983 bool handleMissingValues = false,
2984 int ddepth = -1 );
2985
3004
3054 OutputArray out, OutputArray inliers,
3055 double ransacThreshold = 3, double confidence = 0.99);
3056
3082 CV_OUT double* scale = nullptr, bool force_rotation = true);
3083
3128 OutputArray out, OutputArray inliers,
3129 double ransacThreshold = 3, double confidence = 0.99);
3130
3194 int method = RANSAC, double ransacReprojThreshold = 3,
3195 size_t maxIters = 2000, double confidence = 0.99,
3196 size_t refineIters = 10);
3197
3198
3200 const UsacParams &params);
3201
3246 int method = RANSAC, double ransacReprojThreshold = 3,
3247 size_t maxIters = 2000, double confidence = 0.99,
3248 size_t refineIters = 10);
3249
3279 InputArray K,
3280 OutputArrayOfArrays rotations,
3281 OutputArrayOfArrays translations,
3282 OutputArrayOfArrays normals);
3283
3303 InputArrayOfArrays normals,
3304 InputArray beforePoints,
3305 InputArray afterPoints,
3306 OutputArray possibleSolutions,
3307 InputArray pointsMask = noArray());
3308
3312{
3313public:
3314 enum { DISP_SHIFT = 4,
3315 DISP_SCALE = (1 << DISP_SHIFT)
3317
3326 CV_WRAP virtual void compute( InputArray left, InputArray right,
3327 OutputArray disparity ) = 0;
3328
3329 CV_WRAP virtual int getMinDisparity() const = 0;
3330 CV_WRAP virtual void setMinDisparity(int minDisparity) = 0;
3331
3332 CV_WRAP virtual int getNumDisparities() const = 0;
3333 CV_WRAP virtual void setNumDisparities(int numDisparities) = 0;
3334
3335 CV_WRAP virtual int getBlockSize() const = 0;
3336 CV_WRAP virtual void setBlockSize(int blockSize) = 0;
3337
3338 CV_WRAP virtual int getSpeckleWindowSize() const = 0;
3339 CV_WRAP virtual void setSpeckleWindowSize(int speckleWindowSize) = 0;
3340
3341 CV_WRAP virtual int getSpeckleRange() const = 0;
3342 CV_WRAP virtual void setSpeckleRange(int speckleRange) = 0;
3343
3344 CV_WRAP virtual int getDisp12MaxDiff() const = 0;
3345 CV_WRAP virtual void setDisp12MaxDiff(int disp12MaxDiff) = 0;
3346};
3347
3348
3353{
3354public:
3355 enum { PREFILTER_NORMALIZED_RESPONSE = 0,
3356 PREFILTER_XSOBEL = 1
3358
3359 CV_WRAP virtual int getPreFilterType() const = 0;
3360 CV_WRAP virtual void setPreFilterType(int preFilterType) = 0;
3361
3362 CV_WRAP virtual int getPreFilterSize() const = 0;
3363 CV_WRAP virtual void setPreFilterSize(int preFilterSize) = 0;
3364
3365 CV_WRAP virtual int getPreFilterCap() const = 0;
3366 CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
3367
3368 CV_WRAP virtual int getTextureThreshold() const = 0;
3369 CV_WRAP virtual void setTextureThreshold(int textureThreshold) = 0;
3370
3371 CV_WRAP virtual int getUniquenessRatio() const = 0;
3372 CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
3373
3374 CV_WRAP virtual int getSmallerBlockSize() const = 0;
3375 CV_WRAP virtual void setSmallerBlockSize(int blockSize) = 0;
3376
3377 CV_WRAP virtual Rect getROI1() const = 0;
3378 CV_WRAP virtual void setROI1(Rect roi1) = 0;
3379
3380 CV_WRAP virtual Rect getROI2() const = 0;
3381 CV_WRAP virtual void setROI2(Rect roi2) = 0;
3382
3396 CV_WRAP static Ptr<StereoBM> create(int numDisparities = 0, int blockSize = 21);
3397};
3398
3418{
3419public:
3420 enum
3421 {
3422 MODE_SGBM = 0,
3423 MODE_HH = 1,
3424 MODE_SGBM_3WAY = 2,
3425 MODE_HH4 = 3
3427
3428 CV_WRAP virtual int getPreFilterCap() const = 0;
3429 CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
3430
3431 CV_WRAP virtual int getUniquenessRatio() const = 0;
3432 CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
3433
3434 CV_WRAP virtual int getP1() const = 0;
3435 CV_WRAP virtual void setP1(int P1) = 0;
3436
3437 CV_WRAP virtual int getP2() const = 0;
3438 CV_WRAP virtual void setP2(int P2) = 0;
3439
3440 CV_WRAP virtual int getMode() const = 0;
3441 CV_WRAP virtual void setMode(int mode) = 0;
3442
3480 CV_WRAP static Ptr<StereoSGBM> create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3,
3481 int P1 = 0, int P2 = 0, int disp12MaxDiff = 0,
3482 int preFilterCap = 0, int uniquenessRatio = 0,
3483 int speckleWindowSize = 0, int speckleRange = 0,
3484 int mode = StereoSGBM::MODE_SGBM);
3485};
3486
3487
3494
3527 InputArray newCameraMatrix = noArray() );
3528
3593 InputArray R, InputArray newCameraMatrix,
3594 Size size, int m1type, OutputArray map1, OutputArray map2);
3595
3664 InputArray R, InputArray newCameraMatrix,
3665 const Size& size, int m1type, OutputArray map1, OutputArray map2 );
3666
3670 Size imageSize, int destImageWidth,
3671 int m1type, OutputArray map1, OutputArray map2,
3672 enum UndistortTypes projType = PROJ_SPHERICAL_EQRECT, double alpha = 0);
3673static inline
3675 Size imageSize, int destImageWidth,
3676 int m1type, OutputArray map1, OutputArray map2,
3677 int projType, double alpha = 0)
3678{
3679 return initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth,
3680 m1type, map1, map2, (UndistortTypes)projType, alpha);
3681}
3682
3707 bool centerPrincipalPoint = false);
3708
3756CV_EXPORTS_AS(undistortPointsIter)
3760
3773 TermCriteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5,
3774 0.01));
3775
3777
3781namespace fisheye
3782{
3785
3786 enum{
3798 CALIB_FIX_FOCAL_LENGTH = 1 << 11
3800
3821 CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
3822 InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
3823
3826 InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
3827
3840 CV_EXPORTS_W void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha = 0);
3841
3857
3873 const cv::Size& size, int m1type, OutputArray map1, OutputArray map2);
3874
3904 InputArray K, InputArray D, InputArray Knew = cv::noArray(), const Size& new_size = Size());
3905
3920 OutputArray P, double balance = 0.0, const Size& new_size = Size(), double fov_scale = 1.0);
3921
3960
3992 OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize = Size(),
3993 double balance = 0.0, double fov_scale = 1.0);
3994
4040
4046
4081 OutputArray rvec, OutputArray tvec,
4082 bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE,
4084 );
4085
4087} // end namespace fisheye
4088
4089} //end namespace cv
4090
4091#if 0 //def __cplusplus
4093class CV_EXPORTS CvLevMarq
4094{
4095public:
4096 CvLevMarq();
4097 CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria=
4099 bool completeSymmFlag=false );
4100 ~CvLevMarq();
4101 void init( int nparams, int nerrs, CvTermCriteria criteria=
4103 bool completeSymmFlag=false );
4104 bool update( const CvMat*& param, CvMat*& J, CvMat*& err );
4105 bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm );
4106
4107 void clear();
4108 void step();
4109 enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 };
4110
4112 cv::Ptr<CvMat> prevParam;
4115 cv::Ptr<CvMat> err;
4116 cv::Ptr<CvMat> JtJ;
4117 cv::Ptr<CvMat> JtJN;
4118 cv::Ptr<CvMat> JtErr;
4119 cv::Ptr<CvMat> JtJV;
4120 cv::Ptr<CvMat> JtJW;
4121 double prevErrNorm, errNorm;
4122 int lambdaLg10;
4124 int state;
4125 int iters;
4126 bool completeSymmFlag;
4127 int solveMethod;
4128};
4129#endif
4130
4131#endif
This is a base class for all more or less complex algorithms in OpenCV.
Definition core.hpp:3197
Definition calib3d.hpp:617
virtual bool compute(InputArray param, OutputArray err, OutputArray J) const =0
virtual ~Callback()
Definition calib3d.hpp:619
Definition calib3d.hpp:614
virtual int getMaxIters() const =0
virtual void setMaxIters(int maxIters)=0
static Ptr< LMSolver > create(const Ptr< LMSolver::Callback > &cb, int maxIters, double eps)
virtual int run(InputOutputArray param) const =0
static Ptr< LMSolver > create(const Ptr< LMSolver::Callback > &cb, int maxIters)
n-dimensional dense array class
Definition mat.hpp:812
Template class for 2D points specified by its coordinates x and y.
Definition types.hpp:163
Template class for 2D rectangles.
Definition types.hpp:444
static CV_WRAP Ptr< SimpleBlobDetector > create(const SimpleBlobDetector::Params &parameters=SimpleBlobDetector::Params())
Template class for specifying the size of an image or rectangle.
Definition types.hpp:335
Class for computing stereo correspondence using the block matching algorithm, introduced and contribu...
Definition calib3d.hpp:3353
virtual CV_WRAP Rect getROI1() const =0
virtual CV_WRAP void setROI1(Rect roi1)=0
virtual CV_WRAP int getPreFilterCap() const =0
virtual CV_WRAP int getUniquenessRatio() const =0
virtual CV_WRAP void setPreFilterType(int preFilterType)=0
virtual CV_WRAP void setROI2(Rect roi2)=0
virtual CV_WRAP void setPreFilterCap(int preFilterCap)=0
virtual CV_WRAP int getTextureThreshold() const =0
virtual CV_WRAP int getSmallerBlockSize() const =0
virtual CV_WRAP int getPreFilterSize() const =0
virtual CV_WRAP void setSmallerBlockSize(int blockSize)=0
virtual CV_WRAP void setTextureThreshold(int textureThreshold)=0
virtual CV_WRAP void setUniquenessRatio(int uniquenessRatio)=0
static CV_WRAP Ptr< StereoBM > create(int numDisparities=0, int blockSize=21)
Creates StereoBM object.
virtual CV_WRAP Rect getROI2() const =0
virtual CV_WRAP void setPreFilterSize(int preFilterSize)=0
virtual CV_WRAP int getPreFilterType() const =0
The base class for stereo correspondence algorithms.
Definition calib3d.hpp:3312
virtual CV_WRAP void compute(InputArray left, InputArray right, OutputArray disparity)=0
Computes disparity map for the specified stereo pair.
virtual CV_WRAP void setBlockSize(int blockSize)=0
virtual CV_WRAP void setSpeckleRange(int speckleRange)=0
virtual CV_WRAP void setMinDisparity(int minDisparity)=0
virtual CV_WRAP void setSpeckleWindowSize(int speckleWindowSize)=0
virtual CV_WRAP int getMinDisparity() const =0
virtual CV_WRAP int getDisp12MaxDiff() const =0
virtual CV_WRAP int getSpeckleWindowSize() const =0
virtual CV_WRAP void setNumDisparities(int numDisparities)=0
virtual CV_WRAP int getBlockSize() const =0
virtual CV_WRAP int getNumDisparities() const =0
virtual CV_WRAP int getSpeckleRange() const =0
virtual CV_WRAP void setDisp12MaxDiff(int disp12MaxDiff)=0
The class implements the modified H. Hirschmuller algorithm that differs from the original one as fo...
Definition calib3d.hpp:3418
static CV_WRAP Ptr< StereoSGBM > create(int minDisparity=0, int numDisparities=16, int blockSize=3, int P1=0, int P2=0, int disp12MaxDiff=0, int preFilterCap=0, int uniquenessRatio=0, int speckleWindowSize=0, int speckleRange=0, int mode=StereoSGBM::MODE_SGBM)
Creates StereoSGBM object.
virtual CV_WRAP void setMode(int mode)=0
virtual CV_WRAP int getMode() const =0
virtual CV_WRAP void setPreFilterCap(int preFilterCap)=0
virtual CV_WRAP int getP2() const =0
virtual CV_WRAP void setP1(int P1)=0
virtual CV_WRAP int getUniquenessRatio() const =0
virtual CV_WRAP void setP2(int P2)=0
virtual CV_WRAP int getPreFilterCap() const =0
virtual CV_WRAP void setUniquenessRatio(int uniquenessRatio)=0
virtual CV_WRAP int getP1() const =0
The class defining termination criteria for iterative algorithms.
Definition types.hpp:886
@ MAX_ITER
ditto
Definition types.hpp:894
@ EPS
the desired accuracy or change in parameters at which the iterative algorithm stops
Definition types.hpp:895
@ COUNT
the maximum number of iterations or elements to compute
Definition types.hpp:893
Template class for short numerical vectors, a partial case of Matx.
Definition matx.hpp:369
Definition mat.hpp:387
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition mat.hpp:296
CV_EXPORTS_W double calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size &image_size, InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, DBL_EPSILON))
Performs camera calibration.
CV_EXPORTS_W void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha=0)
Distorts 2D points using fisheye model.
CV_EXPORTS_W void undistortImage(InputArray distorted, OutputArray undistorted, InputArray K, InputArray D, InputArray Knew=cv::noArray(), const Size &new_size=Size())
Transforms an image to compensate for fisheye lens distortion.
CV_EXPORTS_W void estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R, OutputArray P, double balance=0.0, const Size &new_size=Size(), double fov_scale=1.0)
Estimates new camera intrinsic matrix for undistortion or rectification.
@ CALIB_CHECK_COND
Definition calib3d.hpp:3789
@ CALIB_RECOMPUTE_EXTRINSIC
Definition calib3d.hpp:3788
@ CALIB_FIX_SKEW
Definition calib3d.hpp:3790
@ CALIB_FIX_INTRINSIC
Definition calib3d.hpp:3795
CV_EXPORTS_W void solvePnPRefineVVS(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON), double VVSlambda=1)
Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coo...
CV_EXPORTS_W bool find4QuadCornerSubpix(InputArray img, InputOutputArray corners, Size region_size)
finds subpixel-accurate positions of the chessboard corners
CV_EXPORTS_W bool findChessboardCorners(InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
Finds the positions of internal corners of the chessboard.
InputArrayOfArrays Size int iFixedPoint
Definition calib3d.hpp:1686
CV_EXPORTS_W int solvePnPGeneric(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, bool useExtrinsicGuess=false, SolvePnPMethod flags=SOLVEPNP_ITERATIVE, InputArray rvec=noArray(), InputArray tvec=noArray(), OutputArray reprojectionError=noArray())
Finds an object pose from 3D-2D point correspondences.
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray int flags
Definition calib3d.hpp:1617
CV_EXPORTS_W void calibrateRobotWorldHandEye(InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam, InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper, OutputArray R_base2world, OutputArray t_base2world, OutputArray R_gripper2cam, OutputArray t_gripper2cam, RobotWorldHandEyeCalibrationMethod method=CALIB_ROBOT_WORLD_HAND_EYE_SHAH)
Computes Robot-World/Hand-Eye calibration: and .
CV_EXPORTS_W int estimateTranslation3D(InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
Computes an optimal translation between two 3D point sets.
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays tvecs
Definition calib3d.hpp:1613
CV_EXPORTS_W void validateDisparity(InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
validates disparity using the left-right check. The matrix "cost" should be computed by the stereo co...
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray T
Definition calib3d.hpp:1867
InputArrayOfArrays Size int InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray OutputArray stdDeviationsObjPoints
Definition calib3d.hpp:1692
CV_EXPORTS_W int solveP3P(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags)
Finds an object pose from 3 3D-2D point correspondences.
CV_EXPORTS_W Mat findEssentialMat(InputArray points1, InputArray points2, InputArray cameraMatrix, int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
Calculates an essential matrix from the corresponding points in two images.
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray stdDeviationsIntrinsics
Definition calib3d.hpp:1614
CV_EXPORTS_W Mat findFundamentalMat(InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray())
Calculates a fundamental matrix from the corresponding points in two images.
CV_EXPORTS_W int recoverPose(InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, OutputArray E, OutputArray R, OutputArray t, int method=cv::RANSAC, double prob=0.999, double threshold=1.0, InputOutputArray mask=noArray())
Recovers the relative camera rotation and the translation from corresponding points in two images fro...
SolvePnPMethod
Definition calib3d.hpp:459
ScoreMethod
Definition calib3d.hpp:555
CV_EXPORTS_W double calibrateCameraRO(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
CirclesGridFinderParameters CirclesGridFinderParameters2
Definition calib3d.hpp:1444
CV_EXPORTS_W void filterHomographyDecompByVisibleRefpoints(InputArrayOfArrays rotations, InputArrayOfArrays normals, InputArray beforePoints, InputArray afterPoints, OutputArray possibleSolutions, InputArray pointsMask=noArray())
Filters homography decompositions based on additional information.
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray perViewErrors
Definition calib3d.hpp:1616
CV_EXPORTS_W void matMulDeriv(InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
Computes partial derivatives of the matrix product for each multiplied matrix.
LocalOptimMethod
Definition calib3d.hpp:553
CV_EXPORTS_W void convertPointsToHomogeneous(InputArray src, OutputArray dst)
Converts points from Euclidean to homogeneous space.
CV_EXPORTS_W bool stereoRectifyUncalibrated(InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5)
Computes a rectification transform for an uncalibrated stereo camera.
SamplingMethod
Definition calib3d.hpp:551
CV_EXPORTS_W void computeCorrespondEpilines(InputArray points, int whichImage, InputArray F, OutputArray lines)
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
CV_EXPORTS_W void undistortPoints(InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
Computes the ideal point coordinates from the observed point coordinates.
CV_EXPORTS_W void triangulatePoints(InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D)
This function reconstructs 3-dimensional points (in homogeneous coordinates) by using their observati...
CV_EXPORTS_W void projectPoints(InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0)
Projects 3D points to an image plane.
InputArrayOfArrays InputArrayOfArrays imagePoints2
Definition calib3d.hpp:1864
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray cameraMatrix2
Definition calib3d.hpp:1866
CV_EXPORTS_W double calibrateCamera(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
CV_EXPORTS_W void initUndistortRectifyMap(InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
Computes the undistortion and rectification transformation map.
CV_EXPORTS_W void initInverseRectificationMap(InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2)
Computes the projection and inverse-rectification transformation map. In essense, this is the inverse...
CV_EXPORTS_W Mat getOptimalNewCameraMatrix(InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0, bool centerPrincipalPoint=false)
Returns the new camera intrinsic matrix based on the free scaling parameter.
CV_EXPORTS_W void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray())
Converts a rotation matrix to a rotation vector or vice versa.
CV_EXPORTS_W void filterSpeckles(InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
Filters off small noise blobs (speckles) in the disparity map.
CV_EXPORTS void convertPointsHomogeneous(InputArray src, OutputArray dst)
Converts points to/from homogeneous coordinates.
CV_EXPORTS_W Mat initCameraMatrix2D(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0)
Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray distCoeffs1
Definition calib3d.hpp:1865
InputArrayOfArrays imagePoints1
Definition calib3d.hpp:1864
CV_EXPORTS_W cv::Mat estimateAffinePartial2D(InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets...
RobotWorldHandEyeCalibrationMethod
Definition calib3d.hpp:546
InputArrayOfArrays imagePoints
Definition calib3d.hpp:1611
CV_EXPORTS_W bool solvePnPRansac(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, double confidence=0.99, OutputArray inliers=noArray(), int flags=SOLVEPNP_ITERATIVE)
Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
CV_EXPORTS_W Mat findHomography(InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray(), const int maxIters=2000, const double confidence=0.995)
Finds a perspective transformation between two planes.
CV_EXPORTS_W void undistort(InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
Transforms an image to compensate for lens distortion.
CV_EXPORTS_W Scalar estimateChessboardSharpness(InputArray image, Size patternSize, InputArray corners, float rise_distance=0.8F, bool vertical=false, OutputArray sharpness=noArray())
Estimates the sharpness of a detected chessboard.
CV_EXPORTS_W void convertPointsFromHomogeneous(InputArray src, OutputArray dst)
Converts points from homogeneous to Euclidean space.
CV_EXPORTS_W int decomposeHomographyMat(InputArray H, InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals)
Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays rvecs
Definition calib3d.hpp:1613
InputArrayOfArrays Size InputOutputArray InputOutputArray distCoeffs
Definition calib3d.hpp:1612
CV_EXPORTS_W void correctMatches(InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2)
Refines coordinates of corresponding points.
CV_EXPORTS_W int estimateAffine3D(InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
Computes an optimal affine transformation between two 3D point sets.
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray R
Definition calib3d.hpp:1867
CV_EXPORTS_W void undistortImagePoints(InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, TermCriteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 0.01))
Compute undistorted image points position.
CV_EXPORTS_W void calibrationMatrixValues(InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, CV_OUT double &fovx, CV_OUT double &fovy, CV_OUT double &focalLength, CV_OUT Point2d &principalPoint, CV_OUT double &aspectRatio)
Computes useful camera characteristics from the camera intrinsic matrix.
CV_EXPORTS float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, enum UndistortTypes projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
initializes maps for remap for wide-angle
CV_EXPORTS_W bool solvePnP(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=SOLVEPNP_ITERATIVE)
Finds an object pose from 3D-2D point correspondences.
InputArrayOfArrays Size InputOutputArray cameraMatrix
Definition calib3d.hpp:1612
CV_EXPORTS_W bool checkChessboard(InputArray img, Size size)
CV_EXPORTS_W void solvePnPRefineLM(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON))
Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coo...
CV_EXPORTS_W void decomposeProjectionMatrix(InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray())
Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray distCoeffs2
Definition calib3d.hpp:1866
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray stdDeviationsExtrinsics
Definition calib3d.hpp:1615
CV_EXPORTS_W Vec3d RQDecomp3x3(InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray())
Computes an RQ decomposition of 3x3 matrices.
CV_EXPORTS_W Rect getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)
computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by stereo...
UndistortTypes
cv::undistort mode
Definition calib3d.hpp:3490
InputArrayOfArrays Size int InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray newObjPoints
Definition calib3d.hpp:1689
HandEyeCalibrationMethod
Definition calib3d.hpp:537
NeighborSearchMethod
Definition calib3d.hpp:556
CV_EXPORTS_W cv::Mat estimateAffine2D(InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
Computes an optimal affine transformation between two 2D point sets.
CV_EXPORTS_W void reprojectImageTo3D(InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1)
Reprojects a disparity image to 3D space.
CV_EXPORTS_W void drawFrameAxes(InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length, int thickness=3)
Draw axes of the world/object coordinate system from pose estimation.
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray OutputArray E
Definition calib3d.hpp:1867
bool findChessboardCornersSB(InputArray image, Size patternSize, OutputArray corners, int flags, OutputArray meta)
Finds the positions of internal corners of the chessboard using a sector based approach.
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray int TermCriteria criteria
Definition calib3d.hpp:1617
InputArrayOfArrays InputArrayOfArrays InputOutputArray cameraMatrix1
Definition calib3d.hpp:1865
CV_EXPORTS_W void decomposeEssentialMat(InputArray E, OutputArray R1, OutputArray R2, OutputArray t)
Decompose an essential matrix to possible rotations and translation.
PolishingMethod
Definition calib3d.hpp:557
CV_EXPORTS_W float rectify3Collinear(InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, CV_OUT Rect *roi1, CV_OUT Rect *roi2, int flags)
computes the rectification transformations for 3-head camera, where all the heads are on the same lin...
CV_EXPORTS_W void composeRT(InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray())
Combines two rotation-and-shift transformations.
CV_EXPORTS_W void calibrateHandEye(InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base, InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam, OutputArray R_cam2gripper, OutputArray t_cam2gripper, HandEyeCalibrationMethod method=CALIB_HAND_EYE_TSAI)
Computes Hand-Eye calibration: .
CV_EXPORTS_W double sampsonDistance(InputArray pt1, InputArray pt2, InputArray F)
Calculates the Sampson Distance between two points.
CV_EXPORTS_W void stereoRectify(InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha=-1, Size newImageSize=Size(), CV_OUT Rect *validPixROI1=0, CV_OUT Rect *validPixROI2=0)
Computes rectification transforms for each head of a calibrated stereo camera.
CV_EXPORTS_W double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
This is an overloaded member function, provided for convenience. It differs from the above function o...
InputArrayOfArrays Size imageSize
Definition calib3d.hpp:1611
CV_EXPORTS_W Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
Returns the default new camera matrix.
CV_EXPORTS_W void drawChessboardCorners(InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
Renders the detected chessboard corners.
CV_EXPORTS_W bool findCirclesGrid(InputArray image, Size patternSize, OutputArray centers, int flags, const Ptr< FeatureDetector > &blobDetector, const CirclesGridFinderParameters &parameters)
Finds centers in the grid of circles.
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray OutputArray OutputArray F
Definition calib3d.hpp:1867
@ SOLVEPNP_UPNP
Definition calib3d.hpp:467
@ SOLVEPNP_MAX_COUNT
Used for count.
Definition calib3d.hpp:481
@ SOLVEPNP_AP3P
An Efficient Algebraic Solution to the Perspective-Three-Point Problem .
Definition calib3d.hpp:469
@ SOLVEPNP_SQPNP
SQPnP: A Consistently Fast and Globally OptimalSolution to the Perspective-n-Point Problem .
Definition calib3d.hpp:479
@ SOLVEPNP_ITERATIVE
Definition calib3d.hpp:460
@ SOLVEPNP_DLS
Definition calib3d.hpp:465
@ SOLVEPNP_IPPE_SQUARE
Definition calib3d.hpp:472
@ SOLVEPNP_IPPE
Definition calib3d.hpp:470
@ SOLVEPNP_EPNP
EPnP: Efficient Perspective-n-Point Camera Pose Estimation .
Definition calib3d.hpp:463
@ SOLVEPNP_P3P
Complete Solution Classification for the Perspective-Three-Point Problem .
Definition calib3d.hpp:464
@ SCORE_METHOD_RANSAC
Definition calib3d.hpp:555
@ SCORE_METHOD_LMEDS
Definition calib3d.hpp:555
@ SCORE_METHOD_MAGSAC
Definition calib3d.hpp:555
@ SCORE_METHOD_MSAC
Definition calib3d.hpp:555
@ FM_8POINT
8-point algorithm
Definition calib3d.hpp:531
@ FM_LMEDS
least-median algorithm. 7-point algorithm is used.
Definition calib3d.hpp:532
@ FM_7POINT
7-point algorithm
Definition calib3d.hpp:530
@ FM_RANSAC
RANSAC algorithm. It needs at least 15 points. 7-point algorithm is used.
Definition calib3d.hpp:533
@ CALIB_CB_SYMMETRIC_GRID
Definition calib3d.hpp:496
@ CALIB_CB_ASYMMETRIC_GRID
Definition calib3d.hpp:497
@ CALIB_CB_CLUSTERING
Definition calib3d.hpp:498
@ LOCAL_OPTIM_INNER_LO
Definition calib3d.hpp:553
@ LOCAL_OPTIM_NULL
Definition calib3d.hpp:553
@ LOCAL_OPTIM_SIGMA
Definition calib3d.hpp:554
@ LOCAL_OPTIM_GC
Definition calib3d.hpp:554
@ LOCAL_OPTIM_INNER_AND_ITER_LO
Definition calib3d.hpp:553
@ CALIB_FIX_ASPECT_RATIO
Definition calib3d.hpp:503
@ CALIB_RATIONAL_MODEL
Definition calib3d.hpp:513
@ CALIB_FIX_TAUX_TAUY
Definition calib3d.hpp:517
@ CALIB_FIX_INTRINSIC
Definition calib3d.hpp:521
@ CALIB_SAME_FOCAL_LENGTH
Definition calib3d.hpp:522
@ CALIB_FIX_PRINCIPAL_POINT
Definition calib3d.hpp:504
@ CALIB_FIX_K3
Definition calib3d.hpp:509
@ CALIB_USE_LU
use LU instead of SVD decomposition for solving. much faster but potentially less precise
Definition calib3d.hpp:525
@ CALIB_FIX_K5
Definition calib3d.hpp:511
@ CALIB_FIX_TANGENT_DIST
Definition calib3d.hpp:519
@ CALIB_USE_QR
use QR instead of SVD decomposition for solving. Faster but potentially less precise
Definition calib3d.hpp:518
@ CALIB_USE_INTRINSIC_GUESS
Definition calib3d.hpp:502
@ CALIB_FIX_FOCAL_LENGTH
Definition calib3d.hpp:506
@ CALIB_ZERO_TANGENT_DIST
Definition calib3d.hpp:505
@ CALIB_FIX_K2
Definition calib3d.hpp:508
@ CALIB_FIX_K6
Definition calib3d.hpp:512
@ CALIB_NINTRINSIC
Definition calib3d.hpp:501
@ CALIB_USE_EXTRINSIC_GUESS
for stereoCalibrate
Definition calib3d.hpp:526
@ CALIB_THIN_PRISM_MODEL
Definition calib3d.hpp:514
@ CALIB_FIX_K1
Definition calib3d.hpp:507
@ CALIB_FIX_S1_S2_S3_S4
Definition calib3d.hpp:515
@ CALIB_TILTED_MODEL
Definition calib3d.hpp:516
@ CALIB_ZERO_DISPARITY
Definition calib3d.hpp:524
@ CALIB_FIX_K4
Definition calib3d.hpp:510
@ SAMPLING_PROSAC
Definition calib3d.hpp:552
@ SAMPLING_NAPSAC
Definition calib3d.hpp:551
@ SAMPLING_UNIFORM
Definition calib3d.hpp:551
@ SAMPLING_PROGRESSIVE_NAPSAC
Definition calib3d.hpp:551
@ CALIB_ROBOT_WORLD_HAND_EYE_SHAH
Solving the robot-world/hand-eye calibration problem using the kronecker product .
Definition calib3d.hpp:547
@ CALIB_ROBOT_WORLD_HAND_EYE_LI
Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product .
Definition calib3d.hpp:548
@ CALIB_CB_ACCURACY
Definition calib3d.hpp:490
@ CALIB_CB_FAST_CHECK
Definition calib3d.hpp:488
@ CALIB_CB_LARGER
Definition calib3d.hpp:491
@ CALIB_CB_MARKER
Definition calib3d.hpp:492
@ CALIB_CB_ADAPTIVE_THRESH
Definition calib3d.hpp:485
@ CALIB_CB_FILTER_QUADS
Definition calib3d.hpp:487
@ CALIB_CB_EXHAUSTIVE
Definition calib3d.hpp:489
@ CALIB_CB_PLAIN
Definition calib3d.hpp:493
@ CALIB_CB_NORMALIZE_IMAGE
Definition calib3d.hpp:486
@ USAC_FM_8PTS
USAC, fundamental matrix 8 points.
Definition calib3d.hpp:452
@ USAC_PROSAC
USAC, sorted points, runs PROSAC.
Definition calib3d.hpp:455
@ USAC_MAGSAC
USAC, runs MAGSAC++.
Definition calib3d.hpp:456
@ USAC_DEFAULT
USAC algorithm, default settings.
Definition calib3d.hpp:450
@ RHO
RHO algorithm.
Definition calib3d.hpp:449
@ RANSAC
RANSAC algorithm.
Definition calib3d.hpp:448
@ USAC_ACCURATE
USAC, accurate settings.
Definition calib3d.hpp:454
@ USAC_PARALLEL
USAC, parallel version.
Definition calib3d.hpp:451
@ USAC_FAST
USAC, fast settings.
Definition calib3d.hpp:453
@ LMEDS
least-median of squares algorithm
Definition calib3d.hpp:447
@ PROJ_SPHERICAL_EQRECT
Definition calib3d.hpp:3492
@ PROJ_SPHERICAL_ORTHO
Definition calib3d.hpp:3491
@ CALIB_HAND_EYE_TSAI
A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/Eye Calibration .
Definition calib3d.hpp:538
@ CALIB_HAND_EYE_ANDREFF
On-line Hand-Eye Calibration .
Definition calib3d.hpp:541
@ CALIB_HAND_EYE_PARK
Robot Sensor Calibration: Solving AX = XB on the Euclidean Group .
Definition calib3d.hpp:539
@ CALIB_HAND_EYE_HORAUD
Hand-eye Calibration .
Definition calib3d.hpp:540
@ CALIB_HAND_EYE_DANIILIDIS
Hand-Eye Calibration Using Dual Quaternions .
Definition calib3d.hpp:542
@ NEIGH_FLANN_RADIUS
Definition calib3d.hpp:556
@ NEIGH_GRID
Definition calib3d.hpp:556
@ NEIGH_FLANN_KNN
Definition calib3d.hpp:556
@ MAGSAC
Definition calib3d.hpp:557
@ LSQ_POLISHER
Definition calib3d.hpp:557
@ NONE_POLISHER
Definition calib3d.hpp:557
@ COV_POLISHER
Definition calib3d.hpp:557
Point_< double > Point2d
Definition types.hpp:208
Size2i Size
Definition types.hpp:370
CV_EXPORTS InputOutputArray noArray()
InputArray InputArrayOfArrays
Definition mat.hpp:443
CV__DEBUG_NS_END typedef const _InputArray & InputArray
Definition mat.hpp:442
#define CV_TERMCRIT_EPS
Definition types_c.h:897
#define CV_TERMCRIT_ITER
Definition types_c.h:895
CvScalar scale
Definition core_c.h:1088
CV_INLINE CvTermCriteria cvTermCriteria(int type, int max_iter, double epsilon)
Definition types_c.h:918
CvSize size
Definition core_c.h:112
const CvArr const CvArr const CvArr * B
Definition core_c.h:1341
void int step
Definition core_c.h:905
CvArr const CvArr * mask
Definition core_c.h:589
double alpha
Definition core_c.h:1093
#define CV_EXPORTS_W_SIMPLE
Definition cvdef.h:473
#define CV_EXPORTS
Definition cvdef.h:435
#define CV_EXPORTS_AS(synonym)
Definition cvdef.h:474
#define CV_OUT
Definition cvdef.h:478
#define CV_EXPORTS_W
Definition cvdef.h:472
#define CV_PROP_RW
Definition cvdef.h:480
#define CV_WRAP
Definition cvdef.h:481
double threshold
Definition imgproc_c.h:712
CvPoint pt1
Definition imgproc_c.h:357
CvPoint CvPoint pt2
Definition imgproc_c.h:357
int double param
Definition imgproc_c.h:943
int CvMemStorage int double eps
Definition imgproc_c.h:493
const CvArr CvArr int method
Definition imgproc_c.h:384
CvPoint2D32f int CvSize CvSize CvTermCriteria criteria
Definition imgproc_c.h:900
CV_EXPORTS OutputArray int double double InputArray mask
Definition imgproc.hpp:2132
CV_EXPORTS OutputArray int double double InputArray OutputArray int blockSize
Definition imgproc.hpp:2132
CV_EXPORTS OutputArray corners
Definition imgproc.hpp:2130
InputArray int InputArray cost
Definition imgproc.hpp:3387
OutputArray dst
Definition imgproc.hpp:3564
const IplImage * image
Definition videoio_c.h:131
"black box" representation of the file storage associated with a file on disk.
Definition calib3d.hpp:441
Definition types_c.h:455
Definition types_c.h:902
Definition calib3d.hpp:1417
CV_PROP_RW int kmeansAttempts
Definition calib3d.hpp:1421
CV_PROP_RW int minDistanceToAddKeypoint
Definition calib3d.hpp:1422
CV_PROP_RW float minGraphConfidence
Definition calib3d.hpp:1424
CV_PROP_RW cv::Size2f densityNeighborhoodSize
Definition calib3d.hpp:1419
CV_PROP_RW float edgeGain
Definition calib3d.hpp:1428
CV_PROP_RW int keypointScale
Definition calib3d.hpp:1423
CV_PROP_RW float convexHullFactor
Definition calib3d.hpp:1430
CV_PROP_RW float squareSize
Distance between two adjacent points. Used by CALIB_CB_CLUSTERING.
Definition calib3d.hpp:1439
CV_PROP_RW float vertexPenalty
Definition calib3d.hpp:1426
GridType gridType
Definition calib3d.hpp:1437
CV_PROP_RW float edgePenalty
Definition calib3d.hpp:1429
CV_PROP_RW float vertexGain
Definition calib3d.hpp:1425
CV_PROP_RW float existingVertexGain
Definition calib3d.hpp:1427
CV_PROP_RW float minDensity
Definition calib3d.hpp:1420
CV_PROP_RW float minRNGEdgeSwitchDist
Definition calib3d.hpp:1431
CV_PROP_RW float maxRectifiedDistance
Max deviation from prediction. Used by CALIB_CB_CLUSTERING.
Definition calib3d.hpp:1440
GridType
Definition calib3d.hpp:1434
@ SYMMETRIC_GRID
Definition calib3d.hpp:1435
Definition cvstd_wrapper.hpp:74
Definition calib3d.hpp:560
CV_PROP_RW int randomGeneratorState
Definition calib3d.hpp:569
CV_WRAP UsacParams()
CV_PROP_RW LocalOptimMethod loMethod
Definition calib3d.hpp:565
CV_PROP_RW PolishingMethod final_polisher
Definition calib3d.hpp:573
CV_PROP_RW int maxIterations
Definition calib3d.hpp:567
CV_PROP_RW bool isParallel
Definition calib3d.hpp:563
CV_PROP_RW ScoreMethod score
Definition calib3d.hpp:571
CV_PROP_RW int loIterations
Definition calib3d.hpp:564
CV_PROP_RW int final_polisher_iterations
Definition calib3d.hpp:574
CV_PROP_RW SamplingMethod sampler
Definition calib3d.hpp:570
CV_PROP_RW double threshold
Definition calib3d.hpp:572
CV_PROP_RW int loSampleSize
Definition calib3d.hpp:566
CV_PROP_RW NeighborSearchMethod neighborsSearch
Definition calib3d.hpp:568
CV_PROP_RW double confidence
Definition calib3d.hpp:562