generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

nicer interface with the use of InputArray and OutptArray instated of (const Mat&)

Browse Source
This commit is contained in:
alexandre benoit 2013-05-03 11:45:13 +02:00
parent b58d9f1c2a
commit a5acc9ee1f
3 changed files with 40 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
modules/contrib/doc/retina/index.rst
View File

@ -62,16 +62,16 @@ Here is an overview of the abstract Retina interface, allocate one instance with
struct RetinaParameters; // this class is detailled later struct RetinaParameters; // this class is detailled later
// main method for input frame processing // main method for input frame processing
void run (const Mat &inputImage); void run (InputArray inputImage);
// output buffers retreival methods // output buffers retreival methods
// -> foveal color vision details channel with luminance and noise correction // -> foveal color vision details channel with luminance and noise correction
void getParvo (Mat &retinaOutput_parvo); void getParvo (OutputArray retinaOutput_parvo);
void getParvoRAW (Mat &retinaOutput_parvo);// retreive original output buffers without any normalisation void getParvoRAW (OutputArray retinaOutput_parvo);// retreive original output buffers without any normalisation
const Mat getParvoRAW () const;// retreive original output buffers without any normalisation const Mat getParvoRAW () const;// retreive original output buffers without any normalisation
// -> peripheral monochrome motion and events (transient information) channel // -> peripheral monochrome motion and events (transient information) channel
void getMagno (Mat &retinaOutput_magno); void getMagno (OutputArray retinaOutput_magno);
void getMagnoRAW (Mat &retinaOutput_magno); // retreive original output buffers without any normalisation void getMagnoRAW (OutputArray retinaOutput_magno); // retreive original output buffers without any normalisation
const Mat getMagnoRAW () const;// retreive original output buffers without any normalisation const Mat getMagnoRAW () const;// retreive original output buffers without any normalisation
// reset retina buffers... equivalent to closing your eyes for some seconds // reset retina buffers... equivalent to closing your eyes for some seconds
@ -223,8 +223,8 @@ Retina::clearBuffers
Retina::getParvo Retina::getParvo
++++++++++++++++ ++++++++++++++++
.. ocv:function:: void Retina::getParvo( Mat & retinaOutput_parvo ) .. ocv:function:: void Retina::getParvo( OutputArray retinaOutput_parvo )
.. ocv:function:: void Retina::getParvoRAW( Mat & retinaOutput_parvo ) .. ocv:function:: void Retina::getParvoRAW( OutputArray retinaOutput_parvo )
.. ocv:function:: const Mat Retina::getParvoRAW() const .. ocv:function:: const Mat Retina::getParvoRAW() const
Accessor of the details channel of the retina (models foveal vision). Warning, getParvoRAW methods return buffers that are not rescaled within range [0;255] while the non RAW method allows a normalized matrix to be retrieved. Accessor of the details channel of the retina (models foveal vision). Warning, getParvoRAW methods return buffers that are not rescaled within range [0;255] while the non RAW method allows a normalized matrix to be retrieved.
@ -238,8 +238,8 @@ Retina::getParvo
Retina::getMagno Retina::getMagno
++++++++++++++++ ++++++++++++++++
.. ocv:function:: void Retina::getMagno( Mat & retinaOutput_magno ) .. ocv:function:: void Retina::getMagno( OutputArray retinaOutput_magno )
.. ocv:function:: void Retina::getMagnoRAW( Mat & retinaOutput_magno ) .. ocv:function:: void Retina::getMagnoRAW( OutputArray retinaOutput_magno )
.. ocv:function:: const Mat Retina::getMagnoRAW() const .. ocv:function:: const Mat Retina::getMagnoRAW() const
Accessor of the motion channel of the retina (models peripheral vision). Warning, getMagnoRAW methods return buffers that are not rescaled within range [0;255] while the non RAW method allows a normalized matrix to be retrieved. Accessor of the motion channel of the retina (models peripheral vision). Warning, getMagnoRAW methods return buffers that are not rescaled within range [0;255] while the non RAW method allows a normalized matrix to be retrieved.
@ -280,7 +280,7 @@ Retina::printSetup
Retina::run Retina::run
+++++++++++ +++++++++++
.. ocv:function:: void Retina::run(const Mat & inputImage) .. ocv:function:: void Retina::run(InputArray inputImage)
Method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods Method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods
@ -439,7 +439,7 @@ Here is the 'realistic" setup used to obtain the second retina output shown on t
<photoreceptorsTemporalConstant>9.0e-01</photoreceptorsTemporalConstant> <photoreceptorsTemporalConstant>9.0e-01</photoreceptorsTemporalConstant>
<photoreceptorsSpatialConstant>5.3e-01</photoreceptorsSpatialConstant> <photoreceptorsSpatialConstant>5.3e-01</photoreceptorsSpatialConstant>
<horizontalCellsGain>0.3</horizontalCellsGain> <horizontalCellsGain>0.3</horizontalCellsGain>
<hcellsTemporalConstant>0.</hcellsTemporalConstant> <hcellsTemporalConstant>0.5</hcellsTemporalConstant>
<hcellsSpatialConstant>7.</hcellsSpatialConstant> <hcellsSpatialConstant>7.</hcellsSpatialConstant>
<ganglionCellsSensitivity>8.9e-01</ganglionCellsSensitivity></OPLandIPLparvo> <ganglionCellsSensitivity>8.9e-01</ganglionCellsSensitivity></OPLandIPLparvo>
<IPLmagno> <IPLmagno>

