~paparazzi-uav/paparazzi/v5.0-manual

Ptr<cuda::BackgroundSubtractorMOG2> cv::cuda::createBackgroundSubtractorMOG2(int, double, bool) { throw_no_cuda(); return Ptr<cuda::BackgroundSubtractorMOG2>(); }

#else

namespace cv { namespace cuda { namespace device

{

namespace mog2

{

void loadConstants(int nmixtures, float Tb, float TB, float Tg, float varInit, float varMin, float varMax, float tau, unsigned char shadowVal);

void mog2_gpu(PtrStepSzb frame, int cn, PtrStepSzb fgmask, PtrStepSzb modesUsed, PtrStepSzf weight, PtrStepSzf variance, PtrStepSzb mean, float alphaT, float prune, bool detectShadows, cudaStream_t stream);

void getBackgroundImage2_gpu(int cn, PtrStepSzb modesUsed, PtrStepSzf weight, PtrStepSzb mean, PtrStepSzb dst, cudaStream_t stream);

}

}}}

namespace

{

// 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 defaultCT = 0.05f; // complexity reduction prior constant 0 - no reduction of number of components

const unsigned char defaultShadowValue = 127; // value to use in the segmentation mask for shadows, set 0 not to do shadow detection

const float defaultShadowThreshold = 0.5f; // Tau - shadow threshold, see the paper for explanation

class MOG2Impl : public cuda::BackgroundSubtractorMOG2

{

public:

MOG2Impl(int history, double varThreshold, bool detectShadows);

void apply(InputArray image, OutputArray fgmask, double learningRate=-1);

void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream);

void getBackgroundImage(OutputArray backgroundImage) const;

void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const;

int getHistory() const { return history_; }

void setHistory(int history) { history_ = history; }

int getNMixtures() const { return nmixtures_; }

void setNMixtures(int nmixtures) { nmixtures_ = nmixtures; }

double getBackgroundRatio() const { return backgroundRatio_; }

void setBackgroundRatio(double ratio) { backgroundRatio_ = (float) ratio; }

100

101

double getVarThreshold() const { return varThreshold_; }

102

void setVarThreshold(double varThreshold) { varThreshold_ = (float) varThreshold; }

103

104

double getVarThresholdGen() const { return varThresholdGen_; }

105

void setVarThresholdGen(double varThresholdGen) { varThresholdGen_ = (float) varThresholdGen; }

106

107

double getVarInit() const { return varInit_; }

108

void setVarInit(double varInit) { varInit_ = (float) varInit; }

109

110

double getVarMin() const { return varMin_; }

111

void setVarMin(double varMin) { varMin_ = (float) varMin; }

112

113

double getVarMax() const { return varMax_; }

114

void setVarMax(double varMax) { varMax_ = (float) varMax; }

115

116

double getComplexityReductionThreshold() const { return ct_; }

117

void setComplexityReductionThreshold(double ct) { ct_ = (float) ct; }

118

119

bool getDetectShadows() const { return detectShadows_; }

120

void setDetectShadows(bool detectShadows) { detectShadows_ = detectShadows; }

121

122

int getShadowValue() const { return shadowValue_; }

123

void setShadowValue(int value) { shadowValue_ = (uchar) value; }

124

125

double getShadowThreshold() const { return shadowThreshold_; }

126

void setShadowThreshold(double threshold) { shadowThreshold_ = (float) threshold; }

127

128

private:

129

void initialize(Size frameSize, int frameType);

130

131

int history_;

132

int nmixtures_;

133

float backgroundRatio_;

134

float varThreshold_;

135

float varThresholdGen_;

136

float varInit_;

137

float varMin_;

138

float varMax_;

139

float ct_;

140

bool detectShadows_;

141

uchar shadowValue_;

142

float shadowThreshold_;

143

144

Size frameSize_;

145

int frameType_;

146

int nframes_;

147

148

GpuMat weight_;

149

GpuMat variance_;

150

GpuMat mean_;

151

152

//keep track of number of modes per pixel

153

GpuMat bgmodelUsedModes_;

154

};

155

156

MOG2Impl::MOG2Impl(int history, double varThreshold, bool detectShadows) :

157

frameSize_(0, 0), frameType_(0), nframes_(0)

