Basic doxygen documentation support

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

Conflicts:
	CMakeLists.txt
	doc/CMakeLists.txt
	modules/core/include/opencv2/core.hpp
	modules/core/include/opencv2/core/base.hpp
	modules/core/include/opencv2/core/cuda.inl.hpp
	modules/core/include/opencv2/core/mat.hpp
	modules/core/include/opencv2/core/matx.hpp
	modules/core/include/opencv2/core/types.hpp
	modules/flann/include/opencv2/flann/lsh_table.h
	modules/imgproc/include/opencv2/imgproc.hpp

modules/contrib/include/opencv2/contrib/contrib.hpp

@@ -664,6 +664,7 @@ namespace cv
         *\param center the transformation center: where the output precision is maximal
         *\param R the number of rings of the cortical image (default value 70 pixel)
         *\param ro0 the radius of the blind spot (default value 3 pixel)
+        *\param interp interpolation algorithm
         *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
         *            \a 0 means that the retinal image is computed within the inscribed circle.
         *\param S the number of sectors of the cortical image (default value 70 pixel).

modules/contrib/include/opencv2/contrib/retina.hpp

@@ -88,7 +88,7 @@ enum RETINA_COLORSAMPLINGMETHOD
 class RetinaFilter;
 
 /**
- * @class Retina a wrapper class which allows the Gipsa/Listic Labs model to be used.
+ * a wrapper class which allows the Gipsa/Listic Labs model to be used.
  * 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)
@@ -199,7 +199,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
      */
     void setup(RetinaParameters newParameters);
 
@@ -216,7 +215,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
      */
     virtual void write( std::string fs ) const;
 

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

@@ -48,6 +48,8 @@
 
 #include <opencv2/core/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/core.hpp

@@ -716,9 +716,6 @@ public:
 };
 
 
-/*!
-  \typedef
-*/
 typedef Complex<float> Complexf;
 typedef Complex<double> Complexd;
 
@@ -885,11 +882,6 @@ public:
 };
 
 
-/*!
-  \typedef
-
-  shorter aliases for the most popular cv::Point_<>, cv::Size_<> and cv::Rect_<> specializations
-*/
 typedef Point_<int> Point2i;
 typedef Point2i Point;
 typedef Size_<int> Size2i;
@@ -1623,8 +1615,6 @@ public:
    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()
@@ -2266,7 +2256,7 @@ CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
 //! set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
 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))
 CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst);
@@ -2731,7 +2721,7 @@ CV_EXPORTS_W Size getTextSize(const string& text, int fontFace,
 
  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
+ 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:
 
  \code
@@ -3443,6 +3433,7 @@ 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 m Destination matrix
       \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

modules/core/include/opencv2/core/gpumat.hpp

@@ -512,6 +512,7 @@ namespace cv { namespace gpu
         return *this;
     }
 
+    /** @cond IGNORED */
     template <class T> inline GpuMat::operator PtrStepSz<T>() const
     {
         return PtrStepSz<T>(rows, cols, (T*)data, step);
@@ -531,6 +532,7 @@ namespace cv { namespace gpu
     {
         return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this));
     }
+    /** @endcond */
 
     inline GpuMat createContinuous(int rows, int cols, int type)
     {

modules/core/include/opencv2/core/operations.hpp

@@ -365,7 +365,7 @@ template<typename _Tp, int m, int n> inline double Matx<_Tp, m, n>::ddot(const M
 }
 
 
-
+/** @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)
 {
@@ -374,6 +374,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> inline
 Matx<_Tp,m,n> Matx<_Tp,m,n>::randu(_Tp a, _Tp b)

modules/features2d/include/opencv2/features2d/features2d.hpp

@@ -415,7 +415,7 @@ public:
          * @param orientationNormalized enable orientation normalization
          * @param scaleNormalized enable scale normalization
          * @param patternScale scaling of the description pattern
-         * @param nbOctave number of octaves covered by the detected keypoints
+         * @param nOctaves number of octaves covered by the detected keypoints
          * @param selectedPairs (optional) user defined selected pairs
     */
     explicit FREAK( bool orientationNormalized = true,
@@ -814,6 +814,8 @@ class CV_EXPORTS FastAdjuster: public AdjusterAdapter
 public:
     /**\param init_thresh the initial threshold to start with, default = 20
      * \param nonmax whether to use non max or not for fast feature detection
+     * \param min_thresh
+     * \param max_thresh
      */
     FastAdjuster(int init_thresh=20, bool nonmax=true, int min_thresh=1, int max_thresh=200);
 

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

@@ -152,9 +152,13 @@ public:
      * Create the mask and allocate the memory
      * @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
+     * @param indices
      */
-    LshTable(unsigned int /*feature_size*/, unsigned int /*key_size*/, std::vector<size_t> & /*indices*/)
+    LshTable(unsigned int feature_size, unsigned int key_size, std::vector<size_t> & indices)
     {
+        (void)feature_size;
+        (void)key_size;
+        (void)indices;
         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/gpu/include/opencv2/gpu/gpu.hpp

@@ -537,7 +537,7 @@ CV_EXPORTS void log(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null())
 //! supports all, except depth == CV_64F
 CV_EXPORTS void pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream = Stream::Null());
 
-//! compares elements of two arrays (c = a <cmpop> b)
+//! compares elements of two arrays (c = a \<cmpop\> b)
 CV_EXPORTS void compare(const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
 CV_EXPORTS void compare(const GpuMat& a, Scalar sc, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
 
@@ -2264,6 +2264,7 @@ public:
      * model.
      * @param frame        Input frame
      * @param fgmask       Output mask image representing foreground and background pixels
+     * @param learningRate determines how quickly features are “forgotten” from histograms
      * @param stream       Stream for the asynchronous version
      */
     void operator ()(const GpuMat& frame, GpuMat& fgmask, float learningRate = -1.0f, Stream& stream = Stream::Null());

modules/video/include/opencv2/video/background_segm.hpp

@@ -218,6 +218,7 @@ public:
      * model.
      * @param image Input image
      * @param fgmask Output mask image representing foreground and background pixels
+     * @param learningRate Determines how quickly features are "forgotten" from histograms
      */
     virtual void operator()(InputArray image, OutputArray fgmask, double learningRate=-1.0);
 

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

@@ -258,7 +258,7 @@ CV_EXPORTS_W int meanShift( InputArray probImage, CV_OUT CV_IN_OUT Rect& window,
 /*!
  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.
 */