diff --git a/modules/bgsegm/include/opencv2/bgsegm.hpp b/modules/bgsegm/include/opencv2/bgsegm.hpp index 1d2b6f892f2..6c894f8fb2f 100644 --- a/modules/bgsegm/include/opencv2/bgsegm.hpp +++ b/modules/bgsegm/include/opencv2/bgsegm.hpp @@ -62,6 +62,32 @@ The class implements the algorithm described in @cite KB2001 . class CV_EXPORTS_W BackgroundSubtractorMOG : public BackgroundSubtractor { public: + // BackgroundSubtractor interface + /** @brief Computes a foreground mask. + + @param image Next video frame of type CV_8UC(n),CV_8SC(n),CV_16UC(n),CV_16SC(n),CV_32SC(n),CV_32FC(n),CV_64FC(n), where n is 1,2,3,4. + @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. + */ + + CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + + /** @brief Computes a foreground mask and skips known foreground in evaluation. + + @param image Next video frame of type CV_8UC(n),CV_8SC(n),CV_16UC(n),CV_16SC(n),CV_32SC(n),CV_32FC(n),CV_64FC(n), where n is 1,2,3,4. + @param fgmask The output foreground mask as an 8-bit binary image. + @param knownForegroundMask The mask for inputting already known foreground, allows model to ignore learning known pixels. + @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. + */ + + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + CV_WRAP virtual int getHistory() const = 0; CV_WRAP virtual void setHistory(int nframes) = 0; @@ -110,6 +136,22 @@ class CV_EXPORTS_W BackgroundSubtractorGMG : public BackgroundSubtractor is completely reinitialized from the last frame. */ CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + + /** @brief Computes a foreground mask with known foreground mask input. + + @param image Next video frame. + @param fgmask The output foreground mask as an 8-bit binary image. + @param knownForegroundMask The mask for inputting already known foreground. + @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. + + @note This method has a default virtual implementation that throws a "not impemented" error. + Foreground masking may not be supported by all background subtractors. + */ + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0; /** @brief Returns total number of distinct colors to maintain in histogram. @@ -210,6 +252,22 @@ class CV_EXPORTS_W BackgroundSubtractorCNT : public BackgroundSubtractor public: // BackgroundSubtractor interface CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + + /** @brief Computes a foreground mask with known foreground mask input. + + @param image Next video frame. + @param knownForegroundMask The mask for inputting already known foreground. + @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. + + @note This method has a default virtual implementation that throws a "not impemented" error. + Foreground masking may not be supported by all background subtractors. + */ + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0; /** @brief Returns number of frames with same pixel color to consider stable. @@ -269,6 +327,7 @@ class CV_EXPORTS_W BackgroundSubtractorGSOC : public BackgroundSubtractor public: // BackgroundSubtractor interface CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0; }; @@ -280,6 +339,7 @@ class CV_EXPORTS_W BackgroundSubtractorLSBP : public BackgroundSubtractor public: // BackgroundSubtractor interface CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0; CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0; }; diff --git a/modules/bgsegm/src/bgfg_gaussmix.cpp b/modules/bgsegm/src/bgfg_gaussmix.cpp index d6c167689db..f5dc671b769 100644 --- a/modules/bgsegm/src/bgfg_gaussmix.cpp +++ b/modules/bgsegm/src/bgfg_gaussmix.cpp @@ -104,6 +104,8 @@ class BackgroundSubtractorMOGImpl CV_FINAL : public BackgroundSubtractorMOG //! the update operator virtual void apply(InputArray image, OutputArray fgmask, double learningRate=0) CV_OVERRIDE; + virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE; + //! re-initiaization method virtual void initialize(Size _frameSize, int _frameType) { @@ -461,6 +463,15 @@ void BackgroundSubtractorMOGImpl::apply(InputArray _image, OutputArray _fgmask, CV_Error( Error::StsUnsupportedFormat, "Only 1- and 3-channel 8-bit images are supported in BackgroundSubtractorMOG" ); } +void BackgroundSubtractorMOGImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate); +} + Ptr createBackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma) { diff --git a/modules/bgsegm/src/bgfg_gmg.cpp b/modules/bgsegm/src/bgfg_gmg.cpp index a83a83cc696..97c59add5e1 100644 --- a/modules/bgsegm/src/bgfg_gmg.cpp +++ b/modules/bgsegm/src/bgfg_gmg.cpp @@ -97,6 +97,7 @@ class BackgroundSubtractorGMGImpl CV_FINAL : public BackgroundSubtractorGMG * @param fgmask Output mask image representing foreground and background pixels */ virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1.0) CV_OVERRIDE; + virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE; /** * Releases all inner buffers. @@ -473,6 +474,15 @@ void BackgroundSubtractorGMGImpl::apply(InputArray _frame, OutputArray _fgmask, ++frameNum_; } +void BackgroundSubtractorGMGImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double newLearningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, newLearningRate); +} + void BackgroundSubtractorGMGImpl::release() { frameSize_ = Size(); diff --git a/modules/bgsegm/src/bgfg_gsoc.cpp b/modules/bgsegm/src/bgfg_gsoc.cpp index 2cc33febfc6..8daff3900c3 100644 --- a/modules/bgsegm/src/bgfg_gsoc.cpp +++ b/modules/bgsegm/src/bgfg_gsoc.cpp @@ -494,6 +494,7 @@ class BackgroundSubtractorGSOCImpl CV_FINAL : public BackgroundSubtractorGSOC { float noiseRemovalThresholdFacFG); CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate = -1) CV_OVERRIDE; + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE; CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE; @@ -542,6 +543,7 @@ class BackgroundSubtractorLSBPImpl CV_FINAL : public BackgroundSubtractorLSBP { ); CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate = -1) CV_OVERRIDE; + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE; CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE; @@ -793,6 +795,15 @@ void BackgroundSubtractorGSOCImpl::apply(InputArray _image, OutputArray _fgmask, this->postprocessing(fgMask); } +void BackgroundSubtractorGSOCImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate); +} + void BackgroundSubtractorGSOCImpl::getBackgroundImage(OutputArray _backgroundImage) const { CV_Assert(!backgroundModel.empty()); const Size sz = backgroundModel->getSize(); @@ -928,6 +939,15 @@ void BackgroundSubtractorLSBPImpl::apply(InputArray _image, OutputArray _fgmask, this->postprocessing(fgMask); } +void BackgroundSubtractorLSBPImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate); +} + void BackgroundSubtractorLSBPImpl::getBackgroundImage(OutputArray _backgroundImage) const { CV_Assert(!backgroundModel.empty()); const Size sz = backgroundModel->getSize(); diff --git a/modules/bgsegm/src/bgfg_subcnt.cpp b/modules/bgsegm/src/bgfg_subcnt.cpp index 1638de50e62..3aa6ec2a7b2 100644 --- a/modules/bgsegm/src/bgfg_subcnt.cpp +++ b/modules/bgsegm/src/bgfg_subcnt.cpp @@ -61,6 +61,8 @@ class BackgroundSubtractorCNTImpl CV_FINAL : public BackgroundSubtractorCNT // BackgroundSubtractor interface virtual void apply(InputArray image, OutputArray fgmask, double learningRate) CV_OVERRIDE; + virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE; + virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE; int getMinPixelStability() const CV_OVERRIDE; @@ -409,6 +411,14 @@ void BackgroundSubtractorCNTImpl::apply(InputArray image, OutputArray _fgmask, d prevFrame = frame; } +void BackgroundSubtractorCNTImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate); +} Ptr createBackgroundSubtractorCNT(int minPixelStability, bool useHistory, int maxStability, bool isParallel) { diff --git a/modules/cudabgsegm/include/opencv2/cudabgsegm.hpp b/modules/cudabgsegm/include/opencv2/cudabgsegm.hpp index eb5467e9b87..fa05913e51d 100644 --- a/modules/cudabgsegm/include/opencv2/cudabgsegm.hpp +++ b/modules/cudabgsegm/include/opencv2/cudabgsegm.hpp @@ -84,6 +84,8 @@ class CV_EXPORTS_W BackgroundSubtractorMOG : public cv::BackgroundSubtractor using cv::BackgroundSubtractor::apply; CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream) = 0; + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate, Stream& stream) = 0; + using cv::BackgroundSubtractor::getBackgroundImage; virtual void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const = 0; @@ -135,6 +137,8 @@ class CV_EXPORTS_W BackgroundSubtractorMOG2 : public cv::BackgroundSubtractorMOG CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream) = 0; + CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate, Stream& stream) = 0; + virtual void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const = 0; CV_WRAP inline void getBackgroundImage(CV_OUT GpuMat &backgroundImage, Stream& stream) { diff --git a/modules/cudabgsegm/src/mog.cpp b/modules/cudabgsegm/src/mog.cpp index 8a43293d43a..1e65972afc9 100644 --- a/modules/cudabgsegm/src/mog.cpp +++ b/modules/cudabgsegm/src/mog.cpp @@ -79,6 +79,9 @@ namespace void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE; void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream) CV_OVERRIDE; + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE; + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1, Stream& stream) CV_OVERRIDE; + void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE; void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const CV_OVERRIDE; @@ -131,6 +134,24 @@ namespace apply(image, fgmask, learningRate, Stream::Null()); } + void BackgroundSubtractorMOGImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate, Stream::Null()); + } + + void BackgroundSubtractorMOGImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate, Stream &stream){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate, stream); + } + void MOGImpl::apply(InputArray _frame, OutputArray _fgmask, double learningRate, Stream& stream) { using namespace cv::cuda::device::mog; diff --git a/modules/cudabgsegm/src/mog2.cpp b/modules/cudabgsegm/src/mog2.cpp index 47135a088ba..d5a8628052f 100644 --- a/modules/cudabgsegm/src/mog2.cpp +++ b/modules/cudabgsegm/src/mog2.cpp @@ -83,6 +83,9 @@ class MOG2Impl CV_FINAL : public cuda::BackgroundSubtractorMOG2 void apply(InputArray image, OutputArray fgmask, double learningRate = -1) CV_OVERRIDE; void apply(InputArray image, OutputArray fgmask, double learningRate, Stream &stream) CV_OVERRIDE; + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate = -1) CV_OVERRIDE; + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1, Stream& stream) CV_OVERRIDE; + void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE; void getBackgroundImage(OutputArray backgroundImage, Stream &stream) const CV_OVERRIDE; @@ -174,6 +177,24 @@ void MOG2Impl::apply(InputArray image, OutputArray fgmask, double learningRate) apply(image, fgmask, learningRate, Stream::Null()); } +void BackgroundSubtractorMOG2Impl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate, Stream::Null()); +} + +void BackgroundSubtractorMOG2Impl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate, Stream &stream){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate, stream); +} + void MOG2Impl::apply(InputArray _frame, OutputArray _fgmask, double learningRate, Stream &stream) { using namespace cv::cuda::device::mog2; diff --git a/modules/cudalegacy/include/opencv2/cudalegacy.hpp b/modules/cudalegacy/include/opencv2/cudalegacy.hpp index 8230eaa2171..ec8ea72eca2 100644 --- a/modules/cudalegacy/include/opencv2/cudalegacy.hpp +++ b/modules/cudalegacy/include/opencv2/cudalegacy.hpp @@ -92,6 +92,7 @@ class CV_EXPORTS BackgroundSubtractorGMG : public cv::BackgroundSubtractor public: using cv::BackgroundSubtractor::apply; virtual void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream) = 0; + virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate, Stream& stream) = 0; virtual int getMaxFeatures() const = 0; virtual void setMaxFeatures(int maxFeatures) = 0; diff --git a/modules/cudalegacy/src/fgd.cpp b/modules/cudalegacy/src/fgd.cpp index db98348741c..8369ced69a5 100644 --- a/modules/cudalegacy/src/fgd.cpp +++ b/modules/cudalegacy/src/fgd.cpp @@ -546,6 +546,7 @@ namespace ~FGDImpl(); void apply(InputArray image, OutputArray fgmask, double learningRate=-1); + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1); void getBackgroundImage(OutputArray backgroundImage) const; @@ -629,6 +630,15 @@ namespace foreground_.copyTo(fgmask); } + void FGDImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate); + } + void FGDImpl::getBackgroundImage(OutputArray backgroundImage) const { cuda::cvtColor(background_, backgroundImage, COLOR_BGRA2BGR); diff --git a/modules/cudalegacy/src/gmg.cpp b/modules/cudalegacy/src/gmg.cpp index a982d8689bf..288641c9199 100644 --- a/modules/cudalegacy/src/gmg.cpp +++ b/modules/cudalegacy/src/gmg.cpp @@ -73,6 +73,10 @@ namespace void apply(InputArray image, OutputArray fgmask, double learningRate=-1); void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream); + // Overloaded Background Subtractor Applys featuring knownForegroundMask parameter + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1); + void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate, Stream& stream); + void getBackgroundImage(OutputArray backgroundImage) const; int getMaxFeatures() const { return maxFeatures_; } @@ -165,6 +169,24 @@ namespace apply(image, fgmask, learningRate, Stream::Null()); } + void GMGImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, Stream::Null()); + } + + void GMGImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate, Stream& stream){ + Mat knownForegroundMask = _knownForegroundMask.getMat(); + if(!_knownForegroundMask.empty()) + { + CV_Error( Error::StsNotImplemented, "Known Foreground Masking has not been implemented for this specific background subtractor, falling back to subtraction without known foreground"); + } + apply(_image, _fgmask, learningRate, stream); + } + void GMGImpl::apply(InputArray _frame, OutputArray _fgmask, double newLearningRate, Stream& stream) { using namespace cv::cuda::device::gmg;