Merge pull request #1588 from alalek:cv_override_final

7 years ago · 5d9fc41b9e
parent 8e308ab6e3 036e699553
commit 5d9fc41b9e
218 changed files with 1457 additions and 1416 deletions
--- a/modules/aruco/src/aruco.cpp
+++ b/modules/aruco/src/aruco.cpp
@ -293,7 +293,7 @@ class DetectInitialCandidatesParallel : public ParallelLoopBody {
        : grey(_grey), candidatesArrays(_candidatesArrays), contoursArrays(_contoursArrays),
          params(_params) {}

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        const int begin = range.start;
        const int end = range.end;

@ -547,7 +547,7 @@ class IdentifyCandidatesParallel : public ParallelLoopBody {
        : grey(_grey), candidates(_candidates), dictionary(_dictionary),
          idsTmp(_idsTmp), validCandidates(_validCandidates), params(_params) {}

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        const int begin = range.start;
        const int end = range.end;

@ -773,7 +773,7 @@ class MarkerSubpixelParallel : public ParallelLoopBody {
                           const Ptr<DetectorParameters> &_params)
        : grey(_grey), corners(_corners), params(_params) {}

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        const int begin = range.start;
        const int end = range.end;

@ -946,7 +946,7 @@ class MarkerContourParallel : public ParallelLoopBody {
    MarkerContourParallel( vector< vector< Point > >& _contours, vector< vector< Point2f > >& _candidates,  const Mat& _camMatrix, const Mat& _distCoeff)
        : contours(_contours), candidates(_candidates), camMatrix(_camMatrix), distCoeff(_distCoeff){}

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {

        for(int i = range.start; i < range.end; i++) {
            _refineCandidateLines(contours[i], candidates[i], camMatrix, distCoeff);
@ -1179,7 +1179,7 @@ class SinglePoseEstimationParallel : public ParallelLoopBody {
        : markerObjPoints(_markerObjPoints), corners(_corners), cameraMatrix(_cameraMatrix),
          distCoeffs(_distCoeffs), rvecs(_rvecs), tvecs(_tvecs) {}

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        const int begin = range.start;
        const int end = range.end;

--- a/modules/aruco/src/charuco.cpp
+++ b/modules/aruco/src/charuco.cpp
@ -282,7 +282,7 @@ class CharucoSubpixelParallel : public ParallelLoopBody {
        : grey(_grey), filteredChessboardImgPoints(_filteredChessboardImgPoints),
          filteredWinSizes(_filteredWinSizes), params(_params) {}

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        const int begin = range.start;
        const int end = range.end;

--- a/modules/bgsegm/include/opencv2/bgsegm.hpp
+++ b/modules/bgsegm/include/opencv2/bgsegm.hpp
@ -196,8 +196,8 @@ class CV_EXPORTS_W BackgroundSubtractorCNT  : public BackgroundSubtractor
 {
 public:
    // BackgroundSubtractor interface
-    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) = 0;
-    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const = 0;
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0;
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0;

    /** @brief Returns number of frames with same pixel color to consider stable.
    */
@ -255,9 +255,9 @@ class CV_EXPORTS_W BackgroundSubtractorGSOC : public BackgroundSubtractor
 {
 public:
    // BackgroundSubtractor interface
-    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) = 0;
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0;

-    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const = 0;
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0;
 };

 /** @brief Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at @cite LGuo2016
@ -266,9 +266,9 @@ class CV_EXPORTS_W BackgroundSubtractorLSBP : public BackgroundSubtractor
 {
 public:
    // BackgroundSubtractor interface
-    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) = 0;
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0;

-    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const = 0;
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE = 0;
 };

 /** @brief This is for calculation of the LSBP descriptors.
--- a/modules/bgsegm/src/bgfg_gaussmix.cpp
+++ b/modules/bgsegm/src/bgfg_gaussmix.cpp
@ -69,7 +69,7 @@ static const double defaultVarThreshold = 2.5*2.5;
 static const double defaultNoiseSigma = 30*0.5;
 static const double defaultInitialWeight = 0.05;

-class BackgroundSubtractorMOGImpl : public BackgroundSubtractorMOG
+class BackgroundSubtractorMOGImpl CV_FINAL : public BackgroundSubtractorMOG
 {
 public:
    //! the default constructor
@ -102,7 +102,7 @@ public:
    }

    //! the update operator
-    virtual void apply(InputArray image, OutputArray fgmask, double learningRate=0);
+    virtual void apply(InputArray image, OutputArray fgmask, double learningRate=0) CV_OVERRIDE;

    //! re-initiaization method
    virtual void initialize(Size _frameSize, int _frameType)
@ -122,24 +122,24 @@ public:
        bgmodel = Scalar::all(0);
    }

-    virtual void getBackgroundImage(OutputArray) const
+    virtual void getBackgroundImage(OutputArray) const CV_OVERRIDE
    {
        CV_Error( Error::StsNotImplemented, "" );
    }

-    virtual int getHistory() const { return history; }
-    virtual void setHistory(int _nframes) { history = _nframes; }
+    virtual int getHistory() const CV_OVERRIDE { return history; }
+    virtual void setHistory(int _nframes) CV_OVERRIDE { history = _nframes; }

-    virtual int getNMixtures() const { return nmixtures; }
-    virtual void setNMixtures(int nmix) { nmixtures = nmix; }
+    virtual int getNMixtures() const CV_OVERRIDE { return nmixtures; }
+    virtual void setNMixtures(int nmix) CV_OVERRIDE { nmixtures = nmix; }

-    virtual double getBackgroundRatio() const { return backgroundRatio; }
-    virtual void setBackgroundRatio(double _backgroundRatio) { backgroundRatio = _backgroundRatio; }
+    virtual double getBackgroundRatio() const CV_OVERRIDE { return backgroundRatio; }
+    virtual void setBackgroundRatio(double _backgroundRatio) CV_OVERRIDE { backgroundRatio = _backgroundRatio; }

-    virtual double getNoiseSigma() const { return noiseSigma; }
-    virtual void setNoiseSigma(double _noiseSigma) { noiseSigma = _noiseSigma; }
+    virtual double getNoiseSigma() const CV_OVERRIDE { return noiseSigma; }
+    virtual void setNoiseSigma(double _noiseSigma) CV_OVERRIDE { noiseSigma = _noiseSigma; }

-    virtual void write(FileStorage& fs) const
+    virtual void write(FileStorage& fs) const CV_OVERRIDE
    {
        fs << "name" << name_
           << "history" << history
@ -148,7 +148,7 @@ public:
           << "noiseSigma" << noiseSigma;
    }

-    virtual void read(const FileNode& fn)
+    virtual void read(const FileNode& fn) CV_OVERRIDE
    {
        CV_Assert( (String)fn["name"] == name_ );
        history = (int)fn["history"];
--- a/modules/bgsegm/src/bgfg_gmg.cpp
+++ b/modules/bgsegm/src/bgfg_gmg.cpp
@ -57,7 +57,7 @@ namespace cv
 namespace bgsegm
 {

-class BackgroundSubtractorGMGImpl : public BackgroundSubtractorGMG
+class BackgroundSubtractorGMGImpl CV_FINAL : public BackgroundSubtractorGMG
 {
 public:
    BackgroundSubtractorGMGImpl()
@ -96,49 +96,49 @@ public:
     * @param image Input image
     * @param fgmask Output mask image representing foreground and background pixels
     */
-    virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1.0);
+    virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1.0) CV_OVERRIDE;

    /**
     * Releases all inner buffers.
     */
    void release();

-    virtual int getMaxFeatures() const { return maxFeatures; }
-    virtual void setMaxFeatures(int _maxFeatures) { maxFeatures = _maxFeatures; }
+    virtual int getMaxFeatures() const CV_OVERRIDE { return maxFeatures; }
+    virtual void setMaxFeatures(int _maxFeatures) CV_OVERRIDE { maxFeatures = _maxFeatures; }

-    virtual double getDefaultLearningRate() const { return learningRate; }
-    virtual void setDefaultLearningRate(double lr) { learningRate = lr; }
+    virtual double getDefaultLearningRate() const CV_OVERRIDE { return learningRate; }
+    virtual void setDefaultLearningRate(double lr) CV_OVERRIDE { learningRate = lr; }

-    virtual int getNumFrames() const { return numInitializationFrames; }
-    virtual void setNumFrames(int nframes) { numInitializationFrames = nframes; }
+    virtual int getNumFrames() const CV_OVERRIDE { return numInitializationFrames; }
+    virtual void setNumFrames(int nframes) CV_OVERRIDE { numInitializationFrames = nframes; }

-    virtual int getQuantizationLevels() const { return quantizationLevels; }
-    virtual void setQuantizationLevels(int nlevels) { quantizationLevels = nlevels; }
+    virtual int getQuantizationLevels() const CV_OVERRIDE { return quantizationLevels; }
+    virtual void setQuantizationLevels(int nlevels) CV_OVERRIDE { quantizationLevels = nlevels; }

-    virtual double getBackgroundPrior() const { return backgroundPrior; }
-    virtual void setBackgroundPrior(double bgprior) { backgroundPrior = bgprior; }
+    virtual double getBackgroundPrior() const CV_OVERRIDE { return backgroundPrior; }
+    virtual void setBackgroundPrior(double bgprior) CV_OVERRIDE { backgroundPrior = bgprior; }

-    virtual int getSmoothingRadius() const { return smoothingRadius; }
-    virtual void setSmoothingRadius(int radius) { smoothingRadius = radius; }
+    virtual int getSmoothingRadius() const CV_OVERRIDE { return smoothingRadius; }
+    virtual void setSmoothingRadius(int radius) CV_OVERRIDE { smoothingRadius = radius; }

-    virtual double getDecisionThreshold() const { return decisionThreshold; }
-    virtual void setDecisionThreshold(double thresh) { decisionThreshold = thresh; }
+    virtual double getDecisionThreshold() const CV_OVERRIDE { return decisionThreshold; }
+    virtual void setDecisionThreshold(double thresh) CV_OVERRIDE { decisionThreshold = thresh; }

-    virtual bool getUpdateBackgroundModel() const { return updateBackgroundModel; }
-    virtual void setUpdateBackgroundModel(bool update) { updateBackgroundModel = update; }
+    virtual bool getUpdateBackgroundModel() const CV_OVERRIDE { return updateBackgroundModel; }
+    virtual void setUpdateBackgroundModel(bool update) CV_OVERRIDE { updateBackgroundModel = update; }

-    virtual double getMinVal() const { return minVal_; }
-    virtual void setMinVal(double val) { minVal_ = val; }
+    virtual double getMinVal() const CV_OVERRIDE { return minVal_; }
+    virtual void setMinVal(double val) CV_OVERRIDE { minVal_ = val; }

-    virtual double getMaxVal() const  { return maxVal_; }
-    virtual void setMaxVal(double val)  { maxVal_ = val; }
+    virtual double getMaxVal() const CV_OVERRIDE { return maxVal_; }
+    virtual void setMaxVal(double val) CV_OVERRIDE { maxVal_ = val; }

-    virtual void getBackgroundImage(OutputArray backgroundImage) const
+    virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE
    {
        backgroundImage.release();
    }

-    virtual void write(FileStorage& fs) const
+    virtual void write(FileStorage& fs) const CV_OVERRIDE
    {
        fs << "name" << name_
        << "maxFeatures" << maxFeatures
@ -152,7 +152,7 @@ public:
        // we do not save minVal_ & maxVal_, since they depend on the image type.
    }

-    virtual void read(const FileNode& fn)
+    virtual void read(const FileNode& fn) CV_OVERRIDE
    {
        CV_Assert( (String)fn["name"] == name_ );
        maxFeatures = (int)fn["maxFeatures"];
@ -323,7 +323,7 @@ public:
    {
    }

-    void operator() (const Range& range) const;
+    void operator() (const Range& range) const CV_OVERRIDE;

 private:
    Mat frame_;
--- a/modules/bgsegm/src/bgfg_gsoc.cpp
+++ b/modules/bgsegm/src/bgfg_gsoc.cpp
@ -364,7 +364,7 @@ private:
 public:
    ParallelLocalSVDValues(const Size& _sz, Mat& _localSVDValues, const Mat& _frameGray) : sz(_sz), localSVDValues(_localSVDValues), frameGray(_frameGray) {};

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        for (int i = range.start; i < range.end; ++i)
            for (int j = 1; j < sz.width - 1; ++j) {
                localSVDValues.at<float>(i, j) = localSVD(
@ -387,7 +387,7 @@ private:
 public:
    ParallelFromLocalSVDValues(const Size& _sz, Mat& _desc, const Mat& _localSVDValues, const Point2i* _LSBPSamplePoints) : sz(_sz), desc(_desc), localSVDValues(_localSVDValues), LSBPSamplePoints(_LSBPSamplePoints) {};

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        for (int index = range.start; index < range.end; ++index) {
            const int i = index / sz.width, j = index % sz.width;
            int& descVal = desc.at<int>(i, j);
@ -455,7 +455,7 @@ void BackgroundSubtractorLSBPDesc::compute(OutputArray desc, const Mat& frame, c
    computeFromLocalSVDValues(desc, localSVDValues, LSBPSamplePoints);
 }

-class BackgroundSubtractorGSOCImpl : public BackgroundSubtractorGSOC {
+class BackgroundSubtractorGSOCImpl CV_FINAL : public BackgroundSubtractorGSOC {
 private:
    Ptr<BackgroundModelGSOC> backgroundModel;
    Ptr<BackgroundModelGSOC> backgroundModelPrev;
@ -492,14 +492,14 @@ public:
                                 float noiseRemovalThresholdFacBG,
                                 float noiseRemovalThresholdFacFG);

-    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate = -1);
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate = -1) CV_OVERRIDE;

-    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const;
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE;

    friend class ParallelGSOC;
 };

-class BackgroundSubtractorLSBPImpl : public BackgroundSubtractorLSBP {
+class BackgroundSubtractorLSBPImpl CV_FINAL : public BackgroundSubtractorLSBP {
 private:
    Ptr<BackgroundModelLSBP> backgroundModel;
    Ptr<BackgroundModelLSBP> backgroundModelPrev;
@ -540,9 +540,9 @@ public:
                                 int minCount
                                );

-    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate = -1);
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate = -1) CV_OVERRIDE;

-    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const;
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE;

    friend class ParallelLSBP;
 };
@ -561,7 +561,7 @@ public:
    ParallelGSOC(const Size& _sz, BackgroundSubtractorGSOCImpl* _bgs, const Mat& _frame, double _learningRate, Mat& _fgMask)
    : sz(_sz), bgs(_bgs), frame(_frame), learningRate(_learningRate), fgMask(_fgMask) {};

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        BackgroundModelGSOC* backgroundModel = bgs->backgroundModel.get();
        Mat& distMovingAvg = bgs->distMovingAvg;

@ -621,7 +621,7 @@ public:
    ParallelLSBP(const Size& _sz, BackgroundSubtractorLSBPImpl* _bgs, const Mat& _frame, double _learningRate, const Mat& _LSBPDesc, Mat& _fgMask)
    : sz(_sz), bgs(_bgs), frame(_frame), learningRate(_learningRate), LSBPDesc(_LSBPDesc), fgMask(_fgMask) {};

-    void operator()(const Range &range) const {
+    void operator()(const Range &range) const CV_OVERRIDE {
        BackgroundModelLSBP* backgroundModel = bgs->backgroundModel.get();
        Mat& T = bgs->T;
        Mat& R = bgs->R;
--- a/modules/bgsegm/src/bgfg_subcnt.cpp
+++ b/modules/bgsegm/src/bgfg_subcnt.cpp
@ -50,7 +50,7 @@ namespace cv
 namespace bgsegm
 {

-class BackgroundSubtractorCNTImpl: public BackgroundSubtractorCNT
+class BackgroundSubtractorCNTImpl CV_FINAL : public BackgroundSubtractorCNT
 {
 public:

@ -60,20 +60,20 @@ public:
                                bool isParallel);

    // BackgroundSubtractor interface
-    virtual void apply(InputArray image, OutputArray fgmask, double learningRate);
-    virtual void getBackgroundImage(OutputArray backgroundImage) const;
+    virtual void apply(InputArray image, OutputArray fgmask, double learningRate) CV_OVERRIDE;
+    virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE;

-    int getMinPixelStability() const;
-    void setMinPixelStability(int value);
+    int getMinPixelStability() const CV_OVERRIDE;
+    void setMinPixelStability(int value) CV_OVERRIDE;

-    int getMaxPixelStability() const;
-    void setMaxPixelStability(int value);
+    int getMaxPixelStability() const CV_OVERRIDE;
+    void setMaxPixelStability(int value) CV_OVERRIDE;

-    bool getUseHistory() const;
-    void setUseHistory(bool value);
+    bool getUseHistory() const CV_OVERRIDE;
+    void setUseHistory(bool value) CV_OVERRIDE;

-    bool getIsParallel() const;
-    void setIsParallel(bool value);
+    bool getIsParallel() const CV_OVERRIDE;
+    void setIsParallel(bool value) CV_OVERRIDE;

    //! the destructor
    virtual ~BackgroundSubtractorCNTImpl() {}
@ -185,7 +185,7 @@ struct BGSubtractPixel : public CNTFunctor
    //! the destructor
    virtual ~BGSubtractPixel() {}

-    void operator()(Vec4i &vec, uchar currColor, uchar prevColor, uchar &fgMaskPixelRef)
+    void operator()(Vec4i &vec, uchar currColor, uchar prevColor, uchar &fgMaskPixelRef) CV_OVERRIDE
    {
        int &stabilityRef = vec[0];
        int &bgImgRef = vec[3];
@ -248,7 +248,7 @@ struct BGSubtractPixelWithHistory : public CNTFunctor
        }
    }

-    void operator()(Vec4i &vec, uchar currColor, uchar prevColor, uchar &fgMaskPixelRef)
+    void operator()(Vec4i &vec, uchar currColor, uchar prevColor, uchar &fgMaskPixelRef) CV_OVERRIDE
    {
        int &stabilityRef = vec[0];
        int &historyColorRef = vec[1];
@ -316,7 +316,7 @@ public:
    }

    // Iterate rows
-    void operator()(const Range& range) const
+    void operator()(const Range& range) const CV_OVERRIDE
    {
        for (int r = range.start; r < range.end; ++r)
        {
--- a/modules/bioinspired/include/opencv2/bioinspired/retina.hpp
+++ b/modules/bioinspired/include/opencv2/bioinspired/retina.hpp
@ -146,7 +146,7 @@ enum {
    </opencv_storage>
    @endcode
      */
-    struct RetinaParameters{ 
+    struct RetinaParameters{
        //! Outer Plexiform Layer (OPL) and Inner Plexiform Layer Parvocellular (IplParvo) parameters
        struct OPLandIplParvoParameters{
               OPLandIplParvoParameters():colorMode(true),
@ -208,7 +208,7 @@ class CV_EXPORTS_W Retina : public Algorithm {

 public:

-    
+
    /** @brief Retreive retina input buffer size
    @return the retina input buffer size
     */
@ -260,7 +260,7 @@ public:
    CV_WRAP virtual void write( String fs ) const=0;

    /** @overload */
-    virtual void write( FileStorage& fs ) const=0;
+    virtual void write( FileStorage& fs ) const CV_OVERRIDE = 0;

    /** @brief Setup the OPL and IPL parvo channels (see biologocal model)

--- a/modules/bioinspired/include/opencv2/bioinspired/transientareassegmentationmodule.hpp
+++ b/modules/bioinspired/include/opencv2/bioinspired/transientareassegmentationmodule.hpp
@ -80,7 +80,7 @@ namespace bioinspired
 /** @brief parameter structure that stores the transient events detector setup parameters
 */
 struct SegmentationParameters{ // CV_EXPORTS_W_MAP to export to python native dictionnaries
-	// default structure instance construction with default values	
+	// default structure instance construction with default values
 	SegmentationParameters():
 	    thresholdON(100),
 	    thresholdOFF(100),
@ -171,7 +171,7 @@ public:
    /** @brief write xml/yml formated parameters information
    @param fs : a cv::Filestorage object ready to be filled
    */
-    virtual void write( cv::FileStorage& fs ) const=0;
+    virtual void write( cv::FileStorage& fs ) const CV_OVERRIDE = 0;

    /** @brief main processing method, get result using methods getSegmentationPicture()
    @param inputToSegment : the image to process, it must match the instance buffer size !
--- a/modules/bioinspired/src/basicretinafilter.hpp
+++ b/modules/bioinspired/src/basicretinafilter.hpp
@ -487,7 +487,7 @@ namespace bioinspired
 #endif
            }

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {

 #ifdef DEBUG_TBB
                std::cout<<"Parallel_horizontalAnticausalFilter::operator() :"
@ -520,7 +520,7 @@ namespace bioinspired
            Parallel_horizontalCausalFilter_addInput(const float *bufferToAddAsInputProcess, float *bufferToProcess, const unsigned int idStart, const unsigned int nbCols,  const float a,  const float tau)
                :inputFrame(bufferToAddAsInputProcess), outputFrame(bufferToProcess), IDrowStart(idStart), nbColumns(nbCols), filterParam_a(a), filterParam_tau(tau){}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                for (int IDrow=r.start; IDrow!=r.end; ++IDrow)
                {
                    float* outputPTR=outputFrame+(IDrowStart+IDrow)*nbColumns;
@ -545,7 +545,7 @@ namespace bioinspired
            Parallel_verticalCausalFilter(float *bufferToProcess, const unsigned int nbRws, const unsigned int nbCols, const float a )
                :outputFrame(bufferToProcess), nbRows(nbRws), nbColumns(nbCols), filterParam_a(a){}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
                {
                    float result=0;
@ -572,7 +572,7 @@ namespace bioinspired
            Parallel_verticalAnticausalFilter_multGain(float *bufferToProcess, const unsigned int nbRws, const unsigned int nbCols, const float a, const float  gain)
                :outputFrame(bufferToProcess), nbRows(nbRws), nbColumns(nbCols), filterParam_a(a), filterParam_gain(gain){}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                float* offset=outputFrame+nbColumns*nbRows-nbColumns;
                for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
                {
@ -600,7 +600,7 @@ namespace bioinspired
            Parallel_localAdaptation(const float *localLum, const float *inputImg, float *bufferToProcess, const float localLuminanceFact, const float localLuminanceAdd, const float maxInputVal)
                :localLuminance(localLum), inputFrame(inputImg),outputFrame(bufferToProcess), localLuminanceFactor(localLuminanceFact), localLuminanceAddon(localLuminanceAdd), maxInputValue(maxInputVal) {}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                const float *localLuminancePTR=localLuminance+r.start;
                const float *inputFramePTR=inputFrame+r.start;
                float *outputFramePTR=outputFrame+r.start;
@ -626,7 +626,7 @@ namespace bioinspired
            Parallel_horizontalAnticausalFilter_Irregular(float *bufferToProcess, const float *spatialConst, const unsigned int idEnd, const unsigned int nbCols)
                :outputFrame(bufferToProcess), spatialConstantBuffer(spatialConst), IDrowEnd(idEnd), nbColumns(nbCols){}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {

                for (int IDrow=r.start; IDrow!=r.end; ++IDrow)
                {
@ -652,7 +652,7 @@ namespace bioinspired
            Parallel_verticalCausalFilter_Irregular(float *bufferToProcess, const float *spatialConst, const unsigned int nbRws, const unsigned int nbCols)
                :outputFrame(bufferToProcess), spatialConstantBuffer(spatialConst), nbRows(nbRws), nbColumns(nbCols){}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
                {
                    float result=0;
--- a/modules/bioinspired/src/magnoretinafilter.hpp
+++ b/modules/bioinspired/src/magnoretinafilter.hpp
@ -211,7 +211,7 @@ namespace bioinspired
            Parallel_amacrineCellsComputing(const float *OPL_ON_PTR, const float *OPL_OFF_PTR, float *previousInput_ON_PTR, float *previousInput_OFF_PTR, float *amacrinCellsTempOutput_ON_PTR, float *amacrinCellsTempOutput_OFF_PTR, float temporalCoefficientVal)
                :OPL_ON(OPL_ON_PTR), OPL_OFF(OPL_OFF_PTR), previousInput_ON(previousInput_ON_PTR), previousInput_OFF(previousInput_OFF_PTR), amacrinCellsTempOutput_ON(amacrinCellsTempOutput_ON_PTR), amacrinCellsTempOutput_OFF(amacrinCellsTempOutput_OFF_PTR), temporalCoefficient(temporalCoefficientVal) {}

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                const float *OPL_ON_PTR=OPL_ON+r.start;
                const float *OPL_OFF_PTR=OPL_OFF+r.start;
                float *previousInput_ON_PTR= previousInput_ON+r.start;
--- a/modules/bioinspired/src/parvoretinafilter.hpp
+++ b/modules/bioinspired/src/parvoretinafilter.hpp
@ -234,7 +234,7 @@ private:
        Parallel_OPL_OnOffWaysComputing(float *photoreceptorsOutput_PTR, float *horizontalCellsOutput_PTR, float *bipolarCellsON_PTR, float *bipolarCellsOFF_PTR, float *parvocellularOutputON_PTR, float *parvocellularOutputOFF_PTR)
        :photoreceptorsOutput(photoreceptorsOutput_PTR), horizontalCellsOutput(horizontalCellsOutput_PTR), bipolarCellsON(bipolarCellsON_PTR), bipolarCellsOFF(bipolarCellsOFF_PTR), parvocellularOutputON(parvocellularOutputON_PTR), parvocellularOutputOFF(parvocellularOutputOFF_PTR) {}

-        virtual void operator()( const Range& r ) const {
+        virtual void operator()( const Range& r ) const CV_OVERRIDE {
        // compute bipolar cells response equal to photoreceptors minus horizontal cells response
        // and copy the result on parvo cellular outputs... keeping time before their local contrast adaptation for final result
        float *photoreceptorsOutput_PTR= photoreceptorsOutput+r.start;
--- a/modules/bioinspired/src/retina.cpp
+++ b/modules/bioinspired/src/retina.cpp
@ -80,7 +80,7 @@ namespace cv
 namespace bioinspired
 {

-class RetinaImpl : public Retina
+class RetinaImpl CV_FINAL : public Retina
 {
 public:
    /**
@ -100,16 +100,16 @@ public:
     */
    RetinaImpl(const Size inputSize, const bool colorMode, int colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const float reductionFactor=1.0f, const float samplingStrenght=10.0f);

-    virtual ~RetinaImpl();
+    virtual ~RetinaImpl() CV_OVERRIDE;
    /**
     * retreive retina input buffer size
     */
-    Size getInputSize();
+    Size getInputSize() CV_OVERRIDE;

    /**
     * retreive retina output buffer size
     */
-    Size getOutputSize();
+    Size getOutputSize() CV_OVERRIDE;

    /**
     * try to open an XML retina parameters file to adjust current retina instance setup
@ -118,7 +118,7 @@ public:
     * @param retinaParameterFile : the parameters filename
     * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error
     */
-    void setup(String retinaParameterFile="", const bool applyDefaultSetupOnFailure=true);
+    void setup(String retinaParameterFile="", const bool applyDefaultSetupOnFailure=true) CV_OVERRIDE;


    /**
@ -128,7 +128,7 @@ public:
     * @param fs : the open Filestorage which contains retina parameters
     * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error
     */
-    void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure=true);
+    void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure=true) CV_OVERRIDE;

    /**
     * try to open an XML retina parameters file to adjust current retina instance setup
@ -137,31 +137,31 @@ public:
     * @param newParameters : a parameters structures updated with the new target configuration
     * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error
     */
-    void setup(RetinaParameters newParameters);
+    void setup(RetinaParameters newParameters) CV_OVERRIDE;

    /**
    * @return the current parameters setup
    */
-    struct RetinaParameters getParameters();
+    struct RetinaParameters getParameters() CV_OVERRIDE;

    /**
     * parameters setup display method
     * @return a string which contains formatted parameters information
     */
-    const String printSetup();
+    const String printSetup() CV_OVERRIDE;

    /**
     * write xml/yml formated parameters information
     * @rparam fs : the filename of the xml file that will be open and writen with formatted parameters information
     */
-    virtual void write( String fs ) const;
+    virtual void write( String fs ) const CV_OVERRIDE;


    /**
     * write xml/yml formated parameters information
     * @param fs : a cv::Filestorage object ready to be filled
         */
-    virtual void write( FileStorage& fs ) const;
+    virtual void write( FileStorage& fs ) const CV_OVERRIDE;

    /**
     * setup the OPL and IPL parvo channels (see biologocal model)
@ -178,7 +178,7 @@ public:
     * @param HcellsSpatialConstant: the spatial constant of the first order low pass filter of the horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels, typical value is 5 pixel, this value is also used for local contrast computing when computing the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular channel model)
     * @param ganglionCellsSensitivity: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 230
     */
-    void setupOPLandIPLParvoChannel(const bool colorMode=true, const bool normaliseOutput = true, const float photoreceptorsLocalAdaptationSensitivity=0.7f, const float photoreceptorsTemporalConstant=0.5f, const float photoreceptorsSpatialConstant=0.53f, const float horizontalCellsGain=0.f, const float HcellsTemporalConstant=1.f, const float HcellsSpatialConstant=7.f, const float ganglionCellsSensitivity=0.7f);
+    void setupOPLandIPLParvoChannel(const bool colorMode=true, const bool normaliseOutput = true, const float photoreceptorsLocalAdaptationSensitivity=0.7f, const float photoreceptorsTemporalConstant=0.5f, const float photoreceptorsSpatialConstant=0.53f, const float horizontalCellsGain=0.f, const float HcellsTemporalConstant=1.f, const float HcellsSpatialConstant=7.f, const float ganglionCellsSensitivity=0.7f) CV_OVERRIDE;

    /**
     * set parameters values for the Inner Plexiform Layer (IPL) magnocellular channel
@ -192,13 +192,13 @@ public:
     * @param localAdaptintegration_tau: specifies the temporal constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
     * @param localAdaptintegration_k: specifies the spatial constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
     */
-    void setupIPLMagnoChannel(const bool normaliseOutput = true, const float parasolCells_beta=0.f, const float parasolCells_tau=0.f, const float parasolCells_k=7.f, const float amacrinCellsTemporalCutFrequency=1.2f, const float V0CompressionParameter=0.95f, const float localAdaptintegration_tau=0.f, const float localAdaptintegration_k=7.f);
+    void setupIPLMagnoChannel(const bool normaliseOutput = true, const float parasolCells_beta=0.f, const float parasolCells_tau=0.f, const float parasolCells_k=7.f, const float amacrinCellsTemporalCutFrequency=1.2f, const float V0CompressionParameter=0.95f, const float localAdaptintegration_tau=0.f, const float localAdaptintegration_k=7.f) CV_OVERRIDE;

    /**
     * method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods
     * @param inputImage : the input cv::Mat image to be processed, can be gray level or BGR coded in any format (from 8bit to 16bits)
     */
-    void run(InputArray inputImage);
+    void run(InputArray inputImage) CV_OVERRIDE;

    /**
     * method that applies a luminance correction (initially High Dynamic Range (HDR) tone mapping) using only the 2 local adaptation stages of the retina parvo channel : photoreceptors level and ganlion cells level. Spatio temporal filtering is applied but limited to temporal smoothing and eventually high frequencies attenuation. This is a lighter method than the one available using the regular run method. It is then faster but it does not include complete temporal filtering nor retina spectral whitening. This is an adptation of the original still image HDR tone mapping algorithm of David Alleyson, Sabine Susstruck and Laurence Meylan's work, please cite:
@ -206,35 +206,35 @@ public:
     @param inputImage the input image to process RGB or gray levels
     @param outputToneMappedImage the output tone mapped image
     */
-    void applyFastToneMapping(InputArray inputImage, OutputArray outputToneMappedImage);
+    void applyFastToneMapping(InputArray inputImage, OutputArray outputToneMappedImage) CV_OVERRIDE;

    /**
     * accessor of the details channel of the retina (models foveal vision)
     * @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV
     */
-    void getParvo(OutputArray retinaOutput_parvo);
+    void getParvo(OutputArray retinaOutput_parvo) CV_OVERRIDE;

    /**
     * accessor of the details channel of the retina (models foveal vision)
     * @param retinaOutput_parvo : a cv::Mat header filled with the internal parvo buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling
     */
-    void getParvoRAW(OutputArray retinaOutput_parvo);
+    void getParvoRAW(OutputArray retinaOutput_parvo) CV_OVERRIDE;

    /**
     * accessor of the motion channel of the retina (models peripheral vision)
     * @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV
     */
-    void getMagno(OutputArray retinaOutput_magno);
+    void getMagno(OutputArray retinaOutput_magno) CV_OVERRIDE;

    /**
     * accessor of the motion channel of the retina (models peripheral vision)
     * @param retinaOutput_magno : a cv::Mat header filled with the internal retina magno buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling
     */
-    void getMagnoRAW(OutputArray retinaOutput_magno);
+    void getMagnoRAW(OutputArray retinaOutput_magno) CV_OVERRIDE;

    // original API level data accessors : get buffers addresses from a Mat header, similar to getParvoRAW and getMagnoRAW...
-    const Mat getMagnoRAW() const;
-    const Mat getParvoRAW() const;
+    const Mat getMagnoRAW() const CV_OVERRIDE;
+    const Mat getParvoRAW() const CV_OVERRIDE;

    /**
     * activate color saturation as the final step of the color demultiplexing process
@ -242,24 +242,24 @@ public:
     * @param saturateColors: boolean that activates color saturation (if true) or desactivate (if false)
     * @param colorSaturationValue: the saturation factor
     */
-    void setColorSaturation(const bool saturateColors=true, const float colorSaturationValue=4.0f);
+    void setColorSaturation(const bool saturateColors=true, const float colorSaturationValue=4.0f) CV_OVERRIDE;

    /**
     * clear all retina buffers (equivalent to opening the eyes after a long period of eye close ;o)
     */
-    void clearBuffers();
+    void clearBuffers() CV_OVERRIDE;

    /**
     * Activate/desactivate the Magnocellular pathway processing (motion information extraction), by default, it is activated
     * @param activate: true if Magnocellular output should be activated, false if not
     */
-    void activateMovingContoursProcessing(const bool activate);
+    void activateMovingContoursProcessing(const bool activate) CV_OVERRIDE;

    /**
     * Activate/desactivate the Parvocellular pathway processing (contours information extraction), by default, it is activated
     * @param activate: true if Parvocellular (contours information extraction) output should be activated, false if not
     */
-    void activateContoursProcessing(const bool activate);
+    void activateContoursProcessing(const bool activate) CV_OVERRIDE;
 private:

    // Parameteres setup members
--- a/modules/bioinspired/src/retina_ocl.hpp
+++ b/modules/bioinspired/src/retina_ocl.hpp
@ -627,44 +627,44 @@ private:
    void _runGrayToneMapping(const UMat &grayImageInput, UMat &grayImageOutput , const float PhotoreceptorsCompression = 0.6, const float ganglionCellsCompression = 0.6);
 };

-class RetinaOCLImpl : public Retina
+class RetinaOCLImpl CV_FINAL : public Retina
 {
 public:
    RetinaOCLImpl(Size getInputSize);
    RetinaOCLImpl(Size getInputSize, const bool colorMode, int colorSamplingMethod = RETINA_COLOR_BAYER, const bool useRetinaLogSampling = false, const double reductionFactor = 1.0, const double samplingStrenght = 10.0);
-    virtual ~RetinaOCLImpl();
+    virtual ~RetinaOCLImpl() CV_OVERRIDE;

-    Size getInputSize();
-    Size getOutputSize();
+    Size getInputSize() CV_OVERRIDE;
+    Size getOutputSize() CV_OVERRIDE;

-    void setup(String retinaParameterFile = "", const bool applyDefaultSetupOnFailure = true);
-    void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure = true);
-    void setup(RetinaParameters newParameters);
+    void setup(String retinaParameterFile = "", const bool applyDefaultSetupOnFailure = true) CV_OVERRIDE;
+    void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure = true) CV_OVERRIDE;
+    void setup(RetinaParameters newParameters) CV_OVERRIDE;

-    RetinaParameters getParameters();
+    RetinaParameters getParameters() CV_OVERRIDE;

-    const String printSetup();
-    virtual void write(String fs) const;
-    virtual void write(FileStorage& fs) const;
+    const String printSetup() CV_OVERRIDE;
+    virtual void write(String fs) const CV_OVERRIDE;
+    virtual void write(FileStorage& fs) const CV_OVERRIDE;

-    void setupOPLandIPLParvoChannel(const bool colorMode = true, const bool normaliseOutput = true, const float photoreceptorsLocalAdaptationSensitivity = 0.7, const float photoreceptorsTemporalConstant = 0.5, const float photoreceptorsSpatialConstant = 0.53, const float horizontalCellsGain = 0, const float HcellsTemporalConstant = 1, const float HcellsSpatialConstant = 7, const float ganglionCellsSensitivity = 0.7);
-    void setupIPLMagnoChannel(const bool normaliseOutput = true, const float parasolCells_beta = 0, const float parasolCells_tau = 0, const float parasolCells_k = 7, const float amacrinCellsTemporalCutFrequency = 1.2, const float V0CompressionParameter = 0.95, const float localAdaptintegration_tau = 0, const float localAdaptintegration_k = 7);
+    void setupOPLandIPLParvoChannel(const bool colorMode = true, const bool normaliseOutput = true, const float photoreceptorsLocalAdaptationSensitivity = 0.7, const float photoreceptorsTemporalConstant = 0.5, const float photoreceptorsSpatialConstant = 0.53, const float horizontalCellsGain = 0, const float HcellsTemporalConstant = 1, const float HcellsSpatialConstant = 7, const float ganglionCellsSensitivity = 0.7) CV_OVERRIDE;
+    void setupIPLMagnoChannel(const bool normaliseOutput = true, const float parasolCells_beta = 0, const float parasolCells_tau = 0, const float parasolCells_k = 7, const float amacrinCellsTemporalCutFrequency = 1.2, const float V0CompressionParameter = 0.95, const float localAdaptintegration_tau = 0, const float localAdaptintegration_k = 7) CV_OVERRIDE;

-    void run(InputArray inputImage);
-    void getParvo(OutputArray retinaOutput_parvo);
-    void getMagno(OutputArray retinaOutput_magno);
+    void run(InputArray inputImage) CV_OVERRIDE;
+    void getParvo(OutputArray retinaOutput_parvo) CV_OVERRIDE;
+    void getMagno(OutputArray retinaOutput_magno) CV_OVERRIDE;

-    void setColorSaturation(const bool saturateColors = true, const float colorSaturationValue = 4.0);
-    void clearBuffers();
-    void activateMovingContoursProcessing(const bool activate);
-    void activateContoursProcessing(const bool activate);
+    void setColorSaturation(const bool saturateColors = true, const float colorSaturationValue = 4.0) CV_OVERRIDE;
+    void clearBuffers() CV_OVERRIDE;
+    void activateMovingContoursProcessing(const bool activate) CV_OVERRIDE;
+    void activateContoursProcessing(const bool activate) CV_OVERRIDE;

    // unimplemented interfaces:
-    void applyFastToneMapping(InputArray /*inputImage*/, OutputArray /*outputToneMappedImage*/);
-    void getParvoRAW(OutputArray /*retinaOutput_parvo*/);
-    void getMagnoRAW(OutputArray /*retinaOutput_magno*/);
-    const Mat getMagnoRAW() const;
-    const Mat getParvoRAW() const;
+    void applyFastToneMapping(InputArray /*inputImage*/, OutputArray /*outputToneMappedImage*/) CV_OVERRIDE;
+    void getParvoRAW(OutputArray /*retinaOutput_parvo*/) CV_OVERRIDE;
+    void getMagnoRAW(OutputArray /*retinaOutput_magno*/) CV_OVERRIDE;
+    const Mat getMagnoRAW() const CV_OVERRIDE;
+    const Mat getParvoRAW() const CV_OVERRIDE;

 protected:
    RetinaParameters _retinaParameters;
--- a/modules/bioinspired/src/retinacolor.hpp
+++ b/modules/bioinspired/src/retinacolor.hpp
@ -289,7 +289,7 @@ namespace bioinspired
            Parallel_adaptiveHorizontalCausalFilter_addInput(const float *inputImg, float *bufferToProcess, const float *imageGrad, const unsigned int nbCols)
                :outputFrame(bufferToProcess), inputFrame(inputImg), imageGradient(imageGrad), nbColumns(nbCols) { }

-            virtual void operator()( const Range& r ) const
+            virtual void operator()( const Range& r ) const CV_OVERRIDE
            {
                float* outputPTR=outputFrame+r.start*nbColumns;
                const float* inputPTR=inputFrame+r.start*nbColumns;
@ -317,7 +317,7 @@ namespace bioinspired
            Parallel_adaptiveVerticalAnticausalFilter_multGain(float *bufferToProcess, const float *imageGrad, const unsigned int nbRws, const unsigned int nbCols, const float  gain)
                :outputFrame(bufferToProcess), imageGradient(imageGrad), nbRows(nbRws), nbColumns(nbCols), filterParam_gain(gain) { }

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                float* offset=outputFrame+nbColumns*nbRows-nbColumns;
                const float* gradOffset= imageGradient+nbColumns*nbRows-nbColumns;
                for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
@ -346,7 +346,7 @@ namespace bioinspired
            Parallel_computeGradient(const unsigned int nbCols, const unsigned int nbRws, const float *lum, float *imageGrad)
            :imageGradient(imageGrad), luminance(lum), nbColumns(nbCols), doubleNbColumns(2*nbCols), nbRows(nbRws), nbPixels(nbRws*nbCols) { }

-            virtual void operator()( const Range& r ) const {
+            virtual void operator()( const Range& r ) const CV_OVERRIDE {
                for (int idLine=r.start;idLine!=r.end;++idLine)
                {
                    for (unsigned int idColumn=2;idColumn<nbColumns-2;++idColumn)
--- a/modules/bioinspired/src/retinafasttonemapping.cpp
+++ b/modules/bioinspired/src/retinafasttonemapping.cpp
@ -132,7 +132,7 @@ public:
     @param inputImage the input image to process RGB or gray levels
     @param outputToneMappedImage the output tone mapped image
     */
-    virtual void applyFastToneMapping(InputArray inputImage, OutputArray outputToneMappedImage)
+    virtual void applyFastToneMapping(InputArray inputImage, OutputArray outputToneMappedImage) CV_OVERRIDE
    {
        // first convert input image to the compatible format :
        const bool colorMode = _convertCvMat2ValarrayBuffer(inputImage.getMat(), _inputBuffer);
@ -157,7 +157,7 @@ public:
     * @param ganglioncellsNeighborhoodRadius the second stage local adaptation area
     * @param meanLuminanceModulatorK the factor applied to modulate the meanLuminance information (default is 1, see reference paper)
     */
-    virtual void setup(const float photoreceptorsNeighborhoodRadius=3.f, const float ganglioncellsNeighborhoodRadius=1.f, const float meanLuminanceModulatorK=1.f)
+    virtual void setup(const float photoreceptorsNeighborhoodRadius=3.f, const float ganglioncellsNeighborhoodRadius=1.f, const float meanLuminanceModulatorK=1.f) CV_OVERRIDE
    {
        // setup the spatio-temporal properties of each filter
        _meanLuminanceModulatorK = meanLuminanceModulatorK;
--- a/modules/bioinspired/src/templatebuffer.hpp
+++ b/modules/bioinspired/src/templatebuffer.hpp
@ -94,7 +94,7 @@ public:
    Parallel_clipBufferValues(type* bufferToProcess, const type min, const type max)
        : bufferToClip(bufferToProcess), minValue(min), maxValue(max) { }

-    virtual void operator()( const cv::Range &r ) const {
+    virtual void operator()( const cv::Range &r ) const CV_OVERRIDE {
        type *inputOutputBufferPTR=bufferToClip+r.start;
        for (int jf = r.start; jf != r.end; ++jf, ++inputOutputBufferPTR)
        {
--- a/modules/bioinspired/src/transientareassegmentationmodule.cpp
+++ b/modules/bioinspired/src/transientareassegmentationmodule.cpp
@ -227,17 +227,17 @@ class TransientAreasSegmentationModuleImpl_: public  TransientAreasSegmentationM
 {
 public:
    TransientAreasSegmentationModuleImpl_(const Size size):_segmTool(size){}
-    inline virtual Size getSize(){return _segmTool.getSize();}
-    inline virtual void write( cv::FileStorage& fs ) const{_segmTool.write(fs);}
-    inline virtual void setup(String segmentationParameterFile, const bool applyDefaultSetupOnFailure){_segmTool.setup(segmentationParameterFile, applyDefaultSetupOnFailure);}
-    inline virtual void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure){_segmTool.setup(fs, applyDefaultSetupOnFailure);}
-    inline virtual void setup(SegmentationParameters newParameters){_segmTool.setup(newParameters);}
-    inline virtual const String printSetup(){return _segmTool.printSetup();}
-    inline virtual struct SegmentationParameters getParameters(){return _segmTool.getParameters();}
-    inline virtual void write( String fs ) const{_segmTool.write(fs);}
-    inline virtual void run(InputArray inputToSegment, const int channelIndex){_segmTool.run(inputToSegment, channelIndex);}
-    inline virtual void getSegmentationPicture(OutputArray transientAreas){return _segmTool.getSegmentationPicture(transientAreas);}
-    inline virtual void clearAllBuffers(){_segmTool.clearAllBuffers();}
+    inline virtual Size getSize() CV_OVERRIDE { return _segmTool.getSize(); }
+    inline virtual void write( cv::FileStorage& fs ) const CV_OVERRIDE { _segmTool.write(fs); }
+    inline virtual void setup(String segmentationParameterFile, const bool applyDefaultSetupOnFailure) CV_OVERRIDE { _segmTool.setup(segmentationParameterFile, applyDefaultSetupOnFailure); }
+    inline virtual void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure) CV_OVERRIDE { _segmTool.setup(fs, applyDefaultSetupOnFailure); }
+    inline virtual void setup(SegmentationParameters newParameters) CV_OVERRIDE { _segmTool.setup(newParameters); }
+    inline virtual const String printSetup() CV_OVERRIDE { return _segmTool.printSetup(); }
+    inline virtual struct SegmentationParameters getParameters() CV_OVERRIDE { return _segmTool.getParameters(); }
+    inline virtual void write( String fs ) const CV_OVERRIDE { _segmTool.write(fs); }
+    inline virtual void run(InputArray inputToSegment, const int channelIndex) CV_OVERRIDE { _segmTool.run(inputToSegment, channelIndex); }
+    inline virtual void getSegmentationPicture(OutputArray transientAreas) CV_OVERRIDE { return _segmTool.getSegmentationPicture(transientAreas); }
+    inline virtual void clearAllBuffers() CV_OVERRIDE { _segmTool.clearAllBuffers(); }

 private:
    TransientAreasSegmentationModuleImpl _segmTool;
@ -520,7 +520,7 @@ void TransientAreasSegmentationModuleImpl::_convertValarrayBuffer2cvMat(const st
 {
    // fill output buffer with the valarray buffer
    const bool *valarrayPTR=get_data(grayMatrixToConvert);
-   
+
    outBuffer.create(cv::Size(nbColumns, nbRows), CV_8U);
    Mat outMat = outBuffer.getMat();
    for (unsigned int i=0;i<nbRows;++i)
--- a/modules/datasets/CMakeLists.txt
+++ b/modules/datasets/CMakeLists.txt
@ -1,4 +1,12 @@
 set(the_description "datasets framework")
+
+set(filter_srcs "${CMAKE_CURRENT_LIST_DIR}/src/tinyxml2/tinyxml2.cpp")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  ocv_append_source_files_cxx_compiler_options(filter_srcs "-Wno-suggest-override")  # GCC
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  ocv_append_source_files_cxx_compiler_options(filter_srcs "-Wno-inconsistent-missing-override")  # Clang
+endif()
+
 ocv_define_module(datasets opencv_core opencv_imgcodecs opencv_ml opencv_flann OPTIONAL opencv_text WRAP python)

 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4267) # flann, Win64
--- a/modules/datasets/include/opencv2/datasets/ar_hmdb.hpp
+++ b/modules/datasets/include/opencv2/datasets/ar_hmdb.hpp
@ -67,7 +67,7 @@ struct AR_hmdbObj : public Object
 class CV_EXPORTS AR_hmdb : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<AR_hmdb> create();
 };
--- a/modules/datasets/include/opencv2/datasets/ar_sports.hpp
+++ b/modules/datasets/include/opencv2/datasets/ar_sports.hpp
@ -66,7 +66,7 @@ struct AR_sportsObj : public Object
 class CV_EXPORTS AR_sports : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<AR_sports> create();
 };
--- a/modules/datasets/include/opencv2/datasets/fr_adience.hpp
+++ b/modules/datasets/include/opencv2/datasets/fr_adience.hpp
@ -83,7 +83,7 @@ struct FR_adienceObj : public Object
 class CV_EXPORTS FR_adience : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<FR_adience> create();

--- a/modules/datasets/include/opencv2/datasets/fr_lfw.hpp
+++ b/modules/datasets/include/opencv2/datasets/fr_lfw.hpp
@ -66,7 +66,7 @@ struct FR_lfwObj : public Object
 class CV_EXPORTS FR_lfw : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<FR_lfw> create();
 };
--- a/modules/datasets/include/opencv2/datasets/gr_chalearn.hpp
+++ b/modules/datasets/include/opencv2/datasets/gr_chalearn.hpp
@ -83,7 +83,7 @@ struct GR_chalearnObj : public Object
 class CV_EXPORTS GR_chalearn : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<GR_chalearn> create();
 };
--- a/modules/datasets/include/opencv2/datasets/gr_skig.hpp
+++ b/modules/datasets/include/opencv2/datasets/gr_skig.hpp
@ -105,7 +105,7 @@ struct GR_skigObj : public Object
 class CV_EXPORTS GR_skig : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<GR_skig> create();
 };
--- a/modules/datasets/include/opencv2/datasets/hpe_humaneva.hpp
+++ b/modules/datasets/include/opencv2/datasets/hpe_humaneva.hpp
@ -77,7 +77,7 @@ enum datasetType
 class CV_EXPORTS HPE_humaneva : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<HPE_humaneva> create(int num=humaneva_1);
 };
--- a/modules/datasets/include/opencv2/datasets/hpe_parse.hpp
+++ b/modules/datasets/include/opencv2/datasets/hpe_parse.hpp
@ -65,7 +65,7 @@ struct HPE_parseObj : public Object
 class CV_EXPORTS HPE_parse : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<HPE_parse> create();
 };
--- a/modules/datasets/include/opencv2/datasets/ir_affine.hpp
+++ b/modules/datasets/include/opencv2/datasets/ir_affine.hpp
@ -67,7 +67,7 @@ struct IR_affineObj : public Object
 class CV_EXPORTS IR_affine : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<IR_affine> create();
 };
--- a/modules/datasets/include/opencv2/datasets/ir_robot.hpp
+++ b/modules/datasets/include/opencv2/datasets/ir_robot.hpp
@ -76,7 +76,7 @@ struct IR_robotObj : public Object
 class CV_EXPORTS IR_robot : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<IR_robot> create();
 };
--- a/modules/datasets/include/opencv2/datasets/is_bsds.hpp
+++ b/modules/datasets/include/opencv2/datasets/is_bsds.hpp
@ -65,7 +65,7 @@ struct IS_bsdsObj : public Object
 class CV_EXPORTS IS_bsds : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<IS_bsds> create();
 };
--- a/modules/datasets/include/opencv2/datasets/is_weizmann.hpp
+++ b/modules/datasets/include/opencv2/datasets/is_weizmann.hpp
@ -68,7 +68,7 @@ struct IS_weizmannObj : public Object
 class CV_EXPORTS IS_weizmann : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<IS_weizmann> create();
 };
--- a/modules/datasets/include/opencv2/datasets/msm_epfl.hpp
+++ b/modules/datasets/include/opencv2/datasets/msm_epfl.hpp
@ -77,7 +77,7 @@ struct MSM_epflObj : public Object
 class CV_EXPORTS MSM_epfl : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<MSM_epfl> create();
 };
--- a/modules/datasets/include/opencv2/datasets/msm_middlebury.hpp
+++ b/modules/datasets/include/opencv2/datasets/msm_middlebury.hpp
@ -68,7 +68,7 @@ struct MSM_middleburyObj : public Object
 class CV_EXPORTS MSM_middlebury : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<MSM_middlebury> create();
 };
--- a/modules/datasets/include/opencv2/datasets/or_imagenet.hpp
+++ b/modules/datasets/include/opencv2/datasets/or_imagenet.hpp
@ -66,7 +66,7 @@ struct OR_imagenetObj : public Object
 class CV_EXPORTS OR_imagenet : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<OR_imagenet> create();
 };
--- a/modules/datasets/include/opencv2/datasets/or_mnist.hpp
+++ b/modules/datasets/include/opencv2/datasets/or_mnist.hpp
@ -66,7 +66,7 @@ struct OR_mnistObj : public Object
 class CV_EXPORTS OR_mnist : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<OR_mnist> create();
 };
--- a/modules/datasets/include/opencv2/datasets/or_pascal.hpp
+++ b/modules/datasets/include/opencv2/datasets/or_pascal.hpp
@ -89,7 +89,7 @@ struct OR_pascalObj : public Object
 class CV_EXPORTS OR_pascal : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<OR_pascal> create();
 };
--- a/modules/datasets/include/opencv2/datasets/or_sun.hpp
+++ b/modules/datasets/include/opencv2/datasets/or_sun.hpp
@ -66,7 +66,7 @@ struct OR_sunObj : public Object
 class CV_EXPORTS OR_sun : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<OR_sun> create();

--- a/modules/datasets/include/opencv2/datasets/pd_caltech.hpp
+++ b/modules/datasets/include/opencv2/datasets/pd_caltech.hpp
@ -76,7 +76,7 @@ struct PD_caltechObj : public Object
 class CV_EXPORTS PD_caltech : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<PD_caltech> create();
 };
--- a/modules/datasets/include/opencv2/datasets/pd_inria.hpp
+++ b/modules/datasets/include/opencv2/datasets/pd_inria.hpp
@ -57,7 +57,7 @@ namespace datasets
 //! @addtogroup datasets_pd
 //! @{

-enum sampleType 
+enum sampleType
 {
    POS = 0,
    NEG = 1
@ -67,7 +67,7 @@ struct PD_inriaObj : public Object
 {
    // image file name
    std::string filename;
-    
+
    // positive or negative
    sampleType sType;

@ -83,7 +83,7 @@ struct PD_inriaObj : public Object
 class CV_EXPORTS PD_inria : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<PD_inria> create();
 };
--- a/modules/datasets/include/opencv2/datasets/slam_kitti.hpp
+++ b/modules/datasets/include/opencv2/datasets/slam_kitti.hpp
@ -74,7 +74,7 @@ struct SLAM_kittiObj : public Object
 class CV_EXPORTS SLAM_kitti : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<SLAM_kitti> create();
 };
--- a/modules/datasets/include/opencv2/datasets/slam_tumindoor.hpp
+++ b/modules/datasets/include/opencv2/datasets/slam_tumindoor.hpp
@ -74,7 +74,7 @@ struct SLAM_tumindoorObj : public Object
 class CV_EXPORTS SLAM_tumindoor : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<SLAM_tumindoor> create();
 };
--- a/modules/datasets/include/opencv2/datasets/tr_chars.hpp
+++ b/modules/datasets/include/opencv2/datasets/tr_chars.hpp
@ -66,7 +66,7 @@ struct TR_charsObj : public Object
 class CV_EXPORTS TR_chars : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<TR_chars> create();
 };
