Camera Calibration and 3D Reconstruction

最新推荐文章于 2024-05-07 09:53:51 发布
最新推荐文章于 2024-05-07 09:53:51 发布
阅读量658 收藏
点赞数
文章标签： 3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t_t_t_t_/article/details/122147760
版权 
double cv::calibrateCamera (InputArrayOfArrays  objectPoints, 
                            InputArrayOfArrays  imagePoints, 
                            Size                imageSize, 
                            InputOutputArray    cameraMatrix, 
                            InputOutputArray    distCoeffs, 
                            OutputArrayOfArrays rvecs, 
                            OutputArrayOfArrays tvecs, 
                            OutputArray         stdDeviationsIntrinsics, 
                            OutputArray         stdDeviationsExtrinsics, 
                            OutputArray         perViewErrors, 
                            int                 flags=0, 
                            TermCriteria  criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30,DBL_EPSILON)
                            )

double cv::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) 
                            )	

double cv::calibrateCameraRO (InputArrayOfArrays 	objectPoints,
                              InputArrayOfArrays 	imagePoints,
                              Size 	                imageSize,
                              int 	                iFixedPoint,
                              InputOutputArray 	    cameraMatrix,
                              InputOutputArray 	    distCoeffs,
                              OutputArrayOfArrays 	rvecs,
                              OutputArrayOfArrays 	tvecs,
                              OutputArray 	        newObjPoints,
                              OutputArray 	        stdDeviationsIntrinsics,
                              OutputArray 	        stdDeviationsExtrinsics,
                              OutputArray 	        stdDeviationsObjPoints,
                              OutputArray 	        perViewErrors,
                              int 	                flags = 0,
                              TermCriteria 	 criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) 
                              )		

double cv::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) 
                              )	

void cv::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 
                          )	

void cv::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 
)

void cv::calibrationMatrixValues(InputArray 	cameraMatrix,
                                 Size 	        imageSize,
                                 double 	    apertureWidth,
                                 double 	    apertureHeight,
                                 double & 	    fovx,
                                 double & 	    fovy,
                                 double & 	    focalLength,
                                 Point2d & 	    principalPoint,
                                 double & 	    aspectRatio 
                                 )	

bool cv::checkChessboard (InputArray 	img,
                          Size    	    size 
                         )	

void cv::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() 
                  )	

void cv::computeCorrespondEpilines(InputArray 	points,
                                   int 	        whichImage,
                                   InputArray 	F,
                                   OutputArray 	lines 
                                  )

void cv::convertPointsFromHomogeneous(InputArray 	src,
                                      OutputArray 	dst 
                                      )		

void cv::convertPointsHomogeneous(InputArray 	src,
                                  OutputArray 	dst 
                                 )	

void cv::convertPointsToHomogeneous(InputArray 	 src,
                                    OutputArray  dst 
                                   )	

void cv::correctMatches(InputArray 	 F,
                        InputArray 	 points1,
                        InputArray 	 points2,
                        OutputArray  newPoints1,
                        OutputArray  newPoints2 
                        )	

void cv::decomposeEssentialMat(InputArray 	E,
                               OutputArray 	R1,
                               OutputArray 	R2,
                               OutputArray 	t 
                               )	

int cv::decomposeHomographyMat(InputArray 	        H,
                               InputArray 	        K,
                               OutputArrayOfArrays 	rotations,
                               OutputArrayOfArrays 	translations,
                               OutputArrayOfArrays 	normals 
                               )	

void cv::decomposeProjectionMatrix(InputArray 	projMatrix,
                                   OutputArray 	cameraMatrix,
                                   OutputArray 	rotMatrix,
                                   OutputArray 	transVect,
                                   OutputArray 	rotMatrixX = noArray(),
                                   OutputArray 	rotMatrixY = noArray(),
                                   OutputArray 	rotMatrixZ = noArray(),
                                   OutputArray 	eulerAngles = noArray() 
                                   )	

