+++ /dev/null
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-// By downloading, copying, installing or using the software you agree to this license.
-// If you do not agree to this license, do not download, install,
-// copy or use the software.
-//
-//
-// Intel License Agreement
-// For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// * Redistribution's of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistribution's in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// * The name of Intel Corporation may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "_cxcore.h"
-#include <ctype.h>
-
-/****************************************************************************************\
-* Common macros and type definitions *
-\****************************************************************************************/
-
-#define cv_isprint(c) ((signed char)(c) >= (signed char)' ')
-#define cv_isprint_or_tab(c) ((signed char)(c) >= (signed char)' ' || (c) == '\t')
-
-static char* icv_itoa( int _val, char* buffer, int /*radix*/ )
-{
- const int radix = 10;
- char* ptr=buffer + 23 /* enough even for 64-bit integers */;
- unsigned val = abs(_val);
-
- *ptr = '\0';
- do
- {
- unsigned r = val / radix;
- *--ptr = (char)(val - (r*radix) + '0');
- val = r;
- }
- while( val != 0 );
-
- if( _val < 0 )
- *--ptr = '-';
-
- return ptr;
-}
-
-
-typedef struct CvGenericHash
-{
- CV_SET_FIELDS()
- int tab_size;
- void** table;
-}
-CvGenericHash;
-
-typedef CvGenericHash CvStringHash;
-
-typedef struct CvFileMapNode
-{
- CvFileNode value;
- const CvStringHashNode* key;
- struct CvFileMapNode* next;
-}
-CvFileMapNode;
-
-typedef struct CvXMLStackRecord
-{
- CvMemStoragePos pos;
- CvString struct_tag;
- int struct_indent;
- int struct_flags;
-}
-CvXMLStackRecord;
-
-#define CV_XML_OPENING_TAG 1
-#define CV_XML_CLOSING_TAG 2
-#define CV_XML_EMPTY_TAG 3
-#define CV_XML_HEADER_TAG 4
-#define CV_XML_DIRECTIVE_TAG 5
-
-//typedef void (*CvParse)( struct CvFileStorage* fs );
-typedef void (*CvStartWriteStruct)( struct CvFileStorage* fs, const char* key,
- int struct_flags, const char* type_name );
-typedef void (*CvEndWriteStruct)( struct CvFileStorage* fs );
-typedef void (*CvWriteInt)( struct CvFileStorage* fs, const char* key, int value );
-typedef void (*CvWriteReal)( struct CvFileStorage* fs, const char* key, double value );
-typedef void (*CvWriteString)( struct CvFileStorage* fs, const char* key,
- const char* value, int quote );
-typedef void (*CvWriteComment)( struct CvFileStorage* fs, const char* comment, int eol_comment );
-typedef void (*CvStartNextStream)( struct CvFileStorage* fs );
-
-typedef struct CvFileStorage
-{
- int flags;
- int is_xml;
- int write_mode;
- int is_first;
- CvMemStorage* memstorage;
- CvMemStorage* dststorage;
- CvMemStorage* strstorage;
- CvStringHash* str_hash;
- CvSeq* roots;
- CvSeq* write_stack;
- int struct_indent;
- int struct_flags;
- CvString struct_tag;
- int space;
- char* filename;
- FILE* file;
- char* buffer;
- char* buffer_start;
- char* buffer_end;
- int wrap_margin;
- int lineno;
- int dummy_eof;
- const char* errmsg;
- char errmsgbuf[128];
-
- CvStartWriteStruct start_write_struct;
- CvEndWriteStruct end_write_struct;
- CvWriteInt write_int;
- CvWriteReal write_real;
- CvWriteString write_string;
- CvWriteComment write_comment;
- CvStartNextStream start_next_stream;
- //CvParse parse;
-}
-CvFileStorage;
-
-
-#define CV_YML_INDENT 3
-#define CV_XML_INDENT 2
-#define CV_YML_INDENT_FLOW 1
-#define CV_FS_MAX_LEN 4096
-
-#define CV_FILE_STORAGE ('Y' + ('A' << 8) + ('M' << 16) + ('L' << 24))
-#define CV_IS_FILE_STORAGE(fs) ((fs) != 0 && (fs)->flags == CV_FILE_STORAGE)
-
-#define CV_CHECK_FILE_STORAGE(fs) \
-{ \
- if( !CV_IS_FILE_STORAGE(fs) ) \
- CV_ERROR( (fs) ? CV_StsBadArg : CV_StsNullPtr, \
- "Invalid pointer to file storage" ); \
-}
-
-#define CV_CHECK_OUTPUT_FILE_STORAGE(fs) \
-{ \
- CV_CHECK_FILE_STORAGE(fs); \
- if( !fs->write_mode ) \
- CV_ERROR( CV_StsError, "The file storage is opened for reading" ); \
-}
-
-CV_IMPL const char*
-cvAttrValue( const CvAttrList* attr, const char* attr_name )
-{
- while( attr && attr->attr )
- {
- int i;
- for( i = 0; attr->attr[i*2] != 0; i++ )
- {
- if( strcmp( attr_name, attr->attr[i*2] ) == 0 )
- return attr->attr[i*2+1];
- }
- attr = attr->next;
- }
-
- return 0;
-}
-
-
-static CvGenericHash*
-cvCreateMap( int flags, int header_size, int elem_size,
- CvMemStorage* storage, int start_tab_size )
-{
- CvGenericHash* map = 0;
-
- CV_FUNCNAME( "cvCreateMap" );
-
- __BEGIN__;
-
- if( header_size < (int)sizeof(CvGenericHash) )
- CV_ERROR( CV_StsBadSize, "Too small map header_size" );
-
- if( start_tab_size <= 0 )
- start_tab_size = 16;
-
- CV_CALL( map = (CvGenericHash*)cvCreateSet( flags, header_size, elem_size, storage ));
-
- map->tab_size = start_tab_size;
- start_tab_size *= sizeof(map->table[0]);
- CV_CALL( map->table = (void**)cvMemStorageAlloc( storage, start_tab_size ));
- memset( map->table, 0, start_tab_size );
-
- __END__;
-
- if( cvGetErrStatus() < 0 )
- map = 0;
-
- return map;
-}
-
-
-#define CV_PARSE_ERROR( errmsg ) \
-{ \
- icvParseError( fs, cvFuncName, (errmsg), __FILE__, __LINE__ ); \
- EXIT; \
-}
-
-
-static void
-icvParseError( CvFileStorage* fs, const char* func_name,
- const char* err_msg, const char* source_file, int source_line )
-{
- char buf[1<<10];
- sprintf( buf, "%s(%d): %s", fs->filename, fs->lineno, err_msg );
- cvError( CV_StsParseError, func_name, buf, source_file, source_line );
-}
-
-
-static void
-icvFSCreateCollection( CvFileStorage* fs, int tag, CvFileNode* collection )
-{
- CV_FUNCNAME( "icvFSCreateCollection" );
-
- __BEGIN__;
-
- if( CV_NODE_IS_MAP(tag) )
- {
- if( collection->tag != CV_NODE_NONE )
- {
- assert( fs->is_xml != 0 );
- CV_PARSE_ERROR( "Sequence element should not have name (use <_></_>)" );
- }
-
- CV_CALL( collection->data.map = cvCreateMap( 0, sizeof(CvFileNodeHash),
- sizeof(CvFileMapNode), fs->memstorage, 16 ));
- }
- else
- {
- 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 );
-
- collection->data.seq = seq;
- }
-
- collection->tag = tag;
- cvSetSeqBlockSize( collection->data.seq, 8 );
-
- __END__;
-}
-
-
-/*static void
-icvFSReleaseCollection( CvSeq* seq )
-{
- if( seq )
- {
- int is_map = CV_IS_SET(seq);
- CvSeqReader reader;
- int i, total = seq->total;
- cvStartReadSeq( seq, &reader, 0 );
-
- 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 )
- cvRelease( (void**)&node->data.obj.decoded );
- if( !CV_NODE_SEQ_IS_SIMPLE( node->data.seq ))
- icvFSReleaseCollection( node->data.seq );
- }
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- }
- }
-}*/
-
-
-static char*
-icvFSDoResize( CvFileStorage* fs, char* ptr, int len )
-{
- char* new_ptr = 0;
- 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_CALL( new_ptr = (char*)cvAlloc( new_size + 256 ));
- fs->buffer = new_ptr + (fs->buffer - fs->buffer_start);
- if( written_len > 0 )
- memcpy( new_ptr, fs->buffer_start, written_len );
- fs->buffer_start = new_ptr;
- fs->buffer_end = fs->buffer_start + new_size;
- new_ptr += written_len;
-
- __END__;
-
- return new_ptr;
-}
-
-
-inline char* icvFSResizeWriteBuffer( CvFileStorage* fs, char* ptr, int len )
-{
- return ptr + len < fs->buffer_end ? ptr : icvFSDoResize( fs, ptr, len );
-}
-
-
-static char*
-icvFSFlush( CvFileStorage* fs )
-{
- char* ptr = fs->buffer;
- int indent;
-
- if( ptr > fs->buffer_start + fs->space )
- {
- ptr[0] = '\n';
- ptr[1] = '\0';
- fputs( fs->buffer_start, fs->file );
- fs->buffer = fs->buffer_start;
- }
-
- indent = fs->struct_indent;
-
- if( fs->space != indent )
- {
- if( fs->space < indent )
- memset( fs->buffer_start + fs->space, ' ', indent - fs->space );
- fs->space = indent;
- }
-
- ptr = fs->buffer = fs->buffer_start + fs->space;
-
- return ptr;
-}
-
-
-/* closes file storage and deallocates buffers */
-CV_IMPL void
-cvReleaseFileStorage( CvFileStorage** p_fs )
-{
- CV_FUNCNAME("cvReleaseFileStorage" );
-
- __BEGIN__;
-
- if( !p_fs )
- CV_ERROR( CV_StsNullPtr, "NULL double pointer to file storage" );
-
- if( *p_fs )
- {
- CvFileStorage* fs = *p_fs;
- *p_fs = 0;
-
- if( fs->write_mode && fs->file )
- {
- if( fs->write_stack )
- {
- while( fs->write_stack->total > 0 )
- cvEndWriteStruct(fs);
- }
- icvFSFlush(fs);
- if( fs->is_xml )
- fputs("</opencv_storage>\n", fs->file );
- }
-
- //icvFSReleaseCollection( fs->roots ); // delete all the user types recursively
-
- if( fs->file )
- {
- fclose( fs->file );
- fs->file = 0;
- }
-
- cvReleaseMemStorage( &fs->strstorage );
-
- cvFree( &fs->buffer_start );
- cvReleaseMemStorage( &fs->memstorage );
-
- memset( fs, 0, sizeof(*fs) );
- cvFree( &fs );
- }
-
- __END__;
-}
-
-
-#define CV_HASHVAL_SCALE 33
-
-CV_IMPL CvStringHashNode*
-cvGetHashedKey( CvFileStorage* fs, const char* str, int len, int create_missing )
-{
- CvStringHashNode* node = 0;
- CV_FUNCNAME( "cvGetHashedKey" );
-
- __BEGIN__;
-
- unsigned hashval = 0;
- int i, tab_size;
- CvStringHash* map = fs->str_hash;
-
- if( !fs )
- EXIT;
-
- if( len < 0 )
- {
- for( i = 0; str[i] != '\0'; i++ )
- hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
- len = i;
- }
- else for( i = 0; i < len; i++ )
- hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
-
- hashval &= INT_MAX;
- tab_size = map->tab_size;
- if( (tab_size & (tab_size - 1)) == 0 )
- i = (int)(hashval & (tab_size - 1));
- else
- i = (int)(hashval % tab_size);
-
- for( node = (CvStringHashNode*)(map->table[i]); node != 0; node = node->next )
- {
- if( node->hashval == hashval &&
- node->str.len == len &&
- memcmp( node->str.ptr, str, len ) == 0 )
- break;
- }
-
- if( !node && create_missing )
- {
- node = (CvStringHashNode*)cvSetNew( (CvSet*)map );
- node->hashval = hashval;
- CV_CALL( node->str = cvMemStorageAllocString( map->storage, str, len ));
- node->next = (CvStringHashNode*)(map->table[i]);
- map->table[i] = node;
- }
-
- __END__;
-
- return node;
-}
-
-
-CV_IMPL CvFileNode*
-cvGetFileNode( CvFileStorage* fs, CvFileNode* _map_node,
- const CvStringHashNode* key,
- int create_missing )
-{
- CvFileNode* value = 0;
-
- CV_FUNCNAME( "cvGetFileNode" );
-
- __BEGIN__;
-
- int k = 0, attempts = 1;
-
- if( !fs )
- EXIT;
-
- CV_CHECK_FILE_STORAGE(fs);
-
- if( !key )
- CV_ERROR( CV_StsNullPtr, "Null key element" );
-
- if( _map_node )
- {
- if( !fs->roots )
- EXIT;
- attempts = fs->roots->total;
- }
-
- for( k = 0; k < attempts; k++ )
- {
- int i, tab_size;
- CvFileNode* map_node = _map_node;
- CvFileMapNode* another;
- CvFileNodeHash* map;
-
- if( !map_node )
- map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
-
- if( !CV_NODE_IS_MAP(map_node->tag) )
- {
- if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
- CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
- CV_ERROR( CV_StsError, "The node is neither a map nor an empty collection" );
- EXIT;
- }
-
- map = map_node->data.map;
- tab_size = map->tab_size;
-
- if( (tab_size & (tab_size - 1)) == 0 )
- i = (int)(key->hashval & (tab_size - 1));
- else
- i = (int)(key->hashval % tab_size);
-
- for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
- if( another->key == key )
- {
- if( !create_missing )
- {
- value = &another->value;
- EXIT;
- }
- CV_PARSE_ERROR( "Duplicated key" );
- }
-
- if( k == attempts - 1 && create_missing )
- {
- CvFileMapNode* node = (CvFileMapNode*)cvSetNew( (CvSet*)map );
- node->key = key;
-
- node->next = (CvFileMapNode*)(map->table[i]);
- map->table[i] = node;
- value = (CvFileNode*)node;
- }
- }
-
- __END__;
-
- return value;
-}
-
-
-CV_IMPL CvFileNode*
-cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* _map_node, const char* str )
-{
- CvFileNode* value = 0;
- CV_FUNCNAME( "cvGetFileNodeByName" );
-
- __BEGIN__;
-
- int i, len, tab_size;
- unsigned hashval = 0;
- int k = 0, attempts = 1;
-
- if( !fs )
- EXIT;
-
- CV_CHECK_FILE_STORAGE(fs);
-
- if( !str )
- CV_ERROR( CV_StsNullPtr, "Null element name" );
-
- for( i = 0; str[i] != '\0'; i++ )
- hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
- hashval &= INT_MAX;
- len = i;
-
- if( !_map_node )
- {
- if( !fs->roots )
- EXIT;
- attempts = fs->roots->total;
- }
-
- for( k = 0; k < attempts; k++ )
- {
- CvFileNodeHash* map;
- const CvFileNode* map_node = _map_node;
- CvFileMapNode* another;
-
- if( !map_node )
- map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
-
- if( !CV_NODE_IS_MAP(map_node->tag) )
- {
- if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
- CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
- CV_ERROR( CV_StsError, "The node is neither a map nor an empty collection" );
- EXIT;
- }
-
- map = map_node->data.map;
- tab_size = map->tab_size;
-
- if( (tab_size & (tab_size - 1)) == 0 )
- i = (int)(hashval & (tab_size - 1));
- else
- i = (int)(hashval % tab_size);
-
- for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
- {
- const CvStringHashNode* key = another->key;
-
- if( key->hashval == hashval &&
- key->str.len == len &&
- memcmp( key->str.ptr, str, len ) == 0 )
- {
- value = &another->value;
- EXIT;
- }
- }
- }
-
- __END__;
-
- return value;
-}
-
-
-CV_IMPL CvFileNode*
-cvGetRootFileNode( const CvFileStorage* fs, int stream_index )
-{
- CvFileNode* value = 0;
- CV_FUNCNAME( "cvGetRootFileNode" );
-
- __BEGIN__;
-
- CV_CHECK_FILE_STORAGE(fs);
-
- if( !fs->roots || (unsigned)stream_index >= (unsigned)fs->roots->total )
- EXIT;
-
- value = (CvFileNode*)cvGetSeqElem( fs->roots, stream_index );
-
- __END__;
-
- return value;
-}
-
-
-/* returns the sequence element by its index */
-/*CV_IMPL CvFileNode*
-cvGetFileNodeFromSeq( CvFileStorage* fs,
- CvFileNode* seq_node, int index )
-{
- CvFileNode* value = 0;
-
- CV_FUNCNAME( "cvGetFileNodeFromSeq" );
-
- __BEGIN__;
-
- CvSeq* seq;
-
- if( !seq_node )
- seq = fs->roots;
- else if( !CV_NODE_IS_SEQ(seq_node->tag) )
- {
- if( CV_NODE_IS_MAP(seq_node->tag) )
- CV_ERROR( CV_StsError, "The node is map. Use cvGetFileNodeFromMap()." );
- if( CV_NODE_TYPE(seq_node->tag) == CV_NODE_NONE )
- CV_ERROR( CV_StsError, "The node is an empty object (None)." );
- if( index != 0 && index != -1 )
- CV_ERROR( CV_StsOutOfRange, "" );
- value = seq_node;
- EXIT;
- }
- else
- seq = seq_node->data.seq;
-
- if( !seq )
- CV_ERROR( CV_StsNullPtr, "The file storage is empty" );
-
- value = (CvFileNode*)cvGetSeqElem( seq, index, 0 );
-
- __END__;
-
- return value;
-}*/
-
-
-static char*
-icvDoubleToString( char* buf, double value )
-{
- Cv64suf val;
- unsigned ieee754_hi;
-
- val.f = value;
- ieee754_hi = (unsigned)(val.u >> 32);
-
- if( (ieee754_hi & 0x7ff00000) != 0x7ff00000 )
- {
- int ivalue = cvRound(value);
- if( ivalue == value )
- sprintf( buf, "%d.", ivalue );
- else
- {
- static const char* fmt[] = {"%.16e", "%.16f"};
- double avalue = fabs(value);
- char* ptr = buf;
- sprintf( buf, fmt[0.01 <= avalue && avalue < 1000], value );
- if( *ptr == '+' || *ptr == '-' )
- ptr++;
- for( ; isdigit(*ptr); ptr++ )
- ;
- if( *ptr == ',' )
- *ptr = '.';
- }
- }
- else
- {
- unsigned ieee754_lo = (unsigned)val.u;
- if( (ieee754_hi & 0x7fffffff) + (ieee754_lo != 0) > 0x7ff00000 )
- strcpy( buf, ".Nan" );
- else
- strcpy( buf, (int)ieee754_hi < 0 ? "-.Inf" : ".Inf" );
- }
-
- return buf;
-}
-
-
-static char*
-icvFloatToString( char* buf, float value )
-{
- Cv32suf val;
- unsigned ieee754;
- val.f = value;
- ieee754 = val.u;
-
- if( (ieee754 & 0x7f800000) != 0x7f800000 )
- {
- int ivalue = cvRound(value);
- if( ivalue == value )
- sprintf( buf, "%d.", ivalue );
- else
- {
- static const char* fmt[] = {"%.8e", "%.8f"};
- double avalue = fabs((double)value);
- char* ptr = buf;
- sprintf( buf, fmt[0.01 <= avalue && avalue < 1000], value );
- if( *ptr == '+' || *ptr == '-' )
- ptr++;
- for( ; isdigit(*ptr); ptr++ )
- ;
- if( *ptr == ',' )
- *ptr = '.';
- }
- }
- else
- {
- if( (ieee754 & 0x7fffffff) != 0x7f800000 )
- strcpy( buf, ".Nan" );
- else
- strcpy( buf, (int)ieee754 < 0 ? "-.Inf" : ".Inf" );
- }
-
- return buf;
-}
-
-
-static void
-icvProcessSpecialDouble( CvFileStorage* fs, char* buf, double* value, char** endptr )
-{
- 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" );
-
- if( toupper(buf[1]) == 'I' && toupper(buf[2]) == 'N' && toupper(buf[3]) == 'F' )
- *(uint64*)value = ((uint64)inf_hi << 32);
- else if( toupper(buf[1]) == 'N' && toupper(buf[2]) == 'A' && toupper(buf[3]) == 'N' )
- *(uint64*)value = (uint64)-1;
- else
- CV_PARSE_ERROR( "Bad format of floating-point constant" );
-
- *endptr = buf + 4;
-
- __END__;
-}
-
-
-static double icv_strtod( CvFileStorage* fs, char* ptr, char** endptr )
-{
- double fval = strtod( ptr, endptr );
- if( **endptr == '.' )
- {
- char* dot_pos = *endptr;
- *dot_pos = ',';
- double fval2 = strtod( ptr, endptr );
- *dot_pos = '.';
- if( *endptr > dot_pos )
- fval = fval2;
- else
- *endptr = dot_pos;
- }
-
- if( *endptr == ptr || isalpha(**endptr) )
- icvProcessSpecialDouble( fs, ptr, &fval, endptr );
-
- return fval;
-}
-
-
-/****************************************************************************************\
-* YAML Parser *
-\****************************************************************************************/
-
-static char*
-icvYMLSkipSpaces( CvFileStorage* fs, char* ptr, int min_indent, int max_comment_indent )
-{
- CV_FUNCNAME( "icvYMLSkipSpaces" );
-
- __BEGIN__;
-
- for(;;)
- {
- while( *ptr == ' ' )
- ptr++;
- if( *ptr == '#' )
- {
- if( ptr - fs->buffer_start > max_comment_indent )
- EXIT;
- *ptr = '\0';
- }
- else if( cv_isprint(*ptr) )
- {
- if( ptr - fs->buffer_start < min_indent )
- CV_PARSE_ERROR( "Incorrect indentation" );
- break;
- }
- else if( *ptr == '\0' || *ptr == '\n' || *ptr == '\r' )
- {
- int max_size = (int)(fs->buffer_end - fs->buffer_start);
- ptr = fgets( fs->buffer_start, max_size, fs->file );
- if( !ptr )
- {
- // emulate end of stream
- ptr = fs->buffer_start;
- ptr[0] = ptr[1] = ptr[2] = '.';
- ptr[3] = '\0';
- fs->dummy_eof = 1;
- break;
- }
- else
- {
- int l = (int)strlen(ptr);
- if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !feof(fs->file) )
- CV_PARSE_ERROR( "Too long string or a last string w/o newline" );
- }
-
- fs->lineno++;
- }
- else
- CV_PARSE_ERROR( *ptr == '\t' ? "Tabs are prohibited in YAML!" : "Invalid character" );
- }
-
- __END__;
-
- return ptr;
-}
-
-
-static char*
-icvYMLParseKey( CvFileStorage* fs, char* ptr,
- CvFileNode* map_node, CvFileNode** value_placeholder )
-{
- CV_FUNCNAME( "icvYMLParseKey" );
-
- __BEGIN__;
-
- char c;
- char *endptr = ptr - 1, *saveptr;
- CvStringHashNode* str_hash_node;
-
- if( *ptr == '-' )
- CV_PARSE_ERROR( "Key may not start with \'-\'" );
-
- do c = *++endptr;
- while( cv_isprint(c) && c != ':' );
-
- if( c != ':' )
- CV_PARSE_ERROR( "Missing \':\'" );
-
- saveptr = endptr + 1;
- do c = *--endptr;
- while( 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;
-
- __END__;
-
- return ptr;
-}
-
-
-static char*
-icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
- int parent_flags, int min_indent )
-{
- CV_FUNCNAME( "icvYMLParseValue" );
-
- __BEGIN__;
-
- char buf[CV_FS_MAX_LEN + 1024];
- char* endptr = 0;
- char c = ptr[0], d = ptr[1];
- int is_parent_flow = CV_NODE_IS_FLOW(parent_flags);
- int value_type = CV_NODE_NONE;
- int len;
-
- memset( node, 0, sizeof(*node) );
-
- if( c == '!' ) // handle explicit type specification
- {
- if( d == '!' || d == '^' )
- {
- ptr++;
- value_type |= CV_NODE_USER;
- }
-
- endptr = ptr++;
- do d = *++endptr;
- while( cv_isprint(d) && d != ' ' );
- len = (int)(endptr - ptr);
- if( len == 0 )
- 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 )
- value_type = CV_NODE_STRING;
- else if( memcmp( ptr, "int", 3 ) == 0 )
- value_type = CV_NODE_INT;
- else if( memcmp( ptr, "seq", 3 ) == 0 )
- value_type = CV_NODE_SEQ;
- else if( memcmp( ptr, "map", 3 ) == 0 )
- value_type = CV_NODE_MAP;
- }
- else if( len == 5 && !CV_NODE_IS_USER(value_type) )
- {
- if( memcmp( ptr, "float", 5 ) == 0 )
- value_type = CV_NODE_REAL;
- }
- else if( CV_NODE_IS_USER(value_type) )
- {
- CV_CALL( node->info = cvFindType( ptr ));
- if( !node->info )
- node->tag &= ~CV_NODE_USER;
- }
-
- *endptr = d;
- CV_CALL( ptr = icvYMLSkipSpaces( fs, endptr, min_indent, INT_MAX ));
-
- c = *ptr;
-
- if( !CV_NODE_IS_USER(value_type) )
- {
- if( value_type == CV_NODE_STRING && c != '\'' && c != '\"' )
- goto force_string;
- if( value_type == CV_NODE_INT )
- goto force_int;
- if( value_type == CV_NODE_REAL )
- goto force_real;
- }
- }
-
- if( isdigit(c) ||
- (c == '-' || c == '+') && (isdigit(d) || d == '.') ||
- c == '.' && isalnum(d)) // a number
- {
- double fval;
- int ival;
- endptr = ptr + (c == '-' || c == '+');
- while( isdigit(*endptr) )
- endptr++;
- if( *endptr == '.' || *endptr == 'e' )
- {
-force_real:
- fval = icv_strtod( fs, ptr, &endptr );
- /*if( endptr == ptr || isalpha(*endptr) )
- CV_CALL( icvProcessSpecialDouble( fs, endptr, &fval, &endptr ));*/
-
- node->tag = CV_NODE_REAL;
- node->data.f = fval;
- }
- else
- {
-force_int:
- ival = (int)strtol( ptr, &endptr, 0 );
- node->tag = CV_NODE_INT;
- node->data.i = ival;
- }
-
- if( !endptr || endptr == ptr )
- CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" );
-
- ptr = endptr;
- }
- else if( c == '\'' || c == '\"' ) // an explicit string
- {
- node->tag = CV_NODE_STRING;
- if( c == '\'' )
- for( len = 0; len < CV_FS_MAX_LEN; )
- {
- c = *++ptr;
- if( isalnum(c) || (c != '\'' && cv_isprint(c)))
- buf[len++] = c;
- else if( c == '\'' )
- {
- c = *++ptr;
- if( c != '\'' )
- break;
- buf[len++] = c;
- }
- else
- CV_PARSE_ERROR( "Invalid character" );
- }
- else
- for( len = 0; len < CV_FS_MAX_LEN; )
- {
- c = *++ptr;
- if( isalnum(c) || (c != '\\' && c != '\"' && cv_isprint(c)))
- buf[len++] = c;
- else if( c == '\"' )
- {
- ++ptr;
- break;
- }
- else if( c == '\\' )
- {
- d = *++ptr;
- if( d == '\'' )
- buf[len++] = d;
- else if( d == '\"' || d == '\\' || d == '\'' )
- buf[len++] = d;
- else if( d == 'n' )
- buf[len++] = '\n';
- else if( d == 'r' )
- buf[len++] = '\r';
- else if( d == 't' )
- buf[len++] = '\t';
- else if( d == 'x' || isdigit(d) && d < '8' )
- {
- int val, is_hex = d == 'x';
- c = ptr[3];
- ptr[3] = '\0';
- val = strtol( ptr + is_hex, &endptr, is_hex ? 8 : 16 );
- ptr[3] = c;
- if( endptr == ptr + is_hex )
- buf[len++] = 'x';
- else
- {
- buf[len++] = (char)val;
- ptr = endptr;
- }
- }
- }
- else
- CV_PARSE_ERROR( "Invalid character" );
- }
-
- if( len >= CV_FS_MAX_LEN )
- CV_PARSE_ERROR( "Too long string literal" );
-
- CV_CALL( node->data.str = cvMemStorageAllocString( fs->memstorage, buf, len ));
- }
- else if( c == '[' || c == '{' ) // collection as a flow
- {
- 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 ));
-
- d = c == '[' ? ']' : '}';
-
- for( ++ptr ;;)
- {
- CvFileNode* elem = 0;
-
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ));
- if( *ptr == '}' || *ptr == ']' )
- {
- if( *ptr != d )
- CV_PARSE_ERROR( "The wrong closing bracket" );
- ptr++;
- break;
- }
-
- if( node->data.seq->total != 0 )
- {
- if( *ptr != ',' )
- CV_PARSE_ERROR( "Missing , between the elements" );
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr + 1, new_min_indent, INT_MAX ));
- }
-
- if( CV_NODE_IS_MAP(struct_flags) )
- {
- CV_CALL( ptr = icvYMLParseKey( fs, ptr, node, &elem ));
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ));
- }
- else
- {
- if( *ptr == ']' )
- break;
- elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
- }
- CV_CALL( ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, new_min_indent ));
- if( CV_NODE_IS_MAP(struct_flags) )
- elem->tag |= CV_NODE_NAMED;
- is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
- }
- node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
- }
- else
- {
- int indent, struct_flags, is_simple;
-
- if( is_parent_flow || c != '-' )
- {
- // implicit (one-line) string or nested block-style collection
- if( !is_parent_flow )
- {
- if( c == '?' )
- CV_PARSE_ERROR( "Complex keys are not supported" );
- if( c == '|' || c == '>' )
- CV_PARSE_ERROR( "Multi-line text literals are not supported" );
- }
-
-force_string:
- endptr = ptr - 1;
-
- do c = *++endptr;
- while( cv_isprint(c) &&
- (!is_parent_flow || c != ',' && c != '}' && c != ']') &&
- (is_parent_flow || c != ':' || value_type == CV_NODE_STRING));
-
- if( endptr == ptr )
- CV_PARSE_ERROR( "Invalid character" );
-
- if( is_parent_flow || c != ':' )
- {
- char* str_end = endptr;
- node->tag = CV_NODE_STRING;
- // strip spaces in the end of string
- do c = *--str_end;
- while( str_end > ptr && c == ' ' );
- str_end++;
- CV_CALL( node->data.str = cvMemStorageAllocString( fs->memstorage, ptr, (int)(str_end - ptr) ));
- ptr = endptr;
- EXIT;
- }
- struct_flags = CV_NODE_MAP;
- }
- else
- struct_flags = CV_NODE_SEQ;
-
- 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 ));
- }
- else
- {
- c = *ptr++;
- if( c != '-' )
- CV_PARSE_ERROR( "Block sequence elements must be preceded with \'-\'" );
-
- CV_CALL( elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ));
- }
-
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, indent + 1, INT_MAX ));
- CV_CALL( ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, indent + 1 ));
- if( CV_NODE_IS_MAP(struct_flags) )
- elem->tag |= CV_NODE_NAMED;
- is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
-
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
- if( ptr - fs->buffer_start != indent )
- {
- if( ptr - fs->buffer_start < indent )
- break;
- else
- CV_PARSE_ERROR( "Incorrect indentation" );
- }
- if( memcmp( ptr, "...", 3 ) == 0 )
- break;
- }
-
- node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
- }
-
- __END__;
-
- return ptr;
-}
-
-
-static void
-icvYMLParse( CvFileStorage* fs )
-{
- CV_FUNCNAME( "icvYMLParse" );
-
- __BEGIN__;
-
- char* ptr = fs->buffer_start;
- int is_first = 1;
-
- for(;;)
- {
- // 0. skip leading comments and directives and ...
- // 1. reach the first item
- for(;;)
- {
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
- if( !ptr )
- EXIT;
-
- if( *ptr == '%' )
- {
- if( memcmp( ptr, "%YAML:", 6 ) == 0 &&
- memcmp( ptr, "%YAML:1.", 8 ) != 0 )
- CV_PARSE_ERROR( "Unsupported YAML version (it must be 1.x)" );
- *ptr = '\0';
- }
- else if( *ptr == '-' )
- {
- if( memcmp(ptr, "---", 3) == 0 )
- {
- ptr += 3;
- break;
- }
- else if( is_first )
- break;
- }
- else if( isalnum(*ptr) || *ptr=='_')
- {
- if( !is_first )
- CV_PARSE_ERROR( "The YAML streams must start with '---', except the first one" );
- break;
- }
- else
- CV_PARSE_ERROR( "Invalid or unsupported syntax" );
- }
-
- CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
- if( memcmp( ptr, "...", 3 ) != 0 )
- {
- // 2. parse the collection
- CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 );
-
- 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 )
- EXIT;
- }
-
- if( fs->dummy_eof )
- break;
- ptr += 3;
- is_first = 0;
- }
-
- __END__;
-}
-
-
-/****************************************************************************************\
-* YAML Emitter *
-\****************************************************************************************/
-
-static void
-icvYMLWrite( CvFileStorage* fs, const char* key, const char* data, const char* cvFuncName )
-{
- //CV_FUNCNAME( "icvYMLWrite" );
-
- __BEGIN__;
-
- int i, keylen = 0;
- int datalen = 0;
- int struct_flags;
- char* ptr;
-
- struct_flags = fs->struct_flags;
-
- if( key && key[0] == '\0' )
- key = 0;
-
- if( CV_NODE_IS_COLLECTION(struct_flags) )
- {
- if( (CV_NODE_IS_MAP(struct_flags) ^ (key != 0)) )
- CV_ERROR( CV_StsBadArg, "An attempt to add element without a key to a map, "
- "or add element with key to sequence" );
- }
- else
- {
- fs->is_first = 0;
- struct_flags = CV_NODE_EMPTY | (key ? CV_NODE_MAP : CV_NODE_SEQ);
- }
-
- if( key )
- {
- keylen = (int)strlen(key);
- if( keylen == 0 )
- CV_ERROR( CV_StsBadArg, "The key is an empty" );
-
- if( keylen > CV_FS_MAX_LEN )
- CV_ERROR( CV_StsBadArg, "The key is too long" );
- }
-
- if( data )
- datalen = (int)strlen(data);
-
- if( CV_NODE_IS_FLOW(struct_flags) )
- {
- int new_offset;
- ptr = fs->buffer;
- if( !CV_NODE_IS_EMPTY(struct_flags) )
- *ptr++ = ',';
- new_offset = (int)(ptr - fs->buffer_start) + keylen + datalen;
- if( new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10 )
- {
- fs->buffer = ptr;
- ptr = icvFSFlush(fs);
- }
- else
- *ptr++ = ' ';
- }
- else
- {
- ptr = icvFSFlush(fs);
- if( !CV_NODE_IS_MAP(struct_flags) )
- {
- *ptr++ = '-';
- if( data )
- *ptr++ = ' ';
- }
- }
-
- if( key )
- {
- 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" );
- }
-
- ptr += keylen;
- *ptr++ = ':';
- if( !CV_NODE_IS_FLOW(struct_flags) && data )
- *ptr++ = ' ';
- }
-
- if( data )
- {
- ptr = icvFSResizeWriteBuffer( fs, ptr, datalen );
- memcpy( ptr, data, datalen );
- ptr += datalen;
- }
-
- fs->buffer = ptr;
- fs->struct_flags = struct_flags & ~CV_NODE_EMPTY;
-
- __END__;
-}
-
-
-static void
-icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
- const char* type_name CV_DEFAULT(0))
-{
- CV_FUNCNAME( "icvYMLStartWriteStruct" );
-
- __BEGIN__;
-
- int parent_flags;
- char buf[CV_FS_MAX_LEN + 1024];
- const char* data = 0;
-
- struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY;
- if( !CV_NODE_IS_COLLECTION(struct_flags))
- CV_ERROR( CV_StsBadArg,
- "Some collection type - CV_NODE_SEQ or CV_NODE_MAP, must be specified" );
-
- if( CV_NODE_IS_FLOW(struct_flags) )
- {
- char c = CV_NODE_IS_MAP(struct_flags) ? '{' : '[';
- struct_flags |= CV_NODE_FLOW;
-
- if( type_name )
- sprintf( buf, "!!%s %c", type_name, c );
- else
- {
- buf[0] = c;
- buf[1] = '\0';
- }
- data = buf;
- }
- else if( type_name )
- {
- sprintf( buf, "!!%s", type_name );
- data = buf;
- }
-
- CV_CALL( icvYMLWrite( fs, key, data, cvFuncName ));
-
- parent_flags = fs->struct_flags;
- cvSeqPush( fs->write_stack, &parent_flags );
- fs->struct_flags = struct_flags;
-
- if( !CV_NODE_IS_FLOW(parent_flags) )
- fs->struct_indent += CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
-
- __END__;
-}
-
-
-static void
-icvYMLEndWriteStruct( CvFileStorage* fs )
-{
- CV_FUNCNAME( "icvYMLEndWriteStruct" );
-
- __BEGIN__;
-
- int parent_flags = 0, struct_flags;
- char* ptr;
-
- struct_flags = fs->struct_flags;
- if( fs->write_stack->total == 0 )
- CV_ERROR( CV_StsError, "EndWriteStruct w/o matching StartWriteStruct" );
-
- cvSeqPop( fs->write_stack, &parent_flags );
-
- if( CV_NODE_IS_FLOW(struct_flags) )
- {
- ptr = fs->buffer;
- if( ptr > fs->buffer_start + fs->struct_indent && !CV_NODE_IS_EMPTY(struct_flags) )
- *ptr++ = ' ';
- *ptr++ = CV_NODE_IS_MAP(struct_flags) ? '}' : ']';
- fs->buffer = ptr;
- }
- else if( CV_NODE_IS_EMPTY(struct_flags) )
- {
- ptr = icvFSFlush(fs);
- memcpy( ptr, CV_NODE_IS_MAP(struct_flags) ? "{}" : "[]", 2 );
- fs->buffer = ptr + 2;
- }
-
- if( !CV_NODE_IS_FLOW(parent_flags) )
- fs->struct_indent -= CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
- assert( fs->struct_indent >= 0 );
-
- fs->struct_flags = parent_flags;
-
- __END__;
-}
-
-
-static void
-icvYMLStartNextStream( CvFileStorage* fs )
-{
- //CV_FUNCNAME( "icvYMLStartNextStream" );
-
- __BEGIN__;
-
- if( !fs->is_first )
- {
- while( fs->write_stack->total > 0 )
- icvYMLEndWriteStruct(fs);
-
- fs->struct_indent = 0;
- icvFSFlush(fs);
- fputs( "...\n", fs->file );
- fputs( "---\n", fs->file );
- fs->buffer = fs->buffer_start;
- }
-
- __END__;
-}
-
-
-static void
-icvYMLWriteInt( CvFileStorage* fs, const char* key, int value )
-{
- CV_FUNCNAME( "icvYMLWriteInt" );
-
- __BEGIN__;
-
- char buf[128];
- CV_CALL( icvYMLWrite( fs, key, icv_itoa( value, buf, 10 ), cvFuncName ));
-
- __END__;
-}
-
-
-static void
-icvYMLWriteReal( CvFileStorage* fs, const char* key, double value )
-{
- CV_FUNCNAME( "icvYMLWriteReal" );
-
- __BEGIN__;
-
- char buf[128];
- CV_CALL( icvYMLWrite( fs, key, icvDoubleToString( buf, value ), cvFuncName ));
-
- __END__;
-}
-
-
-static void
-icvYMLWriteString( CvFileStorage* fs, const char* key,
- const char* str, int quote CV_DEFAULT(0))
-{
- CV_FUNCNAME( "icvYMLWriteString" );
-
- __BEGIN__;
-
- char buf[CV_FS_MAX_LEN*4+16];
- char* data = (char*)str;
- int i, len;
-
- if( !str )
- CV_ERROR( CV_StsNullPtr, "Null string pointer" );
-
- len = (int)strlen(str);
- if( len > CV_FS_MAX_LEN )
- CV_ERROR( CV_StsBadArg, "The written string is too long" );
-
- if( quote || len == 0 || str[0] != str[len-1] || str[0] != '\"' && str[0] != '\'' )
- {
- int need_quote = quote || len == 0;
- data = buf;
- *data++ = '\"';
- 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;
-
- if( !isalnum(c) && (!cv_isprint(c) || c == '\\' || c == '\'' || c == '\"') )
- {
- *data++ = '\\';
- if( cv_isprint(c) )
- *data++ = c;
- else if( c == '\n' )
- *data++ = 'n';
- else if( c == '\r' )
- *data++ = 'r';
- else if( c == '\t' )
- *data++ = 't';
- else
- {
- sprintf( data, "x%02x", c );
- data += 3;
- }
- }
- else
- *data++ = c;
- }
- if( !need_quote && (isdigit(str[0]) ||
- str[0] == '+' || str[0] == '-' || str[0] == '.' ))
- need_quote = 1;
-
- if( need_quote )
- *data++ = '\"';
- *data++ = '\0';
- data = buf + !need_quote;
- }
-
- CV_CALL( icvYMLWrite( fs, key, data, cvFuncName ));
-
- __END__;
-}
-
-
-static void
-icvYMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
-{
- CV_FUNCNAME( "icvYMLWriteComment" );
-
- __BEGIN__;
-
- int len; //, indent;
- int multiline;
- const char* eol;
- char* ptr;
-
- if( !comment )
- CV_ERROR( CV_StsNullPtr, "Null comment" );
-
- len = (int)strlen(comment);
- eol = strchr(comment, '\n');
- multiline = eol != 0;
- ptr = fs->buffer;
-
- if( !eol_comment || multiline ||
- fs->buffer_end - ptr < len || ptr == fs->buffer_start )
- ptr = icvFSFlush( fs );
- else
- *ptr++ = ' ';
-
- while( comment )
- {
- *ptr++ = '#';
- *ptr++ = ' ';
- if( eol )
- {
- ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 );
- memcpy( ptr, comment, eol - comment + 1 );
- fs->buffer = ptr + (eol - comment);
- comment = eol + 1;
- eol = strchr( comment, '\n' );
- }
- else
- {
- len = (int)strlen(comment);
- ptr = icvFSResizeWriteBuffer( fs, ptr, len );
- memcpy( ptr, comment, len );
- fs->buffer = ptr + len;
- comment = 0;
- }
- ptr = icvFSFlush( fs );
- }
-
- __END__;
-}
-
-
-/****************************************************************************************\
-* XML Parser *
-\****************************************************************************************/
-
-#define CV_XML_INSIDE_COMMENT 1
-#define CV_XML_INSIDE_TAG 2
-#define CV_XML_INSIDE_DIRECTIVE 3
-
-static char*
-icvXMLSkipSpaces( CvFileStorage* fs, char* ptr, int mode )
-{
- CV_FUNCNAME( "icvXMLSkipSpaces" );
-
- __BEGIN__;
-
- int level = 0;
-
- for(;;)
- {
- 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] == '>' );
- mode = 0;
- ptr += 3;
- }
- }
- else if( mode == CV_XML_INSIDE_DIRECTIVE )
- {
- // !!!NOTE!!! This is not quite correct, but should work in most cases
- do
- {
- c = *++ptr;
- level += c == '<';
- level -= c == '>';
- if( level < 0 )
- EXIT;
- } while( cv_isprint_or_tab(c) );
- }
- else
- {
- do c = *++ptr;
- while( c == ' ' || c == '\t' );
-
- if( c == '<' && ptr[1] == '!' && ptr[2] == '-' && ptr[3] == '-' )
- {
- if( mode != 0 )
- CV_PARSE_ERROR( "Comments are not allowed here" );
- mode = CV_XML_INSIDE_COMMENT;
- ptr += 4;
- }
- else if( cv_isprint(c) )
- break;
- }
-
- if( !cv_isprint(*ptr) )
- {
- int max_size = (int)(fs->buffer_end - fs->buffer_start);
- if( *ptr != '\0' && *ptr != '\n' && *ptr != '\r' )
- CV_PARSE_ERROR( "Invalid character in the stream" );
- ptr = fgets( fs->buffer_start, max_size, fs->file );
- if( !ptr )
- {
- ptr = fs->buffer_start;
- *ptr = '\0';
- fs->dummy_eof = 1;
- break;
- }
- else
- {
- int l = (int)strlen(ptr);
- if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !feof(fs->file) )
- CV_PARSE_ERROR( "Too long string or a last string w/o newline" );
- }
- fs->lineno++;
- }
- }
-
- __END__;
-
- return ptr;
-}
-
-
-static char*
-icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag,
- CvAttrList** _list, int* _tag_type );
-
-static char*
-icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
- int value_type CV_DEFAULT(CV_NODE_NONE))
-{
- CV_FUNCNAME( "icvXMLParseValue" );
-
- __BEGIN__;
-
- CvFileNode *elem = node;
- int have_space = 1, is_simple = 1;
- int is_user_type = CV_NODE_IS_USER(value_type);
- memset( node, 0, sizeof(*node) );
-
- value_type = CV_NODE_TYPE(value_type);
-
- for(;;)
- {
- char c = *ptr, d;
- char* endptr;
-
- if( isspace(c) || c == '\0' || c == '<' && ptr[1] == '!' && ptr[2] == '-' )
- {
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
- have_space = 1;
- c = *ptr;
- }
-
- d = ptr[1];
-
- if( c =='<' )
- {
- CvStringHashNode *key = 0, *key2 = 0;
- CvAttrList* list = 0;
- CvTypeInfo* info = 0;
- int tag_type = 0;
- int is_noname = 0;
- const char* type_name = 0;
- int elem_type = CV_NODE_NONE;
-
- if( d == '/' )
- break;
-
- CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type ));
-
- if( tag_type == CV_XML_DIRECTIVE_TAG )
- CV_PARSE_ERROR( "Directive tags are not allowed here" );
- if( tag_type == CV_XML_EMPTY_TAG )
- CV_PARSE_ERROR( "Empty tags are not supported" );
-
- assert( tag_type == CV_XML_OPENING_TAG );
-
- type_name = list ? cvAttrValue( list, "type_id" ) : 0;
- if( type_name )
- {
- if( strcmp( type_name, "str" ) == 0 )
- elem_type = CV_NODE_STRING;
- else if( strcmp( type_name, "map" ) == 0 )
- elem_type = CV_NODE_MAP;
- else if( strcmp( type_name, "seq" ) == 0 )
- elem_type = CV_NODE_MAP;
- else
- {
- CV_CALL( info = cvFindType( type_name ));
- if( info )
- elem_type = CV_NODE_USER;
- }
- }
-
- is_noname = key->str.len == 1 && key->str.ptr[0] == '_';
- if( !CV_NODE_IS_COLLECTION(node->tag) )
- {
- CV_CALL( icvFSCreateCollection( fs, is_noname ? CV_NODE_SEQ : CV_NODE_MAP, node ));
- }
- 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 <_></_>)" );
-
- 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;
- is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
- elem->info = info;
- CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type ));
- if( tag_type != CV_XML_CLOSING_TAG || key2 != key )
- CV_PARSE_ERROR( "Mismatched closing tag" );
- have_space = 1;
- }
- else
- {
- if( !have_space )
- CV_PARSE_ERROR( "There should be space between literals" );
-
- elem = node;
- if( node->tag != CV_NODE_NONE )
- {
- if( !CV_NODE_IS_COLLECTION(node->tag) )
- CV_CALL( icvFSCreateCollection( fs, CV_NODE_SEQ, node ));
-
- elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
- elem->info = 0;
- }
-
- if( value_type != CV_NODE_STRING &&
- (isdigit(c) || (c == '-' || c == '+') &&
- (isdigit(d) || d == '.') || c == '.' && isalnum(d)) ) // a number
- {
- double fval;
- int ival;
- endptr = ptr + (c == '-' || c == '+');
- while( isdigit(*endptr) )
- endptr++;
- if( *endptr == '.' || *endptr == 'e' )
- {
- fval = icv_strtod( fs, ptr, &endptr );
- /*if( endptr == ptr || isalpha(*endptr) )
- CV_CALL( icvProcessSpecialDouble( fs, ptr, &fval, &endptr ));*/
- elem->tag = CV_NODE_REAL;
- elem->data.f = fval;
- }
- else
- {
- ival = (int)strtol( ptr, &endptr, 0 );
- elem->tag = CV_NODE_INT;
- elem->data.i = ival;
- }
-
- if( endptr == ptr )
- CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" );
-
- ptr = endptr;
- }
- else
- {
- // string
- char buf[CV_FS_MAX_LEN+16];
- int i = 0, len, is_quoted = 0;
- elem->tag = CV_NODE_STRING;
- if( c == '\"' )
- is_quoted = 1;
- else
- --ptr;
-
- for( ;; )
- {
- c = *++ptr;
- if( !isalnum(c) )
- {
- if( c == '\"' )
- {
- if( !is_quoted )
- CV_PARSE_ERROR( "Literal \" is not allowed within a string. Use "" );
- ++ptr;
- break;
- }
- else if( !cv_isprint(c) || c == '<' || (!is_quoted && isspace(c)))
- {
- if( is_quoted )
- CV_PARSE_ERROR( "Closing \" is expected" );
- break;
- }
- else if( c == '\'' || c == '>' )
- {
- CV_PARSE_ERROR( "Literal \' or > are not allowed. Use ' or >" );
- }
- else if( c == '&' )
- {
- if( *ptr == '#' )
- {
- int val;
- ptr++;
- val = (int)strtol( ptr, &endptr, 0 );
- if( (unsigned)val > (unsigned)255 ||
- !endptr || *endptr != ';' )
- CV_PARSE_ERROR( "Invalid numeric value in the string" );
- c = (char)val;
- }
- else
- {
- endptr = ptr++;
- do c = *++endptr;
- while( isalnum(c) );
- if( c != ';' )
- CV_PARSE_ERROR( "Invalid character in the symbol entity name" );
- len = (int)(endptr - ptr);
- if( len == 2 && memcmp( ptr, "lt", len ) == 0 )
- c = '<';
- else if( len == 2 && memcmp( ptr, "gt", len ) == 0 )
- c = '>';
- else if( len == 3 && memcmp( ptr, "amp", len ) == 0 )
- c = '&';
- else if( len == 4 && memcmp( ptr, "apos", len ) == 0 )
- c = '\'';
- else if( len == 4 && memcmp( ptr, "quot", len ) == 0 )
- c = '\"';
- else
- {
- memcpy( buf + i, ptr-1, len + 2 );
- i += len + 2;
- }
- }
- ptr = endptr;
- }
- }
- buf[i++] = c;
- if( i >= CV_FS_MAX_LEN )
- CV_PARSE_ERROR( "Too long string literal" );
- }
- CV_CALL( elem->data.str = cvMemStorageAllocString( fs->memstorage, buf, i ));
- }
-
- if( !CV_NODE_IS_COLLECTION(value_type) && value_type != CV_NODE_NONE )
- break;
- have_space = 0;
- }
- }
-
- if( (CV_NODE_TYPE(node->tag) == CV_NODE_NONE ||
- CV_NODE_TYPE(node->tag) != value_type &&
- !CV_NODE_IS_COLLECTION(node->tag)) &&
- CV_NODE_IS_COLLECTION(value_type) )
- {
- CV_CALL( icvFSCreateCollection( fs, CV_NODE_IS_MAP(value_type) ?
- CV_NODE_MAP : CV_NODE_SEQ, node ));
- }
-
- if( value_type != CV_NODE_NONE &&
- value_type != CV_NODE_TYPE(node->tag) )
- CV_PARSE_ERROR( "The actual type is different from the specified type" );
-
- if( CV_NODE_IS_COLLECTION(node->tag) && is_simple )
- node->data.seq->flags |= CV_NODE_SEQ_SIMPLE;
-
- node->tag |= is_user_type ? CV_NODE_USER : 0;
-
- __END__;
-
- return ptr;
-}
-
-
-static char*
-icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag,
- CvAttrList** _list, int* _tag_type )
-{
- int tag_type = 0;
- CvStringHashNode* tagname = 0;
- 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__;
-
- char* endptr;
- char c;
- int have_space;
-
- if( *ptr != '<' )
- CV_PARSE_ERROR( "Tag should start with \'<\'" );
-
- ptr++;
- if( isalnum(*ptr) || *ptr == '_' )
- tag_type = CV_XML_OPENING_TAG;
- else if( *ptr == '/' )
- {
- tag_type = CV_XML_CLOSING_TAG;
- ptr++;
- }
- else if( *ptr == '?' )
- {
- tag_type = CV_XML_HEADER_TAG;
- ptr++;
- }
- else if( *ptr == '!' )
- {
- tag_type = CV_XML_DIRECTIVE_TAG;
- assert( ptr[1] != '-' || ptr[2] != '-' );
- ptr++;
- }
- else
- CV_PARSE_ERROR( "Unknown tag type" );
-
- for(;;)
- {
- CvStringHashNode* attrname;
-
- if( !isalpha(*ptr) && *ptr != '_' )
- CV_PARSE_ERROR( "Name should start with a letter or underscore" );
-
- endptr = ptr - 1;
- do c = *++endptr;
- while( isalnum(c) || c == '_' || c == '-' );
-
- CV_CALL( attrname = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 ));
- ptr = endptr;
-
- if( !tagname )
- tagname = attrname;
- else
- {
- if( tag_type == CV_XML_CLOSING_TAG )
- CV_PARSE_ERROR( "Closing tag should not contain any attributes" );
-
- 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);
- count = 0;
- if( !last )
- first = last = chunk;
- else
- last = last->next = chunk;
- }
- last->attr[count*2] = attrname->str.ptr;
- }
-
- if( last )
- {
- CvFileNode stub;
-
- if( *ptr != '=' )
- {
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
- if( *ptr != '=' )
- CV_PARSE_ERROR( "Attribute name should be followed by \'=\'" );
- }
-
- c = *++ptr;
- if( c != '\"' && c != '\'' )
- {
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
- if( *ptr != '\"' && *ptr != '\'' )
- CV_PARSE_ERROR( "Attribute value should be put into single or double quotes" );
- }
-
- ptr = icvXMLParseValue( fs, ptr, &stub, CV_NODE_STRING );
- assert( stub.tag == CV_NODE_STRING );
- last->attr[count*2+1] = stub.data.str.ptr;
- count++;
- }
-
- c = *ptr;
- have_space = isspace(c) || c == '\0';
-
- if( c != '>' )
- {
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
- c = *ptr;
- }
-
- if( c == '>' )
- {
- if( tag_type == CV_XML_HEADER_TAG )
- CV_PARSE_ERROR( "Invalid closing tag for <?xml ..." );
- ptr++;
- break;
- }
- else if( c == '?' && tag_type == CV_XML_HEADER_TAG )
- {
- if( ptr[1] != '>' )
- CV_PARSE_ERROR( "Invalid closing tag for <?xml ..." );
- ptr += 2;
- break;
- }
- else if( c == '/' && ptr[1] == '>' && tag_type == CV_XML_OPENING_TAG )
- {
- tag_type = CV_XML_EMPTY_TAG;
- ptr += 2;
- break;
- }
-
- if( !have_space )
- CV_PARSE_ERROR( "There should be space between attributes" );
- }
-
- __END__;
-
- *_tag = tagname;
- *_tag_type = tag_type;
- *_list = first;
-
- return ptr;
-}
-
-
-static void
-icvXMLParse( CvFileStorage* fs )
-{
- CV_FUNCNAME( "icvXMLParse" );
-
- __BEGIN__;
-
- char* ptr = fs->buffer_start;
- CvStringHashNode *key = 0, *key2 = 0;
- CvAttrList* list = 0;
- int tag_type = 0;
-
- // CV_XML_INSIDE_TAG is used to prohibit leading comments
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
-
- if( memcmp( ptr, "<?xml", 5 ) != 0 )
- CV_PARSE_ERROR( "Valid XML should start with \'<?xml ...?>\'" );
-
- CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type ));
-
- /*{
- const char* version = cvAttrValue( list, "version" );
- if( version && strncmp( version, "1.", 2 ) != 0 )
- CV_ERROR( CV_StsParseError, "Unsupported version of XML" );
- }*/
- {
- const char* encoding = cvAttrValue( list, "encoding" );
- if( encoding && strcmp( encoding, "ASCII" ) != 0 )
- CV_PARSE_ERROR( "Unsupported encoding" );
- }
-
- while( *ptr != '\0' )
- {
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
-
- if( *ptr != '\0' )
- {
- CvFileNode* root_node;
- CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type ));
- if( tag_type != CV_XML_OPENING_TAG ||
- strcmp(key->str.ptr,"opencv_storage") != 0 )
- CV_PARSE_ERROR( "<opencv_storage> tag is missing" );
-
- root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 );
- CV_CALL( ptr = icvXMLParseValue( fs, ptr, root_node, CV_NODE_NONE ));
- CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type ));
- if( tag_type != CV_XML_CLOSING_TAG || key != key2 )
- CV_PARSE_ERROR( "</opencv_storage> tag is missing" );
- CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
- }
- }
-
- assert( fs->dummy_eof != 0 );
-
- __END__;
-}
-
-
-/****************************************************************************************\
-* XML Emitter *
-\****************************************************************************************/
-
-#define icvXMLFlush icvFSFlush
-
-static void
-icvXMLWriteTag( CvFileStorage* fs, const char* key, int tag_type, CvAttrList list )
-{
- CV_FUNCNAME( "icvXMLWriteTag" );
-
- __BEGIN__;
-
- char* ptr = fs->buffer;
- int i, len = 0;
- int struct_flags = fs->struct_flags;
-
- if( key && key[0] == '\0' )
- key = 0;
-
- if( tag_type == CV_XML_OPENING_TAG || tag_type == CV_XML_EMPTY_TAG )
- {
- if( CV_NODE_IS_COLLECTION(struct_flags) )
- {
- if( CV_NODE_IS_MAP(struct_flags) ^ (key != 0) )
- CV_ERROR( CV_StsBadArg, "An attempt to add element without a key to a map, "
- "or add element with key to sequence" );
- }
- else
- {
- struct_flags = CV_NODE_EMPTY + (key ? CV_NODE_MAP : CV_NODE_SEQ);
- fs->is_first = 0;
- }
-
- if( !CV_NODE_IS_EMPTY(struct_flags) )
- ptr = icvXMLFlush(fs);
- }
-
- if( !key )
- key = "_";
- else if( key[0] == '_' && key[1] == '\0' )
- CV_ERROR( CV_StsBadArg, "A single _ is a reserved tag name" );
-
- len = (int)strlen( key );
- *ptr++ = '<';
- if( tag_type == CV_XML_CLOSING_TAG )
- {
- if( list.attr )
- 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++ )
- {
- char c = key[i];
- if( !isalnum(c) && c != '_' && c != '-' )
- CV_ERROR( CV_StsBadArg, "Invalid character in the key" );
- ptr[i] = c;
- }
- ptr += len;
-
- for(;;)
- {
- const char** attr = list.attr;
-
- for( ; attr && attr[0] != 0; attr += 2 )
- {
- int len0 = (int)strlen(attr[0]);
- int len1 = (int)strlen(attr[1]);
-
- ptr = icvFSResizeWriteBuffer( fs, ptr, len0 + len1 + 4 );
- *ptr++ = ' ';
- memcpy( ptr, attr[0], len0 );
- ptr += len0;
- *ptr++ = '=';
- *ptr++ = '\"';
- memcpy( ptr, attr[1], len1 );
- ptr += len1;
- *ptr++ = '\"';
- }
- if( !list.next )
- break;
- list = *list.next;
- }
-
- if( tag_type == CV_XML_EMPTY_TAG )
- *ptr++ = '/';
- *ptr++ = '>';
- fs->buffer = ptr;
- fs->struct_flags = struct_flags & ~CV_NODE_EMPTY;
-
- __END__;
-}
-
-
-static void
-icvXMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
- const char* type_name CV_DEFAULT(0))
-{
- CV_FUNCNAME( "icvXMLStartWriteStruct" );
-
- __BEGIN__;
-
- CvXMLStackRecord parent;
- const char* attr[10];
- int idx = 0;
-
- struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY;
- if( !CV_NODE_IS_COLLECTION(struct_flags))
- CV_ERROR( CV_StsBadArg,
- "Some collection type: CV_NODE_SEQ or CV_NODE_MAP must be specified" );
-
- if( type_name )
- {
- attr[idx++] = "type_id";
- attr[idx++] = type_name;
- }
- attr[idx++] = 0;
-
- CV_CALL( icvXMLWriteTag( fs, key, CV_XML_OPENING_TAG, cvAttrList(attr,0) ));
-
- parent.struct_flags = fs->struct_flags & ~CV_NODE_EMPTY;
- parent.struct_indent = fs->struct_indent;
- parent.struct_tag = fs->struct_tag;
- cvSaveMemStoragePos( fs->strstorage, &parent.pos );
- cvSeqPush( fs->write_stack, &parent );
-
- fs->struct_indent += CV_XML_INDENT;
- if( !CV_NODE_IS_FLOW(struct_flags) )
- icvXMLFlush( fs );
-
- fs->struct_flags = struct_flags;
- if( key )
- {
- CV_CALL( fs->struct_tag = cvMemStorageAllocString( fs->strstorage, (char*)key, -1 ));
- }
- else
- {
- fs->struct_tag.ptr = 0;
- fs->struct_tag.len = 0;
- }
-
- __END__;
-}
-
-
-static void
-icvXMLEndWriteStruct( CvFileStorage* fs )
-{
- CV_FUNCNAME( "icvXMLStartWriteStruct" );
-
- __BEGIN__;
-
- CvXMLStackRecord parent;
-
- if( fs->write_stack->total == 0 )
- CV_ERROR( CV_StsError, "An extra closing tag" );
-
- CV_CALL( icvXMLWriteTag( fs, fs->struct_tag.ptr, CV_XML_CLOSING_TAG, cvAttrList(0,0) ));
- cvSeqPop( fs->write_stack, &parent );
-
- fs->struct_indent = parent.struct_indent;
- fs->struct_flags = parent.struct_flags;
- fs->struct_tag = parent.struct_tag;
- cvRestoreMemStoragePos( fs->strstorage, &parent.pos );
-
- __END__;
-}
-
-
-static void
-icvXMLStartNextStream( CvFileStorage* fs )
-{
- //CV_FUNCNAME( "icvXMLStartNextStream" );
-
- __BEGIN__;
-
- if( !fs->is_first )
- {
- while( fs->write_stack->total > 0 )
- icvXMLEndWriteStruct(fs);
-
- fs->struct_indent = 0;
- icvXMLFlush(fs);
- /* XML does not allow multiple top-level elements,
- so we just put a comment and continue
- the current (and the only) "stream" */
- fputs( "\n<!-- next stream -->\n", fs->file );
- /*fputs( "</opencv_storage>\n", fs->file );
- fputs( "<opencv_storage>\n", fs->file );*/
- fs->buffer = fs->buffer_start;
- }
-
- __END__;
-}
-
-
-static void
-icvXMLWriteScalar( CvFileStorage* fs, const char* key, const char* data, int len )
-{
- CV_FUNCNAME( "icvXMLWriteScalar" );
-
- __BEGIN__;
-
- if( CV_NODE_IS_MAP(fs->struct_flags) ||
- (!CV_NODE_IS_COLLECTION(fs->struct_flags) && key) )
- {
- icvXMLWriteTag( fs, key, CV_XML_OPENING_TAG, cvAttrList(0,0) );
- char* ptr = icvFSResizeWriteBuffer( fs, fs->buffer, len );
- memcpy( ptr, data, len );
- fs->buffer = ptr + len;
- icvXMLWriteTag( fs, key, CV_XML_CLOSING_TAG, cvAttrList(0,0) );
- }
- else
- {
- char* ptr = fs->buffer;
- int new_offset = (int)(ptr - fs->buffer_start) + len;
-
- if( key )
- CV_ERROR( CV_StsBadArg, "elements with keys can not be written to sequence" );
-
- fs->struct_flags = CV_NODE_SEQ;
-
- if( (new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10) ||
- (ptr > fs->buffer_start && ptr[-1] == '>' && !CV_NODE_IS_EMPTY(fs->struct_flags)) )
- {
- ptr = icvXMLFlush(fs);
- }
- else if( ptr > fs->buffer_start + fs->struct_indent && ptr[-1] != '>' )
- *ptr++ = ' ';
-
- memcpy( ptr, data, len );
- fs->buffer = ptr + len;
- }
-
- __END__;
-}
-
-
-static void
-icvXMLWriteInt( CvFileStorage* fs, const char* key, int value )
-{
- //CV_FUNCNAME( "cvXMLWriteInt" );
-
- __BEGIN__;
-
- char buf[128], *ptr = icv_itoa( value, buf, 10 );
- int len = (int)strlen(ptr);
- icvXMLWriteScalar( fs, key, ptr, len );
-
- __END__;
-}
-
-
-static void
-icvXMLWriteReal( CvFileStorage* fs, const char* key, double value )
-{
- //CV_FUNCNAME( "cvXMLWriteReal" );
-
- __BEGIN__;
-
- char buf[128];
- int len = (int)strlen( icvDoubleToString( buf, value ));
- icvXMLWriteScalar( fs, key, buf, len );
-
- __END__;
-}
-
-
-static void
-icvXMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote )
-{
- CV_FUNCNAME( "cvXMLWriteString" );
-
- __BEGIN__;
-
- char buf[CV_FS_MAX_LEN*6+16];
- char* data = (char*)str;
- int i, len;
-
- if( !str )
- CV_ERROR( CV_StsNullPtr, "Null string pointer" );
-
- len = (int)strlen(str);
- if( len > CV_FS_MAX_LEN )
- CV_ERROR( CV_StsBadArg, "The written string is too long" );
-
- if( quote || len == 0 || str[0] != '\"' || str[0] != str[len-1] )
- {
- int need_quote = quote || len == 0;
- data = buf;
- *data++ = '\"';
- for( i = 0; i < len; i++ )
- {
- char c = str[i];
-
- if( !isalnum(c) && (!cv_isprint(c) || c == '<' || c == '>' ||
- c == '&' || c == '\'' || c == '\"') )
- {
- *data++ = '&';
- if( c == '<' )
- {
- memcpy(data, "lt", 2);
- data += 2;
- }
- else if( c == '>' )
- {
- memcpy(data, "gt", 2);
- data += 2;
- }
- else if( c == '&' )
- {
- memcpy(data, "amp", 3);
- data += 3;
- }
- else if( c == '\'' )
- {
- memcpy(data, "apos", 4);
- data += 4;
- }
- else if( c == '\"' )
- {
- memcpy( data, "quot", 4);
- data += 4;
- }
- else
- {
- sprintf( data, "#x%02x", c );
- data += 4;
- }
- *data++ = ';';
- }
- else
- {
- if( c == ' ' )
- need_quote = 1;
- *data++ = c;
- }
- }
- if( !need_quote && (isdigit(str[0]) ||
- str[0] == '+' || str[0] == '-' || str[0] == '.' ))
- need_quote = 1;
-
- if( need_quote )
- *data++ = '\"';
- len = (int)(data - buf) - !need_quote;
- *data++ = '\0';
- data = buf + !need_quote;
- }
-
- icvXMLWriteScalar( fs, key, data, len );
-
- __END__;
-}
-
-
-static void
-icvXMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
-{
- CV_FUNCNAME( "cvXMLWriteComment" );
-
- __BEGIN__;
-
- int len;
- int multiline;
- const char* eol;
- char* ptr;
-
- if( !comment )
- CV_ERROR( CV_StsNullPtr, "Null comment" );
-
- if( strstr(comment, "--") != 0 )
- CV_ERROR( CV_StsBadArg, "Double hyphen \'--\' is not allowed in the comments" );
-
- len = (int)strlen(comment);
- eol = strchr(comment, '\n');
- multiline = eol != 0;
- ptr = fs->buffer;
-
- if( multiline || !eol_comment || fs->buffer_end - ptr < len + 5 )
- ptr = icvXMLFlush( fs );
- else if( ptr > fs->buffer_start + fs->struct_indent )
- *ptr++ = ' ';
-
- if( !multiline )
- {
- ptr = icvFSResizeWriteBuffer( fs, ptr, len + 9 );
- sprintf( ptr, "<!-- %s -->", comment );
- len = (int)strlen(ptr);
- }
- else
- {
- strcpy( ptr, "<!--" );
- len = 4;
- }
-
- fs->buffer = ptr + len;
- ptr = icvXMLFlush(fs);
-
- if( multiline )
- {
- while( comment )
- {
- if( eol )
- {
- ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 );
- memcpy( ptr, comment, eol - comment + 1 );
- ptr += eol - comment;
- comment = eol + 1;
- eol = strchr( comment, '\n' );
- }
- else
- {
- len = (int)strlen(comment);
- ptr = icvFSResizeWriteBuffer( fs, ptr, len );
- memcpy( ptr, comment, len );
- ptr += len;
- comment = 0;
- }
- fs->buffer = ptr;
- ptr = icvXMLFlush( fs );
- }
- sprintf( ptr, "-->" );
- fs->buffer = ptr + 3;
- icvXMLFlush( fs );
- }
-
- __END__;
-}
-
-
-/****************************************************************************************\
-* Common High-Level Functions *
-\****************************************************************************************/
-
-CV_IMPL CvFileStorage*
-cvOpenFileStorage( const char* filename, CvMemStorage* dststorage, int flags )
-{
- CvFileStorage* fs = 0;
- char* xml_buf = 0;
-
- CV_FUNCNAME("cvOpenFileStorage" );
-
- __BEGIN__;
-
- int default_block_size = 1 << 18;
- bool append = (flags & 3) == CV_STORAGE_APPEND;
-
- if( !filename )
- CV_ERROR( CV_StsNullPtr, "NULL filename" );
-
- CV_CALL( fs = (CvFileStorage*)cvAlloc( sizeof(*fs) ));
- memset( fs, 0, sizeof(*fs));
-
- CV_CALL( fs->memstorage = cvCreateMemStorage( default_block_size ));
- fs->dststorage = dststorage ? dststorage : fs->memstorage;
-
- CV_CALL( fs->filename = (char*)cvMemStorageAlloc( fs->memstorage, strlen(filename)+1 ));
- strcpy( fs->filename, filename );
-
- fs->flags = CV_FILE_STORAGE;
- fs->write_mode = (flags & 3) != 0;
- fs->file = fopen( fs->filename, !fs->write_mode ? "rt" : !append ? "wt" : "a+t" );
- if( !fs->file )
- EXIT;
-
- fs->roots = 0;
- fs->struct_indent = 0;
- fs->struct_flags = 0;
- fs->wrap_margin = 71;
-
- if( fs->write_mode )
- {
- // we use factor=6 for XML (the longest characters (' and ") are encoded with 6 bytes (' and ")
- // and factor=4 for YAML ( as we use 4 bytes for non ASCII characters (e.g. \xAB))
- int buf_size = CV_FS_MAX_LEN*(fs->is_xml ? 6 : 4) + 1024;
-
- char* dot_pos = strrchr( fs->filename, '.' );
- fs->is_xml = dot_pos && (strcmp( dot_pos, ".xml" ) == 0 ||
- strcmp( dot_pos, ".XML" ) == 0 || strcmp( dot_pos, ".Xml" ) == 0);
-
- if( append )
- fseek( fs->file, 0, SEEK_END );
-
- fs->write_stack = cvCreateSeq( 0, sizeof(CvSeq), fs->is_xml ?
- sizeof(CvXMLStackRecord) : sizeof(int), fs->memstorage );
- fs->is_first = 1;
- fs->struct_indent = 0;
- fs->struct_flags = CV_NODE_EMPTY;
- CV_CALL( fs->buffer_start = fs->buffer = (char*)cvAlloc( buf_size + 1024 ));
- fs->buffer_end = fs->buffer_start + buf_size;
- if( fs->is_xml )
- {
- int file_size = (int)ftell( fs->file );
- CV_CALL( fs->strstorage = cvCreateChildMemStorage( fs->memstorage ));
- if( !append || file_size == 0 )
- {
- fputs( "<?xml version=\"1.0\"?>\n", fs->file );
- fputs( "<opencv_storage>\n", fs->file );
- }
- else
- {
- int xml_buf_size = 1 << 10;
- char substr[] = "</opencv_storage>";
- int last_occurence = -1;
- xml_buf_size = MIN(xml_buf_size, file_size);
- fseek( fs->file, -xml_buf_size, SEEK_END );
- CV_CALL(xml_buf = (char*)cvAlloc( xml_buf_size+2 ));
- // find the last occurence of </opencv_storage>
- for(;;)
- {
- int line_offset = ftell( fs->file );
- char* ptr0 = fgets( xml_buf, xml_buf_size, fs->file ), *ptr;
- if( !ptr0 )
- break;
- ptr = ptr0;
- for(;;)
- {
- ptr = strstr( ptr, substr );
- if( !ptr )
- break;
- last_occurence = line_offset + (int)(ptr - ptr0);
- ptr += strlen(substr);
- }
- }
- if( last_occurence < 0 )
- CV_ERROR( CV_StsError, "Could not find </opencv_storage> in the end of file.\n" );
- fclose( fs->file );
- fs->file = fopen( fs->filename, "r+t" );
- fseek( fs->file, last_occurence, SEEK_SET );
- // replace the last "</opencv_storage>" with " <!-- resumed -->", which has the same length
- fputs( " <!-- resumed -->", fs->file );
- fseek( fs->file, 0, SEEK_END );
- fputs( "\n", fs->file );
- }
- fs->start_write_struct = icvXMLStartWriteStruct;
- fs->end_write_struct = icvXMLEndWriteStruct;
- fs->write_int = icvXMLWriteInt;
- fs->write_real = icvXMLWriteReal;
- fs->write_string = icvXMLWriteString;
- fs->write_comment = icvXMLWriteComment;
- fs->start_next_stream = icvXMLStartNextStream;
- }
- else
- {
- if( !append )
- fputs( "%YAML:1.0\n", fs->file );
- else
- fputs( "...\n---\n", fs->file );
- fs->start_write_struct = icvYMLStartWriteStruct;
- fs->end_write_struct = icvYMLEndWriteStruct;
- fs->write_int = icvYMLWriteInt;
- fs->write_real = icvYMLWriteReal;
- fs->write_string = icvYMLWriteString;
- fs->write_comment = icvYMLWriteComment;
- fs->start_next_stream = icvYMLStartNextStream;
- }
- }
- else
- {
- int buf_size;
- const char* yaml_signature = "%YAML:";
- 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 ));
-
- CV_CALL( fs->buffer = fs->buffer_start = (char*)cvAlloc( buf_size + 256 ));
- fs->buffer_end = fs->buffer_start + buf_size;
- fs->buffer[0] = '\n';
- fs->buffer[1] = '\0';
-
- //mode = cvGetErrMode();
- //cvSetErrMode( CV_ErrModeSilent );
- if( fs->is_xml )
- icvXMLParse( fs );
- else
- icvYMLParse( fs );
- //cvSetErrMode( mode );
-
- // release resources that we do not need anymore
- cvFree( &fs->buffer_start );
- fs->buffer = fs->buffer_end = 0;
- }
-
- __END__;
-
- if( fs )
- {
- if( cvGetErrStatus() < 0 || !fs->file )
- {
- cvReleaseFileStorage( &fs );
- }
- else if( !fs->write_mode )
- {
- fclose( fs->file );
- fs->file = 0;
- }
- }
-
- cvFree( &xml_buf );
-
- return fs;
-}
-
-
-CV_IMPL void
-cvStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
- const char* type_name, CvAttrList /*attributes*/ )
-{
- CV_FUNCNAME( "cvStartWriteStruct" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->start_write_struct( fs, key, struct_flags, type_name ));
-
- __END__;
-}
-
-
-CV_IMPL void
-cvEndWriteStruct( CvFileStorage* fs )
-{
- CV_FUNCNAME( "cvEndWriteStruct" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->end_write_struct( fs ));
-
- __END__;
-}
-
-
-CV_IMPL void
-cvWriteInt( CvFileStorage* fs, const char* key, int value )
-{
- CV_FUNCNAME( "cvWriteInt" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->write_int( fs, key, value ));
-
- __END__;
-}
-
-
-CV_IMPL void
-cvWriteReal( CvFileStorage* fs, const char* key, double value )
-{
- CV_FUNCNAME( "cvWriteReal" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->write_real( fs, key, value ));
-
- __END__;
-}
-
-
-CV_IMPL void
-cvWriteString( CvFileStorage* fs, const char* key, const char* value, int quote )
-{
- CV_FUNCNAME( "cvWriteString" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->write_string( fs, key, value, quote ));
-
- __END__;
-}
-
-
-CV_IMPL void
-cvWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
-{
- CV_FUNCNAME( "cvWriteComment" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->write_comment( fs, comment, eol_comment ));
-
- __END__;
-}
-
-
-CV_IMPL void
-cvStartNextStream( CvFileStorage* fs )
-{
- CV_FUNCNAME( "cvStartNextStream" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
- CV_CALL( fs->start_next_stream( fs ));
-
- __END__;
-}
-
-
-static const char icvTypeSymbol[] = "ucwsifdr";
-#define CV_FS_MAX_FMT_PAIRS 128
-
-static char*
-icvEncodeFormat( int elem_type, char* dt )
-{
- sprintf( dt, "%d%c", CV_MAT_CN(elem_type), icvTypeSymbol[CV_MAT_DEPTH(elem_type)] );
- return dt + ( dt[2] == '\0' && dt[0] == '1' );
-}
-
-static int
-icvDecodeFormat( const char* dt, int* fmt_pairs, int max_len )
-{
- int fmt_pair_count = 0;
- CV_FUNCNAME( "icvDecodeFormat" );
-
- __BEGIN__;
-
- int i = 0, k = 0, len = dt ? (int)strlen(dt) : 0;
-
- if( !dt || !len )
- EXIT;
-
- assert( fmt_pairs != 0 && max_len > 0 );
- fmt_pairs[0] = 0;
- max_len *= 2;
-
- for( ; k < len; k++ )
- {
- char c = dt[k];
-
- if( isdigit(c) )
- {
- int count = c - '0';
- if( isdigit(dt[k+1]) )
- {
- char* endptr = 0;
- count = (int)strtol( dt+k, &endptr, 10 );
- k = (int)(endptr - dt) - 1;
- }
-
- if( count <= 0 )
- CV_ERROR( CV_StsBadArg, "Invalid data type specification" );
-
- fmt_pairs[i] = count;
- }
- else
- {
- const char* pos = strchr( icvTypeSymbol, c );
- if( !pos )
- CV_ERROR( CV_StsBadArg, "Invalid data type specification" );
- if( fmt_pairs[i] == 0 )
- fmt_pairs[i] = 1;
- fmt_pairs[i+1] = (int)(pos - icvTypeSymbol);
- if( i > 0 && fmt_pairs[i+1] == fmt_pairs[i-1] )
- fmt_pairs[i-2] += fmt_pairs[i];
- else
- {
- i += 2;
- if( i >= max_len )
- CV_ERROR( CV_StsBadArg, "Too long data type specification" );
- }
- fmt_pairs[i] = 0;
- }
- }
-
- fmt_pair_count = i/2;
-
- __END__;
-
- return fmt_pair_count;
-}
-
-
-static int
-icvCalcElemSize( const char* dt, int initial_size )
-{
- int size = 0;
- CV_FUNCNAME( "icvCalcElemSize" );
-
- __BEGIN__;
-
- int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count;
- int comp_size;
-
- CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
- fmt_pair_count *= 2;
- for( i = 0, size = initial_size; i < fmt_pair_count; i += 2 )
- {
- comp_size = CV_ELEM_SIZE(fmt_pairs[i+1]);
- size = cvAlign( size, comp_size );
- size += comp_size * fmt_pairs[i];
- }
- if( initial_size == 0 )
- {
- comp_size = CV_ELEM_SIZE(fmt_pairs[1]);
- size = cvAlign( size, comp_size );
- }
-
- __END__;
-
- return size;
-}
-
-
-static int
-icvDecodeSimpleFormat( const char* dt )
-{
- int elem_type = -1;
-
- CV_FUNCNAME( "icvDecodeSimpleFormat" );
-
- __BEGIN__;
-
- int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
-
- CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
- if( fmt_pair_count != 1 || fmt_pairs[0] > 4 )
- CV_ERROR( CV_StsError, "Too complex format for the matrix" );
-
- elem_type = CV_MAKETYPE( fmt_pairs[1], fmt_pairs[0] );
-
- __END__;
-
- return elem_type;
-}
-
-
-CV_IMPL void
-cvWriteRawData( CvFileStorage* fs, const void* _data, int len, const char* dt )
-{
- const char* data0 = (const char*)_data;
-
- CV_FUNCNAME( "cvWriteRawData" );
-
- __BEGIN__;
-
- int offset = 0;
- int fmt_pairs[CV_FS_MAX_FMT_PAIRS*2], k, fmt_pair_count;
- char buf[256] = "";
-
- CV_CHECK_OUTPUT_FILE_STORAGE( fs );
-
- if( !data0 )
- CV_ERROR( CV_StsNullPtr, "Null data pointer" );
-
- if( len < 0 )
- CV_ERROR( CV_StsOutOfRange, "Negative number of elements" );
-
- CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
-
- if( !len )
- EXIT;
-
- if( fmt_pair_count == 1 )
- {
- fmt_pairs[0] *= len;
- len = 1;
- }
-
- for(;len--;)
- {
- for( k = 0; k < fmt_pair_count; k++ )
- {
- int i, count = fmt_pairs[k*2];
- 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;
-
- for( i = 0; i < count; i++ )
- {
- switch( elem_type )
- {
- case CV_8U:
- ptr = icv_itoa( *(uchar*)data, buf, 10 );
- data++;
- break;
- case CV_8S:
- ptr = icv_itoa( *(char*)data, buf, 10 );
- data++;
- break;
- case CV_16U:
- ptr = icv_itoa( *(ushort*)data, buf, 10 );
- data += sizeof(ushort);
- break;
- case CV_16S:
- ptr = icv_itoa( *(short*)data, buf, 10 );
- data += sizeof(short);
- break;
- case CV_32S:
- ptr = icv_itoa( *(int*)data, buf, 10 );
- data += sizeof(int);
- break;
- case CV_32F:
- ptr = icvFloatToString( buf, *(float*)data );
- data += sizeof(float);
- break;
- case CV_64F:
- ptr = icvDoubleToString( buf, *(double*)data );
- data += sizeof(double);
- break;
- case CV_USRTYPE1: /* reference */
- ptr = icv_itoa( (int)*(size_t*)data, buf, 10 );
- data += sizeof(size_t);
- break;
- default:
- assert(0);
- EXIT;
- }
-
- if( fs->is_xml )
- {
- int buf_len = (int)strlen(ptr);
- CV_CALL( icvXMLWriteScalar( fs, 0, ptr, buf_len ));
- }
- else
- CV_CALL( icvYMLWrite( fs, 0, ptr, cvFuncName ));
- }
-
- offset = (int)(data - data0);
- }
- }
-
- __END__;
-}
-
-
-CV_IMPL void
-cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader )
-{
- CV_FUNCNAME( "cvStartReadRawData" );
-
- __BEGIN__;
-
- int node_type;
- CV_CHECK_FILE_STORAGE( fs );
-
- 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 = (schar*)src;
- reader->block_max = reader->ptr + sizeof(*src)*2;
- reader->block_min = reader->ptr;
- reader->seq = 0;
- }
- else if( node_type == CV_NODE_SEQ )
- {
- CV_CALL( cvStartReadSeq( src->data.seq, reader, 0 ));
- }
- else if( node_type == CV_NODE_NONE )
- {
- memset( reader, 0, sizeof(*reader) );
- }
- else
- CV_ERROR( CV_StsBadArg, "The file node should be a numerical scalar or a sequence" );
-
- __END__;
-}
-
-
-CV_IMPL void
-cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
- int len, void* _data, const char* dt )
-{
- char* data0 = (char*)_data;
- CV_FUNCNAME( "cvReadRawDataSlice" );
-
- __BEGIN__;
-
- int fmt_pairs[CV_FS_MAX_FMT_PAIRS*2], k = 0, fmt_pair_count;
- int i = 0, offset = 0, count = 0;
-
- CV_CHECK_FILE_STORAGE( fs );
-
- if( !reader || !data0 )
- CV_ERROR( CV_StsNullPtr, "Null pointer to reader or destination array" );
-
- if( !reader->seq && len != 1 )
- CV_ERROR( CV_StsBadSize, "The readed sequence is a scalar, thus len must be 1" );
-
- CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
-
- for(;;)
- {
- for( k = 0; k < fmt_pair_count; k++ )
- {
- int elem_type = fmt_pairs[k*2+1];
- int elem_size = CV_ELEM_SIZE(elem_type);
- char* data;
-
- count = fmt_pairs[k*2];
- offset = cvAlign( offset, elem_size );
- data = data0 + offset;
-
- for( i = 0; i < count; i++ )
- {
- CvFileNode* node = (CvFileNode*)reader->ptr;
- if( CV_NODE_IS_INT(node->tag) )
- {
- int ival = node->data.i;
-
- switch( elem_type )
- {
- case CV_8U:
- *(uchar*)data = CV_CAST_8U(ival);
- data++;
- break;
- case CV_8S:
- *(char*)data = CV_CAST_8S(ival);
- break;
- case CV_16U:
- *(ushort*)data = CV_CAST_16U(ival);
- data += sizeof(ushort);
- break;
- case CV_16S:
- *(short*)data = CV_CAST_16S(ival);
- data += sizeof(short);
- break;
- case CV_32S:
- *(int*)data = ival;
- data += sizeof(int);
- break;
- case CV_32F:
- *(float*)data = (float)ival;
- data += sizeof(float);
- break;
- case CV_64F:
- *(double*)data = (double)ival;
- data += sizeof(double);
- break;
- case CV_USRTYPE1: /* reference */
- *(size_t*)data = ival;
- data += sizeof(size_t);
- break;
- default:
- assert(0);
- EXIT;
- }
- }
- else if( CV_NODE_IS_REAL(node->tag) )
- {
- double fval = node->data.f;
- int ival;
-
- switch( elem_type )
- {
- case CV_8U:
- ival = cvRound(fval);
- *(uchar*)data = CV_CAST_8U(ival);
- data++;
- break;
- case CV_8S:
- ival = cvRound(fval);
- *(char*)data = CV_CAST_8S(ival);
- break;
- case CV_16U:
- ival = cvRound(fval);
- *(ushort*)data = CV_CAST_16U(ival);
- data += sizeof(ushort);
- break;
- case CV_16S:
- ival = cvRound(fval);
- *(short*)data = CV_CAST_16S(ival);
- data += sizeof(short);
- break;
- case CV_32S:
- ival = cvRound(fval);
- *(int*)data = ival;
- data += sizeof(int);
- break;
- case CV_32F:
- *(float*)data = (float)fval;
- data += sizeof(float);
- break;
- case CV_64F:
- *(double*)data = fval;
- data += sizeof(double);
- break;
- case CV_USRTYPE1: /* reference */
- ival = cvRound(fval);
- *(size_t*)data = ival;
- data += sizeof(size_t);
- break;
- default:
- assert(0);
- EXIT;
- }
- }
- 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;
- }
-
- offset = (int)(data - data0);
- }
- }
-
-end_loop:
- if( i != count - 1 || k != fmt_pair_count - 1 )
- CV_ERROR( CV_StsBadSize,
- "The sequence slice does not fit an integer number of records" );
-
- if( !reader->seq )
- reader->ptr -= sizeof(CvFileNode);
-
- __END__;
-}
-
-
-CV_IMPL void
-cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
- void* data, const char* dt )
-{
- CV_FUNCNAME( "cvReadRawData" );
-
- __BEGIN__;
-
- CvSeqReader reader;
-
- if( !src || !data )
- CV_ERROR( CV_StsNullPtr, "Null pointers to source file node or destination array" );
-
- CV_CALL( cvStartReadRawData( fs, src, &reader ));
- cvReadRawDataSlice( fs, &reader, CV_NODE_IS_SEQ(src->tag) ?
- src->data.seq->total : 1, data, dt );
-
- __END__;
-}
-
-
-static void
-icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node );
-
-static void
-icvWriteCollection( CvFileStorage* fs, const CvFileNode* node )
-{
- int i, total = node->data.seq->total;
- int elem_size = node->data.seq->elem_size;
- int is_map = CV_NODE_IS_MAP(node->tag);
- CvSeqReader reader;
-
- cvStartReadSeq( node->data.seq, &reader, 0 );
-
- for( i = 0; i < total; i++ )
- {
- CvFileMapNode* elem = (CvFileMapNode*)reader.ptr;
- if( !is_map || CV_IS_SET_ELEM(elem) )
- {
- const char* name = is_map ? elem->key->str.ptr : 0;
- icvWriteFileNode( fs, name, &elem->value );
- }
- CV_NEXT_SEQ_ELEM( elem_size, reader );
- }
-}
-
-static void
-icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node )
-{
- CV_FUNCNAME( "icvWriteFileNode" );
-
- __BEGIN__;
-
- switch( CV_NODE_TYPE(node->tag) )
- {
- case CV_NODE_INT:
- fs->write_int( fs, name, node->data.i );
- break;
- case CV_NODE_REAL:
- fs->write_real( fs, name, node->data.f );
- break;
- case CV_NODE_STR:
- fs->write_string( fs, name, node->data.str.ptr, 0 );
- break;
- case CV_NODE_SEQ:
- case CV_NODE_MAP:
- fs->start_write_struct( fs, name, CV_NODE_TYPE(node->tag) +
- (CV_NODE_SEQ_IS_SIMPLE(node->data.seq) ? CV_NODE_FLOW : 0),
- node->info ? node->info->type_name : 0 );
- icvWriteCollection( fs, node );
- fs->end_write_struct( fs );
- break;
- case CV_NODE_NONE:
- fs->start_write_struct( fs, name, CV_NODE_SEQ, 0 );
- fs->end_write_struct( fs );
- break;
- default:
- CV_ERROR( CV_StsBadFlag, "Unknown type of file node" );
- }
-
- __END__;
-}
-
-
-CV_IMPL void
-cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
- const CvFileNode* node, int embed )
-{
- CvFileStorage* dst = 0;
-
- CV_FUNCNAME( "cvWriteFileNode" );
-
- __BEGIN__;
-
- CV_CHECK_OUTPUT_FILE_STORAGE(fs);
-
- if( !node )
- EXIT;
-
- if( CV_NODE_IS_COLLECTION(node->tag) && embed )
- {
- CV_CALL( icvWriteCollection( fs, node ));
- }
- else
- {
- CV_CALL( icvWriteFileNode( fs, new_node_name, node ));
- }
- /*
- int i, stream_count;
- stream_count = fs->roots->total;
- for( i = 0; i < stream_count; i++ )
- {
- CvFileNode* node = (CvFileNode*)cvGetSeqElem( fs->roots, i, 0 );
- icvDumpCollection( dst, node );
- if( i < stream_count - 1 )
- dst->start_next_stream( dst );
- }*/
-
- __END__;
-
- cvReleaseFileStorage( &dst );
-}
-
-
-CV_IMPL const char*
-cvGetFileNodeName( const CvFileNode* file_node )
-{
- return file_node && CV_NODE_HAS_NAME(file_node->tag) ?
- ((CvFileMapNode*)file_node)->key->str.ptr : 0;
-}
-
-/****************************************************************************************\
-* Reading/Writing etc. for standard types *
-\****************************************************************************************/
-
-/*#define CV_TYPE_NAME_MAT "opencv-matrix"
-#define CV_TYPE_NAME_MATND "opencv-nd-matrix"
-#define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"
-#define CV_TYPE_NAME_IMAGE "opencv-image"
-#define CV_TYPE_NAME_SEQ "opencv-sequence"
-#define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
-#define CV_TYPE_NAME_GRAPH "opencv-graph"*/
-
-/******************************* CvMat ******************************/
-
-static int
-icvIsMat( const void* ptr )
-{
- return CV_IS_MAT_HDR(ptr);
-}
-
-static void
-icvWriteMat( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList /*attr*/ )
-{
- CV_FUNCNAME( "icvWriteMat" );
-
- __BEGIN__;
-
- const CvMat* mat = (const CvMat*)struct_ptr;
- char dt[16];
- CvSize size;
- int y;
-
- assert( CV_IS_MAT(mat) );
-
- CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_MAT ));
- cvWriteInt( fs, "rows", mat->rows );
- 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) )
- {
- size.width *= size.height;
- size.height = 1;
- }
-
- for( y = 0; y < size.height; y++ )
- cvWriteRawData( fs, mat->data.ptr + y*mat->step, size.width, dt );
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
-
-static int
-icvFileNodeSeqLen( CvFileNode* node )
-{
- return CV_NODE_IS_COLLECTION(node->tag) ? node->data.seq->total :
- CV_NODE_TYPE(node->tag) != CV_NODE_NONE;
-}
-
-
-static void*
-icvReadMat( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- CV_FUNCNAME( "icvReadMat" );
-
- __BEGIN__;
-
- CvMat* mat;
- const char* dt;
- CvFileNode* data;
- int rows, cols, elem_type;
-
- CV_CALL( rows = cvReadIntByName( fs, node, "rows", 0 ));
- cols = cvReadIntByName( fs, node, "cols", 0 );
- dt = cvReadStringByName( fs, node, "dt", 0 );
-
- if( rows == 0 || cols == 0 || dt == 0 )
- CV_ERROR( CV_StsError, "Some of essential matrix attributes are absent" );
-
- CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
-
- data = cvGetFileNodeByName( fs, node, "data" );
- if( !data )
- CV_ERROR( CV_StsError, "The matrix data is not found in file storage" );
-
- if( icvFileNodeSeqLen( data ) != rows*cols*CV_MAT_CN(elem_type) )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The matrix size does not match to the number of stored elements" );
-
- CV_CALL( mat = cvCreateMat( rows, cols, elem_type ));
- CV_CALL( cvReadRawData( fs, data, mat->data.ptr, dt ));
-
- ptr = mat;
-
- __END__;
-
- return ptr;
-}
-
-
-/******************************* CvMatND ******************************/
-
-static int
-icvIsMatND( const void* ptr )
-{
- return CV_IS_MATND(ptr);
-}
-
-
-static void
-icvWriteMatND( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList /*attr*/ )
-{
- CV_FUNCNAME( "icvWriteMatND" );
-
- __BEGIN__;
-
- void* mat = (void*)struct_ptr;
- CvMatND stub;
- CvNArrayIterator iterator;
- int dims, sizes[CV_MAX_DIM];
- char dt[16];
-
- assert( CV_IS_MATND(mat) );
-
- CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_MATND ));
- dims = cvGetDims( mat, sizes );
- cvStartWriteStruct( fs, "sizes", CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, sizes, dims, "i" );
- 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
- cvWriteRawData( fs, iterator.ptr[0], iterator.size.width, dt );
- while( cvNextNArraySlice( &iterator ));
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
-
-static void*
-icvReadMatND( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- CV_FUNCNAME( "icvReadMatND" );
-
- __BEGIN__;
-
- CvMatND* mat;
- const char* dt;
- CvFileNode* data;
- CvFileNode* sizes_node;
- int sizes[CV_MAX_DIM], dims, elem_type;
- int i, total_size;
-
- CV_CALL( sizes_node = cvGetFileNodeByName( fs, node, "sizes" ));
- dt = cvReadStringByName( fs, node, "dt", 0 );
-
- if( !sizes_node || !dt )
- CV_ERROR( CV_StsError, "Some of essential matrix attributes are absent" );
-
- dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
- CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
-
- if( dims <= 0 || dims > CV_MAX_DIM )
- CV_ERROR( CV_StsParseError, "Could not determine the matrix dimensionality" );
-
- CV_CALL( cvReadRawData( fs, sizes_node, sizes, "i" ));
- CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
-
- data = cvGetFileNodeByName( fs, node, "data" );
- if( !data )
- CV_ERROR( CV_StsError, "The matrix data is not found in file storage" );
-
- for( total_size = CV_MAT_CN(elem_type), i = 0; i < dims; i++ )
- total_size *= sizes[i];
-
- if( icvFileNodeSeqLen( data ) != total_size )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The matrix size does not match to the number of stored elements" );
-
- CV_CALL( mat = cvCreateMatND( dims, sizes, elem_type ));
- CV_CALL( cvReadRawData( fs, data, mat->data.ptr, dt ));
-
- ptr = mat;
-
- __END__;
-
- return ptr;
-}
-
-
-/******************************* CvSparseMat ******************************/
-
-static int
-icvIsSparseMat( const void* ptr )
-{
- return CV_IS_SPARSE_MAT(ptr);
-}
-
-
-static int
-icvSortIdxCmpFunc( const void* _a, const void* _b, void* userdata )
-{
- int i, dims = *(int*)userdata;
- const int* a = *(const int**)_a;
- const int* b = *(const int**)_b;
-
- for( i = 0; i < dims; i++ )
- {
- int delta = a[i] - b[i];
- if( delta )
- return delta;
- }
-
- return 0;
-}
-
-
-static void
-icvWriteSparseMat( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList /*attr*/ )
-{
- CvMemStorage* memstorage = 0;
-
- CV_FUNCNAME( "icvWriteSparseMat" );
-
- __BEGIN__;
-
- const CvSparseMat* mat = (const CvSparseMat*)struct_ptr;
- CvSparseMatIterator iterator;
- CvSparseNode* node;
- CvSeq* elements;
- CvSeqReader reader;
- int i, dims;
- int *prev_idx = 0;
- char dt[16];
-
- assert( CV_IS_SPARSE_MAT(mat) );
-
- CV_CALL( memstorage = cvCreateMemStorage());
-
- CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SPARSE_MAT ));
- dims = cvGetDims( mat, 0 );
-
- cvStartWriteStruct( fs, "sizes", CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, mat->size, dims, "i" );
- cvEndWriteStruct( fs );
- cvWriteString( fs, "dt", icvEncodeFormat( CV_MAT_TYPE(mat->type), dt ), 0 );
- cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
-
- elements = cvCreateSeq( CV_SEQ_ELTYPE_PTR, sizeof(CvSeq), sizeof(int*), memstorage );
-
- node = cvInitSparseMatIterator( mat, &iterator );
- while( node )
- {
- int* idx = CV_NODE_IDX( mat, node );
- cvSeqPush( elements, &idx );
- node = cvGetNextSparseNode( &iterator );
- }
-
- cvSeqSort( elements, icvSortIdxCmpFunc, &dims );
- cvStartReadSeq( elements, &reader, 0 );
-
- for( i = 0; i < elements->total; i++ )
- {
- int* idx;
- void* val;
- int k = 0;
-
- CV_READ_SEQ_ELEM( idx, reader );
- if( i > 0 )
- {
- for( ; idx[k] == prev_idx[k]; k++ )
- assert( k < dims );
- if( k < dims - 1 )
- fs->write_int( fs, 0, k - dims + 1 );
- }
- for( ; k < dims; k++ )
- fs->write_int( fs, 0, idx[k] );
- prev_idx = idx;
-
- node = (CvSparseNode*)((uchar*)idx - mat->idxoffset );
- val = CV_NODE_VAL( mat, node );
-
- cvWriteRawData( fs, val, 1, dt );
- }
-
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-
- cvReleaseMemStorage( &memstorage );
-}
-
-
-static void*
-icvReadSparseMat( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- CV_FUNCNAME( "icvReadSparseMat" );
-
- __BEGIN__;
-
- CvSparseMat* mat;
- const char* dt;
- CvFileNode* data;
- CvFileNode* sizes_node;
- CvSeqReader reader;
- CvSeq* elements;
- int* idx;
- int* sizes = 0, dims, elem_type, cn;
- int i;
-
- CV_CALL( sizes_node = cvGetFileNodeByName( fs, node, "sizes" ));
- dt = cvReadStringByName( fs, node, "dt", 0 );
-
- if( !sizes_node || !dt )
- CV_ERROR( CV_StsError, "Some of essential matrix attributes are absent" );
-
- dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
- CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
-
- if( dims <= 0 || dims > CV_MAX_DIM_HEAP )
- CV_ERROR( CV_StsParseError, "Could not determine sparse matrix dimensionality" );
-
- sizes = (int*)alloca( dims*sizeof(sizes[0]));
- CV_CALL( cvReadRawData( fs, sizes_node, sizes, "i" ));
- CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
-
- data = cvGetFileNodeByName( fs, node, "data" );
- if( !data || !CV_NODE_IS_SEQ(data->tag) )
- CV_ERROR( CV_StsError, "The matrix data is not found in file storage" );
-
- CV_CALL( mat = cvCreateSparseMat( dims, sizes, elem_type ));
-
- cn = CV_MAT_CN(elem_type);
- idx = (int*)alloca( dims*sizeof(idx[0]) );
- elements = data->data.seq;
- cvStartReadRawData( fs, data, &reader );
-
- for( i = 0; i < elements->total; )
- {
- CvFileNode* elem = (CvFileNode*)reader.ptr;
- uchar* val;
- int k;
- if( !CV_NODE_IS_INT(elem->tag ))
- CV_ERROR( CV_StsParseError, "Sparse matrix data is corrupted" );
- k = elem->data.i;
- if( i > 0 && k >= 0 )
- idx[dims-1] = k;
- else
- {
- if( i > 0 )
- k = dims + k - 1;
- else
- idx[0] = k, k = 1;
- for( ; k < dims; k++ )
- {
- CV_NEXT_SEQ_ELEM( elements->elem_size, reader );
- i++;
- elem = (CvFileNode*)reader.ptr;
- if( !CV_NODE_IS_INT(elem->tag ) || elem->data.i < 0 )
- CV_ERROR( CV_StsParseError, "Sparse matrix data is corrupted" );
- idx[k] = elem->data.i;
- }
- }
- CV_NEXT_SEQ_ELEM( elements->elem_size, reader );
- i++;
- CV_CALL( val = cvPtrND( mat, idx, 0, 1, 0 ));
- CV_CALL( cvReadRawDataSlice( fs, &reader, cn, val, dt ));
- i += cn;
- }
-
- ptr = mat;
-
- __END__;
-
- return ptr;
-}
-
-
-/******************************* IplImage ******************************/
-
-static int
-icvIsImage( const void* ptr )
-{
- return CV_IS_IMAGE_HDR(ptr);
-}
-
-static void
-icvWriteImage( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList /*attr*/ )
-{
- CV_FUNCNAME( "icvWriteImage" );
-
- __BEGIN__;
-
- const IplImage* image = (const IplImage*)struct_ptr;
- char dt_buf[16], *dt;
- CvSize size;
- int y, depth;
-
- assert( CV_IS_IMAGE(image) );
-
- if( image->dataOrder == IPL_DATA_ORDER_PLANE )
- CV_ERROR( CV_StsUnsupportedFormat,
- "Images with planar data layout are not supported" );
-
- CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_IMAGE ));
- cvWriteInt( fs, "width", image->width );
- cvWriteInt( fs, "height", image->height );
- cvWriteString( fs, "origin", image->origin == IPL_ORIGIN_TL
- ? "top-left" : "bottom-left", 0 );
- cvWriteString( fs, "layout", image->dataOrder == IPL_DATA_ORDER_PLANE
- ? "planar" : "interleaved", 0 );
- if( image->roi )
- {
- cvStartWriteStruct( fs, "roi", CV_NODE_MAP + CV_NODE_FLOW );
- cvWriteInt( fs, "x", image->roi->xOffset );
- cvWriteInt( fs, "y", image->roi->yOffset );
- cvWriteInt( fs, "width", image->roi->width );
- cvWriteInt( fs, "height", image->roi->height );
- cvWriteInt( fs, "coi", image->roi->coi );
- cvEndWriteStruct( fs );
- }
-
- depth = icvIplToCvDepth(image->depth);
- sprintf( dt_buf, "%d%c", image->nChannels, icvTypeSymbol[depth] );
- dt = dt_buf + (dt_buf[2] == '\0' && dt_buf[0] == '1');
- cvWriteString( fs, "dt", dt, 0 );
-
- size = cvSize(image->width, image->height);
- if( size.width*image->nChannels*CV_ELEM_SIZE(depth) == image->widthStep )
- {
- size.width *= size.height;
- size.height = 1;
- }
-
- cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
- for( y = 0; y < size.height; y++ )
- cvWriteRawData( fs, image->imageData + y*image->widthStep, size.width, dt );
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
-
-static void*
-icvReadImage( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- CV_FUNCNAME( "icvReadImage" );
-
- __BEGIN__;
-
- IplImage* image;
- const char* dt;
- CvFileNode* data;
- CvFileNode* roi_node;
- CvSeqReader reader;
- CvRect roi;
- int y, width, height, elem_type, coi, depth;
- const char* origin, *data_order;
-
- CV_CALL( width = cvReadIntByName( fs, node, "width", 0 ));
- height = cvReadIntByName( fs, node, "height", 0 );
- dt = cvReadStringByName( fs, node, "dt", 0 );
- origin = cvReadStringByName( fs, node, "origin", 0 );
-
- if( width == 0 || height == 0 || dt == 0 || origin == 0 )
- CV_ERROR( CV_StsError, "Some of essential image attributes are absent" );
-
- CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
- data_order = cvReadStringByName( fs, node, "layout", "interleaved" );
- if( strcmp( data_order, "interleaved" ) != 0 )
- CV_ERROR( CV_StsError, "Only interleaved images can be read" );
-
- data = cvGetFileNodeByName( fs, node, "data" );
- if( !data )
- CV_ERROR( CV_StsError, "The image data is not found in file storage" );
-
- if( icvFileNodeSeqLen( data ) != width*height*CV_MAT_CN(elem_type) )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The matrix size does not match to the number of stored elements" );
-
- depth = cvCvToIplDepth(elem_type);
- CV_CALL( image = cvCreateImage( cvSize(width,height), depth, CV_MAT_CN(elem_type) ));
-
- roi_node = cvGetFileNodeByName( fs, node, "roi" );
- if( roi_node )
- {
- roi.x = cvReadIntByName( fs, roi_node, "x", 0 );
- roi.y = cvReadIntByName( fs, roi_node, "y", 0 );
- roi.width = cvReadIntByName( fs, roi_node, "width", 0 );
- roi.height = cvReadIntByName( fs, roi_node, "height", 0 );
- coi = cvReadIntByName( fs, roi_node, "coi", 0 );
-
- cvSetImageROI( image, roi );
- cvSetImageCOI( image, coi );
- }
-
- if( width*CV_ELEM_SIZE(elem_type) == image->widthStep )
- {
- width *= height;
- height = 1;
- }
-
- width *= CV_MAT_CN(elem_type);
- cvStartReadRawData( fs, data, &reader );
- for( y = 0; y < height; y++ )
- {
- CV_CALL( cvReadRawDataSlice( fs, &reader, width,
- image->imageData + y*image->widthStep, dt ));
- }
-
- ptr = image;
-
- __END__;
-
- return ptr;
-}
-
-
-/******************************* CvSeq ******************************/
-
-static int
-icvIsSeq( const void* ptr )
-{
- return CV_IS_SEQ(ptr);
-}
-
-
-static void
-icvReleaseSeq( void** ptr )
-{
- CV_FUNCNAME( "icvReleaseSeq" );
-
- __BEGIN__;
-
- if( !ptr )
- CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
-
- *ptr = 0; // it's impossible now to release seq, so just clear the pointer
-
- __END__;
-}
-
-
-static void*
-icvCloneSeq( const void* ptr )
-{
- return cvSeqSlice( (CvSeq*)ptr, CV_WHOLE_SEQ,
- 0 /* use the same storage as for the original sequence */, 1 );
-}
-
-
-static void
-icvWriteHeaderData( CvFileStorage* fs, const CvSeq* seq,
- CvAttrList* attr, int initial_header_size )
-{
- CV_FUNCNAME( "icvWriteHeaderData" );
-
- __BEGIN__;
-
- char header_dt_buf[128];
- const char* header_dt = cvAttrValue( attr, "header_dt" );
-
- if( header_dt )
- {
- int dt_header_size;
- CV_CALL( dt_header_size = icvCalcElemSize( header_dt, initial_header_size ));
- if( dt_header_size > seq->header_size )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The size of header calculated from \"header_dt\" is greater than header_size" );
- }
- else if( seq->header_size > initial_header_size )
- {
- if( CV_IS_SEQ(seq) && CV_IS_SEQ_POINT_SET(seq) &&
- seq->header_size == sizeof(CvPoint2DSeq) &&
- 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 );
- cvWriteInt( fs, "width", point_seq->rect.width );
- cvWriteInt( fs, "height", point_seq->rect.height );
- cvEndWriteStruct( fs );
- cvWriteInt( fs, "color", point_seq->color );
- }
- else if( CV_IS_SEQ(seq) && CV_IS_SEQ_CHAIN(seq) &&
- 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 );
- cvEndWriteStruct( fs );
- }
- else
- {
- unsigned extra_size = seq->header_size - initial_header_size;
- // a heuristic to provide nice defaults for sequences of int's & float's
- if( extra_size % sizeof(int) == 0 )
- sprintf( header_dt_buf, "%ui", (unsigned)(extra_size/sizeof(int)) );
- else
- sprintf( header_dt_buf, "%uu", extra_size );
- header_dt = header_dt_buf;
- }
- }
-
- if( header_dt )
- {
- cvWriteString( fs, "header_dt", header_dt, 0 );
- cvStartWriteStruct( fs, "header_user_data", CV_NODE_SEQ + CV_NODE_FLOW );
- cvWriteRawData( fs, (uchar*)seq + sizeof(CvSeq), 1, header_dt );
- cvEndWriteStruct( fs );
- }
-
- __END__;
-}
-
-
-static char*
-icvGetFormat( const CvSeq* seq, const char* dt_key, CvAttrList* attr,
- int initial_elem_size, char* dt_buf )
-{
- char* dt = 0;
-
- CV_FUNCNAME( "icvWriteFormat" );
-
- __BEGIN__;
-
- dt = (char*)cvAttrValue( attr, dt_key );
-
- if( dt )
- {
- int dt_elem_size;
- CV_CALL( dt_elem_size = icvCalcElemSize( dt, initial_elem_size ));
- if( dt_elem_size != seq->elem_size )
- CV_ERROR( CV_StsUnmatchedSizes,
- "The size of element calculated from \"dt\" and "
- "the elem_size do not match" );
- }
- else if( CV_MAT_TYPE(seq->flags) != 0 || seq->elem_size == 1 )
- {
- int align = CV_MAT_DEPTH(seq->flags) == CV_64F ? sizeof(double) : sizeof(size_t);
- int full_elem_size = cvAlign(CV_ELEM_SIZE(seq->flags) + initial_elem_size, align);
- if( seq->elem_size != full_elem_size )
- CV_ERROR( CV_StsUnmatchedSizes,
- "Size of sequence element (elem_size) is inconsistent with seq->flags" );
- dt = icvEncodeFormat( CV_MAT_TYPE(seq->flags), dt_buf );
- }
- else if( seq->elem_size > initial_elem_size )
- {
- unsigned extra_elem_size = seq->elem_size - initial_elem_size;
- // a heuristic to provide nice defaults for sequences of int's & float's
- if( extra_elem_size % sizeof(int) == 0 )
- sprintf( dt_buf, "%ui", (unsigned)(extra_elem_size/sizeof(int)) );
- else
- sprintf( dt_buf, "%uu", extra_elem_size );
- dt = dt_buf;
- }
-
- __END__;
-
- return dt;
-}
-
-
-static void
-icvWriteSeq( CvFileStorage* fs, const char* name,
- const void* struct_ptr,
- CvAttrList attr, int level )
-{
- CV_FUNCNAME( "icvWriteSeq" );
-
- __BEGIN__;
-
- const CvSeq* seq = (CvSeq*)struct_ptr;
- CvSeqBlock* block;
- char buf[128];
- char dt_buf[128], *dt;
-
- assert( CV_IS_SEQ( seq ));
- CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ ));
-
- if( level >= 0 )
- cvWriteInt( fs, "level", level );
-
- sprintf( buf, "%08x", seq->flags );
- cvWriteString( fs, "flags", buf, 1 );
- cvWriteInt( fs, "count", seq->total );
- CV_CALL( dt = icvGetFormat( seq, "dt", &attr, 0, dt_buf ));
- cvWriteString( fs, "dt", dt, 0 );
-
- 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 );
- if( block == seq->first->prev )
- break;
- }
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
-
- __END__;
-}
-
-
-static void
-icvWriteSeqTree( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList attr )
-{
- CV_FUNCNAME( "icvWriteSeqTree" );
-
- __BEGIN__;
-
- const CvSeq* seq = (CvSeq*)struct_ptr;
- const char* recursive_value = cvAttrValue( &attr, "recursive" );
- int is_recursive = !(!recursive_value || strcmp(recursive_value,"0") == 0 ||
- strlen(recursive_value) == 5 &&
- (strcmp(recursive_value,"false") == 0 ||
- strcmp(recursive_value,"False") == 0 ||
- strcmp(recursive_value,"FALSE") == 0 ));
-
- assert( CV_IS_SEQ( seq ));
-
- if( !is_recursive )
- {
- CV_CALL( icvWriteSeq( fs, name, seq, attr, -1 ));
- }
- else
- {
- CvTreeNodeIterator tree_iterator;
-
- 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 )
- break;
- CV_CALL( icvWriteSeq( fs, 0, tree_iterator.node, attr, tree_iterator.level ));
- cvNextTreeNode( &tree_iterator );
- }
-
- cvEndWriteStruct( fs );
- cvEndWriteStruct( fs );
- }
-
- __END__;
-}
-
-
-static void*
-icvReadSeq( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- CV_FUNCNAME( "icvReadSeq" );
-
- __BEGIN__;
-
- CvSeq* seq;
- CvSeqBlock* block;
- CvFileNode *data, *header_node, *rect_node, *origin_node;
- CvSeqReader reader;
- int total, flags;
- int elem_size, header_size = sizeof(CvSeq);
- int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count;
- int items_per_elem = 0;
- const char* flags_str;
- const char* header_dt;
- const char* dt;
- char* endptr = 0;
-
- CV_CALL( flags_str = cvReadStringByName( fs, node, "flags", 0 ));
- total = cvReadIntByName( fs, node, "count", -1 );
- dt = cvReadStringByName( fs, node, "dt", 0 );
-
- if( !flags_str || total == -1 || !dt )
- CV_ERROR( CV_StsError, "Some of essential sequence attributes are absent" );
-
- flags = (int)strtol( flags_str, &endptr, 16 );
- if( endptr == flags_str || (flags & CV_MAGIC_MASK) != CV_SEQ_MAGIC_VAL )
- CV_ERROR( CV_StsError, "The sequence flags are invalid" );
-
- header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
- header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
-
- if( (header_dt != 0) ^ (header_node != 0) )
- CV_ERROR( CV_StsError,
- "One of \"header_dt\" and \"header_user_data\" is there, while the other is not" );
-
- rect_node = cvGetFileNodeByName( fs, node, "rect" );
- origin_node = cvGetFileNodeByName( fs, node, "origin" );
-
- if( (header_node != 0) + (rect_node != 0) + (origin_node != 0) > 1 )
- CV_ERROR( CV_StsError, "Only one of \"header_user_data\", \"rect\" and \"origin\" tags may occur" );
-
- if( header_dt )
- {
- CV_CALL( header_size = icvCalcElemSize( header_dt, header_size ));
- }
- else if( rect_node )
- header_size = sizeof(CvPoint2DSeq);
- else if( origin_node )
- header_size = sizeof(CvChain);
-
- CV_CALL( elem_size = icvCalcElemSize( dt, 0 ));
- CV_CALL( seq = cvCreateSeq( flags, header_size, elem_size, fs->dststorage ));
-
- if( header_node )
- {
- CV_CALL( cvReadRawData( fs, header_node, (char*)seq + sizeof(CvSeq), header_dt ));
- }
- else if( rect_node )
- {
- CvPoint2DSeq* point_seq = (CvPoint2DSeq*)seq;
- point_seq->rect.x = cvReadIntByName( fs, rect_node, "x", 0 );
- point_seq->rect.y = cvReadIntByName( fs, rect_node, "y", 0 );
- point_seq->rect.width = cvReadIntByName( fs, rect_node, "width", 0 );
- point_seq->rect.height = cvReadIntByName( fs, rect_node, "height", 0 );
- point_seq->color = cvReadIntByName( fs, node, "color", 0 );
- }
- else if( origin_node )
- {
- CvChain* chain = (CvChain*)seq;
- chain->origin.x = cvReadIntByName( fs, origin_node, "x", 0 );
- chain->origin.y = cvReadIntByName( fs, origin_node, "y", 0 );
- }
-
- cvSeqPushMulti( seq, 0, total, 0 );
- CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
- fmt_pair_count *= 2;
- for( i = 0; i < fmt_pair_count; i += 2 )
- items_per_elem += fmt_pairs[i];
-
- data = cvGetFileNodeByName( fs, node, "data" );
- if( !data )
- CV_ERROR( CV_StsError, "The image data is not found in file storage" );
-
- if( icvFileNodeSeqLen( data ) != total*items_per_elem )
- CV_ERROR( CV_StsError, "The number of stored elements does not match to \"count\"" );
-
- cvStartReadRawData( fs, data, &reader );
- for( block = seq->first; block; block = block->next )
- {
- int delta = block->count*items_per_elem;
- cvReadRawDataSlice( fs, &reader, delta, block->data, dt );
- if( block == seq->first->prev )
- break;
- }
-
- ptr = seq;
-
- __END__;
-
- return ptr;
-}
-
-
-static void*
-icvReadSeqTree( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- CV_FUNCNAME( "icvReadSeqTree" );
-
- __BEGIN__;
-
- CvFileNode *sequences_node = cvGetFileNodeByName( fs, node, "sequences" );
- CvSeq* sequences;
- CvSeq* root = 0;
- CvSeq* parent = 0;
- CvSeq* prev_seq = 0;
- CvSeqReader reader;
- int i, total;
- int prev_level = 0;
-
- if( !sequences_node || !CV_NODE_IS_SEQ(sequences_node->tag) )
- CV_ERROR( CV_StsParseError,
- "opencv-sequence-tree instance should contain a field \"sequences\" that should be a sequence" );
-
- sequences = sequences_node->data.seq;
- total = sequences->total;
-
- cvStartReadSeq( sequences, &reader, 0 );
- for( i = 0; i < total; i++ )
- {
- CvFileNode* elem = (CvFileNode*)reader.ptr;
- CvSeq* seq;
- int level;
- CV_CALL( seq = (CvSeq*)cvRead( fs, elem ));
- CV_CALL( level = cvReadIntByName( fs, elem, "level", -1 ));
- if( level < 0 )
- CV_ERROR( CV_StsParseError, "All the sequence tree nodes should contain \"level\" field" );
- if( !root )
- root = seq;
- if( level > prev_level )
- {
- assert( level == prev_level + 1 );
- parent = prev_seq;
- prev_seq = 0;
- if( parent )
- parent->v_next = seq;
- }
- else if( level < prev_level )
- {
- for( ; prev_level > level; prev_level-- )
- prev_seq = prev_seq->v_prev;
- parent = prev_seq->v_prev;
- }
- seq->h_prev = prev_seq;
- if( prev_seq )
- prev_seq->h_next = seq;
- seq->v_prev = parent;
- prev_seq = seq;
- prev_level = level;
- CV_NEXT_SEQ_ELEM( sequences->elem_size, reader );
- }
-
- ptr = root;
-
- __END__;
-
- return ptr;
-}
-
-/******************************* CvGraph ******************************/
-
-static int
-icvIsGraph( const void* ptr )
-{
- return CV_IS_GRAPH(ptr);
-}
-
-
-static void
-icvReleaseGraph( void** ptr )
-{
- CV_FUNCNAME( "icvReleaseGraph" );
-
- __BEGIN__;
-
- if( !ptr )
- CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
-
- *ptr = 0; // it's impossible now to release graph, so just clear the pointer
-
- __END__;
-}
-
-
-static void*
-icvCloneGraph( const void* ptr )
-{
- return cvCloneGraph( (const CvGraph*)ptr, 0 );
-}
-
-
-static void
-icvWriteGraph( CvFileStorage* fs, const char* name,
- const void* struct_ptr, CvAttrList attr )
-{
- int* flag_buf = 0;
- char* write_buf = 0;
- CV_FUNCNAME( "icvWriteGraph" );
-
- __BEGIN__;
-
- const CvGraph* graph = (const CvGraph*)struct_ptr;
- CvSeqReader reader;
- char buf[128];
- int i, k, vtx_count, edge_count;
- char vtx_dt_buf[128], *vtx_dt;
- char edge_dt_buf[128], *edge_dt;
- int write_buf_size;
-
- assert( CV_IS_GRAPH(graph) );
- vtx_count = cvGraphGetVtxCount( graph );
- edge_count = cvGraphGetEdgeCount( graph );
- CV_CALL( flag_buf = (int*)cvAlloc( vtx_count*sizeof(flag_buf[0])));
-
- // count vertices
- cvStartReadSeq( (CvSeq*)graph, &reader );
- for( i = 0, k = 0; i < graph->total; i++ )
- {
- if( CV_IS_SET_ELEM( reader.ptr ))
- {
- CvGraphVtx* vtx = (CvGraphVtx*)reader.ptr;
- flag_buf[k] = vtx->flags;
- vtx->flags = k++;
- }
- 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 );
-
- cvWriteInt( fs, "vertex_count", vtx_count );
- CV_CALL( vtx_dt = icvGetFormat( (CvSeq*)graph, "vertex_dt",
- &attr, sizeof(CvGraphVtx), vtx_dt_buf ));
- if( vtx_dt )
- cvWriteString( fs, "vertex_dt", vtx_dt, 0 );
-
- cvWriteInt( fs, "edge_count", edge_count );
- CV_CALL( edge_dt = icvGetFormat( (CvSeq*)graph->edges, "edge_dt",
- &attr, sizeof(CvGraphEdge), buf ));
- 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 );
- write_buf_size = MAX( 3*graph->edges->elem_size, write_buf_size );
- CV_CALL( write_buf = (char*)cvAlloc( write_buf_size ));
-
- // as vertices and edges are written in similar way,
- // do it as a parametrized 2-iteration loop
- for( k = 0; k < 2; k++ )
- {
- const char* dt = k == 0 ? vtx_dt : edge_dt;
- if( dt )
- {
- CvSet* data = k == 0 ? (CvSet*)graph : graph->edges;
- int elem_size = data->elem_size;
- 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;
- fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
- if( fmt_pair_count > 2 || CV_ELEM_SIZE(fmt_pairs[2*2+1]) >= (int)sizeof(double))
- edge_user_align = sizeof(double);
- }
-
- cvStartWriteStruct( fs, k == 0 ? "vertices" : "edges",
- CV_NODE_SEQ + CV_NODE_FLOW );
- cvStartReadSeq( (CvSeq*)data, &reader );
- for( i = 0; i < data->total; i++ )
- {
- if( CV_IS_SET_ELEM( reader.ptr ))
- {
- if( k == 0 ) // vertices
- memcpy( src_ptr, reader.ptr + sizeof(CvGraphVtx), write_elem_size );
- else
- {
- CvGraphEdge* edge = (CvGraphEdge*)reader.ptr;
- src_ptr = (char*)cvAlignPtr( src_ptr, sizeof(int) );
- ((int*)src_ptr)[0] = edge->vtx[0]->flags;
- ((int*)src_ptr)[1] = edge->vtx[1]->flags;
- *(float*)(src_ptr + sizeof(int)*2) = edge->weight;
- if( elem_size > (int)sizeof(CvGraphEdge) )
- {
- char* src_ptr2 = (char*)cvAlignPtr( src_ptr + 2*sizeof(int)
- + sizeof(float), edge_user_align );
- memcpy( src_ptr2, edge + 1, elem_size - sizeof(CvGraphEdge) );
- }
- }
- src_ptr += write_elem_size;
- if( ++write_count >= write_max )
- {
- cvWriteRawData( fs, write_buf, write_count, dt );
- write_count = 0;
- src_ptr = write_buf;
- }
- }
- CV_NEXT_SEQ_ELEM( data->elem_size, reader );
- }
-
- if( write_count > 0 )
- cvWriteRawData( fs, write_buf, write_count, dt );
- cvEndWriteStruct( fs );
- }
- }
-
- cvEndWriteStruct( fs );
-
- // final stage. restore the graph flags
- cvStartReadSeq( (CvSeq*)graph, &reader );
- vtx_count = 0;
- for( i = 0; i < graph->total; i++ )
- {
- if( CV_IS_SET_ELEM( reader.ptr ))
- ((CvGraphVtx*)reader.ptr)->flags = flag_buf[vtx_count++];
- CV_NEXT_SEQ_ELEM( graph->elem_size, reader );
- }
-
- __END__;
-
- cvFree( &write_buf );
- cvFree( &flag_buf );
-}
-
-
-static void*
-icvReadGraph( CvFileStorage* fs, CvFileNode* node )
-{
- void* ptr = 0;
- char* read_buf = 0;
- CvGraphVtx** vtx_buf = 0;
- CV_FUNCNAME( "icvReadGraph" );
-
- __BEGIN__;
-
- CvGraph* graph;
- CvFileNode *header_node, *vtx_node, *edge_node;
- int flags, vtx_count, edge_count;
- int vtx_size = sizeof(CvGraphVtx), edge_size, header_size = sizeof(CvGraph);
- int src_vtx_size = 0, src_edge_size;
- int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
- int vtx_items_per_elem = 0, edge_items_per_elem = 0;
- int edge_user_align = sizeof(float);
- int read_buf_size;
- int i, k;
- const char* flags_str;
- const char* header_dt;
- const char* vtx_dt;
- const char* edge_dt;
- char* endptr = 0;
-
- CV_CALL( flags_str = cvReadStringByName( fs, node, "flags", 0 ));
- vtx_dt = cvReadStringByName( fs, node, "vertex_dt", 0 );
- edge_dt = cvReadStringByName( fs, node, "edge_dt", 0 );
- vtx_count = cvReadIntByName( fs, node, "vertex_count", -1 );
- edge_count = cvReadIntByName( fs, node, "edge_count", -1 );
-
- if( !flags_str || vtx_count == -1 || edge_count == -1 || !edge_dt )
- CV_ERROR( CV_StsError, "Some of essential sequence attributes are absent" );
-
- flags = (int)strtol( flags_str, &endptr, 16 );
- if( endptr == flags_str ||
- (flags & (CV_SEQ_KIND_MASK|CV_MAGIC_MASK)) != (CV_GRAPH|CV_SET_MAGIC_VAL))
- CV_ERROR( CV_StsError, "Invalid graph signature" );
-
- header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
- header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
-
- if( (header_dt != 0) ^ (header_node != 0) )
- CV_ERROR( CV_StsError,
- "One of \"header_dt\" and \"header_user_data\" is there, while the other is not" );
-
- if( header_dt )
- CV_CALL( header_size = icvCalcElemSize( header_dt, header_size ));
-
- if( vtx_dt > 0 )
- {
- CV_CALL( src_vtx_size = icvCalcElemSize( vtx_dt, 0 ));
- CV_CALL( vtx_size = icvCalcElemSize( vtx_dt, vtx_size ));
- CV_CALL( fmt_pair_count = icvDecodeFormat( edge_dt,
- fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
- fmt_pair_count *= 2;
- for( i = 0; i < fmt_pair_count; i += 2 )
- vtx_items_per_elem += fmt_pairs[i];
- }
-
- {
- char dst_edge_dt_buf[128];
- const char* dst_edge_dt = 0;
-
- CV_CALL( fmt_pair_count = icvDecodeFormat( edge_dt,
- fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
- if( fmt_pair_count < 2 ||
- fmt_pairs[0] != 2 || fmt_pairs[1] != CV_32S ||
- fmt_pairs[2] < 1 || fmt_pairs[3] != CV_32F )
- CV_ERROR( CV_StsBadArg,
- "Graph edges should start with 2 integers and a float" );
-
- // alignment of user part of the edge data following 2if
- if( fmt_pair_count > 2 && CV_ELEM_SIZE(fmt_pairs[5]) >= (int)sizeof(double))
- edge_user_align = sizeof(double);
-
- fmt_pair_count *= 2;
- for( i = 0; i < fmt_pair_count; i += 2 )
- edge_items_per_elem += fmt_pairs[i];
-
- if( edge_dt[2] == 'f' || edge_dt[2] == '1' && edge_dt[3] == 'f' )
- dst_edge_dt = edge_dt + 3 + isdigit(edge_dt[2]);
- else
- {
- int val = (int)strtol( edge_dt + 2, &endptr, 10 );
- sprintf( dst_edge_dt_buf, "%df%s", val-1, endptr );
- dst_edge_dt = dst_edge_dt_buf;
- }
-
- 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 )
- CV_CALL( cvReadRawData( fs, header_node, (char*)graph + sizeof(CvGraph), header_dt ));
-
- read_buf_size = MAX( src_vtx_size*3, 1 << 16 );
- 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++ )
- {
- const char* dt = k == 0 ? vtx_dt : edge_dt;
- int elem_size = k == 0 ? vtx_size : edge_size;
- int src_elem_size = k == 0 ? src_vtx_size : src_edge_size;
- int items_per_elem = k == 0 ? vtx_items_per_elem : edge_items_per_elem;
- int elem_count = k == 0 ? vtx_count : edge_count;
- char* dst_ptr = read_buf;
- int read_max = read_buf_size /MAX(src_elem_size, 1), read_count = 0;
- CvSeqReader reader;
- cvStartReadRawData( fs, k == 0 ? vtx_node : edge_node, &reader );
-
- for( i = 0; i < elem_count; i++ )
- {
- if( read_count == 0 && dt )
- {
- int count = MIN( elem_count - i, read_max )*items_per_elem;
- cvReadRawDataSlice( fs, &reader, count, read_buf, dt );
- read_count = count;
- dst_ptr = read_buf;
- }
-
- if( k == 0 )
- {
- CvGraphVtx* vtx;
- cvGraphAddVtx( graph, 0, &vtx );
- vtx_buf[i] = vtx;
- if( dt )
- memcpy( vtx + 1, dst_ptr, src_elem_size );
- }
- else
- {
- CvGraphEdge* edge = 0;
- int vtx1 = ((int*)dst_ptr)[0];
- int vtx2 = ((int*)dst_ptr)[1];
- int result;
-
- if( (unsigned)vtx1 >= (unsigned)vtx_count ||
- (unsigned)vtx2 >= (unsigned)vtx_count )
- CV_ERROR( CV_StsOutOfRange,
- "Some of stored vertex indices are out of range" );
-
- CV_CALL( result = cvGraphAddEdgeByPtr( graph,
- vtx_buf[vtx1], vtx_buf[vtx2], 0, &edge ));
-
- if( result == 0 )
- CV_ERROR( CV_StsBadArg, "Duplicated edge has occured" );
-
- edge->weight = *(float*)(dst_ptr + sizeof(int)*2);
- if( elem_size > (int)sizeof(CvGraphEdge) )
- {
- char* dst_ptr2 = (char*)cvAlignPtr( dst_ptr + sizeof(int)*2 +
- sizeof(float), edge_user_align );
- memcpy( edge + 1, dst_ptr2, elem_size - sizeof(CvGraphEdge) );
- }
- }
-
- dst_ptr += src_elem_size;
- read_count--;
- }
- }
-
- ptr = graph;
-
- __END__;
-
- cvFree( &read_buf );
- cvFree( &vtx_buf );
-
- return ptr;
-}
-
-/****************************************************************************************\
-* RTTI Functions *
-\****************************************************************************************/
-
-CvTypeInfo *CvType::first = 0, *CvType::last = 0;
-
-CvType::CvType( const char* type_name,
- CvIsInstanceFunc is_instance, CvReleaseFunc release,
- CvReadFunc read, CvWriteFunc write, CvCloneFunc clone )
-{
- CvTypeInfo _info;
- _info.flags = 0;
- _info.header_size = sizeof(_info);
- _info.type_name = type_name;
- _info.prev = _info.next = 0;
- _info.is_instance = is_instance;
- _info.release = release;
- _info.clone = clone;
- _info.read = read;
- _info.write = write;
-
- cvRegisterType( &_info );
- info = first;
-}
-
-
-CvType::~CvType()
-{
- cvUnregisterType( info->type_name );
-}
-
-
-CvType seq_type( CV_TYPE_NAME_SEQ, icvIsSeq, icvReleaseSeq, icvReadSeq,
- icvWriteSeqTree /* this is the entry point for
- writing a single sequence too */, icvCloneSeq );
-
-CvType seq_tree_type( CV_TYPE_NAME_SEQ_TREE, icvIsSeq, icvReleaseSeq,
- icvReadSeqTree, icvWriteSeqTree, icvCloneSeq );
-
-CvType seq_graph_type( CV_TYPE_NAME_GRAPH, icvIsGraph, icvReleaseGraph,
- icvReadGraph, icvWriteGraph, icvCloneGraph );
-
-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 );
-
-CV_IMPL void
-cvRegisterType( const CvTypeInfo* _info )
-{
- CV_FUNCNAME("cvRegisterType" );
-
- __BEGIN__;
-
- CvTypeInfo* info = 0;
- int i, len;
- char c;
-
- //if( !CvType::first )
- // icvCreateStandardTypes();
-
- if( !_info || _info->header_size != sizeof(CvTypeInfo) )
- CV_ERROR( CV_StsBadSize, "Invalid type info" );
-
- if( !_info->is_instance || !_info->release ||
- !_info->read || !_info->write )
- CV_ERROR( CV_StsNullPtr,
- "Some of required function pointers "
- "(is_instance, release, read or write) are NULL");
-
- c = _info->type_name[0];
- if( !isalpha(c) && c != '_' )
- CV_ERROR( CV_StsBadArg, "Type name should start with a letter or _" );
-
- len = (int)strlen(_info->type_name);
-
- for( i = 0; i < len; i++ )
- {
- c = _info->type_name[i];
- if( !isalnum(c) && c != '-' && c != '_' )
- CV_ERROR( CV_StsBadArg,
- "Type name should contain only letters, digits, - and _" );
- }
-
- CV_CALL( info = (CvTypeInfo*)cvAlloc( sizeof(*info) + len + 1 ));
-
- *info = *_info;
- info->type_name = (char*)(info + 1);
- memcpy( (char*)info->type_name, _info->type_name, len + 1 );
-
- info->flags = 0;
- info->next = CvType::first;
- info->prev = 0;
- if( CvType::first )
- CvType::first->prev = info;
- else
- CvType::last = info;
- CvType::first = info;
-
- __END__;
-}
-
-
-CV_IMPL void
-cvUnregisterType( const char* type_name )
-{
- CV_FUNCNAME("cvUnregisterType" );
-
- __BEGIN__;
-
- CvTypeInfo* info;
-
- CV_CALL( info = cvFindType( type_name ));
- if( info )
- {
- if( info->prev )
- info->prev->next = info->next;
- else
- CvType::first = info->next;
-
- if( info->next )
- info->next->prev = info->prev;
- else
- CvType::last = info->prev;
-
- if( !CvType::first || !CvType::last )
- CvType::first = CvType::last = 0;
-
- cvFree( &info );
- }
-
- __END__;
-}
-
-
-CV_IMPL CvTypeInfo*
-cvFirstType( void )
-{
- return CvType::first;
-}
-
-
-CV_IMPL CvTypeInfo*
-cvFindType( const char* type_name )
-{
- CvTypeInfo* info = 0;
-
- for( info = CvType::first; info != 0; info = info->next )
- if( strcmp( info->type_name, type_name ) == 0 )
- break;
-
- return info;
-}
-
-
-CV_IMPL CvTypeInfo*
-cvTypeOf( const void* struct_ptr )
-{
- CvTypeInfo* info = 0;
-
- for( info = CvType::first; info != 0; info = info->next )
- if( info->is_instance( struct_ptr ))
- break;
-
- return info;
-}
-
-
-/* universal functions */
-CV_IMPL void
-cvRelease( void** struct_ptr )
-{
- CV_FUNCNAME("cvRelease" );
-
- __BEGIN__;
-
- CvTypeInfo* info;
-
- if( !struct_ptr )
- CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
-
- if( *struct_ptr )
- {
- CV_CALL( info = cvTypeOf( *struct_ptr ));
- if( !info )
- CV_ERROR( CV_StsError, "Unknown object type" );
- if( !info->release )
- CV_ERROR( CV_StsError, "release function pointer is NULL" );
-
- CV_CALL( info->release( struct_ptr ));
- *struct_ptr = 0;
- }
-
- __END__;
-}
-
-
-void* cvClone( const void* struct_ptr )
-{
- void* struct_copy = 0;
-
- CV_FUNCNAME("cvClone" );
-
- __BEGIN__;
-
- CvTypeInfo* info;
-
- if( !struct_ptr )
- CV_ERROR( CV_StsNullPtr, "NULL structure pointer" );
-
- CV_CALL( info = cvTypeOf( struct_ptr ));
- if( !info )
- CV_ERROR( CV_StsError, "Unknown object type" );
- if( !info->clone )
- CV_ERROR( CV_StsError, "clone function pointer is NULL" );
-
- CV_CALL( struct_copy = info->clone( struct_ptr ));
-
- __END__;
-
- return struct_copy;
-}
-
-
-/* reads matrix, image, sequence, graph etc. */
-CV_IMPL void*
-cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* list )
-{
- void* obj = 0;
-
- CV_FUNCNAME( "cvRead" );
-
- __BEGIN__;
-
- CV_CHECK_FILE_STORAGE( fs );
-
- if( !node )
- EXIT;
-
- if( !CV_NODE_IS_USER(node->tag) || !node->info )
- CV_ERROR( CV_StsError, "The node does not represent a user object (unknown type?)" );
-
- CV_CALL( obj = node->info->read( fs, node ));
-
- __END__;
-
- if( list )
- *list = cvAttrList(0,0);
-
- return obj;
-}
-
-
-/* writes matrix, image, sequence, graph etc. */
-CV_IMPL void
-cvWrite( CvFileStorage* fs, const char* name,
- const void* ptr, CvAttrList attributes )
-{
- CV_FUNCNAME( "cvWrite" );
-
- __BEGIN__;
-
- CvTypeInfo* info;
-
- CV_CHECK_OUTPUT_FILE_STORAGE( fs );
-
- if( !ptr )
- CV_ERROR( CV_StsNullPtr, "Null pointer to the written object" );
-
- CV_CALL( info = cvTypeOf( ptr ));
- if( !info )
- CV_ERROR( CV_StsBadArg, "Unknown object" );
-
- if( !info->write )
- CV_ERROR( CV_StsBadArg, "The object does not have write function" );
-
- CV_CALL( info->write( fs, name, ptr, attributes ));
-
- __END__;
-}
-
-
-/* simple API for reading/writing data */
-CV_IMPL void
-cvSave( const char* filename, const void* struct_ptr,
- const char* _name, const char* comment, CvAttrList attributes )
-{
- CvFileStorage* fs = 0;
-
- CV_FUNCNAME( "cvSave" );
-
- __BEGIN__;
-
- char name_buf[CV_FS_MAX_LEN + 256];
- char* name = (char*)_name;
-
- if( !struct_ptr )
- CV_ERROR( CV_StsNullPtr, "NULL object pointer" );
-
- CV_CALL( fs = cvOpenFileStorage( filename, 0, CV_STORAGE_WRITE ));
- if( !fs )
- CV_ERROR( CV_StsError, "Could not open the file storage. Check the path and permissions" );
-
- if( !name )
- {
- 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 )
- ptr2 = ptr;
- ptr--;
- }
- ptr++;
- if( ptr == ptr2 )
- CV_ERROR( CV_StsBadArg, "Invalid filename" );
-
- name=name_buf;
-
- // name must start with letter or '_'
- if( !isalpha(*ptr) && *ptr!= '_' ){
- *name++ = '_';
- }
-
- while( ptr < ptr2 )
- {
- char c = *ptr++;
- if( !isalnum(c) && c != '-' && c != '_' )
- c = '_';
- *name++ = c;
- }
- *name = '\0';
- name = name_buf;
- if( strcmp( name, "_" ) == 0 )
- strcpy( name, stubname );
- }
-
- if( comment )
- CV_CALL( cvWriteComment( fs, comment, 0 ));
- CV_CALL( cvWrite( fs, name, struct_ptr, attributes ));
-
- __END__;
-
- cvReleaseFileStorage( &fs );
-}
-
-
-CV_IMPL void*
-cvLoad( const char* filename, CvMemStorage* memstorage,
- const char* name, const char** _real_name )
-{
- void* ptr = 0;
- const char* real_name = 0;
- CvFileStorage* fs = 0;
-
- CV_FUNCNAME( "cvLoad" );
-
- __BEGIN__;
-
- CvFileNode* node = 0;
- CV_CALL( fs = cvOpenFileStorage( filename, memstorage, CV_STORAGE_READ ));
-
- if( !fs )
- EXIT;
-
- if( name )
- {
- CV_CALL( node = cvGetFileNodeByName( fs, 0, name ));
- }
- else
- {
- int i, k;
- for( k = 0; k < fs->roots->total; k++ )
- {
- CvSeq* seq;
- CvSeqReader reader;
-
- node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
- if( !CV_NODE_IS_MAP( node->tag ))
- EXIT;
- seq = node->data.seq;
- node = 0;
-
- cvStartReadSeq( seq, &reader, 0 );
-
- // find the first element in the map
- for( i = 0; i < seq->total; i++ )
- {
- if( CV_IS_SET_ELEM( reader.ptr ))
- {
- node = (CvFileNode*)reader.ptr;
- goto stop_search;
- }
- CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
- }
- }
-
-stop_search:
- ;
- }
-
- if( !node )
- CV_ERROR( CV_StsObjectNotFound, "Could not find the/an object in file storage" );
-
- real_name = cvGetFileNodeName( node );
- CV_CALL( ptr = cvRead( fs, node, 0 ));
-
- // sanity check
- if( !memstorage && (CV_IS_SEQ( ptr ) || CV_IS_SET( ptr )) )
- CV_ERROR( CV_StsNullPtr,
- "NULL memory storage is passed - the loaded dynamic structure can not be stored" );
-
- __END__;
-
- cvReleaseFileStorage( &fs );
- if( cvGetErrStatus() < 0 )
- {
- cvRelease( (void**)&ptr );
- real_name = 0;
- }
-
- if( _real_name )
- *_real_name = real_name;
-
- return ptr;
-}
-
-/* End of file. */
projects / opencv / blobdiff