GHZMRSpaceXR/Assets/OpenCVForUnity/org/opencv/ml/RTrees.cs

using OpenCVForUnity.CoreModule;
using OpenCVForUnity.UtilsModule;
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace OpenCVForUnity.MlModule
{

    // C++: class RTrees
    /**
     * The class implements the random forest predictor.
     *
     * SEE: REF: ml_intro_rtrees
     */

    public class RTrees : DTrees
    {

        protected override void Dispose(bool disposing)
        {

            try
            {
                if (disposing)
                {
                }
                if (IsEnabledDispose)
                {
                    if (nativeObj != IntPtr.Zero)
                        ml_RTrees_delete(nativeObj);
                    nativeObj = IntPtr.Zero;
                }
            }
            finally
            {
                base.Dispose(disposing);
            }

        }

        protected internal RTrees(IntPtr addr) : base(addr) { }

        // internal usage only
        public static new RTrees __fromPtr__(IntPtr addr) { return new RTrees(addr); }

        //
        // C++:  bool cv::ml::RTrees::getCalculateVarImportance()
        //

        /**
         * SEE: setCalculateVarImportance
         * return automatically generated
         */
        public bool getCalculateVarImportance()
        {
            ThrowIfDisposed();

            return ml_RTrees_getCalculateVarImportance_10(nativeObj);


        }


        //
        // C++:  void cv::ml::RTrees::setCalculateVarImportance(bool val)
        //

        /**
         *  getCalculateVarImportance SEE: getCalculateVarImportance
         * param val automatically generated
         */
        public void setCalculateVarImportance(bool val)
        {
            ThrowIfDisposed();

            ml_RTrees_setCalculateVarImportance_10(nativeObj, val);


        }


        //
        // C++:  int cv::ml::RTrees::getActiveVarCount()
        //

        /**
         * SEE: setActiveVarCount
         * return automatically generated
         */
        public int getActiveVarCount()
        {
            ThrowIfDisposed();

            return ml_RTrees_getActiveVarCount_10(nativeObj);


        }


        //
        // C++:  void cv::ml::RTrees::setActiveVarCount(int val)
        //

        /**
         *  getActiveVarCount SEE: getActiveVarCount
         * param val automatically generated
         */
        public void setActiveVarCount(int val)
        {
            ThrowIfDisposed();

            ml_RTrees_setActiveVarCount_10(nativeObj, val);


        }


        //
        // C++:  TermCriteria cv::ml::RTrees::getTermCriteria()
        //

        /**
         * SEE: setTermCriteria
         * return automatically generated
         */
        public TermCriteria getTermCriteria()
        {
            ThrowIfDisposed();

            double[] tmpArray = new double[3];
            ml_RTrees_getTermCriteria_10(nativeObj, tmpArray);
            TermCriteria retVal = new TermCriteria(tmpArray);

            return retVal;
        }


        //
        // C++:  void cv::ml::RTrees::setTermCriteria(TermCriteria val)
        //

        /**
         *  getTermCriteria SEE: getTermCriteria
         * param val automatically generated
         */
        public void setTermCriteria(TermCriteria val)
        {
            ThrowIfDisposed();

            ml_RTrees_setTermCriteria_10(nativeObj, val.type, val.maxCount, val.epsilon);


        }


        //
        // C++:  Mat cv::ml::RTrees::getVarImportance()
        //

        /**
         * Returns the variable importance array.
         *     The method returns the variable importance vector, computed at the training stage when
         *     CalculateVarImportance is set to true. If this flag was set to false, the empty matrix is
         *     returned.
         * return automatically generated
         */
        public Mat getVarImportance()
        {
            ThrowIfDisposed();

            return new Mat(DisposableObject.ThrowIfNullIntPtr(ml_RTrees_getVarImportance_10(nativeObj)));


        }


        //
        // C++:  void cv::ml::RTrees::getVotes(Mat samples, Mat& results, int flags)
        //

        /**
         * Returns the result of each individual tree in the forest.
         *     In case the model is a regression problem, the method will return each of the trees'
         *     results for each of the sample cases. If the model is a classifier, it will return
         *     a Mat with samples + 1 rows, where the first row gives the class number and the
         *     following rows return the votes each class had for each sample.
         *         param samples Array containing the samples for which votes will be calculated.
         *         param results Array where the result of the calculation will be written.
         *         param flags Flags for defining the type of RTrees.
         */
        public void getVotes(Mat samples, Mat results, int flags)
        {
            ThrowIfDisposed();
            if (samples != null) samples.ThrowIfDisposed();
            if (results != null) results.ThrowIfDisposed();

            ml_RTrees_getVotes_10(nativeObj, samples.nativeObj, results.nativeObj, flags);


        }


        //
        // C++:  double cv::ml::RTrees::getOOBError()
        //

        /**
         * Returns the OOB error value, computed at the training stage when calcOOBError is set to true.
         * If this flag was set to false, 0 is returned. The OOB error is also scaled by sample weighting.
         * return automatically generated
         */
        public double getOOBError()
        {
            ThrowIfDisposed();

            return ml_RTrees_getOOBError_10(nativeObj);


        }


        //
        // C++: static Ptr_RTrees cv::ml::RTrees::create()
        //

        /**
         * Creates the empty model.
         *     Use StatModel::train to train the model, StatModel::train to create and train the model,
         *     Algorithm::load to load the pre-trained model.
         * return automatically generated
         */
        public static new RTrees create()
        {


            return RTrees.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(ml_RTrees_create_10()));


        }


        //
        // C++: static Ptr_RTrees cv::ml::RTrees::load(String filepath, String nodeName = String())
        //

        /**
         * Loads and creates a serialized RTree from a file
         *
         * Use RTree::save to serialize and store an RTree to disk.
         * Load the RTree from this file again, by calling this function with the path to the file.
         * Optionally specify the node for the file containing the classifier
         *
         * param filepath path to serialized RTree
         * param nodeName name of node containing the classifier
         * return automatically generated
         */
        public static new RTrees load(string filepath, string nodeName)
        {


            return RTrees.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(ml_RTrees_load_10(filepath, nodeName)));


        }

        /**
         * Loads and creates a serialized RTree from a file
         *
         * Use RTree::save to serialize and store an RTree to disk.
         * Load the RTree from this file again, by calling this function with the path to the file.
         * Optionally specify the node for the file containing the classifier
         *
         * param filepath path to serialized RTree
         * return automatically generated
         */
        public static new RTrees load(string filepath)
        {


            return RTrees.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(ml_RTrees_load_11(filepath)));


        }


