mirror of
https://github.com/opencv/opencv.git
synced 2024-12-14 00:39:13 +08:00
Merge pull request #21089 from sturkmen72:clean-up-c-api
This commit is contained in:
Alexander Alekhin
commit
5d04e5b063
@ -181,9 +181,8 @@ void CV_ChessboardSubpixelTest::run( int )
|
||||
break;
|
||||
}
|
||||
|
||||
IplImage chessboard_image_header = cvIplImage(chessboard_image);
|
||||
cvFindCornerSubPix(&chessboard_image_header, (CvPoint2D32f*)&test_corners[0],
|
||||
(int)test_corners.size(), cvSize(3, 3), cvSize(1, 1), cvTermCriteria(CV_TERMCRIT_EPS|CV_TERMCRIT_ITER,300,0.1));
|
||||
cornerSubPix(chessboard_image, test_corners,
|
||||
Size(3, 3), Size(1, 1), TermCriteria(TermCriteria::EPS|TermCriteria::MAX_ITER, 300, 0.1));
|
||||
find4QuadCornerSubpix(chessboard_image, test_corners, Size(5, 5));
|
||||
|
||||
double dist2 = 0.0;
|
||||
|
||||
@ -1078,38 +1078,11 @@ CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
|
||||
#define CV_RAND_UNI 0
|
||||
#define CV_RAND_NORMAL 1
|
||||
|
||||
/** @brief Fills an array with random numbers and updates the RNG state.
|
||||
|
||||
The function fills the destination array with uniformly or normally distributed random numbers.
|
||||
@param rng CvRNG state initialized by cvRNG
|
||||
@param arr The destination array
|
||||
@param dist_type Distribution type
|
||||
> - **CV_RAND_UNI** uniform distribution
|
||||
> - **CV_RAND_NORMAL** normal or Gaussian distribution
|
||||
@param param1 The first parameter of the distribution. In the case of a uniform distribution it is
|
||||
the inclusive lower boundary of the random numbers range. In the case of a normal distribution it
|
||||
is the mean value of the random numbers.
|
||||
@param param2 The second parameter of the distribution. In the case of a uniform distribution it
|
||||
is the exclusive upper boundary of the random numbers range. In the case of a normal distribution
|
||||
it is the standard deviation of the random numbers.
|
||||
@sa randu, randn, RNG::fill.
|
||||
*/
|
||||
CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
|
||||
CvScalar param1, CvScalar param2 );
|
||||
|
||||
CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
|
||||
double iter_factor CV_DEFAULT(1.));
|
||||
|
||||
#define CV_SORT_EVERY_ROW 0
|
||||
#define CV_SORT_EVERY_COLUMN 1
|
||||
#define CV_SORT_ASCENDING 0
|
||||
#define CV_SORT_DESCENDING 16
|
||||
|
||||
CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
|
||||
CvArr* idxmat CV_DEFAULT(NULL),
|
||||
int flags CV_DEFAULT(0));
|
||||
|
||||
|
||||
/** Finds all real and complex roots of a polynomial equation */
|
||||
CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
|
||||
int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));
|
||||
|
||||
@ -1272,45 +1272,6 @@ CvSize2D32f cvSize2D32f(const cv::Size_<_Tp>& sz)
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @sa RotatedRect
|
||||
*/
|
||||
typedef struct CvBox2D
|
||||
{
|
||||
CvPoint2D32f center; /**< Center of the box. */
|
||||
CvSize2D32f size; /**< Box width and length. */
|
||||
float angle; /**< Angle between the horizontal axis */
|
||||
/**< and the first side (i.e. length) in degrees */
|
||||
|
||||
#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
|
||||
CvBox2D(CvPoint2D32f c = CvPoint2D32f(), CvSize2D32f s = CvSize2D32f(), float a = 0) : center(c), size(s), angle(a) {}
|
||||
CvBox2D(const cv::RotatedRect& rr) : center(rr.center), size(rr.size), angle(rr.angle) {}
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
operator cv::RotatedRect() const { return cv::RotatedRect(center, size, angle); }
|
||||
#endif
|
||||
}
|
||||
CvBox2D;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
CV_INLINE CvBox2D cvBox2D(CvPoint2D32f c = CvPoint2D32f(), CvSize2D32f s = CvSize2D32f(), float a = 0)
|
||||
{
|
||||
CvBox2D self;
|
||||
self.center = c;
|
||||
self.size = s;
|
||||
self.angle = a;
|
||||
return self;
|
||||
}
|
||||
CV_INLINE CvBox2D cvBox2D(const cv::RotatedRect& rr)
|
||||
{
|
||||
CvBox2D self;
|
||||
self.center = cvPoint2D32f(rr.center);
|
||||
self.size = cvSize2D32f(rr.size);
|
||||
self.angle = rr.angle;
|
||||
return self;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/** Line iterator state: */
|
||||
typedef struct CvLineIterator
|
||||
@ -1958,167 +1919,6 @@ CvSeqReader;
|
||||
(edge)->next[(edge)->vtx[1] == (vertex)])
|
||||
|
||||
|
||||
|
||||
/****************************************************************************************\
|
||||
* Data structures for persistence (a.k.a serialization) functionality *
|
||||
\****************************************************************************************/
|
||||
|
||||
#if 0
|
||||
|
||||
/** "black box" file storage */
|
||||
typedef struct CvFileStorage CvFileStorage;
|
||||
|
||||
/** Storage flags: */
|
||||
#define CV_STORAGE_READ 0
|
||||
#define CV_STORAGE_WRITE 1
|
||||
#define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE
|
||||
#define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE
|
||||
#define CV_STORAGE_APPEND 2
|
||||
#define CV_STORAGE_MEMORY 4
|
||||
#define CV_STORAGE_FORMAT_MASK (7<<3)
|
||||
#define CV_STORAGE_FORMAT_AUTO 0
|
||||
#define CV_STORAGE_FORMAT_XML 8
|
||||
#define CV_STORAGE_FORMAT_YAML 16
|
||||
#define CV_STORAGE_FORMAT_JSON 24
|
||||
#define CV_STORAGE_BASE64 64
|
||||
#define CV_STORAGE_WRITE_BASE64 (CV_STORAGE_BASE64 | CV_STORAGE_WRITE)
|
||||
|
||||
/** @brief List of attributes. :
|
||||
|
||||
In the current implementation, attributes are used to pass extra parameters when writing user
|
||||
objects (see cvWrite). XML attributes inside tags are not supported, aside from the object type
|
||||
specification (type_id attribute).
|
||||
@see cvAttrList, cvAttrValue
|
||||
*/
|
||||
typedef struct CvAttrList
|
||||
{
|
||||
const char** attr; /**< NULL-terminated array of (attribute_name,attribute_value) pairs. */
|
||||
struct CvAttrList* next; /**< Pointer to next chunk of the attributes list. */
|
||||
}
|
||||
CvAttrList;
|
||||
|
||||
/** initializes CvAttrList structure */
|
||||
CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL),
|
||||
CvAttrList* next CV_DEFAULT(NULL) )
|
||||
{
|
||||
CvAttrList l;
|
||||
l.attr = attr;
|
||||
l.next = next;
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
struct CvTypeInfo;
|
||||
|
||||
#define CV_NODE_NONE 0
|
||||
#define CV_NODE_INT 1
|
||||
#define CV_NODE_INTEGER CV_NODE_INT
|
||||
#define CV_NODE_REAL 2
|
||||
#define CV_NODE_FLOAT CV_NODE_REAL
|
||||
#define CV_NODE_STR 3
|
||||
#define CV_NODE_STRING CV_NODE_STR
|
||||
#define CV_NODE_REF 4 /**< not used */
|
||||
#define CV_NODE_SEQ 5
|
||||
#define CV_NODE_MAP 6
|
||||
#define CV_NODE_TYPE_MASK 7
|
||||
|
||||
#define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK)
|
||||
|
||||
/** file node flags */
|
||||
#define CV_NODE_FLOW 8 /**<Used only for writing structures in YAML format. */
|
||||
#define CV_NODE_USER 16
|
||||
#define CV_NODE_EMPTY 32
|
||||
#define CV_NODE_NAMED 64
|
||||
|
||||
#define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT)
|
||||
#define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL)
|
||||
#define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING)
|
||||
#define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ)
|
||||
#define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP)
|
||||
#define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)
|
||||
#define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0)
|
||||
#define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0)
|
||||
#define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0)
|
||||
#define CV_NODE_HAS_NAME(flags) (((flags) & CV_NODE_NAMED) != 0)
|
||||
|
||||
#define CV_NODE_SEQ_SIMPLE 256
|
||||
#define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)
|
||||
|
||||
typedef struct CvString
|
||||
{
|
||||
int len;
|
||||
char* ptr;
|
||||
}
|
||||
CvString;
|
||||
|
||||
/** All the keys (names) of elements in the read file storage
|
||||
are stored in the hash to speed up the lookup operations: */
|
||||
typedef struct CvStringHashNode
|
||||
{
|
||||
unsigned hashval;
|
||||
CvString str;
|
||||
struct CvStringHashNode* next;
|
||||
}
|
||||
CvStringHashNode;
|
||||
|
||||
typedef struct CvGenericHash CvFileNodeHash;
|
||||
|
||||
/** Basic element of the file storage - scalar or collection: */
|
||||
typedef struct CvFileNode
|
||||
{
|
||||
int tag;
|
||||
struct CvTypeInfo* info; /**< type information
|
||||
(only for user-defined object, for others it is 0) */
|
||||
union
|
||||
{
|
||||
double f; /**< scalar floating-point number */
|
||||
int i; /**< scalar integer number */
|
||||
CvString str; /**< text string */
|
||||
CvSeq* seq; /**< sequence (ordered collection of file nodes) */
|
||||
CvFileNodeHash* map; /**< map (collection of named file nodes) */
|
||||
} data;
|
||||
}
|
||||
CvFileNode;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );
|
||||
typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );
|
||||
typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );
|
||||
typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,
|
||||
const void* struct_ptr, CvAttrList attributes );
|
||||
typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @brief Type information
|
||||
|
||||
The structure contains information about one of the standard or user-defined types. Instances of the
|
||||
type may or may not contain a pointer to the corresponding CvTypeInfo structure. In any case, there
|
||||
is a way to find the type info structure for a given object using the cvTypeOf function.
|
||||
Alternatively, type info can be found by type name using cvFindType, which is used when an object
|
||||
is read from file storage. The user can register a new type with cvRegisterType that adds the type
|
||||
information structure into the beginning of the type list. Thus, it is possible to create
|
||||
specialized types from generic standard types and override the basic methods.
|
||||
*/
|
||||
typedef struct CvTypeInfo
|
||||
{
|
||||
int flags; /**< not used */
|
||||
int header_size; /**< sizeof(CvTypeInfo) */
|
||||
struct CvTypeInfo* prev; /**< previous registered type in the list */
|
||||
struct CvTypeInfo* next; /**< next registered type in the list */
|
||||
const char* type_name; /**< type name, written to file storage */
|
||||
CvIsInstanceFunc is_instance; /**< checks if the passed object belongs to the type */
|
||||
CvReleaseFunc release; /**< releases object (memory etc.) */
|
||||
CvReadFunc read; /**< reads object from file storage */
|
||||
CvWriteFunc write; /**< writes object to file storage */
|
||||
CvCloneFunc clone; /**< creates a copy of the object */
|
||||
}
|
||||
CvTypeInfo;
|
||||
#endif
|
||||
|
||||
/** @} */
|
||||
|
||||
#endif /*OPENCV_CORE_TYPES_H*/
|
||||
|
||||
@ -325,27 +325,4 @@ cvRange( CvArr* arr, double start, double end )
|
||||
return arr;
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvSort( const CvArr* _src, CvArr* _dst, CvArr* _idx, int flags )
|
||||
{
|
||||
cv::Mat src = cv::cvarrToMat(_src);
|
||||
|
||||
if( _idx )
|
||||
{
|
||||
cv::Mat idx0 = cv::cvarrToMat(_idx), idx = idx0;
|
||||
CV_Assert( src.size() == idx.size() && idx.type() == CV_32S && src.data != idx.data );
|
||||
cv::sortIdx( src, idx, flags );
|
||||
CV_Assert( idx0.data == idx.data );
|
||||
}
|
||||
|
||||
if( _dst )
|
||||
{
|
||||
cv::Mat dst0 = cv::cvarrToMat(_dst), dst = dst0;
|
||||
CV_Assert( src.size() == dst.size() && src.type() == dst.type() );
|
||||
cv::sort( src, dst, flags );
|
||||
CV_Assert( dst0.data == dst.data );
|
||||
}
|
||||
}
|
||||
|
||||
#endif // OPENCV_EXCLUDE_C_API
|
||||
|
||||
@ -868,9 +868,9 @@ template<typename T> static void sort_( const Mat& src, Mat& dst, int flags )
|
||||
{
|
||||
AutoBuffer<T> buf;
|
||||
int n, len;
|
||||
bool sortRows = (flags & 1) == CV_SORT_EVERY_ROW;
|
||||
bool sortRows = (flags & 1) == SORT_EVERY_ROW;
|
||||
bool inplace = src.data == dst.data;
|
||||
bool sortDescending = (flags & CV_SORT_DESCENDING) != 0;
|
||||
bool sortDescending = (flags & SORT_DESCENDING) != 0;
|
||||
|
||||
if( sortRows )
|
||||
n = src.rows, len = src.cols;
|
||||
@ -1013,8 +1013,8 @@ template<typename T> static void sortIdx_( const Mat& src, Mat& dst, int flags )
|
||||
{
|
||||
AutoBuffer<T> buf;
|
||||
AutoBuffer<int> ibuf;
|
||||
bool sortRows = (flags & 1) == CV_SORT_EVERY_ROW;
|
||||
bool sortDescending = (flags & CV_SORT_DESCENDING) != 0;
|
||||
bool sortRows = (flags & 1) == SORT_EVERY_ROW;
|
||||
bool sortDescending = (flags & SORT_DESCENDING) != 0;
|
||||
|
||||
CV_Assert( src.data != dst.data );
|
||||
|
||||
|
||||
@ -40,12 +40,6 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
/* ////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Filling CvMat/IplImage instances with random numbers
|
||||
//
|
||||
// */
|
||||
|
||||
#include "precomp.hpp"
|
||||
|
||||
namespace cv
|
||||
@ -751,28 +745,6 @@ void cv::randShuffle( InputOutputArray _dst, double iterFactor, RNG* _rng )
|
||||
}
|
||||
|
||||
|
||||
#ifndef OPENCV_EXCLUDE_C_API
|
||||
|
||||
CV_IMPL void
|
||||
cvRandArr( CvRNG* _rng, CvArr* arr, int disttype, CvScalar param1, CvScalar param2 )
|
||||
{
|
||||
cv::Mat mat = cv::cvarrToMat(arr);
|
||||
// !!! this will only work for current 64-bit MWC RNG !!!
|
||||
cv::RNG& rng = _rng ? (cv::RNG&)*_rng : cv::theRNG();
|
||||
rng.fill(mat, disttype == CV_RAND_NORMAL ?
|
||||
cv::RNG::NORMAL : cv::RNG::UNIFORM, cv::Scalar(param1), cv::Scalar(param2) );
|
||||
}
|
||||
|
||||
CV_IMPL void cvRandShuffle( CvArr* arr, CvRNG* _rng, double iter_factor )
|
||||
{
|
||||
cv::Mat dst = cv::cvarrToMat(arr);
|
||||
cv::RNG& rng = _rng ? (cv::RNG&)*_rng : cv::theRNG();
|
||||
cv::randShuffle( dst, iter_factor, &rng );
|
||||
}
|
||||
|
||||
#endif // OPENCV_EXCLUDE_C_API
|
||||
|
||||
|
||||
// Mersenne Twister random number generator.
|
||||
// Inspired by http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c
|
||||
|
||||
|
||||
@ -193,14 +193,6 @@ CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
|
||||
const CvPoint2D32f* dst,
|
||||
CvMat* map_matrix );
|
||||
|
||||
/** @brief Performs generic geometric transformation using the specified coordinate maps
|
||||
@see cv::remap
|
||||
*/
|
||||
CVAPI(void) cvRemap( const CvArr* src, CvArr* dst,
|
||||
const CvArr* mapx, const CvArr* mapy,
|
||||
int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
|
||||
CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
|
||||
|
||||
/** @brief Returns a structuring element of the specified size and shape for morphological operations.
|
||||
|
||||
@note the created structuring element IplConvKernel\* element must be released in the end using
|
||||
@ -269,23 +261,6 @@ CVAPI(void) cvGetHuMoments( CvMoments* moments, CvHuMoments* hu_moments );
|
||||
|
||||
/*********************************** data sampling **************************************/
|
||||
|
||||
/** @brief Fetches pixels that belong to the specified line segment and stores them to the buffer.
|
||||
|
||||
Returns the number of retrieved points.
|
||||
@see cv::LineSegmentDetector
|
||||
*/
|
||||
CVAPI(int) cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer,
|
||||
int connectivity CV_DEFAULT(8));
|
||||
|
||||
/** @brief Retrieves the rectangular image region with specified center from the input array.
|
||||
|
||||
dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2).
|
||||
Values of pixels with fractional coordinates are retrieved using bilinear interpolation
|
||||
@see cv::getRectSubPix
|
||||
*/
|
||||
CVAPI(void) cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
|
||||
|
||||
|
||||
/** @brief Retrieves quadrangle from the input array.
|
||||
|
||||
matrixarr = ( a11 a12 | b1 ) dst(x,y) <- src(A[x y]' + b)
|
||||
@ -296,13 +271,6 @@ CVAPI(void) cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center
|
||||
CVAPI(void) cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
|
||||
const CvMat* map_matrix );
|
||||
|
||||
/** @brief Measures similarity between template and overlapped windows in the source image
|
||||
and fills the resultant image with the measurements
|
||||
@see cv::matchTemplate
|
||||
*/
|
||||
CVAPI(void) cvMatchTemplate( const CvArr* image, const CvArr* templ,
|
||||
CvArr* result, int method );
|
||||
|
||||
/** @brief Computes earth mover distance between
|
||||
two weighted point sets (called signatures)
|
||||
@see cv::EMD
|
||||
@ -441,24 +409,6 @@ CVAPI(double) cvContourArea( const CvArr* contour,
|
||||
CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
|
||||
int oriented CV_DEFAULT(0));
|
||||
|
||||
/** @brief Finds minimum area rotated rectangle bounding a set of points
|
||||
@see cv::minAreaRect
|
||||
*/
|
||||
CVAPI(CvBox2D) cvMinAreaRect2( const CvArr* points,
|
||||
CvMemStorage* storage CV_DEFAULT(NULL));
|
||||
|
||||
/** @brief Finds minimum enclosing circle for a set of points
|
||||
@see cv::minEnclosingCircle
|
||||
*/
|
||||
CVAPI(int) cvMinEnclosingCircle( const CvArr* points,
|
||||
CvPoint2D32f* center, float* radius );
|
||||
|
||||
/** @brief Compares two contours by matching their moments
|
||||
@see cv::matchShapes
|
||||
*/
|
||||
CVAPI(double) cvMatchShapes( const void* object1, const void* object2,
|
||||
int method, double parameter CV_DEFAULT(0));
|
||||
|
||||
/** @brief Calculates exact convex hull of 2d point set
|
||||
@see cv::convexHull
|
||||
*/
|
||||
@ -473,17 +423,6 @@ CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
|
||||
CVAPI(int) cvCheckContourConvexity( const CvArr* contour );
|
||||
|
||||
|
||||
/** @brief Fits ellipse into a set of 2d points
|
||||
@see cv::fitEllipse
|
||||
*/
|
||||
CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
|
||||
|
||||
/** @brief Finds minimum rectangle containing two given rectangles */
|
||||
CVAPI(CvRect) cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
|
||||
|
||||
/** @brief Finds coordinates of the box vertices */
|
||||
CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
|
||||
|
||||
/** @brief Initializes sequence header for a matrix (column or row vector) of points
|
||||
|
||||
a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!) */
|
||||
@ -491,16 +430,6 @@ CVAPI(CvSeq*) cvPointSeqFromMat( int seq_kind, const CvArr* mat,
|
||||
CvContour* contour_header,
|
||||
CvSeqBlock* block );
|
||||
|
||||
/** @brief Checks whether the point is inside polygon, outside, on an edge (at a vertex).
|
||||
|
||||
Returns positive, negative or zero value, correspondingly.
|
||||
Optionally, measures a signed distance between
|
||||
the point and the nearest polygon edge (measure_dist=1)
|
||||
@see cv::pointPolygonTest
|
||||
*/
|
||||
CVAPI(double) cvPointPolygonTest( const CvArr* contour,
|
||||
CvPoint2D32f pt, int measure_dist );
|
||||
|
||||
/****************************************************************************************\
|
||||
* Histogram functions *
|
||||
\****************************************************************************************/
|
||||
@ -741,16 +670,6 @@ CVAPI(void) cvFloodFill( CvArr* image, CvPoint seed_point,
|
||||
* Feature detection *
|
||||
\****************************************************************************************/
|
||||
|
||||
|
||||
/** @brief Calculates constraint image for corner detection
|
||||
|
||||
Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy.
|
||||
Applying threshold to the result gives coordinates of corners
|
||||
@see cv::preCornerDetect
|
||||
*/
|
||||
CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners,
|
||||
int aperture_size CV_DEFAULT(3) );
|
||||
|
||||
/** @brief Calculates eigen values and vectors of 2x2
|
||||
gradient covariation matrix at every image pixel
|
||||
@see cv::cornerEigenValsAndVecs
|
||||
@ -765,13 +684,6 @@ CVAPI(void) cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
|
||||
CVAPI(void) cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
|
||||
int block_size, int aperture_size CV_DEFAULT(3) );
|
||||
|
||||
/** @brief Adjust corner position using some sort of gradient search
|
||||
@see cv::cornerSubPix
|
||||
*/
|
||||
CVAPI(void) cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
|
||||
int count, CvSize win, CvSize zero_zone,
|
||||
CvTermCriteria criteria );
|
||||
|
||||
|
||||
/** @brief Finds lines on binary image using one of several methods.
|
||||
|
||||
@ -798,11 +710,6 @@ CVAPI(CvSeq*) cvHoughCircles( CvArr* image, void* circle_storage,
|
||||
int min_radius CV_DEFAULT(0),
|
||||
int max_radius CV_DEFAULT(0));
|
||||
|
||||
/** @brief Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)
|
||||
@see cv::fitLine
|
||||
*/
|
||||
CVAPI(void) cvFitLine( const CvArr* points, int dist_type, double param,
|
||||
double reps, double aeps, float* line );
|
||||
|
||||
/****************************************************************************************\
|
||||
* Drawing *
|
||||
@ -860,18 +767,6 @@ CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,
|
||||
CvScalar color, int thickness CV_DEFAULT(1),
|
||||
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
|
||||
|
||||
CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
|
||||
int thickness CV_DEFAULT(1),
|
||||
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
|
||||
{
|
||||
CvSize axes = cvSize(
|
||||
cvRound(box.size.width*0.5),
|
||||
cvRound(box.size.height*0.5)
|
||||
);
|
||||
|
||||
cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,
|
||||
0, 360, color, thickness, line_type, shift );
|
||||
}
|
||||
|
||||
/** @brief Fills an area bounded by one or more arbitrary polygons
|
||||
@see cv::fillPoly
|
||||
|
||||
@ -756,14 +756,4 @@ cvCornerEigenValsAndVecs( const void* srcarr, void* dstarr,
|
||||
cv::cornerEigenValsAndVecs( src, dst, block_size, aperture_size, cv::BORDER_REPLICATE );
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvPreCornerDetect( const void* srcarr, void* dstarr, int aperture_size )
|
||||
{
|
||||
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
|
||||
|
||||
CV_Assert( src.size() == dst.size() && dst.type() == CV_32FC1 );
|
||||
cv::preCornerDetect( src, dst, aperture_size, cv::BORDER_REPLICATE );
|
||||
}
|
||||
|
||||
/* End of file */
|
||||
|
||||
@ -155,17 +155,4 @@ void cv::cornerSubPix( InputArray _image, InputOutputArray _corners,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvFindCornerSubPix( const void* srcarr, CvPoint2D32f* _corners,
|
||||
int count, CvSize win, CvSize zeroZone,
|
||||
CvTermCriteria criteria )
|
||||
{
|
||||
if(!_corners || count <= 0)
|
||||
return;
|
||||
|
||||
cv::Mat src = cv::cvarrToMat(srcarr), corners(count, 1, CV_32FC2, _corners);
|
||||
cv::cornerSubPix(src, corners, win, zeroZone, criteria);
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
|
||||
@ -41,57 +41,6 @@
|
||||
#include "precomp.hpp"
|
||||
|
||||
|
||||
CV_IMPL CvRect
|
||||
cvMaxRect( const CvRect* rect1, const CvRect* rect2 )
|
||||
{
|
||||
if( rect1 && rect2 )
|
||||
{
|
||||
cv::Rect max_rect;
|
||||
int a, b;
|
||||
|
||||
max_rect.x = a = rect1->x;
|
||||
b = rect2->x;
|
||||
if( max_rect.x > b )
|
||||
max_rect.x = b;
|
||||
|
||||
max_rect.width = a += rect1->width;
|
||||
b += rect2->width;
|
||||
|
||||
if( max_rect.width < b )
|
||||
max_rect.width = b;
|
||||
max_rect.width -= max_rect.x;
|
||||
|
||||
max_rect.y = a = rect1->y;
|
||||
b = rect2->y;
|
||||
if( max_rect.y > b )
|
||||
max_rect.y = b;
|
||||
|
||||
max_rect.height = a += rect1->height;
|
||||
b += rect2->height;
|
||||
|
||||
if( max_rect.height < b )
|
||||
max_rect.height = b;
|
||||
max_rect.height -= max_rect.y;
|
||||
return cvRect(max_rect);
|
||||
}
|
||||
else if( rect1 )
|
||||
return *rect1;
|
||||
else if( rect2 )
|
||||
return *rect2;
|
||||
else
|
||||
return cvRect(0,0,0,0);
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] )
|
||||
{
|
||||
if( !pt )
|
||||
CV_Error( CV_StsNullPtr, "NULL vertex array pointer" );
|
||||
cv::RotatedRect(box).points((cv::Point2f*)pt);
|
||||
}
|
||||
|
||||
|
||||
double cv::pointPolygonTest( InputArray _contour, Point2f pt, bool measureDist )
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
@ -244,14 +193,6 @@ double cv::pointPolygonTest( InputArray _contour, Point2f pt, bool measureDist )
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL double
|
||||
cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
|
||||
{
|
||||
cv::AutoBuffer<double> abuf;
|
||||
cv::Mat contour = cv::cvarrToMat(_contour, false, false, 0, &abuf);
|
||||
return cv::pointPolygonTest(contour, pt, measure_dist != 0);
|
||||
}
|
||||
|
||||
/*
|
||||
This code is described in "Computational Geometry in C" (Second Edition),
|
||||
Chapter 7. It is not written to be comprehensible without the
|
||||
|
||||
@ -3299,11 +3299,6 @@ private:
|
||||
int* lut_;
|
||||
};
|
||||
|
||||
CV_IMPL void cvEqualizeHist( const CvArr* srcarr, CvArr* dstarr )
|
||||
{
|
||||
cv::equalizeHist(cv::cvarrToMat(srcarr), cv::cvarrToMat(dstarr));
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
namespace cv {
|
||||
@ -3451,158 +3446,4 @@ void cv::equalizeHist( InputArray _src, OutputArray _dst )
|
||||
lutBody(heightRange);
|
||||
}
|
||||
|
||||
#if 0
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
/* Implementation of RTTI and Generic Functions for CvHistogram */
|
||||
#define CV_TYPE_NAME_HIST "opencv-hist"
|
||||
|
||||
static int icvIsHist( const void * ptr )
|
||||
{
|
||||
return CV_IS_HIST( ((CvHistogram*)ptr) );
|
||||
}
|
||||
|
||||
static CvHistogram * icvCloneHist( const CvHistogram * src )
|
||||
{
|
||||
CvHistogram * dst=NULL;
|
||||
cvCopyHist(src, &dst);
|
||||
return dst;
|
||||
}
|
||||
|
||||
static void *icvReadHist( CvFileStorage * fs, CvFileNode * node )
|
||||
{
|
||||
CvHistogram * h = 0;
|
||||
int type = 0;
|
||||
int is_uniform = 0;
|
||||
int have_ranges = 0;
|
||||
|
||||
h = (CvHistogram *)cvAlloc( sizeof(CvHistogram) );
|
||||
|
||||
type = cvReadIntByName( fs, node, "type", 0 );
|
||||
is_uniform = cvReadIntByName( fs, node, "is_uniform", 0 );
|
||||
have_ranges = cvReadIntByName( fs, node, "have_ranges", 0 );
|
||||
h->type = CV_HIST_MAGIC_VAL | type |
|
||||
(is_uniform ? CV_HIST_UNIFORM_FLAG : 0) |
|
||||
(have_ranges ? CV_HIST_RANGES_FLAG : 0);
|
||||
|
||||
if(type == CV_HIST_ARRAY)
|
||||
{
|
||||
// read histogram bins
|
||||
CvMatND* mat = (CvMatND*)cvReadByName( fs, node, "mat" );
|
||||
int i, sizes[CV_MAX_DIM];
|
||||
|
||||
if(!CV_IS_MATND(mat))
|
||||
CV_Error( CV_StsError, "Expected CvMatND");
|
||||
|
||||
for(i=0; i<mat->dims; i++)
|
||||
sizes[i] = mat->dim[i].size;
|
||||
|
||||
cvInitMatNDHeader( &(h->mat), mat->dims, sizes, mat->type, mat->data.ptr );
|
||||
h->bins = &(h->mat);
|
||||
|
||||
// take ownership of refcount pointer as well
|
||||
h->mat.refcount = mat->refcount;
|
||||
|
||||
// increase refcount so freeing temp header doesn't free data
|
||||
cvIncRefData( mat );
|
||||
|
||||
// free temporary header
|
||||
cvReleaseMatND( &mat );
|
||||
}
|
||||
else
|
||||
{
|
||||
h->bins = cvReadByName( fs, node, "bins" );
|
||||
if(!CV_IS_SPARSE_MAT(h->bins)){
|
||||
CV_Error( CV_StsError, "Unknown Histogram type");
|
||||
}
|
||||
}
|
||||
|
||||
// read thresholds
|
||||
if(have_ranges)
|
||||
{
|
||||
int i, dims, size[CV_MAX_DIM], total = 0;
|
||||
CvSeqReader reader;
|
||||
CvFileNode * thresh_node;
|
||||
|
||||
dims = cvGetDims( h->bins, size );
|
||||
for( i = 0; i < dims; i++ )
|
||||
total += size[i]+1;
|
||||
|
||||
thresh_node = cvGetFileNodeByName( fs, node, "thresh" );
|
||||
if(!thresh_node)
|
||||
CV_Error( CV_StsError, "'thresh' node is missing");
|
||||
cvStartReadRawData( fs, thresh_node, &reader );
|
||||
|
||||
if(is_uniform)
|
||||
{
|
||||
for(i=0; i<dims; i++)
|
||||
cvReadRawDataSlice( fs, &reader, 2, h->thresh[i], "f" );
|
||||
h->thresh2 = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
float* dim_ranges;
|
||||
h->thresh2 = (float**)cvAlloc(
|
||||
dims*sizeof(h->thresh2[0])+
|
||||
total*sizeof(h->thresh2[0][0]));
|
||||
dim_ranges = (float*)(h->thresh2 + dims);
|
||||
for(i=0; i < dims; i++)
|
||||
{
|
||||
h->thresh2[i] = dim_ranges;
|
||||
cvReadRawDataSlice( fs, &reader, size[i]+1, dim_ranges, "f" );
|
||||
dim_ranges += size[i] + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return h;
|
||||
}
|
||||
|
||||
static void icvWriteHist( CvFileStorage* fs, const char* name,
|
||||
const void* struct_ptr, CvAttrList /*attributes*/ )
|
||||
{
|
||||
const CvHistogram * hist = (const CvHistogram *) struct_ptr;
|
||||
int sizes[CV_MAX_DIM];
|
||||
int dims;
|
||||
int i;
|
||||
int is_uniform, have_ranges;
|
||||
|
||||
cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_HIST );
|
||||
|
||||
is_uniform = (CV_IS_UNIFORM_HIST(hist) ? 1 : 0);
|
||||
have_ranges = (hist->type & CV_HIST_RANGES_FLAG ? 1 : 0);
|
||||
|
||||
cvWriteInt( fs, "type", (hist->type & 1) );
|
||||
cvWriteInt( fs, "is_uniform", is_uniform );
|
||||
cvWriteInt( fs, "have_ranges", have_ranges );
|
||||
if(!CV_IS_SPARSE_HIST(hist))
|
||||
cvWrite( fs, "mat", &(hist->mat) );
|
||||
else
|
||||
cvWrite( fs, "bins", hist->bins );
|
||||
|
||||
// write thresholds
|
||||
if(have_ranges){
|
||||
dims = cvGetDims( hist->bins, sizes );
|
||||
cvStartWriteStruct( fs, "thresh", CV_NODE_SEQ + CV_NODE_FLOW );
|
||||
if(is_uniform){
|
||||
for(i=0; i<dims; i++){
|
||||
cvWriteRawData( fs, hist->thresh[i], 2, "f" );
|
||||
}
|
||||
}
|
||||
else{
|
||||
for(i=0; i<dims; i++){
|
||||
cvWriteRawData( fs, hist->thresh2[i], sizes[i]+1, "f" );
|
||||
}
|
||||
}
|
||||
cvEndWriteStruct( fs );
|
||||
}
|
||||
|
||||
cvEndWriteStruct( fs );
|
||||
}
|
||||
|
||||
|
||||
CvType hist_type( CV_TYPE_NAME_HIST, icvIsHist, (CvReleaseFunc)cvReleaseHist,
|
||||
icvReadHist, icvWriteHist, (CvCloneFunc)icvCloneHist );
|
||||
#endif
|
||||
|
||||
/* End of file. */
|
||||
|
||||
@ -3424,31 +3424,6 @@ cvWarpPerspective( const CvArr* srcarr, CvArr* dstarr, const CvMat* marr,
|
||||
fillval );
|
||||
}
|
||||
|
||||
CV_IMPL void
|
||||
cvRemap( const CvArr* srcarr, CvArr* dstarr,
|
||||
const CvArr* _mapx, const CvArr* _mapy,
|
||||
int flags, CvScalar fillval )
|
||||
{
|
||||
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), dst0 = dst;
|
||||
cv::Mat mapx = cv::cvarrToMat(_mapx), mapy = cv::cvarrToMat(_mapy);
|
||||
CV_Assert( src.type() == dst.type() && dst.size() == mapx.size() );
|
||||
cv::remap( src, dst, mapx, mapy, flags & cv::INTER_MAX,
|
||||
(flags & CV_WARP_FILL_OUTLIERS) ? cv::BORDER_CONSTANT : cv::BORDER_TRANSPARENT,
|
||||
fillval );
|
||||
CV_Assert( dst0.data == dst.data );
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL CvMat*
|
||||
cv2DRotationMatrix( CvPoint2D32f center, double angle,
|
||||
double scale, CvMat* matrix )
|
||||
{
|
||||
cv::Mat M0 = cv::cvarrToMat(matrix), M = cv::getRotationMatrix2D(center, angle, scale);
|
||||
CV_Assert( M.size() == M0.size() );
|
||||
M.convertTo(M0, M0.type());
|
||||
return matrix;
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL CvMat*
|
||||
cvGetPerspectiveTransform( const CvPoint2D32f* src,
|
||||
|
||||
@ -634,18 +634,4 @@ void cv::fitLine( InputArray _points, OutputArray _line, int distType,
|
||||
Mat(npoints2 >= 0 ? 4 : 6, 1, CV_32F, linebuf).copyTo(_line);
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvFitLine( const CvArr* array, int dist, double param,
|
||||
double reps, double aeps, float *line )
|
||||
{
|
||||
CV_Assert(line != 0);
|
||||
|
||||
cv::AutoBuffer<double> buf;
|
||||
cv::Mat points = cv::cvarrToMat(array, false, false, 0, &buf);
|
||||
cv::Mat linemat(points.checkVector(2) >= 0 ? 4 : 6, 1, CV_32F, line);
|
||||
|
||||
cv::fitLine(points, linemat, dist, param, reps, aeps);
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
|
||||
@ -170,16 +170,4 @@ double cv::matchShapes(InputArray contour1, InputArray contour2, int method, dou
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL double
|
||||
cvMatchShapes( const void* _contour1, const void* _contour2,
|
||||
int method, double parameter )
|
||||
{
|
||||
cv::AutoBuffer<double> abuf1, abuf2;
|
||||
cv::Mat contour1 = cv::cvarrToMat(_contour1, false, false, 0, &abuf1);
|
||||
cv::Mat contour2 = cv::cvarrToMat(_contour2, false, false, 0, &abuf2);
|
||||
|
||||
return cv::matchShapes(contour1, contour2, method, parameter);
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
|
||||
@ -407,16 +407,6 @@ cv::RotatedRect cv::minAreaRect( InputArray _points )
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL CvBox2D
|
||||
cvMinAreaRect2( const CvArr* array, CvMemStorage* /*storage*/ )
|
||||
{
|
||||
cv::AutoBuffer<double> abuf;
|
||||
cv::Mat points = cv::cvarrToMat(array, false, false, 0, &abuf);
|
||||
|
||||
cv::RotatedRect rr = cv::minAreaRect(points);
|
||||
return cvBox2D(rr);
|
||||
}
|
||||
|
||||
void cv::boxPoints(cv::RotatedRect box, OutputArray _pts)
|
||||
{
|
||||
CV_INSTRUMENT_REGION();
|
||||
|
||||
@ -421,17 +421,6 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center,
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvGetRectSubPix( const void* srcarr, void* dstarr, CvPoint2D32f center )
|
||||
{
|
||||
cv::Mat src = cv::cvarrToMat(srcarr);
|
||||
const cv::Mat dst = cv::cvarrToMat(dstarr);
|
||||
CV_Assert( src.channels() == dst.channels() );
|
||||
|
||||
cv::getRectSubPix(src, dst.size(), center, dst, dst.type());
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL void
|
||||
cvGetQuadrangleSubPix( const void* srcarr, void* dstarr, const CvMat* mat )
|
||||
{
|
||||
@ -463,26 +452,4 @@ cvGetQuadrangleSubPix( const void* srcarr, void* dstarr, const CvMat* mat )
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL int
|
||||
cvSampleLine( const void* _img, CvPoint pt1, CvPoint pt2,
|
||||
void* _buffer, int connectivity )
|
||||
{
|
||||
cv::Mat img = cv::cvarrToMat(_img);
|
||||
cv::LineIterator li(img, pt1, pt2, connectivity, false);
|
||||
uchar* buffer = (uchar*)_buffer;
|
||||
size_t pixsize = img.elemSize();
|
||||
|
||||
if( !buffer )
|
||||
CV_Error( CV_StsNullPtr, "" );
|
||||
|
||||
for( int i = 0; i < li.count; i++, ++li )
|
||||
{
|
||||
for( size_t k = 0; k < pixsize; k++ )
|
||||
*buffer++ = li.ptr[k];
|
||||
}
|
||||
|
||||
return li.count;
|
||||
}
|
||||
|
||||
|
||||
/* End of file. */
|
||||
|
||||
@ -1144,22 +1144,6 @@ cv::Rect cv::boundingRect(InputArray array)
|
||||
|
||||
////////////////////////////////////////////// C API ///////////////////////////////////////////
|
||||
|
||||
CV_IMPL int
|
||||
cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius )
|
||||
{
|
||||
cv::AutoBuffer<double> abuf;
|
||||
cv::Mat points = cv::cvarrToMat(array, false, false, 0, &abuf);
|
||||
cv::Point2f center;
|
||||
float radius;
|
||||
|
||||
cv::minEnclosingCircle(points, center, radius);
|
||||
if(_center)
|
||||
*_center = cvPoint2D32f(center);
|
||||
if(_radius)
|
||||
*_radius = radius;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void
|
||||
icvMemCopy( double **buf1, double **buf2, double **buf3, int *b_max )
|
||||
{
|
||||
@ -1474,14 +1458,6 @@ cvArcLength( const void *array, CvSlice slice, int is_closed )
|
||||
}
|
||||
|
||||
|
||||
CV_IMPL CvBox2D
|
||||
cvFitEllipse2( const CvArr* array )
|
||||
{
|
||||
cv::AutoBuffer<double> abuf;
|
||||
cv::Mat points = cv::cvarrToMat(array, false, false, 0, &abuf);
|
||||
return cvBox2D(cv::fitEllipse(points));
|
||||
}
|
||||
|
||||
/* Calculates bounding rectangle of a point set or retrieves already calculated */
|
||||
CV_IMPL CvRect
|
||||
cvBoundingRect( CvArr* array, int update )
|
||||
|
||||
@ -1193,15 +1193,4 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
|
||||
common_matchTemplate(img, templ, result, method, cn);
|
||||
}
|
||||
|
||||
CV_IMPL void
|
||||
cvMatchTemplate( const CvArr* _img, const CvArr* _templ, CvArr* _result, int method )
|
||||
{
|
||||
cv::Mat img = cv::cvarrToMat(_img), templ = cv::cvarrToMat(_templ),
|
||||
result = cv::cvarrToMat(_result);
|
||||
CV_Assert( result.size() == cv::Size(std::abs(img.cols - templ.cols) + 1,
|
||||
std::abs(img.rows - templ.rows) + 1) &&
|
||||
result.type() == CV_32F );
|
||||
matchTemplate(img, templ, result, method);
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
|
||||
@ -43,40 +43,6 @@
|
||||
|
||||
namespace opencv_test { namespace {
|
||||
|
||||
/*static int
|
||||
cvTsPointConvexPolygon( CvPoint2D32f pt, CvPoint2D32f* v, int n )
|
||||
{
|
||||
CvPoint2D32f v0 = v[n-1];
|
||||
int i, sign = 0;
|
||||
|
||||
for( i = 0; i < n; i++ )
|
||||
{
|
||||
CvPoint2D32f v1 = v[i];
|
||||
float dx = pt.x - v0.x, dy = pt.y - v0.y;
|
||||
float dx1 = v1.x - v0.x, dy1 = v1.y - v0.y;
|
||||
double t = (double)dx*dy1 - (double)dx1*dy;
|
||||
if( fabs(t) > DBL_EPSILON )
|
||||
{
|
||||
if( t*sign < 0 )
|
||||
break;
|
||||
if( sign == 0 )
|
||||
sign = t < 0 ? -1 : 1;
|
||||
}
|
||||
else if( fabs(dx) + fabs(dy) < DBL_EPSILON )
|
||||
return i+1;
|
||||
v0 = v1;
|
||||
}
|
||||
|
||||
return i < n ? -1 : 0;
|
||||
}*/
|
||||
|
||||
CV_INLINE double
|
||||
cvTsDist( CvPoint2D32f a, CvPoint2D32f b )
|
||||
{
|
||||
double dx = a.x - b.x;
|
||||
double dy = a.y - b.y;
|
||||
return sqrt(dx*dx + dy*dy);
|
||||
}
|
||||
CV_INLINE double
|
||||
cvTsDist( const Point2f& a, const Point2f& b )
|
||||
{
|
||||
@ -86,7 +52,7 @@ cvTsDist( const Point2f& a, const Point2f& b )
|
||||
}
|
||||
|
||||
CV_INLINE double
|
||||
cvTsPtLineDist( CvPoint2D32f pt, CvPoint2D32f a, CvPoint2D32f b )
|
||||
cvTsPtLineDist( const Point2f& pt, const Point2f& a, const Point2f& b )
|
||||
{
|
||||
double d0 = cvTsDist( pt, a ), d1;
|
||||
double dd = cvTsDist( a, b );
|
||||
@ -99,7 +65,7 @@ cvTsPtLineDist( CvPoint2D32f pt, CvPoint2D32f a, CvPoint2D32f b )
|
||||
}
|
||||
|
||||
static double
|
||||
cvTsPointPolygonTest( CvPoint2D32f pt, const CvPoint2D32f* vv, int n, int* _idx=0, int* _on_edge=0 )
|
||||
cvTsPointPolygonTest( Point2f pt, const Point2f* vv, int n, int* _idx=0, int* _on_edge=0 )
|
||||
{
|
||||
int i;
|
||||
Point2f v = vv[n-1], v0;
|
||||
@ -176,9 +142,9 @@ cvTsMiddlePoint(const cv::Point2f &a, const cv::Point2f &b)
|
||||
static bool
|
||||
cvTsIsPointOnLineSegment(const cv::Point2f &x, const cv::Point2f &a, const cv::Point2f &b)
|
||||
{
|
||||
double d1 = cvTsDist(cvPoint2D32f(x.x, x.y), cvPoint2D32f(a.x, a.y));
|
||||
double d2 = cvTsDist(cvPoint2D32f(x.x, x.y), cvPoint2D32f(b.x, b.y));
|
||||
double d3 = cvTsDist(cvPoint2D32f(a.x, a.y), cvPoint2D32f(b.x, b.y));
|
||||
double d1 = cvTsDist(x, a);
|
||||
double d2 = cvTsDist(x, b);
|
||||
double d3 = cvTsDist(a, b);
|
||||
|
||||
return (abs(d1 + d2 - d3) <= (1E-5));
|
||||
}
|
||||
@ -549,7 +515,7 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx )
|
||||
CvMat* hull = 0;
|
||||
CvMat* mask = 0;
|
||||
int i, point_count, hull_count;
|
||||
CvPoint2D32f *p, *h;
|
||||
Point2f *p, *h;
|
||||
CvSeq header, hheader, *ptseq, *hseq;
|
||||
CvSeqBlock block, hblock;
|
||||
|
||||
@ -560,7 +526,7 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx )
|
||||
sizeof(CvSeq), CV_ELEM_SIZE(points2->type), points2->data.ptr,
|
||||
points2->rows + points2->cols - 1, &header, &block );
|
||||
point_count = ptseq->total;
|
||||
p = (CvPoint2D32f*)(points2->data.ptr);
|
||||
p = (Point2f*)(points2->data.ptr);
|
||||
|
||||
if( hull1 )
|
||||
hseq = hull1;
|
||||
@ -574,7 +540,7 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx )
|
||||
cvZero( mask );
|
||||
Mat _mask = cvarrToMat(mask);
|
||||
|
||||
h = (CvPoint2D32f*)(hull->data.ptr);
|
||||
h = (Point2f*)(hull->data.ptr);
|
||||
|
||||
// extract convex hull points
|
||||
if( return_points )
|
||||
@ -615,11 +581,11 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx )
|
||||
// check that the convex hull is a convex polygon
|
||||
if( hull_count >= 3 )
|
||||
{
|
||||
CvPoint2D32f pt0 = h[hull_count-1];
|
||||
Point2f pt0 = h[hull_count-1];
|
||||
for( i = 0; i < hull_count; i++ )
|
||||
{
|
||||
int j = i+1;
|
||||
CvPoint2D32f pt1 = h[i], pt2 = h[j < hull_count ? j : 0];
|
||||
Point2f pt1 = h[i], pt2 = h[j < hull_count ? j : 0];
|
||||
float dx0 = pt1.x - pt0.x, dy0 = pt1.y - pt0.y;
|
||||
float dx1 = pt2.x - pt1.x, dy1 = pt2.y - pt1.y;
|
||||
double t = (double)dx0*dy1 - (double)dx1*dy0;
|
||||
@ -681,8 +647,7 @@ protected:
|
||||
void run_func(void);
|
||||
int validate_test_results( int test_case_idx );
|
||||
|
||||
CvBox2D box;
|
||||
CvPoint2D32f box_pt[4];
|
||||
Point2f box_pt[4];
|
||||
};
|
||||
|
||||
|
||||
@ -692,18 +657,9 @@ CV_MinAreaRectTest::CV_MinAreaRectTest()
|
||||
|
||||
|
||||
void CV_MinAreaRectTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
{
|
||||
box = cvMinAreaRect2( points, storage );
|
||||
cvBoxPoints( box, box_pt );
|
||||
}
|
||||
else
|
||||
{
|
||||
cv::RotatedRect r = cv::minAreaRect(cv::cvarrToMat(points));
|
||||
box = cvBox2D(r);
|
||||
r.points((cv::Point2f*)box_pt);
|
||||
}
|
||||
r.points(box_pt);
|
||||
}
|
||||
|
||||
|
||||
@ -735,25 +691,6 @@ int CV_MinAreaRectTest::validate_test_results( int test_case_idx )
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
{
|
||||
int n = 4;
|
||||
double a = 8, c = 8, b = 100, d = 150;
|
||||
CvPoint bp[4], *bpp = bp;
|
||||
cvNamedWindow( "test", 1 );
|
||||
IplImage* img = cvCreateImage( cvSize(500,500), 8, 3 );
|
||||
cvZero(img);
|
||||
for( i = 0; i < point_count; i++ )
|
||||
cvCircle(img,cvPoint(cvRound(p[i].x*a+b),cvRound(p[i].y*c+d)), 3, CV_RGB(0,255,0), -1 );
|
||||
for( i = 0; i < n; i++ )
|
||||
bp[i] = cvPoint(cvRound(box_pt[i].x*a+b),cvRound(box_pt[i].y*c+d));
|
||||
cvPolyLine( img, &bpp, &n, 1, 1, CV_RGB(255,255,0), 1, CV_AA, 0 );
|
||||
cvShowImage( "test", img );
|
||||
cvWaitKey();
|
||||
cvReleaseImage(&img);
|
||||
}
|
||||
#endif
|
||||
|
||||
// check that the box includes all the points
|
||||
// and there is at least one point at (or very close to) every box side
|
||||
for( i = 0; i < point_count; i++ )
|
||||
@ -845,25 +782,6 @@ int CV_MinTriangleTest::validate_test_results( int test_case_idx )
|
||||
double eps = 1e-4;
|
||||
int code = CV_BaseShapeDescrTest::validate_test_results( test_case_idx );
|
||||
|
||||
#if 0
|
||||
{
|
||||
int n = 3;
|
||||
double a = 8, c = 8, b = 100, d = 150;
|
||||
CvPoint bp[4], *bpp = bp;
|
||||
cvNamedWindow( "test", 1 );
|
||||
IplImage* img = cvCreateImage( cvSize(500,500), 8, 3 );
|
||||
cvZero(img);
|
||||
for( i = 0; i < point_count; i++ )
|
||||
cvCircle(img,cvPoint(cvRound(p[i].x*a+b),cvRound(p[i].y*c+d)), 3, CV_RGB(0,255,0), -1 );
|
||||
for( i = 0; i < n; i++ )
|
||||
bp[i] = cvPoint(cvRound(triangle[i].x*a+b),cvRound(triangle[i].y*c+d));
|
||||
cvPolyLine( img, &bpp, &n, 1, 1, CV_RGB(255,255,0), 1, CV_AA, 0 );
|
||||
cvShowImage( "test", img );
|
||||
cvWaitKey();
|
||||
cvReleaseImage(&img);
|
||||
}
|
||||
#endif
|
||||
|
||||
int polygonVertices = (int) convexPolygon.size();
|
||||
|
||||
if (polygonVertices > 2) {
|
||||
@ -957,18 +875,7 @@ CV_MinCircleTest::CV_MinCircleTest()
|
||||
|
||||
void CV_MinCircleTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
{
|
||||
CvPoint2D32f c_center = cvPoint2D32f(center);
|
||||
cvMinEnclosingCircle( points, &c_center, &radius );
|
||||
center = c_center;
|
||||
}
|
||||
else
|
||||
{
|
||||
cv::Point2f tmpcenter;
|
||||
cv::minEnclosingCircle(cv::cvarrToMat(points), tmpcenter, radius);
|
||||
center = tmpcenter;
|
||||
}
|
||||
cv::minEnclosingCircle(cv::cvarrToMat(points), center, radius);
|
||||
}
|
||||
|
||||
|
||||
@ -980,22 +887,6 @@ int CV_MinCircleTest::validate_test_results( int test_case_idx )
|
||||
Point2f *p = (Point2f*)(points2->data.ptr);
|
||||
Point2f v[3];
|
||||
|
||||
#if 0
|
||||
{
|
||||
double a = 2, b = 200, d = 400;
|
||||
cvNamedWindow( "test", 1 );
|
||||
IplImage* img = cvCreateImage( cvSize(500,500), 8, 3 );
|
||||
cvZero(img);
|
||||
for( i = 0; i < point_count; i++ )
|
||||
cvCircle(img,cvPoint(cvRound(p[i].x*a+b),cvRound(p[i].y*a+d)), 3, CV_RGB(0,255,0), -1 );
|
||||
cvCircle( img, cvPoint(cvRound(center.x*a+b),cvRound(center.y*a+d)),
|
||||
cvRound(radius*a), CV_RGB(255,255,0), 1 );
|
||||
cvShowImage( "test", img );
|
||||
cvWaitKey();
|
||||
cvReleaseImage(&img);
|
||||
}
|
||||
#endif
|
||||
|
||||
// check that the circle contains all the points inside and
|
||||
// remember at most 3 points that are close to the boundary
|
||||
for( i = 0; i < point_count; i++ )
|
||||
@ -1381,9 +1272,6 @@ int CV_FitEllipseTest::prepare_test_case( int test_case_idx )
|
||||
|
||||
void CV_FitEllipseTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
box = cvFitEllipse2( points );
|
||||
else
|
||||
box = cv::fitEllipse(cv::cvarrToMat(points));
|
||||
}
|
||||
|
||||
@ -1437,32 +1325,6 @@ int CV_FitEllipseTest::validate_test_results( int test_case_idx )
|
||||
|
||||
_exit_:
|
||||
|
||||
#if 0
|
||||
if( code < 0 )
|
||||
{
|
||||
cvNamedWindow( "test", 0 );
|
||||
IplImage* img = cvCreateImage( cvSize(cvRound(low_high_range*4),
|
||||
cvRound(low_high_range*4)), 8, 3 );
|
||||
cvZero( img );
|
||||
|
||||
box.center.x += (float)low_high_range*2;
|
||||
box.center.y += (float)low_high_range*2;
|
||||
cvEllipseBox( img, box, CV_RGB(255,0,0), 3, 8 );
|
||||
|
||||
for( int i = 0; i < points2->rows + points2->cols - 1; i++ )
|
||||
{
|
||||
CvPoint pt;
|
||||
pt.x = cvRound(points2->data.fl[i*2] + low_high_range*2);
|
||||
pt.y = cvRound(points2->data.fl[i*2+1] + low_high_range*2);
|
||||
cvCircle( img, pt, 1, CV_RGB(255,255,255), -1, 8 );
|
||||
}
|
||||
|
||||
cvShowImage( "test", img );
|
||||
cvReleaseImage( &img );
|
||||
cvWaitKey(0);
|
||||
}
|
||||
#endif
|
||||
|
||||
if( code < 0 )
|
||||
{
|
||||
ts->set_failed_test_info( code );
|
||||
@ -1676,9 +1538,7 @@ int CV_FitLineTest::prepare_test_case( int test_case_idx )
|
||||
|
||||
void CV_FitLineTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
cvFitLine( points, dist_type, 0, reps, aeps, line.data());
|
||||
else if(dims == 2)
|
||||
if(dims == 2)
|
||||
cv::fitLine(cv::cvarrToMat(points), (cv::Vec4f&)line[0], dist_type, 0, reps, aeps);
|
||||
else
|
||||
cv::fitLine(cv::cvarrToMat(points), (cv::Vec6f&)line[0], dist_type, 0, reps, aeps);
|
||||
@ -1898,18 +1758,10 @@ int CV_ContourMomentsTest::prepare_test_case( int test_case_idx )
|
||||
|
||||
|
||||
void CV_ContourMomentsTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
{
|
||||
cvMoments( points, &moments );
|
||||
area = cvContourArea( points );
|
||||
}
|
||||
else
|
||||
{
|
||||
moments = cvMoments(cv::moments(cv::cvarrToMat(points)));
|
||||
area = cv::contourArea(cv::cvarrToMat(points));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int CV_ContourMomentsTest::validate_test_results( int test_case_idx )
|
||||
@ -1956,12 +1808,6 @@ int CV_ContourMomentsTest::validate_test_results( int test_case_idx )
|
||||
|
||||
if( code < 0 )
|
||||
{
|
||||
#if 0
|
||||
cvCmpS( img, 0, img, CV_CMP_GT );
|
||||
cvNamedWindow( "test", 1 );
|
||||
cvShowImage( "test", img );
|
||||
cvWaitKey();
|
||||
#endif
|
||||
ts->set_failed_test_info( code );
|
||||
}
|
||||
|
||||
|
||||
@ -1576,7 +1576,7 @@ CV_PreCornerDetectTest::CV_PreCornerDetectTest() : CV_FeatureSelBaseTest( 1 )
|
||||
|
||||
void CV_PreCornerDetectTest::run_func()
|
||||
{
|
||||
cvPreCornerDetect( test_array[INPUT][0], test_array[OUTPUT][0], aperture_size );
|
||||
preCornerDetect( cvarrToMat( test_array[INPUT][0] ), cvarrToMat( test_array[OUTPUT][0] ), aperture_size, BORDER_REPLICATE );
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -769,8 +769,8 @@ void CV_RemapTest::fill_array( int test_case_idx, int i, int j, Mat& arr )
|
||||
|
||||
void CV_RemapTest::run_func()
|
||||
{
|
||||
cvRemap( test_array[INPUT][0], test_array[INPUT_OUTPUT][0],
|
||||
test_array[INPUT][1], test_array[INPUT][2], interpolation );
|
||||
remap( cvarrToMat( test_array[INPUT][0] ), cvarrToMat( test_array[INPUT_OUTPUT][0] ),
|
||||
cvarrToMat( test_array[INPUT][1] ), cvarrToMat( test_array[INPUT][2] ), interpolation );
|
||||
}
|
||||
|
||||
|
||||
@ -925,15 +925,10 @@ void CV_GetRectSubPixTest::fill_array( int test_case_idx, int i, int j, Mat& arr
|
||||
|
||||
|
||||
void CV_GetRectSubPixTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
cvGetRectSubPix( test_array[INPUT][0], test_array[INPUT_OUTPUT][0], center );
|
||||
else
|
||||
{
|
||||
cv::Mat _out = cv::cvarrToMat(test_array[INPUT_OUTPUT][0]);
|
||||
cv::getRectSubPix( cv::cvarrToMat(test_array[INPUT][0]), _out.size(), center, _out, _out.type());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
double CV_GetRectSubPixTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
|
||||
@ -1144,20 +1139,13 @@ static void check_resize_area(const Mat& expected, const Mat& actual, double tol
|
||||
|
||||
TEST(Imgproc_cvWarpAffine, regression)
|
||||
{
|
||||
IplImage* src = cvCreateImage(cvSize(100, 100), IPL_DEPTH_8U, 1);
|
||||
IplImage* dst = cvCreateImage(cvSize(100, 100), IPL_DEPTH_8U, 1);
|
||||
Mat src(Size(100, 100), CV_8UC1);
|
||||
Mat dst(Size(100, 100), CV_8UC1);
|
||||
|
||||
cvZero(src);
|
||||
|
||||
float m[6];
|
||||
CvMat M = cvMat( 2, 3, CV_32F, m );
|
||||
int w = src->width;
|
||||
int h = src->height;
|
||||
cv2DRotationMatrix(cvPoint2D32f(w*0.5f, h*0.5f), 45.0, 1.0, &M);
|
||||
cvWarpAffine(src, dst, &M);
|
||||
|
||||
cvReleaseImage(&src);
|
||||
cvReleaseImage(&dst);
|
||||
int w = src.cols;
|
||||
int h = src.rows;
|
||||
Mat M = getRotationMatrix2D(Point2f(w*0.5f, h*0.5f), 45.0, 1.0);
|
||||
warpAffine(src, dst, M, Size(w, h));
|
||||
}
|
||||
|
||||
TEST(Imgproc_fitLine_vector_3d, regression)
|
||||
@ -1172,7 +1160,7 @@ TEST(Imgproc_fitLine_vector_3d, regression)
|
||||
|
||||
std::vector<float> line;
|
||||
|
||||
cv::fitLine(points_vector, line, CV_DIST_L2, 0 ,0 ,0);
|
||||
cv::fitLine(points_vector, line, DIST_L2, 0 ,0 ,0);
|
||||
|
||||
ASSERT_EQ(line.size(), (size_t)6);
|
||||
|
||||
@ -1192,7 +1180,7 @@ TEST(Imgproc_fitLine_vector_2d, regression)
|
||||
|
||||
std::vector<float> line;
|
||||
|
||||
cv::fitLine(points_vector, line, CV_DIST_L2, 0 ,0 ,0);
|
||||
cv::fitLine(points_vector, line, DIST_L2, 0 ,0 ,0);
|
||||
|
||||
ASSERT_EQ(line.size(), (size_t)4);
|
||||
}
|
||||
@ -1202,7 +1190,7 @@ TEST(Imgproc_fitLine_Mat_2dC2, regression)
|
||||
cv::Mat mat1 = Mat::zeros(3, 1, CV_32SC2);
|
||||
std::vector<float> line1;
|
||||
|
||||
cv::fitLine(mat1, line1, CV_DIST_L2, 0 ,0 ,0);
|
||||
cv::fitLine(mat1, line1, DIST_L2, 0 ,0 ,0);
|
||||
|
||||
ASSERT_EQ(line1.size(), (size_t)4);
|
||||
}
|
||||
@ -1212,7 +1200,7 @@ TEST(Imgproc_fitLine_Mat_2dC1, regression)
|
||||
cv::Matx<int, 3, 2> mat2;
|
||||
std::vector<float> line2;
|
||||
|
||||
cv::fitLine(mat2, line2, CV_DIST_L2, 0 ,0 ,0);
|
||||
cv::fitLine(mat2, line2, DIST_L2, 0 ,0 ,0);
|
||||
|
||||
ASSERT_EQ(line2.size(), (size_t)4);
|
||||
}
|
||||
@ -1222,7 +1210,7 @@ TEST(Imgproc_fitLine_Mat_3dC3, regression)
|
||||
cv::Mat mat1 = Mat::zeros(2, 1, CV_32SC3);
|
||||
std::vector<float> line1;
|
||||
|
||||
cv::fitLine(mat1, line1, CV_DIST_L2, 0 ,0 ,0);
|
||||
cv::fitLine(mat1, line1, DIST_L2, 0 ,0 ,0);
|
||||
|
||||
ASSERT_EQ(line1.size(), (size_t)6);
|
||||
}
|
||||
@ -1232,7 +1220,7 @@ TEST(Imgproc_fitLine_Mat_3dC1, regression)
|
||||
cv::Mat mat2 = Mat::zeros(2, 3, CV_32SC1);
|
||||
std::vector<float> line2;
|
||||
|
||||
cv::fitLine(mat2, line2, CV_DIST_L2, 0 ,0 ,0);
|
||||
cv::fitLine(mat2, line2, DIST_L2, 0 ,0 ,0);
|
||||
|
||||
ASSERT_EQ(line2.size(), (size_t)6);
|
||||
}
|
||||
@ -1527,7 +1515,7 @@ TEST(Imgproc_Remap, DISABLED_memleak)
|
||||
putchar('.');
|
||||
fflush(stdout);
|
||||
}
|
||||
remap(src, dst, map_x, map_y, CV_INTER_LINEAR);
|
||||
remap(src, dst, map_x, map_y, INTER_LINEAR);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1590,11 +1578,11 @@ TEST(Imgproc_logPolar, identity)
|
||||
{
|
||||
logPolar(src, dst,
|
||||
Point2f((N-1) * 0.5f, (N-1) * 0.5f), M,
|
||||
CV_WARP_FILL_OUTLIERS | CV_INTER_LINEAR | CV_WARP_INVERSE_MAP);
|
||||
WARP_FILL_OUTLIERS | INTER_LINEAR | WARP_INVERSE_MAP);
|
||||
|
||||
logPolar(dst, src,
|
||||
Point2f((N-1) * 0.5f, (N-1) * 0.5f), M,
|
||||
CV_WARP_FILL_OUTLIERS | CV_INTER_LINEAR);
|
||||
WARP_FILL_OUTLIERS | INTER_LINEAR);
|
||||
|
||||
double psnr = cvtest::PSNR(in(roi), src(roi));
|
||||
EXPECT_LE(25, psnr) << "iteration=" << i;
|
||||
@ -1626,11 +1614,11 @@ TEST(Imgproc_warpPolar, identity)
|
||||
Rect roi = Rect(0, 0, in.cols - ((N + 19) / 20), in.rows);
|
||||
Point2f center = Point2f((N - 1) * 0.5f, (N - 1) * 0.5f);
|
||||
double radius = N * 0.5;
|
||||
int flags = CV_WARP_FILL_OUTLIERS | CV_INTER_LINEAR;
|
||||
int flags = WARP_FILL_OUTLIERS | INTER_LINEAR;
|
||||
// test linearPolar
|
||||
for (int ki = 1; ki <= 5; ki++)
|
||||
{
|
||||
warpPolar(src, dst, src.size(), center, radius, flags + WARP_POLAR_LINEAR + CV_WARP_INVERSE_MAP);
|
||||
warpPolar(src, dst, src.size(), center, radius, flags + WARP_POLAR_LINEAR + WARP_INVERSE_MAP);
|
||||
warpPolar(dst, src, src.size(), center, radius, flags + WARP_POLAR_LINEAR);
|
||||
|
||||
double psnr = cv::PSNR(in(roi), src(roi));
|
||||
@ -1640,7 +1628,7 @@ TEST(Imgproc_warpPolar, identity)
|
||||
src = in.clone();
|
||||
for (int ki = 1; ki <= 5; ki++)
|
||||
{
|
||||
warpPolar(src, dst, src.size(),center, radius, flags + WARP_POLAR_LOG + CV_WARP_INVERSE_MAP );
|
||||
warpPolar(src, dst, src.size(),center, radius, flags + WARP_POLAR_LOG + WARP_INVERSE_MAP );
|
||||
warpPolar(dst, src, src.size(),center, radius, flags + WARP_POLAR_LOG);
|
||||
|
||||
double psnr = cv::PSNR(in(roi), src(roi));
|
||||
|
||||
@ -133,15 +133,10 @@ double CV_TemplMatchTest::get_success_error_level( int /*test_case_idx*/, int /*
|
||||
|
||||
|
||||
void CV_TemplMatchTest::run_func()
|
||||
{
|
||||
if(!test_cpp)
|
||||
cvMatchTemplate( test_array[INPUT][0], test_array[INPUT][1], test_array[OUTPUT][0], method );
|
||||
else
|
||||
{
|
||||
cv::Mat _out = cv::cvarrToMat(test_array[OUTPUT][0]);
|
||||
cv::matchTemplate(cv::cvarrToMat(test_array[INPUT][0]), cv::cvarrToMat(test_array[INPUT][1]), _out, method);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void cvTsMatchTemplate( const CvMat* img, const CvMat* templ, CvMat* result, int method )
|
||||
|
||||
Loading…
Reference in New Issue
Block a user