12
modules/contrib/include/opencv2/contrib/retina.hpp
View File

@ -119,7 +119,7 @@ public:
normaliseOutput(true), normaliseOutput(true),
photoreceptorsLocalAdaptationSensitivity(0.75f), photoreceptorsLocalAdaptationSensitivity(0.75f),
photoreceptorsTemporalConstant(0.9f), photoreceptorsTemporalConstant(0.9f),
photoreceptorsSpatialConstant(0.57f), photoreceptorsSpatialConstant(0.53f),
horizontalCellsGain(0.01f), horizontalCellsGain(0.01f),
hcellsTemporalConstant(0.5f), hcellsTemporalConstant(0.5f),
hcellsSpatialConstant(7.f), hcellsSpatialConstant(7.f),
@ -239,31 +239,31 @@ public:
* method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods * method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods
* @param inputImage : the input cv::Mat image to be processed, can be gray level or BGR coded in any format (from 8bit to 16bits) * @param inputImage : the input cv::Mat image to be processed, can be gray level or BGR coded in any format (from 8bit to 16bits)
*/ */
virtual void run(const Mat &inputImage)=0; virtual void run(InputArray inputImage)=0;
/** /**
* accessor of the details channel of the retina (models foveal vision) * accessor of the details channel of the retina (models foveal vision)
* @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV * @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV
*/ */
virtual void getParvo(Mat &retinaOutput_parvo)=0; virtual void getParvo(OutputArray retinaOutput_parvo)=0;
/** /**
* accessor of the details channel of the retina (models foveal vision) * accessor of the details channel of the retina (models foveal vision)
* @param retinaOutput_parvo : a cv::Mat header filled with the internal parvo buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling * @param retinaOutput_parvo : a cv::Mat header filled with the internal parvo buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling
*/ */
virtual void getParvoRAW(Mat &retinaOutput_parvo)=0; virtual void getParvoRAW(OutputArray retinaOutput_parvo)=0;
/** /**
* accessor of the motion channel of the retina (models peripheral vision) * accessor of the motion channel of the retina (models peripheral vision)
* @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV * @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV
*/ */
virtual void getMagno(Mat &retinaOutput_magno)=0; virtual void getMagno(OutputArray retinaOutput_magno)=0;
/** /**
* accessor of the motion channel of the retina (models peripheral vision) * accessor of the motion channel of the retina (models peripheral vision)
* @param retinaOutput_magno : a cv::Mat header filled with the internal retina magno buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling * @param retinaOutput_magno : a cv::Mat header filled with the internal retina magno buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling
*/ */
virtual void getMagnoRAW(Mat &retinaOutput_magno)=0; virtual void getMagnoRAW(OutputArray retinaOutput_magno)=0;
// original API level data accessors : get buffers addresses from a Mat header, similar to getParvoRAW and getMagnoRAW... // original API level data accessors : get buffers addresses from a Mat header, similar to getParvoRAW and getMagnoRAW...
virtual const Mat getMagnoRAW() const=0; virtual const Mat getMagnoRAW() const=0;