--- a/modules/datasets/include/opencv2/datasets/tr_icdar.hpp
+++ b/modules/datasets/include/opencv2/datasets/tr_icdar.hpp
@ -74,7 +74,7 @@ struct TR_icdarObj : public Object
 class CV_EXPORTS TR_icdar : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<TR_icdar> create();
 };
--- a/modules/datasets/include/opencv2/datasets/tr_svt.hpp
+++ b/modules/datasets/include/opencv2/datasets/tr_svt.hpp
@ -73,7 +73,7 @@ struct TR_svtObj : public Object
 class CV_EXPORTS TR_svt : public Dataset
 {
 public:
-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    static Ptr<TR_svt> create();
 };
--- a/modules/datasets/include/opencv2/datasets/track_alov.hpp
+++ b/modules/datasets/include/opencv2/datasets/track_alov.hpp
@ -75,7 +75,7 @@ class CV_EXPORTS TRACK_alov : public Dataset
 public:
    static Ptr<TRACK_alov> create();

-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    //Load only frames with annotations (~every 5-th frame)
    virtual void loadAnnotatedOnly(const std::string &path) = 0;
--- a/modules/datasets/include/opencv2/datasets/track_vot.hpp
+++ b/modules/datasets/include/opencv2/datasets/track_vot.hpp
@ -70,7 +70,7 @@ class CV_EXPORTS TRACK_vot : public Dataset
 public:
    static Ptr<TRACK_vot> create();

