bioinspired -> opencv_contrib

doc/tutorials/bioinspired/table_of_content_bioinspired/table_of_content_bioinspired.rst

+.. _Table-Of-Content-Bioinspired:
+
+*bioinspired* module. Algorithms inspired from biological models
+----------------------------------------------------------------
+
+Here you will learn how to use additional modules of OpenCV defined in the "bioinspired" module.
+
+ .. include:: ../../definitions/tocDefinitions.rst
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+  |RetinaDemoImg| **Title:** :ref:`Retina_Model`
+
+                  *Compatibility:* > OpenCV 2.4
+
+                  *Author:* |Author_AlexB|
+
+                  You will learn how to process images and video streams with a model of retina filter for details enhancement, spatio-temporal noise removal, luminance correction and spatio-temporal events detection.
+
+  =============== ======================================================
+
+  .. |RetinaDemoImg| image:: images/retina_TreeHdr_small.jpg
+                   :height: 90pt
+                   :width:  90pt
+
+ .. raw:: latex
+
+    \pagebreak
+
+.. toctree::
+   :hidden:
+
+   ../retina_model/retina_model

modules/bioinspired/CMakeLists.txt

+set(the_description "Biologically inspired algorithms")
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
+ocv_define_module(bioinspired opencv_core OPTIONAL opencv_highgui opencv_ocl)

modules/bioinspired/doc/bioinspired.rst

+********************************************************************
+bioinspired. Biologically inspired vision models and derivated tools
+********************************************************************
+
+The module provides biological visual systems models (human visual system and others). It also provides derivated objects that take advantage of those bio-inspired models.
+
+.. toctree::
+    :maxdepth: 2
+
+    Human retina documentation <retina/index>

modules/bioinspired/include/opencv2/bioinspired.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BIOINSPIRED_HPP__
+#define __OPENCV_BIOINSPIRED_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/bioinspired/retina.hpp"
+#include "opencv2/bioinspired/retinafasttonemapping.hpp"
+
+#endif

modules/bioinspired/include/opencv2/bioinspired/bioinspired.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/bioinspired.hpp"

modules/bioinspired/include/opencv2/bioinspired/retinafasttonemapping.hpp

