Cleanup: use colon separator after parameter

Helps separate variable names from descriptive text.
Was already used in some parts of the code,
double space and dashes were used elsewhere.

28 files changed, 295 insertions, 295 deletions

diff --git a/source/blender/freestyle/intern/image/GaussianFilter.h b/source/blender/freestyle/intern/image/GaussianFilter.h
index f460d56e5a5..56baa3c3d46 100644
--- a/source/blender/freestyle/intern/image/GaussianFilter.h
+++ b/source/blender/freestyle/intern/image/GaussianFilter.h
@@ -65,16 +65,16 @@ public:
 
 	/*! Returns the value for pixel x,y of image "map" after a gaussian blur, made using the sigma value.
 	 *  The sigma value determines the mask size (~ 2 x sigma).
-	 *  \param map
+	 *  \param map:
 	 *    The image we wish to work on. The Map template must implement the following methods:
 	 *    - float pixel(unsigned int x,unsigned int y) const;
 	 *    - unsigned width() const;
 	 *    - unsigned height() const;
-	 *  \param x
+	 *  \param x:
 	 *    The abscissa of the pixel where we want to evaluate the gaussian blur.
-	 *  \param y
+	 *  \param y:
 	 *    The ordinate of the pixel where we want to evaluate the gaussian blur.
-	 *  \param sigma
+	 *  \param sigma:
 	 *    The sigma value of the gaussian function.
 	 */
 	template<class Map>
diff --git a/source/blender/freestyle/intern/image/Image.h b/source/blender/freestyle/intern/image/Image.h
index 2e78e784214..c262da475d6 100644
--- a/source/blender/freestyle/intern/image/Image.h
+++ b/source/blender/freestyle/intern/image/Image.h
@@ -84,17 +84,17 @@ public:
 	}
 
 	/*! Builds a partial-storing image.
-	 *  \param w
+	 *  \param w:
 	 *    The width of the complete image
-	 *  \param h
+	 *  \param h:
 	 *    The height of the complete image
-	 *  \param sw
+	 *  \param sw:
 	 *    The width of the rectangle that will actually be stored.
-	 *  \param sh
+	 *  \param sh:
 	 *    The height of the rectangle that will actually be stored.
-	 *  \param ox
+	 *  \param ox:
 	 *    The x-abscissa of the origin of the rectangle that will actually be stored.
-	 *  \param oy
+	 *  \param oy:
 	 *    The x-abscissa of the origin of the rectangle that will actually be stored.
 	 */
 	FrsImage(unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy)
@@ -138,22 +138,22 @@ public:
 	virtual float pixel(unsigned x, unsigned y) const = 0;
 
 	/*! Sets the array.
-	 *  \param array
+	 *  \param array:
 	 *    The array containing the values we wish to store.
 	 *    Its size is sw*sh.
-	 *  \param width
+	 *  \param width:
 	 *    The width of the complete image
-	 *  \param height
+	 *  \param height:
 	 *    The height of the complete image
-	 *  \param sw
+	 *  \param sw:
 	 *    The width of the rectangle that will actually be stored.
-	 *  \param sh
+	 *  \param sh:
 	 *    The height of the rectangle that will actually be stored.
-	 *  \param ox
+	 *  \param ox:
 	 *    The x-abscissa of the origin of the rectangle that will actually be stored.
-	 *  \param oy
+	 *  \param oy:
 	 *    The x-abscissa of the origin of the rectangle that will actually be stored.
-	 *  \param copy
+	 *  \param copy:
 	 *    If true, the array is copied, otherwise the pointer is copied
 	 */
 	virtual void setArray(float *array, unsigned width, unsigned height, unsigned sw, unsigned sh,
@@ -208,16 +208,16 @@ public:
 	}
 
 	/*! Builds an RGB partial image from the useful part buffer.
-	 *  \param rgb
+	 *  \param rgb:
 	 *    The array of size 3*sw*sh containing the RGB values of the sw*sh pixels we need to stored.
 	 *    These sw*sh pixels constitute a rectangular part of a bigger RGB image containing w*h pixels.
-	 *  \param w
+	 *  \param w:
 	 *    The width of the complete image
-	 *  \param h
+	 *  \param h:
 	 *    The height of the complete image
-	 *  \param sw
+	 *  \param sw:
 	 *    The width of the part of the image we want to store and work on
-	 *  \param sh
+	 *  \param sh:
 	 *    The height of the part of the image we want to store and work on
 	 */
 	RGBImage(float *rgb, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy)
@@ -341,16 +341,16 @@ public:
 	}
 
 	/*! Builds a partial image from the useful part buffer.
-	 *  \param lvl
+	 *  \param lvl:
 	 *    The array of size sw*sh containing the gray values of the sw*sh pixels we need to stored.
 	 *    These sw*sh pixels constitute a rectangular part of a bigger gray image containing w*h pixels.
-	 *  \param w
+	 *  \param w:
 	 *    The width of the complete image
-	 *  \param h
+	 *  \param h:
 	 *    The height of the complete image
-	 *  \param sw
+	 *  \param sw:
 	 *    The width of the part of the image we want to store and work on
-	 *  \param sh
+	 *  \param sh:
 	 *    The height of the part of the image we want to store and work on
 	 */
 	GrayImage(float *lvl, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy)
diff --git a/source/blender/freestyle/intern/image/ImagePyramid.h b/source/blender/freestyle/intern/image/ImagePyramid.h
index 9a24ac6e1c8..fa55081646a 100644
--- a/source/blender/freestyle/intern/image/ImagePyramid.h
+++ b/source/blender/freestyle/intern/image/ImagePyramid.h
@@ -62,11 +62,11 @@ public:
 
 	virtual GrayImage *getLevel(int l);
 	/*! Returns the pixel x,y using bilinear interpolation.
-	 *  \param x
+	 *  \param x:
 	 *    the abscissa specified in the finest level coordinate system
-	 *  \param y
+	 *  \param y:
 	 *    the ordinate specified in the finest level coordinate system
-	 *  \param level
+	 *  \param level:
 	 *    the level from which we want the pixel to be evaluated
 	 */
 	virtual float pixel(int x, int y, int level=0);
diff --git a/source/blender/freestyle/intern/scene_graph/FrsMaterial.h b/source/blender/freestyle/intern/scene_graph/FrsMaterial.h
index 220c966a5d0..48b0aabffb6 100644
--- a/source/blender/freestyle/intern/scene_graph/FrsMaterial.h
+++ b/source/blender/freestyle/intern/scene_graph/FrsMaterial.h
@@ -45,19 +45,19 @@ public:
 
 	/*! Builds a Material from its line, diffuse, ambiant, specular, emissive
 	 *  colors, a shininess coefficient and line color priority.
-	 *    \param iLine
+	 *    \param iLine:
 	 *      A 4 element float-array containing the line color.
-	 *    \param iDiffuse
+	 *    \param iDiffuse:
 	 *      A 4 element float-array containing the diffuse color.
-	 *    \param iAmbiant
+	 *    \param iAmbiant:
 	 *      A 4 element float-array containing the ambiant color.
-	 *    \param iSpecular
+	 *    \param iSpecular:
 	 *      A 4 element float-array containing the specular color.
-	 *    \param iEmission
+	 *    \param iEmission:
 	 *      A 4 element float-array containing the emissive color.
-	 *    \param iShininess
+	 *    \param iShininess:
 	 *      The shininess coefficient.
-	 *    \param iPriority
+	 *    \param iPriority:
 	 *      The line color priority.
 	 */
 	inline FrsMaterial(const float *iLine, const float *iDiffuse, const float *iAmbiant, const float *iSpecular,
@@ -232,73 +232,73 @@ public:
 	}
 
 	/*! Sets the line color.
-	 *    \param r
+	 *    \param r:
 	 *      Red component
-	 *    \param g
+	 *    \param g:
 	 *      Green component
-	 *    \param b
+	 *    \param b:
 	 *     Blue component
-	 *    \param a
+	 *    \param a:
 	 *      Alpha component
 	 */
 	inline void setLine(const float r, const float g, const float b, const float a);
 
 	/*! Sets the diffuse color.
-	 *    \param r
+	 *    \param r:
 	 *      Red component
-	 *    \param g
+	 *    \param g:
 	 *      Green component
-	 *    \param b
+	 *    \param b:
 	 *     Blue component
-	 *    \param a
+	 *    \param a:
 	 *      Alpha component
 	 */
 	inline void setDiffuse(const float r, const float g, const float b, const float a);
 
 	/*! Sets the specular color.
-	 *    \param r
+	 *    \param r:
 	 *      Red component
-	 *    \param g
+	 *    \param g:
 	 *      Green component
-	 *    \param b
+	 *    \param b:
 	 *     Blue component
-	 *    \param a
+	 *    \param a:
 	 *      Alpha component
 	 */
 	inline void setSpecular(const float r, const float g, const float b, const float a);
 
 	/*! Sets the ambiant color.
-	 *    \param r
+	 *    \param r:
 	 *      Red component
-	 *    \param g
+	 *    \param g:
 	 *      Green component
-	 *    \param b
+	 *    \param b:
 	 *     Blue component
-	 *    \param a
+	 *    \param a:
 	 *      Alpha component
 	 */
 	inline void setAmbient(const float r, const float g, const float b, const float a);
 
 	/*! Sets the emissive color.
-	 *    \param r
+	 *    \param r:
 	 *      Red component
-	 *    \param g
+	 *    \param g:
 	 *      Green component
-	 *    \param b
+	 *    \param b:
 	 *     Blue component
-	 *    \param a
+	 *    \param a:
 	 *      Alpha component
 	 */
 	inline void setEmission(const float r, const float g, const float b, const float a);
 
 	/*! Sets the shininess.
-	 *    \param s
+	 *    \param s:
 	 *      Shininess
 	 */
 	inline void setShininess(const float s);
 
 	/*! Sets the line color priority.
-	 *    \param priority
+	 *    \param priority:
 	 *      Priority
 	 */
 	inline void setPriority(const int priority);
