modules/calib3d/src/precomp.hpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                          License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  15 // Third party copyrights are property of their respective owners.
  16 //
  17 // Redistribution and use in source and binary forms, with or without modification,
  18 // are permitted provided that the following conditions are met:
  19 //
  20 //   * Redistribution's of source code must retain the above copyright notice,
  21 //     this list of conditions and the following disclaimer.
  22 //
  23 //   * Redistribution's in binary form must reproduce the above copyright notice,
  24 //     this list of conditions and the following disclaimer in the documentation
  25 //     and/or other materials provided with the distribution.
  26 //
  27 //   * The name of the copyright holders may not be used to endorse or promote products
  28 //     derived from this software without specific prior written permission.
  29 //
  30 // This software is provided by the copyright holders and contributors "as is" and
  31 // any express or implied warranties, including, but not limited to, the implied
  32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  33 // In no event shall the Intel Corporation or contributors be liable for any direct,
  34 // indirect, incidental, special, exemplary, or consequential damages
  35 // (including, but not limited to, procurement of substitute goods or services;
  36 // loss of use, data, or profits; or business interruption) however caused
  37 // and on any theory of liability, whether in contract, strict liability,
  38 // or tort (including negligence or otherwise) arising in any way out of
  39 // the use of this software, even if advised of the possibility of such damage.
  40 //
  41 //M*/
  42 #ifndef __OPENCV_PRECOMP_H__
  43 #define __OPENCV_PRECOMP_H__
  44
  45 #include "opencv2/calib3d.hpp"
  46 #include "opencv2/imgproc.hpp"
  47 #include "opencv2/features2d.hpp"
  48 #include "opencv2/core/utility.hpp"
  49
  50 #include "opencv2/core/private.hpp"
  51
  52 #include "opencv2/core/ocl.hpp"
  53
  54 #define GET_OPTIMIZED(func) (func)
  55
  56
  57 namespace cv
  58 {
  59
  60 /**
  61  * Compute the number of iterations given the confidence, outlier ratio, number
  62  * of model points and the maximum iteration number.
  63  *
  64  * @param p confidence value
  65  * @param ep outlier ratio
  66  * @param modelPoints number of model points required for estimation
  67  * @param maxIters maximum number of iterations
  68  * @return
  69  * \f[
  70  * \frac{\ln(1-p)}{\ln\left(1-(1-ep)^\mathrm{modelPoints}\right)}
  71  * \f]
  72  *
  73  * If the computed number of iterations is larger than maxIters, then maxIters is returned.
  74  */
  75 int RANSACUpdateNumIters( double p, double ep, int modelPoints, int maxIters );
  76
  77 class CV_EXPORTS LMSolver : public Algorithm
  78 {
  79 public:
  80     class CV_EXPORTS Callback
  81     {
  82     public:
  83         virtual ~Callback() {}
  84         virtual bool compute(InputArray param, OutputArray err, OutputArray J) const = 0;
  85     };
  86
  87     virtual void setCallback(const Ptr<LMSolver::Callback>& cb) = 0;
  88     virtual int run(InputOutputArray _param0) const = 0;
  89 };
  90
  91 CV_EXPORTS Ptr<LMSolver> createLMSolver(const Ptr<LMSolver::Callback>& cb, int maxIters);
  92
  93 class CV_EXPORTS PointSetRegistrator : public Algorithm
  94 {
  95 public:
  96     class CV_EXPORTS Callback
  97     {
  98     public:
  99         virtual ~Callback() {}
 100         virtual int runKernel(InputArray m1, InputArray m2, OutputArray model) const = 0;
 101         virtual void computeError(InputArray m1, InputArray m2, InputArray model, OutputArray err) const = 0;
 102         virtual bool checkSubset(InputArray, InputArray, int) const { return true; }
 103     };
 104
 105     virtual void setCallback(const Ptr<PointSetRegistrator::Callback>& cb) = 0;
 106     virtual bool run(InputArray m1, InputArray m2, OutputArray model, OutputArray mask) const = 0;
 107 };
 108
 109 CV_EXPORTS Ptr<PointSetRegistrator> createRANSACPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
 110                                                                     int modelPoints, double threshold,
 111                                                                     double confidence=0.99, int maxIters=1000 );
 112
 113 CV_EXPORTS Ptr<PointSetRegistrator> createLMeDSPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
 114                                                                    int modelPoints, double confidence=0.99, int maxIters=1000 );
 115
 116 template<typename T> inline int compressElems( T* ptr, const uchar* mask, int mstep, int count )
 117 {
 118     int i, j;
 119     for( i = j = 0; i < count; i++ )
 120         if( mask[i*mstep] )
 121         {
 122             if( i > j )
 123                 ptr[j] = ptr[i];
 124             j++;
 125         }
 126     return j;
 127 }
 128
 129 static inline bool haveCollinearPoints( const Mat& m, int count )
 130 {
 131     int j, k, i = count-1;
 132     const Point2f* ptr = m.ptr<Point2f>();
 133
 134     // check that the i-th selected point does not belong
 135     // to a line connecting some previously selected points
 136     // also checks that points are not too close to each other
 137     for( j = 0; j < i; j++ )
 138     {
 139         double dx1 = ptr[j].x - ptr[i].x;
 140         double dy1 = ptr[j].y - ptr[i].y;
 141         for( k = 0; k < j; k++ )
 142         {
 143             double dx2 = ptr[k].x - ptr[i].x;
 144             double dy2 = ptr[k].y - ptr[i].y;
 145             if( fabs(dx2*dy1 - dy2*dx1) <= FLT_EPSILON*(fabs(dx1) + fabs(dy1) + fabs(dx2) + fabs(dy2)))
 146                 return true;
 147         }
 148     }
 149     return false;
 150 }
 151
 152 } // namespace cv
 153
 154 int checkChessboard(const cv::Mat & img, const cv::Size & size);
 155 int checkChessboardBinary(const cv::Mat & img, const cv::Size & size);
 156
 157 #endif