Basic doxygen documentation support

- updated existing Doxyfile.in
- added corresponding cmake instructions
- added some specific files (layout, icon)
- clean existing doxygen warnings

modules/core/include/opencv2/core.hpp

@@ -102,10 +102,10 @@ public:
   By default the function prints information about the error to stderr,
   then it either stops if setBreakOnError() had been called before or raises the exception.
   It is possible to alternate error processing by using redirectError().
-
   \param exc the exception raisen.
+  \todo drop this version
  */
-//TODO: drop this version
+
 CV_EXPORTS void error( const Exception& exc );
 
 
@@ -332,7 +332,7 @@ CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
 CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb,
                           InputArray upperb, OutputArray dst);
 
-//! compares elements of two arrays (dst = src1 <cmpop> src2)
+//! compares elements of two arrays (dst = src1 \<cmpop\> src2)
 CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop);
 
 //! computes per-element minimum of two arrays (dst = min(src1, src2))

modules/core/include/opencv2/core/affine.hpp

@@ -48,6 +48,8 @@
 
 #include <opencv2/core.hpp>
 
+/*! @file */
+
 namespace cv
 {
     template<typename T>
@@ -429,6 +431,7 @@ cv::Affine3<Y> cv::Affine3<T>::cast() const
     return Affine3<Y>(matrix);
 }
 
+/** @cond IGNORED */
 template<typename T> inline
 cv::Affine3<T> cv::operator*(const cv::Affine3<T>& affine1, const cv::Affine3<T>& affine2)
 {
@@ -446,6 +449,7 @@ V cv::operator*(const cv::Affine3<T>& affine, const V& v)
     r.z = m.val[8] * v.x + m.val[9] * v.y + m.val[10] * v.z + m.val[11];
     return r;
 }
+/** @endcond */
 
 static inline
 cv::Vec3f cv::operator*(const cv::Affine3f& affine, const cv::Vec3f& v)

modules/core/include/opencv2/core/base.hpp

@@ -235,13 +235,15 @@ enum {
 #define CV_SUPPRESS_DEPRECATED_END
 #endif
 
-//! Signals an error and raises the exception.
-/*!
+/*! @brief Signals an error and raises the exception.
   By default the function prints information about the error to stderr,
   then it either stops if setBreakOnError() had been called before or raises the exception.
   It is possible to alternate error processing by using redirectError().
-
-  \param exc the exception raisen.
+  @param _code - error code @see CVStatus
+  @param _err - error description
+  @param _func - function name. Available only when the compiler supports getting it
+  @param _file - source file name where the error has occured
+  @param _line - line number in the source file where the error has occured
  */
 CV_EXPORTS void error(int _code, const String& _err, const char* _func, const char* _file, int _line);
 

modules/core/include/opencv2/core/cuda.inl.hpp

@@ -224,6 +224,7 @@ const _Tp* GpuMat::ptr(int y) const
     return (const _Tp*)ptr(y);
 }
 
+/** @cond IGNORED */
 template <class T> inline
 GpuMat::operator PtrStepSz<T>() const
 {
@@ -235,6 +236,7 @@ GpuMat::operator PtrStep<T>() const
 {
     return PtrStep<T>((T*)data, step);
 }
+/** @endcond */
 
 inline
 GpuMat GpuMat::row(int y) const

modules/core/include/opencv2/core/mat.hpp

@@ -578,8 +578,6 @@ protected:
    cv::Mat::step that is used to actually compute address of a matrix element. cv::Mat::step is needed because the matrix can be
    a part of another matrix or because there can some padding space in the end of each row for a proper alignment.
 
-   \image html roi.png
-
    Given these parameters, address of the matrix element M_{ij} is computed as following:
 
    addr(M_{ij})=M.data + M.step*i + j*M.elemSize()
@@ -962,9 +960,8 @@ protected:
  \endcode
 
  While cv::Mat is sufficient in most cases, cv::Mat_ can be more convenient if you use a lot of element
- access operations and if you know matrix type at compile time.
- Note that cv::Mat::at<_Tp>(int y, int x) and cv::Mat_<_Tp>::operator ()(int y, int x) do absolutely the
- same thing and run at the same speed, but the latter is certainly shorter:
+ access operations and if you know matrix type at compile time. Note that cv::Mat::at and
+ cv::Mat::operator() do absolutely the same thing and run at the same speed, but the latter is certainly shorter:
 
  \code
  Mat_<double> M(20,20);
@@ -1514,9 +1511,13 @@ public:
     void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
     //! converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.
     /*!
-      \param rtype The output matrix data type. When it is =-1, the output array will have the same data type as (*this)
-      \param alpha The scale factor
-      \param beta The optional delta added to the scaled values before the conversion
+        @param [out] m - output matrix; if it does not have a proper size or type before the operation,
+            it is reallocated
+        @param [in] rtype – desired output matrix type or, rather, the depth since the number of channels
+            are the same as the input has; if rtype is negative, the output matrix will have the
+            same type as the input.
+        @param [in] alpha – optional scale factor
+        @param [in] beta – optional delta added to the scaled values
     */
     void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
 

modules/core/include/opencv2/core/matx.hpp

@@ -185,9 +185,6 @@ public:
     _Tp val[m*n]; //< matrix elements
 };
 