diff --git a/source/blender/freestyle/intern/scene_graph/NodeCamera.h b/source/blender/freestyle/intern/scene_graph/NodeCamera.h
index 2fc6a00f955..b5021671873 100644
--- a/source/blender/freestyle/intern/scene_graph/NodeCamera.h
+++ b/source/blender/freestyle/intern/scene_graph/NodeCamera.h
@@ -181,7 +181,7 @@ public:
 	 *    |                             zNear-zFar       zNear-zFar     |
 	 *    |                                                             |
 	 *    (   0               0             -1               0          )
-	 *  \param fovy
+	 *  \param fovy:
 	 *    Field of View specified in radians.
 	 */
 	NodePerspectiveCamera(double fovy, double aspect, double zNear, double zFar);
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
index 87f132b1ff3..f47808e6fc8 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
@@ -52,7 +52,7 @@ class DensityF0D : public UnaryFunction0D<double>
 {
 public:
 	/*! Builds the functor from the gaussian sigma value.
-	 *  \param sigma
+	 *  \param sigma:
 	 *    sigma indicates the x value for which the gaussian function is 0.5. It leads to the window size value.
 	 *    (the larger, the smoother)
 	 */
@@ -111,9 +111,9 @@ private:
 public:
 	/*! Builds the functor from name of the
 	 *  Map that must be read.
-	 *  \param iMapName
+	 *  \param iMapName:
 	 *    The name of the map.
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
 	 */
 	ReadMapPixelF0D(const char *iMapName, int level) : UnaryFunction0D<float>()
@@ -142,9 +142,9 @@ private:
 
 public:
 	/*! Builds the functor
-	 *  \param nOrientation
+	 *  \param nOrientation:
 	 *    The integer belonging to [0,4] indicating the orientation (E,NE,N,NW) we are interested in.
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
 	 */
 	ReadSteerableViewMapPixelF0D(unsigned nOrientation, int level) : UnaryFunction0D<float>()
@@ -172,7 +172,7 @@ private:
 
 public:
 	/*! Builds the functor
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
 	 */
 	ReadCompleteViewMapPixelF0D(int level) : UnaryFunction0D<float>()
@@ -200,7 +200,7 @@ private:
 
 public:
 	/*! Builds the functor
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
 	 */
 	GetViewMapGradientNormF0D(int level) : UnaryFunction0D<float>()
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
index ec698ca5e68..6624d9d255c 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
@@ -54,11 +54,11 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param sigma
+	 *  \param sigma:
 	 *    Thesigma used in DensityF0D and determining the window size used in each density query.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
-	 *  \param sampling
+	 *  \param sampling:
 	 *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
 	 *    the result is obtained by combining the resulting values into a single one, following the method specified
 	 *    by iType.
@@ -98,9 +98,9 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double>
 {
 public:
 	/*! Builds the functor.
-	 *  \param sigma
+	 *  \param sigma:
 	 *    The sigma used in DensityF0D and determining the window size used in each density query.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	LocalAverageDepthF1D(real sigma, IntegrationType iType = MEAN)
@@ -134,13 +134,13 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double>
 {
 public:
 	/*! Builds the functor.
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which
 	 *    the pixel must be read.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute
 	 *    a single value from a set of values.
-	 *  \param sampling
+	 *  \param sampling:
 	 *    The resolution used to sample the chain: the corresponding 0D function
 	 *    is evaluated at each sample point and the result is obtained by
 	 *    combining the resulting values into a single one, following the
@@ -176,13 +176,13 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double>
 {
 public:
 	/*! Builds the functor.
-	 *  \param iOrientation
+	 *  \param iOrientation:
 	 *    The number of the directional map we must work with.
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
-	 *  \param sampling
+	 *  \param sampling:
 	 *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
 	 *    the result is obtained by combining the resulting values into a single one, following the method specified
 	 *    by iType.
@@ -220,11 +220,11 @@ private:
 
 public:
 	/*! Builds the functor from the level of the pyramid from which the pixel must be read.
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
-	 *  \param sampling
+	 *  \param sampling:
 	 *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
 	 *    the result is obtained by combining the resulting values into a single one, following the method specified
 	 *    by iType.
@@ -262,11 +262,11 @@ private:
 
 public:
 	/*! Builds the functor from the level of the pyramid from which the pixel must be read.
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
-	 *  \param sampling
+	 *  \param sampling:
 	 *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
 	 *    the result is obtained by combining the resulting values into a single one, following the method specified
 	 *    by iType.
diff --git a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
index c65f121e9ba..5fcabfe9e0e 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
@@ -52,10 +52,10 @@ class DensityLowerThanUP1D : public UnaryPredicate1D
 {
 public:
 	/*! Builds the functor.
-	 *  \param threshold
+	 *  \param threshold:
 	 *    The value of the threshold density.
 	 *    Any Interface1D having a density lower than this threshold will match.
-	 *  \param sigma
+	 *  \param sigma:
 	 *    The sigma value defining the density evaluation window size used in the DensityF0D functor.
 	 */
 	DensityLowerThanUP1D(double threshold, double sigma = 2)
diff --git a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
index 50b55027de7..c3498003317 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
@@ -41,13 +41,13 @@ class CalligraphicShader : public StrokeShader
 {
 public:
 	/*! Builds the shader.
-	 *  \param iMinThickness
+	 *  \param iMinThickness:
 	 *    The minimum thickness in the direction perpandicular to the main direction.
-	 *  \param iMaxThickness
+	 *  \param iMaxThickness:
 	 *    The maximum thickness in the main direction.
-	 *  \param iOrientation
+	 *  \param iOrientation:
 	 *    The 2D vector giving the main direction.
-	 *  \param clamp
+	 *  \param clamp:
 	 *    Tells ???
 	 */
 	CalligraphicShader(real iMinThickness, real iMaxThickness, const Vec2f &iOrientation, bool clamp);
@@ -74,15 +74,15 @@ class SpatialNoiseShader : public StrokeShader
 {
 public:
 	/*! Builds the shader.
-	 *  \param iAmount
+	 *  \param iAmount:
 	 *    The amplitude of the noise.
-	 *  \param ixScale
+	 *  \param ixScale:
 	 *    The noise frequency
-	 *  \param nbOctave
+	 *  \param nbOctave:
 	 *    The number of octaves
-	 *  \param smooth
+	 *  \param smooth:
 	 *    If you want the noise to be smooth
-	 *  \param pureRandom
+	 *  \param pureRandom:
 	 *    If you don't want any coherence
 	 */
 	SpatialNoiseShader(float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom);
@@ -112,21 +112,21 @@ class SmoothingShader : public StrokeShader
 {
 public:
 	/*! Builds the shader.
-	 *  \param iNbIteration
+	 *  \param iNbIteration:
 	 *    The number of iterations. (400)
-	 *  \param iFactorPoint
+	 *  \param iFactorPoint:
 	 *    0
-	 *  \param ifactorCurvature
+	 *  \param ifactorCurvature:
 	 *    0
-	 *  \param iFactorCurvatureDifference
+	 *  \param iFactorCurvatureDifference:
 	 *    0.2
-	 *  \param iAnisoPoint
+	 *  \param iAnisoPoint:
 	 *    0
-	 *  \param iAnisNormal
+	 *  \param iAnisNormal:
 	 *    0
-	 *  \param iAnisoCurvature
+	 *  \param iAnisoCurvature:
 	 *    0
-	 *  \param icarricatureFactor
+	 *  \param icarricatureFactor:
 	 *    1
 	 */
 	SmoothingShader(int iNbIteration, real iFactorPoint, real ifactorCurvature, real iFactorCurvatureDifference,
diff --git a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
index 1cdc754d725..53e0d5b7175 100644
--- a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
+++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
@@ -61,7 +61,7 @@ class ConstantThicknessShader : public StrokeShader
 {
 public:
 	/*! Builds the shader.
-	 *  \param thickness
+	 *  \param thickness:
 	 *    The thickness that must be assigned to the stroke.
 	 */
 	ConstantThicknessShader(float thickness) : StrokeShader()
@@ -121,9 +121,9 @@ class IncreasingThicknessShader : public StrokeShader
 {
 public:
 	/*! Builds the shader.
-	 *  \param iThicknessMin
+	 *  \param iThicknessMin:
 	 *    The first thickness value.
-	 *  \param iThicknessMax
+	 *  \param iThicknessMax:
 	 *    The second thickness value.
 	 */
 	IncreasingThicknessShader(float iThicknessMin, float iThicknessMax) : StrokeShader()
@@ -161,11 +161,11 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param iThicknessMin
+	 *  \param iThicknessMin:
 	 *    The first thickness value.
-	 *  \param iThicknessMax
+	 *  \param iThicknessMax:
 	 *    The second thickness value.
-	 *  \param iRatio
+	 *  \param iRatio:
 	 *    The ration thickness/length we don't want to exceed.
 	 */
 	ConstrainedIncreasingThicknessShader(float iThicknessMin, float iThicknessMax, float iRatio) : StrokeShader()
@@ -233,9 +233,9 @@ public:
 	ThicknessNoiseShader();
 
 	/*! Builds a Thickness Noise Shader
-	 *    \param iAmplitude
+	 *    \param iAmplitude:
 	 *      The amplitude of the noise signal
-	 *    \param iPeriod
+	 *    \param iPeriod:
 	 *      The period of the noise signal
 	 */
 	ThicknessNoiseShader(float iAmplitude, float iPeriod);
@@ -261,13 +261,13 @@ class ConstantColorShader : public StrokeShader
 {
 public:
 	/*! Builds the shader from a user-specified color.
-	 *  \param iR
+	 *  \param iR:
 	 *    The red component
-	 *  \param iG
+	 *  \param iG:
 	 *    The green component
-	 *  \param iB
+	 *  \param iB:
 	 *    The blue component
-	 *  \param iAlpha
+	 *  \param iAlpha:
 	 *    The alpha value
 	 */
 	ConstantColorShader(float iR, float iG, float iB, float iAlpha = 1.0f) : StrokeShader()
@@ -303,21 +303,21 @@ private:
 
 public:
 	/*! Builds the shader from 2 user-specified colors.
-	 *  \param iRm
+	 *  \param iRm:
 	 *    The first color red component
-	 *  \param iGm
+	 *  \param iGm:
 	 *    The first color green component
-	 *  \param iBm
+	 *  \param iBm:
 	 *    The first color blue component
-	 *  \param iAlpham
+	 *  \param iAlpham:
 	 *    The first color alpha value
-	 *  \param iRM
+	 *  \param iRM:
 	 *    The second color red component
-	 *  \param iGM
+	 *  \param iGM:
 	 *    The second color green component
-	 *  \param iBM
+	 *  \param iBM:
 	 *    The second color blue component
-	 *  \param iAlphaM
+	 *  \param iAlphaM:
 	 *    The second color alpha value
 	 */
 	IncreasingColorShader(float iRm, float iGm, float iBm, float iAlpham,
@@ -379,9 +379,9 @@ public:
 	ColorNoiseShader();
 
 	/*! Builds a Color Noise Shader
-	 *    \param iAmplitude
+	 *    \param iAmplitude:
 	 *      The amplitude of the noise signal
-	 *    \param iPeriod
+	 *    \param iPeriod:
 	 *      The period of the noise signal
 	 */
 	ColorNoiseShader(float iAmplitude, float iPeriod);
@@ -409,7 +409,7 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param iAmount
+	 *  \param iAmount:
 	 *    The stretching amount value.
 	 */
 	BackboneStretcherShader(float iAmount = 2.0f) : StrokeShader()
@@ -437,7 +437,7 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param sampling
+	 *  \param sampling:
 	 *    The sampling to use for the stroke resampling
 	 */
 	SamplingShader(float sampling) : StrokeShader()
@@ -488,7 +488,7 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param error
+	 *  \param error:
 	 *    The error we're allowing for the approximation.
 	 *    This error is the max distance allowed between the new curve and the original geometry.
 	 */
@@ -519,7 +519,7 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param iError
+	 *  \param iError:
 	 *    The error we want our polygonal approximation to have with respect to the original geometry.
 	 *    The smaller, the closer the new stroke to the orinal one.
 	 *    This error corresponds to the maximum distance between the new stroke and the old one.
@@ -552,7 +552,7 @@ private:
 
 public:
 	/*! Builds a Guiding Lines shader
-	 *    \param iOffset
+	 *    \param iOffset:
 	 *      The line that replaces the stroke is initially in the middle of the initial stroke "bbox".
 	 *      iOffset is the value of the displacement which is applied to this line along its normal.
 	 */
@@ -577,7 +577,7 @@ class TipRemoverShader : public StrokeShader
 {
 public:
 	/*! Builds the shader.
-	 *  \param tipLength
+	 *  \param tipLength:
 	 *    The length of the piece of stroke we want to remove at each extremity.
 	 */
 	TipRemoverShader (real tipLength);
@@ -609,7 +609,7 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param mtex
+	 *  \param mtex:
 	 *    The blender texture to use.
 	 */
 	BlenderTextureShader(MTex *mtex) : StrokeShader()
@@ -619,7 +619,7 @@ public:
 	}
 
 	/*! Builds the shader.
-	 *  \param nodetree
+	 *  \param nodetree:
 	 *    A node tree (of new shading nodes) to define textures.
 	 */
 	BlenderTextureShader(bNodeTree *nodetree) : StrokeShader()
@@ -648,7 +648,7 @@ private:
 
 public:
 	/*! Builds the shader.
-	 *  \param id
+	 *  \param id:
 	 *    The number of the preset to use.
 	 */
 	StrokeTextureStepShader(float step) : StrokeShader()
diff --git a/source/blender/freestyle/intern/stroke/Canvas.h b/source/blender/freestyle/intern/stroke/Canvas.h
index 6d84ff995d2..7151a81cce2 100644
--- a/source/blender/freestyle/intern/stroke/Canvas.h
+++ b/source/blender/freestyle/intern/stroke/Canvas.h
@@ -148,11 +148,11 @@ public:
 	/*! Loads an image map. The map will be scaled (without preserving the ratio in order to fit the actual
 	 *  canvas size.).
 	 *  The image must be a gray values image...
-	 *  \param iFileName
+	 *  \param iFileName:
 	 *    The name of the image file
-	 *  \param iMapName
+	 *  \param iMapName:
 	 *    The name that will be used to access this image
-	 *  \param iNbLevels
+	 *  \param iNbLevels:
 	 *    The number of levels in the map pyramid. (default = 4).
 	 *    If iNbLevels == 0, the complete pyramid is built.
 	 */
@@ -160,13 +160,13 @@ public:
 
 	/*! Reads a pixel value in a map.
 	 *  Returns a value between 0 and 1.
-	 *  \param iMapName
+	 *  \param iMapName:
 	 *    The name of the map
-	 *  \param level
+	 *  \param level:
 	 *    The level of the pyramid from which the pixel must be read.
-	 *  \param x
+	 *  \param x:
 	 *    The abscissa of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
-	 *  \param y
+	 *  \param y:
 	 *    The ordinate of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
 	 */
 	float readMapPixel(const char *iMapName, int level, int x, int y);
diff --git a/source/blender/freestyle/intern/stroke/Chain.h b/source/blender/freestyle/intern/stroke/Chain.h
index 6cf3a7199bf..ec1250445fa 100644
--- a/source/blender/freestyle/intern/stroke/Chain.h
+++ b/source/blender/freestyle/intern/stroke/Chain.h
@@ -82,17 +82,17 @@ public:
 	}
 
 	/*! Adds a ViewEdge at the end of the chain
-	 *  \param iViewEdge
+	 *  \param iViewEdge:
 	 *    The ViewEdge that must be added.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    The orientation with which this ViewEdge must be processed.
 	 */
 	void push_viewedge_back(ViewEdge *iViewEdge, bool orientation);
 
 	/*! Adds a ViewEdge at the beginning of the chain
-	 *  \param iViewEdge
+	 *  \param iViewEdge:
 	 *    The ViewEdge that must be added.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    The orientation with which this ViewEdge must be processed.
 	 */
 	void push_viewedge_front(ViewEdge *iViewEdge, bool orientation);
diff --git a/source/blender/freestyle/intern/stroke/ChainingIterators.h b/source/blender/freestyle/intern/stroke/ChainingIterators.h
index 310409f160f..a50a6596f96 100644
--- a/source/blender/freestyle/intern/stroke/ChainingIterators.h
+++ b/source/blender/freestyle/intern/stroke/ChainingIterators.h
@@ -162,13 +162,13 @@ public:
 	void *py_c_it;
 
 	/*! Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation.
-	 *  \param iRestrictToSelection
+	 *  \param iRestrictToSelection:
 	 *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-	 *  \param iRestrictToUnvisited
+	 *  \param iRestrictToUnvisited:
 	 *    Indicates whether a ViewEdge that has already been chained must be ignored ot not.
-	 *  \param begin
+	 *  \param begin:
 	 *    The ViewEdge from which to start the chain.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    The direction to follow to explore the graph. If true, the direction indicated by the first ViewEdge is used.
 	 */
 	ChainingIterator(bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge *begin = NULL,
@@ -205,7 +205,7 @@ public:
 
 	/*! This method iterates over the potential next ViewEdges and returns the one that will be followed next.
 	 *  returns the next ViewEdge to follow or 0 when the end of the chain is reached.
-	 *  \param it
+	 *  \param it:
 	 *    The iterator over the ViewEdges adjacent to the end vertex of the current ViewEdge.
 	 *    The Adjacency iterator reflects the restriction rules by only iterating over the valid ViewEdges.
 	 */
@@ -262,11 +262,11 @@ class ChainSilhouetteIterator : public ChainingIterator
 {
 public:
 	/*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its orientation.
-	 *  \param iRestrictToSelection
+	 *  \param iRestrictToSelection:
 	 *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-	 *  \param begin
+	 *  \param begin:
 	 *    The ViewEdge from where to start the iteration.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
 	 *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
 	 */
@@ -317,13 +317,13 @@ protected:
 
 public:
 	/*! Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
-	 *  \param iRestrictToSelection
+	 *  \param iRestrictToSelection:
 	 *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-	 *  \param iRestrictToUnvisited
+	 *  \param iRestrictToUnvisited:
 	 *    Indicates whether a ViewEdge that has already been chained must be ignored ot not.
-	 *  \param begin
+	 *  \param begin:
 	 *    The ViewEdge from where to start the iteration.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
 	 *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
 	 */
@@ -337,17 +337,17 @@ public:
 
 	/*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting ViewEdge and
 	 *  its orientation.
-	 *  \param iRestrictToSelection
+	 *  \param iRestrictToSelection:
 	 *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-	 *  \param iRestrictToUnvisited
+	 *  \param iRestrictToUnvisited:
 	 *    Indicates whether a ViewEdge that has already been chained must be ignored ot not.
-	 *  \param upred
+	 *  \param upred:
 	 *    The unary predicate that the next ViewEdge must satisfy.
-	 *  \param bpred
+	 *  \param bpred:
 	 *    The binary predicate that the next ViewEdge must satisfy together with the actual pointed ViewEdge.
-	 *  \param begin
+	 *  \param begin:
 	 *    The ViewEdge from where to start the iteration.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
 	 *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
 	 */
diff --git a/source/blender/freestyle/intern/stroke/ContextFunctions.h b/source/blender/freestyle/intern/stroke/ContextFunctions.h
index 97710437e47..58953d021d9 100644
--- a/source/blender/freestyle/intern/stroke/ContextFunctions.h
+++ b/source/blender/freestyle/intern/stroke/ContextFunctions.h
@@ -66,13 +66,13 @@ void LoadMapCF(const char *iFileName, const char *iMapName, unsigned iNbLevels =
 // ReadMapPixel
 /*! Reads a pixel in a user-defined map
  *  \return the floating value stored for that pixel
- *  \param iMapName
+ *  \param iMapName:
  *    The name of the map
- *  \param level
+ *  \param level:
  *    The level of the pyramid in which we wish to read the pixel
- *  \param x
+ *  \param x:
  *    The x-coordinate of the pixel we wish to read. The origin is in the lower-left corner.
- *  \param y
+ *  \param y:
  *    The y-coordinate of the pixel we wish to read. The origin is in the lower-left corner.
  */
 float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
@@ -80,11 +80,11 @@ float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
 // ReadCompleteViewMapPixel
 /*! Reads a pixel in the complete view map
  *  \return the floating value stored for that pixel
- *  \param level
+ *  \param level:
  *    The level of the pyramid in which we wish to read the pixel
- *  \param x
+ *  \param x:
  *    The x-coordinate of the pixel we wish to read. The origin is in the lower-left corner.
- *  \param y
+ *  \param y:
  *    The y-coordinate of the pixel we wish to read. The origin is in the lower-left corner.
  */
 float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y);
@@ -92,13 +92,13 @@ float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y);
 // ReadOrientedViewMapPixel
 /*! Reads a pixel in one of the oriented view map images
  *  \return the floating value stored for that pixel
- *  \param iOrientation
+ *  \param iOrientation:
  *    The number telling which orientation we want to check
- *  \param level
+ *  \param level:
  *    The level of the pyramid in which we wish to read the pixel
- *  \param x
+ *  \param x:
  *    The x-coordinate of the pixel we wish to read. The origin is in the lower-left corner.
- *  \param y
+ *  \param y:
  *    The y-coordinate of the pixel we wish to read. The origin is in the lower-left corner.
  */
 float ReadDirectionalViewMapPixelCF(int iOrientation, int level, unsigned x, unsigned y);
diff --git a/source/blender/freestyle/intern/stroke/Curve.h b/source/blender/freestyle/intern/stroke/Curve.h
index 04cc2fbfd39..1b242d172b2 100644
--- a/source/blender/freestyle/intern/stroke/Curve.h
+++ b/source/blender/freestyle/intern/stroke/Curve.h
@@ -204,21 +204,21 @@ public:
 	CurvePoint();
 
 	/*! Builds a CurvePoint from two SVertex and an interpolation parameter.
-	 *  \param iA
+	 *  \param iA:
 	 *    The first SVertex
-	 *  \param iB
+	 *  \param iB:
 	 *    The second SVertex
-	 *  \param t2d
+	 *  \param t2d:
 	 *    A 2D interpolation parameter used to linearly interpolate \a iA and \a iB
 	 */
 	CurvePoint(SVertex *iA, SVertex *iB, float t2d);
 
 	/*! Builds a CurvePoint from two CurvePoint and an interpolation parameter.
-	 *  \param iA
+	 *  \param iA:
 	 *    The first CurvePoint
-	 *  \param iB
+	 *  \param iB:
 	 *    The second CurvePoint
-	 *  \param t2d
+	 *  \param t2d:
 	 *    The 2D interpolation parameter used to linearly interpolate \a iA and \a iB.
 	 */
 	CurvePoint(CurvePoint *iA, CurvePoint *iB, float t2d);
diff --git a/source/blender/freestyle/intern/stroke/Operators.h b/source/blender/freestyle/intern/stroke/Operators.h
index 4130f9b370e..b364d5a36b4 100644
--- a/source/blender/freestyle/intern/stroke/Operators.h
+++ b/source/blender/freestyle/intern/stroke/Operators.h
@@ -65,7 +65,7 @@ public:
 	////////////////////////////////////////////////
 
 	/*! Selects the ViewEdges of the ViewMap verifying a specified condition.
-	 *  \param pred The predicate expressing this condition
+	 *  \param pred: The predicate expressing this condition
 	 */
 	static int select(UnaryPredicate1D& pred);
 
@@ -73,11 +73,11 @@ public:
 	 *  Each ViewEdge of the current list starts a new chain. The chaining operator then iterates over the ViewEdges
 	 *  of the ViewMap using the user specified iterator.
 	 *  This operator only iterates using the increment operator and is therefore unidirectional.
-	 *  \param it
+	 *  \param it:
 	 *           The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-	 *  \param pred
+	 *  \param pred:
 	 *           The predicate on the ViewEdge that expresses the stopping condition.
-	 *  \param modifier
+	 *  \param modifier:
 	 *           A function that takes a ViewEdge as argument and that is used to modify the processed ViewEdge
 	 *           state (the timestamp incrementation is a typical illustration of such a modifier)
 	 */
@@ -89,9 +89,9 @@ public:
 	 *  This operator only iterates using the increment operator and is therefore unidirectional.
 	 *  This chaining operator is different from the previous one because it doesn't take any modifier as argument.
 	 *  Indeed, the time stamp (insuring that a ViewEdge is processed one time) is automatically managed in this case.
-	 *  \param it
+	 *  \param it:
 	 *           The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-	 *  \param pred
+	 *  \param pred:
 	 *           The predicate on the ViewEdge that expresses the stopping condition.
 	 */
 	static int chain(ViewEdgeInternal::ViewEdgeIterator& it, UnaryPredicate1D& pred);
@@ -104,9 +104,9 @@ public:
 	 *  be told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining.
 	 *  Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track
 	 *  of the number of chains to which a ViewEdge belongs to.
-	 *  \param it
+	 *  \param it:
 	 *           The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-	 *  \param pred
+	 *  \param pred:
 	 *           The predicate on the ViewEdge that expresses the stopping condition.
 	 */
 	static int bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred);
@@ -121,7 +121,7 @@ public:
 	 *  told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining.
 	 *  Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track
 	 *  of the number of chains to which a ViewEdge belongs to.
-	 *  \param it
+	 *  \param it:
 	 *           The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.
 	 */
 	static int bidirectionalChain(ChainingIterator& it);
@@ -133,11 +133,11 @@ public:
 	 *  This allows chains overlapping rather than chains partitioning.
 	 *  The first point of the initial chain is the first point of one of the resulting chains.
 	 *  The splitting ends when no more chain can start.
-	 *  \param startingPred
+	 *  \param startingPred:
 	 *           The predicate on a point that expresses the starting condition
-	 *  \param stoppingPred
+	 *  \param stoppingPred:
 	 *           The predicate on a point that expresses the stopping condition
-	 *  \param sampling
+	 *  \param sampling:
 	 *           The resolution used to sample the chain for the predicates evaluation. (The chain is not actually
 	 *           resampled, a virtual point only progresses along the curve using this resolution)
 	 */
@@ -147,9 +147,9 @@ public:
 	 *  The points of each chain are processed (with a specified sampling) sequentially and each time a user
 	 *  specified condition is verified, the chain is split into two chains.
 	 *  The resulting set of chains is a partition of the initial chain
-	 *  \param pred
+	 *  \param pred:
 	 *           The predicate on a point that expresses the splitting condition
-	 *  \param sampling
+	 *  \param sampling:
 	 *           The resolution used to sample the chain for the predicate evaluation. (The chain is not actually
 	 *           resampled, a virtual point only progresses along the curve using this resolution)
 	 */
@@ -160,14 +160,14 @@ public:
 	 *  function. The chain is split in two at this point and the two new chains are processed in the same way.
 	 *  The recursivity level is controlled through a predicate 1D that expresses a stopping condition
 	 *  on the chain that is about to be processed.
-	 *  \param func
+	 *  \param func:
 	 *           The Unary Function evaluated at each point of the chain.
 	 *           The splitting point is the point minimizing this function
-	 *  \param pred
+	 *  \param pred:
 	 *           The Unary Predicate ex pressing the recursivity stopping condition.
 	 *           This predicate is evaluated for each curve before it actually gets split.
 	 *           If pred(chain) is true, the curve won't be split anymore.
-	 *  \param sampling
+	 *  \param sampling:
 	 *           The resolution used to sample the chain for the predicates evaluation. (The chain is not actually
 	 *           resampled, a virtual point only progresses along the curve using this resolution)
 	 */
@@ -180,19 +180,19 @@ public:
 	 *  A point that doesn't verify the 0D predicate won't be candidate in realizing the min.
 	 *  The recursivity level is controlled through a predicate 1D that expresses a stopping condition
 	 *  on the chain that is about to be processed.
-	 *  \param func
+	 *  \param func:
 	 *           The Unary Function evaluated at each point of the chain.
 	 *           The splitting point is the point minimizing this function
-	 *  \param pred0d
+	 *  \param pred0d:
 	 *           The Unary Predicate 0D used to select the candidate points where the split can occur.
 	 *           For example, it is very likely that would rather have your chain splitting around its middle point
 	 *           than around one of its extremities. A 0D predicate working on the curvilinear abscissa allows
 	 *           to add this kind of constraints.
-	 *  \param pred
+	 *  \param pred:
 	 *           The Unary Predicate ex pressing the recursivity stopping condition.
 	 *           This predicate is evaluated for each curve before it actually gets split.
 	 *           If pred(chain) is true, the curve won't be split anymore.
-	 *  \param sampling
+	 *  \param sampling:
 	 *           The resolution used to sample the chain for the predicates evaluation. (The chain is not actually
 	 *           resampled, a virtual point only progresses along the curve using this resolution)
 	 */
@@ -200,16 +200,16 @@ public:
 	                          float sampling = 0.0f);
 
 	/*! Sorts the current set of chains (or viewedges) according to the comparison predicate given as argument.
-	 *  \param pred
+	 *  \param pred:
 	 *           The binary predicate used for the comparison
 	 */
 	static int sort(BinaryPredicate1D& pred);
 
 	/*! Creates and shades the strokes from the current set of chains.
 	 *  A predicate can be specified to make a selection pass on the chains.
-	 *  \param pred
+	 *  \param pred:
 	 *           The predicate that a chain must verify in order to be transform as a stroke
-	 *  \param shaders
+	 *  \param shaders:
 	 *           The list of shaders used to shade the strokes
 	 */
 	static int create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders);
diff --git a/source/blender/freestyle/intern/stroke/Predicates0D.h b/source/blender/freestyle/intern/stroke/Predicates0D.h
index 6ce77649c31..bf09d99bcbd 100644
--- a/source/blender/freestyle/intern/stroke/Predicates0D.h
+++ b/source/blender/freestyle/intern/stroke/Predicates0D.h
@@ -70,7 +70,7 @@ public:
 	}
 
 	/*! The () operator. Must be overload by inherited classes.
-	 *  \param it
+	 *  \param it:
 	 *    The Interface0DIterator pointing onto the Interface0D at which we wish to evaluate the predicate.
 	 *  \return true if the condition is satisfied, false otherwise.
 	 */
@@ -115,9 +115,9 @@ public:
 
 	/*! The () operator. Must be overload by inherited classes.
 	 *  It evaluates a relation between 2 Interface0D.
-	 *  \param inter1
+	 *  \param inter1:
 	 *    The first Interface0D.
-	 *  \param inter2
+	 *  \param inter2:
 	 *    The second Interface0D.
 	 *  \return true or false.
 	 */
diff --git a/source/blender/freestyle/intern/stroke/Predicates1D.h b/source/blender/freestyle/intern/stroke/Predicates1D.h
index 05fc043822f..9f8b264abcd 100644
--- a/source/blender/freestyle/intern/stroke/Predicates1D.h
+++ b/source/blender/freestyle/intern/stroke/Predicates1D.h
@@ -77,7 +77,7 @@ public:
 	}
 
 	/*! The () operator. Must be overload by inherited classes.
-	 *  \param inter
+	 *  \param inter:
 	 *    The Interface1D on  which we wish to evaluate the predicate.
 	 *  \return true if the condition is satisfied, false otherwise.
 	 */
@@ -122,9 +122,9 @@ public:
 
 	/*! The () operator. Must be overload by inherited classes.
 	 *  It evaluates a relation between 2 Interface1D.
-	 *  \param inter1
+	 *  \param inter1:
 	 *    The first Interface1D.
-	 *  \param inter2
+	 *  \param inter2:
 	 *    The second Interface1D.
 	 *  \return true or false.
 	 */
@@ -195,7 +195,7 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D
 {
 public:
 	/*! Builds the Predicate.
-	 *  \param qi
+	 *  \param qi:
 	 *    The Quantitative Invisibility you want the Interface1D to have
 	 */
 	QuantitativeInvisibilityUP1D(unsigned qi = 0) : _qi(qi) {}
@@ -359,9 +359,9 @@ private:
 
 public:
 	/*! Builds the Predicate.
-	 *  \param idFirst
+	 *  \param idFirst:
 	 *    The first Id component.
-	 *  \param idSecond
+	 *  \param idSecond:
 	 *    The second Id component.
 	 */
 	ShapeUP1D(unsigned idFirst, unsigned idSecond = 0) : UnaryPredicate1D()
@@ -400,13 +400,13 @@ private:
 
 public:
 	/*! Builds the Predicate.
-	 *  \param xmin
+	 *  \param xmin:
 	 *    The X lower bound of the image boundary.
-	 *  \param ymin
+	 *  \param ymin:
 	 *    The Y lower bound of the image boundary.
-	 *  \param xmax
+	 *  \param xmax:
 	 *    The X upper bound of the image boundary.
-	 *  \param ymax
+	 *  \param ymax:
 	 *    The Y upper bound of the image boundary.
 	 */
 	WithinImageBoundaryUP1D(const real xmin, const real ymin, const real xmax, const real ymax)
diff --git a/source/blender/freestyle/intern/stroke/Stroke.h b/source/blender/freestyle/intern/stroke/Stroke.h
index ce63c528ac3..6ef92db99fc 100644
--- a/source/blender/freestyle/intern/stroke/Stroke.h
+++ b/source/blender/freestyle/intern/stroke/Stroke.h
@@ -73,28 +73,28 @@ public:
 	StrokeAttribute(const StrokeAttribute& iBrother);
 
 	/*! Builds a stroke vertex attribute from a set of parameters.
-	 *    \param iRColor
+	 *    \param iRColor:
 	 *      The Red Component value.
-	 *    \param iGColor
+	 *    \param iGColor:
 	 *      The Green Component value.
-	 *    \param iBColor
+	 *    \param iBColor:
 	 *      The Blue Component value.
-	 *    \param iAlpha
+	 *    \param iAlpha:
 	 *      The transparency value
-	 *    \param iRThickness
+	 *    \param iRThickness:
 	 *      The thickness of the stroke on the right
-	 *    \param iLThickness
+	 *    \param iLThickness:
 	 *      The Thickness of the stroke on the left
 	 */
 	StrokeAttribute(float iRColor, float iGColor, float iBColor, float iAlpha, float iRThickness, float iLThickness);
 
 	/*! Interpolation constructor.
 	 *  Builds a StrokeAttribute from two StrokeAttributes and an interpolation parameter.
-	 *  \param a1
+	 *  \param a1:
 	 *    The first Attribute.
-	 *  \param a2
+	 *  \param a2:
 	 *    The second parameter.
-	 *  \param t
+	 *  \param t:
 	 *    The interpolation parameter.
 	 */
 	StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribute& a2, float t);
@@ -179,19 +179,19 @@ public:
 	}
 
 	/*! Returns an attribute of type real
-	 *  \param iName
+	 *  \param iName:
 	 *    The name of the attribute
 	 */
 	float getAttributeReal(const char *iName) const;
 
 	/*! Returns an attribute of type Vec2f
-	 *  \param iName
+	 *  \param iName:
 	 *    The name of the attribute
 	 */
 	Vec2f getAttributeVec2f(const char *iName) const;
 
 	/*! Returns an attribute of type Vec3f
-	 *  \param iName
+	 *  \param iName:
 	 *    The name of the attribute
 	 */
 	Vec3f getAttributeVec3f(const char *iName) const;
@@ -207,11 +207,11 @@ public:
 
 	/* modifiers */
 	/*! sets the attribute's color.
-	 *    \param r
+	 *    \param r:
 	 *      The new R value.
-	 *    \param g
+	 *    \param g:
 	 *      The new G value.
-	 *    \param b
+	 *    \param b:
 	 *      The new B value.
 	 */
 	inline void setColor(float r, float g, float b)
@@ -222,7 +222,7 @@ public:
 	}
 
 	/*! sets the attribute's color.
-	 *    \param iRGB
+	 *    \param iRGB:
 	 *      The new RGB values.
 	 */
 	inline void setColor(const Vec3f& iRGB)
@@ -233,7 +233,7 @@ public:
 	}
 
 	/*! sets the attribute's alpha value.
-	 *  \param alpha
+	 *  \param alpha:
 	 *    The new alpha value.
 	 */
 	inline void setAlpha(float alpha)
@@ -242,9 +242,9 @@ public:
 	}
 
 	/*! sets the attribute's thickness.
-	 *  \param tr
+	 *  \param tr:
 	 *    The thickness on the right of the vertex when following the stroke.
-	 *  \param tl
+	 *  \param tl:
 	 *    The thickness on the left of the vertex when following the stroke.
 	 */
 	inline void setThickness(float tr, float tl)
@@ -254,7 +254,7 @@ public:
 	}
 
 	/*! sets the attribute's thickness.
-	 *  \param tRL
+	 *  \param tRL:
 	 *    The thickness on the right and on the left of the vertex when following the stroke.
 	 */
 	inline void setThickness(const Vec2f& tRL)
