Skip to content

O
opencv
Commit 415978b1 authored by Anatoly Baksheev's avatar Anatoly Baksheev
Browse files
Options

warnings

parent fbe2e6fb
Hide whitespace changes
Inline Side-by-side
Showing with 453 additions and 455 deletions
modules/contrib/src/hybridtracker.cpp
View file @ 415978b1
...@@ -199,15 +199,15 @@ void CvHybridTracker::updateTrackerWithEM(Mat image) { ...@@ -199,15 +199,15 @@ void CvHybridTracker::updateTrackerWithEM(Mat image) {
for (int i = 0; i < proj.rows; i++) for (int i = 0; i < proj.rows; i++)
for (int j = 0; j < proj.cols; j++) for (int j = 0; j < proj.cols; j++)
if (proj.at<double> (i, j) > 0) { if (proj.at<double> (i, j) > 0) {
samples->data.fl[count * 2] = i; samples->data.fl[count * 2] = (float)i;
samples->data.fl[count * 2 + 1] = j; samples->data.fl[count * 2 + 1] = (float)j;
count++; count++;
} }
em_model.train(samples, 0, params.em_params, labels); em_model.train(samples, 0, params.em_params, labels);
curr_center.x = em_model.getMeans().at<double> (0, 0); curr_center.x = (float)em_model.getMeans().at<double> (0, 0);
curr_center.y = em_model.getMeans().at<double> (0, 1); curr_center.y = (float)em_model.getMeans().at<double> (0, 1);
} }
void CvHybridTracker::updateTrackerWithLowPassFilter(Mat image) { void CvHybridTracker::updateTrackerWithLowPassFilter(Mat image) {
......
modules/contrib/src/retinafilter.cpp
View file @ 415978b1
...@@ -73,459 +73,457 @@ ...@@ -73,459 +73,457 @@
namespace cv namespace cv
{ {
// standard constructor without any log sampling of the input frame // standard constructor without any log sampling of the input frame
RetinaFilter::RetinaFilter(const unsigned int sizeRows, const unsigned int sizeColumns, const bool colorMode, const RETINA_COLORSAMPLINGMETHOD samplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght) RetinaFilter::RetinaFilter(const unsigned int sizeRows, const unsigned int sizeColumns, const bool colorMode, const RETINA_COLORSAMPLINGMETHOD samplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
: :
_retinaParvoMagnoMappedFrame(0), _retinaParvoMagnoMappedFrame(0),
_retinaParvoMagnoMapCoefTable(0), _retinaParvoMagnoMapCoefTable(0),
_photoreceptorsPrefilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor), 4), _photoreceptorsPrefilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor), 4),
_ParvoRetinaFilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor)), _ParvoRetinaFilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor)),
_MagnoRetinaFilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor)), _MagnoRetinaFilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor)),
_colorEngine((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor), samplingMethod), _colorEngine((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor), samplingMethod),
// configure retina photoreceptors log sampling... if necessary // configure retina photoreceptors log sampling... if necessary
_photoreceptorsLogSampling(NULL) _photoreceptorsLogSampling(NULL)
{ {
#ifdef RETINADEBUG #ifdef RETINADEBUG
std::cout<<"RetinaFilter::size( "<<_photoreceptorsPrefilter.getNBrows()<<", "<<_photoreceptorsPrefilter.getNBcolumns()<<")"<<" =? "<<_photoreceptorsPrefilter.getNBpixels()<<std::endl; std::cout<<"RetinaFilter::size( "<<_photoreceptorsPrefilter.getNBrows()<<", "<<_photoreceptorsPrefilter.getNBcolumns()<<")"<<" =? "<<_photoreceptorsPrefilter.getNBpixels()<<std::endl;
#endif #endif
if (useRetinaLogSampling) if (useRetinaLogSampling)
{ {
_photoreceptorsLogSampling = new ImageLogPolProjection(sizeRows, sizeColumns, ImageLogPolProjection::RETINALOGPROJECTION, true); _photoreceptorsLogSampling = new ImageLogPolProjection(sizeRows, sizeColumns, ImageLogPolProjection::RETINALOGPROJECTION, true);
if (!_photoreceptorsLogSampling->initProjection(reductionFactor, samplingStrenght)) if (!_photoreceptorsLogSampling->initProjection(reductionFactor, samplingStrenght))
{ {
std::cerr<<"RetinaFilter::Problem initializing photoreceptors log sampling, could not setup retina filter"<<std::endl; std::cerr<<"RetinaFilter::Problem initializing photoreceptors log sampling, could not setup retina filter"<<std::endl;
delete _photoreceptorsLogSampling; delete _photoreceptorsLogSampling;
_photoreceptorsLogSampling=NULL; _photoreceptorsLogSampling=NULL;
} }
else else
{ {
#ifdef RETINADEBUG #ifdef RETINADEBUG
std::cout<<"_photoreceptorsLogSampling::size( "<<_photoreceptorsLogSampling->getNBrows()<<", "<<_photoreceptorsLogSampling->getNBcolumns()<<")"<<" =? "<<_photoreceptorsLogSampling->getNBpixels()<<std::endl; std::cout<<"_photoreceptorsLogSampling::size( "<<_photoreceptorsLogSampling->getNBrows()<<", "<<_photoreceptorsLogSampling->getNBcolumns()<<")"<<" =? "<<_photoreceptorsLogSampling->getNBpixels()<<std::endl;
#endif #endif
} }
} }
// set default processing activities // set default processing activities
_useParvoOutput=true; _useParvoOutput=true;
_useMagnoOutput=true; _useMagnoOutput=true;
_useColorMode=colorMode; _useColorMode=colorMode;
// create hybrid output and related coefficient table // create hybrid output and related coefficient table
_createHybridTable(); _createHybridTable();
// set default parameters // set default parameters
setGlobalParameters(); setGlobalParameters();
// stability controls values init // stability controls values init
_setInitPeriodCount(); _setInitPeriodCount();
_globalTemporalConstant=25; _globalTemporalConstant=25;
// reset all buffers // reset all buffers
clearAllBuffers(); clearAllBuffers();
// std::cout<<"RetinaFilter::size( "<<this->getNBrows()<<", "<<this->getNBcolumns()<<")"<<_filterOutput.size()<<" =? "<<_filterOutput.getNBpixels()<<std::endl; // std::cout<<"RetinaFilter::size( "<<this->getNBrows()<<", "<<this->getNBcolumns()<<")"<<_filterOutput.size()<<" =? "<<_filterOutput.getNBpixels()<<std::endl;
} }
// destructor // destructor
RetinaFilter::~RetinaFilter() RetinaFilter::~RetinaFilter()
{ {
if (_photoreceptorsLogSampling!=NULL) if (_photoreceptorsLogSampling!=NULL)
delete _photoreceptorsLogSampling; delete _photoreceptorsLogSampling;
} }
// function that clears all buffers of the object // function that clears all buffers of the object
void RetinaFilter::clearAllBuffers() void RetinaFilter::clearAllBuffers()
{ {
_photoreceptorsPrefilter.clearAllBuffers(); _photoreceptorsPrefilter.clearAllBuffers();
_ParvoRetinaFilter.clearAllBuffers(); _ParvoRetinaFilter.clearAllBuffers();
_MagnoRetinaFilter.clearAllBuffers(); _MagnoRetinaFilter.clearAllBuffers();
_colorEngine.clearAllBuffers(); _colorEngine.clearAllBuffers();
if (_photoreceptorsLogSampling!=NULL) if (_photoreceptorsLogSampling!=NULL)
_photoreceptorsLogSampling->clearAllBuffers(); _photoreceptorsLogSampling->clearAllBuffers();
// stability controls value init // stability controls value init
_setInitPeriodCount(); _setInitPeriodCount();
} }
/** /**
* resize retina filter object (resize all allocated buffers * resize retina filter object (resize all allocated buffers
* @param NBrows: the new height size * @param NBrows: the new height size
* @param NBcolumns: the new width size * @param NBcolumns: the new width size
*/ */
void RetinaFilter::resize(const unsigned int NBrows, const unsigned int NBcolumns) void RetinaFilter::resize(const unsigned int NBrows, const unsigned int NBcolumns)
{ {
unsigned int rows=NBrows, cols=NBcolumns; unsigned int rows=NBrows, cols=NBcolumns;
// resize optionnal member and adjust other modules size if required // resize optionnal member and adjust other modules size if required
if (_photoreceptorsLogSampling) if (_photoreceptorsLogSampling)
{ {
_photoreceptorsLogSampling->resize(NBrows, NBcolumns); _photoreceptorsLogSampling->resize(NBrows, NBcolumns);
rows=_photoreceptorsLogSampling->getOutputNBrows(); rows=_photoreceptorsLogSampling->getOutputNBrows();
cols=_photoreceptorsLogSampling->getOutputNBcolumns(); cols=_photoreceptorsLogSampling->getOutputNBcolumns();
} }
_photoreceptorsPrefilter.resize(rows, cols); _photoreceptorsPrefilter.resize(rows, cols);
_ParvoRetinaFilter.resize(rows, cols); _ParvoRetinaFilter.resize(rows, cols);
_MagnoRetinaFilter.resize(rows, cols); _MagnoRetinaFilter.resize(rows, cols);
_colorEngine.resize(rows, cols); _colorEngine.resize(rows, cols);
// reset parvo magno mapping // reset parvo magno mapping
_createHybridTable(); _createHybridTable();
// clean buffers // clean buffers
clearAllBuffers(); clearAllBuffers();
} }
// stability controls value init // stability controls value init
void RetinaFilter::_setInitPeriodCount() void RetinaFilter::_setInitPeriodCount()
{ {
// find out the maximum temporal constant value and apply a security factor // find out the maximum temporal constant value and apply a security factor
// false value (obviously too long) but appropriate for simple use // false value (obviously too long) but appropriate for simple use
_globalTemporalConstant=(unsigned int)(_ParvoRetinaFilter.getPhotoreceptorsTemporalConstant()+_ParvoRetinaFilter.getHcellsTemporalConstant()+_MagnoRetinaFilter.getTemporalConstant()); _globalTemporalConstant=(unsigned int)(_ParvoRetinaFilter.getPhotoreceptorsTemporalConstant()+_ParvoRetinaFilter.getHcellsTemporalConstant()+_MagnoRetinaFilter.getTemporalConstant());
// reset frame counter // reset frame counter
_ellapsedFramesSinceLastReset=0; _ellapsedFramesSinceLastReset=0;
} }
void RetinaFilter::_createHybridTable() void RetinaFilter::_createHybridTable()
{ {
// create hybrid output and related coefficient table // create hybrid output and related coefficient table
_retinaParvoMagnoMappedFrame.resize(_photoreceptorsPrefilter.getNBpixels()); _retinaParvoMagnoMappedFrame.resize(_photoreceptorsPrefilter.getNBpixels());
_retinaParvoMagnoMapCoefTable.resize(_photoreceptorsPrefilter.getNBpixels()*2); _retinaParvoMagnoMapCoefTable.resize(_photoreceptorsPrefilter.getNBpixels()*2);
// fill _hybridParvoMagnoCoefTable // fill _hybridParvoMagnoCoefTable
int i, j, halfRows=_photoreceptorsPrefilter.getNBrows()/2, halfColumns=_photoreceptorsPrefilter.getNBcolumns()/2; int i, j, halfRows=_photoreceptorsPrefilter.getNBrows()/2, halfColumns=_photoreceptorsPrefilter.getNBcolumns()/2;
float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0]; float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0];
float minDistance=(float)MIN(halfRows, halfColumns)*0.7; float minDistance=(float)MIN(halfRows, halfColumns)*0.7;
for (i=0;i<(int)_photoreceptorsPrefilter.getNBrows();++i) for (i=0;i<(int)_photoreceptorsPrefilter.getNBrows();++i)
{ {
for (j=0;j<(int)_photoreceptorsPrefilter.getNBcolumns();++j) for (j=0;j<(int)_photoreceptorsPrefilter.getNBcolumns();++j)
{ {
float distanceToCenter=sqrt(((float)(i-halfRows)*(i-halfRows)+(j-halfColumns)*(j-halfColumns))); float distanceToCenter=sqrt(((float)(i-halfRows)*(i-halfRows)+(j-halfColumns)*(j-halfColumns)));
if (distanceToCenter<minDistance) if (distanceToCenter<minDistance)
{ {
float a=*(hybridParvoMagnoCoefTablePTR++)=0.5+0.5*cos(CV_PI*distanceToCenter/minDistance); float a=*(hybridParvoMagnoCoefTablePTR++)=0.5+0.5*cos(CV_PI*distanceToCenter/minDistance);
*(hybridParvoMagnoCoefTablePTR++)=1.0-a; *(hybridParvoMagnoCoefTablePTR++)=1.0-a;
}else }else
{ {
*(hybridParvoMagnoCoefTablePTR++)=0; *(hybridParvoMagnoCoefTablePTR++)=0;
*(hybridParvoMagnoCoefTablePTR++)=1.0; *(hybridParvoMagnoCoefTablePTR++)=1.0;
} }
} }
} }
} }
// setup parameters function and global data filling // setup parameters function and global data filling
void RetinaFilter::setGlobalParameters(const float OPLspatialResponse1, const float OPLtemporalresponse1, const float OPLassymetryGain, const float OPLspatialResponse2, const float OPLtemporalresponse2, const float LPfilterSpatialResponse, const float LPfilterGain, const float LPfilterTemporalresponse, const float MovingContoursExtractorCoefficient, const bool normalizeParvoOutput_0_maxOutputValue, const bool normalizeMagnoOutput_0_maxOutputValue, const float maxOutputValue, const float maxInputValue, const float meanValue) void RetinaFilter::setGlobalParameters(const float OPLspatialResponse1, const float OPLtemporalresponse1, const float OPLassymetryGain, const float OPLspatialResponse2, const float OPLtemporalresponse2, const float LPfilterSpatialResponse, const float LPfilterGain, const float LPfilterTemporalresponse, const float MovingContoursExtractorCoefficient, const bool normalizeParvoOutput_0_maxOutputValue, const bool normalizeMagnoOutput_0_maxOutputValue, const float maxOutputValue, const float maxInputValue, const float meanValue)
{ {
_normalizeParvoOutput_0_maxOutputValue=normalizeParvoOutput_0_maxOutputValue; _normalizeParvoOutput_0_maxOutputValue=normalizeParvoOutput_0_maxOutputValue;
_normalizeMagnoOutput_0_maxOutputValue=normalizeMagnoOutput_0_maxOutputValue; _normalizeMagnoOutput_0_maxOutputValue=normalizeMagnoOutput_0_maxOutputValue;
_maxOutputValue=maxOutputValue; _maxOutputValue=maxOutputValue;
_photoreceptorsPrefilter.setV0CompressionParameter(0.9, maxInputValue, meanValue); _photoreceptorsPrefilter.setV0CompressionParameter(0.9, maxInputValue, meanValue);
_photoreceptorsPrefilter.setLPfilterParameters(10, 0, 1.5, 1); // keeps low pass filter with high cut frequency in memory (usefull for the tone mapping function) _photoreceptorsPrefilter.setLPfilterParameters(10, 0, 1.5, 1); // keeps low pass filter with high cut frequency in memory (usefull for the tone mapping function)
_photoreceptorsPrefilter.setLPfilterParameters(10, 0, 3.0, 2); // keeps low pass filter with low cut frequency in memory (usefull for the tone mapping function) _photoreceptorsPrefilter.setLPfilterParameters(10, 0, 3.0, 2); // keeps low pass filter with low cut frequency in memory (usefull for the tone mapping function)
_photoreceptorsPrefilter.setLPfilterParameters(0, 0, 10, 3); // keeps low pass filter with low cut frequency in memory (usefull for the tone mapping function) _photoreceptorsPrefilter.setLPfilterParameters(0, 0, 10, 3); // keeps low pass filter with low cut frequency in memory (usefull for the tone mapping function)
//this->setV0CompressionParameter(0.6, maxInputValue, meanValue); // keeps log compression sensitivity parameter (usefull for the tone mapping function) //this->setV0CompressionParameter(0.6, maxInputValue, meanValue); // keeps log compression sensitivity parameter (usefull for the tone mapping function)
_ParvoRetinaFilter.setOPLandParvoFiltersParameters(0,OPLtemporalresponse1, OPLspatialResponse1, OPLassymetryGain, OPLtemporalresponse2, OPLspatialResponse2); _ParvoRetinaFilter.setOPLandParvoFiltersParameters(0,OPLtemporalresponse1, OPLspatialResponse1, OPLassymetryGain, OPLtemporalresponse2, OPLspatialResponse2);
_ParvoRetinaFilter.setV0CompressionParameter(0.9, maxInputValue, meanValue); _ParvoRetinaFilter.setV0CompressionParameter(0.9, maxInputValue, meanValue);
_MagnoRetinaFilter.setCoefficientsTable(LPfilterGain, LPfilterTemporalresponse, LPfilterSpatialResponse, MovingContoursExtractorCoefficient, 0, 2.0*LPfilterSpatialResponse); _MagnoRetinaFilter.setCoefficientsTable(LPfilterGain, LPfilterTemporalresponse, LPfilterSpatialResponse, MovingContoursExtractorCoefficient, 0, 2.0*LPfilterSpatialResponse);
_MagnoRetinaFilter.setV0CompressionParameter(0.7, maxInputValue, meanValue); _MagnoRetinaFilter.setV0CompressionParameter(0.7, maxInputValue, meanValue);
// stability controls value init // stability controls value init
_setInitPeriodCount(); _setInitPeriodCount();
} }
const bool RetinaFilter::checkInput(const std::valarray<float> &input, const bool) const bool RetinaFilter::checkInput(const std::valarray<float> &input, const bool)
{ {
BasicRetinaFilter *inputTarget=&_photoreceptorsPrefilter; BasicRetinaFilter *inputTarget=&_photoreceptorsPrefilter;
if (_photoreceptorsLogSampling) if (_photoreceptorsLogSampling)
inputTarget=_photoreceptorsLogSampling; inputTarget=_photoreceptorsLogSampling;
bool test=input.size()==inputTarget->getNBpixels() || input.size()==(inputTarget->getNBpixels()*3) ; bool test=input.size()==inputTarget->getNBpixels() || input.size()==(inputTarget->getNBpixels()*3) ;
if (!test) if (!test)
{ {
std::cerr<<"RetinaFilter::checkInput: input buffer does not match retina buffer size, conversion aborted"<<std::endl; std::cerr<<"RetinaFilter::checkInput: input buffer does not match retina buffer size, conversion aborted"<<std::endl;
std::cout<<"RetinaFilter::checkInput: input size="<<input.size()<<" / "<<"retina size="<<inputTarget->getNBpixels()<<std::endl; std::cout<<"RetinaFilter::checkInput: input size="<<input.size()<<" / "<<"retina size="<<inputTarget->getNBpixels()<<std::endl;
return false; return false;
} }
return true; return true;
} }
// main function that runs the filter for a given input frame // main function that runs the filter for a given input frame
const bool RetinaFilter::runFilter(const std::valarray<float> &imageInput, const bool useAdaptiveFiltering, const bool processRetinaParvoMagnoMapping, const bool useColorMode, const bool inputIsColorMultiplexed) const bool RetinaFilter::runFilter(const std::valarray<float> &imageInput, const bool useAdaptiveFiltering, const bool processRetinaParvoMagnoMapping, const bool useColorMode, const bool inputIsColorMultiplexed)
{ {
// preliminary check // preliminary check
bool processSuccess=true; bool processSuccess=true;
if (!checkInput(imageInput, useColorMode)) if (!checkInput(imageInput, useColorMode))
return false; return false;
// run the color multiplexing if needed and compute each suub filter of the retina: // run the color multiplexing if needed and compute each suub filter of the retina:
// -> local adaptation // -> local adaptation
// -> contours OPL extraction // -> contours OPL extraction
// -> moving contours extraction // -> moving contours extraction
// stability controls value update // stability controls value update
++_ellapsedFramesSinceLastReset; ++_ellapsedFramesSinceLastReset;
_useColorMode=useColorMode; _useColorMode=useColorMode;
/* pointer to the appropriate input data after, /* pointer to the appropriate input data after,
* by default, if graylevel mode, the input is processed, * by default, if graylevel mode, the input is processed,
* if color or something else must be considered, specific preprocessing are applied * if color or something else must be considered, specific preprocessing are applied
*/ */
const std::valarray<float> *selectedPhotoreceptorsLocalAdaptationInput= &imageInput; const std::valarray<float> *selectedPhotoreceptorsLocalAdaptationInput= &imageInput;
const std::valarray<float> *selectedPhotoreceptorsColorInput=&imageInput; const std::valarray<float> *selectedPhotoreceptorsColorInput=&imageInput;
//********** Following is input data specific photoreceptors processing //********** Following is input data specific photoreceptors processing
if (_photoreceptorsLogSampling) if (_photoreceptorsLogSampling)
{ {
_photoreceptorsLogSampling->runProjection(imageInput, useColorMode); _photoreceptorsLogSampling->runProjection(imageInput, useColorMode);
selectedPhotoreceptorsColorInput=selectedPhotoreceptorsLocalAdaptationInput=&(_photoreceptorsLogSampling->getSampledFrame()); selectedPhotoreceptorsColorInput=selectedPhotoreceptorsLocalAdaptationInput=&(_photoreceptorsLogSampling->getSampledFrame());
} }
if (useColorMode&& (!inputIsColorMultiplexed)) // not multiplexed color input case if (useColorMode&& (!inputIsColorMultiplexed)) // not multiplexed color input case
{ {
_colorEngine.runColorMultiplexing(*selectedPhotoreceptorsColorInput); _colorEngine.runColorMultiplexing(*selectedPhotoreceptorsColorInput);
selectedPhotoreceptorsLocalAdaptationInput=&(_colorEngine.getMultiplexedFrame()); selectedPhotoreceptorsLocalAdaptationInput=&(_colorEngine.getMultiplexedFrame());
} }
//********** Following is generic Retina processing //********** Following is generic Retina processing
// photoreceptors local adaptation // photoreceptors local adaptation
_photoreceptorsPrefilter.runFilter_LocalAdapdation(*selectedPhotoreceptorsLocalAdaptationInput, _ParvoRetinaFilter.getHorizontalCellsOutput()); _photoreceptorsPrefilter.runFilter_LocalAdapdation(*selectedPhotoreceptorsLocalAdaptationInput, _ParvoRetinaFilter.getHorizontalCellsOutput());
// safety pixel values checks // safety pixel values checks
//_photoreceptorsPrefilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue); //_photoreceptorsPrefilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue);
// run parvo filter // run parvo filter
_ParvoRetinaFilter.runFilter(_photoreceptorsPrefilter.getOutput(), _useParvoOutput); _ParvoRetinaFilter.runFilter(_photoreceptorsPrefilter.getOutput(), _useParvoOutput);
if (_useParvoOutput) if (_useParvoOutput)
{ {
_ParvoRetinaFilter.normalizeGrayOutputCentredSigmoide(); // models the saturation of the cells, usefull for visualisation of the ON-OFF Parvo Output, Bipolar cells outputs do not change !!! _ParvoRetinaFilter.normalizeGrayOutputCentredSigmoide(); // models the saturation of the cells, usefull for visualisation of the ON-OFF Parvo Output, Bipolar cells outputs do not change !!!
_ParvoRetinaFilter.centerReductImageLuminance(); // best for further spectrum analysis _ParvoRetinaFilter.centerReductImageLuminance(); // best for further spectrum analysis
if (_normalizeParvoOutput_0_maxOutputValue) if (_normalizeParvoOutput_0_maxOutputValue)
_ParvoRetinaFilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue); _ParvoRetinaFilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue);
} }
if (_useParvoOutput&&_useMagnoOutput) if (_useParvoOutput&&_useMagnoOutput)
{ {
_MagnoRetinaFilter.runFilter(_ParvoRetinaFilter.getBipolarCellsON(), _ParvoRetinaFilter.getBipolarCellsOFF()); _MagnoRetinaFilter.runFilter(_ParvoRetinaFilter.getBipolarCellsON(), _ParvoRetinaFilter.getBipolarCellsOFF());
if (_normalizeMagnoOutput_0_maxOutputValue) if (_normalizeMagnoOutput_0_maxOutputValue)
{ {
_MagnoRetinaFilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue); _MagnoRetinaFilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue);
} }
_MagnoRetinaFilter.normalizeGrayOutputNearZeroCentreredSigmoide(); _MagnoRetinaFilter.normalizeGrayOutputNearZeroCentreredSigmoide();
} }
if (_useParvoOutput&&_useMagnoOutput&&processRetinaParvoMagnoMapping) if (_useParvoOutput&&_useMagnoOutput&&processRetinaParvoMagnoMapping)
{ {
_processRetinaParvoMagnoMapping(); _processRetinaParvoMagnoMapping();
if (_useColorMode) if (_useColorMode)
_colorEngine.runColorDemultiplexing(_retinaParvoMagnoMappedFrame, useAdaptiveFiltering, _maxOutputValue);//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput()); _colorEngine.runColorDemultiplexing(_retinaParvoMagnoMappedFrame, useAdaptiveFiltering, _maxOutputValue);//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput());
return processSuccess; return processSuccess;
} }
if (_useParvoOutput&&_useColorMode) if (_useParvoOutput&&_useColorMode)
{ {
_colorEngine.runColorDemultiplexing(_ParvoRetinaFilter.getOutput(), useAdaptiveFiltering, _maxOutputValue);//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput()); _colorEngine.runColorDemultiplexing(_ParvoRetinaFilter.getOutput(), useAdaptiveFiltering, _maxOutputValue);//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput());
// compute A Cr1 Cr2 to LMS color space conversion // compute A Cr1 Cr2 to LMS color space conversion
//if (true) //if (true)
// _applyImageColorSpaceConversion(_ColorEngine->getChrominance(), lmsTempBuffer.Buffer(), _LMStoACr1Cr2); // _applyImageColorSpaceConversion(_ColorEngine->getChrominance(), lmsTempBuffer.Buffer(), _LMStoACr1Cr2);
} }
return processSuccess; return processSuccess;
} }
const std::valarray<float> &RetinaFilter::getContours() const std::valarray<float> &RetinaFilter::getContours()
{ {
if (_useColorMode) if (_useColorMode)
return _colorEngine.getLuminance(); return _colorEngine.getLuminance();
else else
return _ParvoRetinaFilter.getOutput(); return _ParvoRetinaFilter.getOutput();
} }
// run the initilized retina filter in order to perform gray image tone mapping, after this call all retina outputs are updated // run the initilized retina filter in order to perform gray image tone mapping, after this call all retina outputs are updated
void RetinaFilter::runGrayToneMapping(const std::valarray<float> &grayImageInput, std::valarray<float> &grayImageOutput, const float PhotoreceptorsCompression, const float ganglionCellsCompression) void RetinaFilter::runGrayToneMapping(const std::valarray<float> &grayImageInput, std::valarray<float> &grayImageOutput, const float PhotoreceptorsCompression, const float ganglionCellsCompression)
{ {
// preliminary check // preliminary check
if (!checkInput(grayImageInput, false)) if (!checkInput(grayImageInput, false))
return; return;
this->_runGrayToneMapping(grayImageInput, grayImageOutput, PhotoreceptorsCompression, ganglionCellsCompression); this->_runGrayToneMapping(grayImageInput, grayImageOutput, PhotoreceptorsCompression, ganglionCellsCompression);
} }
// run the initilized retina filter in order to perform gray image tone mapping, after this call all retina outputs are updated // run the initilized retina filter in order to perform gray image tone mapping, after this call all retina outputs are updated
void RetinaFilter::_runGrayToneMapping(const std::valarray<float> &grayImageInput, std::valarray<float> &grayImageOutput, const float PhotoreceptorsCompression, const float ganglionCellsCompression) void RetinaFilter::_runGrayToneMapping(const std::valarray<float> &grayImageInput, std::valarray<float> &grayImageOutput, const float PhotoreceptorsCompression, const float ganglionCellsCompression)
{ {
// stability controls value update // stability controls value update
++_ellapsedFramesSinceLastReset; ++_ellapsedFramesSinceLastReset;
std::valarray<float> temp2(grayImageInput.size()); std::valarray<float> temp2(grayImageInput.size());
// apply tone mapping on the multiplexed image // apply tone mapping on the multiplexed image
// -> photoreceptors local adaptation (large area adaptation) // -> photoreceptors local adaptation (large area adaptation)
_photoreceptorsPrefilter.runFilter_LPfilter(grayImageInput, grayImageOutput, 2); // compute low pass filtering modeling the horizontal cells filtering to acess local luminance _photoreceptorsPrefilter.runFilter_LPfilter(grayImageInput, grayImageOutput, 2); // compute low pass filtering modeling the horizontal cells filtering to acess local luminance
_photoreceptorsPrefilter.setV0CompressionParameterToneMapping(PhotoreceptorsCompression, grayImageOutput.sum()/(float)_photoreceptorsPrefilter.getNBpixels()); _photoreceptorsPrefilter.setV0CompressionParameterToneMapping(PhotoreceptorsCompression, grayImageOutput.sum()/(float)_photoreceptorsPrefilter.getNBpixels());
_photoreceptorsPrefilter.runFilter_LocalAdapdation(grayImageInput, grayImageOutput, temp2); // adapt contrast to local luminance _photoreceptorsPrefilter.runFilter_LocalAdapdation(grayImageInput, grayImageOutput, temp2); // adapt contrast to local luminance
// high pass filter // high pass filter
//_spatiotemporalLPfilter(_localBuffer, _filterOutput, 2); // compute low pass filtering (high cut frequency (remove spatio-temporal noise) //_spatiotemporalLPfilter(_localBuffer, _filterOutput, 2); // compute low pass filtering (high cut frequency (remove spatio-temporal noise)
//for (unsigned int i=0;i<_NBpixels;++i) //for (unsigned int i=0;i<_NBpixels;++i)
// _localBuffer[i]-= _filterOutput[i]/2.0; // _localBuffer[i]-= _filterOutput[i]/2.0;
// -> ganglion cells local adaptation (short area adaptation) // -> ganglion cells local adaptation (short area adaptation)
_photoreceptorsPrefilter.runFilter_LPfilter(temp2, grayImageOutput, 1); // compute low pass filtering (high cut frequency (remove spatio-temporal noise) _photoreceptorsPrefilter.runFilter_LPfilter(temp2, grayImageOutput, 1); // compute low pass filtering (high cut frequency (remove spatio-temporal noise)
_photoreceptorsPrefilter.setV0CompressionParameterToneMapping(ganglionCellsCompression, temp2.max(), temp2.sum()/(float)_photoreceptorsPrefilter.getNBpixels()); _photoreceptorsPrefilter.setV0CompressionParameterToneMapping(ganglionCellsCompression, temp2.max(), temp2.sum()/(float)_photoreceptorsPrefilter.getNBpixels());
_photoreceptorsPrefilter.runFilter_LocalAdapdation(temp2, grayImageOutput, grayImageOutput); // adapt contrast to local luminance _photoreceptorsPrefilter.runFilter_LocalAdapdation(temp2, grayImageOutput, grayImageOutput); // adapt contrast to local luminance
} }
// run the initilized retina filter in order to perform color tone mapping, after this call all retina outputs are updated // run the initilized retina filter in order to perform color tone mapping, after this call all retina outputs are updated
void RetinaFilter::runRGBToneMapping(const std::valarray<float> &RGBimageInput, std::valarray<float> &RGBimageOutput, const bool useAdaptiveFiltering, const float PhotoreceptorsCompression, const float ganglionCellsCompression) void RetinaFilter::runRGBToneMapping(const std::valarray<float> &RGBimageInput, std::valarray<float> &RGBimageOutput, const bool useAdaptiveFiltering, const float PhotoreceptorsCompression, const float ganglionCellsCompression)
{ {
// preliminary check // preliminary check
if (!checkInput(RGBimageInput, true)) if (!checkInput(RGBimageInput, true))
return; return;
// multiplex the image with the color sampling method specified in the constructor // multiplex the image with the color sampling method specified in the constructor
_colorEngine.runColorMultiplexing(RGBimageInput); _colorEngine.runColorMultiplexing(RGBimageInput);
// apply tone mapping on the multiplexed image // apply tone mapping on the multiplexed image
_runGrayToneMapping(_colorEngine.getMultiplexedFrame(), RGBimageOutput, PhotoreceptorsCompression, ganglionCellsCompression); _runGrayToneMapping(_colorEngine.getMultiplexedFrame(), RGBimageOutput, PhotoreceptorsCompression, ganglionCellsCompression);
// demultiplex tone maped image // demultiplex tone maped image
_colorEngine.runColorDemultiplexing(RGBimageOutput, useAdaptiveFiltering, _photoreceptorsPrefilter.getMaxInputValue());//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput()); _colorEngine.runColorDemultiplexing(RGBimageOutput, useAdaptiveFiltering, _photoreceptorsPrefilter.getMaxInputValue());//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput());
// rescaling result between 0 and 255 // rescaling result between 0 and 255
_colorEngine.normalizeRGBOutput_0_maxOutputValue(255.0); _colorEngine.normalizeRGBOutput_0_maxOutputValue(255.0);
// return the result // return the result
RGBimageOutput=_colorEngine.getDemultiplexedColorFrame(); RGBimageOutput=_colorEngine.getDemultiplexedColorFrame();
} }
void RetinaFilter::runLMSToneMapping(const std::valarray<float> &, std::valarray<float> &, const bool, const float, const float) void RetinaFilter::runLMSToneMapping(const std::valarray<float> &, std::valarray<float> &, const bool, const float, const float)
{ {
std::cerr<<"not working, sorry"<<std::endl; std::cerr<<"not working, sorry"<<std::endl;
/* // preliminary check /* // preliminary check
const std::valarray<float> &bufferInput=checkInput(LMSimageInput, true); const std::valarray<float> &bufferInput=checkInput(LMSimageInput, true);
if (!bufferInput) if (!bufferInput)
return NULL; return NULL;
if (!_useColorMode) if (!_useColorMode)
std::cerr<<"RetinaFilter::Can not call tone mapping oeration if the retina filter was created for gray scale images"<<std::endl; std::cerr<<"RetinaFilter::Can not call tone mapping oeration if the retina filter was created for gray scale images"<<std::endl;
// create a temporary buffer of size nrows, Mcolumns, 3 layers // create a temporary buffer of size nrows, Mcolumns, 3 layers
std::valarray<float> lmsTempBuffer(LMSimageInput); std::valarray<float> lmsTempBuffer(LMSimageInput);
std::cout<<"RetinaFilter::--->min LMS value="<<lmsTempBuffer.min()<<std::endl; std::cout<<"RetinaFilter::--->min LMS value="<<lmsTempBuffer.min()<<std::endl;
// setup local adaptation parameter at the photoreceptors level // setup local adaptation parameter at the photoreceptors level
setV0CompressionParameter(PhotoreceptorsCompression, _maxInputValue); setV0CompressionParameter(PhotoreceptorsCompression, _maxInputValue);
// get the local energy of each color channel // get the local energy of each color channel
// ->L // ->L
_spatiotemporalLPfilter(LMSimageInput, _filterOutput, 1); _spatiotemporalLPfilter(LMSimageInput, _filterOutput, 1);
setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels); setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels);
_localLuminanceAdaptation(LMSimageInput, _filterOutput, lmsTempBuffer.Buffer()); _localLuminanceAdaptation(LMSimageInput, _filterOutput, lmsTempBuffer.Buffer());
// ->M // ->M
_spatiotemporalLPfilter(LMSimageInput+_NBpixels, _filterOutput, 1); _spatiotemporalLPfilter(LMSimageInput+_NBpixels, _filterOutput, 1);
setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels); setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels);
_localLuminanceAdaptation(LMSimageInput+_NBpixels, _filterOutput, lmsTempBuffer.Buffer()+_NBpixels); _localLuminanceAdaptation(LMSimageInput+_NBpixels, _filterOutput, lmsTempBuffer.Buffer()+_NBpixels);
// ->S // ->S
_spatiotemporalLPfilter(LMSimageInput+_NBpixels*2, _filterOutput, 1); _spatiotemporalLPfilter(LMSimageInput+_NBpixels*2, _filterOutput, 1);
setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels); setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels);
_localLuminanceAdaptation(LMSimageInput+_NBpixels*2, _filterOutput, lmsTempBuffer.Buffer()+_NBpixels*2); _localLuminanceAdaptation(LMSimageInput+_NBpixels*2, _filterOutput, lmsTempBuffer.Buffer()+_NBpixels*2);
// eliminate negative values // eliminate negative values
for (unsigned int i=0;i<lmsTempBuffer.size();++i) for (unsigned int i=0;i<lmsTempBuffer.size();++i)
if (lmsTempBuffer.Buffer()[i]<0) if (lmsTempBuffer.Buffer()[i]<0)
lmsTempBuffer.Buffer()[i]=0; lmsTempBuffer.Buffer()[i]=0;
std::cout<<"RetinaFilter::->min LMS value="<<lmsTempBuffer.min()<<std::endl; std::cout<<"RetinaFilter::->min LMS value="<<lmsTempBuffer.min()<<std::endl;
// compute LMS to A Cr1 Cr2 color space conversion // compute LMS to A Cr1 Cr2 color space conversion
_applyImageColorSpaceConversion(lmsTempBuffer.Buffer(), lmsTempBuffer.Buffer(), _LMStoACr1Cr2); _applyImageColorSpaceConversion(lmsTempBuffer.Buffer(), lmsTempBuffer.Buffer(), _LMStoACr1Cr2);
TemplateBuffer <float> acr1cr2TempBuffer(_NBrows, _NBcolumns, 3); TemplateBuffer <float> acr1cr2TempBuffer(_NBrows, _NBcolumns, 3);
memcpy(acr1cr2TempBuffer.Buffer(), lmsTempBuffer.Buffer(), sizeof(float)*_NBpixels*3); memcpy(acr1cr2TempBuffer.Buffer(), lmsTempBuffer.Buffer(), sizeof(float)*_NBpixels*3);
// compute A Cr1 Cr2 to LMS color space conversion // compute A Cr1 Cr2 to LMS color space conversion
_applyImageColorSpaceConversion(acr1cr2TempBuffer.Buffer(), lmsTempBuffer.Buffer(), _ACr1Cr2toLMS); _applyImageColorSpaceConversion(acr1cr2TempBuffer.Buffer(), lmsTempBuffer.Buffer(), _ACr1Cr2toLMS);
// eliminate negative values // eliminate negative values
for (unsigned int i=0;i<lmsTempBuffer.size();++i) for (unsigned int i=0;i<lmsTempBuffer.size();++i)
if (lmsTempBuffer.Buffer()[i]<0) if (lmsTempBuffer.Buffer()[i]<0)
lmsTempBuffer.Buffer()[i]=0; lmsTempBuffer.Buffer()[i]=0;
// rewrite output to the appropriate buffer // rewrite output to the appropriate buffer
_colorEngine->setDemultiplexedColorFrame(lmsTempBuffer.Buffer()); _colorEngine->setDemultiplexedColorFrame(lmsTempBuffer.Buffer());
*/ */
} }
// 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]; register float *hybridParvoMagnoPTR= &_retinaParvoMagnoMappedFrame[0];
register const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput()); register const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput());
register const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput()); register const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput());
register float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0]; register 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)
{ {
float hybridValue=*(parvoOutputPTR++)**(hybridParvoMagnoCoefTablePTR)+*(magnoXOutputPTR++)**(hybridParvoMagnoCoefTablePTR+1); float hybridValue=*(parvoOutputPTR++)**(hybridParvoMagnoCoefTablePTR)+*(magnoXOutputPTR++)**(hybridParvoMagnoCoefTablePTR+1);
*(hybridParvoMagnoPTR++)=hybridValue; *(hybridParvoMagnoPTR++)=hybridValue;
} }
TemplateBuffer<float>::normalizeGrayOutput_0_maxOutputValue(&_retinaParvoMagnoMappedFrame[0], _photoreceptorsPrefilter.getNBpixels()); TemplateBuffer<float>::normalizeGrayOutput_0_maxOutputValue(&_retinaParvoMagnoMappedFrame[0], _photoreceptorsPrefilter.getNBpixels());
} }
const bool RetinaFilter::getParvoFoveaResponse(std::valarray<float> &parvoFovealResponse) const bool RetinaFilter::getParvoFoveaResponse(std::valarray<float> &parvoFovealResponse)
{ {
if (!_useParvoOutput) if (!_useParvoOutput)
return false; return false;
if (parvoFovealResponse.size() != _ParvoRetinaFilter.getNBpixels()) if (parvoFovealResponse.size() != _ParvoRetinaFilter.getNBpixels())
return false; return false;
register const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput()); register const float *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput());
register float *fovealParvoResponsePTR= &parvoFovealResponse[0]; register float *fovealParvoResponsePTR= &parvoFovealResponse[0];
register float *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0]; register 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)
{ {
*(fovealParvoResponsePTR++)=*(parvoOutputPTR++)**(hybridParvoMagnoCoefTablePTR); *(fovealParvoResponsePTR++)=*(parvoOutputPTR++)**(hybridParvoMagnoCoefTablePTR);
} }
return true; return true;
} }
// method to retrieve the parafoveal magnocellular pathway response (no energy motion in fovea) // method to retrieve the parafoveal magnocellular pathway response (no energy motion in fovea)
const bool RetinaFilter::getMagnoParaFoveaResponse(std::valarray<float> &magnoParafovealResponse) const bool RetinaFilter::getMagnoParaFoveaResponse(std::valarray<float> &magnoParafovealResponse)
{ {
if (!_useMagnoOutput) if (!_useMagnoOutput)
return false; return false;
if (magnoParafovealResponse.size() != _MagnoRetinaFilter.getNBpixels()) if (magnoParafovealResponse.size() != _MagnoRetinaFilter.getNBpixels())
return false; return false;
register const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput()); register const float *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput());
register float *parafovealMagnoResponsePTR=&magnoParafovealResponse[0]; register float *parafovealMagnoResponsePTR=&magnoParafovealResponse[0];
register float *hybridParvoMagnoCoefTablePTR=&_retinaParvoMagnoMapCoefTable[0]+1; register 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)
{ {
*(parafovealMagnoResponsePTR++)=*(magnoXOutputPTR++)**(hybridParvoMagnoCoefTablePTR); *(parafovealMagnoResponsePTR++)=*(magnoXOutputPTR++)**(hybridParvoMagnoCoefTablePTR);
} }
return true; return true;
} }
} }
modules/core/src/cmdparser.cpp
View file @ 415978b1
...@@ -287,25 +287,25 @@ std::string CommandLineParser::analizeValue<std::string>(const std::string& str, ...@@ -287,25 +287,25 @@ std::string CommandLineParser::analizeValue<std::string>(const std::string& str,
} }
template<> template<>
int CommandLineParser::analizeValue<int>(const std::string& str, bool space_delete) int CommandLineParser::analizeValue<int>(const std::string& str, bool /*space_delete*/)
{ {
return fromStringNumber<int>(str); return fromStringNumber<int>(str);
} }
template<> template<>
unsigned int CommandLineParser::analizeValue<unsigned int>(const std::string& str, bool space_delete) unsigned int CommandLineParser::analizeValue<unsigned int>(const std::string& str, bool /*space_delete*/)
{ {
return fromStringNumber<unsigned int>(str); return fromStringNumber<unsigned int>(str);
} }
template<> template<>
float CommandLineParser::analizeValue<float>(const std::string& str, bool space_delete) float CommandLineParser::analizeValue<float>(const std::string& str, bool /*space_delete*/)
{ {
return fromStringNumber<float>(str); return fromStringNumber<float>(str);
} }
template<> template<>
double CommandLineParser::analizeValue<double>(const std::string& str, bool space_delete) double CommandLineParser::analizeValue<double>(const std::string& str, bool /*space_delete*/)
{ {
return fromStringNumber<double>(str); return fromStringNumber<double>(str);
} }
modules/core/test/test_operations.cpp
View file @ 415978b1
...@@ -780,14 +780,14 @@ bool CV_OperationsTest::TestVec() ...@@ -780,14 +780,14 @@ bool CV_OperationsTest::TestVec()
//these compile //these compile
cv::Vec3b b = a; cv::Vec3b b = a;
hsvImage_f.at<cv::Vec3f>(i,j) = cv::Vec3f(i,0,1); hsvImage_f.at<cv::Vec3f>(i,j) = cv::Vec3f((float)i,0,1);
hsvImage_b.at<cv::Vec3b>(i,j) = cv::Vec3b(cv::Vec3f(i,0,1)); hsvImage_b.at<cv::Vec3b>(i,j) = cv::Vec3b(cv::Vec3f((float)i,0,1));
//these don't //these don't
b = cv::Vec3f(1,0,0); b = cv::Vec3f(1,0,0);
cv::Vec3b c; cv::Vec3b c;
c = cv::Vec3f(0,0,1); c = cv::Vec3f(0,0,1);
hsvImage_b.at<cv::Vec3b>(i,j) = cv::Vec3f(i,0,1); hsvImage_b.at<cv::Vec3b>(i,j) = cv::Vec3f((float)i,0,1);
hsvImage_b.at<cv::Vec3b>(i,j) = a; hsvImage_b.at<cv::Vec3b>(i,j) = a;
hsvImage_b.at<cv::Vec3b>(i,j) = cv::Vec3f(1,2,3); hsvImage_b.at<cv::Vec3b>(i,j) = cv::Vec3f(1,2,3);
} }
......
modules/imgproc/src/phasecorr.cpp
View file @ 415978b1
...@@ -322,7 +322,7 @@ void cv::createHanningWindow(OutputArray _dst, cv::Size winSize, int type) ...@@ -322,7 +322,7 @@ void cv::createHanningWindow(OutputArray _dst, cv::Size winSize, int type)
for(int j = 0; j < cols; j++) for(int j = 0; j < cols; j++)
{ {
double wc = 0.5 * (1.0f - cos(2.0f * CV_PI * (double)j / (double)(cols - 1))); double wc = 0.5 * (1.0f - cos(2.0f * CV_PI * (double)j / (double)(cols - 1)));
dstData[i*cols + j] = wr * wc; dstData[i*cols + j] = (float)(wr * wc);
} }
} }
......
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