bioinspired: apply CV_OVERRIDE/CV_FINAL

modules/bioinspired/include/opencv2/bioinspired/retina.hpp

@@ -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)
 

modules/bioinspired/include/opencv2/bioinspired/transientareassegmentationmodule.hpp

@@ -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 !

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;

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;

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;

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

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;

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)

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;

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)
         {

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;