1038 lines
54 KiB
C#
1038 lines
54 KiB
C#
|
|
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);
|
|
|
|
}
|
|
}
|