Merge pull request #2412 from atinfinity:fixed-typo

* fixed typo

* fixed document

Author: atinfinity

modules/aruco/include/opencv2/aruco/charuco.hpp

@@ -124,7 +124,7 @@ class CV_EXPORTS_W CharucoBoard : public Board {
     // size of chessboard squares side (normally in meters)
     float _squareLength;
 
-    // marker side lenght (normally in meters)
+    // marker side length (normally in meters)
     float _markerLength;
 };
 

modules/aruco/samples/detect_board.cpp

@@ -50,7 +50,7 @@ const char* about = "Pose estimation using a ArUco Planar Grid board";
 const char* keys  =
         "{w        |       | Number of squares in X direction }"
         "{h        |       | Number of squares in Y direction }"
-        "{l        |       | Marker side lenght (in pixels) }"
+        "{l        |       | Marker side length (in pixels) }"
         "{s        |       | Separation between two consecutive markers in the grid (in pixels)}"
         "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
         "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "

modules/aruco/samples/detect_markers.cpp

@@ -55,7 +55,7 @@ const char* keys  =
         "{v        |       | Input from video file, if ommited, input comes from camera }"
         "{ci       | 0     | Camera id if input doesnt come from video (-v) }"
         "{c        |       | Camera intrinsic parameters. Needed for camera pose }"
-        "{l        | 0.1   | Marker side lenght (in meters). Needed for correct scale in camera pose }"
+        "{l        | 0.1   | Marker side length (in meters). Needed for correct scale in camera pose }"
         "{dp       |       | File of marker detector parameters }"
         "{r        |       | show rejected candidates too }"
         "{refine   |       | Corner refinement: CORNER_REFINE_NONE=0, CORNER_REFINE_SUBPIX=1,"

modules/aruco/tutorials/aruco_board_detection/aruco_board_detection.markdown

@@ -113,7 +113,7 @@ A ```GridBoard``` object can be defined using the following parameters:
 
 - Number of markers in the X direction.
 - Number of markers in the Y direction.
-- Lenght of the marker side.
+- Length of the marker side.
 - Length of the marker separation.
 - The dictionary of the markers.
 - Ids of all the markers (X*Y markers).

modules/bioinspired/doc/retina.markdown

@@ -207,7 +207,7 @@ functions (C++, Java, Python) :
 
       // Allocators
       cv::Ptr<Retina> Retina::create (Size inputSize);
-      cv::Ptr<Retina> Retina::create (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);
+      cv::Ptr<Retina> Retina::create (Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrength=10.0);
       }} // cv and bioinspired namespaces end
 @endcode
 

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

@@ -438,13 +438,13 @@ class CV_EXPORTS_W Retina : public Algorithm {
     @param reductionFactor only usefull if param useRetinaLogSampling=true, specifies the reduction
     factor of the output frame (as the center (fovea) is high resolution and corners can be
     underscaled, then a reduction of the output is allowed without precision leak
-    @param samplingStrenght only usefull if param useRetinaLogSampling=true, specifies the strenght of
+    @param samplingStrength only usefull if param useRetinaLogSampling=true, specifies the strength of
     the log scale that is applied
      */
     CV_WRAP static Ptr<Retina> create(Size inputSize, const bool colorMode,
                                            int colorSamplingMethod=RETINA_COLOR_BAYER,
                                            const bool useRetinaLogSampling=false,
-                                           const float reductionFactor=1.0f, const float samplingStrenght=10.0f);
+                                           const float reductionFactor=1.0f, const float samplingStrength=10.0f);
 };
 
 //! @}

modules/bioinspired/src/basicretinafilter.hpp

@@ -257,7 +257,7 @@ namespace bioinspired
         * @param beta: gain of the filter (generally set to zero)
         * @param tau: time constant of the filter (unit is frame for video processing)
         * @param alpha0: spatial constant of the filter (unit is pixels) on the border of the image