void cv::drawChessboardCorners(InputOutputArray 	image,
                               Size 	            patternSize,
                               InputArray 	        corners,
                               bool 	            patternWasFound 
                              )	

void cv::drawFrameAxes(InputOutputArray 	image,
                       InputArray 	        cameraMatrix,
                       InputArray 	        distCoeffs,
                       InputArray 	        rvec,
                       InputArray 	        tvec,
                       float 	            length,
                       int 	                thickness = 3 
                       )	

cv::Mat cv::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 
                             )	

cv::Mat cv::estimateAffine2D(InputArray 	pts1,
                             InputArray 	pts2,
                             OutputArray 	inliers,
                             const UsacParams & 	params 
                             )	

int cv::estimateAffine3D(InputArray 	src,
                         InputArray 	dst,
                         OutputArray 	out,
                         OutputArray 	inliers,
                         double 	    ransacThreshold = 3,
                         double 	    confidence = 0.99 
                         )	


cv::Mat cv::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 
                                    )


Scalar cv::estimateChessboardSharpness(InputArray 	image,
                                       Size     	patternSize,
                                       InputArray 	corners,
                                       float 	    rise_distance = 0.8F,
                                       bool 	    vertical = false,
                                       OutputArray 	sharpness = noArray() 
                                       )	

int cv::estimateTranslation3D(InputArray 	src,
                              InputArray 	dst,
                              OutputArray 	out,
                              OutputArray 	inliers,
                              double 	    ransacThreshold = 3,
                              double 	    confidence = 0.99 
                              )	

void cv::filterHomographyDecompByVisibleRefpoints(InputArrayOfArrays 	rotations,
                                                  InputArrayOfArrays 	normals,
                                                  InputArray 	beforePoints,
                                                  InputArray 	afterPoints,
                                                  OutputArray 	possibleSolutions,
                                                  InputArray 	pointsMask = noArray() 
                                                 )	

void cv::filterSpeckles(InputOutputArray 	img,
                        double          	newVal,
                        int             	maxSpeckleSize,
                        double          	maxDiff,
                        InputOutputArray 	buf = noArray() 
                        )	


bool cv::find4QuadCornerSubpix(InputArray       	img,
                               InputOutputArray 	corners,
                               Size 	            region_size 
                               )	

bool cv::findChessboardCorners(InputArray 	image,
                               Size     	patternSize,
                               OutputArray 	corners,
                               int 	        flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE 
                               )	

bool cv::findChessboardCornersSB(InputArray 	image,
                                 Size 	        patternSize,
                                 OutputArray 	corners,
                                 int 	        flags,
                                 OutputArray 	meta 
                                 )	

bool cv::findChessboardCornersSB(InputArray 	image,
                                 Size       	patternSize,
                                 OutputArray 	corners,
                                 int 	        flags = 0 
                                 )	

bool cv::findCirclesGrid(InputArray 	image,
                         Size       	patternSize,
                         OutputArray 	centers,
                         int 	        flags,
                         const Ptr<FeatureDetector> & 	        blobDetector,
                         const CirclesGridFinderParameters & 	parameters 
                        )	

bool cv::findCirclesGrid(InputArray 	image,
                         Size 	        patternSize,
                         OutputArray 	centers,
                         int 	        flags = CALIB_CB_SYMMETRIC_GRID,
                         const Ptr<FeatureDetector>& 	blobDetector = SimpleBlobDetector::create() 
)	

Mat cv::findEssentialMat(InputArray 	points1,
                         InputArray 	points2,
                         InputArray 	cameraMatrix,
                         int 	        method = RANSAC,
                         double 	    prob = 0.999,
                         double 	    threshold = 1.0,
                         OutputArray 	mask = noArray() 
                         )


Mat cv::findEssentialMat(InputArray 	points1,
                         InputArray 	points2,
                         double 	    focal = 1.0,
                         Point2d    	pp = Point2d(0, 0),
                         int 	        method = RANSAC,
                         double 	    prob = 0.999,
                         double 	    threshold = 1.0,
                         OutputArray 	mask = noArray() 
                          )	


