#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
-Ptr<SparsePyrLKOpticalFlow> cv::cuda::SparsePyrLKOpticalFlow::create(Size, int, int, bool) { throw_no_cuda(); return Ptr<SparsePyrLKOpticalFlow>(); }
+Ptr<cv::cuda::SparsePyrLKOpticalFlow> cv::cuda::SparsePyrLKOpticalFlow::create(Size, int, int, bool) { throw_no_cuda(); return Ptr<SparsePyrLKOpticalFlow>(); }
-Ptr<DensePyrLKOpticalFlow> cv::cuda::DensePyrLKOpticalFlow::create(Size, int, int, bool) { throw_no_cuda(); return Ptr<DensePyrLKOpticalFlow>(); }
+Ptr<cv::cuda::DensePyrLKOpticalFlow> cv::cuda::DensePyrLKOpticalFlow::create(Size, int, int, bool) { throw_no_cuda(); return Ptr<DensePyrLKOpticalFlow>(); }
#else /* !defined (HAVE_CUDA) */
vPyr[idx].copyTo(v, stream);
}
- class SparsePyrLKOpticalFlowImpl : public SparsePyrLKOpticalFlow, private PyrLKOpticalFlowBase
+ class SparsePyrLKOpticalFlowImpl : public cv::cuda::SparsePyrLKOpticalFlow, private PyrLKOpticalFlowBase
{
public:
SparsePyrLKOpticalFlowImpl(Size winSize, int maxLevel, int iters, bool useInitialFlow) :
};
}
-Ptr<SparsePyrLKOpticalFlow> cv::cuda::SparsePyrLKOpticalFlow::create(Size winSize, int maxLevel, int iters, bool useInitialFlow)
+Ptr<cv::cuda::SparsePyrLKOpticalFlow> cv::cuda::SparsePyrLKOpticalFlow::create(Size winSize, int maxLevel, int iters, bool useInitialFlow)
{
return makePtr<SparsePyrLKOpticalFlowImpl>(winSize, maxLevel, iters, useInitialFlow);
}
-Ptr<DensePyrLKOpticalFlow> cv::cuda::DensePyrLKOpticalFlow::create(Size winSize, int maxLevel, int iters, bool useInitialFlow)
+Ptr<cv::cuda::DensePyrLKOpticalFlow> cv::cuda::DensePyrLKOpticalFlow::create(Size winSize, int maxLevel, int iters, bool useInitialFlow)
{
return makePtr<DensePyrLKOpticalFlowImpl>(winSize, maxLevel, iters, useInitialFlow);
}
-#endif /* !defined (HAVE_CUDA) */
\ No newline at end of file
+#endif /* !defined (HAVE_CUDA) */
return maxLevel;
}
-#ifdef HAVE_OPENCL
namespace cv
{
- class PyrLKOpticalFlow
+namespace
+{
+ class SparsePyrLKOpticalFlowImpl : public SparsePyrLKOpticalFlow
{
struct dim3
{
dim3() : x(0), y(0), z(0) { }
};
public:
- PyrLKOpticalFlow()
+ SparsePyrLKOpticalFlowImpl(Size winSize_ = Size(21,21),
+ int maxLevel_ = 3,
+ TermCriteria criteria_ = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
+ int flags_ = 0,
+ double minEigThreshold_ = 1e-4) :
+ winSize(winSize_), maxLevel(maxLevel_), criteria(criteria_), flags(flags_), minEigThreshold(minEigThreshold_)
+#ifdef HAVE_OPENCL
+ , iters(criteria_.maxCount), derivLambda(criteria_.epsilon), useInitialFlow(0 != (flags_ & OPTFLOW_LK_GET_MIN_EIGENVALS)), waveSize(0)
+#endif
{
- winSize = Size(21, 21);
- maxLevel = 3;
- iters = 30;
- derivLambda = 0.5;
- useInitialFlow = false;
-
- waveSize = 0;
}
+ virtual Size getWinSize() const {return winSize;}
+ virtual void setWinSize(Size winSize_){winSize = winSize_;}
+
+ virtual int getMaxLevel() const {return maxLevel;}
+ virtual void setMaxLevel(int maxLevel_){maxLevel = maxLevel_;}
+
+ virtual TermCriteria getTermCriteria() const {return criteria;}
+ virtual void setTermCriteria(TermCriteria& crit_){criteria=crit_;}
+
+ virtual int getFlags() const {return flags; }
+ virtual void setFlags(int flags_){flags=flags_;}
+
+ virtual double getMinEigThreshold() const {return minEigThreshold;}
+ virtual void setMinEigThreshold(double minEigThreshold_){minEigThreshold=minEigThreshold_;}
+
+ virtual void calc(InputArray prevImg, InputArray nextImg,
+ InputArray prevPts, InputOutputArray nextPts,
+ OutputArray status,
+ OutputArray err = cv::noArray());
+
+ private:
+#ifdef HAVE_OPENCL
bool checkParam()
{
iters = std::min(std::max(iters, 0), 100);
}
return true;
}
+#endif
Size winSize;
int maxLevel;
+ TermCriteria criteria;
+ int flags;
+ double minEigThreshold;
+#ifdef HAVE_OPENCL
int iters;
double derivLambda;
bool useInitialFlow;
-
- private:
int waveSize;
bool initWaveSize()
{
{
return (cv::ocl::Device::TYPE_CPU == cv::ocl::Device::getDefault().type());
}
- };
- static bool ocl_calcOpticalFlowPyrLK(InputArray _prevImg, InputArray _nextImg,
- InputArray _prevPts, InputOutputArray _nextPts,
- OutputArray _status, OutputArray _err,
- Size winSize, int maxLevel,
- TermCriteria criteria,
- int flags/*, double minEigThreshold*/ )
+ bool ocl_calcOpticalFlowPyrLK(InputArray _prevImg, InputArray _nextImg,
+ InputArray _prevPts, InputOutputArray _nextPts,
+ OutputArray _status, OutputArray _err)
{
if (0 != (OPTFLOW_LK_GET_MIN_EIGENVALS & flags))
return false;
if ((1 != _prevPts.size().height) && (1 != _prevPts.size().width))
return false;
size_t npoints = _prevPts.total();
- bool useInitialFlow = (0 != (flags & OPTFLOW_USE_INITIAL_FLOW));
if (useInitialFlow)
{
if (_nextPts.empty() || _nextPts.type() != CV_32FC2 || (!_prevPts.isContinuous()))
_nextPts.create(_prevPts.size(), _prevPts.type());
}
- PyrLKOpticalFlow opticalFlow;
- opticalFlow.winSize = winSize;
- opticalFlow.maxLevel = maxLevel;
- opticalFlow.iters = criteria.maxCount;
- opticalFlow.derivLambda = criteria.epsilon;
- opticalFlow.useInitialFlow = useInitialFlow;
-
- if (!opticalFlow.checkParam())
+ if (!checkParam())
return false;
UMat umatErr;
_status.create((int)npoints, 1, CV_8UC1);
UMat umatNextPts = _nextPts.getUMat();
UMat umatStatus = _status.getUMat();
- return opticalFlow.sparse(_prevImg.getUMat(), _nextImg.getUMat(), _prevPts.getUMat(), umatNextPts, umatStatus, umatErr);
+ return sparse(_prevImg.getUMat(), _nextImg.getUMat(), _prevPts.getUMat(), umatNextPts, umatStatus, umatErr);
}
-};
#endif
+};
-void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
+void SparsePyrLKOpticalFlowImpl::calc( InputArray _prevImg, InputArray _nextImg,
InputArray _prevPts, InputOutputArray _nextPts,
- OutputArray _status, OutputArray _err,
- Size winSize, int maxLevel,
- TermCriteria criteria,
- int flags, double minEigThreshold )
+ OutputArray _status, OutputArray _err)
{
-#ifdef HAVE_OPENCL
- bool use_opencl = ocl::useOpenCL() &&
- (_prevImg.isUMat() || _nextImg.isUMat()) &&
- ocl::Image2D::isFormatSupported(CV_32F, 1, false);
- if ( use_opencl && ocl_calcOpticalFlowPyrLK(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err, winSize, maxLevel, criteria, flags/*, minEigThreshold*/))
- {
- CV_IMPL_ADD(CV_IMPL_OCL);
- return;
- }
-#endif
+ CV_OCL_RUN(ocl::useOpenCL() &&
+ (_prevImg.isUMat() || _nextImg.isUMat()) &&
+ ocl::Image2D::isFormatSupported(CV_32F, 1, false),
+ ocl_calcOpticalFlowPyrLK(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err))
Mat prevPtsMat = _prevPts.getMat();
const int derivDepth = DataType<cv::detail::deriv_type>::depth;
}
}
+} // namespace
+} // namespace cv
+cv::Ptr<cv::SparsePyrLKOpticalFlow> cv::SparsePyrLKOpticalFlow::create(Size winSize, int maxLevel, TermCriteria crit, int flags, double minEigThreshold){
+ return makePtr<SparsePyrLKOpticalFlowImpl>(winSize,maxLevel,crit,flags,minEigThreshold);
+}
+void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
+ InputArray _prevPts, InputOutputArray _nextPts,
+ OutputArray _status, OutputArray _err,
+ Size winSize, int maxLevel,
+ TermCriteria criteria,
+ int flags, double minEigThreshold )
+{
+ Ptr<cv::SparsePyrLKOpticalFlow> optflow = cv::SparsePyrLKOpticalFlow::create(winSize,maxLevel,criteria,flags,minEigThreshold);
+ optflow->calc(_prevImg,_nextImg,_prevPts,_nextPts,_status,_err);
+}
+
namespace cv
{