X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=src%2Fcxcore%2Fcxpersistence.cpp;fp=src%2Fcxcore%2Fcxpersistence.cpp;h=79d7bd14b47fdcb93b31ea2ee142308a192db071;hb=e4c14cdbdf2fe805e79cd96ded236f57e7b89060;hp=0000000000000000000000000000000000000000;hpb=454138ff8a20f6edb9b65a910101403d8b520643;p=opencv diff --git a/src/cxcore/cxpersistence.cpp b/src/cxcore/cxpersistence.cpp new file mode 100644 index 0000000..79d7bd1 --- /dev/null +++ b/src/cxcore/cxpersistence.cpp @@ -0,0 +1,5205 @@ +/*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. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000-2008, Intel Corporation, all rights reserved. +// Copyright (C) 2009, Willow Garage Inc., 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 the copyright holders 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 +#include +#include + +/****************************************************************************************\ +* 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; +} + +cv::string cv::FileStorage::getDefaultObjectName(const string& _filename) +{ + static const char* stubname = "unnamed"; + const char* filename = _filename.c_str(); + const char* ptr2 = filename + _filename.size(); + const char* ptr = ptr2 - 1; + cv::AutoBuffer name_buf(_filename.size()+1); + + while( ptr >= filename && *ptr != '\\' && *ptr != '/' && *ptr != ':' ) + { + if( *ptr == '.' && (!*ptr2 || strncmp(ptr2, ".gz", 3) == 0) ) + ptr2 = ptr; + ptr--; + } + ptr++; + if( ptr == ptr2 ) + CV_Error( CV_StsBadArg, "Invalid filename" ); + + char* 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 ); + return cv::string(name); +} + +namespace cv +{ + +string fromUtf16(const WString& str) +{ + cv::AutoBuffer _buf(str.size()*4 + 1); + char* buf = _buf; + + size_t sz = wcstombs(buf, str.c_str(), str.size()); + if( sz == (size_t)-1 ) + return string(); + buf[sz] = '\0'; + return string(buf); +} + +WString toUtf16(const string& str) +{ + cv::AutoBuffer _buf(str.size() + 1); + wchar_t* buf = _buf; + + size_t sz = mbstowcs(buf, str.c_str(), str.size()); + if( sz == (size_t)-1 ) + return WString(); + buf[sz] = '\0'; + return WString(buf); +} + +} + +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; + gzFile gzfile; + 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; + +static void icvPuts( CvFileStorage* fs, const char* str ) +{ + CV_Assert( fs->file || fs->gzfile ); + if( fs->file ) + fputs( str, fs->file ); + else + gzputs( fs->gzfile, str ); +} + +static char* icvGets( CvFileStorage* fs, char* str, int maxCount ) +{ + CV_Assert( fs->file || fs->gzfile ); + if( fs->file ) + return fgets( str, maxCount, fs->file ); + return gzgets( fs->gzfile, str, maxCount ); +} + +static int icvEof( CvFileStorage* fs ) +{ + CV_Assert( fs->file || fs->gzfile ); + if( fs->file ) + return feof(fs->file); + return gzeof(fs->gzfile); +} + +static void icvClose( CvFileStorage* fs ) +{ + if( fs->file ) + fclose( fs->file ); + if( fs->gzfile ) + gzclose( fs->gzfile ); + fs->file = 0; + fs->gzfile = 0; +} + +static void icvRewind( CvFileStorage* fs ) +{ + CV_Assert( fs->file || fs->gzfile ); + if( fs->file ) + rewind(fs->file); + else + gzrewind(fs->gzfile); +} + +#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 ) +{ + if( header_size < (int)sizeof(CvGenericHash) ) + CV_Error( CV_StsBadSize, "Too small map header_size" ); + + if( start_tab_size <= 0 ) + start_tab_size = 16; + + CvGenericHash* map = (CvGenericHash*)cvCreateSet( flags, header_size, elem_size, storage ); + + map->tab_size = start_tab_size; + start_tab_size *= sizeof(map->table[0]); + map->table = (void**)cvMemStorageAlloc( storage, start_tab_size ); + memset( map->table, 0, start_tab_size ); + + return map; +} + +#ifdef __GNUC__ +#define CV_PARSE_ERROR( errmsg ) \ + icvParseError( fs, __func__, (errmsg), __FILE__, __LINE__ ) +#else +#define CV_PARSE_ERROR( errmsg ) \ + icvParseError( fs, "", (errmsg), __FILE__, __LINE__ ) +#endif + +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 ) +{ + 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 <_>)" ); + } + + collection->data.map = cvCreateMap( 0, sizeof(CvFileNodeHash), + sizeof(CvFileMapNode), fs->memstorage, 16 ); + } + else + { + CvSeq* seq; + seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvFileNode), fs->memstorage ); + + // if 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 ); +} + + +/*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; + 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 ); + 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; + 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'; + icvPuts( fs, fs->buffer_start ); + 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 ) +{ + 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 || fs->gzfile) ) + { + if( fs->write_stack ) + { + while( fs->write_stack->total > 0 ) + cvEndWriteStruct(fs); + } + icvFSFlush(fs); + if( fs->is_xml ) + icvPuts( fs, "\n" ); + } + + //icvFSReleaseCollection( fs->roots ); // delete all the user types recursively + + icvClose(fs); + + cvReleaseMemStorage( &fs->strstorage ); + + cvFree( &fs->buffer_start ); + cvReleaseMemStorage( &fs->memstorage ); + + memset( fs, 0, sizeof(*fs) ); + cvFree( &fs ); + } +} + + +#define CV_HASHVAL_SCALE 33 + +CV_IMPL CvStringHashNode* +cvGetHashedKey( CvFileStorage* fs, const char* str, int len, int create_missing ) +{ + CvStringHashNode* node = 0; + unsigned hashval = 0; + int i, tab_size; + CvStringHash* map = fs->str_hash; + + if( !fs ) + return 0; + + 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; + node->str = cvMemStorageAllocString( map->storage, str, len ); + node->next = (CvStringHashNode*)(map->table[i]); + map->table[i] = node; + } + + return node; +} + + +CV_IMPL CvFileNode* +cvGetFileNode( CvFileStorage* fs, CvFileNode* _map_node, + const CvStringHashNode* key, + int create_missing ) +{ + CvFileNode* value = 0; + int k = 0, attempts = 1; + + if( !fs ) + return 0; + + CV_CHECK_FILE_STORAGE(fs); + + if( !key ) + CV_Error( CV_StsNullPtr, "Null key element" ); + + if( _map_node ) + { + if( !fs->roots ) + return 0; + 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" ); + return 0; + } + + 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; + return value; + } + 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; + } + } + + return value; +} + + +CV_IMPL CvFileNode* +cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* _map_node, const char* str ) +{ + CvFileNode* value = 0; + int i, len, tab_size; + unsigned hashval = 0; + int k = 0, attempts = 1; + + if( !fs ) + return 0; + + 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 ) + return 0; + 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" ); + return 0; + } + + 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; + return value; + } + } + } + + return value; +} + + +CV_IMPL CvFileNode* +cvGetRootFileNode( const CvFileStorage* fs, int stream_index ) +{ + CV_CHECK_FILE_STORAGE(fs); + + if( !fs->roots || (unsigned)stream_index >= (unsigned)fs->roots->total ) + return 0; + + return (CvFileNode*)cvGetSeqElem( fs->roots, stream_index ); +} + + +/* returns the sequence element by its index */ +/*CV_IMPL CvFileNode* +cvGetFileNodeFromSeq( CvFileStorage* fs, + CvFileNode* seq_node, int index ) +{ + CvFileNode* value = 0; + 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 ); + + + + 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 ) +{ + 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; +} + + +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 ) +{ + for(;;) + { + while( *ptr == ' ' ) + ptr++; + if( *ptr == '#' ) + { + if( ptr - fs->buffer_start > max_comment_indent ) + return ptr; + *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 = icvGets( fs, fs->buffer_start, max_size ); + 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' && !icvEof(fs) ) + 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" ); + } + + return ptr; +} + + +static char* +icvYMLParseKey( CvFileStorage* fs, char* ptr, + CvFileNode* map_node, CvFileNode** value_placeholder ) +{ + 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" ); + + str_hash_node = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 ); + *value_placeholder = cvGetFileNode( fs, map_node, str_hash_node, 1 ); + ptr = saveptr; + + return ptr; +} + + +static char* +icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, + int parent_flags, int min_indent ) +{ + 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) ) + { + node->info = cvFindType( ptr ); + if( !node->info ) + node->tag &= ~CV_NODE_USER; + } + + *endptr = d; + 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) ) + 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" ); + + 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; + + icvFSCreateCollection( fs, CV_NODE_TYPE(struct_flags) + + (node->info ? CV_NODE_USER : 0), node ); + + d = c == '[' ? ']' : '}'; + + for( ++ptr ;;) + { + CvFileNode* elem = 0; + + 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" ); + ptr = icvYMLSkipSpaces( fs, ptr + 1, new_min_indent, INT_MAX ); + } + + if( CV_NODE_IS_MAP(struct_flags) ) + { + ptr = icvYMLParseKey( fs, ptr, node, &elem ); + ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ); + } + else + { + if( *ptr == ']' ) + break; + elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ); + } + 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++; + node->data.str = cvMemStorageAllocString( fs->memstorage, ptr, (int)(str_end - ptr) ); + ptr = endptr; + return ptr; + } + struct_flags = CV_NODE_MAP; + } + else + struct_flags = CV_NODE_SEQ; + + 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) ) + { + ptr = icvYMLParseKey( fs, ptr, node, &elem ); + } + else + { + c = *ptr++; + if( c != '-' ) + CV_PARSE_ERROR( "Block sequence elements must be preceded with \'-\'" ); + + elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ); + } + + ptr = icvYMLSkipSpaces( fs, ptr, indent + 1, INT_MAX ); + 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); + + 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; + } + + return ptr; +} + + +static void +icvYMLParse( CvFileStorage* fs ) +{ + char* ptr = fs->buffer_start; + int is_first = 1; + + for(;;) + { + // 0. skip leading comments and directives and ... + // 1. reach the first item + for(;;) + { + ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); + if( !ptr ) + return; + + 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" ); + } + + ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); + if( memcmp( ptr, "...", 3 ) != 0 ) + { + // 2. parse the collection + CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 ); + + 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 + ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); + if( !ptr ) + return; + } + + if( fs->dummy_eof ) + break; + ptr += 3; + is_first = 0; + } +} + + +/****************************************************************************************\ +* YAML Emitter * +\****************************************************************************************/ + +static void +icvYMLWrite( CvFileStorage* fs, const char* key, const char* data ) +{ + 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, "Key names may only contain alphanumeric characters [a-zA-Z0-9], '-', '_' and ' '" ); + } + + 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; +} + + +static void +icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, + const char* type_name CV_DEFAULT(0)) +{ + 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; + } + + icvYMLWrite( fs, key, data ); + + 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); +} + + +static void +icvYMLEndWriteStruct( CvFileStorage* fs ) +{ + 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; +} + + +static void +icvYMLStartNextStream( CvFileStorage* fs ) +{ + if( !fs->is_first ) + { + while( fs->write_stack->total > 0 ) + icvYMLEndWriteStruct(fs); + + fs->struct_indent = 0; + icvFSFlush(fs); + icvPuts( fs, "...\n" ); + icvPuts( fs, "---\n" ); + fs->buffer = fs->buffer_start; + } +} + + +static void +icvYMLWriteInt( CvFileStorage* fs, const char* key, int value ) +{ + char buf[128]; + icvYMLWrite( fs, key, icv_itoa( value, buf, 10 )); +} + + +static void +icvYMLWriteReal( CvFileStorage* fs, const char* key, double value ) +{ + char buf[128]; + icvYMLWrite( fs, key, icvDoubleToString( buf, value )); +} + + +static void +icvYMLWriteString( CvFileStorage* fs, const char* key, + const char* str, int quote CV_DEFAULT(0)) +{ + 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; + } + + icvYMLWrite( fs, key, data ); +} + + +static void +icvYMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ) +{ + 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 ); + } +} + + +/****************************************************************************************\ +* 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 ) +{ + 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 ) + return ptr; + } 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 = icvGets( fs, fs->buffer_start, max_size ); + 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' && !icvEof(fs) ) + CV_PARSE_ERROR( "Too long string or a last string w/o newline" ); + } + fs->lineno++; + } + } + 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)) +{ + 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] == '-') ) + { + 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; + + 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_SEQ; + else + { + 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) ) + { + 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 + elem = cvGetFileNode( fs, node, key, 1 ); + + 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; + 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) ) + 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) ) + 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" ); + } + 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) ) + { + 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; + 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); + 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 == '-' ); + + 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; + + 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 != '=' ) + { + ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ); + if( *ptr != '=' ) + CV_PARSE_ERROR( "Attribute name should be followed by \'=\'" ); + } + + c = *++ptr; + if( c != '\"' && c != '\'' ) + { + 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 != '>' ) + { + 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 ' ) + CV_PARSE_ERROR( "Invalid closing tag for ' && 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" ); + } + + *_tag = tagname; + *_tag_type = tag_type; + *_list = first; + + return ptr; +} + + +static void +icvXMLParse( CvFileStorage* fs ) +{ + 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 + ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ); + + if( memcmp( ptr, "\'" ); + + 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' ) + { + ptr = icvXMLSkipSpaces( fs, ptr, 0 ); + + if( *ptr != '\0' ) + { + CvFileNode* root_node; + 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( " tag is missing" ); + + root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 ); + ptr = icvXMLParseValue( fs, ptr, root_node, CV_NODE_NONE ); + ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type ); + if( tag_type != CV_XML_CLOSING_TAG || key != key2 ) + CV_PARSE_ERROR( " tag is missing" ); + ptr = icvXMLSkipSpaces( fs, ptr, 0 ); + } + } + + assert( fs->dummy_eof != 0 ); +} + + +/****************************************************************************************\ +* XML Emitter * +\****************************************************************************************/ + +#define icvXMLFlush icvFSFlush + +static void +icvXMLWriteTag( CvFileStorage* fs, const char* key, int tag_type, CvAttrList list ) +{ + 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, "Key name may only contain alphanumeric characters [a-zA-Z0-9], '-' and '_'" ); + 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; +} + + +static void +icvXMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, + const char* type_name CV_DEFAULT(0)) +{ + 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; + + 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 ) + { + fs->struct_tag = cvMemStorageAllocString( fs->strstorage, (char*)key, -1 ); + } + else + { + fs->struct_tag.ptr = 0; + fs->struct_tag.len = 0; + } +} + + +static void +icvXMLEndWriteStruct( CvFileStorage* fs ) +{ + CvXMLStackRecord parent; + + if( fs->write_stack->total == 0 ) + CV_Error( CV_StsError, "An extra closing tag" ); + + 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 ); +} + + +static void +icvXMLStartNextStream( CvFileStorage* fs ) +{ + 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" */ + icvPuts( fs, "\n\n" ); + /*fputs( "\n", fs->file ); + fputs( "\n", fs->file );*/ + fs->buffer = fs->buffer_start; + } +} + + +static void +icvXMLWriteScalar( CvFileStorage* fs, const char* key, const char* data, int len ) +{ + 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; + } +} + + +static void +icvXMLWriteInt( CvFileStorage* fs, const char* key, int value ) +{ + char buf[128], *ptr = icv_itoa( value, buf, 10 ); + int len = (int)strlen(ptr); + icvXMLWriteScalar( fs, key, ptr, len ); +} + + +static void +icvXMLWriteReal( CvFileStorage* fs, const char* key, double value ) +{ + char buf[128]; + int len = (int)strlen( icvDoubleToString( buf, value )); + icvXMLWriteScalar( fs, key, buf, len ); +} + + +static void +icvXMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote ) +{ + 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 ); +} + + +static void +icvXMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ) +{ + 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, "", comment ); + len = (int)strlen(ptr); + } + else + { + strcpy( ptr, "" ); + fs->buffer = ptr + 3; + icvXMLFlush( fs ); + } +} + + +/****************************************************************************************\ +* Common High-Level Functions * +\****************************************************************************************/ + +CV_IMPL CvFileStorage* +cvOpenFileStorage( const char* filename, CvMemStorage* dststorage, int flags ) +{ + CvFileStorage* fs = 0; + char* xml_buf = 0; + int default_block_size = 1 << 18; + bool append = (flags & 3) == CV_STORAGE_APPEND; + bool isGZ = false; + + if( !filename ) + CV_Error( CV_StsNullPtr, "NULL filename" ); + + fs = (CvFileStorage*)cvAlloc( sizeof(*fs) ); + memset( fs, 0, sizeof(*fs)); + + fs->memstorage = cvCreateMemStorage( default_block_size ); + fs->dststorage = dststorage ? dststorage : fs->memstorage; + + int fnamelen = (int)strlen(filename); + if( !fnamelen ) + CV_Error( CV_StsError, "Empty filename" ); + + fs->filename = (char*)cvMemStorageAlloc( fs->memstorage, fnamelen+1 ); + strcpy( fs->filename, filename ); + + char* dot_pos = strrchr(fs->filename, '.'); + char compression = '\0'; + + if( dot_pos && dot_pos[1] == 'g' && dot_pos[2] == 'z' && + (dot_pos[3] == '\0' || (isdigit(dot_pos[3]) && dot_pos[4] == '\0')) ) + { + if( append ) + CV_Error(CV_StsNotImplemented, "Appending data to compressed file is not implemented" ); + isGZ = true; + compression = dot_pos[3]; + if( compression ) + dot_pos[3] = '\0', fnamelen--; + } + + fs->flags = CV_FILE_STORAGE; + fs->write_mode = (flags & 3) != 0; + + if( !isGZ ) + { + fs->file = fopen(fs->filename, !fs->write_mode ? "rt" : !append ? "wt" : "a+t" ); + if( !fs->file ) + goto _exit_; + } + else + { + char mode[] = { fs->write_mode ? 'w' : 'r', 'b', compression ? compression : '3', '\0' }; + fs->gzfile = gzopen(fs->filename, mode); + if( !fs->gzfile ) + goto _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; + + dot_pos = fs->filename + fnamelen - (isGZ ? 7 : 4); + fs->is_xml = dot_pos > fs->filename && (memcmp( dot_pos, ".xml", 4) == 0 || + memcmp(dot_pos, ".XML", 4) == 0 || memcmp(dot_pos, ".Xml", 4) == 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; + 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 = fs->file ? (int)ftell( fs->file ) : 0; + fs->strstorage = cvCreateChildMemStorage( fs->memstorage ); + if( !append || file_size == 0 ) + { + icvPuts( fs, "\n" ); + icvPuts( fs, "\n" ); + } + else + { + int xml_buf_size = 1 << 10; + char substr[] = ""; + int last_occurence = -1; + xml_buf_size = MIN(xml_buf_size, file_size); + fseek( fs->file, -xml_buf_size, SEEK_END ); + xml_buf = (char*)cvAlloc( xml_buf_size+2 ); + // find the last occurence of + for(;;) + { + int line_offset = ftell( fs->file ); + char* ptr0 = icvGets( fs, xml_buf, xml_buf_size ), *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 in the end of file.\n" ); + icvClose( fs ); + fs->file = fopen( fs->filename, "r+t" ); + fseek( fs->file, last_occurence, SEEK_SET ); + // replace the last "" with " ", which has the same length + icvPuts( fs, " " ); + fseek( fs->file, 0, SEEK_END ); + icvPuts( fs, "\n" ); + } + 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 ) + icvPuts( fs, "%YAML:1.0\n" ); + else + icvPuts( fs, "...\n---\n" ); + 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 = 1 << 20; + const char* yaml_signature = "%YAML:"; + char buf[16]; + icvGets( fs, buf, sizeof(buf)-2 ); + fs->is_xml = strncmp( buf, yaml_signature, strlen(yaml_signature) ) != 0; + + if( !isGZ ) + { + fseek( fs->file, 0, SEEK_END ); + buf_size = ftell( fs->file ); + buf_size = MIN( buf_size, (1 << 20) ); + buf_size = MAX( buf_size, CV_FS_MAX_LEN*2 + 1024 ); + } + icvRewind(fs); + + fs->str_hash = cvCreateMap( 0, sizeof(CvStringHash), + sizeof(CvStringHashNode), fs->memstorage, 256 ); + + fs->roots = cvCreateSeq( 0, sizeof(CvSeq), + sizeof(CvFileNode), fs->memstorage ); + + 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; + } +_exit_: + if( fs ) + { + if( cvGetErrStatus() < 0 || (!fs->file && !fs->gzfile) ) + { + cvReleaseFileStorage( &fs ); + } + else if( !fs->write_mode ) + { + icvClose(fs); + } + } + + cvFree( &xml_buf ); + return fs; +} + + +CV_IMPL void +cvStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, + const char* type_name, CvAttrList /*attributes*/ ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->start_write_struct( fs, key, struct_flags, type_name ); +} + + +CV_IMPL void +cvEndWriteStruct( CvFileStorage* fs ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->end_write_struct( fs ); +} + + +CV_IMPL void +cvWriteInt( CvFileStorage* fs, const char* key, int value ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->write_int( fs, key, value ); +} + + +CV_IMPL void +cvWriteReal( CvFileStorage* fs, const char* key, double value ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->write_real( fs, key, value ); +} + + +CV_IMPL void +cvWriteString( CvFileStorage* fs, const char* key, const char* value, int quote ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->write_string( fs, key, value, quote ); +} + + +CV_IMPL void +cvWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->write_comment( fs, comment, eol_comment ); +} + + +CV_IMPL void +cvStartNextStream( CvFileStorage* fs ) +{ + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + fs->start_next_stream( fs ); +} + + +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; + int i = 0, k = 0, len = dt ? (int)strlen(dt) : 0; + + if( !dt || !len ) + return 0; + + 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; + return fmt_pair_count; +} + + +static int +icvCalcElemSize( const char* dt, int initial_size ) +{ + int size = 0; + int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count; + int comp_size; + + 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 ); + } + return size; +} + + +static int +icvDecodeSimpleFormat( const char* dt ) +{ + int elem_type = -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 != 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] ); + + return elem_type; +} + + +CV_IMPL void +cvWriteRawData( CvFileStorage* fs, const void* _data, int len, const char* dt ) +{ + const char* data0 = (const char*)_data; + 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" ); + + fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ); + + if( !len ) + return; + + 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); + return; + } + + if( fs->is_xml ) + { + int buf_len = (int)strlen(ptr); + icvXMLWriteScalar( fs, 0, ptr, buf_len ); + } + else + icvYMLWrite( fs, 0, ptr ); + } + + offset = (int)(data - data0); + } + } +} + + +CV_IMPL void +cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader ) +{ + 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 ) + { + 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" ); +} + + +CV_IMPL void +cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader, + int len, void* _data, const char* dt ) +{ + char* data0 = (char*)_data; + 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" ); + + 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); + data++; + 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); + return; + } + } + 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); + data++; + 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); + return; + } + } + 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); +} + + +CV_IMPL void +cvReadRawData( const CvFileStorage* fs, const CvFileNode* src, + void* data, const char* dt ) +{ + CvSeqReader reader; + + if( !src || !data ) + CV_Error( CV_StsNullPtr, "Null pointers to source file node or destination array" ); + + cvStartReadRawData( fs, src, &reader ); + cvReadRawDataSlice( fs, &reader, CV_NODE_IS_SEQ(src->tag) ? + src->data.seq->total : 1, data, dt ); +} + + +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 ) +{ + 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" ); + } +} + + +CV_IMPL void +cvWriteFileNode( CvFileStorage* fs, const char* new_node_name, + const CvFileNode* node, int embed ) +{ + CvFileStorage* dst = 0; + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + + if( !node ) + return; + + if( CV_NODE_IS_COLLECTION(node->tag) && embed ) + { + icvWriteCollection( fs, node ); + } + else + { + 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 ); + }*/ + 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*/ ) +{ + const CvMat* mat = (const CvMat*)struct_ptr; + char dt[16]; + CvSize size; + int y; + + assert( CV_IS_MAT(mat) ); + + 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 ); +} + + +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; + CvMat* mat; + const char* dt; + CvFileNode* data; + int rows, cols, elem_type; + + 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" ); + + 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" ); + + mat = cvCreateMat( rows, cols, elem_type ); + cvReadRawData( fs, data, mat->data.ptr, dt ); + + ptr = mat; + 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*/ ) +{ + void* mat = (void*)struct_ptr; + CvMatND stub; + CvNArrayIterator iterator; + int dims, sizes[CV_MAX_DIM]; + char dt[16]; + + assert( CV_IS_MATND(mat) ); + + 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 ); + + cvInitNArrayIterator( 1, &mat, 0, &stub, &iterator ); + + do + cvWriteRawData( fs, iterator.ptr[0], iterator.size.width, dt ); + while( cvNextNArraySlice( &iterator )); + cvEndWriteStruct( fs ); + cvEndWriteStruct( fs ); +} + + +static void* +icvReadMatND( CvFileStorage* fs, CvFileNode* node ) +{ + void* ptr = 0; + CvMatND* mat; + const char* dt; + CvFileNode* data; + CvFileNode* sizes_node; + int sizes[CV_MAX_DIM], dims, elem_type; + int i, total_size; + + 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" ); + + cvReadRawData( fs, sizes_node, sizes, "i" ); + 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" ); + + mat = cvCreateMatND( dims, sizes, elem_type ); + cvReadRawData( fs, data, mat->data.ptr, dt ); + + ptr = mat; + 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; + 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) ); + + memstorage = cvCreateMemStorage(); + + 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 ); + cvReleaseMemStorage( &memstorage ); +} + + +static void* +icvReadSparseMat( CvFileStorage* fs, CvFileNode* node ) +{ + void* ptr = 0; + 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; + + 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*)cvStackAlloc( dims*sizeof(sizes[0])); + cvReadRawData( fs, sizes_node, sizes, "i" ); + 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" ); + + 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++; + val = cvPtrND( mat, idx, 0, 1, 0 ); + cvReadRawDataSlice( fs, &reader, cn, val, dt ); + i += cn; + } + + ptr = mat; + 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*/ ) +{ + 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" ); + + 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 = IplToCvDepth(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 ); +} + + +static void* +icvReadImage( CvFileStorage* fs, CvFileNode* node ) +{ + void* ptr = 0; + 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; + + 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" ); + + 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 = cvIplDepth(elem_type); + 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++ ) + { + cvReadRawDataSlice( fs, &reader, width, + image->imageData + y*image->widthStep, dt ); + } + + ptr = image; + return ptr; +} + + +/******************************* CvSeq ******************************/ + +static int +icvIsSeq( const void* ptr ) +{ + return CV_IS_SEQ(ptr); +} + + +static void +icvReleaseSeq( void** ptr ) +{ + if( !ptr ) + CV_Error( CV_StsNullPtr, "NULL double pointer" ); + *ptr = 0; // it's impossible now to release seq, so just clear the pointer +} + + +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 ) +{ + char header_dt_buf[128]; + const char* header_dt = cvAttrValue( attr, "header_dt" ); + + if( header_dt ) + { + int dt_header_size; + 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 ); + } +} + + +static char* +icvGetFormat( const CvSeq* seq, const char* dt_key, CvAttrList* attr, + int initial_elem_size, char* dt_buf ) +{ + char* dt = 0; + dt = (char*)cvAttrValue( attr, dt_key ); + + if( dt ) + { + int dt_elem_size; + 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; + } + + return dt; +} + + +static void +icvWriteSeq( CvFileStorage* fs, const char* name, + const void* struct_ptr, + CvAttrList attr, int level ) +{ + const CvSeq* seq = (CvSeq*)struct_ptr; + CvSeqBlock* block; + char buf[128]; + char dt_buf[128], *dt; + + assert( CV_IS_SEQ( seq )); + 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 ); + dt = icvGetFormat( seq, "dt", &attr, 0, dt_buf ); + cvWriteString( fs, "dt", dt, 0 ); + + 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 ); +} + + +static void +icvWriteSeqTree( CvFileStorage* fs, const char* name, + const void* struct_ptr, CvAttrList attr ) +{ + const CvSeq* seq = (CvSeq*)struct_ptr; + const char* recursive_value = cvAttrValue( &attr, "recursive" ); + int is_recursive = recursive_value && + strcmp(recursive_value,"0") != 0 && + strcmp(recursive_value,"false") != 0 && + strcmp(recursive_value,"False") != 0 && + strcmp(recursive_value,"FALSE") != 0; + + assert( CV_IS_SEQ( seq )); + + if( !is_recursive ) + { + icvWriteSeq( fs, name, seq, attr, -1 ); + } + else + { + CvTreeNodeIterator tree_iterator; + + cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ_TREE ); + cvStartWriteStruct( fs, "sequences", CV_NODE_SEQ ); + cvInitTreeNodeIterator( &tree_iterator, seq, INT_MAX ); + + for(;;) + { + if( !tree_iterator.node ) + break; + icvWriteSeq( fs, 0, tree_iterator.node, attr, tree_iterator.level ); + cvNextTreeNode( &tree_iterator ); + } + + cvEndWriteStruct( fs ); + cvEndWriteStruct( fs ); + } +} + + +static void* +icvReadSeq( CvFileStorage* fs, CvFileNode* node ) +{ + void* ptr = 0; + 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; + + 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 ) + { + header_size = icvCalcElemSize( header_dt, header_size ); + } + else if( rect_node ) + header_size = sizeof(CvPoint2DSeq); + else if( origin_node ) + header_size = sizeof(CvChain); + + elem_size = icvCalcElemSize( dt, 0 ); + seq = cvCreateSeq( flags, header_size, elem_size, fs->dststorage ); + + if( header_node ) + { + 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 ); + 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; + return ptr; +} + + +static void* +icvReadSeqTree( CvFileStorage* fs, CvFileNode* node ) +{ + void* ptr = 0; + 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; + seq = (CvSeq*)cvRead( fs, elem ); + 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; + return ptr; +} + +/******************************* CvGraph ******************************/ + +static int +icvIsGraph( const void* ptr ) +{ + return CV_IS_GRAPH(ptr); +} + + +static void +icvReleaseGraph( void** ptr ) +{ + if( !ptr ) + CV_Error( CV_StsNullPtr, "NULL double pointer" ); + + *ptr = 0; // it's impossible now to release graph, so just clear the pointer +} + + +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; + 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 ); + 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 + 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 ); + 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 ); + 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 ); + + 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 ); + 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 ); + } + + cvFree( &write_buf ); + cvFree( &flag_buf ); +} + + +static void* +icvReadGraph( CvFileStorage* fs, CvFileNode* node ) +{ + void* ptr = 0; + char* read_buf = 0; + CvGraphVtx** vtx_buf = 0; + 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; + + 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 ) + header_size = icvCalcElemSize( header_dt, header_size ); + + if( vtx_dt > 0 ) + { + src_vtx_size = icvCalcElemSize( vtx_dt, 0 ); + vtx_size = icvCalcElemSize( vtx_dt, vtx_size ); + 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; + + 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; + } + + edge_size = icvCalcElemSize( dst_edge_dt, sizeof(CvGraphEdge) ); + src_edge_size = icvCalcElemSize( edge_dt, 0 ); + } + + graph = cvCreateGraph( flags, header_size, vtx_size, edge_size, fs->dststorage ); + + if( header_node ) + 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 ); + read_buf = (char*)cvAlloc( read_buf_size ); + 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" ); + + 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; + 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 ) +{ + 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 _" ); + } + + info = (CvTypeInfo*)malloc( 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; +} + + +CV_IMPL void +cvUnregisterType( const char* type_name ) +{ + CvTypeInfo* info; + + 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; + + free( info ); + } +} + + +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 ) +{ + CvTypeInfo* info; + + if( !struct_ptr ) + CV_Error( CV_StsNullPtr, "NULL double pointer" ); + + if( *struct_ptr ) + { + 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" ); + + info->release( struct_ptr ); + *struct_ptr = 0; + } +} + + +void* cvClone( const void* struct_ptr ) +{ + void* struct_copy = 0; + CvTypeInfo* info; + + if( !struct_ptr ) + CV_Error( CV_StsNullPtr, "NULL structure pointer" ); + + 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" ); + + struct_copy = info->clone( struct_ptr ); + return struct_copy; +} + + +/* reads matrix, image, sequence, graph etc. */ +CV_IMPL void* +cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* list ) +{ + void* obj = 0; + CV_CHECK_FILE_STORAGE( fs ); + + if( !node ) + return 0; + + if( !CV_NODE_IS_USER(node->tag) || !node->info ) + CV_Error( CV_StsError, "The node does not represent a user object (unknown type?)" ); + + obj = node->info->read( fs, node ); + 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 ) +{ + CvTypeInfo* info; + + CV_CHECK_OUTPUT_FILE_STORAGE( fs ); + + if( !ptr ) + CV_Error( CV_StsNullPtr, "Null pointer to the written object" ); + + 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" ); + + info->write( fs, name, ptr, attributes ); +} + + +/* 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; + + if( !struct_ptr ) + CV_Error( CV_StsNullPtr, "NULL object pointer" ); + + fs = cvOpenFileStorage( filename, 0, CV_STORAGE_WRITE ); + if( !fs ) + CV_Error( CV_StsError, "Could not open the file storage. Check the path and permissions" ); + + cv::string name = _name ? cv::string(_name) : cv::FileStorage::getDefaultObjectName(filename); + + if( comment ) + cvWriteComment( fs, comment, 0 ); + cvWrite( fs, name.c_str(), struct_ptr, attributes ); + 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; + + CvFileNode* node = 0; + fs = cvOpenFileStorage( filename, memstorage, CV_STORAGE_READ ); + + if( !fs ) + return 0; + + if( name ) + { + 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 ); + 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" ); + + if( cvGetErrStatus() < 0 ) + { + cvRelease( (void**)&ptr ); + real_name = 0; + } + + if( _real_name) + { + if (real_name) + { + *_real_name = (const char*)cvAlloc(strlen(real_name)); + memcpy((void*)*_real_name, real_name, strlen(real_name)); + } else { + *_real_name = 0; + } + } +exit: + cvReleaseFileStorage( &fs ); + + return ptr; +} + + +///////////////////////// new C++ interface for CvFileStorage /////////////////////////// + +namespace cv +{ + +static void getElemSize( const string& fmt, size_t& elemSize, size_t& cn ) +{ + const char* dt = fmt.c_str(); + cn = 1; + if( isdigit(dt[0]) ) + { + cn = dt[0] - '0'; + dt++; + } + char c = dt[0]; + elemSize = cn*(c == 'u' || c == 'c' ? sizeof(uchar) : c == 'w' || c == 's' ? sizeof(ushort) : + c == 'i' ? sizeof(int) : c == 'f' ? sizeof(float) : c == 'd' ? sizeof(double) : + c == 'r' ? sizeof(void*) : (size_t)0); +} + +FileStorage::FileStorage() +{ + state = UNDEFINED; +} + +FileStorage::FileStorage(const string& filename, int flags) +{ + state = UNDEFINED; + open( filename, flags ); +} + +FileStorage::FileStorage(CvFileStorage* _fs) +{ + fs = Ptr(_fs); + state = _fs ? NAME_EXPECTED + INSIDE_MAP : UNDEFINED; +} + +FileStorage::~FileStorage() +{ + while( structs.size() > 0 ) + { + cvEndWriteStruct(fs); + structs.pop_back(); + } +} + +bool FileStorage::open(const string& filename, int flags) +{ + release(); + fs = Ptr(cvOpenFileStorage( filename.c_str(), 0, flags )); + bool ok = isOpened(); + state = ok ? NAME_EXPECTED + INSIDE_MAP : UNDEFINED; + return ok; +} + +bool FileStorage::isOpened() const +{ + return !fs.empty(); +} + +void FileStorage::release() +{ + fs.release(); + structs.clear(); + state = UNDEFINED; +} + +FileNode FileStorage::root(int streamidx) const +{ + return isOpened() ? FileNode(fs, cvGetRootFileNode(fs, streamidx)) : FileNode(); +} + +FileStorage& operator << (FileStorage& fs, const string& str) +{ + enum { NAME_EXPECTED = FileStorage::NAME_EXPECTED, + VALUE_EXPECTED = FileStorage::VALUE_EXPECTED, + INSIDE_MAP = FileStorage::INSIDE_MAP }; + const char* _str = str.c_str(); + if( !fs.isOpened() || !_str ) + return fs; + if( *_str == '}' || *_str == ']' ) + { + if( fs.structs.empty() ) + CV_Error_( CV_StsError, ("Extra closing '%c'", *_str) ); + if( (*_str == ']' ? '[' : '{') != fs.structs.back() ) + CV_Error_( CV_StsError, + ("The closing '%c' does not match the opening '%c'", *_str, fs.structs.back())); + fs.structs.pop_back(); + fs.state = fs.structs.empty() || fs.structs.back() == '{' ? + INSIDE_MAP + NAME_EXPECTED : VALUE_EXPECTED; + cvEndWriteStruct( *fs ); + fs.elname = string(); + } + else if( fs.state == NAME_EXPECTED + INSIDE_MAP ) + { + if( !isalpha(*_str) ) + CV_Error_( CV_StsError, ("Incorrect element name %s", _str) ); + fs.elname = str; + fs.state = VALUE_EXPECTED + INSIDE_MAP; + } + else if( (fs.state & 3) == VALUE_EXPECTED ) + { + if( *_str == '{' || *_str == '[' ) + { + fs.structs.push_back(*_str); + int flags = *_str++ == '{' ? CV_NODE_MAP : CV_NODE_SEQ; + fs.state = flags == CV_NODE_MAP ? INSIDE_MAP + + NAME_EXPECTED : VALUE_EXPECTED; + if( *_str == ':' ) + { + flags |= CV_NODE_FLOW; + _str++; + } + cvStartWriteStruct( *fs, fs.elname.size() > 0 ? fs.elname.c_str() : 0, + flags, *_str ? _str : 0 ); + fs.elname = string(); + } + else + { + write( fs, fs.elname, (_str[0] == '\\' && (_str[1] == '{' || _str[1] == '}' || + _str[1] == '[' || _str[1] == ']')) ? string(_str+1) : str ); + if( fs.state == INSIDE_MAP + VALUE_EXPECTED ) + fs.state = INSIDE_MAP + NAME_EXPECTED; + } + } + else + CV_Error( CV_StsError, "Invalid fs.state" ); + return fs; +} + + +void FileStorage::writeRaw( const string& fmt, const uchar* vec, size_t len ) +{ + if( !isOpened() ) + return; + size_t elemSize, cn; + getElemSize( fmt, elemSize, cn ); + CV_Assert( len % elemSize == 0 ); + cvWriteRawData( fs, vec, (int)(len/elemSize), fmt.c_str()); +} + + +void FileStorage::writeObj( const string& name, const void* obj ) +{ + if( !isOpened() ) + return; + cvWrite( fs, name.size() > 0 ? name.c_str() : 0, obj ); +} + + +void* FileNode::readObj() const +{ + if( !fs || !node ) + return 0; + return cvRead( (CvFileStorage*)fs, (CvFileNode*)node ); +} + + +FileNodeIterator::FileNodeIterator() +{ + fs = 0; + container = 0; + reader.ptr = 0; + remaining = 0; +} + +FileNodeIterator::FileNodeIterator(const CvFileStorage* _fs, + const CvFileNode* _node, size_t _ofs) +{ + if( _fs && _node ) + { + int node_type = _node->tag & FileNode::TYPE_MASK; + fs = _fs; + container = _node; + if( node_type == FileNode::SEQ || node_type == FileNode::MAP ) + { + cvStartReadSeq( _node->data.seq, &reader ); + remaining = FileNode(_fs, _node).size(); + } + else + { + reader.ptr = (schar*)_node; + reader.seq = 0; + remaining = 1; + } + (*this) += (int)_ofs; + } + else + { + fs = 0; + container = 0; + reader.ptr = 0; + remaining = 0; + } +} + +FileNodeIterator::FileNodeIterator(const FileNodeIterator& it) +{ + fs = it.fs; + container = it.container; + reader = it.reader; + remaining = it.remaining; +} + +FileNodeIterator& FileNodeIterator::operator ++() +{ + if( remaining > 0 ) + { + if( reader.seq ) + CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); + remaining--; + } + return *this; +} + +FileNodeIterator FileNodeIterator::operator ++(int) +{ + FileNodeIterator it = *this; + ++(*this); + return it; +} + +FileNodeIterator& FileNodeIterator::operator --() +{ + if( remaining < FileNode(fs, container).size() ) + { + if( reader.seq ) + CV_PREV_SEQ_ELEM( reader.seq->elem_size, reader ); + remaining++; + } + return *this; +} + +FileNodeIterator FileNodeIterator::operator --(int) +{ + FileNodeIterator it = *this; + --(*this); + return it; +} + +FileNodeIterator& FileNodeIterator::operator += (int ofs) +{ + if( ofs == 0 ) + return *this; + if( ofs > 0 ) + ofs = std::min(ofs, (int)remaining); + else + { + size_t count = FileNode(fs, container).size(); + ofs = (int)(remaining - std::min(remaining - ofs, count)); + } + remaining -= ofs; + if( reader.seq ) + cvSetSeqReaderPos( &reader, ofs, 1 ); + return *this; +} + +FileNodeIterator& FileNodeIterator::operator -= (int ofs) +{ + return operator += (-ofs); +} + + +FileNodeIterator& FileNodeIterator::readRaw( const string& fmt, uchar* vec, size_t maxCount ) +{ + if( fs && container && remaining > 0 ) + { + size_t elem_size, cn; + getElemSize( fmt, elem_size, cn ); + CV_Assert( elem_size > 0 ); + size_t count = std::min(remaining, maxCount); + + if( reader.seq ) + { + cvReadRawDataSlice( fs, &reader, (int)count, vec, fmt.c_str() ); + remaining -= count*cn; + } + else + { + cvReadRawData( fs, container, vec, fmt.c_str() ); + remaining = 0; + } + } + return *this; +} + +void write( FileStorage& fs, const string& name, const Mat& value ) +{ + CvMat mat = value; + cvWrite( *fs, name.size() ? name.c_str() : 0, &mat ); +} + +void write( FileStorage& fs, const string& name, const MatND& value ) +{ + CvMatND mat = value; + cvWrite( *fs, name.size() ? name.c_str() : 0, &mat ); +} + +// TODO: the 4 functions below need to be implemented more efficiently +void write( FileStorage& fs, const string& name, const SparseMat& value ) +{ + Ptr mat = (CvSparseMat*)value; + cvWrite( *fs, name.size() ? name.c_str() : 0, mat ); +} + + +void read( const FileNode& node, Mat& mat, const Mat& default_mat ) +{ + if( node.empty() ) + { + default_mat.copyTo(mat); + return; + } + Ptr m = (CvMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node); + CV_Assert(CV_IS_MAT(m)); + Mat(m).copyTo(mat); +} + +void read( const FileNode& node, MatND& mat, const MatND& default_mat ) +{ + if( node.empty() ) + { + default_mat.copyTo(mat); + return; + } + Ptr m = (CvMatND*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node); + CV_Assert(CV_IS_MATND(m)); + MatND(m).copyTo(mat); +} + +void read( const FileNode& node, SparseMat& mat, const SparseMat& default_mat ) +{ + if( node.empty() ) + { + default_mat.copyTo(mat); + return; + } + Ptr m = (CvSparseMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node); + CV_Assert(CV_IS_SPARSE_MAT(m)); + SparseMat(m).copyTo(mat); +} + +} + +/* End of file. */