Mat cv::findEssentialMat(InputArray 	points1,
                         InputArray 	points2,
                         InputArray 	cameraMatrix1,
                         InputArray 	distCoeffs1,
                         InputArray 	cameraMatrix2,
                         InputArray 	distCoeffs2,
                         int 	        method = RANSAC,
                         double 	    prob = 0.999,
                         double 	    threshold = 1.0,
                         OutputArray 	mask = noArray() 
                        )	


Mat cv::findEssentialMat(InputArray 	points1,
                         InputArray 	points2,
                         InputArray 	cameraMatrix1,
                         InputArray 	cameraMatrix2,
                         InputArray 	dist_coeff1,
                         InputArray 	dist_coeff2,
                         OutputArray 	mask,
                         const UsacParams & 	params 
                         )

Mat cv::findFundamentalMat(InputArray 	points1,
                           InputArray 	points2,
                           int 	        method,
                           double 	    ransacReprojThreshold,
                           double 	    confidence,
                           int 	        maxIters,
                           OutputArray 	mask = noArray() 
                          )	

Mat cv::findFundamentalMat(InputArray 	points1,
                           InputArray 	points2,
                           int          method = FM_RANSAC,
                           double 	    ransacReprojThreshold = 3.,
                           double 	    confidence = 0.99,
                           OutputArray 	mask = noArray() 
                           )	


Mat cv::findFundamentalMat(InputArray 	points1,
                           InputArray 	points2,
                           OutputArray 	mask,
                           int      	method = FM_RANSAC,
                           double 	    ransacReprojThreshold = 3.,
                           double 	    confidence = 0.99 
                           )

Mat cv::findFundamentalMat(InputArray 	points1,
                           InputArray 	points2,
                           OutputArray 	mask,
                           const UsacParams & 	params 
                           )


Mat cv::findHomography(InputArray 	srcPoints,
                       InputArray 	dstPoints,
                       int 	        method = 0,
                       double 	    ransacReprojThreshold = 3,
                       OutputArray 	mask = noArray(),
                       const int 	maxIters = 2000,
                       const double 	confidence = 0.995 
                       )	

Mat cv::findHomography(InputArray 	srcPoints,
                       InputArray 	dstPoints,
                       OutputArray 	mask,
                       int 	        method = 0,
                       double 	    ransacReprojThreshold = 3 
                       )	


Mat cv::findHomography(InputArray 	srcPoints,
                       InputArray 	dstPoints,
                       OutputArray 	mask,
                       const UsacParams & 	params 
                       )	

Mat cv::getDefaultNewCameraMatrix(InputArray 	cameraMatrix,
                                  Size 	        imgsize = Size(),
                                  bool 	        centerPrincipalPoint = false 
                                  )	

Mat cv::getOptimalNewCameraMatrix(InputArray 	cameraMatrix,
                                  InputArray 	distCoeffs,
                                  Size 	        imageSize,
                                  double 	    alpha,
                                  Size 	        newImgSize = Size(),
                                  Rect * 	    validPixROI = 0,
                                  bool 	        centerPrincipalPoint = false 
                                  )	

Rect cv::getValidDisparityROI(Rect 	roi1,
                              Rect 	roi2,
                              int 	minDisparity,
                              int 	numberOfDisparities,
                              int 	blockSize 
                              )


Mat cv::initCameraMatrix2D(InputArrayOfArrays 	objectPoints,
                           InputArrayOfArrays 	imagePoints,
                           Size 	            imageSize,
                           double 	            aspectRatio = 1.0 
)

void cv::initUndistortRectifyMap(InputArray 	cameraMatrix,
                                 InputArray 	distCoeffs,
                                 InputArray 	R,
                                 InputArray 	newCameraMatrix,
                                 Size 	        size,
                                 int 	        m1type,
                                 OutputArray 	map1,
                                 OutputArray 	map2 
                                 )	

