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

bioinspired: remove register specifier to prevent possible warnings from cxx11 compilers

Browse Source
pull/1318/head
Vladislav Sovrasov 8 years ago
parent 54d65f9d74
commit ec6ab8cdd5
11 changed files with 138 additions and 138 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 100
      modules/bioinspired/src/basicretinafilter.cpp
  2. 32
      modules/bioinspired/src/basicretinafilter.hpp
  3. 4
      modules/bioinspired/src/imagelogpolprojection.cpp
  4. 20
      modules/bioinspired/src/magnoretinafilter.cpp
  5. 12
      modules/bioinspired/src/magnoretinafilter.hpp
  6. 10
      modules/bioinspired/src/parvoretinafilter.cpp
  7. 36
      modules/bioinspired/src/retinacolor.cpp
  8. 14
      modules/bioinspired/src/retinacolor.hpp
  9. 20
      modules/bioinspired/src/retinafilter.cpp
  10. 26
      modules/bioinspired/src/templatebuffer.hpp
  11. 2
      modules/bioinspired/src/transientareassegmentationmodule.cpp

100
modules/bioinspired/src/basicretinafilter.cpp
Unescape View File

@ -326,7 +326,7 @@ void BasicRetinaFilter::_localLuminanceAdaptation(float *inputOutputFrame, const
/* const float *localLuminancePTR=localLuminance; /* const float *localLuminancePTR=localLuminance;
float *inputOutputFramePTR=inputOutputFrame; float *inputOutputFramePTR=inputOutputFrame;
for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputOutputFramePTR) for (unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputOutputFramePTR)
{ {
float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon; float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
*(inputOutputFramePTR) = (_maxInputValue+X0)**inputOutputFramePTR/(*inputOutputFramePTR +X0+0.00000000001); *(inputOutputFramePTR) = (_maxInputValue+X0)**inputOutputFramePTR/(*inputOutputFramePTR +X0+0.00000000001);
@ -353,7 +353,7 @@ void BasicRetinaFilter::_localLuminanceAdaptation(const float *inputFrame, const
const float *localLuminancePTR=localLuminance; const float *localLuminancePTR=localLuminance;
const float *inputFramePTR=inputFrame; const float *inputFramePTR=inputFrame;
float *outputFramePTR=outputFrame; float *outputFramePTR=outputFrame;
for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputFramePTR, ++outputFramePTR) for (unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputFramePTR, ++outputFramePTR)
{ {
float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon; float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
// TODO : the following line can lead to a divide by zero ! A small offset is added, take care if the offset is too large in case of High Dynamic Range images which can use very small values... // TODO : the following line can lead to a divide by zero ! A small offset is added, take care if the offset is too large in case of High Dynamic Range images which can use very small values...
@ -370,7 +370,7 @@ void BasicRetinaFilter::_localLuminanceAdaptationPosNegValues(const float *input
const float *inputFramePTR=inputFrame; const float *inputFramePTR=inputFrame;
float *outputFramePTR=outputFrame; float *outputFramePTR=outputFrame;
float factor=_maxInputValue*2.0f/(float)CV_PI; float factor=_maxInputValue*2.0f/(float)CV_PI;
for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputFramePTR) for (unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputFramePTR)
{ {
float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon; float X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
*(outputFramePTR++) = factor*atan(*inputFramePTR/X0);//(_maxInputValue+X0)**inputFramePTR/(*inputFramePTR +X0); *(outputFramePTR++) = factor*atan(*inputFramePTR/X0);//(_maxInputValue+X0)**inputFramePTR/(*inputFramePTR +X0);
@ -455,8 +455,8 @@ void BasicRetinaFilter::_horizontalCausalFilter(float *outputFrame, unsigned int
//#pragma omp parallel for //#pragma omp parallel for
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns();
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(outputPTR)+ _a* result; result = *(outputPTR)+ _a* result;
@ -472,9 +472,9 @@ void BasicRetinaFilter::_horizontalCausalFilter_addInput(const float *inputFrame
#else #else
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns();
register const float* inputPTR=inputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns(); const float* inputPTR=inputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns();
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(inputPTR++) + _tau**(outputPTR)+ _a* result; result = *(inputPTR++) + _tau**(outputPTR)+ _a* result;
@ -493,8 +493,8 @@ void BasicRetinaFilter::_horizontalAnticausalFilter(float *outputFrame, unsigned
#else #else
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(_filterOutput.getNBcolumns())-1; float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(_filterOutput.getNBcolumns())-1;
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(outputPTR)+ _a* result; result = *(outputPTR)+ _a* result;
@ -511,8 +511,8 @@ void BasicRetinaFilter::_horizontalAnticausalFilter_multGain(float *outputFrame,
//#pragma omp parallel for //#pragma omp parallel for
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(_filterOutput.getNBcolumns())-1; float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(_filterOutput.getNBcolumns())-1;
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(outputPTR)+ _a* result; result = *(outputPTR)+ _a* result;
@ -529,8 +529,8 @@ void BasicRetinaFilter::_verticalCausalFilter(float *outputFrame, unsigned int I
#else #else
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputFrame+IDcolumn; float *outputPTR=outputFrame+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
@ -551,8 +551,8 @@ void BasicRetinaFilter::_verticalAnticausalFilter(float *outputFrame, unsigned i
//#pragma omp parallel for //#pragma omp parallel for
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=offset+IDcolumn; float *outputPTR=offset+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
@ -574,8 +574,8 @@ void BasicRetinaFilter::_verticalAnticausalFilter_multGain(float *outputFrame, u
//#pragma omp parallel for //#pragma omp parallel for
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=offset+IDcolumn; float *outputPTR=offset+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
@ -594,11 +594,11 @@ void BasicRetinaFilter::_verticalAnticausalFilter_multGain(float *outputFrame, u
// -> squaring horizontal causal filter // -> squaring horizontal causal filter
void BasicRetinaFilter::_squaringHorizontalCausalFilter(const float *inputFrame, float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd) void BasicRetinaFilter::_squaringHorizontalCausalFilter(const float *inputFrame, float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
{ {
register float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns(); const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(inputPTR)**(inputPTR) + _tau**(outputPTR)+ _a* result; result = *(inputPTR)**(inputPTR) + _tau**(outputPTR)+ _a* result;
@ -611,12 +611,12 @@ void BasicRetinaFilter::_squaringHorizontalCausalFilter(const float *inputFrame,
// vertical anticausal filter that returns the mean value of its result // vertical anticausal filter that returns the mean value of its result
float BasicRetinaFilter::_verticalAnticausalFilter_returnMeanValue(float *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd) float BasicRetinaFilter::_verticalAnticausalFilter_returnMeanValue(float *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
{ {
register float meanValue=0; float meanValue=0;
float* offset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns(); float* offset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=offset+IDcolumn; float *outputPTR=offset+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
@ -653,12 +653,12 @@ void BasicRetinaFilter::_localSquaringSpatioTemporalLPfilter(const float *inputF
// this function take an image in input and squares it befor computing // this function take an image in input and squares it befor computing
void BasicRetinaFilter::_local_squaringHorizontalCausalFilter(const float *inputFrame, float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas) void BasicRetinaFilter::_local_squaringHorizontalCausalFilter(const float *inputFrame, float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas)
{ {
register float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns(); const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
const unsigned int *integrationAreasPTR=integrationAreas; const unsigned int *integrationAreasPTR=integrationAreas;
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
if (*(integrationAreasPTR++)) if (*(integrationAreasPTR++))
@ -675,12 +675,12 @@ void BasicRetinaFilter::_local_squaringHorizontalCausalFilter(const float *input
void BasicRetinaFilter::_local_horizontalAnticausalFilter(float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas) void BasicRetinaFilter::_local_horizontalAnticausalFilter(float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas)
{ {
register float* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1; float* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1;
const unsigned int *integrationAreasPTR=integrationAreas; const unsigned int *integrationAreasPTR=integrationAreas;
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
if (*(integrationAreasPTR++)) if (*(integrationAreasPTR++))
@ -699,8 +699,8 @@ void BasicRetinaFilter::_local_verticalCausalFilter(float *outputFrame, unsigned
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputFrame+IDcolumn; float *outputPTR=outputFrame+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
@ -722,8 +722,8 @@ void BasicRetinaFilter::_local_verticalAnticausalFilter_multGain(float *outputFr
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=offset+IDcolumn; float *outputPTR=offset+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
@ -786,11 +786,11 @@ void BasicRetinaFilter::_spatiotemporalLPfilter_Irregular(const float *inputFram
// horizontal causal filter wich runs on its input buffer // horizontal causal filter wich runs on its input buffer
void BasicRetinaFilter::_horizontalCausalFilter_Irregular(float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd) void BasicRetinaFilter::_horizontalCausalFilter_Irregular(float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
{ {
register float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowStart*_filterOutput.getNBcolumns(); const float* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowStart*_filterOutput.getNBcolumns();
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(outputPTR)+ *(spatialConstantPTR++)* result; result = *(outputPTR)+ *(spatialConstantPTR++)* result;
@ -802,12 +802,12 @@ void BasicRetinaFilter::_horizontalCausalFilter_Irregular(float *outputFrame, un
// horizontal causal filter with add input // horizontal causal filter with add input
void BasicRetinaFilter::_horizontalCausalFilter_Irregular_addInput(const float *inputFrame, float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd) void BasicRetinaFilter::_horizontalCausalFilter_Irregular_addInput(const float *inputFrame, float *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
{ {
register float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns(); const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowStart*_filterOutput.getNBcolumns(); const float* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowStart*_filterOutput.getNBcolumns();
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(inputPTR++) + _tau**(outputPTR)+ *(spatialConstantPTR++)* result; result = *(inputPTR++) + _tau**(outputPTR)+ *(spatialConstantPTR++)* result;
@ -823,12 +823,12 @@ void BasicRetinaFilter::_horizontalAnticausalFilter_Irregular(float *outputFrame
#ifdef MAKE_PARALLEL #ifdef MAKE_PARALLEL
cv::parallel_for_(cv::Range(IDrowStart,IDrowEnd), Parallel_horizontalAnticausalFilter_Irregular(outputFrame, spatialConstantBuffer, IDrowEnd, _filterOutput.getNBcolumns())); cv::parallel_for_(cv::Range(IDrowStart,IDrowEnd), Parallel_horizontalAnticausalFilter_Irregular(outputFrame, spatialConstantBuffer, IDrowEnd, _filterOutput.getNBcolumns()));
#else #else
register float* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1; float* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1;
register const float* spatialConstantPTR=spatialConstantBuffer+IDrowEnd*(_filterOutput.getNBcolumns())-1; const float* spatialConstantPTR=spatialConstantBuffer+IDrowEnd*(_filterOutput.getNBcolumns())-1;
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
result = *(outputPTR)+ *(spatialConstantPTR--)* result; result = *(outputPTR)+ *(spatialConstantPTR--)* result;
@ -847,9 +847,9 @@ void BasicRetinaFilter::_verticalCausalFilter_Irregular(float *outputFrame, unsi
#else #else
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputFrame+IDcolumn; float *outputPTR=outputFrame+IDcolumn;
register const float *spatialConstantPTR=spatialConstantBuffer+IDcolumn; const float *spatialConstantPTR=spatialConstantBuffer+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
result = *(outputPTR) + *(spatialConstantPTR) * result; result = *(outputPTR) + *(spatialConstantPTR) * result;
@ -869,10 +869,10 @@ void BasicRetinaFilter::_verticalAnticausalFilter_Irregular_multGain(float *outp
const float* gainOffset=&_progressiveGain[0]+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns(); const float* gainOffset=&_progressiveGain[0]+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputOffset+IDcolumn; float *outputPTR=outputOffset+IDcolumn;
register const float *spatialConstantPTR=constantOffset+IDcolumn; const float *spatialConstantPTR=constantOffset+IDcolumn;
register const float *progressiveGainPTR=gainOffset+IDcolumn; const float *progressiveGainPTR=gainOffset+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
result = *(outputPTR) + *(spatialConstantPTR) * result; result = *(outputPTR) + *(spatialConstantPTR) * result;

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

@ -498,8 +498,8 @@ namespace bioinspired
#endif #endif
for (int IDrow=r.start; IDrow!=r.end; ++IDrow) for (int IDrow=r.start; IDrow!=r.end; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(nbColumns)-1; float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(nbColumns)-1;
register float result=0; float result=0;
for (unsigned int index=0; index<nbColumns; ++index) for (unsigned int index=0; index<nbColumns; ++index)
{ {
result = *(outputPTR)+ filterParam_a* result; result = *(outputPTR)+ filterParam_a* result;
@ -523,9 +523,9 @@ namespace bioinspired
virtual void operator()( const Range& r ) const { virtual void operator()( const Range& r ) const {
for (int IDrow=r.start; IDrow!=r.end; ++IDrow) for (int IDrow=r.start; IDrow!=r.end; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowStart+IDrow)*nbColumns; float* outputPTR=outputFrame+(IDrowStart+IDrow)*nbColumns;
register const float* inputPTR=inputFrame+(IDrowStart+IDrow)*nbColumns; const float* inputPTR=inputFrame+(IDrowStart+IDrow)*nbColumns;
register float result=0; float result=0;
for (unsigned int index=0; index<nbColumns; ++index) for (unsigned int index=0; index<nbColumns; ++index)
{ {
result = *(inputPTR++) + filterParam_tau**(outputPTR)+ filterParam_a* result; result = *(inputPTR++) + filterParam_tau**(outputPTR)+ filterParam_a* result;
@ -548,8 +548,8 @@ namespace bioinspired
virtual void operator()( const Range& r ) const { virtual void operator()( const Range& r ) const {
for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn) for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputFrame+IDcolumn; float *outputPTR=outputFrame+IDcolumn;
for (unsigned int index=0; index<nbRows; ++index) for (unsigned int index=0; index<nbRows; ++index)
{ {
@ -576,8 +576,8 @@ namespace bioinspired
float* offset=outputFrame+nbColumns*nbRows-nbColumns; float* offset=outputFrame+nbColumns*nbRows-nbColumns;
for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn) for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=offset+IDcolumn; float *outputPTR=offset+IDcolumn;
for (unsigned int index=0; index<nbRows; ++index) for (unsigned int index=0; index<nbRows; ++index)
{ {
@ -604,7 +604,7 @@ namespace bioinspired
const float *localLuminancePTR=localLuminance+r.start; const float *localLuminancePTR=localLuminance+r.start;
const float *inputFramePTR=inputFrame+r.start; const float *inputFramePTR=inputFrame+r.start;
float *outputFramePTR=outputFrame+r.start; float *outputFramePTR=outputFrame+r.start;
for (register int IDpixel=r.start ; IDpixel!=r.end ; ++IDpixel, ++inputFramePTR, ++outputFramePTR) for (int IDpixel=r.start ; IDpixel!=r.end ; ++IDpixel, ++inputFramePTR, ++outputFramePTR)
{ {
float X0=*(localLuminancePTR++)*localLuminanceFactor+localLuminanceAddon; float X0=*(localLuminancePTR++)*localLuminanceFactor+localLuminanceAddon;
// TODO : the following line can lead to a divide by zero ! A small offset is added, take care if the offset is too large in case of High Dynamic Range images which can use very small values... // TODO : the following line can lead to a divide by zero ! A small offset is added, take care if the offset is too large in case of High Dynamic Range images which can use very small values...
@ -630,9 +630,9 @@ namespace bioinspired
for (int IDrow=r.start; IDrow!=r.end; ++IDrow) for (int IDrow=r.start; IDrow!=r.end; ++IDrow)
{ {
register float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(nbColumns)-1; float* outputPTR=outputFrame+(IDrowEnd-IDrow)*(nbColumns)-1;
register const float* spatialConstantPTR=spatialConstantBuffer+(IDrowEnd-IDrow)*(nbColumns)-1; const float* spatialConstantPTR=spatialConstantBuffer+(IDrowEnd-IDrow)*(nbColumns)-1;
register float result=0; float result=0;
for (unsigned int index=0; index<nbColumns; ++index) for (unsigned int index=0; index<nbColumns; ++index)
{ {
result = *(outputPTR)+ *(spatialConstantPTR--)* result; result = *(outputPTR)+ *(spatialConstantPTR--)* result;
@ -655,9 +655,9 @@ namespace bioinspired
virtual void operator()( const Range& r ) const { virtual void operator()( const Range& r ) const {
for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn) for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputFrame+IDcolumn; float *outputPTR=outputFrame+IDcolumn;
register const float* spatialConstantPTR=spatialConstantBuffer+IDcolumn; const float* spatialConstantPTR=spatialConstantBuffer+IDcolumn;
for (unsigned int index=0; index<nbRows; ++index) for (unsigned int index=0; index<nbRows; ++index)
{ {
result = *(outputPTR) + *(spatialConstantPTR) * result; result = *(outputPTR) + *(spatialConstantPTR) * result;

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

@ -410,7 +410,7 @@ std::valarray<float> &ImageLogPolProjection::runProjection(const std::valarray<f
_spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_tempBuffer[0]+_filterOutput.getNBpixels()*2); _spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_tempBuffer[0]+_filterOutput.getNBpixels()*2);
// applying image projection/resampling // applying image projection/resampling
register unsigned int *transformTablePTR=&_transformTable[0]; unsigned int *transformTablePTR=&_transformTable[0];
for (unsigned int i=0 ; i<_usefullpixelIndex ; i+=2, transformTablePTR+=2) for (unsigned int i=0 ; i<_usefullpixelIndex ; i+=2, transformTablePTR+=2)
{ {
#ifdef IMAGELOGPOLPROJECTION_DEBUG #ifdef IMAGELOGPOLPROJECTION_DEBUG
@ -430,7 +430,7 @@ std::valarray<float> &ImageLogPolProjection::runProjection(const std::valarray<f
_spatiotemporalLPfilter_Irregular(get_data(inputFrame), &_irregularLPfilteredFrame[0]); _spatiotemporalLPfilter_Irregular(get_data(inputFrame), &_irregularLPfilteredFrame[0]);
_spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_irregularLPfilteredFrame[0]); _spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_irregularLPfilteredFrame[0]);
// applying image projection/resampling // applying image projection/resampling
register unsigned int *transformTablePTR=&_transformTable[0]; unsigned int *transformTablePTR=&_transformTable[0];
for (unsigned int i=0 ; i<_usefullpixelIndex ; i+=2, transformTablePTR+=2) for (unsigned int i=0 ; i<_usefullpixelIndex ; i+=2, transformTablePTR+=2)
{ {
#ifdef IMAGELOGPOLPROJECTION_DEBUG #ifdef IMAGELOGPOLPROJECTION_DEBUG

20
modules/bioinspired/src/magnoretinafilter.cpp
Unescape View File

@ -158,12 +158,12 @@ void MagnoRetinaFilter::_amacrineCellsComputing(const float *OPL_ON, const float
#ifdef MAKE_PARALLEL #ifdef MAKE_PARALLEL
cv::parallel_for_(cv::Range(0,_filterOutput.getNBpixels()), Parallel_amacrineCellsComputing(OPL_ON, OPL_OFF, &_previousInput_ON[0], &_previousInput_OFF[0], &_amacrinCellsTempOutput_ON[0], &_amacrinCellsTempOutput_OFF[0], _temporalCoefficient)); cv::parallel_for_(cv::Range(0,_filterOutput.getNBpixels()), Parallel_amacrineCellsComputing(OPL_ON, OPL_OFF, &_previousInput_ON[0], &_previousInput_OFF[0], &_amacrinCellsTempOutput_ON[0], &_amacrinCellsTempOutput_OFF[0], _temporalCoefficient));
#else #else
register const float *OPL_ON_PTR=OPL_ON; const float *OPL_ON_PTR=OPL_ON;
register const float *OPL_OFF_PTR=OPL_OFF; const float *OPL_OFF_PTR=OPL_OFF;
register float *previousInput_ON_PTR= &_previousInput_ON[0]; float *previousInput_ON_PTR= &_previousInput_ON[0];
register float *previousInput_OFF_PTR= &_previousInput_OFF[0]; float *previousInput_OFF_PTR= &_previousInput_OFF[0];
register float *amacrinCellsTempOutput_ON_PTR= &_amacrinCellsTempOutput_ON[0]; float *amacrinCellsTempOutput_ON_PTR= &_amacrinCellsTempOutput_ON[0];
register float *amacrinCellsTempOutput_OFF_PTR= &_amacrinCellsTempOutput_OFF[0]; float *amacrinCellsTempOutput_OFF_PTR= &_amacrinCellsTempOutput_OFF[0];
for (unsigned int IDpixel=0 ; IDpixel<this->getNBpixels(); ++IDpixel) for (unsigned int IDpixel=0 ; IDpixel<this->getNBpixels(); ++IDpixel)
{ {
@ -200,10 +200,10 @@ const std::valarray<float> &MagnoRetinaFilter::runFilter(const std::valarray<flo
_localLuminanceAdaptation(&_magnoXOutputOFF[0], &_localProcessBufferOFF[0]); _localLuminanceAdaptation(&_magnoXOutputOFF[0], &_localProcessBufferOFF[0]);
/* Compute MagnoY */ /* Compute MagnoY */
register float *magnoYOutput= &(*_magnoYOutput)[0]; float *magnoYOutput= &(*_magnoYOutput)[0];
register float *magnoXOutputON_PTR= &_magnoXOutputON[0]; float *magnoXOutputON_PTR= &_magnoXOutputON[0];
register float *magnoXOutputOFF_PTR= &_magnoXOutputOFF[0]; float *magnoXOutputOFF_PTR= &_magnoXOutputOFF[0];
for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel) for (unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel)
*(magnoYOutput++)=*(magnoXOutputON_PTR++)+*(magnoXOutputOFF_PTR++); *(magnoYOutput++)=*(magnoXOutputON_PTR++)+*(magnoXOutputOFF_PTR++);
return (*_magnoYOutput); return (*_magnoYOutput);

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

