Chiebot-Mirror
/
opencv_contrib
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bioinspired: apply CV_OVERRIDE/CV_FINAL

Browse Source
pull/1588/head
Alexander Alekhin 7 years ago
parent f730de1af3
commit 06de054482
11 changed files with 82 additions and 82 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      modules/bioinspired/include/opencv2/bioinspired/retina.hpp
  2. 4
      modules/bioinspired/include/opencv2/bioinspired/transientareassegmentationmodule.hpp
  3. 14
      modules/bioinspired/src/basicretinafilter.hpp
  4. 2
      modules/bioinspired/src/magnoretinafilter.hpp
  5. 2
      modules/bioinspired/src/parvoretinafilter.hpp
  6. 50
      modules/bioinspired/src/retina.cpp
  7. 50
      modules/bioinspired/src/retina_ocl.hpp
  8. 6
      modules/bioinspired/src/retinacolor.hpp
  9. 4
      modules/bioinspired/src/retinafasttonemapping.cpp
  10. 2
      modules/bioinspired/src/templatebuffer.hpp
  11. 24
      modules/bioinspired/src/transientareassegmentationmodule.cpp

6
modules/bioinspired/include/opencv2/bioinspired/retina.hpp
Unescape View File

@ -146,7 +146,7 @@ enum {
</opencv_storage>
@endcode
*/
struct RetinaParameters{
struct RetinaParameters{
//! Outer Plexiform Layer (OPL) and Inner Plexiform Layer Parvocellular (IplParvo) parameters
struct OPLandIplParvoParameters{
OPLandIplParvoParameters():colorMode(true),
@ -208,7 +208,7 @@ class CV_EXPORTS_W Retina : public Algorithm {
public:
/** @brief Retreive retina input buffer size
@return the retina input buffer size
*/
@ -260,7 +260,7 @@ public:
CV_WRAP virtual void write( String fs ) const=0;
/** @overload */
virtual void write( FileStorage& fs ) const=0;
virtual void write( FileStorage& fs ) const CV_OVERRIDE = 0;
/** @brief Setup the OPL and IPL parvo channels (see biologocal model)

4
modules/bioinspired/include/opencv2/bioinspired/transientareassegmentationmodule.hpp
Unescape View File

@ -80,7 +80,7 @@ namespace bioinspired
/** @brief parameter structure that stores the transient events detector setup parameters
*/
struct SegmentationParameters{ // CV_EXPORTS_W_MAP to export to python native dictionnaries
// default structure instance construction with default values
// default structure instance construction with default values
SegmentationParameters():
thresholdON(100),
thresholdOFF(100),
@ -171,7 +171,7 @@ public:
/** @brief write xml/yml formated parameters information
@param fs : a cv::Filestorage object ready to be filled
*/
virtual void write( cv::FileStorage& fs ) const=0;
virtual void write( cv::FileStorage& fs ) const CV_OVERRIDE = 0;
/** @brief main processing method, get result using methods getSegmentationPicture()
@param inputToSegment : the image to process, it must match the instance buffer size !

14
modules/bioinspired/src/basicretinafilter.hpp
Unescape View File

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

2
modules/bioinspired/src/magnoretinafilter.hpp
Unescape View File

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

2
modules/bioinspired/src/parvoretinafilter.hpp
Unescape View File

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

50
modules/bioinspired/src/retina.cpp
Unescape View File

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

50
modules/bioinspired/src/retina_ocl.hpp
Unescape View File

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

6
modules/bioinspired/src/retinacolor.hpp
Unescape View File

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

4
modules/bioinspired/src/retinafasttonemapping.cpp
Unescape View File

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

2
modules/bioinspired/src/templatebuffer.hpp
Unescape View File

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

24
modules/bioinspired/src/transientareassegmentationmodule.cpp
Unescape View File

@ -227,17 +227,17 @@ class TransientAreasSegmentationModuleImpl_: public TransientAreasSegmentationM
{
public:
TransientAreasSegmentationModuleImpl_(const Size size):_segmTool(size){}
inline virtual Size getSize(){return _segmTool.getSize();}
inline virtual void write( cv::FileStorage& fs ) const{_segmTool.write(fs);}
inline virtual void setup(String segmentationParameterFile, const bool applyDefaultSetupOnFailure){_segmTool.setup(segmentationParameterFile, applyDefaultSetupOnFailure);}
inline virtual void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure){_segmTool.setup(fs, applyDefaultSetupOnFailure);}
inline virtual void setup(SegmentationParameters newParameters){_segmTool.setup(newParameters);}
inline virtual const String printSetup(){return _segmTool.printSetup();}
inline virtual struct SegmentationParameters getParameters(){return _segmTool.getParameters();}
inline virtual void write( String fs ) const{_segmTool.write(fs);}
inline virtual void run(InputArray inputToSegment, const int channelIndex){_segmTool.run(inputToSegment, channelIndex);}
inline virtual void getSegmentationPicture(OutputArray transientAreas){return _segmTool.getSegmentationPicture(transientAreas);}
inline virtual void clearAllBuffers(){_segmTool.clearAllBuffers();}
inline virtual Size getSize() CV_OVERRIDE { return _segmTool.getSize(); }
inline virtual void write( cv::FileStorage& fs ) const CV_OVERRIDE { _segmTool.write(fs); }
inline virtual void setup(String segmentationParameterFile, const bool applyDefaultSetupOnFailure) CV_OVERRIDE { _segmTool.setup(segmentationParameterFile, applyDefaultSetupOnFailure); }
inline virtual void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure) CV_OVERRIDE { _segmTool.setup(fs, applyDefaultSetupOnFailure); }
inline virtual void setup(SegmentationParameters newParameters) CV_OVERRIDE { _segmTool.setup(newParameters); }
inline virtual const String printSetup() CV_OVERRIDE { return _segmTool.printSetup(); }
inline virtual struct SegmentationParameters getParameters() CV_OVERRIDE { return _segmTool.getParameters(); }
inline virtual void write( String fs ) const CV_OVERRIDE { _segmTool.write(fs); }
inline virtual void run(InputArray inputToSegment, const int channelIndex) CV_OVERRIDE { _segmTool.run(inputToSegment, channelIndex); }
inline virtual void getSegmentationPicture(OutputArray transientAreas) CV_OVERRIDE { return _segmTool.getSegmentationPicture(transientAreas); }
inline virtual void clearAllBuffers() CV_OVERRIDE { _segmTool.clearAllBuffers(); }
private:
TransientAreasSegmentationModuleImpl _segmTool;
@ -520,7 +520,7 @@ void TransientAreasSegmentationModuleImpl::_convertValarrayBuffer2cvMat(const st
{
// fill output buffer with the valarray buffer
const bool *valarrayPTR=get_data(grayMatrixToConvert);
outBuffer.create(cv::Size(nbColumns, nbRows), CV_8U);
Mat outMat = outBuffer.getMat();
for (unsigned int i=0;i<nbRows;++i)

Write Preview
Loading…
Cancel
Save