-        * @param accuracyMap an image (float format) which values range is between 0 and 1, where 0 means, apply no filtering and 1 means apply the filtering as specified in the parameters set, intermediate values allow to smooth variations of the filtering strenght
+        * @param accuracyMap an image (float format) which values range is between 0 and 1, where 0 means, apply no filtering and 1 means apply the filtering as specified in the parameters set, intermediate values allow to smooth variations of the filtering strength
         * @param filterIndex: the index which specifies the parameter set that should be used for the filtering
         */
         void setProgressiveFilterConstants_CustomAccuracy(const float beta, const float tau, const float alpha0, const std::valarray<float> &accuracyMap, const unsigned int filterIndex=0);

modules/bioinspired/src/imagelogpolprojection.cpp

@@ -125,33 +125,33 @@ void ImageLogPolProjection::clearAllBuffers()
 void ImageLogPolProjection::resize(const unsigned int NBrows, const unsigned int NBcolumns)
 {
     BasicRetinaFilter::resize(NBrows, NBcolumns);
-    initProjection(_reductionFactor, _samplingStrenght);
+    initProjection(_reductionFactor, _samplingStrength);
 
     // reset buffers method
     clearAllBuffers();
 
 }
 
 // init functions depending on the projection type
-bool ImageLogPolProjection::initProjection(const double reductionFactor, const double samplingStrenght)
+bool ImageLogPolProjection::initProjection(const double reductionFactor, const double samplingStrength)
 {
     switch(_selectedProjection)
     {
     case RETINALOGPROJECTION:
-        return _initLogRetinaSampling(reductionFactor, samplingStrenght);
+        return _initLogRetinaSampling(reductionFactor, samplingStrength);
         break;
     case CORTEXLOGPOLARPROJECTION:
-        return _initLogPolarCortexSampling(reductionFactor, samplingStrenght);
+        return _initLogPolarCortexSampling(reductionFactor, samplingStrength);
         break;
     default:
         std::cout<<"ImageLogPolProjection::no projection setted up... performing default retina projection... take care"<<std::endl;
-        return _initLogRetinaSampling(reductionFactor, samplingStrenght);
+        return _initLogRetinaSampling(reductionFactor, samplingStrength);
         break;
     }
 }
 
 // -> private init functions dedicated to each projection