@@ -272,9 +272,9 @@ public:
 	/*! Adds a user defined attribute of type real
 	 *  If there is no attribute of name iName, it is added.
 	 *  Otherwise, the new value replaces the old one.
-	 *  \param iName
+	 *  \param iName:
 	 *    The name of the attribute
-	 *  \param att
+	 *  \param att:
 	 *    The attribute's value
 	 */
 	void setAttributeReal(const char *iName, float att);
@@ -282,9 +282,9 @@ public:
 	/*! Adds a user defined attribute of type Vec2f
 	 *  If there is no attribute of name iName, it is added.
 	 *  Otherwise, the new value replaces the old one.
-	 *  \param iName
+	 *  \param iName:
 	 *    The name of the attribute
-	 *  \param att
+	 *  \param att:
 	 *    The attribute's value
 	 */
 	void setAttributeVec2f(const char *iName, const Vec2f& att);
@@ -292,9 +292,9 @@ public:
 	/*! Adds a user defined attribute of type Vec3f
 	 *  If there is no attribute of name iName, it is added.
 	 *  Otherwise, the new value replaces the old one.
-	 *  \param iName
+	 *  \param iName:
 	 *    The name of the attribute
-	 *  \param att
+	 *  \param att:
 	 *    The attribute's value
 	 */
 	void setAttributeVec3f(const char *iName, const Vec3f& att);
