1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
10 // Intel License Agreement
12 // Copyright (C) 2000, Intel Corporation, all rights reserved.
13 // Third party copyrights are property of their respective owners.
15 // Redistribution and use in source and binary forms, with or without modification,
16 // are permitted provided that the following conditions are met:
18 // * Redistribution's of source code must retain the above copyright notice,
19 // this list of conditions and the following disclaimer.
21 // * Redistribution's in binary form must reproduce the above copyright notice,
22 // this list of conditions and the following disclaimer in the documentation
23 // and/or other materials provided with the distribution.
25 // * The name of Intel Corporation may not be used to endorse or promote products
26 // derived from this software without specific prior written permission.
28 // This software is provided by the copyright holders and contributors "as is" and
29 // any express or implied warranties, including, but not limited to, the implied
30 // warranties of merchantability and fitness for a particular purpose are disclaimed.
31 // In no event shall the Intel Corporation or contributors be liable for any direct,
32 // indirect, incidental, special, exemplary, or consequential damages
33 // (including, but not limited to, procurement of substitute goods or services;
34 // loss of use, data, or profits; or business interruption) however caused
35 // and on any theory of liability, whether in contract, strict liability,
36 // or tort (including negligence or otherwise) arising in any way out of
37 // the use of this software, even if advised of the possibility of such damage.
44 // disable deprecation warning which appears in VisualStudio 8.0
46 #pragma warning( disable : 4996 )
54 #if defined WIN32 || defined WIN64
58 #else // SKIP_INCLUDES
60 #if defined WIN32 || defined WIN64
61 #define CV_CDECL __cdecl
62 #define CV_STDCALL __stdcall
70 #define CV_EXTERN_C extern "C"
71 #define CV_DEFAULT(val) = val
74 #define CV_DEFAULT(val)
78 #ifndef CV_EXTERN_C_FUNCPTR
80 #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; }
82 #define CV_EXTERN_C_FUNCPTR(x) typedef x
87 #if defined __cplusplus
88 #define CV_INLINE inline
89 #elif (defined WIN32 || defined WIN64) && !defined __GNUC__
90 #define CV_INLINE __inline
92 #define CV_INLINE static
94 #endif /* CV_INLINE */
96 #if (defined WIN32 || defined WIN64) && defined CVAPI_EXPORTS
97 #define CV_EXPORTS __declspec(dllexport)
103 #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL
106 #endif // SKIP_INCLUDES
111 // Apple defines a check() macro somewhere in the debug headers
112 // that interferes with a method definiton in this header
115 /****************************************************************************************\
116 * Main struct definitions *
117 \****************************************************************************************/
120 #define CV_LOG2PI (1.8378770664093454835606594728112)
122 /* columns of <trainData> matrix are training samples */
123 #define CV_COL_SAMPLE 0
125 /* rows of <trainData> matrix are training samples */
126 #define CV_ROW_SAMPLE 1
128 #define CV_IS_ROW_SAMPLE(flags) ((flags) & CV_ROW_SAMPLE)
144 /* A structure, representing the lattice range of statmodel parameters.
145 It is used for optimizing statmodel parameters by cross-validation method.
146 The lattice is logarithmic, so <step> must be greater then 1. */
147 typedef struct CvParamLattice
155 CV_INLINE CvParamLattice cvParamLattice( double min_val, double max_val,
159 pl.min_val = MIN( min_val, max_val );
160 pl.max_val = MAX( min_val, max_val );
161 pl.step = MAX( log_step, 1. );
165 CV_INLINE CvParamLattice cvDefaultParamLattice( void )
167 CvParamLattice pl = {0,0,0};
173 #define CV_VAR_NUMERICAL 0
174 #define CV_VAR_ORDERED 0
175 #define CV_VAR_CATEGORICAL 1
177 #define CV_TYPE_NAME_ML_SVM "opencv-ml-svm"
178 #define CV_TYPE_NAME_ML_KNN "opencv-ml-knn"
179 #define CV_TYPE_NAME_ML_NBAYES "opencv-ml-bayesian"
180 #define CV_TYPE_NAME_ML_EM "opencv-ml-em"
181 #define CV_TYPE_NAME_ML_BOOSTING "opencv-ml-boost-tree"
182 #define CV_TYPE_NAME_ML_TREE "opencv-ml-tree"
183 #define CV_TYPE_NAME_ML_ANN_MLP "opencv-ml-ann-mlp"
184 #define CV_TYPE_NAME_ML_CNN "opencv-ml-cnn"
185 #define CV_TYPE_NAME_ML_RTREES "opencv-ml-random-trees"
187 class CV_EXPORTS CvStatModel
191 virtual ~CvStatModel();
193 virtual void clear();
195 virtual void save( const char* filename, const char* name=0 );
196 virtual void load( const char* filename, const char* name=0 );
198 virtual void write( CvFileStorage* storage, const char* name );
199 virtual void read( CvFileStorage* storage, CvFileNode* node );
202 const char* default_model_name;
206 /****************************************************************************************\
207 * Normal Bayes Classifier *
208 \****************************************************************************************/
210 /* The structure, representing the grid range of statmodel parameters.
211 It is used for optimizing statmodel accuracy by varying model parameters,
212 the accuracy estimate being computed by cross-validation.
213 The grid is logarithmic, so <step> must be greater then 1. */
214 struct CV_EXPORTS CvParamGrid
217 enum { SVM_C=0, SVM_GAMMA=1, SVM_P=2, SVM_NU=3, SVM_COEF=4, SVM_DEGREE=5 };
221 min_val = max_val = step = 0;
224 CvParamGrid( double _min_val, double _max_val, double log_step )
230 //CvParamGrid( int param_id );
238 class CV_EXPORTS CvNormalBayesClassifier : public CvStatModel
241 CvNormalBayesClassifier();
242 virtual ~CvNormalBayesClassifier();
244 CvNormalBayesClassifier( const CvMat* _train_data, const CvMat* _responses,
245 const CvMat* _var_idx=0, const CvMat* _sample_idx=0 );
247 virtual bool train( const CvMat* _train_data, const CvMat* _responses,
248 const CvMat* _var_idx = 0, const CvMat* _sample_idx=0, bool update=false );
250 virtual float predict( const CvMat* _samples, CvMat* results=0 ) const;
251 virtual void clear();
253 virtual void write( CvFileStorage* storage, const char* name );
254 virtual void read( CvFileStorage* storage, CvFileNode* node );
257 int var_count, var_all;
264 CvMat** inv_eigen_values;
265 CvMat** cov_rotate_mats;
270 /****************************************************************************************\
271 * K-Nearest Neighbour Classifier *
272 \****************************************************************************************/
274 // k Nearest Neighbors
275 class CV_EXPORTS CvKNearest : public CvStatModel
280 virtual ~CvKNearest();
282 CvKNearest( const CvMat* _train_data, const CvMat* _responses,
283 const CvMat* _sample_idx=0, bool _is_regression=false, int max_k=32 );
285 virtual bool train( const CvMat* _train_data, const CvMat* _responses,
286 const CvMat* _sample_idx=0, bool is_regression=false,
287 int _max_k=32, bool _update_base=false );
289 virtual float find_nearest( const CvMat* _samples, int k, CvMat* results=0,
290 const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const;
292 virtual void clear();
293 int get_max_k() const;
294 int get_var_count() const;
295 int get_sample_count() const;
296 bool is_regression() const;
300 virtual float write_results( int k, int k1, int start, int end,
301 const float* neighbor_responses, const float* dist, CvMat* _results,
302 CvMat* _neighbor_responses, CvMat* _dist, Cv32suf* sort_buf ) const;
304 virtual void find_neighbors_direct( const CvMat* _samples, int k, int start, int end,
305 float* neighbor_responses, const float** neighbors, float* dist ) const;
308 int max_k, var_count;
314 /****************************************************************************************\
315 * Support Vector Machines *
316 \****************************************************************************************/
318 // SVM training parameters
319 struct CV_EXPORTS CvSVMParams
322 CvSVMParams( int _svm_type, int _kernel_type,
323 double _degree, double _gamma, double _coef0,
324 double _C, double _nu, double _p,
325 CvMat* _class_weights, CvTermCriteria _term_crit );
329 double degree; // for poly
330 double gamma; // for poly/rbf/sigmoid
331 double coef0; // for poly/sigmoid
333 double C; // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR
334 double nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR
335 double p; // for CV_SVM_EPS_SVR
336 CvMat* class_weights; // for CV_SVM_C_SVC
337 CvTermCriteria term_crit; // termination criteria
341 struct CV_EXPORTS CvSVMKernel
343 typedef void (CvSVMKernel::*Calc)( int vec_count, int vec_size, const float** vecs,
344 const float* another, float* results );
346 CvSVMKernel( const CvSVMParams* _params, Calc _calc_func );
347 virtual bool create( const CvSVMParams* _params, Calc _calc_func );
348 virtual ~CvSVMKernel();
350 virtual void clear();
351 virtual void calc( int vcount, int n, const float** vecs, const float* another, float* results );
353 const CvSVMParams* params;
356 virtual void calc_non_rbf_base( int vec_count, int vec_size, const float** vecs,
357 const float* another, float* results,
358 double alpha, double beta );
360 virtual void calc_linear( int vec_count, int vec_size, const float** vecs,
361 const float* another, float* results );
362 virtual void calc_rbf( int vec_count, int vec_size, const float** vecs,
363 const float* another, float* results );
364 virtual void calc_poly( int vec_count, int vec_size, const float** vecs,
365 const float* another, float* results );
366 virtual void calc_sigmoid( int vec_count, int vec_size, const float** vecs,
367 const float* another, float* results );
371 struct CvSVMKernelRow
373 CvSVMKernelRow* prev;
374 CvSVMKernelRow* next;
379 struct CvSVMSolutionInfo
383 double upper_bound_p;
384 double upper_bound_n;
385 double r; // for Solver_NU
388 class CV_EXPORTS CvSVMSolver
391 typedef bool (CvSVMSolver::*SelectWorkingSet)( int& i, int& j );
392 typedef float* (CvSVMSolver::*GetRow)( int i, float* row, float* dst, bool existed );
393 typedef void (CvSVMSolver::*CalcRho)( double& rho, double& r );
397 CvSVMSolver( int count, int var_count, const float** samples, char* y,
398 int alpha_count, double* alpha, double Cp, double Cn,
399 CvMemStorage* storage, CvSVMKernel* kernel, GetRow get_row,
400 SelectWorkingSet select_working_set, CalcRho calc_rho );
401 virtual bool create( int count, int var_count, const float** samples, char* y,
402 int alpha_count, double* alpha, double Cp, double Cn,
403 CvMemStorage* storage, CvSVMKernel* kernel, GetRow get_row,
404 SelectWorkingSet select_working_set, CalcRho calc_rho );
405 virtual ~CvSVMSolver();
407 virtual void clear();
408 virtual bool solve_generic( CvSVMSolutionInfo& si );
410 virtual bool solve_c_svc( int count, int var_count, const float** samples, char* y,
411 double Cp, double Cn, CvMemStorage* storage,
412 CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si );
413 virtual bool solve_nu_svc( int count, int var_count, const float** samples, char* y,
414 CvMemStorage* storage, CvSVMKernel* kernel,
415 double* alpha, CvSVMSolutionInfo& si );
416 virtual bool solve_one_class( int count, int var_count, const float** samples,
417 CvMemStorage* storage, CvSVMKernel* kernel,
418 double* alpha, CvSVMSolutionInfo& si );
420 virtual bool solve_eps_svr( int count, int var_count, const float** samples, const float* y,
421 CvMemStorage* storage, CvSVMKernel* kernel,
422 double* alpha, CvSVMSolutionInfo& si );
424 virtual bool solve_nu_svr( int count, int var_count, const float** samples, const float* y,
425 CvMemStorage* storage, CvSVMKernel* kernel,
426 double* alpha, CvSVMSolutionInfo& si );
428 virtual float* get_row_base( int i, bool* _existed );
429 virtual float* get_row( int i, float* dst );
435 const float** samples;
436 const CvSVMParams* params;
437 CvMemStorage* storage;
438 CvSVMKernelRow lru_list;
439 CvSVMKernelRow* rows;
446 // -1 - lower bound, 0 - free, 1 - upper bound
454 double C[2]; // C[0] == Cn, C[1] == Cp
457 SelectWorkingSet select_working_set_func;
458 CalcRho calc_rho_func;
461 virtual bool select_working_set( int& i, int& j );
462 virtual bool select_working_set_nu_svm( int& i, int& j );
463 virtual void calc_rho( double& rho, double& r );
464 virtual void calc_rho_nu_svm( double& rho, double& r );
466 virtual float* get_row_svc( int i, float* row, float* dst, bool existed );
467 virtual float* get_row_one_class( int i, float* row, float* dst, bool existed );
468 virtual float* get_row_svr( int i, float* row, float* dst, bool existed );
472 struct CvSVMDecisionFunc
482 class CV_EXPORTS CvSVM : public CvStatModel
486 enum { C_SVC=100, NU_SVC=101, ONE_CLASS=102, EPS_SVR=103, NU_SVR=104 };
489 enum { LINEAR=0, POLY=1, RBF=2, SIGMOID=3 };
492 enum { C=0, GAMMA=1, P=2, NU=3, COEF=4, DEGREE=5 };
497 CvSVM( const CvMat* _train_data, const CvMat* _responses,
498 const CvMat* _var_idx=0, const CvMat* _sample_idx=0,
499 CvSVMParams _params=CvSVMParams() );
501 virtual bool train( const CvMat* _train_data, const CvMat* _responses,
502 const CvMat* _var_idx=0, const CvMat* _sample_idx=0,
503 CvSVMParams _params=CvSVMParams() );
504 virtual bool train_auto( const CvMat* _train_data, const CvMat* _responses,
505 const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params,
507 CvParamGrid C_grid = get_default_grid(CvSVM::C),
508 CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA),
509 CvParamGrid p_grid = get_default_grid(CvSVM::P),
510 CvParamGrid nu_grid = get_default_grid(CvSVM::NU),
511 CvParamGrid coef_grid = get_default_grid(CvSVM::COEF),
512 CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) );
514 virtual float predict( const CvMat* _sample ) const;
516 virtual int get_support_vector_count() const;
517 virtual const float* get_support_vector(int i) const;
518 virtual CvSVMParams get_params() const { return params; };
519 virtual void clear();
521 static CvParamGrid get_default_grid( int param_id );
523 virtual void write( CvFileStorage* storage, const char* name );
524 virtual void read( CvFileStorage* storage, CvFileNode* node );
525 int get_var_count() const { return var_idx ? var_idx->cols : var_all; }
529 virtual bool set_params( const CvSVMParams& _params );
530 virtual bool train1( int sample_count, int var_count, const float** samples,
531 const void* _responses, double Cp, double Cn,
532 CvMemStorage* _storage, double* alpha, double& rho );
533 virtual bool do_train( int svm_type, int sample_count, int var_count, const float** samples,
534 const CvMat* _responses, CvMemStorage* _storage, double* alpha );
535 virtual void create_kernel();
536 virtual void create_solver();
538 virtual void write_params( CvFileStorage* fs );
539 virtual void read_params( CvFileStorage* fs, CvFileNode* node );
547 CvMat* class_weights;
548 CvSVMDecisionFunc* decision_func;
549 CvMemStorage* storage;
555 /****************************************************************************************\
556 * Expectation - Maximization *
557 \****************************************************************************************/
559 struct CV_EXPORTS CvEMParams
561 CvEMParams() : nclusters(10), cov_mat_type(1/*CvEM::COV_MAT_DIAGONAL*/),
562 start_step(0/*CvEM::START_AUTO_STEP*/), probs(0), weights(0), means(0), covs(0)
564 term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON );
567 CvEMParams( int _nclusters, int _cov_mat_type=1/*CvEM::COV_MAT_DIAGONAL*/,
568 int _start_step=0/*CvEM::START_AUTO_STEP*/,
569 CvTermCriteria _term_crit=cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON),
570 const CvMat* _probs=0, const CvMat* _weights=0, const CvMat* _means=0, const CvMat** _covs=0 ) :
571 nclusters(_nclusters), cov_mat_type(_cov_mat_type), start_step(_start_step),
572 probs(_probs), weights(_weights), means(_means), covs(_covs), term_crit(_term_crit)
579 const CvMat* weights;
582 CvTermCriteria term_crit;
586 class CV_EXPORTS CvEM : public CvStatModel
589 // Type of covariation matrices
590 enum { COV_MAT_SPHERICAL=0, COV_MAT_DIAGONAL=1, COV_MAT_GENERIC=2 };
593 enum { START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0 };
597 // TODO: implement non-default constructor!
598 // see bug 1830346 on the sourceforge bug tracker
599 //CvEM( const CvMat* samples, const CvMat* sample_idx=0,
600 // CvEMParams params=CvEMParams(), CvMat* labels=0 );
603 virtual bool train( const CvMat* samples, const CvMat* sample_idx=0,
604 CvEMParams params=CvEMParams(), CvMat* labels=0 );
606 virtual float predict( const CvMat* sample, CvMat* probs ) const;
607 virtual void clear();
609 int get_nclusters() const;
610 const CvMat* get_means() const;
611 const CvMat** get_covs() const;
612 const CvMat* get_weights() const;
613 const CvMat* get_probs() const;
617 virtual void set_params( const CvEMParams& params,
618 const CvVectors& train_data );
619 virtual void init_em( const CvVectors& train_data );
620 virtual double run_em( const CvVectors& train_data );
621 virtual void init_auto( const CvVectors& samples );
622 virtual void kmeans( const CvVectors& train_data, int nclusters,
623 CvMat* labels, CvTermCriteria criteria,
624 const CvMat* means );
626 double log_likelihood;
633 CvMat* log_weight_div_det;
634 CvMat* inv_eigen_values;
635 CvMat** cov_rotate_mats;
638 /****************************************************************************************\
640 \****************************************************************************************/
649 #define CV_DTREE_CAT_DIR(idx,subset) \
650 (2*((subset[(idx)>>5]&(1 << ((idx) & 31)))==0)-1)
690 // global pruning data
693 double node_risk, tree_risk, tree_error;
695 // cross-validation pruning data
697 double* cv_node_risk;
698 double* cv_node_error;
700 int get_num_valid(int vi) { return num_valid ? num_valid[vi] : sample_count; }
701 void set_num_valid(int vi, int n) { if( num_valid ) num_valid[vi] = n; }
705 struct CV_EXPORTS CvDTreeParams
709 int min_sample_count;
713 bool truncate_pruned_tree;
714 float regression_accuracy;
717 CvDTreeParams() : max_categories(10), max_depth(INT_MAX), min_sample_count(10),
718 cv_folds(10), use_surrogates(true), use_1se_rule(true),
719 truncate_pruned_tree(true), regression_accuracy(0.01f), priors(0)
722 CvDTreeParams( int _max_depth, int _min_sample_count,
723 float _regression_accuracy, bool _use_surrogates,
724 int _max_categories, int _cv_folds,
725 bool _use_1se_rule, bool _truncate_pruned_tree,
726 const float* _priors ) :
727 max_categories(_max_categories), max_depth(_max_depth),
728 min_sample_count(_min_sample_count), cv_folds (_cv_folds),
729 use_surrogates(_use_surrogates), use_1se_rule(_use_1se_rule),
730 truncate_pruned_tree(_truncate_pruned_tree),
731 regression_accuracy(_regression_accuracy),
737 struct CV_EXPORTS CvDTreeTrainData
740 CvDTreeTrainData( const CvMat* _train_data, int _tflag,
741 const CvMat* _responses, const CvMat* _var_idx=0,
742 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
743 const CvMat* _missing_mask=0,
744 const CvDTreeParams& _params=CvDTreeParams(),
745 bool _shared=false, bool _add_labels=false );
746 virtual ~CvDTreeTrainData();
748 virtual void set_data( const CvMat* _train_data, int _tflag,
749 const CvMat* _responses, const CvMat* _var_idx=0,
750 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
751 const CvMat* _missing_mask=0,
752 const CvDTreeParams& _params=CvDTreeParams(),
753 bool _shared=false, bool _add_labels=false,
754 bool _update_data=false );
756 virtual void get_vectors( const CvMat* _subsample_idx,
757 float* values, uchar* missing, float* responses, bool get_class_idx=false );
759 virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx );
761 virtual void write_params( CvFileStorage* fs );
762 virtual void read_params( CvFileStorage* fs, CvFileNode* node );
764 // release all the data
765 virtual void clear();
767 int get_num_classes() const;
768 int get_var_type(int vi) const;
769 int get_work_var_count() const;
771 virtual int* get_class_labels( CvDTreeNode* n );
772 virtual float* get_ord_responses( CvDTreeNode* n );
773 virtual int* get_labels( CvDTreeNode* n );
774 virtual int* get_cat_var_data( CvDTreeNode* n, int vi );
775 virtual CvPair32s32f* get_ord_var_data( CvDTreeNode* n, int vi );
776 virtual int get_child_buf_idx( CvDTreeNode* n );
778 ////////////////////////////////////
780 virtual bool set_params( const CvDTreeParams& params );
781 virtual CvDTreeNode* new_node( CvDTreeNode* parent, int count,
782 int storage_idx, int offset );
784 virtual CvDTreeSplit* new_split_ord( int vi, float cmp_val,
785 int split_point, int inversed, float quality );
786 virtual CvDTreeSplit* new_split_cat( int vi, float quality );
787 virtual void free_node_data( CvDTreeNode* node );
788 virtual void free_train_data();
789 virtual void free_node( CvDTreeNode* node );
791 int sample_count, var_all, var_count, max_c_count;
792 int ord_var_count, cat_var_count;
793 bool have_labels, have_priors;
796 int buf_count, buf_size;
809 CvMat* var_type; // i-th element =
811 // k>=0 - categorical, see k-th element of cat_* arrays
815 CvDTreeParams params;
817 CvMemStorage* tree_storage;
818 CvMemStorage* temp_storage;
820 CvDTreeNode* data_root;
831 class CV_EXPORTS CvDTree : public CvStatModel
837 virtual bool train( const CvMat* _train_data, int _tflag,
838 const CvMat* _responses, const CvMat* _var_idx=0,
839 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
840 const CvMat* _missing_mask=0,
841 CvDTreeParams params=CvDTreeParams() );
843 virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx );
845 virtual CvDTreeNode* predict( const CvMat* _sample, const CvMat* _missing_data_mask=0,
846 bool preprocessed_input=false ) const;
847 virtual const CvMat* get_var_importance();
848 virtual void clear();
850 virtual void read( CvFileStorage* fs, CvFileNode* node );
851 virtual void write( CvFileStorage* fs, const char* name );
853 // special read & write methods for trees in the tree ensembles
854 virtual void read( CvFileStorage* fs, CvFileNode* node,
855 CvDTreeTrainData* data );
856 virtual void write( CvFileStorage* fs );
858 const CvDTreeNode* get_root() const;
859 int get_pruned_tree_idx() const;
860 CvDTreeTrainData* get_data();
864 virtual bool do_train( const CvMat* _subsample_idx );
866 virtual void try_split_node( CvDTreeNode* n );
867 virtual void split_node_data( CvDTreeNode* n );
868 virtual CvDTreeSplit* find_best_split( CvDTreeNode* n );
869 virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi );
870 virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi );
871 virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi );
872 virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi );
873 virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi );
874 virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi );
875 virtual double calc_node_dir( CvDTreeNode* node );
876 virtual void complete_node_dir( CvDTreeNode* node );
877 virtual void cluster_categories( const int* vectors, int vector_count,
878 int var_count, int* sums, int k, int* cluster_labels );
880 virtual void calc_node_value( CvDTreeNode* node );
882 virtual void prune_cv();
883 virtual double update_tree_rnc( int T, int fold );
884 virtual int cut_tree( int T, int fold, double min_alpha );
885 virtual void free_prune_data(bool cut_tree);
886 virtual void free_tree();
888 virtual void write_node( CvFileStorage* fs, CvDTreeNode* node );
889 virtual void write_split( CvFileStorage* fs, CvDTreeSplit* split );
890 virtual CvDTreeNode* read_node( CvFileStorage* fs, CvFileNode* node, CvDTreeNode* parent );
891 virtual CvDTreeSplit* read_split( CvFileStorage* fs, CvFileNode* node );
892 virtual void write_tree_nodes( CvFileStorage* fs );
893 virtual void read_tree_nodes( CvFileStorage* fs, CvFileNode* node );
898 CvMat* var_importance;
900 CvDTreeTrainData* data;
904 /****************************************************************************************\
905 * Random Trees Classifier *
906 \****************************************************************************************/
910 class CV_EXPORTS CvForestTree: public CvDTree
914 virtual ~CvForestTree();
916 virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx, CvRTrees* forest );
918 virtual int get_var_count() const {return data ? data->var_count : 0;}
919 virtual void read( CvFileStorage* fs, CvFileNode* node, CvRTrees* forest, CvDTreeTrainData* _data );
921 /* dummy methods to avoid warnings: BEGIN */
922 virtual bool train( const CvMat* _train_data, int _tflag,
923 const CvMat* _responses, const CvMat* _var_idx=0,
924 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
925 const CvMat* _missing_mask=0,
926 CvDTreeParams params=CvDTreeParams() );
928 virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx );
929 virtual void read( CvFileStorage* fs, CvFileNode* node );
930 virtual void read( CvFileStorage* fs, CvFileNode* node,
931 CvDTreeTrainData* data );
932 /* dummy methods to avoid warnings: END */
935 virtual CvDTreeSplit* find_best_split( CvDTreeNode* n );
940 struct CV_EXPORTS CvRTParams : public CvDTreeParams
942 //Parameters for the forest
943 bool calc_var_importance; // true <=> RF processes variable importance
945 CvTermCriteria term_crit;
947 CvRTParams() : CvDTreeParams( 5, 10, 0, false, 10, 0, false, false, 0 ),
948 calc_var_importance(false), nactive_vars(0)
950 term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 50, 0.1 );
953 CvRTParams( int _max_depth, int _min_sample_count,
954 float _regression_accuracy, bool _use_surrogates,
955 int _max_categories, const float* _priors, bool _calc_var_importance,
956 int _nactive_vars, int max_num_of_trees_in_the_forest,
957 float forest_accuracy, int termcrit_type ) :
958 CvDTreeParams( _max_depth, _min_sample_count, _regression_accuracy,
959 _use_surrogates, _max_categories, 0,
960 false, false, _priors ),
961 calc_var_importance(_calc_var_importance),
962 nactive_vars(_nactive_vars)
964 term_crit = cvTermCriteria(termcrit_type,
965 max_num_of_trees_in_the_forest, forest_accuracy);
970 class CV_EXPORTS CvRTrees : public CvStatModel
975 virtual bool train( const CvMat* _train_data, int _tflag,
976 const CvMat* _responses, const CvMat* _var_idx=0,
977 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
978 const CvMat* _missing_mask=0,
979 CvRTParams params=CvRTParams() );
980 virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) const;
981 virtual void clear();
983 virtual const CvMat* get_var_importance();
984 virtual float get_proximity( const CvMat* sample1, const CvMat* sample2,
985 const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const;
987 virtual void read( CvFileStorage* fs, CvFileNode* node );
988 virtual void write( CvFileStorage* fs, const char* name );
990 CvMat* get_active_var_mask();
993 int get_tree_count() const;
994 CvForestTree* get_tree(int i) const;
998 bool grow_forest( const CvTermCriteria term_crit );
1000 // array of the trees of the forest
1001 CvForestTree** trees;
1002 CvDTreeTrainData* data;
1006 CvMat* var_importance;
1010 CvMat* active_var_mask;
1014 /****************************************************************************************\
1015 * Boosted tree classifier *
1016 \****************************************************************************************/
1018 struct CV_EXPORTS CvBoostParams : public CvDTreeParams
1023 double weight_trim_rate;
1026 CvBoostParams( int boost_type, int weak_count, double weight_trim_rate,
1027 int max_depth, bool use_surrogates, const float* priors );
1033 class CV_EXPORTS CvBoostTree: public CvDTree
1037 virtual ~CvBoostTree();
1039 virtual bool train( CvDTreeTrainData* _train_data,
1040 const CvMat* subsample_idx, CvBoost* ensemble );
1042 virtual void scale( double s );
1043 virtual void read( CvFileStorage* fs, CvFileNode* node,
1044 CvBoost* ensemble, CvDTreeTrainData* _data );
1045 virtual void clear();
1047 /* dummy methods to avoid warnings: BEGIN */
1048 virtual bool train( const CvMat* _train_data, int _tflag,
1049 const CvMat* _responses, const CvMat* _var_idx=0,
1050 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
1051 const CvMat* _missing_mask=0,
1052 CvDTreeParams params=CvDTreeParams() );
1054 virtual bool train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx );
1055 virtual void read( CvFileStorage* fs, CvFileNode* node );
1056 virtual void read( CvFileStorage* fs, CvFileNode* node,
1057 CvDTreeTrainData* data );
1058 /* dummy methods to avoid warnings: END */
1062 virtual void try_split_node( CvDTreeNode* n );
1063 virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi );
1064 virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi );
1065 virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi );
1066 virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi );
1067 virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi );
1068 virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi );
1069 virtual void calc_node_value( CvDTreeNode* n );
1070 virtual double calc_node_dir( CvDTreeNode* n );
1076 class CV_EXPORTS CvBoost : public CvStatModel
1080 enum { DISCRETE=0, REAL=1, LOGIT=2, GENTLE=3 };
1082 // Splitting criteria
1083 enum { DEFAULT=0, GINI=1, MISCLASS=3, SQERR=4 };
1088 CvBoost( const CvMat* _train_data, int _tflag,
1089 const CvMat* _responses, const CvMat* _var_idx=0,
1090 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
1091 const CvMat* _missing_mask=0,
1092 CvBoostParams params=CvBoostParams() );
1094 virtual bool train( const CvMat* _train_data, int _tflag,
1095 const CvMat* _responses, const CvMat* _var_idx=0,
1096 const CvMat* _sample_idx=0, const CvMat* _var_type=0,
1097 const CvMat* _missing_mask=0,
1098 CvBoostParams params=CvBoostParams(),
1099 bool update=false );
1101 virtual float predict( const CvMat* _sample, const CvMat* _missing=0,
1102 CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ,
1103 bool raw_mode=false ) const;
1105 virtual void prune( CvSlice slice );
1107 virtual void clear();
1109 virtual void write( CvFileStorage* storage, const char* name );
1110 virtual void read( CvFileStorage* storage, CvFileNode* node );
1112 CvSeq* get_weak_predictors();
1114 CvMat* get_weights();
1115 CvMat* get_subtree_weights();
1116 CvMat* get_weak_response();
1117 const CvBoostParams& get_params() const;
1121 virtual bool set_params( const CvBoostParams& _params );
1122 virtual void update_weights( CvBoostTree* tree );
1123 virtual void trim_weights();
1124 virtual void write_params( CvFileStorage* fs );
1125 virtual void read_params( CvFileStorage* fs, CvFileNode* node );
1127 CvDTreeTrainData* data;
1128 CvBoostParams params;
1131 CvMat* orig_response;
1132 CvMat* sum_response;
1134 CvMat* subsample_mask;
1136 CvMat* subtree_weights;
1137 bool have_subsample;
1141 /****************************************************************************************\
1142 * Artificial Neural Networks (ANN) *
1143 \****************************************************************************************/
1145 /////////////////////////////////// Multi-Layer Perceptrons //////////////////////////////
1147 struct CV_EXPORTS CvANN_MLP_TrainParams
1149 CvANN_MLP_TrainParams();
1150 CvANN_MLP_TrainParams( CvTermCriteria term_crit, int train_method,
1151 double param1, double param2=0 );
1152 ~CvANN_MLP_TrainParams();
1154 enum { BACKPROP=0, RPROP=1 };
1156 CvTermCriteria term_crit;
1159 // backpropagation parameters
1160 double bp_dw_scale, bp_moment_scale;
1163 double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max;
1167 class CV_EXPORTS CvANN_MLP : public CvStatModel
1171 CvANN_MLP( const CvMat* _layer_sizes,
1172 int _activ_func=SIGMOID_SYM,
1173 double _f_param1=0, double _f_param2=0 );
1175 virtual ~CvANN_MLP();
1177 virtual void create( const CvMat* _layer_sizes,
1178 int _activ_func=SIGMOID_SYM,
1179 double _f_param1=0, double _f_param2=0 );
1181 virtual int train( const CvMat* _inputs, const CvMat* _outputs,
1182 const CvMat* _sample_weights, const CvMat* _sample_idx=0,
1183 CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(),
1185 virtual float predict( const CvMat* _inputs,
1186 CvMat* _outputs ) const;
1188 virtual void clear();
1190 // possible activation functions
1191 enum { IDENTITY = 0, SIGMOID_SYM = 1, GAUSSIAN = 2 };
1193 // available training flags
1194 enum { UPDATE_WEIGHTS = 1, NO_INPUT_SCALE = 2, NO_OUTPUT_SCALE = 4 };
1196 virtual void read( CvFileStorage* fs, CvFileNode* node );
1197 virtual void write( CvFileStorage* storage, const char* name );
1199 int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; }
1200 const CvMat* get_layer_sizes() { return layer_sizes; }
1201 double* get_weights(int layer)
1203 return layer_sizes && weights &&
1204 (unsigned)layer <= (unsigned)layer_sizes->cols ? weights[layer] : 0;
1209 virtual bool prepare_to_train( const CvMat* _inputs, const CvMat* _outputs,
1210 const CvMat* _sample_weights, const CvMat* _sample_idx,
1211 CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags );
1213 // sequential random backpropagation
1214 virtual int train_backprop( CvVectors _ivecs, CvVectors _ovecs, const double* _sw );
1217 virtual int train_rprop( CvVectors _ivecs, CvVectors _ovecs, const double* _sw );
1219 virtual void calc_activ_func( CvMat* xf, const double* bias ) const;
1220 virtual void calc_activ_func_deriv( CvMat* xf, CvMat* deriv, const double* bias ) const;
1221 virtual void set_activ_func( int _activ_func=SIGMOID_SYM,
1222 double _f_param1=0, double _f_param2=0 );
1223 virtual void init_weights();
1224 virtual void scale_input( const CvMat* _src, CvMat* _dst ) const;
1225 virtual void scale_output( const CvMat* _src, CvMat* _dst ) const;
1226 virtual void calc_input_scale( const CvVectors* vecs, int flags );
1227 virtual void calc_output_scale( const CvVectors* vecs, int flags );
1229 virtual void write_params( CvFileStorage* fs );
1230 virtual void read_params( CvFileStorage* fs, CvFileNode* node );
1234 CvMat* sample_weights;
1236 double f_param1, f_param2;
1237 double min_val, max_val, min_val1, max_val1;
1239 int max_count, max_buf_sz;
1240 CvANN_MLP_TrainParams params;
1245 /****************************************************************************************\
1246 * Convolutional Neural Network *
1247 \****************************************************************************************/
1248 typedef struct CvCNNLayer CvCNNLayer;
1249 typedef struct CvCNNetwork CvCNNetwork;
1251 #define CV_CNN_LEARN_RATE_DECREASE_HYPERBOLICALLY 1
1252 #define CV_CNN_LEARN_RATE_DECREASE_SQRT_INV 2
1253 #define CV_CNN_LEARN_RATE_DECREASE_LOG_INV 3
1255 #define CV_CNN_GRAD_ESTIM_RANDOM 0
1256 #define CV_CNN_GRAD_ESTIM_BY_WORST_IMG 1
1258 #define ICV_CNN_LAYER 0x55550000
1259 #define ICV_CNN_CONVOLUTION_LAYER 0x00001111
1260 #define ICV_CNN_SUBSAMPLING_LAYER 0x00002222
1261 #define ICV_CNN_FULLCONNECT_LAYER 0x00003333
1263 #define ICV_IS_CNN_LAYER( layer ) \
1264 ( ((layer) != NULL) && ((((CvCNNLayer*)(layer))->flags & CV_MAGIC_MASK)\
1267 #define ICV_IS_CNN_CONVOLUTION_LAYER( layer ) \
1268 ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \
1269 & ~CV_MAGIC_MASK) == ICV_CNN_CONVOLUTION_LAYER )
1271 #define ICV_IS_CNN_SUBSAMPLING_LAYER( layer ) \
1272 ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \
1273 & ~CV_MAGIC_MASK) == ICV_CNN_SUBSAMPLING_LAYER )
1275 #define ICV_IS_CNN_FULLCONNECT_LAYER( layer ) \
1276 ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \
1277 & ~CV_MAGIC_MASK) == ICV_CNN_FULLCONNECT_LAYER )
1279 typedef void (CV_CDECL *CvCNNLayerForward)
1280 ( CvCNNLayer* layer, const CvMat* input, CvMat* output );
1282 typedef void (CV_CDECL *CvCNNLayerBackward)
1283 ( CvCNNLayer* layer, int t, const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX );
1285 typedef void (CV_CDECL *CvCNNLayerRelease)
1286 (CvCNNLayer** layer);
1288 typedef void (CV_CDECL *CvCNNetworkAddLayer)
1289 (CvCNNetwork* network, CvCNNLayer* layer);
1291 typedef void (CV_CDECL *CvCNNetworkRelease)
1292 (CvCNNetwork** network);
1294 #define CV_CNN_LAYER_FIELDS() \
1295 /* Indicator of the layer's type */ \
1298 /* Number of input images */ \
1299 int n_input_planes; \
1300 /* Height of each input image */ \
1302 /* Width of each input image */ \
1305 /* Number of output images */ \
1306 int n_output_planes; \
1307 /* Height of each output image */ \
1308 int output_height; \
1309 /* Width of each output image */ \
1312 /* Learning rate at the first iteration */ \
1313 float init_learn_rate; \
1314 /* Dynamics of learning rate decreasing */ \
1315 int learn_rate_decrease_type; \
1316 /* Trainable weights of the layer (including bias) */ \
1317 /* i-th row is a set of weights of the i-th output plane */ \
1320 CvCNNLayerForward forward; \
1321 CvCNNLayerBackward backward; \
1322 CvCNNLayerRelease release; \
1323 /* Pointers to the previous and next layers in the network */ \
1324 CvCNNLayer* prev_layer; \
1325 CvCNNLayer* next_layer
1327 typedef struct CvCNNLayer
1329 CV_CNN_LAYER_FIELDS();
1332 typedef struct CvCNNConvolutionLayer
1334 CV_CNN_LAYER_FIELDS();
1335 // Kernel size (height and width) for convolution.
1337 // connections matrix, (i,j)-th element is 1 iff there is a connection between
1338 // i-th plane of the current layer and j-th plane of the previous layer;
1339 // (i,j)-th element is equal to 0 otherwise
1340 CvMat *connect_mask;
1341 // value of the learning rate for updating weights at the first iteration
1342 }CvCNNConvolutionLayer;
1344 typedef struct CvCNNSubSamplingLayer
1346 CV_CNN_LAYER_FIELDS();
1347 // ratio between the heights (or widths - ratios are supposed to be equal)
1348 // of the input and output planes
1350 // amplitude of sigmoid activation function
1352 // scale parameter of sigmoid activation function
1354 // exp2ssumWX = exp(2<s>*(bias+w*(x1+...+x4))), where x1,...x4 are some elements of X
1355 // - is the vector used in computing of the activation function in backward
1357 // (x1+x2+x3+x4), where x1,...x4 are some elements of X
1358 // - is the vector used in computing of the activation function in backward
1360 }CvCNNSubSamplingLayer;
1362 // Structure of the last layer.
1363 typedef struct CvCNNFullConnectLayer
1365 CV_CNN_LAYER_FIELDS();
1366 // amplitude of sigmoid activation function
1368 // scale parameter of sigmoid activation function
1370 // exp2ssumWX = exp(2*<s>*(W*X)) - is the vector used in computing of the
1371 // activation function and it's derivative by the formulae
1372 // activ.func. = <a>(exp(2<s>WX)-1)/(exp(2<s>WX)+1) == <a> - 2<a>/(<exp2ssumWX> + 1)
1373 // (activ.func.)' = 4<a><s>exp(2<s>WX)/(exp(2<s>WX)+1)^2
1375 }CvCNNFullConnectLayer;
1377 typedef struct CvCNNetwork
1381 CvCNNetworkAddLayer add_layer;
1382 CvCNNetworkRelease release;
1385 typedef struct CvCNNStatModel
1387 CV_STAT_MODEL_FIELDS();
1388 CvCNNetwork* network;
1389 // etalons are allocated as rows, the i-th etalon has label cls_labeles[i]
1395 typedef struct CvCNNStatModelParams
1397 CV_STAT_MODEL_PARAM_FIELDS();
1398 // network must be created by the functions cvCreateCNNetwork and <add_layer>
1399 CvCNNetwork* network;
1401 // termination criteria
1404 int grad_estim_type;
1405 }CvCNNStatModelParams;
1407 CVAPI(CvCNNLayer*) cvCreateCNNConvolutionLayer(
1408 int n_input_planes, int input_height, int input_width,
1409 int n_output_planes, int K,
1410 float init_learn_rate, int learn_rate_decrease_type,
1411 CvMat* connect_mask CV_DEFAULT(0), CvMat* weights CV_DEFAULT(0) );
1413 CVAPI(CvCNNLayer*) cvCreateCNNSubSamplingLayer(
1414 int n_input_planes, int input_height, int input_width,
1415 int sub_samp_scale, float a, float s,
1416 float init_learn_rate, int learn_rate_decrease_type, CvMat* weights CV_DEFAULT(0) );
1418 CVAPI(CvCNNLayer*) cvCreateCNNFullConnectLayer(
1419 int n_inputs, int n_outputs, float a, float s,
1420 float init_learn_rate, int learning_type, CvMat* weights CV_DEFAULT(0) );
1422 CVAPI(CvCNNetwork*) cvCreateCNNetwork( CvCNNLayer* first_layer );
1424 CVAPI(CvStatModel*) cvTrainCNNClassifier(
1425 const CvMat* train_data, int tflag,
1426 const CvMat* responses,
1427 const CvStatModelParams* params,
1428 const CvMat* CV_DEFAULT(0),
1429 const CvMat* sample_idx CV_DEFAULT(0),
1430 const CvMat* CV_DEFAULT(0), const CvMat* CV_DEFAULT(0) );
1432 /****************************************************************************************\
1433 * Estimate classifiers algorithms *
1434 \****************************************************************************************/
1435 typedef const CvMat* (CV_CDECL *CvStatModelEstimateGetMat)
1436 ( const CvStatModel* estimateModel );
1438 typedef int (CV_CDECL *CvStatModelEstimateNextStep)
1439 ( CvStatModel* estimateModel );
1441 typedef void (CV_CDECL *CvStatModelEstimateCheckClassifier)
1442 ( CvStatModel* estimateModel,
1443 const CvStatModel* model,
1444 const CvMat* features,
1446 const CvMat* responses );
1448 typedef void (CV_CDECL *CvStatModelEstimateCheckClassifierEasy)
1449 ( CvStatModel* estimateModel,
1450 const CvStatModel* model );
1452 typedef float (CV_CDECL *CvStatModelEstimateGetCurrentResult)
1453 ( const CvStatModel* estimateModel,
1454 float* correlation );
1456 typedef void (CV_CDECL *CvStatModelEstimateReset)
1457 ( CvStatModel* estimateModel );
1459 //-------------------------------- Cross-validation --------------------------------------
1460 #define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS() \
1461 CV_STAT_MODEL_PARAM_FIELDS(); \
1463 int is_regression; \
1466 typedef struct CvCrossValidationParams
1468 CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS();
1469 } CvCrossValidationParams;
1471 #define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS() \
1472 CvStatModelEstimateGetMat getTrainIdxMat; \
1473 CvStatModelEstimateGetMat getCheckIdxMat; \
1474 CvStatModelEstimateNextStep nextStep; \
1475 CvStatModelEstimateCheckClassifier check; \
1476 CvStatModelEstimateGetCurrentResult getResult; \
1477 CvStatModelEstimateReset reset; \
1478 int is_regression; \
1481 int* sampleIdxAll; \
1483 int max_fold_size; \
1486 CvMat* sampleIdxTrain; \
1487 CvMat* sampleIdxEval; \
1488 CvMat* predict_results; \
1489 int correct_results; \
1492 double sum_correct; \
1493 double sum_predict; \
1498 typedef struct CvCrossValidationModel
1500 CV_STAT_MODEL_FIELDS();
1501 CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS();
1502 } CvCrossValidationModel;
1505 cvCreateCrossValidationEstimateModel
1507 const CvStatModelParams* estimateParams CV_DEFAULT(0),
1508 const CvMat* sampleIdx CV_DEFAULT(0) );
1511 cvCrossValidation( const CvMat* trueData,
1513 const CvMat* trueClasses,
1514 CvStatModel* (*createClassifier)( const CvMat*,
1517 const CvStatModelParams*,
1522 const CvStatModelParams* estimateParams CV_DEFAULT(0),
1523 const CvStatModelParams* trainParams CV_DEFAULT(0),
1524 const CvMat* compIdx CV_DEFAULT(0),
1525 const CvMat* sampleIdx CV_DEFAULT(0),
1526 CvStatModel** pCrValModel CV_DEFAULT(0),
1527 const CvMat* typeMask CV_DEFAULT(0),
1528 const CvMat* missedMeasurementMask CV_DEFAULT(0) );
1531 /****************************************************************************************\
1532 * Auxilary functions declarations *
1533 \****************************************************************************************/
1535 /* Generates <sample> from multivariate normal distribution, where <mean> - is an
1536 average row vector, <cov> - symmetric covariation matrix */
1537 CVAPI(void) cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample,
1538 CvRNG* rng CV_DEFAULT(0) );
1540 /* Generates sample from gaussian mixture distribution */
1541 CVAPI(void) cvRandGaussMixture( CvMat* means[],
1546 CvMat* sampClasses CV_DEFAULT(0) );
1548 #define CV_TS_CONCENTRIC_SPHERES 0
1550 /* creates test set */
1551 CVAPI(void) cvCreateTestSet( int type, CvMat** samples,
1555 int num_classes, ... );
1557 /* Aij <- Aji for i > j if lower_to_upper != 0
1558 for i < j if lower_to_upper = 0 */
1559 CVAPI(void) cvCompleteSymm( CvMat* matrix, int lower_to_upper );