mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-10 11:03:03 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #23594 from fdivitto:fdivitto-traincascade-patch

Browse Source 
fix: traincascade, use C++ persistence API #23594

This pull allows to compile traincascade application with OpenCV 4.6. Changes uses new persistence C++ API in place of legacy one.
This commit is contained in:
Fabrizio Di Vittorio 2023-05-23 08:19:27 +02:00 committed by GitHub
parent e3c5c0906b
commit 044a322519
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 278 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
apps/traincascade/boost.cpp
View File

@ -1005,7 +1005,7 @@ void CvCascadeBoostTree::read( const FileNode &node, CvBoost* _ensemble,
int step = 3 + ( maxCatCount>0 ? subsetN : 1 ); int step = 3 + ( maxCatCount>0 ? subsetN : 1 );
queue<CvDTreeNode*> internalNodesQueue; queue<CvDTreeNode*> internalNodesQueue;
FileNodeIterator internalNodesIt, leafValsuesIt; int internalNodesIdx, leafValsuesIdx;
CvDTreeNode* prntNode, *cldNode; CvDTreeNode* prntNode, *cldNode;
clear(); clear();
@ -1015,9 +1015,9 @@ void CvCascadeBoostTree::read( const FileNode &node, CvBoost* _ensemble,
// read tree nodes // read tree nodes
FileNode rnode = node[CC_INTERNAL_NODES]; FileNode rnode = node[CC_INTERNAL_NODES];
internalNodesIt = rnode.end(); internalNodesIdx = (int) rnode.size() - 1;
leafValsuesIt = node[CC_LEAF_VALUES].end(); FileNode lnode = node[CC_LEAF_VALUES];
internalNodesIt--; leafValsuesIt--; leafValsuesIdx = (int) lnode.size() - 1;
for( size_t i = 0; i < rnode.size()/step; i++ ) for( size_t i = 0; i < rnode.size()/step; i++ )
{ {
prntNode = data->new_node( 0, 0, 0, 0 ); prntNode = data->new_node( 0, 0, 0, 0 );
@ -1026,23 +1026,23 @@ void CvCascadeBoostTree::read( const FileNode &node, CvBoost* _ensemble,
prntNode->split = data->new_split_cat( 0, 0 ); prntNode->split = data->new_split_cat( 0, 0 );
for( int j = subsetN-1; j>=0; j--) for( int j = subsetN-1; j>=0; j--)
{ {
*internalNodesIt >> prntNode->split->subset[j]; internalNodesIt--; rnode[internalNodesIdx] >> prntNode->split->subset[j]; --internalNodesIdx;
} }
} }
else else
{ {
float split_value; float split_value;
*internalNodesIt >> split_value; internalNodesIt--; rnode[internalNodesIdx] >> split_value; --internalNodesIdx;
prntNode->split = data->new_split_ord( 0, split_value, 0, 0, 0); prntNode->split = data->new_split_ord( 0, split_value, 0, 0, 0);
} }
*internalNodesIt >> prntNode->split->var_idx; internalNodesIt--; rnode[internalNodesIdx] >> prntNode->split->var_idx; --internalNodesIdx;
int ridx, lidx; int ridx, lidx;
*internalNodesIt >> ridx; internalNodesIt--; rnode[internalNodesIdx] >> ridx; --internalNodesIdx;
*internalNodesIt >> lidx;internalNodesIt--; rnode[internalNodesIdx] >> lidx; --internalNodesIdx;
if ( ridx <= 0) if ( ridx <= 0)
{ {
prntNode->right = cldNode = data->new_node( 0, 0, 0, 0 ); prntNode->right = cldNode = data->new_node( 0, 0, 0, 0 );
*leafValsuesIt >> cldNode->value; leafValsuesIt--; lnode[leafValsuesIdx] >> cldNode->value; --leafValsuesIdx;
cldNode->parent = prntNode; cldNode->parent = prntNode;
} }
else else
@ -1055,7 +1055,7 @@ void CvCascadeBoostTree::read( const FileNode &node, CvBoost* _ensemble,
if ( lidx <= 0) if ( lidx <= 0)
{ {
prntNode->left = cldNode = data->new_node( 0, 0, 0, 0 ); prntNode->left = cldNode = data->new_node( 0, 0, 0, 0 );
*leafValsuesIt >> cldNode->value; leafValsuesIt--; lnode[leafValsuesIdx] >> cldNode->value; --leafValsuesIdx;
cldNode->parent = prntNode; cldNode->parent = prntNode;
} }
else else

5
apps/traincascade/cascadeclassifier.cpp
View File

@ -370,7 +370,7 @@ void CvCascadeClassifier::writeStages( FileStorage &fs, const Mat& featureMap )
it != stageClassifiers.end();++it, ++i ) it != stageClassifiers.end();++it, ++i )
{ {
snprintf( cmnt, sizeof(cmnt), "stage %d", i ); snprintf( cmnt, sizeof(cmnt), "stage %d", i );
cvWriteComment( fs.fs, cmnt, 0 ); fs.writeComment(cmnt);
fs << "{"; fs << "{";
(*it)->write( fs, featureMap ); (*it)->write( fs, featureMap );
fs << "}"; fs << "}";
@ -466,7 +466,7 @@ void CvCascadeClassifier::save( const string filename, bool baseFormat )
fs << ICV_HAAR_TREES_NAME << "["; fs << ICV_HAAR_TREES_NAME << "[";
for( int wi = 0; wi < weak->total; wi++ ) for( int wi = 0; wi < weak->total; wi++ )
{ {
int inner_node_idx = -1, total_inner_node_idx = -1; int total_inner_node_idx = -1;
queue<const CvDTreeNode*> inner_nodes_queue; queue<const CvDTreeNode*> inner_nodes_queue;
CvCascadeBoostTree* tree = *((CvCascadeBoostTree**) cvGetSeqElem( weak, wi )); CvCascadeBoostTree* tree = *((CvCascadeBoostTree**) cvGetSeqElem( weak, wi ));
@ -482,7 +482,6 @@ void CvCascadeClassifier::save( const string filename, bool baseFormat )
while (!inner_nodes_queue.empty()) while (!inner_nodes_queue.empty())
{ {
tempNode = inner_nodes_queue.front(); tempNode = inner_nodes_queue.front();
inner_node_idx++;
fs << "{"; fs << "{";
fs << ICV_HAAR_FEATURE_NAME << "{"; fs << ICV_HAAR_FEATURE_NAME << "{";

68
apps/traincascade/old_ml.hpp
View File

@ -800,13 +800,12 @@ public:
virtual const CvMat* get_var_importance(); virtual const CvMat* get_var_importance();
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( const cv::FileNode& node );
virtual void write( CvFileStorage* fs, const char* name ) const; virtual void write( cv::FileStorage& fs, const char* name ) const;
// special read & write methods for trees in the tree ensembles // special read & write methods for trees in the tree ensembles
virtual void read( CvFileStorage* fs, CvFileNode* node, virtual void read( const cv::FileNode& node, CvDTreeTrainData* data );
CvDTreeTrainData* data ); virtual void write( cv::FileStorage& fs ) const;
virtual void write( CvFileStorage* fs ) const;
const CvDTreeNode* get_root() const; const CvDTreeNode* get_root() const;
int get_pruned_tree_idx() const; int get_pruned_tree_idx() const;
@ -843,12 +842,12 @@ protected:
virtual void free_prune_data(bool cut_tree); virtual void free_prune_data(bool cut_tree);
virtual void free_tree(); virtual void free_tree();
virtual void write_node( CvFileStorage* fs, CvDTreeNode* node ) const; virtual void write_node( cv::FileStorage& fs, CvDTreeNode* node ) const;
virtual void write_split( CvFileStorage* fs, CvDTreeSplit* split ) const; virtual void write_split( cv::FileStorage& fs, CvDTreeSplit* split ) const;
virtual CvDTreeNode* read_node( CvFileStorage* fs, CvFileNode* node, CvDTreeNode* parent ); virtual CvDTreeNode* read_node( const cv::FileNode& node, CvDTreeNode* parent );
virtual CvDTreeSplit* read_split( CvFileStorage* fs, CvFileNode* node ); virtual CvDTreeSplit* read_split( const cv::FileNode& node );
virtual void write_tree_nodes( CvFileStorage* fs ) const; virtual void write_tree_nodes( cv::FileStorage& fs ) const;
virtual void read_tree_nodes( CvFileStorage* fs, CvFileNode* node ); virtual void read_tree_nodes( const cv::FileNode& node );
CvDTreeNode* root; CvDTreeNode* root;
CvMat* var_importance; CvMat* var_importance;
@ -876,7 +875,7 @@ public:
virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx, CvRTrees* forest ); virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx, CvRTrees* forest );
virtual int get_var_count() const {return data ? data->var_count : 0;} virtual int get_var_count() const {return data ? data->var_count : 0;}
virtual void read( CvFileStorage* fs, CvFileNode* node, CvRTrees* forest, CvDTreeTrainData* _data ); virtual void read( cv::FileStorage& fs, cv::FileNode& node, CvRTrees* forest, CvDTreeTrainData* _data );
/* dummy methods to avoid warnings: BEGIN */ /* dummy methods to avoid warnings: BEGIN */
virtual bool train( const CvMat* trainData, int tflag, virtual bool train( const CvMat* trainData, int tflag,
@ -886,8 +885,8 @@ public:
CvDTreeParams params=CvDTreeParams() ); CvDTreeParams params=CvDTreeParams() );
virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx ); virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx );
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( cv::FileStorage& fs, cv::FileNode& node );
virtual void read( CvFileStorage* fs, CvFileNode* node, virtual void read( cv::FileStorage& fs, cv::FileNode& node,
CvDTreeTrainData* data ); CvDTreeTrainData* data );
/* dummy methods to avoid warnings: END */ /* dummy methods to avoid warnings: END */
@ -949,8 +948,8 @@ public:
virtual float get_train_error(); virtual float get_train_error();
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( cv::FileStorage& fs, cv::FileNode& node );
virtual void write( CvFileStorage* fs, const char* name ) const; virtual void write( cv::FileStorage& fs, const char* name ) const;
CvMat* get_active_var_mask(); CvMat* get_active_var_mask();
CvRNG* get_rng(); CvRNG* get_rng();
@ -1067,7 +1066,7 @@ public:
const CvMat* subsample_idx, CvBoost* ensemble ); const CvMat* subsample_idx, CvBoost* ensemble );
virtual void scale( double s ); virtual void scale( double s );
virtual void read( CvFileStorage* fs, CvFileNode* node, virtual void read( const cv::FileNode& node,
CvBoost* ensemble, CvDTreeTrainData* _data ); CvBoost* ensemble, CvDTreeTrainData* _data );
virtual void clear(); virtual void clear();
@ -1079,9 +1078,8 @@ public:
CvDTreeParams params=CvDTreeParams() ); CvDTreeParams params=CvDTreeParams() );
virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx ); virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx );
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( cv::FileNode& node );
virtual void read( CvFileStorage* fs, CvFileNode* node, virtual void read( cv::FileNode& node, CvDTreeTrainData* data );
CvDTreeTrainData* data );
/* dummy methods to avoid warnings: END */ /* dummy methods to avoid warnings: END */
protected: protected:
@ -1160,8 +1158,8 @@ public:
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
virtual void write( CvFileStorage* storage, const char* name ) const; virtual void write( cv::FileStorage& storage, const char* name ) const;
virtual void read( CvFileStorage* storage, CvFileNode* node ); virtual void read( cv::FileNode& node );
virtual const CvMat* get_active_vars(bool absolute_idx=true); virtual const CvMat* get_active_vars(bool absolute_idx=true);
CvSeq* get_weak_predictors(); CvSeq* get_weak_predictors();
@ -1177,8 +1175,8 @@ protected:
virtual bool set_params( const CvBoostParams& params ); virtual bool set_params( const CvBoostParams& params );
virtual void update_weights( CvBoostTree* tree ); virtual void update_weights( CvBoostTree* tree );
virtual void trim_weights(); virtual void trim_weights();
virtual void write_params( CvFileStorage* fs ) const; virtual void write_params( cv::FileStorage & fs ) const;
virtual void read_params( CvFileStorage* fs, CvFileNode* node ); virtual void read_params( cv::FileNode& node );
virtual void initialize_weights(double (&p)[2]); virtual void initialize_weights(double (&p)[2]);
@ -1548,7 +1546,7 @@ public:
// Write parameters of the gtb model and data. Write learned model. // Write parameters of the gtb model and data. Write learned model.
// //
// API // API
// virtual void write( CvFileStorage* fs, const char* name ) const; // virtual void write( cv::FileStorage& fs, const char* name ) const;
// //
// INPUT // INPUT
// fs - file storage to read parameters from. // fs - file storage to read parameters from.
@ -1556,7 +1554,7 @@ public:
// OUTPUT // OUTPUT
// RESULT // RESULT
*/ */
virtual void write( CvFileStorage* fs, const char* name ) const; virtual void write( cv::FileStorage& fs, const char* name ) const;
/* /*
@ -1564,7 +1562,7 @@ public:
// Read parameters of the gtb model and data. Read learned model. // Read parameters of the gtb model and data. Read learned model.
// //
// API // API
// virtual void read( CvFileStorage* fs, CvFileNode* node ); // virtual void read( cv::FileStorage& fs, cv::FileNode& node );
// //
// INPUT // INPUT
// fs - file storage to read parameters from. // fs - file storage to read parameters from.
@ -1572,7 +1570,7 @@ public:
// OUTPUT // OUTPUT
// RESULT // RESULT
*/ */
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( cv::FileStorage& fs, cv::FileNode& node );
// new-style C++ interface // new-style C++ interface
@ -1723,14 +1721,14 @@ protected:
// Write parameters of the gtb model. // Write parameters of the gtb model.
// //
// API // API
// virtual void write_params( CvFileStorage* fs ) const; // virtual void write_params( cv::FileStorage& fs ) const;
// //
// INPUT // INPUT
// fs - file storage to write parameters to. // fs - file storage to write parameters to.
// OUTPUT // OUTPUT
// RESULT // RESULT
*/ */
virtual void write_params( CvFileStorage* fs ) const; virtual void write_params( cv::FileStorage& fs ) const;
/* /*
@ -1750,7 +1748,7 @@ protected:
// class_labels - output class labels map. // class_labels - output class labels map.
// RESULT // RESULT
*/ */
virtual void read_params( CvFileStorage* fs, CvFileNode* fnode ); virtual void read_params( cv::FileStorage& fs, cv::FileNode& fnode );
int get_len(const CvMat* mat) const; int get_len(const CvMat* mat) const;
@ -1846,8 +1844,8 @@ public:
// available training flags // available training flags
enum { UPDATE_WEIGHTS = 1, NO_INPUT_SCALE = 2, NO_OUTPUT_SCALE = 4 }; enum { UPDATE_WEIGHTS = 1, NO_INPUT_SCALE = 2, NO_OUTPUT_SCALE = 4 };
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( cv::FileStorage& fs, cv::FileNode& node );
virtual void write( CvFileStorage* storage, const char* name ) const; virtual void write( cv::FileStorage& storage, const char* name ) const;
int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; } int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; }
const CvMat* get_layer_sizes() { return layer_sizes; } const CvMat* get_layer_sizes() { return layer_sizes; }
@ -1880,8 +1878,8 @@ protected:
virtual void calc_input_scale( const CvVectors* vecs, int flags ); virtual void calc_input_scale( const CvVectors* vecs, int flags );
virtual void calc_output_scale( const CvVectors* vecs, int flags ); virtual void calc_output_scale( const CvVectors* vecs, int flags );
virtual void write_params( CvFileStorage* fs ) const; virtual void write_params( cv::FileStorage& fs ) const;
virtual void read_params( CvFileStorage* fs, CvFileNode* node ); virtual void read_params( cv::FileStorage& fs, cv::FileNode& node );
CvMat* layer_sizes; CvMat* layer_sizes;
CvMat* wbuf; CvMat* wbuf;

