void CvANN_MLP::read( CvFileStorage* fs, CvFileNode* node )
{
CvMat* _layer_sizes = 0;
CV_FUNCNAME( "CvANN_MLP::read" );
__BEGIN__;
CvFileNode* w;
CvSeqReader reader;
int i, l_count;
_layer_sizes = (CvMat*)cvReadByName( fs, node, "layer_sizes" );
CV_CALL( create( _layer_sizes, SIGMOID_SYM, 0, 0 ));
l_count = layer_sizes->cols;
CV_CALL( read_params( fs, node ));
w = cvGetFileNodeByName( fs, node, "input_scale" );
if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
w->data.seq->total != layer_sizes->data.i[0]*2 )
CV_ERROR( CV_StsParseError, "input_scale tag is not found or is invalid" );
CV_CALL( cvReadRawData( fs, w, weights[0], "d" ));
w = cvGetFileNodeByName( fs, node, "output_scale" );
if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
w->data.seq->total != layer_sizes->data.i[l_count-1]*2 )
CV_ERROR( CV_StsParseError, "output_scale tag is not found or is invalid" );
CV_CALL( cvReadRawData( fs, w, weights[l_count], "d" ));
w = cvGetFileNodeByName( fs, node, "inv_output_scale" );
if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
w->data.seq->total != layer_sizes->data.i[l_count-1]*2 )
CV_ERROR( CV_StsParseError, "inv_output_scale tag is not found or is invalid" );
CV_CALL( cvReadRawData( fs, w, weights[l_count+1], "d" ));
w = cvGetFileNodeByName( fs, node, "weights" );
if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
w->data.seq->total != l_count - 1 )
CV_ERROR( CV_StsParseError, "weights tag is not found or is invalid" );
cvStartReadSeq( w->data.seq, &reader );
for( i = 1; i < l_count; i++ )
{
w = (CvFileNode*)reader.ptr;
CV_CALL( cvReadRawData( fs, w, weights[i], "d" ));
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
}
__END__;
}
CV_IMPL void
cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader )
{
int node_type;
CV_CHECK_FILE_STORAGE( fs );
if( !src || !reader )
CV_Error( CV_StsNullPtr, "Null pointer to source file node or reader" );
node_type = CV_NODE_TYPE(src->tag);
if( node_type == CV_NODE_INT || node_type == CV_NODE_REAL )
{
// emulate reading from 1-element sequence
reader->ptr = (schar*)src;
reader->block_max = reader->ptr + sizeof(*src)*2;
reader->block_min = reader->ptr;
reader->seq = 0;
}
else if( node_type == CV_NODE_SEQ )
{
cvStartReadSeq( src->data.seq, reader, 0 );
}
else if( node_type == CV_NODE_NONE )
{
memset( reader, 0, sizeof(*reader) );
}
else
CV_Error( CV_StsBadArg, "The file node should be a numerical scalar or a sequence" );
}
CV_IMPL CvFileNode*
cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* _map_node, const char* str )
{
CvFileNode* value = 0;
int i, len, tab_size;
unsigned hashval = 0;
int k = 0, attempts = 1;
if( !fs )
return 0;
CV_CHECK_FILE_STORAGE(fs);
if( !str )
CV_Error( CV_StsNullPtr, "Null element name" );
for( i = 0; str[i] != '\0'; i++ )
hashval = hashval*CV_HASHVAL_SCALE + (unsigned char)str[i];
hashval &= INT_MAX;
len = i;
if( !_map_node )
{
if( !fs->roots )
return 0;
attempts = fs->roots->total;
}
for( k = 0; k < attempts; k++ )
{
CvFileNodeHash* map;
const CvFileNode* map_node = _map_node;
CvFileMapNode* another;
if( !map_node )
map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
if( !CV_NODE_IS_MAP(map_node->tag) )
{
if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
CV_Error( CV_StsError, "The node is neither a map nor an empty collection" );
return 0;
}
map = map_node->data.map;
tab_size = map->tab_size;
if( (tab_size & (tab_size - 1)) == 0 )
i = (int)(hashval & (tab_size - 1));
else
i = (int)(hashval % tab_size);
for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
{
const CvStringHashNode* key = another->key;
if( key->hashval == hashval &&
key->str.len == len &&
memcmp( key->str.ptr, str, len ) == 0 )
{
value = &another->value;
return value;
}
}
}
return value;
}
CV_IMPL CvFileNode*
cvGetFileNode( CvFileStorage* fs, CvFileNode* _map_node,
const CvStringHashNode* key,
int create_missing )
{
CvFileNode* value = 0;
int k = 0, attempts = 1;
if( !fs )
return 0;
CV_CHECK_FILE_STORAGE(fs);
if( !key )
CV_Error( CV_StsNullPtr, "Null key element" );
if( _map_node )
{
if( !fs->roots )
return 0;
attempts = fs->roots->total;
}
for( k = 0; k < attempts; k++ )
{
int i, tab_size;
CvFileNode* map_node = _map_node;
CvFileMapNode* another;
CvFileNodeHash* map;
if( !map_node )
map_node = (CvFileNode*)cvGetSeqElem( fs->roots, k );
CV_Assert(map_node != NULL);
if( !CV_NODE_IS_MAP(map_node->tag) )
{
if( (!CV_NODE_IS_SEQ(map_node->tag) || map_node->data.seq->total != 0) &&
CV_NODE_TYPE(map_node->tag) != CV_NODE_NONE )
CV_Error( CV_StsError, "The node is neither a map nor an empty collection" );
return 0;
}
map = map_node->data.map;
tab_size = map->tab_size;
if( (tab_size & (tab_size - 1)) == 0 )
i = (int)(key->hashval & (tab_size - 1));
else
i = (int)(key->hashval % tab_size);
for( another = (CvFileMapNode*)(map->table[i]); another != 0; another = another->next )
if( another->key == key )
{
if( !create_missing )
{
value = &another->value;
return value;
}
CV_PARSE_ERROR( "Duplicated key" );
}
if( k == attempts - 1 && create_missing )
{
CvFileMapNode* node = (CvFileMapNode*)cvSetNew( (CvSet*)map );
node->key = key;
node->next = (CvFileMapNode*)(map->table[i]);
map->table[i] = node;
value = (CvFileNode*)node;
}
}
return value;
}
