mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-14 00:39:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #21089 from sturkmen72:clean-up-c-api

Browse Source
This commit is contained in:
Alexander Alekhin 2021-12-03 15:11:59 +00:00
commit 5d04e5b063
22 changed files with 49 additions and 974 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/calib/test/test_cornerssubpix.cpp
View File

@ -181,9 +181,8 @@ void CV_ChessboardSubpixelTest::run( int )
break; break;
} }
IplImage chessboard_image_header = cvIplImage(chessboard_image); cornerSubPix(chessboard_image, test_corners,
cvFindCornerSubPix(&chessboard_image_header, (CvPoint2D32f*)&test_corners[0], Size(3, 3), Size(1, 1), TermCriteria(TermCriteria::EPS|TermCriteria::MAX_ITER, 300, 0.1));
(int)test_corners.size(), cvSize(3, 3), cvSize(1, 1), cvTermCriteria(CV_TERMCRIT_EPS|CV_TERMCRIT_ITER,300,0.1));
find4QuadCornerSubpix(chessboard_image, test_corners, Size(5, 5)); find4QuadCornerSubpix(chessboard_image, test_corners, Size(5, 5));
double dist2 = 0.0; double dist2 = 0.0;

27
modules/core/include/opencv2/core/core_c.h
View File

@ -1078,38 +1078,11 @@ CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
#define CV_RAND_UNI 0 #define CV_RAND_UNI 0
#define CV_RAND_NORMAL 1 #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_ROW 0
#define CV_SORT_EVERY_COLUMN 1 #define CV_SORT_EVERY_COLUMN 1
#define CV_SORT_ASCENDING 0 #define CV_SORT_ASCENDING 0
#define CV_SORT_DESCENDING 16 #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 */ /** Finds all real and complex roots of a polynomial equation */
CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2, CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100)); int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));

200
modules/core/include/opencv2/core/types_c.h
View File