@@ -562,9 +562,9 @@ public:
 	/*! Builds a stroke from a set of StrokeVertex.
 	 *  This constructor is templated by an iterator type.
 	 *  This iterator type must allow the vertices parsing using the ++ operator.
-	 *    \param iBegin
+	 *    \param iBegin:
 	 *      The iterator pointing to the first vertex.
-	 *    \param iEnd
+	 *    \param iEnd:
 	 *      The iterator pointing to the end of the vertex list.
 	 */
 	template<class InputVertexIterator>
@@ -580,7 +580,7 @@ public:
 	/*! Compute the sampling needed to get iNVertices vertices.
 	 *  If the specified number of vertices is less than the actual number of vertices, the actual sampling value
 	 *  is returned. (To remove Vertices, use the RemoveVertex() method of this class).
-	 *  \param iNVertices
+	 *  \param iNVertices:
 	 *    The number of StrokeVertices we eventually want in our Stroke.
 	 *  \return the sampling that must be used in the Resample(float) method.
 	 *  \see Resample(int)
@@ -592,7 +592,7 @@ public:
 	 *  Resamples the curve so that it eventually has iNPoints. That means it is going to add iNPoints-vertices_size,
 	 *  if vertices_size is the number of points we already have.
 	 *  If vertices_size >= iNPoints, no resampling is done.
-	 *  \param iNPoints
+	 *  \param iNPoints:
 	 *    The number of vertices we eventually want in our stroke.
 	 */
 	int Resample(int iNPoints);