-    virtual void load(const std::string &path) = 0;
+    virtual void load(const std::string &path) CV_OVERRIDE = 0;

    virtual int getDatasetsNum() = 0;

--- a/modules/datasets/src/ar_hmdb.cpp
+++ b/modules/datasets/src/ar_hmdb.cpp
@ -58,7 +58,7 @@ public:
    //AR_hmdbImp(const string &path, int number = 0);
    virtual ~AR_hmdbImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDatasetSplit(const string &path, int number = 0);
--- a/modules/datasets/src/ar_sports.cpp
+++ b/modules/datasets/src/ar_sports.cpp
@ -56,7 +56,7 @@ public:
    //AR_sportsImp(const string &path);
    virtual ~AR_sportsImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/fr_adience.cpp
+++ b/modules/datasets/src/fr_adience.cpp
@ -52,14 +52,14 @@ namespace datasets

 using namespace std;

-class FR_adienceImp : public FR_adience
+class FR_adienceImp CV_FINAL : public FR_adience
 {
 public:
    FR_adienceImp() {}
    //FR_adienceImp(const string &path);
    virtual ~FR_adienceImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/fr_lfw.cpp
+++ b/modules/datasets/src/fr_lfw.cpp
@ -51,14 +51,14 @@ namespace datasets

 using namespace std;

-class FR_lfwImp : public FR_lfw
+class FR_lfwImp CV_FINAL : public FR_lfw
 {
 public:
    FR_lfwImp() {}
    //FR_lfwImp(const string &path);
    virtual ~FR_lfwImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/gr_chalearn.cpp
+++ b/modules/datasets/src/gr_chalearn.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class GR_chalearnImp : public GR_chalearn
+class GR_chalearnImp CV_FINAL : public GR_chalearn
 {
 public:
    GR_chalearnImp() {}
    //GR_chalearnImp(const string &path);
    virtual ~GR_chalearnImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/gr_skig.cpp
+++ b/modules/datasets/src/gr_skig.cpp
@ -51,14 +51,14 @@ namespace datasets

 using namespace std;

-class GR_skigImp : public GR_skig
+class GR_skigImp CV_FINAL : public GR_skig
 {
 public:
    GR_skigImp() {}
    //GR_skigImp(const string &path);
    virtual ~GR_skigImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/hpe_humaneva.cpp
+++ b/modules/datasets/src/hpe_humaneva.cpp
@ -51,14 +51,14 @@ namespace datasets

 using namespace std;

-class HPE_humanevaImp : public HPE_humaneva
+class HPE_humanevaImp CV_FINAL : public HPE_humaneva
 {
 public:
    HPE_humanevaImp() {}
    //HPE_humanevaImp(const string &path);
    virtual ~HPE_humanevaImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
@ -138,7 +138,7 @@ public:
    //HPE_humanevaImpII(const string &path);
    virtual ~HPE_humanevaImpII() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/hpe_parse.cpp
+++ b/modules/datasets/src/hpe_parse.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class HPE_parseImp : public HPE_parse
+class HPE_parseImp CV_FINAL : public HPE_parse
 {
 public:
    HPE_parseImp() {}
    //HPE_parseImp(const string &path);
    virtual ~HPE_parseImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/ir_affine.cpp
+++ b/modules/datasets/src/ir_affine.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class IR_affineImp : public IR_affine
+class IR_affineImp CV_FINAL : public IR_affine
 {
 public:
    IR_affineImp() {}
    //IR_affineImp(const string &path);
-    virtual ~IR_affineImp() {}
+    virtual ~IR_affineImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/ir_robot.cpp
+++ b/modules/datasets/src/ir_robot.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class IR_robotImp : public IR_robot
+class IR_robotImp CV_FINAL : public IR_robot
 {
 public:
    IR_robotImp() {}
    //IR_robotImp(const string &path);
    virtual ~IR_robotImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/is_bsds.cpp
+++ b/modules/datasets/src/is_bsds.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class IS_bsdsImp : public IS_bsds
+class IS_bsdsImp CV_FINAL : public IS_bsds
 {
 public:
    IS_bsdsImp() {}
    //IS_bsdsImp(const string &path);
    virtual ~IS_bsdsImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/is_weizmann.cpp
+++ b/modules/datasets/src/is_weizmann.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class IS_weizmannImp : public IS_weizmann
+class IS_weizmannImp CV_FINAL : public IS_weizmann
 {
 public:
    IS_weizmannImp() {}
    //IS_weizmannImp(const string &path);
    virtual ~IS_weizmannImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/msm_epfl.cpp
+++ b/modules/datasets/src/msm_epfl.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class MSM_epflImp : public MSM_epfl
+class MSM_epflImp CV_FINAL : public MSM_epfl
 {
 public:
    MSM_epflImp() {}
    //MSM_epflImp(const string &path);
-    virtual ~MSM_epflImp() {}
+    virtual ~MSM_epflImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/msm_middlebury.cpp
+++ b/modules/datasets/src/msm_middlebury.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class MSM_middleburyImp : public MSM_middlebury
+class MSM_middleburyImp CV_FINAL : public MSM_middlebury
 {
 public:
    MSM_middleburyImp() {}
    //MSM_middleburyImp(const string &path);
    virtual ~MSM_middleburyImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/or_imagenet.cpp
+++ b/modules/datasets/src/or_imagenet.cpp
@ -51,14 +51,14 @@ namespace datasets

 using namespace std;

-class OR_imagenetImp : public OR_imagenet
+class OR_imagenetImp CV_FINAL : public OR_imagenet
 {
 public:
    OR_imagenetImp() {}
    //OR_imagenetImp(const string &path);
-    virtual ~OR_imagenetImp() {}
+    virtual ~OR_imagenetImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/or_mnist.cpp
+++ b/modules/datasets/src/or_mnist.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class OR_mnistImp : public OR_mnist
+class OR_mnistImp CV_FINAL : public OR_mnist
 {
 public:
    OR_mnistImp() {}
    //OR_mnistImp(const string &path);
    virtual ~OR_mnistImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/or_pascal.cpp
+++ b/modules/datasets/src/or_pascal.cpp
@ -41,7 +41,14 @@

 #include "opencv2/datasets/or_pascal.hpp"
 #include "opencv2/datasets/util.hpp"
+#if defined(__GNUC__) && __GNUC__ >= 5
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsuggest-override"
+#endif
 #include "tinyxml2/tinyxml2.h"
+#if defined(__GNUC__) && __GNUC__ >= 5
+#pragma GCC diagnostic pop
+#endif
 #include <fstream>

 namespace cv
@ -52,12 +59,12 @@ namespace datasets
 using namespace std;
 using namespace tinyxml2;

-class OR_pascalImp : public OR_pascal
+class OR_pascalImp CV_FINAL : public OR_pascal
 {
 public:
    OR_pascalImp() {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path, const string &nameImageSet, vector< Ptr<Object> > &imageSet);
--- a/modules/datasets/src/or_sun.cpp
+++ b/modules/datasets/src/or_sun.cpp
@ -51,14 +51,14 @@ namespace datasets

 using namespace std;

-class OR_sunImp : public OR_sun
+class OR_sunImp CV_FINAL : public OR_sun
 {
 public:
    OR_sunImp() {}
    //OR_sunImp(const string &path);
-    virtual ~OR_sunImp() {}
+    virtual ~OR_sunImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/pd_caltech.cpp
+++ b/modules/datasets/src/pd_caltech.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class PD_caltechImp : public PD_caltech
+class PD_caltechImp CV_FINAL : public PD_caltech
 {
 public:
    PD_caltechImp() {}
    //PD_caltechImp(const string &path);
-    virtual ~PD_caltechImp() {}
+    virtual ~PD_caltechImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/pd_inria.cpp
+++ b/modules/datasets/src/pd_inria.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class PD_inriaImp : public PD_inria
+class PD_inriaImp CV_FINAL : public PD_inria
 {
 public:
    PD_inriaImp() {}
-    
-    virtual ~PD_inriaImp() {}

-    virtual void load(const string &path);
+    virtual ~PD_inriaImp() CV_OVERRIDE {}
+
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path, const string nameImageSet, vector< Ptr<Object> > &imageSet);
@ -69,7 +69,7 @@ void PD_inriaImp::load(const string &path)
    // Training set
    train.push_back(vector< Ptr<Object> >());
    loadDataset(path, "Train", train.back());
-    
+
    // Testing set
    test.push_back(vector< Ptr<Object> >());
    loadDataset(path, "Test", test.back());
@ -106,16 +106,16 @@ void PD_inriaImp::parseAnnotation(const string filename, Ptr< PD_inriaObj > &obj
        error_message = format("Unable to open file: \n%s\n", filename.c_str());
        CV_Error(Error::StsBadArg, error_message);
    }
-    
+
    string imageSizeHeader = "Image size (X x Y x C) : ";
    string imageSizeFmt = imageSizeHeader + "%d x %d x %d";
    string objWithGTHeader = "Objects with ground truth : ";
    string objWithGTFmt = objWithGTHeader + "%d { \"PASperson\" }";
    string boundBoxHeader = "Bounding box for object ";
    string boundBoxFmt = boundBoxHeader + "%*d \"PASperson\" (Xmin, Ymin) - (Xmax, Ymax) : (%d, %d) - (%d, %d)";
-    
+
    string line = "";
-    
+
    int width = 0;
    int height = 0;
    int depth = 0;
@ -138,7 +138,7 @@ void PD_inriaImp::parseAnnotation(const string filename, Ptr< PD_inriaObj > &obj
        else if (strstr(line.c_str(), objWithGTHeader.c_str()))
        {
            sscanf(line.c_str(), objWithGTFmt.c_str(), &numObjects);
-            
+
            if (numObjects <= 0)
                break;
        }
@ -162,16 +162,16 @@ void PD_inriaImp::loadDataset(const string &path, const string nameImageSet, vec
    string listAnn = path + nameImageSet + "/annotations.lst";
    string listPos = path + nameImageSet + "/pos.lst";
    string listNeg = path + nameImageSet + "/neg.lst";
-    
+
    vector< string > fsAnn;
    vector< string > fsPos;
    vector< string > fsNeg;
-   
+
    // read file names
    readTextLines(listAnn, fsAnn);
    readTextLines(listPos, fsPos);
    readTextLines(listNeg, fsNeg);
-   
+
    CV_Assert(fsAnn.size() == fsPos.size());

    for (unsigned int i = 0; i < fsPos.size(); i++)
@ -180,16 +180,16 @@ void PD_inriaImp::loadDataset(const string &path, const string nameImageSet, vec
        parseAnnotation(path + fsAnn[i], curr);
        curr->filename = path + fsPos[i];
        curr->sType = POS;
-        
+
        imageSet.push_back(curr);
    }
-    
+
    for (unsigned int i = 0; i < fsNeg.size(); i++)
    {
        Ptr<PD_inriaObj> curr(new PD_inriaObj);
-        curr->filename = path + fsNeg[i]; 
+        curr->filename = path + fsNeg[i];
        curr->sType = NEG;
-        
+
        imageSet.push_back(curr);
    }
 }
--- a/modules/datasets/src/slam_kitti.cpp
+++ b/modules/datasets/src/slam_kitti.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class SLAM_kittiImp : public SLAM_kitti
+class SLAM_kittiImp CV_FINAL : public SLAM_kitti
 {
 public:
    SLAM_kittiImp() {}
    //SLAM_kittiImp(const string &path);
-    virtual ~SLAM_kittiImp() {}
+    virtual ~SLAM_kittiImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/slam_tumindoor.cpp
+++ b/modules/datasets/src/slam_tumindoor.cpp
@ -51,14 +51,14 @@ namespace datasets

 using namespace std;

-class SLAM_tumindoorImp : public SLAM_tumindoor
+class SLAM_tumindoorImp CV_FINAL : public SLAM_tumindoor
 {
 public:
    SLAM_tumindoorImp() {}
    //SLAM_tumindoorImp(const string &path);
-    virtual ~SLAM_tumindoorImp() {}
+    virtual ~SLAM_tumindoorImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/tr_chars.cpp
+++ b/modules/datasets/src/tr_chars.cpp
@ -49,14 +49,14 @@ namespace datasets

 using namespace std;

-class TR_charsImp : public TR_chars
+class TR_charsImp CV_FINAL : public TR_chars
 {
 public:
    TR_charsImp() {}
    //TR_charsImp(const string &path, int number = 0);
-    virtual ~TR_charsImp() {}
+    virtual ~TR_charsImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDatasetSplit(const string &path, int number);
--- a/modules/datasets/src/tr_icdar.cpp
+++ b/modules/datasets/src/tr_icdar.cpp
@ -53,14 +53,14 @@ namespace datasets

 using namespace std;

-class TR_icdarImp : public TR_icdar
+class TR_icdarImp CV_FINAL : public TR_icdar
 {
 public:
    TR_icdarImp() {}
    //TR_icdarImp(const string &path);
-    virtual ~TR_icdarImp() {}
+    virtual ~TR_icdarImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/tr_svt.cpp
+++ b/modules/datasets/src/tr_svt.cpp
@ -42,7 +42,14 @@
 #include "opencv2/datasets/tr_svt.hpp"
 #include "opencv2/datasets/util.hpp"

+#if defined(__GNUC__) && __GNUC__ >= 5
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsuggest-override"
+#endif
 #include "tinyxml2/tinyxml2.h"
+#if defined(__GNUC__) && __GNUC__ >= 5
+#pragma GCC diagnostic pop
+#endif

 namespace cv
 {
@ -52,14 +59,14 @@ namespace datasets
 using namespace std;
 using namespace tinyxml2;

-class TR_svtImp : public TR_svt
+class TR_svtImp CV_FINAL : public TR_svt
 {
 public:
    TR_svtImp() {}
    //TR_svtImp(const string &path);
-    virtual ~TR_svtImp() {}
+    virtual ~TR_svtImp() CV_OVERRIDE {}

-    virtual void load(const string &path);
+    virtual void load(const string &path) CV_OVERRIDE;

 private:
    void loadDataset(const string &path);
--- a/modules/datasets/src/track_alov.cpp
+++ b/modules/datasets/src/track_alov.cpp
@ -52,7 +52,7 @@ namespace cv
 namespace datasets
 {

-class TRACK_alovImpl : public TRACK_alov
+class TRACK_alovImpl CV_FINAL : public TRACK_alov
 {
 public:
    //Constructor
@ -62,24 +62,24 @@ public:
        frameCounter = 0;
    }
    //Destructor
-    virtual ~TRACK_alovImpl() {}
+    virtual ~TRACK_alovImpl() CV_OVERRIDE {}

    //Load Dataset
-    virtual void load(const string &path);
-    virtual void loadAnnotatedOnly(const std::string &path);
+    virtual void load(const string &path) CV_OVERRIDE;
+    virtual void loadAnnotatedOnly(const std::string &path) CV_OVERRIDE;

 protected:
-    virtual int getDatasetsNum();
+    virtual int getDatasetsNum() CV_OVERRIDE;

-    virtual int getDatasetLength(int id);
+    virtual int getDatasetLength(int id) CV_OVERRIDE;

-    virtual bool initDataset(int id);
+    virtual bool initDataset(int id) CV_OVERRIDE;

-    virtual bool getNextFrame(Mat &frame);
-    virtual bool getFrame(Mat &frame, int datasetID, int frameID);
+    virtual bool getNextFrame(Mat &frame) CV_OVERRIDE;
+    virtual bool getFrame(Mat &frame, int datasetID, int frameID) CV_OVERRIDE;

-    virtual vector <Point2f> getNextGT();
-    virtual vector <Point2f> getGT(int datasetID, int frameID);
+    virtual vector <Point2f> getNextGT() CV_OVERRIDE;
+    virtual vector <Point2f> getGT(int datasetID, int frameID) CV_OVERRIDE;

    void loadDataset(const string &path);
    void loadDatasetAnnotatedOnly(const string &path);
--- a/modules/datasets/src/track_vot.cpp
+++ b/modules/datasets/src/track_vot.cpp
@ -52,7 +52,7 @@ namespace cv
    namespace datasets
    {

-        class TRACK_votImpl : public TRACK_vot
+        class TRACK_votImpl CV_FINAL : public TRACK_vot
        {
        public:
            //Constructor
@ -62,21 +62,21 @@ namespace cv
                frameCounter = 0;
            }
            //Destructor
-            virtual ~TRACK_votImpl() {}
+            virtual ~TRACK_votImpl() CV_OVERRIDE {}

            //Load Dataset
-            virtual void load(const string &path);
+            virtual void load(const string &path) CV_OVERRIDE;

 		protected:
-            virtual int getDatasetsNum();
+            virtual int getDatasetsNum() CV_OVERRIDE;

-            virtual int getDatasetLength(int id);
+            virtual int getDatasetLength(int id) CV_OVERRIDE;

-            virtual bool initDataset(int id);
+            virtual bool initDataset(int id) CV_OVERRIDE;

-            virtual bool getNextFrame(Mat &frame);
+            virtual bool getNextFrame(Mat &frame) CV_OVERRIDE;

-            virtual vector <Point2d> getGT();
+            virtual vector <Point2d> getGT() CV_OVERRIDE;

            void loadDataset(const string &path);

--- a/modules/dpm/src/dpm_cascade.hpp
+++ b/modules/dpm/src/dpm_cascade.hpp
@ -141,7 +141,7 @@ class ParalComputeRootPCAScores : public ParallelLoopBody
                int dim, std::vector< Mat > &scores);

        // parallel loop body
-        void operator() (const Range &range) const;
+        void operator() (const Range &range) const CV_OVERRIDE;

        ParalComputeRootPCAScores(const ParalComputeRootPCAScores &pComp);

--- a/modules/dpm/src/dpm_cascade_detector.cpp
+++ b/modules/dpm/src/dpm_cascade_detector.cpp
@ -49,19 +49,19 @@ namespace cv
 namespace dpm
 {

-class DPMDetectorImpl : public DPMDetector
+class DPMDetectorImpl CV_FINAL : public DPMDetector
 {
 public:

    DPMDetectorImpl( const vector<string>& filenames, const vector<string>& classNames=vector<string>() );
-    ~DPMDetectorImpl();
+    ~DPMDetectorImpl() CV_OVERRIDE;

-    bool isEmpty() const;
+    bool isEmpty() const CV_OVERRIDE;

-    void detect(Mat &image, CV_OUT vector<ObjectDetection>& objects);
+    void detect(Mat &image, CV_OUT vector<ObjectDetection>& objects) CV_OVERRIDE;

-    const vector<string>& getClassNames() const;
-    size_t getClassCount() const;
+    const vector<string>& getClassNames() const CV_OVERRIDE;
+    size_t getClassCount() const CV_OVERRIDE;
    string extractModelName( const string& filename );

 private:
--- a/modules/dpm/src/dpm_feature.hpp
+++ b/modules/dpm/src/dpm_feature.hpp
@ -153,7 +153,7 @@ class ParalComputePyramid : public ParallelLoopBody
        void initialize();

        // parallel loop body
-        void operator() (const Range &range) const;
+        void operator() (const Range &range) const CV_OVERRIDE;

    private:
        // image to compute feature pyramid
--- a/modules/dpm/src/dpm_model.hpp
+++ b/modules/dpm/src/dpm_model.hpp
@ -130,11 +130,11 @@ class CascadeModel : public Model
        std::vector< Mat > partPCAFilters;
    public:
        CascadeModel() {}
-        ~CascadeModel() {}
+        ~CascadeModel() CV_OVERRIDE {}

-        void initModel();
-        bool serialize(const std::string &filename) const;
-        bool deserialize(const std::string &filename);
+        void initModel() CV_OVERRIDE;
+        bool serialize(const std::string &filename) const CV_OVERRIDE;
+        bool deserialize(const std::string &filename) CV_OVERRIDE;
 };

 } // namespace lsvm
--- a/modules/face/include/opencv2/face.hpp
+++ b/modules/face/include/opencv2/face.hpp
@ -333,13 +333,13 @@ public:
    Saves this model to a given FileStorage.
    @param fs The FileStorage to store this FaceRecognizer to.
    */
-    virtual void write(FileStorage& fs) const = 0;
+    virtual void write(FileStorage& fs) const CV_OVERRIDE = 0;

    /** @overload */
-    virtual void read(const FileNode& fn) = 0;
+    virtual void read(const FileNode& fn) CV_OVERRIDE = 0;

    /** @overload */
-    virtual bool empty() const = 0;
+    virtual bool empty() const CV_OVERRIDE = 0;

    /** @brief Sets string info for the specified model's label.

--- a/modules/face/include/opencv2/face/facemark.hpp
+++ b/modules/face/include/opencv2/face/facemark.hpp
@ -265,8 +265,8 @@ class CV_EXPORTS_W Facemark : public virtual Algorithm
 {
 public:

-    virtual void read( const FileNode& fn )=0;
-    virtual void write( FileStorage& fs ) const=0;
+    virtual void read( const FileNode& fn ) CV_OVERRIDE = 0;
+    virtual void write( FileStorage& fs ) const CV_OVERRIDE = 0;

    /** @brief Add one training sample to the trainer.

--- a/modules/face/include/opencv2/face/facerec.hpp
+++ b/modules/face/include/opencv2/face/facerec.hpp
@ -25,18 +25,18 @@ public:
    /** @copybrief getNumComponents @see getNumComponents */
    CV_WRAP void setNumComponents(int val);
    /** @see setThreshold */
-    CV_WRAP double getThreshold() const;
+    CV_WRAP double getThreshold() const CV_OVERRIDE;
    /** @copybrief getThreshold @see getThreshold */
-    CV_WRAP void setThreshold(double val);
+    CV_WRAP void setThreshold(double val) CV_OVERRIDE;
    CV_WRAP std::vector<cv::Mat> getProjections() const;
    CV_WRAP cv::Mat getLabels() const;
    CV_WRAP cv::Mat getEigenValues() const;
    CV_WRAP cv::Mat getEigenVectors() const;
    CV_WRAP cv::Mat getMean() const;

-    virtual void read(const FileNode& fn);
-    virtual void write(FileStorage& fs) const;
-    virtual bool empty() const;
+    virtual void read(const FileNode& fn) CV_OVERRIDE;
+    virtual void write(FileStorage& fs) const CV_OVERRIDE;
+    virtual bool empty() const CV_OVERRIDE;

    using FaceRecognizer::read;
    using FaceRecognizer::write;
@ -143,9 +143,9 @@ public:
    /** @copybrief getNeighbors @see getNeighbors */
    CV_WRAP virtual void setNeighbors(int val) = 0;
    /** @see setThreshold */
-    CV_WRAP virtual double getThreshold() const = 0;
+    CV_WRAP virtual double getThreshold() const CV_OVERRIDE = 0;
    /** @copybrief getThreshold @see getThreshold */
-    CV_WRAP virtual void setThreshold(double val) = 0;
+    CV_WRAP virtual void setThreshold(double val) CV_OVERRIDE = 0;
    CV_WRAP virtual std::vector<cv::Mat> getHistograms() const = 0;
    CV_WRAP virtual cv::Mat getLabels() const = 0;

--- a/modules/face/include/opencv2/face/predict_collector.hpp
+++ b/modules/face/include/opencv2/face/predict_collector.hpp
@ -98,9 +98,9 @@ public:
    */
    StandardCollector(double threshold_ = DBL_MAX);
    /** @brief overloaded interface method */
-    void init(size_t size);
+    void init(size_t size) CV_OVERRIDE;
    /** @brief overloaded interface method */
-    bool collect(int label, double dist);
+    bool collect(int label, double dist) CV_OVERRIDE;
    /** @brief Returns label with minimal distance */
    CV_WRAP int getMinLabel() const;
    /** @brief Returns minimal distance value */
--- a/modules/face/src/bif.cpp
+++ b/modules/face/src/bif.cpp
@ -91,18 +91,18 @@ const double kGaborWavelens[kNumBandsMax][2] = {
    {11.5, 12.7}, {14.1, 15.4}, {16.8, 18.2}, {19.7, 21.2}
 };

-class BIFImpl : public cv::face::BIF {
+class BIFImpl CV_FINAL : public cv::face::BIF {
 public:
    BIFImpl(int num_bands, int num_rotations) {
        initUnits(num_bands, num_rotations);
    }

-    virtual int getNumBands() const { return num_bands_; }
+    virtual int getNumBands() const CV_OVERRIDE { return num_bands_; }

-    virtual int getNumRotations() const { return num_rotations_; }
+    virtual int getNumRotations() const CV_OVERRIDE { return num_rotations_; }

    virtual void compute(cv::InputArray image,
-                         cv::OutputArray features) const;
+                         cv::OutputArray features) const CV_OVERRIDE;

 private:
    struct UnitParams {
--- a/modules/face/src/eigen_faces.cpp
+++ b/modules/face/src/eigen_faces.cpp
@ -43,11 +43,11 @@ public:

    // Computes an Eigenfaces model with images in src and corresponding labels
    // in labels.
-    void train(InputArrayOfArrays src, InputArray labels);
+    void train(InputArrayOfArrays src, InputArray labels) CV_OVERRIDE;

    // Send all predict results to caller side for custom result handling
-    void predict(InputArray src, Ptr<PredictCollector> collector) const;
-    String getDefaultName() const
+    void predict(InputArray src, Ptr<PredictCollector> collector) const CV_OVERRIDE;
+    String getDefaultName() const CV_OVERRIDE
    {
        return "opencv_eigenfaces";
    }
--- a/modules/face/src/face_alignmentimpl.hpp
+++ b/modules/face/src/face_alignmentimpl.hpp
@ -70,12 +70,12 @@ class FacemarkKazemiImpl : public FacemarkKazemi{

 public:
    FacemarkKazemiImpl(const FacemarkKazemi::Params& parameters);
-    void loadModel(String fs);
-    bool setFaceDetector(FN_FaceDetector f, void* userdata);
-    bool getFaces(InputArray image, OutputArray faces);
-    bool fit(InputArray image, InputArray faces, InputOutputArray landmarks );
-    void training(String imageList, String groundTruth);
-    bool training(vector<Mat>& images, vector< vector<Point2f> >& landmarks,string filename,Size scale,string modelFilename);
+    void loadModel(String fs) CV_OVERRIDE;
+    bool setFaceDetector(FN_FaceDetector f, void* userdata) CV_OVERRIDE;
+    bool getFaces(InputArray image, OutputArray faces) CV_OVERRIDE;
+    bool fit(InputArray image, InputArray faces, InputOutputArray landmarks) CV_OVERRIDE;
+    void training(String imageList, String groundTruth) CV_OVERRIDE;
+    bool training(vector<Mat>& images, vector< vector<Point2f> >& landmarks,string filename,Size scale,string modelFilename) CV_OVERRIDE;
    // Destructor for the class.
    virtual ~FacemarkKazemiImpl();

@ -171,4 +171,4 @@ protected:
 };
 }//face
 }//cv
-#endif
+#endif
--- a/modules/face/src/facemarkAAM.cpp
+++ b/modules/face/src/facemarkAAM.cpp
@ -92,24 +92,24 @@ void FacemarkAAM::Params::write( cv::FileStorage& fs ) const{
 class FacemarkAAMImpl : public FacemarkAAM {
 public:
    FacemarkAAMImpl( const FacemarkAAM::Params &parameters = FacemarkAAM::Params() );
-    void read( const FileNode& /*fn*/ );
-    void write( FileStorage& /*fs*/ ) const;
+    void read( const FileNode& /*fn*/ ) CV_OVERRIDE;
+    void write( FileStorage& /*fs*/ ) const CV_OVERRIDE;

    void saveModel(String fs);
-    void loadModel(String fs);
+    void loadModel(String fs) CV_OVERRIDE;

-    bool setFaceDetector(bool(*f)(InputArray , OutputArray, void * ), void* userData);
-    bool getFaces(InputArray image, OutputArray faces);
+    bool setFaceDetector(bool(*f)(InputArray , OutputArray, void * ), void* userData) CV_OVERRIDE;
+    bool getFaces(InputArray image, OutputArray faces) CV_OVERRIDE;

-    bool getData(void * items);
+    bool getData(void * items) CV_OVERRIDE;

 protected:

-    bool fit( InputArray image, InputArray faces, InputOutputArray landmarks, void * runtime_params);//!< from many ROIs
+    bool fit( InputArray image, InputArray faces, InputOutputArray landmarks, void * runtime_params) CV_OVERRIDE;//!< from many ROIs
    bool fitImpl( const Mat image, std::vector<Point2f>& landmarks,const  Mat R,const  Point2f T,const  float scale, const int sclIdx=0 );

-    bool addTrainingSample(InputArray image, InputArray landmarks);
-    void training(void* parameters);
+    bool addTrainingSample(InputArray image, InputArray landmarks) CV_OVERRIDE;
+    void training(void* parameters) CV_OVERRIDE;

    Mat procrustes(std::vector<Point2f> , std::vector<Point2f> , Mat & , Scalar & , float & );
    void calcMeanShape(std::vector<std::vector<Point2f> > ,std::vector<Point2f> & );
--- a/modules/face/src/facemarkLBF.cpp
+++ b/modules/face/src/facemarkLBF.cpp
@ -102,24 +102,24 @@ class FacemarkLBFImpl : public FacemarkLBF {
 public:
    FacemarkLBFImpl( const FacemarkLBF::Params &parameters = FacemarkLBF::Params() );

-    void read( const FileNode& /*fn*/ );
-    void write( FileStorage& /*fs*/ ) const;
+    void read( const FileNode& /*fn*/ ) CV_OVERRIDE;
+    void write( FileStorage& /*fs*/ ) const CV_OVERRIDE;

-    void loadModel(String fs);
+    void loadModel(String fs) CV_OVERRIDE;

-    bool setFaceDetector(bool(*f)(InputArray , OutputArray, void * extra_params ), void* userData);
-    bool getFaces(InputArray image, OutputArray faces);
-    bool getData(void * items);
+    bool setFaceDetector(bool(*f)(InputArray , OutputArray, void * extra_params ), void* userData) CV_OVERRIDE;
+    bool getFaces(InputArray image, OutputArray faces) CV_OVERRIDE;
+    bool getData(void * items) CV_OVERRIDE;

    Params params;

 protected:

-    bool fit( InputArray image, InputArray faces, InputOutputArray landmarks, void * runtime_params );//!< from many ROIs
+    bool fit( InputArray image, InputArray faces, InputOutputArray landmarks, void * runtime_params ) CV_OVERRIDE;//!< from many ROIs
    bool fitImpl( const Mat image, std::vector<Point2f> & landmarks );//!< from a face

-    bool addTrainingSample(InputArray image, InputArray landmarks);
-    void training(void* parameters);
+    bool addTrainingSample(InputArray image, InputArray landmarks) CV_OVERRIDE;
+    void training(void* parameters) CV_OVERRIDE;

    Rect getBBox(Mat &img, const Mat_<double> shape);
    void prepareTrainingData(Mat img, std::vector<Point2f> facePoints,
--- a/modules/face/src/fisher_faces.cpp
+++ b/modules/face/src/fisher_faces.cpp
@ -38,11 +38,11 @@ public:

    // Computes a Fisherfaces model with images in src and corresponding labels
    // in labels.
-    void train(InputArrayOfArrays src, InputArray labels);
+    void train(InputArrayOfArrays src, InputArray labels) CV_OVERRIDE;

    // Send all predict results to caller side for custom result handling
-    void predict(InputArray src, Ptr<PredictCollector> collector) const;
-    String getDefaultName() const
+    void predict(InputArray src, Ptr<PredictCollector> collector) const CV_OVERRIDE;
+    String getDefaultName() const CV_OVERRIDE
    {
        return "opencv_fisherfaces";
    }
--- a/modules/face/src/lbph_faces.cpp
+++ b/modules/face/src/lbph_faces.cpp
@ -81,40 +81,45 @@ public:
        train(src, labels);
    }

-    ~LBPH() { }
+    ~LBPH() CV_OVERRIDE { }

    // Computes a LBPH model with images in src and
    // corresponding labels in labels.
-    void train(InputArrayOfArrays src, InputArray labels);
+    void train(InputArrayOfArrays src, InputArray labels) CV_OVERRIDE;

    // Updates this LBPH model with images in src and
    // corresponding labels in labels.
-    void update(InputArrayOfArrays src, InputArray labels);
+    void update(InputArrayOfArrays src, InputArray labels) CV_OVERRIDE;

    // Send all predict results to caller side for custom result handling
-    void predict(InputArray src, Ptr<PredictCollector> collector) const;
+    void predict(InputArray src, Ptr<PredictCollector> collector) const CV_OVERRIDE;

    // See FaceRecognizer::write.
-    void read(const FileNode& fn);
+    void read(const FileNode& fn) CV_OVERRIDE;

    // See FaceRecognizer::save.
-    void write(FileStorage& fs) const;
+    void write(FileStorage& fs) const CV_OVERRIDE;

-    bool empty() const {
+    bool empty() const CV_OVERRIDE {
        return (_labels.empty());
    }
-    String getDefaultName() const
+    String getDefaultName() const CV_OVERRIDE
    {
        return "opencv_lbphfaces";
    }

-    CV_IMPL_PROPERTY(int, GridX, _grid_x)
-    CV_IMPL_PROPERTY(int, GridY, _grid_y)
-    CV_IMPL_PROPERTY(int, Radius, _radius)
-    CV_IMPL_PROPERTY(int, Neighbors, _neighbors)
-    CV_IMPL_PROPERTY(double, Threshold, _threshold)
-    CV_IMPL_PROPERTY_RO(std::vector<cv::Mat>, Histograms, _histograms)
-    CV_IMPL_PROPERTY_RO(cv::Mat, Labels, _labels)
+    inline int getGridX() const CV_OVERRIDE { return _grid_x; }
+    inline void setGridX(int val) CV_OVERRIDE { _grid_x = val; }
+    inline int getGridY() const CV_OVERRIDE { return _grid_y; }
+    inline void setGridY(int val) CV_OVERRIDE { _grid_y = val; }
+    inline int getRadius() const CV_OVERRIDE { return _radius; }
+    inline void setRadius(int val) CV_OVERRIDE { _radius = val; }
+    inline int getNeighbors() const CV_OVERRIDE { return _neighbors; }
+    inline void setNeighbors(int val) CV_OVERRIDE { _neighbors = val; }
+    inline double getThreshold() const CV_OVERRIDE { return _threshold; }
+    inline void setThreshold(double val) CV_OVERRIDE { _threshold = val; }
+    inline std::vector<cv::Mat> getHistograms() const CV_OVERRIDE { return _histograms; }
+    inline cv::Mat getLabels() const CV_OVERRIDE { return _labels; }
 };


--- a/modules/face/src/mace.cpp
+++ b/modules/face/src/mace.cpp
@ -72,7 +72,7 @@ static uint64 crc64( const uchar* data, size_t size, uint64 crc0=0 )
    return ~crc;
 }

-struct MACEImpl : MACE {
+struct MACEImpl CV_FINAL : MACE {
    Mat_<Vec2d> maceFilter; // filled from compute()
    Mat convFilter;         // optional random convolution (cancellable)
    int IMGSIZE;            // images will get resized to this
@ -81,7 +81,7 @@ struct MACEImpl : MACE {

    MACEImpl(int siz) : IMGSIZE(siz), threshold(DBL_MAX) {}

-    void salt(const String &passphrase) {
+    void salt(const String &passphrase) CV_OVERRIDE {
        theRNG().state = ((int64)crc64((uchar*)passphrase.c_str(), passphrase.size()));
        convFilter.create(IMGSIZE, IMGSIZE, CV_64F);
        randn(convFilter, 0, 1.0/(IMGSIZE*IMGSIZE));
@ -257,7 +257,7 @@ struct MACEImpl : MACE {
    }

    // MACE interface
-    void train(InputArrayOfArrays input) {
+    void train(InputArrayOfArrays input) CV_OVERRIDE {
        std::vector<Mat> images, dftImg;
        input.getMatVector(images);
        for (size_t i=0; i<images.size(); i++) { // cache dft images
@ -266,27 +266,27 @@ struct MACEImpl : MACE {
        compute(dftImg, true);
        threshold = computeThreshold(dftImg, true);
    }
-    bool same(InputArray img) const {
+    bool same(InputArray img) const CV_OVERRIDE {
        return correlate(img.getMat()) >= threshold;
    }

    // cv::Algorithm:
-    bool empty() const {
+    bool empty() const CV_OVERRIDE {
        return maceFilter.empty() || IMGSIZE == 0;
    }
-    String  getDefaultName () const {
+    String  getDefaultName () const CV_OVERRIDE {
        return String("MACE");
    }
-    void clear() {
+    void clear() CV_OVERRIDE {
        maceFilter.release();
        convFilter.release();
    }
-    void write(cv::FileStorage &fs) const {
+    void write(cv::FileStorage &fs) const CV_OVERRIDE {
        fs << "mace" << maceFilter;
        fs << "conv" << convFilter;
        fs << "threshold" << threshold;
    }
-    void read(const cv::FileNode &fn) {
+    void read(const cv::FileNode &fn) CV_OVERRIDE {
        fn["mace"] >> maceFilter;
        fn["conv"] >> convFilter;
        fn["threshold"] >> threshold;
--- a/modules/face/src/regtree.cpp
+++ b/modules/face/src/regtree.cpp
@ -18,7 +18,7 @@ class doSum : public ParallelLoopBody
        sum(sum_)
        {
        }
-        virtual void operator()( const Range& range) const
+        virtual void operator()( const Range& range) const CV_OVERRIDE
        {
            for (int j = range.start; j < range.end; ++j){
                for(unsigned long k=0;k<(*samples)[j].shapeResiduals.size();k++){
@ -38,7 +38,7 @@ class modifySamples : public ParallelLoopBody
        temp(temp_)
        {
        }
-        virtual void operator()( const Range& range) const
+        virtual void operator()( const Range& range) const CV_OVERRIDE
        {
            for (int j = range.start; j < range.end; ++j){
                for(unsigned long k=0;k<(*samples)[j].shapeResiduals.size();k++){
@ -62,7 +62,7 @@ class splitSamples : public ParallelLoopBody
        feats(feats_)
        {
        }
-        virtual void operator()( const Range& range) const
+        virtual void operator()( const Range& range) const CV_OVERRIDE
        {
            for (int i = range.start; i < range.end; ++i){
                for(unsigned long j=0;j<*(num_test_splits);j++){
@ -310,4 +310,4 @@ unsigned long FacemarkKazemiImpl::divideSamples (splitr split,vector<training_sa
    return i;
 }
 }//cv
-}//face
+}//face
--- a/modules/face/src/trainFacemark.cpp
+++ b/modules/face/src/trainFacemark.cpp
@ -18,7 +18,7 @@ class getDiffShape : public ParallelLoopBody
        samples(samples_)
        {
        }
-        virtual void operator()( const cv::Range& range) const
+        virtual void operator()( const cv::Range& range) const CV_OVERRIDE
        {
            for(size_t j = (size_t)range.start; j < (size_t)range.end; ++j){
                (*samples)[j].shapeResiduals.resize((*samples)[j].current_shape.size());
@ -37,7 +37,7 @@ class getRelPixels : public ParallelLoopBody
        object(object_)
        {
        }
-        virtual void operator()( const cv::Range& range) const
+        virtual void operator()( const cv::Range& range) const CV_OVERRIDE
        {
            for (size_t j = (size_t)range.start; j < (size_t)range.end; ++j){
                object.getRelativePixels(((*samples)[j]).current_shape,((*samples)[j]).pixel_coordinates);
@ -345,4 +345,4 @@ bool FacemarkKazemiImpl::training(vector<Mat>& images, vector< vector<Point2f> >
    return true;
 }
 }//cv
-}//face
+}//face
--- a/modules/freetype/src/freetype.cpp
+++ b/modules/freetype/src/freetype.cpp
@ -61,22 +61,22 @@ namespace freetype {

 using namespace std;

-class CV_EXPORTS_W FreeType2Impl : public FreeType2
+class CV_EXPORTS_W FreeType2Impl CV_FINAL : public FreeType2
 {
 public:
    FreeType2Impl();
    ~FreeType2Impl();
-    void loadFontData(String fontFileName, int id) ;
-    void setSplitNumber( int num );
+    void loadFontData(String fontFileName, int id) CV_OVERRIDE;
+    void setSplitNumber( int num ) CV_OVERRIDE;
    void putText(
        InputOutputArray img, const String& text, Point org,
        int fontHeight, Scalar color,
        int thickness, int line_type, bool bottomLeftOrigin
-    );
+    ) CV_OVERRIDE;
    Size getTextSize(
        const String& text, int fontHeight, int thickness,
        CV_OUT int* baseLine
-    );
+    ) CV_OVERRIDE;

 private:
    FT_Library       mLibrary;
--- a/modules/hdf/src/hdf5.cpp
+++ b/modules/hdf/src/hdf5.cpp
@ -43,151 +43,151 @@ namespace cv
 namespace hdf
 {

-class HDF5Impl : public HDF5
+class HDF5Impl CV_FINAL : public HDF5
 {
 public:

    HDF5Impl( const String& HDF5Filename );

-    virtual ~HDF5Impl() { close(); };
+    virtual ~HDF5Impl() CV_OVERRIDE { close(); };

    // close and release
-    virtual void close( );
+    virtual void close( ) CV_OVERRIDE;

    /*
     * h5 generic
     */

    // check if object / link exists
-    virtual bool hlexists( const String& label ) const;
+    virtual bool hlexists( const String& label ) const CV_OVERRIDE;

-    virtual bool atexists(const String& atlabel) const;
-    virtual void atdelete(const String& atlabel);
+    virtual bool atexists(const String& atlabel) const CV_OVERRIDE;
+    virtual void atdelete(const String& atlabel) CV_OVERRIDE;

-    virtual void atwrite(const int value, const String& atlabel);
-    virtual void atread(int* value, const String& atlabel);
+    virtual void atwrite(const int value, const String& atlabel) CV_OVERRIDE;
+    virtual void atread(int* value, const String& atlabel) CV_OVERRIDE;

-    virtual void atwrite(const double value, const String& atlabel);
-    virtual void atread(double* value, const String& atlabel);
+    virtual void atwrite(const double value, const String& atlabel) CV_OVERRIDE;
+    virtual void atread(double* value, const String& atlabel) CV_OVERRIDE;

-    virtual void atwrite(const String& value, const String& atlabel);
-    virtual void atread(String* value, const String& atlabel);
+    virtual void atwrite(const String& value, const String& atlabel) CV_OVERRIDE;
+    virtual void atread(String* value, const String& atlabel) CV_OVERRIDE;

-    virtual void atwrite(InputArray value, const String& atlabel);
-    virtual void atread(OutputArray value, const String& atlabel);
+    virtual void atwrite(InputArray value, const String& atlabel) CV_OVERRIDE;
+    virtual void atread(OutputArray value, const String& atlabel) CV_OVERRIDE;

    /*
     * h5 group
     */

    // create a group
-    virtual void grcreate( const String& grlabel );
+    virtual void grcreate( const String& grlabel ) CV_OVERRIDE;

    /*
     *  cv::Mat
     */

    // get sizes of dataset
-    virtual vector<int> dsgetsize( const String& dslabel, int dims_flag = H5_GETDIMS ) const;
+    virtual vector<int> dsgetsize( const String& dslabel, int dims_flag = H5_GETDIMS ) const CV_OVERRIDE;

    /* get data type of dataset */
-    virtual int dsgettype( const String& dslabel ) const;
+    virtual int dsgettype( const String& dslabel ) const CV_OVERRIDE;

    // overload dscreate() #1
-    virtual void dscreate( const int rows, const int cols, const int type, const String& dslabel ) const;
+    virtual void dscreate( const int rows, const int cols, const int type, const String& dslabel ) const CV_OVERRIDE;

    // overload dscreate() #2
    virtual void dscreate( const int rows, const int cols, const int type, const String& dslabel,
-             const int compresslevel ) const;
+             const int compresslevel ) const CV_OVERRIDE;

    // overload dscreate() #3
    virtual void dscreate( const int rows, const int cols, const int type, const String& dslabel,
-             const int compresslevel, const vector<int>& dims_chunks ) const;
+             const int compresslevel, const vector<int>& dims_chunks ) const CV_OVERRIDE;

    /* create two dimensional single or mutichannel dataset */
    virtual void dscreate( const int rows, const int cols, const int type, const String& dslabel,
-             const int compresslevel, const int* dims_chunks ) const;
+             const int compresslevel, const int* dims_chunks ) const CV_OVERRIDE;

    // overload dscreate() #1
    virtual void dscreate( const int n_dims, const int* sizes, const int type,
-             const String& dslabel ) const;
+             const String& dslabel ) const CV_OVERRIDE;

    // overload dscreate() #2
    virtual void dscreate( const int n_dims, const int* sizes, const int type,
-             const String& dslabel, const int compresslevel ) const;
+             const String& dslabel, const int compresslevel ) const CV_OVERRIDE;

    // overload dscreate() #3
    virtual void dscreate( const vector<int>& sizes, const int type, const String& dslabel,
-             const int compresslevel = H5_NONE, const vector<int>& dims_chunks = vector<int>() ) const;
+             const int compresslevel = H5_NONE, const vector<int>& dims_chunks = vector<int>() ) const CV_OVERRIDE;

    /* create n-dimensional single or mutichannel dataset */
    virtual void dscreate( const int n_dims, const int* sizes, const int type,
-             const String& dslabel, const int compresslevel, const int* dims_chunks ) const;
+             const String& dslabel, const int compresslevel, const int* dims_chunks ) const CV_OVERRIDE;

    // overload dswrite() #1
-    virtual void dswrite( InputArray Array, const String& dslabel ) const;
+    virtual void dswrite( InputArray Array, const String& dslabel ) const CV_OVERRIDE;

    // overload dswrite() #2
-    virtual void dswrite( InputArray Array, const String& dslabel, const int* dims_offset ) const;
+    virtual void dswrite( InputArray Array, const String& dslabel, const int* dims_offset ) const CV_OVERRIDE;

    // overload dswrite() #3
    virtual void dswrite( InputArray Array, const String& dslabel, const vector<int>& dims_offset,
-             const vector<int>& dims_counts = vector<int>() ) const;
+             const vector<int>& dims_counts = vector<int>() ) const CV_OVERRIDE;

    /* write into dataset */
    virtual void dswrite( InputArray Array, const String& dslabel,
-             const int* dims_offset, const int* dims_counts ) const;
+             const int* dims_offset, const int* dims_counts ) const CV_OVERRIDE;

    // overload dsinsert() #1
-    virtual void dsinsert( InputArray Array, const String& dslabel ) const;
+    virtual void dsinsert( InputArray Array, const String& dslabel ) const CV_OVERRIDE;

    // overload dsinsert() #2
-    virtual void dsinsert( InputArray Array, const String& dslabel, const int* dims_offset ) const;
+    virtual void dsinsert( InputArray Array, const String& dslabel, const int* dims_offset ) const CV_OVERRIDE;

    // overload dsinsert() #3
    virtual void dsinsert( InputArray Array, const String& dslabel,
-             const vector<int>& dims_offset, const vector<int>& dims_counts = vector<int>() ) const;
+             const vector<int>& dims_offset, const vector<int>& dims_counts = vector<int>() ) const CV_OVERRIDE;

    /* append / merge into dataset */
    virtual void dsinsert( InputArray Array, const String& dslabel,
-             const int* dims_offset = NULL, const int* dims_counts = NULL ) const;
+             const int* dims_offset = NULL, const int* dims_counts = NULL ) const CV_OVERRIDE;

    // overload dsread() #1
-    virtual void dsread( OutputArray Array, const String& dslabel ) const;
+    virtual void dsread( OutputArray Array, const String& dslabel ) const CV_OVERRIDE;

    // overload dsread() #2
-    virtual void dsread( OutputArray Array, const String& dslabel, const int* dims_offset ) const;
+    virtual void dsread( OutputArray Array, const String& dslabel, const int* dims_offset ) const CV_OVERRIDE;

    // overload dsread() #3
    virtual void dsread( OutputArray Array, const String& dslabel,
-             const vector<int>& dims_offset, const vector<int>& dims_counts = vector<int>() ) const;
+             const vector<int>& dims_offset, const vector<int>& dims_counts = vector<int>() ) const CV_OVERRIDE;

    // read from dataset
    virtual void dsread( OutputArray Array, const String& dslabel,
-             const int* dims_offset, const int* dims_counts ) const;
+             const int* dims_offset, const int* dims_counts ) const CV_OVERRIDE;

    /*
     *  std::vector<cv::KeyPoint>
     */

    // get size of keypoints dataset
-    virtual int kpgetsize( const String& kplabel, int dims_flag = H5_GETDIMS ) const;
+    virtual int kpgetsize( const String& kplabel, int dims_flag = H5_GETDIMS ) const CV_OVERRIDE;

    // create KeyPoint structure
    virtual void kpcreate( const int size, const String& kplabel,
-             const int compresslevel = H5_NONE, const int chunks = H5_NONE ) const;
+             const int compresslevel = H5_NONE, const int chunks = H5_NONE ) const CV_OVERRIDE;

    // write KeyPoint structures
    virtual void kpwrite( const vector<KeyPoint> keypoints, const String& kplabel,
-             const int offset = H5_NONE, const int counts = H5_NONE ) const;
+             const int offset = H5_NONE, const int counts = H5_NONE ) const CV_OVERRIDE;

    // append / merge KeyPoint structures
    virtual void kpinsert( const vector<KeyPoint> keypoints, const String& kplabel,
-             const int offset = H5_NONE, const int counts = H5_NONE ) const;
+             const int offset = H5_NONE, const int counts = H5_NONE ) const CV_OVERRIDE;

    // read KeyPoint structure
    virtual void kpread( vector<KeyPoint>& keypoints, const String& kplabel,
-             const int offset = H5_NONE, const int counts = H5_NONE ) const;
+             const int offset = H5_NONE, const int counts = H5_NONE ) const CV_OVERRIDE;

 private:

--- a/modules/hfs/src/hfs.cpp
+++ b/modules/hfs/src/hfs.cpp
@ -9,73 +9,73 @@

 namespace cv{ namespace hfs{

-class HfsSegmentImpl : public cv::hfs::HfsSegment{
+class HfsSegmentImpl CV_FINAL : public cv::hfs::HfsSegment{
 public:

-    void setSegEgbThresholdI(float c)
+    void setSegEgbThresholdI(float c) CV_OVERRIDE
    {
        core->hfsSettings.egbThresholdI = c;
    }
-    float getSegEgbThresholdI() {
+    float getSegEgbThresholdI() CV_OVERRIDE {
        return core->hfsSettings.egbThresholdI;
    }


-    void setMinRegionSizeI(int n)
+    void setMinRegionSizeI(int n) CV_OVERRIDE
    {
        core->hfsSettings.minRegionSizeI = n;
    }
-    int getMinRegionSizeI()
+    int getMinRegionSizeI() CV_OVERRIDE
    {
        return core->hfsSettings.minRegionSizeI;
    }

-    void setSegEgbThresholdII(float c)
+    void setSegEgbThresholdII(float c) CV_OVERRIDE
    {
        core->hfsSettings.egbThresholdII = c;
    }
-    float getSegEgbThresholdII() {
+    float getSegEgbThresholdII() CV_OVERRIDE {
        return core->hfsSettings.egbThresholdII;
    }


-    void setMinRegionSizeII(int n)
+    void setMinRegionSizeII(int n) CV_OVERRIDE
    {
        core->hfsSettings.minRegionSizeII = n;
    }
-    int getMinRegionSizeII()
+    int getMinRegionSizeII() CV_OVERRIDE
    {
        return core->hfsSettings.minRegionSizeII;
    }

-    void setSpatialWeight(float w)
+    void setSpatialWeight(float w) CV_OVERRIDE
    {
        core->hfsSettings.slicSettings.coh_weight = w;
        core->reconstructEngine();
    }
-    float getSpatialWeight()
+    float getSpatialWeight() CV_OVERRIDE
    {
        return core->hfsSettings.slicSettings.coh_weight;
    }


-    void setSlicSpixelSize(int n)
+    void setSlicSpixelSize(int n) CV_OVERRIDE
    {
        core->hfsSettings.slicSettings.spixel_size = n;
        core->reconstructEngine();
    }
-    int getSlicSpixelSize()
+    int getSlicSpixelSize() CV_OVERRIDE
    {
        return core->hfsSettings.slicSettings.spixel_size;
    }


-    void setNumSlicIter(int n)
+    void setNumSlicIter(int n) CV_OVERRIDE
    {
        core->hfsSettings.slicSettings.num_iters = n;
        core->reconstructEngine();
    }
-    int getNumSlicIter()
+    int getNumSlicIter() CV_OVERRIDE
    {
        return core->hfsSettings.slicSettings.num_iters;
    }
@ -90,8 +90,8 @@ public:
            spatialWeight, spixelSize, numIter));
    }

-    Mat performSegmentGpu(InputArray src, bool ifDraw = true);
-    Mat performSegmentCpu(InputArray src, bool ifDraw = true);
+    Mat performSegmentGpu(InputArray src, bool ifDraw = true) CV_OVERRIDE;
+    Mat performSegmentCpu(InputArray src, bool ifDraw = true) CV_OVERRIDE;
 private:
    Ptr<HfsCore> core;
 };
--- a/modules/img_hash/src/average_hash.cpp
+++ b/modules/img_hash/src/average_hash.cpp
@ -10,7 +10,7 @@ using namespace img_hash;

 namespace {

-class AverageHashImpl : public ImgHashBase::ImgHashImpl
+class AverageHashImpl CV_FINAL : public ImgHashBase::ImgHashImpl
 {
 private:
    cv::Mat bitsImg;
@ -19,7 +19,7 @@ private:

 public:

-    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr)
+    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) CV_OVERRIDE
    {
        cv::Mat const input = inputArr.getMat();
        CV_Assert(input.type() == CV_8UC4 ||
@ -59,7 +59,7 @@ public:
        }
    }

-    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const
+    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const CV_OVERRIDE
    {
        return norm(hashOne, hashTwo, NORM_HAMMING);
    }
--- a/modules/img_hash/src/block_mean_hash.cpp
+++ b/modules/img_hash/src/block_mean_hash.cpp
@ -22,7 +22,7 @@ enum
    colSize = imgWidth - blockWidth
 };

-class BlockMeanHashImpl : public ImgHashBase::ImgHashImpl
+class BlockMeanHashImpl CV_FINAL : public ImgHashBase::ImgHashImpl
 {
 public:
    BlockMeanHashImpl(int mode)
@ -30,9 +30,9 @@ public:
        setMode(mode);
    }

-    ~BlockMeanHashImpl() {}
+    ~BlockMeanHashImpl() CV_OVERRIDE {}

-    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr)
+    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) CV_OVERRIDE
    {
        cv::Mat const input = inputArr.getMat();
        CV_Assert(input.type() == CV_8UC4 ||
@ -81,7 +81,7 @@ public:
        createHash(hash);
    }

-    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const
+    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const CV_OVERRIDE
    {
        return norm(hashOne, hashTwo, NORM_HAMMING);
    }
--- a/modules/img_hash/src/color_moment_hash.cpp
+++ b/modules/img_hash/src/color_moment_hash.cpp
@ -10,12 +10,12 @@ using namespace std;

 namespace {

-class ColorMomentHashImpl : public ImgHashBase::ImgHashImpl
+class ColorMomentHashImpl CV_FINAL : public ImgHashBase::ImgHashImpl
 {
 public:
-    ~ColorMomentHashImpl() {}
+    ~ColorMomentHashImpl() CV_OVERRIDE {}

-    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr)
+    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) CV_OVERRIDE
    {
      cv::Mat const input = inputArr.getMat();
      CV_Assert(input.type() == CV_8UC4 ||
@ -51,7 +51,7 @@ public:
      computeMoments(hash.ptr<double>(0) + 21);
    }

-    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const
+    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const CV_OVERRIDE
    {
      return norm(hashOne, hashTwo, NORM_L2) * 10000;
    }
--- a/modules/img_hash/src/marr_hildreth_hash.cpp
+++ b/modules/img_hash/src/marr_hildreth_hash.cpp
@ -86,7 +86,7 @@ void createHash(cv::Mat const &blocks, cv::Mat &hash)
    }
 }

-class MarrHildrethHashImpl : public ImgHashBase::ImgHashImpl
+class MarrHildrethHashImpl CV_FINAL : public ImgHashBase::ImgHashImpl
 {
 public:

@ -96,9 +96,9 @@ public:
        blocks.create(31,31, CV_32F);
    }

-    ~MarrHildrethHashImpl() { }
+    ~MarrHildrethHashImpl() CV_OVERRIDE { }

-    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr)
+    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) CV_OVERRIDE
    {
        cv::Mat const input = inputArr.getMat();
        CV_Assert(input.type() == CV_8UC4 ||
@ -131,7 +131,7 @@ public:
        createHash(blocks, hash);
    }

-    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const
+    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const CV_OVERRIDE
    {
        return norm(hashOne, hashTwo, NORM_HAMMING);
    }
--- a/modules/img_hash/src/phash.cpp
+++ b/modules/img_hash/src/phash.cpp
@ -10,10 +10,10 @@ using namespace std;

 namespace {

-class PHashImpl : public ImgHashBase::ImgHashImpl
+class PHashImpl CV_FINAL : public ImgHashBase::ImgHashImpl
 {
 public:
-    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr)
+    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) CV_OVERRIDE
    {
        cv::Mat const input = inputArr.getMat();
        CV_Assert(input.type() == CV_8UC4 ||
@ -58,7 +58,7 @@ public:
        }
    }

-    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const
+    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const CV_OVERRIDE
    {
        return norm(hashOne, hashTwo, NORM_HAMMING);
    }
--- a/modules/img_hash/src/radial_variance_hash.cpp
+++ b/modules/img_hash/src/radial_variance_hash.cpp
@ -26,7 +26,7 @@ inline int createOffSet(int length)
    return static_cast<int>(std::floor(center + roundingFactor(center)));
 }

-class RadialVarianceHashImpl : public ImgHashBase::ImgHashImpl
+class RadialVarianceHashImpl CV_FINAL : public ImgHashBase::ImgHashImpl
 {
 public:
    cv::Mat blurImg_;
@ -42,9 +42,9 @@ public:
    {
    }

-    ~RadialVarianceHashImpl() {}
+    ~RadialVarianceHashImpl() CV_OVERRIDE {}

-    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr)
+    virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) CV_OVERRIDE
    {
        cv::Mat const input = inputArr.getMat();
        CV_Assert(input.type() == CV_8UC4 ||
@ -72,7 +72,7 @@ public:
        hashCalculate(hash);
    }

-    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const
+    virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const CV_OVERRIDE
    {
        cv::Mat const hashOneF = hashOne.getMat();
        cv::Mat const hashTwoF = hashTwo.getMat();
--- a/Show More
+++ b/Show More