#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
        const string LIBNAME = "__Internal";
#else
        const string LIBNAME = "opencvforunity";
#endif



        // C++:  bool cv::ml::RTrees::getCalculateVarImportance()
        [DllImport(LIBNAME)]
        [return: MarshalAs(UnmanagedType.U1)]
        private static extern bool ml_RTrees_getCalculateVarImportance_10(IntPtr nativeObj);

        // C++:  void cv::ml::RTrees::setCalculateVarImportance(bool val)
        [DllImport(LIBNAME)]
        private static extern void ml_RTrees_setCalculateVarImportance_10(IntPtr nativeObj, [MarshalAs(UnmanagedType.U1)] bool val);

        // C++:  int cv::ml::RTrees::getActiveVarCount()
        [DllImport(LIBNAME)]
        private static extern int ml_RTrees_getActiveVarCount_10(IntPtr nativeObj);

        // C++:  void cv::ml::RTrees::setActiveVarCount(int val)
        [DllImport(LIBNAME)]
        private static extern void ml_RTrees_setActiveVarCount_10(IntPtr nativeObj, int val);

        // C++:  TermCriteria cv::ml::RTrees::getTermCriteria()
        [DllImport(LIBNAME)]
        private static extern void ml_RTrees_getTermCriteria_10(IntPtr nativeObj, double[] retVal);

        // C++:  void cv::ml::RTrees::setTermCriteria(TermCriteria val)
        [DllImport(LIBNAME)]
        private static extern void ml_RTrees_setTermCriteria_10(IntPtr nativeObj, int val_type, int val_maxCount, double val_epsilon);

        // C++:  Mat cv::ml::RTrees::getVarImportance()
        [DllImport(LIBNAME)]
        private static extern IntPtr ml_RTrees_getVarImportance_10(IntPtr nativeObj);

        // C++:  void cv::ml::RTrees::getVotes(Mat samples, Mat& results, int flags)
        [DllImport(LIBNAME)]
        private static extern void ml_RTrees_getVotes_10(IntPtr nativeObj, IntPtr samples_nativeObj, IntPtr results_nativeObj, int flags);

        // C++:  double cv::ml::RTrees::getOOBError()
        [DllImport(LIBNAME)]
        private static extern double ml_RTrees_getOOBError_10(IntPtr nativeObj);

        // C++: static Ptr_RTrees cv::ml::RTrees::create()
        [DllImport(LIBNAME)]
        private static extern IntPtr ml_RTrees_create_10();

        // C++: static Ptr_RTrees cv::ml::RTrees::load(String filepath, String nodeName = String())
        [DllImport(LIBNAME)]
        private static extern IntPtr ml_RTrees_load_10(string filepath, string nodeName);
        [DllImport(LIBNAME)]
        private static extern IntPtr ml_RTrees_load_11(string filepath);

        // native support for java finalize()
        [DllImport(LIBNAME)]
        private static extern void ml_RTrees_delete(IntPtr nativeObj);

    }
}