+
+/*#******************************************************************************
+ ** IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ **
+ ** By downloading, copying, installing or using the software you agree to this license.
+ ** If you do not agree to this license, do not download, install,
+ ** copy or use the software.
+ **
+ **
+ ** bioinspired : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+ **
+ ** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+ **
+ **  Creation - enhancement process 2007-2013
+ **      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+ **
+ ** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+ ** Refer to the following research paper for more information:
+ ** 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
+ ** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+ ** 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.
+ **
+ **
+ **
+ **
+ **
+ ** This class is based on image processing tools of the author and already used within the Retina class (this is the same code as method retina::applyFastToneMapping, but in an independent class, it is ligth from a memory requirement point of view). It implements an adaptation of the efficient tone mapping algorithm propose by David Alleyson, Sabine Susstruck and Laurence Meylan's work, please cite:
+ ** -> Meylan L., Alleysson D., and Susstrunk S., A Model of Retinal Local Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of America, A, Vol. 24, N 9, September, 1st, 2007, pp. 2807-2816
+ **
+ **
+ **                          License Agreement
+ **               For Open Source Computer Vision Library
+ **
+ ** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ ** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+ **
+ **               For Human Visual System tools (bioinspired)
+ ** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+ **
+ ** Third party copyrights are property of their respective owners.
+ **
+ ** Redistribution and use in source and binary forms, with or without modification,
+ ** are permitted provided that the following conditions are met:
+ **
+ ** * Redistributions of source code must retain the above copyright notice,
+ **    this list of conditions and the following disclaimer.
+ **
+ ** * Redistributions in binary form must reproduce the above copyright notice,
+ **    this list of conditions and the following disclaimer in the documentation
+ **    and/or other materials provided with the distribution.
+ **
+ ** * The name of the copyright holders may not be used to endorse or promote products
+ **    derived from this software without specific prior written permission.
+ **
+ ** This software is provided by the copyright holders and contributors "as is" and
+ ** any express or implied warranties, including, but not limited to, the implied
+ ** warranties of merchantability and fitness for a particular purpose are disclaimed.
+ ** In no event shall the Intel Corporation or contributors be liable for any direct,
+ ** indirect, incidental, special, exemplary, or consequential damages
+ ** (including, but not limited to, procurement of substitute goods or services;
+ ** loss of use, data, or profits; or business interruption) however caused
+ ** and on any theory of liability, whether in contract, strict liability,
+ ** or tort (including negligence or otherwise) arising in any way out of
+ ** the use of this software, even if advised of the possibility of such damage.
+ *******************************************************************************/
+
+#ifndef __OPENCV_BIOINSPIRED_RETINAFASTTONEMAPPING_HPP__
+#define __OPENCV_BIOINSPIRED_RETINAFASTTONEMAPPING_HPP__
+
+/*
+ * retinafasttonemapping.hpp
+ *
+ *  Created on: May 26, 2013
+ *      Author: Alexandre Benoit
+ */
+
+#include "opencv2/core.hpp" // for all OpenCV core functionalities access, including cv::Exception support
+
+namespace cv{
+namespace bioinspired{
+
+/**
+ * @class RetinaFastToneMappingImpl a wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV.
+ * This algorithm is already implemented in thre Retina class (retina::applyFastToneMapping) but used it does not require all the retina model to be allocated. This allows a light memory use for low memory devices (smartphones, etc.
+ * As a summary, these are the model properties:
+ * => 2 stages of local luminance adaptation with a different local neighborhood for each.
+ * => first stage models the retina photorecetors local luminance adaptation
+ * => second stage models th ganglion cells local information adaptation
+ * => compared to the initial publication, this class uses spatio-temporal low pass filters instead of spatial only filters.
+ * ====> this can help noise robustness and temporal stability for video sequence use cases.
+ * for more information, read to the following papers :
+ *  Meylan L., Alleysson D., and Susstrunk S., A Model of Retinal Local Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of America, A, Vol. 24, N 9, September, 1st, 2007, pp. 2807-2816Benoit 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
+ * regarding spatio-temporal filter and the bigger retina model :
+ * 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.
+ */
+class CV_EXPORTS RetinaFastToneMapping : public Algorithm
+{
+public:
+
+    /**
+     * method that applies a luminance correction (initially High Dynamic Range (HDR) tone mapping) using only the 2 local adaptation stages of the retina parvocellular channel : photoreceptors level and ganlion cells level. Spatio temporal filtering is applied but limited to temporal smoothing and eventually high frequencies attenuation. This is a lighter method than the one available using the regular retina::run method. It is then faster but it does not include complete temporal filtering nor retina spectral whitening. Then, it can have a more limited effect on images with a very high dynamic range. This is an adptation of the original still image HDR tone mapping algorithm of David Alleyson, Sabine Susstruck and Laurence Meylan's work, please cite:
+    * -> Meylan L., Alleysson D., and Susstrunk S., A Model of Retinal Local Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of America, A, Vol. 24, N 9, September, 1st, 2007, pp. 2807-2816
+     @param inputImage the input image to process RGB or gray levels
+     @param outputToneMappedImage the output tone mapped image
+     */
+    virtual void applyFastToneMapping(InputArray inputImage, OutputArray outputToneMappedImage)=0;
+
+    /**
+     * setup method that updates tone mapping behaviors by adjusing the local luminance computation area
+     * @param photoreceptorsNeighborhoodRadius the first stage local adaptation area
+     * @param ganglioncellsNeighborhoodRadius the second stage local adaptation area
+     * @param meanLuminanceModulatorK the factor applied to modulate the meanLuminance information (default is 1, see reference paper)
+     */
+    virtual void setup(const float photoreceptorsNeighborhoodRadius=3.f, const float ganglioncellsNeighborhoodRadius=1.f, const float meanLuminanceModulatorK=1.f)=0;
+};
+
+CV_EXPORTS Ptr<RetinaFastToneMapping> createRetinaFastToneMapping(Size inputSize);
+
+}
+}
+#endif /* __OPENCV_BIOINSPIRED_RETINAFASTTONEMAPPING_HPP__ */

