// **************************************************************************************************
// Project Delphi-OpenCV
// **************************************************************************************************
// Contributors:
// Laentir Valetov
// email:laex@bk.ru
// Mikhail Grigorev
// Email: sleuthhound@gmail.com
// **************************************************************************************************
// You may retrieve the latest version of this file at the GitHub,
// located at git://github.com/Laex/Delphi-OpenCV.git
// **************************************************************************************************
// License:
// The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License");
// you may not use this file except in compliance with the License. You may obtain a copy of the
// License at http://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
// ANY KIND, either express or implied. See the License for the specific language governing rights
// and limitations under the License.
//
// Alternatively, the contents of this file may be used under the terms of the
// GNU Lesser General Public License (the  "LGPL License"), in which case the
// provisions of the LGPL License are applicable instead of those above.
// If you wish to allow use of your version of this file only under the terms
// of the LGPL License and not to allow others to use your version of this file
// under the MPL, indicate your decision by deleting  the provisions above and
// replace  them with the notice and other provisions required by the LGPL
// License.  If you do not delete the provisions above, a recipient may use
// your version of this file under either the MPL or the LGPL License.
//
// For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html
// **************************************************************************************************
// The Initial Developer of the Original Code:
// OpenCV: open source computer vision library
// Homepage:    http://ocv.org
// Online docs: http://docs.ocv.org
// Q&A forum:   http://answers.ocv.org
// Dev zone:    http://code.ocv.org
// **************************************************************************************************
// Original file:
// opencv\modules\ml\include\opencv2\ml.hpp
// *************************************************************************************************

unit ocv.ml;

{$POINTERMATH ON}

interface

Uses
  WinApi.Windows,
  ocv.core.types_c;

/// ****************************************************************************************\
// *                               Main struct definitions                                  *
// \****************************************************************************************/
//
/// * log(2*PI) */
// #define CV_LOG2PI (1.8378770664093454835606594728112)
//
/// * columns of <trainData> matrix are training samples */
// #define CV_COL_SAMPLE 0
//
/// * rows of <trainData> matrix are training samples */
// #define CV_ROW_SAMPLE 1
//
// #define CV_IS_ROW_SAMPLE(flags) ((flags) & CV_ROW_SAMPLE)
//
// struct CvVectors
// {
// int type;
// int dims, count;
// CvVectors* next;
// union
// {
// uchar** ptr;
// float** fl;
// double** db;
// } data;
// };
//
// #if 0
/// * A structure, representing the lattice range of statmodel parameters.
// It is used for optimizing statmodel parameters by cross-validation method.
// The lattice is logarithmic, so <step> must be greater then 1. */
// typedef struct CvParamLattice
// {
// double min_val;
// double max_val;
// double step;
// }
// CvParamLattice;
//
// CV_INLINE CvParamLattice cvParamLattice( double min_val, double max_val,
// double log_step )
// {
// CvParamLattice pl;
// pl.min_val = MIN( min_val, max_val );
// pl.max_val = MAX( min_val, max_val );
// pl.step = MAX( log_step, 1. );
// return pl;
// }
//
// CV_INLINE CvParamLattice cvDefaultParamLattice( void )
// {
// CvParamLattice pl = {0,0,0};
// return pl;
// }
// #endif

const
  /// * Variable type */
  CV_VAR_NUMERICAL   = 0;
  CV_VAR_ORDERED     = 0;
  CV_VAR_CATEGORICAL = 1;

  //
  // #define CV_TYPE_NAME_ML_SVM         "opencv-ml-svm"
  // #define CV_TYPE_NAME_ML_KNN         "opencv-ml-knn"
  // #define CV_TYPE_NAME_ML_NBAYES      "opencv-ml-bayesian"
  // #define CV_TYPE_NAME_ML_EM          "opencv-ml-em"
  // #define CV_TYPE_NAME_ML_BOOSTING    "opencv-ml-boost-tree"
  // #define CV_TYPE_NAME_ML_TREE        "opencv-ml-tree"
  // #define CV_TYPE_NAME_ML_ANN_MLP     "opencv-ml-ann-mlp"
  // #define CV_TYPE_NAME_ML_CNN         "opencv-ml-cnn"
  // #define CV_TYPE_NAME_ML_RTREES      "opencv-ml-random-trees"
  // #define CV_TYPE_NAME_ML_ERTREES     "opencv-ml-extremely-randomized-trees"
  // #define CV_TYPE_NAME_ML_GBT         "opencv-ml-gradient-boosting-trees"
  //
  // #define CV_TRAIN_ERROR  0
  // #define CV_TEST_ERROR   1
  //
  // class CV_EXPORTS_W CvStatModel
  // {
  // public:
  // CvStatModel();
  // virtual ~CvStatModel();
  //
  // virtual void clear();
  //
  // CV_WRAP virtual void save( const char* filename, const char* name=0 ) const;
  // CV_WRAP virtual void load( const char* filename, const char* name=0 );
  //
  // virtual void write( CvFileStorage* storage, const char* name ) const;
  // virtual void read( CvFileStorage* storage, CvFileNode* node );
  //
  // protected:
  // const char* default_model_name;
  // };
  //
  /// ****************************************************************************************\
  // *                                 Normal Bayes Classifier                                *
  // \****************************************************************************************/
  //
  /// * The structure, representing the grid range of statmodel parameters.
  // It is used for optimizing statmodel accuracy by varying model parameters,
  // the accuracy estimate being computed by cross-validation.
  // The grid is logarithmic, so <step> must be greater then 1. */
  //
  // class CvMLData;
  //
  // struct CV_EXPORTS_W_MAP CvParamGrid
  // {
  // // SVM params type
  // enum { SVM_C=0, SVM_GAMMA=1, SVM_P=2, SVM_NU=3, SVM_COEF=4, SVM_DEGREE=5 };
  //
  // CvParamGrid()
  // {
  // min_val = max_val = step = 0;
  // }
  //
  // CvParamGrid( double min_val, double max_val, double log_step );
  // //CvParamGrid( int param_id );
  // bool check() const;
  //
  // CV_PROP_RW double min_val;
  // CV_PROP_RW double max_val;
  // CV_PROP_RW double step;
  // };
  //
  // inline CvParamGrid::CvParamGrid( double _min_val, double _max_val, double _log_step )
  // {
  // min_val = _min_val;
  // max_val = _max_val;
  // step = _log_step;
  // }
  //
  // class CV_EXPORTS_W CvNormalBayesClassifier : public CvStatModel
  // {
  // public:
  // CV_WRAP CvNormalBayesClassifier();
  // virtual ~CvNormalBayesClassifier();
  //
  // CvNormalBayesClassifier( const CvMat* trainData, const CvMat* responses,
  // const CvMat* varIdx=0, const CvMat* sampleIdx=0 );
  //
  // virtual bool train( const CvMat* trainData, const CvMat* responses,
  // const CvMat* varIdx = 0, const CvMat* sampleIdx=0, bool update=false );
  //
  // virtual float predict( const CvMat* samples, CV_OUT CvMat* results=0 ) const;
  // CV_WRAP virtual void clear();
  //
  // CV_WRAP CvNormalBayesClassifier( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat() );
  // CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& varIdx = cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
  // bool update=false );
  // CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0 ) const;
  //
  // virtual void write( CvFileStorage* storage, const char* name ) const;
  // virtual void read( CvFileStorage* storage, CvFileNode* node );
  //
  // protected:
  // int     var_count, var_all;
  // CvMat*  var_idx;
  // CvMat*  cls_labels;
  // CvMat** count;
  // CvMat** sum;
  // CvMat** productsum;
  // CvMat** avg;
  // CvMat** inv_eigen_values;
  // CvMat** cov_rotate_mats;
  // CvMat*  c;
  // };
  //
  //
  /// ****************************************************************************************\
  // *                          K-Nearest Neighbour Classifier                                *
  // \****************************************************************************************/
