658 lines
21 KiB
C#
658 lines
21 KiB
C#
|
|
using OpenCVForUnity.CoreModule;
|
|
using OpenCVForUnity.UtilsModule;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace OpenCVForUnity.VideoModule
|
|
{
|
|
|
|
// C++: class BackgroundSubtractorMOG2
|
|
/**
|
|
* Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
|
|
*
|
|
* The class implements the Gaussian mixture model background subtraction described in CITE: Zivkovic2004
|
|
* and CITE: Zivkovic2006 .
|
|
*/
|
|
|
|
public class BackgroundSubtractorMOG2 : BackgroundSubtractor
|
|
{
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
|
|
try
|
|
{
|
|
if (disposing)
|
|
{
|
|
}
|
|
if (IsEnabledDispose)
|
|
{
|
|
if (nativeObj != IntPtr.Zero)
|
|
video_BackgroundSubtractorMOG2_delete(nativeObj);
|
|
nativeObj = IntPtr.Zero;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
}
|
|
|
|
protected internal BackgroundSubtractorMOG2(IntPtr addr) : base(addr) { }
|
|
|
|
// internal usage only
|
|
public static new BackgroundSubtractorMOG2 __fromPtr__(IntPtr addr) { return new BackgroundSubtractorMOG2(addr); }
|
|
|
|
//
|
|
// C++: int cv::BackgroundSubtractorMOG2::getHistory()
|
|
//
|
|
|
|
/**
|
|
* Returns the number of last frames that affect the background model
|
|
* return automatically generated
|
|
*/
|
|
public int getHistory()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getHistory_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setHistory(int history)
|
|
//
|
|
|
|
/**
|
|
* Sets the number of last frames that affect the background model
|
|
* param history automatically generated
|
|
*/
|
|
public void setHistory(int history)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setHistory_10(nativeObj, history);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::BackgroundSubtractorMOG2::getNMixtures()
|
|
//
|
|
|
|
/**
|
|
* Returns the number of gaussian components in the background model
|
|
* return automatically generated
|
|
*/
|
|
public int getNMixtures()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getNMixtures_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setNMixtures(int nmixtures)
|
|
//
|
|
|
|
/**
|
|
* Sets the number of gaussian components in the background model.
|
|
*
|
|
* The model needs to be reinitalized to reserve memory.
|
|
* param nmixtures automatically generated
|
|
*/
|
|
public void setNMixtures(int nmixtures)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setNMixtures_10(nativeObj, nmixtures);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getBackgroundRatio()
|
|
//
|
|
|
|
/**
|
|
* Returns the "background ratio" parameter of the algorithm
|
|
*
|
|
* If a foreground pixel keeps semi-constant value for about backgroundRatio\*history frames, it's
|
|
* considered background and added to the model as a center of a new component. It corresponds to TB
|
|
* parameter in the paper.
|
|
* return automatically generated
|
|
*/
|
|
public double getBackgroundRatio()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getBackgroundRatio_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setBackgroundRatio(double ratio)
|
|
//
|
|
|
|
/**
|
|
* Sets the "background ratio" parameter of the algorithm
|
|
* param ratio automatically generated
|
|
*/
|
|
public void setBackgroundRatio(double ratio)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setBackgroundRatio_10(nativeObj, ratio);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarThreshold()
|
|
//
|
|
|
|
/**
|
|
* Returns the variance threshold for the pixel-model match
|
|
*
|
|
* The main threshold on the squared Mahalanobis distance to decide if the sample is well described by
|
|
* the background model or not. Related to Cthr from the paper.
|
|
* return automatically generated
|
|
*/
|
|
public double getVarThreshold()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getVarThreshold_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarThreshold(double varThreshold)
|
|
//
|
|
|
|
/**
|
|
* Sets the variance threshold for the pixel-model match
|
|
* param varThreshold automatically generated
|
|
*/
|
|
public void setVarThreshold(double varThreshold)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setVarThreshold_10(nativeObj, varThreshold);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarThresholdGen()
|
|
//
|
|
|
|
/**
|
|
* Returns the variance threshold for the pixel-model match used for new mixture component generation
|
|
*
|
|
* Threshold for the squared Mahalanobis distance that helps decide when a sample is close to the
|
|
* existing components (corresponds to Tg in the paper). If a pixel is not close to any component, it
|
|
* is considered foreground or added as a new component. 3 sigma => Tg=3\*3=9 is default. A smaller Tg
|
|
* value generates more components. A higher Tg value may result in a small number of components but
|
|
* they can grow too large.
|
|
* return automatically generated
|
|
*/
|
|
public double getVarThresholdGen()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getVarThresholdGen_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarThresholdGen(double varThresholdGen)
|
|
//
|
|
|
|
/**
|
|
* Sets the variance threshold for the pixel-model match used for new mixture component generation
|
|
* param varThresholdGen automatically generated
|
|
*/
|
|
public void setVarThresholdGen(double varThresholdGen)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setVarThresholdGen_10(nativeObj, varThresholdGen);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarInit()
|
|
//
|
|
|
|
/**
|
|
* Returns the initial variance of each gaussian component
|
|
* return automatically generated
|
|
*/
|
|
public double getVarInit()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getVarInit_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarInit(double varInit)
|
|
//
|
|
|
|
/**
|
|
* Sets the initial variance of each gaussian component
|
|
* param varInit automatically generated
|
|
*/
|
|
public void setVarInit(double varInit)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setVarInit_10(nativeObj, varInit);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarMin()
|
|
//
|
|
|
|
public double getVarMin()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getVarMin_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarMin(double varMin)
|
|
//
|
|
|
|
public void setVarMin(double varMin)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setVarMin_10(nativeObj, varMin);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarMax()
|
|
//
|
|
|
|
public double getVarMax()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getVarMax_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarMax(double varMax)
|
|
//
|
|
|
|
public void setVarMax(double varMax)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setVarMax_10(nativeObj, varMax);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getComplexityReductionThreshold()
|
|
//
|
|
|
|
/**
|
|
* Returns the complexity reduction threshold
|
|
*
|
|
* This parameter defines the number of samples needed to accept to prove the component exists. CT=0.05
|
|
* is a default value for all the samples. By setting CT=0 you get an algorithm very similar to the
|
|
* standard Stauffer&Grimson algorithm.
|
|
* return automatically generated
|
|
*/
|
|
public double getComplexityReductionThreshold()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getComplexityReductionThreshold_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setComplexityReductionThreshold(double ct)
|
|
//
|
|
|
|
/**
|
|
* Sets the complexity reduction threshold
|
|
* param ct automatically generated
|
|
*/
|
|
public void setComplexityReductionThreshold(double ct)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setComplexityReductionThreshold_10(nativeObj, ct);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: bool cv::BackgroundSubtractorMOG2::getDetectShadows()
|
|
//
|
|
|
|
/**
|
|
* Returns the shadow detection flag
|
|
*
|
|
* If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorMOG2 for
|
|
* details.
|
|
* return automatically generated
|
|
*/
|
|
public bool getDetectShadows()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getDetectShadows_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setDetectShadows(bool detectShadows)
|
|
//
|
|
|
|
/**
|
|
* Enables or disables shadow detection
|
|
* param detectShadows automatically generated
|
|
*/
|
|
public void setDetectShadows(bool detectShadows)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setDetectShadows_10(nativeObj, detectShadows);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::BackgroundSubtractorMOG2::getShadowValue()
|
|
//
|
|
|
|
/**
|
|
* Returns the shadow value
|
|
*
|
|
* Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0
|
|
* in the mask always means background, 255 means foreground.
|
|
* return automatically generated
|
|
*/
|
|
public int getShadowValue()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getShadowValue_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setShadowValue(int value)
|
|
//
|
|
|
|
/**
|
|
* Sets the shadow value
|
|
* param value automatically generated
|
|
*/
|
|
public void setShadowValue(int value)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setShadowValue_10(nativeObj, value);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: double cv::BackgroundSubtractorMOG2::getShadowThreshold()
|
|
//
|
|
|
|
/**
|
|
* Returns the shadow threshold
|
|
*
|
|
* A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in
|
|
* the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel
|
|
* is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,
|
|
* Detecting Moving Shadows...*, IEEE PAMI,2003.
|
|
* return automatically generated
|
|
*/
|
|
public double getShadowThreshold()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_BackgroundSubtractorMOG2_getShadowThreshold_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::setShadowThreshold(double threshold)
|
|
//
|
|
|
|
/**
|
|
* Sets the shadow threshold
|
|
* param threshold automatically generated
|
|
*/
|
|
public void setShadowThreshold(double threshold)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_setShadowThreshold_10(nativeObj, threshold);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::BackgroundSubtractorMOG2::apply(Mat image, Mat& fgmask, double learningRate = -1)
|
|
//
|
|
|
|
/**
|
|
* Computes a foreground mask.
|
|
*
|
|
* param image Next video frame. Floating point frame will be used without scaling and should be in range \([0,255]\).
|
|
* param fgmask The output foreground mask as an 8-bit binary image.
|
|
* param learningRate The value between 0 and 1 that indicates how fast the background model is
|
|
* learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
|
|
* rate. 0 means that the background model is not updated at all, 1 means that the background model
|
|
* is completely reinitialized from the last frame.
|
|
*/
|
|
public override void apply(Mat image, Mat fgmask, double learningRate)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (image != null) image.ThrowIfDisposed();
|
|
if (fgmask != null) fgmask.ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_apply_10(nativeObj, image.nativeObj, fgmask.nativeObj, learningRate);
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Computes a foreground mask.
|
|
*
|
|
* param image Next video frame. Floating point frame will be used without scaling and should be in range \([0,255]\).
|
|
* param fgmask The output foreground mask as an 8-bit binary image.
|
|
* learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
|
|
* rate. 0 means that the background model is not updated at all, 1 means that the background model
|
|
* is completely reinitialized from the last frame.
|
|
*/
|
|
public override void apply(Mat image, Mat fgmask)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (image != null) image.ThrowIfDisposed();
|
|
if (fgmask != null) fgmask.ThrowIfDisposed();
|
|
|
|
video_BackgroundSubtractorMOG2_apply_11(nativeObj, image.nativeObj, fgmask.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
|
|
const string LIBNAME = "__Internal";
|
|
#else
|
|
const string LIBNAME = "opencvforunity";
|
|
#endif
|
|
|
|
|
|
|
|
// C++: int cv::BackgroundSubtractorMOG2::getHistory()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int video_BackgroundSubtractorMOG2_getHistory_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setHistory(int history)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setHistory_10(IntPtr nativeObj, int history);
|
|
|
|
// C++: int cv::BackgroundSubtractorMOG2::getNMixtures()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int video_BackgroundSubtractorMOG2_getNMixtures_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setNMixtures(int nmixtures)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setNMixtures_10(IntPtr nativeObj, int nmixtures);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getBackgroundRatio()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getBackgroundRatio_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setBackgroundRatio(double ratio)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setBackgroundRatio_10(IntPtr nativeObj, double ratio);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarThreshold()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getVarThreshold_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarThreshold(double varThreshold)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setVarThreshold_10(IntPtr nativeObj, double varThreshold);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarThresholdGen()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getVarThresholdGen_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarThresholdGen(double varThresholdGen)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setVarThresholdGen_10(IntPtr nativeObj, double varThresholdGen);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarInit()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getVarInit_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarInit(double varInit)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setVarInit_10(IntPtr nativeObj, double varInit);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarMin()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getVarMin_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarMin(double varMin)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setVarMin_10(IntPtr nativeObj, double varMin);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getVarMax()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getVarMax_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setVarMax(double varMax)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setVarMax_10(IntPtr nativeObj, double varMax);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getComplexityReductionThreshold()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getComplexityReductionThreshold_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setComplexityReductionThreshold(double ct)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setComplexityReductionThreshold_10(IntPtr nativeObj, double ct);
|
|
|
|
// C++: bool cv::BackgroundSubtractorMOG2::getDetectShadows()
|
|
[DllImport(LIBNAME)]
|
|
[return: MarshalAs(UnmanagedType.U1)]
|
|
private static extern bool video_BackgroundSubtractorMOG2_getDetectShadows_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setDetectShadows(bool detectShadows)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setDetectShadows_10(IntPtr nativeObj, [MarshalAs(UnmanagedType.U1)] bool detectShadows);
|
|
|
|
// C++: int cv::BackgroundSubtractorMOG2::getShadowValue()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int video_BackgroundSubtractorMOG2_getShadowValue_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setShadowValue(int value)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setShadowValue_10(IntPtr nativeObj, int value);
|
|
|
|
// C++: double cv::BackgroundSubtractorMOG2::getShadowThreshold()
|
|
[DllImport(LIBNAME)]
|
|
private static extern double video_BackgroundSubtractorMOG2_getShadowThreshold_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::setShadowThreshold(double threshold)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_setShadowThreshold_10(IntPtr nativeObj, double threshold);
|
|
|
|
// C++: void cv::BackgroundSubtractorMOG2::apply(Mat image, Mat& fgmask, double learningRate = -1)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_apply_10(IntPtr nativeObj, IntPtr image_nativeObj, IntPtr fgmask_nativeObj, double learningRate);
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_apply_11(IntPtr nativeObj, IntPtr image_nativeObj, IntPtr fgmask_nativeObj);
|
|
|
|
// native support for java finalize()
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_BackgroundSubtractorMOG2_delete(IntPtr nativeObj);
|
|
|
|
}
|
|
}
|