@ -212,12 +212,12 @@ namespace bioinspired
: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) {} :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 {
register const float *OPL_ON_PTR=OPL_ON+r.start; const float *OPL_ON_PTR=OPL_ON+r.start;
register const float *OPL_OFF_PTR=OPL_OFF+r.start; const float *OPL_OFF_PTR=OPL_OFF+r.start;
register float *previousInput_ON_PTR= previousInput_ON+r.start; float *previousInput_ON_PTR= previousInput_ON+r.start;
register float *previousInput_OFF_PTR= previousInput_OFF+r.start; float *previousInput_OFF_PTR= previousInput_OFF+r.start;
register float *amacrinCellsTempOutput_ON_PTR= amacrinCellsTempOutput_ON+r.start; float *amacrinCellsTempOutput_ON_PTR= amacrinCellsTempOutput_ON+r.start;
register float *amacrinCellsTempOutput_OFF_PTR= amacrinCellsTempOutput_OFF+r.start; float *amacrinCellsTempOutput_OFF_PTR= amacrinCellsTempOutput_OFF+r.start;
for (int IDpixel=r.start ; IDpixel!=r.end; ++IDpixel) for (int IDpixel=r.start ; IDpixel!=r.end; ++IDpixel)
{ {

10
modules/bioinspired/src/parvoretinafilter.cpp
Unescape View File

@ -191,11 +191,11 @@ const std::valarray<float> &ParvoRetinaFilter::runFilter(const std::valarray<flo
// //
//// loop that makes the difference between photoreceptor cells output and horizontal cells //// loop that makes the difference between photoreceptor cells output and horizontal cells
//// positive part goes on the ON way, negative pat goes on the OFF way //// positive part goes on the ON way, negative pat goes on the OFF way
register float *parvocellularOutputONminusOFF_PTR=&(*_parvocellularOutputONminusOFF)[0]; float *parvocellularOutputONminusOFF_PTR=&(*_parvocellularOutputONminusOFF)[0];
register float *parvocellularOutputON_PTR=&_parvocellularOutputON[0]; float *parvocellularOutputON_PTR=&_parvocellularOutputON[0];
register float *parvocellularOutputOFF_PTR=&_parvocellularOutputOFF[0]; float *parvocellularOutputOFF_PTR=&_parvocellularOutputOFF[0];
for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel) for (unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel)
*(parvocellularOutputONminusOFF_PTR++)= (*(parvocellularOutputON_PTR++)-*(parvocellularOutputOFF_PTR++)); *(parvocellularOutputONminusOFF_PTR++)= (*(parvocellularOutputON_PTR++)-*(parvocellularOutputOFF_PTR++));
} }
return (*_parvocellularOutputONminusOFF); return (*_parvocellularOutputONminusOFF);
@ -217,7 +217,7 @@ void ParvoRetinaFilter::_OPL_OnOffWaysComputing() // WARNING : this method requi
float *parvocellularOutputOFF_PTR= &_parvocellularOutputOFF[0]; float *parvocellularOutputOFF_PTR= &_parvocellularOutputOFF[0];
// compute bipolar cells response equal to photoreceptors minus horizontal cells response // 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 // and copy the result on parvo cellular outputs... keeping time before their local contrast adaptation for final result
for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel) for (unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel)
{ {
float pixelDifference = *(photoreceptorsOutput_PTR++) -*(horizontalCellsOutput_PTR++); float pixelDifference = *(photoreceptorsOutput_PTR++) -*(horizontalCellsOutput_PTR++);
// test condition to allow write pixelDifference in ON or OFF buffer and 0 in the over // test condition to allow write pixelDifference in ON or OFF buffer and 0 in the over

36
modules/bioinspired/src/retinacolor.cpp
Unescape View File

@ -239,7 +239,7 @@ void RetinaColor::_initColorSampling()
_spatiotemporalLPfilter(&_RGBmosaic[0]+_filterOutput.getNBpixels(), &_colorLocalDensity[0]+_filterOutput.getNBpixels()); _spatiotemporalLPfilter(&_RGBmosaic[0]+_filterOutput.getNBpixels(), &_colorLocalDensity[0]+_filterOutput.getNBpixels());
_spatiotemporalLPfilter(&_RGBmosaic[0]+_filterOutput.getDoubleNBpixels(), &_colorLocalDensity[0]+_filterOutput.getDoubleNBpixels()); _spatiotemporalLPfilter(&_RGBmosaic[0]+_filterOutput.getDoubleNBpixels(), &_colorLocalDensity[0]+_filterOutput.getDoubleNBpixels());
unsigned int maxNBpixels=3*_filterOutput.getNBpixels(); unsigned int maxNBpixels=3*_filterOutput.getNBpixels();
register float *colorLocalDensityPTR=&_colorLocalDensity[0]; float *colorLocalDensityPTR=&_colorLocalDensity[0];
for (unsigned int i=0;i<maxNBpixels;++i, ++colorLocalDensityPTR) for (unsigned int i=0;i<maxNBpixels;++i, ++colorLocalDensityPTR)
*colorLocalDensityPTR=1.f/ *colorLocalDensityPTR; *colorLocalDensityPTR=1.f/ *colorLocalDensityPTR;
@ -258,8 +258,8 @@ void RetinaColor::runColorDemultiplexing(const std::valarray<float> &multiplexed
// -> first set demultiplexed frame to 0 // -> first set demultiplexed frame to 0
_demultiplexedTempBuffer=0; _demultiplexedTempBuffer=0;
// -> demultiplex process // -> demultiplex process
register unsigned int *colorSamplingPRT=&_colorSampling[0]; unsigned int *colorSamplingPRT=&_colorSampling[0];
register const float *multiplexedColorFramePtr=get_data(multiplexedColorFrame); const float *multiplexedColorFramePtr=get_data(multiplexedColorFrame);
for (unsigned int indexa=0; indexa<_filterOutput.getNBpixels() ; ++indexa) for (unsigned int indexa=0; indexa<_filterOutput.getNBpixels() ; ++indexa)
_demultiplexedTempBuffer[*(colorSamplingPRT++)]=*(multiplexedColorFramePtr++); _demultiplexedTempBuffer[*(colorSamplingPRT++)]=*(multiplexedColorFramePtr++);
@ -280,9 +280,9 @@ void RetinaColor::runColorDemultiplexing(const std::valarray<float> &multiplexed
}*/ }*/
// normalize by the photoreceptors local density and retrieve the local luminance // normalize by the photoreceptors local density and retrieve the local luminance
register float *chrominancePTR= &_chrominance[0]; float *chrominancePTR= &_chrominance[0];
register float *colorLocalDensityPTR= &_colorLocalDensity[0]; float *colorLocalDensityPTR= &_colorLocalDensity[0];
register float *luminance= &(*_luminance)[0]; float *luminance= &(*_luminance)[0];
if (!adaptiveFiltering)// compute the gradient on the luminance if (!adaptiveFiltering)// compute the gradient on the luminance
{ {
if (_samplingMethod==RETINA_COLOR_RANDOM) if (_samplingMethod==RETINA_COLOR_RANDOM)
@ -326,7 +326,7 @@ void RetinaColor::runColorDemultiplexing(const std::valarray<float> &multiplexed
}else }else
{ {
register const float *multiplexedColorFramePTR= get_data(multiplexedColorFrame); const float *multiplexedColorFramePTR= get_data(multiplexedColorFrame);
for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR) for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR)
{ {
// normalize by photoreceptors density // normalize by photoreceptors density
@ -412,8 +412,8 @@ void RetinaColor::runColorDemultiplexing(const std::valarray<float> &multiplexed
void RetinaColor::runColorMultiplexing(const std::valarray<float> &demultiplexedInputFrame, std::valarray<float> &multiplexedFrame) void RetinaColor::runColorMultiplexing(const std::valarray<float> &demultiplexedInputFrame, std::valarray<float> &multiplexedFrame)
{ {
// multiply each color layer by its bayer mask // multiply each color layer by its bayer mask
register unsigned int *colorSamplingPTR= &_colorSampling[0]; unsigned int *colorSamplingPTR= &_colorSampling[0];
register float *multiplexedFramePTR= &multiplexedFrame[0]; float *multiplexedFramePTR= &multiplexedFrame[0];
for (unsigned int indexp=0; indexp<_filterOutput.getNBpixels(); ++indexp) for (unsigned int indexp=0; indexp<_filterOutput.getNBpixels(); ++indexp)
*(multiplexedFramePTR++)=demultiplexedInputFrame[*(colorSamplingPTR++)]; *(multiplexedFramePTR++)=demultiplexedInputFrame[*(colorSamplingPTR++)];
} }
@ -440,8 +440,8 @@ void RetinaColor::clipRGBOutput_0_maxInputValue(float *inputOutputBuffer, const
#ifdef MAKE_PARALLEL // call the TemplateBuffer TBB clipping method #ifdef MAKE_PARALLEL // call the TemplateBuffer TBB clipping method
cv::parallel_for_(cv::Range(0,_filterOutput.getNBpixels()*3), Parallel_clipBufferValues<float>(inputOutputBuffer, 0, maxInputValue)); cv::parallel_for_(cv::Range(0,_filterOutput.getNBpixels()*3), Parallel_clipBufferValues<float>(inputOutputBuffer, 0, maxInputValue));
#else #else
register float *inputOutputBufferPTR=inputOutputBuffer; float *inputOutputBufferPTR=inputOutputBuffer;
for (register unsigned int jf = 0; jf < _filterOutput.getNBpixels()*3; ++jf, ++inputOutputBufferPTR) for (unsigned int jf = 0; jf < _filterOutput.getNBpixels()*3; ++jf, ++inputOutputBufferPTR)
{ {
if (*inputOutputBufferPTR>maxInputValue) if (*inputOutputBufferPTR>maxInputValue)
*inputOutputBufferPTR=maxInputValue; *inputOutputBufferPTR=maxInputValue;
@ -587,12 +587,12 @@ void RetinaColor::_adaptiveHorizontalCausalFilter_addInput(const float *inputFra
#ifdef MAKE_PARALLEL #ifdef MAKE_PARALLEL
cv::parallel_for_(cv::Range(IDrowStart,IDrowEnd), Parallel_adaptiveHorizontalCausalFilter_addInput(inputFrame, outputFrame, &_imageGradient[0], _filterOutput.getNBcolumns())); cv::parallel_for_(cv::Range(IDrowStart,IDrowEnd), Parallel_adaptiveHorizontalCausalFilter_addInput(inputFrame, outputFrame, &_imageGradient[0], _filterOutput.getNBcolumns()));
#else #else
register float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns(); float* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns(); const float* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
register const float *imageGradientPTR= &_imageGradient[0]+IDrowStart*_filterOutput.getNBcolumns(); const float *imageGradientPTR= &_imageGradient[0]+IDrowStart*_filterOutput.getNBcolumns();
for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow) for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index) for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
{ {
//std::cout<<(*imageGradientPTR)<<" "; //std::cout<<(*imageGradientPTR)<<" ";
@ -616,9 +616,9 @@ void RetinaColor::_adaptiveVerticalAnticausalFilter_multGain(float *outputFrame,
for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn) for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=outputOffset+IDcolumn; float *outputPTR=outputOffset+IDcolumn;
register float *imageGradientPTR=gradOffset+IDcolumn; float *imageGradientPTR=gradOffset+IDcolumn;
for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index) for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
{ {
result = *(outputPTR) + (*(imageGradientPTR)) * result; result = *(outputPTR) + (*(imageGradientPTR)) * result;

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

@ -291,12 +291,12 @@ namespace bioinspired
virtual void operator()( const Range& r ) const virtual void operator()( const Range& r ) const
{ {
register float* outputPTR=outputFrame+r.start*nbColumns; float* outputPTR=outputFrame+r.start*nbColumns;
register const float* inputPTR=inputFrame+r.start*nbColumns; const float* inputPTR=inputFrame+r.start*nbColumns;
register const float *imageGradientPTR= imageGradient+r.start*nbColumns; const float *imageGradientPTR= imageGradient+r.start*nbColumns;
for (int IDrow=r.start; IDrow!=r.end; ++IDrow) for (int IDrow=r.start; IDrow!=r.end; ++IDrow)
{ {
register float result=0; float result=0;
for (unsigned int index=0; index<nbColumns; ++index) for (unsigned int index=0; index<nbColumns; ++index)
{ {
result = *(inputPTR++) + (*imageGradientPTR++)* result; result = *(inputPTR++) + (*imageGradientPTR++)* result;
@ -322,9 +322,9 @@ namespace bioinspired
const float* gradOffset= imageGradient+nbColumns*nbRows-nbColumns; const float* gradOffset= imageGradient+nbColumns*nbRows-nbColumns;
for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn) for (int IDcolumn=r.start; IDcolumn!=r.end; ++IDcolumn)
{ {
register float result=0; float result=0;
register float *outputPTR=offset+IDcolumn; float *outputPTR=offset+IDcolumn;
register const float *imageGradientPTR=gradOffset+IDcolumn; const float *imageGradientPTR=gradOffset+IDcolumn;
for (unsigned int index=0; index<nbRows; ++index) for (unsigned int index=0; index<nbRows; ++index)
{ {
result = *(outputPTR) + *(imageGradientPTR) * result; result = *(outputPTR) + *(imageGradientPTR) * result;

20
modules/bioinspired/src/retinafilter.cpp
Unescape View File

@ -469,10 +469,10 @@ namespace bioinspired
// return image with center Parvo and peripheral Magno channels // return image with center Parvo and peripheral Magno channels
void RetinaFilter::_processRetinaParvoMagnoMapping() void RetinaFilter::_processRetinaParvoMagnoMapping()
{ {
register float *hybridParvoMagnoPTR= &_retinaParvoMagnoMappedFrame[0]; float *hybridParvoMagnoPTR= &_retinaParvoMagnoMappedFrame[0];
register const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput()); const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput());
register const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput()); const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput());
register float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0]; float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0];
for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2) for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2)
{ {
@ -491,9 +491,9 @@ namespace bioinspired
if (parvoFovealResponse.size() != _ParvoRetinaFilter.getNBpixels()) if (parvoFovealResponse.size() != _ParvoRetinaFilter.getNBpixels())
return false; return false;
register const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput()); const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput());
register float *fovealParvoResponsePTR= &parvoFovealResponse[0]; float *fovealParvoResponsePTR= &parvoFovealResponse[0];
register float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0]; float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0];
for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2) for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2)
{ {
@ -511,9 +511,9 @@ namespace bioinspired
if (magnoParafovealResponse.size() != _MagnoRetinaFilter.getNBpixels()) if (magnoParafovealResponse.size() != _MagnoRetinaFilter.getNBpixels())
return false; return false;
register const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput()); const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput());
register float *parafovealMagnoResponsePTR=&magnoParafovealResponse[0]; float *parafovealMagnoResponsePTR=&magnoParafovealResponse[0];
register float *hybridParvoMagnoCoefTablePTR=&_retinaParvoMagnoMapCoefTable[0]+1; float *hybridParvoMagnoCoefTablePTR=&_retinaParvoMagnoMapCoefTable[0]+1;
for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2) for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2)
{ {

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

@ -95,8 +95,8 @@ public:
: bufferToClip(bufferToProcess), minValue(min), maxValue(max) { } : bufferToClip(bufferToProcess), minValue(min), maxValue(max) { }
virtual void operator()( const cv::Range &r ) const { virtual void operator()( const cv::Range &r ) const {
register type *inputOutputBufferPTR=bufferToClip+r.start; type *inputOutputBufferPTR=bufferToClip+r.start;
for (register int jf = r.start; jf != r.end; ++jf, ++inputOutputBufferPTR) for (int jf = r.start; jf != r.end; ++jf, ++inputOutputBufferPTR)
{ {
if (*inputOutputBufferPTR>maxValue) if (*inputOutputBufferPTR>maxValue)
*inputOutputBufferPTR=maxValue; *inputOutputBufferPTR=maxValue;
@ -430,8 +430,8 @@ public:
type maxValue=inputOutputBuffer[0], minValue=inputOutputBuffer[0]; type maxValue=inputOutputBuffer[0], minValue=inputOutputBuffer[0];
// get the min and max value // get the min and max value
register type *inputOutputBufferPTR=inputOutputBuffer; type *inputOutputBufferPTR=inputOutputBuffer;
for (register size_t j = 0; j<processedPixels; ++j) for (size_t j = 0; j<processedPixels; ++j)
{ {
type pixValue = *(inputOutputBufferPTR++); type pixValue = *(inputOutputBufferPTR++);
if (maxValue < pixValue) if (maxValue < pixValue)
@ -445,7 +445,7 @@ public:
type offset = (type)(-minValue*factor); type offset = (type)(-minValue*factor);
inputOutputBufferPTR=inputOutputBuffer; inputOutputBufferPTR=inputOutputBuffer;
for (register size_t j = 0; j < processedPixels; ++j, ++inputOutputBufferPTR) for (size_t j = 0; j < processedPixels; ++j, ++inputOutputBufferPTR)
*inputOutputBufferPTR=*(inputOutputBufferPTR)*factor+offset; *inputOutputBufferPTR=*(inputOutputBufferPTR)*factor+offset;
} }
@ -460,10 +460,10 @@ public:
type X0cube=sensitivity*sensitivity*sensitivity; type X0cube=sensitivity*sensitivity*sensitivity;
register type *inputBufferPTR=inputBuffer; type *inputBufferPTR=inputBuffer;
register type *outputBufferPTR=outputBuffer; type *outputBufferPTR=outputBuffer;
for (register size_t j = 0; j < _NBpixels; ++j, ++inputBufferPTR) for (size_t j = 0; j < _NBpixels; ++j, ++inputBufferPTR)
{ {
type currentCubeLuminance=*inputBufferPTR**inputBufferPTR**inputBufferPTR; type currentCubeLuminance=*inputBufferPTR**inputBufferPTR**inputBufferPTR;
@ -485,10 +485,10 @@ public:
type X0=maxOutputValue/(sensitivity-(type)1.0); type X0=maxOutputValue/(sensitivity-(type)1.0);
register type *inputBufferPTR=inputBuffer; type *inputBufferPTR=inputBuffer;
register type *outputBufferPTR=outputBuffer; type *outputBufferPTR=outputBuffer;
for (register size_t j = 0; j < nbPixels; ++j, ++inputBufferPTR) for (size_t j = 0; j < nbPixels; ++j, ++inputBufferPTR)
*(outputBufferPTR++)=(meanValue+(meanValue+X0)*(*(inputBufferPTR)-meanValue)/(_abs(*(inputBufferPTR)-meanValue)+X0)); *(outputBufferPTR++)=(meanValue+(meanValue+X0)*(*(inputBufferPTR)-meanValue)/(_abs(*(inputBufferPTR)-meanValue)+X0));
} }
@ -503,12 +503,12 @@ public:
type meanValue=0, stdValue=0; type meanValue=0, stdValue=0;
// compute mean value // compute mean value
for (register size_t j = 0; j < _NBpixels; ++j) for (size_t j = 0; j < _NBpixels; ++j)
meanValue+=inputOutputBuffer[j]; meanValue+=inputOutputBuffer[j];
meanValue/=((type)_NBpixels); meanValue/=((type)_NBpixels);
// compute std value // compute std value
register type *inputOutputBufferPTR=inputOutputBuffer; type *inputOutputBufferPTR=inputOutputBuffer;
for (size_t index=0;index<_NBpixels;++index) for (size_t index=0;index<_NBpixels;++index)
{ {
type inputMinusMean=*(inputOutputBufferPTR++)-meanValue; type inputMinusMean=*(inputOutputBufferPTR++)-meanValue;

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

@ -462,7 +462,7 @@ void TransientAreasSegmentationModuleImpl::_run(const std::valarray<float> &inpu
float*localMotionPTR=&_localMotion[0], *neighborhoodMotionPTR=&_neighborhoodMotion[0], *contextMotionPTR=&_contextMotionEnergy[0]; float*localMotionPTR=&_localMotion[0], *neighborhoodMotionPTR=&_neighborhoodMotion[0], *contextMotionPTR=&_contextMotionEnergy[0];
// float meanEnergy=LPfilter2.sum()/(float)_LPfilter2.size(); // float meanEnergy=LPfilter2.sum()/(float)_LPfilter2.size();
register bool *segmentationPicturePTR= &_segmentedAreas[0]; bool *segmentationPicturePTR= &_segmentedAreas[0];
for (unsigned int index=0; index<_filterOutput.getNBpixels() ; ++index, ++segmentationPicturePTR, ++localMotionPTR, ++neighborhoodMotionPTR, contextMotionPTR++) for (unsigned int index=0; index<_filterOutput.getNBpixels() ; ++index, ++segmentationPicturePTR, ++localMotionPTR, ++neighborhoodMotionPTR, contextMotionPTR++)
{ {
float generalMotionContextDecision=*neighborhoodMotionPTR-*contextMotionPTR; float generalMotionContextDecision=*neighborhoodMotionPTR-*contextMotionPTR;

Write Preview
Loading…
Cancel
Save