1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #include "_cxcore.h"
43 #include <ctype.h>
44
45 /****************************************************************************************\
46 * Common macros and type definitions *
47 \****************************************************************************************/
48
49 #define cv_isprint(c) ((signed char)(c) >= (signed char)' ')
50 #define cv_isprint_or_tab(c) ((signed char)(c) >= (signed char)' ' || (c) == '\t')
51
icv_itoa(int _val,char * buffer,int)52 static char* icv_itoa( int _val, char* buffer, int /*radix*/ )
53 {
54 const int radix = 10;
55 char* ptr=buffer + 23 /* enough even for 64-bit integers */;
56 unsigned val = abs(_val);
57
58 *ptr = '\0';
59 do
60 {
61 unsigned r = val / radix;
62 *--ptr = (char)(val - (r*radix) + '0');
63 val = r;
64 }
65 while( val != 0 );
66
67 if( _val < 0 )
68 *--ptr = '-';
69
70 return ptr;
71 }
72
73
74 typedef struct CvGenericHash
75 {
76 CV_SET_FIELDS()
77 int tab_size;
78 void** table;
79 }
80 CvGenericHash;
81
82 typedef CvGenericHash CvStringHash;
83
84 typedef struct CvFileMapNode
85 {
86 CvFileNode value;
87 const CvStringHashNode* key;
88 struct CvFileMapNode* next;
89 }
90 CvFileMapNode;
91
92 typedef struct CvXMLStackRecord
93 {
94 CvMemStoragePos pos;
95 CvString struct_tag;
96 int struct_indent;
97 int struct_flags;
98 }
99 CvXMLStackRecord;
100
101 #define CV_XML_OPENING_TAG 1
102 #define CV_XML_CLOSING_TAG 2
103 #define CV_XML_EMPTY_TAG 3
104 #define CV_XML_HEADER_TAG 4
105 #define CV_XML_DIRECTIVE_TAG 5
106
107 //typedef void (*CvParse)( struct CvFileStorage* fs );
108 typedef void (*CvStartWriteStruct)( struct CvFileStorage* fs, const char* key,
109 int struct_flags, const char* type_name );
110 typedef void (*CvEndWriteStruct)( struct CvFileStorage* fs );
111 typedef void (*CvWriteInt)( struct CvFileStorage* fs, const char* key, int value );
112 typedef void (*CvWriteReal)( struct CvFileStorage* fs, const char* key, double value );
113 typedef void (*CvWriteString)( struct CvFileStorage* fs, const char* key,
114 const char* value, int quote );
115 typedef void (*CvWriteComment)( struct CvFileStorage* fs, const char* comment, int eol_comment );
116 typedef void (*CvStartNextStream)( struct CvFileStorage* fs );
117
118 typedef struct CvFileStorage
119 {
120 int flags;
121 int is_xml;
122 int write_mode;
123 int is_first;
124 CvMemStorage* memstorage;
125 CvMemStorage* dststorage;
126 CvMemStorage* strstorage;
127 CvStringHash* str_hash;
128 CvSeq* roots;
129 CvSeq* write_stack;
130 int struct_indent;
131 int struct_flags;
132 CvString struct_tag;
133 int space;
134 char* filename;
135 FILE* file;
136 char* buffer;
137 char* buffer_start;
138 char* buffer_end;
139 int wrap_margin;
140 int lineno;
141 int dummy_eof;
142 const char* errmsg;
143 char errmsgbuf[128];
144
145 CvStartWriteStruct start_write_struct;
146 CvEndWriteStruct end_write_struct;
147 CvWriteInt write_int;
148 CvWriteReal write_real;
149 CvWriteString write_string;
150 CvWriteComment write_comment;
151 CvStartNextStream start_next_stream;
152 //CvParse parse;
153 }
154 CvFileStorage;
155
156
157 #define CV_YML_INDENT 3
158 #define CV_XML_INDENT 2
159 #define CV_YML_INDENT_FLOW 1
160 #define CV_FS_MAX_LEN 4096
161
162 #define CV_FILE_STORAGE ('Y' + ('A' << 8) + ('M' << 16) + ('L' << 24))
163 #define CV_IS_FILE_STORAGE(fs) ((fs) != 0 && (fs)->flags == CV_FILE_STORAGE)
164
165 #define CV_CHECK_FILE_STORAGE(fs) \
166 { \
167 if( !CV_IS_FILE_STORAGE(fs) ) \
168 CV_ERROR( (fs) ? CV_StsBadArg : CV_StsNullPtr, \
169 "Invalid pointer to file storage" ); \
170 }
171
172 #define CV_CHECK_OUTPUT_FILE_STORAGE(fs) \
173 { \
174 CV_CHECK_FILE_STORAGE(fs); \
175 if( !fs->write_mode ) \
176 CV_ERROR( CV_StsError, "The file storage is opened for reading" ); \
177 }
178
179 CV_IMPL const char*
cvAttrValue(const CvAttrList * attr,const char * attr_name)180 cvAttrValue( const CvAttrList* attr, const char* attr_name )
181 {
182 while( attr && attr->attr )
183 {
184 int i;
185 for( i = 0; attr->attr[i*2] != 0; i++ )
186 {
187 if( strcmp( attr_name, attr->attr[i*2] ) == 0 )
188 return attr->attr[i*2+1];
189 }
190 attr = attr->next;
191 }
192
193 return 0;
194 }
195
196
197 static CvGenericHash*
cvCreateMap(int flags,int header_size,int elem_size,CvMemStorage * storage,int start_tab_size)198 cvCreateMap( int flags, int header_size, int elem_size,
199 CvMemStorage* storage, int start_tab_size )
200 {
201 CvGenericHash* map = 0;
202
203 CV_FUNCNAME( "cvCreateMap" );
204
205 __BEGIN__;
206
207 if( header_size < (int)sizeof(CvGenericHash) )
208 CV_ERROR( CV_StsBadSize, "Too small map header_size" );
209
210 if( start_tab_size <= 0 )
211 start_tab_size = 16;
212
213 CV_CALL( map = (CvGenericHash*)cvCreateSet( flags, header_size, elem_size, storage ));
214
215 map->tab_size = start_tab_size;
216 start_tab_size *= sizeof(map->table[0]);
217 CV_CALL( map->table = (void**)cvMemStorageAlloc( storage, start_tab_size ));
218 memset( map->table, 0, start_tab_size );
219
220 __END__;
221
222 if( cvGetErrStatus() < 0 )
223 map = 0;
224
225 return map;
226 }
227
228
229 #define CV_PARSE_ERROR( errmsg ) \
230 { \
231 icvParseError( fs, cvFuncName, (errmsg), __FILE__, __LINE__ ); \
232 EXIT; \
233 }
234
235
236 static void
icvParseError(CvFileStorage * fs,const char * func_name,const char * err_msg,const char * source_file,int source_line)237 icvParseError( CvFileStorage* fs, const char* func_name,
238 const char* err_msg, const char* source_file, int source_line )
239 {
240 char buf[1<<10];
241 sprintf( buf, "%s(%d): %s", fs->filename, fs->lineno, err_msg );
242 cvError( CV_StsParseError, func_name, buf, source_file, source_line );
243 }
244
245
246 static void
icvFSCreateCollection(CvFileStorage * fs,int tag,CvFileNode * collection)247 icvFSCreateCollection( CvFileStorage* fs, int tag, CvFileNode* collection )
248 {
249 CV_FUNCNAME( "icvFSCreateCollection" );
250
251 __BEGIN__;
252
253 if( CV_NODE_IS_MAP(tag) )
254 {
255 if( collection->tag != CV_NODE_NONE )
256 {
257 assert( fs->is_xml != 0 );
258 CV_PARSE_ERROR( "Sequence element should not have name (use <_></_>)" );
259 }
260
261 CV_CALL( collection->data.map = cvCreateMap( 0, sizeof(CvFileNodeHash),
262 sizeof(CvFileMapNode), fs->memstorage, 16 ));
263 }
264 else
265 {
266 CvSeq* seq;
267 CV_CALL( seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvFileNode), fs->memstorage ));
268
269 // if <collection> contains some scalar element, add it to the newly created collection
270 if( CV_NODE_TYPE(collection->tag) != CV_NODE_NONE )
271 cvSeqPush( seq, collection );
272
273 collection->data.seq = seq;
274 }
275
276 collection->tag = tag;
277 cvSetSeqBlockSize( collection->data.seq, 8 );
278
279 __END__;
280 }
281
282
283 /*static void
284 icvFSReleaseCollection( CvSeq* seq )
285 {
286 if( seq )
287 {
288 int is_map = CV_IS_SET(seq);
289 CvSeqReader reader;
290 int i, total = seq->total;
291 cvStartReadSeq( seq, &reader, 0 );
292
293 for( i = 0; i < total; i++ )
294 {
295 CvFileNode* node = (CvFileNode*)reader.ptr;
296
297 if( (!is_map || CV_IS_SET_ELEM( node )) && CV_NODE_IS_COLLECTION(node->tag) )
298 {
299 if( CV_NODE_IS_USER(node->tag) && node->info && node->data.obj.decoded )
300 cvRelease( (void**)&node->data.obj.decoded );
301 if( !CV_NODE_SEQ_IS_SIMPLE( node->data.seq ))
302 icvFSReleaseCollection( node->data.seq );
303 }
304 CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
305 }
306 }
307 }*/
308
309
310 static char*
icvFSDoResize(CvFileStorage * fs,char * ptr,int len)311 icvFSDoResize( CvFileStorage* fs, char* ptr, int len )
312 {
313 char* new_ptr = 0;
314 CV_FUNCNAME( "icvFSDoResize" );
315
316 __BEGIN__;
317
318 int written_len = (int)(ptr - fs->buffer_start);
319 int new_size = (int)((fs->buffer_end - fs->buffer_start)*3/2);
320 new_size = MAX( written_len + len, new_size );
321 CV_CALL( new_ptr = (char*)cvAlloc( new_size + 256 ));
322 fs->buffer = new_ptr + (fs->buffer - fs->buffer_start);
323 if( written_len > 0 )
324 memcpy( new_ptr, fs->buffer_start, written_len );
325 fs->buffer_start = new_ptr;
326 fs->buffer_end = fs->buffer_start + new_size;
327 new_ptr += written_len;
328
329 __END__;
330
331 return new_ptr;
332 }
333
334
icvFSResizeWriteBuffer(CvFileStorage * fs,char * ptr,int len)335 inline char* icvFSResizeWriteBuffer( CvFileStorage* fs, char* ptr, int len )
336 {
337 return ptr + len < fs->buffer_end ? ptr : icvFSDoResize( fs, ptr, len );
338 }
339
340
341 static char*
icvFSFlush(CvFileStorage * fs)342 icvFSFlush( CvFileStorage* fs )
343 {
344 char* ptr = fs->buffer;
345 int indent;
346
347 if( ptr > fs->buffer_start + fs->space )
348 {
349 ptr[0] = '\n';
350 ptr[1] = '\0';
351 fputs( fs->buffer_start, fs->file );
352 fs->buffer = fs->buffer_start;
353 }
354
355 indent = fs->struct_indent;
356
357 if( fs->space != indent )
358 {
359 if( fs->space < indent )
360 memset( fs->buffer_start + fs->space, ' ', indent - fs->space );
361 fs->space = indent;
362 }
363
364 ptr = fs->buffer = fs->buffer_start + fs->space;
365
366 return ptr;
367 }
368
369
370 /* closes file storage and deallocates buffers */
371 CV_IMPL void
cvReleaseFileStorage(CvFileStorage ** p_fs)372 cvReleaseFileStorage( CvFileStorage** p_fs )
373 {
374 CV_FUNCNAME("cvReleaseFileStorage" );
375
376 __BEGIN__;
377
378 if( !p_fs )
379 CV_ERROR( CV_StsNullPtr, "NULL double pointer to file storage" );
380
381 if( *p_fs )
382 {
383 CvFileStorage* fs = *p_fs;
384 *p_fs = 0;
385
386 if( fs->write_mode && fs->file )
387 {
388 if( fs->write_stack )
389 {
390 while( fs->write_stack->total > 0 )
391 cvEndWriteStruct(fs);
392 }
393 icvFSFlush(fs);
394 if( fs->is_xml )
395 fputs("</opencv_storage>\n", fs->file );
396 }
397
398 //icvFSReleaseCollection( fs->roots ); // delete all the user types recursively
399
400 if( fs->file )
401 {
402 fclose( fs->file );
403 fs->file = 0;
404 }
405
406 cvReleaseMemStorage( &fs->strstorage );
407
408 cvFree( &fs->buffer_start );
409 cvReleaseMemStorage( &fs->memstorage );
410
411 memset( fs, 0, sizeof(*fs) );
412 cvFree( &fs );
413 }
414
415 __END__;
416 }
417
418
419 #define CV_HASHVAL_SCALE 33
420
421 CV_IMPL CvStringHashNode*
cvGetHashedKey(CvFileStorage * fs,const char * str,int len,int create_missing)422 cvGetHashedKey( CvFileStorage* fs, const char* str, int len, int create_missing )
423 {
424 CvStringHashNode* node = 0;
425 CV_FUNCNAME( "cvGetHashedKey" );
426
427 __BEGIN__;
428
429 unsigned hashval = 0;
430 int i, tab_size;
431 CvStringHash* map = fs->str_hash;
432
433 if( !fs )
434 EXIT;
435
436 if( len < 0 )
437 {
438 for( i = 0; str[i] != '\0'; i++ )
439 hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
440 len = i;
441 }
442 else for( i = 0; i < len; i++ )
443 hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
444
445 hashval &= INT_MAX;
446 tab_size = map->tab_size;
447 if( (tab_size & (tab_size - 1)) == 0 )
448 i = (int)(hashval & (tab_size - 1));
449 else
450 i = (int)(hashval % tab_size);
451
452 for( node = (CvStringHashNode*)(map->table[i]); node != 0; node = node->next )
453 {
454 if( node->hashval == hashval &&
455 node->str.len == len &&
456 memcmp( node->str.ptr, str, len ) == 0 )
457 break;
458 }
459
460 if( !node && create_missing )
461 {
462 node = (CvStringHashNode*)cvSetNew( (CvSet*)map );
463 node->hashval = hashval;
464 CV_CALL( node->str = cvMemStorageAllocString( map->storage, str, len ));
465 node->next = (CvStringHashNode*)(map->table[i]);
466 map->table[i] = node;
467 }
468
469 __END__;
470
471 return node;
472 }
473
474
475 CV_IMPL CvFileNode*
cvGetFileNode(CvFileStorage * fs,CvFileNode * _map_node,const CvStringHashNode * key,int create_missing)476 cvGetFileNode( CvFileStorage* fs, CvFileNode* _map_node,
477 const CvStringHashNode* key,
478 int create_missing )
479 {
480 CvFileNode* value = 0;
481
482 CV_FUNCNAME( "cvGetFileNode" );
483
484 __BEGIN__;
485
486 int k = 0, attempts = 1;
487
488 if( !fs )
489 EXIT;
490
491 CV_CHECK_FILE_STORAGE(fs);
492
493 if( !key )
494 CV_ERROR( CV_StsNullPtr, "Null key element" );
495
496 if( _map_node )
497 {
498 if( !fs->roots )
499 EXIT;
500 attempts = fs->roots->total;
501 }
502
503 for( k = 0; k < attempts; k++ )
504 {
505 int i, tab_size;
506 CvFileNode* map_node = _map_node;
507 CvFileMapNode* another;
508 CvFileNodeHash* map;
509
510 if( !map_node )
511 map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
512
513 if( !CV_NODE_IS_MAP(map_node->tag) )
514 {
515 if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
516 CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
517 CV_ERROR( CV_StsError, "The node is neither a map nor an empty collection" );
518 EXIT;
519 }
520
521 map = map_node->data.map;
522 tab_size = map->tab_size;
523
524 if( (tab_size & (tab_size - 1)) == 0 )
525 i = (int)(key->hashval & (tab_size - 1));
526 else
527 i = (int)(key->hashval % tab_size);
528
529 for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
530 if( another->key == key )
531 {
532 if( !create_missing )
533 {
534 value = &another->value;
535 EXIT;
536 }
537 CV_PARSE_ERROR( "Duplicated key" );
538 }
539
540 if( k == attempts - 1 && create_missing )
541 {
542 CvFileMapNode* node = (CvFileMapNode*)cvSetNew( (CvSet*)map );
543 node->key = key;
544
545 node->next = (CvFileMapNode*)(map->table[i]);
546 map->table[i] = node;
547 value = (CvFileNode*)node;
548 }
549 }
550
551 __END__;
552
553 return value;
554 }
555
556
557 CV_IMPL CvFileNode*
cvGetFileNodeByName(const CvFileStorage * fs,const CvFileNode * _map_node,const char * str)558 cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* _map_node, const char* str )
559 {
560 CvFileNode* value = 0;
561 CV_FUNCNAME( "cvGetFileNodeByName" );
562
563 __BEGIN__;
564
565 int i, len, tab_size;
566 unsigned hashval = 0;
567 int k = 0, attempts = 1;
568
569 if( !fs )
570 EXIT;
571
572 CV_CHECK_FILE_STORAGE(fs);
573
574 if( !str )
575 CV_ERROR( CV_StsNullPtr, "Null element name" );
576
577 for( i = 0; str[i] != '\0'; i++ )
578 hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
579 hashval &= INT_MAX;
580 len = i;
581
582 if( !_map_node )
583 {
584 if( !fs->roots )
585 EXIT;
586 attempts = fs->roots->total;
587 }
588
589 for( k = 0; k < attempts; k++ )
590 {
591 CvFileNodeHash* map;
592 const CvFileNode* map_node = _map_node;
593 CvFileMapNode* another;
594
595 if( !map_node )
596 map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
597
598 if( !CV_NODE_IS_MAP(map_node->tag) )
599 {
600 if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
601 CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
602 CV_ERROR( CV_StsError, "The node is neither a map nor an empty collection" );
603 EXIT;
604 }
605
606 map = map_node->data.map;
607 tab_size = map->tab_size;
608
609 if( (tab_size & (tab_size - 1)) == 0 )
610 i = (int)(hashval & (tab_size - 1));
611 else
612 i = (int)(hashval % tab_size);
613
614 for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
615 {
616 const CvStringHashNode* key = another->key;
617
618 if( key->hashval == hashval &&
619 key->str.len == len &&
620 memcmp( key->str.ptr, str, len ) == 0 )
621 {
622 value = &another->value;
623 EXIT;
624 }
625 }
626 }
627
628 __END__;
629
630 return value;
631 }
632
633
634 CV_IMPL CvFileNode*
cvGetRootFileNode(const CvFileStorage * fs,int stream_index)635 cvGetRootFileNode( const CvFileStorage* fs, int stream_index )
636 {
637 CvFileNode* value = 0;
638 CV_FUNCNAME( "cvGetRootFileNode" );
639
640 __BEGIN__;
641
642 CV_CHECK_FILE_STORAGE(fs);
643
644 if( !fs->roots || (unsigned)stream_index >= (unsigned)fs->roots->total )
645 EXIT;
646
647 value = (CvFileNode*)cvGetSeqElem( fs->roots, stream_index );
648
649 __END__;
650
651 return value;
652 }
653
654
655 /* returns the sequence element by its index */
656 /*CV_IMPL CvFileNode*
657 cvGetFileNodeFromSeq( CvFileStorage* fs,
658 CvFileNode* seq_node, int index )
659 {
660 CvFileNode* value = 0;
661
662 CV_FUNCNAME( "cvGetFileNodeFromSeq" );
663
664 __BEGIN__;
665
666 CvSeq* seq;
667
668 if( !seq_node )
669 seq = fs->roots;
670 else if( !CV_NODE_IS_SEQ(seq_node->tag) )
671 {
672 if( CV_NODE_IS_MAP(seq_node->tag) )
673 CV_ERROR( CV_StsError, "The node is map. Use cvGetFileNodeFromMap()." );
674 if( CV_NODE_TYPE(seq_node->tag) == CV_NODE_NONE )
675 CV_ERROR( CV_StsError, "The node is an empty object (None)." );
676 if( index != 0 && index != -1 )
677 CV_ERROR( CV_StsOutOfRange, "" );
678 value = seq_node;
679 EXIT;
680 }
681 else
682 seq = seq_node->data.seq;
683
684 if( !seq )
685 CV_ERROR( CV_StsNullPtr, "The file storage is empty" );
686
687 value = (CvFileNode*)cvGetSeqElem( seq, index, 0 );
688
689 __END__;
690
691 return value;
692 }*/
693
694
695 static char*
icvDoubleToString(char * buf,double value)696 icvDoubleToString( char* buf, double value )
697 {
698 Cv64suf val;
699 unsigned ieee754_hi;
700
701 val.f = value;
702 ieee754_hi = (unsigned)(val.u >> 32);
703
704 if( (ieee754_hi & 0x7ff00000) != 0x7ff00000 )
705 {
706 int ivalue = cvRound(value);
707 if( ivalue == value )
708 sprintf( buf, "%d.", ivalue );
709 else
710 {
711 static const char* fmt[] = {"%.16e", "%.16f"};
712 double avalue = fabs(value);
713 char* ptr = buf;
714 sprintf( buf, fmt[0.01 <= avalue && avalue < 1000], value );
715 if( *ptr == '+' || *ptr == '-' )
716 ptr++;
717 for( ; isdigit(*ptr); ptr++ )
718 ;
719 if( *ptr == ',' )
720 *ptr = '.';
721 }
722 }
723 else
724 {
725 unsigned ieee754_lo = (unsigned)val.u;
726 if( (ieee754_hi & 0x7fffffff) + (ieee754_lo != 0) > 0x7ff00000 )
727 strcpy( buf, ".Nan" );
728 else
729 strcpy( buf, (int)ieee754_hi < 0 ? "-.Inf" : ".Inf" );
730 }
731
732 return buf;
733 }
734
735
736 static char*
icvFloatToString(char * buf,float value)737 icvFloatToString( char* buf, float value )
738 {
739 Cv32suf val;
740 unsigned ieee754;
741 val.f = value;
742 ieee754 = val.u;
743
744 if( (ieee754 & 0x7f800000) != 0x7f800000 )
745 {
746 int ivalue = cvRound(value);
747 if( ivalue == value )
748 sprintf( buf, "%d.", ivalue );
749 else
750 {
751 static const char* fmt[] = {"%.8e", "%.8f"};
752 double avalue = fabs((double)value);
753 char* ptr = buf;
754 sprintf( buf, fmt[0.01 <= avalue && avalue < 1000], value );
755 if( *ptr == '+' || *ptr == '-' )
756 ptr++;
757 for( ; isdigit(*ptr); ptr++ )
758 ;
759 if( *ptr == ',' )
760 *ptr = '.';
761 }
762 }
763 else
764 {
765 if( (ieee754 & 0x7fffffff) != 0x7f800000 )
766 strcpy( buf, ".Nan" );
767 else
768 strcpy( buf, (int)ieee754 < 0 ? "-.Inf" : ".Inf" );
769 }
770
771 return buf;
772 }
773
774
775 static void
icvProcessSpecialDouble(CvFileStorage * fs,char * buf,double * value,char ** endptr)776 icvProcessSpecialDouble( CvFileStorage* fs, char* buf, double* value, char** endptr )
777 {
778 CV_FUNCNAME( "icvProcessSpecialDouble" );
779
780 __BEGIN__;
781
782 char c = buf[0];
783 int inf_hi = 0x7ff00000;
784
785 if( c == '-' || c == '+' )
786 {
787 inf_hi = c == '-' ? 0xfff00000 : 0x7ff00000;
788 c = *++buf;
789 }
790
791 if( c != '.' )
792 CV_PARSE_ERROR( "Bad format of floating-point constant" );
793
794 if( toupper(buf[1]) == 'I' && toupper(buf[2]) == 'N' && toupper(buf[3]) == 'F' )
795 *(uint64*)value = ((uint64)inf_hi << 32);
796 else if( toupper(buf[1]) == 'N' && toupper(buf[2]) == 'A' && toupper(buf[3]) == 'N' )
797 *(uint64*)value = (uint64)-1;
798 else
799 CV_PARSE_ERROR( "Bad format of floating-point constant" );
800
801 *endptr = buf + 4;
802
803 __END__;
804 }
805
806
icv_strtod(CvFileStorage * fs,char * ptr,char ** endptr)807 static double icv_strtod( CvFileStorage* fs, char* ptr, char** endptr )
808 {
809 double fval = strtod( ptr, endptr );
810 if( **endptr == '.' )
811 {
812 char* dot_pos = *endptr;
813 *dot_pos = ',';
814 double fval2 = strtod( ptr, endptr );
815 *dot_pos = '.';
816 if( *endptr > dot_pos )
817 fval = fval2;
818 else
819 *endptr = dot_pos;
820 }
821
822 if( *endptr == ptr || isalpha(**endptr) )
823 icvProcessSpecialDouble( fs, ptr, &fval, endptr );
824
825 return fval;
826 }
827
828
829 /****************************************************************************************\
830 * YAML Parser *
831 \****************************************************************************************/
832
833 static char*
icvYMLSkipSpaces(CvFileStorage * fs,char * ptr,int min_indent,int max_comment_indent)834 icvYMLSkipSpaces( CvFileStorage* fs, char* ptr, int min_indent, int max_comment_indent )
835 {
836 CV_FUNCNAME( "icvYMLSkipSpaces" );
837
838 __BEGIN__;
839
840 for(;;)
841 {
842 while( *ptr == ' ' )
843 ptr++;
844 if( *ptr == '#' )
845 {
846 if( ptr - fs->buffer_start > max_comment_indent )
847 EXIT;
848 *ptr = '\0';
849 }
850 else if( cv_isprint(*ptr) )
851 {
852 if( ptr - fs->buffer_start < min_indent )
853 CV_PARSE_ERROR( "Incorrect indentation" );
854 break;
855 }
856 else if( *ptr == '\0' || *ptr == '\n' || *ptr == '\r' )
857 {
858 int max_size = (int)(fs->buffer_end - fs->buffer_start);
859 ptr = fgets( fs->buffer_start, max_size, fs->file );
860 if( !ptr )
861 {
862 // emulate end of stream
863 ptr = fs->buffer_start;
864 ptr[0] = ptr[1] = ptr[2] = '.';
865 ptr[3] = '\0';
866 fs->dummy_eof = 1;
867 break;
868 }
869 else
870 {
871 int l = (int)strlen(ptr);
872 if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !feof(fs->file) )
873 CV_PARSE_ERROR( "Too long string or a last string w/o newline" );
874 }
875
876 fs->lineno++;
877 }
878 else
879 CV_PARSE_ERROR( *ptr == '\t' ? "Tabs are prohibited in YAML!" : "Invalid character" );
880 }
881
882 __END__;
883
884 return ptr;
885 }
886
887
888 static char*
icvYMLParseKey(CvFileStorage * fs,char * ptr,CvFileNode * map_node,CvFileNode ** value_placeholder)889 icvYMLParseKey( CvFileStorage* fs, char* ptr,
890 CvFileNode* map_node, CvFileNode** value_placeholder )
891 {
892 CV_FUNCNAME( "icvYMLParseKey" );
893
894 __BEGIN__;
895
896 char c;
897 char *endptr = ptr - 1, *saveptr;
898 CvStringHashNode* str_hash_node;
899
900 if( *ptr == '-' )
901 CV_PARSE_ERROR( "Key may not start with \'-\'" );
902
903 do c = *++endptr;
904 while( cv_isprint(c) && c != ':' );
905
906 if( c != ':' )
907 CV_PARSE_ERROR( "Missing \':\'" );
908
909 saveptr = endptr + 1;
910 do c = *--endptr;
911 while( c == ' ' );
912
913 ++endptr;
914 if( endptr == ptr )
915 CV_PARSE_ERROR( "An empty key" );
916
917 CV_CALL( str_hash_node = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 ));
918 CV_CALL( *value_placeholder = cvGetFileNode( fs, map_node, str_hash_node, 1 ));
919 ptr = saveptr;
920
921 __END__;
922
923 return ptr;
924 }
925
926
927 static char*
icvYMLParseValue(CvFileStorage * fs,char * ptr,CvFileNode * node,int parent_flags,int min_indent)928 icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
929 int parent_flags, int min_indent )
930 {
931 CV_FUNCNAME( "icvYMLParseValue" );
932
933 __BEGIN__;
934
935 char buf[CV_FS_MAX_LEN + 1024];
936 char* endptr = 0;
937 char c = ptr[0], d = ptr[1];
938 int is_parent_flow = CV_NODE_IS_FLOW(parent_flags);
939 int value_type = CV_NODE_NONE;
940 int len;
941
942 memset( node, 0, sizeof(*node) );
943
944 if( c == '!' ) // handle explicit type specification
945 {
946 if( d == '!' || d == '^' )
947 {
948 ptr++;
949 value_type |= CV_NODE_USER;
950 }
951
952 endptr = ptr++;
953 do d = *++endptr;
954 while( cv_isprint(d) && d != ' ' );
955 len = (int)(endptr - ptr);
956 if( len == 0 )
957 CV_PARSE_ERROR( "Empty type name" );
958 d = *endptr;
959 *endptr = '\0';
960
961 if( len == 3 && !CV_NODE_IS_USER(value_type) )
962 {
963 if( memcmp( ptr, "str", 3 ) == 0 )
964 value_type = CV_NODE_STRING;
965 else if( memcmp( ptr, "int", 3 ) == 0 )
966 value_type = CV_NODE_INT;
967 else if( memcmp( ptr, "seq", 3 ) == 0 )
968 value_type = CV_NODE_SEQ;
969 else if( memcmp( ptr, "map", 3 ) == 0 )
970 value_type = CV_NODE_MAP;
971 }
972 else if( len == 5 && !CV_NODE_IS_USER(value_type) )
973 {
974 if( memcmp( ptr, "float", 5 ) == 0 )
975 value_type = CV_NODE_REAL;
976 }
977 else if( CV_NODE_IS_USER(value_type) )
978 {
979 CV_CALL( node->info = cvFindType( ptr ));
980 if( !node->info )
981 node->tag &= ~CV_NODE_USER;
982 }
983
984 *endptr = d;
985 CV_CALL( ptr = icvYMLSkipSpaces( fs, endptr, min_indent, INT_MAX ));
986
987 c = *ptr;
988
989 if( !CV_NODE_IS_USER(value_type) )
990 {
991 if( value_type == CV_NODE_STRING && c != '\'' && c != '\"' )
992 goto force_string;
993 if( value_type == CV_NODE_INT )
994 goto force_int;
995 if( value_type == CV_NODE_REAL )
996 goto force_real;
997 }
998 }
999
1000 if( isdigit(c) ||
1001 ((c == '-' || c == '+') && (isdigit(d) || d == '.')) ||
1002 (c == '.' && isalnum(d))) // a number
1003 {
1004 double fval;
1005 int ival;
1006 endptr = ptr + (c == '-' || c == '+');
1007 while( isdigit(*endptr) )
1008 endptr++;
1009 if( *endptr == '.' || *endptr == 'e' )
1010 {
1011 force_real:
1012 fval = icv_strtod( fs, ptr, &endptr );
1013 /*if( endptr == ptr || isalpha(*endptr) )
1014 CV_CALL( icvProcessSpecialDouble( fs, endptr, &fval, &endptr ));*/
1015
1016 node->tag = CV_NODE_REAL;
1017 node->data.f = fval;
1018 }
1019 else
1020 {
1021 force_int:
1022 ival = (int)strtol( ptr, &endptr, 0 );
1023 node->tag = CV_NODE_INT;
1024 node->data.i = ival;
1025 }
1026
1027 if( !endptr || endptr == ptr )
1028 CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" );
1029
1030 ptr = endptr;
1031 }
1032 else if( c == '\'' || c == '\"' ) // an explicit string
1033 {
1034 node->tag = CV_NODE_STRING;
1035 if( c == '\'' )
1036 for( len = 0; len < CV_FS_MAX_LEN; )
1037 {
1038 c = *++ptr;
1039 if( isalnum(c) || (c != '\'' && cv_isprint(c)))
1040 buf[len++] = c;
1041 else if( c == '\'' )
1042 {
1043 c = *++ptr;
1044 if( c != '\'' )
1045 break;
1046 buf[len++] = c;
1047 }
1048 else
1049 CV_PARSE_ERROR( "Invalid character" );
1050 }
1051 else
1052 for( len = 0; len < CV_FS_MAX_LEN; )
1053 {
1054 c = *++ptr;
1055 if( isalnum(c) || (c != '\\' && c != '\"' && cv_isprint(c)))
1056 buf[len++] = c;
1057 else if( c == '\"' )
1058 {
1059 ++ptr;
1060 break;
1061 }
1062 else if( c == '\\' )
1063 {
1064 d = *++ptr;
1065 if( d == '\'' )
1066 buf[len++] = d;
1067 else if( d == '\"' || d == '\\' || d == '\'' )
1068 buf[len++] = d;
1069 else if( d == 'n' )
1070 buf[len++] = '\n';
1071 else if( d == 'r' )
1072 buf[len++] = '\r';
1073 else if( d == 't' )
1074 buf[len++] = '\t';
1075 else if( d == 'x' || (isdigit(d) && d < '8') )
1076 {
1077 int val, is_hex = d == 'x';
1078 c = ptr[3];
1079 ptr[3] = '\0';
1080 val = strtol( ptr + is_hex, &endptr, is_hex ? 8 : 16 );
1081 ptr[3] = c;
1082 if( endptr == ptr + is_hex )
1083 buf[len++] = 'x';
1084 else
1085 {
1086 buf[len++] = (char)val;
1087 ptr = endptr;
1088 }
1089 }
1090 }
1091 else
1092 CV_PARSE_ERROR( "Invalid character" );
1093 }
1094
1095 if( len >= CV_FS_MAX_LEN )
1096 CV_PARSE_ERROR( "Too long string literal" );
1097
1098 CV_CALL( node->data.str = cvMemStorageAllocString( fs->memstorage, buf, len ));
1099 }
1100 else if( c == '[' || c == '{' ) // collection as a flow
1101 {
1102 int new_min_indent = min_indent + !is_parent_flow;
1103 int struct_flags = CV_NODE_FLOW + (c == '{' ? CV_NODE_MAP : CV_NODE_SEQ);
1104 int is_simple = 1;
1105
1106 CV_CALL( icvFSCreateCollection( fs, CV_NODE_TYPE(struct_flags) +
1107 (node->info ? CV_NODE_USER : 0), node ));
1108
1109 d = c == '[' ? ']' : '}';
1110
1111 for( ++ptr ;;)
1112 {
1113 CvFileNode* elem = 0;
1114
1115 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ));
1116 if( *ptr == '}' || *ptr == ']' )
1117 {
1118 if( *ptr != d )
1119 CV_PARSE_ERROR( "The wrong closing bracket" );
1120 ptr++;
1121 break;
1122 }
1123
1124 if( node->data.seq->total != 0 )
1125 {
1126 if( *ptr != ',' )
1127 CV_PARSE_ERROR( "Missing , between the elements" );
1128 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr + 1, new_min_indent, INT_MAX ));
1129 }
1130
1131 if( CV_NODE_IS_MAP(struct_flags) )
1132 {
1133 CV_CALL( ptr = icvYMLParseKey( fs, ptr, node, &elem ));
1134 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ));
1135 }
1136 else
1137 {
1138 if( *ptr == ']' )
1139 break;
1140 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1141 }
1142 CV_CALL( ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, new_min_indent ));
1143 if( CV_NODE_IS_MAP(struct_flags) )
1144 elem->tag |= CV_NODE_NAMED;
1145 is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
1146 }
1147 node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
1148 }
1149 else
1150 {
1151 int indent, struct_flags, is_simple;
1152
1153 if( is_parent_flow || c != '-' )
1154 {
1155 // implicit (one-line) string or nested block-style collection
1156 if( !is_parent_flow )
1157 {
1158 if( c == '?' )
1159 CV_PARSE_ERROR( "Complex keys are not supported" );
1160 if( c == '|' || c == '>' )
1161 CV_PARSE_ERROR( "Multi-line text literals are not supported" );
1162 }
1163
1164 force_string:
1165 endptr = ptr - 1;
1166
1167 do c = *++endptr;
1168 while( cv_isprint(c) &&
1169 (!is_parent_flow || (c != ',' && c != '}' && c != ']')) &&
1170 (is_parent_flow || c != ':' || value_type == CV_NODE_STRING));
1171
1172 if( endptr == ptr )
1173 CV_PARSE_ERROR( "Invalid character" );
1174
1175 if( is_parent_flow || c != ':' )
1176 {
1177 char* str_end = endptr;
1178 node->tag = CV_NODE_STRING;
1179 // strip spaces in the end of string
1180 do c = *--str_end;
1181 while( str_end > ptr && c == ' ' );
1182 str_end++;
1183 CV_CALL( node->data.str = cvMemStorageAllocString( fs->memstorage, ptr, (int)(str_end - ptr) ));
1184 ptr = endptr;
1185 EXIT;
1186 }
1187 struct_flags = CV_NODE_MAP;
1188 }
1189 else
1190 struct_flags = CV_NODE_SEQ;
1191
1192 CV_CALL( icvFSCreateCollection( fs, struct_flags +
1193 (node->info ? CV_NODE_USER : 0), node ));
1194
1195 indent = (int)(ptr - fs->buffer_start);
1196 is_simple = 1;
1197
1198 for(;;)
1199 {
1200 CvFileNode* elem = 0;
1201
1202 if( CV_NODE_IS_MAP(struct_flags) )
1203 {
1204 CV_CALL( ptr = icvYMLParseKey( fs, ptr, node, &elem ));
1205 }
1206 else
1207 {
1208 c = *ptr++;
1209 if( c != '-' )
1210 CV_PARSE_ERROR( "Block sequence elements must be preceded with \'-\'" );
1211
1212 CV_CALL( elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ));
1213 }
1214
1215 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, indent + 1, INT_MAX ));
1216 CV_CALL( ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, indent + 1 ));
1217 if( CV_NODE_IS_MAP(struct_flags) )
1218 elem->tag |= CV_NODE_NAMED;
1219 is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
1220
1221 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
1222 if( ptr - fs->buffer_start != indent )
1223 {
1224 if( ptr - fs->buffer_start < indent )
1225 break;
1226 else
1227 CV_PARSE_ERROR( "Incorrect indentation" );
1228 }
1229 if( memcmp( ptr, "...", 3 ) == 0 )
1230 break;
1231 }
1232
1233 node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
1234 }
1235
1236 __END__;
1237
1238 return ptr;
1239 }
1240
1241
1242 static void
icvYMLParse(CvFileStorage * fs)1243 icvYMLParse( CvFileStorage* fs )
1244 {
1245 CV_FUNCNAME( "icvYMLParse" );
1246
1247 __BEGIN__;
1248
1249 char* ptr = fs->buffer_start;
1250 int is_first = 1;
1251
1252 for(;;)
1253 {
1254 // 0. skip leading comments and directives and ...
1255 // 1. reach the first item
1256 for(;;)
1257 {
1258 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
1259 if( !ptr )
1260 EXIT;
1261
1262 if( *ptr == '%' )
1263 {
1264 if( memcmp( ptr, "%YAML:", 6 ) == 0 &&
1265 memcmp( ptr, "%YAML:1.", 8 ) != 0 )
1266 CV_PARSE_ERROR( "Unsupported YAML version (it must be 1.x)" );
1267 *ptr = '\0';
1268 }
1269 else if( *ptr == '-' )
1270 {
1271 if( memcmp(ptr, "---", 3) == 0 )
1272 {
1273 ptr += 3;
1274 break;
1275 }
1276 else if( is_first )
1277 break;
1278 }
1279 else if( isalnum(*ptr) || *ptr=='_')
1280 {
1281 if( !is_first )
1282 CV_PARSE_ERROR( "The YAML streams must start with '---', except the first one" );
1283 break;
1284 }
1285 else
1286 CV_PARSE_ERROR( "Invalid or unsupported syntax" );
1287 }
1288
1289 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
1290 if( memcmp( ptr, "...", 3 ) != 0 )
1291 {
1292 // 2. parse the collection
1293 CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 );
1294
1295 CV_CALL( ptr = icvYMLParseValue( fs, ptr, root_node, CV_NODE_NONE, 0 ));
1296 if( !CV_NODE_IS_COLLECTION(root_node->tag) )
1297 CV_PARSE_ERROR( "Only collections as YAML streams are supported by this parser" );
1298
1299 // 3. parse until the end of file or next collection
1300 CV_CALL( ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ));
1301 if( !ptr )
1302 EXIT;
1303 }
1304
1305 if( fs->dummy_eof )
1306 break;
1307 ptr += 3;
1308 is_first = 0;
1309 }
1310
1311 __END__;
1312 }
1313
1314
1315 /****************************************************************************************\
1316 * YAML Emitter *
1317 \****************************************************************************************/
1318
1319 static void
icvYMLWrite(CvFileStorage * fs,const char * key,const char * data,const char * cvFuncName)1320 icvYMLWrite( CvFileStorage* fs, const char* key, const char* data, const char* cvFuncName )
1321 {
1322 //CV_FUNCNAME( "icvYMLWrite" );
1323
1324 __BEGIN__;
1325
1326 int i, keylen = 0;
1327 int datalen = 0;
1328 int struct_flags;
1329 char* ptr;
1330
1331 struct_flags = fs->struct_flags;
1332
1333 if( key && key[0] == '\0' )
1334 key = 0;
1335
1336 if( CV_NODE_IS_COLLECTION(struct_flags) )
1337 {
1338 if( (CV_NODE_IS_MAP(struct_flags) ^ (key != 0)) )
1339 CV_ERROR( CV_StsBadArg, "An attempt to add element without a key to a map, "
1340 "or add element with key to sequence" );
1341 }
1342 else
1343 {
1344 fs->is_first = 0;
1345 struct_flags = CV_NODE_EMPTY | (key ? CV_NODE_MAP : CV_NODE_SEQ);
1346 }
1347
1348 if( key )
1349 {
1350 keylen = (int)strlen(key);
1351 if( keylen == 0 )
1352 CV_ERROR( CV_StsBadArg, "The key is an empty" );
1353
1354 if( keylen > CV_FS_MAX_LEN )
1355 CV_ERROR( CV_StsBadArg, "The key is too long" );
1356 }
1357
1358 if( data )
1359 datalen = (int)strlen(data);
1360
1361 if( CV_NODE_IS_FLOW(struct_flags) )
1362 {
1363 int new_offset;
1364 ptr = fs->buffer;
1365 if( !CV_NODE_IS_EMPTY(struct_flags) )
1366 *ptr++ = ',';
1367 new_offset = (int)(ptr - fs->buffer_start) + keylen + datalen;
1368 if( new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10 )
1369 {
1370 fs->buffer = ptr;
1371 ptr = icvFSFlush(fs);
1372 }
1373 else
1374 *ptr++ = ' ';
1375 }
1376 else
1377 {
1378 ptr = icvFSFlush(fs);
1379 if( !CV_NODE_IS_MAP(struct_flags) )
1380 {
1381 *ptr++ = '-';
1382 if( data )
1383 *ptr++ = ' ';
1384 }
1385 }
1386
1387 if( key )
1388 {
1389 if( !isalpha(key[0]) && key[0] != '_' )
1390 CV_ERROR( CV_StsBadArg, "Key must start with a letter or _" );
1391
1392 ptr = icvFSResizeWriteBuffer( fs, ptr, keylen );
1393
1394 for( i = 0; i < keylen; i++ )
1395 {
1396 int c = key[i];
1397
1398 ptr[i] = (char)c;
1399 if( !isalnum(c) && c != '-' && c != '_' && c != ' ' )
1400 CV_ERROR( CV_StsBadArg, "Invalid character occurs in the key" );
1401 }
1402
1403 ptr += keylen;
1404 *ptr++ = ':';
1405 if( !CV_NODE_IS_FLOW(struct_flags) && data )
1406 *ptr++ = ' ';
1407 }
1408
1409 if( data )
1410 {
1411 ptr = icvFSResizeWriteBuffer( fs, ptr, datalen );
1412 memcpy( ptr, data, datalen );
1413 ptr += datalen;
1414 }
1415
1416 fs->buffer = ptr;
1417 fs->struct_flags = struct_flags & ~CV_NODE_EMPTY;
1418
1419 __END__;
1420 }
1421
1422
1423 static void
1424 icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
1425 const char* type_name CV_DEFAULT(0))
1426 {
1427 CV_FUNCNAME( "icvYMLStartWriteStruct" );
1428
1429 __BEGIN__;
1430
1431 int parent_flags;
1432 char buf[CV_FS_MAX_LEN + 1024];
1433 const char* data = 0;
1434
1435 struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY;
1436 if( !CV_NODE_IS_COLLECTION(struct_flags))
1437 CV_ERROR( CV_StsBadArg,
1438 "Some collection type - CV_NODE_SEQ or CV_NODE_MAP, must be specified" );
1439
1440 if( CV_NODE_IS_FLOW(struct_flags) )
1441 {
1442 char c = CV_NODE_IS_MAP(struct_flags) ? '{' : '[';
1443 struct_flags |= CV_NODE_FLOW;
1444
1445 if( type_name )
1446 sprintf( buf, "!!%s %c", type_name, c );
1447 else
1448 {
1449 buf[0] = c;
1450 buf[1] = '\0';
1451 }
1452 data = buf;
1453 }
1454 else if( type_name )
1455 {
1456 sprintf( buf, "!!%s", type_name );
1457 data = buf;
1458 }
1459
1460 CV_CALL( icvYMLWrite( fs, key, data, cvFuncName ));
1461
1462 parent_flags = fs->struct_flags;
1463 cvSeqPush( fs->write_stack, &parent_flags );
1464 fs->struct_flags = struct_flags;
1465
1466 if( !CV_NODE_IS_FLOW(parent_flags) )
1467 fs->struct_indent += CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
1468
1469 __END__;
1470 }
1471
1472
1473 static void
icvYMLEndWriteStruct(CvFileStorage * fs)1474 icvYMLEndWriteStruct( CvFileStorage* fs )
1475 {
1476 CV_FUNCNAME( "icvYMLEndWriteStruct" );
1477
1478 __BEGIN__;
1479
1480 int parent_flags = 0, struct_flags;
1481 char* ptr;
1482
1483 struct_flags = fs->struct_flags;
1484 if( fs->write_stack->total == 0 )
1485 CV_ERROR( CV_StsError, "EndWriteStruct w/o matching StartWriteStruct" );
1486
1487 cvSeqPop( fs->write_stack, &parent_flags );
1488
1489 if( CV_NODE_IS_FLOW(struct_flags) )
1490 {
1491 ptr = fs->buffer;
1492 if( ptr > fs->buffer_start + fs->struct_indent && !CV_NODE_IS_EMPTY(struct_flags) )
1493 *ptr++ = ' ';
1494 *ptr++ = CV_NODE_IS_MAP(struct_flags) ? '}' : ']';
1495 fs->buffer = ptr;
1496 }
1497 else if( CV_NODE_IS_EMPTY(struct_flags) )
1498 {
1499 ptr = icvFSFlush(fs);
1500 memcpy( ptr, CV_NODE_IS_MAP(struct_flags) ? "{}" : "[]", 2 );
1501 fs->buffer = ptr + 2;
1502 }
1503
1504 if( !CV_NODE_IS_FLOW(parent_flags) )
1505 fs->struct_indent -= CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags);
1506 assert( fs->struct_indent >= 0 );
1507
1508 fs->struct_flags = parent_flags;
1509
1510 __END__;
1511 }
1512
1513
1514 static void
icvYMLStartNextStream(CvFileStorage * fs)1515 icvYMLStartNextStream( CvFileStorage* fs )
1516 {
1517 //CV_FUNCNAME( "icvYMLStartNextStream" );
1518
1519 __BEGIN__;
1520
1521 if( !fs->is_first )
1522 {
1523 while( fs->write_stack->total > 0 )
1524 icvYMLEndWriteStruct(fs);
1525
1526 fs->struct_indent = 0;
1527 icvFSFlush(fs);
1528 fputs( "...\n", fs->file );
1529 fputs( "---\n", fs->file );
1530 fs->buffer = fs->buffer_start;
1531 }
1532
1533 __END__;
1534 }
1535
1536
1537 static void
icvYMLWriteInt(CvFileStorage * fs,const char * key,int value)1538 icvYMLWriteInt( CvFileStorage* fs, const char* key, int value )
1539 {
1540 CV_FUNCNAME( "icvYMLWriteInt" );
1541
1542 __BEGIN__;
1543
1544 char buf[128];
1545 CV_CALL( icvYMLWrite( fs, key, icv_itoa( value, buf, 10 ), cvFuncName ));
1546
1547 __END__;
1548 }
1549
1550
1551 static void
icvYMLWriteReal(CvFileStorage * fs,const char * key,double value)1552 icvYMLWriteReal( CvFileStorage* fs, const char* key, double value )
1553 {
1554 CV_FUNCNAME( "icvYMLWriteReal" );
1555
1556 __BEGIN__;
1557
1558 char buf[128];
1559 CV_CALL( icvYMLWrite( fs, key, icvDoubleToString( buf, value ), cvFuncName ));
1560
1561 __END__;
1562 }
1563
1564
1565 static void
1566 icvYMLWriteString( CvFileStorage* fs, const char* key,
1567 const char* str, int quote CV_DEFAULT(0))
1568 {
1569 CV_FUNCNAME( "icvYMLWriteString" );
1570
1571 __BEGIN__;
1572
1573 char buf[CV_FS_MAX_LEN*4+16];
1574 char* data = (char*)str;
1575 int i, len;
1576
1577 if( !str )
1578 CV_ERROR( CV_StsNullPtr, "Null string pointer" );
1579
1580 len = (int)strlen(str);
1581 if( len > CV_FS_MAX_LEN )
1582 CV_ERROR( CV_StsBadArg, "The written string is too long" );
1583
1584 if( quote || len == 0 || str[0] != str[len-1] || (str[0] != '\"' && str[0] != '\'') )
1585 {
1586 int need_quote = quote || len == 0;
1587 data = buf;
1588 *data++ = '\"';
1589 for( i = 0; i < len; i++ )
1590 {
1591 char c = str[i];
1592
1593 if( !need_quote && !isalnum(c) && c != '_' && c != ' ' && c != '-' &&
1594 c != '(' && c != ')' && c != '/' && c != '+' && c != ';' )
1595 need_quote = 1;
1596
1597 if( !isalnum(c) && (!cv_isprint(c) || c == '\\' || c == '\'' || c == '\"') )
1598 {
1599 *data++ = '\\';
1600 if( cv_isprint(c) )
1601 *data++ = c;
1602 else if( c == '\n' )
1603 *data++ = 'n';
1604 else if( c == '\r' )
1605 *data++ = 'r';
1606 else if( c == '\t' )
1607 *data++ = 't';
1608 else
1609 {
1610 sprintf( data, "x%02x", c );
1611 data += 3;
1612 }
1613 }
1614 else
1615 *data++ = c;
1616 }
1617 if( !need_quote && (isdigit(str[0]) ||
1618 str[0] == '+' || str[0] == '-' || str[0] == '.' ))
1619 need_quote = 1;
1620
1621 if( need_quote )
1622 *data++ = '\"';
1623 *data++ = '\0';
1624 data = buf + !need_quote;
1625 }
1626
1627 CV_CALL( icvYMLWrite( fs, key, data, cvFuncName ));
1628
1629 __END__;
1630 }
1631
1632
1633 static void
icvYMLWriteComment(CvFileStorage * fs,const char * comment,int eol_comment)1634 icvYMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
1635 {
1636 CV_FUNCNAME( "icvYMLWriteComment" );
1637
1638 __BEGIN__;
1639
1640 int len; //, indent;
1641 int multiline;
1642 const char* eol;
1643 char* ptr;
1644
1645 if( !comment )
1646 CV_ERROR( CV_StsNullPtr, "Null comment" );
1647
1648 len = (int)strlen(comment);
1649 eol = strchr(comment, '\n');
1650 multiline = eol != 0;
1651 ptr = fs->buffer;
1652
1653 if( !eol_comment || multiline ||
1654 fs->buffer_end - ptr < len || ptr == fs->buffer_start )
1655 ptr = icvFSFlush( fs );
1656 else
1657 *ptr++ = ' ';
1658
1659 while( comment )
1660 {
1661 *ptr++ = '#';
1662 *ptr++ = ' ';
1663 if( eol )
1664 {
1665 ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 );
1666 memcpy( ptr, comment, eol - comment + 1 );
1667 fs->buffer = ptr + (eol - comment);
1668 comment = eol + 1;
1669 eol = strchr( comment, '\n' );
1670 }
1671 else
1672 {
1673 len = (int)strlen(comment);
1674 ptr = icvFSResizeWriteBuffer( fs, ptr, len );
1675 memcpy( ptr, comment, len );
1676 fs->buffer = ptr + len;
1677 comment = 0;
1678 }
1679 ptr = icvFSFlush( fs );
1680 }
1681
1682 __END__;
1683 }
1684
1685
1686 /****************************************************************************************\
1687 * XML Parser *
1688 \****************************************************************************************/
1689
1690 #define CV_XML_INSIDE_COMMENT 1
1691 #define CV_XML_INSIDE_TAG 2
1692 #define CV_XML_INSIDE_DIRECTIVE 3
1693
1694 static char*
icvXMLSkipSpaces(CvFileStorage * fs,char * ptr,int mode)1695 icvXMLSkipSpaces( CvFileStorage* fs, char* ptr, int mode )
1696 {
1697 CV_FUNCNAME( "icvXMLSkipSpaces" );
1698
1699 __BEGIN__;
1700
1701 int level = 0;
1702
1703 for(;;)
1704 {
1705 char c;
1706 ptr--;
1707
1708 if( mode == CV_XML_INSIDE_COMMENT )
1709 {
1710 do c = *++ptr;
1711 while( cv_isprint_or_tab(c) && (c != '-' || ptr[1] != '-' || ptr[2] != '>') );
1712
1713 if( c == '-' )
1714 {
1715 assert( ptr[1] == '-' && ptr[2] == '>' );
1716 mode = 0;
1717 ptr += 3;
1718 }
1719 }
1720 else if( mode == CV_XML_INSIDE_DIRECTIVE )
1721 {
1722 // !!!NOTE!!! This is not quite correct, but should work in most cases
1723 do
1724 {
1725 c = *++ptr;
1726 level += c == '<';
1727 level -= c == '>';
1728 if( level < 0 )
1729 EXIT;
1730 } while( cv_isprint_or_tab(c) );
1731 }
1732 else
1733 {
1734 do c = *++ptr;
1735 while( c == ' ' || c == '\t' );
1736
1737 if( c == '<' && ptr[1] == '!' && ptr[2] == '-' && ptr[3] == '-' )
1738 {
1739 if( mode != 0 )
1740 CV_PARSE_ERROR( "Comments are not allowed here" );
1741 mode = CV_XML_INSIDE_COMMENT;
1742 ptr += 4;
1743 }
1744 else if( cv_isprint(c) )
1745 break;
1746 }
1747
1748 if( !cv_isprint(*ptr) )
1749 {
1750 int max_size = (int)(fs->buffer_end - fs->buffer_start);
1751 if( *ptr != '\0' && *ptr != '\n' && *ptr != '\r' )
1752 CV_PARSE_ERROR( "Invalid character in the stream" );
1753 ptr = fgets( fs->buffer_start, max_size, fs->file );
1754 if( !ptr )
1755 {
1756 ptr = fs->buffer_start;
1757 *ptr = '\0';
1758 fs->dummy_eof = 1;
1759 break;
1760 }
1761 else
1762 {
1763 int l = (int)strlen(ptr);
1764 if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !feof(fs->file) )
1765 CV_PARSE_ERROR( "Too long string or a last string w/o newline" );
1766 }
1767 fs->lineno++;
1768 }
1769 }
1770
1771 __END__;
1772
1773 return ptr;
1774 }
1775
1776
1777 static char*
1778 icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag,
1779 CvAttrList** _list, int* _tag_type );
1780
1781 static char*
icvXMLParseValue(CvFileStorage * fs,char * ptr,CvFileNode * node,int value_type CV_DEFAULT (CV_NODE_NONE))1782 icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
1783 int value_type CV_DEFAULT(CV_NODE_NONE))
1784 {
1785 CV_FUNCNAME( "icvXMLParseValue" );
1786
1787 __BEGIN__;
1788
1789 CvFileNode *elem = node;
1790 int have_space = 1, is_simple = 1;
1791 int is_user_type = CV_NODE_IS_USER(value_type);
1792 memset( node, 0, sizeof(*node) );
1793
1794 value_type = CV_NODE_TYPE(value_type);
1795
1796 for(;;)
1797 {
1798 char c = *ptr, d;
1799 char* endptr;
1800
1801 if( isspace(c) || c == '\0' || (c == '<' && ptr[1] == '!' && ptr[2] == '-') )
1802 {
1803 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
1804 have_space = 1;
1805 c = *ptr;
1806 }
1807
1808 d = ptr[1];
1809
1810 if( c =='<' )
1811 {
1812 CvStringHashNode *key = 0, *key2 = 0;
1813 CvAttrList* list = 0;
1814 CvTypeInfo* info = 0;
1815 int tag_type = 0;
1816 int is_noname = 0;
1817 const char* type_name = 0;
1818 int elem_type = CV_NODE_NONE;
1819
1820 if( d == '/' )
1821 break;
1822
1823 CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type ));
1824
1825 if( tag_type == CV_XML_DIRECTIVE_TAG )
1826 CV_PARSE_ERROR( "Directive tags are not allowed here" );
1827 if( tag_type == CV_XML_EMPTY_TAG )
1828 CV_PARSE_ERROR( "Empty tags are not supported" );
1829
1830 assert( tag_type == CV_XML_OPENING_TAG );
1831
1832 type_name = list ? cvAttrValue( list, "type_id" ) : 0;
1833 if( type_name )
1834 {
1835 if( strcmp( type_name, "str" ) == 0 )
1836 elem_type = CV_NODE_STRING;
1837 else if( strcmp( type_name, "map" ) == 0 )
1838 elem_type = CV_NODE_MAP;
1839 else if( strcmp( type_name, "seq" ) == 0 )
1840 elem_type = CV_NODE_MAP;
1841 else
1842 {
1843 CV_CALL( info = cvFindType( type_name ));
1844 if( info )
1845 elem_type = CV_NODE_USER;
1846 }
1847 }
1848
1849 is_noname = key->str.len == 1 && key->str.ptr[0] == '_';
1850 if( !CV_NODE_IS_COLLECTION(node->tag) )
1851 {
1852 CV_CALL( icvFSCreateCollection( fs, is_noname ? CV_NODE_SEQ : CV_NODE_MAP, node ));
1853 }
1854 else if( is_noname ^ CV_NODE_IS_SEQ(node->tag) )
1855 CV_PARSE_ERROR( is_noname ? "Map element should have a name" :
1856 "Sequence element should not have name (use <_></_>)" );
1857
1858 if( is_noname )
1859 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1860 else
1861 CV_CALL( elem = cvGetFileNode( fs, node, key, 1 ));
1862
1863 CV_CALL( ptr = icvXMLParseValue( fs, ptr, elem, elem_type));
1864 if( !is_noname )
1865 elem->tag |= CV_NODE_NAMED;
1866 is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
1867 elem->info = info;
1868 CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type ));
1869 if( tag_type != CV_XML_CLOSING_TAG || key2 != key )
1870 CV_PARSE_ERROR( "Mismatched closing tag" );
1871 have_space = 1;
1872 }
1873 else
1874 {
1875 if( !have_space )
1876 CV_PARSE_ERROR( "There should be space between literals" );
1877
1878 elem = node;
1879 if( node->tag != CV_NODE_NONE )
1880 {
1881 if( !CV_NODE_IS_COLLECTION(node->tag) )
1882 CV_CALL( icvFSCreateCollection( fs, CV_NODE_SEQ, node ));
1883
1884 elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
1885 elem->info = 0;
1886 }
1887
1888 if( value_type != CV_NODE_STRING &&
1889 (isdigit(c) || ((c == '-' || c == '+') &&
1890 (isdigit(d) || d == '.')) || (c == '.' && isalnum(d))) ) // a number
1891 {
1892 double fval;
1893 int ival;
1894 endptr = ptr + (c == '-' || c == '+');
1895 while( isdigit(*endptr) )
1896 endptr++;
1897 if( *endptr == '.' || *endptr == 'e' )
1898 {
1899 fval = icv_strtod( fs, ptr, &endptr );
1900 /*if( endptr == ptr || isalpha(*endptr) )
1901 CV_CALL( icvProcessSpecialDouble( fs, ptr, &fval, &endptr ));*/
1902 elem->tag = CV_NODE_REAL;
1903 elem->data.f = fval;
1904 }
1905 else
1906 {
1907 ival = (int)strtol( ptr, &endptr, 0 );
1908 elem->tag = CV_NODE_INT;
1909 elem->data.i = ival;
1910 }
1911
1912 if( endptr == ptr )
1913 CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" );
1914
1915 ptr = endptr;
1916 }
1917 else
1918 {
1919 // string
1920 char buf[CV_FS_MAX_LEN+16];
1921 int i = 0, len, is_quoted = 0;
1922 elem->tag = CV_NODE_STRING;
1923 if( c == '\"' )
1924 is_quoted = 1;
1925 else
1926 --ptr;
1927
1928 for( ;; )
1929 {
1930 c = *++ptr;
1931 if( !isalnum(c) )
1932 {
1933 if( c == '\"' )
1934 {
1935 if( !is_quoted )
1936 CV_PARSE_ERROR( "Literal \" is not allowed within a string. Use "" );
1937 ++ptr;
1938 break;
1939 }
1940 else if( !cv_isprint(c) || c == '<' || (!is_quoted && isspace(c)))
1941 {
1942 if( is_quoted )
1943 CV_PARSE_ERROR( "Closing \" is expected" );
1944 break;
1945 }
1946 else if( c == '\'' || c == '>' )
1947 {
1948 CV_PARSE_ERROR( "Literal \' or > are not allowed. Use ' or >" );
1949 }
1950 else if( c == '&' )
1951 {
1952 if( *ptr == '#' )
1953 {
1954 int val;
1955 ptr++;
1956 val = (int)strtol( ptr, &endptr, 0 );
1957 if( (unsigned)val > (unsigned)255 ||
1958 !endptr || *endptr != ';' )
1959 CV_PARSE_ERROR( "Invalid numeric value in the string" );
1960 c = (char)val;
1961 }
1962 else
1963 {
1964 endptr = ptr++;
1965 do c = *++endptr;
1966 while( isalnum(c) );
1967 if( c != ';' )
1968 CV_PARSE_ERROR( "Invalid character in the symbol entity name" );
1969 len = (int)(endptr - ptr);
1970 if( len == 2 && memcmp( ptr, "lt", len ) == 0 )
1971 c = '<';
1972 else if( len == 2 && memcmp( ptr, "gt", len ) == 0 )
1973 c = '>';
1974 else if( len == 3 && memcmp( ptr, "amp", len ) == 0 )
1975 c = '&';
1976 else if( len == 4 && memcmp( ptr, "apos", len ) == 0 )
1977 c = '\'';
1978 else if( len == 4 && memcmp( ptr, "quot", len ) == 0 )
1979 c = '\"';
1980 else
1981 {
1982 memcpy( buf + i, ptr-1, len + 2 );
1983 i += len + 2;
1984 }
1985 }
1986 ptr = endptr;
1987 }
1988 }
1989 buf[i++] = c;
1990 if( i >= CV_FS_MAX_LEN )
1991 CV_PARSE_ERROR( "Too long string literal" );
1992 }
1993 CV_CALL( elem->data.str = cvMemStorageAllocString( fs->memstorage, buf, i ));
1994 }
1995
1996 if( !CV_NODE_IS_COLLECTION(value_type) && value_type != CV_NODE_NONE )
1997 break;
1998 have_space = 0;
1999 }
2000 }
2001
2002 if( (CV_NODE_TYPE(node->tag) == CV_NODE_NONE ||
2003 (CV_NODE_TYPE(node->tag) != value_type &&
2004 !CV_NODE_IS_COLLECTION(node->tag))) &&
2005 CV_NODE_IS_COLLECTION(value_type) )
2006 {
2007 CV_CALL( icvFSCreateCollection( fs, CV_NODE_IS_MAP(value_type) ?
2008 CV_NODE_MAP : CV_NODE_SEQ, node ));
2009 }
2010
2011 if( value_type != CV_NODE_NONE &&
2012 value_type != CV_NODE_TYPE(node->tag) )
2013 CV_PARSE_ERROR( "The actual type is different from the specified type" );
2014
2015 if( CV_NODE_IS_COLLECTION(node->tag) && is_simple )
2016 node->data.seq->flags |= CV_NODE_SEQ_SIMPLE;
2017
2018 node->tag |= is_user_type ? CV_NODE_USER : 0;
2019
2020 __END__;
2021
2022 return ptr;
2023 }
2024
2025
2026 static char*
icvXMLParseTag(CvFileStorage * fs,char * ptr,CvStringHashNode ** _tag,CvAttrList ** _list,int * _tag_type)2027 icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag,
2028 CvAttrList** _list, int* _tag_type )
2029 {
2030 int tag_type = 0;
2031 CvStringHashNode* tagname = 0;
2032 CvAttrList *first = 0, *last = 0;
2033 int count = 0, max_count = 4;
2034 int attr_buf_size = (max_count*2 + 1)*sizeof(char*) + sizeof(CvAttrList);
2035
2036 CV_FUNCNAME( "icvXMLParseTag" );
2037
2038 __BEGIN__;
2039
2040 char* endptr;
2041 char c;
2042 int have_space;
2043
2044 if( *ptr != '<' )
2045 CV_PARSE_ERROR( "Tag should start with \'<\'" );
2046
2047 ptr++;
2048 if( isalnum(*ptr) || *ptr == '_' )
2049 tag_type = CV_XML_OPENING_TAG;
2050 else if( *ptr == '/' )
2051 {
2052 tag_type = CV_XML_CLOSING_TAG;
2053 ptr++;
2054 }
2055 else if( *ptr == '?' )
2056 {
2057 tag_type = CV_XML_HEADER_TAG;
2058 ptr++;
2059 }
2060 else if( *ptr == '!' )
2061 {
2062 tag_type = CV_XML_DIRECTIVE_TAG;
2063 assert( ptr[1] != '-' || ptr[2] != '-' );
2064 ptr++;
2065 }
2066 else
2067 CV_PARSE_ERROR( "Unknown tag type" );
2068
2069 for(;;)
2070 {
2071 CvStringHashNode* attrname;
2072
2073 if( !isalpha(*ptr) && *ptr != '_' )
2074 CV_PARSE_ERROR( "Name should start with a letter or underscore" );
2075
2076 endptr = ptr - 1;
2077 do c = *++endptr;
2078 while( isalnum(c) || c == '_' || c == '-' );
2079
2080 CV_CALL( attrname = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 ));
2081 ptr = endptr;
2082
2083 if( !tagname )
2084 tagname = attrname;
2085 else
2086 {
2087 if( tag_type == CV_XML_CLOSING_TAG )
2088 CV_PARSE_ERROR( "Closing tag should not contain any attributes" );
2089
2090 if( !last || count >= max_count )
2091 {
2092 CvAttrList* chunk;
2093
2094 CV_CALL( chunk = (CvAttrList*)cvMemStorageAlloc( fs->memstorage, attr_buf_size ));
2095 memset( chunk, 0, attr_buf_size );
2096 chunk->attr = (const char**)(chunk + 1);
2097 count = 0;
2098 if( !last )
2099 first = last = chunk;
2100 else
2101 last = last->next = chunk;
2102 }
2103 last->attr[count*2] = attrname->str.ptr;
2104 }
2105
2106 if( last )
2107 {
2108 CvFileNode stub;
2109
2110 if( *ptr != '=' )
2111 {
2112 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
2113 if( *ptr != '=' )
2114 CV_PARSE_ERROR( "Attribute name should be followed by \'=\'" );
2115 }
2116
2117 c = *++ptr;
2118 if( c != '\"' && c != '\'' )
2119 {
2120 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
2121 if( *ptr != '\"' && *ptr != '\'' )
2122 CV_PARSE_ERROR( "Attribute value should be put into single or double quotes" );
2123 }
2124
2125 ptr = icvXMLParseValue( fs, ptr, &stub, CV_NODE_STRING );
2126 assert( stub.tag == CV_NODE_STRING );
2127 last->attr[count*2+1] = stub.data.str.ptr;
2128 count++;
2129 }
2130
2131 c = *ptr;
2132 have_space = isspace(c) || c == '\0';
2133
2134 if( c != '>' )
2135 {
2136 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
2137 c = *ptr;
2138 }
2139
2140 if( c == '>' )
2141 {
2142 if( tag_type == CV_XML_HEADER_TAG )
2143 CV_PARSE_ERROR( "Invalid closing tag for <?xml ..." );
2144 ptr++;
2145 break;
2146 }
2147 else if( c == '?' && tag_type == CV_XML_HEADER_TAG )
2148 {
2149 if( ptr[1] != '>' )
2150 CV_PARSE_ERROR( "Invalid closing tag for <?xml ..." );
2151 ptr += 2;
2152 break;
2153 }
2154 else if( c == '/' && ptr[1] == '>' && tag_type == CV_XML_OPENING_TAG )
2155 {
2156 tag_type = CV_XML_EMPTY_TAG;
2157 ptr += 2;
2158 break;
2159 }
2160
2161 if( !have_space )
2162 CV_PARSE_ERROR( "There should be space between attributes" );
2163 }
2164
2165 __END__;
2166
2167 *_tag = tagname;
2168 *_tag_type = tag_type;
2169 *_list = first;
2170
2171 return ptr;
2172 }
2173
2174
2175 static void
icvXMLParse(CvFileStorage * fs)2176 icvXMLParse( CvFileStorage* fs )
2177 {
2178 CV_FUNCNAME( "icvXMLParse" );
2179
2180 __BEGIN__;
2181
2182 char* ptr = fs->buffer_start;
2183 CvStringHashNode *key = 0, *key2 = 0;
2184 CvAttrList* list = 0;
2185 int tag_type = 0;
2186
2187 // CV_XML_INSIDE_TAG is used to prohibit leading comments
2188 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, CV_XML_INSIDE_TAG ));
2189
2190 if( memcmp( ptr, "<?xml", 5 ) != 0 )
2191 CV_PARSE_ERROR( "Valid XML should start with \'<?xml ...?>\'" );
2192
2193 CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type ));
2194
2195 /*{
2196 const char* version = cvAttrValue( list, "version" );
2197 if( version && strncmp( version, "1.", 2 ) != 0 )
2198 CV_ERROR( CV_StsParseError, "Unsupported version of XML" );
2199 }*/
2200 {
2201 const char* encoding = cvAttrValue( list, "encoding" );
2202 if( encoding && strcmp( encoding, "ASCII" ) != 0 )
2203 CV_PARSE_ERROR( "Unsupported encoding" );
2204 }
2205
2206 while( *ptr != '\0' )
2207 {
2208 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
2209
2210 if( *ptr != '\0' )
2211 {
2212 CvFileNode* root_node;
2213 CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type ));
2214 if( tag_type != CV_XML_OPENING_TAG ||
2215 strcmp(key->str.ptr,"opencv_storage") != 0 )
2216 CV_PARSE_ERROR( "<opencv_storage> tag is missing" );
2217
2218 root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 );
2219 CV_CALL( ptr = icvXMLParseValue( fs, ptr, root_node, CV_NODE_NONE ));
2220 CV_CALL( ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type ));
2221 if( tag_type != CV_XML_CLOSING_TAG || key != key2 )
2222 CV_PARSE_ERROR( "</opencv_storage> tag is missing" );
2223 CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
2224 }
2225 }
2226
2227 assert( fs->dummy_eof != 0 );
2228
2229 __END__;
2230 }
2231
2232
2233 /****************************************************************************************\
2234 * XML Emitter *
2235 \****************************************************************************************/
2236
2237 #define icvXMLFlush icvFSFlush
2238
2239 static void
icvXMLWriteTag(CvFileStorage * fs,const char * key,int tag_type,CvAttrList list)2240 icvXMLWriteTag( CvFileStorage* fs, const char* key, int tag_type, CvAttrList list )
2241 {
2242 CV_FUNCNAME( "icvXMLWriteTag" );
2243
2244 __BEGIN__;
2245
2246 char* ptr = fs->buffer;
2247 int i, len = 0;
2248 int struct_flags = fs->struct_flags;
2249
2250 if( key && key[0] == '\0' )
2251 key = 0;
2252
2253 if( tag_type == CV_XML_OPENING_TAG || tag_type == CV_XML_EMPTY_TAG )
2254 {
2255 if( CV_NODE_IS_COLLECTION(struct_flags) )
2256 {
2257 if( CV_NODE_IS_MAP(struct_flags) ^ (key != 0) )
2258 CV_ERROR( CV_StsBadArg, "An attempt to add element without a key to a map, "
2259 "or add element with key to sequence" );
2260 }
2261 else
2262 {
2263 struct_flags = CV_NODE_EMPTY + (key ? CV_NODE_MAP : CV_NODE_SEQ);
2264 fs->is_first = 0;
2265 }
2266
2267 if( !CV_NODE_IS_EMPTY(struct_flags) )
2268 ptr = icvXMLFlush(fs);
2269 }
2270
2271 if( !key )
2272 key = "_";
2273 else if( key[0] == '_' && key[1] == '\0' )
2274 CV_ERROR( CV_StsBadArg, "A single _ is a reserved tag name" );
2275
2276 len = (int)strlen( key );
2277 *ptr++ = '<';
2278 if( tag_type == CV_XML_CLOSING_TAG )
2279 {
2280 if( list.attr )
2281 CV_ERROR( CV_StsBadArg, "Closing tag should not include any attributes" );
2282 *ptr++ = '/';
2283 }
2284
2285 if( !isalpha(key[0]) && key[0] != '_' )
2286 CV_ERROR( CV_StsBadArg, "Key should start with a letter or _" );
2287
2288 ptr = icvFSResizeWriteBuffer( fs, ptr, len );
2289 for( i = 0; i < len; i++ )
2290 {
2291 char c = key[i];
2292 if( !isalnum(c) && c != '_' && c != '-' )
2293 CV_ERROR( CV_StsBadArg, "Invalid character in the key" );
2294 ptr[i] = c;
2295 }
2296 ptr += len;
2297
2298 for(;;)
2299 {
2300 const char** attr = list.attr;
2301
2302 for( ; attr && attr[0] != 0; attr += 2 )
2303 {
2304 int len0 = (int)strlen(attr[0]);
2305 int len1 = (int)strlen(attr[1]);
2306
2307 ptr = icvFSResizeWriteBuffer( fs, ptr, len0 + len1 + 4 );
2308 *ptr++ = ' ';
2309 memcpy( ptr, attr[0], len0 );
2310 ptr += len0;
2311 *ptr++ = '=';
2312 *ptr++ = '\"';
2313 memcpy( ptr, attr[1], len1 );
2314 ptr += len1;
2315 *ptr++ = '\"';
2316 }
2317 if( !list.next )
2318 break;
2319 list = *list.next;
2320 }
2321
2322 if( tag_type == CV_XML_EMPTY_TAG )
2323 *ptr++ = '/';
2324 *ptr++ = '>';
2325 fs->buffer = ptr;
2326 fs->struct_flags = struct_flags & ~CV_NODE_EMPTY;
2327
2328 __END__;
2329 }
2330
2331
2332 static void
2333 icvXMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
2334 const char* type_name CV_DEFAULT(0))
2335 {
2336 CV_FUNCNAME( "icvXMLStartWriteStruct" );
2337
2338 __BEGIN__;
2339
2340 CvXMLStackRecord parent;
2341 const char* attr[10];
2342 int idx = 0;
2343
2344 struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY;
2345 if( !CV_NODE_IS_COLLECTION(struct_flags))
2346 CV_ERROR( CV_StsBadArg,
2347 "Some collection type: CV_NODE_SEQ or CV_NODE_MAP must be specified" );
2348
2349 if( type_name )
2350 {
2351 attr[idx++] = "type_id";
2352 attr[idx++] = type_name;
2353 }
2354 attr[idx++] = 0;
2355
2356 CV_CALL( icvXMLWriteTag( fs, key, CV_XML_OPENING_TAG, cvAttrList(attr,0) ));
2357
2358 parent.struct_flags = fs->struct_flags & ~CV_NODE_EMPTY;
2359 parent.struct_indent = fs->struct_indent;
2360 parent.struct_tag = fs->struct_tag;
2361 cvSaveMemStoragePos( fs->strstorage, &parent.pos );
2362 cvSeqPush( fs->write_stack, &parent );
2363
2364 fs->struct_indent += CV_XML_INDENT;
2365 if( !CV_NODE_IS_FLOW(struct_flags) )
2366 icvXMLFlush( fs );
2367
2368 fs->struct_flags = struct_flags;
2369 if( key )
2370 {
2371 CV_CALL( fs->struct_tag = cvMemStorageAllocString( fs->strstorage, (char*)key, -1 ));
2372 }
2373 else
2374 {
2375 fs->struct_tag.ptr = 0;
2376 fs->struct_tag.len = 0;
2377 }
2378
2379 __END__;
2380 }
2381
2382
2383 static void
icvXMLEndWriteStruct(CvFileStorage * fs)2384 icvXMLEndWriteStruct( CvFileStorage* fs )
2385 {
2386 CV_FUNCNAME( "icvXMLStartWriteStruct" );
2387
2388 __BEGIN__;
2389
2390 CvXMLStackRecord parent;
2391
2392 if( fs->write_stack->total == 0 )
2393 CV_ERROR( CV_StsError, "An extra closing tag" );
2394
2395 CV_CALL( icvXMLWriteTag( fs, fs->struct_tag.ptr, CV_XML_CLOSING_TAG, cvAttrList(0,0) ));
2396 cvSeqPop( fs->write_stack, &parent );
2397
2398 fs->struct_indent = parent.struct_indent;
2399 fs->struct_flags = parent.struct_flags;
2400 fs->struct_tag = parent.struct_tag;
2401 cvRestoreMemStoragePos( fs->strstorage, &parent.pos );
2402
2403 __END__;
2404 }
2405
2406
2407 static void
icvXMLStartNextStream(CvFileStorage * fs)2408 icvXMLStartNextStream( CvFileStorage* fs )
2409 {
2410 //CV_FUNCNAME( "icvXMLStartNextStream" );
2411
2412 __BEGIN__;
2413
2414 if( !fs->is_first )
2415 {
2416 while( fs->write_stack->total > 0 )
2417 icvXMLEndWriteStruct(fs);
2418
2419 fs->struct_indent = 0;
2420 icvXMLFlush(fs);
2421 /* XML does not allow multiple top-level elements,
2422 so we just put a comment and continue
2423 the current (and the only) "stream" */
2424 fputs( "\n<!-- next stream -->\n", fs->file );
2425 /*fputs( "</opencv_storage>\n", fs->file );
2426 fputs( "<opencv_storage>\n", fs->file );*/
2427 fs->buffer = fs->buffer_start;
2428 }
2429
2430 __END__;
2431 }
2432
2433
2434 static void
icvXMLWriteScalar(CvFileStorage * fs,const char * key,const char * data,int len)2435 icvXMLWriteScalar( CvFileStorage* fs, const char* key, const char* data, int len )
2436 {
2437 CV_FUNCNAME( "icvXMLWriteScalar" );
2438
2439 __BEGIN__;
2440
2441 if( CV_NODE_IS_MAP(fs->struct_flags) ||
2442 (!CV_NODE_IS_COLLECTION(fs->struct_flags) && key) )
2443 {
2444 icvXMLWriteTag( fs, key, CV_XML_OPENING_TAG, cvAttrList(0,0) );
2445 char* ptr = icvFSResizeWriteBuffer( fs, fs->buffer, len );
2446 memcpy( ptr, data, len );
2447 fs->buffer = ptr + len;
2448 icvXMLWriteTag( fs, key, CV_XML_CLOSING_TAG, cvAttrList(0,0) );
2449 }
2450 else
2451 {
2452 char* ptr = fs->buffer;
2453 int new_offset = (int)(ptr - fs->buffer_start) + len;
2454
2455 if( key )
2456 CV_ERROR( CV_StsBadArg, "elements with keys can not be written to sequence" );
2457
2458 fs->struct_flags = CV_NODE_SEQ;
2459
2460 if( (new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10) ||
2461 (ptr > fs->buffer_start && ptr[-1] == '>' && !CV_NODE_IS_EMPTY(fs->struct_flags)) )
2462 {
2463 ptr = icvXMLFlush(fs);
2464 }
2465 else if( ptr > fs->buffer_start + fs->struct_indent && ptr[-1] != '>' )
2466 *ptr++ = ' ';
2467
2468 memcpy( ptr, data, len );
2469 fs->buffer = ptr + len;
2470 }
2471
2472 __END__;
2473 }
2474
2475
2476 static void
icvXMLWriteInt(CvFileStorage * fs,const char * key,int value)2477 icvXMLWriteInt( CvFileStorage* fs, const char* key, int value )
2478 {
2479 //CV_FUNCNAME( "cvXMLWriteInt" );
2480
2481 __BEGIN__;
2482
2483 char buf[128], *ptr = icv_itoa( value, buf, 10 );
2484 int len = (int)strlen(ptr);
2485 icvXMLWriteScalar( fs, key, ptr, len );
2486
2487 __END__;
2488 }
2489
2490
2491 static void
icvXMLWriteReal(CvFileStorage * fs,const char * key,double value)2492 icvXMLWriteReal( CvFileStorage* fs, const char* key, double value )
2493 {
2494 //CV_FUNCNAME( "cvXMLWriteReal" );
2495
2496 __BEGIN__;
2497
2498 char buf[128];
2499 int len = (int)strlen( icvDoubleToString( buf, value ));
2500 icvXMLWriteScalar( fs, key, buf, len );
2501
2502 __END__;
2503 }
2504
2505
2506 static void
icvXMLWriteString(CvFileStorage * fs,const char * key,const char * str,int quote)2507 icvXMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote )
2508 {
2509 CV_FUNCNAME( "cvXMLWriteString" );
2510
2511 __BEGIN__;
2512
2513 char buf[CV_FS_MAX_LEN*6+16];
2514 char* data = (char*)str;
2515 int i, len;
2516
2517 if( !str )
2518 CV_ERROR( CV_StsNullPtr, "Null string pointer" );
2519
2520 len = (int)strlen(str);
2521 if( len > CV_FS_MAX_LEN )
2522 CV_ERROR( CV_StsBadArg, "The written string is too long" );
2523
2524 if( quote || len == 0 || str[0] != '\"' || str[0] != str[len-1] )
2525 {
2526 int need_quote = quote || len == 0;
2527 data = buf;
2528 *data++ = '\"';
2529 for( i = 0; i < len; i++ )
2530 {
2531 char c = str[i];
2532
2533 if( !isalnum(c) && (!cv_isprint(c) || c == '<' || c == '>' ||
2534 c == '&' || c == '\'' || c == '\"') )
2535 {
2536 *data++ = '&';
2537 if( c == '<' )
2538 {
2539 memcpy(data, "lt", 2);
2540 data += 2;
2541 }
2542 else if( c == '>' )
2543 {
2544 memcpy(data, "gt", 2);
2545 data += 2;
2546 }
2547 else if( c == '&' )
2548 {
2549 memcpy(data, "amp", 3);
2550 data += 3;
2551 }
2552 else if( c == '\'' )
2553 {
2554 memcpy(data, "apos", 4);
2555 data += 4;
2556 }
2557 else if( c == '\"' )
2558 {
2559 memcpy( data, "quot", 4);
2560 data += 4;
2561 }
2562 else
2563 {
2564 sprintf( data, "#x%02x", c );
2565 data += 4;
2566 }
2567 *data++ = ';';
2568 }
2569 else
2570 {
2571 if( c == ' ' )
2572 need_quote = 1;
2573 *data++ = c;
2574 }
2575 }
2576 if( !need_quote && (isdigit(str[0]) ||
2577 str[0] == '+' || str[0] == '-' || str[0] == '.' ))
2578 need_quote = 1;
2579
2580 if( need_quote )
2581 *data++ = '\"';
2582 len = (int)(data - buf) - !need_quote;
2583 *data++ = '\0';
2584 data = buf + !need_quote;
2585 }
2586
2587 icvXMLWriteScalar( fs, key, data, len );
2588
2589 __END__;
2590 }
2591
2592
2593 static void
icvXMLWriteComment(CvFileStorage * fs,const char * comment,int eol_comment)2594 icvXMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
2595 {
2596 CV_FUNCNAME( "cvXMLWriteComment" );
2597
2598 __BEGIN__;
2599
2600 int len;
2601 int multiline;
2602 const char* eol;
2603 char* ptr;
2604
2605 if( !comment )
2606 CV_ERROR( CV_StsNullPtr, "Null comment" );
2607
2608 if( strstr(comment, "--") != 0 )
2609 CV_ERROR( CV_StsBadArg, "Double hyphen \'--\' is not allowed in the comments" );
2610
2611 len = (int)strlen(comment);
2612 eol = strchr(comment, '\n');
2613 multiline = eol != 0;
2614 ptr = fs->buffer;
2615
2616 if( multiline || !eol_comment || fs->buffer_end - ptr < len + 5 )
2617 ptr = icvXMLFlush( fs );
2618 else if( ptr > fs->buffer_start + fs->struct_indent )
2619 *ptr++ = ' ';
2620
2621 if( !multiline )
2622 {
2623 ptr = icvFSResizeWriteBuffer( fs, ptr, len + 9 );
2624 sprintf( ptr, "<!-- %s -->", comment );
2625 len = (int)strlen(ptr);
2626 }
2627 else
2628 {
2629 strcpy( ptr, "<!--" );
2630 len = 4;
2631 }
2632
2633 fs->buffer = ptr + len;
2634 ptr = icvXMLFlush(fs);
2635
2636 if( multiline )
2637 {
2638 while( comment )
2639 {
2640 if( eol )
2641 {
2642 ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 );
2643 memcpy( ptr, comment, eol - comment + 1 );
2644 ptr += eol - comment;
2645 comment = eol + 1;
2646 eol = strchr( comment, '\n' );
2647 }
2648 else
2649 {
2650 len = (int)strlen(comment);
2651 ptr = icvFSResizeWriteBuffer( fs, ptr, len );
2652 memcpy( ptr, comment, len );
2653 ptr += len;
2654 comment = 0;
2655 }
2656 fs->buffer = ptr;
2657 ptr = icvXMLFlush( fs );
2658 }
2659 sprintf( ptr, "-->" );
2660 fs->buffer = ptr + 3;
2661 icvXMLFlush( fs );
2662 }
2663
2664 __END__;
2665 }
2666
2667
2668 /****************************************************************************************\
2669 * Common High-Level Functions *
2670 \****************************************************************************************/
2671
2672 CV_IMPL CvFileStorage*
cvOpenFileStorage(const char * filename,CvMemStorage * dststorage,int flags)2673 cvOpenFileStorage( const char* filename, CvMemStorage* dststorage, int flags )
2674 {
2675 CvFileStorage* fs = 0;
2676 char* xml_buf = 0;
2677
2678 CV_FUNCNAME("cvOpenFileStorage" );
2679
2680 __BEGIN__;
2681
2682 int default_block_size = 1 << 18;
2683 bool append = (flags & 3) == CV_STORAGE_APPEND;
2684
2685 if( !filename )
2686 CV_ERROR( CV_StsNullPtr, "NULL filename" );
2687
2688 CV_CALL( fs = (CvFileStorage*)cvAlloc( sizeof(*fs) ));
2689 memset( fs, 0, sizeof(*fs));
2690
2691 CV_CALL( fs->memstorage = cvCreateMemStorage( default_block_size ));
2692 fs->dststorage = dststorage ? dststorage : fs->memstorage;
2693
2694 CV_CALL( fs->filename = (char*)cvMemStorageAlloc( fs->memstorage, strlen(filename)+1 ));
2695 strcpy( fs->filename, filename );
2696
2697 fs->flags = CV_FILE_STORAGE;
2698 fs->write_mode = (flags & 3) != 0;
2699 fs->file = fopen( fs->filename, !fs->write_mode ? "rt" : !append ? "wt" : "a+t" );
2700 if( !fs->file )
2701 EXIT;
2702
2703 fs->roots = 0;
2704 fs->struct_indent = 0;
2705 fs->struct_flags = 0;
2706 fs->wrap_margin = 71;
2707
2708 if( fs->write_mode )
2709 {
2710 // we use factor=6 for XML (the longest characters (' and ") are encoded with 6 bytes (' and ")
2711 // and factor=4 for YAML ( as we use 4 bytes for non ASCII characters (e.g. \xAB))
2712 int buf_size = CV_FS_MAX_LEN*(fs->is_xml ? 6 : 4) + 1024;
2713
2714 char* dot_pos = strrchr( fs->filename, '.' );
2715 fs->is_xml = dot_pos && (strcmp( dot_pos, ".xml" ) == 0 ||
2716 strcmp( dot_pos, ".XML" ) == 0 || strcmp( dot_pos, ".Xml" ) == 0);
2717
2718 if( append )
2719 fseek( fs->file, 0, SEEK_END );
2720
2721 fs->write_stack = cvCreateSeq( 0, sizeof(CvSeq), fs->is_xml ?
2722 sizeof(CvXMLStackRecord) : sizeof(int), fs->memstorage );
2723 fs->is_first = 1;
2724 fs->struct_indent = 0;
2725 fs->struct_flags = CV_NODE_EMPTY;
2726 CV_CALL( fs->buffer_start = fs->buffer = (char*)cvAlloc( buf_size + 1024 ));
2727 fs->buffer_end = fs->buffer_start + buf_size;
2728 if( fs->is_xml )
2729 {
2730 int file_size = (int)ftell( fs->file );
2731 CV_CALL( fs->strstorage = cvCreateChildMemStorage( fs->memstorage ));
2732 if( !append || file_size == 0 )
2733 {
2734 fputs( "<?xml version=\"1.0\"?>\n", fs->file );
2735 fputs( "<opencv_storage>\n", fs->file );
2736 }
2737 else
2738 {
2739 int xml_buf_size = 1 << 10;
2740 char substr[] = "</opencv_storage>";
2741 int last_occurence = -1;
2742 xml_buf_size = MIN(xml_buf_size, file_size);
2743 fseek( fs->file, -xml_buf_size, SEEK_END );
2744 CV_CALL(xml_buf = (char*)cvAlloc( xml_buf_size+2 ));
2745 // find the last occurence of </opencv_storage>
2746 for(;;)
2747 {
2748 int line_offset = ftell( fs->file );
2749 char* ptr0 = fgets( xml_buf, xml_buf_size, fs->file ), *ptr;
2750 if( !ptr0 )
2751 break;
2752 ptr = ptr0;
2753 for(;;)
2754 {
2755 ptr = strstr( ptr, substr );
2756 if( !ptr )
2757 break;
2758 last_occurence = line_offset + (int)(ptr - ptr0);
2759 ptr += strlen(substr);
2760 }
2761 }
2762 if( last_occurence < 0 )
2763 CV_ERROR( CV_StsError, "Could not find </opencv_storage> in the end of file.\n" );
2764 fclose( fs->file );
2765 fs->file = fopen( fs->filename, "r+t" );
2766 fseek( fs->file, last_occurence, SEEK_SET );
2767 // replace the last "</opencv_storage>" with " <!-- resumed -->", which has the same length
2768 fputs( " <!-- resumed -->", fs->file );
2769 fseek( fs->file, 0, SEEK_END );
2770 fputs( "\n", fs->file );
2771 }
2772 fs->start_write_struct = icvXMLStartWriteStruct;
2773 fs->end_write_struct = icvXMLEndWriteStruct;
2774 fs->write_int = icvXMLWriteInt;
2775 fs->write_real = icvXMLWriteReal;
2776 fs->write_string = icvXMLWriteString;
2777 fs->write_comment = icvXMLWriteComment;
2778 fs->start_next_stream = icvXMLStartNextStream;
2779 }
2780 else
2781 {
2782 if( !append )
2783 fputs( "%YAML:1.0\n", fs->file );
2784 else
2785 fputs( "...\n---\n", fs->file );
2786 fs->start_write_struct = icvYMLStartWriteStruct;
2787 fs->end_write_struct = icvYMLEndWriteStruct;
2788 fs->write_int = icvYMLWriteInt;
2789 fs->write_real = icvYMLWriteReal;
2790 fs->write_string = icvYMLWriteString;
2791 fs->write_comment = icvYMLWriteComment;
2792 fs->start_next_stream = icvYMLStartNextStream;
2793 }
2794 }
2795 else
2796 {
2797 int buf_size;
2798 const char* yaml_signature = "%YAML:";
2799 char buf[16];
2800 fgets( buf, sizeof(buf)-2, fs->file );
2801 fs->is_xml = strncmp( buf, yaml_signature, strlen(yaml_signature) ) != 0;
2802
2803 fseek( fs->file, 0, SEEK_END );
2804 buf_size = ftell( fs->file );
2805 fseek( fs->file, 0, SEEK_SET );
2806
2807 buf_size = MIN( buf_size, (1 << 20) );
2808 buf_size = MAX( buf_size, CV_FS_MAX_LEN*2 + 1024 );
2809
2810 CV_CALL( fs->str_hash = cvCreateMap( 0, sizeof(CvStringHash),
2811 sizeof(CvStringHashNode), fs->memstorage, 256 ));
2812
2813 CV_CALL( fs->roots = cvCreateSeq( 0, sizeof(CvSeq),
2814 sizeof(CvFileNode), fs->memstorage ));
2815
2816 CV_CALL( fs->buffer = fs->buffer_start = (char*)cvAlloc( buf_size + 256 ));
2817 fs->buffer_end = fs->buffer_start + buf_size;
2818 fs->buffer[0] = '\n';
2819 fs->buffer[1] = '\0';
2820
2821 //mode = cvGetErrMode();
2822 //cvSetErrMode( CV_ErrModeSilent );
2823 if( fs->is_xml )
2824 icvXMLParse( fs );
2825 else
2826 icvYMLParse( fs );
2827 //cvSetErrMode( mode );
2828
2829 // release resources that we do not need anymore
2830 cvFree( &fs->buffer_start );
2831 fs->buffer = fs->buffer_end = 0;
2832 }
2833
2834 __END__;
2835
2836 if( fs )
2837 {
2838 if( cvGetErrStatus() < 0 || !fs->file )
2839 {
2840 cvReleaseFileStorage( &fs );
2841 }
2842 else if( !fs->write_mode )
2843 {
2844 fclose( fs->file );
2845 fs->file = 0;
2846 }
2847 }
2848
2849 cvFree( &xml_buf );
2850
2851 return fs;
2852 }
2853
2854
2855 CV_IMPL void
cvStartWriteStruct(CvFileStorage * fs,const char * key,int struct_flags,const char * type_name,CvAttrList)2856 cvStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
2857 const char* type_name, CvAttrList /*attributes*/ )
2858 {
2859 CV_FUNCNAME( "cvStartWriteStruct" );
2860
2861 __BEGIN__;
2862
2863 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2864 CV_CALL( fs->start_write_struct( fs, key, struct_flags, type_name ));
2865
2866 __END__;
2867 }
2868
2869
2870 CV_IMPL void
cvEndWriteStruct(CvFileStorage * fs)2871 cvEndWriteStruct( CvFileStorage* fs )
2872 {
2873 CV_FUNCNAME( "cvEndWriteStruct" );
2874
2875 __BEGIN__;
2876
2877 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2878 CV_CALL( fs->end_write_struct( fs ));
2879
2880 __END__;
2881 }
2882
2883
2884 CV_IMPL void
cvWriteInt(CvFileStorage * fs,const char * key,int value)2885 cvWriteInt( CvFileStorage* fs, const char* key, int value )
2886 {
2887 CV_FUNCNAME( "cvWriteInt" );
2888
2889 __BEGIN__;
2890
2891 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2892 CV_CALL( fs->write_int( fs, key, value ));
2893
2894 __END__;
2895 }
2896
2897
2898 CV_IMPL void
cvWriteReal(CvFileStorage * fs,const char * key,double value)2899 cvWriteReal( CvFileStorage* fs, const char* key, double value )
2900 {
2901 CV_FUNCNAME( "cvWriteReal" );
2902
2903 __BEGIN__;
2904
2905 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2906 CV_CALL( fs->write_real( fs, key, value ));
2907
2908 __END__;
2909 }
2910
2911
2912 CV_IMPL void
cvWriteString(CvFileStorage * fs,const char * key,const char * value,int quote)2913 cvWriteString( CvFileStorage* fs, const char* key, const char* value, int quote )
2914 {
2915 CV_FUNCNAME( "cvWriteString" );
2916
2917 __BEGIN__;
2918
2919 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2920 CV_CALL( fs->write_string( fs, key, value, quote ));
2921
2922 __END__;
2923 }
2924
2925
2926 CV_IMPL void
cvWriteComment(CvFileStorage * fs,const char * comment,int eol_comment)2927 cvWriteComment( CvFileStorage* fs, const char* comment, int eol_comment )
2928 {
2929 CV_FUNCNAME( "cvWriteComment" );
2930
2931 __BEGIN__;
2932
2933 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2934 CV_CALL( fs->write_comment( fs, comment, eol_comment ));
2935
2936 __END__;
2937 }
2938
2939
2940 CV_IMPL void
cvStartNextStream(CvFileStorage * fs)2941 cvStartNextStream( CvFileStorage* fs )
2942 {
2943 CV_FUNCNAME( "cvStartNextStream" );
2944
2945 __BEGIN__;
2946
2947 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
2948 CV_CALL( fs->start_next_stream( fs ));
2949
2950 __END__;
2951 }
2952
2953
2954 static const char icvTypeSymbol[] = "ucwsifdr";
2955 #define CV_FS_MAX_FMT_PAIRS 128
2956
2957 static char*
icvEncodeFormat(int elem_type,char * dt)2958 icvEncodeFormat( int elem_type, char* dt )
2959 {
2960 sprintf( dt, "%d%c", CV_MAT_CN(elem_type), icvTypeSymbol[CV_MAT_DEPTH(elem_type)] );
2961 return dt + ( dt[2] == '\0' && dt[0] == '1' );
2962 }
2963
2964 static int
icvDecodeFormat(const char * dt,int * fmt_pairs,int max_len)2965 icvDecodeFormat( const char* dt, int* fmt_pairs, int max_len )
2966 {
2967 int fmt_pair_count = 0;
2968 CV_FUNCNAME( "icvDecodeFormat" );
2969
2970 __BEGIN__;
2971
2972 int i = 0, k = 0, len = dt ? (int)strlen(dt) : 0;
2973
2974 if( !dt || !len )
2975 EXIT;
2976
2977 assert( fmt_pairs != 0 && max_len > 0 );
2978 fmt_pairs[0] = 0;
2979 max_len *= 2;
2980
2981 for( ; k < len; k++ )
2982 {
2983 char c = dt[k];
2984
2985 if( isdigit(c) )
2986 {
2987 int count = c - '0';
2988 if( isdigit(dt[k+1]) )
2989 {
2990 char* endptr = 0;
2991 count = (int)strtol( dt+k, &endptr, 10 );
2992 k = (int)(endptr - dt) - 1;
2993 }
2994
2995 if( count <= 0 )
2996 CV_ERROR( CV_StsBadArg, "Invalid data type specification" );
2997
2998 fmt_pairs[i] = count;
2999 }
3000 else
3001 {
3002 const char* pos = strchr( icvTypeSymbol, c );
3003 if( !pos )
3004 CV_ERROR( CV_StsBadArg, "Invalid data type specification" );
3005 if( fmt_pairs[i] == 0 )
3006 fmt_pairs[i] = 1;
3007 fmt_pairs[i+1] = (int)(pos - icvTypeSymbol);
3008 if( i > 0 && fmt_pairs[i+1] == fmt_pairs[i-1] )
3009 fmt_pairs[i-2] += fmt_pairs[i];
3010 else
3011 {
3012 i += 2;
3013 if( i >= max_len )
3014 CV_ERROR( CV_StsBadArg, "Too long data type specification" );
3015 }
3016 fmt_pairs[i] = 0;
3017 }
3018 }
3019
3020 fmt_pair_count = i/2;
3021
3022 __END__;
3023
3024 return fmt_pair_count;
3025 }
3026
3027
3028 static int
icvCalcElemSize(const char * dt,int initial_size)3029 icvCalcElemSize( const char* dt, int initial_size )
3030 {
3031 int size = 0;
3032 CV_FUNCNAME( "icvCalcElemSize" );
3033
3034 __BEGIN__;
3035
3036 int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count;
3037 int comp_size;
3038
3039 CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
3040 fmt_pair_count *= 2;
3041 for( i = 0, size = initial_size; i < fmt_pair_count; i += 2 )
3042 {
3043 comp_size = CV_ELEM_SIZE(fmt_pairs[i+1]);
3044 size = cvAlign( size, comp_size );
3045 size += comp_size * fmt_pairs[i];
3046 }
3047 if( initial_size == 0 )
3048 {
3049 comp_size = CV_ELEM_SIZE(fmt_pairs[1]);
3050 size = cvAlign( size, comp_size );
3051 }
3052
3053 __END__;
3054
3055 return size;
3056 }
3057
3058
3059 static int
icvDecodeSimpleFormat(const char * dt)3060 icvDecodeSimpleFormat( const char* dt )
3061 {
3062 int elem_type = -1;
3063
3064 CV_FUNCNAME( "icvDecodeSimpleFormat" );
3065
3066 __BEGIN__;
3067
3068 int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
3069
3070 CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
3071 if( fmt_pair_count != 1 || fmt_pairs[0] > 4 )
3072 CV_ERROR( CV_StsError, "Too complex format for the matrix" );
3073
3074 elem_type = CV_MAKETYPE( fmt_pairs[1], fmt_pairs[0] );
3075
3076 __END__;
3077
3078 return elem_type;
3079 }
3080
3081
3082 CV_IMPL void
cvWriteRawData(CvFileStorage * fs,const void * _data,int len,const char * dt)3083 cvWriteRawData( CvFileStorage* fs, const void* _data, int len, const char* dt )
3084 {
3085 const char* data0 = (const char*)_data;
3086
3087 CV_FUNCNAME( "cvWriteRawData" );
3088
3089 __BEGIN__;
3090
3091 int offset = 0;
3092 int fmt_pairs[CV_FS_MAX_FMT_PAIRS*2], k, fmt_pair_count;
3093 char buf[256] = "";
3094
3095 CV_CHECK_OUTPUT_FILE_STORAGE( fs );
3096
3097 if( !data0 )
3098 CV_ERROR( CV_StsNullPtr, "Null data pointer" );
3099
3100 if( len < 0 )
3101 CV_ERROR( CV_StsOutOfRange, "Negative number of elements" );
3102
3103 CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
3104
3105 if( !len )
3106 EXIT;
3107
3108 if( fmt_pair_count == 1 )
3109 {
3110 fmt_pairs[0] *= len;
3111 len = 1;
3112 }
3113
3114 for(;len--;)
3115 {
3116 for( k = 0; k < fmt_pair_count; k++ )
3117 {
3118 int i, count = fmt_pairs[k*2];
3119 int elem_type = fmt_pairs[k*2+1];
3120 int elem_size = CV_ELEM_SIZE(elem_type);
3121 const char* data, *ptr;
3122
3123 offset = cvAlign( offset, elem_size );
3124 data = data0 + offset;
3125
3126 for( i = 0; i < count; i++ )
3127 {
3128 switch( elem_type )
3129 {
3130 case CV_8U:
3131 ptr = icv_itoa( *(uchar*)data, buf, 10 );
3132 data++;
3133 break;
3134 case CV_8S:
3135 ptr = icv_itoa( *(char*)data, buf, 10 );
3136 data++;
3137 break;
3138 case CV_16U:
3139 ptr = icv_itoa( *(ushort*)data, buf, 10 );
3140 data += sizeof(ushort);
3141 break;
3142 case CV_16S:
3143 ptr = icv_itoa( *(short*)data, buf, 10 );
3144 data += sizeof(short);
3145 break;
3146 case CV_32S:
3147 ptr = icv_itoa( *(int*)data, buf, 10 );
3148 data += sizeof(int);
3149 break;
3150 case CV_32F:
3151 ptr = icvFloatToString( buf, *(float*)data );
3152 data += sizeof(float);
3153 break;
3154 case CV_64F:
3155 ptr = icvDoubleToString( buf, *(double*)data );
3156 data += sizeof(double);
3157 break;
3158 case CV_USRTYPE1: /* reference */
3159 ptr = icv_itoa( (int)*(size_t*)data, buf, 10 );
3160 data += sizeof(size_t);
3161 break;
3162 default:
3163 assert(0);
3164 EXIT;
3165 }
3166
3167 if( fs->is_xml )
3168 {
3169 int buf_len = (int)strlen(ptr);
3170 CV_CALL( icvXMLWriteScalar( fs, 0, ptr, buf_len ));
3171 }
3172 else
3173 CV_CALL( icvYMLWrite( fs, 0, ptr, cvFuncName ));
3174 }
3175
3176 offset = (int)(data - data0);
3177 }
3178 }
3179
3180 __END__;
3181 }
3182
3183
3184 CV_IMPL void
cvStartReadRawData(const CvFileStorage * fs,const CvFileNode * src,CvSeqReader * reader)3185 cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader )
3186 {
3187 CV_FUNCNAME( "cvStartReadRawData" );
3188
3189 __BEGIN__;
3190
3191 int node_type;
3192 CV_CHECK_FILE_STORAGE( fs );
3193
3194 if( !src || !reader )
3195 CV_ERROR( CV_StsNullPtr, "Null pointer to source file node or reader" );
3196
3197 node_type = CV_NODE_TYPE(src->tag);
3198 if( node_type == CV_NODE_INT || node_type == CV_NODE_REAL )
3199 {
3200 // emulate reading from 1-element sequence
3201 reader->ptr = (schar*)src;
3202 reader->block_max = reader->ptr + sizeof(*src)*2;
3203 reader->block_min = reader->ptr;
3204 reader->seq = 0;
3205 }
3206 else if( node_type == CV_NODE_SEQ )
3207 {
3208 CV_CALL( cvStartReadSeq( src->data.seq, reader, 0 ));
3209 }
3210 else if( node_type == CV_NODE_NONE )
3211 {
3212 memset( reader, 0, sizeof(*reader) );
3213 }
3214 else
3215 CV_ERROR( CV_StsBadArg, "The file node should be a numerical scalar or a sequence" );
3216
3217 __END__;
3218 }
3219
3220
3221 CV_IMPL void
cvReadRawDataSlice(const CvFileStorage * fs,CvSeqReader * reader,int len,void * _data,const char * dt)3222 cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
3223 int len, void* _data, const char* dt )
3224 {
3225 char* data0 = (char*)_data;
3226 CV_FUNCNAME( "cvReadRawDataSlice" );
3227
3228 __BEGIN__;
3229
3230 int fmt_pairs[CV_FS_MAX_FMT_PAIRS*2], k = 0, fmt_pair_count;
3231 int i = 0, offset = 0, count = 0;
3232
3233 CV_CHECK_FILE_STORAGE( fs );
3234
3235 if( !reader || !data0 )
3236 CV_ERROR( CV_StsNullPtr, "Null pointer to reader or destination array" );
3237
3238 if( !reader->seq && len != 1 )
3239 CV_ERROR( CV_StsBadSize, "The readed sequence is a scalar, thus len must be 1" );
3240
3241 CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
3242
3243 for(;;)
3244 {
3245 for( k = 0; k < fmt_pair_count; k++ )
3246 {
3247 int elem_type = fmt_pairs[k*2+1];
3248 int elem_size = CV_ELEM_SIZE(elem_type);
3249 char* data;
3250
3251 count = fmt_pairs[k*2];
3252 offset = cvAlign( offset, elem_size );
3253 data = data0 + offset;
3254
3255 for( i = 0; i < count; i++ )
3256 {
3257 CvFileNode* node = (CvFileNode*)reader->ptr;
3258 if( CV_NODE_IS_INT(node->tag) )
3259 {
3260 int ival = node->data.i;
3261
3262 switch( elem_type )
3263 {
3264 case CV_8U:
3265 *(uchar*)data = CV_CAST_8U(ival);
3266 data++;
3267 break;
3268 case CV_8S:
3269 *(char*)data = CV_CAST_8S(ival);
3270 break;
3271 case CV_16U:
3272 *(ushort*)data = CV_CAST_16U(ival);
3273 data += sizeof(ushort);
3274 break;
3275 case CV_16S:
3276 *(short*)data = CV_CAST_16S(ival);
3277 data += sizeof(short);
3278 break;
3279 case CV_32S:
3280 *(int*)data = ival;
3281 data += sizeof(int);
3282 break;
3283 case CV_32F:
3284 *(float*)data = (float)ival;
3285 data += sizeof(float);
3286 break;
3287 case CV_64F:
3288 *(double*)data = (double)ival;
3289 data += sizeof(double);
3290 break;
3291 case CV_USRTYPE1: /* reference */
3292 *(size_t*)data = ival;
3293 data += sizeof(size_t);
3294 break;
3295 default:
3296 assert(0);
3297 EXIT;
3298 }
3299 }
3300 else if( CV_NODE_IS_REAL(node->tag) )
3301 {
3302 double fval = node->data.f;
3303 int ival;
3304
3305 switch( elem_type )
3306 {
3307 case CV_8U:
3308 ival = cvRound(fval);
3309 *(uchar*)data = CV_CAST_8U(ival);
3310 data++;
3311 break;
3312 case CV_8S:
3313 ival = cvRound(fval);
3314 *(char*)data = CV_CAST_8S(ival);
3315 break;
3316 case CV_16U:
3317 ival = cvRound(fval);
3318 *(ushort*)data = CV_CAST_16U(ival);
3319 data += sizeof(ushort);
3320 break;
3321 case CV_16S:
3322 ival = cvRound(fval);
3323 *(short*)data = CV_CAST_16S(ival);
3324 data += sizeof(short);
3325 break;
3326 case CV_32S:
3327 ival = cvRound(fval);
3328 *(int*)data = ival;
3329 data += sizeof(int);
3330 break;
3331 case CV_32F:
3332 *(float*)data = (float)fval;
3333 data += sizeof(float);
3334 break;
3335 case CV_64F:
3336 *(double*)data = fval;
3337 data += sizeof(double);
3338 break;
3339 case CV_USRTYPE1: /* reference */
3340 ival = cvRound(fval);
3341 *(size_t*)data = ival;
3342 data += sizeof(size_t);
3343 break;
3344 default:
3345 assert(0);
3346 EXIT;
3347 }
3348 }
3349 else
3350 CV_ERROR( CV_StsError,
3351 "The sequence element is not a numerical scalar" );
3352
3353 CV_NEXT_SEQ_ELEM( sizeof(CvFileNode), *reader );
3354 if( !--len )
3355 goto end_loop;
3356 }
3357
3358 offset = (int)(data - data0);
3359 }
3360 }
3361
3362 end_loop:
3363 if( i != count - 1 || k != fmt_pair_count - 1 )
3364 CV_ERROR( CV_StsBadSize,
3365 "The sequence slice does not fit an integer number of records" );
3366
3367 if( !reader->seq )
3368 reader->ptr -= sizeof(CvFileNode);
3369
3370 __END__;
3371 }
3372
3373
3374 CV_IMPL void
cvReadRawData(const CvFileStorage * fs,const CvFileNode * src,void * data,const char * dt)3375 cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
3376 void* data, const char* dt )
3377 {
3378 CV_FUNCNAME( "cvReadRawData" );
3379
3380 __BEGIN__;
3381
3382 CvSeqReader reader;
3383
3384 if( !src || !data )
3385 CV_ERROR( CV_StsNullPtr, "Null pointers to source file node or destination array" );
3386
3387 CV_CALL( cvStartReadRawData( fs, src, &reader ));
3388 cvReadRawDataSlice( fs, &reader, CV_NODE_IS_SEQ(src->tag) ?
3389 src->data.seq->total : 1, data, dt );
3390
3391 __END__;
3392 }
3393
3394
3395 static void
3396 icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node );
3397
3398 static void
icvWriteCollection(CvFileStorage * fs,const CvFileNode * node)3399 icvWriteCollection( CvFileStorage* fs, const CvFileNode* node )
3400 {
3401 int i, total = node->data.seq->total;
3402 int elem_size = node->data.seq->elem_size;
3403 int is_map = CV_NODE_IS_MAP(node->tag);
3404 CvSeqReader reader;
3405
3406 cvStartReadSeq( node->data.seq, &reader, 0 );
3407
3408 for( i = 0; i < total; i++ )
3409 {
3410 CvFileMapNode* elem = (CvFileMapNode*)reader.ptr;
3411 if( !is_map || CV_IS_SET_ELEM(elem) )
3412 {
3413 const char* name = is_map ? elem->key->str.ptr : 0;
3414 icvWriteFileNode( fs, name, &elem->value );
3415 }
3416 CV_NEXT_SEQ_ELEM( elem_size, reader );
3417 }
3418 }
3419
3420 static void
icvWriteFileNode(CvFileStorage * fs,const char * name,const CvFileNode * node)3421 icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node )
3422 {
3423 CV_FUNCNAME( "icvWriteFileNode" );
3424
3425 __BEGIN__;
3426
3427 switch( CV_NODE_TYPE(node->tag) )
3428 {
3429 case CV_NODE_INT:
3430 fs->write_int( fs, name, node->data.i );
3431 break;
3432 case CV_NODE_REAL:
3433 fs->write_real( fs, name, node->data.f );
3434 break;
3435 case CV_NODE_STR:
3436 fs->write_string( fs, name, node->data.str.ptr, 0 );
3437 break;
3438 case CV_NODE_SEQ:
3439 case CV_NODE_MAP:
3440 fs->start_write_struct( fs, name, CV_NODE_TYPE(node->tag) +
3441 (CV_NODE_SEQ_IS_SIMPLE(node->data.seq) ? CV_NODE_FLOW : 0),
3442 node->info ? node->info->type_name : 0 );
3443 icvWriteCollection( fs, node );
3444 fs->end_write_struct( fs );
3445 break;
3446 case CV_NODE_NONE:
3447 fs->start_write_struct( fs, name, CV_NODE_SEQ, 0 );
3448 fs->end_write_struct( fs );
3449 break;
3450 default:
3451 CV_ERROR( CV_StsBadFlag, "Unknown type of file node" );
3452 }
3453
3454 __END__;
3455 }
3456
3457
3458 CV_IMPL void
cvWriteFileNode(CvFileStorage * fs,const char * new_node_name,const CvFileNode * node,int embed)3459 cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
3460 const CvFileNode* node, int embed )
3461 {
3462 CvFileStorage* dst = 0;
3463
3464 CV_FUNCNAME( "cvWriteFileNode" );
3465
3466 __BEGIN__;
3467
3468 CV_CHECK_OUTPUT_FILE_STORAGE(fs);
3469
3470 if( !node )
3471 EXIT;
3472
3473 if( CV_NODE_IS_COLLECTION(node->tag) && embed )
3474 {
3475 CV_CALL( icvWriteCollection( fs, node ));
3476 }
3477 else
3478 {
3479 CV_CALL( icvWriteFileNode( fs, new_node_name, node ));
3480 }
3481 /*
3482 int i, stream_count;
3483 stream_count = fs->roots->total;
3484 for( i = 0; i < stream_count; i++ )
3485 {
3486 CvFileNode* node = (CvFileNode*)cvGetSeqElem( fs->roots, i, 0 );
3487 icvDumpCollection( dst, node );
3488 if( i < stream_count - 1 )
3489 dst->start_next_stream( dst );
3490 }*/
3491
3492 __END__;
3493
3494 cvReleaseFileStorage( &dst );
3495 }
3496
3497
3498 CV_IMPL const char*
cvGetFileNodeName(const CvFileNode * file_node)3499 cvGetFileNodeName( const CvFileNode* file_node )
3500 {
3501 return file_node && CV_NODE_HAS_NAME(file_node->tag) ?
3502 ((CvFileMapNode*)file_node)->key->str.ptr : 0;
3503 }
3504
3505 /****************************************************************************************\
3506 * Reading/Writing etc. for standard types *
3507 \****************************************************************************************/
3508
3509 /*#define CV_TYPE_NAME_MAT "opencv-matrix"
3510 #define CV_TYPE_NAME_MATND "opencv-nd-matrix"
3511 #define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"
3512 #define CV_TYPE_NAME_IMAGE "opencv-image"
3513 #define CV_TYPE_NAME_SEQ "opencv-sequence"
3514 #define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
3515 #define CV_TYPE_NAME_GRAPH "opencv-graph"*/
3516
3517 /******************************* CvMat ******************************/
3518
3519 static int
icvIsMat(const void * ptr)3520 icvIsMat( const void* ptr )
3521 {
3522 return CV_IS_MAT_HDR(ptr);
3523 }
3524
3525 static void
icvWriteMat(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList)3526 icvWriteMat( CvFileStorage* fs, const char* name,
3527 const void* struct_ptr, CvAttrList /*attr*/ )
3528 {
3529 CV_FUNCNAME( "icvWriteMat" );
3530
3531 __BEGIN__;
3532
3533 const CvMat* mat = (const CvMat*)struct_ptr;
3534 char dt[16];
3535 CvSize size;
3536 int y;
3537
3538 assert( CV_IS_MAT(mat) );
3539
3540 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_MAT ));
3541 cvWriteInt( fs, "rows", mat->rows );
3542 cvWriteInt( fs, "cols", mat->cols );
3543 cvWriteString( fs, "dt", icvEncodeFormat( CV_MAT_TYPE(mat->type), dt ), 0 );
3544 cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3545
3546 size = cvGetSize(mat);
3547 if( CV_IS_MAT_CONT(mat->type) )
3548 {
3549 size.width *= size.height;
3550 size.height = 1;
3551 }
3552
3553 for( y = 0; y < size.height; y++ )
3554 cvWriteRawData( fs, mat->data.ptr + y*mat->step, size.width, dt );
3555 cvEndWriteStruct( fs );
3556 cvEndWriteStruct( fs );
3557
3558 __END__;
3559 }
3560
3561
3562 static int
icvFileNodeSeqLen(CvFileNode * node)3563 icvFileNodeSeqLen( CvFileNode* node )
3564 {
3565 return CV_NODE_IS_COLLECTION(node->tag) ? node->data.seq->total :
3566 CV_NODE_TYPE(node->tag) != CV_NODE_NONE;
3567 }
3568
3569
3570 static void*
icvReadMat(CvFileStorage * fs,CvFileNode * node)3571 icvReadMat( CvFileStorage* fs, CvFileNode* node )
3572 {
3573 void* ptr = 0;
3574 CV_FUNCNAME( "icvReadMat" );
3575
3576 __BEGIN__;
3577
3578 CvMat* mat;
3579 const char* dt;
3580 CvFileNode* data;
3581 int rows, cols, elem_type;
3582
3583 CV_CALL( rows = cvReadIntByName( fs, node, "rows", 0 ));
3584 cols = cvReadIntByName( fs, node, "cols", 0 );
3585 dt = cvReadStringByName( fs, node, "dt", 0 );
3586
3587 if( rows == 0 || cols == 0 || dt == 0 )
3588 CV_ERROR( CV_StsError, "Some of essential matrix attributes are absent" );
3589
3590 CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
3591
3592 data = cvGetFileNodeByName( fs, node, "data" );
3593 if( !data )
3594 CV_ERROR( CV_StsError, "The matrix data is not found in file storage" );
3595
3596 if( icvFileNodeSeqLen( data ) != rows*cols*CV_MAT_CN(elem_type) )
3597 CV_ERROR( CV_StsUnmatchedSizes,
3598 "The matrix size does not match to the number of stored elements" );
3599
3600 CV_CALL( mat = cvCreateMat( rows, cols, elem_type ));
3601 CV_CALL( cvReadRawData( fs, data, mat->data.ptr, dt ));
3602
3603 ptr = mat;
3604
3605 __END__;
3606
3607 return ptr;
3608 }
3609
3610
3611 /******************************* CvMatND ******************************/
3612
3613 static int
icvIsMatND(const void * ptr)3614 icvIsMatND( const void* ptr )
3615 {
3616 return CV_IS_MATND(ptr);
3617 }
3618
3619
3620 static void
icvWriteMatND(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList)3621 icvWriteMatND( CvFileStorage* fs, const char* name,
3622 const void* struct_ptr, CvAttrList /*attr*/ )
3623 {
3624 CV_FUNCNAME( "icvWriteMatND" );
3625
3626 __BEGIN__;
3627
3628 void* mat = (void*)struct_ptr;
3629 CvMatND stub;
3630 CvNArrayIterator iterator;
3631 int dims, sizes[CV_MAX_DIM];
3632 char dt[16];
3633
3634 assert( CV_IS_MATND(mat) );
3635
3636 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_MATND ));
3637 dims = cvGetDims( mat, sizes );
3638 cvStartWriteStruct( fs, "sizes", CV_NODE_SEQ + CV_NODE_FLOW );
3639 cvWriteRawData( fs, sizes, dims, "i" );
3640 cvEndWriteStruct( fs );
3641 cvWriteString( fs, "dt", icvEncodeFormat( cvGetElemType(mat), dt ), 0 );
3642 cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3643
3644 CV_CALL( cvInitNArrayIterator( 1, &mat, 0, &stub, &iterator ));
3645
3646 do
3647 cvWriteRawData( fs, iterator.ptr[0], iterator.size.width, dt );
3648 while( cvNextNArraySlice( &iterator ));
3649 cvEndWriteStruct( fs );
3650 cvEndWriteStruct( fs );
3651
3652 __END__;
3653 }
3654
3655
3656 static void*
icvReadMatND(CvFileStorage * fs,CvFileNode * node)3657 icvReadMatND( CvFileStorage* fs, CvFileNode* node )
3658 {
3659 void* ptr = 0;
3660 CV_FUNCNAME( "icvReadMatND" );
3661
3662 __BEGIN__;
3663
3664 CvMatND* mat;
3665 const char* dt;
3666 CvFileNode* data;
3667 CvFileNode* sizes_node;
3668 int sizes[CV_MAX_DIM], dims, elem_type;
3669 int i, total_size;
3670
3671 CV_CALL( sizes_node = cvGetFileNodeByName( fs, node, "sizes" ));
3672 dt = cvReadStringByName( fs, node, "dt", 0 );
3673
3674 if( !sizes_node || !dt )
3675 CV_ERROR( CV_StsError, "Some of essential matrix attributes are absent" );
3676
3677 dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
3678 CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
3679
3680 if( dims <= 0 || dims > CV_MAX_DIM )
3681 CV_ERROR( CV_StsParseError, "Could not determine the matrix dimensionality" );
3682
3683 CV_CALL( cvReadRawData( fs, sizes_node, sizes, "i" ));
3684 CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
3685
3686 data = cvGetFileNodeByName( fs, node, "data" );
3687 if( !data )
3688 CV_ERROR( CV_StsError, "The matrix data is not found in file storage" );
3689
3690 for( total_size = CV_MAT_CN(elem_type), i = 0; i < dims; i++ )
3691 total_size *= sizes[i];
3692
3693 if( icvFileNodeSeqLen( data ) != total_size )
3694 CV_ERROR( CV_StsUnmatchedSizes,
3695 "The matrix size does not match to the number of stored elements" );
3696
3697 CV_CALL( mat = cvCreateMatND( dims, sizes, elem_type ));
3698 CV_CALL( cvReadRawData( fs, data, mat->data.ptr, dt ));
3699
3700 ptr = mat;
3701
3702 __END__;
3703
3704 return ptr;
3705 }
3706
3707
3708 /******************************* CvSparseMat ******************************/
3709
3710 static int
icvIsSparseMat(const void * ptr)3711 icvIsSparseMat( const void* ptr )
3712 {
3713 return CV_IS_SPARSE_MAT(ptr);
3714 }
3715
3716
3717 static int
icvSortIdxCmpFunc(const void * _a,const void * _b,void * userdata)3718 icvSortIdxCmpFunc( const void* _a, const void* _b, void* userdata )
3719 {
3720 int i, dims = *(int*)userdata;
3721 const int* a = *(const int**)_a;
3722 const int* b = *(const int**)_b;
3723
3724 for( i = 0; i < dims; i++ )
3725 {
3726 int delta = a[i] - b[i];
3727 if( delta )
3728 return delta;
3729 }
3730
3731 return 0;
3732 }
3733
3734
3735 static void
icvWriteSparseMat(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList)3736 icvWriteSparseMat( CvFileStorage* fs, const char* name,
3737 const void* struct_ptr, CvAttrList /*attr*/ )
3738 {
3739 CvMemStorage* memstorage = 0;
3740
3741 CV_FUNCNAME( "icvWriteSparseMat" );
3742
3743 __BEGIN__;
3744
3745 const CvSparseMat* mat = (const CvSparseMat*)struct_ptr;
3746 CvSparseMatIterator iterator;
3747 CvSparseNode* node;
3748 CvSeq* elements;
3749 CvSeqReader reader;
3750 int i, dims;
3751 int *prev_idx = 0;
3752 char dt[16];
3753
3754 assert( CV_IS_SPARSE_MAT(mat) );
3755
3756 CV_CALL( memstorage = cvCreateMemStorage());
3757
3758 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SPARSE_MAT ));
3759 dims = cvGetDims( mat, 0 );
3760
3761 cvStartWriteStruct( fs, "sizes", CV_NODE_SEQ + CV_NODE_FLOW );
3762 cvWriteRawData( fs, mat->size, dims, "i" );
3763 cvEndWriteStruct( fs );
3764 cvWriteString( fs, "dt", icvEncodeFormat( CV_MAT_TYPE(mat->type), dt ), 0 );
3765 cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3766
3767 elements = cvCreateSeq( CV_SEQ_ELTYPE_PTR, sizeof(CvSeq), sizeof(int*), memstorage );
3768
3769 node = cvInitSparseMatIterator( mat, &iterator );
3770 while( node )
3771 {
3772 int* idx = CV_NODE_IDX( mat, node );
3773 cvSeqPush( elements, &idx );
3774 node = cvGetNextSparseNode( &iterator );
3775 }
3776
3777 cvSeqSort( elements, icvSortIdxCmpFunc, &dims );
3778 cvStartReadSeq( elements, &reader, 0 );
3779
3780 for( i = 0; i < elements->total; i++ )
3781 {
3782 int* idx;
3783 void* val;
3784 int k = 0;
3785
3786 CV_READ_SEQ_ELEM( idx, reader );
3787 if( i > 0 )
3788 {
3789 for( ; idx[k] == prev_idx[k]; k++ )
3790 assert( k < dims );
3791 if( k < dims - 1 )
3792 fs->write_int( fs, 0, k - dims + 1 );
3793 }
3794 for( ; k < dims; k++ )
3795 fs->write_int( fs, 0, idx[k] );
3796 prev_idx = idx;
3797
3798 node = (CvSparseNode*)((uchar*)idx - mat->idxoffset );
3799 val = CV_NODE_VAL( mat, node );
3800
3801 cvWriteRawData( fs, val, 1, dt );
3802 }
3803
3804 cvEndWriteStruct( fs );
3805 cvEndWriteStruct( fs );
3806
3807 __END__;
3808
3809 cvReleaseMemStorage( &memstorage );
3810 }
3811
3812
3813 static void*
icvReadSparseMat(CvFileStorage * fs,CvFileNode * node)3814 icvReadSparseMat( CvFileStorage* fs, CvFileNode* node )
3815 {
3816 void* ptr = 0;
3817 CV_FUNCNAME( "icvReadSparseMat" );
3818
3819 __BEGIN__;
3820
3821 CvSparseMat* mat;
3822 const char* dt;
3823 CvFileNode* data;
3824 CvFileNode* sizes_node;
3825 CvSeqReader reader;
3826 CvSeq* elements;
3827 int* idx;
3828 int* sizes = 0, dims, elem_type, cn;
3829 int i;
3830
3831 CV_CALL( sizes_node = cvGetFileNodeByName( fs, node, "sizes" ));
3832 dt = cvReadStringByName( fs, node, "dt", 0 );
3833
3834 if( !sizes_node || !dt )
3835 CV_ERROR( CV_StsError, "Some of essential matrix attributes are absent" );
3836
3837 dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
3838 CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
3839
3840 if( dims <= 0 || dims > CV_MAX_DIM_HEAP )
3841 CV_ERROR( CV_StsParseError, "Could not determine sparse matrix dimensionality" );
3842
3843 sizes = (int*)alloca( dims*sizeof(sizes[0]));
3844 CV_CALL( cvReadRawData( fs, sizes_node, sizes, "i" ));
3845 CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
3846
3847 data = cvGetFileNodeByName( fs, node, "data" );
3848 if( !data || !CV_NODE_IS_SEQ(data->tag) )
3849 CV_ERROR( CV_StsError, "The matrix data is not found in file storage" );
3850
3851 CV_CALL( mat = cvCreateSparseMat( dims, sizes, elem_type ));
3852
3853 cn = CV_MAT_CN(elem_type);
3854 idx = (int*)alloca( dims*sizeof(idx[0]) );
3855 elements = data->data.seq;
3856 cvStartReadRawData( fs, data, &reader );
3857
3858 for( i = 0; i < elements->total; )
3859 {
3860 CvFileNode* elem = (CvFileNode*)reader.ptr;
3861 uchar* val;
3862 int k;
3863 if( !CV_NODE_IS_INT(elem->tag ))
3864 CV_ERROR( CV_StsParseError, "Sparse matrix data is corrupted" );
3865 k = elem->data.i;
3866 if( i > 0 && k >= 0 )
3867 idx[dims-1] = k;
3868 else
3869 {
3870 if( i > 0 )
3871 k = dims + k - 1;
3872 else
3873 idx[0] = k, k = 1;
3874 for( ; k < dims; k++ )
3875 {
3876 CV_NEXT_SEQ_ELEM( elements->elem_size, reader );
3877 i++;
3878 elem = (CvFileNode*)reader.ptr;
3879 if( !CV_NODE_IS_INT(elem->tag ) || elem->data.i < 0 )
3880 CV_ERROR( CV_StsParseError, "Sparse matrix data is corrupted" );
3881 idx[k] = elem->data.i;
3882 }
3883 }
3884 CV_NEXT_SEQ_ELEM( elements->elem_size, reader );
3885 i++;
3886 CV_CALL( val = cvPtrND( mat, idx, 0, 1, 0 ));
3887 CV_CALL( cvReadRawDataSlice( fs, &reader, cn, val, dt ));
3888 i += cn;
3889 }
3890
3891 ptr = mat;
3892
3893 __END__;
3894
3895 return ptr;
3896 }
3897
3898
3899 /******************************* IplImage ******************************/
3900
3901 static int
icvIsImage(const void * ptr)3902 icvIsImage( const void* ptr )
3903 {
3904 return CV_IS_IMAGE_HDR(ptr);
3905 }
3906
3907 static void
icvWriteImage(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList)3908 icvWriteImage( CvFileStorage* fs, const char* name,
3909 const void* struct_ptr, CvAttrList /*attr*/ )
3910 {
3911 CV_FUNCNAME( "icvWriteImage" );
3912
3913 __BEGIN__;
3914
3915 const IplImage* image = (const IplImage*)struct_ptr;
3916 char dt_buf[16], *dt;
3917 CvSize size;
3918 int y, depth;
3919
3920 assert( CV_IS_IMAGE(image) );
3921
3922 if( image->dataOrder == IPL_DATA_ORDER_PLANE )
3923 CV_ERROR( CV_StsUnsupportedFormat,
3924 "Images with planar data layout are not supported" );
3925
3926 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_IMAGE ));
3927 cvWriteInt( fs, "width", image->width );
3928 cvWriteInt( fs, "height", image->height );
3929 cvWriteString( fs, "origin", image->origin == IPL_ORIGIN_TL
3930 ? "top-left" : "bottom-left", 0 );
3931 cvWriteString( fs, "layout", image->dataOrder == IPL_DATA_ORDER_PLANE
3932 ? "planar" : "interleaved", 0 );
3933 if( image->roi )
3934 {
3935 cvStartWriteStruct( fs, "roi", CV_NODE_MAP + CV_NODE_FLOW );
3936 cvWriteInt( fs, "x", image->roi->xOffset );
3937 cvWriteInt( fs, "y", image->roi->yOffset );
3938 cvWriteInt( fs, "width", image->roi->width );
3939 cvWriteInt( fs, "height", image->roi->height );
3940 cvWriteInt( fs, "coi", image->roi->coi );
3941 cvEndWriteStruct( fs );
3942 }
3943
3944 depth = icvIplToCvDepth(image->depth);
3945 sprintf( dt_buf, "%d%c", image->nChannels, icvTypeSymbol[depth] );
3946 dt = dt_buf + (dt_buf[2] == '\0' && dt_buf[0] == '1');
3947 cvWriteString( fs, "dt", dt, 0 );
3948
3949 size = cvSize(image->width, image->height);
3950 if( size.width*image->nChannels*CV_ELEM_SIZE(depth) == image->widthStep )
3951 {
3952 size.width *= size.height;
3953 size.height = 1;
3954 }
3955
3956 cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
3957 for( y = 0; y < size.height; y++ )
3958 cvWriteRawData( fs, image->imageData + y*image->widthStep, size.width, dt );
3959 cvEndWriteStruct( fs );
3960 cvEndWriteStruct( fs );
3961
3962 __END__;
3963 }
3964
3965
3966 static void*
icvReadImage(CvFileStorage * fs,CvFileNode * node)3967 icvReadImage( CvFileStorage* fs, CvFileNode* node )
3968 {
3969 void* ptr = 0;
3970 CV_FUNCNAME( "icvReadImage" );
3971
3972 __BEGIN__;
3973
3974 IplImage* image;
3975 const char* dt;
3976 CvFileNode* data;
3977 CvFileNode* roi_node;
3978 CvSeqReader reader;
3979 CvRect roi;
3980 int y, width, height, elem_type, coi, depth;
3981 const char* origin, *data_order;
3982
3983 CV_CALL( width = cvReadIntByName( fs, node, "width", 0 ));
3984 height = cvReadIntByName( fs, node, "height", 0 );
3985 dt = cvReadStringByName( fs, node, "dt", 0 );
3986 origin = cvReadStringByName( fs, node, "origin", 0 );
3987
3988 if( width == 0 || height == 0 || dt == 0 || origin == 0 )
3989 CV_ERROR( CV_StsError, "Some of essential image attributes are absent" );
3990
3991 CV_CALL( elem_type = icvDecodeSimpleFormat( dt ));
3992 data_order = cvReadStringByName( fs, node, "layout", "interleaved" );
3993 if( strcmp( data_order, "interleaved" ) != 0 )
3994 CV_ERROR( CV_StsError, "Only interleaved images can be read" );
3995
3996 data = cvGetFileNodeByName( fs, node, "data" );
3997 if( !data )
3998 CV_ERROR( CV_StsError, "The image data is not found in file storage" );
3999
4000 if( icvFileNodeSeqLen( data ) != width*height*CV_MAT_CN(elem_type) )
4001 CV_ERROR( CV_StsUnmatchedSizes,
4002 "The matrix size does not match to the number of stored elements" );
4003
4004 depth = cvCvToIplDepth(elem_type);
4005 CV_CALL( image = cvCreateImage( cvSize(width,height), depth, CV_MAT_CN(elem_type) ));
4006
4007 roi_node = cvGetFileNodeByName( fs, node, "roi" );
4008 if( roi_node )
4009 {
4010 roi.x = cvReadIntByName( fs, roi_node, "x", 0 );
4011 roi.y = cvReadIntByName( fs, roi_node, "y", 0 );
4012 roi.width = cvReadIntByName( fs, roi_node, "width", 0 );
4013 roi.height = cvReadIntByName( fs, roi_node, "height", 0 );
4014 coi = cvReadIntByName( fs, roi_node, "coi", 0 );
4015
4016 cvSetImageROI( image, roi );
4017 cvSetImageCOI( image, coi );
4018 }
4019
4020 if( width*CV_ELEM_SIZE(elem_type) == image->widthStep )
4021 {
4022 width *= height;
4023 height = 1;
4024 }
4025
4026 width *= CV_MAT_CN(elem_type);
4027 cvStartReadRawData( fs, data, &reader );
4028 for( y = 0; y < height; y++ )
4029 {
4030 CV_CALL( cvReadRawDataSlice( fs, &reader, width,
4031 image->imageData + y*image->widthStep, dt ));
4032 }
4033
4034 ptr = image;
4035
4036 __END__;
4037
4038 return ptr;
4039 }
4040
4041
4042 /******************************* CvSeq ******************************/
4043
4044 static int
icvIsSeq(const void * ptr)4045 icvIsSeq( const void* ptr )
4046 {
4047 return CV_IS_SEQ(ptr);
4048 }
4049
4050
4051 static void
icvReleaseSeq(void ** ptr)4052 icvReleaseSeq( void** ptr )
4053 {
4054 CV_FUNCNAME( "icvReleaseSeq" );
4055
4056 __BEGIN__;
4057
4058 if( !ptr )
4059 CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
4060
4061 *ptr = 0; // it's impossible now to release seq, so just clear the pointer
4062
4063 __END__;
4064 }
4065
4066
4067 static void*
icvCloneSeq(const void * ptr)4068 icvCloneSeq( const void* ptr )
4069 {
4070 return cvSeqSlice( (CvSeq*)ptr, CV_WHOLE_SEQ,
4071 0 /* use the same storage as for the original sequence */, 1 );
4072 }
4073
4074
4075 static void
icvWriteHeaderData(CvFileStorage * fs,const CvSeq * seq,CvAttrList * attr,int initial_header_size)4076 icvWriteHeaderData( CvFileStorage* fs, const CvSeq* seq,
4077 CvAttrList* attr, int initial_header_size )
4078 {
4079 CV_FUNCNAME( "icvWriteHeaderData" );
4080
4081 __BEGIN__;
4082
4083 char header_dt_buf[128];
4084 const char* header_dt = cvAttrValue( attr, "header_dt" );
4085
4086 if( header_dt )
4087 {
4088 int dt_header_size;
4089 CV_CALL( dt_header_size = icvCalcElemSize( header_dt, initial_header_size ));
4090 if( dt_header_size > seq->header_size )
4091 CV_ERROR( CV_StsUnmatchedSizes,
4092 "The size of header calculated from \"header_dt\" is greater than header_size" );
4093 }
4094 else if( seq->header_size > initial_header_size )
4095 {
4096 if( CV_IS_SEQ(seq) && CV_IS_SEQ_POINT_SET(seq) &&
4097 seq->header_size == sizeof(CvPoint2DSeq) &&
4098 seq->elem_size == sizeof(int)*2 )
4099 {
4100 CvPoint2DSeq* point_seq = (CvPoint2DSeq*)seq;
4101
4102 cvStartWriteStruct( fs, "rect", CV_NODE_MAP + CV_NODE_FLOW );
4103 cvWriteInt( fs, "x", point_seq->rect.x );
4104 cvWriteInt( fs, "y", point_seq->rect.y );
4105 cvWriteInt( fs, "width", point_seq->rect.width );
4106 cvWriteInt( fs, "height", point_seq->rect.height );
4107 cvEndWriteStruct( fs );
4108 cvWriteInt( fs, "color", point_seq->color );
4109 }
4110 else if( CV_IS_SEQ(seq) && CV_IS_SEQ_CHAIN(seq) &&
4111 CV_MAT_TYPE(seq->flags) == CV_8UC1 )
4112 {
4113 CvChain* chain = (CvChain*)seq;
4114
4115 cvStartWriteStruct( fs, "origin", CV_NODE_MAP + CV_NODE_FLOW );
4116 cvWriteInt( fs, "x", chain->origin.x );
4117 cvWriteInt( fs, "y", chain->origin.y );
4118 cvEndWriteStruct( fs );
4119 }
4120 else
4121 {
4122 unsigned extra_size = seq->header_size - initial_header_size;
4123 // a heuristic to provide nice defaults for sequences of int's & float's
4124 if( extra_size % sizeof(int) == 0 )
4125 sprintf( header_dt_buf, "%ui", (unsigned)(extra_size/sizeof(int)) );
4126 else
4127 sprintf( header_dt_buf, "%uu", extra_size );
4128 header_dt = header_dt_buf;
4129 }
4130 }
4131
4132 if( header_dt )
4133 {
4134 cvWriteString( fs, "header_dt", header_dt, 0 );
4135 cvStartWriteStruct( fs, "header_user_data", CV_NODE_SEQ + CV_NODE_FLOW );
4136 cvWriteRawData( fs, (uchar*)seq + sizeof(CvSeq), 1, header_dt );
4137 cvEndWriteStruct( fs );
4138 }
4139
4140 __END__;
4141 }
4142
4143
4144 static char*
icvGetFormat(const CvSeq * seq,const char * dt_key,CvAttrList * attr,int initial_elem_size,char * dt_buf)4145 icvGetFormat( const CvSeq* seq, const char* dt_key, CvAttrList* attr,
4146 int initial_elem_size, char* dt_buf )
4147 {
4148 char* dt = 0;
4149
4150 CV_FUNCNAME( "icvWriteFormat" );
4151
4152 __BEGIN__;
4153
4154 dt = (char*)cvAttrValue( attr, dt_key );
4155
4156 if( dt )
4157 {
4158 int dt_elem_size;
4159 CV_CALL( dt_elem_size = icvCalcElemSize( dt, initial_elem_size ));
4160 if( dt_elem_size != seq->elem_size )
4161 CV_ERROR( CV_StsUnmatchedSizes,
4162 "The size of element calculated from \"dt\" and "
4163 "the elem_size do not match" );
4164 }
4165 else if( CV_MAT_TYPE(seq->flags) != 0 || seq->elem_size == 1 )
4166 {
4167 int align = CV_MAT_DEPTH(seq->flags) == CV_64F ? sizeof(double) : sizeof(size_t);
4168 int full_elem_size = cvAlign(CV_ELEM_SIZE(seq->flags) + initial_elem_size, align);
4169 if( seq->elem_size != full_elem_size )
4170 CV_ERROR( CV_StsUnmatchedSizes,
4171 "Size of sequence element (elem_size) is inconsistent with seq->flags" );
4172 dt = icvEncodeFormat( CV_MAT_TYPE(seq->flags), dt_buf );
4173 }
4174 else if( seq->elem_size > initial_elem_size )
4175 {
4176 unsigned extra_elem_size = seq->elem_size - initial_elem_size;
4177 // a heuristic to provide nice defaults for sequences of int's & float's
4178 if( extra_elem_size % sizeof(int) == 0 )
4179 sprintf( dt_buf, "%ui", (unsigned)(extra_elem_size/sizeof(int)) );
4180 else
4181 sprintf( dt_buf, "%uu", extra_elem_size );
4182 dt = dt_buf;
4183 }
4184
4185 __END__;
4186
4187 return dt;
4188 }
4189
4190
4191 static void
icvWriteSeq(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList attr,int level)4192 icvWriteSeq( CvFileStorage* fs, const char* name,
4193 const void* struct_ptr,
4194 CvAttrList attr, int level )
4195 {
4196 CV_FUNCNAME( "icvWriteSeq" );
4197
4198 __BEGIN__;
4199
4200 const CvSeq* seq = (CvSeq*)struct_ptr;
4201 CvSeqBlock* block;
4202 char buf[128];
4203 char dt_buf[128], *dt;
4204
4205 assert( CV_IS_SEQ( seq ));
4206 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ ));
4207
4208 if( level >= 0 )
4209 cvWriteInt( fs, "level", level );
4210
4211 sprintf( buf, "%08x", seq->flags );
4212 cvWriteString( fs, "flags", buf, 1 );
4213 cvWriteInt( fs, "count", seq->total );
4214 CV_CALL( dt = icvGetFormat( seq, "dt", &attr, 0, dt_buf ));
4215 cvWriteString( fs, "dt", dt, 0 );
4216
4217 CV_CALL( icvWriteHeaderData( fs, seq, &attr, sizeof(CvSeq) ));
4218 cvStartWriteStruct( fs, "data", CV_NODE_SEQ + CV_NODE_FLOW );
4219
4220 for( block = seq->first; block; block = block->next )
4221 {
4222 cvWriteRawData( fs, block->data, block->count, dt );
4223 if( block == seq->first->prev )
4224 break;
4225 }
4226 cvEndWriteStruct( fs );
4227 cvEndWriteStruct( fs );
4228
4229 __END__;
4230 }
4231
4232
4233 static void
icvWriteSeqTree(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList attr)4234 icvWriteSeqTree( CvFileStorage* fs, const char* name,
4235 const void* struct_ptr, CvAttrList attr )
4236 {
4237 CV_FUNCNAME( "icvWriteSeqTree" );
4238
4239 __BEGIN__;
4240
4241 const CvSeq* seq = (CvSeq*)struct_ptr;
4242 const char* recursive_value = cvAttrValue( &attr, "recursive" );
4243 int is_recursive = recursive_value &&
4244 strcmp(recursive_value,"0") != 0 &&
4245 strcmp(recursive_value,"false") != 0 &&
4246 strcmp(recursive_value,"False") != 0 &&
4247 strcmp(recursive_value,"FALSE") != 0;
4248
4249 assert( CV_IS_SEQ( seq ));
4250
4251 if( !is_recursive )
4252 {
4253 CV_CALL( icvWriteSeq( fs, name, seq, attr, -1 ));
4254 }
4255 else
4256 {
4257 CvTreeNodeIterator tree_iterator;
4258
4259 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_SEQ_TREE ));
4260 CV_CALL( cvStartWriteStruct( fs, "sequences", CV_NODE_SEQ ));
4261 cvInitTreeNodeIterator( &tree_iterator, seq, INT_MAX );
4262
4263 for(;;)
4264 {
4265 if( !tree_iterator.node )
4266 break;
4267 CV_CALL( icvWriteSeq( fs, 0, tree_iterator.node, attr, tree_iterator.level ));
4268 cvNextTreeNode( &tree_iterator );
4269 }
4270
4271 cvEndWriteStruct( fs );
4272 cvEndWriteStruct( fs );
4273 }
4274
4275 __END__;
4276 }
4277
4278
4279 static void*
icvReadSeq(CvFileStorage * fs,CvFileNode * node)4280 icvReadSeq( CvFileStorage* fs, CvFileNode* node )
4281 {
4282 void* ptr = 0;
4283 CV_FUNCNAME( "icvReadSeq" );
4284
4285 __BEGIN__;
4286
4287 CvSeq* seq;
4288 CvSeqBlock* block;
4289 CvFileNode *data, *header_node, *rect_node, *origin_node;
4290 CvSeqReader reader;
4291 int total, flags;
4292 int elem_size, header_size = sizeof(CvSeq);
4293 int fmt_pairs[CV_FS_MAX_FMT_PAIRS], i, fmt_pair_count;
4294 int items_per_elem = 0;
4295 const char* flags_str;
4296 const char* header_dt;
4297 const char* dt;
4298 char* endptr = 0;
4299
4300 CV_CALL( flags_str = cvReadStringByName( fs, node, "flags", 0 ));
4301 total = cvReadIntByName( fs, node, "count", -1 );
4302 dt = cvReadStringByName( fs, node, "dt", 0 );
4303
4304 if( !flags_str || total == -1 || !dt )
4305 CV_ERROR( CV_StsError, "Some of essential sequence attributes are absent" );
4306
4307 flags = (int)strtol( flags_str, &endptr, 16 );
4308 if( endptr == flags_str || (flags & CV_MAGIC_MASK) != CV_SEQ_MAGIC_VAL )
4309 CV_ERROR( CV_StsError, "The sequence flags are invalid" );
4310
4311 header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
4312 header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
4313
4314 if( (header_dt != 0) ^ (header_node != 0) )
4315 CV_ERROR( CV_StsError,
4316 "One of \"header_dt\" and \"header_user_data\" is there, while the other is not" );
4317
4318 rect_node = cvGetFileNodeByName( fs, node, "rect" );
4319 origin_node = cvGetFileNodeByName( fs, node, "origin" );
4320
4321 if( (header_node != 0) + (rect_node != 0) + (origin_node != 0) > 1 )
4322 CV_ERROR( CV_StsError, "Only one of \"header_user_data\", \"rect\" and \"origin\" tags may occur" );
4323
4324 if( header_dt )
4325 {
4326 CV_CALL( header_size = icvCalcElemSize( header_dt, header_size ));
4327 }
4328 else if( rect_node )
4329 header_size = sizeof(CvPoint2DSeq);
4330 else if( origin_node )
4331 header_size = sizeof(CvChain);
4332
4333 CV_CALL( elem_size = icvCalcElemSize( dt, 0 ));
4334 CV_CALL( seq = cvCreateSeq( flags, header_size, elem_size, fs->dststorage ));
4335
4336 if( header_node )
4337 {
4338 CV_CALL( cvReadRawData( fs, header_node, (char*)seq + sizeof(CvSeq), header_dt ));
4339 }
4340 else if( rect_node )
4341 {
4342 CvPoint2DSeq* point_seq = (CvPoint2DSeq*)seq;
4343 point_seq->rect.x = cvReadIntByName( fs, rect_node, "x", 0 );
4344 point_seq->rect.y = cvReadIntByName( fs, rect_node, "y", 0 );
4345 point_seq->rect.width = cvReadIntByName( fs, rect_node, "width", 0 );
4346 point_seq->rect.height = cvReadIntByName( fs, rect_node, "height", 0 );
4347 point_seq->color = cvReadIntByName( fs, node, "color", 0 );
4348 }
4349 else if( origin_node )
4350 {
4351 CvChain* chain = (CvChain*)seq;
4352 chain->origin.x = cvReadIntByName( fs, origin_node, "x", 0 );
4353 chain->origin.y = cvReadIntByName( fs, origin_node, "y", 0 );
4354 }
4355
4356 cvSeqPushMulti( seq, 0, total, 0 );
4357 CV_CALL( fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
4358 fmt_pair_count *= 2;
4359 for( i = 0; i < fmt_pair_count; i += 2 )
4360 items_per_elem += fmt_pairs[i];
4361
4362 data = cvGetFileNodeByName( fs, node, "data" );
4363 if( !data )
4364 CV_ERROR( CV_StsError, "The image data is not found in file storage" );
4365
4366 if( icvFileNodeSeqLen( data ) != total*items_per_elem )
4367 CV_ERROR( CV_StsError, "The number of stored elements does not match to \"count\"" );
4368
4369 cvStartReadRawData( fs, data, &reader );
4370 for( block = seq->first; block; block = block->next )
4371 {
4372 int delta = block->count*items_per_elem;
4373 cvReadRawDataSlice( fs, &reader, delta, block->data, dt );
4374 if( block == seq->first->prev )
4375 break;
4376 }
4377
4378 ptr = seq;
4379
4380 __END__;
4381
4382 return ptr;
4383 }
4384
4385
4386 static void*
icvReadSeqTree(CvFileStorage * fs,CvFileNode * node)4387 icvReadSeqTree( CvFileStorage* fs, CvFileNode* node )
4388 {
4389 void* ptr = 0;
4390 CV_FUNCNAME( "icvReadSeqTree" );
4391
4392 __BEGIN__;
4393
4394 CvFileNode *sequences_node = cvGetFileNodeByName( fs, node, "sequences" );
4395 CvSeq* sequences;
4396 CvSeq* root = 0;
4397 CvSeq* parent = 0;
4398 CvSeq* prev_seq = 0;
4399 CvSeqReader reader;
4400 int i, total;
4401 int prev_level = 0;
4402
4403 if( !sequences_node || !CV_NODE_IS_SEQ(sequences_node->tag) )
4404 CV_ERROR( CV_StsParseError,
4405 "opencv-sequence-tree instance should contain a field \"sequences\" that should be a sequence" );
4406
4407 sequences = sequences_node->data.seq;
4408 total = sequences->total;
4409
4410 cvStartReadSeq( sequences, &reader, 0 );
4411 for( i = 0; i < total; i++ )
4412 {
4413 CvFileNode* elem = (CvFileNode*)reader.ptr;
4414 CvSeq* seq;
4415 int level;
4416 CV_CALL( seq = (CvSeq*)cvRead( fs, elem ));
4417 CV_CALL( level = cvReadIntByName( fs, elem, "level", -1 ));
4418 if( level < 0 )
4419 CV_ERROR( CV_StsParseError, "All the sequence tree nodes should contain \"level\" field" );
4420 if( !root )
4421 root = seq;
4422 if( level > prev_level )
4423 {
4424 assert( level == prev_level + 1 );
4425 parent = prev_seq;
4426 prev_seq = 0;
4427 if( parent )
4428 parent->v_next = seq;
4429 }
4430 else if( level < prev_level )
4431 {
4432 for( ; prev_level > level; prev_level-- )
4433 prev_seq = prev_seq->v_prev;
4434 parent = prev_seq->v_prev;
4435 }
4436 seq->h_prev = prev_seq;
4437 if( prev_seq )
4438 prev_seq->h_next = seq;
4439 seq->v_prev = parent;
4440 prev_seq = seq;
4441 prev_level = level;
4442 CV_NEXT_SEQ_ELEM( sequences->elem_size, reader );
4443 }
4444
4445 ptr = root;
4446
4447 __END__;
4448
4449 return ptr;
4450 }
4451
4452 /******************************* CvGraph ******************************/
4453
4454 static int
icvIsGraph(const void * ptr)4455 icvIsGraph( const void* ptr )
4456 {
4457 return CV_IS_GRAPH(ptr);
4458 }
4459
4460
4461 static void
icvReleaseGraph(void ** ptr)4462 icvReleaseGraph( void** ptr )
4463 {
4464 CV_FUNCNAME( "icvReleaseGraph" );
4465
4466 __BEGIN__;
4467
4468 if( !ptr )
4469 CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
4470
4471 *ptr = 0; // it's impossible now to release graph, so just clear the pointer
4472
4473 __END__;
4474 }
4475
4476
4477 static void*
icvCloneGraph(const void * ptr)4478 icvCloneGraph( const void* ptr )
4479 {
4480 return cvCloneGraph( (const CvGraph*)ptr, 0 );
4481 }
4482
4483
4484 static void
icvWriteGraph(CvFileStorage * fs,const char * name,const void * struct_ptr,CvAttrList attr)4485 icvWriteGraph( CvFileStorage* fs, const char* name,
4486 const void* struct_ptr, CvAttrList attr )
4487 {
4488 int* flag_buf = 0;
4489 char* write_buf = 0;
4490 CV_FUNCNAME( "icvWriteGraph" );
4491
4492 __BEGIN__;
4493
4494 const CvGraph* graph = (const CvGraph*)struct_ptr;
4495 CvSeqReader reader;
4496 char buf[128];
4497 int i, k, vtx_count, edge_count;
4498 char vtx_dt_buf[128], *vtx_dt;
4499 char edge_dt_buf[128], *edge_dt;
4500 int write_buf_size;
4501
4502 assert( CV_IS_GRAPH(graph) );
4503 vtx_count = cvGraphGetVtxCount( graph );
4504 edge_count = cvGraphGetEdgeCount( graph );
4505 CV_CALL( flag_buf = (int*)cvAlloc( vtx_count*sizeof(flag_buf[0])));
4506
4507 // count vertices
4508 cvStartReadSeq( (CvSeq*)graph, &reader );
4509 for( i = 0, k = 0; i < graph->total; i++ )
4510 {
4511 if( CV_IS_SET_ELEM( reader.ptr ))
4512 {
4513 CvGraphVtx* vtx = (CvGraphVtx*)reader.ptr;
4514 flag_buf[k] = vtx->flags;
4515 vtx->flags = k++;
4516 }
4517 CV_NEXT_SEQ_ELEM( graph->elem_size, reader );
4518 }
4519
4520 // write header
4521 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_GRAPH ));
4522
4523 sprintf( buf, "%08x", graph->flags );
4524 cvWriteString( fs, "flags", buf, 1 );
4525
4526 cvWriteInt( fs, "vertex_count", vtx_count );
4527 CV_CALL( vtx_dt = icvGetFormat( (CvSeq*)graph, "vertex_dt",
4528 &attr, sizeof(CvGraphVtx), vtx_dt_buf ));
4529 if( vtx_dt )
4530 cvWriteString( fs, "vertex_dt", vtx_dt, 0 );
4531
4532 cvWriteInt( fs, "edge_count", edge_count );
4533 CV_CALL( edge_dt = icvGetFormat( (CvSeq*)graph->edges, "edge_dt",
4534 &attr, sizeof(CvGraphEdge), buf ));
4535 sprintf( edge_dt_buf, "2if%s", edge_dt ? edge_dt : "" );
4536 edge_dt = edge_dt_buf;
4537 cvWriteString( fs, "edge_dt", edge_dt, 0 );
4538
4539 CV_CALL( icvWriteHeaderData( fs, (CvSeq*)graph, &attr, sizeof(CvGraph) ));
4540
4541 write_buf_size = MAX( 3*graph->elem_size, 1 << 16 );
4542 write_buf_size = MAX( 3*graph->edges->elem_size, write_buf_size );
4543 CV_CALL( write_buf = (char*)cvAlloc( write_buf_size ));
4544
4545 // as vertices and edges are written in similar way,
4546 // do it as a parametrized 2-iteration loop
4547 for( k = 0; k < 2; k++ )
4548 {
4549 const char* dt = k == 0 ? vtx_dt : edge_dt;
4550 if( dt )
4551 {
4552 CvSet* data = k == 0 ? (CvSet*)graph : graph->edges;
4553 int elem_size = data->elem_size;
4554 int write_elem_size = icvCalcElemSize( dt, 0 );
4555 char* src_ptr = write_buf;
4556 int write_max = write_buf_size / write_elem_size, write_count = 0;
4557
4558 // alignment of user part of the edge data following 2if
4559 int edge_user_align = sizeof(float);
4560
4561 if( k == 1 )
4562 {
4563 int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
4564 fmt_pair_count = icvDecodeFormat( dt, fmt_pairs, CV_FS_MAX_FMT_PAIRS );
4565 if( fmt_pair_count > 2 || CV_ELEM_SIZE(fmt_pairs[2*2+1]) >= (int)sizeof(double))
4566 edge_user_align = sizeof(double);
4567 }
4568
4569 cvStartWriteStruct( fs, k == 0 ? "vertices" : "edges",
4570 CV_NODE_SEQ + CV_NODE_FLOW );
4571 cvStartReadSeq( (CvSeq*)data, &reader );
4572 for( i = 0; i < data->total; i++ )
4573 {
4574 if( CV_IS_SET_ELEM( reader.ptr ))
4575 {
4576 if( k == 0 ) // vertices
4577 memcpy( src_ptr, reader.ptr + sizeof(CvGraphVtx), write_elem_size );
4578 else
4579 {
4580 CvGraphEdge* edge = (CvGraphEdge*)reader.ptr;
4581 src_ptr = (char*)cvAlignPtr( src_ptr, sizeof(int) );
4582 ((int*)src_ptr)[0] = edge->vtx[0]->flags;
4583 ((int*)src_ptr)[1] = edge->vtx[1]->flags;
4584 *(float*)(src_ptr + sizeof(int)*2) = edge->weight;
4585 if( elem_size > (int)sizeof(CvGraphEdge) )
4586 {
4587 char* src_ptr2 = (char*)cvAlignPtr( src_ptr + 2*sizeof(int)
4588 + sizeof(float), edge_user_align );
4589 memcpy( src_ptr2, edge + 1, elem_size - sizeof(CvGraphEdge) );
4590 }
4591 }
4592 src_ptr += write_elem_size;
4593 if( ++write_count >= write_max )
4594 {
4595 cvWriteRawData( fs, write_buf, write_count, dt );
4596 write_count = 0;
4597 src_ptr = write_buf;
4598 }
4599 }
4600 CV_NEXT_SEQ_ELEM( data->elem_size, reader );
4601 }
4602
4603 if( write_count > 0 )
4604 cvWriteRawData( fs, write_buf, write_count, dt );
4605 cvEndWriteStruct( fs );
4606 }
4607 }
4608
4609 cvEndWriteStruct( fs );
4610
4611 // final stage. restore the graph flags
4612 cvStartReadSeq( (CvSeq*)graph, &reader );
4613 vtx_count = 0;
4614 for( i = 0; i < graph->total; i++ )
4615 {
4616 if( CV_IS_SET_ELEM( reader.ptr ))
4617 ((CvGraphVtx*)reader.ptr)->flags = flag_buf[vtx_count++];
4618 CV_NEXT_SEQ_ELEM( graph->elem_size, reader );
4619 }
4620
4621 __END__;
4622
4623 cvFree( &write_buf );
4624 cvFree( &flag_buf );
4625 }
4626
4627
4628 static void*
icvReadGraph(CvFileStorage * fs,CvFileNode * node)4629 icvReadGraph( CvFileStorage* fs, CvFileNode* node )
4630 {
4631 void* ptr = 0;
4632 char* read_buf = 0;
4633 CvGraphVtx** vtx_buf = 0;
4634 CV_FUNCNAME( "icvReadGraph" );
4635
4636 __BEGIN__;
4637
4638 CvGraph* graph;
4639 CvFileNode *header_node, *vtx_node, *edge_node;
4640 int flags, vtx_count, edge_count;
4641 int vtx_size = sizeof(CvGraphVtx), edge_size, header_size = sizeof(CvGraph);
4642 int src_vtx_size = 0, src_edge_size;
4643 int fmt_pairs[CV_FS_MAX_FMT_PAIRS], fmt_pair_count;
4644 int vtx_items_per_elem = 0, edge_items_per_elem = 0;
4645 int edge_user_align = sizeof(float);
4646 int read_buf_size;
4647 int i, k;
4648 const char* flags_str;
4649 const char* header_dt;
4650 const char* vtx_dt;
4651 const char* edge_dt;
4652 char* endptr = 0;
4653
4654 CV_CALL( flags_str = cvReadStringByName( fs, node, "flags", 0 ));
4655 vtx_dt = cvReadStringByName( fs, node, "vertex_dt", 0 );
4656 edge_dt = cvReadStringByName( fs, node, "edge_dt", 0 );
4657 vtx_count = cvReadIntByName( fs, node, "vertex_count", -1 );
4658 edge_count = cvReadIntByName( fs, node, "edge_count", -1 );
4659
4660 if( !flags_str || vtx_count == -1 || edge_count == -1 || !edge_dt )
4661 CV_ERROR( CV_StsError, "Some of essential sequence attributes are absent" );
4662
4663 flags = (int)strtol( flags_str, &endptr, 16 );
4664 if( endptr == flags_str ||
4665 (flags & (CV_SEQ_KIND_MASK|CV_MAGIC_MASK)) != (CV_GRAPH|CV_SET_MAGIC_VAL))
4666 CV_ERROR( CV_StsError, "Invalid graph signature" );
4667
4668 header_dt = cvReadStringByName( fs, node, "header_dt", 0 );
4669 header_node = cvGetFileNodeByName( fs, node, "header_user_data" );
4670
4671 if( (header_dt != 0) ^ (header_node != 0) )
4672 CV_ERROR( CV_StsError,
4673 "One of \"header_dt\" and \"header_user_data\" is there, while the other is not" );
4674
4675 if( header_dt )
4676 CV_CALL( header_size = icvCalcElemSize( header_dt, header_size ));
4677
4678 if( vtx_dt > 0 )
4679 {
4680 CV_CALL( src_vtx_size = icvCalcElemSize( vtx_dt, 0 ));
4681 CV_CALL( vtx_size = icvCalcElemSize( vtx_dt, vtx_size ));
4682 CV_CALL( fmt_pair_count = icvDecodeFormat( edge_dt,
4683 fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
4684 fmt_pair_count *= 2;
4685 for( i = 0; i < fmt_pair_count; i += 2 )
4686 vtx_items_per_elem += fmt_pairs[i];
4687 }
4688
4689 {
4690 char dst_edge_dt_buf[128];
4691 const char* dst_edge_dt = 0;
4692
4693 CV_CALL( fmt_pair_count = icvDecodeFormat( edge_dt,
4694 fmt_pairs, CV_FS_MAX_FMT_PAIRS ));
4695 if( fmt_pair_count < 2 ||
4696 fmt_pairs[0] != 2 || fmt_pairs[1] != CV_32S ||
4697 fmt_pairs[2] < 1 || fmt_pairs[3] != CV_32F )
4698 CV_ERROR( CV_StsBadArg,
4699 "Graph edges should start with 2 integers and a float" );
4700
4701 // alignment of user part of the edge data following 2if
4702 if( fmt_pair_count > 2 && CV_ELEM_SIZE(fmt_pairs[5]) >= (int)sizeof(double))
4703 edge_user_align = sizeof(double);
4704
4705 fmt_pair_count *= 2;
4706 for( i = 0; i < fmt_pair_count; i += 2 )
4707 edge_items_per_elem += fmt_pairs[i];
4708
4709 if( edge_dt[2] == 'f' || (edge_dt[2] == '1' && edge_dt[3] == 'f') )
4710 dst_edge_dt = edge_dt + 3 + isdigit(edge_dt[2]);
4711 else
4712 {
4713 int val = (int)strtol( edge_dt + 2, &endptr, 10 );
4714 sprintf( dst_edge_dt_buf, "%df%s", val-1, endptr );
4715 dst_edge_dt = dst_edge_dt_buf;
4716 }
4717
4718 CV_CALL( edge_size = icvCalcElemSize( dst_edge_dt, sizeof(CvGraphEdge) ));
4719 CV_CALL( src_edge_size = icvCalcElemSize( edge_dt, 0 ));
4720 }
4721
4722 CV_CALL( graph = cvCreateGraph( flags, header_size, vtx_size, edge_size, fs->dststorage ));
4723
4724 if( header_node )
4725 CV_CALL( cvReadRawData( fs, header_node, (char*)graph + sizeof(CvGraph), header_dt ));
4726
4727 read_buf_size = MAX( src_vtx_size*3, 1 << 16 );
4728 read_buf_size = MAX( src_edge_size*3, read_buf_size );
4729 CV_CALL( read_buf = (char*)cvAlloc( read_buf_size ));
4730 CV_CALL( vtx_buf = (CvGraphVtx**)cvAlloc( vtx_count * sizeof(vtx_buf[0]) ));
4731
4732 vtx_node = cvGetFileNodeByName( fs, node, "vertices" );
4733 edge_node = cvGetFileNodeByName( fs, node, "edges" );
4734 if( !edge_node )
4735 CV_ERROR( CV_StsBadArg, "No edges data" );
4736 if( vtx_dt && !vtx_node )
4737 CV_ERROR( CV_StsBadArg, "No vertices data" );
4738
4739 // as vertices and edges are read in similar way,
4740 // do it as a parametrized 2-iteration loop
4741 for( k = 0; k < 2; k++ )
4742 {
4743 const char* dt = k == 0 ? vtx_dt : edge_dt;
4744 int elem_size = k == 0 ? vtx_size : edge_size;
4745 int src_elem_size = k == 0 ? src_vtx_size : src_edge_size;
4746 int items_per_elem = k == 0 ? vtx_items_per_elem : edge_items_per_elem;
4747 int elem_count = k == 0 ? vtx_count : edge_count;
4748 char* dst_ptr = read_buf;
4749 int read_max = read_buf_size /MAX(src_elem_size, 1), read_count = 0;
4750 CvSeqReader reader;
4751 cvStartReadRawData( fs, k == 0 ? vtx_node : edge_node, &reader );
4752
4753 for( i = 0; i < elem_count; i++ )
4754 {
4755 if( read_count == 0 && dt )
4756 {
4757 int count = MIN( elem_count - i, read_max )*items_per_elem;
4758 cvReadRawDataSlice( fs, &reader, count, read_buf, dt );
4759 read_count = count;
4760 dst_ptr = read_buf;
4761 }
4762
4763 if( k == 0 )
4764 {
4765 CvGraphVtx* vtx;
4766 cvGraphAddVtx( graph, 0, &vtx );
4767 vtx_buf[i] = vtx;
4768 if( dt )
4769 memcpy( vtx + 1, dst_ptr, src_elem_size );
4770 }
4771 else
4772 {
4773 CvGraphEdge* edge = 0;
4774 int vtx1 = ((int*)dst_ptr)[0];
4775 int vtx2 = ((int*)dst_ptr)[1];
4776 int result;
4777
4778 if( (unsigned)vtx1 >= (unsigned)vtx_count ||
4779 (unsigned)vtx2 >= (unsigned)vtx_count )
4780 CV_ERROR( CV_StsOutOfRange,
4781 "Some of stored vertex indices are out of range" );
4782
4783 CV_CALL( result = cvGraphAddEdgeByPtr( graph,
4784 vtx_buf[vtx1], vtx_buf[vtx2], 0, &edge ));
4785
4786 if( result == 0 )
4787 CV_ERROR( CV_StsBadArg, "Duplicated edge has occured" );
4788
4789 edge->weight = *(float*)(dst_ptr + sizeof(int)*2);
4790 if( elem_size > (int)sizeof(CvGraphEdge) )
4791 {
4792 char* dst_ptr2 = (char*)cvAlignPtr( dst_ptr + sizeof(int)*2 +
4793 sizeof(float), edge_user_align );
4794 memcpy( edge + 1, dst_ptr2, elem_size - sizeof(CvGraphEdge) );
4795 }
4796 }
4797
4798 dst_ptr += src_elem_size;
4799 read_count--;
4800 }
4801 }
4802
4803 ptr = graph;
4804
4805 __END__;
4806
4807 cvFree( &read_buf );
4808 cvFree( &vtx_buf );
4809
4810 return ptr;
4811 }
4812
4813 /****************************************************************************************\
4814 * RTTI Functions *
4815 \****************************************************************************************/
4816
4817 CvTypeInfo *CvType::first = 0, *CvType::last = 0;
4818
CvType(const char * type_name,CvIsInstanceFunc is_instance,CvReleaseFunc release,CvReadFunc read,CvWriteFunc write,CvCloneFunc clone)4819 CvType::CvType( const char* type_name,
4820 CvIsInstanceFunc is_instance, CvReleaseFunc release,
4821 CvReadFunc read, CvWriteFunc write, CvCloneFunc clone )
4822 {
4823 CvTypeInfo _info;
4824 _info.flags = 0;
4825 _info.header_size = sizeof(_info);
4826 _info.type_name = type_name;
4827 _info.prev = _info.next = 0;
4828 _info.is_instance = is_instance;
4829 _info.release = release;
4830 _info.clone = clone;
4831 _info.read = read;
4832 _info.write = write;
4833
4834 cvRegisterType( &_info );
4835 info = first;
4836 }
4837
4838
~CvType()4839 CvType::~CvType()
4840 {
4841 cvUnregisterType( info->type_name );
4842 }
4843
4844
4845 CvType seq_type( CV_TYPE_NAME_SEQ, icvIsSeq, icvReleaseSeq, icvReadSeq,
4846 icvWriteSeqTree /* this is the entry point for
4847 writing a single sequence too */, icvCloneSeq );
4848
4849 CvType seq_tree_type( CV_TYPE_NAME_SEQ_TREE, icvIsSeq, icvReleaseSeq,
4850 icvReadSeqTree, icvWriteSeqTree, icvCloneSeq );
4851
4852 CvType seq_graph_type( CV_TYPE_NAME_GRAPH, icvIsGraph, icvReleaseGraph,
4853 icvReadGraph, icvWriteGraph, icvCloneGraph );
4854
4855 CvType sparse_mat_type( CV_TYPE_NAME_SPARSE_MAT, icvIsSparseMat,
4856 (CvReleaseFunc)cvReleaseSparseMat, icvReadSparseMat,
4857 icvWriteSparseMat, (CvCloneFunc)cvCloneSparseMat );
4858
4859 CvType image_type( CV_TYPE_NAME_IMAGE, icvIsImage, (CvReleaseFunc)cvReleaseImage,
4860 icvReadImage, icvWriteImage, (CvCloneFunc)cvCloneImage );
4861
4862 CvType mat_type( CV_TYPE_NAME_MAT, icvIsMat, (CvReleaseFunc)cvReleaseMat,
4863 icvReadMat, icvWriteMat, (CvCloneFunc)cvCloneMat );
4864
4865 CvType matnd_type( CV_TYPE_NAME_MATND, icvIsMatND, (CvReleaseFunc)cvReleaseMatND,
4866 icvReadMatND, icvWriteMatND, (CvCloneFunc)cvCloneMatND );
4867
4868 CV_IMPL void
cvRegisterType(const CvTypeInfo * _info)4869 cvRegisterType( const CvTypeInfo* _info )
4870 {
4871 CV_FUNCNAME("cvRegisterType" );
4872
4873 __BEGIN__;
4874
4875 CvTypeInfo* info = 0;
4876 int i, len;
4877 char c;
4878
4879 //if( !CvType::first )
4880 // icvCreateStandardTypes();
4881
4882 if( !_info || _info->header_size != sizeof(CvTypeInfo) )
4883 CV_ERROR( CV_StsBadSize, "Invalid type info" );
4884
4885 if( !_info->is_instance || !_info->release ||
4886 !_info->read || !_info->write )
4887 CV_ERROR( CV_StsNullPtr,
4888 "Some of required function pointers "
4889 "(is_instance, release, read or write) are NULL");
4890
4891 c = _info->type_name[0];
4892 if( !isalpha(c) && c != '_' )
4893 CV_ERROR( CV_StsBadArg, "Type name should start with a letter or _" );
4894
4895 len = (int)strlen(_info->type_name);
4896
4897 for( i = 0; i < len; i++ )
4898 {
4899 c = _info->type_name[i];
4900 if( !isalnum(c) && c != '-' && c != '_' )
4901 CV_ERROR( CV_StsBadArg,
4902 "Type name should contain only letters, digits, - and _" );
4903 }
4904
4905 CV_CALL( info = (CvTypeInfo*)cvAlloc( sizeof(*info) + len + 1 ));
4906
4907 *info = *_info;
4908 info->type_name = (char*)(info + 1);
4909 memcpy( (char*)info->type_name, _info->type_name, len + 1 );
4910
4911 info->flags = 0;
4912 info->next = CvType::first;
4913 info->prev = 0;
4914 if( CvType::first )
4915 CvType::first->prev = info;
4916 else
4917 CvType::last = info;
4918 CvType::first = info;
4919
4920 __END__;
4921 }
4922
4923
4924 CV_IMPL void
cvUnregisterType(const char * type_name)4925 cvUnregisterType( const char* type_name )
4926 {
4927 CV_FUNCNAME("cvUnregisterType" );
4928
4929 __BEGIN__;
4930
4931 CvTypeInfo* info;
4932
4933 CV_CALL( info = cvFindType( type_name ));
4934 if( info )
4935 {
4936 if( info->prev )
4937 info->prev->next = info->next;
4938 else
4939 CvType::first = info->next;
4940
4941 if( info->next )
4942 info->next->prev = info->prev;
4943 else
4944 CvType::last = info->prev;
4945
4946 if( !CvType::first || !CvType::last )
4947 CvType::first = CvType::last = 0;
4948
4949 cvFree( &info );
4950 }
4951
4952 __END__;
4953 }
4954
4955
4956 CV_IMPL CvTypeInfo*
cvFirstType(void)4957 cvFirstType( void )
4958 {
4959 return CvType::first;
4960 }
4961
4962
4963 CV_IMPL CvTypeInfo*
cvFindType(const char * type_name)4964 cvFindType( const char* type_name )
4965 {
4966 CvTypeInfo* info = 0;
4967
4968 for( info = CvType::first; info != 0; info = info->next )
4969 if( strcmp( info->type_name, type_name ) == 0 )
4970 break;
4971
4972 return info;
4973 }
4974
4975
4976 CV_IMPL CvTypeInfo*
cvTypeOf(const void * struct_ptr)4977 cvTypeOf( const void* struct_ptr )
4978 {
4979 CvTypeInfo* info = 0;
4980
4981 for( info = CvType::first; info != 0; info = info->next )
4982 if( info->is_instance( struct_ptr ))
4983 break;
4984
4985 return info;
4986 }
4987
4988
4989 /* universal functions */
4990 CV_IMPL void
cvRelease(void ** struct_ptr)4991 cvRelease( void** struct_ptr )
4992 {
4993 CV_FUNCNAME("cvRelease" );
4994
4995 __BEGIN__;
4996
4997 CvTypeInfo* info;
4998
4999 if( !struct_ptr )
5000 CV_ERROR( CV_StsNullPtr, "NULL double pointer" );
5001
5002 if( *struct_ptr )
5003 {
5004 CV_CALL( info = cvTypeOf( *struct_ptr ));
5005 if( !info )
5006 CV_ERROR( CV_StsError, "Unknown object type" );
5007 if( !info->release )
5008 CV_ERROR( CV_StsError, "release function pointer is NULL" );
5009
5010 CV_CALL( info->release( struct_ptr ));
5011 *struct_ptr = 0;
5012 }
5013
5014 __END__;
5015 }
5016
5017
cvClone(const void * struct_ptr)5018 void* cvClone( const void* struct_ptr )
5019 {
5020 void* struct_copy = 0;
5021
5022 CV_FUNCNAME("cvClone" );
5023
5024 __BEGIN__;
5025
5026 CvTypeInfo* info;
5027
5028 if( !struct_ptr )
5029 CV_ERROR( CV_StsNullPtr, "NULL structure pointer" );
5030
5031 CV_CALL( info = cvTypeOf( struct_ptr ));
5032 if( !info )
5033 CV_ERROR( CV_StsError, "Unknown object type" );
5034 if( !info->clone )
5035 CV_ERROR( CV_StsError, "clone function pointer is NULL" );
5036
5037 CV_CALL( struct_copy = info->clone( struct_ptr ));
5038
5039 __END__;
5040
5041 return struct_copy;
5042 }
5043
5044
5045 /* reads matrix, image, sequence, graph etc. */
5046 CV_IMPL void*
cvRead(CvFileStorage * fs,CvFileNode * node,CvAttrList * list)5047 cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* list )
5048 {
5049 void* obj = 0;
5050
5051 CV_FUNCNAME( "cvRead" );
5052
5053 __BEGIN__;
5054
5055 CV_CHECK_FILE_STORAGE( fs );
5056
5057 if( !node )
5058 EXIT;
5059
5060 if( !CV_NODE_IS_USER(node->tag) || !node->info )
5061 CV_ERROR( CV_StsError, "The node does not represent a user object (unknown type?)" );
5062
5063 CV_CALL( obj = node->info->read( fs, node ));
5064
5065 __END__;
5066
5067 if( list )
5068 *list = cvAttrList(0,0);
5069
5070 return obj;
5071 }
5072
5073
5074 /* writes matrix, image, sequence, graph etc. */
5075 CV_IMPL void
cvWrite(CvFileStorage * fs,const char * name,const void * ptr,CvAttrList attributes)5076 cvWrite( CvFileStorage* fs, const char* name,
5077 const void* ptr, CvAttrList attributes )
5078 {
5079 CV_FUNCNAME( "cvWrite" );
5080
5081 __BEGIN__;
5082
5083 CvTypeInfo* info;
5084
5085 CV_CHECK_OUTPUT_FILE_STORAGE( fs );
5086
5087 if( !ptr )
5088 CV_ERROR( CV_StsNullPtr, "Null pointer to the written object" );
5089
5090 CV_CALL( info = cvTypeOf( ptr ));
5091 if( !info )
5092 CV_ERROR( CV_StsBadArg, "Unknown object" );
5093
5094 if( !info->write )
5095 CV_ERROR( CV_StsBadArg, "The object does not have write function" );
5096
5097 CV_CALL( info->write( fs, name, ptr, attributes ));
5098
5099 __END__;
5100 }
5101
5102
5103 /* simple API for reading/writing data */
5104 CV_IMPL void
cvSave(const char * filename,const void * struct_ptr,const char * _name,const char * comment,CvAttrList attributes)5105 cvSave( const char* filename, const void* struct_ptr,
5106 const char* _name, const char* comment, CvAttrList attributes )
5107 {
5108 CvFileStorage* fs = 0;
5109
5110 CV_FUNCNAME( "cvSave" );
5111
5112 __BEGIN__;
5113
5114 char name_buf[CV_FS_MAX_LEN + 256];
5115 char* name = (char*)_name;
5116
5117 if( !struct_ptr )
5118 CV_ERROR( CV_StsNullPtr, "NULL object pointer" );
5119
5120 CV_CALL( fs = cvOpenFileStorage( filename, 0, CV_STORAGE_WRITE ));
5121 if( !fs )
5122 CV_ERROR( CV_StsError, "Could not open the file storage. Check the path and permissions" );
5123
5124 if( !name )
5125 {
5126 static const char* stubname = "unnamed";
5127 const char* ptr2 = filename + strlen( filename );
5128 const char* ptr = ptr2 - 1;
5129
5130 while( ptr >= filename && *ptr != '\\' && *ptr != '/' && *ptr != ':' )
5131 {
5132 if( *ptr == '.' && !*ptr2 )
5133 ptr2 = ptr;
5134 ptr--;
5135 }
5136 ptr++;
5137 if( ptr == ptr2 )
5138 CV_ERROR( CV_StsBadArg, "Invalid filename" );
5139
5140 name=name_buf;
5141
5142 // name must start with letter or '_'
5143 if( !isalpha(*ptr) && *ptr!= '_' ){
5144 *name++ = '_';
5145 }
5146
5147 while( ptr < ptr2 )
5148 {
5149 char c = *ptr++;
5150 if( !isalnum(c) && c != '-' && c != '_' )
5151 c = '_';
5152 *name++ = c;
5153 }
5154 *name = '\0';
5155 name = name_buf;
5156 if( strcmp( name, "_" ) == 0 )
5157 strcpy( name, stubname );
5158 }
5159
5160 if( comment )
5161 CV_CALL( cvWriteComment( fs, comment, 0 ));
5162 CV_CALL( cvWrite( fs, name, struct_ptr, attributes ));
5163
5164 __END__;
5165
5166 cvReleaseFileStorage( &fs );
5167 }
5168
5169
5170 CV_IMPL void*
cvLoad(const char * filename,CvMemStorage * memstorage,const char * name,const char ** _real_name)5171 cvLoad( const char* filename, CvMemStorage* memstorage,
5172 const char* name, const char** _real_name )
5173 {
5174 void* ptr = 0;
5175 const char* real_name = 0;
5176 CvFileStorage* fs = 0;
5177
5178 CV_FUNCNAME( "cvLoad" );
5179
5180 __BEGIN__;
5181
5182 CvFileNode* node = 0;
5183 CV_CALL( fs = cvOpenFileStorage( filename, memstorage, CV_STORAGE_READ ));
5184
5185 if( !fs )
5186 EXIT;
5187
5188 if( name )
5189 {
5190 CV_CALL( node = cvGetFileNodeByName( fs, 0, name ));
5191 }
5192 else
5193 {
5194 int i, k;
5195 for( k = 0; k < fs->roots->total; k++ )
5196 {
5197 CvSeq* seq;
5198 CvSeqReader reader;
5199
5200 node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
5201 if( !CV_NODE_IS_MAP( node->tag ))
5202 EXIT;
5203 seq = node->data.seq;
5204 node = 0;
5205
5206 cvStartReadSeq( seq, &reader, 0 );
5207
5208 // find the first element in the map
5209 for( i = 0; i < seq->total; i++ )
5210 {
5211 if( CV_IS_SET_ELEM( reader.ptr ))
5212 {
5213 node = (CvFileNode*)reader.ptr;
5214 goto stop_search;
5215 }
5216 CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
5217 }
5218 }
5219
5220 stop_search:
5221 ;
5222 }
5223
5224 if( !node )
5225 CV_ERROR( CV_StsObjectNotFound, "Could not find the/an object in file storage" );
5226
5227 real_name = cvGetFileNodeName( node );
5228 CV_CALL( ptr = cvRead( fs, node, 0 ));
5229
5230 // sanity check
5231 if( !memstorage && (CV_IS_SEQ( ptr ) || CV_IS_SET( ptr )) )
5232 CV_ERROR( CV_StsNullPtr,
5233 "NULL memory storage is passed - the loaded dynamic structure can not be stored" );
5234
5235 __END__;
5236
5237 cvReleaseFileStorage( &fs );
5238 if( cvGetErrStatus() < 0 )
5239 {
5240 cvRelease( (void**)&ptr );
5241 real_name = 0;
5242 }
5243
5244 if( _real_name )
5245 *_real_name = real_name;
5246
5247 return ptr;
5248 }
5249
5250 /* End of file. */
5251