float sharpness() const { return sharpness_; }
void setSharpness(float val) { sharpness_ = val; }
- void prepare(Rect dst_roi);
- void feed(InputArray img, InputArray mask, Point tl);
- void blend(InputOutputArray dst, InputOutputArray dst_mask);
+ void prepare(Rect dst_roi) CV_OVERRIDE;
+ void feed(InputArray img, InputArray mask, Point tl) CV_OVERRIDE;
+ void blend(InputOutputArray dst, InputOutputArray dst_mask) CV_OVERRIDE;
//! Creates weight maps for fixed set of source images by their masks and top-left corners.
//! Final image can be obtained by simple weighting of the source images.
int numBands() const { return actual_num_bands_; }
void setNumBands(int val) { actual_num_bands_ = val; }
- void prepare(Rect dst_roi);
- void feed(InputArray img, InputArray mask, Point tl);
- void blend(InputOutputArray dst, InputOutputArray dst_mask);
+ void prepare(Rect dst_roi) CV_OVERRIDE;
+ void feed(InputArray img, InputArray mask, Point tl) CV_OVERRIDE;
+ void blend(InputOutputArray dst, InputOutputArray dst_mask) CV_OVERRIDE;
private:
int actual_num_bands_, num_bands_;
{
public:
void feed(const std::vector<Point> &/*corners*/, const std::vector<UMat> &/*images*/,
- const std::vector<std::pair<UMat,uchar> > &/*masks*/) { }
- void apply(int /*index*/, Point /*corner*/, InputOutputArray /*image*/, InputArray /*mask*/) { }
+ const std::vector<std::pair<UMat,uchar> > &/*masks*/) CV_OVERRIDE { }
+ void apply(int /*index*/, Point /*corner*/, InputOutputArray /*image*/, InputArray /*mask*/) CV_OVERRIDE { }
};
/** @brief Exposure compensator which tries to remove exposure related artifacts by adjusting image
{
public:
void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
- const std::vector<std::pair<UMat,uchar> > &masks);
- void apply(int index, Point corner, InputOutputArray image, InputArray mask);
+ const std::vector<std::pair<UMat,uchar> > &masks) CV_OVERRIDE;
+ void apply(int index, Point corner, InputOutputArray image, InputArray mask) CV_OVERRIDE;
std::vector<double> gains() const;
private:
BlocksGainCompensator(int bl_width = 32, int bl_height = 32)
: bl_width_(bl_width), bl_height_(bl_height) {}
void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
- const std::vector<std::pair<UMat,uchar> > &masks);
- void apply(int index, Point corner, InputOutputArray image, InputArray mask);
+ const std::vector<std::pair<UMat,uchar> > &masks) CV_OVERRIDE;
+ void apply(int index, Point corner, InputOutputArray image, InputArray mask) CV_OVERRIDE;
private:
int bl_width_, bl_height_;
int num_octaves_descr = /*4*/3, int num_layers_descr = /*2*/4);
private:
- void find(InputArray image, ImageFeatures &features);
+ void find(InputArray image, ImageFeatures &features) CV_OVERRIDE;
Ptr<FeatureDetector> detector_;
Ptr<DescriptorExtractor> extractor_;
OrbFeaturesFinder(Size _grid_size = Size(3,1), int nfeatures=1500, float scaleFactor=1.3f, int nlevels=5);
private:
- void find(InputArray image, ImageFeatures &features);
+ void find(InputArray image, ImageFeatures &features) CV_OVERRIDE;
Ptr<ORB> orb;
Size grid_size;
int diffusivity = KAZE::DIFF_PM_G2);
private:
- void find(InputArray image, detail::ImageFeatures &features);
+ void find(InputArray image, ImageFeatures &features) CV_OVERRIDE;
Ptr<AKAZE> akaze;
};
SurfFeaturesFinderGpu(double hess_thresh = 300., int num_octaves = 3, int num_layers = 4,
int num_octaves_descr = 4, int num_layers_descr = 2);
- void collectGarbage();
+ void collectGarbage() CV_OVERRIDE;
private:
- void find(InputArray image, ImageFeatures &features);
+ void find(InputArray image, ImageFeatures &features) CV_OVERRIDE;
cuda::GpuMat image_;
cuda::GpuMat gray_image_;
BestOf2NearestMatcher(bool try_use_gpu = false, float match_conf = 0.3f, int num_matches_thresh1 = 6,
int num_matches_thresh2 = 6);
- void collectGarbage();
+ void collectGarbage() CV_OVERRIDE;
protected:
- void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info);
+ void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info) CV_OVERRIDE;
int num_matches_thresh1_;
int num_matches_thresh2_;
full_affine_(full_affine) {}
protected:
- void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info);
+ void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info) CV_OVERRIDE;
bool full_affine_;
};
private:
virtual bool estimate(const std::vector<ImageFeatures> &features,
const std::vector<MatchesInfo> &pairwise_matches,
- std::vector<CameraParams> &cameras);
+ std::vector<CameraParams> &cameras) CV_OVERRIDE;
bool is_focals_estimated_;
};
private:
virtual bool estimate(const std::vector<ImageFeatures> &features,
const std::vector<MatchesInfo> &pairwise_matches,
- std::vector<CameraParams> &cameras);
+ std::vector<CameraParams> &cameras) CV_OVERRIDE;
};
/** @brief Base class for all camera parameters refinement methods.
// Runs bundle adjustment
virtual bool estimate(const std::vector<ImageFeatures> &features,
const std::vector<MatchesInfo> &pairwise_matches,
- std::vector<CameraParams> &cameras);
+ std::vector<CameraParams> &cameras) CV_OVERRIDE;
/** @brief Sets initial camera parameter to refine.
private:
bool estimate(const std::vector<ImageFeatures> &, const std::vector<MatchesInfo> &,
- std::vector<CameraParams> &)
+ std::vector<CameraParams> &) CV_OVERRIDE
{
return true;
}
- void setUpInitialCameraParams(const std::vector<CameraParams> &) {}
- void obtainRefinedCameraParams(std::vector<CameraParams> &) const {}
- void calcError(Mat &) {}
- void calcJacobian(Mat &) {}
+ void setUpInitialCameraParams(const std::vector<CameraParams> &) CV_OVERRIDE {}
+ void obtainRefinedCameraParams(std::vector<CameraParams> &) const CV_OVERRIDE {}
+ void calcError(Mat &) CV_OVERRIDE {}
+ void calcJacobian(Mat &) CV_OVERRIDE {}
};
BundleAdjusterReproj() : BundleAdjusterBase(7, 2) {}
private:
- void setUpInitialCameraParams(const std::vector<CameraParams> &cameras);
- void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const;
- void calcError(Mat &err);
- void calcJacobian(Mat &jac);
+ void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+ void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+ void calcError(Mat &err) CV_OVERRIDE;
+ void calcJacobian(Mat &jac) CV_OVERRIDE;
Mat err1_, err2_;
};
BundleAdjusterRay() : BundleAdjusterBase(4, 3) {}
private:
- void setUpInitialCameraParams(const std::vector<CameraParams> &cameras);
- void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const;
- void calcError(Mat &err);
- void calcJacobian(Mat &jac);
+ void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+ void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+ void calcError(Mat &err) CV_OVERRIDE;
+ void calcJacobian(Mat &jac) CV_OVERRIDE;
Mat err1_, err2_;
};
BundleAdjusterAffine() : BundleAdjusterBase(6, 2) {}
private:
- void setUpInitialCameraParams(const std::vector<CameraParams> &cameras);
- void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const;
- void calcError(Mat &err);
- void calcJacobian(Mat &jac);
+ void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+ void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+ void calcError(Mat &err) CV_OVERRIDE;
+ void calcJacobian(Mat &jac) CV_OVERRIDE;
Mat err1_, err2_;
};
BundleAdjusterAffinePartial() : BundleAdjusterBase(4, 2) {}
private:
- void setUpInitialCameraParams(const std::vector<CameraParams> &cameras);
- void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const;
- void calcError(Mat &err);
- void calcJacobian(Mat &jac);
+ void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+ void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+ void calcError(Mat &err) CV_OVERRIDE;
+ void calcJacobian(Mat &jac) CV_OVERRIDE;
Mat err1_, err2_;
};
class CV_EXPORTS NoSeamFinder : public SeamFinder
{
public:
- void find(const std::vector<UMat>&, const std::vector<Point>&, std::vector<UMat>&) {}
+ void find(const std::vector<UMat>&, const std::vector<Point>&, std::vector<UMat>&) CV_OVERRIDE {}
};
/** @brief Base class for all pairwise seam estimators.
{
public:
virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
- std::vector<UMat> &masks);
+ std::vector<UMat> &masks) CV_OVERRIDE;
protected:
void run();
{
public:
virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
- std::vector<UMat> &masks);
+ std::vector<UMat> &masks) CV_OVERRIDE;
virtual void find(const std::vector<Size> &size, const std::vector<Point> &corners,
std::vector<UMat> &masks);
private:
- void findInPair(size_t first, size_t second, Rect roi);
+ void findInPair(size_t first, size_t second, Rect roi) CV_OVERRIDE;
};
void setCostFunction(CostFunction val) { costFunc_ = val; }
virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
- std::vector<UMat> &masks);
+ std::vector<UMat> &masks) CV_OVERRIDE;
private:
enum ComponentState
~GraphCutSeamFinder();
void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
- std::vector<UMat> &masks);
+ std::vector<UMat> &masks) CV_OVERRIDE;
private:
// To avoid GCGraph dependency
bad_region_penalty_(bad_region_penalty) {}
void find(const std::vector<cv::UMat> &src, const std::vector<cv::Point> &corners,
- std::vector<cv::UMat> &masks);
+ std::vector<cv::UMat> &masks) CV_OVERRIDE;
void findInPair(size_t first, size_t second, Rect roi);
private:
class CV_EXPORTS TimelapserCrop : public Timelapser
{
public:
- virtual void initialize(const std::vector<Point> &corners, const std::vector<Size> &sizes);
+ virtual void initialize(const std::vector<Point> &corners, const std::vector<Size> &sizes) CV_OVERRIDE;
};
//! @}
class CV_EXPORTS_TEMPLATE RotationWarperBase : public RotationWarper
{
public:
- Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R);
+ Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R) CV_OVERRIDE;
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap);
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
- OutputArray dst);
+ OutputArray dst) CV_OVERRIDE;
void warpBackward(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
- Size dst_size, OutputArray dst);
+ Size dst_size, OutputArray dst) CV_OVERRIDE;
- Rect warpRoi(Size src_size, InputArray K, InputArray R);
+ Rect warpRoi(Size src_size, InputArray K, InputArray R) CV_OVERRIDE;
- float getScale() const { return projector_.scale; }
- void setScale(float val) { projector_.scale = val; }
+ float getScale() const CV_OVERRIDE{ return projector_.scale; }
+ void setScale(float val) CV_OVERRIDE { projector_.scale = val; }
protected:
*/
PlaneWarper(float scale = 1.f) { projector_.scale = scale; }
- Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R);
+ Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R) CV_OVERRIDE;
Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R, InputArray T);
virtual Rect buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, OutputArray xmap, OutputArray ymap);
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap);
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
Point warp(InputArray src, InputArray K, InputArray R,
- int interp_mode, int border_mode, OutputArray dst);
+ int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
virtual Point warp(InputArray src, InputArray K, InputArray R, InputArray T, int interp_mode, int border_mode,
OutputArray dst);
- Rect warpRoi(Size src_size, InputArray K, InputArray R);
+ Rect warpRoi(Size src_size, InputArray K, InputArray R) CV_OVERRIDE;
Rect warpRoi(Size src_size, InputArray K, InputArray R, InputArray T);
protected:
- void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
+ void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE;
};
*/
AffineWarper(float scale = 1.f) : PlaneWarper(scale) {}
- Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R);
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap);
+ Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R) CV_OVERRIDE;
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
Point warp(InputArray src, InputArray K, InputArray R,
- int interp_mode, int border_mode, OutputArray dst);
- Rect warpRoi(Size src_size, InputArray K, InputArray R);
+ int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
+ Rect warpRoi(Size src_size, InputArray K, InputArray R) CV_OVERRIDE;
protected:
/** @brief Extracts rotation and translation matrices from matrix H representing
*/
SphericalWarper(float scale) { projector_.scale = scale; }
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap);
- Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst);
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
+ Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
protected:
- void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
+ void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE;
};
*/
CylindricalWarper(float scale) { projector_.scale = scale; }
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap);
- Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst);
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
+ Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
protected:
- void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+ void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE
{
RotationWarperBase<CylindricalProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
}
public:
PlaneWarperGpu(float scale = 1.f) : PlaneWarper(scale) {}
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
{
Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
d_xmap_.download(xmap);
return result;
}
- Rect buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, OutputArray xmap, OutputArray ymap)
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
{
Rect result = buildMaps(src_size, K, R, T, d_xmap_, d_ymap_);
d_xmap_.download(xmap);
}
Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
- OutputArray dst)
+ OutputArray dst) CV_OVERRIDE
{
d_src_.upload(src);
Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
}
Point warp(InputArray src, InputArray K, InputArray R, InputArray T, int interp_mode, int border_mode,
- OutputArray dst)
+ OutputArray dst) CV_OVERRIDE
{
d_src_.upload(src);
Point result = warp(d_src_, K, R, T, interp_mode, border_mode, d_dst_);
public:
SphericalWarperGpu(float scale) : SphericalWarper(scale) {}
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
{
Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
d_xmap_.download(xmap);
}
Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
- OutputArray dst)
+ OutputArray dst) CV_OVERRIDE
{
d_src_.upload(src);
Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
public:
CylindricalWarperGpu(float scale) : CylindricalWarper(scale) {}
- Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+ Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
{
Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
d_xmap_.download(xmap);
}
Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
- OutputArray dst)
+ OutputArray dst) CV_OVERRIDE
{
d_src_.upload(src);
Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
SphericalPortraitWarper(float scale) { projector_.scale = scale; }
protected:
- void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
+ void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE;
};
struct CV_EXPORTS CylindricalPortraitProjector : ProjectorBase
CylindricalPortraitWarper(float scale) { projector_.scale = scale; }
protected:
- void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+ void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE
{
RotationWarperBase<CylindricalPortraitProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
}
PlanePortraitWarper(float scale) { projector_.scale = scale; }
protected:
- void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+ void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE
{
RotationWarperBase<PlanePortraitProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
}
class PlaneWarper : public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::PlaneWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PlaneWarper>(scale); }
};
/** @brief Affine warper factory class.
class AffineWarper : public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::AffineWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::AffineWarper>(scale); }
};
/** @brief Cylindrical warper factory class.
class CylindricalWarper: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::CylindricalWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CylindricalWarper>(scale); }
};
/** @brief Spherical warper factory class */
class SphericalWarper: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::SphericalWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::SphericalWarper>(scale); }
};
class FisheyeWarper : public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::FisheyeWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::FisheyeWarper>(scale); }
};
class StereographicWarper: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::StereographicWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::StereographicWarper>(scale); }
};
class CompressedRectilinearWarper: public WarperCreator
{
a = A; b = B;
}
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::CompressedRectilinearWarper>(scale, a, b); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CompressedRectilinearWarper>(scale, a, b); }
};
class CompressedRectilinearPortraitWarper: public WarperCreator
{
a = A; b = B;
}
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::CompressedRectilinearPortraitWarper>(scale, a, b); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CompressedRectilinearPortraitWarper>(scale, a, b); }
};
class PaniniWarper: public WarperCreator
{
a = A; b = B;
}
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::PaniniWarper>(scale, a, b); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PaniniWarper>(scale, a, b); }
};
class PaniniPortraitWarper: public WarperCreator
{
a = A; b = B;
}
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::PaniniPortraitWarper>(scale, a, b); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PaniniPortraitWarper>(scale, a, b); }
};
class MercatorWarper: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::MercatorWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::MercatorWarper>(scale); }
};
class TransverseMercatorWarper: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::TransverseMercatorWarper>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::TransverseMercatorWarper>(scale); }
};
class PlaneWarperGpu: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::PlaneWarperGpu>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PlaneWarperGpu>(scale); }
};
class CylindricalWarperGpu: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::CylindricalWarperGpu>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CylindricalWarperGpu>(scale); }
};
class SphericalWarperGpu: public WarperCreator
{
public:
- Ptr<detail::RotationWarper> create(float scale) const { return makePtr<detail::SphericalWarperGpu>(scale); }
+ Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::SphericalWarperGpu>(scale); }
};
#endif
: matcher(_matcher), features(_features),
pairwise_matches(_pairwise_matches), near_pairs(_near_pairs) {}
- void operator ()(const Range &r) const
+ void operator ()(const Range &r) const CV_OVERRIDE
{
cv::RNG rng = cv::theRNG(); // save entry rng state
const int num_images = static_cast<int>(features.size());
std::vector<ImageFeatures> &features, const std::vector<std::vector<cv::Rect> > *rois)
: finder_(finder), images_(images), features_(features), rois_(rois) {}
- void operator ()(const Range &r) const
+ void operator ()(const Range &r) const CV_OVERRIDE
{
for (int i = r.start; i < r.end; ++i)
{
// These two classes are aimed to find features matches only, not to
// estimate homography
-class CpuMatcher : public FeaturesMatcher
+class CpuMatcher CV_FINAL : public FeaturesMatcher
{
public:
CpuMatcher(float match_conf) : FeaturesMatcher(true), match_conf_(match_conf) {}
- void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info);
+ void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info) CV_OVERRIDE;
private:
float match_conf_;
};
#ifdef HAVE_OPENCV_CUDAFEATURES2D
-class GpuMatcher : public FeaturesMatcher
+class GpuMatcher CV_FINAL : public FeaturesMatcher
{
public:
GpuMatcher(float match_conf) : match_conf_(match_conf) {}
}
-class GraphCutSeamFinder::Impl : public PairwiseSeamFinder
+class GraphCutSeamFinder::Impl CV_FINAL : public PairwiseSeamFinder
{
public:
Impl(int cost_type, float terminal_cost, float bad_region_penalty)
~Impl() {}
- void find(const std::vector<UMat> &src, const std::vector<Point> &corners, std::vector<UMat> &masks);
- void findInPair(size_t first, size_t second, Rect roi);
+ void find(const std::vector<UMat> &src, const std::vector<Point> &corners, std::vector<UMat> &masks) CV_OVERRIDE;
+ void findInPair(size_t first, size_t second, Rect roi) CV_OVERRIDE;
private:
void setGraphWeightsColor(const Mat &img1, const Mat &img2,