-/*!
-  \typedef
-*/
 typedef Matx<float, 1, 2> Matx12f;
 typedef Matx<double, 1, 2> Matx12d;
 typedef Matx<float, 1, 3> Matx13f;
@@ -631,6 +628,7 @@ double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const
     return s;
 }
 
+/** @cond IGNORED */
 template<typename _Tp, int m, int n> inline
 Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
 {
@@ -639,6 +637,7 @@ Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
         M(i,i) = d(i, 0);
     return M;
 }
+/** @endcond */
 
 template<typename _Tp, int m, int n> template<typename T2>
 inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const

modules/core/include/opencv2/core/types.hpp

@@ -84,15 +84,9 @@ public:
     _Tp re, im; //< the real and the imaginary parts
 };
 
-/*!
-  \typedef
-*/
 typedef Complex<float> Complexf;
 typedef Complex<double> Complexd;
 
-/*!
-  traits
-*/
 template<typename _Tp> class DataType< Complex<_Tp> >
 {
 public:
@@ -151,17 +145,11 @@ public:
     _Tp x, y; //< the point coordinates
 };
 
-/*!
-  \typedef
-*/
 typedef Point_<int> Point2i;
 typedef Point_<float> Point2f;
 typedef Point_<double> Point2d;
 typedef Point2i Point;
 
-/*!
-  traits
-*/
 template<typename _Tp> class DataType< Point_<_Tp> >
 {
 public:
@@ -219,16 +207,10 @@ public:
     _Tp x, y, z; //< the point coordinates
 };
 
-/*!
-  \typedef
-*/
 typedef Point3_<int> Point3i;
 typedef Point3_<float> Point3f;
 typedef Point3_<double> Point3d;
 
-/*!
-  traits
-*/
 template<typename _Tp> class DataType< Point3_<_Tp> >
 {
 public:
@@ -277,17 +259,11 @@ public:
     _Tp width, height; // the width and the height
 };
 
-/*!
-  \typedef
-*/
 typedef Size_<int> Size2i;
 typedef Size_<float> Size2f;
 typedef Size_<double> Size2d;
 typedef Size2i Size;
 
-/*!
-  traits
-*/
 template<typename _Tp> class DataType< Size_<_Tp> >
 {
 public:
@@ -347,17 +323,11 @@ public:
     _Tp x, y, width, height; //< the top-left corner, as well as width and height of the rectangle
 };
 
-/*!
-  \typedef
-*/
 typedef Rect_<int> Rect2i;
 typedef Rect_<float> Rect2f;
 typedef Rect_<double> Rect2d;
 typedef Rect2i Rect;
 
-/*!
-  traits
-*/
 template<typename _Tp> class DataType< Rect_<_Tp> >
 {
 public:
@@ -404,9 +374,6 @@ public:
     float angle;    //< the rotation angle. When the angle is 0, 90, 180, 270 etc., the rectangle becomes an up-right rectangle.
 };
 
-/*!
-  traits
-*/
 template<> class DataType< RotatedRect >
 {
 public:
@@ -445,9 +412,6 @@ public:
     int start, end;
 };
 
-/*!
-  traits
-*/
 template<> class DataType<Range>
 {
 public:
@@ -502,14 +466,8 @@ public:
     bool isReal() const;
 };
 
-/*!
-  \typedef
-*/
 typedef Scalar_<double> Scalar;
 
-/*!
-  traits
-*/
 template<typename _Tp> class DataType< Scalar_<_Tp> >
 {
 public:
@@ -579,9 +537,6 @@ public:
     CV_PROP_RW int class_id; //!< object class (if the keypoints need to be clustered by an object they belong to)
 };
 
-/*!
-  traits
-*/
 template<> class DataType<KeyPoint>
 {
 public:
@@ -623,9 +578,6 @@ public:
     bool operator<(const DMatch &m) const;
 };
 
-/*!
-  traits
-*/
 template<> class DataType<DMatch>
 {
 public:
@@ -695,9 +647,6 @@ public:
     CV_PROP_RW double  nu20, nu11, nu02, nu30, nu21, nu12, nu03;
 };
 
