potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-31 08:13:04 +04:00
Code Packages Releases Wiki Activity

Clean up C API

Browse Source
This commit is contained in:
Suleyman TURKMEN
2021-03-03 00:26:50 +03:00
parent 178240ccf1
commit 703dea4817
23 changed files with 0 additions and 2351 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/core/include/opencv2/core/core_c.h
-807
View File
@@ -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}
<opencv_storage>
<!-- stream #1 data -->
</opencv_storage>
<opencv_storage>
<!-- stream #2 data -->
</opencv_storage>
...
@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<double>* 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 //////