class CV_EXPORTS NullDeblurer : public DeblurerBase
{
public:
- virtual void deblur(int /*idx*/, Mat &/*frame*/) {}
+ virtual void deblur(int /*idx*/, Mat &/*frame*/) CV_OVERRIDE {}
};
class CV_EXPORTS WeightingDeblurer : public DeblurerBase
void setSensitivity(float val) { sensitivity_ = val; }
float sensitivity() const { return sensitivity_; }
- virtual void deblur(int idx, Mat &frame);
+ virtual void deblur(int idx, Mat &frame) CV_OVERRIDE;
private:
float sensitivity_;
class CV_EXPORTS NullFrameSource : public IFrameSource
{
public:
- virtual void reset() {}
- virtual Mat nextFrame() { return Mat(); }
+ virtual void reset() CV_OVERRIDE {}
+ virtual Mat nextFrame() CV_OVERRIDE { return Mat(); }
};
class CV_EXPORTS VideoFileSource : public IFrameSource
public:
VideoFileSource(const String &path, bool volatileFrame = false);
- virtual void reset();
- virtual Mat nextFrame();
+ virtual void reset() CV_OVERRIDE;
+ virtual Mat nextFrame() CV_OVERRIDE;
int width();
int height();
void setMinInlierRatio(float val) { minInlierRatio_ = val; }
float minInlierRatio() const { return minInlierRatio_; }
- virtual Mat estimate(InputArray points0, InputArray points1, bool *ok = 0);
+ virtual Mat estimate(InputArray points0, InputArray points1, bool *ok = 0) CV_OVERRIDE;
private:
RansacParams ransacParams_;
public:
MotionEstimatorL1(MotionModel model = MM_AFFINE);
- virtual Mat estimate(InputArray points0, InputArray points1, bool *ok = 0);
+ virtual Mat estimate(InputArray points0, InputArray points1, bool *ok = 0) CV_OVERRIDE;
private:
std::vector<double> obj_, collb_, colub_;
public:
FromFileMotionReader(const String &path);
- virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0);
+ virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0) CV_OVERRIDE;
private:
std::ifstream file_;
public:
ToFileMotionWriter(const String &path, Ptr<ImageMotionEstimatorBase> estimator);
- virtual void setMotionModel(MotionModel val) { motionEstimator_->setMotionModel(val); }
- virtual MotionModel motionModel() const { return motionEstimator_->motionModel(); }
+ virtual void setMotionModel(MotionModel val) CV_OVERRIDE { motionEstimator_->setMotionModel(val); }
+ virtual MotionModel motionModel() const CV_OVERRIDE { return motionEstimator_->motionModel(); }
- virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0);
+ virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0) CV_OVERRIDE;
private:
std::ofstream file_;
public:
KeypointBasedMotionEstimator(Ptr<MotionEstimatorBase> estimator);
- virtual void setMotionModel(MotionModel val) { motionEstimator_->setMotionModel(val); }
- virtual MotionModel motionModel() const { return motionEstimator_->motionModel(); }
+ virtual void setMotionModel(MotionModel val) CV_OVERRIDE { motionEstimator_->setMotionModel(val); }
+ virtual MotionModel motionModel() const CV_OVERRIDE { return motionEstimator_->motionModel(); }
void setDetector(Ptr<FeatureDetector> val) { detector_ = val; }
Ptr<FeatureDetector> detector() const { return detector_; }
void setOutlierRejector(Ptr<IOutlierRejector> val) { outlierRejector_ = val; }
Ptr<IOutlierRejector> outlierRejector() const { return outlierRejector_; }
- virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0);
+ virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0) CV_OVERRIDE;
Mat estimate(InputArray frame0, InputArray frame1, bool *ok = 0);
private:
public:
KeypointBasedMotionEstimatorGpu(Ptr<MotionEstimatorBase> estimator);
- virtual void setMotionModel(MotionModel val) { motionEstimator_->setMotionModel(val); }
- virtual MotionModel motionModel() const { return motionEstimator_->motionModel(); }
+ virtual void setMotionModel(MotionModel val) CV_OVERRIDE { motionEstimator_->setMotionModel(val); }
+ virtual MotionModel motionModel() const CV_OVERRIDE { return motionEstimator_->motionModel(); }
void setOutlierRejector(Ptr<IOutlierRejector> val) { outlierRejector_ = val; }
Ptr<IOutlierRejector> outlierRejector() const { return outlierRejector_; }
- virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0);
+ virtual Mat estimate(const Mat &frame0, const Mat &frame1, bool *ok = 0) CV_OVERRIDE;
Mat estimate(const cuda::GpuMat &frame0, const cuda::GpuMat &frame1, bool *ok = 0);
private:
class CV_EXPORTS NullInpainter : public InpainterBase
{
public:
- virtual void inpaint(int /*idx*/, Mat &/*frame*/, Mat &/*mask*/) {}
+ virtual void inpaint(int /*idx*/, Mat &/*frame*/, Mat &/*mask*/) CV_OVERRIDE {}
};
class CV_EXPORTS InpaintingPipeline : public InpainterBase
void pushBack(Ptr<InpainterBase> inpainter) { inpainters_.push_back(inpainter); }
bool empty() const { return inpainters_.empty(); }
- virtual void setRadius(int val);
- virtual void setMotionModel(MotionModel val);
- virtual void setFrames(const std::vector<Mat> &val);
- virtual void setMotions(const std::vector<Mat> &val);
- virtual void setStabilizedFrames(const std::vector<Mat> &val);
- virtual void setStabilizationMotions(const std::vector<Mat> &val);
+ virtual void setRadius(int val) CV_OVERRIDE;
+ virtual void setMotionModel(MotionModel val) CV_OVERRIDE;
+ virtual void setFrames(const std::vector<Mat> &val) CV_OVERRIDE;
+ virtual void setMotions(const std::vector<Mat> &val) CV_OVERRIDE;
+ virtual void setStabilizedFrames(const std::vector<Mat> &val) CV_OVERRIDE;
+ virtual void setStabilizationMotions(const std::vector<Mat> &val) CV_OVERRIDE;
- virtual void inpaint(int idx, Mat &frame, Mat &mask);
+ virtual void inpaint(int idx, Mat &frame, Mat &mask) CV_OVERRIDE;
private:
std::vector<Ptr<InpainterBase> > inpainters_;
void setStdevThresh(float val) { stdevThresh_ = val; }
float stdevThresh() const { return stdevThresh_; }
- virtual void inpaint(int idx, Mat &frame, Mat &mask);
+ virtual void inpaint(int idx, Mat &frame, Mat &mask) CV_OVERRIDE;
private:
float stdevThresh_;
void setBorderMode(int val) { borderMode_ = val; }
int borderMode() const { return borderMode_; }
- virtual void inpaint(int idx, Mat &frame, Mat &mask);
+ virtual void inpaint(int idx, Mat &frame, Mat &mask) CV_OVERRIDE;
private:
FastMarchingMethod fmm_;
class CV_EXPORTS ColorAverageInpainter : public InpainterBase
{
public:
- virtual void inpaint(int idx, Mat &frame, Mat &mask);
+ virtual void inpaint(int idx, Mat &frame, Mat &mask) CV_OVERRIDE;
private:
FastMarchingMethod fmm_;
public:
ColorInpainter(int method = INPAINT_TELEA, double radius = 2.);
- virtual void inpaint(int idx, Mat &frame, Mat &mask);
+ virtual void inpaint(int idx, Mat &frame, Mat &mask) CV_OVERRIDE;
private:
int method_;
class CV_EXPORTS NullLog : public ILog
{
public:
- virtual void print(const char * /*format*/, ...) {}
+ virtual void print(const char * /*format*/, ...) CV_OVERRIDE {}
};
class CV_EXPORTS LogToStdout : public ILog
{
public:
- virtual void print(const char *format, ...);
+ virtual void print(const char *format, ...) CV_OVERRIDE;
};
//! @}
virtual void stabilize(
int size, const std::vector<Mat> &motions, std::pair<int,int> range,
- Mat *stabilizationMotions);
+ Mat *stabilizationMotions) CV_OVERRIDE;
private:
std::vector<Ptr<IMotionStabilizer> > stabilizers_;
virtual void stabilize(
int size, const std::vector<Mat> &motions, std::pair<int,int> range,
- Mat *stabilizationMotions);
+ Mat *stabilizationMotions) CV_OVERRIDE;
};
class CV_EXPORTS GaussianMotionFilter : public MotionFilterBase
float stdev() const { return stdev_; }
virtual Mat stabilize(
- int idx, const std::vector<Mat> &motions, std::pair<int,int> range);
+ int idx, const std::vector<Mat> &motions, std::pair<int,int> range) CV_OVERRIDE;
private:
int radius_;
virtual void stabilize(
int size, const std::vector<Mat> &motions, std::pair<int,int> range,
- Mat *stabilizationMotions);
+ Mat *stabilizationMotions) CV_OVERRIDE;
private:
MotionModel model_;
public:
virtual void run(
InputArray frame0, InputArray frame1, InputArray points0, InputOutputArray points1,
- OutputArray status, OutputArray errors);
+ OutputArray status, OutputArray errors) CV_OVERRIDE;
};
#ifdef HAVE_OPENCV_CUDAOPTFLOW
virtual void run(
InputArray frame0, InputArray frame1, InputArray points0, InputOutputArray points1,
- OutputArray status, OutputArray errors);
+ OutputArray status, OutputArray errors) CV_OVERRIDE;
void run(const cuda::GpuMat &frame0, const cuda::GpuMat &frame1, const cuda::GpuMat &points0, cuda::GpuMat &points1,
cuda::GpuMat &status, cuda::GpuMat &errors);
{
public:
virtual void process(
- Size frameSize, InputArray points0, InputArray points1, OutputArray mask);
+ Size frameSize, InputArray points0, InputArray points1, OutputArray mask) CV_OVERRIDE;
};
class CV_EXPORTS TranslationBasedLocalOutlierRejector : public IOutlierRejector
RansacParams ransacParams() const { return ransacParams_; }
virtual void process(
- Size frameSize, InputArray points0, InputArray points1, OutputArray mask);
+ Size frameSize, InputArray points0, InputArray points1, OutputArray mask) CV_OVERRIDE;
private:
Size cellSize_;
void setMotionFilter(Ptr<MotionFilterBase> val) { motionFilter_ = val; }
Ptr<MotionFilterBase> motionFilter() const { return motionFilter_; }
- virtual void reset();
- virtual Mat nextFrame() { return nextStabilizedFrame(); }
+ virtual void reset() CV_OVERRIDE;
+ virtual Mat nextFrame() CV_OVERRIDE { return nextStabilizedFrame(); }
protected:
- virtual void setUp(const Mat &firstFrame);
- virtual Mat estimateMotion();
- virtual Mat estimateStabilizationMotion();
- virtual Mat postProcessFrame(const Mat &frame);
+ virtual void setUp(const Mat &firstFrame) CV_OVERRIDE;
+ virtual Mat estimateMotion() CV_OVERRIDE;
+ virtual Mat estimateStabilizationMotion() CV_OVERRIDE;
+ virtual Mat postProcessFrame(const Mat &frame) CV_OVERRIDE;
Ptr<MotionFilterBase> motionFilter_;
};
void setEstimateTrimRatio(bool val) { mustEstTrimRatio_ = val; }
bool mustEstimateTrimaRatio() const { return mustEstTrimRatio_; }
- virtual void reset();
- virtual Mat nextFrame();
+ virtual void reset() CV_OVERRIDE;
+ virtual Mat nextFrame() CV_OVERRIDE;
protected:
void runPrePassIfNecessary();
- virtual void setUp(const Mat &firstFrame);
- virtual Mat estimateMotion();
- virtual Mat estimateStabilizationMotion();
- virtual Mat postProcessFrame(const Mat &frame);
+ virtual void setUp(const Mat &firstFrame) CV_OVERRIDE;
+ virtual Mat estimateMotion() CV_OVERRIDE;
+ virtual Mat estimateStabilizationMotion() CV_OVERRIDE;
+ virtual Mat postProcessFrame(const Mat &frame) CV_OVERRIDE;
Ptr<IMotionStabilizer> motionStabilizer_;
Ptr<WobbleSuppressorBase> wobbleSuppressor_;
class CV_EXPORTS NullWobbleSuppressor : public WobbleSuppressorBase
{
public:
- virtual void suppress(int idx, const Mat &frame, Mat &result);
+ virtual void suppress(int idx, const Mat &frame, Mat &result) CV_OVERRIDE;
};
class CV_EXPORTS MoreAccurateMotionWobbleSuppressorBase : public WobbleSuppressorBase
class CV_EXPORTS MoreAccurateMotionWobbleSuppressor : public MoreAccurateMotionWobbleSuppressorBase
{
public:
- virtual void suppress(int idx, const Mat &frame, Mat &result);
+ virtual void suppress(int idx, const Mat &frame, Mat &result) CV_OVERRIDE;
private:
Mat_<float> mapx_, mapy_;
VideoFileSourceImpl(const String &path, bool volatileFrame)
: path_(path), volatileFrame_(volatileFrame) { reset(); }
- virtual void reset()
+ virtual void reset() CV_OVERRIDE
{
#ifdef HAVE_OPENCV_VIDEOIO
vc.release();
#endif
}
- virtual Mat nextFrame()
+ virtual Mat nextFrame() CV_OVERRIDE
{
Mat frame;
#ifdef HAVE_OPENCV_VIDEOIO