float cv::initWideAngleProjMap(InputArray 	cameraMatrix,
                               InputArray 	distCoeffs,
                               Size 	    imageSize,
                               int 	        destImageWidth,
                               int 	        m1type,
                               OutputArray 	map1,
                               OutputArray 	map2,
               enum UndistortTypes 	projType = PROJ_SPHERICAL_EQRECT,
                               double 	alpha = 0 
)	

static float cv::initWideAngleProjMap(InputArray 	cameraMatrix,
                                      InputArray 	distCoeffs,
                                      Size      	imageSize,
                                      int 	        destImageWidth,
                                      int 	        m1type,
                                      OutputArray 	map1,
                                      OutputArray 	map2,
                                      int 	        projType,
                                      double 	    alpha = 0 
                                     )	

void cv::matMulDeriv(InputArray 	A,
                     InputArray 	B,
                     OutputArray 	dABdA,
                     OutputArray 	dABdB 
                    )	


void cv::projectPoints(InputArray 	objectPoints,
                       InputArray 	rvec,
                       InputArray 	tvec,
                       InputArray 	cameraMatrix,
                       InputArray 	distCoeffs,
                       OutputArray 	imagePoints,
                       OutputArray 	jacobian = noArray(),
                       double 	    aspectRatio = 0 
)	

int cv::recoverPose(InputArray 	E,
                    InputArray 	points1,
                    InputArray 	points2,
                    InputArray 	cameraMatrix,
                    OutputArray 	R,
                    OutputArray 	t,
                    InputOutputArray 	mask = noArray() 
)	


int cv::recoverPose(InputArray 	E,
                    InputArray 	points1,
                    InputArray 	points2,
                    OutputArray 	R,
                    OutputArray 	t,
                    double 	focal = 1.0,
                    Point2d  pp = Point2d(0, 0),
                    InputOutputArray 	mask = noArray() 
                    )	

int cv::recoverPose(InputArray 	E,
                    InputArray 	points1,
                    InputArray 	points2,
                    InputArray 	cameraMatrix,
                    OutputArray 	R,
                    OutputArray 	t,
                    double 	distanceThresh,
                    InputOutputArray 	mask = noArray(),
                    OutputArray 	triangulatedPoints = noArray() 
                    )	

float cv::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,
                            Rect * 	        roi1,
                            Rect * 	        roi2,
                            int   	        flags 
                           )		

void cv::reprojectImageTo3D(InputArray  	disparity,
                            OutputArray 	_3dImage,
                            InputArray  	Q,
                            bool 	        handleMissingValues = false,
                            int 	        ddepth = -1 
                           )		

void cv::Rodrigues(InputArray 	src,
                   OutputArray 	dst,
                   OutputArray 	jacobian = noArray() 
                   )	

Vec3d cv::RQDecomp3x3(InputArray 	src,
                      OutputArray 	mtxR,
                      OutputArray 	mtxQ,
                      OutputArray 	Qx = noArray(),
                      OutputArray 	Qy = noArray(),
                      OutputArray 	Qz = noArray() 
)	

double cv::sampsonDistance(InputArray 	pt1,
                           InputArray 	pt2,
                           InputArray 	F 
                           )	

int cv::solveP3P(InputArray 	objectPoints,
                 InputArray 	imagePoints,
                 InputArray 	cameraMatrix,
                 InputArray 	distCoeffs,
                 OutputArrayOfArrays 	rvecs,
                 OutputArrayOfArrays 	tvecs,
                 int 	        flags 
                 )	

bool cv::solvePnP(InputArray 	objectPoints,
                  InputArray 	imagePoints,
                  InputArray 	cameraMatrix,
                  InputArray 	distCoeffs,
                  OutputArray 	rvec,
                  OutputArray 	tvec,
                  bool 	        useExtrinsicGuess = false,
                  int 	        flags = SOLVEPNP_ITERATIVE 
                  )

int cv::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() 
                        )	

