GHZMRSpaceXR/Assets/OpenCVForUnity/org/opencv_contrib/bgsegm/Bgsegm.cs

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

namespace OpenCVForUnity.BgsegmModule
{
    // C++: class Bgsegm


    public class Bgsegm
    {

        // C++: enum cv.bgsegm.LSBPCameraMotionCompensation
        public const int LSBP_CAMERA_MOTION_COMPENSATION_NONE = 0;
        public const int LSBP_CAMERA_MOTION_COMPENSATION_LK = 0 + 1;
        //
        // C++:  Ptr_BackgroundSubtractorMOG cv::bgsegm::createBackgroundSubtractorMOG(int history = 200, int nmixtures = 5, double backgroundRatio = 0.7, double noiseSigma = 0)
        //

        /**
         * Creates mixture-of-gaussian background subtractor
         *
         * param history Length of the history.
         * param nmixtures Number of Gaussian mixtures.
         * param backgroundRatio Background ratio.
         * param noiseSigma Noise strength (standard deviation of the brightness or each color channel). 0
         * means some automatic value.
         * return automatically generated
         */
        public static BackgroundSubtractorMOG createBackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma)
        {


            return BackgroundSubtractorMOG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorMOG_10(history, nmixtures, backgroundRatio, noiseSigma)));


        }

        /**
         * Creates mixture-of-gaussian background subtractor
         *
         * param history Length of the history.
         * param nmixtures Number of Gaussian mixtures.
         * param backgroundRatio Background ratio.
         * means some automatic value.
         * return automatically generated
         */
        public static BackgroundSubtractorMOG createBackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio)
        {


            return BackgroundSubtractorMOG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorMOG_11(history, nmixtures, backgroundRatio)));


        }

        /**
         * Creates mixture-of-gaussian background subtractor
         *
         * param history Length of the history.
         * param nmixtures Number of Gaussian mixtures.
         * means some automatic value.
         * return automatically generated
         */
        public static BackgroundSubtractorMOG createBackgroundSubtractorMOG(int history, int nmixtures)
        {


            return BackgroundSubtractorMOG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorMOG_12(history, nmixtures)));


        }

        /**
         * Creates mixture-of-gaussian background subtractor
         *
         * param history Length of the history.
         * means some automatic value.
         * return automatically generated
         */
        public static BackgroundSubtractorMOG createBackgroundSubtractorMOG(int history)
        {


            return BackgroundSubtractorMOG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorMOG_13(history)));


        }

        /**
         * Creates mixture-of-gaussian background subtractor
         *
         * means some automatic value.
         * return automatically generated
         */
        public static BackgroundSubtractorMOG createBackgroundSubtractorMOG()
        {


            return BackgroundSubtractorMOG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorMOG_14()));


        }


        //
        // C++:  Ptr_BackgroundSubtractorGMG cv::bgsegm::createBackgroundSubtractorGMG(int initializationFrames = 120, double decisionThreshold = 0.8)
        //

        /**
         * Creates a GMG Background Subtractor
         *
         * param initializationFrames number of frames used to initialize the background models.
         * param decisionThreshold Threshold value, above which it is marked foreground, else background.
         * return automatically generated
         */
        public static BackgroundSubtractorGMG createBackgroundSubtractorGMG(int initializationFrames, double decisionThreshold)
        {


            return BackgroundSubtractorGMG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGMG_10(initializationFrames, decisionThreshold)));


        }

        /**
         * Creates a GMG Background Subtractor
         *
         * param initializationFrames number of frames used to initialize the background models.
         * return automatically generated
         */
        public static BackgroundSubtractorGMG createBackgroundSubtractorGMG(int initializationFrames)
        {


            return BackgroundSubtractorGMG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGMG_11(initializationFrames)));


        }

        /**
         * Creates a GMG Background Subtractor
         *
         * return automatically generated
         */
        public static BackgroundSubtractorGMG createBackgroundSubtractorGMG()
        {


            return BackgroundSubtractorGMG.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGMG_12()));


        }


        //
        // C++:  Ptr_BackgroundSubtractorCNT cv::bgsegm::createBackgroundSubtractorCNT(int minPixelStability = 15, bool useHistory = true, int maxPixelStability = 15*60, bool isParallel = true)
        //

        /**
         * Creates a CNT Background Subtractor
         *
         * param minPixelStability number of frames with same pixel color to consider stable
         * param useHistory determines if we're giving a pixel credit for being stable for a long time
         * param maxPixelStability maximum allowed credit for a pixel in history
         * param isParallel determines if we're parallelizing the algorithm
         * return automatically generated
         */
        public static BackgroundSubtractorCNT createBackgroundSubtractorCNT(int minPixelStability, bool useHistory, int maxPixelStability, bool isParallel)
        {


            return BackgroundSubtractorCNT.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorCNT_10(minPixelStability, useHistory, maxPixelStability, isParallel)));


        }

        /**
         * Creates a CNT Background Subtractor
         *
         * param minPixelStability number of frames with same pixel color to consider stable
         * param useHistory determines if we're giving a pixel credit for being stable for a long time
         * param maxPixelStability maximum allowed credit for a pixel in history
         * return automatically generated
         */
        public static BackgroundSubtractorCNT createBackgroundSubtractorCNT(int minPixelStability, bool useHistory, int maxPixelStability)
        {


            return BackgroundSubtractorCNT.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorCNT_11(minPixelStability, useHistory, maxPixelStability)));


        }

        /**
         * Creates a CNT Background Subtractor
         *
         * param minPixelStability number of frames with same pixel color to consider stable
         * param useHistory determines if we're giving a pixel credit for being stable for a long time
         * return automatically generated
         */
        public static BackgroundSubtractorCNT createBackgroundSubtractorCNT(int minPixelStability, bool useHistory)
        {


            return BackgroundSubtractorCNT.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorCNT_12(minPixelStability, useHistory)));


        }

        /**
         * Creates a CNT Background Subtractor
         *
         * param minPixelStability number of frames with same pixel color to consider stable
         * return automatically generated
         */
        public static BackgroundSubtractorCNT createBackgroundSubtractorCNT(int minPixelStability)
        {


            return BackgroundSubtractorCNT.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorCNT_13(minPixelStability)));


        }

        /**
         * Creates a CNT Background Subtractor
         *
         * return automatically generated
         */
        public static BackgroundSubtractorCNT createBackgroundSubtractorCNT()
        {


            return BackgroundSubtractorCNT.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorCNT_14()));


        }


        //
        // C++:  Ptr_BackgroundSubtractorGSOC cv::bgsegm::createBackgroundSubtractorGSOC(int mc = LSBP_CAMERA_MOTION_COMPENSATION_NONE, int nSamples = 20, float replaceRate = 0.003f, float propagationRate = 0.01f, int hitsThreshold = 32, float alpha = 0.01f, float beta = 0.0022f, float blinkingSupressionDecay = 0.1f, float blinkingSupressionMultiplier = 0.1f, float noiseRemovalThresholdFacBG = 0.0004f, float noiseRemovalThresholdFacFG = 0.0008f)
        //

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * param alpha Scale coefficient for threshold.
         * param beta Bias coefficient for threshold.
         * param blinkingSupressionDecay Blinking supression decay factor.
         * param blinkingSupressionMultiplier Blinking supression multiplier.
         * param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
         * param noiseRemovalThresholdFacFG Strength of the noise removal for foreground points.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay, float blinkingSupressionMultiplier, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_10(mc, nSamples, replaceRate, propagationRate, hitsThreshold, alpha, beta, blinkingSupressionDecay, blinkingSupressionMultiplier, noiseRemovalThresholdFacBG, noiseRemovalThresholdFacFG)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * param alpha Scale coefficient for threshold.
         * param beta Bias coefficient for threshold.
         * param blinkingSupressionDecay Blinking supression decay factor.
         * param blinkingSupressionMultiplier Blinking supression multiplier.
         * param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay, float blinkingSupressionMultiplier, float noiseRemovalThresholdFacBG)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_11(mc, nSamples, replaceRate, propagationRate, hitsThreshold, alpha, beta, blinkingSupressionDecay, blinkingSupressionMultiplier, noiseRemovalThresholdFacBG)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * param alpha Scale coefficient for threshold.
         * param beta Bias coefficient for threshold.
         * param blinkingSupressionDecay Blinking supression decay factor.
         * param blinkingSupressionMultiplier Blinking supression multiplier.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay, float blinkingSupressionMultiplier)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_12(mc, nSamples, replaceRate, propagationRate, hitsThreshold, alpha, beta, blinkingSupressionDecay, blinkingSupressionMultiplier)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * param alpha Scale coefficient for threshold.
         * param beta Bias coefficient for threshold.
         * param blinkingSupressionDecay Blinking supression decay factor.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_13(mc, nSamples, replaceRate, propagationRate, hitsThreshold, alpha, beta, blinkingSupressionDecay)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * param alpha Scale coefficient for threshold.
         * param beta Bias coefficient for threshold.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_14(mc, nSamples, replaceRate, propagationRate, hitsThreshold, alpha, beta)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * param alpha Scale coefficient for threshold.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_15(mc, nSamples, replaceRate, propagationRate, hitsThreshold, alpha)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_16(mc, nSamples, replaceRate, propagationRate, hitsThreshold)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * param propagationRate Probability of propagating to neighbors.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate, float propagationRate)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_17(mc, nSamples, replaceRate, propagationRate)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param replaceRate Probability of replacing the old sample - how fast the model will update itself.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples, float replaceRate)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_18(mc, nSamples, replaceRate)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc, int nSamples)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_19(mc, nSamples)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * param mc Whether to use camera motion compensation.
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC(int mc)
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_110(mc)));


        }

        /**
         * Creates an instance of BackgroundSubtractorGSOC algorithm.
         *
         * Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
         *
         * return automatically generated
         */
        public static BackgroundSubtractorGSOC createBackgroundSubtractorGSOC()
        {


            return BackgroundSubtractorGSOC.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorGSOC_111()));


        }


        //
        // C++:  Ptr_BackgroundSubtractorLSBP cv::bgsegm::createBackgroundSubtractorLSBP(int mc = LSBP_CAMERA_MOTION_COMPENSATION_NONE, int nSamples = 20, int LSBPRadius = 16, float Tlower = 2.0f, float Tupper = 32.0f, float Tinc = 1.0f, float Tdec = 0.05f, float Rscale = 10.0f, float Rincdec = 0.005f, float noiseRemovalThresholdFacBG = 0.0004f, float noiseRemovalThresholdFacFG = 0.0008f, int LSBPthreshold = 8, int minCount = 2)
        //

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * param Rscale Scale coefficient for threshold values.
         * param Rincdec Increase/Decrease step for threshold values.
         * param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
         * param noiseRemovalThresholdFacFG Strength of the noise removal for foreground points.
         * param LSBPthreshold Threshold for LSBP binary string.
         * param minCount Minimal number of matches for sample to be considered as foreground.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG, int LSBPthreshold, int minCount)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_10(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec, Rscale, Rincdec, noiseRemovalThresholdFacBG, noiseRemovalThresholdFacFG, LSBPthreshold, minCount)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * param Rscale Scale coefficient for threshold values.
         * param Rincdec Increase/Decrease step for threshold values.
         * param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
         * param noiseRemovalThresholdFacFG Strength of the noise removal for foreground points.
         * param LSBPthreshold Threshold for LSBP binary string.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG, int LSBPthreshold)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_11(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec, Rscale, Rincdec, noiseRemovalThresholdFacBG, noiseRemovalThresholdFacFG, LSBPthreshold)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * param Rscale Scale coefficient for threshold values.
         * param Rincdec Increase/Decrease step for threshold values.
         * param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
         * param noiseRemovalThresholdFacFG Strength of the noise removal for foreground points.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_12(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec, Rscale, Rincdec, noiseRemovalThresholdFacBG, noiseRemovalThresholdFacFG)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * param Rscale Scale coefficient for threshold values.
         * param Rincdec Increase/Decrease step for threshold values.
         * param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_13(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec, Rscale, Rincdec, noiseRemovalThresholdFacBG)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * param Rscale Scale coefficient for threshold values.
         * param Rincdec Increase/Decrease step for threshold values.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_14(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec, Rscale, Rincdec)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * param Rscale Scale coefficient for threshold values.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_15(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec, Rscale)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * param Tdec Decrease step for T-values. See CITE: LGuo2016 for details.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_16(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc, Tdec)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * param Tinc Increase step for T-values. See CITE: LGuo2016 for details.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_17(mc, nSamples, LSBPRadius, Tlower, Tupper, Tinc)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * param Tupper Upper bound for T-values. See CITE: LGuo2016 for details.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_18(mc, nSamples, LSBPRadius, Tlower, Tupper)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * param Tlower Lower bound for T-values. See CITE: LGuo2016 for details.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius, float Tlower)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_19(mc, nSamples, LSBPRadius, Tlower)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * param LSBPRadius LSBP descriptor radius.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples, int LSBPRadius)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_110(mc, nSamples, LSBPRadius)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * param nSamples Number of samples to maintain at each point of the frame.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc, int nSamples)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_111(mc, nSamples)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * param mc Whether to use camera motion compensation.
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP(int mc)
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_112(mc)));


        }

        /**
         * Creates an instance of BackgroundSubtractorLSBP algorithm.
         *
         * Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at CITE: LGuo2016
         *
         * return automatically generated
         */
        public static BackgroundSubtractorLSBP createBackgroundSubtractorLSBP()
        {


            return BackgroundSubtractorLSBP.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createBackgroundSubtractorLSBP_113()));


        }


        //
        // C++:  Ptr_SyntheticSequenceGenerator cv::bgsegm::createSyntheticSequenceGenerator(Mat background, Mat _object, double amplitude = 2.0, double wavelength = 20.0, double wavespeed = 0.2, double objspeed = 6.0)
        //

        /**
         * Creates an instance of SyntheticSequenceGenerator.
         *
         * param background Background image for object.
         * param amplitude Amplitude of wave distortion applied to background.
         * param wavelength Length of waves in distortion applied to background.
         * param wavespeed How fast waves will move.
         * param objspeed How fast object will fly over background.
         * param _object automatically generated
         * return automatically generated
         */
        public static SyntheticSequenceGenerator createSyntheticSequenceGenerator(Mat background, Mat _object, double amplitude, double wavelength, double wavespeed, double objspeed)
        {
            if (background != null) background.ThrowIfDisposed();
            if (_object != null) _object.ThrowIfDisposed();

            return SyntheticSequenceGenerator.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createSyntheticSequenceGenerator_10(background.nativeObj, _object.nativeObj, amplitude, wavelength, wavespeed, objspeed)));


        }

        /**
         * Creates an instance of SyntheticSequenceGenerator.
         *
         * param background Background image for object.
         * param amplitude Amplitude of wave distortion applied to background.
         * param wavelength Length of waves in distortion applied to background.
         * param wavespeed How fast waves will move.
         * param _object automatically generated
         * return automatically generated
         */
        public static SyntheticSequenceGenerator createSyntheticSequenceGenerator(Mat background, Mat _object, double amplitude, double wavelength, double wavespeed)
        {
            if (background != null) background.ThrowIfDisposed();
            if (_object != null) _object.ThrowIfDisposed();

            return SyntheticSequenceGenerator.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createSyntheticSequenceGenerator_11(background.nativeObj, _object.nativeObj, amplitude, wavelength, wavespeed)));


        }

        /**
         * Creates an instance of SyntheticSequenceGenerator.
         *
         * param background Background image for object.
         * param amplitude Amplitude of wave distortion applied to background.
         * param wavelength Length of waves in distortion applied to background.
         * param _object automatically generated
         * return automatically generated
         */
        public static SyntheticSequenceGenerator createSyntheticSequenceGenerator(Mat background, Mat _object, double amplitude, double wavelength)
        {
            if (background != null) background.ThrowIfDisposed();
            if (_object != null) _object.ThrowIfDisposed();

            return SyntheticSequenceGenerator.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createSyntheticSequenceGenerator_12(background.nativeObj, _object.nativeObj, amplitude, wavelength)));


        }

        /**
         * Creates an instance of SyntheticSequenceGenerator.
         *
         * param background Background image for object.
         * param amplitude Amplitude of wave distortion applied to background.
         * param _object automatically generated
         * return automatically generated
         */
        public static SyntheticSequenceGenerator createSyntheticSequenceGenerator(Mat background, Mat _object, double amplitude)
        {
            if (background != null) background.ThrowIfDisposed();
            if (_object != null) _object.ThrowIfDisposed();

            return SyntheticSequenceGenerator.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createSyntheticSequenceGenerator_13(background.nativeObj, _object.nativeObj, amplitude)));


        }

        /**
         * Creates an instance of SyntheticSequenceGenerator.
         *
         * param background Background image for object.
         * param _object automatically generated
         * return automatically generated
         */
        public static SyntheticSequenceGenerator createSyntheticSequenceGenerator(Mat background, Mat _object)
        {
            if (background != null) background.ThrowIfDisposed();
            if (_object != null) _object.ThrowIfDisposed();

            return SyntheticSequenceGenerator.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(bgsegm_Bgsegm_createSyntheticSequenceGenerator_14(background.nativeObj, _object.nativeObj)));


        }


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



        // C++:  Ptr_BackgroundSubtractorMOG cv::bgsegm::createBackgroundSubtractorMOG(int history = 200, int nmixtures = 5, double backgroundRatio = 0.7, double noiseSigma = 0)
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorMOG_10(int history, int nmixtures, double backgroundRatio, double noiseSigma);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorMOG_11(int history, int nmixtures, double backgroundRatio);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorMOG_12(int history, int nmixtures);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorMOG_13(int history);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorMOG_14();

        // C++:  Ptr_BackgroundSubtractorGMG cv::bgsegm::createBackgroundSubtractorGMG(int initializationFrames = 120, double decisionThreshold = 0.8)
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGMG_10(int initializationFrames, double decisionThreshold);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGMG_11(int initializationFrames);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGMG_12();

        // C++:  Ptr_BackgroundSubtractorCNT cv::bgsegm::createBackgroundSubtractorCNT(int minPixelStability = 15, bool useHistory = true, int maxPixelStability = 15*60, bool isParallel = true)
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorCNT_10(int minPixelStability, [MarshalAs(UnmanagedType.U1)] bool useHistory, int maxPixelStability, [MarshalAs(UnmanagedType.U1)] bool isParallel);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorCNT_11(int minPixelStability, [MarshalAs(UnmanagedType.U1)] bool useHistory, int maxPixelStability);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorCNT_12(int minPixelStability, [MarshalAs(UnmanagedType.U1)] bool useHistory);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorCNT_13(int minPixelStability);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorCNT_14();

        // C++:  Ptr_BackgroundSubtractorGSOC cv::bgsegm::createBackgroundSubtractorGSOC(int mc = LSBP_CAMERA_MOTION_COMPENSATION_NONE, int nSamples = 20, float replaceRate = 0.003f, float propagationRate = 0.01f, int hitsThreshold = 32, float alpha = 0.01f, float beta = 0.0022f, float blinkingSupressionDecay = 0.1f, float blinkingSupressionMultiplier = 0.1f, float noiseRemovalThresholdFacBG = 0.0004f, float noiseRemovalThresholdFacFG = 0.0008f)
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_10(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay, float blinkingSupressionMultiplier, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_11(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay, float blinkingSupressionMultiplier, float noiseRemovalThresholdFacBG);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_12(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay, float blinkingSupressionMultiplier);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_13(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta, float blinkingSupressionDecay);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_14(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha, float beta);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_15(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold, float alpha);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_16(int mc, int nSamples, float replaceRate, float propagationRate, int hitsThreshold);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_17(int mc, int nSamples, float replaceRate, float propagationRate);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_18(int mc, int nSamples, float replaceRate);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_19(int mc, int nSamples);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_110(int mc);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorGSOC_111();

        // C++:  Ptr_BackgroundSubtractorLSBP cv::bgsegm::createBackgroundSubtractorLSBP(int mc = LSBP_CAMERA_MOTION_COMPENSATION_NONE, int nSamples = 20, int LSBPRadius = 16, float Tlower = 2.0f, float Tupper = 32.0f, float Tinc = 1.0f, float Tdec = 0.05f, float Rscale = 10.0f, float Rincdec = 0.005f, float noiseRemovalThresholdFacBG = 0.0004f, float noiseRemovalThresholdFacFG = 0.0008f, int LSBPthreshold = 8, int minCount = 2)
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_10(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG, int LSBPthreshold, int minCount);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_11(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG, int LSBPthreshold);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_12(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG, float noiseRemovalThresholdFacFG);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_13(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec, float noiseRemovalThresholdFacBG);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_14(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale, float Rincdec);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_15(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec, float Rscale);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_16(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc, float Tdec);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_17(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper, float Tinc);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_18(int mc, int nSamples, int LSBPRadius, float Tlower, float Tupper);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_19(int mc, int nSamples, int LSBPRadius, float Tlower);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_110(int mc, int nSamples, int LSBPRadius);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_111(int mc, int nSamples);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_112(int mc);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createBackgroundSubtractorLSBP_113();

        // C++:  Ptr_SyntheticSequenceGenerator cv::bgsegm::createSyntheticSequenceGenerator(Mat background, Mat _object, double amplitude = 2.0, double wavelength = 20.0, double wavespeed = 0.2, double objspeed = 6.0)
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createSyntheticSequenceGenerator_10(IntPtr background_nativeObj, IntPtr _object_nativeObj, double amplitude, double wavelength, double wavespeed, double objspeed);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createSyntheticSequenceGenerator_11(IntPtr background_nativeObj, IntPtr _object_nativeObj, double amplitude, double wavelength, double wavespeed);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createSyntheticSequenceGenerator_12(IntPtr background_nativeObj, IntPtr _object_nativeObj, double amplitude, double wavelength);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createSyntheticSequenceGenerator_13(IntPtr background_nativeObj, IntPtr _object_nativeObj, double amplitude);
        [DllImport(LIBNAME)]
        private static extern IntPtr bgsegm_Bgsegm_createSyntheticSequenceGenerator_14(IntPtr background_nativeObj, IntPtr _object_nativeObj);

    }
}