Merge pull request opencv#26435 from vrabaud:4x_calibration_base

Remove unused internal C functions

Author: asmorkalov

modules/calib3d/src/calib3d_c_api.h

@@ -55,45 +55,8 @@ extern "C" {
 *                      Camera Calibration, Pose Estimation and Stereo                    *
 \****************************************************************************************/
 
-typedef struct CvPOSITObject CvPOSITObject;
-
-/* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */
-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 */
-void  cvPOSIT(  CvPOSITObject* posit_object, CvPoint2D32f* image_points,
-                       double focal_length, CvTermCriteria criteria,
-                       float* rotation_matrix, float* translation_vector);
-
-/* Releases CvPOSITObject structure */
-void  cvReleasePOSITObject( CvPOSITObject**  posit_object );
-
-/* updates the number of RANSAC iterations */
-int cvRANSACUpdateNumIters( double p, double err_prob,
-                                   int model_points, int max_iters );
-
 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*/
-
-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 */
@@ -102,15 +65,6 @@ void cvComputeCorrespondEpilines( const CvMat* points,
                                   const CvMat* fundamental_matrix,
                                   CvMat* correspondent_lines );
 
-/* Triangulation functions */
-
-void cvTriangulatePoints(CvMat* projMatr1, CvMat* projMatr2,
-                         CvMat* projPoints1, CvMat* projPoints2,
-                         CvMat* points4D);
-
-void cvCorrectMatches(CvMat* F, CvMat* points1, CvMat* points2,
-                      CvMat* new_points1, CvMat* new_points2);
-
 /* Finds perspective transformation between the object plane and image (view) plane */
 int cvFindHomography( const CvMat* src_points,
                       const CvMat* dst_points,
@@ -129,45 +83,6 @@ void cvInitIntrinsicParams2D( const CvMat* object_points,
                               CvMat* camera_matrix,
                               double aspect_ratio CV_DEFAULT(1.) );
 
-// 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
-int cvCheckChessboard(IplImage* src, CvSize size);
-
-    /* Detects corners on a chessboard calibration pattern */
-/*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 */
-/*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
-#define CV_CALIB_TILTED_MODEL  262144
-#define CV_CALIB_FIX_TAUX_TAUY  524288
-#define CV_CALIB_FIX_TANGENT_DIST 2097152
-
-#define CV_CALIB_NINTRINSIC 18*/
-
 /* Finds intrinsic and extrinsic camera parameters
    from a few views of known calibration pattern */
 double cvCalibrateCamera2( const CvMat* object_points,
@@ -182,37 +97,6 @@ double cvCalibrateCamera2( const CvMat* object_points,
                                 CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria(
                                     CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON)) );
 
-/* Finds intrinsic and extrinsic camera parameters
-   from a few views of known calibration pattern */
-double cvCalibrateCamera4( const CvMat* object_points,
-                                const CvMat* image_points,
-                                const CvMat* point_counts,
-                                CvSize image_size,
-                                int iFixedPoint,
-                                CvMat* camera_matrix,
-                                CvMat* distortion_coeffs,
-                                CvMat* rotation_vectors CV_DEFAULT(NULL),
-                                CvMat* translation_vectors CV_DEFAULT(NULL),
-                                CvMat* newObjPoints 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 */
-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 */
@@ -248,95 +132,6 @@ int cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2,
                                  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
-
-CvStereoBMState* cvCreateStereoBMState(int preset CV_DEFAULT(CV_STEREO_BM_BASIC),
-                                        int numberOfDisparities CV_DEFAULT(0));
-
-void cvReleaseStereoBMState( CvStereoBMState** state );
-
-void cvFindStereoCorrespondenceBM( const CvArr* left, const CvArr* right,
-                                   CvArr* disparity, CvStereoBMState* state );
-
-CvRect cvGetValidDisparityROI( CvRect roi1, CvRect roi2, int minDisparity,
-                               int numberOfDisparities, int SADWindowSize );
-
-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 */
-void  cvReprojectImageTo3D( const CvArr* disparityImage,
-                            CvArr* _3dImage, const CvMat* Q,
-                            int handleMissingValues CV_DEFAULT(0) );
-
-/** @brief Transforms the input image to compensate lens distortion
-@see cv::undistort
-*/
-void cvUndistort2( const CvArr* src, CvArr* dst,
-                   const CvMat* camera_matrix,
-                   const CvMat* distortion_coeffs,
-                   const CvMat* new_camera_matrix CV_DEFAULT(0) );
-
-/** @brief Computes transformation map from intrinsic camera parameters
-   that can used by cvRemap
-*/
-void cvInitUndistortMap( const CvMat* camera_matrix,
-                         const CvMat* distortion_coeffs,
-                         CvArr* mapx, CvArr* mapy );
-
-/** @brief Computes undistortion+rectification map for a head of stereo camera
-@see cv::initUndistortRectifyMap
-*/
-void cvInitUndistortRectifyMap( const CvMat* camera_matrix,
-                                const CvMat* dist_coeffs,
-                                const CvMat *R, const CvMat* new_camera_matrix,
-                                CvArr* mapx, CvArr* mapy );
-
 /** @brief Computes the original (undistorted) feature coordinates
    from the observed (distorted) coordinates
 @see cv::undistortPoints

modules/calib3d/src/calibration.cpp

@@ -679,82 +679,6 @@ CV_IMPL double cvCalibrateCamera2( const CvMat* objectPoints,
                                       distCoeffs, rvecs, tvecs, NULL, NULL, NULL, flags, termCrit);
 }
 
-CV_IMPL double cvCalibrateCamera4( const CvMat* objectPoints,
-                    const CvMat* imagePoints, const CvMat* npoints,
-                    CvSize imageSize, int iFixedPoint, CvMat* cameraMatrix, CvMat* distCoeffs,
-                    CvMat* rvecs, CvMat* tvecs, CvMat* newObjPoints, int flags, CvTermCriteria termCrit )
-{
-    if( !CV_IS_MAT(npoints) )
-        CV_Error( cv::Error::StsBadArg, "npoints is not a valid matrix" );
-    if( CV_MAT_TYPE(npoints->type) != CV_32SC1 ||
-        (npoints->rows != 1 && npoints->cols != 1) )
-        CV_Error( cv::Error::StsUnsupportedFormat,
-            "the array of point counters must be 1-dimensional integer vector" );
-
-    bool releaseObject = iFixedPoint > 0 && iFixedPoint < npoints->data.i[0] - 1;
-    int nimages = npoints->rows * npoints->cols;
-    int npstep = npoints->rows == 1 ? 1 : npoints->step / CV_ELEM_SIZE(npoints->type);
-    int i, ni;
-    // check object points. If not qualified, report errors.
-    if( releaseObject )
-    {
-        if( !CV_IS_MAT(objectPoints) )
-            CV_Error( cv::Error::StsBadArg, "objectPoints is not a valid matrix" );
-        Mat matM;
-        if(CV_MAT_CN(objectPoints->type) == 3) {
-            matM = cvarrToMat(objectPoints);
-        } else {
-            convertPointsHomogeneous(cvarrToMat(objectPoints), matM);
-        }
-
-        matM = matM.reshape(3, 1);
-        ni = npoints->data.i[0];
-        for( i = 1; i < nimages; i++ )
-        {
-            if( npoints->data.i[i * npstep] != ni )
-            {
-                CV_Error( cv::Error::StsBadArg, "All objectPoints[i].size() should be equal when "
-                                        "object-releasing method is requested." );
-            }
-            Mat ocmp = matM.colRange(ni * i, ni * i + ni) != matM.colRange(0, ni);
-            ocmp = ocmp.reshape(1);
-            if( countNonZero(ocmp) )
-            {
-                CV_Error( cv::Error::StsBadArg, "All objectPoints[i] should be identical when object-releasing"
-                                        " method is requested." );
-            }
-        }
-    }
-
-    return cvCalibrateCamera2Internal(objectPoints, imagePoints, npoints, imageSize, iFixedPoint,
-                                      cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints, NULL,
-                                      NULL, flags, termCrit);
-}
-
-void cvCalibrationMatrixValues( const CvMat *calibMatr, CvSize imgSize,
-    double apertureWidth, double apertureHeight, double *fovx, double *fovy,
-    double *focalLength, CvPoint2D64f *principalPoint, double *pasp )
-{
-    /* Validate parameters. */
-    if(calibMatr == 0)
-        CV_Error(cv::Error::StsNullPtr, "Some of parameters is a NULL pointer!");
-
-    if(!CV_IS_MAT(calibMatr))
-        CV_Error(cv::Error::StsUnsupportedFormat, "Input parameters must be matrices!");
-
-    double dummy = .0;
-    Point2d pp;
-    cv::calibrationMatrixValues(cvarrToMat(calibMatr), imgSize, apertureWidth, apertureHeight,
-            fovx ? *fovx : dummy,
-            fovy ? *fovy : dummy,
-            focalLength ? *focalLength : dummy,
-            pp,
-            pasp ? *pasp : dummy);
-
-    if(principalPoint)
-        *principalPoint = cvPoint2D64f(pp.x, pp.y);
-}
-
 
 //////////////////////////////// Stereo Calibration ///////////////////////////////////
 
@@ -1870,21 +1794,6 @@ void cv::reprojectImageTo3D( InputArray _disparity,
 }
 
 
-void cvReprojectImageTo3D( const CvArr* disparityImage,
-                           CvArr* _3dImage, const CvMat* matQ,
-                           int handleMissingValues )
-{
-    cv::Mat disp = cv::cvarrToMat(disparityImage);
-    cv::Mat _3dimg = cv::cvarrToMat(_3dImage);
-    cv::Mat mq = cv::cvarrToMat(matQ);
-    CV_Assert( disp.size() == _3dimg.size() );
-    int dtype = _3dimg.type();
-    CV_Assert( dtype == CV_16SC3 || dtype == CV_32SC3 || dtype == CV_32FC3 );
-
-    cv::reprojectImageTo3D(disp, _3dimg, mq, handleMissingValues != 0, dtype );
-}
-
-
 
 namespace cv
 {

modules/calib3d/src/checkchessboard.cpp

@@ -40,7 +40,6 @@
  //M*/
 
 #include "precomp.hpp"
-#include "calib3d_c_api.h"
 
 #include <vector>
 #include <algorithm>
@@ -150,18 +149,6 @@ static bool checkQuads(vector<pair<float, int> > & quads, const cv::Size & size)
     return false;
 }
 
-// does 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
-int cvCheckChessboard(IplImage* src, CvSize size)
-{
-    cv::Mat img = cv::cvarrToMat(src);
-    return (int)cv::checkChessboard(img, size);
-}
-
 bool cv::checkChessboard(InputArray _img, Size size)
 {
     Mat img = _img.getMat();