bool cv::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 
                        )		

bool cv::solvePnPRansac(InputArray 	objectPoints,
                        InputArray 	imagePoints,
                        InputOutputArray 	cameraMatrix,
                        InputArray 	distCoeffs,
                        OutputArray 	rvec,
                        OutputArray 	tvec,
                        OutputArray 	inliers,
                        const UsacParams & 	params = UsacParams() 
                        )	

void cv::solvePnPRefineLM(InputArray 	objectPoints,
                          InputArray 	imagePoints,
                          InputArray 	cameraMatrix,
                          InputArray 	distCoeffs,
                          InputOutputArray 	rvec,
                          InputOutputArray 	tvec,
                          TermCriteria 	criteria = TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON) 
                          )	


void cv::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 
)	


double cv::stereoCalibrate(InputArrayOfArrays 	objectPoints,
                           InputArrayOfArrays 	imagePoints1,
                           InputArrayOfArrays 	imagePoints2,
                           InputOutputArray 	cameraMatrix1,
                           InputOutputArray 	distCoeffs1,
                           InputOutputArray 	cameraMatrix2,
                           InputOutputArray 	distCoeffs2,
                           Size 	            imageSize,
                           InputOutputArray 	R,
                           InputOutputArray 	T,
                           OutputArray      	E,
                           OutputArray      	F,
                           OutputArray      	perViewErrors,
                           int  flags = CALIB_FIX_INTRINSIC,
                           TermCriteria 	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) 
)	

double cv::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) 
)	

void cv::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(),
                       Rect * 	validPixROI1 = 0,
                       Rect * 	validPixROI2 = 0 
                      )	

bool cv::stereoRectifyUncalibrated(InputArray 	points1,
                                   InputArray 	points2,
                                   InputArray 	F,
                                   Size 	imgSize,
                                   OutputArray 	H1,
                                   OutputArray 	H2,
                                   double 	threshold = 5 
                                   )	

void cv::triangulatePoints(InputArray 	projMatr1,
                           InputArray 	projMatr2,
                           InputArray 	projPoints1,
                           InputArray 	projPoints2,
                          OutputArray 	points4D 
                           )	

void cv::undistort(InputArray 	src,
                   OutputArray 	dst,
                   InputArray 	cameraMatrix,
                   InputArray 	distCoeffs,
                   InputArray 	newCameraMatrix = noArray() 
                   )	

void cv::undistortPoints(InputArray 	src,
                         OutputArray 	dst,
                         InputArray 	cameraMatrix,
                         InputArray 	distCoeffs,
                         InputArray 	R = noArray(),
                         InputArray 	P = noArray() 
                         )	

void cv::undistortPoints(InputArray 	src,
                         OutputArray 	dst,
                         InputArray 	cameraMatrix,
                         InputArray 	distCoeffs,
                         InputArray 	R,
                         InputArray 	P,
                         TermCriteria 	criteria 
                        )


void cv::validateDisparity(InputOutputArray 	disparity,
                           InputArray 	cost,
                           int 	minDisparity,
                           int 	numberOfDisparities,
                           int 	disp12MaxDisp = 1 
                           )
