c54b8f9b00
* 'master' of github.com:itseez/opencv: (82 commits)
moved part of video to contrib/{outflow, bgsegm}; moved matlab to contrib
added some basic functionality needed by the new face module (moved from the old "contrib")
moved to the new opencv_contrib/face module
fixed various warnings and obvious errors reported by clang compiler and the coverity tool.
Fixed review comment from Vadim Pisarevsky
modified farneback sample to use T-API
ECC patch by the author (G. Evangelidis); fixed some OCL Farneback optical flow test failures on Mac
small fix for GaussianBlur ocl test
fix binary package build
small fix for ocl_resize
fix IOS framework
fixed test ocl_MatchTemplate for sparse matrix
Fixed typos
fixing error, wrong template method param.
fixing Mac build
some formal changes (generally adding constness)
Fixed choice of kercn and rowsPerWI for non-Intel device.
fixed nDiffs for CalcBackProject
fixed tests for ocl_filter2d, ocl_matchTemplate, ocl_histogram.cpp
Fixed issue: Mat::copyTo(UMat) if device copy is obsolete. Added test.
...
Conflicts:
modules/core/include/opencv2/core/mat.inl.hpp
483 lines
25 KiB
C++
483 lines
25 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
|
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
|
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
#ifndef __OPENCV_CALIB3D_HPP__
|
|
#define __OPENCV_CALIB3D_HPP__
|
|
|
|
#include "opencv2/core.hpp"
|
|
#include "opencv2/features2d.hpp"
|
|
#include "opencv2/core/affine.hpp"
|
|
|
|
namespace cv
|
|
{
|
|
|
|
//! type of the robust estimation algorithm
|
|
enum { LMEDS = 4, //!< least-median algorithm
|
|
RANSAC = 8 //!< RANSAC algorithm
|
|
};
|
|
|
|
enum { ITERATIVE = 0,
|
|
EPNP = 1, // F.Moreno-Noguer, V.Lepetit and P.Fua "EPnP: Efficient Perspective-n-Point Camera Pose Estimation"
|
|
P3P = 2 // X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang; "Complete Solution Classification for the Perspective-Three-Point Problem"
|
|
};
|
|
|
|
enum { CALIB_CB_ADAPTIVE_THRESH = 1,
|
|
CALIB_CB_NORMALIZE_IMAGE = 2,
|
|
CALIB_CB_FILTER_QUADS = 4,
|
|
CALIB_CB_FAST_CHECK = 8
|
|
};
|
|
|
|
enum { CALIB_CB_SYMMETRIC_GRID = 1,
|
|
CALIB_CB_ASYMMETRIC_GRID = 2,
|
|
CALIB_CB_CLUSTERING = 4
|
|
};
|
|
|
|
enum { CALIB_USE_INTRINSIC_GUESS = 0x00001,
|
|
CALIB_FIX_ASPECT_RATIO = 0x00002,
|
|
CALIB_FIX_PRINCIPAL_POINT = 0x00004,
|
|
CALIB_ZERO_TANGENT_DIST = 0x00008,
|
|
CALIB_FIX_FOCAL_LENGTH = 0x00010,
|
|
CALIB_FIX_K1 = 0x00020,
|
|
CALIB_FIX_K2 = 0x00040,
|
|
CALIB_FIX_K3 = 0x00080,
|
|
CALIB_FIX_K4 = 0x00800,
|
|
CALIB_FIX_K5 = 0x01000,
|
|
CALIB_FIX_K6 = 0x02000,
|
|
CALIB_RATIONAL_MODEL = 0x04000,
|
|
CALIB_THIN_PRISM_MODEL = 0x08000,
|
|
CALIB_FIX_S1_S2_S3_S4 = 0x10000,
|
|
// only for stereo
|
|
CALIB_FIX_INTRINSIC = 0x00100,
|
|
CALIB_SAME_FOCAL_LENGTH = 0x00200,
|
|
// for stereo rectification
|
|
CALIB_ZERO_DISPARITY = 0x00400
|
|
};
|
|
|
|
//! the algorithm for finding fundamental matrix
|
|
enum { FM_7POINT = 1, //!< 7-point algorithm
|
|
FM_8POINT = 2, //!< 8-point algorithm
|
|
FM_LMEDS = 4, //!< least-median algorithm
|
|
FM_RANSAC = 8 //!< RANSAC algorithm
|
|
};
|
|
|
|
|
|
|
|
//! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
|
|
CV_EXPORTS_W void Rodrigues( InputArray src, OutputArray dst, OutputArray jacobian = noArray() );
|
|
|
|
//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
|
|
CV_EXPORTS_W Mat findHomography( InputArray srcPoints, InputArray dstPoints,
|
|
int method = 0, double ransacReprojThreshold = 3,
|
|
OutputArray mask=noArray());
|
|
|
|
//! variant of findHomography for backward compatibility
|
|
CV_EXPORTS Mat findHomography( InputArray srcPoints, InputArray dstPoints,
|
|
OutputArray mask, int method = 0, double ransacReprojThreshold = 3 );
|
|
|
|
//! Computes RQ decomposition of 3x3 matrix
|
|
CV_EXPORTS_W Vec3d RQDecomp3x3( InputArray src, OutputArray mtxR, OutputArray mtxQ,
|
|
OutputArray Qx = noArray(),
|
|
OutputArray Qy = noArray(),
|
|
OutputArray Qz = noArray());
|
|
|
|
//! Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
|
|
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() );
|
|
|
|
//! computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
|
|
CV_EXPORTS_W void matMulDeriv( InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB );
|
|
|
|
//! composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
|
|
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() );
|
|
|
|
//! projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters
|
|
CV_EXPORTS_W void projectPoints( InputArray objectPoints,
|
|
InputArray rvec, InputArray tvec,
|
|
InputArray cameraMatrix, InputArray distCoeffs,
|
|
OutputArray imagePoints,
|
|
OutputArray jacobian = noArray(),
|
|
double aspectRatio = 0 );
|
|
|
|
//! computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.
|
|
CV_EXPORTS_W bool solvePnP( InputArray objectPoints, InputArray imagePoints,
|
|
InputArray cameraMatrix, InputArray distCoeffs,
|
|
OutputArray rvec, OutputArray tvec,
|
|
bool useExtrinsicGuess = false, int flags = ITERATIVE );
|
|
|
|
//! computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
|
|
CV_EXPORTS_W void solvePnPRansac( InputArray objectPoints, InputArray imagePoints,
|
|
InputArray cameraMatrix, InputArray distCoeffs,
|
|
OutputArray rvec, OutputArray tvec,
|
|
bool useExtrinsicGuess = false, int iterationsCount = 100,
|
|
float reprojectionError = 8.0, int minInliersCount = 100,
|
|
OutputArray inliers = noArray(), int flags = ITERATIVE );
|
|
|
|
//! initializes camera matrix from a few 3D points and the corresponding projections.
|
|
CV_EXPORTS_W Mat initCameraMatrix2D( InputArrayOfArrays objectPoints,
|
|
InputArrayOfArrays imagePoints,
|
|
Size imageSize, double aspectRatio = 1.0 );
|
|
|
|
//! finds checkerboard pattern of the specified size in the image
|
|
CV_EXPORTS_W bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners,
|
|
int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE );
|
|
|
|
//! finds subpixel-accurate positions of the chessboard corners
|
|
CV_EXPORTS bool find4QuadCornerSubpix( InputArray img, InputOutputArray corners, Size region_size );
|
|
|
|
//! draws the checkerboard pattern (found or partly found) in the image
|
|
CV_EXPORTS_W void drawChessboardCorners( InputOutputArray image, Size patternSize,
|
|
InputArray corners, bool patternWasFound );
|
|
|
|
//! finds circles' grid pattern of the specified size in the image
|
|
CV_EXPORTS_W bool findCirclesGrid( InputArray image, Size patternSize,
|
|
OutputArray centers, int flags = CALIB_CB_SYMMETRIC_GRID,
|
|
const Ptr<FeatureDetector> &blobDetector = makePtr<SimpleBlobDetector>());
|
|
|
|
//! finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
|
|
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) );
|
|
|
|
//! computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
|
|
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 );
|
|
|
|
//! finds intrinsic and extrinsic parameters of a stereo camera
|
|
CV_EXPORTS_W double stereoCalibrate( InputArrayOfArrays objectPoints,
|
|
InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
|
|
InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1,
|
|
InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2,
|
|
Size imageSize, OutputArray R,OutputArray T, OutputArray E, OutputArray F,
|
|
int flags = CALIB_FIX_INTRINSIC,
|
|
TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) );
|
|
|
|
|
|
//! computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
|
|
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 the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
|
|
CV_EXPORTS_W bool stereoRectifyUncalibrated( InputArray points1, InputArray points2,
|
|
InputArray F, Size imgSize,
|
|
OutputArray H1, OutputArray H2,
|
|
double threshold = 5 );
|
|
|
|
//! computes the rectification transformations for 3-head camera, where all the heads are on the same line.
|
|
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 );
|
|
|
|
//! returns the optimal new camera matrix
|
|
CV_EXPORTS_W Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs,
|
|
Size imageSize, double alpha, Size newImgSize = Size(),
|
|
CV_OUT Rect* validPixROI = 0,
|
|
bool centerPrincipalPoint = false);
|
|
|
|
//! converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
|
|
CV_EXPORTS_W void convertPointsToHomogeneous( InputArray src, OutputArray dst );
|
|
|
|
//! converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
|
|
CV_EXPORTS_W void convertPointsFromHomogeneous( InputArray src, OutputArray dst );
|
|
|
|
//! for backward compatibility
|
|
CV_EXPORTS void convertPointsHomogeneous( InputArray src, OutputArray dst );
|
|
|
|
//! finds fundamental matrix from a set of corresponding 2D points
|
|
CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2,
|
|
int method = FM_RANSAC,
|
|
double param1 = 3., double param2 = 0.99,
|
|
OutputArray mask = noArray() );
|
|
|
|
//! variant of findFundamentalMat for backward compatibility
|
|
CV_EXPORTS Mat findFundamentalMat( InputArray points1, InputArray points2,
|
|
OutputArray mask, int method = FM_RANSAC,
|
|
double param1 = 3., double param2 = 0.99 );
|
|
|
|
//! finds essential matrix from a set of corresponding 2D points using five-point algorithm
|
|
CV_EXPORTS_W Mat 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() );
|
|
|
|
//! decompose essential matrix to possible rotation matrix and one translation vector
|
|
CV_EXPORTS_W void decomposeEssentialMat( InputArray E, OutputArray R1, OutputArray R2, OutputArray t );
|
|
|
|
//! recover relative camera pose from a set of corresponding 2D points
|
|
CV_EXPORTS_W int recoverPose( InputArray E, InputArray points1, InputArray points2,
|
|
OutputArray R, OutputArray t,
|
|
double focal = 1.0, Point2d pp = Point2d(0, 0),
|
|
InputOutputArray mask = noArray() );
|
|
|
|
|
|
//! finds coordinates of epipolar lines corresponding the specified points
|
|
CV_EXPORTS_W void computeCorrespondEpilines( InputArray points, int whichImage,
|
|
InputArray F, OutputArray lines );
|
|
|
|
CV_EXPORTS_W void triangulatePoints( InputArray projMatr1, InputArray projMatr2,
|
|
InputArray projPoints1, InputArray projPoints2,
|
|
OutputArray points4D );
|
|
|
|
CV_EXPORTS_W void correctMatches( InputArray F, InputArray points1, InputArray points2,
|
|
OutputArray newPoints1, OutputArray newPoints2 );
|
|
|
|
//! filters off speckles (small regions of incorrectly computed disparity)
|
|
CV_EXPORTS_W void filterSpeckles( InputOutputArray img, double newVal,
|
|
int maxSpeckleSize, double maxDiff,
|
|
InputOutputArray buf = noArray() );
|
|
|
|
//! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
|
|
CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2,
|
|
int minDisparity, int numberOfDisparities,
|
|
int SADWindowSize );
|
|
|
|
//! validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
|
|
CV_EXPORTS_W void validateDisparity( InputOutputArray disparity, InputArray cost,
|
|
int minDisparity, int numberOfDisparities,
|
|
int disp12MaxDisp = 1 );
|
|
|
|
//! reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
|
|
CV_EXPORTS_W void reprojectImageTo3D( InputArray disparity,
|
|
OutputArray _3dImage, InputArray Q,
|
|
bool handleMissingValues = false,
|
|
int ddepth = -1 );
|
|
|
|
CV_EXPORTS_W int estimateAffine3D(InputArray src, InputArray dst,
|
|
OutputArray out, OutputArray inliers,
|
|
double ransacThreshold = 3, double confidence = 0.99);
|
|
|
|
|
|
CV_EXPORTS_W int decomposeHomographyMat(InputArray H,
|
|
InputArray K,
|
|
OutputArrayOfArrays rotations,
|
|
OutputArrayOfArrays translations,
|
|
OutputArrayOfArrays normals);
|
|
|
|
class CV_EXPORTS_W StereoMatcher : public Algorithm
|
|
{
|
|
public:
|
|
enum { DISP_SHIFT = 4,
|
|
DISP_SCALE = (1 << DISP_SHIFT)
|
|
};
|
|
|
|
CV_WRAP virtual void compute( InputArray left, InputArray right,
|
|
OutputArray disparity ) = 0;
|
|
|
|
CV_WRAP virtual int getMinDisparity() const = 0;
|
|
CV_WRAP virtual void setMinDisparity(int minDisparity) = 0;
|
|
|
|
CV_WRAP virtual int getNumDisparities() const = 0;
|
|
CV_WRAP virtual void setNumDisparities(int numDisparities) = 0;
|
|
|
|
CV_WRAP virtual int getBlockSize() const = 0;
|
|
CV_WRAP virtual void setBlockSize(int blockSize) = 0;
|
|
|
|
CV_WRAP virtual int getSpeckleWindowSize() const = 0;
|
|
CV_WRAP virtual void setSpeckleWindowSize(int speckleWindowSize) = 0;
|
|
|
|
CV_WRAP virtual int getSpeckleRange() const = 0;
|
|
CV_WRAP virtual void setSpeckleRange(int speckleRange) = 0;
|
|
|
|
CV_WRAP virtual int getDisp12MaxDiff() const = 0;
|
|
CV_WRAP virtual void setDisp12MaxDiff(int disp12MaxDiff) = 0;
|
|
};
|
|
|
|
|
|
|
|
class CV_EXPORTS_W StereoBM : public StereoMatcher
|
|
{
|
|
public:
|
|
enum { PREFILTER_NORMALIZED_RESPONSE = 0,
|
|
PREFILTER_XSOBEL = 1
|
|
};
|
|
|
|
CV_WRAP virtual int getPreFilterType() const = 0;
|
|
CV_WRAP virtual void setPreFilterType(int preFilterType) = 0;
|
|
|
|
CV_WRAP virtual int getPreFilterSize() const = 0;
|
|
CV_WRAP virtual void setPreFilterSize(int preFilterSize) = 0;
|
|
|
|
CV_WRAP virtual int getPreFilterCap() const = 0;
|
|
CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
|
|
|
|
CV_WRAP virtual int getTextureThreshold() const = 0;
|
|
CV_WRAP virtual void setTextureThreshold(int textureThreshold) = 0;
|
|
|
|
CV_WRAP virtual int getUniquenessRatio() const = 0;
|
|
CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
|
|
|
|
CV_WRAP virtual int getSmallerBlockSize() const = 0;
|
|
CV_WRAP virtual void setSmallerBlockSize(int blockSize) = 0;
|
|
|
|
CV_WRAP virtual Rect getROI1() const = 0;
|
|
CV_WRAP virtual void setROI1(Rect roi1) = 0;
|
|
|
|
CV_WRAP virtual Rect getROI2() const = 0;
|
|
CV_WRAP virtual void setROI2(Rect roi2) = 0;
|
|
};
|
|
|
|
CV_EXPORTS_W Ptr<StereoBM> createStereoBM(int numDisparities = 0, int blockSize = 21);
|
|
|
|
|
|
class CV_EXPORTS_W StereoSGBM : public StereoMatcher
|
|
{
|
|
public:
|
|
enum { MODE_SGBM = 0,
|
|
MODE_HH = 1
|
|
};
|
|
|
|
CV_WRAP virtual int getPreFilterCap() const = 0;
|
|
CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
|
|
|
|
CV_WRAP virtual int getUniquenessRatio() const = 0;
|
|
CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
|
|
|
|
CV_WRAP virtual int getP1() const = 0;
|
|
CV_WRAP virtual void setP1(int P1) = 0;
|
|
|
|
CV_WRAP virtual int getP2() const = 0;
|
|
CV_WRAP virtual void setP2(int P2) = 0;
|
|
|
|
CV_WRAP virtual int getMode() const = 0;
|
|
CV_WRAP virtual void setMode(int mode) = 0;
|
|
};
|
|
|
|
|
|
CV_EXPORTS_W Ptr<StereoSGBM> createStereoSGBM(int minDisparity, int numDisparities, int blockSize,
|
|
int P1 = 0, int P2 = 0, int disp12MaxDiff = 0,
|
|
int preFilterCap = 0, int uniquenessRatio = 0,
|
|
int speckleWindowSize = 0, int speckleRange = 0,
|
|
int mode = StereoSGBM::MODE_SGBM);
|
|
|
|
namespace fisheye
|
|
{
|
|
enum{
|
|
CALIB_USE_INTRINSIC_GUESS = 1,
|
|
CALIB_RECOMPUTE_EXTRINSIC = 2,
|
|
CALIB_CHECK_COND = 4,
|
|
CALIB_FIX_SKEW = 8,
|
|
CALIB_FIX_K1 = 16,
|
|
CALIB_FIX_K2 = 32,
|
|
CALIB_FIX_K3 = 64,
|
|
CALIB_FIX_K4 = 128,
|
|
CALIB_FIX_INTRINSIC = 256
|
|
};
|
|
|
|
//! projects 3D points using fisheye model
|
|
CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
|
|
InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
|
|
|
|
//! projects points using fisheye model
|
|
CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray rvec, InputArray tvec,
|
|
InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
|
|
|
|
//! distorts 2D points using fisheye model
|
|
CV_EXPORTS void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha = 0);
|
|
|
|
//! undistorts 2D points using fisheye model
|
|
CV_EXPORTS void undistortPoints(InputArray distorted, OutputArray undistorted,
|
|
InputArray K, InputArray D, InputArray R = noArray(), InputArray P = noArray());
|
|
|
|
//! computing undistortion and rectification maps for image transform by cv::remap()
|
|
//! If D is empty zero distortion is used, if R or P is empty identity matrixes are used
|
|
CV_EXPORTS void initUndistortRectifyMap(InputArray K, InputArray D, InputArray R, InputArray P,
|
|
const cv::Size& size, int m1type, OutputArray map1, OutputArray map2);
|
|
|
|
//! undistorts image, optionally changes resolution and camera matrix. If Knew zero identity matrix is used
|
|
CV_EXPORTS void undistortImage(InputArray distorted, OutputArray undistorted,
|
|
InputArray K, InputArray D, InputArray Knew = cv::noArray(), const Size& new_size = Size());
|
|
|
|
//! estimates new camera matrix for undistortion or rectification
|
|
CV_EXPORTS 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);
|
|
|
|
//! performs camera calibaration
|
|
CV_EXPORTS 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));
|
|
|
|
//! stereo rectification estimation
|
|
CV_EXPORTS void stereoRectify(InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec,
|
|
OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize = Size(),
|
|
double balance = 0.0, double fov_scale = 1.0);
|
|
|
|
//! performs stereo calibaration
|
|
CV_EXPORTS double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
|
|
InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
|
|
OutputArray R, OutputArray T, int flags = CALIB_FIX_INTRINSIC,
|
|
TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
|
|
|
|
}
|
|
|
|
} // cv
|
|
|
|
#endif
|