Merge pull request #114 from mshabunin/doxygen-docs

Fixed some existing doxygen warnings

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

@@ -85,7 +85,7 @@ enum {
 };
 
 /**
- * @class Retina a wrapper class which allows the Gipsa/Listic Labs model to be used with OpenCV.
+ * a wrapper class which allows the Gipsa/Listic Labs model to be used with OpenCV.
  * This retina model allows spatio-temporal image processing (applied on still images, video sequences).
  * As a summary, these are the retina model properties:
  * => It applies a spectral whithening (mid-frequency details enhancement)
@@ -176,7 +176,6 @@ public:
      * => if the xml file does not exist, then default setup is applied
      * => warning, Exceptions are thrown if read XML file is not valid
      * @param newParameters : a parameters structures updated with the new target configuration
-         * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error
      */
     CV_WRAP virtual void setup(RetinaParameters newParameters)=0;
 
@@ -193,7 +192,7 @@ public:
 
     /**
      * write xml/yml formated parameters information
-     * @rparam fs : the filename of the xml file that will be open and writen with formatted parameters information
+     * @param fs : the filename of the xml file that will be open and writen with formatted parameters information
      */
     CV_WRAP virtual void write( String fs ) const=0;
 

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

@@ -80,7 +80,7 @@ namespace cv{
 namespace bioinspired{
 
 /**
- * @class RetinaFastToneMappingImpl a wrapper class which allows the tone mapping algorithm of Meylan&al(2007) to be used with OpenCV.
+ * 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.

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

@@ -116,7 +116,7 @@ public:
      * try to open an XML segmentation parameters file to adjust current segmentation instance setup
      * => if the xml file does not exist, then default setup is applied
      * => warning, Exceptions are thrown if read XML file is not valid
-     * @param retinaParameterFile : the parameters filename
+     * @param segmentationParameterFile : the parameters filename
      * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error
      */
     CV_WRAP virtual void setup(String segmentationParameterFile="", const bool applyDefaultSetupOnFailure=true)=0;
@@ -135,7 +135,6 @@ public:
      * => if the xml file does not exist, then default setup is applied
      * => warning, Exceptions are thrown if read XML file is not valid
      * @param newParameters : a parameters structures updated with the new target configuration
-     * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error
      */
     CV_WRAP virtual void setup(SegmentationParameters newParameters)=0;
 
@@ -152,7 +151,7 @@ public:
 
     /**
      * write xml/yml formated parameters information
-     * @rparam fs : the filename of the xml file that will be open and writen with formatted parameters information
+     * @param fs : the filename of the xml file that will be open and writen with formatted parameters information
      */
     CV_WRAP virtual void write( String fs ) const=0;
 
@@ -181,9 +180,8 @@ public:
     CV_WRAP virtual void clearAllBuffers()=0;
 };
 
-    /**
-     * allocator
-     * @param Size : size of the images input to segment (output will be the same size)
+    /** allocator
+     * @param inputSize : size of the images input to segment (output will be the same size)
      */
 CV_EXPORTS_W Ptr<TransientAreasSegmentationModule> createTransientAreasSegmentationModule(Size inputSize);
 

modules/rgbd/include/opencv2/rgbd.hpp

@@ -233,7 +233,7 @@ namespace rgbd
 
   /**
    * @param depth the depth image
-   * @param K
+   * @param in_K
    * @param in_points the list of xy coordinates
    * @param points3d the resulting 3d points
    */
@@ -259,7 +259,7 @@ namespace rgbd
    * Otherwise, the image is simply converted to floats
    * @param in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters
    *              (as done with the Microsoft Kinect), it is assumed in meters)
-   * @param the desired output depth (floats or double)
+   * @param depth the desired output depth (floats or double)
    * @param out The rescaled float depth image
    */
   CV_EXPORTS