110
apps/traincascade/old_ml_boost.cpp
View File

@ -876,21 +876,21 @@ CvBoostTree::calc_node_value( CvDTreeNode* node )
} }
void CvBoostTree::read( CvFileStorage* fs, CvFileNode* fnode, CvBoost* _ensemble, CvDTreeTrainData* _data ) void CvBoostTree::read( const cv::FileNode& fnode, CvBoost* _ensemble, CvDTreeTrainData* _data )
{ {
CvDTree::read( fs, fnode, _data ); CvDTree::read( fnode, _data );
ensemble = _ensemble; ensemble = _ensemble;
} }
void CvBoostTree::read( CvFileStorage*, CvFileNode* ) void CvBoostTree::read( cv::FileNode& )
{ {
assert(0); assert(0);
} }
void CvBoostTree::read( CvFileStorage* _fs, CvFileNode* _node, void CvBoostTree::read( cv::FileNode& _node,
CvDTreeTrainData* _data ) CvDTreeTrainData* _data )
{ {
CvDTree::read( _fs, _node, _data ); CvDTree::read( _node, _data );
} }
@ -1884,7 +1884,7 @@ float CvBoost::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
return err; return err;
} }
void CvBoost::write_params( CvFileStorage* fs ) const void CvBoost::write_params( cv::FileStorage& fs ) const
{ {
const char* boost_type_str = const char* boost_type_str =
params.boost_type == DISCRETE ? "DiscreteAdaboost" : params.boost_type == DISCRETE ? "DiscreteAdaboost" :
@ -1899,35 +1899,33 @@ void CvBoost::write_params( CvFileStorage* fs ) const
params.boost_type == SQERR ? "SquaredErr" : 0; params.boost_type == SQERR ? "SquaredErr" : 0;
if( boost_type_str ) if( boost_type_str )
cvWriteString( fs, "boosting_type", boost_type_str ); fs.write( "boosting_type", boost_type_str );
else else
cvWriteInt( fs, "boosting_type", params.boost_type ); fs.write( "boosting_type", params.boost_type );
if( split_crit_str ) if( split_crit_str )
cvWriteString( fs, "splitting_criteria", split_crit_str ); fs.write( "splitting_criteria", split_crit_str );
else else
cvWriteInt( fs, "splitting_criteria", params.split_criteria ); fs.write( "splitting_criteria", params.split_criteria );
cvWriteInt( fs, "ntrees", weak->total ); fs.write( "ntrees", weak->total );
cvWriteReal( fs, "weight_trimming_rate", params.weight_trim_rate ); fs.write( "weight_trimming_rate", params.weight_trim_rate );
data->write_params( fs ); data->write_params( fs );
} }
void CvBoost::read_params( CvFileStorage* fs, CvFileNode* fnode ) void CvBoost::read_params( cv::FileNode& fnode )
{ {
CV_FUNCNAME( "CvBoost::read_params" ); CV_FUNCNAME( "CvBoost::read_params" );
__BEGIN__; __BEGIN__;
CvFileNode* temp; if( fnode.empty() || !fnode.isMap() )
if( !fnode || !CV_NODE_IS_MAP(fnode->tag) )
return; return;
data = new CvDTreeTrainData(); data = new CvDTreeTrainData();
CV_CALL( data->read_params(fs, fnode)); data->read_params( fnode );
data->shared = true; data->shared = true;
params.max_depth = data->params.max_depth; params.max_depth = data->params.max_depth;
@ -1937,41 +1935,41 @@ void CvBoost::read_params( CvFileStorage* fs, CvFileNode* fnode )
params.regression_accuracy = data->params.regression_accuracy; params.regression_accuracy = data->params.regression_accuracy;
params.use_surrogates = data->params.use_surrogates; params.use_surrogates = data->params.use_surrogates;
temp = cvGetFileNodeByName( fs, fnode, "boosting_type" ); cv::FileNode temp = fnode[ "boosting_type" ];
if( !temp ) if( temp.empty() )
return; return;
if( temp && CV_NODE_IS_STRING(temp->tag) ) if ( temp.isString() )
{ {
const char* boost_type_str = cvReadString( temp, "" ); std::string boost_type_str = temp;
params.boost_type = strcmp( boost_type_str, "DiscreteAdaboost" ) == 0 ? DISCRETE : params.boost_type = (boost_type_str == "DiscreteAdaboost") ? DISCRETE :
strcmp( boost_type_str, "RealAdaboost" ) == 0 ? REAL : (boost_type_str == "RealAdaboost") ? REAL :
strcmp( boost_type_str, "LogitBoost" ) == 0 ? LOGIT : (boost_type_str == "LogitBoost") ? LOGIT :
strcmp( boost_type_str, "GentleAdaboost" ) == 0 ? GENTLE : -1; (boost_type_str == "GentleAdaboost") ? GENTLE : -1;
} }
else else
params.boost_type = cvReadInt( temp, -1 ); params.boost_type = temp.empty() ? -1 : (int)temp;
if( params.boost_type < DISCRETE || params.boost_type > GENTLE ) if( params.boost_type < DISCRETE || params.boost_type > GENTLE )
CV_ERROR( CV_StsBadArg, "Unknown boosting type" ); CV_ERROR( CV_StsBadArg, "Unknown boosting type" );
temp = cvGetFileNodeByName( fs, fnode, "splitting_criteria" ); temp = fnode[ "splitting_criteria" ];
if( temp && CV_NODE_IS_STRING(temp->tag) ) if( !temp.empty() && temp.isString() )
{ {
const char* split_crit_str = cvReadString( temp, "" ); std::string split_crit_str = temp;
params.split_criteria = strcmp( split_crit_str, "Default" ) == 0 ? DEFAULT : params.split_criteria = ( split_crit_str == "Default" ) ? DEFAULT :
strcmp( split_crit_str, "Gini" ) == 0 ? GINI : ( split_crit_str == "Gini" ) ? GINI :
strcmp( split_crit_str, "Misclassification" ) == 0 ? MISCLASS : ( split_crit_str == "Misclassification" ) ? MISCLASS :
strcmp( split_crit_str, "SquaredErr" ) == 0 ? SQERR : -1; ( split_crit_str == "SquaredErr" ) ? SQERR : -1;
} }
else else
params.split_criteria = cvReadInt( temp, -1 ); params.split_criteria = temp.empty() ? -1 : (int) temp;
if( params.split_criteria < DEFAULT || params.boost_type > SQERR ) if( params.split_criteria < DEFAULT || params.boost_type > SQERR )
CV_ERROR( CV_StsBadArg, "Unknown boosting type" ); CV_ERROR( CV_StsBadArg, "Unknown boosting type" );
params.weak_count = cvReadIntByName( fs, fnode, "ntrees" ); params.weak_count = (int) fnode[ "ntrees" ];
params.weight_trim_rate = cvReadRealByName( fs, fnode, "weight_trimming_rate", 0. ); params.weight_trim_rate = (double)fnode["weight_trimming_rate"];
__END__; __END__;
} }
@ -1979,29 +1977,29 @@ void CvBoost::read_params( CvFileStorage* fs, CvFileNode* fnode )
void void
CvBoost::read( CvFileStorage* fs, CvFileNode* node ) CvBoost::read( cv::FileNode& node )
{ {
CV_FUNCNAME( "CvBoost::read" ); CV_FUNCNAME( "CvBoost::read" );
__BEGIN__; __BEGIN__;
CvSeqReader reader; cv::FileNodeIterator reader;
CvFileNode* trees_fnode; cv::FileNode trees_fnode;
CvMemStorage* storage; CvMemStorage* storage;
int i, ntrees; int ntrees;
clear(); clear();
read_params( fs, node ); read_params( node );
if( !data ) if( !data )
EXIT; EXIT;
trees_fnode = cvGetFileNodeByName( fs, node, "trees" ); trees_fnode = node[ "trees" ];
if( !trees_fnode || !CV_NODE_IS_SEQ(trees_fnode->tag) ) if( trees_fnode.empty() || !trees_fnode.isSeq() )
CV_ERROR( CV_StsParseError, "<trees> tag is missing" ); CV_ERROR( CV_StsParseError, "<trees> tag is missing" );
cvStartReadSeq( trees_fnode->data.seq, &reader ); reader = trees_fnode.begin();
ntrees = trees_fnode->data.seq->total; ntrees = (int) trees_fnode.size();
if( ntrees != params.weak_count ) if( ntrees != params.weak_count )
CV_ERROR( CV_StsUnmatchedSizes, CV_ERROR( CV_StsUnmatchedSizes,
@ -2010,11 +2008,11 @@ CvBoost::read( CvFileStorage* fs, CvFileNode* node )
CV_CALL( storage = cvCreateMemStorage() ); CV_CALL( storage = cvCreateMemStorage() );
weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage ); weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage );
for( i = 0; i < ntrees; i++ ) for( int i = 0; i < ntrees; i++ )
{ {
CvBoostTree* tree = new CvBoostTree(); CvBoostTree* tree = new CvBoostTree();
CV_CALL(tree->read( fs, (CvFileNode*)reader.ptr, this, data )); tree->read( *reader, this, data );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); reader++;
cvSeqPush( weak, &tree ); cvSeqPush( weak, &tree );
} }
get_active_vars(); get_active_vars();
@ -2024,7 +2022,7 @@ CvBoost::read( CvFileStorage* fs, CvFileNode* node )
void void
CvBoost::write( CvFileStorage* fs, const char* name ) const CvBoost::write( cv::FileStorage& fs, const char* name ) const
{ {
CV_FUNCNAME( "CvBoost::write" ); CV_FUNCNAME( "CvBoost::write" );
@ -2033,27 +2031,27 @@ CvBoost::write( CvFileStorage* fs, const char* name ) const
CvSeqReader reader; CvSeqReader reader;
int i; int i;
cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_BOOSTING ); fs.startWriteStruct( name, cv::FileNode::MAP, CV_TYPE_NAME_ML_BOOSTING );
if( !weak ) if( !weak )
CV_ERROR( CV_StsBadArg, "The classifier has not been trained yet" ); CV_ERROR( CV_StsBadArg, "The classifier has not been trained yet" );
write_params( fs ); write_params( fs );
cvStartWriteStruct( fs, "trees", CV_NODE_SEQ ); fs.startWriteStruct( "trees", cv::FileNode::SEQ );
cvStartReadSeq( weak, &reader ); cvStartReadSeq(weak, &reader);
for( i = 0; i < weak->total; i++ ) for( i = 0; i < weak->total; i++ )
{ {
CvBoostTree* tree; CvBoostTree* tree;
CV_READ_SEQ_ELEM( tree, reader ); CV_READ_SEQ_ELEM( tree, reader );
cvStartWriteStruct( fs, 0, CV_NODE_MAP ); fs.startWriteStruct( 0, cv::FileNode::MAP );
tree->write( fs ); tree->write( fs );
cvEndWriteStruct( fs ); fs.endWriteStruct();
} }
cvEndWriteStruct( fs ); fs.endWriteStruct();
cvEndWriteStruct( fs ); fs.endWriteStruct();
__END__; __END__;
} }

