Lines Matching defs:node
295 CvFileNode* node = (CvFileNode*)reader.ptr;
297 if( (!is_map || CV_IS_SET_ELEM( node )) && CV_NODE_IS_COLLECTION(node->tag) )
299 if( CV_NODE_IS_USER(node->tag) && node->info && node->data.obj.decoded )
300 cvRelease( (void**)&node->data.obj.decoded );
301 if( !CV_NODE_SEQ_IS_SIMPLE( node->data.seq ))
302 icvFSReleaseCollection( node->data.seq );
424 CvStringHashNode* node = 0;
452 for( node = (CvStringHashNode*)(map->table[i]); node != 0; node = node->next )
454 if( node->hashval == hashval &&
455 node->str.len == len &&
456 memcmp( node->str.ptr, str, len ) == 0 )
460 if( !node && create_missing )
462 node = (CvStringHashNode*)cvSetNew( (CvSet*)map );
463 node->hashval = hashval;
464 CV_CALL( node->str = cvMemStorageAllocString( map->storage, str, len ));
465 node->next = (CvStringHashNode*)(map->table[i]);
466 map->table[i] = node;
471 return node;
517 CV_ERROR( CV_StsError, "The node is neither a map nor an empty collection" );
542 CvFileMapNode* node = (CvFileMapNode*)cvSetNew( (CvSet*)map );
543 node->key = key;
545 node->next = (CvFileMapNode*)(map->table[i]);
546 map->table[i] = node;
547 value = (CvFileNode*)node;
602 CV_ERROR( CV_StsError, "The node is neither a map nor an empty collection" );
673 CV_ERROR( CV_StsError, "The node is map. Use cvGetFileNodeFromMap()." );
675 CV_ERROR( CV_StsError, "The node is an empty object (None)." );
928 icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
942 memset( node, 0, sizeof(*node) );
979 CV_CALL( node->info = cvFindType( ptr ));
980 if( !node->info )
981 node->tag &= ~CV_NODE_USER;
1016 node->tag = CV_NODE_REAL;
1017 node->data.f = fval;
1023 node->tag = CV_NODE_INT;
1024 node->data.i = ival;
1034 node->tag = CV_NODE_STRING;
1098 CV_CALL( node->data.str = cvMemStorageAllocString( fs->memstorage, buf, len ));
1107 (node->info ? CV_NODE_USER : 0), node ));
1124 if( node->data.seq->total != 0 )
1133 CV_CALL( ptr = icvYMLParseKey( fs, ptr, node, &elem ));
1140 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1147 node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
1178 node->tag = CV_NODE_STRING;
1183 CV_CALL( node->data.str = cvMemStorageAllocString( fs->memstorage, ptr, (int)(str_end - ptr) ));
1193 (node->info ? CV_NODE_USER : 0), node ));
1204 CV_CALL( ptr = icvYMLParseKey( fs, ptr, node, &elem ));
1212 CV_CALL( elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ));
1233 node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
1782 icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
1789 CvFileNode *elem = node;
1792 memset( node, 0, sizeof(*node) );
1850 if( !CV_NODE_IS_COLLECTION(node->tag) )
1852 CV_CALL( icvFSCreateCollection( fs, is_noname ? CV_NODE_SEQ : CV_NODE_MAP, node ));
1854 else if( is_noname ^ CV_NODE_IS_SEQ(node->tag) )
1859 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1861 CV_CALL( elem = cvGetFileNode( fs, node, key, 1 ));
1878 elem = node;
1879 if( node->tag != CV_NODE_NONE )
1881 if( !CV_NODE_IS_COLLECTION(node->tag) )
1882 CV_CALL( icvFSCreateCollection( fs, CV_NODE_SEQ, node ));
1884 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
2002 if( (CV_NODE_TYPE(node->tag) == CV_NODE_NONE ||
2003 (CV_NODE_TYPE(node->tag) != value_type &&
2004 !CV_NODE_IS_COLLECTION(node->tag))) &&
2008 CV_NODE_MAP : CV_NODE_SEQ, node ));
2012 value_type != CV_NODE_TYPE(node->tag) )
2015 if( CV_NODE_IS_COLLECTION(node->tag) && is_simple )
2016 node->data.seq->flags |= CV_NODE_SEQ_SIMPLE;
2018 node->tag |= is_user_type ? CV_NODE_USER : 0;
3195 CV_ERROR( CV_StsNullPtr, "Null pointer to source file node or reader" );
3215 CV_ERROR( CV_StsBadArg, "The file node should be a numerical scalar or a sequence" );
3257 CvFileNode* node = (CvFileNode*)reader->ptr;
3258 if( CV_NODE_IS_INT(node->tag) )
3260 int ival = node->data.i;
3300 else if( CV_NODE_IS_REAL(node->tag) )
3302 double fval = node->data.f;
3385 CV_ERROR( CV_StsNullPtr, "Null pointers to source file node or destination array" );
3396 icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node );
3399 icvWriteCollection( CvFileStorage* fs, const CvFileNode* node )
3401 int i, total = node->data.seq->total;
3402 int elem_size = node->data.seq->elem_size;
3403 int is_map = CV_NODE_IS_MAP(node->tag);
3406 cvStartReadSeq( node->data.seq, &reader, 0 );
3421 icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node )
3427 switch( CV_NODE_TYPE(node->tag) )
3430 fs->write_int( fs, name, node->data.i );
3433 fs->write_real( fs, name, node->data.f );
3436 fs->write_string( fs, name, node->data.str.ptr, 0 );
3440 fs->start_write_struct( fs, name, CV_NODE_TYPE(node->tag) +
3441 (CV_NODE_SEQ_IS_SIMPLE(node->data.seq) ? CV_NODE_FLOW : 0),
3442 node->info ? node->info->type_name : 0 );
3443 icvWriteCollection( fs, node );
3451 CV_ERROR( CV_StsBadFlag, "Unknown type of file node" );
3460 const CvFileNode* node, int embed )
3470 if( !node )
3473 if( CV_NODE_IS_COLLECTION(node->tag) && embed )
3475 CV_CALL( icvWriteCollection( fs, node ));
3479 CV_CALL( icvWriteFileNode( fs, new_node_name, node ));
3486 CvFileNode* node = (CvFileNode*)cvGetSeqElem( fs->roots, i, 0 );
3487 icvDumpCollection( dst, node );
3563 icvFileNodeSeqLen( CvFileNode* node )
3565 return CV_NODE_IS_COLLECTION(node->tag) ? node->data.seq->total :
3566 CV_NODE_TYPE(node->tag) != CV_NODE_NONE;
3571 icvReadMat( CvFileStorage* fs, CvFileNode* node )
3583 CV_CALL( rows = cvReadIntByName( fs, node, "rows", 0 ));
3584 cols = cvReadIntByName( fs, node, "cols", 0 );
3585 dt = cvReadStringByName( fs, node, "dt", 0 );
3592 data = cvGetFileNodeByName( fs, node, "data" );
3657 icvReadMatND( CvFileStorage* fs, CvFileNode* node )
3671 CV_CALL( sizes_node = cvGetFileNodeByName( fs, node, "sizes" ));
3672 dt = cvReadStringByName( fs, node, "dt", 0 );
3686 data = cvGetFileNodeByName( fs, node, "data" );
3747 CvSparseNode* node;
3769 node = cvInitSparseMatIterator( mat, &iterator );
3770 while( node )
3772 int* idx = CV_NODE_IDX( mat, node );
3774 node = cvGetNextSparseNode( &iterator );
3798 node = (CvSparseNode*)((uchar*)idx - mat->idxoffset );
3799 val = CV_NODE_VAL( mat, node );
3814 icvReadSparseMat( CvFileStorage* fs, CvFileNode* node )
3831 CV_CALL( sizes_node = cvGetFileNodeByName( fs, node, "sizes" ));
3832 dt = cvReadStringByName( fs, node, "dt", 0 );
3847 data = cvGetFileNodeByName( fs, node, "data" );
3967 icvReadImage( CvFileStorage* fs, CvFileNode* node )
3983 CV_CALL( width = cvReadIntByName( fs, node, "width", 0 ));
3984 height = cvReadIntByName( fs, node, "height", 0 );
3985 dt = cvReadStringByName( fs, node, "dt", 0 );
3986 origin = cvReadStringByName( fs, node, "origin", 0 );
3992 data_order = cvReadStringByName( fs, node, "layout", "interleaved" );
3996 data = cvGetFileNodeByName( fs, node, "data" );
4007 roi_node = cvGetFileNodeByName( fs, node, "roi" );
4265 if( !tree_iterator.node )
4267 CV_CALL( icvWriteSeq( fs, 0, tree_iterator.node, attr, tree_iterator.level ));
4280 icvReadSeq( CvFileStorage* fs, CvFileNode* node )
4300 CV_CALL( flags_str = cvReadStringByName( fs, node, "flags", 0 ));
4301 total = cvReadIntByName( fs, node, "count", -1 );
4302 dt = cvReadStringByName( fs, node, "dt", 0 );
4311 header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
4312 header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
4318 rect_node = cvGetFileNodeByName( fs, node, "rect" );
4319 origin_node = cvGetFileNodeByName( fs, node, "origin" );
4347 point_seq->color = cvReadIntByName( fs, node, "color", 0 );
4362 data = cvGetFileNodeByName( fs, node, "data" );
4387 icvReadSeqTree( CvFileStorage* fs, CvFileNode* node )
4394 CvFileNode *sequences_node = cvGetFileNodeByName( fs, node, "sequences" );
4629 icvReadGraph( CvFileStorage* fs, CvFileNode* node )
4654 CV_CALL( flags_str = cvReadStringByName( fs, node, "flags", 0 ));
4655 vtx_dt = cvReadStringByName( fs, node, "vertex_dt", 0 );
4656 edge_dt = cvReadStringByName( fs, node, "edge_dt", 0 );
4657 vtx_count = cvReadIntByName( fs, node, "vertex_count", -1 );
4658 edge_count = cvReadIntByName( fs, node, "edge_count", -1 );
4668 header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
4669 header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
4732 vtx_node = cvGetFileNodeByName( fs, node, "vertices" );
4733 edge_node = cvGetFileNodeByName( fs, node, "edges" );
5047 cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* list )
5057 if( !node )
5060 if( !CV_NODE_IS_USER(node->tag) || !node->info )
5061 CV_ERROR( CV_StsError, "The node does not represent a user object (unknown type?)" );
5063 CV_CALL( obj = node->info->read( fs, node ));
5182 CvFileNode* node = 0;
5190 CV_CALL( node = cvGetFileNodeByName( fs, 0, name ));
5200 node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
5201 if( !CV_NODE_IS_MAP( node->tag ))
5203 seq = node->data.seq;
5204 node = 0;
5213 node = (CvFileNode*)reader.ptr;
5224 if( !node )
5227 real_name = cvGetFileNodeName( node );
5228 CV_CALL( ptr = cvRead( fs, node, 0 ));