modules/bioinspired/samples/cpp/retinaDemo.cpp

+//============================================================================
+// Name        : retinademo.cpp
+// Author      : Alexandre Benoit, benoit.alexandre.vision@gmail.com
+// Version     : 0.1
+// Copyright   : LISTIC/GIPSA French Labs, july 2011
+// Description : Gipsa/LISTIC Labs retina demo in C++, Ansi-style
+//============================================================================
+
+#include <iostream>
+#include <cstring>
+
+#include "opencv2/bioinspired.hpp"
+#include "opencv2/highgui.hpp"
+
+static void help(std::string errorMessage)
+{
+    std::cout<<"Program init error : "<<errorMessage<<std::endl;
+    std::cout<<"\nProgram call procedure : retinaDemo [processing mode] [Optional : media target] [Optional LAST parameter: \"log\" to activate retina log sampling]"<<std::endl;
+    std::cout<<"\t[processing mode] :"<<std::endl;
+    std::cout<<"\t -image : for still image processing"<<std::endl;
+    std::cout<<"\t -video : for video stream processing"<<std::endl;
+    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[]) {
+    // welcome message
+    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 still images, video 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;
+
+    // basic input arguments checking
+    if (argc<2)
+    {
+        help("bad number of parameter");
+        return -1;
+    }
+
+    bool useLogSampling = !strcmp(argv[argc-1], "log"); // check if user wants retina log sampling processing
+
+    std::string inputMediaType=argv[1];
+
+    // declare the retina input buffer... that will be fed differently in regard of the input media
+    cv::Mat inputFrame;
+    cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here
+
+    //////////////////////////////////////////////////////////////////////////////
+    // checking input media type (still image, video file, live video acquisition)
+    if (!strcmp(inputMediaType.c_str(), "-image") && argc >= 3)
+    {
+        std::cout<<"RetinaDemo: processing image "<<argv[2]<<std::endl;
+        // image processing case
+        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())
+    {
+        help("Input media could not be loaded, aborting");
+        return -1;
+    }
+
+
+    //////////////////////////////////////////////////////////////////////////////
+    // Program start in a try/catch safety context (Retina may throw errors)
+    try
+    {
+        // create a retina instance with default parameters setup, uncomment the initialisation you wanna test
+        cv::Ptr<cv::bioinspired::Retina> myRetina;
+
+        // if the last parameter is 'log', then activate log sampling (favour foveal vision and subsamples peripheral vision)
+        if (useLogSampling)
+                {
+                        myRetina = cv::bioinspired::createRetina(inputFrame.size(), true, cv::bioinspired::RETINA_COLOR_BAYER, true, 2.0, 10.0);
+                }
+        else// -> else allocate "classical" retina :
+            myRetina = cv::bioinspired::createRetina(inputFrame.size());
+
+        // 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");
+
+        // load parameters if file exists
+        myRetina->setup("RetinaSpecificParameters.xml");
+        myRetina->clearBuffers();
+
+        // declare retina output buffers
+        cv::Mat retinaOutput_parvo;
+        cv::Mat retinaOutput_magno;
+
+        // processing loop with stop condition
+        bool continueProcessing=true; // FIXME : not yet managed during process...
+        while(continueProcessing)
+        {
+            // if using video stream, then, grabbing a new frame, else, input remains the same
+            if (videoCapture.isOpened())
+                videoCapture>>inputFrame;
+
+            // 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);
+        }
+    }catch(cv::Exception e)
+    {
+        std::cerr<<"Error using Retina : "<<e.what()<<std::endl;
+    }
+
+    // Program end message
+    std::cout<<"Retina demo end"<<std::endl;
+
+    return 0;
+}

modules/bioinspired/samples/cpp/tutorial_code/bioinspired/retina_tutorial.cpp