-/*!
-  traits
-*/
 template<> class DataType<Moments>
 {
 public:

modules/flann/include/opencv2/flann/dynamic_bitset.h

@@ -57,14 +57,14 @@ namespace cvflann {
 class DynamicBitset
 {
 public:
-    /** @param default constructor
+    /** default constructor
      */
     DynamicBitset()
     {
     }
 
-    /** @param only constructor we use in our code
-     * @param the size of the bitset (in bits)
+    /** only constructor we use in our code
+     * @param sz the size of the bitset (in bits)
      */
     DynamicBitset(size_t sz)
     {
@@ -87,7 +87,7 @@ public:
         return bitset_.empty();
     }
 
-    /** @param set all the bits to 0
+    /** set all the bits to 0
      */
     void reset()
     {
@@ -95,7 +95,7 @@ public:
     }
 
     /** @brief set one bit to 0
-     * @param
+     * @param index
      */
     void reset(size_t index)
     {
@@ -106,15 +106,15 @@ public:
      * This function is useful when resetting a given set of bits so that the
      * whole bitset ends up being 0: if that's the case, we don't care about setting
      * other bits to 0
-     * @param
+     * @param index
      */
     void reset_block(size_t index)
     {
         bitset_[index / cell_bit_size_] = 0;
     }
 
-    /** @param resize the bitset so that it contains at least size bits
-     * @param size
+    /** resize the bitset so that it contains at least sz bits
+     * @param sz
      */
     void resize(size_t sz)
     {
@@ -122,7 +122,7 @@ public:
         bitset_.resize(sz / cell_bit_size_ + 1);
     }
 
-    /** @param set a bit to true
+    /** set a bit to true
      * @param index the index of the bit to set to 1
      */
     void set(size_t index)
@@ -130,14 +130,14 @@ public:
         bitset_[index / cell_bit_size_] |= size_t(1) << (index % cell_bit_size_);
     }
 
-    /** @param gives the number of contained bits
+    /** gives the number of contained bits
      */
     size_t size() const
     {
         return size_;
     }
 
-    /** @param check if a bit is set
+    /** check if a bit is set
      * @param index the index of the bit to check
      * @return true if the bit is set
      */

modules/flann/include/opencv2/flann/lsh_table.h

@@ -153,8 +153,10 @@ public:
      * @param feature_size is the size of the feature (considered as a ElementType[])
      * @param key_size is the number of bits that are turned on in the feature
      */
-    LshTable(unsigned int /*feature_size*/, unsigned int /*key_size*/)
+    LshTable(unsigned int feature_size, unsigned int key_size)
     {
+        (void)feature_size;
+        (void)key_size;
         std::cerr << "LSH is not implemented for that type" << std::endl;
         assert(0);
     }

modules/flann/include/opencv2/flann/result_set.h

@@ -449,7 +449,7 @@ class RadiusUniqueResultSet : public UniqueResultSet<DistanceType>
 {
 public:
     /** Constructor
-     * @param capacity the number of neighbors to store at max
+     * @param radius the maximum distance of a neighbor
      */
     RadiusUniqueResultSet(DistanceType radius) :
         radius_(radius)
@@ -509,6 +509,7 @@ class KNNRadiusUniqueResultSet : public KNNUniqueResultSet<DistanceType>
 public:
     /** Constructor
      * @param capacity the number of neighbors to store at max
+     * @param radius the maximum distance of a neighbor
      */
     KNNRadiusUniqueResultSet(unsigned int capacity, DistanceType radius)
     {

modules/imgproc/include/opencv2/imgproc.hpp

@@ -698,8 +698,7 @@ public:
 
 /**
  * Draw lines on the given canvas.
- *
- * @param image     The image, where lines will be drawn.
+ * @param _image    The image, where lines will be drawn.
  *                  Should have the size of the image, where the lines were found
  * @param lines     The lines that need to be drawn
  */
@@ -707,11 +706,10 @@ public:
 
 /**
  * Draw both vectors on the image canvas. Uses blue for lines 1 and red for lines 2.
- *
  * @param size      The size of the image, where lines were found.
  * @param lines1    The first lines that need to be drawn. Color - Blue.
  * @param lines2    The second lines that need to be drawn. Color - Red.
- * @param image     Optional image, where lines will be drawn.
+ * @param _image    Optional image, where lines will be drawn.
  *                  Should have the size of the image, where the lines were found
  * @return          The number of mismatching pixels between lines1 and lines2.
  */

modules/video/include/opencv2/video/tracking.hpp

@@ -110,7 +110,7 @@ CV_EXPORTS_W double findTransformECC( InputArray templateImage, InputArray input
 /*!
  Kalman filter.
 
- The class implements standard Kalman filter \url{http://en.wikipedia.org/wiki/Kalman_filter}.
+ The class implements standard Kalman filter http://en.wikipedia.org/wiki/Kalman_filter.
  However, you can modify KalmanFilter::transitionMatrix, KalmanFilter::controlMatrix and
  KalmanFilter::measurementMatrix to get the extended Kalman filter functionality.
 */