diff --git a/apps/haartraining/CMakeLists.txt b/apps/haartraining/CMakeLists.txt index e25f56fc0e..f71cbeeaa2 100644 --- a/apps/haartraining/CMakeLists.txt +++ b/apps/haartraining/CMakeLists.txt @@ -1,4 +1,4 @@ -SET(OPENCV_HAARTRAINING_DEPS opencv_core opencv_imgproc opencv_photo opencv_highgui opencv_objdetect opencv_calib3d opencv_video opencv_features2d opencv_flann opencv_legacy) +SET(OPENCV_HAARTRAINING_DEPS opencv_core opencv_imgproc opencv_photo opencv_ml opencv_highgui opencv_objdetect opencv_calib3d opencv_video opencv_features2d opencv_flann opencv_legacy) ocv_check_dependencies(${OPENCV_HAARTRAINING_DEPS}) if(NOT OCV_DEPENDENCIES_FOUND) diff --git a/apps/haartraining/cvclassifier.h b/apps/haartraining/cvclassifier.h index df644ed173..9a43441187 100644 --- a/apps/haartraining/cvclassifier.h +++ b/apps/haartraining/cvclassifier.h @@ -112,7 +112,9 @@ CV_INLINE float cvLogRatio( float val ) /* each trainData matrix row is a sample */ #define CV_ROW_SAMPLE 1 -#define CV_IS_ROW_SAMPLE( flags ) ( ( flags ) & CV_ROW_SAMPLE ) +#ifndef CV_IS_ROW_SAMPLE +# define CV_IS_ROW_SAMPLE( flags ) ( ( flags ) & CV_ROW_SAMPLE ) +#endif /* Classifier supports tune function */ #define CV_TUNABLE (1 << 1) diff --git a/apps/traincascade/HOGfeatures.cpp b/apps/traincascade/HOGfeatures.cpp index b4ae56d373..132e2e62e9 100644 --- a/apps/traincascade/HOGfeatures.cpp +++ b/apps/traincascade/HOGfeatures.cpp @@ -1,4 +1,5 @@ #include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" #include "HOGfeatures.h" #include "cascadeclassifier.h" diff --git a/apps/traincascade/haarfeatures.cpp b/apps/traincascade/haarfeatures.cpp index 40af47d42c..ceb730aafb 100644 --- a/apps/traincascade/haarfeatures.cpp +++ b/apps/traincascade/haarfeatures.cpp @@ -1,4 +1,5 @@ #include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" #include "haarfeatures.h" #include "cascadeclassifier.h" diff --git a/apps/traincascade/lbpfeatures.cpp b/apps/traincascade/lbpfeatures.cpp index eb15b5ae87..dd1659f9de 100644 --- a/apps/traincascade/lbpfeatures.cpp +++ b/apps/traincascade/lbpfeatures.cpp @@ -1,4 +1,5 @@ #include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" #include "lbpfeatures.h" #include "cascadeclassifier.h" diff --git a/cmake/OpenCVDetectOpenCL.cmake b/cmake/OpenCVDetectOpenCL.cmake index eafecd93cc..069f95981c 100644 --- a/cmake/OpenCVDetectOpenCL.cmake +++ b/cmake/OpenCVDetectOpenCL.cmake @@ -13,6 +13,13 @@ else(APPLE) DOC "OpenCL root directory" NO_DEFAULT_PATH) + find_path(OPENCL_INCLUDE_DIR + NAMES OpenCL/cl.h CL/cl.h + HINTS ${OPENCL_ROOT_DIR} + PATH_SUFFIXES include include/nvidia-current + DOC "OpenCL include directory" + NO_DEFAULT_PATH) + find_path(OPENCL_INCLUDE_DIR NAMES OpenCL/cl.h CL/cl.h HINTS ${OPENCL_ROOT_DIR} @@ -25,6 +32,13 @@ else(APPLE) set(OPENCL_POSSIBLE_LIB_SUFFIXES lib/Win32 lib/x86) endif() + find_library(OPENCL_LIBRARY + NAMES OpenCL + HINTS ${OPENCL_ROOT_DIR} + PATH_SUFFIXES ${OPENCL_POSSIBLE_LIB_SUFFIXES} + DOC "OpenCL library" + NO_DEFAULT_PATH) + find_library(OPENCL_LIBRARY NAMES OpenCL HINTS ${OPENCL_ROOT_DIR} diff --git a/include/opencv/cv.h b/include/opencv/cv.h index 87fc0f2cfe..5a517dc739 100644 --- a/include/opencv/cv.h +++ b/include/opencv/cv.h @@ -63,12 +63,9 @@ #include "opencv2/core/core_c.h" #include "opencv2/imgproc/imgproc_c.h" #include "opencv2/photo/photo_c.h" - -#include "opencv2/video.hpp" -#include "opencv2/features2d.hpp" -#include "opencv2/flann.hpp" -#include "opencv2/calib3d.hpp" -#include "opencv2/objdetect.hpp" +#include "opencv2/video/tracking_c.h" +#include "opencv2/objdetect/objdetect_c.h" +#include "opencv2/legacy.hpp" #include "opencv2/legacy/compat.hpp" #if !defined(CV_IMPL) diff --git a/include/opencv/cv.hpp b/include/opencv/cv.hpp index 6b579ff91c..e498d7ac1a 100644 --- a/include/opencv/cv.hpp +++ b/include/opencv/cv.hpp @@ -51,6 +51,10 @@ #include "opencv2/core.hpp" #include "opencv2/imgproc.hpp" #include "opencv2/photo.hpp" +#include "opencv2/video.hpp" #include "opencv2/highgui.hpp" +#include "opencv2/features2d.hpp" +#include "opencv2/calib3d.hpp" +#include "opencv2/objdetect.hpp" #endif diff --git a/include/opencv/cvaux.h b/include/opencv/cvaux.h index 78777ac1b2..2332c8798b 100644 --- a/include/opencv/cvaux.h +++ b/include/opencv/cvaux.h @@ -49,14 +49,12 @@ #include "opencv2/core/core_c.h" #include "opencv2/imgproc/imgproc_c.h" #include "opencv2/photo/photo_c.h" - -#include "opencv2/video.hpp" -#include "opencv2/features2d.hpp" -#include "opencv2/calib3d.hpp" -#include "opencv2/objdetect.hpp" +#include "opencv2/video/tracking_c.h" +#include "opencv2/objdetect/objdetect_c.h" #include "opencv2/legacy.hpp" #include "opencv2/legacy/compat.hpp" #include "opencv2/legacy/blobtrack.hpp" + #include "opencv2/contrib.hpp" #endif diff --git a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst index 63305bfa4c..9f47213324 100644 --- a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst +++ b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst @@ -115,7 +115,7 @@ calibrateCamera --------------- Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern. -.. ocv:function:: 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) ) +.. ocv:function:: 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) ) .. ocv:pyfunction:: cv2.calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs @@ -454,7 +454,7 @@ findChessboardCorners ------------------------- Finds the positions of internal corners of the chessboard. -.. ocv:function:: bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE ) +.. ocv:function:: bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE ) .. ocv:pyfunction:: cv2.findChessboardCorners(image, patternSize[, corners[, flags]]) -> retval, corners @@ -515,7 +515,7 @@ Finds centers in the grid of circles. .. ocv:function:: bool findCirclesGrid( InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr &blobDetector = new SimpleBlobDetector() ) -.. ocv:pyfunction:: cv2.findCirclesGridDefault(image, patternSize[, centers[, flags]]) -> retval, centers +.. ocv:pyfunction:: cv2.findCirclesGrid(image, patternSize[, centers[, flags[, blobDetector]]]) -> retval, centers :param image: grid view of input circles; it must be an 8-bit grayscale or color image. @@ -694,7 +694,7 @@ findEssentialMat ------------------ Calculates an essential matrix from the corresponding points in two images. -.. ocv:function:: Mat findEssentialMat( InputArray points1, InputArray points2, double focal=1.0, Point2d pp=Point2d(0, 0), int method=CV_RANSAC, double prob=0.999, double threshold=1.0, OutputArray mask=noArray() ) +.. ocv:function:: 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() ) :param points1: Array of ``N`` ``(N >= 5)`` 2D points from the first image. The point coordinates should be floating-point (single or double precision). @@ -975,7 +975,7 @@ initCameraMatrix2D ---------------------- Finds an initial camera matrix from 3D-2D point correspondences. -.. ocv:function:: Mat initCameraMatrix2D( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.) +.. ocv:function:: Mat initCameraMatrix2D( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0 ) .. ocv:pyfunction:: cv2.initCameraMatrix2D(objectPoints, imagePoints, imageSize[, aspectRatio]) -> retval diff --git a/modules/calib3d/include/opencv2/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d.hpp index f3c7e8262c..64462eea8a 100644 --- a/modules/calib3d/include/opencv2/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d.hpp @@ -7,7 +7,7 @@ // copy or use the software. // // -// License Agreement +// License Agreement // For Open Source Computer Vision Library // // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. @@ -44,562 +44,184 @@ #ifndef __OPENCV_CALIB3D_HPP__ #define __OPENCV_CALIB3D_HPP__ -#ifdef __cplusplus -# include "opencv2/core.hpp" -#endif -#include "opencv2/core/core_c.h" +#include "opencv2/core.hpp" #include "opencv2/features2d.hpp" -#ifdef __cplusplus -extern "C" { -#endif - -/****************************************************************************************\ -* Camera Calibration, Pose Estimation and Stereo * -\****************************************************************************************/ - -typedef struct CvPOSITObject CvPOSITObject; - -/* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */ -CVAPI(CvPOSITObject*) cvCreatePOSITObject( CvPoint3D32f* points, int point_count ); - - -/* Runs POSIT (POSe from ITeration) algorithm for determining 3d position of - an object given its model and projection in a weak-perspective case */ -CVAPI(void) cvPOSIT( CvPOSITObject* posit_object, CvPoint2D32f* image_points, - double focal_length, CvTermCriteria criteria, - float* rotation_matrix, float* translation_vector); - -/* Releases CvPOSITObject structure */ -CVAPI(void) cvReleasePOSITObject( CvPOSITObject** posit_object ); - -/* updates the number of RANSAC iterations */ -CVAPI(int) cvRANSACUpdateNumIters( double p, double err_prob, - int model_points, int max_iters ); - -CVAPI(void) cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst ); - -/* Calculates fundamental matrix given a set of corresponding points */ -#define CV_FM_7POINT 1 -#define CV_FM_8POINT 2 - -#define CV_LMEDS 4 -#define CV_RANSAC 8 - -#define CV_FM_LMEDS_ONLY CV_LMEDS -#define CV_FM_RANSAC_ONLY CV_RANSAC -#define CV_FM_LMEDS CV_LMEDS -#define CV_FM_RANSAC CV_RANSAC - -enum -{ - CV_ITERATIVE = 0, - CV_EPNP = 1, // F.Moreno-Noguer, V.Lepetit and P.Fua "EPnP: Efficient Perspective-n-Point Camera Pose Estimation" - CV_P3P = 2 // X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang; "Complete Solution Classification for the Perspective-Three-Point Problem" -}; - -CVAPI(int) cvFindFundamentalMat( const CvMat* points1, const CvMat* points2, - CvMat* fundamental_matrix, - int method CV_DEFAULT(CV_FM_RANSAC), - double param1 CV_DEFAULT(3.), double param2 CV_DEFAULT(0.99), - CvMat* status CV_DEFAULT(NULL) ); - -/* For each input point on one of images - computes parameters of the corresponding - epipolar line on the other image */ -CVAPI(void) cvComputeCorrespondEpilines( const CvMat* points, - int which_image, - const CvMat* fundamental_matrix, - CvMat* correspondent_lines ); - -/* Triangulation functions */ - -CVAPI(void) cvTriangulatePoints(CvMat* projMatr1, CvMat* projMatr2, - CvMat* projPoints1, CvMat* projPoints2, - CvMat* points4D); - -CVAPI(void) cvCorrectMatches(CvMat* F, CvMat* points1, CvMat* points2, - CvMat* new_points1, CvMat* new_points2); - - -/* Computes the optimal new camera matrix according to the free scaling parameter alpha: - alpha=0 - only valid pixels will be retained in the undistorted image - alpha=1 - all the source image pixels will be retained in the undistorted image -*/ -CVAPI(void) cvGetOptimalNewCameraMatrix( const CvMat* camera_matrix, - const CvMat* dist_coeffs, - CvSize image_size, double alpha, - CvMat* new_camera_matrix, - CvSize new_imag_size CV_DEFAULT(cvSize(0,0)), - CvRect* valid_pixel_ROI CV_DEFAULT(0), - int center_principal_point CV_DEFAULT(0)); - -/* Converts rotation vector to rotation matrix or vice versa */ -CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst, - CvMat* jacobian CV_DEFAULT(0) ); - -/* Finds perspective transformation between the object plane and image (view) plane */ -CVAPI(int) cvFindHomography( const CvMat* src_points, - const CvMat* dst_points, - CvMat* homography, - int method CV_DEFAULT(0), - double ransacReprojThreshold CV_DEFAULT(3), - CvMat* mask CV_DEFAULT(0)); - -/* Computes RQ decomposition for 3x3 matrices */ -CVAPI(void) cvRQDecomp3x3( const CvMat *matrixM, CvMat *matrixR, CvMat *matrixQ, - CvMat *matrixQx CV_DEFAULT(NULL), - CvMat *matrixQy CV_DEFAULT(NULL), - CvMat *matrixQz CV_DEFAULT(NULL), - CvPoint3D64f *eulerAngles CV_DEFAULT(NULL)); - -/* Computes projection matrix decomposition */ -CVAPI(void) cvDecomposeProjectionMatrix( const CvMat *projMatr, CvMat *calibMatr, - CvMat *rotMatr, CvMat *posVect, - CvMat *rotMatrX CV_DEFAULT(NULL), - CvMat *rotMatrY CV_DEFAULT(NULL), - CvMat *rotMatrZ CV_DEFAULT(NULL), - CvPoint3D64f *eulerAngles CV_DEFAULT(NULL)); - -/* Computes d(AB)/dA and d(AB)/dB */ -CVAPI(void) cvCalcMatMulDeriv( const CvMat* A, const CvMat* B, CvMat* dABdA, CvMat* dABdB ); - -/* Computes r3 = rodrigues(rodrigues(r2)*rodrigues(r1)), - t3 = rodrigues(r2)*t1 + t2 and the respective derivatives */ -CVAPI(void) cvComposeRT( const CvMat* _rvec1, const CvMat* _tvec1, - const CvMat* _rvec2, const CvMat* _tvec2, - CvMat* _rvec3, CvMat* _tvec3, - CvMat* dr3dr1 CV_DEFAULT(0), CvMat* dr3dt1 CV_DEFAULT(0), - CvMat* dr3dr2 CV_DEFAULT(0), CvMat* dr3dt2 CV_DEFAULT(0), - CvMat* dt3dr1 CV_DEFAULT(0), CvMat* dt3dt1 CV_DEFAULT(0), - CvMat* dt3dr2 CV_DEFAULT(0), CvMat* dt3dt2 CV_DEFAULT(0) ); - -/* Projects object points to the view plane using - the specified extrinsic and intrinsic camera parameters */ -CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector, - const CvMat* translation_vector, const CvMat* camera_matrix, - const CvMat* distortion_coeffs, CvMat* image_points, - CvMat* dpdrot CV_DEFAULT(NULL), CvMat* dpdt CV_DEFAULT(NULL), - CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL), - CvMat* dpddist CV_DEFAULT(NULL), - double aspect_ratio CV_DEFAULT(0)); - -/* Finds extrinsic camera parameters from - a few known corresponding point pairs and intrinsic parameters */ -CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points, - const CvMat* image_points, - const CvMat* camera_matrix, - const CvMat* distortion_coeffs, - CvMat* rotation_vector, - CvMat* translation_vector, - int use_extrinsic_guess CV_DEFAULT(0) ); - -/* Computes initial estimate of the intrinsic camera parameters - in case of planar calibration target (e.g. chessboard) */ -CVAPI(void) cvInitIntrinsicParams2D( const CvMat* object_points, - const CvMat* image_points, - const CvMat* npoints, CvSize image_size, - CvMat* camera_matrix, - double aspect_ratio CV_DEFAULT(1.) ); - -#define CV_CALIB_CB_ADAPTIVE_THRESH 1 -#define CV_CALIB_CB_NORMALIZE_IMAGE 2 -#define CV_CALIB_CB_FILTER_QUADS 4 -#define CV_CALIB_CB_FAST_CHECK 8 - -// Performs a fast check if a chessboard is in the input image. This is a workaround to -// a problem of cvFindChessboardCorners being slow on images with no chessboard -// - src: input image -// - size: chessboard size -// Returns 1 if a chessboard can be in this image and findChessboardCorners should be called, -// 0 if there is no chessboard, -1 in case of error -CVAPI(int) cvCheckChessboard(IplImage* src, CvSize size); - - /* Detects corners on a chessboard calibration pattern */ -CVAPI(int) cvFindChessboardCorners( const void* image, CvSize pattern_size, - CvPoint2D32f* corners, - int* corner_count CV_DEFAULT(NULL), - int flags CV_DEFAULT(CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE) ); - -/* Draws individual chessboard corners or the whole chessboard detected */ -CVAPI(void) cvDrawChessboardCorners( CvArr* image, CvSize pattern_size, - CvPoint2D32f* corners, - int count, int pattern_was_found ); - -#define CV_CALIB_USE_INTRINSIC_GUESS 1 -#define CV_CALIB_FIX_ASPECT_RATIO 2 -#define CV_CALIB_FIX_PRINCIPAL_POINT 4 -#define CV_CALIB_ZERO_TANGENT_DIST 8 -#define CV_CALIB_FIX_FOCAL_LENGTH 16 -#define CV_CALIB_FIX_K1 32 -#define CV_CALIB_FIX_K2 64 -#define CV_CALIB_FIX_K3 128 -#define CV_CALIB_FIX_K4 2048 -#define CV_CALIB_FIX_K5 4096 -#define CV_CALIB_FIX_K6 8192 -#define CV_CALIB_RATIONAL_MODEL 16384 -#define CV_CALIB_THIN_PRISM_MODEL 32768 -#define CV_CALIB_FIX_S1_S2_S3_S4 65536 - - -/* Finds intrinsic and extrinsic camera parameters - from a few views of known calibration pattern */ -CVAPI(double) cvCalibrateCamera2( const CvMat* object_points, - const CvMat* image_points, - const CvMat* point_counts, - CvSize image_size, - CvMat* camera_matrix, - CvMat* distortion_coeffs, - CvMat* rotation_vectors CV_DEFAULT(NULL), - CvMat* translation_vectors CV_DEFAULT(NULL), - int flags CV_DEFAULT(0), - CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria( - CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON)) ); - -/* Computes various useful characteristics of the camera from the data computed by - cvCalibrateCamera2 */ -CVAPI(void) cvCalibrationMatrixValues( const CvMat *camera_matrix, - CvSize image_size, - double aperture_width CV_DEFAULT(0), - double aperture_height CV_DEFAULT(0), - double *fovx CV_DEFAULT(NULL), - double *fovy CV_DEFAULT(NULL), - double *focal_length CV_DEFAULT(NULL), - CvPoint2D64f *principal_point CV_DEFAULT(NULL), - double *pixel_aspect_ratio CV_DEFAULT(NULL)); - -#define CV_CALIB_FIX_INTRINSIC 256 -#define CV_CALIB_SAME_FOCAL_LENGTH 512 - -/* Computes the transformation from one camera coordinate system to another one - from a few correspondent views of the same calibration target. Optionally, calibrates - both cameras */ -CVAPI(double) cvStereoCalibrate( const CvMat* object_points, const CvMat* image_points1, - const CvMat* image_points2, const CvMat* npoints, - CvMat* camera_matrix1, CvMat* dist_coeffs1, - CvMat* camera_matrix2, CvMat* dist_coeffs2, - CvSize image_size, CvMat* R, CvMat* T, - CvMat* E CV_DEFAULT(0), CvMat* F CV_DEFAULT(0), - CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria( - CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6)), - int flags CV_DEFAULT(CV_CALIB_FIX_INTRINSIC)); - -#define CV_CALIB_ZERO_DISPARITY 1024 - -/* Computes 3D rotations (+ optional shift) for each camera coordinate system to make both - views parallel (=> to make all the epipolar lines horizontal or vertical) */ -CVAPI(void) cvStereoRectify( const CvMat* camera_matrix1, const CvMat* camera_matrix2, - const CvMat* dist_coeffs1, const CvMat* dist_coeffs2, - CvSize image_size, const CvMat* R, const CvMat* T, - CvMat* R1, CvMat* R2, CvMat* P1, CvMat* P2, - CvMat* Q CV_DEFAULT(0), - int flags CV_DEFAULT(CV_CALIB_ZERO_DISPARITY), - double alpha CV_DEFAULT(-1), - CvSize new_image_size CV_DEFAULT(cvSize(0,0)), - CvRect* valid_pix_ROI1 CV_DEFAULT(0), - CvRect* valid_pix_ROI2 CV_DEFAULT(0)); - -/* Computes rectification transformations for uncalibrated pair of images using a set - of point correspondences */ -CVAPI(int) cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2, - const CvMat* F, CvSize img_size, - CvMat* H1, CvMat* H2, - double threshold CV_DEFAULT(5)); - - - -/* stereo correspondence parameters and functions */ - -#define CV_STEREO_BM_NORMALIZED_RESPONSE 0 -#define CV_STEREO_BM_XSOBEL 1 - -/* Block matching algorithm structure */ -typedef struct CvStereoBMState -{ - // pre-filtering (normalization of input images) - int preFilterType; // =CV_STEREO_BM_NORMALIZED_RESPONSE now - int preFilterSize; // averaging window size: ~5x5..21x21 - int preFilterCap; // the output of pre-filtering is clipped by [-preFilterCap,preFilterCap] - - // correspondence using Sum of Absolute Difference (SAD) - int SADWindowSize; // ~5x5..21x21 - int minDisparity; // minimum disparity (can be negative) - int numberOfDisparities; // maximum disparity - minimum disparity (> 0) - - // post-filtering - int textureThreshold; // the disparity is only computed for pixels - // with textured enough neighborhood - int uniquenessRatio; // accept the computed disparity d* only if - // SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.) - // for any d != d*+/-1 within the search range. - int speckleWindowSize; // disparity variation window - int speckleRange; // acceptable range of variation in window - - int trySmallerWindows; // if 1, the results may be more accurate, - // at the expense of slower processing - CvRect roi1, roi2; - int disp12MaxDiff; - - // temporary buffers - CvMat* preFilteredImg0; - CvMat* preFilteredImg1; - CvMat* slidingSumBuf; - CvMat* cost; - CvMat* disp; -} CvStereoBMState; - -#define CV_STEREO_BM_BASIC 0 -#define CV_STEREO_BM_FISH_EYE 1 -#define CV_STEREO_BM_NARROW 2 - -CVAPI(CvStereoBMState*) cvCreateStereoBMState(int preset CV_DEFAULT(CV_STEREO_BM_BASIC), - int numberOfDisparities CV_DEFAULT(0)); - -CVAPI(void) cvReleaseStereoBMState( CvStereoBMState** state ); - -CVAPI(void) cvFindStereoCorrespondenceBM( const CvArr* left, const CvArr* right, - CvArr* disparity, CvStereoBMState* state ); - -CVAPI(CvRect) cvGetValidDisparityROI( CvRect roi1, CvRect roi2, int minDisparity, - int numberOfDisparities, int SADWindowSize ); - -CVAPI(void) cvValidateDisparity( CvArr* disparity, const CvArr* cost, - int minDisparity, int numberOfDisparities, - int disp12MaxDiff CV_DEFAULT(1) ); - -/* Reprojects the computed disparity image to the 3D space using the specified 4x4 matrix */ -CVAPI(void) cvReprojectImageTo3D( const CvArr* disparityImage, - CvArr* _3dImage, const CvMat* Q, - int handleMissingValues CV_DEFAULT(0) ); - - -#ifdef __cplusplus -} - -////////////////////////////////////////////////////////////////////////////////////////// -class CV_EXPORTS CvLevMarq -{ -public: - CvLevMarq(); - CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria= - cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON), - bool completeSymmFlag=false ); - ~CvLevMarq(); - void init( int nparams, int nerrs, CvTermCriteria criteria= - cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON), - bool completeSymmFlag=false ); - bool update( const CvMat*& param, CvMat*& J, CvMat*& err ); - bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm ); - - void clear(); - void step(); - enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 }; - - cv::Ptr mask; - cv::Ptr prevParam; - cv::Ptr param; - cv::Ptr J; - cv::Ptr err; - cv::Ptr JtJ; - cv::Ptr JtJN; - cv::Ptr JtErr; - cv::Ptr JtJV; - cv::Ptr JtJW; - double prevErrNorm, errNorm; - int lambdaLg10; - CvTermCriteria criteria; - int state; - int iters; - bool completeSymmFlag; -}; - namespace cv { -//! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation -CV_EXPORTS_W void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray()); //! type of the robust estimation algorithm -enum -{ - LMEDS=CV_LMEDS, //!< least-median algorithm - RANSAC=CV_RANSAC //!< RANSAC 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, + 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); + 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()); + 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() ); + 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 ); +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() ); + 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 ); + OutputArray jacobian = noArray(), + double aspectRatio = 0 ); //! computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled. -enum -{ - ITERATIVE=CV_ITERATIVE, - EPNP=CV_EPNP, - P3P=CV_P3P -}; CV_EXPORTS_W bool solvePnP( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, - bool useExtrinsicGuess=false, int flags=ITERATIVE); + 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); +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. ); - -enum { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2, - CALIB_CB_FILTER_QUADS = 4, CALIB_CB_FAST_CHECK = 8 }; + 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 ); +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); +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 ); -enum { CALIB_CB_SYMMETRIC_GRID = 1, CALIB_CB_ASYMMETRIC_GRID = 2, - CALIB_CB_CLUSTERING = 4 }; - //! 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 &blobDetector = new SimpleBlobDetector()); - -//! the deprecated function. Use findCirclesGrid() instead of it. -CV_EXPORTS_W bool findCirclesGridDefault( InputArray image, Size patternSize, - OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID ); -enum -{ - CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS, - CALIB_FIX_ASPECT_RATIO = CV_CALIB_FIX_ASPECT_RATIO, - CALIB_FIX_PRINCIPAL_POINT = CV_CALIB_FIX_PRINCIPAL_POINT, - CALIB_ZERO_TANGENT_DIST = CV_CALIB_ZERO_TANGENT_DIST, - CALIB_FIX_FOCAL_LENGTH = CV_CALIB_FIX_FOCAL_LENGTH, - CALIB_FIX_K1 = CV_CALIB_FIX_K1, - CALIB_FIX_K2 = CV_CALIB_FIX_K2, - CALIB_FIX_K3 = CV_CALIB_FIX_K3, - CALIB_FIX_K4 = CV_CALIB_FIX_K4, - CALIB_FIX_K5 = CV_CALIB_FIX_K5, - CALIB_FIX_K6 = CV_CALIB_FIX_K6, - CALIB_RATIONAL_MODEL = CV_CALIB_RATIONAL_MODEL, - CALIB_THIN_PRISM_MODEL = CV_CALIB_THIN_PRISM_MODEL, - CALIB_FIX_S1_S2_S3_S4=CV_CALIB_FIX_S1_S2_S3_S4, - // only for stereo - CALIB_FIX_INTRINSIC = CV_CALIB_FIX_INTRINSIC, - CALIB_SAME_FOCAL_LENGTH = CV_CALIB_SAME_FOCAL_LENGTH, - // for stereo rectification - CALIB_ZERO_DISPARITY = CV_CALIB_ZERO_DISPARITY -}; + OutputArray centers, int flags = CALIB_CB_SYMMETRIC_GRID, + const Ptr &blobDetector = new 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, + 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) ); + 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 ); +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, + InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, + InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, + InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, + Size imageSize, OutputArray R,OutputArray T, OutputArray E, OutputArray F, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), - int flags=CALIB_FIX_INTRINSIC ); + int flags = CALIB_FIX_INTRINSIC ); //! 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 ); + 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 ); + 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, @@ -615,8 +237,9 @@ CV_EXPORTS_W float rectify3Collinear( InputArray cameraMatrix1, InputArray distC //! 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); + 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 ); @@ -627,44 +250,36 @@ CV_EXPORTS_W void convertPointsFromHomogeneous( InputArray src, OutputArray dst //! for backward compatibility CV_EXPORTS void convertPointsHomogeneous( InputArray src, OutputArray dst ); -//! the algorithm for finding fundamental matrix -enum -{ - FM_7POINT = CV_FM_7POINT, //!< 7-point algorithm - FM_8POINT = CV_FM_8POINT, //!< 8-point algorithm - FM_LMEDS = CV_FM_LMEDS, //!< least-median algorithm - FM_RANSAC = CV_FM_RANSAC //!< RANSAC algorithm -}; - //! 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()); + 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); + 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 Mat findEssentialMat( InputArray points1, InputArray points2, double focal = 1.0, Point2d pp = Point2d(0, 0), - int method = CV_RANSAC, - double prob = 0.999, double threshold = 1.0, OutputArray mask = noArray() ); +CV_EXPORTS 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 void decomposeEssentialMat( InputArray E, OutputArray R1, OutputArray R2, OutputArray t ); //! recover relative camera pose from a set of corresponding 2D points -CV_EXPORTS int recoverPose( InputArray E, InputArray points1, InputArray points2, OutputArray R, OutputArray t, +CV_EXPORTS int recoverPose( InputArray E, InputArray points1, InputArray points2, + OutputArray R, OutputArray t, double focal = 1.0, Point2d pp = Point2d(0, 0), - InputOutputArray mask = noArray()); + InputOutputArray mask = noArray() ); //! finds coordinates of epipolar lines corresponding the specified points -CV_EXPORTS void computeCorrespondEpilines( InputArray points, - int whichImage, InputArray F, - OutputArray lines ); +CV_EXPORTS void computeCorrespondEpilines( InputArray points, int whichImage, + InputArray F, OutputArray lines ); CV_EXPORTS_W void triangulatePoints( InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, @@ -673,13 +288,39 @@ CV_EXPORTS_W void triangulatePoints( InputArray projMatr1, InputArray projMatr2, 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); + -template<> CV_EXPORTS void Ptr::delete_obj(); class CV_EXPORTS_W StereoMatcher : public Algorithm { public: - enum { DISP_SHIFT=4, DISP_SCALE=(1 << DISP_SHIFT) }; + enum { DISP_SHIFT = 4, + DISP_SCALE = (1 << DISP_SHIFT) + }; CV_WRAP virtual void compute( InputArray left, InputArray right, OutputArray disparity ) = 0; @@ -704,10 +345,13 @@ public: }; + class CV_EXPORTS_W StereoBM : public StereoMatcher { public: - enum { PREFILTER_NORMALIZED_RESPONSE = 0, PREFILTER_XSOBEL = 1 }; + enum { PREFILTER_NORMALIZED_RESPONSE = 0, + PREFILTER_XSOBEL = 1 + }; CV_WRAP virtual int getPreFilterType() const = 0; CV_WRAP virtual void setPreFilterType(int preFilterType) = 0; @@ -734,13 +378,15 @@ public: CV_WRAP virtual void setROI2(Rect roi2) = 0; }; -CV_EXPORTS_W Ptr createStereoBM(int numDisparities=0, int blockSize=21); +CV_EXPORTS_W Ptr createStereoBM(int numDisparities = 0, int blockSize = 21); class CV_EXPORTS_W StereoSGBM : public StereoMatcher { public: - enum { MODE_SGBM=0, MODE_HH=1 }; + enum { MODE_SGBM = 0, + MODE_HH = 1 + }; CV_WRAP virtual int getPreFilterCap() const = 0; CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0; @@ -760,38 +406,11 @@ public: CV_EXPORTS_W Ptr 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); + 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); -//! 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); - -} - -#endif +} // cv #endif diff --git a/modules/calib3d/include/opencv2/calib3d/calib3d_c.h b/modules/calib3d/include/opencv2/calib3d/calib3d_c.h new file mode 100644 index 0000000000..a505d526db --- /dev/null +++ b/modules/calib3d/include/opencv2/calib3d/calib3d_c.h @@ -0,0 +1,413 @@ +/*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_C_H__ +#define __OPENCV_CALIB3D_C_H__ + +#include "opencv2/core/core_c.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************************\ +* Camera Calibration, Pose Estimation and Stereo * +\****************************************************************************************/ + +typedef struct CvPOSITObject CvPOSITObject; + +/* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */ +CVAPI(CvPOSITObject*) cvCreatePOSITObject( CvPoint3D32f* points, int point_count ); + + +/* Runs POSIT (POSe from ITeration) algorithm for determining 3d position of + an object given its model and projection in a weak-perspective case */ +CVAPI(void) cvPOSIT( CvPOSITObject* posit_object, CvPoint2D32f* image_points, + double focal_length, CvTermCriteria criteria, + float* rotation_matrix, float* translation_vector); + +/* Releases CvPOSITObject structure */ +CVAPI(void) cvReleasePOSITObject( CvPOSITObject** posit_object ); + +/* updates the number of RANSAC iterations */ +CVAPI(int) cvRANSACUpdateNumIters( double p, double err_prob, + int model_points, int max_iters ); + +CVAPI(void) cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst ); + +/* Calculates fundamental matrix given a set of corresponding points */ +#define CV_FM_7POINT 1 +#define CV_FM_8POINT 2 + +#define CV_LMEDS 4 +#define CV_RANSAC 8 + +#define CV_FM_LMEDS_ONLY CV_LMEDS +#define CV_FM_RANSAC_ONLY CV_RANSAC +#define CV_FM_LMEDS CV_LMEDS +#define CV_FM_RANSAC CV_RANSAC + +enum +{ + CV_ITERATIVE = 0, + CV_EPNP = 1, // F.Moreno-Noguer, V.Lepetit and P.Fua "EPnP: Efficient Perspective-n-Point Camera Pose Estimation" + CV_P3P = 2 // X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang; "Complete Solution Classification for the Perspective-Three-Point Problem" +}; + +CVAPI(int) cvFindFundamentalMat( const CvMat* points1, const CvMat* points2, + CvMat* fundamental_matrix, + int method CV_DEFAULT(CV_FM_RANSAC), + double param1 CV_DEFAULT(3.), double param2 CV_DEFAULT(0.99), + CvMat* status CV_DEFAULT(NULL) ); + +/* For each input point on one of images + computes parameters of the corresponding + epipolar line on the other image */ +CVAPI(void) cvComputeCorrespondEpilines( const CvMat* points, + int which_image, + const CvMat* fundamental_matrix, + CvMat* correspondent_lines ); + +/* Triangulation functions */ + +CVAPI(void) cvTriangulatePoints(CvMat* projMatr1, CvMat* projMatr2, + CvMat* projPoints1, CvMat* projPoints2, + CvMat* points4D); + +CVAPI(void) cvCorrectMatches(CvMat* F, CvMat* points1, CvMat* points2, + CvMat* new_points1, CvMat* new_points2); + + +/* Computes the optimal new camera matrix according to the free scaling parameter alpha: + alpha=0 - only valid pixels will be retained in the undistorted image + alpha=1 - all the source image pixels will be retained in the undistorted image +*/ +CVAPI(void) cvGetOptimalNewCameraMatrix( const CvMat* camera_matrix, + const CvMat* dist_coeffs, + CvSize image_size, double alpha, + CvMat* new_camera_matrix, + CvSize new_imag_size CV_DEFAULT(cvSize(0,0)), + CvRect* valid_pixel_ROI CV_DEFAULT(0), + int center_principal_point CV_DEFAULT(0)); + +/* Converts rotation vector to rotation matrix or vice versa */ +CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst, + CvMat* jacobian CV_DEFAULT(0) ); + +/* Finds perspective transformation between the object plane and image (view) plane */ +CVAPI(int) cvFindHomography( const CvMat* src_points, + const CvMat* dst_points, + CvMat* homography, + int method CV_DEFAULT(0), + double ransacReprojThreshold CV_DEFAULT(3), + CvMat* mask CV_DEFAULT(0)); + +/* Computes RQ decomposition for 3x3 matrices */ +CVAPI(void) cvRQDecomp3x3( const CvMat *matrixM, CvMat *matrixR, CvMat *matrixQ, + CvMat *matrixQx CV_DEFAULT(NULL), + CvMat *matrixQy CV_DEFAULT(NULL), + CvMat *matrixQz CV_DEFAULT(NULL), + CvPoint3D64f *eulerAngles CV_DEFAULT(NULL)); + +/* Computes projection matrix decomposition */ +CVAPI(void) cvDecomposeProjectionMatrix( const CvMat *projMatr, CvMat *calibMatr, + CvMat *rotMatr, CvMat *posVect, + CvMat *rotMatrX CV_DEFAULT(NULL), + CvMat *rotMatrY CV_DEFAULT(NULL), + CvMat *rotMatrZ CV_DEFAULT(NULL), + CvPoint3D64f *eulerAngles CV_DEFAULT(NULL)); + +/* Computes d(AB)/dA and d(AB)/dB */ +CVAPI(void) cvCalcMatMulDeriv( const CvMat* A, const CvMat* B, CvMat* dABdA, CvMat* dABdB ); + +/* Computes r3 = rodrigues(rodrigues(r2)*rodrigues(r1)), + t3 = rodrigues(r2)*t1 + t2 and the respective derivatives */ +CVAPI(void) cvComposeRT( const CvMat* _rvec1, const CvMat* _tvec1, + const CvMat* _rvec2, const CvMat* _tvec2, + CvMat* _rvec3, CvMat* _tvec3, + CvMat* dr3dr1 CV_DEFAULT(0), CvMat* dr3dt1 CV_DEFAULT(0), + CvMat* dr3dr2 CV_DEFAULT(0), CvMat* dr3dt2 CV_DEFAULT(0), + CvMat* dt3dr1 CV_DEFAULT(0), CvMat* dt3dt1 CV_DEFAULT(0), + CvMat* dt3dr2 CV_DEFAULT(0), CvMat* dt3dt2 CV_DEFAULT(0) ); + +/* Projects object points to the view plane using + the specified extrinsic and intrinsic camera parameters */ +CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector, + const CvMat* translation_vector, const CvMat* camera_matrix, + const CvMat* distortion_coeffs, CvMat* image_points, + CvMat* dpdrot CV_DEFAULT(NULL), CvMat* dpdt CV_DEFAULT(NULL), + CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL), + CvMat* dpddist CV_DEFAULT(NULL), + double aspect_ratio CV_DEFAULT(0)); + +/* Finds extrinsic camera parameters from + a few known corresponding point pairs and intrinsic parameters */ +CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points, + const CvMat* image_points, + const CvMat* camera_matrix, + const CvMat* distortion_coeffs, + CvMat* rotation_vector, + CvMat* translation_vector, + int use_extrinsic_guess CV_DEFAULT(0) ); + +/* Computes initial estimate of the intrinsic camera parameters + in case of planar calibration target (e.g. chessboard) */ +CVAPI(void) cvInitIntrinsicParams2D( const CvMat* object_points, + const CvMat* image_points, + const CvMat* npoints, CvSize image_size, + CvMat* camera_matrix, + double aspect_ratio CV_DEFAULT(1.) ); + +#define CV_CALIB_CB_ADAPTIVE_THRESH 1 +#define CV_CALIB_CB_NORMALIZE_IMAGE 2 +#define CV_CALIB_CB_FILTER_QUADS 4 +#define CV_CALIB_CB_FAST_CHECK 8 + +// Performs a fast check if a chessboard is in the input image. This is a workaround to +// a problem of cvFindChessboardCorners being slow on images with no chessboard +// - src: input image +// - size: chessboard size +// Returns 1 if a chessboard can be in this image and findChessboardCorners should be called, +// 0 if there is no chessboard, -1 in case of error +CVAPI(int) cvCheckChessboard(IplImage* src, CvSize size); + + /* Detects corners on a chessboard calibration pattern */ +CVAPI(int) cvFindChessboardCorners( const void* image, CvSize pattern_size, + CvPoint2D32f* corners, + int* corner_count CV_DEFAULT(NULL), + int flags CV_DEFAULT(CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE) ); + +/* Draws individual chessboard corners or the whole chessboard detected */ +CVAPI(void) cvDrawChessboardCorners( CvArr* image, CvSize pattern_size, + CvPoint2D32f* corners, + int count, int pattern_was_found ); + +#define CV_CALIB_USE_INTRINSIC_GUESS 1 +#define CV_CALIB_FIX_ASPECT_RATIO 2 +#define CV_CALIB_FIX_PRINCIPAL_POINT 4 +#define CV_CALIB_ZERO_TANGENT_DIST 8 +#define CV_CALIB_FIX_FOCAL_LENGTH 16 +#define CV_CALIB_FIX_K1 32 +#define CV_CALIB_FIX_K2 64 +#define CV_CALIB_FIX_K3 128 +#define CV_CALIB_FIX_K4 2048 +#define CV_CALIB_FIX_K5 4096 +#define CV_CALIB_FIX_K6 8192 +#define CV_CALIB_RATIONAL_MODEL 16384 +#define CV_CALIB_THIN_PRISM_MODEL 32768 +#define CV_CALIB_FIX_S1_S2_S3_S4 65536 + + +/* Finds intrinsic and extrinsic camera parameters + from a few views of known calibration pattern */ +CVAPI(double) cvCalibrateCamera2( const CvMat* object_points, + const CvMat* image_points, + const CvMat* point_counts, + CvSize image_size, + CvMat* camera_matrix, + CvMat* distortion_coeffs, + CvMat* rotation_vectors CV_DEFAULT(NULL), + CvMat* translation_vectors CV_DEFAULT(NULL), + int flags CV_DEFAULT(0), + CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria( + CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON)) ); + +/* Computes various useful characteristics of the camera from the data computed by + cvCalibrateCamera2 */ +CVAPI(void) cvCalibrationMatrixValues( const CvMat *camera_matrix, + CvSize image_size, + double aperture_width CV_DEFAULT(0), + double aperture_height CV_DEFAULT(0), + double *fovx CV_DEFAULT(NULL), + double *fovy CV_DEFAULT(NULL), + double *focal_length CV_DEFAULT(NULL), + CvPoint2D64f *principal_point CV_DEFAULT(NULL), + double *pixel_aspect_ratio CV_DEFAULT(NULL)); + +#define CV_CALIB_FIX_INTRINSIC 256 +#define CV_CALIB_SAME_FOCAL_LENGTH 512 + +/* Computes the transformation from one camera coordinate system to another one + from a few correspondent views of the same calibration target. Optionally, calibrates + both cameras */ +CVAPI(double) cvStereoCalibrate( const CvMat* object_points, const CvMat* image_points1, + const CvMat* image_points2, const CvMat* npoints, + CvMat* camera_matrix1, CvMat* dist_coeffs1, + CvMat* camera_matrix2, CvMat* dist_coeffs2, + CvSize image_size, CvMat* R, CvMat* T, + CvMat* E CV_DEFAULT(0), CvMat* F CV_DEFAULT(0), + CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria( + CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6)), + int flags CV_DEFAULT(CV_CALIB_FIX_INTRINSIC)); + +#define CV_CALIB_ZERO_DISPARITY 1024 + +/* Computes 3D rotations (+ optional shift) for each camera coordinate system to make both + views parallel (=> to make all the epipolar lines horizontal or vertical) */ +CVAPI(void) cvStereoRectify( const CvMat* camera_matrix1, const CvMat* camera_matrix2, + const CvMat* dist_coeffs1, const CvMat* dist_coeffs2, + CvSize image_size, const CvMat* R, const CvMat* T, + CvMat* R1, CvMat* R2, CvMat* P1, CvMat* P2, + CvMat* Q CV_DEFAULT(0), + int flags CV_DEFAULT(CV_CALIB_ZERO_DISPARITY), + double alpha CV_DEFAULT(-1), + CvSize new_image_size CV_DEFAULT(cvSize(0,0)), + CvRect* valid_pix_ROI1 CV_DEFAULT(0), + CvRect* valid_pix_ROI2 CV_DEFAULT(0)); + +/* Computes rectification transformations for uncalibrated pair of images using a set + of point correspondences */ +CVAPI(int) cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2, + const CvMat* F, CvSize img_size, + CvMat* H1, CvMat* H2, + double threshold CV_DEFAULT(5)); + + + +/* stereo correspondence parameters and functions */ + +#define CV_STEREO_BM_NORMALIZED_RESPONSE 0 +#define CV_STEREO_BM_XSOBEL 1 + +/* Block matching algorithm structure */ +typedef struct CvStereoBMState +{ + // pre-filtering (normalization of input images) + int preFilterType; // =CV_STEREO_BM_NORMALIZED_RESPONSE now + int preFilterSize; // averaging window size: ~5x5..21x21 + int preFilterCap; // the output of pre-filtering is clipped by [-preFilterCap,preFilterCap] + + // correspondence using Sum of Absolute Difference (SAD) + int SADWindowSize; // ~5x5..21x21 + int minDisparity; // minimum disparity (can be negative) + int numberOfDisparities; // maximum disparity - minimum disparity (> 0) + + // post-filtering + int textureThreshold; // the disparity is only computed for pixels + // with textured enough neighborhood + int uniquenessRatio; // accept the computed disparity d* only if + // SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.) + // for any d != d*+/-1 within the search range. + int speckleWindowSize; // disparity variation window + int speckleRange; // acceptable range of variation in window + + int trySmallerWindows; // if 1, the results may be more accurate, + // at the expense of slower processing + CvRect roi1, roi2; + int disp12MaxDiff; + + // temporary buffers + CvMat* preFilteredImg0; + CvMat* preFilteredImg1; + CvMat* slidingSumBuf; + CvMat* cost; + CvMat* disp; +} CvStereoBMState; + +#define CV_STEREO_BM_BASIC 0 +#define CV_STEREO_BM_FISH_EYE 1 +#define CV_STEREO_BM_NARROW 2 + +CVAPI(CvStereoBMState*) cvCreateStereoBMState(int preset CV_DEFAULT(CV_STEREO_BM_BASIC), + int numberOfDisparities CV_DEFAULT(0)); + +CVAPI(void) cvReleaseStereoBMState( CvStereoBMState** state ); + +CVAPI(void) cvFindStereoCorrespondenceBM( const CvArr* left, const CvArr* right, + CvArr* disparity, CvStereoBMState* state ); + +CVAPI(CvRect) cvGetValidDisparityROI( CvRect roi1, CvRect roi2, int minDisparity, + int numberOfDisparities, int SADWindowSize ); + +CVAPI(void) cvValidateDisparity( CvArr* disparity, const CvArr* cost, + int minDisparity, int numberOfDisparities, + int disp12MaxDiff CV_DEFAULT(1) ); + +/* Reprojects the computed disparity image to the 3D space using the specified 4x4 matrix */ +CVAPI(void) cvReprojectImageTo3D( const CvArr* disparityImage, + CvArr* _3dImage, const CvMat* Q, + int handleMissingValues CV_DEFAULT(0) ); + +#ifdef __cplusplus +} // extern "C" + +////////////////////////////////////////////////////////////////////////////////////////// +class CV_EXPORTS CvLevMarq +{ +public: + CvLevMarq(); + CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria= + cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON), + bool completeSymmFlag=false ); + ~CvLevMarq(); + void init( int nparams, int nerrs, CvTermCriteria criteria= + cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON), + bool completeSymmFlag=false ); + bool update( const CvMat*& param, CvMat*& J, CvMat*& err ); + bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm ); + + void clear(); + void step(); + enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 }; + + cv::Ptr mask; + cv::Ptr prevParam; + cv::Ptr param; + cv::Ptr J; + cv::Ptr err; + cv::Ptr JtJ; + cv::Ptr JtJN; + cv::Ptr JtErr; + cv::Ptr JtJV; + cv::Ptr JtJW; + double prevErrNorm, errNorm; + int lambdaLg10; + CvTermCriteria criteria; + int state; + int iters; + bool completeSymmFlag; +}; + +#endif + +#endif /* __OPENCV_CALIB3D_C_H__ */ diff --git a/modules/calib3d/perf/perf_pnp.cpp b/modules/calib3d/perf/perf_pnp.cpp index 02ecd2c599..e881557298 100644 --- a/modules/calib3d/perf/perf_pnp.cpp +++ b/modules/calib3d/perf/perf_pnp.cpp @@ -10,7 +10,7 @@ using namespace perf; using std::tr1::make_tuple; using std::tr1::get; -CV_ENUM(pnpAlgo, CV_ITERATIVE, CV_EPNP /*, CV_P3P*/) +CV_ENUM(pnpAlgo, ITERATIVE, EPNP /*, P3P*/) typedef std::tr1::tuple PointsNum_Algo_t; typedef perf::TestBaseWithParam PointsNum_Algo; @@ -20,7 +20,7 @@ typedef perf::TestBaseWithParam PointsNum; PERF_TEST_P(PointsNum_Algo, solvePnP, testing::Combine( testing::Values(/*4,*/ 3*9, 7*13), //TODO: find why results on 4 points are too unstable - testing::Values((int)CV_ITERATIVE, (int)CV_EPNP) + testing::Values((int)ITERATIVE, (int)EPNP) ) ) { @@ -93,7 +93,7 @@ PERF_TEST(PointsNum_Algo, solveP3P) TEST_CYCLE_N(1000) { - solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, CV_P3P); + solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, P3P); } SANITY_CHECK(rvec, 1e-6); diff --git a/modules/calib3d/src/calibinit.cpp b/modules/calib3d/src/calibinit.cpp index ac4c8367a3..b93b4951ed 100644 --- a/modules/calib3d/src/calibinit.cpp +++ b/modules/calib3d/src/calibinit.cpp @@ -61,6 +61,7 @@ #include "precomp.hpp" #include "opencv2/imgproc/imgproc_c.h" +#include "opencv2/calib3d/calib3d_c.h" #include "circlesgrid.hpp" #include diff --git a/modules/calib3d/src/calibration.cpp b/modules/calib3d/src/calibration.cpp index 176503f81f..bb78635752 100644 --- a/modules/calib3d/src/calibration.cpp +++ b/modules/calib3d/src/calibration.cpp @@ -42,6 +42,7 @@ #include "precomp.hpp" #include "opencv2/imgproc/imgproc_c.h" +#include "opencv2/calib3d/calib3d_c.h" #include #include @@ -825,7 +826,7 @@ CV_IMPL void cvProjectPoints2( const CvMat* objectPoints, dpdk_p[dpdk_step+7] = fy*y*cdist*(-icdist2)*icdist2*r6; if( _dpdk->cols > 8 ) { - dpdk_p[8] = fx*r2; //s1 + dpdk_p[8] = fx*r2; //s1 dpdk_p[9] = fx*r4; //s2 dpdk_p[10] = 0;//s3 dpdk_p[11] = 0;//s4 @@ -1255,7 +1256,7 @@ CV_IMPL double cvCalibrateCamera2( const CvMat* objectPoints, //when the thin prism model is used the distortion coefficients matrix must have 12 parameters if((flags & CV_CALIB_THIN_PRISM_MODEL) && (distCoeffs->cols*distCoeffs->rows != 12)) CV_Error( CV_StsBadArg, "Thin prism model must have 12 parameters in the distortion matrix" ); - + nimages = npoints->rows*npoints->cols; npstep = npoints->rows == 1 ? 1 : npoints->step/CV_ELEM_SIZE(npoints->type); diff --git a/modules/calib3d/src/checkchessboard.cpp b/modules/calib3d/src/checkchessboard.cpp index 4019d564e6..715fe73ef8 100644 --- a/modules/calib3d/src/checkchessboard.cpp +++ b/modules/calib3d/src/checkchessboard.cpp @@ -41,6 +41,7 @@ #include "precomp.hpp" #include "opencv2/imgproc/imgproc_c.h" +#include "opencv2/calib3d/calib3d_c.h" #include #include diff --git a/modules/calib3d/src/circlesgrid.cpp b/modules/calib3d/src/circlesgrid.cpp index 3514aeb4be..db95304832 100644 --- a/modules/calib3d/src/circlesgrid.cpp +++ b/modules/calib3d/src/circlesgrid.cpp @@ -202,12 +202,12 @@ void CirclesGridClusterFinder::findCorners(const std::vector &hull2 //corners are the most sharp angles (6) Mat anglesMat = Mat(angles); Mat sortedIndices; - sortIdx(anglesMat, sortedIndices, CV_SORT_EVERY_COLUMN + CV_SORT_DESCENDING); + sortIdx(anglesMat, sortedIndices, SORT_EVERY_COLUMN + SORT_DESCENDING); CV_Assert(sortedIndices.type() == CV_32SC1); CV_Assert(sortedIndices.cols == 1); const int cornersCount = isAsymmetricGrid ? 6 : 4; Mat cornersIndices; - cv::sort(sortedIndices.rowRange(0, cornersCount), cornersIndices, CV_SORT_EVERY_COLUMN + CV_SORT_ASCENDING); + cv::sort(sortedIndices.rowRange(0, cornersCount), cornersIndices, SORT_EVERY_COLUMN + SORT_ASCENDING); corners.clear(); for(int i=0; i (id, Vertex())); } void Graph::addEdge(size_t id1, size_t id2) { - assert( doesVertexExist( id1 ) ); - assert( doesVertexExist( id2 ) ); + CV_Assert( doesVertexExist( id1 ) ); + CV_Assert( doesVertexExist( id2 ) ); vertices[id1].neighbors.insert(id2); vertices[id2].neighbors.insert(id1); @@ -454,8 +454,8 @@ void Graph::addEdge(size_t id1, size_t id2) void Graph::removeEdge(size_t id1, size_t id2) { - assert( doesVertexExist( id1 ) ); - assert( doesVertexExist( id2 ) ); + CV_Assert( doesVertexExist( id1 ) ); + CV_Assert( doesVertexExist( id2 ) ); vertices[id1].neighbors.erase(id2); vertices[id2].neighbors.erase(id1); @@ -463,8 +463,8 @@ void Graph::removeEdge(size_t id1, size_t id2) bool Graph::areVerticesAdjacent(size_t id1, size_t id2) const { - assert( doesVertexExist( id1 ) ); - assert( doesVertexExist( id2 ) ); + CV_Assert( doesVertexExist( id1 ) ); + CV_Assert( doesVertexExist( id2 ) ); Vertices::const_iterator it = vertices.find(id1); return it->second.neighbors.find(id2) != it->second.neighbors.end(); @@ -477,7 +477,7 @@ size_t Graph::getVerticesCount() const size_t Graph::getDegree(size_t id) const { - assert( doesVertexExist(id) ); + CV_Assert( doesVertexExist(id) ); Vertices::const_iterator it = vertices.find(id); return it->second.neighbors.size(); @@ -495,7 +495,7 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const distanceMatrix.at ((int)it1->first, (int)it1->first) = 0; for (Neighbors::const_iterator it2 = it1->second.neighbors.begin(); it2 != it1->second.neighbors.end(); it2++) { - assert( it1->first != *it2 ); + CV_Assert( it1->first != *it2 ); distanceMatrix.at ((int)it1->first, (int)*it2) = edgeWeight; } } @@ -524,7 +524,7 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const const Graph::Neighbors& Graph::getNeighbors(size_t id) const { - assert( doesVertexExist(id) ); + CV_Assert( doesVertexExist(id) ); Vertices::const_iterator it = vertices.find(id); return it->second.neighbors; @@ -604,7 +604,7 @@ bool CirclesGridFinder::findHoles() } default: - CV_Error(CV_StsBadArg, "Unkown pattern type"); + CV_Error(Error::StsBadArg, "Unkown pattern type"); } return (isDetectionCorrect()); //CV_Error( 0, "Detection is not correct" ); @@ -813,7 +813,7 @@ void CirclesGridFinder::findMCS(const std::vector &basis, std::vector& centers, const std::vector &keypoints, std::vector &warpedKeypoints) { - assert( !centers.empty() ); + CV_Assert( !centers.empty() ); const float edgeLength = 30; const Point2f offset(150, 150); @@ -832,7 +832,7 @@ Mat CirclesGridFinder::rectifyGrid(Size detectedGridSize, const std::vector srcKeypoints; @@ -912,7 +912,7 @@ void CirclesGridFinder::findCandidateLine(std::vector &line, size_t seed } } - assert( line.size() == seeds.size() ); + CV_Assert( line.size() == seeds.size() ); } void CirclesGridFinder::findCandidateHoles(std::vector &above, std::vector &below, bool addRow, Point2f basisVec, @@ -927,9 +927,9 @@ void CirclesGridFinder::findCandidateHoles(std::vector &above, std::vect size_t lastIdx = addRow ? holes.size() - 1 : holes[0].size() - 1; findCandidateLine(below, lastIdx, addRow, basisVec, belowSeeds); - assert( below.size() == above.size() ); - assert( belowSeeds.size() == aboveSeeds.size() ); - assert( below.size() == belowSeeds.size() ); + CV_Assert( below.size() == above.size() ); + CV_Assert( belowSeeds.size() == aboveSeeds.size() ); + CV_Assert( below.size() == belowSeeds.size() ); } bool CirclesGridFinder::areCentersNew(const std::vector &newCenters, const std::vector > &holes) @@ -1000,10 +1000,10 @@ void CirclesGridFinder::insertWinner(float aboveConfidence, float belowConfidenc float CirclesGridFinder::computeGraphConfidence(const std::vector &basisGraphs, bool addRow, const std::vector &points, const std::vector &seeds) { - assert( points.size() == seeds.size() ); + CV_Assert( points.size() == seeds.size() ); float confidence = 0; const size_t vCount = basisGraphs[0].getVerticesCount(); - assert( basisGraphs[0].getVerticesCount() == basisGraphs[1].getVerticesCount() ); + CV_Assert( basisGraphs[0].getVerticesCount() == basisGraphs[1].getVerticesCount() ); for (size_t i = 0; i < seeds.size(); i++) { @@ -1087,7 +1087,7 @@ void CirclesGridFinder::findBasis(const std::vector &samples, std::vect const int clustersCount = 4; kmeans(Mat(samples).reshape(1, 0), clustersCount, bestLabels, termCriteria, parameters.kmeansAttempts, KMEANS_RANDOM_CENTERS, centers); - assert( centers.type() == CV_32FC1 ); + CV_Assert( centers.type() == CV_32FC1 ); std::vector basisIndices; //TODO: only remove duplicate @@ -1204,7 +1204,7 @@ void CirclesGridFinder::computeRNG(Graph &rng, std::vector &vectors void computePredecessorMatrix(const Mat &dm, int verticesCount, Mat &predecessorMatrix) { - assert( dm.type() == CV_32SC1 ); + CV_Assert( dm.type() == CV_32SC1 ); predecessorMatrix.create(verticesCount, verticesCount, CV_32SC1); predecessorMatrix = -1; for (int i = 0; i < predecessorMatrix.rows; i++) @@ -1253,7 +1253,6 @@ size_t CirclesGridFinder::findLongestPath(std::vector &basisGraphs, Path double maxVal; Point maxLoc; - assert (infinity < 0); minMaxLoc(distanceMatrix, 0, &maxVal, 0, &maxLoc); if (maxVal > longestPaths[0].length) @@ -1594,9 +1593,3 @@ size_t CirclesGridFinder::getFirstCorner(std::vector &largeCornerIndices, return cornerIdx; } - -bool cv::findCirclesGridDefault( InputArray image, Size patternSize, - OutputArray centers, int flags ) -{ - return findCirclesGrid(image, patternSize, centers, flags); -} diff --git a/modules/calib3d/src/compat_ptsetreg.cpp b/modules/calib3d/src/compat_ptsetreg.cpp index dca0d0dabe..74c9e00122 100644 --- a/modules/calib3d/src/compat_ptsetreg.cpp +++ b/modules/calib3d/src/compat_ptsetreg.cpp @@ -41,6 +41,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" /************************************************************************************\ Some backward compatibility stuff, to be moved to legacy or compat module diff --git a/modules/calib3d/src/compat_stereo.cpp b/modules/calib3d/src/compat_stereo.cpp index f1d9834245..16eefc6847 100644 --- a/modules/calib3d/src/compat_stereo.cpp +++ b/modules/calib3d/src/compat_stereo.cpp @@ -41,6 +41,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" CvStereoBMState* cvCreateStereoBMState( int /*preset*/, int numberOfDisparities ) { @@ -83,10 +84,6 @@ void cvReleaseStereoBMState( CvStereoBMState** state ) cvFree( state ); } -template<> void cv::Ptr::delete_obj() -{ cvReleaseStereoBMState(&obj); } - - void cvFindStereoCorrespondenceBM( const CvArr* leftarr, const CvArr* rightarr, CvArr* disparr, CvStereoBMState* state ) { diff --git a/modules/calib3d/src/epnp.h b/modules/calib3d/src/epnp.h index 203830a6d6..fe01606305 100644 --- a/modules/calib3d/src/epnp.h +++ b/modules/calib3d/src/epnp.h @@ -2,6 +2,7 @@ #define epnp_h #include "precomp.hpp" +#include "opencv2/core/core_c.h" class epnp { public: diff --git a/modules/calib3d/src/five-point.cpp b/modules/calib3d/src/five-point.cpp index 5af82bde77..7eae2ebf8d 100644 --- a/modules/calib3d/src/five-point.cpp +++ b/modules/calib3d/src/five-point.cpp @@ -435,7 +435,7 @@ cv::Mat cv::findEssentialMat( InputArray _points1, InputArray _points2, double f threshold /= focal; Mat E; - if( method == CV_RANSAC ) + if( method == RANSAC ) createRANSACPointSetRegistrator(new EMEstimatorCallback, 5, threshold, prob)->run(points1, points2, E, _mask); else createLMeDSPointSetRegistrator(new EMEstimatorCallback, 5, prob)->run(points1, points2, E, _mask); diff --git a/modules/calib3d/src/fundam.cpp b/modules/calib3d/src/fundam.cpp index 0db8fcab9b..c58e8220aa 100644 --- a/modules/calib3d/src/fundam.cpp +++ b/modules/calib3d/src/fundam.cpp @@ -181,12 +181,12 @@ public: LtL[j][k] += Lx[j]*Lx[k] + Ly[j]*Ly[k]; } completeSymm( _LtL ); - + eigen( _LtL, matW, matV ); _Htemp = _invHnorm*_H0; _H0 = _Htemp*_Hnorm2; _H0.convertTo(_model, _H0.type(), 1./_H0.at(2,2) ); - + return 1; } @@ -292,7 +292,7 @@ cv::Mat cv::findHomography( InputArray _points1, InputArray _points2, { npoints = p.checkVector(3, -1, false); if( npoints < 0 ) - CV_Error(CV_StsBadArg, "The input arrays should be 2D or 3D point sets"); + CV_Error(Error::StsBadArg, "The input arrays should be 2D or 3D point sets"); if( npoints == 0 ) return Mat(); convertPointsFromHomogeneous(p, p); @@ -317,7 +317,7 @@ cv::Mat cv::findHomography( InputArray _points1, InputArray _points2, else if( method == LMEDS ) result = createLMeDSPointSetRegistrator(cb, 4, confidence, maxIters)->run(src, dst, H, tempMask); else - CV_Error(CV_StsBadArg, "Unknown estimation method"); + CV_Error(Error::StsBadArg, "Unknown estimation method"); if( result && npoints > 4 ) { @@ -475,7 +475,7 @@ static int run7Point( const Mat& _m1, const Mat& _m2, Mat& _fmatrix ) return n; } - + static int run8Point( const Mat& _m1, const Mat& _m2, Mat& _fmatrix ) { double a[9*9], w[9], v[9*9]; @@ -585,11 +585,11 @@ static int run8Point( const Mat& _m1, const Mat& _m2, Mat& _fmatrix ) gemm( T2, F0, 1., 0, 0., TF, GEMM_1_T ); F0 = Mat(3, 3, CV_64F, fmatrix); gemm( TF, T1, 1., 0, 0., F0, 0 ); - + // make F(3,3) = 1 if( fabs(F0.at(2,2)) > FLT_EPSILON ) F0 *= 1./F0.at(2,2); - + return 1; } @@ -671,7 +671,7 @@ cv::Mat cv::findFundamentalMat( InputArray _points1, InputArray _points2, { npoints = p.checkVector(3, -1, false); if( npoints < 0 ) - CV_Error(CV_StsBadArg, "The input arrays should be 2D or 3D point sets"); + CV_Error(Error::StsBadArg, "The input arrays should be 2D or 3D point sets"); if( npoints == 0 ) return Mat(); convertPointsFromHomogeneous(p, p); @@ -739,7 +739,7 @@ void cv::computeCorrespondEpilines( InputArray _points, int whichImage, { npoints = points.checkVector(3); if( npoints < 0 ) - CV_Error( CV_StsBadArg, "The input should be a 2D or 3D point set"); + CV_Error( Error::StsBadArg, "The input should be a 2D or 3D point set"); Mat temp; convertPointsFromHomogeneous(points, temp); points = temp; @@ -893,7 +893,7 @@ void cv::convertPointsFromHomogeneous( InputArray _src, OutputArray _dst ) } } else - CV_Error(CV_StsUnsupportedFormat, ""); + CV_Error(Error::StsUnsupportedFormat, ""); } @@ -974,7 +974,7 @@ void cv::convertPointsToHomogeneous( InputArray _src, OutputArray _dst ) } } else - CV_Error(CV_StsUnsupportedFormat, ""); + CV_Error(Error::StsUnsupportedFormat, ""); } diff --git a/modules/calib3d/src/posit.cpp b/modules/calib3d/src/posit.cpp index c8c1c2c2f1..14c33e1e7b 100644 --- a/modules/calib3d/src/posit.cpp +++ b/modules/calib3d/src/posit.cpp @@ -39,6 +39,7 @@ // //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" /* POSIT structure */ struct CvPOSITObject diff --git a/modules/calib3d/src/ptsetreg.cpp b/modules/calib3d/src/ptsetreg.cpp index 6c5f20f7ca..c92d858dc0 100644 --- a/modules/calib3d/src/ptsetreg.cpp +++ b/modules/calib3d/src/ptsetreg.cpp @@ -53,7 +53,7 @@ namespace cv int RANSACUpdateNumIters( double p, double ep, int modelPoints, int maxIters ) { if( modelPoints <= 0 ) - CV_Error( CV_StsOutOfRange, "the number of model points should be positive" ); + CV_Error( Error::StsOutOfRange, "the number of model points should be positive" ); p = MAX(p, 0.); p = MIN(p, 1.); diff --git a/modules/calib3d/src/quadsubpix.cpp b/modules/calib3d/src/quadsubpix.cpp index b2a9ab836b..2e98a462b5 100644 --- a/modules/calib3d/src/quadsubpix.cpp +++ b/modules/calib3d/src/quadsubpix.cpp @@ -108,7 +108,7 @@ static void findCorner(const std::vector& contour, Point2f point, Point min_idx = (int)i; } } - assert(min_idx >= 0); + CV_Assert(min_idx >= 0); // temporary solution, have to make something more precise corner = contour[min_idx]; diff --git a/modules/calib3d/src/solvepnp.cpp b/modules/calib3d/src/solvepnp.cpp index 5bcffb3166..7b5b0d4d6d 100644 --- a/modules/calib3d/src/solvepnp.cpp +++ b/modules/calib3d/src/solvepnp.cpp @@ -43,6 +43,8 @@ #include "precomp.hpp" #include "epnp.h" #include "p3p.h" +#include "opencv2/calib3d/calib3d_c.h" + #include using namespace cv; @@ -57,7 +59,7 @@ bool cv::solvePnP( InputArray _opoints, InputArray _ipoints, _tvec.create(3, 1, CV_64F); Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat(); - if (flags == CV_EPNP) + if (flags == EPNP) { cv::Mat undistortedPoints; cv::undistortPoints(ipoints, undistortedPoints, cameraMatrix, distCoeffs); @@ -68,7 +70,7 @@ bool cv::solvePnP( InputArray _opoints, InputArray _ipoints, cv::Rodrigues(R, rvec); return true; } - else if (flags == CV_P3P) + else if (flags == P3P) { CV_Assert( npoints == 4); cv::Mat undistortedPoints; @@ -81,7 +83,7 @@ bool cv::solvePnP( InputArray _opoints, InputArray _ipoints, cv::Rodrigues(R, rvec); return result; } - else if (flags == CV_ITERATIVE) + else if (flags == ITERATIVE) { CvMat c_objectPoints = opoints, c_imagePoints = ipoints; CvMat c_cameraMatrix = cameraMatrix, c_distCoeffs = distCoeffs; @@ -342,7 +344,7 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints, if (localInliers.size() >= (size_t)pnpransac::MIN_POINTS_COUNT) { - if (flags != CV_P3P) + if (flags != P3P) { int i, pointsCount = (int)localInliers.size(); Mat inlierObjectPoints(1, pointsCount, CV_32FC3), inlierImagePoints(1, pointsCount, CV_32FC2); diff --git a/modules/calib3d/src/stereobm.cpp b/modules/calib3d/src/stereobm.cpp index f073aa9664..1fc193a0a9 100644 --- a/modules/calib3d/src/stereobm.cpp +++ b/modules/calib3d/src/stereobm.cpp @@ -84,7 +84,7 @@ struct StereoBMParams int disp12MaxDiff; int dispType; }; - + static void prefilterNorm( const Mat& src, Mat& dst, int winsize, int ftzero, uchar* buf ) { @@ -783,46 +783,46 @@ public: { params = StereoBMParams(_numDisparities, _SADWindowSize); } - + void compute( InputArray leftarr, InputArray rightarr, OutputArray disparr ) { Mat left0 = leftarr.getMat(), right0 = rightarr.getMat(); int dtype = disparr.fixedType() ? disparr.type() : params.dispType; if (left0.size() != right0.size()) - CV_Error( CV_StsUnmatchedSizes, "All the images must have the same size" ); + CV_Error( Error::StsUnmatchedSizes, "All the images must have the same size" ); if (left0.type() != CV_8UC1 || right0.type() != CV_8UC1) - CV_Error( CV_StsUnsupportedFormat, "Both input images must have CV_8UC1" ); + CV_Error( Error::StsUnsupportedFormat, "Both input images must have CV_8UC1" ); if (dtype != CV_16SC1 && dtype != CV_32FC1) - CV_Error( CV_StsUnsupportedFormat, "Disparity image must have CV_16SC1 or CV_32FC1 format" ); + CV_Error( Error::StsUnsupportedFormat, "Disparity image must have CV_16SC1 or CV_32FC1 format" ); disparr.create(left0.size(), dtype); Mat disp0 = disparr.getMat(); if( params.preFilterType != PREFILTER_NORMALIZED_RESPONSE && params.preFilterType != PREFILTER_XSOBEL ) - CV_Error( CV_StsOutOfRange, "preFilterType must be = CV_STEREO_BM_NORMALIZED_RESPONSE" ); + CV_Error( Error::StsOutOfRange, "preFilterType must be = CV_STEREO_BM_NORMALIZED_RESPONSE" ); if( params.preFilterSize < 5 || params.preFilterSize > 255 || params.preFilterSize % 2 == 0 ) - CV_Error( CV_StsOutOfRange, "preFilterSize must be odd and be within 5..255" ); + CV_Error( Error::StsOutOfRange, "preFilterSize must be odd and be within 5..255" ); if( params.preFilterCap < 1 || params.preFilterCap > 63 ) - CV_Error( CV_StsOutOfRange, "preFilterCap must be within 1..63" ); + CV_Error( Error::StsOutOfRange, "preFilterCap must be within 1..63" ); if( params.SADWindowSize < 5 || params.SADWindowSize > 255 || params.SADWindowSize % 2 == 0 || params.SADWindowSize >= std::min(left0.cols, left0.rows) ) - CV_Error( CV_StsOutOfRange, "SADWindowSize must be odd, be within 5..255 and be not larger than image width or height" ); + CV_Error( Error::StsOutOfRange, "SADWindowSize must be odd, be within 5..255 and be not larger than image width or height" ); if( params.numDisparities <= 0 || params.numDisparities % 16 != 0 ) - CV_Error( CV_StsOutOfRange, "numDisparities must be positive and divisble by 16" ); + CV_Error( Error::StsOutOfRange, "numDisparities must be positive and divisble by 16" ); if( params.textureThreshold < 0 ) - CV_Error( CV_StsOutOfRange, "texture threshold must be non-negative" ); + CV_Error( Error::StsOutOfRange, "texture threshold must be non-negative" ); if( params.uniquenessRatio < 0 ) - CV_Error( CV_StsOutOfRange, "uniqueness ratio must be non-negative" ); + CV_Error( Error::StsOutOfRange, "uniqueness ratio must be non-negative" ); preFilteredImg0.create( left0.size(), CV_8U ); preFilteredImg1.create( left0.size(), CV_8U ); @@ -887,15 +887,15 @@ public: R2.area() > 0 ? Rect(0, 0, width, height) : validDisparityRect, params.minDisparity, params.numDisparities, params.SADWindowSize); - + parallel_for_(Range(0, nstripes), FindStereoCorrespInvoker(left, right, disp, ¶ms, nstripes, bufSize0, useShorts, validDisparityRect, slidingSumBuf, cost)); - + if( params.speckleRange >= 0 && params.speckleWindowSize > 0 ) filterSpeckles(disp, FILTERED, params.speckleWindowSize, params.speckleRange, slidingSumBuf); - + if (disp0.data != disp.data) disp.convertTo(disp0, disp0.type(), 1./(1 << DISPARITY_SHIFT), 0); } @@ -963,7 +963,7 @@ public: void read(const FileNode& fn) { FileNode n = fn["name"]; - CV_Assert( n.isString() && strcmp(n.node->data.str.ptr, name_) == 0 ); + CV_Assert( n.isString() && String(n) == name_ ); params.minDisparity = (int)fn["minDisparity"]; params.numDisparities = (int)fn["numDisparities"]; params.SADWindowSize = (int)fn["blockSize"]; diff --git a/modules/calib3d/src/stereosgbm.cpp b/modules/calib3d/src/stereosgbm.cpp index 160d92637c..508eb59b1f 100644 --- a/modules/calib3d/src/stereosgbm.cpp +++ b/modules/calib3d/src/stereosgbm.cpp @@ -919,7 +919,7 @@ public: void read(const FileNode& fn) { FileNode n = fn["name"]; - CV_Assert( n.isString() && strcmp(n.node->data.str.ptr, name_) == 0 ); + CV_Assert( n.isString() && String(n) == name_ ); params.minDisparity = (int)fn["minDisparity"]; params.numDisparities = (int)fn["numDisparities"]; params.SADWindowSize = (int)fn["blockSize"]; diff --git a/modules/calib3d/src/triangulate.cpp b/modules/calib3d/src/triangulate.cpp index 9f52b37163..59c7c0f2be 100644 --- a/modules/calib3d/src/triangulate.cpp +++ b/modules/calib3d/src/triangulate.cpp @@ -40,6 +40,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" // cvCorrectMatches function is Copyright (C) 2009, Jostein Austvik Jacobsen. // cvTriangulatePoints function is derived from icvReconstructPointsFor3View, originally by Valery Mosyagin. diff --git a/modules/calib3d/test/test_cameracalibration.cpp b/modules/calib3d/test/test_cameracalibration.cpp index e8b5570949..fb82382377 100644 --- a/modules/calib3d/test/test_cameracalibration.cpp +++ b/modules/calib3d/test/test_cameracalibration.cpp @@ -40,6 +40,7 @@ //M*/ #include "test_precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include diff --git a/modules/calib3d/test/test_cameracalibration_artificial.cpp b/modules/calib3d/test/test_cameracalibration_artificial.cpp index 811e7002e6..1ff13c9e87 100644 --- a/modules/calib3d/test/test_cameracalibration_artificial.cpp +++ b/modules/calib3d/test/test_cameracalibration_artificial.cpp @@ -327,7 +327,7 @@ protected: Mat camMat_est = Mat::eye(3, 3, CV_64F), distCoeffs_est = Mat::zeros(1, 5, CV_64F); vector rvecs_est, tvecs_est; - int flags = /*CV_CALIB_FIX_K3|*/CV_CALIB_FIX_K4|CV_CALIB_FIX_K5|CV_CALIB_FIX_K6; //CALIB_FIX_K3; //CALIB_FIX_ASPECT_RATIO | | CALIB_ZERO_TANGENT_DIST; + int flags = /*CALIB_FIX_K3|*/CALIB_FIX_K4|CALIB_FIX_K5|CALIB_FIX_K6; //CALIB_FIX_K3; //CALIB_FIX_ASPECT_RATIO | | CALIB_ZERO_TANGENT_DIST; TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, DBL_EPSILON); double rep_error = calibrateCamera(objectPoints, imagePoints, imgSize, camMat_est, distCoeffs_est, rvecs_est, tvecs_est, flags, criteria); rep_error /= brdsNum * cornersSize.area(); diff --git a/modules/calib3d/test/test_cameracalibration_badarg.cpp b/modules/calib3d/test/test_cameracalibration_badarg.cpp index b805e71a49..91118e1ed2 100644 --- a/modules/calib3d/test/test_cameracalibration_badarg.cpp +++ b/modules/calib3d/test/test_cameracalibration_badarg.cpp @@ -41,6 +41,7 @@ #include "test_precomp.hpp" #include "test_chessboardgenerator.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include diff --git a/modules/calib3d/test/test_chessboardgenerator.cpp b/modules/calib3d/test/test_chessboardgenerator.cpp index 7c761fc572..3a5ebbc3a0 100644 --- a/modules/calib3d/test/test_chessboardgenerator.cpp +++ b/modules/calib3d/test/test_chessboardgenerator.cpp @@ -161,15 +161,15 @@ Mat cv::ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat if (rendererResolutionMultiplier == 1) { result = bg.clone(); - drawContours(result, whole_contour, -1, Scalar::all(255), CV_FILLED, CV_AA); - drawContours(result, squares_black, -1, Scalar::all(0), CV_FILLED, CV_AA); + drawContours(result, whole_contour, -1, Scalar::all(255), FILLED, LINE_AA); + drawContours(result, squares_black, -1, Scalar::all(0), FILLED, LINE_AA); } else { Mat tmp; resize(bg, tmp, bg.size() * rendererResolutionMultiplier); - drawContours(tmp, whole_contour, -1, Scalar::all(255), CV_FILLED, CV_AA); - drawContours(tmp, squares_black, -1, Scalar::all(0), CV_FILLED, CV_AA); + drawContours(tmp, whole_contour, -1, Scalar::all(255), FILLED, LINE_AA); + drawContours(tmp, squares_black, -1, Scalar::all(0), FILLED, LINE_AA); resize(tmp, result, bg.size(), 0, 0, INTER_AREA); } diff --git a/modules/calib3d/test/test_chesscorners.cpp b/modules/calib3d/test/test_chesscorners.cpp index bbc792ea5b..f9625d540a 100644 --- a/modules/calib3d/test/test_chesscorners.cpp +++ b/modules/calib3d/test/test_chesscorners.cpp @@ -57,14 +57,14 @@ void show_points( const Mat& gray, const Mat& u, const vector& v, Size merge(vector(3, gray), rgb); for(size_t i = 0; i < v.size(); i++ ) - circle( rgb, v[i], 3, CV_RGB(255, 0, 0), CV_FILLED); + circle( rgb, v[i], 3, Scalar(255, 0, 0), FILLED); if( !u.empty() ) { const Point2f* u_data = u.ptr(); size_t count = u.cols * u.rows; for(size_t i = 0; i < count; i++ ) - circle( rgb, u_data[i], 3, CV_RGB(0, 255, 0), CV_FILLED); + circle( rgb, u_data[i], 3, Scalar(0, 255, 0), FILLED); } if (!v.empty()) { @@ -208,7 +208,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename ) } int progress = 0; - int max_idx = board_list.node->data.seq->total/2; + int max_idx = board_list.size()/2; double sum_error = 0.0; int count = 0; @@ -244,7 +244,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename ) switch( pattern ) { case CHESSBOARD: - result = findChessboardCorners(gray, pattern_size, v, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE); + result = findChessboardCorners(gray, pattern_size, v, CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_NORMALIZE_IMAGE); break; case CIRCLES_GRID: result = findCirclesGrid(gray, pattern_size, v); @@ -459,7 +459,7 @@ bool CV_ChessboardDetectorTest::checkByGenerator() vector& cnt = cnts[0]; cnt.push_back(cg[ 0]); cnt.push_back(cg[0+2]); cnt.push_back(cg[7+0]); cnt.push_back(cg[7+2]); - cv::drawContours(cb, cnts, -1, Scalar::all(128), CV_FILLED); + cv::drawContours(cb, cnts, -1, Scalar::all(128), FILLED); found = findChessboardCorners(cb, cbg.cornersSize(), corners_found); if (found) diff --git a/modules/calib3d/test/test_chesscorners_badarg.cpp b/modules/calib3d/test/test_chesscorners_badarg.cpp index d7c4c4f4ce..318912eeb4 100644 --- a/modules/calib3d/test/test_chesscorners_badarg.cpp +++ b/modules/calib3d/test/test_chesscorners_badarg.cpp @@ -41,6 +41,7 @@ #include "test_precomp.hpp" #include "test_chessboardgenerator.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include diff --git a/modules/calib3d/test/test_chesscorners_timing.cpp b/modules/calib3d/test/test_chesscorners_timing.cpp index 7dffd597e3..47653f88d8 100644 --- a/modules/calib3d/test/test_chesscorners_timing.cpp +++ b/modules/calib3d/test/test_chesscorners_timing.cpp @@ -41,6 +41,7 @@ #include "test_precomp.hpp" #include "opencv2/imgproc/imgproc_c.h" +#include "opencv2/calib3d/calib3d_c.h" class CV_ChessboardDetectorTimingTest : public cvtest::BaseTest { diff --git a/modules/calib3d/test/test_fundam.cpp b/modules/calib3d/test/test_fundam.cpp index 67a8a98d54..7e6f9a8e71 100644 --- a/modules/calib3d/test/test_fundam.cpp +++ b/modules/calib3d/test/test_fundam.cpp @@ -40,6 +40,7 @@ //M*/ #include "test_precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" using namespace cv; using namespace std; diff --git a/modules/calib3d/test/test_homography.cpp b/modules/calib3d/test/test_homography.cpp index f68af1d7c1..5bb50bb265 100644 --- a/modules/calib3d/test/test_homography.cpp +++ b/modules/calib3d/test/test_homography.cpp @@ -65,7 +65,7 @@ #define METHODS_COUNT 3 int NORM_TYPE[COUNT_NORM_TYPES] = {cv::NORM_L1, cv::NORM_L2, cv::NORM_INF}; -int METHOD[METHODS_COUNT] = {0, CV_RANSAC, CV_LMEDS}; +int METHOD[METHODS_COUNT] = {0, cv::RANSAC, cv::LMEDS}; using namespace cv; using namespace std; @@ -309,7 +309,7 @@ void CV_HomographyTest::run(int) switch (method) { case 0: - case CV_LMEDS: + case LMEDS: { Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f, method), cv::findHomography(src_mat_2f, dst_vec, method), @@ -339,14 +339,14 @@ void CV_HomographyTest::run(int) continue; } - case CV_RANSAC: + case RANSAC: { cv::Mat mask [4]; double diff; - Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f, CV_RANSAC, reproj_threshold, mask[0]), - cv::findHomography(src_mat_2f, dst_vec, CV_RANSAC, reproj_threshold, mask[1]), - cv::findHomography(src_vec, dst_mat_2f, CV_RANSAC, reproj_threshold, mask[2]), - cv::findHomography(src_vec, dst_vec, CV_RANSAC, reproj_threshold, mask[3]) }; + Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f, RANSAC, reproj_threshold, mask[0]), + cv::findHomography(src_mat_2f, dst_vec, RANSAC, reproj_threshold, mask[1]), + cv::findHomography(src_vec, dst_mat_2f, RANSAC, reproj_threshold, mask[2]), + cv::findHomography(src_vec, dst_vec, RANSAC, reproj_threshold, mask[3]) }; for (int j = 0; j < 4; ++j) { @@ -411,7 +411,7 @@ void CV_HomographyTest::run(int) switch (method) { case 0: - case CV_LMEDS: + case LMEDS: { Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f), cv::findHomography(src_mat_2f, dst_vec), @@ -466,14 +466,14 @@ void CV_HomographyTest::run(int) continue; } - case CV_RANSAC: + case RANSAC: { cv::Mat mask_res [4]; - Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f, CV_RANSAC, reproj_threshold, mask_res[0]), - cv::findHomography(src_mat_2f, dst_vec, CV_RANSAC, reproj_threshold, mask_res[1]), - cv::findHomography(src_vec, dst_mat_2f, CV_RANSAC, reproj_threshold, mask_res[2]), - cv::findHomography(src_vec, dst_vec, CV_RANSAC, reproj_threshold, mask_res[3]) }; + Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f, RANSAC, reproj_threshold, mask_res[0]), + cv::findHomography(src_mat_2f, dst_vec, RANSAC, reproj_threshold, mask_res[1]), + cv::findHomography(src_vec, dst_mat_2f, RANSAC, reproj_threshold, mask_res[2]), + cv::findHomography(src_vec, dst_vec, RANSAC, reproj_threshold, mask_res[3]) }; for (int j = 0; j < 4; ++j) { diff --git a/modules/calib3d/test/test_posit.cpp b/modules/calib3d/test/test_posit.cpp index 186c4f2d4c..8a77d19ad8 100644 --- a/modules/calib3d/test/test_posit.cpp +++ b/modules/calib3d/test/test_posit.cpp @@ -40,6 +40,7 @@ //M*/ #include "test_precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" using namespace cv; using namespace std; diff --git a/modules/calib3d/test/test_reproject_image_to_3d.cpp b/modules/calib3d/test/test_reproject_image_to_3d.cpp index a93804f74e..3b44566abe 100644 --- a/modules/calib3d/test/test_reproject_image_to_3d.cpp +++ b/modules/calib3d/test/test_reproject_image_to_3d.cpp @@ -41,6 +41,7 @@ //M*/ #include "test_precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include #include diff --git a/modules/calib3d/test/test_solvepnp_ransac.cpp b/modules/calib3d/test/test_solvepnp_ransac.cpp index 7e93369676..c0aff188db 100644 --- a/modules/calib3d/test/test_solvepnp_ransac.cpp +++ b/modules/calib3d/test/test_solvepnp_ransac.cpp @@ -54,9 +54,9 @@ class CV_solvePnPRansac_Test : public cvtest::BaseTest public: CV_solvePnPRansac_Test() { - eps[CV_ITERATIVE] = 1.0e-2; - eps[CV_EPNP] = 1.0e-2; - eps[CV_P3P] = 1.0e-2; + eps[ITERATIVE] = 1.0e-2; + eps[EPNP] = 1.0e-2; + eps[P3P] = 1.0e-2; totalTestsCount = 10; } ~CV_solvePnPRansac_Test() {} @@ -193,9 +193,9 @@ class CV_solvePnP_Test : public CV_solvePnPRansac_Test public: CV_solvePnP_Test() { - eps[CV_ITERATIVE] = 1.0e-6; - eps[CV_EPNP] = 1.0e-6; - eps[CV_P3P] = 1.0e-4; + eps[ITERATIVE] = 1.0e-6; + eps[EPNP] = 1.0e-6; + eps[P3P] = 1.0e-4; totalTestsCount = 1000; } diff --git a/modules/calib3d/test/test_stereomatching.cpp b/modules/calib3d/test/test_stereomatching.cpp index 4e58fcadf7..8e1120e475 100644 --- a/modules/calib3d/test/test_stereomatching.cpp +++ b/modules/calib3d/test/test_stereomatching.cpp @@ -75,7 +75,7 @@ void computeTextureBasedMasks( const Mat& _img, Mat* texturelessMask, Mat* textu if( !texturelessMask && !texturedMask ) return; if( _img.empty() ) - CV_Error( CV_StsBadArg, "img is empty" ); + CV_Error( Error::StsBadArg, "img is empty" ); Mat img = _img; if( _img.channels() > 1) @@ -95,21 +95,21 @@ void computeTextureBasedMasks( const Mat& _img, Mat* texturelessMask, Mat* textu void checkTypeAndSizeOfDisp( const Mat& dispMap, const Size* sz ) { if( dispMap.empty() ) - CV_Error( CV_StsBadArg, "dispMap is empty" ); + CV_Error( Error::StsBadArg, "dispMap is empty" ); if( dispMap.type() != CV_32FC1 ) - CV_Error( CV_StsBadArg, "dispMap must have CV_32FC1 type" ); + CV_Error( Error::StsBadArg, "dispMap must have CV_32FC1 type" ); if( sz && (dispMap.rows != sz->height || dispMap.cols != sz->width) ) - CV_Error( CV_StsBadArg, "dispMap has incorrect size" ); + CV_Error( Error::StsBadArg, "dispMap has incorrect size" ); } void checkTypeAndSizeOfMask( const Mat& mask, Size sz ) { if( mask.empty() ) - CV_Error( CV_StsBadArg, "mask is empty" ); + CV_Error( Error::StsBadArg, "mask is empty" ); if( mask.type() != CV_8UC1 ) - CV_Error( CV_StsBadArg, "mask must have CV_8UC1 type" ); + CV_Error( Error::StsBadArg, "mask must have CV_8UC1 type" ); if( mask.rows != sz.height || mask.cols != sz.width ) - CV_Error( CV_StsBadArg, "mask has incorrect size" ); + CV_Error( Error::StsBadArg, "mask has incorrect size" ); } void checkDispMapsAndUnknDispMasks( const Mat& leftDispMap, const Mat& rightDispMap, @@ -143,7 +143,7 @@ void checkDispMapsAndUnknDispMasks( const Mat& leftDispMap, const Mat& rightDisp minMaxLoc( rightDispMap, &rightMinVal, 0, 0, 0, ~rightUnknDispMask ); } if( leftMinVal < 0 || rightMinVal < 0) - CV_Error( CV_StsBadArg, "known disparity values must be positive" ); + CV_Error( Error::StsBadArg, "known disparity values must be positive" ); } /* @@ -163,7 +163,7 @@ void computeOcclusionBasedMasks( const Mat& leftDisp, const Mat& _rightDisp, if( _rightDisp.empty() ) { if( !rightUnknDispMask.empty() ) - CV_Error( CV_StsBadArg, "rightUnknDispMask must be empty if _rightDisp is empty" ); + CV_Error( Error::StsBadArg, "rightUnknDispMask must be empty if _rightDisp is empty" ); rightDisp.create(leftDisp.size(), CV_32FC1); rightDisp.setTo(Scalar::all(0) ); for( int leftY = 0; leftY < leftDisp.rows; leftY++ ) @@ -230,9 +230,9 @@ void computeDepthDiscontMask( const Mat& disp, Mat& depthDiscontMask, const Mat& float dispGap = EVAL_DISP_GAP, int discontWidth = EVAL_DISCONT_WIDTH ) { if( disp.empty() ) - CV_Error( CV_StsBadArg, "disp is empty" ); + CV_Error( Error::StsBadArg, "disp is empty" ); if( disp.type() != CV_32FC1 ) - CV_Error( CV_StsBadArg, "disp must have CV_32FC1 type" ); + CV_Error( Error::StsBadArg, "disp must have CV_32FC1 type" ); if( !unknDispMask.empty() ) checkTypeAndSizeOfMask( unknDispMask, disp.size() ); @@ -571,9 +571,9 @@ int CV_StereoMatchingTest::processStereoMatchingResults( FileStorage& fs, int ca if( isWrite ) { fs << caseNames[caseIdx] << "{"; - cvWriteComment( fs.fs, RMS_STR.c_str(), 0 ); + //cvWriteComment( fs.fs, RMS_STR.c_str(), 0 ); writeErrors( RMS_STR, rmss, &fs ); - cvWriteComment( fs.fs, BAD_PXLS_FRACTION_STR.c_str(), 0 ); + //cvWriteComment( fs.fs, BAD_PXLS_FRACTION_STR.c_str(), 0 ); writeErrors( BAD_PXLS_FRACTION_STR, badPxlsFractions, &fs ); fs << "}"; // datasetName } diff --git a/modules/contrib/include/opencv2/contrib.hpp b/modules/contrib/include/opencv2/contrib.hpp index dc4a72ae1a..35bac1b90a 100644 --- a/modules/contrib/include/opencv2/contrib.hpp +++ b/modules/contrib/include/opencv2/contrib.hpp @@ -48,6 +48,8 @@ #include "opencv2/features2d.hpp" #include "opencv2/objdetect.hpp" +#include "opencv2/core/core_c.h" + #include #ifdef __cplusplus diff --git a/modules/contrib/src/ba.cpp b/modules/contrib/src/ba.cpp index fb361d49c2..8e4faf2216 100644 --- a/modules/contrib/src/ba.cpp +++ b/modules/contrib/src/ba.cpp @@ -41,6 +41,7 @@ #include "precomp.hpp" #include "opencv2/calib3d.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include using namespace cv; diff --git a/modules/contrib/src/colortracker.cpp b/modules/contrib/src/colortracker.cpp index 5a9d9b7c43..c1d91bb9b8 100644 --- a/modules/contrib/src/colortracker.cpp +++ b/modules/contrib/src/colortracker.cpp @@ -60,7 +60,7 @@ void CvMeanShiftTracker::newTrackingWindow(Mat image, Rect selection) float srange[] = { 0, 1 }; const float* ranges[] = {hrange, srange}; - cvtColor(image, hsv, CV_BGR2HSV); + cvtColor(image, hsv, COLOR_BGR2HSV); inRange(hsv, Scalar(0, 30, MIN(10, 256)), Scalar(180, 256, MAX(10, 256)), mask); hue.create(hsv.size(), CV_8UC2); @@ -83,7 +83,7 @@ RotatedRect CvMeanShiftTracker::updateTrackingWindow(Mat image) float srange[] = { 0, 1 }; const float* ranges[] = {hrange, srange}; - cvtColor(image, hsv, CV_BGR2HSV); + cvtColor(image, hsv, COLOR_BGR2HSV); inRange(hsv, Scalar(0, 30, MIN(10, 256)), Scalar(180, 256, MAX(10, 256)), mask); hue.create(hsv.size(), CV_8UC2); mixChannels(&hsv, 1, &hue, 1, channels, 2); diff --git a/modules/contrib/src/featuretracker.cpp b/modules/contrib/src/featuretracker.cpp index 575f69abf9..4350aec467 100644 --- a/modules/contrib/src/featuretracker.cpp +++ b/modules/contrib/src/featuretracker.cpp @@ -80,7 +80,7 @@ CvFeatureTracker::~CvFeatureTracker() void CvFeatureTracker::newTrackingWindow(Mat image, Rect selection) { image.copyTo(prev_image); - cvtColor(prev_image, prev_image_bw, CV_BGR2GRAY); + cvtColor(prev_image, prev_image_bw, COLOR_BGR2GRAY); prev_trackwindow = selection; prev_center.x = selection.x; prev_center.y = selection.y; @@ -131,7 +131,7 @@ Rect CvFeatureTracker::updateTrackingWindowWithSIFT(Mat image) curr_keys.push_back(curr_keypoints[matches[i].trainIdx].pt); } - Mat T = findHomography(prev_keys, curr_keys, CV_LMEDS); + Mat T = findHomography(prev_keys, curr_keys, LMEDS); prev_trackwindow.x += cvRound(T.at (0, 2)); prev_trackwindow.y += cvRound(T.at (1, 2)); @@ -148,12 +148,12 @@ Rect CvFeatureTracker::updateTrackingWindowWithFlow(Mat image) ittr++; Size subPixWinSize(10,10), winSize(31,31); Mat image_bw; - TermCriteria termcrit(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03); + TermCriteria termcrit(TermCriteria::COUNT | TermCriteria::EPS, 20, 0.03); std::vector status; std::vector err; - cvtColor(image, image_bw, CV_BGR2GRAY); - cvtColor(prev_image, prev_image_bw, CV_BGR2GRAY); + cvtColor(image, image_bw, COLOR_BGR2GRAY); + cvtColor(prev_image, prev_image_bw, COLOR_BGR2GRAY); if (ittr == 1) { diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp index 8fc875ac8c..9833315d56 100644 --- a/modules/core/include/opencv2/core.hpp +++ b/modules/core/include/opencv2/core.hpp @@ -109,6 +109,52 @@ public: CV_EXPORTS void error( const Exception& exc ); +enum { SORT_EVERY_ROW = 0, + SORT_EVERY_COLUMN = 1, + SORT_ASCENDING = 0, + SORT_DESCENDING = 16 + }; + +enum { COVAR_SCRAMBLED = 0, + COVAR_NORMAL = 1, + COVAR_USE_AVG = 2, + COVAR_SCALE = 4, + COVAR_ROWS = 8, + COVAR_COLS = 16 + }; + +/*! + k-Means flags +*/ +enum { KMEANS_RANDOM_CENTERS = 0, // Chooses random centers for k-Means initialization + KMEANS_PP_CENTERS = 2, // Uses k-Means++ algorithm for initialization + KMEANS_USE_INITIAL_LABELS = 1 // Uses the user-provided labels for K-Means initialization + }; + +enum { FILLED = -1, + LINE_4 = 4, + LINE_8 = 8, + LINE_AA = 16 + }; + +enum { FONT_HERSHEY_SIMPLEX = 0, + FONT_HERSHEY_PLAIN = 1, + FONT_HERSHEY_DUPLEX = 2, + FONT_HERSHEY_COMPLEX = 3, + FONT_HERSHEY_TRIPLEX = 4, + FONT_HERSHEY_COMPLEX_SMALL = 5, + FONT_HERSHEY_SCRIPT_SIMPLEX = 6, + FONT_HERSHEY_SCRIPT_COMPLEX = 7, + FONT_ITALIC = 16 + }; + +enum { REDUCE_SUM = 0, + REDUCE_AVG = 1, + REDUCE_MAX = 2, + REDUCE_MIN = 3 + }; + + //! swaps two matrices CV_EXPORTS void swap(Mat& a, Mat& b); @@ -371,14 +417,6 @@ CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags = DECOMP_L CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags = DECOMP_LU); -enum -{ - SORT_EVERY_ROW = 0, - SORT_EVERY_COLUMN = 1, - SORT_ASCENDING = 0, - SORT_DESCENDING = 16 -}; - //! sorts independently each matrix row or each matrix column CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags); @@ -395,16 +433,6 @@ CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors = noArray()); -enum -{ - COVAR_SCRAMBLED = 0, - COVAR_NORMAL = 1, - COVAR_USE_AVG = 2, - COVAR_SCALE = 4, - COVAR_ROWS = 8, - COVAR_COLS = 16 -}; - //! computes covariation matrix of a set of samples CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F); //TODO: InputArrayOfArrays @@ -454,16 +482,6 @@ CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c, //! computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently CV_EXPORTS_W int getOptimalDFTSize(int vecsize); -/*! - k-Means flags -*/ -enum -{ - KMEANS_RANDOM_CENTERS = 0, // Chooses random centers for k-Means initialization - KMEANS_PP_CENTERS = 2, // Uses k-Means++ algorithm for initialization - KMEANS_USE_INITIAL_LABELS = 1 // Uses the user-provided labels for K-Means initialization -}; - //! clusters the input data using k-Means algorithm CV_EXPORTS_W double kmeans( InputArray data, int K, InputOutputArray bestLabels, TermCriteria criteria, int attempts, @@ -481,12 +499,6 @@ CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev //! shuffles the input array elements CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1., RNG* rng = 0); -enum { FILLED = -1, - LINE_4 = 4, - LINE_8 = 8, - LINE_AA = 16 - }; - //! draws the line segment (pt1, pt2) in the image CV_EXPORTS_W void line(CV_IN_OUT Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness = 1, int lineType = LINE_8, int shift = 0); @@ -562,19 +574,6 @@ CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, CV_OUT std::vector& pts ); -enum -{ - FONT_HERSHEY_SIMPLEX = 0, - FONT_HERSHEY_PLAIN = 1, - FONT_HERSHEY_DUPLEX = 2, - FONT_HERSHEY_COMPLEX = 3, - FONT_HERSHEY_TRIPLEX = 4, - FONT_HERSHEY_COMPLEX_SMALL = 5, - FONT_HERSHEY_SCRIPT_SIMPLEX = 6, - FONT_HERSHEY_SCRIPT_COMPLEX = 7, - FONT_ITALIC = 16 -}; - //! renders text string in the image CV_EXPORTS_W void putText( Mat& img, const String& text, Point org, int fontFace, double fontScale, Scalar color, @@ -694,7 +693,10 @@ public: class CV_EXPORTS SVD { public: - enum { MODIFY_A = 1, NO_UV = 2, FULL_UV = 4 }; + enum { MODIFY_A = 1, + NO_UV = 2, + FULL_UV = 4 + }; //! the default constructor SVD(); @@ -861,7 +863,9 @@ public: class CV_EXPORTS RNG { public: - enum { UNIFORM = 0, NORMAL = 1 }; + enum { UNIFORM = 0, + NORMAL = 1 + }; RNG(); RNG(uint64 state); diff --git a/modules/core/include/opencv2/core/base.hpp b/modules/core/include/opencv2/core/base.hpp index 5cce1db148..eb635a76ae 100644 --- a/modules/core/include/opencv2/core/base.hpp +++ b/modules/core/include/opencv2/core/base.hpp @@ -109,7 +109,8 @@ enum { GpuNotSupported= -216, GpuApiCallError= -217, OpenGlNotSupported= -218, - OpenGlApiCallError= -219 + OpenGlApiCallError= -219, + OpenCLApiCallError= -220 }; } //Error diff --git a/modules/features2d/include/opencv2/features2d.hpp b/modules/features2d/include/opencv2/features2d.hpp index 5997668fee..301b216d98 100644 --- a/modules/features2d/include/opencv2/features2d.hpp +++ b/modules/features2d/include/opencv2/features2d.hpp @@ -43,10 +43,8 @@ #ifndef __OPENCV_FEATURES_2D_HPP__ #define __OPENCV_FEATURES_2D_HPP__ -#ifdef __cplusplus #include "opencv2/core.hpp" #include "opencv2/flann/miniflann.hpp" -#include namespace cv { @@ -1521,8 +1519,4 @@ protected: } /* namespace cv */ -#endif /* __cplusplus */ - #endif - -/* End of file. */ diff --git a/modules/imgproc/src/gcgraph.hpp b/modules/imgproc/src/gcgraph.hpp index 59c9744e7b..f93bd19a20 100644 --- a/modules/imgproc/src/gcgraph.hpp +++ b/modules/imgproc/src/gcgraph.hpp @@ -241,7 +241,7 @@ TWeight GCGraph::maxFlow() // find the minimum edge weight along the path minWeight = edgePtr[e0].weight; - assert( minWeight > 0 ); + CV_Assert( minWeight > 0 ); // k = 1: source tree, k = 0: destination tree for( int k = 1; k >= 0; k-- ) { @@ -251,11 +251,11 @@ TWeight GCGraph::maxFlow() break; weight = edgePtr[ei^k].weight; minWeight = MIN(minWeight, weight); - assert( minWeight > 0 ); + CV_Assert( minWeight > 0 ); } weight = fabs(v->weight); minWeight = MIN(minWeight, weight); - assert( minWeight > 0 ); + CV_Assert( minWeight > 0 ); } // modify weights of the edges along the path and collect orphans diff --git a/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java b/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java index 8bcaf58a05..e6520a43d7 100644 --- a/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java +++ b/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java @@ -188,13 +188,13 @@ public class Calib3dTest extends OpenCVTestCase { assertTrue(!corners.empty()); } - public void testFindCirclesGridDefaultMatSizeMat() { + public void testFindCirclesGridMatSizeMat() { int size = 300; Mat img = new Mat(size, size, CvType.CV_8U); img.setTo(new Scalar(255)); Mat centers = new Mat(); - assertFalse(Calib3d.findCirclesGridDefault(img, new Size(5, 5), centers)); + assertFalse(Calib3d.findCirclesGrid(img, new Size(5, 5), centers)); for (int i = 0; i < 5; i++) for (int j = 0; j < 5; j++) { @@ -202,20 +202,20 @@ public class Calib3dTest extends OpenCVTestCase { Core.circle(img, pt, 10, new Scalar(0), -1); } - assertTrue(Calib3d.findCirclesGridDefault(img, new Size(5, 5), centers)); + assertTrue(Calib3d.findCirclesGrid(img, new Size(5, 5), centers)); assertEquals(25, centers.rows()); assertEquals(1, centers.cols()); assertEquals(CvType.CV_32FC2, centers.type()); } - public void testFindCirclesGridDefaultMatSizeMatInt() { + public void testFindCirclesGridMatSizeMatInt() { int size = 300; Mat img = new Mat(size, size, CvType.CV_8U); img.setTo(new Scalar(255)); Mat centers = new Mat(); - assertFalse(Calib3d.findCirclesGridDefault(img, new Size(3, 5), centers, Calib3d.CALIB_CB_CLUSTERING + assertFalse(Calib3d.findCirclesGrid(img, new Size(3, 5), centers, Calib3d.CALIB_CB_CLUSTERING | Calib3d.CALIB_CB_ASYMMETRIC_GRID)); int step = size * 2 / 15; @@ -227,7 +227,7 @@ public class Calib3dTest extends OpenCVTestCase { Core.circle(img, pt, 10, new Scalar(0), -1); } - assertTrue(Calib3d.findCirclesGridDefault(img, new Size(3, 5), centers, Calib3d.CALIB_CB_CLUSTERING + assertTrue(Calib3d.findCirclesGrid(img, new Size(3, 5), centers, Calib3d.CALIB_CB_CLUSTERING | Calib3d.CALIB_CB_ASYMMETRIC_GRID)); assertEquals(15, centers.rows()); diff --git a/modules/legacy/include/opencv2/legacy.hpp b/modules/legacy/include/opencv2/legacy.hpp index 29714f25eb..ed0ac9cc34 100644 --- a/modules/legacy/include/opencv2/legacy.hpp +++ b/modules/legacy/include/opencv2/legacy.hpp @@ -43,11 +43,11 @@ #define __OPENCV_LEGACY_HPP__ #include "opencv2/imgproc/imgproc_c.h" -#include "opencv2/features2d.hpp" -#include "opencv2/calib3d.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include "opencv2/ml.hpp" #ifdef __cplusplus +#include "opencv2/features2d.hpp" extern "C" { #endif diff --git a/modules/legacy/src/3dtracker.cpp b/modules/legacy/src/3dtracker.cpp index ae3742b470..a55a9f8516 100644 --- a/modules/legacy/src/3dtracker.cpp +++ b/modules/legacy/src/3dtracker.cpp @@ -40,6 +40,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" #include #include diff --git a/modules/legacy/src/blobtrackpostprockalman.cpp b/modules/legacy/src/blobtrackpostprockalman.cpp index debe89d3f5..fb6f8dee9f 100644 --- a/modules/legacy/src/blobtrackpostprockalman.cpp +++ b/modules/legacy/src/blobtrackpostprockalman.cpp @@ -39,6 +39,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/video/tracking_c.h" /*======================= KALMAN FILTER =========================*/ /* State vector is (x,y,w,h,dx,dy,dw,dh). */ diff --git a/modules/legacy/src/camshift.cpp b/modules/legacy/src/camshift.cpp index 830e198249..b3cd9974a4 100644 --- a/modules/legacy/src/camshift.cpp +++ b/modules/legacy/src/camshift.cpp @@ -39,6 +39,7 @@ // //M*/ #include "precomp.hpp" +#include "opencv2/video/tracking_c.h" CvCamShiftTracker::CvCamShiftTracker() { diff --git a/modules/legacy/src/compat.cpp b/modules/legacy/src/compat.cpp index 5e7a0d6c6a..52e05b99ff 100644 --- a/modules/legacy/src/compat.cpp +++ b/modules/legacy/src/compat.cpp @@ -41,6 +41,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" CvMat cvMatArray( int rows, int cols, int type, int count, void* data) diff --git a/modules/legacy/src/planardetect.cpp b/modules/legacy/src/planardetect.cpp index a9e3190cbc..2bffea0ed7 100644 --- a/modules/legacy/src/planardetect.cpp +++ b/modules/legacy/src/planardetect.cpp @@ -41,6 +41,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d.hpp" #include namespace cv diff --git a/modules/legacy/src/trifocal.cpp b/modules/legacy/src/trifocal.cpp index a8ad68628e..c8e7b0896a 100644 --- a/modules/legacy/src/trifocal.cpp +++ b/modules/legacy/src/trifocal.cpp @@ -40,6 +40,7 @@ //M*/ #include "precomp.hpp" +#include "opencv2/calib3d/calib3d_c.h" //#include "cvtypes.h" #include diff --git a/modules/legacy/test/test_optflow.cpp b/modules/legacy/test/test_optflow.cpp index f72d4c36af..99645410fe 100644 --- a/modules/legacy/test/test_optflow.cpp +++ b/modules/legacy/test/test_optflow.cpp @@ -42,6 +42,7 @@ #include "test_precomp.hpp" #include "opencv2/video/tracking.hpp" +#include "opencv2/video/tracking_c.h" #include #include diff --git a/modules/nonfree/CMakeLists.txt b/modules/nonfree/CMakeLists.txt index 5689a12e36..55f6b410c3 100644 --- a/modules/nonfree/CMakeLists.txt +++ b/modules/nonfree/CMakeLists.txt @@ -3,5 +3,4 @@ if(BUILD_ANDROID_PACKAGE) endif() set(the_description "Functionality with possible limitations on the use") -ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef) ocv_define_module(nonfree opencv_imgproc opencv_features2d opencv_calib3d OPTIONAL opencv_gpu opencv_ocl) diff --git a/modules/nonfree/include/opencv2/nonfree/features2d.hpp b/modules/nonfree/include/opencv2/nonfree/features2d.hpp index 57b9f1e688..4acd747c15 100644 --- a/modules/nonfree/include/opencv2/nonfree/features2d.hpp +++ b/modules/nonfree/include/opencv2/nonfree/features2d.hpp @@ -45,8 +45,6 @@ #include "opencv2/features2d.hpp" -#ifdef __cplusplus - namespace cv { @@ -58,9 +56,9 @@ namespace cv class CV_EXPORTS_W SIFT : public Feature2D { public: - CV_WRAP explicit SIFT( int nfeatures=0, int nOctaveLayers=3, - double contrastThreshold=0.04, double edgeThreshold=10, - double sigma=1.6); + CV_WRAP explicit SIFT( int nfeatures = 0, int nOctaveLayers = 3, + double contrastThreshold = 0.04, double edgeThreshold = 10, + double sigma = 1.6); //! returns the descriptor size in floats (128) CV_WRAP int descriptorSize() const; @@ -76,7 +74,7 @@ public: void operator()(InputArray img, InputArray mask, std::vector& keypoints, OutputArray descriptors, - bool useProvidedKeypoints=false) const; + bool useProvidedKeypoints = false) const; AlgorithmInfo* info() const; @@ -86,7 +84,7 @@ public: std::vector& keypoints ) const; protected: - void detectImpl( const Mat& image, std::vector& keypoints, const Mat& mask=Mat() ) const; + void detectImpl( const Mat& image, std::vector& keypoints, const Mat& mask = Mat() ) const; void computeImpl( const Mat& image, std::vector& keypoints, Mat& descriptors ) const; CV_PROP_RW int nfeatures; @@ -111,8 +109,8 @@ public: CV_WRAP SURF(); //! the full constructor taking all the necessary parameters explicit CV_WRAP SURF(double hessianThreshold, - int nOctaves=4, int nOctaveLayers=2, - bool extended=true, bool upright=false); + int nOctaves = 4, int nOctaveLayers = 2, + bool extended = true, bool upright = false); //! returns the descriptor size in float's (64 or 128) CV_WRAP int descriptorSize() const; @@ -127,7 +125,7 @@ public: void operator()(InputArray img, InputArray mask, CV_OUT std::vector& keypoints, OutputArray descriptors, - bool useProvidedKeypoints=false) const; + bool useProvidedKeypoints = false) const; AlgorithmInfo* info() const; @@ -139,7 +137,7 @@ public: protected: - void detectImpl( const Mat& image, std::vector& keypoints, const Mat& mask=Mat() ) const; + void detectImpl( const Mat& image, std::vector& keypoints, const Mat& mask = Mat() ) const; void computeImpl( const Mat& image, std::vector& keypoints, Mat& descriptors ) const; }; @@ -148,8 +146,4 @@ typedef SURF SurfDescriptorExtractor; } /* namespace cv */ -#endif /* __cplusplus */ - #endif - -/* End of file. */ diff --git a/modules/nonfree/include/opencv2/nonfree/ocl.hpp b/modules/nonfree/include/opencv2/nonfree/ocl.hpp index 9ceb9c3301..2b788ba3c8 100644 --- a/modules/nonfree/include/opencv2/nonfree/ocl.hpp +++ b/modules/nonfree/include/opencv2/nonfree/ocl.hpp @@ -121,4 +121,4 @@ namespace cv } } -#endif //__OPENCV_NONFREE_OCL_HPP__ \ No newline at end of file +#endif //__OPENCV_NONFREE_OCL_HPP__ diff --git a/modules/nonfree/src/surf.ocl.cpp b/modules/nonfree/src/surf.ocl.cpp index 893ddc32de..3b7e7a9bbb 100644 --- a/modules/nonfree/src/surf.ocl.cpp +++ b/modules/nonfree/src/surf.ocl.cpp @@ -182,7 +182,7 @@ public: if (use_mask) { - CV_Error(CV_StsBadFunc, "Masked SURF detector is not implemented yet"); + CV_Error(Error::StsBadFunc, "Masked SURF detector is not implemented yet"); //!FIXME // temp fix for missing min overload //oclMat temp(mask.size(), mask.type()); diff --git a/modules/nonfree/test/test_features2d.cpp b/modules/nonfree/test/test_features2d.cpp index 5de09f2a09..09997abe51 100644 --- a/modules/nonfree/test/test_features2d.cpp +++ b/modules/nonfree/test/test_features2d.cpp @@ -275,12 +275,16 @@ static Mat readMatFromBin( const string& filename ) size_t elements_read4 = fread( (void*)&dataSize, sizeof(int), 1, f ); CV_Assert(elements_read1 == 1 && elements_read2 == 1 && elements_read3 == 1 && elements_read4 == 1); - uchar* data = (uchar*)cvAlloc(dataSize); - size_t elements_read = fread( (void*)data, 1, dataSize, f ); + size_t step = dataSize / rows / CV_ELEM_SIZE(type); + CV_Assert(step >= (size_t)cols); + + Mat m = Mat( rows, step, type).colRange(0, cols); + + size_t elements_read = fread( m.ptr(), 1, dataSize, f ); CV_Assert(elements_read == (size_t)(dataSize)); fclose(f); - return Mat( rows, cols, type, data ); + return m; } return Mat(); } @@ -402,7 +406,7 @@ protected: double t = (double)getTickCount(); dextractor->compute( img, keypoints, calcDescriptors ); t = getTickCount() - t; - ts->printf(cvtest::TS::LOG, "\nAverage time of computing one descriptor = %g ms.\n", t/((double)cvGetTickFrequency()*1000.)/calcDescriptors.rows ); + ts->printf(cvtest::TS::LOG, "\nAverage time of computing one descriptor = %g ms.\n", t/((double)getTickFrequency()*1000.)/calcDescriptors.rows ); if( calcDescriptors.rows != (int)keypoints.size() ) { diff --git a/modules/objdetect/include/opencv2/objdetect.hpp b/modules/objdetect/include/opencv2/objdetect.hpp index bde149e16b..3ccb057e33 100644 --- a/modules/objdetect/include/opencv2/objdetect.hpp +++ b/modules/objdetect/include/opencv2/objdetect.hpp @@ -7,11 +7,12 @@ // copy or use the software. // // -// License Agreement +// 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, @@ -43,248 +44,10 @@ #ifndef __OPENCV_OBJDETECT_HPP__ #define __OPENCV_OBJDETECT_HPP__ -#ifdef __cplusplus -# include "opencv2/core.hpp" -#endif -#include "opencv2/core/core_c.h" +#include "opencv2/core.hpp" -#ifdef __cplusplus -#include -#include - -extern "C" { -#endif - -/****************************************************************************************\ -* Haar-like Object Detection functions * -\****************************************************************************************/ - -#define CV_HAAR_MAGIC_VAL 0x42500000 -#define CV_TYPE_NAME_HAAR "opencv-haar-classifier" - -#define CV_IS_HAAR_CLASSIFIER( haar ) \ - ((haar) != NULL && \ - (((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL) - -#define CV_HAAR_FEATURE_MAX 3 - -typedef struct CvHaarFeature -{ - int tilted; - struct - { - CvRect r; - float weight; - } rect[CV_HAAR_FEATURE_MAX]; -} CvHaarFeature; - -typedef struct CvHaarClassifier -{ - int count; - CvHaarFeature* haar_feature; - float* threshold; - int* left; - int* right; - float* alpha; -} CvHaarClassifier; - -typedef struct CvHaarStageClassifier -{ - int count; - float threshold; - CvHaarClassifier* classifier; - - int next; - int child; - int parent; -} CvHaarStageClassifier; - -typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade; - -typedef struct CvHaarClassifierCascade -{ - int flags; - int count; - CvSize orig_window_size; - CvSize real_window_size; - double scale; - CvHaarStageClassifier* stage_classifier; - CvHidHaarClassifierCascade* hid_cascade; -} CvHaarClassifierCascade; - -typedef struct CvAvgComp -{ - CvRect rect; - int neighbors; -} CvAvgComp; - -/* Loads haar classifier cascade from a directory. - It is obsolete: convert your cascade to xml and use cvLoad instead */ -CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade( - const char* directory, CvSize orig_window_size); - -CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade ); - -#define CV_HAAR_DO_CANNY_PRUNING 1 -#define CV_HAAR_SCALE_IMAGE 2 -#define CV_HAAR_FIND_BIGGEST_OBJECT 4 -#define CV_HAAR_DO_ROUGH_SEARCH 8 - -//CVAPI(CvSeq*) cvHaarDetectObjectsForROC( const CvArr* image, -// CvHaarClassifierCascade* cascade, CvMemStorage* storage, -// CvSeq** rejectLevels, CvSeq** levelWeightds, -// double scale_factor CV_DEFAULT(1.1), -// int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0), -// CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0)), -// bool outputRejectLevels = false ); - - -CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image, - CvHaarClassifierCascade* cascade, CvMemStorage* storage, - double scale_factor CV_DEFAULT(1.1), - int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0), - CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0))); - -/* sets images for haar classifier cascade */ -CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade, - const CvArr* sum, const CvArr* sqsum, - const CvArr* tilted_sum, double scale ); - -/* runs the cascade on the specified window */ -CVAPI(int) cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade, - CvPoint pt, int start_stage CV_DEFAULT(0)); - - -/****************************************************************************************\ -* Latent SVM Object Detection functions * -\****************************************************************************************/ - -// DataType: STRUCT position -// Structure describes the position of the filter in the feature pyramid -// l - level in the feature pyramid -// (x, y) - coordinate in level l -typedef struct CvLSVMFilterPosition -{ - int x; - int y; - int l; -} CvLSVMFilterPosition; - -// DataType: STRUCT filterObject -// Description of the filter, which corresponds to the part of the object -// V - ideal (penalty = 0) position of the partial filter -// from the root filter position (V_i in the paper) -// penaltyFunction - vector describes penalty function (d_i in the paper) -// pf[0] * x + pf[1] * y + pf[2] * x^2 + pf[3] * y^2 -// FILTER DESCRIPTION -// Rectangular map (sizeX x sizeY), -// every cell stores feature vector (dimension = p) -// H - matrix of feature vectors -// to set and get feature vectors (i,j) -// used formula H[(j * sizeX + i) * p + k], where -// k - component of feature vector in cell (i, j) -// END OF FILTER DESCRIPTION -typedef struct CvLSVMFilterObject{ - CvLSVMFilterPosition V; - float fineFunction[4]; - int sizeX; - int sizeY; - int numFeatures; - float *H; -} CvLSVMFilterObject; - -// data type: STRUCT CvLatentSvmDetector -// structure contains internal representation of trained Latent SVM detector -// num_filters - total number of filters (root plus part) in model -// num_components - number of components in model -// num_part_filters - array containing number of part filters for each component -// filters - root and part filters for all model components -// b - biases for all model components -// score_threshold - confidence level threshold -typedef struct CvLatentSvmDetector -{ - int num_filters; - int num_components; - int* num_part_filters; - CvLSVMFilterObject** filters; - float* b; - float score_threshold; -} -CvLatentSvmDetector; - -// data type: STRUCT CvObjectDetection -// structure contains the bounding box and confidence level for detected object -// rect - bounding box for a detected object -// score - confidence level -typedef struct CvObjectDetection -{ - CvRect rect; - float score; -} CvObjectDetection; - -//////////////// Object Detection using Latent SVM ////////////// - - -/* -// load trained detector from a file -// -// API -// CvLatentSvmDetector* cvLoadLatentSvmDetector(const char* filename); -// INPUT -// filename - path to the file containing the parameters of - - trained Latent SVM detector -// OUTPUT -// trained Latent SVM detector in internal representation -*/ -CVAPI(CvLatentSvmDetector*) cvLoadLatentSvmDetector(const char* filename); - -/* -// release memory allocated for CvLatentSvmDetector structure -// -// API -// void cvReleaseLatentSvmDetector(CvLatentSvmDetector** detector); -// INPUT -// detector - CvLatentSvmDetector structure to be released -// OUTPUT -*/ -CVAPI(void) cvReleaseLatentSvmDetector(CvLatentSvmDetector** detector); - -/* -// find rectangular regions in the given image that are likely -// to contain objects and corresponding confidence levels -// -// API -// CvSeq* cvLatentSvmDetectObjects(const IplImage* image, -// CvLatentSvmDetector* detector, -// CvMemStorage* storage, -// float overlap_threshold = 0.5f, -// int numThreads = -1); -// INPUT -// image - image to detect objects in -// detector - Latent SVM detector in internal representation -// storage - memory storage to store the resultant sequence -// of the object candidate rectangles -// overlap_threshold - threshold for the non-maximum suppression algorithm - = 0.5f [here will be the reference to original paper] -// OUTPUT -// sequence of detected objects (bounding boxes and confidence levels stored in CvObjectDetection structures) -*/ -CVAPI(CvSeq*) cvLatentSvmDetectObjects(IplImage* image, - CvLatentSvmDetector* detector, - CvMemStorage* storage, - float overlap_threshold CV_DEFAULT(0.5f), - int numThreads CV_DEFAULT(-1)); - -#ifdef __cplusplus -} - -CV_EXPORTS CvSeq* cvHaarDetectObjectsForROC( const CvArr* image, - CvHaarClassifierCascade* cascade, CvMemStorage* storage, - std::vector& rejectLevels, std::vector& levelWeightds, - double scale_factor CV_DEFAULT(1.1), - int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0), - CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0)), - bool outputRejectLevels = false ); +typedef struct CvLatentSvmDetector CvLatentSvmDetector; +typedef struct CvHaarClassifierCascade CvHaarClassifierCascade; namespace cv { @@ -303,24 +66,24 @@ public: struct CV_EXPORTS ObjectDetection { ObjectDetection(); - ObjectDetection( const Rect& rect, float score, int classID=-1 ); + ObjectDetection( const Rect& rect, float score, int classID = -1 ); Rect rect; float score; int classID; }; LatentSvmDetector(); - LatentSvmDetector( const std::vector& filenames, const std::vector& classNames=std::vector() ); + LatentSvmDetector( const std::vector& filenames, const std::vector& classNames = std::vector() ); virtual ~LatentSvmDetector(); virtual void clear(); virtual bool empty() const; - bool load( const std::vector& filenames, const std::vector& classNames=std::vector() ); + bool load( const std::vector& filenames, const std::vector& classNames = std::vector() ); virtual void detect( const Mat& image, std::vector& objectDetections, - float overlapThreshold=0.5f, - int numThreads=-1 ); + float overlapThreshold = 0.5f, + int numThreads = -1 ); const std::vector& getClassNames() const; size_t getClassCount() const; @@ -330,19 +93,22 @@ private: std::vector classNames; }; -CV_EXPORTS void groupRectangles(CV_OUT CV_IN_OUT std::vector& rectList, int groupThreshold, double eps=0.2); -CV_EXPORTS_W void groupRectangles(CV_OUT CV_IN_OUT std::vector& rectList, CV_OUT std::vector& weights, int groupThreshold, double eps=0.2); -CV_EXPORTS void groupRectangles( std::vector& rectList, int groupThreshold, double eps, std::vector* weights, std::vector* levelWeights ); -CV_EXPORTS void groupRectangles(std::vector& rectList, std::vector& rejectLevels, - std::vector& levelWeights, int groupThreshold, double eps=0.2); -CV_EXPORTS void groupRectangles_meanshift(std::vector& rectList, std::vector& foundWeights, std::vector& foundScales, +CV_EXPORTS void groupRectangles(std::vector& rectList, int groupThreshold, double eps = 0.2); +CV_EXPORTS_W void groupRectangles(CV_IN_OUT std::vector& rectList, CV_OUT std::vector& weights, int groupThreshold, double eps = 0.2); +CV_EXPORTS void groupRectangles(std::vector& rectList, int groupThreshold, double eps, std::vector* weights, std::vector* levelWeights ); +CV_EXPORTS void groupRectangles(std::vector& rectList, std::vector& rejectLevels, + std::vector& levelWeights, int groupThreshold, double eps = 0.2); +CV_EXPORTS void groupRectangles_meanshift(std::vector& rectList, std::vector& foundWeights, std::vector& foundScales, double detectThreshold = 0.0, Size winDetSize = Size(64, 128)); - class CV_EXPORTS FeatureEvaluator { public: - enum { HAAR = 0, LBP = 1, HOG = 2 }; + enum { HAAR = 0, + LBP = 1, + HOG = 2 + }; + virtual ~FeatureEvaluator(); virtual bool read(const FileNode& node); @@ -360,13 +126,11 @@ public: template<> CV_EXPORTS void Ptr::delete_obj(); -enum -{ - CASCADE_DO_CANNY_PRUNING=1, - CASCADE_SCALE_IMAGE=2, - CASCADE_FIND_BIGGEST_OBJECT=4, - CASCADE_DO_ROUGH_SEARCH=8 -}; +enum { CASCADE_DO_CANNY_PRUNING = 1, + CASCADE_SCALE_IMAGE = 2, + CASCADE_FIND_BIGGEST_OBJECT = 4, + CASCADE_DO_ROUGH_SEARCH = 8 + }; class CV_EXPORTS_W CascadeClassifier { @@ -380,20 +144,20 @@ public: virtual bool read( const FileNode& node ); CV_WRAP virtual void detectMultiScale( const Mat& image, CV_OUT std::vector& objects, - double scaleFactor=1.1, - int minNeighbors=3, int flags=0, - Size minSize=Size(), - Size maxSize=Size() ); + double scaleFactor = 1.1, + int minNeighbors = 3, int flags = 0, + Size minSize = Size(), + Size maxSize = Size() ); CV_WRAP virtual void detectMultiScale( const Mat& image, CV_OUT std::vector& objects, CV_OUT std::vector& rejectLevels, CV_OUT std::vector& levelWeights, - double scaleFactor=1.1, - int minNeighbors=3, int flags=0, - Size minSize=Size(), - Size maxSize=Size(), - bool outputRejectLevels=false ); + double scaleFactor = 1.1, + int minNeighbors = 3, int flags = 0, + Size minSize = Size(), + Size maxSize = Size(), + bool outputRejectLevels = false ); bool isOldFormatCascade() const; @@ -402,17 +166,18 @@ public: bool setImage( const Mat& ); protected: - //virtual bool detectSingleScale( const Mat& image, int stripCount, Size processingRectSize, - // int stripSize, int yStep, double factor, std::vector& candidates ); - virtual bool detectSingleScale( const Mat& image, int stripCount, Size processingRectSize, int stripSize, int yStep, double factor, std::vector& candidates, - std::vector& rejectLevels, std::vector& levelWeights, bool outputRejectLevels=false); + std::vector& rejectLevels, std::vector& levelWeights, bool outputRejectLevels = false); protected: - enum { BOOST = 0 }; - enum { DO_CANNY_PRUNING = 1, SCALE_IMAGE = 2, - FIND_BIGGEST_OBJECT = 4, DO_ROUGH_SEARCH = 8 }; + enum { BOOST = 0 + }; + enum { DO_CANNY_PRUNING = CASCADE_DO_CANNY_PRUNING, + SCALE_IMAGE = CASCADE_SCALE_IMAGE, + FIND_BIGGEST_OBJECT = CASCADE_FIND_BIGGEST_OBJECT, + DO_ROUGH_SEARCH = CASCADE_DO_ROUGH_SEARCH + }; friend class CascadeClassifierInvoker; @@ -507,8 +272,10 @@ struct DetectionROI struct CV_EXPORTS_W HOGDescriptor { public: - enum { L2Hys=0 }; - enum { DEFAULT_NLEVELS=64 }; + enum { L2Hys = 0 + }; + enum { DEFAULT_NLEVELS = 64 + }; CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8), cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1), @@ -548,38 +315,38 @@ public: virtual bool read(FileNode& fn); virtual void write(FileStorage& fs, const String& objname) const; - CV_WRAP virtual bool load(const String& filename, const String& objname=String()); - CV_WRAP virtual void save(const String& filename, const String& objname=String()) const; + CV_WRAP virtual bool load(const String& filename, const String& objname = String()); + CV_WRAP virtual void save(const String& filename, const String& objname = String()) const; virtual void copyTo(HOGDescriptor& c) const; CV_WRAP virtual void compute(const Mat& img, CV_OUT std::vector& descriptors, - Size winStride=Size(), Size padding=Size(), - const std::vector& locations=std::vector()) const; + Size winStride = Size(), Size padding = Size(), + const std::vector& locations = std::vector()) const; //with found weights output CV_WRAP virtual void detect(const Mat& img, CV_OUT std::vector& foundLocations, CV_OUT std::vector& weights, - double hitThreshold=0, Size winStride=Size(), - Size padding=Size(), - const std::vector& searchLocations=std::vector()) const; + double hitThreshold = 0, Size winStride = Size(), + Size padding = Size(), + const std::vector& searchLocations = std::vector()) const; //without found weights output virtual void detect(const Mat& img, CV_OUT std::vector& foundLocations, - double hitThreshold=0, Size winStride=Size(), - Size padding=Size(), + double hitThreshold = 0, Size winStride = Size(), + Size padding = Size(), const std::vector& searchLocations=std::vector()) const; //with result weights output CV_WRAP virtual void detectMultiScale(const Mat& img, CV_OUT std::vector& foundLocations, - CV_OUT std::vector& foundWeights, double hitThreshold=0, - Size winStride=Size(), Size padding=Size(), double scale=1.05, - double finalThreshold=2.0,bool useMeanshiftGrouping = false) const; + CV_OUT std::vector& foundWeights, double hitThreshold = 0, + Size winStride = Size(), Size padding = Size(), double scale = 1.05, + double finalThreshold = 2.0,bool useMeanshiftGrouping = false) const; //without found weights output virtual void detectMultiScale(const Mat& img, CV_OUT std::vector& foundLocations, - double hitThreshold=0, Size winStride=Size(), - Size padding=Size(), double scale=1.05, - double finalThreshold=2.0, bool useMeanshiftGrouping = false) const; + double hitThreshold = 0, Size winStride = Size(), + Size padding = Size(), double scale = 1.05, + double finalThreshold = 2.0, bool useMeanshiftGrouping = false) const; CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs, - Size paddingTL=Size(), Size paddingBR=Size()) const; + Size paddingTL = Size(), Size paddingBR = Size()) const; CV_WRAP static std::vector getDefaultPeopleDetector(); CV_WRAP static std::vector getDaimlerPeopleDetector(); @@ -618,430 +385,14 @@ public: CV_EXPORTS_W void findDataMatrix(InputArray image, CV_OUT std::vector& codes, - OutputArray corners=noArray(), - OutputArrayOfArrays dmtx=noArray()); + OutputArray corners = noArray(), + OutputArrayOfArrays dmtx = noArray()); + CV_EXPORTS_W void drawDataMatrixCodes(InputOutputArray image, const std::vector& codes, InputArray corners); } -/****************************************************************************************\ -* Datamatrix * -\****************************************************************************************/ - -struct CV_EXPORTS CvDataMatrixCode { - char msg[4]; - CvMat *original; - CvMat *corners; -}; - -CV_EXPORTS std::deque cvFindDataMatrix(CvMat *im); - -/****************************************************************************************\ -* LINE-MOD * -\****************************************************************************************/ - -namespace cv { -namespace linemod { - -/// @todo Convert doxy comments to rst - -/** - * \brief Discriminant feature described by its location and label. - */ -struct CV_EXPORTS Feature -{ - int x; ///< x offset - int y; ///< y offset - int label; ///< Quantization - - Feature() : x(0), y(0), label(0) {} - Feature(int x, int y, int label); - - void read(const FileNode& fn); - void write(FileStorage& fs) const; -}; - -inline Feature::Feature(int _x, int _y, int _label) : x(_x), y(_y), label(_label) {} - -struct CV_EXPORTS Template -{ - int width; - int height; - int pyramid_level; - std::vector features; - - void read(const FileNode& fn); - void write(FileStorage& fs) const; -}; - -/** - * \brief Represents a modality operating over an image pyramid. - */ -class QuantizedPyramid -{ -public: - // Virtual destructor - virtual ~QuantizedPyramid() {} - - /** - * \brief Compute quantized image at current pyramid level for online detection. - * - * \param[out] dst The destination 8-bit image. For each pixel at most one bit is set, - * representing its classification. - */ - virtual void quantize(Mat& dst) const =0; - - /** - * \brief Extract most discriminant features at current pyramid level to form a new template. - * - * \param[out] templ The new template. - */ - virtual bool extractTemplate(Template& templ) const =0; - - /** - * \brief Go to the next pyramid level. - * - * \todo Allow pyramid scale factor other than 2 - */ - virtual void pyrDown() =0; - -protected: - /// Candidate feature with a score - struct Candidate - { - Candidate(int x, int y, int label, float score); - - /// Sort candidates with high score to the front - bool operator<(const Candidate& rhs) const - { - return score > rhs.score; - } - - Feature f; - float score; - }; - - /** - * \brief Choose candidate features so that they are not bunched together. - * - * \param[in] candidates Candidate features sorted by score. - * \param[out] features Destination vector of selected features. - * \param[in] num_features Number of candidates to select. - * \param[in] distance Hint for desired distance between features. - */ - static void selectScatteredFeatures(const std::vector& candidates, - std::vector& features, - size_t num_features, float distance); -}; - -inline QuantizedPyramid::Candidate::Candidate(int x, int y, int label, float _score) : f(x, y, label), score(_score) {} - -/** - * \brief Interface for modalities that plug into the LINE template matching representation. - * - * \todo Max response, to allow optimization of summing (255/MAX) features as uint8 - */ -class CV_EXPORTS Modality -{ -public: - // Virtual destructor - virtual ~Modality() {} - - /** - * \brief Form a quantized image pyramid from a source image. - * - * \param[in] src The source image. Type depends on the modality. - * \param[in] mask Optional mask. If not empty, unmasked pixels are set to zero - * in quantized image and cannot be extracted as features. - */ - Ptr process(const Mat& src, - const Mat& mask = Mat()) const - { - return processImpl(src, mask); - } - - virtual String name() const =0; - - virtual void read(const FileNode& fn) =0; - virtual void write(FileStorage& fs) const =0; - - /** - * \brief Create modality by name. - * - * The following modality types are supported: - * - "ColorGradient" - * - "DepthNormal" - */ - static Ptr create(const String& modality_type); - - /** - * \brief Load a modality from file. - */ - static Ptr create(const FileNode& fn); - -protected: - // Indirection is because process() has a default parameter. - virtual Ptr processImpl(const Mat& src, - const Mat& mask) const =0; -}; - -/** - * \brief Modality that computes quantized gradient orientations from a color image. - */ -class CV_EXPORTS ColorGradient : public Modality -{ -public: - /** - * \brief Default constructor. Uses reasonable default parameter values. - */ - ColorGradient(); - - /** - * \brief Constructor. - * - * \param weak_threshold When quantizing, discard gradients with magnitude less than this. - * \param num_features How many features a template must contain. - * \param strong_threshold Consider as candidate features only gradients whose norms are - * larger than this. - */ - ColorGradient(float weak_threshold, size_t num_features, float strong_threshold); - - virtual String name() const; - - virtual void read(const FileNode& fn); - virtual void write(FileStorage& fs) const; - - float weak_threshold; - size_t num_features; - float strong_threshold; - -protected: - virtual Ptr processImpl(const Mat& src, - const Mat& mask) const; -}; - -/** - * \brief Modality that computes quantized surface normals from a dense depth map. - */ -class CV_EXPORTS DepthNormal : public Modality -{ -public: - /** - * \brief Default constructor. Uses reasonable default parameter values. - */ - DepthNormal(); - - /** - * \brief Constructor. - * - * \param distance_threshold Ignore pixels beyond this distance. - * \param difference_threshold When computing normals, ignore contributions of pixels whose - * depth difference with the central pixel is above this threshold. - * \param num_features How many features a template must contain. - * \param extract_threshold Consider as candidate feature only if there are no differing - * orientations within a distance of extract_threshold. - */ - DepthNormal(int distance_threshold, int difference_threshold, size_t num_features, - int extract_threshold); - - virtual String name() const; - - virtual void read(const FileNode& fn); - virtual void write(FileStorage& fs) const; - - int distance_threshold; - int difference_threshold; - size_t num_features; - int extract_threshold; - -protected: - virtual Ptr processImpl(const Mat& src, - const Mat& mask) const; -}; - -/** - * \brief Debug function to colormap a quantized image for viewing. - */ -void colormap(const Mat& quantized, Mat& dst); - -/** - * \brief Represents a successful template match. - */ -struct CV_EXPORTS Match -{ - Match() - { - } - - Match(int x, int y, float similarity, const String& class_id, int template_id); - - /// Sort matches with high similarity to the front - bool operator<(const Match& rhs) const - { - // Secondarily sort on template_id for the sake of duplicate removal - if (similarity != rhs.similarity) - return similarity > rhs.similarity; - else - return template_id < rhs.template_id; - } - - bool operator==(const Match& rhs) const - { - return x == rhs.x && y == rhs.y && similarity == rhs.similarity && class_id == rhs.class_id; - } - - int x; - int y; - float similarity; - String class_id; - int template_id; -}; - -inline Match::Match(int _x, int _y, float _similarity, const String& _class_id, int _template_id) - : x(_x), y(_y), similarity(_similarity), class_id(_class_id), template_id(_template_id) - { - } - -/** - * \brief Object detector using the LINE template matching algorithm with any set of - * modalities. - */ -class CV_EXPORTS Detector -{ -public: - /** - * \brief Empty constructor, initialize with read(). - */ - Detector(); - - /** - * \brief Constructor. - * - * \param modalities Modalities to use (color gradients, depth normals, ...). - * \param T_pyramid Value of the sampling step T at each pyramid level. The - * number of pyramid levels is T_pyramid.size(). - */ - Detector(const std::vector< Ptr >& modalities, const std::vector& T_pyramid); - - /** - * \brief Detect objects by template matching. - * - * Matches globally at the lowest pyramid level, then refines locally stepping up the pyramid. - * - * \param sources Source images, one for each modality. - * \param threshold Similarity threshold, a percentage between 0 and 100. - * \param[out] matches Template matches, sorted by similarity score. - * \param class_ids If non-empty, only search for the desired object classes. - * \param[out] quantized_images Optionally return vector of quantized images. - * \param masks The masks for consideration during matching. The masks should be CV_8UC1 - * where 255 represents a valid pixel. If non-empty, the vector must be - * the same size as sources. Each element must be - * empty or the same size as its corresponding source. - */ - void match(const std::vector& sources, float threshold, std::vector& matches, - const std::vector& class_ids = std::vector(), - OutputArrayOfArrays quantized_images = noArray(), - const std::vector& masks = std::vector()) const; - - /** - * \brief Add new object template. - * - * \param sources Source images, one for each modality. - * \param class_id Object class ID. - * \param object_mask Mask separating object from background. - * \param[out] bounding_box Optionally return bounding box of the extracted features. - * - * \return Template ID, or -1 if failed to extract a valid template. - */ - int addTemplate(const std::vector& sources, const String& class_id, - const Mat& object_mask, Rect* bounding_box = NULL); - - /** - * \brief Add a new object template computed by external means. - */ - int addSyntheticTemplate(const std::vector