+//============================================================================
+// Name        : retina_tutorial.cpp
+// Author      : Alexandre Benoit, benoit.alexandre.vision@gmail.com
+// Version     : 0.1
+// Copyright   : LISTIC/GIPSA French Labs, july 2012
+// Description : Gipsa/LISTIC Labs retina demo in C++, Ansi-style
+//============================================================================
+
+#include <iostream>
+#include <cstring>
+
+#include "opencv2/bioinspired.hpp"
+#include "opencv2/highgui.hpp"
+
+static void help(std::string errorMessage)
+{
+    std::cout<<"Program init error : "<<errorMessage<<std::endl;
+    std::cout<<"\nProgram call procedure : retinaDemo [processing mode] [Optional : media target] [Optional LAST parameter: \"log\" to activate retina log sampling]"<<std::endl;
+    std::cout<<"\t[processing mode] :"<<std::endl;
+    std::cout<<"\t -image : for still image processing"<<std::endl;
+    std::cout<<"\t -video : for video stream processing"<<std::endl;
+    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;
+    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;
+}
+
+int main(int argc, char* argv[]) {
+    // welcome message
+    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 demo will try to load the file 'RetinaSpecificParameters.xml' (if exists).\nTo create it, copy the autogenerated template 'RetinaDefaultParameters.xml'.\nThen tweak it with your own retina parameters."<<std::endl;
+    // basic input arguments checking
+    if (argc<2)
+    {
+        help("bad number of parameter");
+        return -1;
+    }
+
+    bool useLogSampling = !strcmp(argv[argc-1], "log"); // check if user wants retina log sampling processing
+
+    std::string inputMediaType=argv[1];
+
+    // declare the retina input buffer... that will be fed differently in regard of the input media
+    cv::Mat inputFrame;
+    cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here
+
+    //////////////////////////////////////////////////////////////////////////////
+    // checking input media type (still image, video file, live video acquisition)
+    if (!strcmp(inputMediaType.c_str(), "-image") && argc >= 3)
+    {
+        std::cout<<"RetinaDemo: processing image "<<argv[2]<<std::endl;
+        // image processing case
+        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())
+    {
+        help("Input media could not be loaded, aborting");
+        return -1;
+    }
+
+
+    //////////////////////////////////////////////////////////////////////////////
+    // Program start in a try/catch safety context (Retina may throw errors)
+    try
+    {
+        // create a retina instance with default parameters setup, uncomment the initialisation you wanna test
+        cv::Ptr<cv::bioinspired::Retina> myRetina;
+
+        // if the last parameter is 'log', then activate log sampling (favour foveal vision and subsamples peripheral vision)
+        if (useLogSampling)
+        {
+            myRetina = cv::bioinspired::createRetina(inputFrame.size(), true, cv::bioinspired::RETINA_COLOR_BAYER, true, 2.0, 10.0);
+        }
+        else// -> else allocate "classical" retina :
+        {
+            myRetina = cv::bioinspired::createRetina(inputFrame.size());
+        }
+
+        // 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");
+
+        // load parameters if file exists
+        myRetina->setup("RetinaSpecificParameters.xml");
+
+        // reset all retina buffers (imagine you close your eyes for a long time)
+        myRetina->clearBuffers();
+
+        // declare retina output buffers
+        cv::Mat retinaOutput_parvo;
+        cv::Mat retinaOutput_magno;
+
+        // processing loop with no stop condition
+        for(;;)
+        {
+            // if using video stream, then, grabbing a new frame, else, input remains the same
+            if (videoCapture.isOpened())
+                videoCapture>>inputFrame;
+
+            // run retina filter on the loaded input frame
+            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(10);
+        }
+    }catch(cv::Exception e)
+    {
+        std::cerr<<"Error using Retina or end of video sequence reached : "<<e.what()<<std::endl;
+    }
+
+    // Program end message
+    std::cout<<"Retina demo end"<<std::endl;
+
+    return 0;
+}

modules/bioinspired/samples/ocl/retina_ocl.cpp