32
apps/traincascade/old_ml_inner_functions.cpp
View File

@ -60,61 +60,57 @@ void CvStatModel::clear()
void CvStatModel::save( const char* filename, const char* name ) const void CvStatModel::save( const char* filename, const char* name ) const
{ {
CvFileStorage* fs = 0; cv::FileStorage fs;
CV_FUNCNAME( "CvStatModel::save" ); CV_FUNCNAME( "CvStatModel::save" );
__BEGIN__; __BEGIN__;
CV_CALL( fs = cvOpenFileStorage( filename, 0, CV_STORAGE_WRITE )); if( !fs.open( filename, cv::FileStorage::WRITE ))
if( !fs )
CV_ERROR( CV_StsError, "Could not open the file storage. Check the path and permissions" ); CV_ERROR( CV_StsError, "Could not open the file storage. Check the path and permissions" );
write( fs, name ? name : default_model_name ); write( fs, name ? name : default_model_name );
__END__; __END__;
cvReleaseFileStorage( &fs );
} }
void CvStatModel::load( const char* filename, const char* name ) void CvStatModel::load( const char* filename, const char* name )
{ {
CvFileStorage* fs = 0; cv::FileStorage fs;
CV_FUNCNAME( "CvAlgorithm::load" ); CV_FUNCNAME( "CvStatModel::load" );
__BEGIN__; __BEGIN__;
CvFileNode* model_node = 0; cv::FileNode model_node;
CV_CALL( fs = cvOpenFileStorage( filename, 0, CV_STORAGE_READ )); if( !fs.open(filename, cv::FileStorage::READ) )
if( !fs ) CV_ERROR( CV_StsError, "Could not open the file storage. Check the path and permissions" );
EXIT;
if( name ) if( name )
model_node = cvGetFileNodeByName( fs, 0, name ); model_node = fs[ name ];
else else
{ {
CvFileNode* root = cvGetRootFileNode( fs ); auto root = fs.root();
if( root->data.seq->total > 0 ) if ( root.size() > 0 )
model_node = (CvFileNode*)cvGetSeqElem( root->data.seq, 0 ); model_node = fs[0];
} }
read( fs, model_node ); read( model_node );
__END__; __END__;
cvReleaseFileStorage( &fs );
} }
void CvStatModel::write( CvFileStorage*, const char* ) const void CvStatModel::write( cv::FileStorage&, const char* ) const
{ {
OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::write", "" ); OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::write", "" );
} }
void CvStatModel::read( CvFileStorage*, CvFileNode* ) void CvStatModel::read( const cv::FileNode& )
{ {
OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::read", "" ); OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::read", "" );
} }