-bool ImageLogPolProjection::_initLogRetinaSampling(const double reductionFactor, const double samplingStrenght)
+bool ImageLogPolProjection::_initLogRetinaSampling(const double reductionFactor, const double samplingStrength)
 {
     _initOK=false;
 
@@ -173,7 +173,7 @@ bool ImageLogPolProjection::_initLogRetinaSampling(const double reductionFactor,
     _outputDoubleNBpixels=_outputNBrows*_outputNBcolumns*2;
 
 #ifdef IMAGELOGPOLPROJECTION_DEBUG
-    std::cout<<"ImageLogPolProjection::initLogRetinaSampling: Log resampled image resampling factor: "<<reductionFactor<<", strenght:"<<samplingStrenght<<std::endl;
+    std::cout<<"ImageLogPolProjection::initLogRetinaSampling: Log resampled image resampling factor: "<<reductionFactor<<", strength:"<<samplingStrength<<std::endl;
     std::cout<<"ImageLogPolProjection::initLogRetinaSampling: Log resampled image size: "<<_outputNBrows<<"*"<<_outputNBcolumns<<std::endl;
 #endif
 
@@ -185,16 +185,16 @@ bool ImageLogPolProjection::_initLogRetinaSampling(const double reductionFactor,
 
     // specifiying new reduction factor after preliminar checks
     _reductionFactor=reductionFactor;
-    _samplingStrenght=samplingStrenght;
+    _samplingStrength=samplingStrength;
 
     // compute the rlim for symetric rows/columns sampling, then, the rlim is based on the smallest dimension
     _minDimension=(double)(_filterOutput.getNBrows() < _filterOutput.getNBcolumns() ? _filterOutput.getNBrows() : _filterOutput.getNBcolumns());
 
     // input frame dimensions dependent log sampling:
-    //double rlim=1.0/reductionFactor*(minDimension/2.0+samplingStrenght);
+    //double rlim=1.0/reductionFactor*(minDimension/2.0+samplingStrength);
 
     // input frame dimensions INdependent log sampling:
-    _azero=(1.0+reductionFactor*std::sqrt(samplingStrenght))/(reductionFactor*reductionFactor*samplingStrenght-1.0);
+    _azero=(1.0+reductionFactor*std::sqrt(samplingStrength))/(reductionFactor*reductionFactor*samplingStrength-1.0);
     _alim=(1.0+_azero)/reductionFactor;
 #ifdef IMAGELOGPOLPROJECTION_DEBUG
     std::cout<<"ImageLogPolProjection::initLogRetinaSampling: rlim= "<<rlim<<std::endl;
@@ -224,7 +224,7 @@ bool ImageLogPolProjection::_initLogRetinaSampling(const double reductionFactor,
             // get the pixel position in the original picture
 
             // -> input frame dimensions dependent log sampling:
-            //double scale = samplingStrenght/(rlim-(double)std::sqrt(idRow*idRow+idColumn*idColumn));
+            //double scale = samplingStrength/(rlim-(double)std::sqrt(idRow*idRow+idColumn*idColumn));
 
             // -> input frame dimensions INdependent log sampling:
             double scale=getOriginalRadiusLength((double)std::sqrt((double)(idRow*idRow+idColumn*idColumn)));
@@ -363,14 +363,14 @@ bool ImageLogPolProjection::_initLogPolarCortexSampling(const double reductionFa
 
     //std::cout<<"ImageLogPolProjection::Starting cortex projection"<<std::endl;
     // compute transformation, get theta and Radius in reagrd of the output sampled pixel
-    double diagonalLenght=std::sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
+    double diagonalLength=std::sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
     for (unsigned int radiusIndex=0;radiusIndex<_outputNBcolumns;++radiusIndex)
         for(unsigned int orientationIndex=0;orientationIndex<_outputNBrows;++orientationIndex)
         {
             double x=1.0+sinh(radiusAxis[radiusIndex])*cos(orientationAxis[orientationIndex]);
             double y=sinh(radiusAxis[radiusIndex])*sin(orientationAxis[orientationIndex]);
             // get the input picture coordinate
-            double R=diagonalLenght*std::sqrt(x*x+y*y)/(5.0+std::sqrt(x*x+y*y));
+            double R=diagonalLength*std::sqrt(x*x+y*y)/(5.0+std::sqrt(x*x+y*y));
             double theta=atan2(y,x);
             // convert input polar coord into cartesian/C compatble coordinate
             unsigned int columnIndex=(unsigned int)(cos(theta)*R)+halfInputColumns;

modules/bioinspired/src/imagelogpolprojection.hpp

@@ -142,10 +142,10 @@ class ImageLogPolProjection:public BasicRetinaFilter
     /**
     * init function depending on the projection type
     * @param reductionFactor: the size reduction factor of the ouptup image in regard of the size of the input image, must be superior to 1
-    * @param samplingStrenght: specifies the strenght of the log compression effect (magnifying coefficient)
+    * @param samplingStrength: specifies the strength of the log compression effect (magnifying coefficient)
     * @return true if the init was performed without any errors
     */
-    bool initProjection(const double reductionFactor, const double samplingStrenght);
+    bool initProjection(const double reductionFactor, const double samplingStrength);
 
     /**
     * main funtion of the class: run projection function
@@ -206,8 +206,8 @@ class ImageLogPolProjection:public BasicRetinaFilter
 
     // is the object able to manage color flag
     bool _colorModeCapable;
-    // sampling strenght factor
-    double _samplingStrenght;
+    // sampling strength factor
+    double _samplingStrength;
     // sampling reduction factor
     double _reductionFactor;
 
@@ -231,8 +231,8 @@ class ImageLogPolProjection:public BasicRetinaFilter
     // specifies if init was done correctly
     bool _initOK;
     // private init projections functions called by "initProjection(...)" function
-    bool _initLogRetinaSampling(const double reductionFactor, const double samplingStrenght);
-    bool _initLogPolarCortexSampling(const double reductionFactor, const double samplingStrenght);
+    bool _initLogRetinaSampling(const double reductionFactor, const double samplingStrength);
+    bool _initLogPolarCortexSampling(const double reductionFactor, const double samplingStrength);
 
     ImageLogPolProjection(const ImageLogPolProjection&);
     ImageLogPolProjection& operator=(const ImageLogPolProjection&);

modules/bioinspired/src/retina.cpp

@@ -96,9 +96,9 @@ class RetinaImpl CV_FINAL : public Retina
      * @param colorSamplingMethod: specifies which kind of color sampling will be used
      * @param useRetinaLogSampling: activate retina log sampling, if true, the 2 following parameters can be used
      * @param reductionFactor: only usefull if param useRetinaLogSampling=true, specifies the reduction factor of the output frame (as the center (fovea) is high resolution and corners can be underscaled, then a reduction of the output is allowed without precision leak
-     * @param samplingStrenght: only usefull if param useRetinaLogSampling=true, specifies the strenght of the log scale that is applied
+     * @param samplingStrength: only usefull if param useRetinaLogSampling=true, specifies the strength of the log scale that is applied
      */
-    RetinaImpl(const Size inputSize, const bool colorMode, int colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const float reductionFactor=1.0f, const float samplingStrenght=10.0f);
+    RetinaImpl(const Size inputSize, const bool colorMode, int colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const float reductionFactor=1.0f, const float samplingStrength=10.0f);
 
     virtual ~RetinaImpl() CV_OVERRIDE;
     /**
@@ -272,7 +272,7 @@ class RetinaImpl CV_FINAL : public Retina
     cv::Ptr<RetinaFilter> _retinaFilter; //!< the pointer to the retina module, allocated with instance construction
 
     //! private method called by constructors, gathers their parameters and use them in a unified way
-    void _init(const Size inputSize, const bool colorMode, int colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const float reductionFactor=1.0f, const float samplingStrenght=10.0f);
+    void _init(const Size inputSize, const bool colorMode, int colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const float reductionFactor=1.0f, const float samplingStrength=10.0f);
 
     /**
      * exports a valarray buffer outing from bioinspired objects to a cv::Mat in CV_8UC1 (gray level picture) or CV_8UC3 (color) format
@@ -311,9 +311,9 @@ Ptr<Retina> Retina::create(Size inputSize)
     return makePtr<RetinaImpl>(inputSize);
 }
 
-Ptr<Retina> Retina::create(Size inputSize, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght)
+Ptr<Retina> Retina::create(Size inputSize, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrength)
 {
-    return makePtr<RetinaImpl>(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
+    return makePtr<RetinaImpl>(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrength);
 }
 
 
@@ -327,13 +327,13 @@ RetinaImpl::RetinaImpl(const cv::Size inputSz)
 #endif
 }
 
-RetinaImpl::RetinaImpl(const cv::Size inputSz, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght)
+RetinaImpl::RetinaImpl(const cv::Size inputSz, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrength)
 {
-    _init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
+    _init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrength);
 #ifdef HAVE_OPENCL
     if (inputSz.width % 4 == 0 && !useRetinaLogSampling && cv::ocl::useOpenCL())
         _ocl_retina.reset(new ocl::RetinaOCLImpl(inputSz, colorMode, colorSamplingMethod,
-                                                 useRetinaLogSampling, reductionFactor, samplingStrenght));
+                                                 useRetinaLogSampling, reductionFactor, samplingStrength));
 #endif
 }
 
@@ -712,7 +712,7 @@ const Mat RetinaImpl::getParvoRAW() const {
 }
 
 // private method called by constructors
-void RetinaImpl::_init(const cv::Size inputSz, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrenght)
+void RetinaImpl::_init(const cv::Size inputSz, const bool colorMode, int colorSamplingMethod, const bool useRetinaLogSampling, const float reductionFactor, const float samplingStrength)
 {
     _wasOCLRunCalled = false;
     // basic error check
@@ -724,7 +724,7 @@ void RetinaImpl::_init(const cv::Size inputSz, const bool colorMode, int colorSa
     _inputBuffer.resize(nbPixels*3); // buffer supports gray images but also 3 channels color buffers... (larger is better...)
 
     // allocate the retina model
-    _retinaFilter.reset(new RetinaFilter(inputSz.height, inputSz.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght));
+    _retinaFilter.reset(new RetinaFilter(inputSz.height, inputSz.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrength));
 
     _retinaParameters.OPLandIplParvo.colorMode = colorMode;
     // prepare the default parameter XML file with default setup