ml: apply CV_OVERRIDE/CV_FINAL

modules/ml/include/opencv2/ml.hpp

@@ -318,7 +318,7 @@ public:
     /** @brief Returns the number of variables in training samples */
     CV_WRAP virtual int getVarCount() const = 0;
 
-    CV_WRAP virtual bool empty() const;
+    CV_WRAP virtual bool empty() const CV_OVERRIDE;
 
     /** @brief Returns true if the model is trained */
     CV_WRAP virtual bool isTrained() const = 0;
@@ -894,7 +894,7 @@ public:
     posterior probabilities for each sample from the input
     @param flags This parameter will be ignored
      */
-    CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const = 0;
+    CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const CV_OVERRIDE = 0;
 
     /** @brief Returns a likelihood logarithm value and an index of the most probable mixture component
     for the given sample.
@@ -1656,7 +1656,7 @@ public:
     @param results Predicted labels as a column matrix of type CV_32S.
     @param flags Not used.
      */
-    CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const = 0;
+    CV_WRAP virtual float predict( InputArray samples, OutputArray results=noArray(), int flags=0 ) const CV_OVERRIDE = 0;
 
     /** @brief This function returns the trained parameters arranged across rows.
 

modules/ml/src/ann_mlp.cpp

@@ -213,7 +213,7 @@ void ANN_MLP::setAnnealEnergyRNG(const RNG& rng)
     this_->setAnnealEnergyRNG(rng);
 }
 
-class ANN_MLPImpl : public ANN_MLP_ANNEAL
+class ANN_MLPImpl CV_FINAL : public ANN_MLP_ANNEAL
 {
 public:
     ANN_MLPImpl()
@@ -226,23 +226,34 @@ public:
 
     virtual ~ANN_MLPImpl() {}
 
-    CV_IMPL_PROPERTY(TermCriteria, TermCriteria, params.termCrit)
-    CV_IMPL_PROPERTY(double, BackpropWeightScale, params.bpDWScale)
-    CV_IMPL_PROPERTY(double, BackpropMomentumScale, params.bpMomentScale)
-    CV_IMPL_PROPERTY(double, RpropDW0, params.rpDW0)
-    CV_IMPL_PROPERTY(double, RpropDWPlus, params.rpDWPlus)
-    CV_IMPL_PROPERTY(double, RpropDWMinus, params.rpDWMinus)
-    CV_IMPL_PROPERTY(double, RpropDWMin, params.rpDWMin)
-    CV_IMPL_PROPERTY(double, RpropDWMax, params.rpDWMax)
-    CV_IMPL_PROPERTY(double, AnnealInitialT, params.initialT)
-    CV_IMPL_PROPERTY(double, AnnealFinalT, params.finalT)
-    CV_IMPL_PROPERTY(double, AnnealCoolingRatio, params.coolingRatio)
-    CV_IMPL_PROPERTY(int, AnnealItePerStep, params.itePerStep)
-
-    //CV_IMPL_PROPERTY(RNG, AnnealEnergyRNG, params.rEnergy)
-    inline void setAnnealEnergyRNG(const RNG& val) { params.rEnergy = val; }
-
-    void clear()
+    inline TermCriteria getTermCriteria() const CV_OVERRIDE { return params.termCrit; }
+    inline void setTermCriteria(TermCriteria val) CV_OVERRIDE { params.termCrit = val; }
+    inline double getBackpropWeightScale() const CV_OVERRIDE { return params.bpDWScale; }
+    inline void setBackpropWeightScale(double val) CV_OVERRIDE { params.bpDWScale = val; }
+    inline double getBackpropMomentumScale() const CV_OVERRIDE { return params.bpMomentScale; }
+    inline void setBackpropMomentumScale(double val) CV_OVERRIDE { params.bpMomentScale = val; }
+    inline double getRpropDW0() const CV_OVERRIDE { return params.rpDW0; }
+    inline void setRpropDW0(double val) CV_OVERRIDE { params.rpDW0 = val; }
+    inline double getRpropDWPlus() const CV_OVERRIDE { return params.rpDWPlus; }
+    inline void setRpropDWPlus(double val) CV_OVERRIDE { params.rpDWPlus = val; }
+    inline double getRpropDWMinus() const CV_OVERRIDE { return params.rpDWMinus; }
+    inline void setRpropDWMinus(double val) CV_OVERRIDE { params.rpDWMinus = val; }
+    inline double getRpropDWMin() const CV_OVERRIDE { return params.rpDWMin; }
+    inline void setRpropDWMin(double val) CV_OVERRIDE { params.rpDWMin = val; }
+    inline double getRpropDWMax() const CV_OVERRIDE { return params.rpDWMax; }
+    inline void setRpropDWMax(double val) CV_OVERRIDE { params.rpDWMax = val; }
+    inline double getAnnealInitialT() const CV_OVERRIDE { return params.initialT; }
+    inline void setAnnealInitialT(double val) CV_OVERRIDE { params.initialT = val; }
+    inline double getAnnealFinalT() const CV_OVERRIDE { return params.finalT; }
+    inline void setAnnealFinalT(double val) CV_OVERRIDE { params.finalT = val; }
+    inline double getAnnealCoolingRatio() const CV_OVERRIDE { return params.coolingRatio; }
+    inline void setAnnealCoolingRatio(double val) CV_OVERRIDE { params.coolingRatio = val; }
+    inline int getAnnealItePerStep() const CV_OVERRIDE { return params.itePerStep; }
+    inline void setAnnealItePerStep(int val) CV_OVERRIDE { params.itePerStep = val; }
+    // disabled getAnnealEnergyRNG()
+    inline void setAnnealEnergyRNG(const RNG& val) CV_OVERRIDE { params.rEnergy = val; }
+
+    void clear() CV_OVERRIDE
     {
         min_val = max_val = min_val1 = max_val1 = 0.;
         rng = RNG((uint64)-1);
@@ -253,7 +264,7 @@ public:
 
     int layer_count() const { return (int)layer_sizes.size(); }
 
-    void setTrainMethod(int method, double param1, double param2)
+    void setTrainMethod(int method, double param1, double param2) CV_OVERRIDE
     {
         if (method != ANN_MLP::RPROP && method != ANN_MLP::BACKPROP && method != ANN_MLP::ANNEAL)
             method = ANN_MLP::RPROP;
@@ -276,12 +287,12 @@ public:
         }
     }
 
-    int getTrainMethod() const
+    int getTrainMethod() const CV_OVERRIDE
     {
         return params.trainMethod;
     }
 
-    void setActivationFunction(int _activ_func, double _f_param1, double _f_param2)
+    void setActivationFunction(int _activ_func, double _f_param1, double _f_param2) CV_OVERRIDE
     {
         if( _activ_func < 0 || _activ_func > LEAKYRELU)
             CV_Error( CV_StsOutOfRange, "Unknown activation function" );
@@ -362,12 +373,12 @@ public:
         }
     }
 
-    Mat getLayerSizes() const
+    Mat getLayerSizes() const CV_OVERRIDE
     {
         return Mat_<int>(layer_sizes, true);
     }
 
-    void setLayerSizes( InputArray _layer_sizes )
+    void setLayerSizes( InputArray _layer_sizes ) CV_OVERRIDE
     {
         clear();
 
@@ -399,7 +410,7 @@ public:
         }
     }
 
-    float predict( InputArray _inputs, OutputArray _outputs, int ) const
+    float predict( InputArray _inputs, OutputArray _outputs, int ) const CV_OVERRIDE
     {
         if( !trained )
             CV_Error( CV_StsError, "The network has not been trained or loaded" );
@@ -907,7 +918,7 @@ public:
         calc_output_scale( outputs, flags );
     }
 
-    bool train( const Ptr<TrainData>& trainData, int flags )
+    bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         const int MAX_ITER = 1000;
         const double DEFAULT_EPSILON = FLT_EPSILON;
@@ -1108,7 +1119,7 @@ public:
         int dcount0;
         double* pE;
 
-        void operator()( const Range& range ) const
+        void operator()(const Range& range) const CV_OVERRIDE
         {
             double inv_count = 1./inputs.rows;
             int ivcount = ann->layer_sizes.front();
@@ -1392,7 +1403,7 @@ public:
         fs << "}" << "}";
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         if( layer_sizes.empty() )
             return;
@@ -1502,7 +1513,7 @@ public:
         }
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         clear();
 
@@ -1531,28 +1542,28 @@ public:
         trained = true;
     }
 
-    Mat getWeights(int layerIdx) const
+    Mat getWeights(int layerIdx) const CV_OVERRIDE
     {
         CV_Assert( 0 <= layerIdx && layerIdx < (int)weights.size() );
         return weights[layerIdx];
     }
 
-    bool isTrained() const
+    bool isTrained() const CV_OVERRIDE
     {
         return trained;
     }
 
-    bool isClassifier() const
+    bool isClassifier() const CV_OVERRIDE
     {
         return false;
     }
 
-    int getVarCount() const
+    int getVarCount() const CV_OVERRIDE
     {
         return layer_sizes.empty() ? 0 : layer_sizes[0];
     }
 
-    String getDefaultName() const
+    String getDefaultName() const CV_OVERRIDE
     {
         return "opencv_ml_ann_mlp";
     }

modules/ml/src/boost.cpp

@@ -69,7 +69,7 @@ BoostTreeParams::BoostTreeParams( int _boostType, int _weak_count,
     weightTrimRate = _weightTrimRate;
 }
 
-class DTreesImplForBoost : public DTreesImpl
+class DTreesImplForBoost CV_FINAL : public DTreesImpl
 {
 public:
     DTreesImplForBoost()
@@ -79,14 +79,14 @@ public:
     }
     virtual ~DTreesImplForBoost() {}
 
-    bool isClassifier() const { return true; }
+    bool isClassifier() const CV_OVERRIDE { return true; }
 
-    void clear()
+    void clear() CV_OVERRIDE
     {
         DTreesImpl::clear();
     }
 
-    void startTraining( const Ptr<TrainData>& trainData, int flags )
+    void startTraining( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         DTreesImpl::startTraining(trainData, flags);
         sumResult.assign(w->sidx.size(), 0.);
@@ -132,7 +132,7 @@ public:
         }
     }
 
-    void endTraining()
+    void endTraining() CV_OVERRIDE
     {
         DTreesImpl::endTraining();
         vector<double> e;
@@ -167,7 +167,7 @@ public:
         }
     }
 
-    void calcValue( int nidx, const vector<int>& _sidx )
+    void calcValue( int nidx, const vector<int>& _sidx ) CV_OVERRIDE
     {
         DTreesImpl::calcValue(nidx, _sidx);
         WNode* node = &w->wnodes[nidx];
@@ -182,7 +182,7 @@ public:
         }
     }
 
-    bool train( const Ptr<TrainData>& trainData, int flags )
+    bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         startTraining(trainData, flags);
         int treeidx, ntrees = bparams.weakCount >= 0 ? bparams.weakCount : 10000;
@@ -356,7 +356,7 @@ public:
         }
     }
 
-    float predictTrees( const Range& range, const Mat& sample, int flags0 ) const
+    float predictTrees( const Range& range, const Mat& sample, int flags0 ) const CV_OVERRIDE
     {
         int flags = (flags0 & ~PREDICT_MASK) | PREDICT_SUM;
         float val = DTreesImpl::predictTrees(range, sample, flags);
@@ -370,7 +370,7 @@ public:
         return val;
     }
 
-    void writeTrainingParams( FileStorage& fs ) const
+    void writeTrainingParams( FileStorage& fs ) const CV_OVERRIDE
     {
         fs << "boosting_type" <<
         (bparams.boostType == Boost::DISCRETE ? "DiscreteAdaboost" :
@@ -382,7 +382,7 @@ public:
         fs << "weight_trimming_rate" << bparams.weightTrimRate;
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         if( roots.empty() )
             CV_Error( CV_StsBadArg, "RTrees have not been trained" );
@@ -405,7 +405,7 @@ public:
         fs << "]";
     }
 
-    void readParams( const FileNode& fn )
+    void readParams( const FileNode& fn ) CV_OVERRIDE
     {
         DTreesImpl::readParams(fn);
 
@@ -423,7 +423,7 @@ public:
                                     tparams_node["weight_trimming_rate"] : fn["weight_trimming_rate"]);
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         clear();
 
@@ -452,51 +452,63 @@ public:
     BoostImpl() {}
     virtual ~BoostImpl() {}
 
-    CV_IMPL_PROPERTY(int, BoostType, impl.bparams.boostType)
-    CV_IMPL_PROPERTY(int, WeakCount, impl.bparams.weakCount)
-    CV_IMPL_PROPERTY(double, WeightTrimRate, impl.bparams.weightTrimRate)
-
-    CV_WRAP_SAME_PROPERTY(int, MaxCategories, impl.params)
-    CV_WRAP_SAME_PROPERTY(int, MaxDepth, impl.params)
-    CV_WRAP_SAME_PROPERTY(int, MinSampleCount, impl.params)
-    CV_WRAP_SAME_PROPERTY(int, CVFolds, impl.params)
-    CV_WRAP_SAME_PROPERTY(bool, UseSurrogates, impl.params)
-    CV_WRAP_SAME_PROPERTY(bool, Use1SERule, impl.params)
-    CV_WRAP_SAME_PROPERTY(bool, TruncatePrunedTree, impl.params)
-    CV_WRAP_SAME_PROPERTY(float, RegressionAccuracy, impl.params)
-    CV_WRAP_SAME_PROPERTY_S(cv::Mat, Priors, impl.params)
-
-    String getDefaultName() const { return "opencv_ml_boost"; }
-
-    bool train( const Ptr<TrainData>& trainData, int flags )
+    inline int getBoostType() const CV_OVERRIDE { return impl.bparams.boostType; }
+    inline void setBoostType(int val) CV_OVERRIDE { impl.bparams.boostType = val; }
+    inline int getWeakCount() const CV_OVERRIDE { return impl.bparams.weakCount; }
+    inline void setWeakCount(int val) CV_OVERRIDE { impl.bparams.weakCount = val; }
+    inline double getWeightTrimRate() const CV_OVERRIDE { return impl.bparams.weightTrimRate; }
+    inline void setWeightTrimRate(double val) CV_OVERRIDE { impl.bparams.weightTrimRate = val; }
+
+    inline int getMaxCategories() const CV_OVERRIDE { return impl.params.getMaxCategories(); }
+    inline void setMaxCategories(int val) CV_OVERRIDE { impl.params.setMaxCategories(val); }
+    inline int getMaxDepth() const CV_OVERRIDE { return impl.params.getMaxDepth(); }
+    inline void setMaxDepth(int val) CV_OVERRIDE { impl.params.setMaxDepth(val); }
+    inline int getMinSampleCount() const CV_OVERRIDE { return impl.params.getMinSampleCount(); }
+    inline void setMinSampleCount(int val) CV_OVERRIDE { impl.params.setMinSampleCount(val); }
+    inline int getCVFolds() const CV_OVERRIDE { return impl.params.getCVFolds(); }
+    inline void setCVFolds(int val) CV_OVERRIDE { impl.params.setCVFolds(val); }
+    inline bool getUseSurrogates() const CV_OVERRIDE { return impl.params.getUseSurrogates(); }
+    inline void setUseSurrogates(bool val) CV_OVERRIDE { impl.params.setUseSurrogates(val); }
+    inline bool getUse1SERule() const CV_OVERRIDE { return impl.params.getUse1SERule(); }
+    inline void setUse1SERule(bool val) CV_OVERRIDE { impl.params.setUse1SERule(val); }
+    inline bool getTruncatePrunedTree() const CV_OVERRIDE { return impl.params.getTruncatePrunedTree(); }
+    inline void setTruncatePrunedTree(bool val) CV_OVERRIDE { impl.params.setTruncatePrunedTree(val); }
+    inline float getRegressionAccuracy() const CV_OVERRIDE { return impl.params.getRegressionAccuracy(); }
+    inline void setRegressionAccuracy(float val) CV_OVERRIDE { impl.params.setRegressionAccuracy(val); }
+    inline cv::Mat getPriors() const CV_OVERRIDE { return impl.params.getPriors(); }
+    inline void setPriors(const cv::Mat& val) CV_OVERRIDE { impl.params.setPriors(val); }
+
+    String getDefaultName() const CV_OVERRIDE { return "opencv_ml_boost"; }
+
+    bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         return impl.train(trainData, flags);
     }
 
-    float predict( InputArray samples, OutputArray results, int flags ) const
+    float predict( InputArray samples, OutputArray results, int flags ) const CV_OVERRIDE
     {
         return impl.predict(samples, results, flags);
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         impl.write(fs);
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         impl.read(fn);
     }
 
-    int getVarCount() const { return impl.getVarCount(); }
+    int getVarCount() const CV_OVERRIDE { return impl.getVarCount(); }
 
-    bool isTrained() const { return impl.isTrained(); }
-    bool isClassifier() const { return impl.isClassifier(); }
+    bool isTrained() const CV_OVERRIDE { return impl.isTrained(); }
+    bool isClassifier() const CV_OVERRIDE { return impl.isClassifier(); }
 
-    const vector<int>& getRoots() const { return impl.getRoots(); }
-    const vector<Node>& getNodes() const { return impl.getNodes(); }
-    const vector<Split>& getSplits() const { return impl.getSplits(); }
-    const vector<int>& getSubsets() const { return impl.getSubsets(); }
+    const vector<int>& getRoots() const CV_OVERRIDE { return impl.getRoots(); }
+    const vector<Node>& getNodes() const CV_OVERRIDE { return impl.getNodes(); }
+    const vector<Split>& getSplits() const CV_OVERRIDE { return impl.getSplits(); }
+    const vector<int>& getSubsets() const CV_OVERRIDE { return impl.getSubsets(); }
 
     DTreesImplForBoost impl;
 };

modules/ml/src/data.cpp

@@ -119,7 +119,7 @@ Mat TrainData::getSubVector(const Mat& vec, const Mat& idx)
     return subvec;
 }
 
-class TrainDataImpl : public TrainData
+class TrainDataImpl CV_FINAL : public TrainData
 {
 public:
     typedef std::map<String, int> MapType;
@@ -132,75 +132,75 @@ public:
 
     virtual ~TrainDataImpl() { closeFile(); }
 
-    int getLayout() const { return layout; }
-    int getNSamples() const
+    int getLayout() const CV_OVERRIDE { return layout; }
+    int getNSamples() const CV_OVERRIDE
     {
         return !sampleIdx.empty() ? (int)sampleIdx.total() :
                layout == ROW_SAMPLE ? samples.rows : samples.cols;
     }
-    int getNTrainSamples() const
+    int getNTrainSamples() const CV_OVERRIDE
     {
         return !trainSampleIdx.empty() ? (int)trainSampleIdx.total() : getNSamples();
     }
-    int getNTestSamples() const
+    int getNTestSamples() const CV_OVERRIDE
     {
         return !testSampleIdx.empty() ? (int)testSampleIdx.total() : 0;
     }
-    int getNVars() const
+    int getNVars() const CV_OVERRIDE
     {
         return !varIdx.empty() ? (int)varIdx.total() : getNAllVars();
     }
-    int getNAllVars() const
+    int getNAllVars() const CV_OVERRIDE
     {
         return layout == ROW_SAMPLE ? samples.cols : samples.rows;
     }
 
-    Mat getSamples() const { return samples; }
-    Mat getResponses() const { return responses; }
-    Mat getMissing() const { return missing; }
-    Mat getVarIdx() const { return varIdx; }
-    Mat getVarType() const { return varType; }
-    int getResponseType() const
+    Mat getSamples() const CV_OVERRIDE { return samples; }
+    Mat getResponses() const CV_OVERRIDE { return responses; }
+    Mat getMissing() const CV_OVERRIDE { return missing; }
+    Mat getVarIdx() const CV_OVERRIDE { return varIdx; }
+    Mat getVarType() const CV_OVERRIDE { return varType; }
+    int getResponseType() const CV_OVERRIDE
     {
         return classLabels.empty() ? VAR_ORDERED : VAR_CATEGORICAL;
     }
-    Mat getTrainSampleIdx() const { return !trainSampleIdx.empty() ? trainSampleIdx : sampleIdx; }
-    Mat getTestSampleIdx() const { return testSampleIdx; }
-    Mat getSampleWeights() const
+    Mat getTrainSampleIdx() const CV_OVERRIDE { return !trainSampleIdx.empty() ? trainSampleIdx : sampleIdx; }
+    Mat getTestSampleIdx() const CV_OVERRIDE { return testSampleIdx; }
+    Mat getSampleWeights() const CV_OVERRIDE
     {
         return sampleWeights;
     }
-    Mat getTrainSampleWeights() const
+    Mat getTrainSampleWeights() const CV_OVERRIDE
     {
         return getSubVector(sampleWeights, getTrainSampleIdx());
     }
-    Mat getTestSampleWeights() const
+    Mat getTestSampleWeights() const CV_OVERRIDE
     {
         Mat idx = getTestSampleIdx();
         return idx.empty() ? Mat() : getSubVector(sampleWeights, idx);
     }
-    Mat getTrainResponses() const
+    Mat getTrainResponses() const CV_OVERRIDE
     {
         return getSubVector(responses, getTrainSampleIdx());
     }
-    Mat getTrainNormCatResponses() const
+    Mat getTrainNormCatResponses() const CV_OVERRIDE
     {
         return getSubVector(normCatResponses, getTrainSampleIdx());
     }
-    Mat getTestResponses() const
+    Mat getTestResponses() const CV_OVERRIDE
     {
         Mat idx = getTestSampleIdx();
         return idx.empty() ? Mat() : getSubVector(responses, idx);
     }
-    Mat getTestNormCatResponses() const
+    Mat getTestNormCatResponses() const CV_OVERRIDE
     {
         Mat idx = getTestSampleIdx();
         return idx.empty() ? Mat() : getSubVector(normCatResponses, idx);
     }
-    Mat getNormCatResponses() const { return normCatResponses; }
-    Mat getClassLabels() const { return classLabels; }
+    Mat getNormCatResponses() const CV_OVERRIDE { return normCatResponses; }
+    Mat getClassLabels() const CV_OVERRIDE { return classLabels; }
     Mat getClassCounters() const { return classCounters; }
-    int getCatCount(int vi) const
+    int getCatCount(int vi) const CV_OVERRIDE
     {
         int n = (int)catOfs.total();
         CV_Assert( 0 <= vi && vi < n );
@@ -208,10 +208,10 @@ public:
         return ofs[1] - ofs[0];
     }
 
-    Mat getCatOfs() const { return catOfs; }
-    Mat getCatMap() const { return catMap; }
+    Mat getCatOfs() const CV_OVERRIDE { return catOfs; }
+    Mat getCatMap() const CV_OVERRIDE { return catMap; }
 
-    Mat getDefaultSubstValues() const { return missingSubst; }
+    Mat getDefaultSubstValues() const CV_OVERRIDE { return missingSubst; }
 
     void closeFile() { if(file) fclose(file); file=0; }
     void clear()
@@ -767,13 +767,13 @@ public:
             CV_Error( CV_StsBadArg, "type of some variables is not specified" );
     }
 
-    void setTrainTestSplitRatio(double ratio, bool shuffle)
+    void setTrainTestSplitRatio(double ratio, bool shuffle) CV_OVERRIDE
     {
         CV_Assert( 0. <= ratio && ratio <= 1. );
         setTrainTestSplit(cvRound(getNSamples()*ratio), shuffle);
     }
 
-    void setTrainTestSplit(int count, bool shuffle)
+    void setTrainTestSplit(int count, bool shuffle) CV_OVERRIDE
     {
         int i, nsamples = getNSamples();
         CV_Assert( 0 <= count && count < nsamples );
@@ -810,7 +810,7 @@ public:
         }
     }
 
-    void shuffleTrainTest()
+    void shuffleTrainTest() CV_OVERRIDE
     {
         if( !trainSampleIdx.empty() && !testSampleIdx.empty() )
         {
@@ -844,7 +844,7 @@ public:
 
     Mat getTrainSamples(int _layout,
                         bool compressSamples,
-                        bool compressVars) const
+                        bool compressVars) const CV_OVERRIDE
     {
         if( samples.empty() )
             return samples;
@@ -884,7 +884,7 @@ public:
         return dsamples;
     }
 
-    void getValues( int vi, InputArray _sidx, float* values ) const
+    void getValues( int vi, InputArray _sidx, float* values ) const CV_OVERRIDE
     {
         Mat sidx = _sidx.getMat();
         int i, n = sidx.checkVector(1, CV_32S), nsamples = getNSamples();
@@ -914,7 +914,7 @@ public:
         }
     }
 
-    void getNormCatValues( int vi, InputArray _sidx, int* values ) const
+    void getNormCatValues( int vi, InputArray _sidx, int* values ) const CV_OVERRIDE
     {
         float* fvalues = (float*)values;
         getValues(vi, _sidx, fvalues);
@@ -960,7 +960,7 @@ public:
         }
     }
 
-    void getSample(InputArray _vidx, int sidx, float* buf) const
+    void getSample(InputArray _vidx, int sidx, float* buf) const CV_OVERRIDE
     {
         CV_Assert(buf != 0 && 0 <= sidx && sidx < getNSamples());
         Mat vidx = _vidx.getMat();

modules/ml/src/em.cpp

@@ -48,7 +48,7 @@ namespace ml
 
 const double minEigenValue = DBL_EPSILON;
 
-class CV_EXPORTS EMImpl : public EM
+class CV_EXPORTS EMImpl CV_FINAL : public EM
 {
 public:
 
@@ -56,20 +56,21 @@ public:
     int covMatType;
     TermCriteria termCrit;
 
-    CV_IMPL_PROPERTY_S(TermCriteria, TermCriteria, termCrit)
+    inline TermCriteria getTermCriteria() const CV_OVERRIDE { return termCrit; }
+    inline void setTermCriteria(const TermCriteria& val) CV_OVERRIDE { termCrit = val; }
 
-    void setClustersNumber(int val)
+    void setClustersNumber(int val) CV_OVERRIDE
     {
         nclusters = val;
         CV_Assert(nclusters >= 1);
     }
 
-    int getClustersNumber() const
+    int getClustersNumber() const CV_OVERRIDE
     {
         return nclusters;
     }
 
-    void setCovarianceMatrixType(int val)
+    void setCovarianceMatrixType(int val) CV_OVERRIDE
     {
         covMatType = val;
         CV_Assert(covMatType == COV_MAT_SPHERICAL ||
@@ -77,7 +78,7 @@ public:
                   covMatType == COV_MAT_GENERIC);
     }
 
-    int getCovarianceMatrixType() const
+    int getCovarianceMatrixType() const CV_OVERRIDE
     {
         return covMatType;
     }
@@ -91,7 +92,7 @@ public:
 
     virtual ~EMImpl() {}
 
-    void clear()
+    void clear() CV_OVERRIDE
     {
         trainSamples.release();
         trainProbs.release();
@@ -109,7 +110,7 @@ public:
         logWeightDivDet.release();
     }
 
-    bool train(const Ptr<TrainData>& data, int)
+    bool train(const Ptr<TrainData>& data, int) CV_OVERRIDE
     {
         Mat samples = data->getTrainSamples(), labels;
         return trainEM(samples, labels, noArray(), noArray());
@@ -118,7 +119,7 @@ public:
     bool trainEM(InputArray samples,
                OutputArray logLikelihoods,
                OutputArray labels,
-               OutputArray probs)
+               OutputArray probs) CV_OVERRIDE
     {
         Mat samplesMat = samples.getMat();
         setTrainData(START_AUTO_STEP, samplesMat, 0, 0, 0, 0);
@@ -131,7 +132,7 @@ public:
                 InputArray _weights0,
                 OutputArray logLikelihoods,
                 OutputArray labels,
-                OutputArray probs)
+                OutputArray probs) CV_OVERRIDE
     {
         Mat samplesMat = samples.getMat();
         std::vector<Mat> covs0;
@@ -148,7 +149,7 @@ public:
                 InputArray _probs0,
                 OutputArray logLikelihoods,
                 OutputArray labels,
-                OutputArray probs)
+                OutputArray probs) CV_OVERRIDE
     {
         Mat samplesMat = samples.getMat();
         Mat probs0 = _probs0.getMat();
@@ -157,7 +158,7 @@ public:
         return doTrain(START_M_STEP, logLikelihoods, labels, probs);
     }
 
-    float predict(InputArray _inputs, OutputArray _outputs, int) const
+    float predict(InputArray _inputs, OutputArray _outputs, int) const CV_OVERRIDE
     {
         bool needprobs = _outputs.needed();
         Mat samples = _inputs.getMat(), probs, probsrow;
@@ -186,7 +187,7 @@ public:
         return firstres;
     }
 
-    Vec2d predict2(InputArray _sample, OutputArray _probs) const
+    Vec2d predict2(InputArray _sample, OutputArray _probs) const CV_OVERRIDE
     {
         int ptype = CV_64F;
         Mat sample = _sample.getMat();
@@ -213,22 +214,22 @@ public:
         return computeProbabilities(sample, !probs.empty() ? &probs : 0, ptype);
     }
 
-    bool isTrained() const
+    bool isTrained() const CV_OVERRIDE
     {
         return !means.empty();
     }
 
-    bool isClassifier() const
+    bool isClassifier() const CV_OVERRIDE
     {
         return true;
     }
 
-    int getVarCount() const
+    int getVarCount() const CV_OVERRIDE
     {
         return means.cols;
     }
 
-    String getDefaultName() const
+    String getDefaultName() const CV_OVERRIDE
     {
         return "opencv_ml_em";
     }
@@ -768,7 +769,7 @@ public:
         writeTermCrit(fs, termCrit);
     }
 
-    void write(FileStorage& fs) const
+    void write(FileStorage& fs) const CV_OVERRIDE
     {
         writeFormat(fs);
         fs << "training_params" << "{";
@@ -796,7 +797,7 @@ public:
         termCrit = readTermCrit(fn);
     }
 
-    void read(const FileNode& fn)
+    void read(const FileNode& fn) CV_OVERRIDE
     {
         clear();
         read_params(fn["training_params"]);
@@ -816,9 +817,9 @@ public:
         computeLogWeightDivDet();
     }
 
-    Mat getWeights() const { return weights; }
-    Mat getMeans() const { return means; }
-    void getCovs(std::vector<Mat>& _covs) const
+    Mat getWeights() const CV_OVERRIDE { return weights; }
+    Mat getMeans() const CV_OVERRIDE { return means; }
+    void getCovs(std::vector<Mat>& _covs) const CV_OVERRIDE
     {
         _covs.resize(covs.size());
         std::copy(covs.begin(), covs.end(), _covs.begin());

modules/ml/src/inner_functions.cpp

@@ -89,7 +89,7 @@ public:
         errStrip(e)
     {
     }
-    virtual void operator()(const Range& range) const
+    virtual void operator()(const Range& range) const CV_OVERRIDE
     {
         int idxErr = range.start;
         CV_TRACE_FUNCTION_SKIP_NESTED();

modules/ml/src/knearest.cpp

@@ -134,11 +134,11 @@ public:
     Mat responses;
 };
 
-class BruteForceImpl : public Impl
+class BruteForceImpl CV_FINAL : public Impl
 {
 public:
-    String getModelName() const { return NAME_BRUTE_FORCE; }
-    int getType() const { return ml::KNearest::BRUTE_FORCE; }
+    String getModelName() const CV_OVERRIDE { return NAME_BRUTE_FORCE; }
+    int getType() const CV_OVERRIDE { return ml::KNearest::BRUTE_FORCE; }
 
     void findNearestCore( const Mat& _samples, int k0, const Range& range,
                           Mat* results, Mat* neighbor_responses,
@@ -294,7 +294,7 @@ public:
             presult = _presult;
         }
 
-        void operator()( const Range& range ) const
+        void operator()(const Range& range) const CV_OVERRIDE
         {
             int delta = std::min(range.end - range.start, 256);
             for( int start = range.start; start < range.end; start += delta )
@@ -316,7 +316,7 @@ public:
     float findNearest( InputArray _samples, int k,
                        OutputArray _results,
                        OutputArray _neighborResponses,
-                       OutputArray _dists ) const
+                       OutputArray _dists ) const CV_OVERRIDE
     {
         float result = 0.f;
         CV_Assert( 0 < k );
@@ -358,13 +358,13 @@ public:
 };
 
 
-class KDTreeImpl : public Impl
+class KDTreeImpl CV_FINAL : public Impl
 {
 public:
-    String getModelName() const { return NAME_KDTREE; }
-    int getType() const { return ml::KNearest::KDTREE; }
+    String getModelName() const CV_OVERRIDE { return NAME_KDTREE; }
+    int getType() const CV_OVERRIDE { return ml::KNearest::KDTREE; }
 
-    void doTrain(InputArray points)
+    void doTrain(InputArray points) CV_OVERRIDE
     {
         tr.build(points);
     }
@@ -372,7 +372,7 @@ public:
     float findNearest( InputArray _samples, int k,
                        OutputArray _results,
                        OutputArray _neighborResponses,
-                       OutputArray _dists ) const
+                       OutputArray _dists ) const CV_OVERRIDE
     {
         float result = 0.f;
         CV_Assert( 0 < k );
@@ -432,18 +432,21 @@ public:
 
 //================================================================
 
-class KNearestImpl : public KNearest
+class KNearestImpl CV_FINAL : public KNearest
 {
-    CV_IMPL_PROPERTY(int, DefaultK, impl->defaultK)
-    CV_IMPL_PROPERTY(bool, IsClassifier, impl->isclassifier)
-    CV_IMPL_PROPERTY(int, Emax, impl->Emax)
+    inline int getDefaultK() const CV_OVERRIDE { return impl->defaultK; }
+    inline void setDefaultK(int val) CV_OVERRIDE { impl->defaultK = val; }
+    inline bool getIsClassifier() const CV_OVERRIDE { return impl->isclassifier; }
+    inline void setIsClassifier(bool val) CV_OVERRIDE { impl->isclassifier = val; }
+    inline int getEmax() const CV_OVERRIDE { return impl->Emax; }
+    inline void setEmax(int val) CV_OVERRIDE { impl->Emax = val; }
 
 public:
-    int getAlgorithmType() const
+    int getAlgorithmType() const CV_OVERRIDE
     {
         return impl->getType();
     }
-    void setAlgorithmType(int val)
+    void setAlgorithmType(int val) CV_OVERRIDE
     {
         if (val != BRUTE_FORCE && val != KDTREE)
             val = BRUTE_FORCE;
@@ -459,18 +462,18 @@ public:
     {
     }
 
-    bool isClassifier() const { return impl->isclassifier; }
-    bool isTrained() const { return !impl->samples.empty(); }
+    bool isClassifier() const CV_OVERRIDE { return impl->isclassifier; }
+    bool isTrained() const CV_OVERRIDE { return !impl->samples.empty(); }
 
-    int getVarCount() const { return impl->samples.cols; }
+    int getVarCount() const CV_OVERRIDE { return impl->samples.cols; }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         writeFormat(fs);
         impl->write(fs);
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         int algorithmType = BRUTE_FORCE;
         if (fn.name() == NAME_KDTREE)
@@ -482,22 +485,22 @@ public:
     float findNearest( InputArray samples, int k,
                        OutputArray results,
                        OutputArray neighborResponses=noArray(),
-                       OutputArray dist=noArray() ) const
+                       OutputArray dist=noArray() ) const CV_OVERRIDE
     {
         return impl->findNearest(samples, k, results, neighborResponses, dist);
     }
 
-    float predict(InputArray inputs, OutputArray outputs, int) const
+    float predict(InputArray inputs, OutputArray outputs, int) const CV_OVERRIDE
     {
         return impl->findNearest( inputs, impl->defaultK, outputs, noArray(), noArray() );
     }
 
-    bool train( const Ptr<TrainData>& data, int flags )
+    bool train( const Ptr<TrainData>& data, int flags ) CV_OVERRIDE
     {
         return impl->train(data, flags);
     }
 
-    String getDefaultName() const { return impl->getModelName(); }
+    String getDefaultName() const CV_OVERRIDE { return impl->getModelName(); }
 
 protected:
     void initImpl(int algorithmType)

modules/ml/src/lr.cpp

@@ -81,30 +81,36 @@ public:
     TermCriteria term_crit;
 };
 
-class LogisticRegressionImpl : public LogisticRegression
+class LogisticRegressionImpl CV_FINAL : public LogisticRegression
 {
 public:
 
     LogisticRegressionImpl() { }
     virtual ~LogisticRegressionImpl() {}
 
-    CV_IMPL_PROPERTY(double, LearningRate, params.alpha)
-    CV_IMPL_PROPERTY(int, Iterations, params.num_iters)
-    CV_IMPL_PROPERTY(int, Regularization, params.norm)
-    CV_IMPL_PROPERTY(int, TrainMethod, params.train_method)
-    CV_IMPL_PROPERTY(int, MiniBatchSize, params.mini_batch_size)
-    CV_IMPL_PROPERTY(TermCriteria, TermCriteria, params.term_crit)
-
-    virtual bool train( const Ptr<TrainData>& trainData, int=0 );
-    virtual float predict(InputArray samples, OutputArray results, int flags=0) const;
-    virtual void clear();
-    virtual void write(FileStorage& fs) const;
-    virtual void read(const FileNode& fn);
-    virtual Mat get_learnt_thetas() const { return learnt_thetas; }
-    virtual int getVarCount() const { return learnt_thetas.cols; }
-    virtual bool isTrained() const { return !learnt_thetas.empty(); }
-    virtual bool isClassifier() const { return true; }
-    virtual String getDefaultName() const { return "opencv_ml_lr"; }
+    inline double getLearningRate() const CV_OVERRIDE { return params.alpha; }
+    inline void setLearningRate(double val) CV_OVERRIDE { params.alpha = val; }
+    inline int getIterations() const CV_OVERRIDE { return params.num_iters; }
+    inline void setIterations(int val) CV_OVERRIDE { params.num_iters = val; }
+    inline int getRegularization() const CV_OVERRIDE { return params.norm; }
+    inline void setRegularization(int val) CV_OVERRIDE { params.norm = val; }
+    inline int getTrainMethod() const CV_OVERRIDE { return params.train_method; }
+    inline void setTrainMethod(int val) CV_OVERRIDE { params.train_method = val; }
+    inline int getMiniBatchSize() const CV_OVERRIDE { return params.mini_batch_size; }
+    inline void setMiniBatchSize(int val) CV_OVERRIDE { params.mini_batch_size = val; }
+    inline TermCriteria getTermCriteria() const CV_OVERRIDE { return params.term_crit; }
+    inline void setTermCriteria(TermCriteria val) CV_OVERRIDE { params.term_crit = val; }
+
+    virtual bool train( const Ptr<TrainData>& trainData, int=0 ) CV_OVERRIDE;
+    virtual float predict(InputArray samples, OutputArray results, int flags=0) const CV_OVERRIDE;
+    virtual void clear() CV_OVERRIDE;
+    virtual void write(FileStorage& fs) const CV_OVERRIDE;
+    virtual void read(const FileNode& fn) CV_OVERRIDE;
+    virtual Mat get_learnt_thetas() const CV_OVERRIDE { return learnt_thetas; }
+    virtual int getVarCount() const CV_OVERRIDE { return learnt_thetas.cols; }
+    virtual bool isTrained() const CV_OVERRIDE { return !learnt_thetas.empty(); }
+    virtual bool isClassifier() const CV_OVERRIDE { return true; }
+    virtual String getDefaultName() const CV_OVERRIDE { return "opencv_ml_lr"; }
 protected:
     Mat calc_sigmoid(const Mat& data) const;
     double compute_cost(const Mat& _data, const Mat& _labels, const Mat& _init_theta);
@@ -392,7 +398,7 @@ struct LogisticRegressionImpl_ComputeDradient_Impl : ParallelLoopBody
 
     }
 
-    void operator()(const cv::Range& r) const
+    void operator()(const cv::Range& r) const CV_OVERRIDE
     {
         const Mat& _data  = *data;
         const Mat &_theta = *theta;

modules/ml/src/nbayes.cpp

@@ -52,7 +52,7 @@ public:
         nallvars = 0;
     }
 
-    bool train( const Ptr<TrainData>& trainData, int flags )
+    bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         const float min_variation = FLT_EPSILON;
         Mat responses = trainData->getNormCatResponses();
@@ -219,7 +219,7 @@ public:
         float* value;
         bool rawOutput;
 
-        void operator()( const Range& range ) const
+        void operator()(const Range& range) const CV_OVERRIDE
         {
             int cls = -1;
             int rtype = 0, rptype = 0;
@@ -298,12 +298,12 @@ public:
         }
     };
 
-    float predict( InputArray _samples, OutputArray _results, int flags ) const
+    float predict( InputArray _samples, OutputArray _results, int flags ) const CV_OVERRIDE
     {
         return predictProb(_samples, _results, noArray(), flags);
     }
 
-    float predictProb( InputArray _samples, OutputArray _results, OutputArray _resultsProb, int flags ) const
+    float predictProb( InputArray _samples, OutputArray _results, OutputArray _resultsProb, int flags ) const CV_OVERRIDE
     {
         int value=0;
         Mat samples = _samples.getMat(), results, resultsProb;
@@ -339,7 +339,7 @@ public:
         return (float)value;
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         int nclasses = (int)cls_labels.total(), i;
 
@@ -380,7 +380,7 @@ public:
         fs << "c" << c;
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         clear();
 
@@ -427,7 +427,7 @@ public:
         fn["c"] >> c;
     }
 
-    void clear()
+    void clear() CV_OVERRIDE
     {
         count.clear();
         sum.clear();
@@ -442,10 +442,10 @@ public:
         nallvars = 0;
     }
 
-    bool isTrained() const { return !avg.empty(); }
-    bool isClassifier() const { return true; }
-    int getVarCount() const { return nallvars; }
-    String getDefaultName() const { return "opencv_ml_nbayes"; }
+    bool isTrained() const CV_OVERRIDE { return !avg.empty(); }
+    bool isClassifier() const CV_OVERRIDE { return true; }
+    int getVarCount() const CV_OVERRIDE { return nallvars; }
+    String getDefaultName() const CV_OVERRIDE { return "opencv_ml_nbayes"; }
 
     int nallvars;
     Mat var_idx, cls_labels, c;

modules/ml/src/precomp.hpp

@@ -173,13 +173,17 @@ namespace ml
         inline int getCVFolds() const { return CVFolds; }
         inline float getRegressionAccuracy() const { return regressionAccuracy; }
 
-        CV_IMPL_PROPERTY(bool, UseSurrogates, useSurrogates)
-        CV_IMPL_PROPERTY(bool, Use1SERule, use1SERule)
-        CV_IMPL_PROPERTY(bool, TruncatePrunedTree, truncatePrunedTree)
-        CV_IMPL_PROPERTY_S(cv::Mat, Priors, priors)
+        inline bool getUseSurrogates() const { return useSurrogates; }
+        inline void setUseSurrogates(bool val) { useSurrogates = val; }
+        inline bool getUse1SERule() const { return use1SERule; }
+        inline void setUse1SERule(bool val) { use1SERule = val; }
+        inline bool getTruncatePrunedTree() const { return truncatePrunedTree; }
+        inline void setTruncatePrunedTree(bool val) { truncatePrunedTree = val; }
+        inline cv::Mat getPriors() const { return priors; }
+        inline void setPriors(const cv::Mat& val) { priors = val; }
 
         public:
-            bool  useSurrogates;
+        bool  useSurrogates;
         bool  use1SERule;
         bool  truncatePrunedTree;
         Mat priors;
@@ -281,24 +285,33 @@ namespace ml
             int maxSubsetSize;
         };
 
-        CV_WRAP_SAME_PROPERTY(int, MaxCategories, params)
-        CV_WRAP_SAME_PROPERTY(int, MaxDepth, params)
-        CV_WRAP_SAME_PROPERTY(int, MinSampleCount, params)
-        CV_WRAP_SAME_PROPERTY(int, CVFolds, params)
-        CV_WRAP_SAME_PROPERTY(bool, UseSurrogates, params)
-        CV_WRAP_SAME_PROPERTY(bool, Use1SERule, params)
-        CV_WRAP_SAME_PROPERTY(bool, TruncatePrunedTree, params)
-        CV_WRAP_SAME_PROPERTY(float, RegressionAccuracy, params)
-        CV_WRAP_SAME_PROPERTY_S(cv::Mat, Priors, params)
+        inline int getMaxCategories() const CV_OVERRIDE { return params.getMaxCategories(); }
+        inline void setMaxCategories(int val) CV_OVERRIDE { params.setMaxCategories(val); }
+        inline int getMaxDepth() const CV_OVERRIDE { return params.getMaxDepth(); }
+        inline void setMaxDepth(int val) CV_OVERRIDE { params.setMaxDepth(val); }
+        inline int getMinSampleCount() const CV_OVERRIDE { return params.getMinSampleCount(); }
+        inline void setMinSampleCount(int val) CV_OVERRIDE { params.setMinSampleCount(val); }
+        inline int getCVFolds() const CV_OVERRIDE { return params.getCVFolds(); }
+        inline void setCVFolds(int val) CV_OVERRIDE { params.setCVFolds(val); }
+        inline bool getUseSurrogates() const CV_OVERRIDE { return params.getUseSurrogates(); }
+        inline void setUseSurrogates(bool val) CV_OVERRIDE { params.setUseSurrogates(val); }
+        inline bool getUse1SERule() const CV_OVERRIDE { return params.getUse1SERule(); }
+        inline void setUse1SERule(bool val) CV_OVERRIDE { params.setUse1SERule(val); }
+        inline bool getTruncatePrunedTree() const CV_OVERRIDE { return params.getTruncatePrunedTree(); }
+        inline void setTruncatePrunedTree(bool val) CV_OVERRIDE { params.setTruncatePrunedTree(val); }
+        inline float getRegressionAccuracy() const CV_OVERRIDE { return params.getRegressionAccuracy(); }
+        inline void setRegressionAccuracy(float val) CV_OVERRIDE { params.setRegressionAccuracy(val); }
+        inline cv::Mat getPriors() const CV_OVERRIDE { return params.getPriors(); }
+        inline void setPriors(const cv::Mat& val) CV_OVERRIDE { params.setPriors(val); }
 
         DTreesImpl();
-        virtual ~DTreesImpl();
-        virtual void clear();
+        virtual ~DTreesImpl() CV_OVERRIDE;
+        virtual void clear() CV_OVERRIDE;
 
-        String getDefaultName() const { return "opencv_ml_dtree"; }
-        bool isTrained() const { return !roots.empty(); }
-        bool isClassifier() const { return _isClassifier; }
-        int getVarCount() const { return varType.empty() ? 0 : (int)(varType.size() - 1); }
+        String getDefaultName() const CV_OVERRIDE { return "opencv_ml_dtree"; }
+        bool isTrained() const CV_OVERRIDE { return !roots.empty(); }
+        bool isClassifier() const CV_OVERRIDE { return _isClassifier; }
+        int getVarCount() const CV_OVERRIDE { return varType.empty() ? 0 : (int)(varType.size() - 1); }
         int getCatCount(int vi) const { return catOfs[vi][1] - catOfs[vi][0]; }
         int getSubsetSize(int vi) const { return (getCatCount(vi) + 31)/32; }
 
@@ -306,7 +319,7 @@ namespace ml
         virtual void startTraining( const Ptr<TrainData>& trainData, int flags );
         virtual void endTraining();
         virtual void initCompVarIdx();
-        virtual bool train( const Ptr<TrainData>& trainData, int flags );
+        virtual bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE;
 
         virtual int addTree( const vector<int>& sidx );
         virtual int addNodeAndTrySplit( int parent, const vector<int>& sidx );
@@ -329,25 +342,25 @@ namespace ml
         virtual double updateTreeRNC( int root, double T, int fold );
         virtual bool cutTree( int root, double T, int fold, double min_alpha );
         virtual float predictTrees( const Range& range, const Mat& sample, int flags ) const;
-        virtual float predict( InputArray inputs, OutputArray outputs, int flags ) const;
+        virtual float predict( InputArray inputs, OutputArray outputs, int flags ) const CV_OVERRIDE;
 
         virtual void writeTrainingParams( FileStorage& fs ) const;
         virtual void writeParams( FileStorage& fs ) const;
         virtual void writeSplit( FileStorage& fs, int splitidx ) const;
         virtual void writeNode( FileStorage& fs, int nidx, int depth ) const;
         virtual void writeTree( FileStorage& fs, int root ) const;
-        virtual void write( FileStorage& fs ) const;
+        virtual void write( FileStorage& fs ) const CV_OVERRIDE;
 
         virtual void readParams( const FileNode& fn );
         virtual int readSplit( const FileNode& fn );
         virtual int readNode( const FileNode& fn );
         virtual int readTree( const FileNode& fn );
-        virtual void read( const FileNode& fn );
+        virtual void read( const FileNode& fn ) CV_OVERRIDE;
 
-        virtual const std::vector<int>& getRoots() const { return roots; }
-        virtual const std::vector<Node>& getNodes() const { return nodes; }
-        virtual const std::vector<Split>& getSplits() const { return splits; }
-        virtual const std::vector<int>& getSubsets() const { return subsets; }
+        virtual const std::vector<int>& getRoots() const CV_OVERRIDE { return roots; }
+        virtual const std::vector<Node>& getNodes() const CV_OVERRIDE { return nodes; }
+        virtual const std::vector<Split>& getSplits() const CV_OVERRIDE { return splits; }
+        virtual const std::vector<int>& getSubsets() const CV_OVERRIDE { return subsets; }
 
         TreeParams params;
 

modules/ml/src/rtrees.cpp

@@ -66,7 +66,7 @@ RTreeParams::RTreeParams(bool _calcVarImportance,
 }
 
 
-class DTreesImplForRTrees : public DTreesImpl
+class DTreesImplForRTrees CV_FINAL : public DTreesImpl
 {
 public:
     DTreesImplForRTrees()
@@ -85,7 +85,7 @@ public:
     }
     virtual ~DTreesImplForRTrees() {}
 
-    void clear()
+    void clear() CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         DTreesImpl::clear();
@@ -93,7 +93,7 @@ public:
         rng = RNG((uint64)-1);
     }
 
-    const vector<int>& getActiveVars()
+    const vector<int>& getActiveVars() CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         int i, nvars = (int)allVars.size(), m = (int)activeVars.size();
@@ -108,7 +108,7 @@ public:
         return activeVars;
     }
 
-    void startTraining( const Ptr<TrainData>& trainData, int flags )
+    void startTraining( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         DTreesImpl::startTraining(trainData, flags);
@@ -121,7 +121,7 @@ public:
             allVars[i] = varIdx[i];
     }
 
-    void endTraining()
+    void endTraining() CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         DTreesImpl::endTraining();
@@ -130,7 +130,7 @@ public:
         std::swap(activeVars, b);
     }
 
-    bool train( const Ptr<TrainData>& trainData, int flags )
+    bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         startTraining(trainData, flags);
@@ -293,14 +293,14 @@ public:
         return true;
     }
 
-    void writeTrainingParams( FileStorage& fs ) const
+    void writeTrainingParams( FileStorage& fs ) const CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         DTreesImpl::writeTrainingParams(fs);
         fs << "nactive_vars" << rparams.nactiveVars;
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         if( roots.empty() )
@@ -328,7 +328,7 @@ public:
         fs << "]";
     }
 
-    void readParams( const FileNode& fn )
+    void readParams( const FileNode& fn ) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         DTreesImpl::readParams(fn);
@@ -337,7 +337,7 @@ public:
         rparams.nactiveVars = (int)tparams_node["nactive_vars"];
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         clear();
@@ -425,29 +425,41 @@ public:
 };
 
 
-class RTreesImpl : public RTrees
+class RTreesImpl CV_FINAL : public RTrees
 {
 public:
-    CV_IMPL_PROPERTY(bool, CalculateVarImportance, impl.rparams.calcVarImportance)
-    CV_IMPL_PROPERTY(int, ActiveVarCount, impl.rparams.nactiveVars)
-    CV_IMPL_PROPERTY_S(TermCriteria, TermCriteria, impl.rparams.termCrit)
-
-    CV_WRAP_SAME_PROPERTY(int, MaxCategories, impl.params)
-    CV_WRAP_SAME_PROPERTY(int, MaxDepth, impl.params)
-    CV_WRAP_SAME_PROPERTY(int, MinSampleCount, impl.params)
-    CV_WRAP_SAME_PROPERTY(int, CVFolds, impl.params)
-    CV_WRAP_SAME_PROPERTY(bool, UseSurrogates, impl.params)
-    CV_WRAP_SAME_PROPERTY(bool, Use1SERule, impl.params)
-    CV_WRAP_SAME_PROPERTY(bool, TruncatePrunedTree, impl.params)
-    CV_WRAP_SAME_PROPERTY(float, RegressionAccuracy, impl.params)
-    CV_WRAP_SAME_PROPERTY_S(cv::Mat, Priors, impl.params)
+    inline bool getCalculateVarImportance() const CV_OVERRIDE { return impl.rparams.calcVarImportance; }
+    inline void setCalculateVarImportance(bool val) CV_OVERRIDE { impl.rparams.calcVarImportance = val; }
+    inline int getActiveVarCount() const CV_OVERRIDE { return impl.rparams.nactiveVars; }
+    inline void setActiveVarCount(int val) CV_OVERRIDE { impl.rparams.nactiveVars = val; }
+    inline TermCriteria getTermCriteria() const CV_OVERRIDE { return impl.rparams.termCrit; }
+    inline void setTermCriteria(const TermCriteria& val) CV_OVERRIDE { impl.rparams.termCrit = val; }
+
+    inline int getMaxCategories() const CV_OVERRIDE { return impl.params.getMaxCategories(); }
+    inline void setMaxCategories(int val) CV_OVERRIDE { impl.params.setMaxCategories(val); }
+    inline int getMaxDepth() const CV_OVERRIDE { return impl.params.getMaxDepth(); }
+    inline void setMaxDepth(int val) CV_OVERRIDE { impl.params.setMaxDepth(val); }
+    inline int getMinSampleCount() const CV_OVERRIDE { return impl.params.getMinSampleCount(); }
+    inline void setMinSampleCount(int val) CV_OVERRIDE { impl.params.setMinSampleCount(val); }
+    inline int getCVFolds() const CV_OVERRIDE { return impl.params.getCVFolds(); }
+    inline void setCVFolds(int val) CV_OVERRIDE { impl.params.setCVFolds(val); }
+    inline bool getUseSurrogates() const CV_OVERRIDE { return impl.params.getUseSurrogates(); }
+    inline void setUseSurrogates(bool val) CV_OVERRIDE { impl.params.setUseSurrogates(val); }
+    inline bool getUse1SERule() const CV_OVERRIDE { return impl.params.getUse1SERule(); }
+    inline void setUse1SERule(bool val) CV_OVERRIDE { impl.params.setUse1SERule(val); }
+    inline bool getTruncatePrunedTree() const CV_OVERRIDE { return impl.params.getTruncatePrunedTree(); }
+    inline void setTruncatePrunedTree(bool val) CV_OVERRIDE { impl.params.setTruncatePrunedTree(val); }
+    inline float getRegressionAccuracy() const CV_OVERRIDE { return impl.params.getRegressionAccuracy(); }
+    inline void setRegressionAccuracy(float val) CV_OVERRIDE { impl.params.setRegressionAccuracy(val); }
+    inline cv::Mat getPriors() const CV_OVERRIDE { return impl.params.getPriors(); }
+    inline void setPriors(const cv::Mat& val) CV_OVERRIDE { impl.params.setPriors(val); }
 
     RTreesImpl() {}
-    virtual ~RTreesImpl() {}
+    virtual ~RTreesImpl() CV_OVERRIDE {}
 
-    String getDefaultName() const { return "opencv_ml_rtrees"; }
+    String getDefaultName() const CV_OVERRIDE { return "opencv_ml_rtrees"; }
 
-    bool train( const Ptr<TrainData>& trainData, int flags )
+    bool train( const Ptr<TrainData>& trainData, int flags ) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         if (impl.getCVFolds() != 0)
@@ -455,19 +467,19 @@ public:
         return impl.train(trainData, flags);
     }
 
-    float predict( InputArray samples, OutputArray results, int flags ) const
+    float predict( InputArray samples, OutputArray results, int flags ) const CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         return impl.predict(samples, results, flags);
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         impl.write(fs);
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         CV_TRACE_FUNCTION();
         impl.read(fn);
@@ -479,16 +491,16 @@ public:
         impl.getVotes(samples, results, flags);
     }
 
-    Mat getVarImportance() const { return Mat_<float>(impl.varImportance, true); }
-    int getVarCount() const { return impl.getVarCount(); }
+    Mat getVarImportance() const CV_OVERRIDE { return Mat_<float>(impl.varImportance, true); }
+    int getVarCount() const CV_OVERRIDE { return impl.getVarCount(); }
 
-    bool isTrained() const { return impl.isTrained(); }
-    bool isClassifier() const { return impl.isClassifier(); }
+    bool isTrained() const CV_OVERRIDE { return impl.isTrained(); }
+    bool isClassifier() const CV_OVERRIDE { return impl.isClassifier(); }
 
-    const vector<int>& getRoots() const { return impl.getRoots(); }
-    const vector<Node>& getNodes() const { return impl.getNodes(); }
-    const vector<Split>& getSplits() const { return impl.getSplits(); }
-    const vector<int>& getSubsets() const { return impl.getSubsets(); }
+    const vector<int>& getRoots() const CV_OVERRIDE { return impl.getRoots(); }
+    const vector<Node>& getNodes() const CV_OVERRIDE { return impl.getNodes(); }
+    const vector<Split>& getSplits() const CV_OVERRIDE { return impl.getSplits(); }
+    const vector<int>& getSubsets() const CV_OVERRIDE { return impl.getSubsets(); }
 
     DTreesImplForRTrees impl;
 };

modules/ml/src/svm.cpp

@@ -149,7 +149,7 @@ struct SvmParams
 };
 
 /////////////////////////////////////// SVM kernel ///////////////////////////////////////
-class SVMKernelImpl : public SVM::Kernel
+class SVMKernelImpl CV_FINAL : public SVM::Kernel
 {
 public:
     SVMKernelImpl( const SvmParams& _params = SvmParams() )
@@ -157,7 +157,7 @@ public:
         params = _params;
     }
 
-    int getType() const
+    int getType() const CV_OVERRIDE
     {
         return params.kernelType;
     }
@@ -300,7 +300,7 @@ public:
     }
 
     void calc( int vcount, int var_count, const float* vecs,
-               const float* another, Qfloat* results )
+               const float* another, Qfloat* results ) CV_OVERRIDE
     {
         switch( params.kernelType )
         {
@@ -414,7 +414,7 @@ ParamGrid SVM::getDefaultGrid( int param_id )
 }
 
 
-class SVMImpl : public SVM
+class SVMImpl CV_FINAL : public SVM
 {
 public:
     struct DecisionFunc
@@ -1241,7 +1241,7 @@ public:
         clear();
     }
 
-    void clear()
+    void clear() CV_OVERRIDE
     {
         decision_func.clear();
         df_alpha.clear();
@@ -1255,34 +1255,39 @@ public:
         return uncompressed_sv;
     }
 
-    Mat getSupportVectors() const
+    Mat getSupportVectors() const CV_OVERRIDE
     {
         return sv;
     }
 
-    CV_IMPL_PROPERTY(int, Type, params.svmType)
-    CV_IMPL_PROPERTY(double, Gamma, params.gamma)
-    CV_IMPL_PROPERTY(double, Coef0, params.coef0)
-    CV_IMPL_PROPERTY(double, Degree, params.degree)
-    CV_IMPL_PROPERTY(double, C, params.C)
-    CV_IMPL_PROPERTY(double, Nu, params.nu)
-    CV_IMPL_PROPERTY(double, P, params.p)
-    CV_IMPL_PROPERTY_S(cv::Mat, ClassWeights, params.classWeights)
-    CV_IMPL_PROPERTY_S(cv::TermCriteria, TermCriteria, params.termCrit)
-
-    int getKernelType() const
-    {
-        return params.kernelType;
-    }
-
-    void setKernel(int kernelType)
+    inline int getType() const CV_OVERRIDE { return params.svmType; }
+    inline void setType(int val) CV_OVERRIDE { params.svmType = val; }
+    inline double getGamma() const CV_OVERRIDE { return params.gamma; }
+    inline void setGamma(double val) CV_OVERRIDE { params.gamma = val; }
+    inline double getCoef0() const CV_OVERRIDE { return params.coef0; }
+    inline void setCoef0(double val) CV_OVERRIDE { params.coef0 = val; }
+    inline double getDegree() const CV_OVERRIDE { return params.degree; }
+    inline void setDegree(double val) CV_OVERRIDE { params.degree = val; }
+    inline double getC() const CV_OVERRIDE { return params.C; }
+    inline void setC(double val) CV_OVERRIDE { params.C = val; }
+    inline double getNu() const CV_OVERRIDE { return params.nu; }
+    inline void setNu(double val) CV_OVERRIDE { params.nu = val; }
+    inline double getP() const CV_OVERRIDE { return params.p; }
+    inline void setP(double val) CV_OVERRIDE { params.p = val; }
+    inline cv::Mat getClassWeights() const CV_OVERRIDE { return params.classWeights; }
+    inline void setClassWeights(const cv::Mat& val) CV_OVERRIDE { params.classWeights = val; }
+    inline cv::TermCriteria getTermCriteria() const CV_OVERRIDE { return params.termCrit; }
+    inline void setTermCriteria(const cv::TermCriteria& val) CV_OVERRIDE { params.termCrit = val; }
+
+    int getKernelType() const CV_OVERRIDE { return params.kernelType; }
+    void setKernel(int kernelType) CV_OVERRIDE
     {
         params.kernelType = kernelType;
         if (kernelType != CUSTOM)
             kernel = makePtr<SVMKernelImpl>(params);
     }
 
-    void setCustomKernel(const Ptr<Kernel> &_kernel)
+    void setCustomKernel(const Ptr<Kernel> &_kernel) CV_OVERRIDE
     {
         params.kernelType = CUSTOM;
         kernel = _kernel;
@@ -1606,7 +1611,7 @@ public:
         std::swap(decision_func, new_df);
     }
 
-    bool train( const Ptr<TrainData>& data, int )
+    bool train( const Ptr<TrainData>& data, int ) CV_OVERRIDE
     {
         clear();
 
@@ -1651,7 +1656,7 @@ public:
         sidx(_sidx), is_classification(_is_classification), k_fold(_k_fold), result(_result)
         {}
 
-        void operator()( const cv::Range& range ) const
+        void operator()( const cv::Range& range ) const CV_OVERRIDE
         {
             int sample_count = samples.rows;
             int var_count_ = samples.cols;
@@ -1732,7 +1737,7 @@ public:
     bool trainAuto( const Ptr<TrainData>& data, int k_fold,
                     ParamGrid C_grid, ParamGrid gamma_grid, ParamGrid p_grid,
                     ParamGrid nu_grid, ParamGrid coef_grid, ParamGrid degree_grid,
-                    bool balanced )
+                    bool balanced ) CV_OVERRIDE
     {
         checkParams();
 
@@ -1902,7 +1907,7 @@ public:
             returnDFVal = _returnDFVal;
         }
 
-        void operator()( const Range& range ) const
+        void operator()(const Range& range) const CV_OVERRIDE
         {
             int svmType = svm->params.svmType;
             int sv_total = svm->sv.rows;
@@ -1995,7 +2000,7 @@ public:
     }
 
 
-    float predict( InputArray _samples, OutputArray _results, int flags ) const
+    float predict( InputArray _samples, OutputArray _results, int flags ) const CV_OVERRIDE
     {
         float result = 0;
         Mat samples = _samples.getMat(), results;
@@ -2023,7 +2028,7 @@ public:
         return result;
     }
 
-    double getDecisionFunction(int i, OutputArray _alpha, OutputArray _svidx ) const
+    double getDecisionFunction(int i, OutputArray _alpha, OutputArray _svidx ) const CV_OVERRIDE
     {
         CV_Assert( 0 <= i && i < (int)decision_func.size());
         const DecisionFunc& df = decision_func[i];
@@ -2085,27 +2090,27 @@ public:
         fs << "}";
     }
 
-    bool isTrained() const
+    bool isTrained() const CV_OVERRIDE
     {
         return !sv.empty();
     }
 
-    bool isClassifier() const
+    bool isClassifier() const CV_OVERRIDE
     {
         return params.svmType == C_SVC || params.svmType == NU_SVC || params.svmType == ONE_CLASS;
     }
 
-    int getVarCount() const
+    int getVarCount() const CV_OVERRIDE
     {
         return var_count;
     }
 
-    String getDefaultName() const
+    String getDefaultName() const CV_OVERRIDE
     {
         return "opencv_ml_svm";
     }
 
-    void write( FileStorage& fs ) const
+    void write( FileStorage& fs ) const CV_OVERRIDE
     {
         int class_count = !class_labels.empty() ? (int)class_labels.total() :
                           params.svmType == ONE_CLASS ? 1 : 0;
@@ -2238,7 +2243,7 @@ public:
         setParams( _params );
     }
 
-    void read( const FileNode& fn )
+    void read( const FileNode& fn ) CV_OVERRIDE
     {
         clear();
 

modules/ml/src/svmsgd.cpp

@@ -57,7 +57,7 @@ namespace cv
 namespace ml
 {
 
-class SVMSGDImpl : public SVMSGD
+class SVMSGDImpl CV_FINAL : public SVMSGD
 {
 
 public:
@@ -65,36 +65,42 @@ public:
 
     virtual ~SVMSGDImpl() {}
 
-    virtual bool train(const Ptr<TrainData>& data, int);
+    virtual bool train(const Ptr<TrainData>& data, int) CV_OVERRIDE;
 
-    virtual float predict( InputArray samples, OutputArray results=noArray(), int flags = 0 ) const;
+    virtual float predict( InputArray samples, OutputArray results=noArray(), int flags = 0 ) const CV_OVERRIDE;
 
-    virtual bool isClassifier() const;
+    virtual bool isClassifier() const CV_OVERRIDE;
 
-    virtual bool isTrained() const;
+    virtual bool isTrained() const CV_OVERRIDE;
 
-    virtual void clear();
+    virtual void clear() CV_OVERRIDE;
 
-    virtual void write(FileStorage &fs) const;
+    virtual void write(FileStorage &fs) const CV_OVERRIDE;
 
-    virtual void read(const FileNode &fn);
+    virtual void read(const FileNode &fn) CV_OVERRIDE;
 
-    virtual Mat getWeights(){ return weights_; }
+    virtual Mat getWeights() CV_OVERRIDE { return weights_; }
 
-    virtual float getShift(){ return shift_; }
+    virtual float getShift() CV_OVERRIDE { return shift_; }
 
-    virtual int getVarCount() const { return weights_.cols; }
+    virtual int getVarCount() const CV_OVERRIDE { return weights_.cols; }
 
-    virtual String getDefaultName() const {return "opencv_ml_svmsgd";}
+    virtual String getDefaultName() const CV_OVERRIDE {return "opencv_ml_svmsgd";}
 
-    virtual void setOptimalParameters(int svmsgdType = ASGD, int marginType = SOFT_MARGIN);
+    virtual void setOptimalParameters(int svmsgdType = ASGD, int marginType = SOFT_MARGIN) CV_OVERRIDE;
 
-    CV_IMPL_PROPERTY(int, SvmsgdType, params.svmsgdType)
-    CV_IMPL_PROPERTY(int, MarginType, params.marginType)
-    CV_IMPL_PROPERTY(float, MarginRegularization, params.marginRegularization)
-    CV_IMPL_PROPERTY(float, InitialStepSize, params.initialStepSize)
-    CV_IMPL_PROPERTY(float, StepDecreasingPower, params.stepDecreasingPower)
-    CV_IMPL_PROPERTY_S(cv::TermCriteria, TermCriteria, params.termCrit)
+    inline int getSvmsgdType() const CV_OVERRIDE { return params.svmsgdType; }
+    inline void setSvmsgdType(int val) CV_OVERRIDE { params.svmsgdType = val; }
+    inline int getMarginType() const CV_OVERRIDE { return params.marginType; }
+    inline void setMarginType(int val) CV_OVERRIDE { params.marginType = val; }
+    inline float getMarginRegularization() const CV_OVERRIDE { return params.marginRegularization; }
+    inline void setMarginRegularization(float val) CV_OVERRIDE { params.marginRegularization = val; }
+    inline float getInitialStepSize() const CV_OVERRIDE { return params.initialStepSize; }
+    inline void setInitialStepSize(float val) CV_OVERRIDE { params.initialStepSize = val; }
+    inline float getStepDecreasingPower() const CV_OVERRIDE { return params.stepDecreasingPower; }
+    inline void setStepDecreasingPower(float val) CV_OVERRIDE { params.stepDecreasingPower = val; }
+    inline cv::TermCriteria getTermCriteria() const CV_OVERRIDE { return params.termCrit; }
+    inline void setTermCriteria(const cv::TermCriteria& val) CV_OVERRIDE { params.termCrit = val; }
 
 private:
     void updateWeights(InputArray sample, bool positive, float stepSize, Mat &weights);