Type
  TCvKNearest = class(TObject)
    function train(const trainData: pCvMat; const responses: pCvMat; const sampleIdx: pCvMat = nil;
      is_regression: bool = false; maxK: Integer = 32; updateBase: bool = false): bool; virtual; stdcall; abstract;
    function find_nearest(const samples: pCvMat; k: Integer; results: pCvMat = nil; const neighbors: pSingle = nil;
      neighborResponses: pCvMat = nil; dist: pCvMat = nil): float; virtual; stdcall; abstract;
    // -----------------------------------
    class function Create: TCvKNearest; overload;
    class function Create(const trainData: pCvMat; const responses: pCvMat; const sampleIdx: pCvMat = nil;
      isRegression: bool = false; max_k: Integer = 32): TCvKNearest; overload;
    procedure Free; reintroduce;
  end;

  // k Nearest Neighbors
  // class CV_EXPORTS_W CvKNearest : public CvStatModel
  // {
  // public:
  //
  // CV_WRAP CvKNearest();
  // virtual ~CvKNearest();
  //
  // CvKNearest( const CvMat* trainData, const CvMat* responses, const CvMat* sampleIdx=0, bool isRegression=false, int max_k=32 );
  //
  // virtual bool train( const CvMat* trainData, const CvMat* responses,
  // const CvMat* sampleIdx=0, bool is_regression=false,
  // int maxK=32, bool updateBase=false );
  //
  // virtual float find_nearest( const CvMat* samples, int k, CV_OUT CvMat* results=0,
  // const float** neighbors=0, CV_OUT CvMat* neighborResponses=0, CV_OUT CvMat* dist=0 ) const;
  //
  // CV_WRAP CvKNearest( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false, int max_k=32 );
  //
  // CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false,
  // int maxK=32, bool updateBase=false );
  //
  // virtual float find_nearest( const cv::Mat& samples, int k, cv::Mat* results=0,
  // const float** neighbors=0, cv::Mat* neighborResponses=0,
  // cv::Mat* dist=0 ) const;
  // CV_WRAP virtual float find_nearest( const cv::Mat& samples, int k, CV_OUT cv::Mat& results,
  // CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const;
  //
  // virtual void clear();
  // int get_max_k() const;
  // int get_var_count() const;
  // int get_sample_count() const;
  // bool is_regression() const;
  //
  // virtual float write_results( int k, int k1, int start, int end,
  // const float* neighbor_responses, const float* dist, CvMat* _results,
  // CvMat* _neighbor_responses, CvMat* _dist, Cv32suf* sort_buf ) const;
  //
  // virtual void find_neighbors_direct( const CvMat* _samples, int k, int start, int end,
  // float* neighbor_responses, const float** neighbors, float* dist ) const;
  //
  // protected:
  //
  // int max_k, var_count;
  // int total;
  // bool regression;
  // CvVectors* samples;
  // };
  //
  /// ****************************************************************************************\
  // *                                   Support Vector Machines                              *
  // \****************************************************************************************/
  //
  /// / SVM training parameters
  // struct CV_EXPORTS_W_MAP CvSVMParams
  // {
  // CvSVMParams();
  // CvSVMParams( int svm_type, int kernel_type,
  // double degree, double gamma, double coef0,
  // double Cvalue, double nu, double p,
  // CvMat* class_weights, CvTermCriteria term_crit );
  //
  // CV_PROP_RW int         svm_type;
  // CV_PROP_RW int         kernel_type;
  // CV_PROP_RW double      degree; // for poly
  // CV_PROP_RW double      gamma;  // for poly/rbf/sigmoid/chi2
  // CV_PROP_RW double      coef0;  // for poly/sigmoid
  //
  // CV_PROP_RW double      C;  // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR
  // CV_PROP_RW double      nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR
  // CV_PROP_RW double      p; // for CV_SVM_EPS_SVR
  // CvMat*      class_weights; // for CV_SVM_C_SVC
  // CV_PROP_RW CvTermCriteria term_crit; // termination criteria
  // };
  //
  //
  // struct CV_EXPORTS CvSVMKernel
  // {
  // typedef void (CvSVMKernel::*Calc)( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results );
  // CvSVMKernel();
  // CvSVMKernel( const CvSVMParams* params, Calc _calc_func );
  // virtual bool create( const CvSVMParams* params, Calc _calc_func );
  // virtual ~CvSVMKernel();
  //
  // virtual void clear();
  // virtual void calc( int vcount, int n, const float** vecs, const float* another, float* results );
  //
  // const CvSVMParams* params;
  // Calc calc_func;
  //
  // virtual void calc_non_rbf_base( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results,
  // double alpha, double beta );
  // virtual void calc_intersec( int vcount, int var_count, const float** vecs,
  // const float* another, float* results );
  // virtual void calc_chi2( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results );
  // virtual void calc_linear( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results );
  // virtual void calc_rbf( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results );
  // virtual void calc_poly( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results );
  // virtual void calc_sigmoid( int vec_count, int vec_size, const float** vecs,
  // const float* another, float* results );
  // };
  //
  //
  // struct CvSVMKernelRow
  // {
  // CvSVMKernelRow* prev;
  // CvSVMKernelRow* next;
  // float* data;
  // };
  //
  //
  // struct CvSVMSolutionInfo
  // {
  // double obj;
  // double rho;
  // double upper_bound_p;
  // double upper_bound_n;
  // double r;   // for Solver_NU
  // };
  //
  // class CV_EXPORTS CvSVMSolver
  // {
  // public:
  // typedef bool (CvSVMSolver::*SelectWorkingSet)( int& i, int& j );
  // typedef float* (CvSVMSolver::*GetRow)( int i, float* row, float* dst, bool existed );
  // typedef void (CvSVMSolver::*CalcRho)( double& rho, double& r );
  //
  // CvSVMSolver();
  //
  // CvSVMSolver( int count, int var_count, const float** samples, schar* y,
  // int alpha_count, double* alpha, double Cp, double Cn,
  // CvMemStorage* storage, CvSVMKernel* kernel, GetRow get_row,
  // SelectWorkingSet select_working_set, CalcRho calc_rho );
  // virtual bool create( int count, int var_count, const float** samples, schar* y,
  // int alpha_count, double* alpha, double Cp, double Cn,
  // CvMemStorage* storage, CvSVMKernel* kernel, GetRow get_row,
  // SelectWorkingSet select_working_set, CalcRho calc_rho );
  // virtual ~CvSVMSolver();
  //
  // virtual void clear();
  // virtual bool solve_generic( CvSVMSolutionInfo& si );
  //
  // virtual bool solve_c_svc( int count, int var_count, const float** samples, schar* y,
  // double Cp, double Cn, CvMemStorage* storage,
  // CvSVMKernel* kernel, double* alpha, CvSVMSolutionInfo& si );
  // virtual bool solve_nu_svc( int count, int var_count, const float** samples, schar* y,
  // CvMemStorage* storage, CvSVMKernel* kernel,
  // double* alpha, CvSVMSolutionInfo& si );
  // virtual bool solve_one_class( int count, int var_count, const float** samples,
  // CvMemStorage* storage, CvSVMKernel* kernel,
  // double* alpha, CvSVMSolutionInfo& si );
  //
  // virtual bool solve_eps_svr( int count, int var_count, const float** samples, const float* y,
  // CvMemStorage* storage, CvSVMKernel* kernel,
  // double* alpha, CvSVMSolutionInfo& si );
  //
  // virtual bool solve_nu_svr( int count, int var_count, const float** samples, const float* y,
  // CvMemStorage* storage, CvSVMKernel* kernel,
  // double* alpha, CvSVMSolutionInfo& si );
  //
  // virtual float* get_row_base( int i, bool* _existed );
  // virtual float* get_row( int i, float* dst );
  //
  // int sample_count;
  // int var_count;
  // int cache_size;
  // int cache_line_size;
  // const float** samples;
  // const CvSVMParams* params;
  // CvMemStorage* storage;
  // CvSVMKernelRow lru_list;
  // CvSVMKernelRow* rows;
  //
  // int alpha_count;
  //
  // double* G;
  // double* alpha;
  //
  // // -1 - lower bound, 0 - free, 1 - upper bound
  // schar* alpha_status;
  //
  // schar* y;
  // double* b;
  // float* buf[2];
  // double eps;
  // int max_iter;
  // double C[2];  // C[0] == Cn, C[1] == Cp
  // CvSVMKernel* kernel;
  //
  // SelectWorkingSet select_working_set_func;
  // CalcRho calc_rho_func;
  // GetRow get_row_func;
  //
  // virtual bool select_working_set( int& i, int& j );
  // virtual bool select_working_set_nu_svm( int& i, int& j );
  // virtual void calc_rho( double& rho, double& r );
  // virtual void calc_rho_nu_svm( double& rho, double& r );
  //
  // virtual float* get_row_svc( int i, float* row, float* dst, bool existed );
  // virtual float* get_row_one_class( int i, float* row, float* dst, bool existed );
  // virtual float* get_row_svr( int i, float* row, float* dst, bool existed );
  // };
  //
  //
  // struct CvSVMDecisionFunc
  // {
  // double rho;
  // int sv_count;
  // double* alpha;
  // int* sv_index;
  // };
  //
  //
  /// / SVM model
  // class CV_EXPORTS_W CvSVM : public CvStatModel
  // {
  // public:
  // // SVM type
  // enum { C_SVC=100, NU_SVC=101, ONE_CLASS=102, EPS_SVR=103, NU_SVR=104 };
  //
  // // SVM kernel type
  // enum { LINEAR=0, POLY=1, RBF=2, SIGMOID=3, CHI2=4, INTER=5 };
  //
  // // SVM params type
  // enum { C=0, GAMMA=1, P=2, NU=3, COEF=4, DEGREE=5 };
  //
  // CV_WRAP CvSVM();
  // virtual ~CvSVM();
  //
  // CvSVM( const CvMat* trainData, const CvMat* responses,
  // const CvMat* varIdx=0, const CvMat* sampleIdx=0,
  // CvSVMParams params=CvSVMParams() );
  //
  // virtual bool train( const CvMat* trainData, const CvMat* responses,
  // const CvMat* varIdx=0, const CvMat* sampleIdx=0,
  // CvSVMParams params=CvSVMParams() );
  //
  // virtual bool train_auto( const CvMat* trainData, const CvMat* responses,
  // const CvMat* varIdx, const CvMat* sampleIdx, CvSVMParams params,
  // int kfold = 10,
  // CvParamGrid Cgrid      = get_default_grid(CvSVM::C),
  // CvParamGrid gammaGrid  = get_default_grid(CvSVM::GAMMA),
  // CvParamGrid pGrid      = get_default_grid(CvSVM::P),
  // CvParamGrid nuGrid     = get_default_grid(CvSVM::NU),
  // CvParamGrid coeffGrid  = get_default_grid(CvSVM::COEF),
  // CvParamGrid degreeGrid = get_default_grid(CvSVM::DEGREE),
  // bool balanced=false );
  //
  // virtual float predict( const CvMat* sample, bool returnDFVal=false ) const;
  // virtual float predict( const CvMat* samples, CV_OUT CvMat* results ) const;
  //
  // CV_WRAP CvSVM( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
  // CvSVMParams params=CvSVMParams() );
  //
  // CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
  // CvSVMParams params=CvSVMParams() );
  //
  // CV_WRAP virtual bool train_auto( const cv::Mat& trainData, const cv::Mat& responses,
  // const cv::Mat& varIdx, const cv::Mat& sampleIdx, CvSVMParams params,
  // int k_fold = 10,
  // CvParamGrid Cgrid      = CvSVM::get_default_grid(CvSVM::C),
  // CvParamGrid gammaGrid  = CvSVM::get_default_grid(CvSVM::GAMMA),
  // CvParamGrid pGrid      = CvSVM::get_default_grid(CvSVM::P),
  // CvParamGrid nuGrid     = CvSVM::get_default_grid(CvSVM::NU),
  // CvParamGrid coeffGrid  = CvSVM::get_default_grid(CvSVM::COEF),
  // CvParamGrid degreeGrid = CvSVM::get_default_grid(CvSVM::DEGREE),
  // bool balanced=false);
  // CV_WRAP virtual float predict( const cv::Mat& sample, bool returnDFVal=false ) const;
  // CV_WRAP_AS(predict_all) virtual void predict( cv::InputArray samples, cv::OutputArray results ) const;
  //
  // CV_WRAP virtual int get_support_vector_count() const;
  // virtual const float* get_support_vector(int i) const;
  // virtual CvSVMParams get_params() const { return params; };
  // CV_WRAP virtual void clear();
  //
  // static CvParamGrid get_default_grid( int param_id );
  //
  // virtual void write( CvFileStorage* storage, const char* name ) const;
  // virtual void read( CvFileStorage* storage, CvFileNode* node );
  // CV_WRAP int get_var_count() const { return var_idx ? var_idx->cols : var_all; }
  //
  // protected:
  //
  // virtual bool set_params( const CvSVMParams& params );
  // virtual bool train1( int sample_count, int var_count, const float** samples,
  // const void* responses, double Cp, double Cn,
  // CvMemStorage* _storage, double* alpha, double& rho );
  // virtual bool do_train( int svm_type, int sample_count, int var_count, const float** samples,
  // const CvMat* responses, CvMemStorage* _storage, double* alpha );
  // virtual void create_kernel();
  // virtual void create_solver();
  //
  // virtual float predict( const float* row_sample, int row_len, bool returnDFVal=false ) const;
  //
  // virtual void write_params( CvFileStorage* fs ) const;
  // virtual void read_params( CvFileStorage* fs, CvFileNode* node );
  //
  // void optimize_linear_svm();
  //
  // CvSVMParams params;
  // CvMat* class_labels;
  // int var_all;
  // float** sv;
  // int sv_total;
  // CvMat* var_idx;
  // CvMat* class_weights;
  // CvSVMDecisionFunc* decision_func;
  // CvMemStorage* storage;
  //
  // CvSVMSolver* solver;
  // CvSVMKernel* kernel;
  // };
  //
  /// ****************************************************************************************\
  // *                              Expectation - Maximization                                *
  // \****************************************************************************************/
  // namespace cv
  // {
  // class CV_EXPORTS_W EM : public Algorithm
  // {
  // public:
  // // Type of covariation matrices
  // enum {COV_MAT_SPHERICAL=0, COV_MAT_DIAGONAL=1, COV_MAT_GENERIC=2, COV_MAT_DEFAULT=COV_MAT_DIAGONAL};
  //
  // // Default parameters
  // enum {DEFAULT_NCLUSTERS=5, DEFAULT_MAX_ITERS=100};
  //
  // // The initial step
  // enum {START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0};
  //
  // CV_WRAP EM(int nclusters=EM::DEFAULT_NCLUSTERS, int covMatType=EM::COV_MAT_DIAGONAL,
  // const TermCriteria& termCrit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS,
  // EM::DEFAULT_MAX_ITERS, FLT_EPSILON));
  //
  // virtual ~EM();
  // CV_WRAP virtual void clear();
  //
  // CV_WRAP virtual bool train(InputArray samples,
  // OutputArray logLikelihoods=noArray(),
  // OutputArray labels=noArray(),
  // OutputArray probs=noArray());
  //
  // CV_WRAP virtual bool trainE(InputArray samples,
  // InputArray means0,
  // InputArray covs0=noArray(),
  // InputArray weights0=noArray(),
  // OutputArray logLikelihoods=noArray(),
  // OutputArray labels=noArray(),
  // OutputArray probs=noArray());
  //
  // CV_WRAP virtual bool trainM(InputArray samples,
  // InputArray probs0,
  // OutputArray logLikelihoods=noArray(),
  // OutputArray labels=noArray(),
  // OutputArray probs=noArray());
  //
  // CV_WRAP Vec2d predict(InputArray sample,
  // OutputArray probs=noArray()) const;
  //
  // CV_WRAP bool isTrained() const;
  //
  // AlgorithmInfo* info() const;
  // virtual void read(const FileNode& fn);
  //
  // protected:
  //
  // virtual void setTrainData(int startStep, const Mat& samples,
  // const Mat* probs0,
  // const Mat* means0,
  // const std::vector<Mat>* covs0,
  // const Mat* weights0);
  //
  // bool doTrain(int startStep,
  // OutputArray logLikelihoods,
  // OutputArray labels,
  // OutputArray probs);
  // virtual void eStep();
  // virtual void mStep();
  //
  // void clusterTrainSamples();
  // void decomposeCovs();
  // void computeLogWeightDivDet();
  //
  // Vec2d computeProbabilities(const Mat& sample, Mat* probs) const;
  //
  // // all inner matrices have type CV_64FC1
  // CV_PROP_RW int nclusters;
  // CV_PROP_RW int covMatType;
  // CV_PROP_RW int maxIters;
  // CV_PROP_RW double epsilon;
  //
  // Mat trainSamples;
  // Mat trainProbs;
  // Mat trainLogLikelihoods;
  // Mat trainLabels;
  //
  // CV_PROP Mat weights;
  // CV_PROP Mat means;
  // CV_PROP std::vector<Mat> covs;
  //
  // std::vector<Mat> covsEigenValues;
  // std::vector<Mat> covsRotateMats;
  // std::vector<Mat> invCovsEigenValues;
  // Mat logWeightDivDet;
  // };
  // } // namespace cv
  //
  /// ****************************************************************************************\
  // *                                      Decision Tree                                     *
  // \****************************************************************************************/\
  // struct CvPair16u32s
  // {
  // unsigned short* u;
  // int* i;
  // };
  //
  //
  // #define CV_DTREE_CAT_DIR(idx,subset) \
  // (2*((subset[(idx)>>5]&(1 << ((idx) & 31)))==0)-1)