+#include <iostream>
+#include <cstring>
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/ocl.hpp"
+#include "opencv2/bioinspired.hpp"
+
+using namespace cv;
+using namespace cv::ocl;
+using namespace std;
+
+const int total_loop_count = 50;
+
+static void help(CommandLineParser cmd, const String& errorMessage)
+{
+    cout << errorMessage << endl;
+    cout << "Avaible options:" << endl;
+    cmd.printMessage();
+}
+
+int main(int argc, char* argv[])
+{
+    //set this to save kernel compile time from second time you run
+    ocl::setBinaryDiskCache();
+    const char* keys =
+        "{ h   | help     | false           | print help message }"
+        "{ c   | cpu      | false           | use cpu (original version) or gpu(OpenCL) to process the image }"
+        "{ i   | image    | cat.jpg         | specify the input image }";
+
+    CommandLineParser cmd(argc, argv, keys);
+
+    if(cmd.get<bool>("help"))
+    {
+        help(cmd, "Usage: ./retina_ocl [options]");
+        return EXIT_FAILURE;
+    }
+
+    String fname = cmd.get<String>("i");
+    bool useCPU = cmd.get<bool>("c");
+
+    cv::Mat input = imread(fname);
+    if(input.empty())
+    {
+        help(cmd, "Error opening: " + fname);
+        return EXIT_FAILURE;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Program start in a try/catch safety context (Retina may throw errors)
+    try
+    {
+        // create a retina instance with default parameters setup, uncomment the initialisation you wanna test
+        cv::Ptr<cv::bioinspired::Retina> oclRetina;
+        cv::Ptr<cv::bioinspired::Retina> retina;
+        // declare retina output buffers
+        cv::ocl::oclMat retina_parvo_ocl;
+        cv::ocl::oclMat retina_magno_ocl;
+        cv::Mat retina_parvo;
+        cv::Mat retina_magno;
+
+        if(useCPU)
+        {
+            retina = cv::bioinspired::createRetina(input.size());
+            retina->clearBuffers();
+        }
+        else
+        {
+            oclRetina = cv::bioinspired::createRetina_OCL(input.size());
+            oclRetina->clearBuffers();
+        }
+
+        int64 temp_time = 0, total_time = 0;
+
+        int loop_counter = 0;
+        for(; loop_counter <= total_loop_count; ++loop_counter)
+        {
+            if(useCPU)
+            {
+                temp_time = cv::getTickCount();
+                retina->run(input);
+                retina->getParvo(retina_parvo);
+                retina->getMagno(retina_magno);
+            }
+            else
+            {
+                cv::ocl::oclMat input_ocl(input);
+                temp_time = cv::getTickCount();
+                oclRetina->run(input_ocl);
+                oclRetina->getParvo(retina_parvo_ocl);
+                oclRetina->getMagno(retina_magno_ocl);
+            }
+            // will not count the first loop, which is considered as warm-up period
+            if(loop_counter > 0)
+            {
+                temp_time = (cv::getTickCount() - temp_time);
+                total_time += temp_time;
+                printf("Frame id %2d: %3.4fms\n", loop_counter, (double)temp_time / cv::getTickFrequency() * 1000.0);
+            }
+            if(!useCPU)
+            {
+                retina_parvo = retina_parvo_ocl;
+                retina_magno = retina_magno_ocl;
+            }
+            cv::imshow("retina input", input);
+            cv::imshow("Retina Parvo", retina_parvo);
+            cv::imshow("Retina Magno", retina_magno);
+            cv::waitKey(10);
+        }
+        printf("Average: %.4fms\n", (double)total_time / total_loop_count / cv::getTickFrequency() * 1000.0);
+    }
+    catch(cv::Exception e)
+    {
+        std::cerr << "Error using Retina : " << e.what() << std::endl;
+    }
+    // Program end message
+    std::cout << "Retina demo end" << std::endl;
+    return EXIT_SUCCESS;
+}

modules/bioinspired/src/precomp.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/bioinspired.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+#include "opencv2/core/ocl.hpp"
+
+#include <valarray>
+
+#ifdef HAVE_OPENCV_OCL
+    #include "opencv2/ocl/private/util.hpp"
+#endif
+
+namespace cv
+{
+
+// special function to get pointer to constant valarray elements, since
+// simple &arr[0] does not compile on VS2005/VS2008.
+template<typename T> inline const T* get_data(const std::valarray<T>& arr)
+{ return &((std::valarray<T>&)arr)[0]; }
+
+}
+
+#endif

modules/bioinspired/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

modules/bioinspired/test/test_precomp.hpp

+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/bioinspired.hpp"
+#include <iostream>
+
+#endif