OpenCV 4.5.3(日本語機械翻訳)
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/features2d.hpp"
49 #include "opencv2/core/affine.hpp"
50
437 namespace cv
438{
439
442
444 enum { LMEDS = 4,
445 RANSAC = 8,
446 RHO = 16,
447 USAC_DEFAULT = 32,
448 USAC_PARALLEL = 33,
449 USAC_FM_8PTS = 34,
450 USAC_FAST = 35,
451 USAC_ACCURATE = 36,
452 USAC_PROSAC = 37,
453 USAC_MAGSAC = 38
454 };
455
456 enum SolvePnPMethod {
457 SOLVEPNP_ITERATIVE = 0,
458 SOLVEPNP_EPNP = 1,
459 SOLVEPNP_P3P = 2,
460 SOLVEPNP_DLS = 3,
462 SOLVEPNP_UPNP = 4,
464 SOLVEPNP_AP3P = 5,
465 SOLVEPNP_IPPE = 6,
467 SOLVEPNP_IPPE_SQUARE = 7,
474 SOLVEPNP_SQPNP = 8,
475 #ifndef CV_DOXYGEN
476 SOLVEPNP_MAX_COUNT
477 #endif
478 };
479
480 enum { CALIB_CB_ADAPTIVE_THRESH = 1,
481 CALIB_CB_NORMALIZE_IMAGE = 2,
482 CALIB_CB_FILTER_QUADS = 4,
483 CALIB_CB_FAST_CHECK = 8,
484 CALIB_CB_EXHAUSTIVE = 16,
485 CALIB_CB_ACCURACY = 32,
486 CALIB_CB_LARGER = 64,
487 CALIB_CB_MARKER = 128
488 };
489
490 enum { CALIB_CB_SYMMETRIC_GRID = 1,
491 CALIB_CB_ASYMMETRIC_GRID = 2,
492 CALIB_CB_CLUSTERING = 4
493 };
494
495 enum { CALIB_NINTRINSIC = 18,
496 CALIB_USE_INTRINSIC_GUESS = 0x00001,
497 CALIB_FIX_ASPECT_RATIO = 0x00002,
498 CALIB_FIX_PRINCIPAL_POINT = 0x00004,
499 CALIB_ZERO_TANGENT_DIST = 0x00008,
500 CALIB_FIX_FOCAL_LENGTH = 0x00010,
501 CALIB_FIX_K1 = 0x00020,
502 CALIB_FIX_K2 = 0x00040,
503 CALIB_FIX_K3 = 0x00080,
504 CALIB_FIX_K4 = 0x00800,
505 CALIB_FIX_K5 = 0x01000,
506 CALIB_FIX_K6 = 0x02000,
507 CALIB_RATIONAL_MODEL = 0x04000,
508 CALIB_THIN_PRISM_MODEL = 0x08000,
509 CALIB_FIX_S1_S2_S3_S4 = 0x10000,
510 CALIB_TILTED_MODEL = 0x40000,
511 CALIB_FIX_TAUX_TAUY = 0x80000,
512 CALIB_USE_QR = 0x100000,
513 CALIB_FIX_TANGENT_DIST = 0x200000,
514 // only for stereo
515 CALIB_FIX_INTRINSIC = 0x00100,
516 CALIB_SAME_FOCAL_LENGTH = 0x00200,
517 // for stereo rectification
518 CALIB_ZERO_DISPARITY = 0x00400,
519 CALIB_USE_LU = (1 << 17),
520 CALIB_USE_EXTRINSIC_GUESS = (1 << 22)
521 };
522
524 enum { FM_7POINT = 1,
525 FM_8POINT = 2,
526 FM_LMEDS = 4,
527 FM_RANSAC = 8
528 };
529
530 enum HandEyeCalibrationMethod
531{
532 CALIB_HAND_EYE_TSAI = 0,
533 CALIB_HAND_EYE_PARK = 1,
534 CALIB_HAND_EYE_HORAUD = 2,
535 CALIB_HAND_EYE_ANDREFF = 3,
536 CALIB_HAND_EYE_DANIILIDIS = 4
537 };
538
539 enum RobotWorldHandEyeCalibrationMethod
540{
541 CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0,
542 CALIB_ROBOT_WORLD_HAND_EYE_LI = 1
543 };
544
545 enum SamplingMethod { SAMPLING_UNIFORM, SAMPLING_PROGRESSIVE_NAPSAC, SAMPLING_NAPSAC,
546 SAMPLING_PROSAC };
547 enum LocalOptimMethod {LOCAL_OPTIM_NULL, LOCAL_OPTIM_INNER_LO, LOCAL_OPTIM_INNER_AND_ITER_LO,
548 LOCAL_OPTIM_GC, LOCAL_OPTIM_SIGMA};
549 enum ScoreMethod {SCORE_METHOD_RANSAC, SCORE_METHOD_MSAC, SCORE_METHOD_MAGSAC, SCORE_METHOD_LMEDS};
550 enum NeighborSearchMethod { NEIGH_FLANN_KNN, NEIGH_GRID, NEIGH_FLANN_RADIUS };
551
552 struct CV_EXPORTS_W_SIMPLE UsacParams
553{ // in alphabetical order
554 CV_WRAP UsacParams();
555 CV_PROP_RW double confidence;
556 CV_PROP_RW bool isParallel;
557 CV_PROP_RW int loIterations;
558 CV_PROP_RW LocalOptimMethod loMethod;
559 CV_PROP_RW int loSampleSize;
560 CV_PROP_RW int maxIterations;
561 CV_PROP_RW NeighborSearchMethod neighborsSearch;
562 CV_PROP_RW int randomGeneratorState;
563 CV_PROP_RW SamplingMethod sampler;
564 CV_PROP_RW ScoreMethod score;
565 CV_PROP_RW double threshold;
566};
567
594 CV_EXPORTS_W void Rodrigues( InputArray src, OutputArray dst, OutputArray jacobian = noArray() );
595
596
597
604 class CV_EXPORTS LMSolver : public Algorithm
605{
606 public:
607 class CV_EXPORTS Callback
608 {
609 public:
610 virtual ~Callback() {}
623 virtual bool compute(InputArray param, OutputArray err, OutputArray J) const = 0;
624 };
625
638 virtual int run(InputOutputArray param) const = 0;
639
644 virtual void setMaxIters(int maxIters) = 0;
648 virtual int getMaxIters() const = 0;
649
657 static Ptr<LMSolver> create(const Ptr<LMSolver::Callback>& cb, int maxIters);
658 static Ptr<LMSolver> create(const Ptr<LMSolver::Callback>& cb, int maxIters, double eps);
659};
660
661
662
728 CV_EXPORTS_W Mat findHomography( InputArray srcPoints, InputArray dstPoints,
729 int method = 0, double ransacReprojThreshold = 3,
730 OutputArray mask=noArray(), const int maxIters = 2000,
731 const double confidence = 0.995);
732
734 CV_EXPORTS Mat findHomography( InputArray srcPoints, InputArray dstPoints,
735 OutputArray mask, int method = 0, double ransacReprojThreshold = 3 );
736
737
738CV_EXPORTS_W Mat findHomography(InputArray srcPoints, InputArray dstPoints, OutputArray mask,
739 const UsacParams &params);
740
760 CV_EXPORTS_W Vec3d RQDecomp3x3( InputArray src, OutputArray mtxR, OutputArray mtxQ,
761 OutputArray Qx = noArray(),
762 OutputArray Qy = noArray(),
763 OutputArray Qz = noArray());
764
787 CV_EXPORTS_W void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix,
788 OutputArray rotMatrix, OutputArray transVect,
789 OutputArray rotMatrixX = noArray(),
790 OutputArray rotMatrixY = noArray(),
791 OutputArray rotMatrixZ = noArray(),
792 OutputArray eulerAngles =noArray() );
793
807 CV_EXPORTS_W void matMulDeriv( InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB );
808
838 CV_EXPORTS_W void composeRT( InputArray rvec1, InputArray tvec1,
839 InputArray rvec2, InputArray tvec2,
840 OutputArray rvec3, OutputArray tvec3,
841 OutputArray dr3dr1 = noArray(), OutputArray dr3dt1 = noArray(),
842 OutputArray dr3dr2 = noArray(), OutputArray dr3dt2 = noArray(),
843 OutputArray dt3dr1 = noArray(), OutputArray dt3dt1 = noArray(),
844 OutputArray dt3dr2 = noArray(), OutputArray dt3dt2 = noArray() );
845
879 CV_EXPORTS_W void projectPoints( InputArray objectPoints,
880 InputArray rvec, InputArray tvec,
881 InputArray cameraMatrix, InputArray distCoeffs,
882 OutputArray imagePoints,
883 OutputArray jacobian = noArray(),
884 double aspectRatio = 0 );
885
1078 CV_EXPORTS_W bool solvePnP( InputArray objectPoints, InputArray imagePoints,
1079 InputArray cameraMatrix, InputArray distCoeffs,
1080 OutputArray rvec, OutputArray tvec,
1081 bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE );
1082
1124 CV_EXPORTS_W bool solvePnPRansac( InputArray objectPoints, InputArray imagePoints,
1125 InputArray cameraMatrix, InputArray distCoeffs,
1126 OutputArray rvec, OutputArray tvec,
1127 bool useExtrinsicGuess = false, int iterationsCount = 100,
1128 float reprojectionError = 8.0, double confidence = 0.99,
1129 OutputArray inliers = noArray(), int flags = SOLVEPNP_ITERATIVE );
1130
1131
1132 /*
1133 Finds rotation and translation vector.
1134 If cameraMatrix is given then run P3P. Otherwise run linear P6P and output cameraMatrix too.
1135 */
1136CV_EXPORTS_W bool solvePnPRansac( InputArray objectPoints, InputArray imagePoints,
1137 InputOutputArray cameraMatrix, InputArray distCoeffs,
1138 OutputArray rvec, OutputArray tvec, OutputArray inliers,
1139 const UsacParams &params=UsacParams());
1140
1166 CV_EXPORTS_W int solveP3P( InputArray objectPoints, InputArray imagePoints,
1167 InputArray cameraMatrix, InputArray distCoeffs,
1168 OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
1169 int flags );
1170
1193 CV_EXPORTS_W void solvePnPRefineLM( InputArray objectPoints, InputArray imagePoints,
1194 InputArray cameraMatrix, InputArray distCoeffs,
1195 InputOutputArray rvec, InputOutputArray tvec,
1196 TermCriteria criteria = TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 20, FLT_EPSILON));
1197
1222 CV_EXPORTS_W void solvePnPRefineVVS( InputArray objectPoints, InputArray imagePoints,
1223 InputArray cameraMatrix, InputArray distCoeffs,
1224 InputOutputArray rvec, InputOutputArray tvec,
1225 TermCriteria criteria = TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 20, FLT_EPSILON),
1226 double VVSlambda = 1);
1227
1418 CV_EXPORTS_W int solvePnPGeneric( InputArray objectPoints, InputArray imagePoints,
1419 InputArray cameraMatrix, InputArray distCoeffs,
1420 OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
1421 bool useExtrinsicGuess = false, SolvePnPMethod flags = SOLVEPNP_ITERATIVE,
1422 InputArray rvec = noArray(), InputArray tvec = noArray(),
1423 OutputArray reprojectionError = noArray() );
1424
1440 CV_EXPORTS_W Mat initCameraMatrix2D( InputArrayOfArrays objectPoints,
1441 InputArrayOfArrays imagePoints,
1442 Size imageSize, double aspectRatio = 1.0 );
1443
1493 CV_EXPORTS_W bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners,
1494 int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE );
1495
1496 /*
1497 Checks whether the image contains chessboard of the specific size or not.
1498 If yes, nonzero value is returned.
1499 */
1500CV_EXPORTS_W bool checkChessboard(InputArray img, Size size);
1501
1550 CV_EXPORTS_AS(findChessboardCornersSBWithMeta)
1551 bool findChessboardCornersSB(InputArray image,Size patternSize, OutputArray corners,
1552 int flags,OutputArray meta);
1554CV_EXPORTS_W inline
1555 bool findChessboardCornersSB(InputArray image, Size patternSize, OutputArray corners,
1556 int flags = 0)
1557{
1558 return findChessboardCornersSB(image, patternSize, corners, flags, noArray());
1559}
1560
1588 CV_EXPORTS_W Scalar estimateChessboardSharpness(InputArray image, Size patternSize, InputArray corners,
1589 float rise_distance=0.8F,bool vertical=false,
1590 OutputArray sharpness=noArray());
1591
1592
1594 CV_EXPORTS_W bool find4QuadCornerSubpix( InputArray img, InputOutputArray corners, Size region_size );
1595
1608 CV_EXPORTS_W void drawChessboardCorners( InputOutputArray image, Size patternSize,
1609 InputArray corners, bool patternWasFound );
1610
1627 CV_EXPORTS_W void drawFrameAxes(InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs,
1628 InputArray rvec, InputArray tvec, float length, int thickness=3);
1629
1630 struct CV_EXPORTS_W_SIMPLE CirclesGridFinderParameters
1631{
1632 CV_WRAP CirclesGridFinderParameters();
1633 CV_PROP_RW cv::Size2f densityNeighborhoodSize;
1634 CV_PROP_RW float minDensity;
1635 CV_PROP_RW int kmeansAttempts;
1636 CV_PROP_RW int minDistanceToAddKeypoint;
1637 CV_PROP_RW int keypointScale;
1638 CV_PROP_RW float minGraphConfidence;
1639 CV_PROP_RW float vertexGain;
1640 CV_PROP_RW float vertexPenalty;
1641 CV_PROP_RW float existingVertexGain;
1642 CV_PROP_RW float edgeGain;
1643 CV_PROP_RW float edgePenalty;
1644 CV_PROP_RW float convexHullFactor;
1645 CV_PROP_RW float minRNGEdgeSwitchDist;
1646
1647 enum GridType
1648 {
1649 SYMMETRIC_GRID, ASYMMETRIC_GRID
1650 };
1651 GridType gridType;
1652
1653 CV_PROP_RW float squareSize;
1654 CV_PROP_RW float maxRectifiedDistance;
1655};
1656
1657 #ifndef DISABLE_OPENCV_3_COMPATIBILITY
1658 typedef CirclesGridFinderParameters CirclesGridFinderParameters2;
1659 #endif
1660
1694 CV_EXPORTS_W bool findCirclesGrid( InputArray image, Size patternSize,
1695 OutputArray centers, int flags,
1696 const Ptr<FeatureDetector> &blobDetector,
1697 const CirclesGridFinderParameters& parameters);
1698
1700 CV_EXPORTS_W bool findCirclesGrid( InputArray image, Size patternSize,
1701 OutputArray centers, int flags = CALIB_CB_SYMMETRIC_GRID,
1702 const Ptr<FeatureDetector> &blobDetector = SimpleBlobDetector::create());
1703
1820 CV_EXPORTS_AS(calibrateCameraExtended) double calibrateCamera( InputArrayOfArrays objectPoints,
1821 InputArrayOfArrays imagePoints, Size imageSize,
1822 InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
1823 OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
1824 OutputArray stdDeviationsIntrinsics,
1825 OutputArray stdDeviationsExtrinsics,
1826 OutputArray perViewErrors,
1827 int flags = 0, TermCriteria criteria = TermCriteria(
1828 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1829
1831 CV_EXPORTS_W double calibrateCamera( InputArrayOfArrays objectPoints,
1832 InputArrayOfArrays imagePoints, Size imageSize,
1833 InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
1834 OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
1835 int flags = 0, TermCriteria criteria = TermCriteria(
1836 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1837
1895 CV_EXPORTS_AS(calibrateCameraROExtended) double calibrateCameraRO( InputArrayOfArrays objectPoints,
1896 InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint,
1897 InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
1898 OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
1899 OutputArray newObjPoints,
1900 OutputArray stdDeviationsIntrinsics,
1901 OutputArray stdDeviationsExtrinsics,
1902 OutputArray stdDeviationsObjPoints,
1903 OutputArray perViewErrors,
1904 int flags = 0, TermCriteria criteria = TermCriteria(
1905 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1906
1908 CV_EXPORTS_W double calibrateCameraRO( InputArrayOfArrays objectPoints,
1909 InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint,
1910 InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
1911 OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
1912 OutputArray newObjPoints,
1913 int flags = 0, TermCriteria criteria = TermCriteria(
1914 TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) );
1915
1936 CV_EXPORTS_W void calibrationMatrixValues( InputArray cameraMatrix, Size imageSize,
1937 double apertureWidth, double apertureHeight,
1938 CV_OUT double& fovx, CV_OUT double& fovy,
1939 CV_OUT double& focalLength, CV_OUT Point2d& principalPoint,
1940 CV_OUT double& aspectRatio );
1941
2064 CV_EXPORTS_AS(stereoCalibrateExtended) double stereoCalibrate( InputArrayOfArrays objectPoints,
2065 InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
2066 InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1,
2067 InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2,
2068 Size imageSize, InputOutputArray R,InputOutputArray T, OutputArray E, OutputArray F,
2069 OutputArray perViewErrors, int flags = CALIB_FIX_INTRINSIC,
2070 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) );
2071
2073 CV_EXPORTS_W double stereoCalibrate( InputArrayOfArrays objectPoints,
2074 InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
2075 InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1,
2076 InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2,
2077 Size imageSize, OutputArray R,OutputArray T, OutputArray E, OutputArray F,
2078 int flags = CALIB_FIX_INTRINSIC,
2079 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) );
2080
2186 CV_EXPORTS_W void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs1,
2187 InputArray cameraMatrix2, InputArray distCoeffs2,
2188 Size imageSize, InputArray R, InputArray T,
2189 OutputArray R1, OutputArray R2,
2190 OutputArray P1, OutputArray P2,
2191 OutputArray Q, int flags = CALIB_ZERO_DISPARITY,
2192 double alpha = -1, Size newImageSize = Size(),
2193 CV_OUT Rect* validPixROI1 = 0, CV_OUT Rect* validPixROI2 = 0 );
2194
2224 CV_EXPORTS_W bool stereoRectifyUncalibrated( InputArray points1, InputArray points2,
2225 InputArray F, Size imgSize,
2226 OutputArray H1, OutputArray H2,
2227 double threshold = 5 );
2228
2230 CV_EXPORTS_W float rectify3Collinear( InputArray cameraMatrix1, InputArray distCoeffs1,
2231 InputArray cameraMatrix2, InputArray distCoeffs2,
2232 InputArray cameraMatrix3, InputArray distCoeffs3,
2233 InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3,
2234 Size imageSize, InputArray R12, InputArray T12,
2235 InputArray R13, InputArray T13,
2236 OutputArray R1, OutputArray R2, OutputArray R3,
2237 OutputArray P1, OutputArray P2, OutputArray P3,
2238 OutputArray Q, double alpha, Size newImgSize,
2239 CV_OUT Rect* roi1, CV_OUT Rect* roi2, int flags );
2240
2267 CV_EXPORTS_W Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs,
2268 Size imageSize, double alpha, Size newImgSize = Size(),
2269 CV_OUT Rect* validPixROI = 0,
2270 bool centerPrincipalPoint = false);
2271
2418 CV_EXPORTS_W void calibrateHandEye( InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base,
2419 InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam,
2420 OutputArray R_cam2gripper, OutputArray t_cam2gripper,
2421 HandEyeCalibrationMethod method=CALIB_HAND_EYE_TSAI );
2422
2561 CV_EXPORTS_W void calibrateRobotWorldHandEye( InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam,
2562 InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper,
2563 OutputArray R_base2world, OutputArray t_base2world,
2564 OutputArray R_gripper2cam, OutputArray t_gripper2cam,
2565 RobotWorldHandEyeCalibrationMethod method=CALIB_ROBOT_WORLD_HAND_EYE_SHAH );
2566
2575 CV_EXPORTS_W void convertPointsToHomogeneous( InputArray src, OutputArray dst );
2576
2586 CV_EXPORTS_W void convertPointsFromHomogeneous( InputArray src, OutputArray dst );
2587
2598 CV_EXPORTS void convertPointsHomogeneous( InputArray src, OutputArray dst );
2599
2651 CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2,
2652 int method, double ransacReprojThreshold, double confidence,
2653 int maxIters, OutputArray mask = noArray() );
2654
2656 CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2,
2657 int method = FM_RANSAC,
2658 double ransacReprojThreshold = 3., double confidence = 0.99,
2659 OutputArray mask = noArray() );
2660
2662 CV_EXPORTS Mat findFundamentalMat( InputArray points1, InputArray points2,
2663 OutputArray mask, int method = FM_RANSAC,
2664 double ransacReprojThreshold = 3., double confidence = 0.99 );
2665
2666
2667CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2,
2668 OutputArray mask, const UsacParams &params);
2669
2703CV_EXPORTS_W
2704 Mat findEssentialMat(
2705 InputArray points1, InputArray points2,
2706 InputArray cameraMatrix, int method = RANSAC,
2707 double prob = 0.999, double threshold = 1.0,
2708 int maxIters = 1000, OutputArray mask = noArray()
2709);
2710
2712CV_EXPORTS
2713 Mat findEssentialMat(
2714 InputArray points1, InputArray points2,
2715 InputArray cameraMatrix, int method,
2716 double prob, double threshold,
2717 OutputArray mask
2718); // TODO remove from OpenCV 5.0
2719
2750CV_EXPORTS_W
2751 Mat findEssentialMat(
2752 InputArray points1, InputArray points2,
2753 double focal = 1.0, Point2d pp = Point2d(0, 0),
2754 int method = RANSAC, double prob = 0.999,
2755 double threshold = 1.0, int maxIters = 1000,
2756 OutputArray mask = noArray()
2757);
2758
2760CV_EXPORTS
2761 Mat findEssentialMat(
2762 InputArray points1, InputArray points2,
2763 double focal, Point2d pp,
2764 int method, double prob,
2765 double threshold, OutputArray mask
2766); // TODO remove from OpenCV 5.0
2767
2812 CV_EXPORTS_W Mat findEssentialMat( InputArray points1, InputArray points2,
2813 InputArray cameraMatrix1, InputArray distCoeffs1,
2814 InputArray cameraMatrix2, InputArray distCoeffs2,
2815 int method = RANSAC,
2816 double prob = 0.999, double threshold = 1.0,
2817 OutputArray mask = noArray() );
2818
2819
2820CV_EXPORTS_W Mat findEssentialMat( InputArray points1, InputArray points2,
2821 InputArray cameraMatrix1, InputArray cameraMatrix2,
2822 InputArray dist_coeff1, InputArray dist_coeff2, OutputArray mask,
2823 const UsacParams &params);
2824
2843 CV_EXPORTS_W void decomposeEssentialMat( InputArray E, OutputArray R1, OutputArray R2, OutputArray t );
2844
2895 CV_EXPORTS_W int recoverPose( InputArray E, InputArray points1, InputArray points2,
2896 InputArray cameraMatrix, OutputArray R, OutputArray t,
2897 InputOutputArray mask = noArray() );
2898
2928 CV_EXPORTS_W int recoverPose( InputArray E, InputArray points1, InputArray points2,
2929 OutputArray R, OutputArray t,
2930 double focal = 1.0, Point2d pp = Point2d(0, 0),
2931 InputOutputArray mask = noArray() );
2932
2958 CV_EXPORTS_W int recoverPose( InputArray E, InputArray points1, InputArray points2,
2959 InputArray cameraMatrix, OutputArray R, OutputArray t, double distanceThresh, InputOutputArray mask = noArray(),
2960 OutputArray triangulatedPoints = noArray());
2961
2985 CV_EXPORTS_W void computeCorrespondEpilines( InputArray points, int whichImage,
2986 InputArray F, OutputArray lines );
2987
3012 CV_EXPORTS_W void triangulatePoints( InputArray projMatr1, InputArray projMatr2,
3013 InputArray projPoints1, InputArray projPoints2,
3014 OutputArray points4D );
3015
3031 CV_EXPORTS_W void correctMatches( InputArray F, InputArray points1, InputArray points2,
3032 OutputArray newPoints1, OutputArray newPoints2 );
3033
3046 CV_EXPORTS_W void filterSpeckles( InputOutputArray img, double newVal,
3047 int maxSpeckleSize, double maxDiff,
3048 InputOutputArray buf = noArray() );
3049
3051 CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2,
3052 int minDisparity, int numberOfDisparities,
3053 int blockSize );
3054
3056 CV_EXPORTS_W void validateDisparity( InputOutputArray disparity, InputArray cost,
3057 int minDisparity, int numberOfDisparities,
3058 int disp12MaxDisp = 1 );
3059
3099 CV_EXPORTS_W void reprojectImageTo3D( InputArray disparity,
3100 OutputArray _3dImage, InputArray Q,
3101 bool handleMissingValues = false,
3102 int ddepth = -1 );
3103
3121 CV_EXPORTS_W double sampsonDistance(InputArray pt1, InputArray pt2, InputArray F);
3122
3171 CV_EXPORTS_W int estimateAffine3D(InputArray src, InputArray dst,
3172 OutputArray out, OutputArray inliers,
3173 double ransacThreshold = 3, double confidence = 0.99);
3174
3199 CV_EXPORTS_W cv::Mat estimateAffine3D(InputArray src, InputArray dst,
3200 CV_OUT double* scale = nullptr, bool force_rotation = true);
3201
3245 CV_EXPORTS_W int estimateTranslation3D(InputArray src, InputArray dst,
3246 OutputArray out, OutputArray inliers,
3247 double ransacThreshold = 3, double confidence = 0.99);
3248
3311 CV_EXPORTS_W cv::Mat estimateAffine2D(InputArray from, InputArray to, OutputArray inliers = noArray(),
3312 int method = RANSAC, double ransacReprojThreshold = 3,
3313 size_t maxIters = 2000, double confidence = 0.99,
3314 size_t refineIters = 10);
3315
3316
3317CV_EXPORTS_W cv::Mat estimateAffine2D(InputArray pts1, InputArray pts2, OutputArray inliers,
3318 const UsacParams &params);
3319
3363 CV_EXPORTS_W cv::Mat estimateAffinePartial2D(InputArray from, InputArray to, OutputArray inliers = noArray(),
3364 int method = RANSAC, double ransacReprojThreshold = 3,
3365 size_t maxIters = 2000, double confidence = 0.99,
3366 size_t refineIters = 10);
3367
3396 CV_EXPORTS_W int decomposeHomographyMat(InputArray H,
3397 InputArray K,
3398 OutputArrayOfArrays rotations,
3399 OutputArrayOfArrays translations,
3400 OutputArrayOfArrays normals);
3401
3420 CV_EXPORTS_W void filterHomographyDecompByVisibleRefpoints(InputArrayOfArrays rotations,
3421 InputArrayOfArrays normals,
3422 InputArray beforePoints,
3423 InputArray afterPoints,
3424 OutputArray possibleSolutions,
3425 InputArray pointsMask = noArray());
3426
3429 class CV_EXPORTS_W StereoMatcher : public Algorithm
3430{
3431 public:
3432 enum { DISP_SHIFT = 4,
3433 DISP_SCALE = (1 << DISP_SHIFT)
3434 };
3435
3444 CV_WRAP virtual void compute( InputArray left, InputArray right,
3445 OutputArray disparity ) = 0;
3446
3447 CV_WRAP virtual int getMinDisparity() const = 0;
3448 CV_WRAP virtual void setMinDisparity(int minDisparity) = 0;
3449
3450 CV_WRAP virtual int getNumDisparities() const = 0;
3451 CV_WRAP virtual void setNumDisparities(int numDisparities) = 0;
3452
3453 CV_WRAP virtual int getBlockSize() const = 0;
3454 CV_WRAP virtual void setBlockSize(int blockSize) = 0;
3455
3456 CV_WRAP virtual int getSpeckleWindowSize() const = 0;
3457 CV_WRAP virtual void setSpeckleWindowSize(int speckleWindowSize) = 0;
3458
3459 CV_WRAP virtual int getSpeckleRange() const = 0;
3460 CV_WRAP virtual void setSpeckleRange(int speckleRange) = 0;
3461
3462 CV_WRAP virtual int getDisp12MaxDiff() const = 0;
3463 CV_WRAP virtual void setDisp12MaxDiff(int disp12MaxDiff) = 0;
3464};
3465
3466
3470 class CV_EXPORTS_W StereoBM : public StereoMatcher
3471{
3472 public:
3473 enum { PREFILTER_NORMALIZED_RESPONSE = 0,
3474 PREFILTER_XSOBEL = 1
3475 };
3476
3477 CV_WRAP virtual int getPreFilterType() const = 0;
3478 CV_WRAP virtual void setPreFilterType(int preFilterType) = 0;
3479
3480 CV_WRAP virtual int getPreFilterSize() const = 0;
3481 CV_WRAP virtual void setPreFilterSize(int preFilterSize) = 0;
3482
3483 CV_WRAP virtual int getPreFilterCap() const = 0;
3484 CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
3485
3486 CV_WRAP virtual int getTextureThreshold() const = 0;
3487 CV_WRAP virtual void setTextureThreshold(int textureThreshold) = 0;
3488
3489 CV_WRAP virtual int getUniquenessRatio() const = 0;
3490 CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
3491
3492 CV_WRAP virtual int getSmallerBlockSize() const = 0;
3493 CV_WRAP virtual void setSmallerBlockSize(int blockSize) = 0;
3494
3495 CV_WRAP virtual Rect getROI1() const = 0;
3496 CV_WRAP virtual void setROI1(Rect roi1) = 0;
3497
3498 CV_WRAP virtual Rect getROI2() const = 0;
3499 CV_WRAP virtual void setROI2(Rect roi2) = 0;
3500
3514 CV_WRAP static Ptr<StereoBM> create(int numDisparities = 0, int blockSize = 21);
3515};
3516
3535 class CV_EXPORTS_W StereoSGBM : public StereoMatcher
3536{
3537 public:
3538 enum
3539 {
3540 MODE_SGBM = 0,
3541 MODE_HH = 1,
3542 MODE_SGBM_3WAY = 2,
3543 MODE_HH4 = 3
3544 };
3545
3546 CV_WRAP virtual int getPreFilterCap() const = 0;
3547 CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
3548
3549 CV_WRAP virtual int getUniquenessRatio() const = 0;
3550 CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
3551
3552 CV_WRAP virtual int getP1() const = 0;
3553 CV_WRAP virtual void setP1(int P1) = 0;
3554
3555 CV_WRAP virtual int getP2() const = 0;
3556 CV_WRAP virtual void setP2(int P2) = 0;
3557
3558 CV_WRAP virtual int getMode() const = 0;
3559 CV_WRAP virtual void setMode(int mode) = 0;
3560
3598 CV_WRAP static Ptr<StereoSGBM> create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3,
3599 int P1 = 0, int P2 = 0, int disp12MaxDiff = 0,
3600 int preFilterCap = 0, int uniquenessRatio = 0,
3601 int speckleWindowSize = 0, int speckleRange = 0,
3602 int mode = StereoSGBM::MODE_SGBM);
3603};
3604
3605
3607 enum UndistortTypes
3608{
3609 PROJ_SPHERICAL_ORTHO = 0,
3610 PROJ_SPHERICAL_EQRECT = 1
3611};
3612
3642 CV_EXPORTS_W void undistort( InputArray src, OutputArray dst,
3643 InputArray cameraMatrix,
3644 InputArray distCoeffs,
3645 InputArray newCameraMatrix = noArray() );
3646
3709CV_EXPORTS_W
3710 void initUndistortRectifyMap(InputArray cameraMatrix, InputArray distCoeffs,
3711 InputArray R, InputArray newCameraMatrix,
3712 Size size, int m1type, OutputArray map1, OutputArray map2);
3713
3780CV_EXPORTS_W
3781 void initInverseRectificationMap( InputArray cameraMatrix, InputArray distCoeffs,
3782 InputArray R, InputArray newCameraMatrix,
3783 const Size& size, int m1type, OutputArray map1, OutputArray map2 );
3784
3786CV_EXPORTS
3787 float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs,
3788 Size imageSize, int destImageWidth,
3789 int m1type, OutputArray map1, OutputArray map2,
3790 enum UndistortTypes projType = PROJ_SPHERICAL_EQRECT, double alpha = 0);
3791 static inline
3792 float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs,
3793 Size imageSize, int destImageWidth,
3794 int m1type, OutputArray map1, OutputArray map2,
3795 int projType, double alpha = 0)
3796{
3797 return initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth,
3798 m1type, map1, map2, (UndistortTypes)projType, alpha);
3799}
3800
3823CV_EXPORTS_W
3824 Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgsize = Size(),
3825 bool centerPrincipalPoint = false);
3826
3867CV_EXPORTS_W
3868 void undistortPoints(InputArray src, OutputArray dst,
3869 InputArray cameraMatrix, InputArray distCoeffs,
3870 InputArray R = noArray(), InputArray P = noArray());
3874 CV_EXPORTS_AS(undistortPointsIter)
3875 void undistortPoints(InputArray src, OutputArray dst,
3876 InputArray cameraMatrix, InputArray distCoeffs,
3877 InputArray R, InputArray P, TermCriteria criteria);
3878
3880
3884 namespace fisheye
3885{
3888
3889 enum{
3890 CALIB_USE_INTRINSIC_GUESS = 1 << 0,
3891 CALIB_RECOMPUTE_EXTRINSIC = 1 << 1,
3892 CALIB_CHECK_COND = 1 << 2,
3893 CALIB_FIX_SKEW = 1 << 3,
3894 CALIB_FIX_K1 = 1 << 4,
3895 CALIB_FIX_K2 = 1 << 5,
3896 CALIB_FIX_K3 = 1 << 6,
3897 CALIB_FIX_K4 = 1 << 7,
3898 CALIB_FIX_INTRINSIC = 1 << 8,
3899 CALIB_FIX_PRINCIPAL_POINT = 1 << 9,
3900 CALIB_ZERO_DISPARITY = 1 << 10,
3901 CALIB_FIX_FOCAL_LENGTH = 1 << 11
3902 };
3903
3924 CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
3925 InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
3926
3928 CV_EXPORTS_W void projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray rvec, InputArray tvec,
3929 InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
3930
3944 CV_EXPORTS_W void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha = 0);
3945
3957 CV_EXPORTS_W void undistortPoints(InputArray distorted, OutputArray undistorted,
3958 InputArray K, InputArray D, InputArray R = noArray(), InputArray P = noArray());
3959
3974 CV_EXPORTS_W void initUndistortRectifyMap(InputArray K, InputArray D, InputArray R, InputArray P,
3975 const cv::Size& size, int m1type, OutputArray map1, OutputArray map2);
3976
4005 CV_EXPORTS_W void undistortImage(InputArray distorted, OutputArray undistorted,
4006 InputArray K, InputArray D, InputArray Knew = cv::noArray(), const Size& new_size = Size());
4007
4021 CV_EXPORTS_W void estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,
4022 OutputArray P, double balance = 0.0, const Size& new_size = Size(), double fov_scale = 1.0);
4023
4059 CV_EXPORTS_W double calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
4060 InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags = 0,
4061 TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
4062
4093 CV_EXPORTS_W void stereoRectify(InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec,
4094 OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize = Size(),
4095 double balance = 0.0, double fov_scale = 1.0);
4096
4129 CV_EXPORTS_W double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
4130 InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
4131 OutputArray R, OutputArray T, int flags = fisheye::CALIB_FIX_INTRINSIC,
4132 TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
4133
4135} // end namespace fisheye
4136
4137} //end namespace cv
4138
4139 #if 0 //def __cplusplus
4141 class CV_EXPORTS CvLevMarq
4142{
4143 public:
4144 CvLevMarq();
4145 CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria=
4146 cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
4147 bool completeSymmFlag=false );
4148 ~CvLevMarq();
4149 void init( int nparams, int nerrs, CvTermCriteria criteria=
4150 cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
4151 bool completeSymmFlag=false );
4152 bool update( const CvMat*& param, CvMat*& J, CvMat*& err );
4153 bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm );
4154
4155 void clear();
4156 void step();
4157 enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 };
4158
4159 cv::Ptr<CvMat> mask;
4160 cv::Ptr<CvMat> prevParam;
4161 cv::Ptr<CvMat> param;
4162 cv::Ptr<CvMat> J;
4163 cv::Ptr<CvMat> err;
4164 cv::Ptr<CvMat> JtJ;
4165 cv::Ptr<CvMat> JtJN;
4166 cv::Ptr<CvMat> JtErr;
4167 cv::Ptr<CvMat> JtJV;
4168 cv::Ptr<CvMat> JtJW;
4169 double prevErrNorm, errNorm;
4170 int lambdaLg10;
4171 CvTermCriteria criteria;
4172 int state;
4173 int iters;
4174 bool completeSymmFlag;
4175 int solveMethod;
4176};
4177 #endif
4178
4179 #endif
cv::_InputOutputArray
Definition: mat.hpp:386
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::Algorithm
This is a base class for all more or less complex algorithms in OpenCV
Definition: core.hpp:3091
cv::LMSolver::Callback
Definition: calib3d.hpp:608
cv::LMSolver::Callback::compute
virtual bool compute(InputArray param, OutputArray err, OutputArray J) const =0
cv::LMSolver
Definition: calib3d.hpp:605
cv::LMSolver::getMaxIters
virtual int getMaxIters() const =0
cv::LMSolver::setMaxIters
virtual void setMaxIters(int maxIters)=0
cv::LMSolver::run
virtual int run(InputOutputArray param) const =0
cv::LMSolver::create
static Ptr< LMSolver > create(const Ptr< LMSolver::Callback > &cb, int maxIters)
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Point_
Template class for 2D points specified by its coordinates x and y.
Definition: core/types.hpp:158
cv::Rect_
Template class for 2D rectangles
Definition: core/types.hpp:421
cv::Scalar_< double >
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::StereoBM
Class for computing stereo correspondence using the block matching algorithm, introduced and contribu...
Definition: calib3d.hpp:3471
cv::StereoMatcher
The base class for stereo correspondence algorithms.
Definition: calib3d.hpp:3430
cv::StereoSGBM
The class implements the modified H. Hirschmuller algorithm that differs from the original one as fo...
Definition: calib3d.hpp:3536
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::TermCriteria::EPS
@ EPS
the desired accuracy or change in parameters at which the iterative algorithm stops
Definition: core/types.hpp:862
cv::TermCriteria::COUNT
@ COUNT
the maximum number of iterations or elements to compute
Definition: core/types.hpp:860
cv::Vec
Template class for short numerical vectors, a partial case of Matx
Definition: matx.hpp:342
cv::fisheye::calibrate
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 calibaration
cv::fisheye::distortPoints
CV_EXPORTS_W void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha=0)
Distorts 2D points using fisheye model.
cv::fisheye::undistortImage
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::fisheye::estimateNewCameraMatrixForUndistortRectify
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.
cv::solvePnPRefineVVS
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::find4QuadCornerSubpix
CV_EXPORTS_W bool find4QuadCornerSubpix(InputArray img, InputOutputArray corners, Size region_size)
finds subpixel-accurate positions of the chessboard corners
cv::findChessboardCorners
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.
cv::solvePnPGeneric
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. This function returns a list of all the possib...
cv::CV_EXPORTS_AS
CV_EXPORTS_AS(calibrateCameraExtended) double calibrateCamera(InputArrayOfArrays objectPoints
Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
cv::calibrateRobotWorldHandEye
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::estimateTranslation3D
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.
cv::validateDisparity
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...
cv::solveP3P
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::findEssentialMat
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.
cv::findFundamentalMat
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::SolvePnPMethod
SolvePnPMethod
Definition: calib3d.hpp:456
cv::calibrateCameraRO
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))
cv::filterHomographyDecompByVisibleRefpoints
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.
cv::matMulDeriv
CV_EXPORTS_W void matMulDeriv(InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
Computes partial derivatives of the matrix product for each multiplied matrix.
cv::convertPointsToHomogeneous
CV_EXPORTS_W void convertPointsToHomogeneous(InputArray src, OutputArray dst)
Converts points from Euclidean to homogeneous space.
cv::stereoRectifyUncalibrated
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.
cv::computeCorrespondEpilines
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::undistortPoints
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::triangulatePoints
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::projectPoints
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.
cv::calibrateCamera
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::recoverPose
CV_EXPORTS_W int recoverPose(InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, InputOutputArray mask=noArray())
Recovers the relative camera rotation and the translation from an estimated essential matrix and the ...
cv::initUndistortRectifyMap
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::initInverseRectificationMap
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::getOptimalNewCameraMatrix
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::Rodrigues
CV_EXPORTS_W void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray())
Converts a rotation matrix to a rotation vector or vice versa.
cv::filterSpeckles
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::convertPointsHomogeneous
CV_EXPORTS void convertPointsHomogeneous(InputArray src, OutputArray dst)
Converts points to/from homogeneous coordinates.
cv::initCameraMatrix2D
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.
cv::estimateAffinePartial2D
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...
cv::RobotWorldHandEyeCalibrationMethod
RobotWorldHandEyeCalibrationMethod
Definition: calib3d.hpp:540
cv::solvePnPRansac
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::findHomography
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::undistort
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::estimateChessboardSharpness
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::convertPointsFromHomogeneous
CV_EXPORTS_W void convertPointsFromHomogeneous(InputArray src, OutputArray dst)
Converts points from homogeneous to Euclidean space.
cv::decomposeHomographyMat
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).
cv::correctMatches
CV_EXPORTS_W void correctMatches(InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2)
Refines coordinates of corresponding points.
cv::estimateAffine3D
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.
cv::calibrationMatrixValues
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::initWideAngleProjMap
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::solvePnP
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. This function returns the rotation and the tra...
cv::solvePnPRefineLM
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::decomposeProjectionMatrix
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.
cv::RQDecomp3x3
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::getValidDisparityROI
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...
cv::UndistortTypes
UndistortTypes
cv::undistort mode
Definition: calib3d.hpp:3608
cv::HandEyeCalibrationMethod
HandEyeCalibrationMethod
Definition: calib3d.hpp:531
cv::estimateAffine2D
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::reprojectImageTo3D
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::drawFrameAxes
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.
cv::findChessboardCornersSB
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.
cv::decomposeEssentialMat
CV_EXPORTS_W void decomposeEssentialMat(InputArray E, OutputArray R1, OutputArray R2, OutputArray t)
Decompose an essential matrix to possible rotations and translation.
cv::rectify3Collinear
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::composeRT
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::calibrateHandEye
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::sampsonDistance
CV_EXPORTS_W double sampsonDistance(InputArray pt1, InputArray pt2, InputArray F)
Calculates the Sampson Distance between two points.
cv::stereoRectify
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::stereoCalibrate
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))
これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。
cv::getDefaultNewCameraMatrix
CV_EXPORTS_W Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
Returns the default new camera matrix.
cv::drawChessboardCorners
CV_EXPORTS_W void drawChessboardCorners(InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
Renders the detected chessboard corners.
cv::findCirclesGrid
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.
cv::SOLVEPNP_UPNP
@ SOLVEPNP_UPNP
Definition: calib3d.hpp:462
cv::SOLVEPNP_MAX_COUNT
@ SOLVEPNP_MAX_COUNT
Used for count
Definition: calib3d.hpp:476
cv::SOLVEPNP_AP3P
@ SOLVEPNP_AP3P
An Efficient Algebraic Solution to the Perspective-Three-Point Problem
Definition: calib3d.hpp:464
cv::SOLVEPNP_SQPNP
@ SOLVEPNP_SQPNP
SQPnP: A Consistently Fast and Globally OptimalSolution to the Perspective-n-Point Problem
Definition: calib3d.hpp:474
cv::SOLVEPNP_DLS
@ SOLVEPNP_DLS
Definition: calib3d.hpp:460
cv::SOLVEPNP_IPPE_SQUARE
@ SOLVEPNP_IPPE_SQUARE
Definition: calib3d.hpp:467
cv::SOLVEPNP_IPPE
@ SOLVEPNP_IPPE
Definition: calib3d.hpp:465
cv::SOLVEPNP_EPNP
@ SOLVEPNP_EPNP
EPnP: Efficient Perspective-n-Point Camera Pose Estimation
Definition: calib3d.hpp:458
cv::SOLVEPNP_P3P
@ SOLVEPNP_P3P
Complete Solution Classification for the Perspective-Three-Point Problem
Definition: calib3d.hpp:459
cv::CALIB_USE_LU
@ CALIB_USE_LU
use LU instead of SVD decomposition for solving. much faster but potentially less precise
Definition: calib3d.hpp:519
cv::CALIB_USE_QR
@ CALIB_USE_QR
use QR instead of SVD decomposition for solving. Faster but potentially less precise
Definition: calib3d.hpp:512
cv::CALIB_USE_EXTRINSIC_GUESS
@ CALIB_USE_EXTRINSIC_GUESS
for stereoCalibrate
Definition: calib3d.hpp:520
cv::CALIB_ROBOT_WORLD_HAND_EYE_SHAH
@ CALIB_ROBOT_WORLD_HAND_EYE_SHAH
Solving the robot-world/hand-eye calibration problem using the kronecker product
Definition: calib3d.hpp:541
cv::CALIB_ROBOT_WORLD_HAND_EYE_LI
@ CALIB_ROBOT_WORLD_HAND_EYE_LI
Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product
Definition: calib3d.hpp:542
cv::USAC_FM_8PTS
@ USAC_FM_8PTS
USAC, fundamental matrix 8 points
Definition: calib3d.hpp:449
cv::USAC_PROSAC
@ USAC_PROSAC
USAC, sorted points, runs PROSAC
Definition: calib3d.hpp:452
cv::USAC_MAGSAC
@ USAC_MAGSAC
USAC, runs MAGSAC++
Definition: calib3d.hpp:453
cv::USAC_DEFAULT
@ USAC_DEFAULT
USAC algorithm, default settings
Definition: calib3d.hpp:447
cv::RHO
@ RHO
RHO algorithm
Definition: calib3d.hpp:446
cv::RANSAC
@ RANSAC
RANSAC algorithm
Definition: calib3d.hpp:445
cv::USAC_ACCURATE
@ USAC_ACCURATE
USAC, accurate settings
Definition: calib3d.hpp:451
cv::USAC_PARALLEL
@ USAC_PARALLEL
USAC, parallel version
Definition: calib3d.hpp:448
cv::USAC_FAST
@ USAC_FAST
USAC, fast settings
Definition: calib3d.hpp:450
cv::LMEDS
@ LMEDS
least-median of squares algorithm
Definition: calib3d.hpp:444
cv::CALIB_HAND_EYE_TSAI
@ CALIB_HAND_EYE_TSAI
A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/Eye Calibration
Definition: calib3d.hpp:532
cv::CALIB_HAND_EYE_ANDREFF
@ CALIB_HAND_EYE_ANDREFF
On-line Hand-Eye Calibration
Definition: calib3d.hpp:535
cv::CALIB_HAND_EYE_PARK
@ CALIB_HAND_EYE_PARK
Robot Sensor Calibration: Solving AX = XB on the Euclidean Group
Definition: calib3d.hpp:533
cv::CALIB_HAND_EYE_HORAUD
@ CALIB_HAND_EYE_HORAUD
Hand-eye Calibration
Definition: calib3d.hpp:534
cv::CALIB_HAND_EYE_DANIILIDIS
@ CALIB_HAND_EYE_DANIILIDIS
Hand-Eye Calibration Using Dual Quaternions
Definition: calib3d.hpp:536
cv::FM_8POINT
@ FM_8POINT
8-point algorithm
Definition: calib3d.hpp:525
cv::FM_LMEDS
@ FM_LMEDS
least-median algorithm. 7-point algorithm is used.
Definition: calib3d.hpp:526
cv::FM_7POINT
@ FM_7POINT
7-point algorithm
Definition: calib3d.hpp:524
cv::FM_RANSAC
@ FM_RANSAC
RANSAC algorithm. It needs at least 15 points. 7-point algorithm is used.
Definition: calib3d.hpp:527
cv::threshold
CV_EXPORTS_W double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)
Applies a fixed-level threshold to each array element.
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
CvMat
Definition: core/types_c.h:469
CvTermCriteria
Definition: core/types_c.h:918
cv::CirclesGridFinderParameters
Definition: calib3d.hpp:1631
cv::Ptr
Definition: cvstd_wrapper.hpp:74
cv::UsacParams
Definition: calib3d.hpp:553
構築: doxygen 1.9.2