@@ -600,7 +600,7 @@ public:
 	/*! Resampling method.
 	 *  Resamples the curve with a given sampling.
 	 *  If this sampling is < to the actual sampling value, no resampling is done.
-	 *  \param iSampling
+	 *  \param iSampling:
 	 *    The new sampling value.
 	 */
 	int Resample(float iSampling);
@@ -618,9 +618,9 @@ public:
 
 	/*! Inserts the stroke vertex iVertex in the stroke before next.
 	 *  The length, curvilinear abscissa are updated consequently.
-	 *  \param iVertex
+	 *  \param iVertex:
 	 *    The StrokeVertex to insert in the Stroke.
-	 *  \param next
+	 *  \param next:
 	 *    A StrokeVertexIterator pointing to the StrokeVeretx before which iVertex must be inserted.
 	 */
 	void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);
@@ -837,7 +837,7 @@ public:
 
 	/*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can specify a sampling
 	 *  value to resample the Stroke on the fly if needed.
-	 *  \param t
+	 *  \param t:
 	 *    The resampling value with which we want our Stroke to be resampled.
 	 *    If 0 is specified, no resampling is done.
 	 */
diff --git a/source/blender/freestyle/intern/stroke/StrokeShader.h b/source/blender/freestyle/intern/stroke/StrokeShader.h
index e655b80d397..1b070a685cc 100644
--- a/source/blender/freestyle/intern/stroke/StrokeShader.h
+++ b/source/blender/freestyle/intern/stroke/StrokeShader.h
@@ -93,7 +93,7 @@ public:
 	}
 
 	/*! The shading method. This method must be overloaded by inherited classes.
-	 *  \param ioStroke
+	 *  \param ioStroke:
 	 *    The stroke we wish to shade. this Stroke is modified by the Shader (which typically
 	 *    modifies the Stroke's attribute's values such as Color, Thickness, Geometry...)
 	 */