Type
  TOrd = record
    c: float;
    split_point: Integer;
  end;

  pCvDTreeSplit = ^TCvDTreeSplit;

  TCvDTreeSplit = record // struct CvDTreeSplit
    var_idx: Integer; // int var_idx;
    condensed_idx: Integer; // int condensed_idx;
    inversed: Integer; // int inversed;
    quality: float; // float quality;
    next: pCvDTreeSplit; // CvDTreeSplit* next;
    case byte of
      // union
      // {
      // int subset[2];
      0:
        (subset: array [0 .. 1] of Integer);
      1:
        (ord: TOrd);
    // struct
    // {
    // float c;
    // int split_point;
    // }
    // ord;
    // };
  end;

  pCvDTreeNode = ^TCvDTreeNode;

  TCvDTreeNode = record // struct CvDTreeNode
    class_idx: Integer; // int class_idx;
    Tn: Integer; // int Tn;
    value: Double; // double value;
    //
    parent: pCvDTreeNode; // CvDTreeNode* parent;
    left: pCvDTreeNode; // CvDTreeNode* left;
    right: pCvDTreeNode; // CvDTreeNode* right;
    //
    split: pCvDTreeSplit; // CvDTreeSplit* split;
    //
    sample_count: Integer; // int sample_count;
    depth: Integer; // int depth;
    num_valid: pInteger; // int* num_valid;
    offset: Integer; // int offset;
    buf_idx: Integer; // int buf_idx;
    maxlr: Double; // double maxlr;
    //
    // // global pruning data
    complexity: Integer; // int complexity;
    alpha: Double; // double alpha;
    node_risk, tree_risk, tree_error: Double; // double node_risk, tree_risk, tree_error;
    //
    // // cross-validation pruning data
    cv_Tn: pInteger; // int* cv_Tn;
    cv_node_risk: pDouble; // double* cv_node_risk;
    cv_node_error: pDouble; // double* cv_node_error;
    //
    // int get_num_valid(int vi) { return num_valid ? num_valid[vi] : sample_count; }
    function get_num_valid(vi: Integer): Integer;
    // void set_num_valid(int vi, int n) { if( num_valid ) num_valid[vi] = n; }
    procedure set_num_valid(vi: Integer; n: Integer);
  end;

  TCvDTreeParams = record // struct CV_EXPORTS_W_MAP CvDTreeParams
    max_categories: Integer; // CV_PROP_RW int   max_categories                      ;
    max_depth: Integer; // CV_PROP_RW int   max_depth                           ;
    min_sample_count: Integer; // CV_PROP_RW int   min_sample_count                    ;
    cv_folds: Integer; // CV_PROP_RW int   cv_folds                            ;
    use_surrogates: ByteBool; // CV_PROP_RW bool  use_surrogates                      ;
    use_1se_rule: ByteBool; // CV_PROP_RW bool  use_1se_rule                        ;
    truncate_pruned_tree: ByteBool; // CV_PROP_RW bool  truncate_pruned_tree                ;
    regression_accuracy: float; // CV_PROP_RW float regression_accuracy                 ;
    priors: pFloat; // const float* priors;
    //
    // CvDTreeParams();
    {
      CvDTreeParams( int max_depth, int min_sample_count, float regression_accuracy,
      bool use_surrogates, int max_categories, int cv_folds,
      bool use_1se_rule, bool truncate_pruned_tree, const float* priors );
    }
  end;

  // struct CV_EXPORTS CvDTreeTrainData
  // {
  // CvDTreeTrainData();
  // CvDTreeTrainData( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // const CvDTreeParams& params=CvDTreeParams(),
  // bool _shared=false, bool _add_labels=false );
  // virtual ~CvDTreeTrainData();
  //
  // virtual void set_data( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // const CvDTreeParams& params=CvDTreeParams(),
  // bool _shared=false, bool _add_labels=false,
  // bool _update_data=false );
  // virtual void do_responses_copy();
  //
  // virtual void get_vectors( const CvMat* _subsample_idx,
  // float* values, uchar* missing, float* responses, bool get_class_idx=false );
  //
  // virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx );
  //
  // virtual void write_params( CvFileStorage* fs ) const;
  // virtual void read_params( CvFileStorage* fs, CvFileNode* node );
  //
  // // release all the data
  // virtual void clear();
  //
  // int get_num_classes() const;
  // int get_var_type(int vi) const;
  // int get_work_var_count() const {return work_var_count;}
  //
  // virtual const float* get_ord_responses( CvDTreeNode* n, float* values_buf, int* sample_indices_buf );
  // virtual const int* get_class_labels( CvDTreeNode* n, int* labels_buf );
  // virtual const int* get_cv_labels( CvDTreeNode* n, int* labels_buf );
  // virtual const int* get_sample_indices( CvDTreeNode* n, int* indices_buf );
  // virtual const int* get_cat_var_data( CvDTreeNode* n, int vi, int* cat_values_buf );
  // virtual void get_ord_var_data( CvDTreeNode* n, int vi, float* ord_values_buf, int* sorted_indices_buf,
  // const float** ord_values, const int** sorted_indices, int* sample_indices_buf );
  // virtual int get_child_buf_idx( CvDTreeNode* n );
  //
  // ////////////////////////////////////
  //
  // virtual bool set_params( const CvDTreeParams& params );
  // virtual CvDTreeNode* new_node( CvDTreeNode* parent, int count,
  // int storage_idx, int offset );
  //
  // virtual CvDTreeSplit* new_split_ord( int vi, float cmp_val,
  // int split_point, int inversed, float quality );
  // virtual CvDTreeSplit* new_split_cat( int vi, float quality );
  // virtual void free_node_data( CvDTreeNode* node );
  // virtual void free_train_data();
  // virtual void free_node( CvDTreeNode* node );
  //
  // int sample_count, var_all, var_count, max_c_count;
  // int ord_var_count, cat_var_count, work_var_count;
  // bool have_labels, have_priors;
  // bool is_classifier;
  // int tflag;
  //
  // const CvMat* train_data;
  // const CvMat* responses;
  // CvMat* responses_copy; // used in Boosting
  //
  // int buf_count, buf_size; // buf_size is obsolete, please do not use it, use expression ((int64)buf->rows * (int64)buf->cols / buf_count) instead
  // bool shared;
  // int is_buf_16u;
  //
  // CvMat* cat_count;
  // CvMat* cat_ofs;
  // CvMat* cat_map;
  //
  // CvMat* counts;
  // CvMat* buf;
  // inline size_t get_length_subbuf() const
  // {
  // size_t res = (size_t)(work_var_count + 1) * (size_t)sample_count;
  // return res;
  // }
  //
  // CvMat* direction;
  // CvMat* split_buf;
  //
  // CvMat* var_idx;
  // CvMat* var_type; // i-th element =
  // //   k<0  - ordered
  // //   k>=0 - categorical, see k-th element of cat_* arrays
  // CvMat* priors;
  // CvMat* priors_mult;
  //
  // CvDTreeParams params;
  //
  // CvMemStorage* tree_storage;
  // CvMemStorage* temp_storage;
  //
  // CvDTreeNode* data_root;
  //
  // CvSet* node_heap;
  // CvSet* split_heap;
  // CvSet* cv_heap;
  // CvSet* nv_heap;
  //
  // cv::RNG* rng;
  // };
  //
  // class CvDTree;
  // class CvForestTree;
  //
  // namespace cv
  // {
  // struct DTreeBestSplitFinder;
  // struct ForestTreeBestSplitFinder;
  // }
  //
  // class CV_EXPORTS_W CvDTree : public CvStatModel
  // {
  // public:
  // CV_WRAP CvDTree();
  // virtual ~CvDTree();
  //
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvDTreeParams params=CvDTreeParams() );
  //
  // virtual bool train( CvMLData* trainData, CvDTreeParams params=CvDTreeParams() );
  //
  // // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
  // virtual float calc_error( CvMLData* trainData, int type, std::vector<float> *resp = 0 );
  //
  // virtual bool train( CvDTreeTrainData* trainData, const CvMat* subsampleIdx );
  //
  // virtual CvDTreeNode* predict( const CvMat* sample, const CvMat* missingDataMask=0,
  // bool preprocessedInput=false ) const;
  //
  // CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvDTreeParams params=CvDTreeParams() );
  //
  // CV_WRAP virtual CvDTreeNode* predict( const cv::Mat& sample, const cv::Mat& missingDataMask=cv::Mat(),
  // bool preprocessedInput=false ) const;
  // CV_WRAP virtual cv::Mat getVarImportance();
  //
  // virtual const CvMat* get_var_importance();
  // CV_WRAP virtual void clear();
  //
  // virtual void read( CvFileStorage* fs, CvFileNode* node );
  // virtual void write( CvFileStorage* fs, const char* name ) const;
  //
  // // special read & write methods for trees in the tree ensembles
  // virtual void read( CvFileStorage* fs, CvFileNode* node,
  // CvDTreeTrainData* data );
  // virtual void write( CvFileStorage* fs ) const;
  //
  // const CvDTreeNode* get_root() const;
  // int get_pruned_tree_idx() const;
  // CvDTreeTrainData* get_data();
  //
  // protected:
  // friend struct cv::DTreeBestSplitFinder;
  //
  // virtual bool do_train( const CvMat* _subsample_idx );
  //
  // virtual void try_split_node( CvDTreeNode* n );
  // virtual void split_node_data( CvDTreeNode* n );
  // virtual CvDTreeSplit* find_best_split( CvDTreeNode* n );
  // virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
  // virtual double calc_node_dir( CvDTreeNode* node );
  // virtual void complete_node_dir( CvDTreeNode* node );
  // virtual void cluster_categories( const int* vectors, int vector_count,
  // int var_count, int* sums, int k, int* cluster_labels );
  //
  // virtual void calc_node_value( CvDTreeNode* node );
  //
  // virtual void prune_cv();
  // virtual double update_tree_rnc( int T, int fold );
  // virtual int cut_tree( int T, int fold, double min_alpha );
  // virtual void free_prune_data(bool cut_tree);
  // virtual void free_tree();
  //
  // virtual void write_node( CvFileStorage* fs, CvDTreeNode* node ) const;
  // virtual void write_split( CvFileStorage* fs, CvDTreeSplit* split ) const;
  // virtual CvDTreeNode* read_node( CvFileStorage* fs, CvFileNode* node, CvDTreeNode* parent );
  // virtual CvDTreeSplit* read_split( CvFileStorage* fs, CvFileNode* node );
  // virtual void write_tree_nodes( CvFileStorage* fs ) const;
  // virtual void read_tree_nodes( CvFileStorage* fs, CvFileNode* node );
  //
  // CvDTreeNode* root;
  // CvMat* var_importance;
  // CvDTreeTrainData* data;
  //
  // public:
  // int pruned_tree_idx;
  // };
  //
  //
  /// ****************************************************************************************\
  // *                                   Random Trees Classifier                              *
  // \****************************************************************************************/
  //
  // class CvRTrees;
  //
  // class CV_EXPORTS CvForestTree: public CvDTree
  // {
  // public:
  // CvForestTree();
  // virtual ~CvForestTree();
  //
  // virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx, CvRTrees* forest );
  //
  // virtual int get_var_count() const {return data ? data->var_count : 0;}
  // virtual void read( CvFileStorage* fs, CvFileNode* node, CvRTrees* forest, CvDTreeTrainData* _data );
  //
  // /* dummy methods to avoid warnings: BEGIN */
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvDTreeParams params=CvDTreeParams() );
  //
  // virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx );
  // virtual void read( CvFileStorage* fs, CvFileNode* node );
  // virtual void read( CvFileStorage* fs, CvFileNode* node,
  // CvDTreeTrainData* data );
  // /* dummy methods to avoid warnings: END */
  //
  // protected:
  // friend struct cv::ForestTreeBestSplitFinder;
  //
  // virtual CvDTreeSplit* find_best_split( CvDTreeNode* n );
  // CvRTrees* forest;
  // };
  //
  //
  // struct CV_EXPORTS_W_MAP CvRTParams : public CvDTreeParams
  // {
  // //Parameters for the forest
  // CV_PROP_RW bool calc_var_importance; // true <=> RF processes variable importance
  // CV_PROP_RW int nactive_vars;
  // CV_PROP_RW CvTermCriteria term_crit;
  //
  // CvRTParams();
  // CvRTParams( int max_depth, int min_sample_count,
  // float regression_accuracy, bool use_surrogates,
  // int max_categories, const float* priors, bool calc_var_importance,
  // int nactive_vars, int max_num_of_trees_in_the_forest,
  // float forest_accuracy, int termcrit_type );
  // };
  //
  //
  // class CV_EXPORTS_W CvRTrees : public CvStatModel
  // {
  // public:
  // CV_WRAP CvRTrees();
  // virtual ~CvRTrees();
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvRTParams params=CvRTParams() );
  //
  // virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() );
  // virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) const;
  // virtual float predict_prob( const CvMat* sample, const CvMat* missing = 0 ) const;
  //
  // CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvRTParams params=CvRTParams() );
  // CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
  // CV_WRAP virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
  // CV_WRAP virtual cv::Mat getVarImportance();
  //
  // CV_WRAP virtual void clear();
  //
  // virtual const CvMat* get_var_importance();
  // virtual float get_proximity( const CvMat* sample1, const CvMat* sample2,
  // const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const;
  //
  // virtual float calc_error( CvMLData* data, int type , std::vector<float>* resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
  //
  // virtual float get_train_error();
  //
  // virtual void read( CvFileStorage* fs, CvFileNode* node );
  // virtual void write( CvFileStorage* fs, const char* name ) const;
  //
  // CvMat* get_active_var_mask();
  // CvRNG* get_rng();
  //
  // int get_tree_count() const;
  // CvForestTree* get_tree(int i) const;
  //
  // protected:
  // virtual cv::String getName() const;
  //
  // virtual bool grow_forest( const CvTermCriteria term_crit );
  //
  // // array of the trees of the forest
  // CvForestTree** trees;
  // CvDTreeTrainData* data;
  // int ntrees;
  // int nclasses;
  // double oob_error;
  // CvMat* var_importance;
  // int nsamples;
  //
  // cv::RNG* rng;
  // CvMat* active_var_mask;
  // };
  //
  /// ****************************************************************************************\
  // *                           Extremely randomized trees Classifier                        *
  // \****************************************************************************************/
  // struct CV_EXPORTS CvERTreeTrainData : public CvDTreeTrainData
  // {
  // virtual void set_data( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // const CvDTreeParams& params=CvDTreeParams(),
  // bool _shared=false, bool _add_labels=false,
  // bool _update_data=false );
  // virtual void get_ord_var_data( CvDTreeNode* n, int vi, float* ord_values_buf, int* missing_buf,
  // const float** ord_values, const int** missing, int* sample_buf = 0 );
  // virtual const int* get_sample_indices( CvDTreeNode* n, int* indices_buf );
  // virtual const int* get_cv_labels( CvDTreeNode* n, int* labels_buf );
  // virtual const int* get_cat_var_data( CvDTreeNode* n, int vi, int* cat_values_buf );
  // virtual void get_vectors( const CvMat* _subsample_idx, float* values, uchar* missing,
  // float* responses, bool get_class_idx=false );
  // virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx );
  // const CvMat* missing_mask;
  // };
  //
  // class CV_EXPORTS CvForestERTree : public CvForestTree
  // {
  // protected:
  // virtual double calc_node_dir( CvDTreeNode* node );
  // virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual void split_node_data( CvDTreeNode* n );
  // };
  //
  // class CV_EXPORTS_W CvERTrees : public CvRTrees
  // {
  // public:
  // CV_WRAP CvERTrees();
  // virtual ~CvERTrees();
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvRTParams params=CvRTParams());
  // CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvRTParams params=CvRTParams());
  // virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() );
  // protected:
  // virtual cv::String getName() const;
  // virtual bool grow_forest( const CvTermCriteria term_crit );
  // };
  //
  //
  /// ****************************************************************************************\
  // *                                   Boosted tree classifier                              *
  // \****************************************************************************************/
  //
  // struct CV_EXPORTS_W_MAP CvBoostParams : public CvDTreeParams
  // {
  // CV_PROP_RW int boost_type;
  // CV_PROP_RW int weak_count;
  // CV_PROP_RW int split_criteria;
  // CV_PROP_RW double weight_trim_rate;
  //
  // CvBoostParams();
  // CvBoostParams( int boost_type, int weak_count, double weight_trim_rate,
  // int max_depth, bool use_surrogates, const float* priors );
  // };
  //
  //
  // class CvBoost;
  //
  // class CV_EXPORTS CvBoostTree: public CvDTree
  // {
  // public:
  // CvBoostTree();
  // virtual ~CvBoostTree();
  //
  // virtual bool train( CvDTreeTrainData* trainData,
  // const CvMat* subsample_idx, CvBoost* ensemble );
  //
  // virtual void scale( double s );
  // virtual void read( CvFileStorage* fs, CvFileNode* node,
  // CvBoost* ensemble, CvDTreeTrainData* _data );
  // virtual void clear();
  //
  // /* dummy methods to avoid warnings: BEGIN */
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvDTreeParams params=CvDTreeParams() );
  // virtual bool train( CvDTreeTrainData* trainData, const CvMat* _subsample_idx );
  //
  // virtual void read( CvFileStorage* fs, CvFileNode* node );
  // virtual void read( CvFileStorage* fs, CvFileNode* node,
  // CvDTreeTrainData* data );
  // /* dummy methods to avoid warnings: END */
  //
  // protected:
  //
  // virtual void try_split_node( CvDTreeNode* n );
  // virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
  // float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
  // virtual void calc_node_value( CvDTreeNode* n );
  // virtual double calc_node_dir( CvDTreeNode* n );
  //
  // CvBoost* ensemble;
  // };
  //
  //
  // class CV_EXPORTS_W CvBoost : public CvStatModel
  // {
  // public:
  // // Boosting type
  // enum { DISCRETE=0, REAL=1, LOGIT=2, GENTLE=3 };
  //
  // // Splitting criteria
  // enum { DEFAULT=0, GINI=1, MISCLASS=3, SQERR=4 };
  //
  // CV_WRAP CvBoost();
  // virtual ~CvBoost();
  //
  // CvBoost( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvBoostParams params=CvBoostParams() );
  //
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvBoostParams params=CvBoostParams(),
  // bool update=false );
  //
  // virtual bool train( CvMLData* data,
  // CvBoostParams params=CvBoostParams(),
  // bool update=false );
  //
  // virtual float predict( const CvMat* sample, const CvMat* missing=0,
  // CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ,
  // bool raw_mode=false, bool return_sum=false ) const;
  //
  // CV_WRAP CvBoost( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvBoostParams params=CvBoostParams() );
  //
  // CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvBoostParams params=CvBoostParams(),
  // bool update=false );
  //
  // CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(),
  // const cv::Range& slice=cv::Range::all(), bool rawMode=false,
  // bool returnSum=false ) const;
  //
  // virtual float calc_error( CvMLData* _data, int type , std::vector<float> *resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
  //
  // CV_WRAP virtual void prune( CvSlice slice );
  //
  // CV_WRAP virtual void clear();
  //
  // virtual void write( CvFileStorage* storage, const char* name ) const;
  // virtual void read( CvFileStorage* storage, CvFileNode* node );
  // virtual const CvMat* get_active_vars(bool absolute_idx=true);
  //
  // CvSeq* get_weak_predictors();
  //
  // CvMat* get_weights();
  // CvMat* get_subtree_weights();
  // CvMat* get_weak_response();
  // const CvBoostParams& get_params() const;
  // const CvDTreeTrainData* get_data() const;
  //
  // protected:
  //
  // virtual bool set_params( const CvBoostParams& params );
  // virtual void update_weights( CvBoostTree* tree );
  // virtual void trim_weights();
  // virtual void write_params( CvFileStorage* fs ) const;
  // virtual void read_params( CvFileStorage* fs, CvFileNode* node );
  //
  // virtual void initialize_weights(double (&p)[2]);
  //
  // CvDTreeTrainData* data;
  // CvBoostParams params;
  // CvSeq* weak;
  //
  // CvMat* active_vars;
  // CvMat* active_vars_abs;
  // bool have_active_cat_vars;
  //
  // CvMat* orig_response;
  // CvMat* sum_response;
  // CvMat* weak_eval;
  // CvMat* subsample_mask;
  // CvMat* weights;
  // CvMat* subtree_weights;
  // bool have_subsample;
  // };
  //
  //
  /// ****************************************************************************************\
  // *                                   Gradient Boosted Trees                               *
  // \****************************************************************************************/
  //
  /// / DataType: STRUCT CvGBTreesParams
  /// / Parameters of GBT (Gradient Boosted trees model), including single
  /// / tree settings and ensemble parameters.
  /// /
  /// / weak_count          - count of trees in the ensemble
  /// / loss_function_type  - loss function used for ensemble training
  /// / subsample_portion   - portion of whole training set used for
  /// /                       every single tree training.
  /// /                       subsample_portion value is in (0.0, 1.0].
  /// /                       subsample_portion == 1.0 when whole dataset is
  /// /                       used on each step. Count of sample used on each
  /// /                       step is computed as
  /// /                       int(total_samples_count * subsample_portion).
  /// / shrinkage           - regularization parameter.
  /// /                       Each tree prediction is multiplied on shrinkage value.
  //
  //
  // struct CV_EXPORTS_W_MAP CvGBTreesParams : public CvDTreeParams
  // {
  // CV_PROP_RW int weak_count;
  // CV_PROP_RW int loss_function_type;
  // CV_PROP_RW float subsample_portion;
  // CV_PROP_RW float shrinkage;
  //
  // CvGBTreesParams();
  // CvGBTreesParams( int loss_function_type, int weak_count, float shrinkage,
  // float subsample_portion, int max_depth, bool use_surrogates );
  // };
  //
  /// / DataType: CLASS CvGBTrees
  /// / Gradient Boosting Trees (GBT) algorithm implementation.
  /// /
  /// / data             - training dataset
  /// / params           - parameters of the CvGBTrees
  /// / weak             - array[0..(class_count-1)] of CvSeq
  /// /                    for storing tree ensembles
  /// / orig_response    - original responses of the training set samples
  /// / sum_response     - predicitons of the current model on the training dataset.
  /// /                    this matrix is updated on every iteration.
  /// / sum_response_tmp - predicitons of the model on the training set on the next
  /// /                    step. On every iteration values of sum_responses_tmp are
  /// /                    computed via sum_responses values. When the current
  /// /                    step is complete sum_response values become equal to
  /// /                    sum_responses_tmp.
  /// / sampleIdx       - indices of samples used for training the ensemble.
  /// /                    CvGBTrees training procedure takes a set of samples
  /// /                    (train_data) and a set of responses (responses).
  /// /                    Only pairs (train_data[i], responses[i]), where i is
  /// /                    in sample_idx are used for training the ensemble.
  /// / subsample_train  - indices of samples used for training a single decision
  /// /                    tree on the current step. This indices are countered
  /// /                    relatively to the sample_idx, so that pairs
  /// /                    (train_data[sample_idx[i]], responses[sample_idx[i]])
  /// /                    are used for training a decision tree.
  /// /                    Training set is randomly splited
  /// /                    in two parts (subsample_train and subsample_test)
  /// /                    on every iteration accordingly to the portion parameter.
  /// / subsample_test   - relative indices of samples from the training set,
  /// /                    which are not used for training a tree on the current
  /// /                    step.
  /// / missing          - mask of the missing values in the training set. This
  /// /                    matrix has the same size as train_data. 1 - missing
  /// /                    value, 0 - not a missing value.
  /// / class_labels     - output class labels map.
  /// / rng              - random number generator. Used for spliting the
  /// /                    training set.
  /// / class_count      - count of output classes.
  /// /                    class_count == 1 in the case of regression,
  /// /                    and > 1 in the case of classification.
  /// / delta            - Huber loss function parameter.
  /// / base_value       - start point of the gradient descent procedure.
  /// /                    model prediction is
  /// /                    f(x) = f_0 + sum_{i=1..weak_count-1}(f_i(x)), where
  /// /                    f_0 is the base value.
  //
  //
  //
  // class CV_EXPORTS_W CvGBTrees : public CvStatModel
  // {
  // public:
  //
  // /*
  // // DataType: ENUM
  // // Loss functions implemented in CvGBTrees.
  // //
  // // SQUARED_LOSS
  // // problem: regression
  // // loss = (x - x')^2
  // //
  // // ABSOLUTE_LOSS
  // // problem: regression
  // // loss = abs(x - x')
  // //
  // // HUBER_LOSS
  // // problem: regression
  // // loss = delta*( abs(x - x') - delta/2), if abs(x - x') > delta
  // //           1/2*(x - x')^2, if abs(x - x') <= delta,
  // //           where delta is the alpha-quantile of pseudo responses from
  // //           the training set.
  // //
  // // DEVIANCE_LOSS
  // // problem: classification
  // //
  // */
  // enum {SQUARED_LOSS=0, ABSOLUTE_LOSS, HUBER_LOSS=3, DEVIANCE_LOSS};
  //
  //
  // /*
  // // Default constructor. Creates a model only (without training).
  // // Should be followed by one form of the train(...) function.
  // //
  // // API
  // // CvGBTrees();
  //
  // // INPUT
  // // OUTPUT
  // // RESULT
  // */
  // CV_WRAP CvGBTrees();
  //
  //
  // /*
  // // Full form constructor. Creates a gradient boosting model and does the
  // // train.
  // //
  // // API
  // // CvGBTrees( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvGBTreesParams params=CvGBTreesParams() );
  //
  // // INPUT
  // // trainData    - a set of input feature vectors.
  // //                  size of matrix is
  // //                  <count of samples> x <variables count>
  // //                  or <variables count> x <count of samples>
  // //                  depending on the tflag parameter.
  // //                  matrix values are float.
  // // tflag         - a flag showing how do samples stored in the
  // //                  trainData matrix row by row (tflag=CV_ROW_SAMPLE)
  // //                  or column by column (tflag=CV_COL_SAMPLE).
  // // responses     - a vector of responses corresponding to the samples
  // //                  in trainData.
  // // varIdx       - indices of used variables. zero value means that all
  // //                  variables are active.
  // // sampleIdx    - indices of used samples. zero value means that all
  // //                  samples from trainData are in the training set.
  // // varType      - vector of <variables count> length. gives every
  // //                  variable type CV_VAR_CATEGORICAL or CV_VAR_ORDERED.
  // //                  varType = 0 means all variables are numerical.
  // // missingDataMask  - a mask of misiing values in trainData.
  // //                  missingDataMask = 0 means that there are no missing
  // //                  values.
  // // params         - parameters of GTB algorithm.
  // // OUTPUT
  // // RESULT
  // */
  // CvGBTrees( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvGBTreesParams params=CvGBTreesParams() );
  //
  //
  // /*
  // // Destructor.
  // */
  // virtual ~CvGBTrees();
  //
  //
  // /*
  // // Gradient tree boosting model training
  // //
  // // API
  // // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvGBTreesParams params=CvGBTreesParams(),
  // bool update=false );
  //
  // // INPUT
  // // trainData    - a set of input feature vectors.
  // //                  size of matrix is
  // //                  <count of samples> x <variables count>
  // //                  or <variables count> x <count of samples>
  // //                  depending on the tflag parameter.
  // //                  matrix values are float.
  // // tflag         - a flag showing how do samples stored in the
  // //                  trainData matrix row by row (tflag=CV_ROW_SAMPLE)
  // //                  or column by column (tflag=CV_COL_SAMPLE).
  // // responses     - a vector of responses corresponding to the samples
  // //                  in trainData.
  // // varIdx       - indices of used variables. zero value means that all
  // //                  variables are active.
  // // sampleIdx    - indices of used samples. zero value means that all
  // //                  samples from trainData are in the training set.
  // // varType      - vector of <variables count> length. gives every
  // //                  variable type CV_VAR_CATEGORICAL or CV_VAR_ORDERED.
  // //                  varType = 0 means all variables are numerical.
  // // missingDataMask  - a mask of misiing values in trainData.
  // //                  missingDataMask = 0 means that there are no missing
  // //                  values.
  // // params         - parameters of GTB algorithm.
  // // update         - is not supported now. (!)
  // // OUTPUT
  // // RESULT
  // // Error state.
  // */
  // virtual bool train( const CvMat* trainData, int tflag,
  // const CvMat* responses, const CvMat* varIdx=0,
  // const CvMat* sampleIdx=0, const CvMat* varType=0,
  // const CvMat* missingDataMask=0,
  // CvGBTreesParams params=CvGBTreesParams(),
  // bool update=false );
  //
  //
  // /*
  // // Gradient tree boosting model training
  // //
  // // API
  // // virtual bool train( CvMLData* data,
  // CvGBTreesParams params=CvGBTreesParams(),
  // bool update=false ) {return false;};
  //
  // // INPUT
  // // data          - training set.
  // // params        - parameters of GTB algorithm.
  // // update        - is not supported now. (!)
  // // OUTPUT
  // // RESULT
  // // Error state.
  // */
  // virtual bool train( CvMLData* data,
  // CvGBTreesParams params=CvGBTreesParams(),
  // bool update=false );
  //
  //
  // /*
  // // Response value prediction
  // //
  // // API
  // // virtual float predict_serial( const CvMat* sample, const CvMat* missing=0,
  // CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
  // int k=-1 ) const;
  //
  // // INPUT
  // // sample         - input sample of the same type as in the training set.
  // // missing        - missing values mask. missing=0 if there are no
  // //                   missing values in sample vector.
  // // weak_responses  - predictions of all of the trees.
  // //                   not implemented (!)
  // // slice           - part of the ensemble used for prediction.
  // //                   slice = CV_WHOLE_SEQ when all trees are used.
  // // k               - number of ensemble used.
  // //                   k is in {-1,0,1,..,<count of output classes-1>}.
  // //                   in the case of classification problem
  // //                   <count of output classes-1> ensembles are built.
  // //                   If k = -1 ordinary prediction is the result,
  // //                   otherwise function gives the prediction of the
  // //                   k-th ensemble only.
  // // OUTPUT
  // // RESULT
  // // Predicted value.
  // */
  // virtual float predict_serial( const CvMat* sample, const CvMat* missing=0,
  // CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ,
  // int k=-1 ) const;
  //
  // /*
  // // Response value prediction.
  // // Parallel version (in the case of TBB existence)
  // //
  // // API
  // // virtual float predict( const CvMat* sample, const CvMat* missing=0,
  // CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
  // int k=-1 ) const;
  //
  // // INPUT
  // // sample         - input sample of the same type as in the training set.
  // // missing        - missing values mask. missing=0 if there are no
  // //                   missing values in sample vector.
  // // weak_responses  - predictions of all of the trees.
  // //                   not implemented (!)
  // // slice           - part of the ensemble used for prediction.
  // //                   slice = CV_WHOLE_SEQ when all trees are used.
  // // k               - number of ensemble used.
  // //                   k is in {-1,0,1,..,<count of output classes-1>}.
  // //                   in the case of classification problem
  // //                   <count of output classes-1> ensembles are built.
  // //                   If k = -1 ordinary prediction is the result,
  // //                   otherwise function gives the prediction of the
  // //                   k-th ensemble only.
  // // OUTPUT
  // // RESULT
  // // Predicted value.
  // */
  // virtual float predict( const CvMat* sample, const CvMat* missing=0,
  // CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ,
  // int k=-1 ) const;
  //
  // /*
  // // Deletes all the data.
  // //
  // // API
  // // virtual void clear();
  //
  // // INPUT
  // // OUTPUT
  // // delete data, weak, orig_response, sum_response,
  // //        weak_eval, subsample_train, subsample_test,
  // //        sample_idx, missing, lass_labels
  // // delta = 0.0
  // // RESULT
  // */
  // CV_WRAP virtual void clear();
  //
  // /*
  // // Compute error on the train/test set.
  // //
  // // API
  // // virtual float calc_error( CvMLData* _data, int type,
  // //        std::vector<float> *resp = 0 );
  // //
  // // INPUT
  // // data  - dataset
  // // type  - defines which error is to compute: train (CV_TRAIN_ERROR) or
  // //         test (CV_TEST_ERROR).
  // // OUTPUT
  // // resp  - vector of predicitons
  // // RESULT
  // // Error value.
  // */
  // virtual float calc_error( CvMLData* _data, int type,
  // std::vector<float> *resp = 0 );
  //
  // /*
  // //
  // // Write parameters of the gtb model and data. Write learned model.
  // //
  // // API
  // // virtual void write( CvFileStorage* fs, const char* name ) const;
  // //
  // // INPUT
  // // fs     - file storage to read parameters from.
  // // name   - model name.
  // // OUTPUT
  // // RESULT
  // */
  // virtual void write( CvFileStorage* fs, const char* name ) const;
  //
  //
  // /*
  // //
  // // Read parameters of the gtb model and data. Read learned model.
  // //
  // // API
  // // virtual void read( CvFileStorage* fs, CvFileNode* node );
  // //
  // // INPUT
  // // fs     - file storage to read parameters from.
  // // node   - file node.
  // // OUTPUT
  // // RESULT
  // */
  // virtual void read( CvFileStorage* fs, CvFileNode* node );
  //
  //
  // // new-style C++ interface
  // CV_WRAP CvGBTrees( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvGBTreesParams params=CvGBTreesParams() );
  //
  // CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
  // const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
  // const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
  // const cv::Mat& missingDataMask=cv::Mat(),
  // CvGBTreesParams params=CvGBTreesParams(),
  // bool update=false );
  //
  // CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(),
  // const cv::Range& slice = cv::Range::all(),
  // int k=-1 ) const;
  //
  // protected:
  //
  // /*
  // // Compute the gradient vector components.
  // //
  // // API
  // // virtual void find_gradient( const int k = 0);
  //
  // // INPUT
  // // k        - used for classification problem, determining current
  // //            tree ensemble.
  // // OUTPUT
  // // changes components of data->responses
  // // which correspond to samples used for training
  // // on the current step.
  // // RESULT
  // */
  // virtual void find_gradient( const int k = 0);
  //
  //
  // /*
  // //
  // // Change values in tree leaves according to the used loss function.
  // //
  // // API
  // // virtual void change_values(CvDTree* tree, const int k = 0);
  // //
  // // INPUT
  // // tree      - decision tree to change.
  // // k         - used for classification problem, determining current
  // //             tree ensemble.
  // // OUTPUT
  // // changes 'value' fields of the trees' leaves.
  // // changes sum_response_tmp.
  // // RESULT
  // */
  // virtual void change_values(CvDTree* tree, const int k = 0);
  //
  //
  // /*
  // //
  // // Find optimal constant prediction value according to the used loss
  // // function.
  // // The goal is to find a constant which gives the minimal summary loss
  // // on the _Idx samples.
  // //
  // // API
  // // virtual float find_optimal_value( const CvMat* _Idx );
  // //
  // // INPUT
  // // _Idx        - indices of the samples from the training set.
  // // OUTPUT
  // // RESULT
  // // optimal constant value.
  // */
  // virtual float find_optimal_value( const CvMat* _Idx );
  //
  //
  // /*
  // //
  // // Randomly split the whole training set in two parts according
  // // to params.portion.
  // //
  // // API
  // // virtual void do_subsample();
  // //
  // // INPUT
  // // OUTPUT
  // // subsample_train - indices of samples used for training
  // // subsample_test  - indices of samples used for test
  // // RESULT
  // */
  // virtual void do_subsample();
  //
  //
  // /*
  // //
  // // Internal recursive function giving an array of subtree tree leaves.
  // //
  // // API
  // // void leaves_get( CvDTreeNode** leaves, int& count, CvDTreeNode* node );
  // //
  // // INPUT
  // // node         - current leaf.
  // // OUTPUT
  // // count        - count of leaves in the subtree.
  // // leaves       - array of pointers to leaves.
  // // RESULT
  // */
  // void leaves_get( CvDTreeNode** leaves, int& count, CvDTreeNode* node );
  //
  //
  // /*
  // //
  // // Get leaves of the tree.
  // //
  // // API
  // // CvDTreeNode** GetLeaves( const CvDTree* dtree, int& len );
  // //
  // // INPUT
  // // dtree            - decision tree.
  // // OUTPUT
  // // len              - count of the leaves.
  // // RESULT
  // // CvDTreeNode**    - array of pointers to leaves.
  // */
  // CvDTreeNode** GetLeaves( const CvDTree* dtree, int& len );
  //
  //
  // /*
  // //
  // // Is it a regression or a classification.
  // //
  // // API
  // // bool problem_type();
  // //
  // // INPUT
  // // OUTPUT
  // // RESULT
  // // false if it is a classification problem,
  // // true - if regression.
  // */
  // virtual bool problem_type() const;
  //
  //
  // /*
  // //
  // // Write parameters of the gtb model.
  // //
  // // API
  // // virtual void write_params( CvFileStorage* fs ) const;
  // //
  // // INPUT
  // // fs           - file storage to write parameters to.
  // // OUTPUT
  // // RESULT
  // */
  // virtual void write_params( CvFileStorage* fs ) const;
  //
  //
  // /*
  // //
  // // Read parameters of the gtb model and data.
  // //
  // // API
  // // virtual void read_params( CvFileStorage* fs );
  // //
  // // INPUT
  // // fs           - file storage to read parameters from.
  // // OUTPUT
  // // params       - parameters of the gtb model.
  // // data         - contains information about the structure
  // //                of the data set (count of variables,
  // //                their types, etc.).
  // // class_labels - output class labels map.
  // // RESULT
  // */
  // virtual void read_params( CvFileStorage* fs, CvFileNode* fnode );
  // int get_len(const CvMat* mat) const;
  //
  //
  // CvDTreeTrainData* data;
  // CvGBTreesParams params;
  //
  // CvSeq** weak;
  // CvMat* orig_response;
  // CvMat* sum_response;
  // CvMat* sum_response_tmp;
  // CvMat* sample_idx;
  // CvMat* subsample_train;
  // CvMat* subsample_test;
  // CvMat* missing;
  // CvMat* class_labels;
  //
  // cv::RNG* rng;
  //
  // int class_count;
  // float delta;
  // float base_value;
  //
  // };
  //
  //
  //
  /// ****************************************************************************************\
  // *                              Artificial Neural Networks (ANN)                          *
  // \****************************************************************************************/
  //
  /// ////////////////////////////////// Multi-Layer Perceptrons //////////////////////////////
  //
  // struct CV_EXPORTS_W_MAP CvANN_MLP_TrainParams
  // {
  // CvANN_MLP_TrainParams();
  // CvANN_MLP_TrainParams( CvTermCriteria term_crit, int train_method,
  // double param1, double param2=0 );
  // ~CvANN_MLP_TrainParams();
  //
  // enum { BACKPROP=0, RPROP=1 };
  //
  // CV_PROP_RW CvTermCriteria term_crit;
  // CV_PROP_RW int train_method;
  //
  // // backpropagation parameters
  // CV_PROP_RW double bp_dw_scale, bp_moment_scale;
  //
  // // rprop parameters
  // CV_PROP_RW double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max;
  // };
  //
  //
  // class CV_EXPORTS_W CvANN_MLP : public CvStatModel
  // {
  // public:
  // CV_WRAP CvANN_MLP();
  // CvANN_MLP( const CvMat* layerSizes,
  // int activateFunc=CvANN_MLP::SIGMOID_SYM,
  // double fparam1=0, double fparam2=0 );
  //
  // virtual ~CvANN_MLP();
  //
  // virtual void create( const CvMat* layerSizes,
  // int activateFunc=CvANN_MLP::SIGMOID_SYM,
  // double fparam1=0, double fparam2=0 );
  //
  // virtual int train( const CvMat* inputs, const CvMat* outputs,
  // const CvMat* sampleWeights, const CvMat* sampleIdx=0,
  // CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(),
  // int flags=0 );
  // virtual float predict( const CvMat* inputs, CV_OUT CvMat* outputs ) const;
  //
  // CV_WRAP CvANN_MLP( const cv::Mat& layerSizes,
  // int activateFunc=CvANN_MLP::SIGMOID_SYM,
  // double fparam1=0, double fparam2=0 );
  //
  // CV_WRAP virtual void create( const cv::Mat& layerSizes,
  // int activateFunc=CvANN_MLP::SIGMOID_SYM,
  // double fparam1=0, double fparam2=0 );
  //
  // CV_WRAP virtual int train( const cv::Mat& inputs, const cv::Mat& outputs,
  // const cv::Mat& sampleWeights, const cv::Mat& sampleIdx=cv::Mat(),
  // CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(),
  // int flags=0 );
  //
  // CV_WRAP virtual float predict( const cv::Mat& inputs, CV_OUT cv::Mat& outputs ) const;
  //
  // CV_WRAP virtual void clear();
  //
  // // possible activation functions
  // enum { IDENTITY = 0, SIGMOID_SYM = 1, GAUSSIAN = 2 };
  //
  // // available training flags
  // enum { UPDATE_WEIGHTS = 1, NO_INPUT_SCALE = 2, NO_OUTPUT_SCALE = 4 };
  //
  // virtual void read( CvFileStorage* fs, CvFileNode* node );
  // virtual void write( CvFileStorage* storage, const char* name ) const;
  //
  // int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; }
  // const CvMat* get_layer_sizes() { return layer_sizes; }
  // double* get_weights(int layer)
  // {
  // return layer_sizes && weights &&
  // (unsigned)layer <= (unsigned)layer_sizes->cols ? weights[layer] : 0;
  // }
  //
  // virtual void calc_activ_func_deriv( CvMat* xf, CvMat* deriv, const double* bias ) const;
  //
  // protected:
  //
  // virtual bool prepare_to_train( const CvMat* _inputs, const CvMat* _outputs,
  // const CvMat* _sample_weights, const CvMat* sampleIdx,
  // CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags );
  //
  // // sequential random backpropagation
  // virtual int train_backprop( CvVectors _ivecs, CvVectors _ovecs, const double* _sw );
  //
  // // RPROP algorithm
  // virtual int train_rprop( CvVectors _ivecs, CvVectors _ovecs, const double* _sw );
  //
  // virtual void calc_activ_func( CvMat* xf, const double* bias ) const;
  // virtual void set_activ_func( int _activ_func=SIGMOID_SYM,
  // double _f_param1=0, double _f_param2=0 );
  // virtual void init_weights();
  // virtual void scale_input( const CvMat* _src, CvMat* _dst ) const;
  // virtual void scale_output( const CvMat* _src, CvMat* _dst ) const;
  // virtual void calc_input_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 read_params( CvFileStorage* fs, CvFileNode* node );
  //
  // CvMat* layer_sizes;
  // CvMat* wbuf;
  // CvMat* sample_weights;
  // double** weights;
  // double f_param1, f_param2;
  // double min_val, max_val, min_val1, max_val1;
  // int activ_func;
  // int max_count, max_buf_sz;
  // CvANN_MLP_TrainParams params;
  // cv::RNG* rng;
  // };
  //
  /// ****************************************************************************************\
  // *                           Auxilary functions declarations                              *
  // \****************************************************************************************/
  //
  /// * Generates <sample> from multivariate normal distribution, where <mean> - is an
  // average row vector, <cov> - symmetric covariation matrix */
  // CVAPI(void) cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample,
  // CvRNG* rng CV_DEFAULT(0) );
  //
  /// * Generates sample from gaussian mixture distribution */
  // CVAPI(void) cvRandGaussMixture( CvMat* means[],
  // CvMat* covs[],
  // float weights[],
  // int clsnum,
  // CvMat* sample,
  // CvMat* sampClasses CV_DEFAULT(0) );
  //
  // #define CV_TS_CONCENTRIC_SPHERES 0
  //
  /// * creates test set */
  // CVAPI(void) cvCreateTestSet( int type, CvMat** samples,
  // int num_samples,
  // int num_features,
  // CvMat** responses,
  // int num_classes, ... );
  //
  /// ****************************************************************************************\
  // *                                      Data                                             *
  // \****************************************************************************************/
  //
  // #define CV_COUNT     0
  // #define CV_PORTION   1
  //
  // struct CV_EXPORTS CvTrainTestSplit
  // {
  // CvTrainTestSplit();
  // CvTrainTestSplit( int train_sample_count, bool mix = true);
  // CvTrainTestSplit( float train_sample_portion, bool mix = true);
  //
  // union
  // {
  // int count;
  // float portion;
  // } train_sample_part;
  // int train_sample_part_mode;
  //
  // bool mix;
  // };
  //
  // class CV_EXPORTS CvMLData
  // {
  // public:
  // CvMLData();
  // virtual ~CvMLData();
  //
  // // returns:
  // // 0 - OK
  // // -1 - file can not be opened or is not correct
  // int read_csv( const char* filename );
  //
  // const CvMat* get_values() const;
  // const CvMat* get_responses();
  // const CvMat* get_missing() const;
  //
  // void set_header_lines_number( int n );
  // int get_header_lines_number() const;
  //
  // void set_response_idx( int idx ); // old response become predictors, new response_idx = idx
  // // if idx < 0 there will be no response
  // int get_response_idx() const;
  //
  // void set_train_test_split( const CvTrainTestSplit * spl );
  // const CvMat* get_train_sample_idx() const;
  // const CvMat* get_test_sample_idx() const;
  // void mix_train_and_test_idx();
  //
  // const CvMat* get_var_idx();
  // void chahge_var_idx( int vi, bool state ); // misspelled (saved for back compitability),
  // // use change_var_idx
  // void change_var_idx( int vi, bool state ); // state == true to set vi-variable as predictor
  //
  // const CvMat* get_var_types();
  // int get_var_type( int var_idx ) const;
  // // following 2 methods enable to change vars type
  // // use these methods to assign CV_VAR_CATEGORICAL type for categorical variable
  // // with numerical labels; in the other cases var types are correctly determined automatically
  // void set_var_types( const char* str );  // str examples:
  // // "ord[0-17],cat[18]", "ord[0,2,4,10-12], cat[1,3,5-9,13,14]",
  // // "cat", "ord" (all vars are categorical/ordered)
  // void change_var_type( int var_idx, int type); // type in { CV_VAR_ORDERED, CV_VAR_CATEGORICAL }
  //
  // void set_delimiter( char ch );
  // char get_delimiter() const;
  //
  // void set_miss_ch( char ch );
  // char get_miss_ch() const;
  //
  // const std::map<cv::String, int>& get_class_labels_map() const;
  //
  // protected:
  // virtual void clear();
  //
  // void str_to_flt_elem( const char* token, float& flt_elem, int& type);
  // void free_train_test_idx();
  //
  // char delimiter;
  // char miss_ch;
  // //char flt_separator;
  //
  // CvMat* values;
  // CvMat* missing;
  // CvMat* var_types;
  // CvMat* var_idx_mask;
  //
  // CvMat* response_out; // header
  // CvMat* var_idx_out; // mat
  // CvMat* var_types_out; // mat
  //
  // int header_lines_number;
  //
  // int response_idx;
  //
  // int train_sample_count;
  // bool mix;
  //
  // int total_class_count;
  // std::map<cv::String, int> class_map;
  //
  // CvMat* train_sample_idx;
  // CvMat* test_sample_idx;
  // int* sample_idx; // data of train_sample_idx and test_sample_idx
  //
  // cv::RNG* rng;
  // };
  //
  //
  // namespace cv
  // {
  //
  // typedef CvStatModel StatModel;
  // typedef CvParamGrid ParamGrid;
  // typedef CvNormalBayesClassifier NormalBayesClassifier;
  // typedef CvKNearest KNearest;
  // typedef CvSVMParams SVMParams;
  // typedef CvSVMKernel SVMKernel;
  // typedef CvSVMSolver SVMSolver;
  // typedef CvSVM SVM;
  // typedef CvDTreeParams DTreeParams;
  // typedef CvMLData TrainData;
  // typedef CvDTree DecisionTree;
  // typedef CvForestTree ForestTree;
  // typedef CvRTParams RandomTreeParams;
  // typedef CvRTrees RandomTrees;
  // typedef CvERTreeTrainData ERTreeTRainData;
  // typedef CvForestERTree ERTree;
  // typedef CvERTrees ERTrees;
  // typedef CvBoostParams BoostParams;
  // typedef CvBoostTree BoostTree;
  // typedef CvBoost Boost;
  // typedef CvANN_MLP_TrainParams ANN_MLP_TrainParams;
  // typedef CvANN_MLP NeuralNet_MLP;
  // typedef CvGBTreesParams GradientBoostingTreeParams;
  // typedef CvGBTrees GradientBoostingTrees;
  //
  // template<> CV_EXPORTS void Ptr<CvDTreeSplit>::delete_obj();
  //
  // CV_EXPORTS bool initModule_ml(void);
  // }

  // function CreateCvKNearest: TCvKNearest; stdcall; overload;
  // function CreateCvKNearest(const trainData: pCvMat; const responses: pCvMat; const sampleIdx: pCvMat = nil;
  // isRegression: bool = false; max_k: Integer = 32): TCvKNearest; stdcall; overload;
  // procedure ReleaseCvKNearest(ex: TCvKNearest); stdcall;