@ -1272,45 +1272,6 @@ CvSize2D32f cvSize2D32f(const cv::Size_<_Tp>& sz)
} }
#endif #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: */ /** Line iterator state: */
typedef struct CvLineIterator typedef struct CvLineIterator
@ -1958,167 +1919,6 @@ CvSeqReader;
(edge)->next[(edge)->vtx[1] == (vertex)]) (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*/ #endif /*OPENCV_CORE_TYPES_H*/

23
modules/core/src/matrix_c.cpp
View File

@ -325,27 +325,4 @@ cvRange( CvArr* arr, double start, double end )
return arr; 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 #endif // OPENCV_EXCLUDE_C_API

8
modules/core/src/matrix_operations.cpp
View File

@ -868,9 +868,9 @@ template<typename T> static void sort_( const Mat& src, Mat& dst, int flags )
{ {
AutoBuffer<T> buf; AutoBuffer<T> buf;
int n, len; 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 inplace = src.data == dst.data;
bool sortDescending = (flags & CV_SORT_DESCENDING) != 0; bool sortDescending = (flags & SORT_DESCENDING) != 0;
if( sortRows ) if( sortRows )
n = src.rows, len = src.cols; 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<T> buf;
AutoBuffer<int> ibuf; AutoBuffer<int> ibuf;
bool sortRows = (flags & 1) == CV_SORT_EVERY_ROW; bool sortRows = (flags & 1) == SORT_EVERY_ROW;
bool sortDescending = (flags & CV_SORT_DESCENDING) != 0; bool sortDescending = (flags & SORT_DESCENDING) != 0;
CV_Assert( src.data != dst.data ); CV_Assert( src.data != dst.data );

28
modules/core/src/rand.cpp
View File

@ -40,12 +40,6 @@
// //
//M*/ //M*/
/* ////////////////////////////////////////////////////////////////////
//
// Filling CvMat/IplImage instances with random numbers
//
// */
#include "precomp.hpp" #include "precomp.hpp"
namespace cv 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. // Mersenne Twister random number generator.
// Inspired by http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c // Inspired by http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c

105
modules/imgproc/include/opencv2/imgproc/imgproc_c.h
View File

@ -193,14 +193,6 @@ CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
const CvPoint2D32f* dst, const CvPoint2D32f* dst,
CvMat* map_matrix ); 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. /** @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 @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 **************************************/ /*********************************** 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. /** @brief Retrieves quadrangle from the input array.
matrixarr = ( a11 a12 | b1 ) dst(x,y) <- src(A[x y]' + b) 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, CVAPI(void) cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
const CvMat* map_matrix ); 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 /** @brief Computes earth mover distance between
two weighted point sets (called signatures) two weighted point sets (called signatures)
@see cv::EMD @see cv::EMD
@ -441,24 +409,6 @@ CVAPI(double) cvContourArea( const CvArr* contour,
CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ), CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
int oriented CV_DEFAULT(0)); 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 /** @brief Calculates exact convex hull of 2d point set
@see cv::convexHull @see cv::convexHull
*/ */
@ -473,17 +423,6 @@ CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
CVAPI(int) cvCheckContourConvexity( const CvArr* contour ); 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 /** @brief Initializes sequence header for a matrix (column or row vector) of points
a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!) */ 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, CvContour* contour_header,
CvSeqBlock* block ); 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 * * Histogram functions *
\****************************************************************************************/ \****************************************************************************************/
@ -741,16 +670,6 @@ CVAPI(void) cvFloodFill( CvArr* image, CvPoint seed_point,
* Feature detection * * 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 /** @brief Calculates eigen values and vectors of 2x2
gradient covariation matrix at every image pixel gradient covariation matrix at every image pixel
@see cv::cornerEigenValsAndVecs @see cv::cornerEigenValsAndVecs
@ -765,13 +684,6 @@ CVAPI(void) cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
CVAPI(void) cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval, CVAPI(void) cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
int block_size, int aperture_size CV_DEFAULT(3) ); 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. /** @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 min_radius CV_DEFAULT(0),
int max_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 * * Drawing *
@ -860,18 +767,6 @@ CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,
CvScalar color, int thickness CV_DEFAULT(1), CvScalar color, int thickness CV_DEFAULT(1),
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0)); 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 /** @brief Fills an area bounded by one or more arbitrary polygons
@see cv::fillPoly @see cv::fillPoly

10
modules/imgproc/src/corner.cpp
View File

@ -756,14 +756,4 @@ cvCornerEigenValsAndVecs( const void* srcarr, void* dstarr,
cv::cornerEigenValsAndVecs( src, dst, block_size, aperture_size, cv::BORDER_REPLICATE ); 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 */ /* End of file */

13
modules/imgproc/src/cornersubpix.cpp
View 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. */ /* End of file. */

59
modules/imgproc/src/geometry.cpp
View File

@ -41,57 +41,6 @@
#include "precomp.hpp" #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 ) double cv::pointPolygonTest( InputArray _contour, Point2f pt, bool measureDist )
{ {
CV_INSTRUMENT_REGION(); 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), This code is described in "Computational Geometry in C" (Second Edition),
Chapter 7. It is not written to be comprehensible without the Chapter 7. It is not written to be comprehensible without the

159
modules/imgproc/src/histogram.cpp
View File

@ -3299,11 +3299,6 @@ private:
int* lut_; int* lut_;
}; };
CV_IMPL void cvEqualizeHist( const CvArr* srcarr, CvArr* dstarr )
{
cv::equalizeHist(cv::cvarrToMat(srcarr), cv::cvarrToMat(dstarr));
}
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
namespace cv { namespace cv {
@ -3451,158 +3446,4 @@ void cv::equalizeHist( InputArray _src, OutputArray _dst )
lutBody(heightRange); 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. */ /* End of file. */

25
modules/imgproc/src/imgwarp.cpp
View File

@ -3424,31 +3424,6 @@ cvWarpPerspective( const CvArr* srcarr, CvArr* dstarr, const CvMat* marr,
fillval ); 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* CV_IMPL CvMat*
cvGetPerspectiveTransform( const CvPoint2D32f* src, cvGetPerspectiveTransform( const CvPoint2D32f* src,

14
modules/imgproc/src/linefit.cpp
View File

@ -634,18 +634,4 @@ void cv::fitLine( InputArray _points, OutputArray _line, int distType,
Mat(npoints2 >= 0 ? 4 : 6, 1, CV_32F, linebuf).copyTo(_line); 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. */ /* End of file. */

12
modules/imgproc/src/matchcontours.cpp
View File

@ -170,16 +170,4 @@ double cv::matchShapes(InputArray contour1, InputArray contour2, int method, dou
return result; 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. */ /* End of file. */

10
modules/imgproc/src/rotcalipers.cpp
View 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) void cv::boxPoints(cv::RotatedRect box, OutputArray _pts)
{ {
CV_INSTRUMENT_REGION(); CV_INSTRUMENT_REGION();

33
modules/imgproc/src/samplers.cpp
View File

@ -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 CV_IMPL void
cvGetQuadrangleSubPix( const void* srcarr, void* dstarr, const CvMat* mat ) 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. */ /* End of file. */

24
modules/imgproc/src/shapedescr.cpp
View File

@ -1144,22 +1144,6 @@ cv::Rect cv::boundingRect(InputArray array)
////////////////////////////////////////////// C API /////////////////////////////////////////// ////////////////////////////////////////////// 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 static void
icvMemCopy( double **buf1, double **buf2, double **buf3, int *b_max ) 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 */ /* Calculates bounding rectangle of a point set or retrieves already calculated */
CV_IMPL CvRect CV_IMPL CvRect
cvBoundingRect( CvArr* array, int update ) cvBoundingRect( CvArr* array, int update )

11
modules/imgproc/src/templmatch.cpp
View File

@ -1193,15 +1193,4 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
common_matchTemplate(img, templ, result, method, cn); 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. */ /* End of file. */

182
modules/imgproc/test/test_convhull.cpp
View File

@ -43,40 +43,6 @@
namespace opencv_test { namespace { 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 CV_INLINE double
cvTsDist( const Point2f& a, const Point2f& b ) cvTsDist( const Point2f& a, const Point2f& b )
{ {
@ -86,7 +52,7 @@ cvTsDist( const Point2f& a, const Point2f& b )
} }
CV_INLINE double 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 d0 = cvTsDist( pt, a ), d1;
double dd = cvTsDist( a, b ); double dd = cvTsDist( a, b );
@ -99,7 +65,7 @@ cvTsPtLineDist( CvPoint2D32f pt, CvPoint2D32f a, CvPoint2D32f b )
} }
static double 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; int i;
Point2f v = vv[n-1], v0; Point2f v = vv[n-1], v0;
@ -176,9 +142,9 @@ cvTsMiddlePoint(const cv::Point2f &a, const cv::Point2f &b)
static bool static bool
cvTsIsPointOnLineSegment(const cv::Point2f &x, const cv::Point2f &a, const cv::Point2f &b) 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 d1 = cvTsDist(x, a);
double d2 = cvTsDist(cvPoint2D32f(x.x, x.y), cvPoint2D32f(b.x, b.y)); double d2 = cvTsDist(x, b);
double d3 = cvTsDist(cvPoint2D32f(a.x, a.y), cvPoint2D32f(b.x, b.y)); double d3 = cvTsDist(a, b);
return (abs(d1 + d2 - d3) <= (1E-5)); 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* hull = 0;
CvMat* mask = 0; CvMat* mask = 0;
int i, point_count, hull_count; int i, point_count, hull_count;
CvPoint2D32f *p, *h; Point2f *p, *h;
CvSeq header, hheader, *ptseq, *hseq; CvSeq header, hheader, *ptseq, *hseq;
CvSeqBlock block, hblock; 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, sizeof(CvSeq), CV_ELEM_SIZE(points2->type), points2->data.ptr,
points2->rows + points2->cols - 1, &header, &block ); points2->rows + points2->cols - 1, &header, &block );
point_count = ptseq->total; point_count = ptseq->total;
p = (CvPoint2D32f*)(points2->data.ptr); p = (Point2f*)(points2->data.ptr);
if( hull1 ) if( hull1 )
hseq = hull1; hseq = hull1;
@ -574,7 +540,7 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx )
cvZero( mask ); cvZero( mask );
Mat _mask = cvarrToMat(mask); Mat _mask = cvarrToMat(mask);
h = (CvPoint2D32f*)(hull->data.ptr); h = (Point2f*)(hull->data.ptr);
// extract convex hull points // extract convex hull points
if( return_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 // check that the convex hull is a convex polygon
if( hull_count >= 3 ) if( hull_count >= 3 )
{ {
CvPoint2D32f pt0 = h[hull_count-1]; Point2f pt0 = h[hull_count-1];
for( i = 0; i < hull_count; i++ ) for( i = 0; i < hull_count; i++ )
{ {
int j = i+1; 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 dx0 = pt1.x - pt0.x, dy0 = pt1.y - pt0.y;
float dx1 = pt2.x - pt1.x, dy1 = pt2.y - pt1.y; float dx1 = pt2.x - pt1.x, dy1 = pt2.y - pt1.y;
double t = (double)dx0*dy1 - (double)dx1*dy0; double t = (double)dx0*dy1 - (double)dx1*dy0;
@ -681,8 +647,7 @@ protected:
void run_func(void); void run_func(void);
int validate_test_results( int test_case_idx ); int validate_test_results( int test_case_idx );
CvBox2D box; Point2f box_pt[4];
CvPoint2D32f box_pt[4];
}; };
@ -693,17 +658,8 @@ CV_MinAreaRectTest::CV_MinAreaRectTest()
void CV_MinAreaRectTest::run_func() 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)); cv::RotatedRect r = cv::minAreaRect(cv::cvarrToMat(points));
box = cvBox2D(r); r.points(box_pt);
r.points((cv::Point2f*)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 // check that the box includes all the points
// and there is at least one point at (or very close to) every box side // and there is at least one point at (or very close to) every box side
for( i = 0; i < point_count; i++ ) 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; double eps = 1e-4;
int code = CV_BaseShapeDescrTest::validate_test_results( test_case_idx ); 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(); int polygonVertices = (int) convexPolygon.size();
if (polygonVertices > 2) { if (polygonVertices > 2) {
@ -957,18 +875,7 @@ CV_MinCircleTest::CV_MinCircleTest()
void CV_MinCircleTest::run_func() void CV_MinCircleTest::run_func()
{ {
if(!test_cpp) cv::minEnclosingCircle(cv::cvarrToMat(points), center, radius);
{
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;
}
} }
@ -980,22 +887,6 @@ int CV_MinCircleTest::validate_test_results( int test_case_idx )
Point2f *p = (Point2f*)(points2->data.ptr); Point2f *p = (Point2f*)(points2->data.ptr);
Point2f v[3]; 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 // check that the circle contains all the points inside and
// remember at most 3 points that are close to the boundary // remember at most 3 points that are close to the boundary
for( i = 0; i < point_count; i++ ) 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() void CV_FitEllipseTest::run_func()
{ {
if(!test_cpp)
box = cvFitEllipse2( points );
else
box = cv::fitEllipse(cv::cvarrToMat(points)); box = cv::fitEllipse(cv::cvarrToMat(points));
} }
@ -1437,32 +1325,6 @@ int CV_FitEllipseTest::validate_test_results( int test_case_idx )
_exit_: _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 ) if( code < 0 )
{ {
ts->set_failed_test_info( code ); 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() void CV_FitLineTest::run_func()
{ {
if(!test_cpp) if(dims == 2)
cvFitLine( points, dist_type, 0, reps, aeps, line.data());
else if(dims == 2)
cv::fitLine(cv::cvarrToMat(points), (cv::Vec4f&)line[0], dist_type, 0, reps, aeps); cv::fitLine(cv::cvarrToMat(points), (cv::Vec4f&)line[0], dist_type, 0, reps, aeps);
else else
cv::fitLine(cv::cvarrToMat(points), (cv::Vec6f&)line[0], dist_type, 0, reps, aeps); cv::fitLine(cv::cvarrToMat(points), (cv::Vec6f&)line[0], dist_type, 0, reps, aeps);
@ -1899,16 +1759,8 @@ int CV_ContourMomentsTest::prepare_test_case( int test_case_idx )
void CV_ContourMomentsTest::run_func() void CV_ContourMomentsTest::run_func()
{ {
if(!test_cpp)
{
cvMoments( points, &moments );
area = cvContourArea( points );
}
else
{
moments = cvMoments(cv::moments(cv::cvarrToMat(points))); moments = cvMoments(cv::moments(cv::cvarrToMat(points)));
area = cv::contourArea(cv::cvarrToMat(points)); area = cv::contourArea(cv::cvarrToMat(points));
}
} }
@ -1956,12 +1808,6 @@ int CV_ContourMomentsTest::validate_test_results( int test_case_idx )
if( code < 0 ) 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 ); ts->set_failed_test_info( code );
} }

2
modules/imgproc/test/test_filter.cpp
View File

@ -1576,7 +1576,7 @@ CV_PreCornerDetectTest::CV_PreCornerDetectTest() : CV_FeatureSelBaseTest( 1 )
void CV_PreCornerDetectTest::run_func() 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 );
} }

52
modules/imgproc/test/test_imgwarp.cpp
View File

@ -769,8 +769,8 @@ void CV_RemapTest::fill_array( int test_case_idx, int i, int j, Mat& arr )
void CV_RemapTest::run_func() void CV_RemapTest::run_func()
{ {
cvRemap( test_array[INPUT][0], test_array[INPUT_OUTPUT][0], remap( cvarrToMat( test_array[INPUT][0] ), cvarrToMat( test_array[INPUT_OUTPUT][0] ),
test_array[INPUT][1], test_array[INPUT][2], interpolation ); cvarrToMat( test_array[INPUT][1] ), cvarrToMat( test_array[INPUT][2] ), interpolation );
} }
@ -926,13 +926,8 @@ void CV_GetRectSubPixTest::fill_array( int test_case_idx, int i, int j, Mat& arr
void CV_GetRectSubPixTest::run_func() 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::Mat _out = cv::cvarrToMat(test_array[INPUT_OUTPUT][0]);
cv::getRectSubPix( cv::cvarrToMat(test_array[INPUT][0]), _out.size(), center, _out, _out.type()); cv::getRectSubPix( cv::cvarrToMat(test_array[INPUT][0]), _out.size(), center, _out, _out.type());
}
} }
@ -1144,20 +1139,13 @@ static void check_resize_area(const Mat& expected, const Mat& actual, double tol
TEST(Imgproc_cvWarpAffine, regression) TEST(Imgproc_cvWarpAffine, regression)
{ {
IplImage* src = cvCreateImage(cvSize(100, 100), IPL_DEPTH_8U, 1); Mat src(Size(100, 100), CV_8UC1);
IplImage* dst = cvCreateImage(cvSize(100, 100), IPL_DEPTH_8U, 1); Mat dst(Size(100, 100), CV_8UC1);
cvZero(src); int w = src.cols;
int h = src.rows;
float m[6]; Mat M = getRotationMatrix2D(Point2f(w*0.5f, h*0.5f), 45.0, 1.0);
CvMat M = cvMat( 2, 3, CV_32F, m ); warpAffine(src, dst, M, Size(w, h));
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);
} }
TEST(Imgproc_fitLine_vector_3d, regression) TEST(Imgproc_fitLine_vector_3d, regression)
@ -1172,7 +1160,7 @@ TEST(Imgproc_fitLine_vector_3d, regression)
std::vector<float> line; 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); ASSERT_EQ(line.size(), (size_t)6);
@ -1192,7 +1180,7 @@ TEST(Imgproc_fitLine_vector_2d, regression)
std::vector<float> line; 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); 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); cv::Mat mat1 = Mat::zeros(3, 1, CV_32SC2);
std::vector<float> line1; 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); ASSERT_EQ(line1.size(), (size_t)4);
} }
@ -1212,7 +1200,7 @@ TEST(Imgproc_fitLine_Mat_2dC1, regression)
cv::Matx<int, 3, 2> mat2; cv::Matx<int, 3, 2> mat2;
std::vector<float> line2; 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); 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); cv::Mat mat1 = Mat::zeros(2, 1, CV_32SC3);
std::vector<float> line1; 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); 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); cv::Mat mat2 = Mat::zeros(2, 3, CV_32SC1);
std::vector<float> line2; 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); ASSERT_EQ(line2.size(), (size_t)6);
} }
@ -1527,7 +1515,7 @@ TEST(Imgproc_Remap, DISABLED_memleak)
putchar('.'); putchar('.');
fflush(stdout); 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, logPolar(src, dst,
Point2f((N-1) * 0.5f, (N-1) * 0.5f), M, 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, logPolar(dst, src,
Point2f((N-1) * 0.5f, (N-1) * 0.5f), M, 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)); double psnr = cvtest::PSNR(in(roi), src(roi));
EXPECT_LE(25, psnr) << "iteration=" << i; 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); Rect roi = Rect(0, 0, in.cols - ((N + 19) / 20), in.rows);
Point2f center = Point2f((N - 1) * 0.5f, (N - 1) * 0.5f); Point2f center = Point2f((N - 1) * 0.5f, (N - 1) * 0.5f);
double radius = N * 0.5; double radius = N * 0.5;
int flags = CV_WARP_FILL_OUTLIERS | CV_INTER_LINEAR; int flags = WARP_FILL_OUTLIERS | INTER_LINEAR;
// test linearPolar // test linearPolar
for (int ki = 1; ki <= 5; ki++) 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); warpPolar(dst, src, src.size(), center, radius, flags + WARP_POLAR_LINEAR);
double psnr = cv::PSNR(in(roi), src(roi)); double psnr = cv::PSNR(in(roi), src(roi));
@ -1640,7 +1628,7 @@ TEST(Imgproc_warpPolar, identity)
src = in.clone(); src = in.clone();
for (int ki = 1; ki <= 5; ki++) 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); warpPolar(dst, src, src.size(),center, radius, flags + WARP_POLAR_LOG);
double psnr = cv::PSNR(in(roi), src(roi)); double psnr = cv::PSNR(in(roi), src(roi));

5
modules/imgproc/test/test_templmatch.cpp
View File

@ -134,13 +134,8 @@ double CV_TemplMatchTest::get_success_error_level( int /*test_case_idx*/, int /*
void CV_TemplMatchTest::run_func() 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::Mat _out = cv::cvarrToMat(test_array[OUTPUT][0]);
cv::matchTemplate(cv::cvarrToMat(test_array[INPUT][0]), cv::cvarrToMat(test_array[INPUT][1]), _out, method); cv::matchTemplate(cv::cvarrToMat(test_array[INPUT][0]), cv::cvarrToMat(test_array[INPUT][1]), _out, method);
}
} }