diff --git a/source/blender/freestyle/intern/view_map/FEdgeXDetector.h b/source/blender/freestyle/intern/view_map/FEdgeXDetector.h
index cbb47d387fb..99b7c127fff 100644
--- a/source/blender/freestyle/intern/view_map/FEdgeXDetector.h
+++ b/source/blender/freestyle/intern/view_map/FEdgeXDetector.h
@@ -93,7 +93,7 @@ public:
 	virtual void ProcessCreaseEdge(WXEdge *iEdge);
 
 	/*! Sets the minimum angle for detecting crease edges
-	 *  \param angle
+	 *  \param angle:
 	 *    The angular threshold in degrees (between 0 and 180) for detecting crease edges. An edge is considered
 	 *    a crease edge if the angle between two faces sharing the edge is smaller than the given threshold.
 	 */
@@ -125,7 +125,7 @@ public:
 	virtual void postProcessSuggestiveContourShape(WXShape *iShape);
 	virtual void postProcessSuggestiveContourFace(WXFace *iFace);
 	/*! Sets the minimal derivative of the radial curvature for suggestive contours
-	 *  \param dkr
+	 *  \param dkr:
 	 *    The minimal derivative of the radial curvature
 	 */
 	inline void setSuggestiveContourKrDerivativeEpsilon(float dkr)
