mirror of
https://github.com/opencv/opencv.git
synced 2024-12-26 18:58:16 +08:00
78be4f66f7
Conflicts: CMakeLists.txt modules/calib3d/src/calibration.cpp modules/ocl/src/cl_programcache.cpp modules/ocl/src/filtering.cpp modules/ocl/src/imgproc.cpp samples/ocl/adaptive_bilateral_filter.cpp samples/ocl/bgfg_segm.cpp samples/ocl/clahe.cpp samples/ocl/facedetect.cpp samples/ocl/pyrlk_optical_flow.cpp samples/ocl/squares.cpp samples/ocl/surf_matcher.cpp samples/ocl/tvl1_optical_flow.cpp
640 lines
25 KiB
C++
640 lines
25 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2010-2013, Multicoreware, Inc., all rights reserved.
|
|
// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// @Authors
|
|
// Jin Ma, jin@multicorewareinc.com
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors as is and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
#include "precomp.hpp"
|
|
#include "opencl_kernels.hpp"
|
|
|
|
using namespace cv;
|
|
using namespace cv::ocl;
|
|
|
|
namespace cv
|
|
{
|
|
namespace ocl
|
|
{
|
|
typedef struct _contant_struct
|
|
{
|
|
cl_float c_Tb;
|
|
cl_float c_TB;
|
|
cl_float c_Tg;
|
|
cl_float c_varInit;
|
|
cl_float c_varMin;
|
|
cl_float c_varMax;
|
|
cl_float c_tau;
|
|
cl_uchar c_shadowVal;
|
|
}contant_struct;
|
|
|
|
cl_mem cl_constants = NULL;
|
|
float c_TB;
|
|
}
|
|
}
|
|
|
|
#if defined _MSC_VER
|
|
#define snprintf sprintf_s
|
|
#endif
|
|
|
|
namespace cv { namespace ocl { namespace device
|
|
{
|
|
namespace mog
|
|
{
|
|
void mog_ocl(const oclMat& frame, int cn, oclMat& fgmask, oclMat& weight, oclMat& sortKey, oclMat& mean, oclMat& var,
|
|
int nmixtures, float varThreshold, float learningRate, float backgroundRatio, float noiseSigma);
|
|
|
|
void getBackgroundImage_ocl(int cn, const oclMat& weight, const oclMat& mean, oclMat& dst, int nmixtures, float backgroundRatio);
|
|
|
|
void loadConstants(float Tb, float TB, float Tg, float varInit, float varMin, float varMax, float tau,
|
|
unsigned char shadowVal);
|
|
|
|
void mog2_ocl(const oclMat& frame, int cn, oclMat& fgmask, oclMat& modesUsed, oclMat& weight, oclMat& variance, oclMat& mean,
|
|
float alphaT, float prune, bool detectShadows, int nmixtures);
|
|
|
|
void getBackgroundImage2_ocl(int cn, const oclMat& modesUsed, const oclMat& weight, const oclMat& mean, oclMat& dst, int nmixtures);
|
|
}
|
|
}}}
|
|
|
|
namespace mog
|
|
{
|
|
const int defaultNMixtures = 5;
|
|
const int defaultHistory = 200;
|
|
const float defaultBackgroundRatio = 0.7f;
|
|
const float defaultVarThreshold = 2.5f * 2.5f;
|
|
const float defaultNoiseSigma = 30.0f * 0.5f;
|
|
const float defaultInitialWeight = 0.05f;
|
|
}
|
|
void cv::ocl::BackgroundSubtractor::operator()(const oclMat&, oclMat&, float)
|
|
{
|
|
|
|
}
|
|
cv::ocl::BackgroundSubtractor::~BackgroundSubtractor()
|
|
{
|
|
|
|
}
|
|
|
|
cv::ocl::MOG::MOG(int nmixtures) :
|
|
frameSize_(0, 0), frameType_(0), nframes_(0)
|
|
{
|
|
nmixtures_ = std::min(nmixtures > 0 ? nmixtures : mog::defaultNMixtures, 8);
|
|
history = mog::defaultHistory;
|
|
varThreshold = mog::defaultVarThreshold;
|
|
backgroundRatio = mog::defaultBackgroundRatio;
|
|
noiseSigma = mog::defaultNoiseSigma;
|
|
}
|
|
|
|
void cv::ocl::MOG::initialize(cv::Size frameSize, int frameType)
|
|
{
|
|
CV_Assert(frameType == CV_8UC1 || frameType == CV_8UC3 || frameType == CV_8UC4);
|
|
|
|
frameSize_ = frameSize;
|
|
frameType_ = frameType;
|
|
|
|
int ch = CV_MAT_CN(frameType);
|
|
int work_ch = ch;
|
|
|
|
// for each gaussian mixture of each pixel bg model we store
|
|
// the mixture sort key (w/sum_of_variances), the mixture weight (w),
|
|
// the mean (nchannels values) and
|
|
// the diagonal covariance matrix (another nchannels values)
|
|
|
|
weight_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC1);
|
|
sortKey_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC1);
|
|
mean_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC(work_ch));
|
|
var_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC(work_ch));
|
|
|
|
weight_.setTo(cv::Scalar::all(0));
|
|
sortKey_.setTo(cv::Scalar::all(0));
|
|
mean_.setTo(cv::Scalar::all(0));
|
|
var_.setTo(cv::Scalar::all(0));
|
|
|
|
nframes_ = 0;
|
|
}
|
|
|
|
void cv::ocl::MOG::operator()(const cv::ocl::oclMat& frame, cv::ocl::oclMat& fgmask, float learningRate)
|
|
{
|
|
using namespace cv::ocl::device::mog;
|
|
|
|
CV_Assert(frame.depth() == CV_8U);
|
|
|
|
int ch = frame.oclchannels();
|
|
int work_ch = ch;
|
|
|
|
if (nframes_ == 0 || learningRate >= 1.0 || frame.size() != frameSize_ || work_ch != mean_.oclchannels())
|
|
initialize(frame.size(), frame.type());
|
|
|
|
fgmask.create(frameSize_, CV_8UC1);
|
|
|
|
++nframes_;
|
|
learningRate = learningRate >= 0.0f && nframes_ > 1 ? learningRate : 1.0f / std::min(nframes_, history);
|
|
CV_Assert(learningRate >= 0.0f);
|
|
|
|
mog_ocl(frame, ch, fgmask, weight_, sortKey_, mean_, var_, nmixtures_,
|
|
varThreshold, learningRate, backgroundRatio, noiseSigma);
|
|
}
|
|
|
|
void cv::ocl::MOG::getBackgroundImage(oclMat& backgroundImage) const
|
|
{
|
|
using namespace cv::ocl::device::mog;
|
|
|
|
backgroundImage.create(frameSize_, frameType_);
|
|
|
|
cv::ocl::device::mog::getBackgroundImage_ocl(backgroundImage.oclchannels(), weight_, mean_, backgroundImage, nmixtures_, backgroundRatio);
|
|
}
|
|
|
|
void cv::ocl::MOG::release()
|
|
{
|
|
frameSize_ = Size(0, 0);
|
|
frameType_ = 0;
|
|
nframes_ = 0;
|
|
|
|
weight_.release();
|
|
sortKey_.release();
|
|
mean_.release();
|
|
var_.release();
|
|
clReleaseMemObject(cl_constants);
|
|
}
|
|
|
|
static void mog_withoutLearning(const oclMat& frame, int cn, oclMat& fgmask, oclMat& weight, oclMat& mean, oclMat& var,
|
|
int nmixtures, float varThreshold, float backgroundRatio)
|
|
{
|
|
Context* clCxt = Context::getContext();
|
|
|
|
size_t local_thread[] = {32, 8, 1};
|
|
size_t global_thread[] = {frame.cols, frame.rows, 1};
|
|
|
|
int frame_step = (int)(frame.step/frame.elemSize());
|
|
int fgmask_step = (int)(fgmask.step/fgmask.elemSize());
|
|
int weight_step = (int)(weight.step/weight.elemSize());
|
|
int mean_step = (int)(mean.step/mean.elemSize());
|
|
int var_step = (int)(var.step/var.elemSize());
|
|
|
|
int fgmask_offset_y = (int)(fgmask.offset/fgmask.step);
|
|
int fgmask_offset_x = (int)(fgmask.offset%fgmask.step);
|
|
fgmask_offset_x = fgmask_offset_x/(int)fgmask.elemSize();
|
|
|
|
int frame_offset_y = (int)(frame.offset/frame.step);
|
|
int frame_offset_x = (int)(frame.offset%frame.step);
|
|
frame_offset_x = frame_offset_x/(int)frame.elemSize();
|
|
|
|
char build_option[50];
|
|
if(cn == 1)
|
|
{
|
|
snprintf(build_option, 50, "-D CN1 -D NMIXTURES=%d", nmixtures);
|
|
}else
|
|
{
|
|
snprintf(build_option, 50, "-D NMIXTURES=%d", nmixtures);
|
|
}
|
|
|
|
String kernel_name = "mog_withoutLearning_kernel";
|
|
std::vector<std::pair<size_t, const void*> > args;
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&frame.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&fgmask.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&weight.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&mean.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&var.data));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame.rows));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame.cols));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&weight_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&mean_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&var_step));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&varThreshold));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&backgroundRatio));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_offset_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_offset_y));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_offset_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_offset_y));
|
|
|
|
openCLExecuteKernel(clCxt, &bgfg_mog, kernel_name, global_thread, local_thread, args, -1, -1, build_option);
|
|
}
|
|
|
|
|
|
static void mog_withLearning(const oclMat& frame, int cn, oclMat& fgmask_raw, oclMat& weight, oclMat& sortKey, oclMat& mean, oclMat& var,
|
|
int nmixtures, float varThreshold, float backgroundRatio, float learningRate, float minVar)
|
|
{
|
|
Context* clCxt = Context::getContext();
|
|
|
|
size_t local_thread[] = {32, 8, 1};
|
|
size_t global_thread[] = {frame.cols, frame.rows, 1};
|
|
|
|
oclMat fgmask(fgmask_raw.size(), CV_32SC1);
|
|
|
|
int frame_step = (int)(frame.step/frame.elemSize());
|
|
int fgmask_step = (int)(fgmask.step/fgmask.elemSize());
|
|
int weight_step = (int)(weight.step/weight.elemSize());
|
|
int sortKey_step = (int)(sortKey.step/sortKey.elemSize());
|
|
int mean_step = (int)(mean.step/mean.elemSize());
|
|
int var_step = (int)(var.step/var.elemSize());
|
|
|
|
int fgmask_offset_y = (int)(fgmask.offset/fgmask.step);
|
|
int fgmask_offset_x = (int)(fgmask.offset%fgmask.step);
|
|
fgmask_offset_x = fgmask_offset_x/(int)fgmask.elemSize();
|
|
|
|
int frame_offset_y = (int)(frame.offset/frame.step);
|
|
int frame_offset_x = (int)(frame.offset%frame.step);
|
|
frame_offset_x = frame_offset_x/(int)frame.elemSize();
|
|
|
|
char build_option[50];
|
|
if(cn == 1)
|
|
{
|
|
snprintf(build_option, 50, "-D CN1 -D NMIXTURES=%d", nmixtures);
|
|
}else
|
|
{
|
|
snprintf(build_option, 50, "-D NMIXTURES=%d", nmixtures);
|
|
}
|
|
|
|
String kernel_name = "mog_withLearning_kernel";
|
|
std::vector<std::pair<size_t, const void*> > args;
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&frame.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&fgmask.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&weight.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&sortKey.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&mean.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&var.data));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame.rows));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame.cols));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&weight_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&sortKey_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&mean_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&var_step));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&varThreshold));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&backgroundRatio));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&learningRate));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&minVar));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_offset_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_offset_y));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_offset_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_offset_y));
|
|
|
|
openCLExecuteKernel(clCxt, &bgfg_mog, kernel_name, global_thread, local_thread, args, -1, -1, build_option);
|
|
fgmask.convertTo(fgmask, CV_8U);
|
|
fgmask.copyTo(fgmask_raw);
|
|
}
|
|
|
|
void cv::ocl::device::mog::mog_ocl(const oclMat& frame, int cn, oclMat& fgmask, oclMat& weight, oclMat& sortKey, oclMat& mean, oclMat& var,
|
|
int nmixtures, float varThreshold, float learningRate, float backgroundRatio, float noiseSigma)
|
|
{
|
|
const float minVar = noiseSigma * noiseSigma;
|
|
|
|
if(learningRate > 0.0f)
|
|
mog_withLearning(frame, cn, fgmask, weight, sortKey, mean, var, nmixtures,
|
|
varThreshold, backgroundRatio, learningRate, minVar);
|
|
else
|
|
mog_withoutLearning(frame, cn, fgmask, weight, mean, var, nmixtures, varThreshold, backgroundRatio);
|
|
}
|
|
|
|
void cv::ocl::device::mog::getBackgroundImage_ocl(int cn, const oclMat& weight, const oclMat& mean, oclMat& dst, int nmixtures, float backgroundRatio)
|
|
{
|
|
Context* clCxt = Context::getContext();
|
|
|
|
size_t local_thread[] = {32, 8, 1};
|
|
size_t global_thread[] = {dst.cols, dst.rows, 1};
|
|
|
|
int weight_step = (int)(weight.step/weight.elemSize());
|
|
int mean_step = (int)(mean.step/mean.elemSize());
|
|
int dst_step = (int)(dst.step/dst.elemSize());
|
|
|
|
char build_option[50];
|
|
if(cn == 1)
|
|
{
|
|
snprintf(build_option, 50, "-D CN1 -D NMIXTURES=%d", nmixtures);
|
|
}else
|
|
{
|
|
snprintf(build_option, 50, "-D NMIXTURES=%d", nmixtures);
|
|
}
|
|
|
|
String kernel_name = "getBackgroundImage_kernel";
|
|
std::vector<std::pair<size_t, const void*> > args;
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&weight.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&mean.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&dst.data));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&dst.rows));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&dst.cols));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&weight_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&mean_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&dst_step));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&backgroundRatio));
|
|
|
|
openCLExecuteKernel(clCxt, &bgfg_mog, kernel_name, global_thread, local_thread, args, -1, -1, build_option);
|
|
}
|
|
|
|
void cv::ocl::device::mog::loadConstants(float Tb, float TB, float Tg, float varInit, float varMin, float varMax, float tau, unsigned char shadowVal)
|
|
{
|
|
varMin = cv::min(varMin, varMax);
|
|
varMax = cv::max(varMin, varMax);
|
|
|
|
c_TB = TB;
|
|
|
|
_contant_struct *constants = new _contant_struct;
|
|
constants->c_Tb = Tb;
|
|
constants->c_TB = TB;
|
|
constants->c_Tg = Tg;
|
|
constants->c_varInit = varInit;
|
|
constants->c_varMin = varMin;
|
|
constants->c_varMax = varMax;
|
|
constants->c_tau = tau;
|
|
constants->c_shadowVal = shadowVal;
|
|
|
|
cl_constants = load_constant(*((cl_context*)getClContextPtr()), *((cl_command_queue*)getClCommandQueuePtr()),
|
|
(void *)constants, sizeof(_contant_struct));
|
|
}
|
|
|
|
void cv::ocl::device::mog::mog2_ocl(const oclMat& frame, int cn, oclMat& fgmaskRaw, oclMat& modesUsed, oclMat& weight, oclMat& variance,
|
|
oclMat& mean, float alphaT, float prune, bool detectShadows, int nmixtures)
|
|
{
|
|
oclMat fgmask(fgmaskRaw.size(), CV_32SC1);
|
|
|
|
Context* clCxt = Context::getContext();
|
|
|
|
const float alpha1 = 1.0f - alphaT;
|
|
|
|
cl_int detectShadows_flag = 0;
|
|
if(detectShadows)
|
|
detectShadows_flag = 1;
|
|
|
|
size_t local_thread[] = {32, 8, 1};
|
|
size_t global_thread[] = {frame.cols, frame.rows, 1};
|
|
|
|
int frame_step = (int)(frame.step/frame.elemSize());
|
|
int fgmask_step = (int)(fgmask.step/fgmask.elemSize());
|
|
int weight_step = (int)(weight.step/weight.elemSize());
|
|
int modesUsed_step = (int)(modesUsed.step/modesUsed.elemSize());
|
|
int mean_step = (int)(mean.step/mean.elemSize());
|
|
int var_step = (int)(variance.step/variance.elemSize());
|
|
|
|
int fgmask_offset_y = (int)(fgmask.offset/fgmask.step);
|
|
int fgmask_offset_x = (int)(fgmask.offset%fgmask.step);
|
|
fgmask_offset_x = fgmask_offset_x/(int)fgmask.elemSize();
|
|
|
|
int frame_offset_y = (int)(frame.offset/frame.step);
|
|
int frame_offset_x = (int)(frame.offset%frame.step);
|
|
frame_offset_x = frame_offset_x/(int)frame.elemSize();
|
|
|
|
String kernel_name = "mog2_kernel";
|
|
std::vector<std::pair<size_t, const void*> > args;
|
|
|
|
char build_option[50];
|
|
if(cn == 1)
|
|
{
|
|
snprintf(build_option, 50, "-D CN1 -D NMIXTURES=%d", nmixtures);
|
|
}else
|
|
{
|
|
snprintf(build_option, 50, "-D NMIXTURES=%d", nmixtures);
|
|
}
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&frame.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&fgmask.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&weight.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&mean.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&modesUsed.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&variance.data));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame.rows));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame.cols));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&weight_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&mean_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&modesUsed_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&var_step));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&alphaT));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&alpha1));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&prune));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&detectShadows_flag));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_offset_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&fgmask_offset_y));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_offset_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&frame_offset_y));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&cl_constants));
|
|
|
|
openCLExecuteKernel(clCxt, &bgfg_mog, kernel_name, global_thread, local_thread, args, -1, -1, build_option);
|
|
|
|
fgmask.convertTo(fgmask, CV_8U);
|
|
fgmask.copyTo(fgmaskRaw);
|
|
}
|
|
|
|
void cv::ocl::device::mog::getBackgroundImage2_ocl(int cn, const oclMat& modesUsed, const oclMat& weight, const oclMat& mean, oclMat& dst, int nmixtures)
|
|
{
|
|
Context* clCxt = Context::getContext();
|
|
|
|
size_t local_thread[] = {32, 8, 1};
|
|
size_t global_thread[] = {modesUsed.cols, modesUsed.rows, 1};
|
|
|
|
int weight_step = (int)(weight.step/weight.elemSize());
|
|
int modesUsed_step = (int)(modesUsed.step/modesUsed.elemSize());
|
|
int mean_step = (int)(mean.step/mean.elemSize());
|
|
int dst_step = (int)(dst.step/dst.elemSize());
|
|
|
|
int dst_y = (int)(dst.offset/dst.step);
|
|
int dst_x = (int)(dst.offset%dst.step);
|
|
dst_x = dst_x/(int)dst.elemSize();
|
|
|
|
String kernel_name = "getBackgroundImage2_kernel";
|
|
std::vector<std::pair<size_t, const void*> > args;
|
|
|
|
char build_option[50];
|
|
if(cn == 1)
|
|
{
|
|
snprintf(build_option, 50, "-D CN1 -D NMIXTURES=%d", nmixtures);
|
|
}else
|
|
{
|
|
snprintf(build_option, 50, "-D NMIXTURES=%d", nmixtures);
|
|
}
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&modesUsed.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&weight.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&mean.data));
|
|
args.push_back(std::make_pair(sizeof(cl_mem), (void*)&dst.data));
|
|
args.push_back(std::make_pair(sizeof(cl_float), (void*)&c_TB));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&modesUsed.rows));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&modesUsed.cols));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&modesUsed_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&weight_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&mean_step));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&dst_step));
|
|
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&dst_x));
|
|
args.push_back(std::make_pair(sizeof(cl_int), (void*)&dst_y));
|
|
|
|
openCLExecuteKernel(clCxt, &bgfg_mog, kernel_name, global_thread, local_thread, args, -1, -1, build_option);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// MOG2
|
|
|
|
namespace mog2
|
|
{
|
|
// default parameters of gaussian background detection algorithm
|
|
const int defaultHistory = 500; // Learning rate; alpha = 1/defaultHistory2
|
|
const float defaultVarThreshold = 4.0f * 4.0f;
|
|
const int defaultNMixtures = 5; // maximal number of Gaussians in mixture
|
|
const float defaultBackgroundRatio = 0.9f; // threshold sum of weights for background test
|
|
const float defaultVarThresholdGen = 3.0f * 3.0f;
|
|
const float defaultVarInit = 15.0f; // initial variance for new components
|
|
const float defaultVarMax = 5.0f * defaultVarInit;
|
|
const float defaultVarMin = 4.0f;
|
|
|
|
// additional parameters
|
|
const float defaultfCT = 0.05f; // complexity reduction prior constant 0 - no reduction of number of components
|
|
const unsigned char defaultnShadowDetection = 127; // value to use in the segmentation mask for shadows, set 0 not to do shadow detection
|
|
const float defaultfTau = 0.5f; // Tau - shadow threshold, see the paper for explanation
|
|
}
|
|
|
|
cv::ocl::MOG2::MOG2(int nmixtures) : frameSize_(0, 0), frameType_(0), nframes_(0)
|
|
{
|
|
nmixtures_ = nmixtures > 0 ? nmixtures : mog2::defaultNMixtures;
|
|
|
|
history = mog2::defaultHistory;
|
|
varThreshold = mog2::defaultVarThreshold;
|
|
bShadowDetection = true;
|
|
|
|
backgroundRatio = mog2::defaultBackgroundRatio;
|
|
fVarInit = mog2::defaultVarInit;
|
|
fVarMax = mog2::defaultVarMax;
|
|
fVarMin = mog2::defaultVarMin;
|
|
|
|
varThresholdGen = mog2::defaultVarThresholdGen;
|
|
fCT = mog2::defaultfCT;
|
|
nShadowDetection = mog2::defaultnShadowDetection;
|
|
fTau = mog2::defaultfTau;
|
|
}
|
|
|
|
void cv::ocl::MOG2::initialize(cv::Size frameSize, int frameType)
|
|
{
|
|
using namespace cv::ocl::device::mog;
|
|
CV_Assert(frameType == CV_8UC1 || frameType == CV_8UC3 || frameType == CV_8UC4);
|
|
|
|
frameSize_ = frameSize;
|
|
frameType_ = frameType;
|
|
nframes_ = 0;
|
|
|
|
int ch = CV_MAT_CN(frameType);
|
|
int work_ch = ch;
|
|
|
|
// for each gaussian mixture of each pixel bg model we store ...
|
|
// the mixture weight (w),
|
|
// the mean (nchannels values) and
|
|
// the covariance
|
|
weight_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC1);
|
|
weight_.setTo(Scalar::all(0));
|
|
|
|
variance_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC1);
|
|
variance_.setTo(Scalar::all(0));
|
|
|
|
mean_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC(work_ch)); //4 channels
|
|
mean_.setTo(Scalar::all(0));
|
|
|
|
//make the array for keeping track of the used modes per pixel - all zeros at start
|
|
bgmodelUsedModes_.create(frameSize_, CV_32FC1);
|
|
bgmodelUsedModes_.setTo(cv::Scalar::all(0));
|
|
|
|
loadConstants(varThreshold, backgroundRatio, varThresholdGen, fVarInit, fVarMin, fVarMax, fTau, nShadowDetection);
|
|
}
|
|
|
|
void cv::ocl::MOG2::operator()(const oclMat& frame, oclMat& fgmask, float learningRate)
|
|
{
|
|
using namespace cv::ocl::device::mog;
|
|
|
|
int ch = frame.oclchannels();
|
|
int work_ch = ch;
|
|
|
|
if (nframes_ == 0 || learningRate >= 1.0f || frame.size() != frameSize_ || work_ch != mean_.oclchannels())
|
|
initialize(frame.size(), frame.type());
|
|
|
|
fgmask.create(frameSize_, CV_8UC1);
|
|
fgmask.setTo(cv::Scalar::all(0));
|
|
|
|
++nframes_;
|
|
learningRate = learningRate >= 0.0f && nframes_ > 1 ? learningRate : 1.0f / std::min(2 * nframes_, history);
|
|
CV_Assert(learningRate >= 0.0f);
|
|
|
|
mog2_ocl(frame, frame.oclchannels(), fgmask, bgmodelUsedModes_, weight_, variance_, mean_, learningRate, -learningRate * fCT, bShadowDetection, nmixtures_);
|
|
}
|
|
|
|
void cv::ocl::MOG2::getBackgroundImage(oclMat& backgroundImage) const
|
|
{
|
|
using namespace cv::ocl::device::mog;
|
|
|
|
backgroundImage.create(frameSize_, frameType_);
|
|
|
|
cv::ocl::device::mog::getBackgroundImage2_ocl(backgroundImage.oclchannels(), bgmodelUsedModes_, weight_, mean_, backgroundImage, nmixtures_);
|
|
}
|
|
|
|
void cv::ocl::MOG2::release()
|
|
{
|
|
frameSize_ = Size(0, 0);
|
|
frameType_ = 0;
|
|
nframes_ = 0;
|
|
|
|
weight_.release();
|
|
variance_.release();
|
|
mean_.release();
|
|
|
|
bgmodelUsedModes_.release();
|
|
}
|