6
apps/traincascade/old_ml_precomp.hpp
View File

@ -321,9 +321,9 @@ cvWritebackLabels( const CvMat* labels, CvMat* dst_labels,
#define cvWritebackResponses cvWritebackLabels #define cvWritebackResponses cvWritebackLabels
#define XML_FIELD_NAME "_name" #define XML_FIELD_NAME "_name"
CvFileNode* icvFileNodeGetChild(CvFileNode* father, const char* name); cv::FileNode icvFileNodeGetChild( cv::FileNode& father, const char* name );
CvFileNode* icvFileNodeGetChildArrayElem(CvFileNode* father, const char* name,int index); cv::FileNode icvFileNodeGetChildArrayElem( cv::FileNode& father, const char* name,int index );
CvFileNode* icvFileNodeGetNext(CvFileNode* n, const char* name); cv::FileNode icvFileNodeGetNext( cv::FileNode& n, const char* name );
void cvCheckTrainData( const CvMat* train_data, int tflag, void cvCheckTrainData( const CvMat* train_data, int tflag,

317
apps/traincascade/old_ml_tree.cpp
View File

@ -1287,7 +1287,7 @@ int CvDTreeTrainData::get_child_buf_idx( CvDTreeNode* n )
} }
void CvDTreeTrainData::write_params( CvFileStorage* fs ) const void CvDTreeTrainData::write_params( cv::FileStorage& fs ) const
{ {
CV_FUNCNAME( "CvDTreeTrainData::write_params" ); CV_FUNCNAME( "CvDTreeTrainData::write_params" );
@ -1295,113 +1295,118 @@ void CvDTreeTrainData::write_params( CvFileStorage* fs ) const
int vi, vcount = var_count; int vi, vcount = var_count;
cvWriteInt( fs, "is_classifier", is_classifier ? 1 : 0 ); fs.write( "is_classifier", is_classifier ? 1 : 0 );
cvWriteInt( fs, "var_all", var_all ); fs.write( "var_all", var_all );
cvWriteInt( fs, "var_count", var_count ); fs.write( "var_count", var_count );
cvWriteInt( fs, "ord_var_count", ord_var_count ); fs.write( "ord_var_count", ord_var_count );
cvWriteInt( fs, "cat_var_count", cat_var_count ); fs.write( "cat_var_count", cat_var_count );
cvStartWriteStruct( fs, "training_params", CV_NODE_MAP ); fs.startWriteStruct( "training_params", FileNode::MAP );
cvWriteInt( fs, "use_surrogates", params.use_surrogates ? 1 : 0 ); fs.write( "use_surrogates", params.use_surrogates ? 1 : 0 );
if( is_classifier ) if( is_classifier )
{ {
cvWriteInt( fs, "max_categories", params.max_categories ); fs.write( "max_categories", params.max_categories );
} }
else else
{ {
cvWriteReal( fs, "regression_accuracy", params.regression_accuracy ); fs.write( "regression_accuracy", params.regression_accuracy );
} }
cvWriteInt( fs, "max_depth", params.max_depth ); fs.write( "max_depth", params.max_depth );
cvWriteInt( fs, "min_sample_count", params.min_sample_count ); fs.write( "min_sample_count", params.min_sample_count );
cvWriteInt( fs, "cross_validation_folds", params.cv_folds ); fs.write( "cross_validation_folds", params.cv_folds );
if( params.cv_folds > 1 ) if( params.cv_folds > 1 )
{ {
cvWriteInt( fs, "use_1se_rule", params.use_1se_rule ? 1 : 0 ); fs.write( "use_1se_rule", params.use_1se_rule ? 1 : 0 );
cvWriteInt( fs, "truncate_pruned_tree", params.truncate_pruned_tree ? 1 : 0 ); fs.write( "truncate_pruned_tree", params.truncate_pruned_tree ? 1 : 0 );
} }
if( priors ) if( priors )
cvWrite( fs, "priors", priors ); fs.write( "priors", cvarrToMat(priors) );
cvEndWriteStruct( fs ); fs.endWriteStruct();
if( var_idx ) if( var_idx )
cvWrite( fs, "var_idx", var_idx ); fs.write( "var_idx", cvarrToMat(var_idx) );
cvStartWriteStruct( fs, "var_type", CV_NODE_SEQ+CV_NODE_FLOW ); fs.startWriteStruct("var_type", FileNode::SEQ + FileNode::FLOW );
for( vi = 0; vi < vcount; vi++ ) for( vi = 0; vi < vcount; vi++ )
cvWriteInt( fs, 0, var_type->data.i[vi] >= 0 ); fs.write( 0, var_type->data.i[vi] >= 0 );
cvEndWriteStruct( fs ); fs.endWriteStruct();
if( cat_count && (cat_var_count > 0 || is_classifier) ) if( cat_count && (cat_var_count > 0 || is_classifier) )
{ {
CV_ASSERT( cat_count != 0 ); CV_ASSERT( cat_count != 0 );
cvWrite( fs, "cat_count", cat_count ); fs.write( "cat_count", cvarrToMat(cat_count) );
cvWrite( fs, "cat_map", cat_map ); fs.write( "cat_map", cvarrToMat(cat_map) );
} }
__END__; __END__;
} }
void CvDTreeTrainData::read_params( CvFileStorage* fs, CvFileNode* node ) void CvDTreeTrainData::read_params( const cv::FileNode& node )
{ {
CV_FUNCNAME( "CvDTreeTrainData::read_params" ); CV_FUNCNAME( "CvDTreeTrainData::read_params" );
__BEGIN__; __BEGIN__;
CvFileNode *tparams_node, *vartype_node; cv::FileNode tparams_node, vartype_node;
CvSeqReader reader; FileNodeIterator reader;
int vi, max_split_size, tree_block_size; int vi, max_split_size, tree_block_size;
is_classifier = (cvReadIntByName( fs, node, "is_classifier" ) != 0); is_classifier = (int) node[ "is_classifier" ] != 0;
var_all = cvReadIntByName( fs, node, "var_all" ); var_all = (int) node[ "var_all" ];
var_count = cvReadIntByName( fs, node, "var_count", var_all ); var_count = node[ "var_count" ].empty() ? var_all : (int)node[ "var_count" ];
cat_var_count = cvReadIntByName( fs, node, "cat_var_count" ); cat_var_count = (int) node[ "cat_var_count" ];
ord_var_count = cvReadIntByName( fs, node, "ord_var_count" ); ord_var_count = (int) node[ "ord_var_count" ];
tparams_node = cvGetFileNodeByName( fs, node, "training_params" ); tparams_node = node[ "training_params" ];
if( tparams_node ) // training parameters are not necessary if( !tparams_node.empty() ) // training parameters are not necessary
{ {
params.use_surrogates = cvReadIntByName( fs, tparams_node, "use_surrogates", 1 ) != 0; params.use_surrogates = (tparams_node[ "use_surrogates" ].empty() ? 1 : (int)tparams_node[ "use_surrogates" ] ) != 0;
if( is_classifier ) if( is_classifier )
{ {
params.max_categories = cvReadIntByName( fs, tparams_node, "max_categories" ); params.max_categories = (int) tparams_node[ "max_categories" ];
} }
else else
{ {
params.regression_accuracy = params.regression_accuracy = (float) tparams_node[ "regression_accuracy" ];
(float)cvReadRealByName( fs, tparams_node, "regression_accuracy" );
} }
params.max_depth = cvReadIntByName( fs, tparams_node, "max_depth" ); params.max_depth = (int) tparams_node[ "max_depth" ];
params.min_sample_count = cvReadIntByName( fs, tparams_node, "min_sample_count" ); params.min_sample_count = (int) tparams_node[ "min_sample_count" ];
params.cv_folds = cvReadIntByName( fs, tparams_node, "cross_validation_folds" ); params.cv_folds = (int) tparams_node[ "cross_validation_folds" ];
if( params.cv_folds > 1 ) if( params.cv_folds > 1 )
{ {
params.use_1se_rule = cvReadIntByName( fs, tparams_node, "use_1se_rule" ) != 0; params.use_1se_rule = (int)tparams_node[ "use_1se_rule" ] != 0;
params.truncate_pruned_tree = params.truncate_pruned_tree = (int) tparams_node[ "truncate_pruned_tree" ] != 0;
cvReadIntByName( fs, tparams_node, "truncate_pruned_tree" ) != 0;
} }
priors = (CvMat*)cvReadByName( fs, tparams_node, "priors" ); priors = nullptr;
if( priors ) if(!tparams_node[ "priors" ].empty())
{ {
auto tmat = cvMat( tparams_node[ "priors" ].mat() );
priors = cvCloneMat( &tmat );
if( !CV_IS_MAT(priors) ) if( !CV_IS_MAT(priors) )
CV_ERROR( CV_StsParseError, "priors must stored as a matrix" ); CV_ERROR( CV_StsParseError, "priors must stored as a matrix" );
priors_mult = cvCloneMat( priors ); priors_mult = cvCloneMat( priors );
} }
} }
CV_CALL( var_idx = (CvMat*)cvReadByName( fs, node, "var_idx" )); var_idx = nullptr;
if (!node[ "var_idx" ].empty())
{
auto tmat = cvMat( tparams_node[ "var_idx" ].mat() );
var_idx = cvCloneMat( &tmat );
}
if( var_idx ) if( var_idx )
{ {
if( !CV_IS_MAT(var_idx) || if( !CV_IS_MAT(var_idx) ||
@ -1421,25 +1426,25 @@ void CvDTreeTrainData::read_params( CvFileStorage* fs, CvFileNode* node )
cat_var_count = 0; cat_var_count = 0;
ord_var_count = -1; ord_var_count = -1;
vartype_node = cvGetFileNodeByName( fs, node, "var_type" ); vartype_node = node[ "var_type" ];
if( vartype_node && CV_NODE_TYPE(vartype_node->tag) == CV_NODE_INT && var_count == 1 ) if( !vartype_node.empty() && vartype_node.isInt() && var_count == 1 )
var_type->data.i[0] = vartype_node->data.i ? cat_var_count++ : ord_var_count--; var_type->data.i[0] = (int)vartype_node ? cat_var_count++ : ord_var_count--;
else else
{ {
if( !vartype_node || CV_NODE_TYPE(vartype_node->tag) != CV_NODE_SEQ || if( vartype_node.empty() || !vartype_node.isSeq() ||
vartype_node->data.seq->total != var_count ) vartype_node.size() != (size_t) var_count )
CV_ERROR( CV_StsParseError, "var_type must exist and be a sequence of 0's and 1's" ); CV_ERROR( CV_StsParseError, "var_type must exist and be a sequence of 0's and 1's" );
cvStartReadSeq( vartype_node->data.seq, &reader ); reader = vartype_node.begin();
for( vi = 0; vi < var_count; vi++ ) for( vi = 0; vi < var_count; vi++ )
{ {
CvFileNode* n = (CvFileNode*)reader.ptr; cv::FileNode n = *reader;
if( CV_NODE_TYPE(n->tag) != CV_NODE_INT || (n->data.i & ~1) ) if( !n.isInt() || ((int) n & ~1) )
CV_ERROR( CV_StsParseError, "var_type must exist and be a sequence of 0's and 1's" ); CV_ERROR( CV_StsParseError, "var_type must exist and be a sequence of 0's and 1's" );
var_type->data.i[vi] = n->data.i ? cat_var_count++ : ord_var_count--; var_type->data.i[vi] = (int) n ? cat_var_count++ : ord_var_count--;
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); reader++;
} }
} }
var_type->data.i[var_count] = cat_var_count; var_type->data.i[var_count] = cat_var_count;
@ -1450,8 +1455,12 @@ void CvDTreeTrainData::read_params( CvFileStorage* fs, CvFileNode* node )
if( cat_var_count > 0 || is_classifier ) if( cat_var_count > 0 || is_classifier )
{ {
int ccount, total_c_count = 0; int ccount, total_c_count = 0;
CV_CALL( cat_count = (CvMat*)cvReadByName( fs, node, "cat_count" ));
CV_CALL( cat_map = (CvMat*)cvReadByName( fs, node, "cat_map" )); auto cat_count_m = cvMat( node["cat_count"].mat() );
cat_count = cvCloneMat( &cat_count_m );
auto cat_map_m = cvMat( node[ "cat_map" ].mat() );
cat_map = cvCloneMat( &cat_map_m );
if( !CV_IS_MAT(cat_count) || !CV_IS_MAT(cat_map) || if( !CV_IS_MAT(cat_count) || !CV_IS_MAT(cat_map) ||
(cat_count->cols != 1 && cat_count->rows != 1) || (cat_count->cols != 1 && cat_count->rows != 1) ||
@ -3690,10 +3699,8 @@ CvDTreeNode* CvDTree::predict( const CvMat* _sample,
CV_Error( CV_StsBadArg, CV_Error( CV_StsBadArg,
"one of input categorical variable is not an integer" ); "one of input categorical variable is not an integer" );
int sh = 0;
while( a < b ) while( a < b )
{ {
sh++;
c = (a + b) >> 1; c = (a + b) >> 1;
if( ival < cmap[c] ) if( ival < cmap[c] )
b = c; b = c;
@ -3779,13 +3786,13 @@ const CvMat* CvDTree::get_var_importance()
} }
void CvDTree::write_split( CvFileStorage* fs, CvDTreeSplit* split ) const void CvDTree::write_split( cv::FileStorage& fs, CvDTreeSplit* split ) const
{ {
int ci; int ci;
cvStartWriteStruct( fs, 0, CV_NODE_MAP + CV_NODE_FLOW ); fs.startWriteStruct( 0, FileNode::MAP + FileNode::FLOW );
cvWriteInt( fs, "var", split->var_idx ); fs.write( "var", split->var_idx );
cvWriteReal( fs, "quality", split->quality ); fs.write( "quality", split->quality );
ci = data->get_var_type(split->var_idx); ci = data->get_var_type(split->var_idx);
if( ci >= 0 ) // split on a categorical var if( ci >= 0 ) // split on a categorical var
@ -3798,59 +3805,57 @@ void CvDTree::write_split( CvFileStorage* fs, CvDTreeSplit* split ) const
// to achieve more compact and clear representation // to achieve more compact and clear representation
default_dir = to_right <= 1 || to_right <= MIN(3, n/2) || to_right <= n/3 ? -1 : 1; default_dir = to_right <= 1 || to_right <= MIN(3, n/2) || to_right <= n/3 ? -1 : 1;
cvStartWriteStruct( fs, default_dir*(split->inversed ? -1 : 1) > 0 ? fs.startWriteStruct( default_dir*(split->inversed ? -1 : 1) > 0 ?
"in" : "not_in", CV_NODE_SEQ+CV_NODE_FLOW ); "in" : "not_in", FileNode::SEQ+FileNode::FLOW );
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
int dir = CV_DTREE_CAT_DIR(i,split->subset); int dir = CV_DTREE_CAT_DIR(i,split->subset);
if( dir*default_dir < 0 ) if( dir*default_dir < 0 )
cvWriteInt( fs, 0, i ); fs.write( 0, i );
} }
cvEndWriteStruct( fs ); fs.endWriteStruct();
} }
else else
cvWriteReal( fs, !split->inversed ? "le" : "gt", split->ord.c ); fs.write( !split->inversed ? "le" : "gt", split->ord.c );
cvEndWriteStruct( fs ); fs.endWriteStruct();
} }
void CvDTree::write_node( CvFileStorage* fs, CvDTreeNode* node ) const void CvDTree::write_node( cv::FileStorage& fs, CvDTreeNode* node ) const
{ {
CvDTreeSplit* split; fs.startWriteStruct( 0, FileNode::MAP );
cvStartWriteStruct( fs, 0, CV_NODE_MAP ); fs.write( "depth", node->depth );
fs.write( "sample_count", node->sample_count );
cvWriteInt( fs, "depth", node->depth ); fs.write( "value", node->value );
cvWriteInt( fs, "sample_count", node->sample_count );
cvWriteReal( fs, "value", node->value );
if( data->is_classifier ) if( data->is_classifier )
cvWriteInt( fs, "norm_class_idx", node->class_idx ); fs.write( "norm_class_idx", node->class_idx );
cvWriteInt( fs, "Tn", node->Tn ); fs.write( "Tn", node->Tn );
cvWriteInt( fs, "complexity", node->complexity ); fs.write( "complexity", node->complexity );
cvWriteReal( fs, "alpha", node->alpha ); fs.write( "alpha", node->alpha );
cvWriteReal( fs, "node_risk", node->node_risk ); fs.write( "node_risk", node->node_risk );
cvWriteReal( fs, "tree_risk", node->tree_risk ); fs.write( "tree_risk", node->tree_risk );
cvWriteReal( fs, "tree_error", node->tree_error ); fs.write( "tree_error", node->tree_error );
if( node->left ) if( node->left )
{ {
cvStartWriteStruct( fs, "splits", CV_NODE_SEQ ); fs.startWriteStruct( "splits", FileNode::SEQ );
for( split = node->split; split != 0; split = split->next ) for( CvDTreeSplit* split = node->split; split != 0; split = split->next )
write_split( fs, split ); write_split( fs, split );
cvEndWriteStruct( fs ); fs.endWriteStruct();
} }
cvEndWriteStruct( fs ); fs.endWriteStruct();
} }
void CvDTree::write_tree_nodes( CvFileStorage* fs ) const void CvDTree::write_tree_nodes( cv::FileStorage& fs ) const
{ {
//CV_FUNCNAME( "CvDTree::write_tree_nodes" ); //CV_FUNCNAME( "CvDTree::write_tree_nodes" );
@ -3884,13 +3889,13 @@ void CvDTree::write_tree_nodes( CvFileStorage* fs ) const
} }
void CvDTree::write( CvFileStorage* fs, const char* name ) const void CvDTree::write( cv::FileStorage& fs, const char* name ) const
{ {
//CV_FUNCNAME( "CvDTree::write" ); //CV_FUNCNAME( "CvDTree::write" );
__BEGIN__; __BEGIN__;
cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_TREE ); fs.startWriteStruct( name, FileNode::MAP, CV_TYPE_NAME_ML_TREE );
//get_var_importance(); //get_var_importance();
data->write_params( fs ); data->write_params( fs );
@ -3898,29 +3903,29 @@ void CvDTree::write( CvFileStorage* fs, const char* name ) const
//cvWrite( fs, "var_importance", var_importance ); //cvWrite( fs, "var_importance", var_importance );
write( fs ); write( fs );
cvEndWriteStruct( fs ); fs.endWriteStruct();
__END__; __END__;
} }
void CvDTree::write( CvFileStorage* fs ) const void CvDTree::write( cv::FileStorage& fs ) const
{ {
//CV_FUNCNAME( "CvDTree::write" ); //CV_FUNCNAME( "CvDTree::write" );
__BEGIN__; __BEGIN__;
cvWriteInt( fs, "best_tree_idx", pruned_tree_idx ); fs.write( "best_tree_idx", pruned_tree_idx );
cvStartWriteStruct( fs, "nodes", CV_NODE_SEQ ); fs.startWriteStruct( "nodes", FileNode::SEQ );
write_tree_nodes( fs ); write_tree_nodes( fs );
cvEndWriteStruct( fs ); fs.endWriteStruct();
__END__; __END__;
} }
CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode ) CvDTreeSplit* CvDTree::read_split( const cv::FileNode& fnode )
{ {
CvDTreeSplit* split = 0; CvDTreeSplit* split = 0;
@ -3930,10 +3935,10 @@ CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode )
int vi, ci; int vi, ci;
if( !fnode || CV_NODE_TYPE(fnode->tag) != CV_NODE_MAP ) if( fnode.empty() || !fnode.isMap() )
CV_ERROR( CV_StsParseError, "some of the splits are not stored properly" ); CV_ERROR( CV_StsParseError, "some of the splits are not stored properly" );
vi = cvReadIntByName( fs, fnode, "var", -1 ); vi = fnode[ "var" ].empty() ? -1 : (int) fnode[ "var" ];
if( (unsigned)vi >= (unsigned)data->var_count ) if( (unsigned)vi >= (unsigned)data->var_count )
CV_ERROR( CV_StsOutOfRange, "Split variable index is out of range" ); CV_ERROR( CV_StsOutOfRange, "Split variable index is out of range" );
@ -3941,23 +3946,23 @@ CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode )
if( ci >= 0 ) // split on categorical var if( ci >= 0 ) // split on categorical var
{ {
int i, n = data->cat_count->data.i[ci], inversed = 0, val; int i, n = data->cat_count->data.i[ci], inversed = 0, val;
CvSeqReader reader; FileNodeIterator reader;
CvFileNode* inseq; cv::FileNode inseq;
split = data->new_split_cat( vi, 0 ); split = data->new_split_cat( vi, 0 );
inseq = cvGetFileNodeByName( fs, fnode, "in" ); inseq = fnode[ "in" ];
if( !inseq ) if( inseq.empty() )
{ {
inseq = cvGetFileNodeByName( fs, fnode, "not_in" ); inseq = fnode[ "not_in" ];
inversed = 1; inversed = 1;
} }
if( !inseq || if( inseq.empty() ||
(CV_NODE_TYPE(inseq->tag) != CV_NODE_SEQ && CV_NODE_TYPE(inseq->tag) != CV_NODE_INT)) (!inseq.isSeq() && !inseq.isInt()))
CV_ERROR( CV_StsParseError, CV_ERROR( CV_StsParseError,
"Either 'in' or 'not_in' tags should be inside a categorical split data" ); "Either 'in' or 'not_in' tags should be inside a categorical split data" );
if( CV_NODE_TYPE(inseq->tag) == CV_NODE_INT ) if( inseq.isInt() )
{ {
val = inseq->data.i; val = (int) inseq;
if( (unsigned)val >= (unsigned)n ) if( (unsigned)val >= (unsigned)n )
CV_ERROR( CV_StsOutOfRange, "some of in/not_in elements are out of range" ); CV_ERROR( CV_StsOutOfRange, "some of in/not_in elements are out of range" );
@ -3965,17 +3970,17 @@ CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode )
} }
else else
{ {
cvStartReadSeq( inseq->data.seq, &reader ); reader = inseq.begin();
for( i = 0; i < reader.seq->total; i++ ) for( i = 0; i < (int) (*reader).size(); i++ )
{ {
CvFileNode* inode = (CvFileNode*)reader.ptr; cv::FileNode inode = *reader;
val = inode->data.i; val = (int) inode;
if( CV_NODE_TYPE(inode->tag) != CV_NODE_INT || (unsigned)val >= (unsigned)n ) if( !inode.isInt() || (unsigned)val >= (unsigned)n )
CV_ERROR( CV_StsOutOfRange, "some of in/not_in elements are out of range" ); CV_ERROR( CV_StsOutOfRange, "some of in/not_in elements are out of range" );
split->subset[val >> 5] |= 1 << (val & 31); split->subset[val >> 5] |= 1 << (val & 31);
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); reader++;
} }
} }
@ -3987,20 +3992,20 @@ CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode )
} }
else else
{ {
CvFileNode* cmp_node; cv::FileNode cmp_node;
split = data->new_split_ord( vi, 0, 0, 0, 0 ); split = data->new_split_ord( vi, 0, 0, 0, 0 );
cmp_node = cvGetFileNodeByName( fs, fnode, "le" ); cmp_node = fnode[ "le" ];
if( !cmp_node ) if( cmp_node.empty() )
{ {
cmp_node = cvGetFileNodeByName( fs, fnode, "gt" ); cmp_node = fnode[ "gt" ];
split->inversed = 1; split->inversed = 1;
} }
split->ord.c = (float)cvReadReal( cmp_node ); split->ord.c = (float) cmp_node;
} }
split->quality = (float)cvReadRealByName( fs, fnode, "quality" ); split->quality = (float) fnode[ "quality" ];
__END__; __END__;
@ -4008,7 +4013,7 @@ CvDTreeSplit* CvDTree::read_split( CvFileStorage* fs, CvFileNode* fnode )
} }
CvDTreeNode* CvDTree::read_node( CvFileStorage* fs, CvFileNode* fnode, CvDTreeNode* parent ) CvDTreeNode* CvDTree::read_node( const cv::FileNode& fnode, CvDTreeNode* parent )
{ {
CvDTreeNode* node = 0; CvDTreeNode* node = 0;
@ -4016,49 +4021,49 @@ CvDTreeNode* CvDTree::read_node( CvFileStorage* fs, CvFileNode* fnode, CvDTreeNo
__BEGIN__; __BEGIN__;
CvFileNode* splits; cv::FileNode splits;
int i, depth; int i, depth;
if( !fnode || CV_NODE_TYPE(fnode->tag) != CV_NODE_MAP ) if( fnode.empty() || !fnode.isMap() )
CV_ERROR( CV_StsParseError, "some of the tree elements are not stored properly" ); CV_ERROR( CV_StsParseError, "some of the tree elements are not stored properly" );
CV_CALL( node = data->new_node( parent, 0, 0, 0 )); CV_CALL( node = data->new_node( parent, 0, 0, 0 ));
depth = cvReadIntByName( fs, fnode, "depth", -1 ); depth = fnode[ "depth" ].empty() ? -1 : (int) fnode[ "depth" ];
if( depth != node->depth ) if( depth != node->depth )
CV_ERROR( CV_StsParseError, "incorrect node depth" ); CV_ERROR( CV_StsParseError, "incorrect node depth" );
node->sample_count = cvReadIntByName( fs, fnode, "sample_count" ); node->sample_count = (int) fnode[ "sample_count" ];
node->value = cvReadRealByName( fs, fnode, "value" ); node->value = (double) fnode[ "value" ];
if( data->is_classifier ) if( data->is_classifier )
node->class_idx = cvReadIntByName( fs, fnode, "norm_class_idx" ); node->class_idx = (int) fnode[ "norm_class_idx" ];
node->Tn = cvReadIntByName( fs, fnode, "Tn" ); node->Tn = (int) fnode[ "Tn" ];
node->complexity = cvReadIntByName( fs, fnode, "complexity" ); node->complexity = (int) fnode[ "complexity" ];
node->alpha = cvReadRealByName( fs, fnode, "alpha" ); node->alpha = (double) fnode[ "alpha" ];
node->node_risk = cvReadRealByName( fs, fnode, "node_risk" ); node->node_risk = (double) fnode[ "node_risk" ];
node->tree_risk = cvReadRealByName( fs, fnode, "tree_risk" ); node->tree_risk = (double) fnode[ "tree_risk" ];
node->tree_error = cvReadRealByName( fs, fnode, "tree_error" ); node->tree_error = (double) fnode[ "tree_error" ];
splits = cvGetFileNodeByName( fs, fnode, "splits" ); splits = fnode[ "splits" ];
if( splits ) if( !splits.empty() )
{ {
CvSeqReader reader; FileNodeIterator reader;
CvDTreeSplit* last_split = 0; CvDTreeSplit* last_split = 0;
if( CV_NODE_TYPE(splits->tag) != CV_NODE_SEQ ) if( !splits.isSeq() )
CV_ERROR( CV_StsParseError, "splits tag must stored as a sequence" ); CV_ERROR( CV_StsParseError, "splits tag must stored as a sequence" );
cvStartReadSeq( splits->data.seq, &reader ); reader = splits.begin();
for( i = 0; i < reader.seq->total; i++ ) for( i = 0; i < (int) (*reader).size(); i++ )
{ {
CvDTreeSplit* split; CvDTreeSplit* split;
CV_CALL( split = read_split( fs, (CvFileNode*)reader.ptr )); CV_CALL( split = read_split( *reader ));
if( !last_split ) if( !last_split )
node->split = last_split = split; node->split = last_split = split;
else else
last_split = last_split->next = split; last_split = last_split->next = split;
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); reader++;
} }
} }
@ -4068,25 +4073,25 @@ CvDTreeNode* CvDTree::read_node( CvFileStorage* fs, CvFileNode* fnode, CvDTreeNo
} }
void CvDTree::read_tree_nodes( CvFileStorage* fs, CvFileNode* fnode ) void CvDTree::read_tree_nodes( const cv::FileNode& fnode )
{ {
CV_FUNCNAME( "CvDTree::read_tree_nodes" ); CV_FUNCNAME( "CvDTree::read_tree_nodes" );
__BEGIN__; __BEGIN__;
CvSeqReader reader; FileNodeIterator reader;
CvDTreeNode _root; CvDTreeNode _root;
CvDTreeNode* parent = &_root; CvDTreeNode* parent = &_root;
int i; int i;
parent->left = parent->right = parent->parent = 0; parent->left = parent->right = parent->parent = 0;
cvStartReadSeq( fnode->data.seq, &reader ); reader = fnode.begin();
for( i = 0; i < reader.seq->total; i++ ) for( i = 0; i < (int) (*reader).size(); i++ )
{ {
CvDTreeNode* node; CvDTreeNode* node;
CV_CALL( node = read_node( fs, (CvFileNode*)reader.ptr, parent != &_root ? parent : 0 )); CV_CALL( node = read_node( *reader, parent != &_root ? parent : 0 ));
if( !parent->left ) if( !parent->left )
parent->left = node; parent->left = node;
else else
@ -4099,7 +4104,7 @@ void CvDTree::read_tree_nodes( CvFileStorage* fs, CvFileNode* fnode )
parent = parent->parent; parent = parent->parent;
} }
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); reader++;
} }
root = _root.left; root = _root.left;
@ -4108,34 +4113,34 @@ void CvDTree::read_tree_nodes( CvFileStorage* fs, CvFileNode* fnode )
} }
void CvDTree::read( CvFileStorage* fs, CvFileNode* fnode ) void CvDTree::read( const cv::FileNode& fnode )
{ {
CvDTreeTrainData* _data = new CvDTreeTrainData(); CvDTreeTrainData* _data = new CvDTreeTrainData();
_data->read_params( fs, fnode ); _data->read_params( fnode );
read( fs, fnode, _data ); read( fnode, _data );
get_var_importance(); get_var_importance();
} }
// a special entry point for reading weak decision trees from the tree ensembles // a special entry point for reading weak decision trees from the tree ensembles
void CvDTree::read( CvFileStorage* fs, CvFileNode* node, CvDTreeTrainData* _data ) void CvDTree::read( const cv::FileNode& node, CvDTreeTrainData* _data )
{ {
CV_FUNCNAME( "CvDTree::read" ); CV_FUNCNAME( "CvDTree::read" );
__BEGIN__; __BEGIN__;
CvFileNode* tree_nodes; cv::FileNode tree_nodes;
clear(); clear();
data = _data; data = _data;
tree_nodes = cvGetFileNodeByName( fs, node, "nodes" ); tree_nodes = node[ "nodes" ];
if( !tree_nodes || CV_NODE_TYPE(tree_nodes->tag) != CV_NODE_SEQ ) if( tree_nodes.empty() || !tree_nodes.isSeq() )
CV_ERROR( CV_StsParseError, "nodes tag is missing" ); CV_ERROR( CV_StsParseError, "nodes tag is missing" );
pruned_tree_idx = cvReadIntByName( fs, node, "best_tree_idx", -1 ); pruned_tree_idx = node[ "best_tree_idx" ].empty() ? -1 : node[ "best_tree_idx" ];
read_tree_nodes( fs, tree_nodes ); read_tree_nodes( tree_nodes );
__END__; __END__;
} }