@@ -290,10 +290,10 @@ namespace rgbd
 
     /** Find The planes in a depth image
      * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels
-     * @param the normals for every point in the depth image
+     * @param normals the normals for every point in the depth image
      * @param mask An image where each pixel is labeled with the plane it belongs to
      *        and 255 if it does not belong to any plane
-     * @param the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0, norm(a,b,c)=1
+     * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0, norm(a,b,c)=1
      *        and c < 0 (so that the normal points towards the camera)
      */
     void
@@ -304,7 +304,7 @@ namespace rgbd
      * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels
      * @param mask An image where each pixel is labeled with the plane it belongs to
      *        and 255 if it does not belong to any plane
-     * @param the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0
+     * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0
      */
     void
     operator()(InputArray points3d, OutputArray mask, OutputArray plane_coefficients);
@@ -457,11 +457,10 @@ namespace rgbd
     /** Prepare a cache for the frame. The function checks the precomputed/passed data (throws the error if this data
      * does not satisfy) and computes all remaining cache data needed for the frame. Returned size is a resolution
      * of the prepared frame.
-     * @param odometry The odometry which will process the frame.
+     * @param frame The odometry which will process the frame.
      * @param cacheType The cache type: CACHE_SRC, CACHE_DST or CACHE_ALL.
      */
-    virtual Size
-    prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
+    virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
   protected:
     virtual void
@@ -488,14 +487,15 @@ namespace rgbd
      * @param iterCounts Count of iterations on each pyramid level.
      * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out
      *                              if they have gradient magnitude less than minGradientMagnitudes[level].
+     * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart
+     * @param transformType Class of transformation
      */
     RgbdOdometry(const Mat& cameraMatrix, float minDepth = DEFAULT_MIN_DEPTH(), float maxDepth = DEFAULT_MAX_DEPTH(),
                  float maxDepthDiff = DEFAULT_MAX_DEPTH_DIFF(), const std::vector<int>& iterCounts = std::vector<int>(),
                  const std::vector<float>& minGradientMagnitudes = std::vector<float>(), float maxPointsPart = DEFAULT_MAX_POINTS_PART(),
                  int transformType = RIGID_BODY_MOTION);
 
-    virtual Size
-    prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
+    virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
     AlgorithmInfo*
     info() const;
@@ -536,15 +536,15 @@ namespace rgbd
      * @param maxDepth Pixels with depth larger than maxDepth will not be used
      * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out
      *                     if their depth difference is larger than maxDepthDiff
-     * @param pointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart
+     * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart
      * @param iterCounts Count of iterations on each pyramid level.
+     * @param transformType Class of trasformation
      */
     ICPOdometry(const Mat& cameraMatrix, float minDepth = DEFAULT_MIN_DEPTH(), float maxDepth = DEFAULT_MAX_DEPTH(),
                 float maxDepthDiff = DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = DEFAULT_MAX_POINTS_PART(),
                 const std::vector<int>& iterCounts = std::vector<int>(), int transformType = RIGID_BODY_MOTION);
 
-    virtual Size
-    prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
+    virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
     AlgorithmInfo*
     info() const;
@@ -586,10 +586,11 @@ namespace rgbd
      * @param maxDepth Pixels with depth larger than maxDepth will not be used
      * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out
      *                     if their depth difference is larger than maxDepthDiff
-     * @param pointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart
+     * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart
      * @param iterCounts Count of iterations on each pyramid level.
      * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out
      *                              if they have gradient magnitude less than minGradientMagnitudes[level].
+     * @param transformType Class of trasformation
      */
     RgbdICPOdometry(const Mat& cameraMatrix, float minDepth = DEFAULT_MIN_DEPTH(), float maxDepth = DEFAULT_MAX_DEPTH(),
                     float maxDepthDiff = DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = DEFAULT_MAX_POINTS_PART(),
@@ -597,8 +598,7 @@ namespace rgbd
                     const std::vector<float>& minGradientMagnitudes = std::vector<float>(),
                     int transformType = RIGID_BODY_MOTION);
 
