diff --git a/modules/core/include/opencv2/core/core_c.h b/modules/core/include/opencv2/core/core_c.h
index 09ac1e789a..ac7bb926fc 100644
--- a/modules/core/include/opencv2/core/core_c.h
+++ b/modules/core/include/opencv2/core/core_c.h
@@ -408,18 +408,6 @@ CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )
return cvGetCols( arr, submat, col, col + 1 );
}
-/** @brief Returns one of array diagonals.
-
-The function returns the header, corresponding to a specified diagonal of the input array.
-@param arr Input array
-@param submat Pointer to the resulting sub-array header
-@param diag Index of the array diagonal. Zero value corresponds to the main diagonal, -1
-corresponds to the diagonal above the main, 1 corresponds to the diagonal below the main, and so
-forth.
- */
-CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
- int diag CV_DEFAULT(0));
-
/** low-level scalar <-> raw data conversion functions */
CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
int extend_to_12 CV_DEFAULT(0) );
@@ -560,37 +548,6 @@ CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
}
-#define CV_MAX_ARR 10
-
-/** matrix iterator: used for n-ary operations on dense arrays */
-typedef struct CvNArrayIterator
-{
- int count; /**< number of arrays */
- int dims; /**< number of dimensions to iterate */
- CvSize size; /**< maximal common linear size: { width = size, height = 1 } */
- uchar* ptr[CV_MAX_ARR]; /**< pointers to the array slices */
- int stack[CV_MAX_DIM]; /**< for internal use */
- CvMatND* hdr[CV_MAX_ARR]; /**< pointers to the headers of the
- matrices that are processed */
-}
-CvNArrayIterator;
-
-#define CV_NO_DEPTH_CHECK 1
-#define CV_NO_CN_CHECK 2
-#define CV_NO_SIZE_CHECK 4
-
-/** initializes iterator that traverses through several arrays simultaneously
- (the function together with cvNextArraySlice is used for
- N-ari element-wise operations) */
-CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
- const CvArr* mask, CvMatND* stubs,
- CvNArrayIterator* array_iterator,
- int flags CV_DEFAULT(0) );
-
-/** returns zero value if iteration is finished, non-zero (slice length) otherwise */
-CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
-
-
/** @brief Returns type of array elements.
The function returns type of the array elements. In the case of IplImage the type is converted to
@@ -793,46 +750,6 @@ this function, we will get different headers if the ROI is set in the original i
CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
-/** @brief Changes the shape of a multi-dimensional array without copying the data.
-
-The function is an advanced version of cvReshape that can work with multi-dimensional arrays as
-well (though it can work with ordinary images and matrices) and change the number of dimensions.
-
-Below are the two samples from the cvReshape description rewritten using cvReshapeMatND:
-@code
- IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
- IplImage gray_img_hdr, *gray_img;
- gray_img = (IplImage*)cvReshapeMatND(color_img, sizeof(gray_img_hdr), &gray_img_hdr, 1, 0, 0);
- ...
- int size[] = { 2, 2, 2 };
- CvMatND* mat = cvCreateMatND(3, size, CV_32F);
- CvMat row_header, *row;
- row = (CvMat*)cvReshapeMatND(mat, sizeof(row_header), &row_header, 0, 1, 0);
-@endcode
-In C, the header file for this function includes a convenient macro cvReshapeND that does away with
-the sizeof_header parameter. So, the lines containing the call to cvReshapeMatND in the examples
-may be replaced as follow:
-@code
- gray_img = (IplImage*)cvReshapeND(color_img, &gray_img_hdr, 1, 0, 0);
- ...
- row = (CvMat*)cvReshapeND(mat, &row_header, 0, 1, 0);
-@endcode
-@param arr Input array
-@param sizeof_header Size of output header to distinguish between IplImage, CvMat and CvMatND
-output headers
-@param header Output header to be filled
-@param new_cn New number of channels. new_cn = 0 means that the number of channels remains
-unchanged.
-@param new_dims New number of dimensions. new_dims = 0 means that the number of dimensions
-remains the same.
-@param new_sizes Array of new dimension sizes. Only new_dims-1 values are used, because the
-total number of elements must remain the same. Thus, if new_dims = 1, new_sizes array is not
-used.
- */
-CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
- int sizeof_header, CvArr* header,
- int new_cn, int new_dims, int* new_sizes );
-
#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \
cvReshapeMatND( (arr), sizeof(*(header)), (header), \
(new_cn), (new_dims), (new_sizes))
@@ -867,10 +784,6 @@ unchanged unless it needs to be changed according to new_cn value.
CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
int new_cn, int new_rows CV_DEFAULT(0) );
-/** Repeats source 2d array several times in both horizontal and
- vertical direction to fill destination array */
-CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
-
/** @brief Allocates array data
The function allocates image, matrix or multi-dimensional dense array data. Note that in the case of
@@ -1084,12 +997,6 @@ CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,
/** dst = src1 * scale + src2 */
CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale,
const CvArr* src2, CvArr* dst );
-#define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
-
-/** dst = src1 * alpha + src2 * beta + gamma */
-CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,
- const CvArr* src2, double beta,
- double gamma, CvArr* dst );
/** @brief Calculates the dot product of two arrays in Euclidean metrics.
@@ -1132,14 +1039,6 @@ CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
/** dst(idx) = ~src(idx) */
CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
-/** dst(idx) = lower(idx) <= src(idx) < upper(idx) */
-CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
- const CvArr* upper, CvArr* dst );
-
-/** dst(idx) = lower <= src(idx) < upper */
-CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
- CvScalar upper, CvArr* dst );
-
#define CV_CMP_EQ 0
#define CV_CMP_GT 1
#define CV_CMP_GE 2
@@ -1150,48 +1049,13 @@ CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
/** The comparison operation support single-channel arrays only.
Destination image should be 8uC1 or 8sC1 */
-/** dst(idx) = src1(idx) _cmp_op_ src2(idx) */
-CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
-
/** dst(idx) = src1(idx) _cmp_op_ value */
CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
-/** dst(idx) = min(src1(idx),src2(idx)) */
-CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/** dst(idx) = max(src1(idx),src2(idx)) */
-CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/** dst(idx) = min(src(idx),value) */
-CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
-
-/** dst(idx) = max(src(idx),value) */
-CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
-
-/** dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
-CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/** dst(x,y,c) = abs(src(x,y,c) - value(c)) */
-CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
-#define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
-
/****************************************************************************************\
* Math operations *
\****************************************************************************************/
-/** Does cartesian->polar coordinates conversion.
- Either of output components (magnitude or angle) is optional */
-CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y,
- CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
- int angle_in_degrees CV_DEFAULT(0));
-
-/** Does polar->cartesian coordinates conversion.
- Either of output components (magnitude or angle) is optional.
- If magnitude is missing it is assumed to be all 1's */
-CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
- CvArr* x, CvArr* y,
- int angle_in_degrees CV_DEFAULT(0));
-
/** Does powering: dst(idx) = src(idx)^power */
CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
@@ -1200,17 +1064,6 @@ CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
Maximal relative error is ~7e-6 for single-precision input */
CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
-/** Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
- Logarithm of 0 gives large negative number(~-700)
- Maximal relative error is ~3e-7 for single-precision output
-*/
-CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
-
-/** Fast arctangent calculation */
-CVAPI(float) cvFastArctan( float y, float x );
-
-/** Fast cubic root calculation */
-CVAPI(float) cvCbrt( float value );
#define CV_CHECK_RANGE 1
#define CV_CHECK_QUIET 2
@@ -1256,8 +1109,6 @@ CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
CvArr* idxmat CV_DEFAULT(NULL),
int flags CV_DEFAULT(0));
-/** Finds real roots of a cubic equation */
-CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
/** Finds all real and complex roots of a polynomial equation */
CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
@@ -1917,21 +1768,10 @@ CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
CvMemStorage* storage );
-/** The function implements the K-means algorithm for clustering an array of sample
- vectors in a specified number of classes */
-#define CV_KMEANS_USE_INITIAL_LABELS 1
-CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels,
- CvTermCriteria termcrit, int attempts CV_DEFAULT(1),
- CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0),
- CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );
-
/****************************************************************************************\
* System functions *
\****************************************************************************************/
-/** Loads optimized functions from IPP, MKL etc. or switches back to pure C code */
-CVAPI(int) cvUseOptimized( int on_off );
-
typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
(int,int,int,char*,char*,int,int,int,int,int,
IplROI*,IplImage*,void*,IplTileInfo*);
@@ -1966,598 +1806,6 @@ CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \
iplDeallocate, iplCreateROI, iplCloneImage )
-/****************************************************************************************\
-* Data Persistence *
-\****************************************************************************************/
-
-#if 0
-/********************************** High-level functions ********************************/
-
-/** @brief Opens file storage for reading or writing data.
-
-The function opens file storage for reading or writing data. In the latter case, a new file is
-created or an existing file is rewritten. The type of the read or written file is determined by the
-filename extension: .xml for XML, .yml or .yaml for YAML and .json for JSON.
-
-At the same time, it also supports adding parameters like "example.xml?base64".
-
-The function returns a pointer to the CvFileStorage structure.
-If the file cannot be opened then the function returns NULL.
-@param filename Name of the file associated with the storage
-@param memstorage Memory storage used for temporary data and for
-: storing dynamic structures, such as CvSeq or CvGraph . If it is NULL, a temporary memory
- storage is created and used.
-@param flags Can be one of the following:
-> - **CV_STORAGE_READ** the storage is open for reading
-> - **CV_STORAGE_WRITE** the storage is open for writing
- (use **CV_STORAGE_WRITE | CV_STORAGE_WRITE_BASE64** to write rawdata in Base64)
-@param encoding
- */
-CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,
- int flags, const char* encoding CV_DEFAULT(NULL) );
-
-/** @brief Releases file storage.
-
-The function closes the file associated with the storage and releases all the temporary structures.
-It must be called after all I/O operations with the storage are finished.
-@param fs Double pointer to the released file storage
- */
-CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
-
-/** returns attribute value or 0 (NULL) if there is no such attribute */
-CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
-
-/** @brief Starts writing a new structure.
-
-The function starts writing a compound structure (collection) that can be a sequence or a map. After
-all the structure fields, which can be scalars or structures, are written, cvEndWriteStruct should
-be called. The function can be used to group some objects or to implement the write function for a
-some user object (see CvTypeInfo).
-@param fs File storage
-@param name Name of the written structure. The structure can be accessed by this name when the
-storage is read.
-@param struct_flags A combination one of the following values:
-- **CV_NODE_SEQ** the written structure is a sequence (see discussion of CvFileStorage ),
- that is, its elements do not have a name.
-- **CV_NODE_MAP** the written structure is a map (see discussion of CvFileStorage ), that
- is, all its elements have names.
-One and only one of the two above flags must be specified
-- **CV_NODE_FLOW** the optional flag that makes sense only for YAML streams. It means that
- the structure is written as a flow (not as a block), which is more compact. It is
- recommended to use this flag for structures or arrays whose elements are all scalars.
-@param type_name Optional parameter - the object type name. In
- case of XML it is written as a type_id attribute of the structure opening tag. In the case of
- YAML it is written after a colon following the structure name (see the example in
- CvFileStorage description). In case of JSON it is written as a name/value pair.
- Mainly it is used with user objects. When the storage is read, the
- encoded type name is used to determine the object type (see CvTypeInfo and cvFindType ).
-@param attributes This parameter is not used in the current implementation
- */
-CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
- int struct_flags, const char* type_name CV_DEFAULT(NULL),
- CvAttrList attributes CV_DEFAULT(cvAttrList()));
-
-/** @brief Finishes writing to a file node collection.
-@param fs File storage
-@sa cvStartWriteStruct.
- */
-CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
-
-/** @brief Writes an integer value.
-
-The function writes a single integer value (with or without a name) to the file storage.
-@param fs File storage
-@param name Name of the written value. Should be NULL if and only if the parent structure is a
-sequence.
-@param value The written value
- */
-CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
-
-/** @brief Writes a floating-point value.
-
-The function writes a single floating-point value (with or without a name) to file storage. Special
-values are encoded as follows: NaN (Not A Number) as .NaN, infinity as +.Inf or -.Inf.
-
-The following example shows how to use the low-level writing functions to store custom structures,
-such as termination criteria, without registering a new type. :
-@code
- void write_termcriteria( CvFileStorage* fs, const char* struct_name,
- CvTermCriteria* termcrit )
- {
- cvStartWriteStruct( fs, struct_name, CV_NODE_MAP, NULL, cvAttrList(0,0));
- cvWriteComment( fs, "termination criteria", 1 ); // just a description
- if( termcrit->type & CV_TERMCRIT_ITER )
- cvWriteInteger( fs, "max_iterations", termcrit->max_iter );
- if( termcrit->type & CV_TERMCRIT_EPS )
- cvWriteReal( fs, "accuracy", termcrit->epsilon );
- cvEndWriteStruct( fs );
- }
-@endcode
-@param fs File storage
-@param name Name of the written value. Should be NULL if and only if the parent structure is a
-sequence.
-@param value The written value
-*/
-CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
-
-/** @brief Writes a text string.
-
-The function writes a text string to file storage.
-@param fs File storage
-@param name Name of the written string . Should be NULL if and only if the parent structure is a
-sequence.
-@param str The written text string
-@param quote If non-zero, the written string is put in quotes, regardless of whether they are
-required. Otherwise, if the flag is zero, quotes are used only when they are required (e.g. when
-the string starts with a digit or contains spaces).
- */
-CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
- const char* str, int quote CV_DEFAULT(0) );
-
-/** @brief Writes a comment.
-
-The function writes a comment into file storage. The comments are skipped when the storage is read.
-@param fs File storage
-@param comment The written comment, single-line or multi-line
-@param eol_comment If non-zero, the function tries to put the comment at the end of current line.
-If the flag is zero, if the comment is multi-line, or if it does not fit at the end of the current
-line, the comment starts a new line.
- */
-CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
- int eol_comment );
-
-/** @brief Writes an object to file storage.
-
-The function writes an object to file storage. First, the appropriate type info is found using
-cvTypeOf. Then, the write method associated with the type info is called.
-
-Attributes are used to customize the writing procedure. The standard types support the following
-attributes (all the dt attributes have the same format as in cvWriteRawData):
-
--# CvSeq
- - **header_dt** description of user fields of the sequence header that follow CvSeq, or
- CvChain (if the sequence is a Freeman chain) or CvContour (if the sequence is a contour or
- point sequence)
- - **dt** description of the sequence elements.
- - **recursive** if the attribute is present and is not equal to "0" or "false", the whole
- tree of sequences (contours) is stored.
--# CvGraph
- - **header_dt** description of user fields of the graph header that follows CvGraph;
- - **vertex_dt** description of user fields of graph vertices
- - **edge_dt** description of user fields of graph edges (note that the edge weight is
- always written, so there is no need to specify it explicitly)
-
-Below is the code that creates the YAML file shown in the CvFileStorage description:
-@code
- #include "cxcore.h"
-
- int main( int argc, char** argv )
- {
- CvMat* mat = cvCreateMat( 3, 3, CV_32F );
- CvFileStorage* fs = cvOpenFileStorage( "example.yml", 0, CV_STORAGE_WRITE );
-
- cvSetIdentity( mat );
- cvWrite( fs, "A", mat, cvAttrList(0,0) );
-
- cvReleaseFileStorage( &fs );
- cvReleaseMat( &mat );
- return 0;
- }
-@endcode
-@param fs File storage
-@param name Name of the written object. Should be NULL if and only if the parent structure is a
-sequence.
-@param ptr Pointer to the object
-@param attributes The attributes of the object. They are specific for each particular type (see
-the discussion below).
- */
-CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
- CvAttrList attributes CV_DEFAULT(cvAttrList()));
-
-/** @brief Starts the next stream.
-
-The function finishes the currently written stream and starts the next stream. In the case of XML
-the file with multiple streams looks like this:
-@code{.xml}
-
-
-
-
-
-
- ...
-@endcode
-The YAML file will look like this:
-@code{.yaml}
- %YAML 1.0
- # stream #1 data
- ...
- ---
- # stream #2 data
-@endcode
-This is useful for concatenating files or for resuming the writing process.
-@param fs File storage
- */
-CVAPI(void) cvStartNextStream( CvFileStorage* fs );
-
-/** @brief Writes multiple numbers.
-
-The function writes an array, whose elements consist of single or multiple numbers. The function
-call can be replaced with a loop containing a few cvWriteInt and cvWriteReal calls, but a single
-call is more efficient. Note that because none of the elements have a name, they should be written
-to a sequence rather than a map.
-@param fs File storage
-@param src Pointer to the written array
-@param len Number of the array elements to write
-@param dt Specification of each array element, see @ref format_spec "format specification"
- */
-CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
- int len, const char* dt );
-
-/** @brief Writes multiple numbers in Base64.
-
-If either CV_STORAGE_WRITE_BASE64 or cv::FileStorage::WRITE_BASE64 is used,
-this function will be the same as cvWriteRawData. If neither, the main
-difference is that it outputs a sequence in Base64 encoding rather than
-in plain text.
-
-This function can only be used to write a sequence with a type "binary".
-
-@param fs File storage
-@param src Pointer to the written array
-@param len Number of the array elements to write
-@param dt Specification of each array element, see @ref format_spec "format specification"
-*/
-CVAPI(void) cvWriteRawDataBase64( CvFileStorage* fs, const void* src,
- int len, const char* dt );
-
-/** @brief Returns a unique pointer for a given name.
-
-The function returns a unique pointer for each particular file node name. This pointer can be then
-passed to the cvGetFileNode function that is faster than cvGetFileNodeByName because it compares
-text strings by comparing pointers rather than the strings' content.
-
-Consider the following example where an array of points is encoded as a sequence of 2-entry maps:
-@code
- points:
- - { x: 10, y: 10 }
- - { x: 20, y: 20 }
- - { x: 30, y: 30 }
- # ...
-@endcode
-Then, it is possible to get hashed "x" and "y" pointers to speed up decoding of the points. :
-@code
- #include "cxcore.h"
-
- int main( int argc, char** argv )
- {
- CvFileStorage* fs = cvOpenFileStorage( "points.yml", 0, CV_STORAGE_READ );
- CvStringHashNode* x_key = cvGetHashedNode( fs, "x", -1, 1 );
- CvStringHashNode* y_key = cvGetHashedNode( fs, "y", -1, 1 );
- CvFileNode* points = cvGetFileNodeByName( fs, 0, "points" );
-
- if( CV_NODE_IS_SEQ(points->tag) )
- {
- CvSeq* seq = points->data.seq;
- int i, total = seq->total;
- CvSeqReader reader;
- cvStartReadSeq( seq, &reader, 0 );
- for( i = 0; i < total; i++ )
- {
- CvFileNode* pt = (CvFileNode*)reader.ptr;
- #if 1 // faster variant
- CvFileNode* xnode = cvGetFileNode( fs, pt, x_key, 0 );
- CvFileNode* ynode = cvGetFileNode( fs, pt, y_key, 0 );
- assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
- ynode && CV_NODE_IS_INT(ynode->tag));
- int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
- int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
- #elif 1 // slower variant; does not use x_key & y_key
- CvFileNode* xnode = cvGetFileNodeByName( fs, pt, "x" );
- CvFileNode* ynode = cvGetFileNodeByName( fs, pt, "y" );
- assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
- ynode && CV_NODE_IS_INT(ynode->tag));
- int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
- int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
- #else // the slowest yet the easiest to use variant
- int x = cvReadIntByName( fs, pt, "x", 0 );
- int y = cvReadIntByName( fs, pt, "y", 0 );
- #endif
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- printf("
- }
- }
- cvReleaseFileStorage( &fs );
- return 0;
- }
-@endcode
-Please note that whatever method of accessing a map you are using, it is still much slower than
-using plain sequences; for example, in the above example, it is more efficient to encode the points
-as pairs of integers in a single numeric sequence.
-@param fs File storage
-@param name Literal node name
-@param len Length of the name (if it is known apriori), or -1 if it needs to be calculated
-@param create_missing Flag that specifies, whether an absent key should be added into the hash table
-*/
-CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
- int len CV_DEFAULT(-1),
- int create_missing CV_DEFAULT(0));
-
-/** @brief Retrieves one of the top-level nodes of the file storage.
-
-The function returns one of the top-level file nodes. The top-level nodes do not have a name, they
-correspond to the streams that are stored one after another in the file storage. If the index is out
-of range, the function returns a NULL pointer, so all the top-level nodes can be iterated by
-subsequent calls to the function with stream_index=0,1,..., until the NULL pointer is returned.
-This function can be used as a base for recursive traversal of the file storage.
-@param fs File storage
-@param stream_index Zero-based index of the stream. See cvStartNextStream . In most cases,
-there is only one stream in the file; however, there can be several.
- */
-CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
- int stream_index CV_DEFAULT(0) );
-
-/** @brief Finds a node in a map or file storage.
-
-The function finds a file node. It is a faster version of cvGetFileNodeByName (see
-cvGetHashedKey discussion). Also, the function can insert a new node, if it is not in the map yet.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node. If both map and
-key are NULLs, the function returns the root file node - a map that contains top-level nodes.
-@param key Unique pointer to the node name, retrieved with cvGetHashedKey
-@param create_missing Flag that specifies whether an absent node should be added to the map
- */
-CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
- const CvStringHashNode* key,
- int create_missing CV_DEFAULT(0) );
-
-/** @brief Finds a node in a map or file storage.
-
-The function finds a file node by name. The node is searched either in map or, if the pointer is
-NULL, among the top-level file storage nodes. Using this function for maps and cvGetSeqElem (or
-sequence reader) for sequences, it is possible to navigate through the file storage. To speed up
-multiple queries for a certain key (e.g., in the case of an array of structures) one may use a
-combination of cvGetHashedKey and cvGetFileNode.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches in all the top-level nodes
-(streams), starting with the first one.
-@param name The file node name
- */
-CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
- const CvFileNode* map,
- const char* name );
-
-/** @brief Retrieves an integer value from a file node.
-
-The function returns an integer that is represented by the file node. If the file node is NULL, the
-default_value is returned (thus, it is convenient to call the function right after cvGetFileNode
-without checking for a NULL pointer). If the file node has type CV_NODE_INT, then node-\>data.i is
-returned. If the file node has type CV_NODE_REAL, then node-\>data.f is converted to an integer
-and returned. Otherwise the error is reported.
-@param node File node
-@param default_value The value that is returned if node is NULL
- */
-CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
-{
- return !node ? default_value :
- CV_NODE_IS_INT(node->tag) ? node->data.i :
- CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
-}
-
-/** @brief Finds a file node and returns its value.
-
-The function is a simple superposition of cvGetFileNodeByName and cvReadInt.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param default_value The value that is returned if the file node is not found
- */
-CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
- const char* name, int default_value CV_DEFAULT(0) )
-{
- return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-/** @brief Retrieves a floating-point value from a file node.
-
-The function returns a floating-point value that is represented by the file node. If the file node
-is NULL, the default_value is returned (thus, it is convenient to call the function right after
-cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_REAL ,
-then node-\>data.f is returned. If the file node has type CV_NODE_INT , then node-:math:\>data.f
-is converted to floating-point and returned. Otherwise the result is not determined.
-@param node File node
-@param default_value The value that is returned if node is NULL
- */
-CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
-{
- return !node ? default_value :
- CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
- CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
-}
-
-/** @brief Finds a file node and returns its value.
-
-The function is a simple superposition of cvGetFileNodeByName and cvReadReal .
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param default_value The value that is returned if the file node is not found
- */
-CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
- const char* name, double default_value CV_DEFAULT(0.) )
-{
- return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-/** @brief Retrieves a text string from a file node.
-
-The function returns a text string that is represented by the file node. If the file node is NULL,
-the default_value is returned (thus, it is convenient to call the function right after
-cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_STR , then
-node-:math:\>data.str.ptr is returned. Otherwise the result is not determined.
-@param node File node
-@param default_value The value that is returned if node is NULL
- */
-CV_INLINE const char* cvReadString( const CvFileNode* node,
- const char* default_value CV_DEFAULT(NULL) )
-{
- return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
-}
-
-/** @brief Finds a file node by its name and returns its value.
-
-The function is a simple superposition of cvGetFileNodeByName and cvReadString .
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param default_value The value that is returned if the file node is not found
- */
-CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
- const char* name, const char* default_value CV_DEFAULT(NULL) )
-{
- return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-
-/** @brief Decodes an object and returns a pointer to it.
-
-The function decodes a user object (creates an object in a native representation from the file
-storage subtree) and returns it. The object to be decoded must be an instance of a registered type
-that supports the read method (see CvTypeInfo). The type of the object is determined by the type
-name that is encoded in the file. If the object is a dynamic structure, it is created either in
-memory storage and passed to cvOpenFileStorage or, if a NULL pointer was passed, in temporary
-memory storage, which is released when cvReleaseFileStorage is called. Otherwise, if the object is
-not a dynamic structure, it is created in a heap and should be released with a specialized function
-or by using the generic cvRelease.
-@param fs File storage
-@param node The root object node
-@param attributes Unused parameter
- */
-CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
- CvAttrList* attributes CV_DEFAULT(NULL));
-
-/** @brief Finds an object by name and decodes it.
-
-The function is a simple superposition of cvGetFileNodeByName and cvRead.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param attributes Unused parameter
- */
-CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
- const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
-{
- return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
-}
-
-
-/** @brief Initializes the file node sequence reader.
-
-The function initializes the sequence reader to read data from a file node. The initialized reader
-can be then passed to cvReadRawDataSlice.
-@param fs File storage
-@param src The file node (a sequence) to read numbers from
-@param reader Pointer to the sequence reader
- */
-CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
- CvSeqReader* reader );
-
-/** @brief Initializes file node sequence reader.
-
-The function reads one or more elements from the file node, representing a sequence, to a
-user-specified array. The total number of read sequence elements is a product of total and the
-number of components in each array element. For example, if dt=2if, the function will read total\*3
-sequence elements. As with any sequence, some parts of the file node sequence can be skipped or read
-repeatedly by repositioning the reader using cvSetSeqReaderPos.
-@param fs File storage
-@param reader The sequence reader. Initialize it with cvStartReadRawData .
-@param count The number of elements to read
-@param dst Pointer to the destination array
-@param dt Specification of each array element. It has the same format as in cvWriteRawData .
- */
-CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
- int count, void* dst, const char* dt );
-
-/** @brief Reads multiple numbers.
-
-The function reads elements from a file node that represents a sequence of scalars.
-@param fs File storage
-@param src The file node (a sequence) to read numbers from
-@param dst Pointer to the destination array
-@param dt Specification of each array element. It has the same format as in cvWriteRawData .
- */
-CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
- void* dst, const char* dt );
-
-/** @brief Writes a file node to another file storage.
-
-The function writes a copy of a file node to file storage. Possible applications of the function are
-merging several file storages into one and conversion between XML, YAML and JSON formats.
-@param fs Destination file storage
-@param new_node_name New name of the file node in the destination file storage. To keep the
-existing name, use cvcvGetFileNodeName
-@param node The written node
-@param embed If the written node is a collection and this parameter is not zero, no extra level of
-hierarchy is created. Instead, all the elements of node are written into the currently written
-structure. Of course, map elements can only be embedded into another map, and sequence elements
-can only be embedded into another sequence.
- */
-CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
- const CvFileNode* node, int embed );
-
-/** @brief Returns the name of a file node.
-
-The function returns the name of a file node or NULL, if the file node does not have a name or if
-node is NULL.
-@param node File node
- */
-CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
-
-/*********************************** Adding own types ***********************************/
-
-/** @brief Registers a new type.
-
-The function registers a new type, which is described by info . The function creates a copy of the
-structure, so the user should delete it after calling the function.
-@param info Type info structure
- */
-CVAPI(void) cvRegisterType( const CvTypeInfo* info );
-
-/** @brief Unregisters the type.
-
-The function unregisters a type with a specified name. If the name is unknown, it is possible to
-locate the type info by an instance of the type using cvTypeOf or by iterating the type list,
-starting from cvFirstType, and then calling cvUnregisterType(info-\>typeName).
-@param type_name Name of an unregistered type
- */
-CVAPI(void) cvUnregisterType( const char* type_name );
-
-/** @brief Returns the beginning of a type list.
-
-The function returns the first type in the list of registered types. Navigation through the list can
-be done via the prev and next fields of the CvTypeInfo structure.
- */
-CVAPI(CvTypeInfo*) cvFirstType(void);
-
-/** @brief Finds a type by its name.
-
-The function finds a registered type by its name. It returns NULL if there is no type with the
-specified name.
-@param type_name Type name
- */
-CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
-
-/** @brief Returns the type of an object.
-
-The function finds the type of a given object. It iterates through the list of registered types and
-calls the is_instance function/method for every type info structure with that object until one of
-them returns non-zero or until the whole list has been traversed. In the latter case, the function
-returns NULL.
-@param struct_ptr The object pointer
- */
-CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
-
-#endif
/** @brief Releases an object.
@@ -2566,34 +1814,6 @@ CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
*/
CVAPI(void) cvRelease( void** struct_ptr );
-/** @brief Makes a clone of an object.
-
-The function finds the type of a given object and calls clone with the passed object. Of course, if
-you know the object type, for example, struct_ptr is CvMat\*, it is faster to call the specific
-function, like cvCloneMat.
-@param struct_ptr The object to clone
- */
-CVAPI(void*) cvClone( const void* struct_ptr );
-
-/*********************************** Measuring Execution Time ***************************/
-
-/** helper functions for RNG initialization and accurate time measurement:
- uses internal clock counter on x86 */
-CVAPI(int64) cvGetTickCount( void );
-CVAPI(double) cvGetTickFrequency( void );
-
-/*********************************** CPU capabilities ***********************************/
-
-CVAPI(int) cvCheckHardwareSupport(int feature);
-
-/*********************************** Multi-Threading ************************************/
-
-/** retrieve/set the number of threads used in OpenMP implementations */
-CVAPI(int) cvGetNumThreads( void );
-CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
-/** get index of the thread being executed */
-CVAPI(int) cvGetThreadNum( void );
-
/********************************** Error Handling **************************************/
@@ -2629,25 +1849,6 @@ CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
/** Maps IPP error codes to the counterparts from OpenCV */
CVAPI(int) cvErrorFromIppStatus( int ipp_status );
-typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
- const char* err_msg, const char* file_name, int line, void* userdata );
-
-/** Assigns a new error-handling function */
-CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
- void* userdata CV_DEFAULT(NULL),
- void** prev_userdata CV_DEFAULT(NULL) );
-
-/** Output nothing */
-CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
- const char* file_name, int line, void* userdata );
-
-/** Output to console(fprintf(stderr,...)) */
-CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
- const char* file_name, int line, void* userdata );
-
-/** Output to MessageBox(WIN32) */
-CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
- const char* file_name, int line, void* userdata );
#define OPENCV_ERROR(status,func,context) \
cvError((status),(func),(context),__FILE__,__LINE__)
@@ -2740,17 +1941,9 @@ CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
bool allowND=true, int coiMode=0,
AutoBuffer* buf=0);
-static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
-{
- return cvarrToMat(arr, copyData, true, coiMode);
-}
-
//! extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
-//! inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
-CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1);
-
////// specialized implementations of DefaultDeleter::operator() for classic OpenCV types //////
diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp
index 2672ea194c..1c95985e9a 100644
--- a/modules/core/src/arithm.cpp
+++ b/modules/core/src/arithm.cpp
@@ -1999,69 +1999,6 @@ CV_IMPL void cvDiv( const CvArr* srcarr1, const CvArr* srcarr2,
}
-CV_IMPL void
-cvAddWeighted( const CvArr* srcarr1, double alpha,
- const CvArr* srcarr2, double beta,
- double gamma, CvArr* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
- dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.channels() == dst.channels() );
- cv::addWeighted( src1, alpha, src2, beta, gamma, dst, dst.type() );
-}
-
-
-CV_IMPL void
-cvAbsDiff( const CvArr* srcarr1, const CvArr* srcarr2, CvArr* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
-
- cv::absdiff( src1, cv::cvarrToMat(srcarr2), dst );
-}
-
-
-CV_IMPL void
-cvAbsDiffS( const CvArr* srcarr1, CvArr* dstarr, CvScalar scalar )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
-
- cv::absdiff( src1, (const cv::Scalar&)scalar, dst );
-}
-
-
-CV_IMPL void
-cvInRange( const void* srcarr1, const void* srcarr2,
- const void* srcarr3, void* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && dst.type() == CV_8U );
-
- cv::inRange( src1, cv::cvarrToMat(srcarr2), cv::cvarrToMat(srcarr3), dst );
-}
-
-
-CV_IMPL void
-cvInRangeS( const void* srcarr1, CvScalar lowerb, CvScalar upperb, void* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && dst.type() == CV_8U );
-
- cv::inRange( src1, (const cv::Scalar&)lowerb, (const cv::Scalar&)upperb, dst );
-}
-
-
-CV_IMPL void
-cvCmp( const void* srcarr1, const void* srcarr2, void* dstarr, int cmp_op )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && dst.type() == CV_8U );
-
- cv::compare( src1, cv::cvarrToMat(srcarr2), dst, cmp_op );
-}
-
-
CV_IMPL void
cvCmpS( const void* srcarr1, double value, void* dstarr, int cmp_op )
{
@@ -2071,44 +2008,4 @@ cvCmpS( const void* srcarr1, double value, void* dstarr, int cmp_op )
cv::compare( src1, value, dst, cmp_op );
}
-
-CV_IMPL void
-cvMin( const void* srcarr1, const void* srcarr2, void* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
-
- cv::min( src1, cv::cvarrToMat(srcarr2), dst );
-}
-
-
-CV_IMPL void
-cvMax( const void* srcarr1, const void* srcarr2, void* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
-
- cv::max( src1, cv::cvarrToMat(srcarr2), dst );
-}
-
-
-CV_IMPL void
-cvMinS( const void* srcarr1, double value, void* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
-
- cv::min( src1, value, dst );
-}
-
-
-CV_IMPL void
-cvMaxS( const void* srcarr1, double value, void* dstarr )
-{
- cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
-
- cv::max( src1, value, dst );
-}
-
/* End of file. */
diff --git a/modules/core/src/array.cpp b/modules/core/src/array.cpp
index 057dd4ba88..b2f20e41c9 100644
--- a/modules/core/src/array.cpp
+++ b/modules/core/src/array.cpp
@@ -324,200 +324,6 @@ cvCloneMatND( const CvMatND* src )
}
-static CvMatND*
-cvGetMatND( const CvArr* arr, CvMatND* matnd, int* coi )
-{
- CvMatND* result = 0;
-
- if( coi )
- *coi = 0;
-
- if( !matnd || !arr )
- CV_Error( CV_StsNullPtr, "NULL array pointer is passed" );
-
- if( CV_IS_MATND_HDR(arr))
- {
- if( !((CvMatND*)arr)->data.ptr )
- CV_Error( CV_StsNullPtr, "The matrix has NULL data pointer" );
-
- result = (CvMatND*)arr;
- }
- else
- {
- CvMat stub, *mat = (CvMat*)arr;
-
- if( CV_IS_IMAGE_HDR( mat ))
- mat = cvGetMat( mat, &stub, coi );
-
- if( !CV_IS_MAT_HDR( mat ))
- CV_Error( CV_StsBadArg, "Unrecognized or unsupported array type" );
-
- if( !mat->data.ptr )
- CV_Error( CV_StsNullPtr, "Input array has NULL data pointer" );
-
- matnd->data.ptr = mat->data.ptr;
- matnd->refcount = 0;
- matnd->hdr_refcount = 0;
- matnd->type = mat->type;
- matnd->dims = 2;
- matnd->dim[0].size = mat->rows;
- matnd->dim[0].step = mat->step;
- matnd->dim[1].size = mat->cols;
- matnd->dim[1].step = CV_ELEM_SIZE(mat->type);
- result = matnd;
- }
-
- return result;
-}
-
-
-// returns number of dimensions to iterate.
-/*
-Checks whether arrays have equal type, sizes (mask is optional array
-that needs to have the same size, but 8uC1 or 8sC1 type - feature has been disabled).
-Returns number of dimensions to iterate through:
-0 means that all arrays are continuous,
-1 means that all arrays are vectors of continuous arrays etc.
-and the size of largest common continuous part of the arrays
-*/
-CV_IMPL int
-cvInitNArrayIterator( int count, CvArr** arrs,
- const CvArr* mask, CvMatND* stubs,
- CvNArrayIterator* iterator, int flags )
-{
- int dims = -1;
- int i, j, size, dim0 = -1;
- int64 step;
- CvMatND* hdr0 = 0;
-
- if( count < 1 || count > CV_MAX_ARR )
- CV_Error( CV_StsOutOfRange, "Incorrect number of arrays" );
-
- if( !arrs || !stubs )
- CV_Error( CV_StsNullPtr, "Some of required array pointers is NULL" );
-
- if( !iterator )
- CV_Error( CV_StsNullPtr, "Iterator pointer is NULL" );
-
- if (mask)
- CV_Error( CV_StsBadArg, "Iterator with mask is not supported" );
-
- for( i = 0; i < count; i++ )
- {
- const CvArr* arr = arrs[i];
- CvMatND* hdr;
-
- if( !arr )
- CV_Error( CV_StsNullPtr, "Some of required array pointers is NULL" );
-
- if( CV_IS_MATND( arr ))
- hdr = (CvMatND*)arr;
- else
- {
- int coi = 0;
- hdr = cvGetMatND( arr, stubs + i, &coi );
- if( coi != 0 )
- CV_Error( CV_BadCOI, "COI set is not allowed here" );
- }
-
- iterator->hdr[i] = hdr;
-
- if( i > 0 )
- {
- if( hdr->dims != hdr0->dims )
- CV_Error( CV_StsUnmatchedSizes,
- "Number of dimensions is the same for all arrays" );
-
- switch( flags & (CV_NO_DEPTH_CHECK|CV_NO_CN_CHECK))
- {
- case 0:
- if( !CV_ARE_TYPES_EQ( hdr, hdr0 ))
- CV_Error( CV_StsUnmatchedFormats,
- "Data type is not the same for all arrays" );
- break;
- case CV_NO_DEPTH_CHECK:
- if( !CV_ARE_CNS_EQ( hdr, hdr0 ))
- CV_Error( CV_StsUnmatchedFormats,
- "Number of channels is not the same for all arrays" );
- break;
- case CV_NO_CN_CHECK:
- if( !CV_ARE_CNS_EQ( hdr, hdr0 ))
- CV_Error( CV_StsUnmatchedFormats,
- "Depth is not the same for all arrays" );
- break;
- }
-
- if( !(flags & CV_NO_SIZE_CHECK) )
- {
- for( j = 0; j < hdr->dims; j++ )
- if( hdr->dim[j].size != hdr0->dim[j].size )
- CV_Error( CV_StsUnmatchedSizes,
- "Dimension sizes are the same for all arrays" );
- }
- }
- else
- hdr0 = hdr;
-
- step = CV_ELEM_SIZE(hdr->type);
- for( j = hdr->dims - 1; j > dim0; j-- )
- {
- if( step != hdr->dim[j].step )
- break;
- step *= hdr->dim[j].size;
- }
-
- if( j == dim0 && step > INT_MAX )
- j++;
-
- if( j > dim0 )
- dim0 = j;
-
- iterator->hdr[i] = (CvMatND*)hdr;
- iterator->ptr[i] = (uchar*)hdr->data.ptr;
- }
-
- size = 1;
- for( j = hdr0->dims - 1; j > dim0; j-- )
- size *= hdr0->dim[j].size;
-
- dims = dim0 + 1;
- iterator->dims = dims;
- iterator->count = count;
- iterator->size = cvSize(size,1);
-
- for( i = 0; i < dims; i++ )
- iterator->stack[i] = hdr0->dim[i].size;
-
- return dims;
-}
-
-
-// returns zero value if iteration is finished, non-zero otherwise
-CV_IMPL int cvNextNArraySlice( CvNArrayIterator* iterator )
-{
- assert( iterator != 0 );
- int i, dims;
-
- for( dims = iterator->dims; dims > 0; dims-- )
- {
- for( i = 0; i < iterator->count; i++ )
- iterator->ptr[i] += iterator->hdr[i]->dim[dims-1].step;
-
- if( --iterator->stack[dims-1] > 0 )
- break;
-
- const int size = iterator->hdr[0]->dim[dims-1].size;
-
- for( i = 0; i < iterator->count; i++ )
- iterator->ptr[i] -= (size_t)size*iterator->hdr[i]->dim[dims-1].step;
-
- iterator->stack[dims-1] = size;
- }
-
- return dims > 0;
-}
-
-
/****************************************************************************************\
* CvSparseMat creation and basic operations *
\****************************************************************************************/
@@ -1387,67 +1193,6 @@ cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col )
}
-// Selects array diagonal
-CV_IMPL CvMat*
-cvGetDiag( const CvArr* arr, CvMat* submat, int diag )
-{
- CvMat* res = 0;
- CvMat stub, *mat = (CvMat*)arr;
- int len, pix_size;
-
- if( !CV_IS_MAT( mat ))
- mat = cvGetMat( mat, &stub );
-
- if( !submat )
- CV_Error( CV_StsNullPtr, "" );
-
- pix_size = CV_ELEM_SIZE(mat->type);
-
- /*{
- int* refcount = mat->refcount;
-
- if( refcount )
- ++*refcount;
-
- cvDecRefData( submat );
- }*/
-
- if( diag >= 0 )
- {
- len = mat->cols - diag;
-
- if( len <= 0 )
- CV_Error( CV_StsOutOfRange, "" );
-
- len = CV_IMIN( len, mat->rows );
- submat->data.ptr = mat->data.ptr + diag*pix_size;
- }
- else
- {
- len = mat->rows + diag;
-
- if( len <= 0 )
- CV_Error( CV_StsOutOfRange, "" );
-
- len = CV_IMIN( len, mat->cols );
- submat->data.ptr = mat->data.ptr - diag*mat->step;
- }
-
- submat->rows = len;
- submat->cols = 1;
- submat->step = mat->step + (submat->rows > 1 ? pix_size : 0);
- submat->type = mat->type;
- if( submat->rows > 1 )
- submat->type &= ~CV_MAT_CONT_FLAG;
- else
- submat->type |= CV_MAT_CONT_FLAG;
- submat->refcount = 0;
- submat->hdr_refcount = 0;
- res = submat;
-
- return res;
-}
-
/****************************************************************************************\
* Operations on CvScalar and accessing array elements *
\****************************************************************************************/
@@ -2498,214 +2243,6 @@ cvGetMat( const CvArr* array, CvMat* mat,
}
-CV_IMPL CvArr*
-cvReshapeMatND( const CvArr* arr,
- int sizeof_header, CvArr* _header,
- int new_cn, int new_dims, int* new_sizes )
-{
- CvArr* result = 0;
- int dims, coi = 0;
-
- if( !arr || !_header )
- CV_Error( CV_StsNullPtr, "NULL pointer to array or destination header" );
-
- if( new_cn == 0 && new_dims == 0 )
- CV_Error( CV_StsBadArg, "None of array parameters is changed: dummy call?" );
-
- dims = cvGetDims( arr );
-
- if( new_dims == 0 )
- {
- new_sizes = 0;
- new_dims = dims;
- }
- else if( new_dims == 1 )
- {
- new_sizes = 0;
- }
- else
- {
- if( new_dims <= 0 || new_dims > CV_MAX_DIM )
- CV_Error( CV_StsOutOfRange, "Non-positive or too large number of dimensions" );
- if( !new_sizes )
- CV_Error( CV_StsNullPtr, "New dimension sizes are not specified" );
- }
-
- if( new_dims <= 2 )
- {
- CvMat* mat = (CvMat*)arr;
- CvMat header;
- int* refcount = 0;
- int hdr_refcount = 0;
- int total_width, new_rows, cn;
-
- if( sizeof_header != sizeof(CvMat) && sizeof_header != sizeof(CvMatND) )
- CV_Error( CV_StsBadArg, "The output header should be CvMat or CvMatND" );
-
- if( mat == (CvMat*)_header )
- {
- refcount = mat->refcount;
- hdr_refcount = mat->hdr_refcount;
- }
-
- if( !CV_IS_MAT( mat ))
- mat = cvGetMat( mat, &header, &coi, 1 );
-
- cn = CV_MAT_CN( mat->type );
- total_width = mat->cols * cn;
-
- if( new_cn == 0 )
- new_cn = cn;
-
- if( new_sizes )
- new_rows = new_sizes[0];
- else if( new_dims == 1 )
- new_rows = total_width*mat->rows/new_cn;
- else
- {
- new_rows = mat->rows;
- if( new_cn > total_width )
- new_rows = mat->rows * total_width / new_cn;
- }
-
- if( new_rows != mat->rows )
- {
- int total_size = total_width * mat->rows;
-
- if( !CV_IS_MAT_CONT( mat->type ))
- CV_Error( CV_BadStep,
- "The matrix is not continuous so the number of rows can not be changed" );
-
- total_width = total_size / new_rows;
-
- if( total_width * new_rows != total_size )
- CV_Error( CV_StsBadArg, "The total number of matrix elements "
- "is not divisible by the new number of rows" );
- }
-
- header.rows = new_rows;
- header.cols = total_width / new_cn;
-
- if( header.cols * new_cn != total_width ||
- (new_sizes && header.cols != new_sizes[1]) )
- CV_Error( CV_StsBadArg, "The total matrix width is not "
- "divisible by the new number of columns" );
-
- header.type = (mat->type & ~CV_MAT_TYPE_MASK) | CV_MAKETYPE(mat->type, new_cn);
- header.step = header.cols * CV_ELEM_SIZE(mat->type);
- header.step &= new_rows > 1 ? -1 : 0;
- header.refcount = refcount;
- header.hdr_refcount = hdr_refcount;
-
- if( sizeof_header == sizeof(CvMat) )
- *(CvMat*)_header = header;
- else
- {
- CvMatND* __header = (CvMatND*)_header;
- cvGetMatND(&header, __header, 0);
- if( new_dims > 0 )
- __header->dims = new_dims;
- }
- }
- else
- {
- CvMatND* header = (CvMatND*)_header;
-
- if( sizeof_header != sizeof(CvMatND))
- CV_Error( CV_StsBadSize, "The output header should be CvMatND" );
-
- if( !new_sizes )
- {
- if( !CV_IS_MATND( arr ))
- CV_Error( CV_StsBadArg, "The input array must be CvMatND" );
-
- {
- CvMatND* mat = (CvMatND*)arr;
- assert( new_cn > 0 );
- int last_dim_size = mat->dim[mat->dims-1].size*CV_MAT_CN(mat->type);
- int new_size = last_dim_size/new_cn;
-
- if( new_size*new_cn != last_dim_size )
- CV_Error( CV_StsBadArg,
- "The last dimension full size is not divisible by new number of channels");
-
- if( mat != header )
- {
- memcpy( header, mat, sizeof(*header));
- header->refcount = 0;
- header->hdr_refcount = 0;
- }
-
- header->dim[header->dims-1].size = new_size;
- header->type = (header->type & ~CV_MAT_TYPE_MASK) | CV_MAKETYPE(header->type, new_cn);
- }
- }
- else
- {
- CvMatND stub;
- CvMatND* mat = (CvMatND*)arr;
- int i, size1, size2;
- int step;
-
- if( new_cn != 0 )
- CV_Error( CV_StsBadArg,
- "Simultaneous change of shape and number of channels is not supported. "
- "Do it by 2 separate calls" );
-
- if( !CV_IS_MATND( mat ))
- {
- cvGetMatND( mat, &stub, &coi );
- mat = &stub;
- }
-
- if( CV_IS_MAT_CONT( mat->type ))
- CV_Error( CV_StsBadArg, "Non-continuous nD arrays are not supported" );
-
- size1 = mat->dim[0].size;
- for( i = 1; i < dims; i++ )
- size1 *= mat->dim[i].size;
-
- size2 = 1;
- for( i = 0; i < new_dims; i++ )
- {
- if( new_sizes[i] <= 0 )
- CV_Error( CV_StsBadSize,
- "One of new dimension sizes is non-positive" );
- size2 *= new_sizes[i];
- }
-
- if( size1 != size2 )
- CV_Error( CV_StsBadSize,
- "Number of elements in the original and reshaped array is different" );
-
- if( header != mat )
- {
- header->refcount = 0;
- header->hdr_refcount = 0;
- }
-
- header->dims = new_dims;
- header->type = mat->type;
- header->data.ptr = mat->data.ptr;
- step = CV_ELEM_SIZE(header->type);
-
- for( i = new_dims - 1; i >= 0; i-- )
- {
- header->dim[i].size = new_sizes[i];
- header->dim[i].step = step;
- step *= new_sizes[i];
- }
- }
- }
-
- if( coi )
- CV_Error( CV_BadCOI, "COI is not supported by this operation" );
-
- result = _header;
- return result;
-}
-
-
CV_IMPL CvMat*
cvReshape( const CvArr* array, CvMat* header,
int new_cn, int new_rows )
@@ -3279,20 +2816,5 @@ cvRelease( void** struct_ptr )
}
}
-void* cvClone( const void* struct_ptr )
-{
- void* ptr = 0;
- if( !struct_ptr )
- CV_Error( CV_StsNullPtr, "NULL structure pointer" );
-
- if( CV_IS_MAT(struct_ptr) )
- ptr = cvCloneMat((const CvMat*)struct_ptr);
- else if( CV_IS_IMAGE(struct_ptr))
- ptr = cvCloneImage((const IplImage*)struct_ptr);
- else
- CV_Error( CV_StsError, "Unknown object type" );
- return ptr;
-}
-
/* End of file. */
diff --git a/modules/core/src/copy.cpp b/modules/core/src/copy.cpp
index dcd585d834..c1e86c6a9c 100644
--- a/modules/core/src/copy.cpp
+++ b/modules/core/src/copy.cpp
@@ -1606,13 +1606,4 @@ cvFlip( const CvArr* srcarr, CvArr* dstarr, int flip_mode )
cv::flip( src, dst, flip_mode );
}
-CV_IMPL void
-cvRepeat( const CvArr* srcarr, CvArr* dstarr )
-{
- cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src.type() == dst.type() &&
- dst.rows % src.rows == 0 && dst.cols % src.cols == 0 );
- cv::repeat(src, dst.rows/src.rows, dst.cols/src.cols, dst);
-}
-
/* End of file. */
diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp
index 18bdf6ce4d..d4f8dc0ba4 100644
--- a/modules/core/src/mathfuncs.cpp
+++ b/modules/core/src/mathfuncs.cpp
@@ -1638,60 +1638,6 @@ void patchNaNs( InputOutputArray _a, double _val )
}
-CV_IMPL float cvCbrt(float value) { return cv::cubeRoot(value); }
-CV_IMPL float cvFastArctan(float y, float x) { return cv::fastAtan2(y, x); }
-
-CV_IMPL void
-cvCartToPolar( const CvArr* xarr, const CvArr* yarr,
- CvArr* magarr, CvArr* anglearr,
- int angle_in_degrees )
-{
- cv::Mat X = cv::cvarrToMat(xarr), Y = cv::cvarrToMat(yarr), Mag, Angle;
- if( magarr )
- {
- Mag = cv::cvarrToMat(magarr);
- CV_Assert( Mag.size() == X.size() && Mag.type() == X.type() );
- }
- if( anglearr )
- {
- Angle = cv::cvarrToMat(anglearr);
- CV_Assert( Angle.size() == X.size() && Angle.type() == X.type() );
- }
- if( magarr )
- {
- if( anglearr )
- cv::cartToPolar( X, Y, Mag, Angle, angle_in_degrees != 0 );
- else
- cv::magnitude( X, Y, Mag );
- }
- else
- cv::phase( X, Y, Angle, angle_in_degrees != 0 );
-}
-
-CV_IMPL void
-cvPolarToCart( const CvArr* magarr, const CvArr* anglearr,
- CvArr* xarr, CvArr* yarr, int angle_in_degrees )
-{
- cv::Mat X, Y, Angle = cv::cvarrToMat(anglearr), Mag;
- if( magarr )
- {
- Mag = cv::cvarrToMat(magarr);
- CV_Assert( Mag.size() == Angle.size() && Mag.type() == Angle.type() );
- }
- if( xarr )
- {
- X = cv::cvarrToMat(xarr);
- CV_Assert( X.size() == Angle.size() && X.type() == Angle.type() );
- }
- if( yarr )
- {
- Y = cv::cvarrToMat(yarr);
- CV_Assert( Y.size() == Angle.size() && Y.type() == Angle.type() );
- }
-
- cv::polarToCart( Mag, Angle, X, Y, angle_in_degrees != 0 );
-}
-
CV_IMPL void cvExp( const CvArr* srcarr, CvArr* dstarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
@@ -1699,13 +1645,6 @@ CV_IMPL void cvExp( const CvArr* srcarr, CvArr* dstarr )
cv::exp( src, dst );
}
-CV_IMPL void cvLog( const CvArr* srcarr, CvArr* dstarr )
-{
- cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
- CV_Assert( src.type() == dst.type() && src.size == dst.size );
- cv::log( src, dst );
-}
-
CV_IMPL void cvPow( const CvArr* srcarr, CvArr* dstarr, double power )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
@@ -2016,16 +1955,6 @@ double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters )
}
-CV_IMPL int
-cvSolveCubic( const CvMat* coeffs, CvMat* roots )
-{
- cv::Mat _coeffs = cv::cvarrToMat(coeffs), _roots = cv::cvarrToMat(roots), _roots0 = _roots;
- int nroots = cv::solveCubic(_coeffs, _roots);
- CV_Assert( _roots.data == _roots0.data ); // check that the array of roots was not reallocated
- return nroots;
-}
-
-
void cvSolvePoly(const CvMat* a, CvMat *r, int maxiter, int)
{
cv::Mat _a = cv::cvarrToMat(a);
diff --git a/modules/core/src/matrix_c.cpp b/modules/core/src/matrix_c.cpp
index 1c3e58857c..dc935c3eca 100644
--- a/modules/core/src/matrix_c.cpp
+++ b/modules/core/src/matrix_c.cpp
@@ -200,19 +200,6 @@ void extractImageCOI(const CvArr* arr, OutputArray _ch, int coi)
mixChannels( &mat, 1, &ch, 1, _pairs, 1 );
}
-void insertImageCOI(InputArray _ch, CvArr* arr, int coi)
-{
- Mat ch = _ch.getMat(), mat = cvarrToMat(arr, false, true, 1);
- if(coi < 0)
- {
- CV_Assert( CV_IS_IMAGE(arr) );
- coi = cvGetImageCOI((const IplImage*)arr)-1;
- }
- CV_Assert(ch.size == mat.size && ch.depth() == mat.depth() && 0 <= coi && coi < mat.channels());
- int _pairs[] = { 0, coi };
- mixChannels( &ch, 1, &mat, 1, _pairs, 1 );
-}
-
} // cv::
// operations
@@ -355,33 +342,3 @@ cvSort( const CvArr* _src, CvArr* _dst, CvArr* _idx, int flags )
CV_Assert( dst0.data == dst.data );
}
}
-
-
-CV_IMPL int
-cvKMeans2( const CvArr* _samples, int cluster_count, CvArr* _labels,
- CvTermCriteria termcrit, int attempts, CvRNG*,
- int flags, CvArr* _centers, double* _compactness )
-{
- cv::Mat data = cv::cvarrToMat(_samples), labels = cv::cvarrToMat(_labels), centers;
- if( _centers )
- {
- centers = cv::cvarrToMat(_centers);
-
- centers = centers.reshape(1);
- data = data.reshape(1);
-
- CV_Assert( !centers.empty() );
- CV_Assert( centers.rows == cluster_count );
- CV_Assert( centers.cols == data.cols );
- CV_Assert( centers.depth() == data.depth() );
- }
- CV_Assert( labels.isContinuous() && labels.type() == CV_32S &&
- (labels.cols == 1 || labels.rows == 1) &&
- labels.cols + labels.rows - 1 == data.rows );
-
- double compactness = cv::kmeans(data, cluster_count, labels, termcrit, attempts,
- flags, _centers ? cv::_OutputArray(centers) : cv::_OutputArray() );
- if( _compactness )
- *_compactness = compactness;
- return 1;
-}
diff --git a/modules/core/src/parallel.cpp b/modules/core/src/parallel.cpp
index b4043b0b63..9dc0fd00f0 100644
--- a/modules/core/src/parallel.cpp
+++ b/modules/core/src/parallel.cpp
@@ -972,18 +972,3 @@ const char* currentParallelFramework() {
}
} // namespace cv::
-
-CV_IMPL void cvSetNumThreads(int nt)
-{
- cv::setNumThreads(nt);
-}
-
-CV_IMPL int cvGetNumThreads()
-{
- return cv::getNumThreads();
-}
-
-CV_IMPL int cvGetThreadNum()
-{
- return cv::getThreadNum();
-}
diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp
index 3acf77035f..e0fdde33e8 100644
--- a/modules/core/src/system.cpp
+++ b/modules/core/src/system.cpp
@@ -1178,58 +1178,6 @@ redirectError( ErrorCallback errCallback, void* userdata, void** prevUserdata)
}
-CV_IMPL int cvCheckHardwareSupport(int feature)
-{
- CV_DbgAssert( 0 <= feature && feature <= CV_HARDWARE_MAX_FEATURE );
- return cv::currentFeatures->have[feature];
-}
-
-CV_IMPL int cvUseOptimized( int flag )
-{
- int prevMode = cv::useOptimizedFlag;
- cv::setUseOptimized( flag != 0 );
- return prevMode;
-}
-
-CV_IMPL int64 cvGetTickCount(void)
-{
- return cv::getTickCount();
-}
-
-CV_IMPL double cvGetTickFrequency(void)
-{
- return cv::getTickFrequency()*1e-6;
-}
-
-CV_IMPL CvErrorCallback
-cvRedirectError( CvErrorCallback errCallback, void* userdata, void** prevUserdata)
-{
- return cv::redirectError(errCallback, userdata, prevUserdata);
-}
-
-CV_IMPL int cvNulDevReport( int, const char*, const char*,
- const char*, int, void* )
-{
- return 0;
-}
-
-CV_IMPL int cvStdErrReport( int, const char*, const char*,
- const char*, int, void* )
-{
- return 0;
-}
-
-CV_IMPL int cvGuiBoxReport( int, const char*, const char*,
- const char*, int, void* )
-{
- return 0;
-}
-
-CV_IMPL int cvGetErrInfo( const char**, const char**, const char**, int* )
-{
- return 0;
-}
-
CV_IMPL const char* cvErrorStr( int status )
{
diff --git a/modules/imgproc/include/opencv2/imgproc/imgproc_c.h b/modules/imgproc/include/opencv2/imgproc/imgproc_c.h
index 86dc119fdd..67653eb71e 100644
--- a/modules/imgproc/include/opencv2/imgproc/imgproc_c.h
+++ b/modules/imgproc/include/opencv2/imgproc/imgproc_c.h
@@ -83,11 +83,6 @@ CVAPI(void) cvRunningAvg( const CvArr* image, CvArr* acc, double alpha,
* Image Processing *
\****************************************************************************************/
-/** Copies source 2D array inside of the larger destination array and
- makes a border of the specified type (IPL_BORDER_*) around the copied area. */
-CVAPI(void) cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset,
- int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
-
/** @brief Smooths the image in one of several ways.
@param src The source image
@@ -156,47 +151,6 @@ CVAPI(void) cvPyrDown( const CvArr* src, CvArr* dst,
CVAPI(void) cvPyrUp( const CvArr* src, CvArr* dst,
int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
-/** @brief Builds pyramid for an image
-@see buildPyramid
-*/
-CVAPI(CvMat**) cvCreatePyramid( const CvArr* img, int extra_layers, double rate,
- const CvSize* layer_sizes CV_DEFAULT(0),
- CvArr* bufarr CV_DEFAULT(0),
- int calc CV_DEFAULT(1),
- int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
-
-/** @brief Releases pyramid */
-CVAPI(void) cvReleasePyramid( CvMat*** pyramid, int extra_layers );
-
-
-/** @brief Filters image using meanshift algorithm
-@see cv::pyrMeanShiftFiltering
-*/
-CVAPI(void) cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst,
- double sp, double sr, int max_level CV_DEFAULT(1),
- CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)));
-
-/** @brief Segments image using seed "markers"
-@see cv::watershed
-*/
-CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
-
-/** @brief Calculates an image derivative using generalized Sobel
-
- (aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator.
- Scharr can be used only for the first dx or dy derivative
-@see cv::Sobel
-*/
-CVAPI(void) cvSobel( const CvArr* src, CvArr* dst,
- int xorder, int yorder,
- int aperture_size CV_DEFAULT(3));
-
-/** @brief Calculates the image Laplacian: (d2/dx + d2/dy)I
-@see cv::Laplacian
-*/
-CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst,
- int aperture_size CV_DEFAULT(3) );
-
/** @brief Converts input array pixels from one color space to another
@see cv::cvtColor
*/
@@ -218,12 +172,6 @@ CVAPI(void) cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix
int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
-/** @brief Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2)
-@see cv::getAffineTransform
-*/
-CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f * src,
- const CvPoint2D32f * dst,
- CvMat * map_matrix );
/** @brief Computes rotation_matrix matrix
@see cv::getRotationMatrix2D
@@ -253,26 +201,6 @@ CVAPI(void) cvRemap( const CvArr* src, CvArr* dst,
int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
-/** @brief Converts mapx & mapy from floating-point to integer formats for cvRemap
-@see cv::convertMaps
-*/
-CVAPI(void) cvConvertMaps( const CvArr* mapx, const CvArr* mapy,
- CvArr* mapxy, CvArr* mapalpha );
-
-/** @brief Performs forward or inverse log-polar image transform
-@see cv::warpPolar
-*/
-CVAPI(void) cvLogPolar( const CvArr* src, CvArr* dst,
- CvPoint2D32f center, double M,
- int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
-
-/** Performs forward or inverse linear-polar image transform
-@see cv::warpPolar
-*/
-CVAPI(void) cvLinearPolar( const CvArr* src, CvArr* dst,
- CvPoint2D32f center, double maxRadius,
- int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
-
/** @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
@@ -545,12 +473,6 @@ CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
CVAPI(int) cvCheckContourConvexity( const CvArr* contour );
-/** @brief Finds convexity defects for the contour
-@see cv::convexityDefects
-*/
-CVAPI(CvSeq*) cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
- CvMemStorage* storage CV_DEFAULT(NULL));
-
/** @brief Fits ellipse into a set of 2d points
@see cv::fitEllipse
*/
@@ -778,20 +700,6 @@ CVAPI(void) cvCalcArrBackProjectPatch( CvArr** image, CvArr* dst, CvSize range,
cvCalcArrBackProjectPatch( (CvArr**)image, dst, range, hist, method, factor )
-/** @brief Divides one histogram by another.
-
-The function calculates the object probability density from two histograms as:
-
-\f[\texttt{disthist} (I)= \forkthree{0}{if \(\texttt{hist1}(I)=0\)}{\texttt{scale}}{if \(\texttt{hist1}(I) \ne 0\) and \(\texttt{hist2}(I) > \texttt{hist1}(I)\)}{\frac{\texttt{hist2}(I) \cdot \texttt{scale}}{\texttt{hist1}(I)}}{if \(\texttt{hist1}(I) \ne 0\) and \(\texttt{hist2}(I) \le \texttt{hist1}(I)\)}\f]
-
-@param hist1 First histogram (the divisor).
-@param hist2 Second histogram.
-@param dst_hist Destination histogram.
-@param scale Scale factor for the destination histogram.
- */
-CVAPI(void) cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
- CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
-
/** @brief equalizes histogram of 8-bit single-channel image
@see cv::equalizeHist
*/
@@ -818,19 +726,6 @@ CVAPI(double) cvThreshold( const CvArr* src, CvArr* dst,
double threshold, double max_value,
int threshold_type );
-/** @brief Applies adaptive threshold to grayscale image.
-
- The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and
- CV_ADAPTIVE_THRESH_GAUSSIAN_C are:
- neighborhood size (3, 5, 7 etc.),
- and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...)
-@see cv::adaptiveThreshold
-*/
-CVAPI(void) cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
- int adaptive_method CV_DEFAULT(CV_ADAPTIVE_THRESH_MEAN_C),
- int threshold_type CV_DEFAULT(CV_THRESH_BINARY),
- int block_size CV_DEFAULT(3),
- double param1 CV_DEFAULT(5));
/** @brief Fills the connected component until the color difference gets large enough
@see cv::floodFill
@@ -846,11 +741,6 @@ CVAPI(void) cvFloodFill( CvArr* image, CvPoint seed_point,
* Feature detection *
\****************************************************************************************/
-/** @brief Runs canny edge detector
-@see cv::Canny
-*/
-CVAPI(void) cvCanny( const CvArr* image, CvArr* edges, double threshold1,
- double threshold2, int aperture_size CV_DEFAULT(3) );
/** @brief Calculates constraint image for corner detection
@@ -875,15 +765,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 Harris corner detector:
-
- Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel
-@see cv::cornerHarris
-*/
-CVAPI(void) cvCornerHarris( const CvArr* image, CvArr* harris_response,
- int block_size, int aperture_size CV_DEFAULT(3),
- double k CV_DEFAULT(0.04) );
-
/** @brief Adjust corner position using some sort of gradient search
@see cv::cornerSubPix
*/
@@ -891,18 +772,6 @@ CVAPI(void) cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
int count, CvSize win, CvSize zero_zone,
CvTermCriteria criteria );
-/** @brief Finds a sparse set of points within the selected region
- that seem to be easy to track
-@see cv::goodFeaturesToTrack
-*/
-CVAPI(void) cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image,
- CvArr* temp_image, CvPoint2D32f* corners,
- int* corner_count, double quality_level,
- double min_distance,
- const CvArr* mask CV_DEFAULT(NULL),
- int block_size CV_DEFAULT(3),
- int use_harris CV_DEFAULT(0),
- double k CV_DEFAULT(0.04) );
/** @brief Finds lines on binary image using one of several methods.
@@ -970,14 +839,6 @@ CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
int line_type CV_DEFAULT(8),
int shift CV_DEFAULT(0));
-/** @brief Draws a rectangle specified by a CvRect structure
-@see cv::rectangle
-*/
-CVAPI(void) cvRectangleR( CvArr* img, CvRect r,
- CvScalar color, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8),
- int shift CV_DEFAULT(0));
-
/** @brief Draws a circle with specified center and radius.
@@ -1012,12 +873,6 @@ CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
0, 360, color, thickness, line_type, shift );
}
-/** @brief Fills convex or monotonous polygon.
-@see cv::fillConvexPoly
-*/
-CVAPI(void) cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color,
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
/** @brief Fills an area bounded by one or more arbitrary polygons
@see cv::fillPoly
*/
@@ -1032,19 +887,6 @@ CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contour
int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-#define cvDrawRect cvRectangle
-#define cvDrawLine cvLine
-#define cvDrawCircle cvCircle
-#define cvDrawEllipse cvEllipse
-#define cvDrawPolyLine cvPolyLine
-
-/** @brief Clips the line segment connecting *pt1 and *pt2
- by the rectangular window
-
- (0<=xstorage;
- }
- else
- {
- ptseq = cvPointSeqFromMat( CV_SEQ_KIND_GENERIC, array, &contour_header, &block );
- }
-
- if( CV_SEQ_ELTYPE( ptseq ) != CV_32SC2 )
- CV_Error( CV_StsUnsupportedFormat, "Floating-point coordinates are not supported here" );
-
- if( CV_IS_SEQ( hull ))
- {
- int hulltype = CV_SEQ_ELTYPE( hull );
- if( hulltype != CV_SEQ_ELTYPE_PPOINT && hulltype != CV_SEQ_ELTYPE_INDEX )
- CV_Error( CV_StsUnsupportedFormat,
- "Convex hull must represented as a sequence "
- "of indices or sequence of pointers" );
- if( !storage )
- storage = hull->storage;
- }
- else
- {
- CvMat* mat = (CvMat*)hull;
-
- if( !CV_IS_MAT( hull ))
- CV_Error(CV_StsBadArg, "Convex hull is neither sequence nor matrix");
-
- if( (mat->cols != 1 && mat->rows != 1) ||
- !CV_IS_MAT_CONT(mat->type) || CV_MAT_TYPE(mat->type) != CV_32SC1 )
- CV_Error( CV_StsBadArg,
- "The matrix should be 1-dimensional and continuous array of int's" );
-
- if( mat->cols + mat->rows - 1 > ptseq->total )
- CV_Error( CV_StsBadSize, "Convex hull is larger than the point sequence" );
-
- hull = cvMakeSeqHeaderForArray(
- CV_SEQ_KIND_CURVE|CV_MAT_TYPE(mat->type)|CV_SEQ_FLAG_CLOSED,
- sizeof(hull_header), CV_ELEM_SIZE(mat->type), mat->data.ptr,
- mat->cols + mat->rows - 1, &hull_header, &hullblock );
- }
-
- is_index = CV_SEQ_ELTYPE(hull) == CV_SEQ_ELTYPE_INDEX;
-
- if( !storage )
- CV_Error( CV_StsNullPtr, "NULL storage pointer" );
-
- defects = cvCreateSeq( CV_SEQ_KIND_GENERIC, sizeof(CvSeq), sizeof(CvConvexityDefect), storage );
-
- if( ptseq->total < 4 || hull->total < 3)
- {
- //CV_ERROR( CV_StsBadSize,
- // "point seq size must be >= 4, convex hull size must be >= 3" );
- return defects;
- }
-
- /* recognize co-orientation of ptseq and its hull */
- {
- int sign = 0;
- int index1, index2, index3;
-
- if( !is_index )
- {
- CvPoint* pos = *CV_SEQ_ELEM( hull, CvPoint*, 0 );
- index1 = cvSeqElemIdx( ptseq, pos );
-
- pos = *CV_SEQ_ELEM( hull, CvPoint*, 1 );
- index2 = cvSeqElemIdx( ptseq, pos );
-
- pos = *CV_SEQ_ELEM( hull, CvPoint*, 2 );
- index3 = cvSeqElemIdx( ptseq, pos );
- }
- else
- {
- index1 = *CV_SEQ_ELEM( hull, int, 0 );
- index2 = *CV_SEQ_ELEM( hull, int, 1 );
- index3 = *CV_SEQ_ELEM( hull, int, 2 );
- }
-
- sign += (index2 > index1) ? 1 : 0;
- sign += (index3 > index2) ? 1 : 0;
- sign += (index1 > index3) ? 1 : 0;
-
- rev_orientation = (sign == 2) ? 0 : 1;
- }
-
- cvStartReadSeq( ptseq, &ptseq_reader, 0 );
- cvStartReadSeq( hull, &hull_reader, rev_orientation );
-
- if( !is_index )
- {
- hull_cur = *(CvPoint**)hull_reader.prev_elem;
- index = cvSeqElemIdx( ptseq, (char*)hull_cur, 0 );
- }
- else
- {
- index = *(int*)hull_reader.prev_elem;
- hull_cur = CV_GET_SEQ_ELEM( CvPoint, ptseq, index );
- }
- cvSetSeqReaderPos( &ptseq_reader, index );
- cvStartAppendToSeq( defects, &writer );
-
- /* cycle through ptseq and hull with computing defects */
- for( i = 0; i < hull->total; i++ )
- {
- CvConvexityDefect defect;
- int is_defect = 0;
- double dx0, dy0;
- double depth = 0, scale;
- CvPoint* hull_next;
-
- if( !is_index )
- hull_next = *(CvPoint**)hull_reader.ptr;
- else
- {
- int t = *(int*)hull_reader.ptr;
- hull_next = CV_GET_SEQ_ELEM( CvPoint, ptseq, t );
- }
- CV_Assert(hull_next != NULL && hull_cur != NULL);
-
- dx0 = (double)hull_next->x - (double)hull_cur->x;
- dy0 = (double)hull_next->y - (double)hull_cur->y;
- assert( dx0 != 0 || dy0 != 0 );
- scale = 1./std::sqrt(dx0*dx0 + dy0*dy0);
-
- defect.start = hull_cur;
- defect.end = hull_next;
-
- for(;;)
- {
- /* go through ptseq to achieve next hull point */
- CV_NEXT_SEQ_ELEM( sizeof(CvPoint), ptseq_reader );
-
- if( ptseq_reader.ptr == (schar*)hull_next )
- break;
- else
- {
- CvPoint* cur = (CvPoint*)ptseq_reader.ptr;
-
- /* compute distance from current point to hull edge */
- double dx = (double)cur->x - (double)hull_cur->x;
- double dy = (double)cur->y - (double)hull_cur->y;
-
- /* compute depth */
- double dist = fabs(-dy0*dx + dx0*dy) * scale;
-
- if( dist > depth )
- {
- depth = dist;
- defect.depth_point = cur;
- defect.depth = (float)depth;
- is_defect = 1;
- }
- }
- }
- if( is_defect )
- {
- CV_WRITE_SEQ_ELEM( defect, writer );
- }
-
- hull_cur = hull_next;
- if( rev_orientation )
- {
- CV_PREV_SEQ_ELEM( hull->elem_size, hull_reader );
- }
- else
- {
- CV_NEXT_SEQ_ELEM( hull->elem_size, hull_reader );
- }
- }
-
- return cvEndWriteSeq( &writer );
-}
-
-
CV_IMPL int
cvCheckContourConvexity( const CvArr* array )
{
diff --git a/modules/imgproc/src/corner.cpp b/modules/imgproc/src/corner.cpp
index f0ea0b5bb5..c6bfd6abe5 100644
--- a/modules/imgproc/src/corner.cpp
+++ b/modules/imgproc/src/corner.cpp
@@ -746,17 +746,6 @@ cvCornerMinEigenVal( const CvArr* srcarr, CvArr* dstarr,
cv::cornerMinEigenVal( src, dst, block_size, aperture_size, cv::BORDER_REPLICATE );
}
-CV_IMPL void
-cvCornerHarris( const CvArr* srcarr, CvArr* dstarr,
- int block_size, int aperture_size, double k )
-{
- cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
-
- CV_Assert( src.size() == dst.size() && dst.type() == CV_32FC1 );
- cv::cornerHarris( src, dst, block_size, aperture_size, k, cv::BORDER_REPLICATE );
-}
-
-
CV_IMPL void
cvCornerEigenValsAndVecs( const void* srcarr, void* dstarr,
int block_size, int aperture_size )
diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp
index 2d8b59926d..29e11561c5 100644
--- a/modules/imgproc/src/deriv.cpp
+++ b/modules/imgproc/src/deriv.cpp
@@ -875,29 +875,4 @@ void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
}
}
-/////////////////////////////////////////////////////////////////////////////////////////
-
-CV_IMPL void
-cvSobel( const void* srcarr, void* dstarr, int dx, int dy, int aperture_size )
-{
- cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
-
- CV_Assert( src.size() == dst.size() && src.channels() == dst.channels() );
-
- cv::Sobel( src, dst, dst.depth(), dx, dy, aperture_size, 1, 0, cv::BORDER_REPLICATE );
- if( CV_IS_IMAGE(srcarr) && ((IplImage*)srcarr)->origin && dy % 2 != 0 )
- dst *= -1;
-}
-
-
-CV_IMPL void
-cvLaplace( const void* srcarr, void* dstarr, int aperture_size )
-{
- cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
-
- CV_Assert( src.size() == dst.size() && src.channels() == dst.channels() );
-
- cv::Laplacian( src, dst, dst.depth(), aperture_size, 1, 0, cv::BORDER_REPLICATE );
-}
-
/* End of file. */
diff --git a/modules/imgproc/src/drawing.cpp b/modules/imgproc/src/drawing.cpp
index 2a3e717973..b7a5eb9be0 100644
--- a/modules/imgproc/src/drawing.cpp
+++ b/modules/imgproc/src/drawing.cpp
@@ -2346,24 +2346,6 @@ cvDrawContours( void* _img, CvSeq* contour,
contour0->h_next = h_next;
}
-CV_IMPL int
-cvClipLine( CvSize size, CvPoint* pt1, CvPoint* pt2 )
-{
- CV_Assert( pt1 && pt2 );
- return cv::clipLine( size, *(cv::Point*)pt1, *(cv::Point*)pt2 );
-}
-
-
-CV_IMPL int
-cvEllipse2Poly( CvPoint center, CvSize axes, int angle,
- int arc_start, int arc_end, CvPoint* _pts, int delta )
-{
- std::vector pts;
- cv::ellipse2Poly( Point(center), Size(axes), angle, arc_start, arc_end, delta, pts );
- memcpy( _pts, &pts[0], pts.size()*sizeof(_pts[0]) );
- return (int)pts.size();
-}
-
CV_IMPL CvScalar
cvColorToScalar( double packed_color, int type )
{
@@ -2463,15 +2445,6 @@ cvRectangle( CvArr* _img, CvPoint pt1, CvPoint pt2,
cv::rectangle( img, pt1, pt2, color, thickness, line_type, shift );
}
-CV_IMPL void
-cvRectangleR( CvArr* _img, CvRect rec,
- CvScalar color, int thickness,
- int line_type, int shift )
-{
- cv::Mat img = cv::cvarrToMat(_img);
- cv::rectangle( img, rec, color, thickness, line_type, shift );
-}
-
CV_IMPL void
cvCircle( CvArr* _img, CvPoint center, int radius,
CvScalar color, int thickness, int line_type, int shift )
@@ -2490,15 +2463,6 @@ cvEllipse( CvArr* _img, CvPoint center, CvSize axes,
color, thickness, line_type, shift );
}
-CV_IMPL void
-cvFillConvexPoly( CvArr* _img, const CvPoint *pts, int npts,
- CvScalar color, int line_type, int shift )
-{
- cv::Mat img = cv::cvarrToMat(_img);
- cv::fillConvexPoly( img, (const cv::Point*)pts, npts,
- color, line_type, shift );
-}
-
CV_IMPL void
cvFillPoly( CvArr* _img, CvPoint **pts, const int *npts, int ncontours,
CvScalar color, int line_type, int shift )
@@ -2546,14 +2510,4 @@ cvInitFont( CvFont *font, int font_face, double hscale, double vscale,
font->line_type = line_type;
}
-CV_IMPL void
-cvGetTextSize( const char *text, const CvFont *_font, CvSize *_size, int *_base_line )
-{
- CV_Assert(text != 0 && _font != 0);
- cv::Size size = cv::getTextSize( text, _font->font_face, (_font->hscale + _font->vscale)*0.5,
- _font->thickness, _base_line );
- if( _size )
- *_size = cvSize(size);
-}
-
/* End of file. */
diff --git a/modules/imgproc/src/featureselect.cpp b/modules/imgproc/src/featureselect.cpp
index 26c20ea832..cc3b9c0680 100644
--- a/modules/imgproc/src/featureselect.cpp
+++ b/modules/imgproc/src/featureselect.cpp
@@ -511,29 +511,6 @@ void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
Mat(corners).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);
}
-CV_IMPL void
-cvGoodFeaturesToTrack( const void* _image, void*, void*,
- CvPoint2D32f* _corners, int *_corner_count,
- double quality_level, double min_distance,
- const void* _maskImage, int block_size,
- int use_harris, double harris_k )
-{
- cv::Mat image = cv::cvarrToMat(_image), mask;
- std::vector corners;
-
- if( _maskImage )
- mask = cv::cvarrToMat(_maskImage);
-
- CV_Assert( _corners && _corner_count );
- cv::goodFeaturesToTrack( image, corners, *_corner_count, quality_level,
- min_distance, mask, block_size, use_harris != 0, harris_k );
-
- size_t i, ncorners = corners.size();
- for( i = 0; i < ncorners; i++ )
- _corners[i] = cvPoint2D32f(corners[i]);
- *_corner_count = (int)ncorners;
-}
-
void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
int maxCorners, double qualityLevel, double minDistance,
InputArray _mask, int blockSize,
diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp
index 35923b1e47..048e27aa29 100644
--- a/modules/imgproc/src/histogram.cpp
+++ b/modules/imgproc/src/histogram.cpp
@@ -3172,50 +3172,6 @@ cvCalcBayesianProb( CvHistogram** src, int count, CvHistogram** dst )
}
-CV_IMPL void
-cvCalcProbDensity( const CvHistogram* hist, const CvHistogram* hist_mask,
- CvHistogram* hist_dens, double scale )
-{
- if( scale <= 0 )
- CV_Error( CV_StsOutOfRange, "scale must be positive" );
-
- if( !CV_IS_HIST(hist) || !CV_IS_HIST(hist_mask) || !CV_IS_HIST(hist_dens) )
- CV_Error( CV_StsBadArg, "Invalid histogram pointer[s]" );
-
- {
- CvArr* arrs[] = { hist->bins, hist_mask->bins, hist_dens->bins };
- CvMatND stubs[3];
- CvNArrayIterator iterator;
-
- cvInitNArrayIterator( 3, arrs, 0, stubs, &iterator );
-
- if( CV_MAT_TYPE(iterator.hdr[0]->type) != CV_32FC1 )
- CV_Error( CV_StsUnsupportedFormat, "All histograms must have 32fC1 type" );
-
- do
- {
- const float* srcdata = (const float*)(iterator.ptr[0]);
- const float* maskdata = (const float*)(iterator.ptr[1]);
- float* dstdata = (float*)(iterator.ptr[2]);
- int i;
-
- for( i = 0; i < iterator.size.width; i++ )
- {
- float s = srcdata[i];
- float m = maskdata[i];
- if( s > FLT_EPSILON )
- if( m <= s )
- dstdata[i] = (float)(m*scale/s);
- else
- dstdata[i] = (float)scale;
- else
- dstdata[i] = (float)0;
- }
- }
- while( cvNextNArraySlice( &iterator ));
- }
-}
-
class EqualizeHistCalcHist_Invoker : public cv::ParallelLoopBody
{
public:
diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp
index 2362380cc6..9401bd5831 100644
--- a/modules/imgproc/src/imgwarp.cpp
+++ b/modules/imgproc/src/imgwarp.cpp
@@ -3462,36 +3462,6 @@ cvGetPerspectiveTransform( const CvPoint2D32f* src,
}
-CV_IMPL CvMat*
-cvGetAffineTransform( const CvPoint2D32f* src,
- const CvPoint2D32f* dst,
- CvMat* matrix )
-{
- cv::Mat M0 = cv::cvarrToMat(matrix),
- M = cv::getAffineTransform((const cv::Point2f*)src, (const cv::Point2f*)dst);
- CV_Assert( M.size() == M0.size() );
- M.convertTo(M0, M0.type());
- return matrix;
-}
-
-
-CV_IMPL void
-cvConvertMaps( const CvArr* arr1, const CvArr* arr2, CvArr* dstarr1, CvArr* dstarr2 )
-{
- cv::Mat map1 = cv::cvarrToMat(arr1), map2;
- cv::Mat dstmap1 = cv::cvarrToMat(dstarr1), dstmap2;
-
- if( arr2 )
- map2 = cv::cvarrToMat(arr2);
- if( dstarr2 )
- {
- dstmap2 = cv::cvarrToMat(dstarr2);
- if( dstmap2.type() == CV_16SC1 )
- dstmap2 = cv::Mat(dstmap2.size(), CV_16UC1, dstmap2.ptr(), dstmap2.step);
- }
-
- cv::convertMaps( map1, map2, dstmap1, dstmap2, dstmap1.type(), false );
-}
/****************************************************************************************
PkLab.net 2018 based on cv::linearPolar from OpenCV by J.L. Blanco, Apr 2009
@@ -3627,30 +3597,4 @@ void cv::logPolar( InputArray _src, OutputArray _dst,
warpPolar(_src, _dst, ssize, center, M, flags | WARP_POLAR_LOG);
}
-CV_IMPL
-void cvLinearPolar( const CvArr* srcarr, CvArr* dstarr,
- CvPoint2D32f center, double maxRadius, int flags )
-{
- Mat src = cvarrToMat(srcarr);
- Mat dst = cvarrToMat(dstarr);
-
- CV_Assert(src.size == dst.size);
- CV_Assert(src.type() == dst.type());
-
- cv::linearPolar(src, dst, center, maxRadius, flags);
-}
-
-CV_IMPL
-void cvLogPolar( const CvArr* srcarr, CvArr* dstarr,
- CvPoint2D32f center, double M, int flags )
-{
- Mat src = cvarrToMat(srcarr);
- Mat dst = cvarrToMat(dstarr);
-
- CV_Assert(src.size == dst.size);
- CV_Assert(src.type() == dst.type());
-
- cv::logPolar(src, dst, center, M, flags);
-}
-
/* End of file. */
diff --git a/modules/imgproc/src/pyramids.cpp b/modules/imgproc/src/pyramids.cpp
index 2fa8537c36..2625533f76 100644
--- a/modules/imgproc/src/pyramids.cpp
+++ b/modules/imgproc/src/pyramids.cpp
@@ -1566,96 +1566,4 @@ CV_IMPL void cvPyrUp( const void* srcarr, void* dstarr, int _filter )
cv::pyrUp( src, dst, dst.size() );
}
-
-CV_IMPL void
-cvReleasePyramid( CvMat*** _pyramid, int extra_layers )
-{
- if( !_pyramid )
- CV_Error( CV_StsNullPtr, "" );
-
- if( *_pyramid )
- for( int i = 0; i <= extra_layers; i++ )
- cvReleaseMat( &(*_pyramid)[i] );
-
- cvFree( _pyramid );
-}
-
-
-CV_IMPL CvMat**
-cvCreatePyramid( const CvArr* srcarr, int extra_layers, double rate,
- const CvSize* layer_sizes, CvArr* bufarr,
- int calc, int filter )
-{
- const float eps = 0.1f;
- uchar* ptr = 0;
-
- CvMat stub, *src = cvGetMat( srcarr, &stub );
-
- if( extra_layers < 0 )
- CV_Error( CV_StsOutOfRange, "The number of extra layers must be non negative" );
-
- int i, layer_step, elem_size = CV_ELEM_SIZE(src->type);
- cv::Size layer_size, size = cvGetMatSize(src);
-
- if( bufarr )
- {
- CvMat bstub, *buf;
- int bufsize = 0;
-
- buf = cvGetMat( bufarr, &bstub );
- bufsize = buf->rows*buf->cols*CV_ELEM_SIZE(buf->type);
- layer_size = size;
- for( i = 1; i <= extra_layers; i++ )
- {
- if( !layer_sizes )
- {
- layer_size.width = cvRound(layer_size.width*rate+eps);
- layer_size.height = cvRound(layer_size.height*rate+eps);
- }
- else
- layer_size = layer_sizes[i-1];
- layer_step = layer_size.width*elem_size;
- bufsize -= layer_step*layer_size.height;
- }
-
- if( bufsize < 0 )
- CV_Error( CV_StsOutOfRange, "The buffer is too small to fit the pyramid" );
- ptr = buf->data.ptr;
- }
-
- CvMat** pyramid = (CvMat**)cvAlloc( (extra_layers+1)*sizeof(pyramid[0]) );
- memset( pyramid, 0, (extra_layers+1)*sizeof(pyramid[0]) );
-
- pyramid[0] = cvCreateMatHeader( size.height, size.width, src->type );
- cvSetData( pyramid[0], src->data.ptr, src->step );
- layer_size = size;
-
- for( i = 1; i <= extra_layers; i++ )
- {
- if( !layer_sizes )
- {
- layer_size.width = cvRound(layer_size.width*rate + eps);
- layer_size.height = cvRound(layer_size.height*rate + eps);
- }
- else
- layer_size = layer_sizes[i];
-
- if( bufarr )
- {
- pyramid[i] = cvCreateMatHeader( layer_size.height, layer_size.width, src->type );
- layer_step = layer_size.width*elem_size;
- cvSetData( pyramid[i], ptr, layer_step );
- ptr += layer_step*layer_size.height;
- }
- else
- pyramid[i] = cvCreateMat( layer_size.height, layer_size.width, src->type );
-
- if( calc )
- cvPyrDown( pyramid[i-1], pyramid[i], filter );
- //cvResize( pyramid[i-1], pyramid[i], CV_INTER_LINEAR );
- }
-
- return pyramid;
-}
-
/* End of file. */
diff --git a/modules/imgproc/src/segmentation.cpp b/modules/imgproc/src/segmentation.cpp
index c78931221f..e4896fbce0 100644
--- a/modules/imgproc/src/segmentation.cpp
+++ b/modules/imgproc/src/segmentation.cpp
@@ -546,24 +546,3 @@ void cv::pyrMeanShiftFiltering( InputArray _src, OutputArray _dst,
}
}
}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-CV_IMPL void cvWatershed( const CvArr* _src, CvArr* _markers )
-{
- cv::Mat src = cv::cvarrToMat(_src), markers = cv::cvarrToMat(_markers);
- cv::watershed(src, markers);
-}
-
-
-CV_IMPL void
-cvPyrMeanShiftFiltering( const CvArr* srcarr, CvArr* dstarr,
- double sp0, double sr, int max_level,
- CvTermCriteria termcrit )
-{
- cv::Mat src = cv::cvarrToMat(srcarr);
- const cv::Mat dst = cv::cvarrToMat(dstarr);
-
- cv::pyrMeanShiftFiltering(src, dst, sp0, sr, max_level, termcrit);
-}
diff --git a/modules/imgproc/src/thresh.cpp b/modules/imgproc/src/thresh.cpp
index 7cd8ff0b22..83c290da6b 100644
--- a/modules/imgproc/src/thresh.cpp
+++ b/modules/imgproc/src/thresh.cpp
@@ -1753,14 +1753,4 @@ cvThreshold( const void* srcarr, void* dstarr, double thresh, double maxval, int
return thresh;
}
-
-CV_IMPL void
-cvAdaptiveThreshold( const void *srcIm, void *dstIm, double maxValue,
- int method, int type, int blockSize, double delta )
-{
- cv::Mat src = cv::cvarrToMat(srcIm), dst = cv::cvarrToMat(dstIm);
- CV_Assert( src.size == dst.size && src.type() == dst.type() );
- cv::adaptiveThreshold( src, dst, maxValue, method, type, blockSize, delta );
-}
-
/* End of file. */
diff --git a/modules/imgproc/src/utils.cpp b/modules/imgproc/src/utils.cpp
index 4f45cde5e0..b0dc1b7dbb 100644
--- a/modules/imgproc/src/utils.cpp
+++ b/modules/imgproc/src/utils.cpp
@@ -75,16 +75,4 @@ CV_IMPL CvSeq* cvPointSeqFromMat( int seq_kind, const CvArr* arr,
return (CvSeq*)contour_header;
}
-CV_IMPL void
-cvCopyMakeBorder( const CvArr* srcarr, CvArr* dstarr, CvPoint offset,
- int borderType, CvScalar value )
-{
- cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
- int left = offset.x, right = dst.cols - src.cols - left;
- int top = offset.y, bottom = dst.rows - src.rows - top;
-
- CV_Assert( dst.type() == src.type() );
- cv::copyMakeBorder( src, dst, top, bottom, left, right, borderType, value );
-}
-
/* End of file. */
diff --git a/modules/videoio/include/opencv2/videoio/videoio_c.h b/modules/videoio/include/opencv2/videoio/videoio_c.h
index cf1a6d0411..367a1592d0 100644
--- a/modules/videoio/include/opencv2/videoio/videoio_c.h
+++ b/modules/videoio/include/opencv2/videoio/videoio_c.h
@@ -65,18 +65,6 @@ In C++ use cv::VideoCapture
*/
typedef struct CvCapture CvCapture;
-/** @brief start capturing frames from video file
-*/
-CVAPI(CvCapture*) cvCreateFileCapture( const char* filename );
-
-/** @brief start capturing frames from video file. allows specifying a preferred API to use
-*/
-CVAPI(CvCapture*) cvCreateFileCaptureWithPreference( const char* filename , int apiPreference);
-
-/** @brief start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*)
-*/
-CVAPI(CvCapture*) cvCreateCameraCapture( int index );
-
/** @brief grab a frame, return 1 on success, 0 on fail.
this function is thought to be fast
@@ -108,12 +96,6 @@ CVAPI(double) cvGetCaptureProperty( CvCapture* capture, int property_id );
*/
CVAPI(int) cvSetCaptureProperty( CvCapture* capture, int property_id, double value );
-/** @brief Return the type of the capturer (eg, ::CV_CAP_VFW, ::CV_CAP_UNICAP)
-
-It is unknown if created with ::CV_CAP_ANY
-*/
-CVAPI(int) cvGetCaptureDomain( CvCapture* capture);
-
/** @brief "black box" video file writer structure
In C++ use cv::VideoWriter
@@ -134,16 +116,6 @@ CVAPI(int) cvWriteFrame( CvVideoWriter* writer, const IplImage* image );
*/
CVAPI(void) cvReleaseVideoWriter( CvVideoWriter** writer );
-// ***************************************************************************************
-//! @name Obsolete functions/synonyms
-//! @{
-#define cvCaptureFromCAM cvCreateCameraCapture //!< @deprecated use cvCreateCameraCapture() instead
-#define cvCaptureFromFile cvCreateFileCapture //!< @deprecated use cvCreateFileCapture() instead
-#define cvCaptureFromAVI cvCaptureFromFile //!< @deprecated use cvCreateFileCapture() instead
-#define cvCreateAVIWriter cvCreateVideoWriter //!< @deprecated use cvCreateVideoWriter() instead
-#define cvWriteToAVI cvWriteFrame //!< @deprecated use cvWriteFrame() instead
-//! @} Obsolete...
-
//! @} videoio_c
#ifdef __cplusplus
diff --git a/modules/videoio/src/videoio_c.cpp b/modules/videoio/src/videoio_c.cpp
index 72e65a7999..2a10a85b8e 100644
--- a/modules/videoio/src/videoio_c.cpp
+++ b/modules/videoio/src/videoio_c.cpp
@@ -10,29 +10,6 @@ using namespace cv;
// Legacy C-like API
-CV_IMPL CvCapture* cvCreateCameraCapture(int)
-{
- CV_LOG_WARNING(NULL, "cvCreateCameraCapture doesn't support legacy API anymore.")
- return NULL;
-}
-
-CV_IMPL CvCapture* cvCreateFileCaptureWithPreference(const char*, int)
-{
- CV_LOG_WARNING(NULL, "cvCreateFileCaptureWithPreference doesn't support legacy API anymore.")
- return NULL;
-}
-
-CV_IMPL CvCapture* cvCreateFileCapture(const char * filename)
-{
- return cvCreateFileCaptureWithPreference(filename, CAP_ANY);
-}
-
-CV_IMPL CvVideoWriter* cvCreateVideoWriter(const char*, int, double, CvSize, int)
-{
- CV_LOG_WARNING(NULL, "cvCreateVideoWriter doesn't support legacy API anymore.")
- return NULL;
-}
-
CV_IMPL int cvWriteFrame(CvVideoWriter* writer, const IplImage* image)
{
return writer ? writer->writeFrame(image) : 0;
@@ -84,8 +61,3 @@ CV_IMPL int cvSetCaptureProperty(CvCapture* capture, int id, double value)
{
return capture ? capture->setProperty(id, value) : 0;
}
-
-CV_IMPL int cvGetCaptureDomain(CvCapture* capture)
-{
- return capture ? capture->getCaptureDomain() : 0;
-}