40
modules/contrib/src/retina.cpp
View File

@ -194,31 +194,31 @@ public:
* method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods * method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods
* @param inputImage : the input cv::Mat image to be processed, can be gray level or BGR coded in any format (from 8bit to 16bits) * @param inputImage : the input cv::Mat image to be processed, can be gray level or BGR coded in any format (from 8bit to 16bits)
*/ */
void run(const Mat &inputImage); void run(InputArray inputImage);
/** /**
* accessor of the details channel of the retina (models foveal vision) * accessor of the details channel of the retina (models foveal vision)
* @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV * @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV
*/ */
void getParvo(Mat &retinaOutput_parvo); void getParvo(OutputArray retinaOutput_parvo);
/** /**
* accessor of the details channel of the retina (models foveal vision) * accessor of the details channel of the retina (models foveal vision)
* @param retinaOutput_parvo : a cv::Mat header filled with the internal parvo buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling * @param retinaOutput_parvo : a cv::Mat header filled with the internal parvo buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling
*/ */
void getParvoRAW(Mat &retinaOutput_parvo); void getParvoRAW(OutputArray retinaOutput_parvo);
/** /**
* accessor of the motion channel of the retina (models peripheral vision) * accessor of the motion channel of the retina (models peripheral vision)
* @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV * @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV
*/ */
void getMagno(Mat &retinaOutput_magno); void getMagno(OutputArray retinaOutput_magno);
/** /**
* accessor of the motion channel of the retina (models peripheral vision) * accessor of the motion channel of the retina (models peripheral vision)
* @param retinaOutput_magno : a cv::Mat header filled with the internal retina magno buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling * @param retinaOutput_magno : a cv::Mat header filled with the internal retina magno buffer of the retina module. This output is the original retina filter model output, without any quantification or rescaling
*/ */
void getMagnoRAW(Mat &retinaOutput_magno); void getMagnoRAW(OutputArray retinaOutput_magno);
// original API level data accessors : get buffers addresses from a Mat header, similar to getParvoRAW and getMagnoRAW... // original API level data accessors : get buffers addresses from a Mat header, similar to getParvoRAW and getMagnoRAW...
const Mat getMagnoRAW() const; const Mat getMagnoRAW() const;
@ -267,7 +267,7 @@ private:
* @param colorMode : a flag which mentions if matrix is color (true) or graylevel (false) * @param colorMode : a flag which mentions if matrix is color (true) or graylevel (false)
* @param outBuffer : the output matrix which is reallocated to satisfy Retina output buffer dimensions * @param outBuffer : the output matrix which is reallocated to satisfy Retina output buffer dimensions
*/ */
void _convertValarrayBuffer2cvMat(const std::valarray<float> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, Mat &outBuffer); void _convertValarrayBuffer2cvMat(const std::valarray<float> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, OutputArray outBuffer);
/** /**
* *
@ -275,7 +275,7 @@ private:
* @param outputValarrayMatrix : the output valarray * @param outputValarrayMatrix : the output valarray
* @return the input image color mode (color=true, gray levels=false) * @return the input image color mode (color=true, gray levels=false)
*/ */
bool _convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, std::valarray<float> &outputValarrayMatrix); bool _convertCvMat2ValarrayBuffer(InputArray inputMatToConvert, std::valarray<float> &outputValarrayMatrix);
//! private method called by constructors, gathers their parameters and use them in a unified way //! private method called by constructors, gathers their parameters and use them in a unified way
void _init(const Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0); void _init(const Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0);
@ -517,16 +517,16 @@ void RetinaImpl::setupIPLMagnoChannel(const bool normaliseOutput, const float pa
_retinaParameters.IplMagno.localAdaptintegration_k = localAdaptintegration_k; _retinaParameters.IplMagno.localAdaptintegration_k = localAdaptintegration_k;
} }
void RetinaImpl::run(const cv::Mat &inputMatToConvert) void RetinaImpl::run(InputArray inputMatToConvert)
{ {
// 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, _inputBuffer); const bool colorMode = _convertCvMat2ValarrayBuffer(inputMatToConvert.getMat(), _inputBuffer);
// process the retina // process the retina
if (!_retinaFilter->runFilter(_inputBuffer, colorMode, false, _retinaParameters.OPLandIplParvo.colorMode && colorMode, false)) if (!_retinaFilter->runFilter(_inputBuffer, colorMode, false, _retinaParameters.OPLandIplParvo.colorMode && colorMode, false))
throw cv::Exception(-1, "RetinaImpl cannot be applied, wrong input buffer size", "RetinaImpl::run", "RetinaImpl.h", 0); throw cv::Exception(-1, "RetinaImpl cannot be applied, wrong input buffer size", "RetinaImpl::run", "RetinaImpl.h", 0);
} }
void RetinaImpl::getParvo(cv::Mat &retinaOutput_parvo) void RetinaImpl::getParvo(OutputArray retinaOutput_parvo)
{ {
if (_retinaFilter->getColorMode()) if (_retinaFilter->getColorMode())
{ {
@ -539,7 +539,7 @@ void RetinaImpl::getParvo(cv::Mat &retinaOutput_parvo)
} }
//retinaOutput_parvo/=255.0; //retinaOutput_parvo/=255.0;
} }
void RetinaImpl::getMagno(cv::Mat &retinaOutput_magno) void RetinaImpl::getMagno(OutputArray retinaOutput_magno)
{ {
// 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);
@ -547,14 +547,14 @@ void RetinaImpl::getMagno(cv::Mat &retinaOutput_magno)
} }
// original API level data accessors : copy buffers if size matches, reallocate if required // original API level data accessors : copy buffers if size matches, reallocate if required
void RetinaImpl::getMagnoRAW(cv::Mat &magnoOutputBufferCopy){ void RetinaImpl::getMagnoRAW(OutputArray magnoOutputBufferCopy){
// 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
magnoChannel.copyTo(magnoOutputBufferCopy); magnoChannel.copyTo(magnoOutputBufferCopy);
} }
void RetinaImpl::getParvoRAW(cv::Mat &parvoOutputBufferCopy){ void RetinaImpl::getParvoRAW(OutputArray parvoOutputBufferCopy){
// get parvo channel header // get parvo channel header
const cv::Mat parvoChannel=cv::Mat(getMagnoRAW()); const cv::Mat parvoChannel=cv::Mat(getMagnoRAW());
// copy data // copy data
@ -605,25 +605,27 @@ void RetinaImpl::_init(const cv::Size inputSz, const bool colorMode, RETINA_COLO
printf("%s\n", printSetup().c_str()); printf("%s\n", printSetup().c_str());
} }
void RetinaImpl::_convertValarrayBuffer2cvMat(const std::valarray<float> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, cv::Mat &outBuffer) void RetinaImpl::_convertValarrayBuffer2cvMat(const std::valarray<float> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, OutputArray outBuffer)
{ {
// fill output buffer with the valarray buffer // fill output buffer with the valarray buffer
const float *valarrayPTR=get_data(grayMatrixToConvert); const float *valarrayPTR=get_data(grayMatrixToConvert);
if (!colorMode) if (!colorMode)
{ {
outBuffer.create(cv::Size(nbColumns, nbRows), CV_8U); outBuffer.create(cv::Size(nbColumns, nbRows), CV_8U);
Mat outMat = outBuffer.getMat();
for (unsigned int i=0;i<nbRows;++i) for (unsigned int i=0;i<nbRows;++i)
{ {
for (unsigned int j=0;j<nbColumns;++j) for (unsigned int j=0;j<nbColumns;++j)
{ {
cv::Point2d pixel(j,i); cv::Point2d pixel(j,i);
outBuffer.at<unsigned char>(pixel)=(unsigned char)*(valarrayPTR++); outMat.at<unsigned char>(pixel)=(unsigned char)*(valarrayPTR++);
} }
} }
}else }else
{ {
const unsigned int doubleNBpixels=_retinaFilter->getOutputNBpixels()*2; const unsigned int doubleNBpixels=_retinaFilter->getOutputNBpixels()*2;
outBuffer.create(cv::Size(nbColumns, nbRows), CV_8UC3); outBuffer.create(cv::Size(nbColumns, nbRows), CV_8UC3);
Mat outMat = outBuffer.getMat();
for (unsigned int i=0;i<nbRows;++i) for (unsigned int i=0;i<nbRows;++i)
{ {
for (unsigned int j=0;j<nbColumns;++j,++valarrayPTR) for (unsigned int j=0;j<nbColumns;++j,++valarrayPTR)
@ -634,14 +636,15 @@ void RetinaImpl::_convertValarrayBuffer2cvMat(const std::valarray<float> &grayMa
pixelValues[1]=(unsigned char)*(valarrayPTR+_retinaFilter->getOutputNBpixels()); pixelValues[1]=(unsigned char)*(valarrayPTR+_retinaFilter->getOutputNBpixels());
pixelValues[0]=(unsigned char)*(valarrayPTR+doubleNBpixels); pixelValues[0]=(unsigned char)*(valarrayPTR+doubleNBpixels);
outBuffer.at<cv::Vec3b>(pixel)=pixelValues; outMat.at<cv::Vec3b>(pixel)=pixelValues;
} }
} }
} }
} }
bool RetinaImpl::_convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, std::valarray<float> &outputValarrayMatrix) bool RetinaImpl::_convertCvMat2ValarrayBuffer(InputArray inputMat, std::valarray<float> &outputValarrayMatrix)
{ {
const Mat inputMatToConvert=inputMat.getMat();
// first check input consistency // first check input consistency
if (inputMatToConvert.empty()) if (inputMatToConvert.empty())
throw cv::Exception(-1, "RetinaImpl cannot be applied, input buffer is empty", "RetinaImpl::run", "RetinaImpl.h", 0); throw cv::Exception(-1, "RetinaImpl cannot be applied, input buffer is empty", "RetinaImpl::run", "RetinaImpl.h", 0);
@ -654,6 +657,7 @@ bool RetinaImpl::_convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, s
const int dsttype = DataType<T>::depth; // output buffer is float format const int dsttype = DataType<T>::depth; // output buffer is float format
if(imageNumberOfChannels==4) if(imageNumberOfChannels==4)
{ {
// create a cv::Mat table (for RGBA planes) // create a cv::Mat table (for RGBA planes)
@ -665,7 +669,7 @@ bool RetinaImpl::_convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, s
}; };
planes[3] = cv::Mat(inputMatToConvert.size(), dsttype); // last channel (alpha) does not point on the valarray (not usefull in our case) planes[3] = cv::Mat(inputMatToConvert.size(), dsttype); // last channel (alpha) does not point on the valarray (not usefull in our case)
// split color cv::Mat in 4 planes... it fills valarray directely // split color cv::Mat in 4 planes... it fills valarray directely
cv::split(cv::Mat_<Vec<T, 4> >(inputMatToConvert), planes); cv::split(Mat_<Vec<T, 4> >(inputMatToConvert), planes);
} }
else if (imageNumberOfChannels==3) else if (imageNumberOfChannels==3)
{ {