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.

15 files changed, 193 insertions, 193 deletions

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...)
 	 */