158

{

159

history_ = history > 0 ? history : defaultHistory;

160

varThreshold_ = varThreshold > 0 ? (float) varThreshold : defaultVarThreshold;

161

detectShadows_ = detectShadows;

162

163

nmixtures_ = defaultNMixtures;

164

backgroundRatio_ = defaultBackgroundRatio;

165

varInit_ = defaultVarInit;

166

varMax_ = defaultVarMax;

167

varMin_ = defaultVarMin;

168

varThresholdGen_ = defaultVarThresholdGen;

169

ct_ = defaultCT;

170

shadowValue_ = defaultShadowValue;

171

shadowThreshold_ = defaultShadowThreshold;

172

}

173

174

void MOG2Impl::apply(InputArray image, OutputArray fgmask, double learningRate)

175

{

176

apply(image, fgmask, learningRate, Stream::Null());

177

}

178

179

void MOG2Impl::apply(InputArray _frame, OutputArray _fgmask, double learningRate, Stream& stream)

180

{

181

using namespace cv::cuda::device::mog2;

182

183

GpuMat frame = _frame.getGpuMat();

184

185

int ch = frame.channels();

186

int work_ch = ch;

187

188

if (nframes_ == 0 || learningRate >= 1.0 || frame.size() != frameSize_ || work_ch != mean_.channels())

189

initialize(frame.size(), frame.type());

190

191

_fgmask.create(frameSize_, CV_8UC1);

192

GpuMat fgmask = _fgmask.getGpuMat();

193

194

fgmask.setTo(Scalar::all(0), stream);

195

196

++nframes_;

197

learningRate = learningRate >= 0 && nframes_ > 1 ? learningRate : 1.0 / std::min(2 * nframes_, history_);

198

CV_Assert( learningRate >= 0 );

199

200

mog2_gpu(frame, frame.channels(), fgmask, bgmodelUsedModes_, weight_, variance_, mean_,

201

(float) learningRate, static_cast<float>(-learningRate * ct_), detectShadows_, StreamAccessor::getStream(stream));

202

}

203

204

void MOG2Impl::getBackgroundImage(OutputArray backgroundImage) const

205

{

206

getBackgroundImage(backgroundImage, Stream::Null());

207

}

208

209

void MOG2Impl::getBackgroundImage(OutputArray _backgroundImage, Stream& stream) const

210

{

211

using namespace cv::cuda::device::mog2;

212

213

_backgroundImage.create(frameSize_, frameType_);

214

GpuMat backgroundImage = _backgroundImage.getGpuMat();

215

216

getBackgroundImage2_gpu(backgroundImage.channels(), bgmodelUsedModes_, weight_, mean_, backgroundImage, StreamAccessor::getStream(stream));

217

}

218

219

void MOG2Impl::initialize(cv::Size frameSize, int frameType)

220

{

221

using namespace cv::cuda::device::mog2;

222

223

CV_Assert( frameType == CV_8UC1 || frameType == CV_8UC3 || frameType == CV_8UC4 );

224

225

frameSize_ = frameSize;

226

frameType_ = frameType;

227

nframes_ = 0;

228

229

int ch = CV_MAT_CN(frameType);

230

int work_ch = ch;

231

232

// for each gaussian mixture of each pixel bg model we store ...

233

// the mixture weight (w),

234

// the mean (nchannels values) and

235

// the covariance

236

weight_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC1);

237

variance_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC1);

238

mean_.create(frameSize.height * nmixtures_, frameSize_.width, CV_32FC(work_ch));

239

240

//make the array for keeping track of the used modes per pixel - all zeros at start

241

bgmodelUsedModes_.create(frameSize_, CV_8UC1);

242

bgmodelUsedModes_.setTo(Scalar::all(0));

243

244

loadConstants(nmixtures_, varThreshold_, backgroundRatio_, varThresholdGen_, varInit_, varMin_, varMax_, shadowThreshold_, shadowValue_);

245

}

246

}

247

248

Ptr<cuda::BackgroundSubtractorMOG2> cv::cuda::createBackgroundSubtractorMOG2(int history, double varThreshold, bool detectShadows)

249

{

250

return makePtr<MOG2Impl>(history, varThreshold, detectShadows);

251

}

252

253

#endif

Older »