-    virtual Size
-    prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
+    virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
     AlgorithmInfo*
     info() const;

modules/surface_matching/include/opencv2/surface_matching/icp.hpp

@@ -101,14 +101,18 @@ public:
 
   /**
      *  \brief ICP constructor with default arguments.
+     *  @param [in] iterations
      *  @param [in] tolerence Controls the accuracy of registration at each iteration of ICP.
-     *  @param [in] rejectionScale Robust outlier rejection is applied for robustness. This value actually corresponds to the standard deviation coefficient. Points with rejectionScale * \sigma are ignored during registration.
-     *  @param [in] numLevels Number of pyramid levels to proceed. Deep pyramids increase speed but decrease accuracy. Too coarse pyramids might have computational overhead on top of the inaccurate registrtaion. This parameter should be chosen to optimize a balance. Typical values range from 4 to 10.
-     *  @param [in] sampleType Currently this parameter is ignored and only uniform sampling is applied. Leave it as 0.
+     *  @param [in] rejectionScale Robust outlier rejection is applied for robustness. This value
+            actually corresponds to the standard deviation coefficient. Points with
+            rejectionScale * &sigma are ignored during registration.
+     *  @param [in] numLevels Number of pyramid levels to proceed. Deep pyramids increase speed but
+            decrease accuracy. Too coarse pyramids might have computational overhead on top of the
+            inaccurate registrtaion. This parameter should be chosen to optimize a balance. Typical
+            values range from 4 to 10.
+     *  @param [in] sampleType Currently this parameter is ignored and only uniform sampling is
+            applied. Leave it as 0.
      *  @param [in] numMaxCorr Currently this parameter is ignored and only PickyICP is applied. Leave it as 1.
-     *  \return
-     *
-     *  \details Constructor
      */
   ICP(const int iterations, const float tolerence=0.05, const float rejectionScale=2.5, const int numLevels=6, const ICP_SAMPLING_TYPE sampleType = ICP_SAMPLING_TYPE_UNIFORM, const int numMaxCorr=1)
   {

modules/surface_matching/include/opencv2/surface_matching/pose_3d.hpp

@@ -96,13 +96,11 @@ public:
 
   /**
    *  \brief Updates the pose with the new one
-   *  \param [in] NewPose New pose to overwrite
    */
   void updatePose(double NewR[9], double NewT[3]);
 
   /**
    *  \brief Updates the pose with the new one, but this time using quaternions to represent rotation
-   *  \param [in] NewPose New pose to overwrite
    */
   void updatePoseQuat(double Q[4], double NewT[3]);
 

modules/surface_matching/include/opencv2/surface_matching/ppf_helpers.hpp

@@ -49,18 +49,18 @@ namespace ppf_match_3d
 {
 
 /**
- *  \brief Load a PLY file
- *
- *  \param [in] fileName The PLY model to read
- *  \param [in] withNormals Flag wheather the input PLY contains normal information, 
+ *  @brief Load a PLY file
+ *  @param [in] fileName The PLY model to read
+ *  @param [in] withNormals Flag wheather the input PLY contains normal information,
  *  and whether it should be loaded or not
- *  \return Returns the matrix on successfull load
+ *  @return Returns the matrix on successfull load
  */
 CV_EXPORTS Mat loadPLYSimple(const char* fileName, int withNormals);
 
 /**
- *  \brief Write a point cloud to PLY file
- *  \param [in] fileName The PLY model file to write
+ *  @brief Write a point cloud to PLY file
+ *  @param [in] PC Input point cloud
+ *  @param [in] fileName The PLY model file to write
 */
 CV_EXPORTS void writePLY(Mat PC, const char* fileName);
 
@@ -69,6 +69,7 @@ Mat samplePCUniformInd(Mat PC, int sampleStep, std::vector<int>& indices);
 
 /**
  *  Sample a point cloud using uniform steps
+ *  @param [in] pc Input point cloud
  *  @param [in] xrange X components (min and max) of the bounding box of the model
  *  @param [in] yrange Y components (min and max) of the bounding box of the model
  *  @param [in] zrange Z components (min and max) of the bounding box of the model
@@ -77,7 +78,7 @@ Mat samplePCUniformInd(Mat PC, int sampleStep, std::vector<int>& indices);
  *  the parameter sample_step_relative. 
  *  @param [in] weightByCenter The contribution of the quantized data points can be weighted
  *  by the distance to the origin. This parameter enables/disables the use of weighting.
- *  \return Sampled point cloud
+ *  @return Sampled point cloud
 */
 CV_EXPORTS Mat samplePCByQuantization(Mat pc, float xrange[2], float yrange[2], float zrange[2], float sample_step_relative, int weightByCenter=0);
 
@@ -94,7 +95,7 @@ void queryPCFlann(void* flannIndex, Mat& pc, Mat& indices, Mat& distances);
  *  @param [in] pc Input point cloud (CV_32F family). Point clouds with 3 or 6 elements per
  *  row are expected.
  *  @param [in] scale The scale after normalization. Default to 1.
- *  \return Normalized point cloud
+ *  @return Normalized point cloud
 */
 CV_EXPORTS Mat normalize_pc(Mat pc, float scale);
 
@@ -107,7 +108,7 @@ Mat transPCCoeff(Mat pc, float scale, float Cx, float Cy, float Cz, float MinVal
  *  row are expected. In the case where the normals are provided, they are also rotated to be
  *  compatible with the entire transformation
  *  @param [in] Pose 4x4 pose matrix, but linearized in row-major form.
- *  \return Transformed point cloud
+ *  @return Transformed point cloud
 */
 CV_EXPORTS Mat transformPCPose(Mat pc, double Pose[16]);
 
@@ -120,25 +121,23 @@ CV_EXPORTS void getRandomPose(double Pose[16]);
 /**
  *  Adds a uniform noise in the given scale to the input point cloud
  *  @param [in] pc Input point cloud (CV_32F family). 
- *  @param [in] scale Input scale of the noise. The larger the scale, the more
- *  noisy the output
+ *  @param [in] scale Input scale of the noise. The larger the scale, the more noisy the output
 */
 CV_EXPORTS Mat addNoisePC(Mat pc, double scale);
 
 /**
- *  \brief Compute the normals of an arbitrary point cloud
- *
- *  @param [in] PC Input point cloud to compute the normals for.
- *  @param [in] PCNormals Output point cloud
- *  @param [in] NumNeighbors Number of neighbors to take into account in a local region
- *  @param [in] FlipViewpoint Should normals be flipped to a viewing direction?
- *  \return Returns 0 on success
- *
- *  \details computeNormalsPC3d uses a plane fitting approach to smoothly compute
+ *  @brief Compute the normals of an arbitrary point cloud
+ *  computeNormalsPC3d uses a plane fitting approach to smoothly compute
  *  local normals. Normals are obtained through the eigenvector of the covariance
  *  matrix, corresponding to the smallest eigen value.
  *  If PCNormals is provided to be an Nx6 matrix, then no new allocation
  *  is made, instead the existing memory is overwritten.
+ *  @param [in] PC Input point cloud to compute the normals for.
+ *  @param [in] PCNormals Output point cloud
+ *  @param [in] NumNeighbors Number of neighbors to take into account in a local region
+ *  @param [in] FlipViewpoint Should normals be flipped to a viewing direction?
+ *  @param [in] viewpoint
+ *  @return Returns 0 on success
  */
 CV_EXPORTS int computeNormalsPC3d(const Mat& PC, Mat& PCNormals, const int NumNeighbors, const bool FlipViewpoint, const double viewpoint[3]);
 } // namespace ppf_match_3d

modules/text/include/opencv2/text/erfilter.hpp

@@ -165,15 +165,14 @@ public:
     probability is above a global limit pmin and the difference between local maximum and
     local minimum is greater than minProbabilityDiff).
 
-    \param  cb                Callback with the classifier.
-                              default classifier can be implicitly load with function loadClassifierNM1()
-                              from file in samples/cpp/trained_classifierNM1.xml
-    \param  thresholdDelta    Threshold step in subsequent thresholds when extracting the component tree
-    \param  minArea           The minimum area (% of image size) allowed for retreived ER's
-    \param  minArea           The maximum area (% of image size) allowed for retreived ER's
-    \param  minProbability    The minimum probability P(er|character) allowed for retreived ER's
-    \param  nonMaxSuppression Whenever non-maximum suppression is done over the branch probabilities
-    \param  minProbability    The minimum probability difference between local maxima and local minima ERs
+    @param cb – Callback with the classifier. Default classifier can be implicitly load with function
+        loadClassifierNM1(), e.g. from file in samples/cpp/trained_classifierNM1.xml
+    @param thresholdDelta – Threshold step in subsequent thresholds when extracting the component tree
+    @param minArea – The minimum area (% of image size) allowed for retreived ER’s
+    @param maxArea – The maximum area (% of image size) allowed for retreived ER’s
+    @param minProbability – The minimum probability P(er|character) allowed for retreived ER’s
+    @param nonMaxSuppression – Whenever non-maximum suppression is done over the branch probabilities
+    @param minProbabilityDiff – The minimum probability difference between local maxima and local minima ERs
 */
 CV_EXPORTS Ptr<ERFilter> createERFilterNM1(const Ptr<ERFilter::Callback>& cb,
                                                   int thresholdDelta = 1, float minArea = 0.00025,
@@ -260,11 +259,20 @@ enum { ERGROUPING_ORIENTATION_HORIZ,
     combine all these hypotheses to get the final estimate. Each of the resulting groups are finally
     validated using a classifier in order to assest if they form a valid horizontally-aligned text block.
 
-    \param  src            Vector of sinle channel images CV_8UC1 from wich the regions were extracted.
-    \param  regions        Vector of ER's retreived from the ERFilter algorithm from each channel
-    \param  filename       The XML or YAML file with the classifier model (e.g. trained_classifier_erGrouping.xml)
-    \param  minProbability The minimum probability for accepting a group
-    \param  groups         The output of the algorithm are stored in this parameter as list of rectangles.
+    @param img – Original RGB or Grayscale image from wich the regions were extracted.
+    @param channels – Vector of single channel images CV_8UC1 from wich the regions were extracted.
+    @param regions – Vector of ER’s retreived from the ERFilter algorithm from each channel.
+    @param groups – The output of the algorithm is stored in this parameter as set of lists of
+        indexes to provided regions.
+    @param groups_rects – The output of the algorithm are stored in this parameter as list of rectangles.
+    @param method – Grouping method (see the details below). Can be one of ERGROUPING_ORIENTATION_HORIZ,
+        ERGROUPING_ORIENTATION_ANY.
+    @param filename – The XML or YAML file with the classifier model (e.g.
+        samples/trained_classifier_erGrouping.xml). Only to use when grouping method is
+        ERGROUPING_ORIENTATION_ANY.
+    @param minProbablity – The minimum probability for accepting a group. Only to use when grouping
+        method is ERGROUPING_ORIENTATION_ANY.
+
 */
 CV_EXPORTS void erGrouping(InputArray img, InputArrayOfArrays channels,
                                            std::vector<std::vector<ERStat> > &regions,

modules/ximgproc/include/opencv2/ximgproc/edge_filter.hpp

@@ -101,7 +101,7 @@ public:
         * @brief Apply High-dimensional filtering using adaptive manifolds
         * @param src       Input image to be filtered.
         * @param dst       Adaptive-manifold filter response.
-        * @param src_joint Image for joint filtering (optional).
+        * @param joint Image for joint filtering (optional).
         */
     CV_WRAP virtual void filter(InputArray src, OutputArray dst, InputArray joint = noArray()) = 0;