凶萌的小老虎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
3D Calibration
09-29
We studied the topic of depth sensing camera calibration. Two devices Microsoft Kinect and Swissranger SR-4000, that work on different physical principles, were investigated. Both 3D cameras were described and subjected to experiments in order to evaluate their performance. Several systematic error sources were identified and we proposed methods to compensate for them. A comparison of reconstruction performance of both 3D cameras and a stereo-pair of conventional cameras was presented. Finally, we showed an application of the depth sensing camera together with conventional color camera in area of complex scene reconstruction.
python 手眼标定OpenCV手眼标定（calibrateHandeye()）一
weixin_43134049的博客
02-09 1万+
以下代码来源 本篇博客通过该代码，附上记录的公式与查找连接，方面以后调用能弄懂各个参数的意思 1.参数说明 calibrateHandeye() 参数描述如下：R_gripper2base，t_gripper2base是机械臂抓手相对于机器人基坐标系的旋转矩阵与平移向量，需要通过机器人运动控制器或示教器读取相关参数转换计算得到；R_target2cam ， t_target2cam 是标定板相对于双目相机的齐次矩阵，在进行相机标定时可以求取得到（calibrateCamera()得到）, 也可以通过sol
3D Computer Vision : Efficient Methods and Applications
04-23
This book provides an introduction to the foundations of three-dimensional computer vision and describes recent contributions to the field. Geometric methods include linear and bundle adjustment based approaches to scene reconstruction and camera calibration, stereo vision, point cloud segmentation, and pose estimation of rigid, articulated, and flexible objects. Photometric techniques evaluate the intensity distribution in the image to infer three-dimensional scene structure, while real-aperture approaches exploit the behavior of the point spread function. It is shown how the integration of several methods increases reconstruction accuracy and robustness. Applications scenarios include industrial quality inspection, metrology, human-robot-interaction, and remote sensing.
OPENCV函数学习手册.pdf
01-12
OPENCV函数学习手册.pdf ，方便童鞋们了解opencv库函数的使用方法。 包含很全面的函数用法介绍：图像基本处理函数、结构分析、运动分析和对象跟踪、模式识别、照相机标定和三维重建等。
3D with kinect
01-12
We analyze Kinect as a 3D measuring device, experimentally investigate depth measurement resolution and error properties, and make a quantitative comparison of Kinect accuracy with stereo reconstruction from SLR cameras and a 3D-TOF camera. We propose a Kinect geometrical model and its calibration procedure providing an accurate calibration of Kinect 3D measurement and Kinect cameras. We compare our Kinect calibration procedure with its alternatives available on Internet, and integrate it into an SfM pipeline where 3D measurements from a moving Kinect are transformed into a common coordinate system, by computing relative poses from matches in its color camera.
opencv的标定函数
alay_sjl的博客
06-13 188
问了一下同事，解答说一个名字长的那个求解AX=ZB ，相机与机器人，标定板与法兰盘工具坐标的关系一并求解。google了一下“difference opencv calibrateRobotWorldHandEye calibrateHandEye” 只有提问 没有回答，问了一下chatGPT 返回的还是一如既往的流水账。然后这篇文章说的还挺好的记录一下 https://blog.csdn.net/AAAA202012/article/details/125117458。
【6月第一周学习记录】UU-Computer vision(1)：3D reconstruction&Camera calibration
”好的程序员不应该花大量时间在程序调试上，bug从一开始就不该被引入“
06-07 203
世界坐标系→相机坐标系：把物体的世界坐标系先旋转，与相机坐标系对齐，然后平移首先，绕X轴旋转：X不变注意：要变换某个坐标系，都是用变换矩阵对其进行左乘这就是相机的外参数（Extrinsics）：*把加号融入进变换矩阵的行为，就是转化为了齐次幻灯片来源：PP_AI的个人空间_哔哩哔哩_Bilibili ，感谢老师......
关于opencv(C++)中decomposeHomographyMat()与filterHomographyDecompByVisibleRefpoints()的使用
weixin_43955005的博客
08-07 3229
针对问题：需要通过单应矩阵H（homography）分解出相机的R和t。当然，在opencv的C++版本中封装有实现这个功能的函数（然而在其js版本中就去掉了，不知道为什么…）。但是，在opencv的官方文档中，函数的接口（输入输出参数）的参数类型全是清一色的Array或者ArrayOfArray。然而，opencv中Array的类型千千万，你如果用错了，他还会给你报错“内存X…… 出现错误”。本文将展示我摸索出的可行参数类型。...
摄像机标定和几何重构Camera Calibration and Reconstruction of Geometry from Images
03-24
一本详细介绍计算机视觉中的摄像机标定和几何重构的英文书籍。Camera Calibration and Reconstruction of Geometry from Images。
Single-camera active stereo vision system using fiber bundles
02-05
We propose an approach for realizing 3D reconstruction in small field of view or some extreme environments. We combine the stereo vision and the structured light technologies and change the traditional ways of ap-plying them by employing two fiber bundles. The processes of calibration and 3D reconstruction are also introduced. Experiments are performed to verify the feasibility and effectiveness of our proposed approach.
solvepnp详解
热门推荐
flyyufenfei的博客
04-22 5万+
转载自：http://blog.csdn.net/aptx704610875/article/details/48915149 注意点1：solvePnP里有三种解法：P3P， EPnP，迭代法（默认）；opencv2里参数分别为CV_P3P，CV_EPNP，CV_ITERATIVE （opencv3里多了DLS和UPnP解法）。 注意点2：solvePnP需要至少3组点：
python中GPU版本的opencv常用方法介绍
submarineas的博客
07-21 1万+
引言 本篇是以python的视角介绍相关的函数还有自我使用中的一些问题，本想在这篇之前总结一下opencv编译的全过程，但遇到了太多坑，暂时不太想回看做过的笔记，所以主要总结python下GPU版本的opencv。 bitwise_and() bitwise_not() bitwise_or() bitwise_xor() compare() divide()：除 exp() log() max() min() multiply() threshold()：二值化，但要指定设定阈值 blendLinea
opencv-python 4.2 函数手册
qq_47232518的博客
01-09 3741
opencv-python 4.2 函数手册欢迎使用Markdown编辑器 欢迎使用Markdown编辑器 cv2.absdiff() cv2.accumulate() cv2.accumulateProduct() cv2.accumulateSquare() cv2.accumulateWeighted() cv2.adaptiveThreshold() # 图像自适应局部二值化 cv2.add() # 两个图像相加 cv2.addText() # 添加文字 cv2.addWeighted()
Camera Calibration and 3D Reconstruction(opencv 2.4)
凌风探梅的专栏
12-21 4295
Camera Calibration and 3D Reconstruction¶ The functions in this section use a so-called pinhole camera model. In this model, a scene view is formed by projecting 3D points into the image plane using
雷达和RGB相机对齐的核心代码crop
baidu_40840693的博客
03-01 734
代码来源： https://github.com/agarwa65/lidar_camera_calibration 最核心的只是把校准函数calibrate的核心crop，去理解整个过程，其实和 结构光相机与RGB相机对齐，没有区别 import numpy import math #from tf.transformations import euler_from_matrix #原函数 # axis sequences for Euler angles _NEXT_AXIS = [1, .
【MachineVision】Hand-Eye-Calibration
zhy29563
07-23 2011
1. 眼在手上 标定过程 标定板放置在固定位置，机器人变换不同的姿态，相机获取不同姿态下的标定板图像 目标 上图中描述了闭环的坐标系空间关系，包含以下部分： baseHtool^{base}H_{tool}baseHtool​​​​​​ 机器人末端的工具坐标系到机器人基坐标系的变换矩阵​。 可变量 camHtool^{cam}H_{tool}camHtool​ 机器人末端的工具坐标系到相机坐标系的变换矩阵。 不变量 camHcal^{cam}H_{cal}camHcal​​​​​​ 标定板坐标系到
什么是web3D？应用场景有哪些？如何实现web3D展示？
最新发布
mirrornan的博客
05-07 660
​ 要实现Web3D展示，只需要通过51建模网即可实现，平台基于强大的WebGL 3D可视化引擎核心技术，可以通过在网页中嵌入html代码实现，不借助任何插件，即可在PC端、移动端实现3D产品720°立体化旋转缩放展示。
camera calibration
03-16
相机标定是一种使相机在三维空间中的位置和姿态与其预期位置和姿态保持一致的过程。这通常是通过测量相机与特定模型或标准物体的位置关系来完成的。标定的结果可用于提高图像处理算法的性能，并为机器人和自动控制系统提供精确的位置和姿态信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值