@@ -190,7 +190,7 @@ public:
 	}
 
 	/*! Sets the radius of the geodesic sphere around each vertex (for the curvature computation)
-	 *  \param r
+	 *  \param r:
 	 *    The radius of the sphere expressed as a ratio of the mean edge size
 	 */
 	inline void setSphereRadius(float r)
diff --git a/source/blender/freestyle/intern/view_map/Functions0D.h b/source/blender/freestyle/intern/view_map/Functions0D.h
index f0009fca6ea..035da76a6e4 100644
--- a/source/blender/freestyle/intern/view_map/Functions0D.h
+++ b/source/blender/freestyle/intern/view_map/Functions0D.h
@@ -103,7 +103,7 @@ public:
 	}
 
 	/*! The operator ().
-	 *  \param iter
+	 *  \param iter:
 	 *    An Interface0DIterator pointing onto the point at which we wish to evaluate the function.
 	 *  \return the result of the function of type T.
 	 */
diff --git a/source/blender/freestyle/intern/view_map/Functions1D.h b/source/blender/freestyle/intern/view_map/Functions1D.h
index f3c8957a804..60b3192910f 100644
--- a/source/blender/freestyle/intern/view_map/Functions1D.h
+++ b/source/blender/freestyle/intern/view_map/Functions1D.h
@@ -81,7 +81,7 @@ public:
 	}
 
 	/*! Builds a UnaryFunction1D from an integration type.
-	 *  \param iType
+	 *  \param iType:
 	 *    In case the result for the Interface1D would be obtained by evaluating a 0D function over the different
 	 *    Interface0D of the Interface1D, \a iType tells which integration method to use.
 	 *    The default integration method is the MEAN.
@@ -101,7 +101,7 @@ public:
 	}
 
 	/*! The operator ().
-	 *  \param inter
+	 *  \param inter:
 	 *    The Interface1D on which we wish to evaluate the function.
 	 *  \return the result of the function of type T.
 	 */