implementation

uses ocv.lib;

function CreateCvKNearest: TCvKNearest; stdcall; external opencv_classes_lib; overload;
function CreateCvKNearest(const trainData: pCvMat; const responses: pCvMat; const sampleIdx: pCvMat = nil;
  isRegression: bool = false; max_k: Integer = 32): TCvKNearest; stdcall; external opencv_classes_lib; overload;
procedure ReleaseCvKNearest(ex: TCvKNearest); stdcall; external opencv_classes_lib;

{ TCvDTreeNode }

function TCvDTreeNode.get_num_valid(vi: Integer): Integer;
begin
  if num_valid = nil then
    Result := sample_count
  else
    Result := num_valid[vi];
end;

procedure TCvDTreeNode.set_num_valid(vi, n: Integer);
begin
  if num_valid <> nil then
    num_valid[vi] := n;
end;

{ TCvKNearest }

class function TCvKNearest.Create: TCvKNearest;
begin
  Result := CreateCvKNearest;
end;

class function TCvKNearest.Create(const trainData, responses, sampleIdx: pCvMat; isRegression: bool; max_k: Integer)
  : TCvKNearest;
begin
  Result := CreateCvKNearest(trainData, responses, sampleIdx, isRegression, max_k);
end;

procedure TCvKNearest.Free;
begin
  ReleaseCvKNearest(Self);
end;

end.