Skip to content

O
opencv_contrib
Commit 5f2d7974 authored by Alexander Alekhin's avatar Alexander Alekhin
Browse files
Options

Merge pull request #1318 from sovrasov:bioinspired_improvement

parents e7a2e63e 53b82426
Hide whitespace changes
Inline Side-by-side
Showing with 260 additions and 363 deletions
modules/bioinspired/include/opencv2/bioinspired/retina.hpp
View file @ 5f2d7974
...@@ -422,32 +422,30 @@ public: ...@@ -422,32 +422,30 @@ public:
Retina::getParvo methods Retina::getParvo methods
*/ */
CV_WRAP virtual void activateContoursProcessing(const bool activate)=0; CV_WRAP virtual void activateContoursProcessing(const bool activate)=0;
};
//! @relates bioinspired::Retina
//! @{
/** @overload */
CV_EXPORTS_W Ptr<Retina> createRetina(Size inputSize);
/** @brief Constructors from standardized interfaces : retreive a smart pointer to a Retina instance
@param inputSize the input frame size
@param colorMode the chosen processing mode : with or without color processing
@param colorSamplingMethod specifies which kind of color sampling will be used :
- cv::bioinspired::RETINA_COLOR_RANDOM: each pixel position is either R, G or B in a random choice
- cv::bioinspired::RETINA_COLOR_DIAGONAL: color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...
- cv::bioinspired::RETINA_COLOR_BAYER: standard bayer sampling
@param useRetinaLogSampling activate retina log sampling, if true, the 2 following parameters can
be used
@param reductionFactor only usefull if param useRetinaLogSampling=true, specifies the reduction
factor of the output frame (as the center (fovea) is high resolution and corners can be
underscaled, then a reduction of the output is allowed without precision leak
@param samplingStrenght only usefull if param useRetinaLogSampling=true, specifies the strenght of
the log scale that is applied
*/
CV_EXPORTS_W Ptr<Retina> createRetina(Size inputSize, const bool colorMode, int colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const float reductionFactor=1.0f, const float samplingStrenght=10.0f);
//! @} /** @overload */
CV_WRAP static Ptr<Retina> create(Size inputSize);
/** @brief Constructors from standardized interfaces : retreive a smart pointer to a Retina instance
@param inputSize the input frame size
@param colorMode the chosen processing mode : with or without color processing
@param colorSamplingMethod specifies which kind of color sampling will be used :
- cv::bioinspired::RETINA_COLOR_RANDOM: each pixel position is either R, G or B in a random choice
- cv::bioinspired::RETINA_COLOR_DIAGONAL: color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...
- cv::bioinspired::RETINA_COLOR_BAYER: standard bayer sampling
@param useRetinaLogSampling activate retina log sampling, if true, the 2 following parameters can
be used
@param reductionFactor only usefull if param useRetinaLogSampling=true, specifies the reduction
factor of the output frame (as the center (fovea) is high resolution and corners can be
underscaled, then a reduction of the output is allowed without precision leak
@param samplingStrenght only usefull if param useRetinaLogSampling=true, specifies the strenght of
the log scale that is applied
*/
CV_WRAP static Ptr<Retina> create(Size inputSize, const bool colorMode,
int colorSamplingMethod=RETINA_COLOR_BAYER,
const bool useRetinaLogSampling=false,
const float reductionFactor=1.0f, const float samplingStrenght=10.0f);
};
//! @} //! @}
......
modules/bioinspired/include/opencv2/bioinspired/retinafasttonemapping.hpp
View file @ 5f2d7974
...@@ -126,10 +126,10 @@ public: ...@@ -126,10 +126,10 @@ public:
(default is 1, see reference paper) (default is 1, see reference paper)
*/ */
CV_WRAP virtual void setup(const float photoreceptorsNeighborhoodRadius=3.f, const float ganglioncellsNeighborhoodRadius=1.f, const float meanLuminanceModulatorK=1.f)=0; CV_WRAP virtual void setup(const float photoreceptorsNeighborhoodRadius=3.f, const float ganglioncellsNeighborhoodRadius=1.f, const float meanLuminanceModulatorK=1.f)=0;
CV_WRAP static Ptr<RetinaFastToneMapping> create(Size inputSize);
}; };
//! @relates bioinspired::RetinaFastToneMapping
CV_EXPORTS_W Ptr<RetinaFastToneMapping> createRetinaFastToneMapping(Size inputSize);
//! @} //! @}
......
modules/bioinspired/include/opencv2/bioinspired/transientareassegmentationmodule.hpp
View file @ 5f2d7974
...@@ -187,13 +187,12 @@ public: ...@@ -187,13 +187,12 @@ public:
/** @brief cleans all the buffers of the instance /** @brief cleans all the buffers of the instance
*/ */
CV_WRAP virtual void clearAllBuffers()=0; CV_WRAP virtual void clearAllBuffers()=0;
};
/** @brief allocator /** @brief allocator
@param inputSize : size of the images input to segment (output will be the same size) @param inputSize : size of the images input to segment (output will be the same size)
@relates bioinspired::TransientAreasSegmentationModule */
*/ CV_WRAP static Ptr<TransientAreasSegmentationModule> create(Size inputSize);
CV_EXPORTS_W Ptr<TransientAreasSegmentationModule> createTransientAreasSegmentationModule(Size inputSize); };
//! @} //! @}
......
modules/bioinspired/perf/opencl/perf_retina.ocl.cpp
View file @ 5f2d7974
...@@ -29,7 +29,7 @@ OCL_PERF_TEST_P(RetinaFixture, Retina, ...@@ -29,7 +29,7 @@ OCL_PERF_TEST_P(RetinaFixture, Retina,
UMat ocl_parvo, ocl_magno; UMat ocl_parvo, ocl_magno;
{ {
Ptr<cv::bioinspired::Retina> retina = cv::bioinspired::createRetina( Ptr<cv::bioinspired::Retina> retina = cv::bioinspired::Retina::create(
input.size(), colorMode, colorSamplingMethod, useLogSampling, input.size(), colorMode, colorSamplingMethod, useLogSampling,
reductionFactor, samplingStrength); reductionFactor, samplingStrength);
......
modules/bioinspired/samples/OpenEXRimages_HDR_Retina_toneMapping.cpp
View file @ 5f2d7974
...@@ -220,10 +220,10 @@ int main(int argc, char* argv[]) ...@@ -220,10 +220,10 @@ int main(int argc, char* argv[])
*/ */
if (useLogSampling) if (useLogSampling)
{ {
retina = cv::bioinspired::createRetina(inputImage.size(),true, cv::bioinspired::RETINA_COLOR_BAYER, true, 2.0, 10.0); retina = cv::bioinspired::Retina::create(inputImage.size(),true, cv::bioinspired::RETINA_COLOR_BAYER, true, 2.0, 10.0);
} }
else// -> else allocate "classical" retina : else// -> else allocate "classical" retina :
retina = cv::bioinspired::createRetina(inputImage.size()); retina = cv::bioinspired::Retina::create(inputImage.size());
// create a fast retina tone mapper (Meyla&al algorithm) // create a fast retina tone mapper (Meyla&al algorithm)
std::cout<<"Allocating fast tone mapper..."<<std::endl; std::cout<<"Allocating fast tone mapper..."<<std::endl;
......
modules/bioinspired/samples/basicRetina.cpp deleted 100644 → 0
View file @ e7a2e63e
//============================================================================
// Name : retinademo.cpp
// Author : Alexandre Benoit, benoit.alexandre.vision@gmail.com
// Version : 0.1
// Copyright : LISTIC/GIPSA French Labs, May 2015
// Description : Gipsa/LISTIC Labs quick retina demo in C++, Ansi-style
//============================================================================
// include bioinspired module and OpenCV core utilities
#include "opencv2/bioinspired.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/videoio.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
#include <cstring>
// main function
int main(int argc, char* argv[]) {
// basic input arguments checking
if (argc>1)
{
std::cout<<"****************************************************"<<std::endl;
std::cout<<"* Retina demonstration : demonstrates the use of is a wrapper class of the Gipsa/Listic Labs retina model."<<std::endl;
std::cout<<"* This retina model allows spatio-temporal image processing (applied on a webcam sequences)."<<std::endl;
std::cout<<"* As a summary, these are the retina model properties:"<<std::endl;
std::cout<<"* => It applies a spectral whithening (mid-frequency details enhancement)"<<std::endl;
std::cout<<"* => high frequency spatio-temporal noise reduction"<<std::endl;
std::cout<<"* => low frequency luminance to be reduced (luminance range compression)"<<std::endl;
std::cout<<"* => local logarithmic luminance compression allows details to be enhanced in low light conditions\n"<<std::endl;
std::cout<<"* for more information, reer to the following papers :"<<std::endl;
std::cout<<"* Benoit A., Caplier A., Durette B., Herault, J., \"USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING\", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011"<<std::endl;
std::cout<<"* Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891."<<std::endl;
std::cout<<"* => reports comments/remarks at benoit.alexandre.vision@gmail.com"<<std::endl;
std::cout<<"* => more informations and papers at : http://sites.google.com/site/benoitalexandrevision/"<<std::endl;
std::cout<<"****************************************************"<<std::endl;
std::cout<<" NOTE : this program generates the default retina parameters file 'RetinaDefaultParameters.xml'"<<std::endl;
std::cout<<" => you can use this to fine tune parameters and load them if you save to file 'RetinaSpecificParameters.xml'"<<std::endl;
if (strcmp(argv[1], "help")==0){
std::cout<<"No help provided for now, please test the retina Demo for a more complete program"<<std::endl;
}
}
std::string inputMediaType=argv[1];
// declare the retina input buffer.
cv::Mat inputFrame;
// setup webcam reader and grab a first frame to get its size
cv::VideoCapture videoCapture(0);
videoCapture>>inputFrame;
// allocate a retina instance with input size equal to the one of the loaded image
cv::Ptr<cv::bioinspired::Retina> myRetina = cv::bioinspired::createRetina(inputFrame.size());
/* retina parameters management methods use sample
-> save current (here default) retina parameters to a xml file (you may use it only one time to get the file and modify it)
*/
myRetina->write("RetinaDefaultParameters.xml");
// -> load parameters if file exists
myRetina->setup("RetinaSpecificParameters.xml");
// reset all retina buffers (open your eyes)
myRetina->clearBuffers();
// declare retina output buffers
cv::Mat retinaOutput_parvo;
cv::Mat retinaOutput_magno;
//main processing loop
bool stillProcess=true;
while(stillProcess){
// if using video stream, then, grabbing a new frame, else, input remains the same
if (videoCapture.isOpened())
videoCapture>>inputFrame;
else
stillProcess=false;
// run retina filter
myRetina->run(inputFrame);
// Retrieve and display retina output
myRetina->getParvo(retinaOutput_parvo);
myRetina->getMagno(retinaOutput_magno);
cv::imshow("retina input", inputFrame);
cv::imshow("Retina Parvo", retinaOutput_parvo);
cv::imshow("Retina Magno", retinaOutput_magno);
cv::waitKey(5);
}
}
modules/bioinspired/samples/retinaDemo.cpp
View file @ 5f2d7974
...@@ -13,96 +13,66 @@ ...@@ -13,96 +13,66 @@
#include "opencv2/imgcodecs.hpp" #include "opencv2/imgcodecs.hpp"
#include "opencv2/videoio.hpp" #include "opencv2/videoio.hpp"
#include "opencv2/highgui.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/core/ocl.hpp"
static void help(std::string errorMessage) const std::string keys =
{ "{image | | Input from image file }"
std::cout<<"Program init error : "<<errorMessage<<std::endl; "{video | | Input from video file }"
std::cout<<"\nProgram call procedure : retinaDemo [processing mode] [Optional : media target] [Optional LAST parameter: \"log\" to activate retina log sampling]"<<std::endl; "{camera | 0 | Index of input camera. If image or video is not specified, camera 0 will be used }"
std::cout<<"\t[processing mode] :"<<std::endl; "{log | | Activate retina log sampling }"
std::cout<<"\t -image : for still image processing"<<std::endl; "{ocl | | Use OpenCL acceleration if possible }"
std::cout<<"\t -video : for video stream processing"<<std::endl; "{help | | Print help}";
std::cout<<"\t[Optional : media target] :"<<std::endl;
std::cout<<"\t if processing an image or video file, then, specify the path and filename of the target to process"<<std::endl;
std::cout<<"\t leave empty if processing video stream coming from a connected video device"<<std::endl;
std::cout<<"\t[Optional : activate retina log sampling] : an optional last parameter can be specified for retina spatial log sampling"<<std::endl;
std::cout<<"\t set \"log\" without quotes to activate this sampling, output frame size will be divided by 4"<<std::endl;
std::cout<<"\nExamples:"<<std::endl;
std::cout<<"\t-Image processing : ./retinaDemo -image lena.jpg"<<std::endl;
std::cout<<"\t-Image processing with log sampling : ./retinaDemo -image lena.jpg log"<<std::endl;
std::cout<<"\t-Video processing : ./retinaDemo -video myMovie.mp4"<<std::endl;
std::cout<<"\t-Live video processing : ./retinaDemo -video"<<std::endl;
std::cout<<"\nPlease start again with new parameters"<<std::endl;
}
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
// welcome message // welcome message
std::cout<<"****************************************************"<<std::endl; std::cout<<"****************************************************"<<std::endl
std::cout<<"* Retina demonstration : demonstrates the use of is a wrapper class of the Gipsa/Listic Labs retina model."<<std::endl; <<"* Retina demonstration : demonstrates the use of is a wrapper class of the Gipsa/Listic Labs retina model."<<std::endl
std::cout<<"* This retina model allows spatio-temporal image processing (applied on still images, video sequences)."<<std::endl; <<"* This retina model allows spatio-temporal image processing (applied on still images, video sequences)."<<std::endl
std::cout<<"* As a summary, these are the retina model properties:"<<std::endl; <<"* As a summary, these are the retina model properties:"<<std::endl
std::cout<<"* => It applies a spectral whithening (mid-frequency details enhancement)"<<std::endl; <<"* => It applies a spectral whithening (mid-frequency details enhancement)"<<std::endl
std::cout<<"* => high frequency spatio-temporal noise reduction"<<std::endl; <<"* => high frequency spatio-temporal noise reduction"<<std::endl
std::cout<<"* => low frequency luminance to be reduced (luminance range compression)"<<std::endl; <<"* => low frequency luminance to be reduced (luminance range compression)"<<std::endl
std::cout<<"* => local logarithmic luminance compression allows details to be enhanced in low light conditions\n"<<std::endl; <<"* => local logarithmic luminance compression allows details to be enhanced in low light conditions\n"<<std::endl
std::cout<<"* for more information, reer to the following papers :"<<std::endl; <<"* for more information, reer to the following papers :"<<std::endl
std::cout<<"* Benoit A., Caplier A., Durette B., Herault, J., \"USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING\", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011"<<std::endl; <<"* Benoit A., Caplier A., Durette B., Herault, J., \"USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING\", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011"<<std::endl
std::cout<<"* Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891."<<std::endl; <<"* Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891."<<std::endl
std::cout<<"* => reports comments/remarks at benoit.alexandre.vision@gmail.com"<<std::endl; <<"* => reports comments/remarks at benoit.alexandre.vision@gmail.com"<<std::endl
std::cout<<"* => more informations and papers at : http://sites.google.com/site/benoitalexandrevision/"<<std::endl; <<"* => more informations and papers at : http://sites.google.com/site/benoitalexandrevision/"<<std::endl
std::cout<<"****************************************************"<<std::endl; <<"****************************************************"<<std::endl
std::cout<<" NOTE : this program generates the default retina parameters file 'RetinaDefaultParameters.xml'"<<std::endl; <<" NOTE : this program generates the default retina parameters file 'RetinaDefaultParameters.xml'"<<std::endl
std::cout<<" => you can use this to fine tune parameters and load them if you save to file 'RetinaSpecificParameters.xml'"<<std::endl; <<" => you can use this to fine tune parameters and load them if you save to file 'RetinaSpecificParameters.xml'"<<std::endl;
// basic input arguments checking cv::CommandLineParser parser(argc, argv, keys);
if (argc<2) if(!parser.check() || parser.has("help")) {
{ parser.printMessage();
help("bad number of parameter"); return 0;
return -1; }
}
bool useLogSampling = parser.has("log"); // check if user wants retina log sampling processing
bool useLogSampling = !strcmp(argv[argc-1], "log"); // check if user wants retina log sampling processing bool useOCL = parser.has("ocl");
cv::ocl::setUseOpenCL(useOCL);
std::string inputMediaType=argv[1]; if(useOCL && !cv::ocl::useOpenCL())
std::cout << "Failed to enable OpenCL\n";
// declare the retina input buffer... that will be fed differently in regard of the input media // declare the retina input buffer... that will be fed differently in regard of the input media
cv::Mat inputFrame; cv::Mat inputFrame;
cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here
////////////////////////////////////////////////////////////////////////////// if(parser.has("video"))
// checking input media type (still image, video file, live video acquisition) videoCapture.open(parser.get<cv::String>("video"));
if (!strcmp(inputMediaType.c_str(), "-image") && argc >= 3) else if(parser.has("image"))
{ inputFrame = cv::imread(parser.get<cv::String>("image"));
std::cout<<"RetinaDemo: processing image "<<argv[2]<<std::endl; else
// image processing case videoCapture.open(parser.get<int>("camera"));
inputFrame = cv::imread(std::string(argv[2]), 1); // load image in RGB mode
}else
if (!strcmp(inputMediaType.c_str(), "-video"))
{
if (argc == 2 || (argc == 3 && useLogSampling)) // attempt to grab images from a video capture device
{
videoCapture.open(0);
}else// attempt to grab images from a video filestream
{
std::cout<<"RetinaDemo: processing video stream "<<argv[2]<<std::endl;
videoCapture.open(argv[2]);
}
// grab a first frame to check if everything is ok
videoCapture>>inputFrame;
}else
{
// bad command parameter
help("bad command parameter");
return -1;
}
if (inputFrame.empty()) videoCapture >> inputFrame;
{
help("Input media could not be loaded, aborting");
return -1;
}
if(inputFrame.empty())
{
std::cout << "Failed to open media source\n";
return 0;
}
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// Program start in a try/catch safety context (Retina may throw errors) // Program start in a try/catch safety context (Retina may throw errors)
...@@ -114,10 +84,11 @@ int main(int argc, char* argv[]) ...@@ -114,10 +84,11 @@ int main(int argc, char* argv[])
// if the last parameter is 'log', then activate log sampling (favour foveal vision and subsamples peripheral vision) // if the last parameter is 'log', then activate log sampling (favour foveal vision and subsamples peripheral vision)
if (useLogSampling) if (useLogSampling)
{ {
myRetina = cv::bioinspired::createRetina(inputFrame.size(), true, cv::bioinspired::RETINA_COLOR_BAYER, true, 2.0, 10.0); myRetina = cv::bioinspired::Retina::create(inputFrame.size(),
true, cv::bioinspired::RETINA_COLOR_BAYER, true, 2.0, 10.0);
} }
else// -> else allocate "classical" retina : else// -> else allocate "classical" retina :
myRetina = cv::bioinspired::createRetina(inputFrame.size()); myRetina = cv::bioinspired::Retina::create(inputFrame.size());
// save default retina parameters file in order to let you see this and maybe modify it and reload using method "setup" // save default retina parameters file in order to let you see this and maybe modify it and reload using method "setup"
myRetina->write("RetinaDefaultParameters.xml"); myRetina->write("RetinaDefaultParameters.xml");
...@@ -127,35 +98,43 @@ int main(int argc, char* argv[]) ...@@ -127,35 +98,43 @@ int main(int argc, char* argv[])
myRetina->clearBuffers(); myRetina->clearBuffers();
// declare retina output buffers // declare retina output buffers
cv::Mat retinaOutput_parvo; cv::UMat retinaOutput_parvo;
cv::Mat retinaOutput_magno; cv::UMat retinaOutput_magno;
// processing loop with stop condition // processing loop with stop condition
bool continueProcessing=true; // FIXME : not yet managed during process... int64 totalTime = 0;
while(continueProcessing) int64 totalFrames = 0;
while(true)
{ {
// if using video stream, then, grabbing a new frame, else, input remains the same // if using video stream, then, grabbing a new frame, else, input remains the same
if (videoCapture.isOpened()) if (videoCapture.isOpened())
videoCapture>>inputFrame; videoCapture>>inputFrame;
if(inputFrame.empty())
break;
// run retina filter // run retina filter
int64 frameTime = cv::getTickCount();
myRetina->run(inputFrame); myRetina->run(inputFrame);
// Retrieve and display retina output // Retrieve and display retina output
frameTime = cv::getTickCount() - frameTime;
totalTime += frameTime;
totalFrames++;
myRetina->getParvo(retinaOutput_parvo); myRetina->getParvo(retinaOutput_parvo);
myRetina->getMagno(retinaOutput_magno); myRetina->getMagno(retinaOutput_magno);
cv::imshow("retina input", inputFrame); cv::imshow("retina input", inputFrame);
cv::imshow("Retina Parvo", retinaOutput_parvo); cv::imshow("Retina Parvo", retinaOutput_parvo);
cv::imshow("Retina Magno", retinaOutput_magno); cv::imshow("Retina Magno", retinaOutput_magno);
cv::waitKey(5); int key = cv::waitKey(5);
if(key == 'q')
break;
} }
}catch(cv::Exception e) std::cout << "\nMean frame processing time: " << (totalTime / cv::getTickFrequency()) / totalFrames << " s" << std::endl;
std::cout << "Retina demo end" << std::endl;
}
catch(const cv::Exception& e)
{ {
std::cerr<<"Error using Retina : "<<e.what()<<std::endl; std::cerr<<"Error using Retina : "<<e.what()<<std::endl;
} }
// Program end message
std::cout<<"Retina demo end"<<std::endl;
return 0; return 0;
} }
modules/bioinspired/src/basicretinafilter.cpp
View file @ 5f2d7974
...@@ -326,7 +326,7 @@ void BasicRetinaFilter::_localLuminanceAdaptation(float *inputOutputFrame, const ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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, ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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, ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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;
......
modules/bioinspired/src/basicretinafilter.hpp
View file @ 5f2d7974
...@@ -498,8 +498,8 @@ namespace bioinspired ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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;
......
modules/bioinspired/src/imagelogpolprojection.cpp
View file @ 5f2d7974
...@@ -410,7 +410,7 @@ std::valarray<float> &ImageLogPolProjection::runProjection(const std::valarray<f ...@@ -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 ...@@ -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
......
modules/bioinspired/src/magnoretinafilter.cpp
View file @ 5f2d7974
...@@ -158,12 +158,12 @@ void MagnoRetinaFilter::_amacrineCellsComputing(const float *OPL_ON, const float ...@@ -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 ...@@ -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);
......
modules/bioinspired/src/magnoretinafilter.hpp
View file @ 5f2d7974
...@@ -212,12 +212,12 @@ namespace bioinspired ...@@ -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)
{ {
......
modules/bioinspired/src/parvoretinafilter.cpp
View file @ 5f2d7974
...@@ -191,11 +191,11 @@ const std::valarray<float> &ParvoRetinaFilter::runFilter(const std::valarray<flo ...@@ -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 ...@@ -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
......
modules/bioinspired/src/retina.cpp
View file @ 5f2d7974
...@@ -293,6 +293,7 @@ private: ...@@ -293,6 +293,7 @@ private:
bool _convertCvMat2ValarrayBuffer(InputArray inputMatToConvert, std::valarray<float> &outputValarrayMatrix); bool _convertCvMat2ValarrayBuffer(InputArray inputMatToConvert, std::valarray<float> &outputValarrayMatrix);
bool _wasOCLRunCalled;
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
ocl::RetinaOCLImpl* _ocl_retina; ocl::RetinaOCLImpl* _ocl_retina;
...@@ -305,12 +306,12 @@ private: ...@@ -305,12 +306,12 @@ private:
}; };
// smart pointers allocation : // smart pointers allocation :
Ptr<Retina> createRetina(Size inputSize) Ptr<Retina> Retina::create(Size inputSize)
{ {
return makePtr<RetinaImpl>(inputSize); return makePtr<RetinaImpl>(inputSize);
} }
Ptr<Retina> createRetina(Size inputSize, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght) Ptr<Retina> Retina::create(Size inputSize, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght)
{ {
return makePtr<RetinaImpl>(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght); return makePtr<RetinaImpl>(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
} }
...@@ -334,7 +335,7 @@ RetinaImpl::RetinaImpl(const cv::Size inputSz, const bool colorMode, int colorSa ...@@ -334,7 +335,7 @@ RetinaImpl::RetinaImpl(const cv::Size inputSz, const bool colorMode, int colorSa
_init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght); _init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
_ocl_retina = 0; _ocl_retina = 0;
if (inputSz.width % 4 == 0) if (inputSz.width % 4 == 0 && !useRetinaLogSampling)
_ocl_retina = new ocl::RetinaOCLImpl(inputSz, colorMode, colorSamplingMethod, _ocl_retina = new ocl::RetinaOCLImpl(inputSz, colorMode, colorSamplingMethod,
useRetinaLogSampling, reductionFactor, samplingStrenght); useRetinaLogSampling, reductionFactor, samplingStrenght);
#endif #endif
...@@ -564,6 +565,7 @@ void RetinaImpl::setupIPLMagnoChannel(const bool normaliseOutput, const float pa ...@@ -564,6 +565,7 @@ void RetinaImpl::setupIPLMagnoChannel(const bool normaliseOutput, const float pa
bool RetinaImpl::ocl_run(InputArray inputMatToConvert) bool RetinaImpl::ocl_run(InputArray inputMatToConvert)
{ {
_ocl_retina->run(inputMatToConvert); _ocl_retina->run(inputMatToConvert);
_wasOCLRunCalled = true;
return true; return true;
} }
#endif #endif
...@@ -572,6 +574,7 @@ void RetinaImpl::run(InputArray inputMatToConvert) ...@@ -572,6 +574,7 @@ void RetinaImpl::run(InputArray inputMatToConvert)
{ {
CV_OCL_RUN((_ocl_retina != 0), ocl_run(inputMatToConvert)); CV_OCL_RUN((_ocl_retina != 0), ocl_run(inputMatToConvert));
_wasOCLRunCalled = false;
// first convert input image to the compatible format : std::valarray<float> // first convert input image to the compatible format : std::valarray<float>
const bool colorMode = _convertCvMat2ValarrayBuffer(inputMatToConvert.getMat(), _inputBuffer); const bool colorMode = _convertCvMat2ValarrayBuffer(inputMatToConvert.getMat(), _inputBuffer);
// process the retina // process the retina
...@@ -603,6 +606,7 @@ void RetinaImpl::applyFastToneMapping(InputArray inputImage, OutputArray outputT ...@@ -603,6 +606,7 @@ void RetinaImpl::applyFastToneMapping(InputArray inputImage, OutputArray outputT
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
bool RetinaImpl::ocl_getParvo(OutputArray retinaOutput_parvo) bool RetinaImpl::ocl_getParvo(OutputArray retinaOutput_parvo)
{ {
CV_Assert(_wasOCLRunCalled);
_ocl_retina->getParvo(retinaOutput_parvo); _ocl_retina->getParvo(retinaOutput_parvo);
return true; return true;
} }
...@@ -611,6 +615,7 @@ bool RetinaImpl::ocl_getParvo(OutputArray retinaOutput_parvo) ...@@ -611,6 +615,7 @@ bool RetinaImpl::ocl_getParvo(OutputArray retinaOutput_parvo)
void RetinaImpl::getParvo(OutputArray retinaOutput_parvo) void RetinaImpl::getParvo(OutputArray retinaOutput_parvo)
{ {
CV_OCL_RUN((_ocl_retina != 0) && retinaOutput_parvo.isUMat(), ocl_getParvo(retinaOutput_parvo)); CV_OCL_RUN((_ocl_retina != 0) && retinaOutput_parvo.isUMat(), ocl_getParvo(retinaOutput_parvo));
CV_Assert(!_wasOCLRunCalled);
if (_retinaFilter->getColorMode()) if (_retinaFilter->getColorMode())
{ {
...@@ -627,6 +632,7 @@ void RetinaImpl::getParvo(OutputArray retinaOutput_parvo) ...@@ -627,6 +632,7 @@ void RetinaImpl::getParvo(OutputArray retinaOutput_parvo)
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
bool RetinaImpl::ocl_getMagno(OutputArray retinaOutput_magno) bool RetinaImpl::ocl_getMagno(OutputArray retinaOutput_magno)
{ {
CV_Assert(_wasOCLRunCalled);
_ocl_retina->getMagno(retinaOutput_magno); _ocl_retina->getMagno(retinaOutput_magno);
return true; return true;
} }
...@@ -635,6 +641,7 @@ bool RetinaImpl::ocl_getMagno(OutputArray retinaOutput_magno) ...@@ -635,6 +641,7 @@ bool RetinaImpl::ocl_getMagno(OutputArray retinaOutput_magno)
void RetinaImpl::getMagno(OutputArray retinaOutput_magno) void RetinaImpl::getMagno(OutputArray retinaOutput_magno)
{ {
CV_OCL_RUN((_ocl_retina != 0) && retinaOutput_magno.isUMat(), ocl_getMagno(retinaOutput_magno)); CV_OCL_RUN((_ocl_retina != 0) && retinaOutput_magno.isUMat(), ocl_getMagno(retinaOutput_magno));
CV_Assert(!_wasOCLRunCalled);
// reallocate output buffer (if necessary) // reallocate output buffer (if necessary)
_convertValarrayBuffer2cvMat(_retinaFilter->getMovingContours(), _retinaFilter->getOutputNBrows(), _retinaFilter->getOutputNBcolumns(), false, retinaOutput_magno); _convertValarrayBuffer2cvMat(_retinaFilter->getMovingContours(), _retinaFilter->getOutputNBrows(), _retinaFilter->getOutputNBcolumns(), false, retinaOutput_magno);
...@@ -644,6 +651,7 @@ void RetinaImpl::getMagno(OutputArray retinaOutput_magno) ...@@ -644,6 +651,7 @@ void RetinaImpl::getMagno(OutputArray retinaOutput_magno)
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
bool RetinaImpl::ocl_getMagnoRAW(OutputArray magnoOutputBufferCopy) bool RetinaImpl::ocl_getMagnoRAW(OutputArray magnoOutputBufferCopy)
{ {
CV_Assert(_wasOCLRunCalled);
_ocl_retina->getMagnoRAW(magnoOutputBufferCopy); _ocl_retina->getMagnoRAW(magnoOutputBufferCopy);
return true; return true;
} }
...@@ -653,7 +661,7 @@ bool RetinaImpl::ocl_getMagnoRAW(OutputArray magnoOutputBufferCopy) ...@@ -653,7 +661,7 @@ bool RetinaImpl::ocl_getMagnoRAW(OutputArray magnoOutputBufferCopy)
void RetinaImpl::getMagnoRAW(OutputArray magnoOutputBufferCopy){ void RetinaImpl::getMagnoRAW(OutputArray magnoOutputBufferCopy){
CV_OCL_RUN((_ocl_retina != 0) && magnoOutputBufferCopy.isUMat(), ocl_getMagnoRAW(magnoOutputBufferCopy)); CV_OCL_RUN((_ocl_retina != 0) && magnoOutputBufferCopy.isUMat(), ocl_getMagnoRAW(magnoOutputBufferCopy));
CV_Assert(!_wasOCLRunCalled);
// get magno channel header // get magno channel header
const cv::Mat magnoChannel=cv::Mat(getMagnoRAW()); const cv::Mat magnoChannel=cv::Mat(getMagnoRAW());
// copy data // copy data
...@@ -663,6 +671,7 @@ void RetinaImpl::getMagnoRAW(OutputArray magnoOutputBufferCopy){ ...@@ -663,6 +671,7 @@ void RetinaImpl::getMagnoRAW(OutputArray magnoOutputBufferCopy){
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCL
bool RetinaImpl::ocl_getParvoRAW(OutputArray parvoOutputBufferCopy) bool RetinaImpl::ocl_getParvoRAW(OutputArray parvoOutputBufferCopy)
{ {
CV_Assert(_wasOCLRunCalled);
_ocl_retina->getParvoRAW(parvoOutputBufferCopy); _ocl_retina->getParvoRAW(parvoOutputBufferCopy);
return true; return true;
} }
...@@ -671,7 +680,7 @@ bool RetinaImpl::ocl_getParvoRAW(OutputArray parvoOutputBufferCopy) ...@@ -671,7 +680,7 @@ bool RetinaImpl::ocl_getParvoRAW(OutputArray parvoOutputBufferCopy)
void RetinaImpl::getParvoRAW(OutputArray parvoOutputBufferCopy){ void RetinaImpl::getParvoRAW(OutputArray parvoOutputBufferCopy){
CV_OCL_RUN((_ocl_retina != 0) && parvoOutputBufferCopy.isUMat(), ocl_getParvoRAW(parvoOutputBufferCopy)); CV_OCL_RUN((_ocl_retina != 0) && parvoOutputBufferCopy.isUMat(), ocl_getParvoRAW(parvoOutputBufferCopy));
CV_Assert(!_wasOCLRunCalled);
// get parvo channel header // get parvo channel header
const cv::Mat parvoChannel=cv::Mat(getParvoRAW()); const cv::Mat parvoChannel=cv::Mat(getParvoRAW());
// copy data // copy data
...@@ -680,12 +689,14 @@ void RetinaImpl::getParvoRAW(OutputArray parvoOutputBufferCopy){ ...@@ -680,12 +689,14 @@ void RetinaImpl::getParvoRAW(OutputArray parvoOutputBufferCopy){
// original API level data accessors : get buffers addresses... // original API level data accessors : get buffers addresses...
const Mat RetinaImpl::getMagnoRAW() const { const Mat RetinaImpl::getMagnoRAW() const {
CV_Assert(!_wasOCLRunCalled);
// create a cv::Mat header for the valarray // create a cv::Mat header for the valarray
return Mat((int)_retinaFilter->getMovingContours().size(),1, CV_32F, (void*)get_data(_retinaFilter->getMovingContours())); return Mat((int)_retinaFilter->getMovingContours().size(),1, CV_32F, (void*)get_data(_retinaFilter->getMovingContours()));
} }
const Mat RetinaImpl::getParvoRAW() const { const Mat RetinaImpl::getParvoRAW() const {
CV_Assert(!_wasOCLRunCalled);
if (_retinaFilter->getColorMode()) // check if color mode is enabled if (_retinaFilter->getColorMode()) // check if color mode is enabled
{ {
// create a cv::Mat table (for RGB planes as a single vector) // create a cv::Mat table (for RGB planes as a single vector)
...@@ -699,6 +710,7 @@ const Mat RetinaImpl::getParvoRAW() const { ...@@ -699,6 +710,7 @@ const Mat RetinaImpl::getParvoRAW() const {
// private method called by constructors // private method called by constructors
void RetinaImpl::_init(const cv::Size inputSz, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght) void RetinaImpl::_init(const cv::Size inputSz, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght)
{ {
_wasOCLRunCalled = false;
// basic error check // basic error check
if (inputSz.height*inputSz.width <= 0) if (inputSz.height*inputSz.width <= 0)
throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "RetinaImpl::setup", "Retina.cpp", 0); throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "RetinaImpl::setup", "Retina.cpp", 0);
......
modules/bioinspired/src/retinacolor.cpp
View file @ 5f2d7974
...@@ -239,7 +239,7 @@ void RetinaColor::_initColorSampling() ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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, ...@@ -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;
......
modules/bioinspired/src/retinacolor.hpp
View file @ 5f2d7974
...@@ -291,12 +291,12 @@ namespace bioinspired ...@@ -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 ...@@ -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;
......
modules/bioinspired/src/retinafasttonemapping.cpp
View file @ 5f2d7974
...@@ -309,7 +309,7 @@ void _runRGBToneMapping(const std::valarray<float> &RGBimageInput, std::valarray ...@@ -309,7 +309,7 @@ void _runRGBToneMapping(const std::valarray<float> &RGBimageInput, std::valarray
}; };
CV_EXPORTS Ptr<RetinaFastToneMapping> createRetinaFastToneMapping(Size inputSize) Ptr<RetinaFastToneMapping> RetinaFastToneMapping::create(Size inputSize)
{ {
return makePtr<RetinaFastToneMappingImpl>(inputSize); return makePtr<RetinaFastToneMappingImpl>(inputSize);
} }
......
modules/bioinspired/src/retinafilter.cpp
View file @ 5f2d7974
...@@ -469,10 +469,10 @@ namespace bioinspired ...@@ -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 ...@@ -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 ...@@ -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)
{ {
......
modules/bioinspired/src/templatebuffer.hpp
View file @ 5f2d7974
...@@ -95,8 +95,8 @@ public: ...@@ -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: ...@@ -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: ...@@ -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: ...@@ -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: ...@@ -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: ...@@ -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;
......
modules/bioinspired/src/transientareassegmentationmodule.cpp
View file @ 5f2d7974
...@@ -247,7 +247,7 @@ private: ...@@ -247,7 +247,7 @@ private:
* allocator * allocator
* @param Size : size of the images input to segment (output will be the same size) * @param Size : size of the images input to segment (output will be the same size)
*/ */
Ptr<TransientAreasSegmentationModule> createTransientAreasSegmentationModule(Size inputSize){ Ptr<TransientAreasSegmentationModule> TransientAreasSegmentationModule::create(Size inputSize){
return makePtr<TransientAreasSegmentationModuleImpl_>(inputSize); return makePtr<TransientAreasSegmentationModuleImpl_>(inputSize);
} }
...@@ -462,7 +462,7 @@ void TransientAreasSegmentationModuleImpl::_run(const std::valarray<float> &inpu ...@@ -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;
......
modules/bioinspired/test/test_retina_ocl.cpp
View file @ 5f2d7974
...@@ -76,7 +76,7 @@ OCL_TEST_P(Retina_OCL, Accuracy) ...@@ -76,7 +76,7 @@ OCL_TEST_P(Retina_OCL, Accuracy)
Mat input = imread(cvtest::TS::ptr()->get_data_path() + "shared/lena.png", colorMode); Mat input = imread(cvtest::TS::ptr()->get_data_path() + "shared/lena.png", colorMode);
CV_Assert(!input.empty()); CV_Assert(!input.empty());
Ptr<bioinspired::Retina> retina = bioinspired::createRetina( Ptr<bioinspired::Retina> retina = bioinspired::Retina::create(
input.size(), input.size(),
colorMode, colorMode,
colorSamplingMethod, colorSamplingMethod,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment