CV_FUNCNAME( "icvFSCreateCollection" );
__BEGIN__;
-
+
if( CV_NODE_IS_MAP(tag) )
{
if( collection->tag != CV_NODE_NONE )
{
CvSeq* seq;
CV_CALL( seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvFileNode), fs->memstorage ));
-
+
// if <collection> contains some scalar element, add it to the newly created collection
if( CV_NODE_TYPE(collection->tag) != CV_NODE_NONE )
cvSeqPush( seq, collection );
for( i = 0; i < total; i++ )
{
CvFileNode* node = (CvFileNode*)reader.ptr;
-
+
if( (!is_map || CV_IS_SET_ELEM( node )) && CV_NODE_IS_COLLECTION(node->tag) )
{
if( CV_NODE_IS_USER(node->tag) && node->info && node->data.obj.decoded )
CV_FUNCNAME( "icvFSDoResize" );
__BEGIN__;
-
+
int written_len = (int)(ptr - fs->buffer_start);
int new_size = (int)((fs->buffer_end - fs->buffer_start)*3/2);
new_size = MAX( written_len + len, new_size );
CV_FUNCNAME( "cvGetHashedKey" );
__BEGIN__;
-
+
unsigned hashval = 0;
int i, tab_size;
CvStringHash* map = fs->str_hash;
int create_missing )
{
CvFileNode* value = 0;
-
+
CV_FUNCNAME( "cvGetFileNode" );
__BEGIN__;
if( !fs->roots )
EXIT;
attempts = fs->roots->total;
- }
+ }
for( k = 0; k < attempts; k++ )
{
if( !fs->roots )
EXIT;
attempts = fs->roots->total;
- }
+ }
for( k = 0; k < attempts; k++ )
{
CvFileNode* seq_node, int index )
{
CvFileNode* value = 0;
-
+
CV_FUNCNAME( "cvGetFileNodeFromSeq" );
__BEGIN__;
}
else
seq = seq_node->data.seq;
-
+
if( !seq )
CV_ERROR( CV_StsNullPtr, "The file storage is empty" );
CV_FUNCNAME( "icvProcessSpecialDouble" );
__BEGIN__;
-
+
char c = buf[0];
int inf_hi = 0x7ff00000;
-
+
if( c == '-' || c == '+' )
{
inf_hi = c == '-' ? 0xfff00000 : 0x7ff00000;
c = *++buf;
}
-
+
if( c != '.' )
CV_PARSE_ERROR( "Bad format of floating-point constant" );
CV_FUNCNAME( "icvYMLSkipSpaces" );
__BEGIN__;
-
+
for(;;)
{
while( *ptr == ' ' )
fs->lineno++;
}
else
- CV_PARSE_ERROR( *ptr == '\t' ? "Tabs are prohibited in YAML!" : "Invalid character" );
+ CV_PARSE_ERROR( *ptr == '\t' ? "Tabs are prohibited in YAML!" : "Invalid character" );
}
__END__;
CvFileNode* map_node, CvFileNode** value_placeholder )
{
CV_FUNCNAME( "icvYMLParseKey" );
-
+
__BEGIN__;
char c;
++endptr;
if( endptr == ptr )
CV_PARSE_ERROR( "An empty key" );
-
+
CV_CALL( str_hash_node = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 ));
CV_CALL( *value_placeholder = cvGetFileNode( fs, map_node, str_hash_node, 1 ));
ptr = saveptr;
int parent_flags, int min_indent )
{
CV_FUNCNAME( "icvYMLParseValue" );
-
+
__BEGIN__;
char buf[CV_FS_MAX_LEN + 1024];
CV_PARSE_ERROR( "Empty type name" );
d = *endptr;
*endptr = '\0';
-
+
if( len == 3 && !CV_NODE_IS_USER(value_type) )
{
if( memcmp( ptr, "str", 3 ) == 0 )
*endptr = d;
CV_CALL( ptr = icvYMLSkipSpaces( fs, endptr, min_indent, INT_MAX ));
-
+
c = *ptr;
if( !CV_NODE_IS_USER(value_type) )
int new_min_indent = min_indent + !is_parent_flow;
int struct_flags = CV_NODE_FLOW + (c == '{' ? CV_NODE_MAP : CV_NODE_SEQ);
int is_simple = 1;
-
+
CV_CALL( icvFSCreateCollection( fs, CV_NODE_TYPE(struct_flags) +
(node->info ? CV_NODE_USER : 0), node ));
else
{
int indent, struct_flags, is_simple;
-
+
if( is_parent_flow || c != '-' )
{
// implicit (one-line) string or nested block-style collection
CV_CALL( icvFSCreateCollection( fs, struct_flags +
(node->info ? CV_NODE_USER : 0), node ));
-
+
indent = (int)(ptr - fs->buffer_start);
is_simple = 1;
for(;;)
{
CvFileNode* elem = 0;
-
+
if( CV_NODE_IS_MAP(struct_flags) )
{
CV_CALL( ptr = icvYMLParseKey( fs, ptr, node, &elem ));
CV_CALL( ptr = icvYMLParseValue( fs, ptr, root_node, CV_NODE_NONE, 0 ));
if( !CV_NODE_IS_COLLECTION(root_node->tag) )
CV_PARSE_ERROR( "Only collections as YAML streams are supported by this parser" );
-
+
// 3. parse until the end of file or next collection
CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
if( !ptr )
//CV_FUNCNAME( "icvYMLWrite" );
__BEGIN__;
-
+
int i, keylen = 0;
int datalen = 0;
int struct_flags;
{
if( !isalpha(key[0]) && key[0] != '_' )
CV_ERROR( CV_StsBadArg, "Key must start with a letter or _" );
-
+
ptr = icvFSResizeWriteBuffer( fs, ptr, keylen );
for( i = 0; i < keylen; i++ )
{
int c = key[i];
-
+
ptr[i] = (char)c;
if( !isalnum(c) && c != '-' && c != '_' && c != ' ' )
CV_ERROR( CV_StsBadArg, "Invalid character occurs in the key" );
if( !CV_NODE_IS_FLOW(parent_flags) )
fs->struct_indent += CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
- __END__;
+ __END__;
}
CV_FUNCNAME( "icvYMLWriteInt" );
__BEGIN__;
-
+
char buf[128];
CV_CALL( icvYMLWrite( fs, key, icv_itoa( value, buf, 10 ), cvFuncName ));
-
- __END__;
+
+ __END__;
}
CV_FUNCNAME( "icvYMLWriteReal" );
__BEGIN__;
-
+
char buf[128];
CV_CALL( icvYMLWrite( fs, key, icvDoubleToString( buf, value ), cvFuncName ));
-
- __END__;
+
+ __END__;
}
for( i = 0; i < len; i++ )
{
char c = str[i];
-
+
if( !need_quote && !isalnum(c) && c != '_' && c != ' ' && c != '-' &&
c != '(' && c != ')' && c != '/' && c != '+' && c != ';' )
need_quote = 1;
}
ptr = icvFSFlush( fs );
}
-
+
__END__;
}
{
char c;
ptr--;
-
+
if( mode == CV_XML_INSIDE_COMMENT )
{
do c = *++ptr;
while( cv_isprint_or_tab(c) && (c != '-' || ptr[1] != '-' || ptr[2] != '>') );
-
+
if( c == '-' )
{
assert( ptr[1] == '-' && ptr[2] == '>' );
else if( cv_isprint(c) )
break;
}
-
+
if( !cv_isprint(*ptr) )
{
int max_size = (int)(fs->buffer_end - fs->buffer_start);
int value_type CV_DEFAULT(CV_NODE_NONE))
{
CV_FUNCNAME( "icvXMLParseValue" );
-
+
__BEGIN__;
CvFileNode *elem = node;
memset( node, 0, sizeof(*node) );
value_type = CV_NODE_TYPE(value_type);
-
+
for(;;)
{
char c = *ptr, d;
}
else if( is_noname ^ CV_NODE_IS_SEQ(node->tag) )
CV_PARSE_ERROR( is_noname ? "Map element should have a name" :
- "Sequence element should not have name (use <_></_>)" );
+ "Sequence element should not have name (use <_></_>)" );
if( is_noname )
elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
else
CV_CALL( elem = cvGetFileNode( fs, node, key, 1 ));
-
+
CV_CALL( ptr = icvXMLParseValue( fs, ptr, elem, elem_type));
if( !is_noname )
elem->tag |= CV_NODE_NAMED;
{
if( !have_space )
CV_PARSE_ERROR( "There should be space between literals" );
-
+
elem = node;
if( node->tag != CV_NODE_NONE )
{
CvAttrList *first = 0, *last = 0;
int count = 0, max_count = 4;
int attr_buf_size = (max_count*2 + 1)*sizeof(char*) + sizeof(CvAttrList);
-
+
CV_FUNCNAME( "icvXMLParseTag" );
__BEGIN__;
for(;;)
{
CvStringHashNode* attrname;
-
+
if( !isalpha(*ptr) && *ptr != '_' )
CV_PARSE_ERROR( "Name should start with a letter or underscore" );
if( !last || count >= max_count )
{
CvAttrList* chunk;
-
+
CV_CALL( chunk = (CvAttrList*)cvMemStorageAlloc( fs->memstorage, attr_buf_size ));
memset( chunk, 0, attr_buf_size );
chunk->attr = (const char**)(chunk + 1);
if( last )
{
CvFileNode stub;
-
+
if( *ptr != '=' )
{
CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
last->attr[count*2+1] = stub.data.str.ptr;
count++;
}
-
+
c = *ptr;
have_space = isspace(c) || c == '\0';
ptr = icvXMLFlush(fs);
}
- if( !key )
+ if( !key )
key = "_";
else if( key[0] == '_' && key[1] == '\0' )
CV_ERROR( CV_StsBadArg, "A single _ is a reserved tag name" );
CV_ERROR( CV_StsBadArg, "Closing tag should not include any attributes" );
*ptr++ = '/';
}
-
+
if( !isalpha(key[0]) && key[0] != '_' )
CV_ERROR( CV_StsBadArg, "Key should start with a letter or _" );
-
+
ptr = icvFSResizeWriteBuffer( fs, ptr, len );
for( i = 0; i < len; i++ )
{
for(;;)
{
const char** attr = list.attr;
-
+
for( ; attr && attr[0] != 0; attr += 2 )
{
int len0 = (int)strlen(attr[0]);
fs->struct_tag.len = 0;
}
- __END__;
+ __END__;
}
}
else if( ptr > fs->buffer_start + fs->struct_indent && ptr[-1] != '>' )
*ptr++ = ' ';
-
+
memcpy( ptr, data, len );
fs->buffer = ptr + len;
}
//CV_FUNCNAME( "cvXMLWriteInt" );
__BEGIN__;
-
+
char buf[128], *ptr = icv_itoa( value, buf, 10 );
int len = (int)strlen(ptr);
icvXMLWriteScalar( fs, key, ptr, len );
-
- __END__;
+
+ __END__;
}
//CV_FUNCNAME( "cvXMLWriteReal" );
__BEGIN__;
-
+
char buf[128];
int len = (int)strlen( icvDoubleToString( buf, value ));
icvXMLWriteScalar( fs, key, buf, len );
-
- __END__;
+
+ __END__;
}
for( i = 0; i < len; i++ )
{
char c = str[i];
-
+
if( !isalnum(c) && (!cv_isprint(c) || c == '<' || c == '>' ||
c == '&' || c == '\'' || c == '\"') )
{
fs->buffer = ptr + 3;
icvXMLFlush( fs );
}
-
+
__END__;
}
char buf[16];
fgets( buf, sizeof(buf)-2, fs->file );
fs->is_xml = strncmp( buf, yaml_signature, strlen(yaml_signature) ) != 0;
-
+
fseek( fs->file, 0, SEEK_END );
buf_size = ftell( fs->file );
fseek( fs->file, 0, SEEK_SET );
buf_size = MIN( buf_size, (1 << 20) );
buf_size = MAX( buf_size, CV_FS_MAX_LEN*2 + 1024 );
-
+
CV_CALL( fs->str_hash = cvCreateMap( 0, sizeof(CvStringHash),
sizeof(CvStringHashNode), fs->memstorage, 256 ));
-
+
CV_CALL( fs->roots = cvCreateSeq( 0, sizeof(CvSeq),
sizeof(CvFileNode), fs->memstorage ));
static const char icvTypeSymbol[] = "ucwsifdr";
-#define CV_FS_MAX_FMT_PAIRS 128
+#define CV_FS_MAX_FMT_PAIRS 128
static char*
icvEncodeFormat( int elem_type, char* dt )
__BEGIN__;
int i = 0, k = 0, len = dt ? (int)strlen(dt) : 0;
-
+
if( !dt || !len )
EXIT;
for( ; k < len; k++ )
{
char c = dt[k];
-
+
if( isdigit(c) )
{
int count = c - '0';
int elem_type = fmt_pairs[k*2+1];
int elem_size = CV_ELEM_SIZE(elem_type);
const char* data, *ptr;
-
+
offset = cvAlign( offset, elem_size );
data = data0 + offset;
if( !src || !reader )
CV_ERROR( CV_StsNullPtr, "Null pointer to source file node or reader" );
-
+
node_type = CV_NODE_TYPE(src->tag);
if( node_type == CV_NODE_INT || node_type == CV_NODE_REAL )
{
// emulate reading from 1-element sequence
- reader->ptr = (char*)src;
+ reader->ptr = (schar*)src;
reader->block_max = reader->ptr + sizeof(*src)*2;
reader->block_min = reader->ptr;
reader->seq = 0;
EXIT;
}
}
- else if( CV_NODE_IS_REAL(node->tag) )
+ else if( CV_NODE_IS_REAL(node->tag) )
{
double fval = node->data.f;
int ival;
else
CV_ERROR( CV_StsError,
"The sequence element is not a numerical scalar" );
-
+
CV_NEXT_SEQ_ELEM( sizeof(CvFileNode), *reader );
if( !--len )
goto end_loop;
CV_CALL( cvStartReadRawData( fs, src, &reader ));
cvReadRawDataSlice( fs, &reader, CV_NODE_IS_SEQ(src->tag) ?
src->data.seq->total : 1, data, dt );
-
+
__END__;
}
CV_FUNCNAME( "icvWriteFileNode" );
__BEGIN__;
-
+
switch( CV_NODE_TYPE(node->tag) )
{
case CV_NODE_INT:
const CvFileNode* node, int embed )
{
CvFileStorage* dst = 0;
-
+
CV_FUNCNAME( "cvWriteFileNode" );
-
+
__BEGIN__;
CV_CHECK_OUTPUT_FILE_STORAGE(fs);
cvWriteInt( fs, "cols", mat->cols );
cvWriteString( fs, "dt", icvEncodeFormat( CV_MAT_TYPE(mat->type), dt ), 0 );
cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
-
+
size = cvGetSize(mat);
if( CV_IS_MAT_CONT(mat->type) )
{
cvEndWriteStruct( fs );
cvWriteString( fs, "dt", icvEncodeFormat( cvGetElemType(mat), dt ), 0 );
cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
-
+
CV_CALL( cvInitNArrayIterator( 1, &mat, 0, &stub, &iterator ));
do
const void* struct_ptr, CvAttrList /*attr*/ )
{
CvMemStorage* memstorage = 0;
-
+
CV_FUNCNAME( "icvWriteSparseMat" );
__BEGIN__;
node = cvGetNextSparseNode( &iterator );
}
- cvSeqSort( elements, icvSortIdxCmpFunc, &dims );
+ cvSeqSort( elements, icvSortIdxCmpFunc, &dims );
cvStartReadSeq( elements, &reader, 0 );
for( i = 0; i < elements->total; i++ )
for( ; idx[k] == prev_idx[k]; k++ )
assert( k < dims );
if( k < dims - 1 )
- fs->write_int( fs, 0, k - dims + 1 );
+ fs->write_int( fs, 0, k - dims + 1 );
}
for( ; k < dims; k++ )
fs->write_int( fs, 0, idx[k] );
{
CvFileNode* elem = (CvFileNode*)reader.ptr;
uchar* val;
- int k;
+ int k;
if( !CV_NODE_IS_INT(elem->tag ))
CV_ERROR( CV_StsParseError, "Sparse matrix data is corrupted" );
k = elem->data.i;
char header_dt_buf[128];
const char* header_dt = cvAttrValue( attr, "header_dt" );
-
+
if( header_dt )
{
int dt_header_size;
seq->elem_size == sizeof(int)*2 )
{
CvPoint2DSeq* point_seq = (CvPoint2DSeq*)seq;
-
+
cvStartWriteStruct( fs, "rect", CV_NODE_MAP + CV_NODE_FLOW );
cvWriteInt( fs, "x", point_seq->rect.x );
cvWriteInt( fs, "y", point_seq->rect.y );
CV_MAT_TYPE(seq->flags) == CV_8UC1 )
{
CvChain* chain = (CvChain*)seq;
-
+
cvStartWriteStruct( fs, "origin", CV_NODE_MAP + CV_NODE_FLOW );
cvWriteInt( fs, "x", chain->origin.x );
cvWriteInt( fs, "y", chain->origin.y );
cvWriteRawData( fs, (uchar*)seq + sizeof(CvSeq), 1, header_dt );
cvEndWriteStruct( fs );
}
-
+
__END__;
}
int initial_elem_size, char* dt_buf )
{
char* dt = 0;
-
+
CV_FUNCNAME( "icvWriteFormat" );
__BEGIN__;
if( level >= 0 )
cvWriteInt( fs, "level", level );
-
+
sprintf( buf, "%08x", seq->flags );
cvWriteString( fs, "flags", buf, 1 );
cvWriteInt( fs, "count", seq->total );
CV_CALL( icvWriteHeaderData( fs, seq, &attr, sizeof(CvSeq) ));
cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
-
+
for( block = seq->first; block; block = block->next )
{
cvWriteRawData( fs, block->data, block->count, dt );
CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ_TREE ));
CV_CALL( cvStartWriteStruct( fs, "sequences", CV_NODE_SEQ ));
cvInitTreeNodeIterator( &tree_iterator, seq, INT_MAX );
-
+
for(;;)
{
if( !tree_iterator.node )
}
CV_NEXT_SEQ_ELEM( graph->elem_size, reader );
}
-
+
// write header
CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_GRAPH ));
-
+
sprintf( buf, "%08x", graph->flags );
cvWriteString( fs, "flags", buf, 1 );
sprintf( edge_dt_buf, "2if%s", edge_dt ? edge_dt : "" );
edge_dt = edge_dt_buf;
cvWriteString( fs, "edge_dt", edge_dt, 0 );
-
+
CV_CALL( icvWriteHeaderData( fs, (CvSeq*)graph, &attr, sizeof(CvGraph) ));
write_buf_size = MAX( 3*graph->elem_size, 1 << 16 );
int write_elem_size = icvCalcElemSize( dt, 0 );
char* src_ptr = write_buf;
int write_max = write_buf_size / write_elem_size, write_count = 0;
-
+
// alignment of user part of the edge data following 2if
int edge_user_align = sizeof(float);
-
+
if( k == 1 )
{
int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
CV_CALL( edge_size = icvCalcElemSize( dst_edge_dt, sizeof(CvGraphEdge) ));
CV_CALL( src_edge_size = icvCalcElemSize( edge_dt, 0 ));
}
-
+
CV_CALL( graph = cvCreateGraph( flags, header_size, vtx_size, edge_size, fs->dststorage ));
if( header_node )
read_buf_size = MAX( src_edge_size*3, read_buf_size );
CV_CALL( read_buf = (char*)cvAlloc( read_buf_size ));
CV_CALL( vtx_buf = (CvGraphVtx**)cvAlloc( vtx_count * sizeof(vtx_buf[0]) ));
-
+
vtx_node = cvGetFileNodeByName( fs, node, "vertices" );
edge_node = cvGetFileNodeByName( fs, node, "edges" );
if( !edge_node )
CV_ERROR( CV_StsBadArg, "No edges data" );
if( vtx_dt && !vtx_node )
CV_ERROR( CV_StsBadArg, "No vertices data" );
-
+
// as vertices and edges are read in similar way,
// do it as a parametrized 2-iteration loop
for( k = 0; k < 2; k++ )
CvType sparse_mat_type( CV_TYPE_NAME_SPARSE_MAT, icvIsSparseMat,
(CvReleaseFunc)cvReleaseSparseMat, icvReadSparseMat,
icvWriteSparseMat, (CvCloneFunc)cvCloneSparseMat );
-
+
CvType image_type( CV_TYPE_NAME_IMAGE, icvIsImage, (CvReleaseFunc)cvReleaseImage,
icvReadImage, icvWriteImage, (CvCloneFunc)cvCloneImage );
CvType mat_type( CV_TYPE_NAME_MAT, icvIsMat, (CvReleaseFunc)cvReleaseMat,
icvReadMat, icvWriteMat, (CvCloneFunc)cvCloneMat );
-
+
CvType matnd_type( CV_TYPE_NAME_MATND, icvIsMatND, (CvReleaseFunc)cvReleaseMatND,
icvReadMatND, icvWriteMatND, (CvCloneFunc)cvCloneMatND );
CvTypeInfo* info = 0;
int i, len;
char c;
-
+
//if( !CvType::first )
// icvCreateStandardTypes();
cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* list )
{
void* obj = 0;
-
+
CV_FUNCNAME( "cvRead" );
__BEGIN__;
const char* _name, const char* comment, CvAttrList attributes )
{
CvFileStorage* fs = 0;
-
+
CV_FUNCNAME( "cvSave" );
__BEGIN__;
static const char* stubname = "unnamed";
const char* ptr2 = filename + strlen( filename );
const char* ptr = ptr2 - 1;
-
+
while( ptr >= filename && *ptr != '\\' && *ptr != '/' && *ptr != ':' )
{
if( *ptr == '.' && !*ptr2 )
ptr++;
if( ptr == ptr2 )
CV_ERROR( CV_StsBadArg, "Invalid filename" );
-
+
name=name_buf;
// name must start with letter or '_'
CvFileNode* node = 0;
CV_CALL( fs = cvOpenFileStorage( filename, memstorage, CV_STORAGE_READ ));
-
+
if( !fs )
EXIT;
{
CvSeq* seq;
CvSeqReader reader;
-
+
node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
if( !CV_NODE_IS_MAP( node->tag ))
EXIT;
projects / opencv / blobdiff