1 // This file is part of OpenCV project.
2 // It is subject to the license terms in the LICENSE file found in the top-level directory
3 // of this distribution and at http://opencv.org/license.html.
4 #include "precomp.hpp"
5 #include "rlof/rlof_localflow.h"
6 #include "rlof/geo_interpolation.hpp"
7 #include "opencv2/ximgproc.hpp"
8
9
10 namespace cv {
11 namespace optflow {
12
create()13 Ptr<RLOFOpticalFlowParameter> RLOFOpticalFlowParameter::create()
14 {
15 return Ptr<RLOFOpticalFlowParameter>(new RLOFOpticalFlowParameter);
16 }
17
setUseMEstimator(bool val)18 void RLOFOpticalFlowParameter::setUseMEstimator(bool val)
19 {
20 if (val)
21 {
22 normSigma0 = 3.2f;
23 normSigma1 = 7.f;
24 }
25 else
26 {
27 normSigma0 = std::numeric_limits<float>::max();
28 normSigma1 = std::numeric_limits<float>::max();
29 }
30 }
setSolverType(SolverType val)31 void RLOFOpticalFlowParameter::setSolverType(SolverType val){ solverType = val;}
getSolverType() const32 SolverType RLOFOpticalFlowParameter::getSolverType() const { return solverType;}
33
setSupportRegionType(SupportRegionType val)34 void RLOFOpticalFlowParameter::setSupportRegionType(SupportRegionType val){ supportRegionType = val;}
getSupportRegionType() const35 SupportRegionType RLOFOpticalFlowParameter::getSupportRegionType() const { return supportRegionType;}
36
setNormSigma0(float val)37 void RLOFOpticalFlowParameter::setNormSigma0(float val){ normSigma0 = val;}
getNormSigma0() const38 float RLOFOpticalFlowParameter::getNormSigma0() const { return normSigma0;}
39
setNormSigma1(float val)40 void RLOFOpticalFlowParameter::setNormSigma1(float val){ normSigma1 = val;}
getNormSigma1() const41 float RLOFOpticalFlowParameter::getNormSigma1() const { return normSigma1;}
42
setSmallWinSize(int val)43 void RLOFOpticalFlowParameter::setSmallWinSize(int val){ smallWinSize = val;}
getSmallWinSize() const44 int RLOFOpticalFlowParameter::getSmallWinSize() const { return smallWinSize;}
45
setLargeWinSize(int val)46 void RLOFOpticalFlowParameter::setLargeWinSize(int val){ largeWinSize = val;}
getLargeWinSize() const47 int RLOFOpticalFlowParameter::getLargeWinSize() const { return largeWinSize;}
48
setCrossSegmentationThreshold(int val)49 void RLOFOpticalFlowParameter::setCrossSegmentationThreshold(int val){ crossSegmentationThreshold = val;}
getCrossSegmentationThreshold() const50 int RLOFOpticalFlowParameter::getCrossSegmentationThreshold() const { return crossSegmentationThreshold;}
51
setMaxLevel(int val)52 void RLOFOpticalFlowParameter::setMaxLevel(int val){ maxLevel = val;}
getMaxLevel() const53 int RLOFOpticalFlowParameter::getMaxLevel() const { return maxLevel;}
54
setUseInitialFlow(bool val)55 void RLOFOpticalFlowParameter::setUseInitialFlow(bool val){ useInitialFlow = val;}
getUseInitialFlow() const56 bool RLOFOpticalFlowParameter::getUseInitialFlow() const { return useInitialFlow;}
57
setUseIlluminationModel(bool val)58 void RLOFOpticalFlowParameter::setUseIlluminationModel(bool val){ useIlluminationModel = val;}
getUseIlluminationModel() const59 bool RLOFOpticalFlowParameter::getUseIlluminationModel() const { return useIlluminationModel;}
60
setUseGlobalMotionPrior(bool val)61 void RLOFOpticalFlowParameter::setUseGlobalMotionPrior(bool val){ useGlobalMotionPrior = val;}
getUseGlobalMotionPrior() const62 bool RLOFOpticalFlowParameter::getUseGlobalMotionPrior() const { return useGlobalMotionPrior;}
63
setMaxIteration(int val)64 void RLOFOpticalFlowParameter::setMaxIteration(int val){ maxIteration = val;}
getMaxIteration() const65 int RLOFOpticalFlowParameter::getMaxIteration() const { return maxIteration;}
66
setMinEigenValue(float val)67 void RLOFOpticalFlowParameter::setMinEigenValue(float val){ minEigenValue = val;}
getMinEigenValue() const68 float RLOFOpticalFlowParameter::getMinEigenValue() const { return minEigenValue;}
69
setGlobalMotionRansacThreshold(float val)70 void RLOFOpticalFlowParameter::setGlobalMotionRansacThreshold(float val){ globalMotionRansacThreshold = val;}
getGlobalMotionRansacThreshold() const71 float RLOFOpticalFlowParameter::getGlobalMotionRansacThreshold() const { return globalMotionRansacThreshold;}
72
73 class DenseOpticalFlowRLOFImpl : public DenseRLOFOpticalFlow
74 {
75 public:
DenseOpticalFlowRLOFImpl()76 DenseOpticalFlowRLOFImpl()
77 : param(Ptr<RLOFOpticalFlowParameter>(new RLOFOpticalFlowParameter))
78 , forwardBackwardThreshold(1.f)
79 , gridStep(6, 6)
80 , interp_type(InterpolationType::INTERP_GEO)
81 , k(128)
82 , sigma(0.05f)
83 , lambda(999.f)
84 , fgs_lambda(500.0f)
85 , fgs_sigma(1.5f)
86 , use_post_proc(true)
87 , use_variational_refinement(false)
88 , sp_size(15)
89 , slic_type(ximgproc::SLIC)
90
91 {
92 prevPyramid[0] = cv::Ptr<CImageBuffer>(new CImageBuffer);
93 prevPyramid[1] = cv::Ptr<CImageBuffer>(new CImageBuffer);
94 currPyramid[0] = cv::Ptr<CImageBuffer>(new CImageBuffer);
95 currPyramid[1] = cv::Ptr<CImageBuffer>(new CImageBuffer);
96 }
setRLOFOpticalFlowParameter(Ptr<RLOFOpticalFlowParameter> val)97 virtual void setRLOFOpticalFlowParameter(Ptr<RLOFOpticalFlowParameter> val) CV_OVERRIDE { param = val; }
getRLOFOpticalFlowParameter() const98 virtual Ptr<RLOFOpticalFlowParameter> getRLOFOpticalFlowParameter() const CV_OVERRIDE { return param; }
99
getForwardBackward() const100 virtual float getForwardBackward() const CV_OVERRIDE { return forwardBackwardThreshold; }
setForwardBackward(float val)101 virtual void setForwardBackward(float val) CV_OVERRIDE { forwardBackwardThreshold = val; }
102
setInterpolation(InterpolationType val)103 virtual void setInterpolation(InterpolationType val) CV_OVERRIDE { interp_type = val; }
getInterpolation() const104 virtual InterpolationType getInterpolation() const CV_OVERRIDE { return interp_type; }
105
getGridStep() const106 virtual Size getGridStep() const CV_OVERRIDE { return gridStep; }
setGridStep(Size val)107 virtual void setGridStep(Size val) CV_OVERRIDE { gridStep = val; }
108
getEPICK() const109 virtual int getEPICK() const CV_OVERRIDE { return k; }
setEPICK(int val)110 virtual void setEPICK(int val) CV_OVERRIDE { k = val; }
111
getEPICSigma() const112 virtual float getEPICSigma() const CV_OVERRIDE { return sigma; }
setEPICSigma(float val)113 virtual void setEPICSigma(float val) CV_OVERRIDE { sigma = val; }
114
getEPICLambda() const115 virtual float getEPICLambda() const CV_OVERRIDE { return lambda; }
setEPICLambda(float val)116 virtual void setEPICLambda(float val) CV_OVERRIDE { lambda = val; }
117
getFgsLambda() const118 virtual float getFgsLambda() const CV_OVERRIDE { return fgs_lambda; }
setFgsLambda(float val)119 virtual void setFgsLambda(float val) CV_OVERRIDE { fgs_lambda = val; }
120
getFgsSigma() const121 virtual float getFgsSigma() const CV_OVERRIDE { return fgs_sigma; }
setFgsSigma(float val)122 virtual void setFgsSigma(float val) CV_OVERRIDE { fgs_sigma = val; }
123
getUsePostProc() const124 virtual bool getUsePostProc() const CV_OVERRIDE { return use_post_proc; }
setUsePostProc(bool val)125 virtual void setUsePostProc(bool val) CV_OVERRIDE { use_post_proc = val; }
126
setUseVariationalRefinement(bool val)127 virtual void setUseVariationalRefinement(bool val) CV_OVERRIDE { use_variational_refinement = val; }
getUseVariationalRefinement() const128 virtual bool getUseVariationalRefinement() const CV_OVERRIDE { return use_variational_refinement; }
129
setRICSPSize(int val)130 virtual void setRICSPSize(int val) CV_OVERRIDE { sp_size = val; }
getRICSPSize() const131 virtual int getRICSPSize() const CV_OVERRIDE { return sp_size; }
132
setRICSLICType(int val)133 virtual void setRICSLICType(int val) CV_OVERRIDE { slic_type = static_cast<ximgproc::SLICType>(val); }
getRICSLICType() const134 virtual int getRICSLICType() const CV_OVERRIDE { return slic_type; }
135
calc(InputArray I0,InputArray I1,InputOutputArray flow)136 virtual void calc(InputArray I0, InputArray I1, InputOutputArray flow) CV_OVERRIDE
137 {
138 CV_Assert(!I0.empty() && I0.depth() == CV_8U && (I0.channels() == 3 || I0.channels() == 1));
139 CV_Assert(!I1.empty() && I1.depth() == CV_8U && (I1.channels() == 3 || I1.channels() == 1));
140 CV_Assert(I0.sameSize(I1));
141 if (param.empty())
142 param = Ptr<RLOFOpticalFlowParameter>(new RLOFOpticalFlowParameter());
143 if (param->supportRegionType == SR_CROSS)
144 CV_Assert( I0.channels() == 3 && I1.channels() == 3);
145 CV_Assert(interp_type == InterpolationType::INTERP_EPIC || interp_type == InterpolationType::INTERP_GEO || interp_type == InterpolationType::INTERP_RIC);
146 // if no parameter is used use the default parameter
147
148 Mat prevImage = I0.getMat();
149 Mat currImage = I1.getMat();
150 int noPoints = prevImage.cols * prevImage.rows;
151 std::vector<cv::Point2f> prevPoints(noPoints);
152 std::vector<cv::Point2f> currPoints, refPoints;
153 noPoints = 0;
154 cv::Size grid_h = gridStep / 2;
155 for (int r = grid_h.height; r < prevImage.rows - grid_h.height; r += gridStep.height)
156 {
157 for (int c = grid_h.width; c < prevImage.cols - grid_h.width; c += gridStep.width)
158 {
159 prevPoints[noPoints++] = cv::Point2f(static_cast<float>(c), static_cast<float>(r));
160 }
161 }
162 prevPoints.erase(prevPoints.begin() + noPoints, prevPoints.end());
163 currPoints.resize(prevPoints.size());
164 calcLocalOpticalFlow(prevImage, currImage, prevPyramid, currPyramid, prevPoints, currPoints, *(param.get()));
165 flow.create(prevImage.size(), CV_32FC2);
166 Mat dense_flow = flow.getMat();
167
168 std::vector<Point2f> filtered_prevPoints;
169 std::vector<Point2f> filtered_currPoints;
170 if (gridStep == cv::Size(1, 1) && forwardBackwardThreshold <= 0)
171 {
172 for (unsigned int n = 0; n < prevPoints.size(); n++)
173 {
174 dense_flow.at<Point2f>(prevPoints[n]) = currPoints[n] - prevPoints[n];
175 }
176 return;
177 }
178 if (forwardBackwardThreshold > 0)
179 {
180 // reuse image pyramids
181 calcLocalOpticalFlow(currImage, prevImage, currPyramid, prevPyramid, currPoints, refPoints, *(param.get()));
182
183 filtered_prevPoints.resize(prevPoints.size());
184 filtered_currPoints.resize(prevPoints.size());
185 float sqrForwardBackwardThreshold = forwardBackwardThreshold * forwardBackwardThreshold;
186 noPoints = 0;
187 for (unsigned int r = 0; r < refPoints.size(); r++)
188 {
189 Point2f diff = refPoints[r] - prevPoints[r];
190 if (diff.x * diff.x + diff.y * diff.y < sqrForwardBackwardThreshold)
191 {
192 filtered_prevPoints[noPoints] = prevPoints[r];
193 filtered_currPoints[noPoints++] = currPoints[r];
194 }
195 }
196
197 filtered_prevPoints.erase(filtered_prevPoints.begin() + noPoints, filtered_prevPoints.end());
198 filtered_currPoints.erase(filtered_currPoints.begin() + noPoints, filtered_currPoints.end());
199
200 }
201 else
202 {
203 filtered_prevPoints = prevPoints;
204 filtered_currPoints = currPoints;
205 }
206 // Interpolators below expect non empty matches
207 if (filtered_prevPoints.empty()) {
208 flow.setTo(0);
209 return;
210 }
211 if (interp_type == InterpolationType::INTERP_EPIC)
212 {
213 Ptr<ximgproc::EdgeAwareInterpolator> gd = ximgproc::createEdgeAwareInterpolator();
214 gd->setK(k);
215 gd->setSigma(sigma);
216 gd->setLambda(lambda);
217 gd->setFGSLambda(fgs_lambda);
218 gd->setFGSSigma(fgs_sigma);
219 gd->setUsePostProcessing(use_post_proc);
220 gd->interpolate(prevImage, filtered_prevPoints, currImage, filtered_currPoints, dense_flow);
221 }
222 else if (interp_type == InterpolationType::INTERP_RIC)
223 {
224 Ptr<ximgproc::RICInterpolator> gd = ximgproc::createRICInterpolator();
225 gd->setK(k);
226 gd->setFGSLambda(fgs_lambda);
227 gd->setFGSSigma(fgs_sigma);
228 gd->setSuperpixelSize(sp_size);
229 gd->setSuperpixelMode(slic_type);
230 gd->setUseGlobalSmootherFilter(use_post_proc);
231 gd->setUseVariationalRefinement(false);
232 gd->interpolate(prevImage, filtered_prevPoints, currImage, filtered_currPoints, dense_flow);
233 }
234 else
235 {
236 Mat blurredPrevImage, blurredCurrImage;
237 GaussianBlur(prevImage, blurredPrevImage, cv::Size(5, 5), -1);
238 std::vector<uchar> status(filtered_currPoints.size(), 1);
239 interpolate_irregular_nn_raster(filtered_prevPoints, filtered_currPoints, status, blurredPrevImage).copyTo(dense_flow);
240 std::vector<Mat> vecMats;
241 std::vector<Mat> vecMats2(2);
242 cv::split(dense_flow, vecMats);
243 cv::bilateralFilter(vecMats[0], vecMats2[0], 5, 2, 20);
244 cv::bilateralFilter(vecMats[1], vecMats2[1], 5, 2, 20);
245 cv::merge(vecMats2, dense_flow);
246 if (use_post_proc)
247 {
248 ximgproc::fastGlobalSmootherFilter(prevImage, flow, flow, fgs_lambda, fgs_sigma);
249 }
250 }
251 if (use_variational_refinement)
252 {
253 Mat prevGrey, currGrey;
254 Ptr<VariationalRefinement > variationalrefine = VariationalRefinement::create();
255 cvtColor(prevImage, prevGrey, COLOR_BGR2GRAY);
256 cvtColor(currImage, currGrey, COLOR_BGR2GRAY);
257 variationalrefine->setOmega(1.9f);
258 variationalrefine->calc(prevGrey, currGrey, flow);
259 }
260 }
261
collectGarbage()262 virtual void collectGarbage() CV_OVERRIDE
263 {
264 prevPyramid[0].release();
265 prevPyramid[1].release();
266 currPyramid[0].release();
267 currPyramid[1].release();
268 }
269
270 protected:
271 Ptr<RLOFOpticalFlowParameter> param;
272 float forwardBackwardThreshold;
273 Ptr<CImageBuffer> prevPyramid[2];
274 Ptr<CImageBuffer> currPyramid[2];
275 cv::Size gridStep;
276 InterpolationType interp_type;
277 int k;
278 float sigma;
279 float lambda;
280 float fgs_lambda;
281 float fgs_sigma;
282 bool use_post_proc;
283 bool use_variational_refinement;
284 int sp_size;
285 ximgproc::SLICType slic_type;
286 };
287
create(Ptr<RLOFOpticalFlowParameter> rlofParam,float forwardBackwardThreshold,cv::Size gridStep,InterpolationType interp_type,int epicK,float epicSigma,float epicLambda,int ricSPSize,int ricSLICType,bool use_post_proc,float fgs_lambda,float fgs_sigma,bool use_variational_refinement)288 Ptr<DenseRLOFOpticalFlow> DenseRLOFOpticalFlow::create(
289 Ptr<RLOFOpticalFlowParameter> rlofParam,
290 float forwardBackwardThreshold,
291 cv::Size gridStep,
292 InterpolationType interp_type,
293 int epicK,
294 float epicSigma,
295 float epicLambda,
296 int ricSPSize,
297 int ricSLICType,
298 bool use_post_proc,
299 float fgs_lambda,
300 float fgs_sigma,
301 bool use_variational_refinement)
302 {
303 Ptr<DenseRLOFOpticalFlow> algo = makePtr<DenseOpticalFlowRLOFImpl>();
304 algo->setRLOFOpticalFlowParameter(rlofParam);
305 algo->setForwardBackward(forwardBackwardThreshold);
306 algo->setGridStep(gridStep);
307 algo->setInterpolation(interp_type);
308 algo->setEPICK(epicK);
309 algo->setEPICSigma(epicSigma);
310 algo->setEPICLambda(epicLambda);
311 algo->setUsePostProc(use_post_proc);
312 algo->setFgsLambda(fgs_lambda);
313 algo->setFgsSigma(fgs_sigma);
314 algo->setRICSLICType(ricSLICType);
315 algo->setRICSPSize(ricSPSize);
316 algo->setUseVariationalRefinement(use_variational_refinement);
317 return algo;
318 }
319
320 class SparseRLOFOpticalFlowImpl : public SparseRLOFOpticalFlow
321 {
322 public:
SparseRLOFOpticalFlowImpl()323 SparseRLOFOpticalFlowImpl()
324 : param(Ptr<RLOFOpticalFlowParameter>(new RLOFOpticalFlowParameter))
325 , forwardBackwardThreshold(1.f)
326 {
327 prevPyramid[0] = cv::Ptr< CImageBuffer>(new CImageBuffer);
328 prevPyramid[1] = cv::Ptr< CImageBuffer>(new CImageBuffer);
329 currPyramid[0] = cv::Ptr< CImageBuffer>(new CImageBuffer);
330 currPyramid[1] = cv::Ptr< CImageBuffer>(new CImageBuffer);
331 }
setRLOFOpticalFlowParameter(Ptr<RLOFOpticalFlowParameter> val)332 virtual void setRLOFOpticalFlowParameter(Ptr<RLOFOpticalFlowParameter> val) CV_OVERRIDE { param = val; }
getRLOFOpticalFlowParameter() const333 virtual Ptr<RLOFOpticalFlowParameter> getRLOFOpticalFlowParameter() const CV_OVERRIDE { return param; }
334
getForwardBackward() const335 virtual float getForwardBackward() const CV_OVERRIDE { return forwardBackwardThreshold; }
setForwardBackward(float val)336 virtual void setForwardBackward(float val) CV_OVERRIDE { forwardBackwardThreshold = val; }
337
calc(InputArray prevImg,InputArray nextImg,InputArray prevPts,InputOutputArray nextPts,OutputArray status,OutputArray err)338 virtual void calc(InputArray prevImg, InputArray nextImg,
339 InputArray prevPts, InputOutputArray nextPts,
340 OutputArray status,
341 OutputArray err) CV_OVERRIDE
342 {
343 CV_Assert(!prevImg.empty() && prevImg.depth() == CV_8U && (prevImg.channels() == 3 || prevImg.channels() == 1));
344 CV_Assert(!nextImg.empty() && nextImg.depth() == CV_8U && (nextImg.channels() == 3 || nextImg.channels() == 1));
345 CV_Assert(prevImg.sameSize(nextImg));
346
347 if (param.empty())
348 {
349 param = makePtr<RLOFOpticalFlowParameter>();
350 }
351 CV_DbgAssert(!param.empty());
352
353 if (param->supportRegionType == SR_CROSS)
354 {
355 CV_CheckChannelsEQ(prevImg.channels(), 3, "SR_CROSS mode requires images with 3 channels");
356 CV_CheckChannelsEQ(nextImg.channels(), 3, "SR_CROSS mode requires images with 3 channels");
357 }
358
359 Mat prevImage = prevImg.getMat();
360 Mat nextImage = nextImg.getMat();
361 Mat prevPtsMat = prevPts.getMat();
362
363 if (param->useInitialFlow == false)
364 nextPts.create(prevPtsMat.size(), prevPtsMat.type(), -1, true);
365
366 int npoints = 0;
367 CV_Assert((npoints = prevPtsMat.checkVector(2, CV_32F, true)) >= 0);
368 if (npoints == 0)
369 {
370 nextPts.release();
371 status.release();
372 err.release();
373 return;
374 }
375 Mat nextPtsMat = nextPts.getMat();
376 CV_Assert(nextPtsMat.checkVector(2, CV_32F, true) == npoints);
377
378 std::vector<cv::Point2f> prevPoints(npoints), nextPoints(npoints), refPoints;
379
380 if (prevPtsMat.channels() != 2)
381 prevPtsMat = prevPtsMat.reshape(2, npoints);
382
383 prevPtsMat.copyTo(prevPoints);
384
385 if (param->useInitialFlow )
386 {
387 if (nextPtsMat.channels() != 2)
388 nextPtsMat = nextPtsMat.reshape(2, npoints);
389 nextPtsMat.copyTo(nextPoints);
390 }
391 cv::Mat statusMat;
392 cv::Mat errorMat;
393 if (status.needed() || forwardBackwardThreshold > 0)
394 {
395 status.create((int)npoints, 1, CV_8U, -1, true);
396 statusMat = status.getMat();
397 statusMat.setTo(1);
398 }
399
400 if (err.needed() || forwardBackwardThreshold > 0)
401 {
402 err.create((int)npoints, 1, CV_32F, -1, true);
403 errorMat = err.getMat();
404 errorMat.setTo(0);
405 }
406
407 calcLocalOpticalFlow(prevImage, nextImage, prevPyramid, currPyramid, prevPoints, nextPoints, *(param.get()));
408 cv::Mat(1,npoints , CV_32FC2, &nextPoints[0]).copyTo(nextPtsMat);
409 if (forwardBackwardThreshold > 0)
410 {
411 // reuse image pyramids
412 calcLocalOpticalFlow(nextImage, prevImage, currPyramid, prevPyramid, nextPoints, refPoints, *(param.get()));
413 }
414 for (unsigned int r = 0; r < refPoints.size(); r++)
415 {
416 Point2f diff = refPoints[r] - prevPoints[r];
417 errorMat.at<float>(r) = sqrt(diff.x * diff.x + diff.y * diff.y);
418 if (errorMat.at<float>(r) > forwardBackwardThreshold)
419 statusMat.at<uchar>(r) = 0;
420 }
421
422 }
423
424 protected:
425 Ptr<RLOFOpticalFlowParameter> param;
426 float forwardBackwardThreshold;
427 Ptr<CImageBuffer> prevPyramid[2];
428 Ptr<CImageBuffer> currPyramid[2];
429 };
430
create(Ptr<RLOFOpticalFlowParameter> rlofParam,float forwardBackwardThreshold)431 Ptr<SparseRLOFOpticalFlow> SparseRLOFOpticalFlow::create(
432 Ptr<RLOFOpticalFlowParameter> rlofParam,
433 float forwardBackwardThreshold)
434 {
435 Ptr<SparseRLOFOpticalFlow> algo = makePtr<SparseRLOFOpticalFlowImpl>();
436 algo->setRLOFOpticalFlowParameter(rlofParam);
437 algo->setForwardBackward(forwardBackwardThreshold);
438 return algo;
439 }
440
calcOpticalFlowDenseRLOF(InputArray I0,InputArray I1,InputOutputArray flow,Ptr<RLOFOpticalFlowParameter> rlofParam,float forewardBackwardThreshold,Size gridStep,InterpolationType interp_type,int epicK,float epicSigma,float epicLambda,int superpixelSize,int superpixelType,bool use_post_proc,float fgsLambda,float fgsSigma,bool use_variational_refinement)441 void calcOpticalFlowDenseRLOF(InputArray I0, InputArray I1, InputOutputArray flow,
442 Ptr<RLOFOpticalFlowParameter> rlofParam ,
443 float forewardBackwardThreshold, Size gridStep,
444 InterpolationType interp_type,
445 int epicK, float epicSigma, float epicLambda,
446 int superpixelSize, int superpixelType,
447 bool use_post_proc, float fgsLambda, float fgsSigma, bool use_variational_refinement)
448 {
449 Ptr<DenseRLOFOpticalFlow> algo = DenseRLOFOpticalFlow::create(
450 rlofParam, forewardBackwardThreshold, gridStep, interp_type,
451 epicK, epicSigma, epicLambda, superpixelSize, superpixelType,
452 use_post_proc, fgsLambda, fgsSigma, use_variational_refinement);
453 algo->calc(I0, I1, flow);
454 algo->collectGarbage();
455 }
456
calcOpticalFlowSparseRLOF(InputArray prevImg,InputArray nextImg,InputArray prevPts,InputOutputArray nextPts,OutputArray status,OutputArray err,Ptr<RLOFOpticalFlowParameter> rlofParam,float forewardBackwardThreshold)457 void calcOpticalFlowSparseRLOF(InputArray prevImg, InputArray nextImg,
458 InputArray prevPts, InputOutputArray nextPts,
459 OutputArray status, OutputArray err,
460 Ptr<RLOFOpticalFlowParameter> rlofParam,
461 float forewardBackwardThreshold)
462 {
463 Ptr<SparseRLOFOpticalFlow> algo = SparseRLOFOpticalFlow::create(
464 rlofParam, forewardBackwardThreshold);
465 algo->calc(prevImg, nextImg, prevPts, nextPts, status, err);
466 }
createOptFlow_DenseRLOF()467 Ptr<DenseOpticalFlow> createOptFlow_DenseRLOF()
468 {
469 return DenseRLOFOpticalFlow::create();
470 }
471
createOptFlow_SparseRLOF()472 Ptr<SparseOpticalFlow> createOptFlow_SparseRLOF()
473 {
474 return SparseRLOFOpticalFlow::create();
475 }
476
477 }} // namespace
478