@@ -195,7 +195,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	GetXF1D(IntegrationType iType) : UnaryFunction1D<double>(iType) {}
@@ -219,7 +219,7 @@ Functions0D::GetYF0D _func;
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -243,7 +243,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -267,7 +267,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -291,7 +291,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -315,7 +315,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -339,7 +339,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
@@ -363,7 +363,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType) {}
@@ -390,7 +390,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -418,7 +418,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
@@ -446,7 +446,7 @@ private:
 
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
@@ -513,7 +513,7 @@ class Curvature2DAngleF1D : public UnaryFunction1D<double>
 {
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<double>(iType) {}
@@ -541,7 +541,7 @@ class Normal2DF1D : public UnaryFunction1D<Vec2f>
 {
 public:
 	/*! Builds the functor.
-	 *  \param iType
+	 *  \param iType:
 	 *    The integration method used to compute a single value from a set of values.
 	 */
 	Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
diff --git a/source/blender/freestyle/intern/view_map/Interface1D.h b/source/blender/freestyle/intern/view_map/Interface1D.h
index 7afa61ff496..d6f402bf153 100644
--- a/source/blender/freestyle/intern/view_map/Interface1D.h
+++ b/source/blender/freestyle/intern/view_map/Interface1D.h
@@ -60,14 +60,14 @@ typedef enum {
 } IntegrationType;
 
 /*! Returns a single value from a set of values evaluated at each 0D element of this 1D element.
- *  \param fun
+ *  \param fun:
  *    The UnaryFunction0D used to compute a value at each Interface0D.
- *  \param it
+ *  \param it:
  *    The Interface0DIterator used to iterate over the 0D elements of this 1D element. The integration will occur
  *    over the 0D elements starting from the one pointed by it.
- *  \param it_end
+ *  \param it_end:
  *    The Interface0DIterator pointing the end of the 0D elements of the 1D element.
- *  \param integration_type
+ *  \param integration_type:
  *    The integration method used to compute a single value from a set of values.
  *  \return the single value obtained for the 1D element.
  */
@@ -156,7 +156,7 @@ public:
 	/*! Returns an iterator over the Interface1D points, pointing to the first point. The difference with
 	 *  verticesBegin() is that here we can iterate over points of the 1D element at a any given sampling.
 	 *  Indeed, for each iteration, a virtual point is created.
-	 *  \param t
+	 *  \param t:
 	 *    The sampling with which we want to iterate over points of this 1D element.
 	 */
 	virtual Interface0DIterator pointsBegin(float t = 0.0f);
@@ -164,7 +164,7 @@ public:
 	/*! Returns an iterator over the Interface1D points, pointing after the last point. The difference with
 	 *  verticesEnd() is that here we can iterate over points of the 1D element at a any given sampling.
 	 *  Indeed, for each iteration, a virtual point is created.
-	 *  \param t
+	 *  \param t:
 	 *    The sampling with which we want to iterate over points of this 1D element.
 	 */
 	virtual Interface0DIterator pointsEnd(float t = 0.0f);
diff --git a/source/blender/freestyle/intern/view_map/Silhouette.h b/source/blender/freestyle/intern/view_map/Silhouette.h
index 44bce375a75..a18cf41797b 100644
--- a/source/blender/freestyle/intern/view_map/Silhouette.h
+++ b/source/blender/freestyle/intern/view_map/Silhouette.h
@@ -949,7 +949,7 @@ public:
 	/*! Returns an iterator over the FEdge points, pointing to the first point. The difference with verticesBegin()
 	 *  is that here we can iterate over points of the FEdge at a any given sampling.
 	 *  Indeed, for each iteration, a virtual point is created.
-	 *  \param t
+	 *  \param t:
 	 *    The sampling with which we want to iterate over points of this FEdge.
 	 */
 	virtual inline Interface0DIterator pointsBegin(float t = 0.0f);
@@ -957,7 +957,7 @@ public:
 	/*! Returns an iterator over the FEdge points, pointing after the last point. The difference with verticesEnd()
 	 * is that here we can iterate over points of the FEdge at a any given sampling.
 	 *  Indeed, for each iteration, a virtual point is created.
-	 *  \param t
+	 *  \param t:
 	 *    The sampling with which we want to iterate over points of this FEdge.
 	 */
 	virtual inline Interface0DIterator pointsEnd(float t = 0.0f);
diff --git a/source/blender/freestyle/intern/view_map/SteerableViewMap.h b/source/blender/freestyle/intern/view_map/SteerableViewMap.h
index 0327b4a460e..1259d081209 100644
--- a/source/blender/freestyle/intern/view_map/SteerableViewMap.h
+++ b/source/blender/freestyle/intern/view_map/SteerableViewMap.h
@@ -82,27 +82,27 @@ public:
 	double ComputeWeight(const Vec2d& dir, unsigned iNOrientation);
 
 	/*! Returns the number of the SVM to which a direction belongs to.
-	 *  \param dir
+	 *  \param dir:
 	 *    The direction
 	 */
 	unsigned getSVMNumber(const Vec2f& dir);
 
 	/*! Returns the number of the SVM to which a FEdge belongs most.
-	 *  \param id
+	 *  \param id:
 	 *    The First element of the Id struct of the FEdge we're interested in.
 	 */
 	unsigned getSVMNumber(unsigned id);
 
 	/*! Builds _nbOrientations+1 pyramids of images from the _nbOrientations+1 base images of the steerable viewmap.
-	 *  \param steerableBases
+	 *  \param steerableBases:
 	 *    The _nbOrientations+1 images constituting the basis for the steerable pyramid.
-	 *  \param copy
+	 *  \param copy:
 	 *    If false, the data is not duplicated, and Canvas deals with the memory management of these
 	 *    _nbOrientations+1 images. If true, data is copied, and it's up to the caller to delete the images.
-	 *  \param iNbLevels
+	 *  \param iNbLevels:
 	 *    The number of levels desired for each pyramid.
 	 *    If iNbLevels == 0, the complete pyramid is built.
-	 *  \param iSigma
+	 *  \param iSigma:
 	 *    The sigma that will be used for the gaussian blur
 	 */
 	void buildImagesPyramids(GrayImage **steerableBases, bool copy = false, unsigned iNbLevels = 4,
@@ -110,7 +110,7 @@ public:
 
 	/*! Reads a pixel value in one of the VewMap density steerable pyramids.
 	 *  Returns a value between 0 and 1.
-	 *  \param iOrientation
+	 *  \param iOrientation:
 	 *    the number telling which orientation we need to check.
 	 *    There are _nbOrientations+1 oriented ViewMaps:
 	 *    0 -> the ViewMap containing every horizontal lines
@@ -118,11 +118,11 @@ public:
 	 *    2 -> the ViewMap containing every vertical lines
 	 *    3 -> the ViewMap containing every lines whose orientation is around 3PI/4
 	 *    4 -> the complete ViewMap
-	 *  \param iLevel
+	 *  \param iLevel:
 	 *    The level of the pyramid we want to read
-	 *  \param x
+	 *  \param x:
 	 *    The abscissa of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
-	 *  \param y
+	 *  \param y:
 	 *    The ordinate of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
 	 */
 	float readSteerableViewMapPixel(unsigned iOrientation, int iLevel, int x, int y);
diff --git a/source/blender/freestyle/intern/view_map/ViewMap.h b/source/blender/freestyle/intern/view_map/ViewMap.h
index 74fb875ffc6..0acc6ca39d8 100644
--- a/source/blender/freestyle/intern/view_map/ViewMap.h
+++ b/source/blender/freestyle/intern/view_map/ViewMap.h
@@ -1364,14 +1364,14 @@ public:
 
 	/*! Returns an Interface0DIterator to iterate over the points of this ViewEdge at a given resolution.
 	 *  The returned Interface0DIterator points on the first Point of the ViewEdge.
-	 *  \param t
+	 *  \param t:
 	 *    the sampling value.
 	 */
 	virtual Interface0DIterator pointsBegin(float t = 0.0f);
 
 	/*! Returns an Interface0DIterator to iterate over the points of this ViewEdge at a given resolution.
 	 *  The returned Interface0DIterator points after the last Point of the ViewEdge.
-	 *  \param t
+	 *  \param t:
 	 *    the sampling value.
 	 */
 	virtual Interface0DIterator pointsEnd(float t = 0.0f);
diff --git a/source/blender/freestyle/intern/view_map/ViewMapIterators.h b/source/blender/freestyle/intern/view_map/ViewMapIterators.h
index b10de13cef7..bec57bf36df 100644
--- a/source/blender/freestyle/intern/view_map/ViewMapIterators.h
+++ b/source/blender/freestyle/intern/view_map/ViewMapIterators.h
@@ -417,9 +417,9 @@ class ViewEdgeIterator : public Iterator
 {
 public:
 	/*! Builds a ViewEdgeIterator from a starting ViewEdge and its orientation.
-	 *  \param begin
+	 *  \param begin:
 	 *    The ViewEdge from where to start the iteration.
-	 *  \param orientation
+	 *  \param orientation:
 	 *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
 	 *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
 	 */