Cleanup: use Blender's code style for doxygen commetns in freestyle

27 files changed, 457 insertions, 457 deletions

diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
index 17e419bed54..212187e598c 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
@@ -36,13 +36,13 @@ namespace Freestyle {
 namespace Functions0D {
 
 // DensityF0D
-/*! Returns the density of the (result) image evaluated at an Interface0D.
+/** Returns the density of the (result) image evaluated at an Interface0D.
  *  This density is evaluated using a pixels square window around the evaluation point and
  * integrating these values using a gaussian.
  */
 class DensityF0D : public UnaryFunction0D<double> {
  public:
-  /*! Builds the functor from the gaussian sigma value.
+  /** Builds the functor from the gaussian sigma value.
    *  \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)
@@ -52,13 +52,13 @@ class DensityF0D : public UnaryFunction0D<double> {
     _filter.setSigma((float)sigma);
   }
 
-  /*! Returns the string "DensityF0D" */
+  /** Returns the string "DensityF0D" */
   string getName() const
   {
     return "DensityF0D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface0DIterator &iter);
 
  private:
@@ -66,7 +66,7 @@ class DensityF0D : public UnaryFunction0D<double> {
 };
 
 // LocalAverageDepthF0D
-/*! Returns the average depth around a point.
+/** Returns the average depth around a point.
  *  The result is obtained by querying the depth buffer on a window around that point.
  */
 class LocalAverageDepthF0D : public UnaryFunction0D<double> {
@@ -74,31 +74,31 @@ class LocalAverageDepthF0D : public UnaryFunction0D<double> {
   GaussianFilter _filter;
 
  public:
-  /*! Builds the functor from the size of the mask that will be used. */
+  /** Builds the functor from the size of the mask that will be used. */
   LocalAverageDepthF0D(real maskSize = 5.0f) : UnaryFunction0D<double>()
   {
     _filter.setSigma((float)maskSize / 2.0f);
   }
 
-  /*! Returns the string "LocalAverageDepthF0D" */
+  /** Returns the string "LocalAverageDepthF0D" */
   string getName() const
   {
     return "LocalAverageDepthF0D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface0DIterator &iter);
 };
 
 // ReadMapPixel
-/*! Reads a pixel in a map. */
+/** Reads a pixel in a map. */
 class ReadMapPixelF0D : public UnaryFunction0D<float> {
  private:
   const char *_mapName;
   int _level;
 
  public:
-  /*! Builds the functor from name of the
+  /** Builds the functor from name of the
    *  Map that must be read.
    *  \param iMapName:
    *    The name of the map.
@@ -111,25 +111,25 @@ class ReadMapPixelF0D : public UnaryFunction0D<float> {
     _level = level;
   }
 
-  /*! Returns the string "ReadMapPixelF0D" */
+  /** Returns the string "ReadMapPixelF0D" */
   string getName() const
   {
     return "ReadMapPixelF0D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface0DIterator &iter);
 };
 
 // ReadSteerableViewMapPixel
-/*! Reads a pixel in one of the level of one of the steerable viewmaps. */
+/** Reads a pixel in one of the level of one of the steerable viewmaps. */
 class ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float> {
  private:
   unsigned _orientation;
   int _level;
 
  public:
-  /*! Builds the functor
+  /** Builds the functor
    *  \param nOrientation:
    *    The integer belonging to [0,4] indicating the orientation (E,NE,N,NW) we are interested in.
    *  \param level:
@@ -141,24 +141,24 @@ class ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float> {
     _level = level;
   }
 
-  /*! Returns the string "ReadSteerableViewMapPixelF0D" */
+  /** Returns the string "ReadSteerableViewMapPixelF0D" */
   string getName() const
   {
     return "ReadSteerableViewMapPixelF0D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface0DIterator &iter);
 };
 
 // ReadCompleteViewMapPixel
-/*! Reads a pixel in one of the level of the complete viewmap. */
+/** Reads a pixel in one of the level of the complete viewmap. */
 class ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float> {
  private:
   int _level;
 
  public:
-  /*! Builds the functor
+  /** Builds the functor
    *  \param level:
    *    The level of the pyramid from which the pixel must be read.
    */
@@ -167,25 +167,25 @@ class ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float> {
     _level = level;
   }
 
-  /*! Returns the string "ReadCompleteViewMapPixelF0D" */
+  /** Returns the string "ReadCompleteViewMapPixelF0D" */
   string getName() const
   {
     return "ReadCompleteViewMapPixelF0D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface0DIterator &iter);
 };
 
 // GetViewMapGradientNormF0D
-/*! Returns the norm of the gradient of the global viewmap density image. */
+/** Returns the norm of the gradient of the global viewmap density image. */
 class GetViewMapGradientNormF0D : public UnaryFunction0D<float> {
  private:
   int _level;
   float _step;
 
  public:
-  /*! Builds the functor
+  /** Builds the functor
    *  \param level:
    *    The level of the pyramid from which the pixel must be read.
    */
@@ -195,13 +195,13 @@ class GetViewMapGradientNormF0D : public UnaryFunction0D<float> {
     _step = (float)pow(2.0, _level);
   }
 
-  /*! Returns the string "GetOccludeeF0D" */
+  /** Returns the string "GetOccludeeF0D" */
   string getName() const
   {
     return "GetViewMapGradientNormF0D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface0DIterator &iter);
 };
 
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
index 349db393e17..07ef0a7039c 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
@@ -35,7 +35,7 @@ namespace Freestyle {
 namespace Functions1D {
 
 // DensityF1D
-/*! Returns the density evaluated for an Interface1D.
+/** Returns the density evaluated for an Interface1D.
  *  The density is evaluated for a set of points along the Interface1D (using the DensityF0D
  * functor) with a user-defined sampling and then integrated into a single value using a
  * user-defined integration method.
@@ -45,7 +45,7 @@ class DensityF1D : public UnaryFunction1D<double> {
   float _sampling;
 
  public:
-  /*! Builds the functor.
+  /** Builds the functor.
    *  \param sigma:
    *    Thesigma used in DensityF0D and determining the window size used in each density query.
    *  \param iType:
@@ -61,18 +61,18 @@ class DensityF1D : public UnaryFunction1D<double> {
     _sampling = sampling;
   }
 
-  /*! Destructor */
+  /** Destructor */
   virtual ~DensityF1D()
   {
   }
 
-  /*! Returns the string "DensityF1D"*/
+  /** Returns the string "DensityF1D"*/
   string getName() const
   {
     return "DensityF1D";
   }
 
-  /*! the () operator.*/
+  /** the () operator.*/
   int operator()(Interface1D &inter)
   {
     result = integrate(
@@ -85,14 +85,14 @@ class DensityF1D : public UnaryFunction1D<double> {
 };
 
 // LocalAverageDepthF1D
-/*! Returns the average depth evaluated for an Interface1D.
+/** Returns the average depth evaluated for an Interface1D.
  *  The average depth is evaluated for a set of points along the Interface1D (using the
  * LocalAverageDepthF0D functor) with a user-defined sampling and then integrated into a single
  * value using a user-defined integration method.
  */
 class LocalAverageDepthF1D : public UnaryFunction1D<double> {
  public:
-  /*! Builds the functor.
+  /** Builds the functor.
    *  \param sigma:
    *    The sigma used in DensityF0D and determining the window size used in each density query.
    *  \param iType:
@@ -103,13 +103,13 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> {
   {
   }
 
-  /*! Returns the string "LocalAverageDepthF1D" */
+  /** Returns the string "LocalAverageDepthF1D" */
   string getName() const
   {
     return "LocalAverageDepthF1D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface1D &inter)
   {
     result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
@@ -121,14 +121,14 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> {
 };
 
 // GetCompleteViewMapDensity
-/*! Returns the density evaluated for an Interface1D in the complete viewmap image.
+/** Returns the density evaluated for an Interface1D in the complete viewmap image.
  *  The density is evaluated for a set of points along the Interface1D (using the
  * ReadCompleteViewMapPixelF0D functor) and then integrated into a single value using a
  * user-defined integration method.
  */
 class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
  public:
-  /*! Builds the functor.
+  /** Builds the functor.
    *  \param level:
    *    The level of the pyramid from which
    *    the pixel must be read.
@@ -147,13 +147,13 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
     _sampling = sampling;
   }
 
-  /*! Returns the string "GetCompleteViewMapDensityF1D" */
+  /** Returns the string "GetCompleteViewMapDensityF1D" */
   string getName() const
   {
     return "GetCompleteViewMapDensityF1D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface1D &inter);
 
  private:
@@ -162,7 +162,7 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
 };
 
 // GetDirectionalViewMapDensity
-/*! Returns the density evaluated for an Interface1D in of the steerable viewmaps image.
+/** Returns the density evaluated for an Interface1D in of the steerable viewmaps image.
  *  The direction telling which Directional map to choose is explicitly specified by the user.
  *  The density is evaluated for a set of points along the Interface1D
  *  (using the ReadSteerableViewMapPixelF0D functor)
@@ -170,7 +170,7 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
  */
 class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
  public:
-  /*! Builds the functor.
+  /** Builds the functor.
    *  \param iOrientation:
    *    The number of the directional map we must work with.
    *  \param level:
@@ -191,13 +191,13 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
     _sampling = sampling;
   }
 
-  /*! Returns the string "GetDirectionalViewMapDensityF1D" */
+  /** Returns the string "GetDirectionalViewMapDensityF1D" */
   string getName() const
   {
     return "GetDirectionalViewMapDensityF1D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface1D &inter);
 
  private:
@@ -206,7 +206,7 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
 };
 
 // GetSteerableViewMapDensityF1D
-/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
+/** Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
  * evaluated in the proper steerable ViewMap depending on its orientation.
  */
 class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
@@ -215,7 +215,7 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
   float _sampling;
 
  public:
-  /*! Builds the functor from the level of the pyramid from which the pixel must be read.
+  /** Builds the functor from the level of the pyramid from which the pixel must be read.
    *  \param level:
    *    The level of the pyramid from which the pixel must be read.
    *  \param iType:
@@ -232,23 +232,23 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
     _sampling = sampling;
   }
 
-  /*! Destructor */
+  /** Destructor */
   virtual ~GetSteerableViewMapDensityF1D()
   {
   }
 
-  /*! Returns the string "GetSteerableViewMapDensityF1D" */
+  /** Returns the string "GetSteerableViewMapDensityF1D" */
   string getName() const
   {
     return "GetSteerableViewMapDensityF1D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface1D &inter);
 };
 
 // GetViewMapGradientNormF1D
-/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
+/** Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
  * evaluated in the proper steerable ViewMap depending on its orientation.
  */
 class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
@@ -258,7 +258,7 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
   Functions0D::GetViewMapGradientNormF0D _func;
 
  public:
-  /*! Builds the functor from the level of the pyramid from which the pixel must be read.
+  /** Builds the functor from the level of the pyramid from which the pixel must be read.
    *  \param level:
    *    The level of the pyramid from which the pixel must be read.
    *  \param iType:
@@ -275,13 +275,13 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
     _sampling = sampling;
   }
 
-  /*! Returns the string "GetSteerableViewMapDensityF1D" */
+  /** Returns the string "GetSteerableViewMapDensityF1D" */
   string getName() const
   {
     return "GetViewMapGradientNormF1D";
   }
 
-  /*! the () operator. */
+  /** the () operator. */
   int operator()(Interface1D &inter);
 };
 
diff --git a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
index 25a5efcce34..d7c501e97ad 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
@@ -38,12 +38,12 @@ namespace Freestyle {
 namespace Predicates1D {
 
 // DensityLowerThanUP1D
-/*! Returns true if the density evaluated for the
+/** Returns true if the density evaluated for the
  *  Interface1D is less than a user-defined density value.
  */
 class DensityLowerThanUP1D : public UnaryPredicate1D {
  public:
-  /*! Builds the functor.
+  /** Builds the functor.
    *  \param threshold:
    *    The value of the threshold density.
    *    Any Interface1D having a density lower than this threshold will match.
@@ -56,13 +56,13 @@ class DensityLowerThanUP1D : public UnaryPredicate1D {
     _sigma = sigma;
   }
 
-  /*! Returns the string "DensityLowerThanUP1D" */
+  /** Returns the string "DensityLowerThanUP1D" */
   string getName() const
   {
     return "DensityLowerThanUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     Functions1D::DensityF1D fun(_sigma);
diff --git a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
index 63c7d451599..52cd037a73a 100644
--- a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
+++ b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
@@ -25,14 +25,14 @@
 
 namespace Freestyle {
 
-/*! [ Thickness Shader ].
+/** [ Thickness Shader ].
  *  Assigns thicknesses to the stroke vertices so that the stroke looks like made with a
  * calligraphic tool. i.e. The stroke will be the thickest in a main direction, the thinnest in the
  * direction perpendicular to this one, and an interpolation in between.
  */
 class CalligraphicShader : public StrokeShader {
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param iMinThickness:
    *    The minimum thickness in the direction perpendicular to the main direction.
    *  \param iMaxThickness:
@@ -47,12 +47,12 @@ class CalligraphicShader : public StrokeShader {
                      const Vec2f &iOrientation,
                      bool clamp);
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~CalligraphicShader()
   {
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &ioStroke) const;
 
  protected:
@@ -62,14 +62,14 @@ class CalligraphicShader : public StrokeShader {
   bool _clamp;
 };
 
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Spatial Noise stroke shader.
  *  Moves the vertices to make the stroke more noisy.
  * \see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly
  */
 class SpatialNoiseShader : public StrokeShader {
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param iAmount:
    *    The amplitude of the noise.
    *  \param ixScale:
@@ -83,12 +83,12 @@ class SpatialNoiseShader : public StrokeShader {
    */
   SpatialNoiseShader(float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom);
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~SpatialNoiseShader()
   {
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &ioStroke) const;
 
  protected:
@@ -99,7 +99,7 @@ class SpatialNoiseShader : public StrokeShader {
   bool _pureRandom;
 };
 
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Smooths the stroke.
  *  (Moves the vertices to make the stroke smoother).
  *  Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we
@@ -108,7 +108,7 @@ class SpatialNoiseShader : public StrokeShader {
  */
 class SmoothingShader : public StrokeShader {
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param iNbIteration:
    *    The number of iterations. (400)
    *  \param iFactorPoint:
@@ -135,12 +135,12 @@ class SmoothingShader : public StrokeShader {
                   real iAnisoCurvature,
                   real icarricatureFactor);
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~SmoothingShader()
   {
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &ioStroke) const;
 
  protected:
@@ -213,7 +213,7 @@ class Omitter : public Smoother {
   real _lengthFlat;
 };
 
-/*! Omission shader */
+/** Omission shader */
 class OmissionShader : public StrokeShader {
  public:
   OmissionShader(real sizeWindow, real thrVari, real thrFlat, real lFlat);
diff --git a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
index 0ac0aa09cf9..fcf661ea72f 100644
--- a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
+++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
@@ -47,12 +47,12 @@ namespace StrokeShaders {
 //
 //////////////////////////////////////////////////////
 
-/*! [ Thickness Shader ].
+/** [ Thickness Shader ].
  *  Assigns an absolute constant thickness to every vertices of the Stroke.
  */
 class ConstantThicknessShader : public StrokeShader {
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param thickness:
    *    The thickness that must be assigned to the stroke.
    */
@@ -61,18 +61,18 @@ class ConstantThicknessShader : public StrokeShader {
     _thickness = thickness;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~ConstantThicknessShader()
   {
   }
 
-  /*! Returns the string "ConstantThicknessShader".*/
+  /** Returns the string "ConstantThicknessShader".*/
   virtual string getName() const
   {
     return "ConstantThicknessShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 
  private:
@@ -106,7 +106,7 @@ class ConstantExternThicknessShader : public StrokeShader {
   float _thickness;
 };
 
-/*! [ Thickness Shader ].
+/** [ Thickness Shader ].
  *  Assigns thicknesses values such as the thickness increases from a thickness value A to a
  * thickness value B between the first vertex to the midpoint vertex and then decreases from B to a
  * A between this midpoint vertex and the last vertex. The thickness is linearly interpolated from
@@ -114,7 +114,7 @@ class ConstantExternThicknessShader : public StrokeShader {
  */
 class IncreasingThicknessShader : public StrokeShader {
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param iThicknessMin:
    *    The first thickness value.
    *  \param iThicknessMax:
@@ -126,7 +126,7 @@ class IncreasingThicknessShader : public StrokeShader {
     _ThicknessMax = iThicknessMax;
   }
 
-  /*! Destructor.*/
+  /** Destructor.*/
   virtual ~IncreasingThicknessShader()
   {
   }
@@ -136,7 +136,7 @@ class IncreasingThicknessShader : public StrokeShader {
     return "IncreasingThicknessShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 
  private:
@@ -144,7 +144,7 @@ class IncreasingThicknessShader : public StrokeShader {
   float _ThicknessMax;
 };
 
-/*! [ Thickness shader ].
+/** [ Thickness shader ].
  *  Same as previous but here we allow the user to control the ratio thickness/length so that  we
  * don't get fat short lines
  */
@@ -155,7 +155,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader {
   float _ratio;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param iThicknessMin:
    *    The first thickness value.
    *  \param iThicknessMax:
@@ -171,7 +171,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader {
     _ratio = iRatio;
   }
 
-  /*! Destructor.*/
+  /** Destructor.*/
   virtual ~ConstrainedIncreasingThicknessShader()
   {
   }
@@ -181,7 +181,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader {
     return "ConstrainedIncreasingThicknessShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 };
 
@@ -217,7 +217,7 @@ class LengthDependingThicknessShader : public StrokeShader {
   virtual int shade(Stroke &stroke) const;
 };
 
-/*!  [ Thickness Shader ].
+/**  [ Thickness Shader ].
  *   Adds some noise to the stroke thickness.
  *   \see \htmlonly <a href=noise/noise.html>noise/noise.html</a>\endhtmlonly
  */
@@ -229,7 +229,7 @@ class ThicknessNoiseShader : public StrokeShader {
  public:
   ThicknessNoiseShader();
 
-  /*! Builds a Thickness Noise Shader
+  /** Builds a Thickness Noise Shader
    *    \param iAmplitude:
    *      The amplitude of the noise signal
    *    \param iPeriod:
@@ -242,7 +242,7 @@ class ThicknessNoiseShader : public StrokeShader {
     return "ThicknessNoiseShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 };
 
@@ -250,12 +250,12 @@ class ThicknessNoiseShader : public StrokeShader {
 //  Color shaders
 //
 /////////////////////////////////////////////////////////
-/*!  [ Color Shader ].
+/**  [ Color Shader ].
  *   Assigns a constant color to every vertices of the Stroke.
  */
 class ConstantColorShader : public StrokeShader {
  public:
-  /*! Builds the shader from a user-specified color.
+  /** Builds the shader from a user-specified color.
    *  \param iR:
    *    The red component
    *  \param iG:
@@ -278,14 +278,14 @@ class ConstantColorShader : public StrokeShader {
     return "ConstantColorShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 
  private:
   float _color[4];
 };
 
-/*!  [ Color Shader ].
+/**  [ Color Shader ].
  *   Assigns a varying color to the stroke.
  *   The user specifies 2 colors A and B. The stroke color will change linearly from A to B between
  * the first and the last vertex.
@@ -296,7 +296,7 @@ class IncreasingColorShader : public StrokeShader {
   float _colorMax[4];
 
  public:
-  /*! Builds the shader from 2 user-specified colors.
+  /** Builds the shader from 2 user-specified colors.
    *  \param iRm:
    *    The first color red component
    *  \param iGm:
@@ -340,7 +340,7 @@ class IncreasingColorShader : public StrokeShader {
     return "IncreasingColorShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 };
 
@@ -366,7 +366,7 @@ class MaterialColorShader : public StrokeShader {
   virtual int shade(Stroke &stroke) const;
 };
 
-/*! [ Color Shader ].
+/** [ Color Shader ].
  *  Shader to add noise to the stroke colors.
  */
 class ColorNoiseShader : public StrokeShader {
@@ -377,7 +377,7 @@ class ColorNoiseShader : public StrokeShader {
  public:
   ColorNoiseShader();
 
-  /*! Builds a Color Noise Shader
+  /** Builds a Color Noise Shader
    *    \param iAmplitude:
    *      The amplitude of the noise signal
    *    \param iPeriod:
@@ -390,7 +390,7 @@ class ColorNoiseShader : public StrokeShader {
     return "ColorNoiseShader";
   }
 
-  /*! The shading method. */
+  /** The shading method. */
   virtual int shade(Stroke &stroke) const;
 };
 
@@ -398,7 +398,7 @@ class ColorNoiseShader : public StrokeShader {
 //  Geometry Shaders
 //
 ///////////////////////////////////////////////////////////////////////////////
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Stretches the stroke at its two extremities and following the respective directions: v(1)v(0)
  * and v(n-1)v(n).
  */
@@ -407,7 +407,7 @@ class BackboneStretcherShader : public StrokeShader {
   float _amount;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param iAmount:
    *    The stretching amount value.
    */
@@ -421,11 +421,11 @@ class BackboneStretcherShader : public StrokeShader {
     return "BackboneStretcherShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
-/*! [ Geometry Shader. ]
+/** [ Geometry Shader. ]
  *  Resamples the stroke.
  * \see Stroke::Resample(float).
  */
@@ -434,7 +434,7 @@ class SamplingShader : public StrokeShader {
   float _sampling;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param sampling:
    *    The sampling to use for the stroke resampling
    */
@@ -448,7 +448,7 @@ class SamplingShader : public StrokeShader {
     return "SamplingShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
@@ -471,7 +471,7 @@ class ExternalContourStretcherShader : public StrokeShader {
 };
 
 // Bezier curve stroke shader
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation
  * of the original backbone geometry. \see \htmlonly <a
  * href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
@@ -481,7 +481,7 @@ class BezierCurveShader : public StrokeShader {
   float _error;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \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.
@@ -496,11 +496,11 @@ class BezierCurveShader : public StrokeShader {
     return "BezierCurveShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Shader to modify the Stroke geometry so that it looks more "polygonal".
  *  The basic idea is to start from the minimal stroke approximation consisting in a line joining
  * the first vertex to the last one and to subdivide using the original stroke vertices until a
@@ -511,7 +511,7 @@ class PolygonalizationShader : public StrokeShader {
   float _error;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \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 original one.
@@ -527,11 +527,11 @@ class PolygonalizationShader : public StrokeShader {
     return "PolygonalizationShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Shader to modify the Stroke geometry so that it corresponds to its main direction line.
  *  This shader must be used together with the splitting operator using the curvature criterion.
  *  Indeed, the precision of the approximation will depend on the size of the stroke's pieces.
@@ -542,7 +542,7 @@ class GuidingLinesShader : public StrokeShader {
   float _offset;
 
  public:
-  /*! Builds a Guiding Lines shader
+  /** Builds a Guiding Lines shader
    *    \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
@@ -558,27 +558,27 @@ class GuidingLinesShader : public StrokeShader {
     return "GuidingLinesShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
-/*! [ Geometry Shader ].
+/** [ Geometry Shader ].
  *  Removes the stroke's extremities.
  */
 class TipRemoverShader : public StrokeShader {
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param tipLength:
    *    The length of the piece of stroke we want to remove at each extremity.
    */
   TipRemoverShader(real tipLength);
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~TipRemoverShader()
   {
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual string getName() const
   {
     return "TipRemoverShader";
@@ -590,7 +590,7 @@ class TipRemoverShader : public StrokeShader {
   real _tipLength;
 };
 
-/*! [ Texture Shader ].
+/** [ Texture Shader ].
  *  Shader to assign texture to the Stroke material.
  */
 
@@ -600,7 +600,7 @@ class BlenderTextureShader : public StrokeShader {
   bNodeTree *_nodeTree;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param mtex:
    *    The blender texture to use.
    */
@@ -610,7 +610,7 @@ class BlenderTextureShader : public StrokeShader {
     _nodeTree = NULL;
   }
 
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param nodetree:
    *    A node tree (of new shading nodes) to define textures.
    */
@@ -625,11 +625,11 @@ class BlenderTextureShader : public StrokeShader {
     return "BlenderTextureShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
-/*! [ Texture Shader ].
+/** [ Texture Shader ].
  *  Shader to assign texture to the Stroke material.
  */
 
@@ -638,7 +638,7 @@ class StrokeTextureStepShader : public StrokeShader {
   float _step;
 
  public:
-  /*! Builds the shader.
+  /** Builds the shader.
    *  \param id:
    *    The number of the preset to use.
    */
@@ -652,7 +652,7 @@ class StrokeTextureStepShader : public StrokeShader {
     return "StrokeTextureStepShader";
   }
 
-  /*! The shading method */
+  /** The shading method */
   virtual int shade(Stroke &stroke) const;
 };
 
diff --git a/source/blender/freestyle/intern/stroke/Canvas.h b/source/blender/freestyle/intern/stroke/Canvas.h
index 91676946b5d..8d71cd534ec 100644
--- a/source/blender/freestyle/intern/stroke/Canvas.h
+++ b/source/blender/freestyle/intern/stroke/Canvas.h
@@ -60,12 +60,12 @@ class ImagePyramid;
 class SteerableViewMap;
 class StyleModule;
 
-/*! Class to define the canvas on which strokes are drawn.
+/** Class to define the canvas on which strokes are drawn.
  *  It's used to store state information about the drawing.
  */
 class Canvas {
  public:
-  /*! Returns a pointer on the Canvas instance */
+  /** Returns a pointer on the Canvas instance */
   static Canvas *getInstance()
   {
     return _pInstance;
@@ -136,7 +136,7 @@ class Canvas {
   }
 
   /* Maps management */
-  /*! Loads an image map. The map will be scaled
+  /** 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:
@@ -152,7 +152,7 @@ class Canvas {
                unsigned iNbLevels = 4,
                float iSigma = 1.0f);
 
-  /*! Reads a pixel value in a map.
+  /** Reads a pixel value in a map.
    *  Returns a value between 0 and 1.
    *  \param iMapName:
    *    The name of the map
@@ -167,19 +167,19 @@ class Canvas {
    */
   float readMapPixel(const char *iMapName, int level, int x, int y);
 
-  /*! Sets the steerable viewmap */
+  /** Sets the steerable viewmap */
   void loadSteerableViewMap(SteerableViewMap *iSVM)
   {
     _steerableViewMap = iSVM;
   }
 
-  /*! Returns the steerable VM */
+  /** Returns the steerable VM */
   SteerableViewMap *getSteerableViewMap()
   {
     return _steerableViewMap;
   }
 
-  /*! accessors */
+  /** accessors */
   inline const FEdge *selectedFEdge() const
   {
     return _SelectedFEdge;
@@ -215,13 +215,13 @@ class Canvas {
     return stroke_count;
   }
 
-  /*! modifiers */
+  /** modifiers */
   inline void setSelectedFEdge(FEdge *iFEdge)
   {
     _SelectedFEdge = iFEdge;
   }
 
-  /*! inserts a shader at pos index+1 */
+  /** inserts a shader at pos index+1 */
   void PushBackStyleModule(StyleModule *iStyleModule);
   void InsertStyleModule(unsigned index, StyleModule *iStyleModule);
   void RemoveStyleModule(unsigned index);
diff --git a/source/blender/freestyle/intern/stroke/Chain.h b/source/blender/freestyle/intern/stroke/Chain.h
index d5dae5c35ba..bcc6957b714 100644
--- a/source/blender/freestyle/intern/stroke/Chain.h
+++ b/source/blender/freestyle/intern/stroke/Chain.h
@@ -27,7 +27,7 @@
 
 namespace Freestyle {
 
-/*! Class to represent a 1D elements issued from the chaining process.
+/** Class to represent a 1D elements issued from the chaining process.
  *  A Chain is the last step before the Stroke and is used in the Splitting and Creation processes.
  */
 class Chain : public Curve {
@@ -38,28 +38,28 @@ class Chain : public Curve {
       _fedgeB;  // the last FEdge of the ViewEdge passed to the last call for push_viewedge_back().
 
  public:
-  /*! Default constructor. */
+  /** Default constructor. */
   Chain() : Curve()
   {
     _splittingId = 0;
     _fedgeB = 0;
   }
 
-  /*! Builds a chain from its Id. */
+  /** Builds a chain from its Id. */
   Chain(const Id &id) : Curve(id)
   {
     _splittingId = 0;
     _fedgeB = 0;
   }
 
-  /*! Copy Constructor */
+  /** Copy Constructor */
   Chain(const Chain &iBrother) : Curve(iBrother)
   {
     _splittingId = iBrother._splittingId;
     _fedgeB = iBrother._fedgeB;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~Chain()
   {
     // only the last splitted deletes this id
@@ -70,13 +70,13 @@ class Chain : public Curve {
     }
   }
 
-  /*! Returns the string "Chain" */
+  /** Returns the string "Chain" */
   virtual string getExactTypeName() const
   {
     return "Chain";
   }
 
-  /*! Adds a ViewEdge at the end of the chain
+  /** Adds a ViewEdge at the end of the chain
    *  \param iViewEdge:
    *    The ViewEdge that must be added.
    *  \param orientation:
@@ -84,7 +84,7 @@ class Chain : public Curve {
    */
   void push_viewedge_back(ViewEdge *iViewEdge, bool orientation);
 
-  /*! Adds a ViewEdge at the beginning of the chain
+  /** Adds a ViewEdge at the beginning of the chain
    *  \param iViewEdge:
    *    The ViewEdge that must be added.
    *  \param orientation:
diff --git a/source/blender/freestyle/intern/stroke/ChainingIterators.h b/source/blender/freestyle/intern/stroke/ChainingIterators.h
index 0a9e7114ecb..c0259471277 100644
--- a/source/blender/freestyle/intern/stroke/ChainingIterators.h
+++ b/source/blender/freestyle/intern/stroke/ChainingIterators.h
@@ -98,11 +98,11 @@ class AdjacencyIterator : public Iterator {
     return _internalIterator.isBegin();
   }
 
-  /*! Returns true if the current ViewEdge is coming towards the iteration vertex.
+  /** Returns true if the current ViewEdge is coming towards the iteration vertex.
    * False otherwise. */
   bool isIncoming() const;
 
-  /*! Returns a *pointer* to the pointed ViewEdge. */
+  /** Returns a *pointer* to the pointed ViewEdge. */
   virtual ViewEdge *operator*();
 
   virtual ViewEdge *operator->()
@@ -140,7 +140,7 @@ class AdjacencyIterator : public Iterator {
 //
 ///////////////////////////////////////////////////////////
 
-/*! Base class for chaining iterators.
+/** Base class for chaining iterators.
  *  This class is designed to be overloaded in order to describe chaining rules.
  *  It makes the works of chaining rules description easier.
  *  The two main methods that need to overloaded are traverse() and init().
@@ -159,7 +159,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
   ViewEdge *result;
   void *py_c_it;
 
-  /*! Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation.
+  /** Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation.
    *  \param iRestrictToSelection:
    *    Indicates whether to force the chaining to stay within
    *    the set of selected ViewEdges or not.
@@ -183,7 +183,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
     py_c_it = NULL;
   }
 
-  /*! Copy constructor */
+  /** Copy constructor */
   ChainingIterator(const ChainingIterator &brother) : ViewEdgeIterator(brother)
   {
     _restrictToSelection = brother._restrictToSelection;
@@ -192,19 +192,19 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
     py_c_it = brother.py_c_it;
   }
 
-  /*! Returns the string "ChainingIterator" */
+  /** Returns the string "ChainingIterator" */
   virtual string getExactTypeName() const
   {
     return "ChainingIterator";
   }
 
-  /*! Inits the iterator context.
+  /** Inits the iterator context.
    *  This method is called each time a new chain is started.
    *  It can be used to reset some history information that you might want to keep.
    */
   virtual int init();
 
-  /*! This method iterates over the potential next ViewEdges and returns the one that will be
+  /** 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:
    *    The iterator over the ViewEdges adjacent to the end vertex of the current ViewEdge.
@@ -214,11 +214,11 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
   virtual int traverse(const AdjacencyIterator &it);
 
   /* accessors */
-  /*! Returns true if the orientation of the current ViewEdge corresponds to its natural
+  /** Returns true if the orientation of the current ViewEdge corresponds to its natural
    * orientation */
   // inline bool getOrientation() const {}
 
-  /*! Returns the vertex which is the next crossing */
+  /** Returns the vertex which is the next crossing */
   inline ViewVertex *getVertex()
   {
     if (_increment) {
@@ -239,7 +239,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
     }
   }
 
-  /*! Returns true if the current iteration is an incrementation */
+  /** Returns true if the current iteration is an incrementation */
   inline bool isIncrementing() const
   {
     return _increment;
@@ -255,7 +255,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
 //
 ///////////////////////////////////////////////////////////
 
-/*! A ViewEdge Iterator used to follow ViewEdges the most naturally.
+/** A ViewEdge Iterator used to follow ViewEdges the most naturally.
  *  For example, it will follow visible ViewEdges of same nature.
  *  As soon, as the nature or the visibility changes, the iteration stops (by setting the pointed
  *  ViewEdge to 0). In the case of an iteration over a set of ViewEdge that are both Silhouette
@@ -263,7 +263,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
  */
 class ChainSilhouetteIterator : public ChainingIterator {
  public:
-  /*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its
+  /** Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its
    *  orientation.
    *  \param iRestrictToSelection:
    *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or
@@ -282,24 +282,24 @@ class ChainSilhouetteIterator : public ChainingIterator {
   {
   }
 
-  /*! Copy constructor */
+  /** Copy constructor */
   ChainSilhouetteIterator(const ChainSilhouetteIterator &brother) : ChainingIterator(brother)
   {
   }
 
-  /*! Returns the string "ChainSilhouetteIterator" */
+  /** Returns the string "ChainSilhouetteIterator" */
   virtual string getExactTypeName() const
   {
     return "ChainSilhouetteIterator";
   }
 
-  /*! This method iterates over the potential next ViewEdges and returns the one that will be
+  /** This method iterates over the potential next ViewEdges and returns the one that will be
    *  followed next.
    *  When reaching the end of a chain, 0 is returned.
    */
   virtual int traverse(const AdjacencyIterator &it);
 
-  /*! Inits the iterator context */
+  /** Inits the iterator context */
   virtual int init()
   {
     return 0;
@@ -311,7 +311,7 @@ class ChainSilhouetteIterator : public ChainingIterator {
 //
 ///////////////////////////////////////////////////////////
 
-/*! A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a
+/** A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a
  *  unary predicate and a binary predicate.
  *  First, the unary predicate is evaluated for all potential next ViewEdges in order to only
  *  keep the ones respecting a certain constraint.
@@ -327,7 +327,7 @@ class ChainPredicateIterator : public ChainingIterator {
   UnaryPredicate1D *_unary_predicate;  // the caller is responsible for the deletion of this object
 
  public:
-  /*! Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
+  /** Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
    *  \param iRestrictToSelection:
    *    Indicates whether to force the chaining to stay
    *    within the set of selected ViewEdges or not.
@@ -350,7 +350,7 @@ class ChainPredicateIterator : public ChainingIterator {
     _unary_predicate = 0;
   }
 
-  /*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting
+  /** Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting
    *  ViewEdge and its orientation.
    *  \param iRestrictToSelection:
    *    Indicates whether to force the chaining to stay
@@ -381,32 +381,32 @@ class ChainPredicateIterator : public ChainingIterator {
     _binary_predicate = &bpred;
   }
 
-  /*! Copy constructor */
+  /** Copy constructor */
   ChainPredicateIterator(const ChainPredicateIterator &brother) : ChainingIterator(brother)
   {
     _unary_predicate = brother._unary_predicate;
     _binary_predicate = brother._binary_predicate;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~ChainPredicateIterator()
   {
     _unary_predicate = 0;
     _binary_predicate = 0;
   }
 
-  /*! Returns the string "ChainPredicateIterator" */
+  /** Returns the string "ChainPredicateIterator" */
   virtual string getExactTypeName() const
   {
     return "ChainPredicateIterator";
   }
 
-  /*! This method iterates over the potential next ViewEdges and returns the one that will be
+  /** This method iterates over the potential next ViewEdges and returns the one that will be
    *  followed next. When reaching the end of a chain, 0 is returned.
    */
   virtual int traverse(const AdjacencyIterator &it);
 
-  /*! Inits the iterator context */
+  /** Inits the iterator context */
   virtual int init()
   {
     return 0;
diff --git a/source/blender/freestyle/intern/stroke/ContextFunctions.h b/source/blender/freestyle/intern/stroke/ContextFunctions.h
index 334bdd657c1..4878d2a6c54 100644
--- a/source/blender/freestyle/intern/stroke/ContextFunctions.h
+++ b/source/blender/freestyle/intern/stroke/ContextFunctions.h
@@ -33,34 +33,34 @@ namespace Freestyle {
 // Context Functions definitions
 //
 ///////////////////////////////////////////////////////////
-/*! namespace containing all the Context related functions */
+/** namespace containing all the Context related functions */
 namespace ContextFunctions {
 
 // GetTimeStamp
-/*! Returns the system time stamp */
+/** Returns the system time stamp */
 unsigned GetTimeStampCF();
 
 // GetCanvasWidth
-/*! Returns the canvas width */
+/** Returns the canvas width */
 unsigned GetCanvasWidthCF();
 
 // GetCanvasHeight
-/*! Returns the canvas height */
+/** Returns the canvas height */
 unsigned GetCanvasHeightCF();
 
 // GetBorder
-/*! Returns the border */
+/** Returns the border */
 BBox<Vec2i> GetBorderCF();
 
 // Load map
-/*! Loads an image map for further reading */
+/** Loads an image map for further reading */
 void LoadMapCF(const char *iFileName,
                const char *iMapName,
                unsigned iNbLevels = 4,
                float iSigma = 1.0f);
 
 // ReadMapPixel
-/*! Reads a pixel in a user-defined map
+/** Reads a pixel in a user-defined map
  * \return the floating value stored for that pixel
  * \param iMapName:
  *    The name of the map
@@ -74,7 +74,7 @@ void LoadMapCF(const char *iFileName,
 float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
 
 // ReadCompleteViewMapPixel
-/*! Reads a pixel in the complete view map
+/** Reads a pixel in the complete view map
  * \return the floating value stored for that pixel
  * \param level:
  *    The level of the pyramid in which we wish to read the pixel
@@ -86,7 +86,7 @@ float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
 float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y);
 
 // ReadOrientedViewMapPixel
-/*! Reads a pixel in one of the oriented view map images
+/** Reads a pixel in one of the oriented view map images
  * \return the floating value stored for that pixel
  * \param iOrientation:
  *    The number telling which orientation we want to check
diff --git a/source/blender/freestyle/intern/stroke/Curve.cpp b/source/blender/freestyle/intern/stroke/Curve.cpp
index 768e9efa15d..08d7a0b792a 100644
--- a/source/blender/freestyle/intern/stroke/Curve.cpp
+++ b/source/blender/freestyle/intern/stroke/Curve.cpp
@@ -573,7 +573,7 @@ Curve::~Curve()
   }
 }
 
-/*! iterators access */
+/** iterators access */
 Curve::point_iterator Curve::points_begin(float step)
 {
   vertex_container::iterator second = _Vertices.begin();
diff --git a/source/blender/freestyle/intern/stroke/Curve.h b/source/blender/freestyle/intern/stroke/Curve.h
index f0db45150a9..cce5353a5c7 100644
--- a/source/blender/freestyle/intern/stroke/Curve.h
+++ b/source/blender/freestyle/intern/stroke/Curve.h
@@ -52,7 +52,7 @@ using namespace Geometry;
 /*                                */
 /**********************************/
 
-/*! Class to represent a point of a curve.
+/** Class to represent a point of a curve.
  *  A CurvePoint can be any point of a 1D curve (it doesn't have to be a vertex of the curve).
  *  Any Interface1D is built upon ViewEdges, themselves built upon FEdges. Therefore, a curve is
  * basically a polyline made of a list SVertex. Thus, a CurvePoint is built by linearly
@@ -61,56 +61,56 @@ using namespace Geometry;
  */
 class CurvePoint : public Interface0D {
  public:  // Implementation of Interface0D
-  /*! Returns the string "CurvePoint"*/
+  /** Returns the string "CurvePoint"*/
   virtual string getExactTypeName() const
   {
     return "CurvePoint";
   }
 
   // Data access methods
-  /*! Returns the 3D X coordinate of the point */
+  /** Returns the 3D X coordinate of the point */
   virtual real getX() const
   {
     return _Point3d.x();
   }
 
-  /*! Returns the 3D Y coordinate of the point */
+  /** Returns the 3D Y coordinate of the point */
   virtual real getY() const
   {
     return _Point3d.y();
   }
 
-  /*! Returns the 3D Z coordinate of the point */
+  /** Returns the 3D Z coordinate of the point */
   virtual real getZ() const
   {
     return _Point3d.z();
   }
 
-  /*!  Returns the 3D point. */
+  /**  Returns the 3D point. */
   virtual Vec3r getPoint3D() const
   {
     return _Point3d;
   }
 
-  /*! Returns the projected 3D X coordinate of the point */
+  /** Returns the projected 3D X coordinate of the point */
   virtual real getProjectedX() const
   {
     return _Point2d.x();
   }
 
-  /*! Returns the projected 3D Y coordinate of the point */
+  /** Returns the projected 3D Y coordinate of the point */
   virtual real getProjectedY() const
   {
     return _Point2d.y();
   }
 
-  /*! Returns the projected 3D Z coordinate of the point */
+  /** Returns the projected 3D Z coordinate of the point */
   virtual real getProjectedZ() const
   {
     return _Point2d.z();
   }
 
-  /*!  Returns the 2D point. */
+  /**  Returns the 2D point. */
   virtual Vec2r getPoint2D() const
   {
     return Vec2r(_Point2d.x(), _Point2d.y());
@@ -118,7 +118,7 @@ class CurvePoint : public Interface0D {
 
   virtual FEdge *getFEdge(Interface0D &inter);
 
-  /*! Returns the CurvePoint's Id */
+  /** Returns the CurvePoint's Id */
   virtual Id getId() const
   {
     Id id;
@@ -131,7 +131,7 @@ class CurvePoint : public Interface0D {
     return id;
   }
 
-  /*! Returns the CurvePoint's Nature */
+  /** Returns the CurvePoint's Nature */
   virtual Nature::VertexNature getNature() const
   {
     Nature::VertexNature nature = Nature::POINT;
@@ -144,7 +144,7 @@ class CurvePoint : public Interface0D {
     return nature;
   }
 
-  /*! Cast the Interface0D in SVertex if it can be. */
+  /** Cast the Interface0D in SVertex if it can be. */
   virtual SVertex *castToSVertex()
   {
     if (_t2d == 0) {
@@ -156,7 +156,7 @@ class CurvePoint : public Interface0D {
     return Interface0D::castToSVertex();
   }
 
-  /*! Cast the Interface0D in ViewVertex if it can be. */
+  /** Cast the Interface0D in ViewVertex if it can be. */
   virtual ViewVertex *castToViewVertex()
   {
     if (_t2d == 0) {
@@ -168,7 +168,7 @@ class CurvePoint : public Interface0D {
     return Interface0D::castToViewVertex();
   }
 
-  /*! Cast the Interface0D in NonTVertex if it can be. */
+  /** Cast the Interface0D in NonTVertex if it can be. */
   virtual NonTVertex *castToNonTVertex()
   {
     if (_t2d == 0) {
@@ -180,7 +180,7 @@ class CurvePoint : public Interface0D {
     return Interface0D::castToNonTVertex();
   }
 
-  /*! Cast the Interface0D in TVertex if it can be. */
+  /** Cast the Interface0D in TVertex if it can be. */
   virtual TVertex *castToTVertex()
   {
     if (_t2d == 0) {
@@ -204,10 +204,10 @@ class CurvePoint : public Interface0D {
   Vec3r _Point3d;
 
  public:
-  /*! Default Constructor. */
+  /** Default Constructor. */
   CurvePoint();
 
-  /*! Builds a CurvePoint from two SVertex and an interpolation parameter.
+  /** Builds a CurvePoint from two SVertex and an interpolation parameter.
    *  \param iA:
    *    The first SVertex
    *  \param iB:
@@ -217,7 +217,7 @@ class CurvePoint : public Interface0D {
    */
   CurvePoint(SVertex *iA, SVertex *iB, float t);
 
-  /*! Builds a CurvePoint from two CurvePoint and an interpolation parameter.
+  /** Builds a CurvePoint from two CurvePoint and an interpolation parameter.
    *  \param iA:
    *    The first CurvePoint
    *  \param iB:
@@ -229,35 +229,35 @@ class CurvePoint : public Interface0D {
 
   // CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d);
 
-  /*! Copy Constructor. */
+  /** Copy Constructor. */
   CurvePoint(const CurvePoint &iBrother);
 
-  /*! Operator = */
+  /** Operator = */
   CurvePoint &operator=(const CurvePoint &iBrother);
 
-  /*! Destructor */
+  /** Destructor */
   virtual ~CurvePoint() = default;
 
-  /*! Operator == */
+  /** Operator == */
   bool operator==(const CurvePoint &b)
   {
     return ((__A == b.__A) && (__B == b.__B) && (_t2d == b._t2d));
   }
 
   /* accessors */
-  /*! Returns the first SVertex upon which the CurvePoint is built. */
+  /** Returns the first SVertex upon which the CurvePoint is built. */
   inline SVertex *A()
   {
     return __A;
   }
 
-  /*! Returns the second SVertex upon which the CurvePoint is built. */
+  /** Returns the second SVertex upon which the CurvePoint is built. */
   inline SVertex *B()
   {
     return __B;
   }
 
-  /*! Returns the interpolation parameter. */
+  /** Returns the interpolation parameter. */
   inline float t2d() const
   {
     return _t2d;
@@ -271,19 +271,19 @@ class CurvePoint : public Interface0D {
 #endif
 
   /* modifiers */
-  /*! Sets the first SVertex upon which to build the CurvePoint. */
+  /** Sets the first SVertex upon which to build the CurvePoint. */
   inline void setA(SVertex *iA)
   {
     __A = iA;
   }
 
-  /*! Sets the second SVertex upon which to build the CurvePoint. */
+  /** Sets the second SVertex upon which to build the CurvePoint. */
   inline void setB(SVertex *iB)
   {
     __B = iB;
   }
 
-  /*! Sets the 2D interpolation parameter to use. */
+  /** Sets the 2D interpolation parameter to use. */
   inline void setT2d(float t)
   {
     _t2d = t;
@@ -339,7 +339,7 @@ class CurvePoint : public Interface0D {
   }
 
   Vec3r curvature2d_as_vector() const;
-  /*! angle in radians */
+  /** angle in radians */
   real curvature2d_as_angle() const;
 
   real curvatureFredo() const;
@@ -368,7 +368,7 @@ class CurvePointIterator;
 
 }  // end of namespace CurveInternal
 
-/*! Base class for curves made of CurvePoints.
+/** Base class for curves made of CurvePoints.
  *  SVertex is the type of the initial curve vertices.
  *  A Chain is a specialization of a Curve.
  */
@@ -396,7 +396,7 @@ class Curve : public Interface1D {
   unsigned _nSegments;  // number of segments
 
  public:
-  /*! Default Constructor. */
+  /** Default Constructor. */
   Curve()
   {
     _Length = 0;
@@ -404,7 +404,7 @@ class Curve : public Interface1D {
     _nSegments = 0;
   }
 
-  /*! Builds a Curve from its id */
+  /** Builds a Curve from its id */
   Curve(const Id &id)
   {
     _Length = 0;
@@ -412,7 +412,7 @@ class Curve : public Interface1D {
     _nSegments = 0;
   }
 
-  /*! Copy Constructor. */
+  /** Copy Constructor. */
   Curve(const Curve &iBrother)
   {
     _Length = iBrother._Length;
@@ -421,10 +421,10 @@ class Curve : public Interface1D {
     _nSegments = 0;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~Curve();
 
-  /*! Returns the string "Curve" */
+  /** Returns the string "Curve" */
   virtual string getExactTypeName() const
   {
     return "Curve";
@@ -435,7 +435,7 @@ class Curve : public Interface1D {
   void computeCurvatureAndOrientation();
 #endif
 
-  /*! Adds a single vertex (CurvePoint) at the end of the Curve */
+  /** Adds a single vertex (CurvePoint) at the end of the Curve */
   inline void push_vertex_back(Vertex *iVertex)
   {
     if (!_Vertices.empty()) {
@@ -447,7 +447,7 @@ class Curve : public Interface1D {
     _Vertices.push_back(new_vertex);
   }
 
-  /*! Adds a single vertex (SVertex) at the end of the Curve */
+  /** Adds a single vertex (SVertex) at the end of the Curve */
   inline void push_vertex_back(SVertex *iVertex)
   {
     if (!_Vertices.empty()) {
@@ -459,7 +459,7 @@ class Curve : public Interface1D {
     _Vertices.push_back(new_vertex);
   }
 
-  /*! Adds a single vertex (CurvePoint) at the front of the Curve */
+  /** Adds a single vertex (CurvePoint) at the front of the Curve */
   inline void push_vertex_front(Vertex *iVertex)
   {
     if (!_Vertices.empty()) {
@@ -471,7 +471,7 @@ class Curve : public Interface1D {
     _Vertices.push_front(new_vertex);
   }
 
-  /*! Adds a single vertex (SVertex) at the front of the Curve */
+  /** Adds a single vertex (SVertex) at the front of the Curve */
   inline void push_vertex_front(SVertex *iVertex)
   {
     if (!_Vertices.empty()) {
@@ -483,25 +483,25 @@ class Curve : public Interface1D {
     _Vertices.push_front(new_vertex);
   }
 
-  /*! Returns true is the Curve doesn't have any Vertex yet. */
+  /** Returns true is the Curve doesn't have any Vertex yet. */
   inline bool empty() const
   {
     return _Vertices.empty();
   }
 
-  /*! Returns the 2D length of the Curve. */
+  /** Returns the 2D length of the Curve. */
   inline real getLength2D() const
   {
     return _Length;
   }
 
-  /*! Returns the Id of the 1D element. */
+  /** Returns the Id of the 1D element. */
   virtual Id getId() const
   {
     return _Id;
   }
 
-  /*! Returns the number of segments in the polyline constituting the Curve. */
+  /** Returns the number of segments in the polyline constituting the Curve. */
   inline unsigned int nSegments() const
   {
     return _nSegments;
@@ -549,7 +549,7 @@ class Curve : public Interface1D {
   float local_depth_variance(int iCombination = 0) const;
   real local_average_density(float sigma = 2.3f, int iCombination = 0) const;
   Vec3r curvature2d_as_vector(int iCombination = 0) const;
-  /*! angle in radians */
+  /** angle in radians */
   real curvature2d_as_angle(int iCombination = 0) const;
 #endif
 
@@ -573,23 +573,23 @@ class Curve : public Interface1D {
   CurveInternal::CurvePointIterator curveVerticesEnd();
 
   // Iterators access
-  /*! Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can
+  /** Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can
    * iterate over the \a vertices of the Curve.
    */
   virtual Interface0DIterator verticesBegin();
 
-  /*! Returns an Interface0DIterator pointing after the last vertex of the Curve and that can
+  /** Returns an Interface0DIterator pointing after the last vertex of the Curve and that can
    * iterate over the \a vertices of the Curve.
    */
   virtual Interface0DIterator verticesEnd();
 
-  /*! Returns an Interface0DIterator pointing onto the first point of the Curve and that can
+  /** Returns an Interface0DIterator pointing onto the first point of the Curve and that can
    * iterate over the \a points of the Curve at any resolution. At each iteration a virtual
    * temporary CurvePoint is created.
    */
   virtual Interface0DIterator pointsBegin(float t = 0.0f);
 
-  /*! Returns an Interface0DIterator pointing after the last point of the Curve and that can
+  /** Returns an Interface0DIterator pointing after the last point of the Curve and that can
    * iterate over the \a points of the Curve at any resolution. At each iteration a virtual
    * temporary CurvePoint is created.
    */
diff --git a/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h b/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
index 1896a674477..5cb5ab69711 100644
--- a/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
+++ b/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
@@ -50,7 +50,7 @@ class CurvePoint_nonconst_traits : public Nonconst_traits<CurvePoint *> {
 /*                                */
 /**********************************/
 
-/*! iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is
+/** iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is
  * instantiated and returned when the iterator is dereferenced.
  */
 template<class Traits>
diff --git a/source/blender/freestyle/intern/stroke/CurveIterators.h b/source/blender/freestyle/intern/stroke/CurveIterators.h
index 9d1cf33ed80..abbde02979d 100644
--- a/source/blender/freestyle/intern/stroke/CurveIterators.h
+++ b/source/blender/freestyle/intern/stroke/CurveIterators.h
@@ -28,7 +28,7 @@ namespace Freestyle {
 
 namespace CurveInternal {
 
-/*! iterator on a curve. Allows an iterating outside
+/** iterator on a curve. Allows an iterating outside
  *  initial vertices. A CurvePoint is instantiated an returned
  *  when the iterator is dereferenced.
  */
diff --git a/source/blender/freestyle/intern/stroke/Modifiers.h b/source/blender/freestyle/intern/stroke/Modifiers.h
index 0aac6f58658..1952659dab7 100644
--- a/source/blender/freestyle/intern/stroke/Modifiers.h
+++ b/source/blender/freestyle/intern/stroke/Modifiers.h
@@ -35,16 +35,16 @@ namespace Freestyle {
  *                                           *
  * ----------------------------------------- */
 
-/*! Base class for modifiers.
+/** Base class for modifiers.
  *  Modifiers are used in the Operators in order to "mark" the processed Interface1D.
  */
 template<class Edge> struct EdgeModifier : public unary_function<Edge, void> {
-  /*! Default construction */
+  /** Default construction */
   EdgeModifier() : unary_function<Edge, void>()
   {
   }
 
-  /*! the () operator */
+  /** the () operator */
   virtual void operator()(Edge &iEdge)
   {
   }
@@ -54,14 +54,14 @@ template<class Edge> struct EdgeModifier : public unary_function<Edge, void> {
 #endif
 };
 
-/*! Modifier that sets the time stamp of an Interface1D to the time stamp of the system. */
+/** Modifier that sets the time stamp of an Interface1D to the time stamp of the system. */
 template<class Edge> struct TimestampModifier : public EdgeModifier<Edge> {
-  /*! Default constructor */
+  /** Default constructor */
   TimestampModifier() : EdgeModifier<Edge>()
   {
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   virtual void operator()(Edge &iEdge)
   {
     TimeStamp *timestamp = TimeStamp::instance();
diff --git a/source/blender/freestyle/intern/stroke/Operators.h b/source/blender/freestyle/intern/stroke/Operators.h
index e721e9fb837..4de331993f7 100644
--- a/source/blender/freestyle/intern/stroke/Operators.h
+++ b/source/blender/freestyle/intern/stroke/Operators.h
@@ -41,7 +41,7 @@
 
 namespace Freestyle {
 
-/*! Class defining the operators used in a style module.
+/** Class defining the operators used in a style module.
  *  There are 4 classes of operators: Selection, Chaining, Splitting and Creating.
  *  All these operators are user controlled in the scripting language through Functors, Predicates
  *  and Shaders that are taken as arguments.
@@ -57,12 +57,12 @@ class Operators {
   //
   ////////////////////////////////////////////////
 
-  /*! Selects the ViewEdges of the ViewMap verifying a specified condition.
+  /** Selects the ViewEdges of the ViewMap verifying a specified condition.
    *  \param pred: The predicate expressing this condition
    */
   static int select(UnaryPredicate1D &pred);
 
-  /*! Builds a set of chains from the current set of ViewEdges.
+  /** Builds a set of chains from the current set of ViewEdges.
    *  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.
@@ -80,7 +80,7 @@ class Operators {
                    UnaryPredicate1D &pred,
                    UnaryFunction1D_void &modifier);
 
-  /*! Builds a set of chains from the current set of ViewEdges.
+  /** Builds a set of chains from the current set of ViewEdges.
    *  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.
@@ -95,7 +95,7 @@ class Operators {
    */
   static int chain(ViewEdgeInternal::ViewEdgeIterator &it, UnaryPredicate1D &pred);
 
-  /*! Builds a set of chains from the current set of ViewEdges.
+  /** Builds a set of chains from the current set of ViewEdges.
    *  Each ViewEdge of the current list potentially starts a new chain. The chaining operator then
    *  iterates over the ViewEdges of the ViewMap using the user specified iterator.
    *  This operator iterates both using the increment and decrement operators and is therefore
@@ -111,7 +111,7 @@ class Operators {
    */
   static int bidirectionalChain(ChainingIterator &it, UnaryPredicate1D &pred);
 
-  /*! The only difference with the above bidirectional chaining algorithm is that we don't need to
+  /** The only difference with the above bidirectional chaining algorithm is that we don't need to
    *  pass a stopping criterion. This might be desirable when the stopping criterion is already
    *  contained in the iterator definition. Builds a set of chains from the current set of
    *  ViewEdges. Each ViewEdge of the current list potentially starts a new chain. The chaining
@@ -127,7 +127,7 @@ class Operators {
    */
   static int bidirectionalChain(ChainingIterator &it);
 
-  /*! Splits each chain of the current set of chains in a sequential way.
+  /** Splits each chain of the current set of chains in a sequential way.
    *  The points of each chain are processed (with a specified sampling) sequentially.
    *  Each time a user specified starting condition is verified, a new chain begins and ends as
    *  soon as a user-defined stopping predicate is verified.
@@ -147,7 +147,7 @@ class Operators {
                              UnaryPredicate0D &stoppingPred,
                              float sampling = 0.0f);
 
-  /*! Splits each chain of the current set of chains in a sequential way.
+  /** Splits each chain of the current set of chains in a sequential way.
    *  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
@@ -160,7 +160,7 @@ class Operators {
    */
   static int sequentialSplit(UnaryPredicate0D &pred, float sampling = 0.0f);
 
-  /*! Splits the current set of chains in a recursive way.
+  /** Splits the current set of chains in a recursive way.
    *  We process the points of each chain (with a specified sampling) to find the point
    *  minimizing a specified 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
@@ -181,7 +181,7 @@ class Operators {
                             UnaryPredicate1D &pred,
                             float sampling = 0);
 
-  /*! Splits the current set of chains in a recursive way.
+  /** Splits the current set of chains in a recursive way.
    *  We process the points of each chain (with a specified sampling) to find the point minimizing
    *  a specified function. The chain is split in two at this point and the two new chains are
    *  processed in the same way. The user can specify a 0D predicate to make a first selection on
@@ -210,14 +210,14 @@ class Operators {
                             UnaryPredicate1D &pred,
                             float sampling = 0.0f);
 
-  /*! Sorts the current set of chains (or viewedges)
+  /** Sorts the current set of chains (or viewedges)
    *  according to the comparison predicate given as argument.
    *  \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.
+  /** 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:
    *           The predicate that a chain must verify in order to be transform as a stroke
diff --git a/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h
index 46bb46ad8b2..349392a4c0e 100644
--- a/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h
+++ b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h
@@ -41,7 +41,7 @@ class PSStrokeRenderer : public StrokeRenderer {
  public:
   PSStrokeRenderer(const char *iFileName = NULL);
 
-  /*! Renders a stroke rep */
+  /** Renders a stroke rep */
   virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
   virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;
 
diff --git a/source/blender/freestyle/intern/stroke/Predicates0D.h b/source/blender/freestyle/intern/stroke/Predicates0D.h
index 89dbaeb339d..cd00d582b30 100644
--- a/source/blender/freestyle/intern/stroke/Predicates0D.h
+++ b/source/blender/freestyle/intern/stroke/Predicates0D.h
@@ -34,7 +34,7 @@ namespace Freestyle {
 //
 ///////////////////////////////////////////////////////////
 
-/*! Base class for Unary Predicates that work on Interface0DIterator.
+/** Base class for Unary Predicates that work on Interface0DIterator.
  *  A UnaryPredicate0D is a functor that evaluates a condition on a Interface0DIterator and returns
  *  true or false depending on whether this condition is satisfied or not.
  *  The UnaryPredicate0D is used by calling its () operator.
@@ -45,24 +45,24 @@ class UnaryPredicate0D {
   bool result;
   void *py_up0D;
 
-  /*! Default constructor. */
+  /** Default constructor. */
   UnaryPredicate0D()
   {
     py_up0D = 0;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~UnaryPredicate0D()
   {
   }
 
-  /*! Returns the string of the name of the UnaryPredicate0D. */
+  /** Returns the string of the name of the UnaryPredicate0D. */
   virtual string getName() const
   {
     return "UnaryPredicate0D";
   }
 
-  /*! The () operator. Must be overload by inherited classes.
+  /** The () operator. Must be overload by inherited classes.
    *  \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.
@@ -79,7 +79,7 @@ class UnaryPredicate0D {
 //
 ///////////////////////////////////////////////////////////
 
-/*! Base class for Binary Predicates working on Interface0D.
+/** Base class for Binary Predicates working on Interface0D.
  *  A BinaryPredicate0D is typically an ordering relation between two Interface0D.
  *  It evaluates a relation between 2 Interface0D and returns true or false.
  *  It is used by calling the () operator.
@@ -89,24 +89,24 @@ class BinaryPredicate0D {
   bool result;
   void *py_bp0D;
 
-  /*! Default constructor. */
+  /** Default constructor. */
   BinaryPredicate0D()
   {
     py_bp0D = 0;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~BinaryPredicate0D()
   {
   }
 
-  /*! Returns the string of the name of the binary predicate. */
+  /** Returns the string of the name of the binary predicate. */
   virtual string getName() const
   {
     return "BinaryPredicate0D";
   }
 
-  /*! The () operator. Must be overload by inherited classes.
+  /** The () operator. Must be overload by inherited classes.
    *  It evaluates a relation between 2 Interface0D.
    *  \param inter1:
    *    The first Interface0D.
@@ -129,21 +129,21 @@ class BinaryPredicate0D {
 namespace Predicates0D {
 
 // TrueUP0D
-/*! Returns true any time */
+/** Returns true any time */
 class TrueUP0D : public UnaryPredicate0D {
  public:
-  /*! Default constructor. */
+  /** Default constructor. */
   TrueUP0D()
   {
   }
 
-  /*! Returns the string "TrueUP0D"*/
+  /** Returns the string "TrueUP0D"*/
   string getName() const
   {
     return "TrueUP0D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface0DIterator &)
   {
     result = true;
@@ -152,21 +152,21 @@ class TrueUP0D : public UnaryPredicate0D {
 };
 
 // FalseUP0D
-/*! Returns false any time */
+/** Returns false any time */
 class FalseUP0D : public UnaryPredicate0D {
  public:
-  /*! Default constructor. */
+  /** Default constructor. */
   FalseUP0D()
   {
   }
 
-  /*! Returns the string "FalseUP0D"*/
+  /** Returns the string "FalseUP0D"*/
   string getName() const
   {
     return "FalseUP0D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface0DIterator &)
   {
     result = false;
diff --git a/source/blender/freestyle/intern/stroke/Predicates1D.h b/source/blender/freestyle/intern/stroke/Predicates1D.h
index c174162b214..ceb2e7fcc17 100644
--- a/source/blender/freestyle/intern/stroke/Predicates1D.h
+++ b/source/blender/freestyle/intern/stroke/Predicates1D.h
@@ -41,7 +41,7 @@ namespace Freestyle {
 //
 ///////////////////////////////////////////////////////////
 
-/*! Base class for Unary Predicates that work on Interface1D.
+/** Base class for Unary Predicates that work on Interface1D.
  *  A UnaryPredicate1D is a functor that evaluates a condition on a Interface1D and returns
  *  true or false depending on whether this condition is satisfied or not.
  *  The UnaryPredicate1D is used by calling its () operator.
@@ -52,24 +52,24 @@ class UnaryPredicate1D {
   bool result;
   void *py_up1D;
 
-  /*! Default constructor. */
+  /** Default constructor. */
   UnaryPredicate1D()
   {
     py_up1D = NULL;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~UnaryPredicate1D()
   {
   }
 
-  /*! Returns the string of the name of the UnaryPredicate1D. */
+  /** Returns the string of the name of the UnaryPredicate1D. */
   virtual string getName() const
   {
     return "UnaryPredicate1D";
   }
 
-  /*! The () operator. Must be overload by inherited classes.
+  /** The () operator. Must be overload by inherited classes.
    *  \param inter:
    *    The Interface1D on  which we wish to evaluate the predicate.
    *  \return true if the condition is satisfied, false otherwise.
@@ -86,7 +86,7 @@ class UnaryPredicate1D {
 //
 ///////////////////////////////////////////////////////////
 
-/*! Base class for Binary Predicates working on Interface1D.
+/** Base class for Binary Predicates working on Interface1D.
  *  A BinaryPredicate1D is typically an ordering relation between two Interface1D.
  *  It evaluates a relation between 2 Interface1D and returns true or false.
  *  It is used by calling the () operator.
@@ -96,24 +96,24 @@ class BinaryPredicate1D {
   bool result;
   void *py_bp1D;
 
-  /*! Default constructor. */
+  /** Default constructor. */
   BinaryPredicate1D()
   {
     py_bp1D = NULL;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~BinaryPredicate1D()
   {
   }
 
-  /*! Returns the string of the name of the binary predicate. */
+  /** Returns the string of the name of the binary predicate. */
   virtual string getName() const
   {
     return "BinaryPredicate1D";
   }
 
-  /*! The () operator. Must be overload by inherited classes.
+  /** The () operator. Must be overload by inherited classes.
    *  It evaluates a relation between 2 Interface1D.
    *  \param inter1:
    *    The first Interface1D.
@@ -136,21 +136,21 @@ class BinaryPredicate1D {
 namespace Predicates1D {
 
 // TrueUP1D
-/*! Returns true */
+/** Returns true */
 class TrueUP1D : public UnaryPredicate1D {
  public:
-  /*! Constructor */
+  /** Constructor */
   TrueUP1D()
   {
   }
 
-  /*! Returns the string "TrueUP1D"*/
+  /** Returns the string "TrueUP1D"*/
   string getName() const
   {
     return "TrueUP1D";
   }
 
-  /*! the () operator */
+  /** the () operator */
   int operator()(Interface1D &)
   {
     result = true;
@@ -159,21 +159,21 @@ class TrueUP1D : public UnaryPredicate1D {
 };
 
 // FalseUP1D
-/*! Returns false */
+/** Returns false */
 class FalseUP1D : public UnaryPredicate1D {
  public:
-  /*! Constructor */
+  /** Constructor */
   FalseUP1D()
   {
   }
 
-  /*! Returns the string "FalseUP1D"*/
+  /** Returns the string "FalseUP1D"*/
   string getName() const
   {
     return "FalseUP1D";
   }
 
-  /*! the () operator */
+  /** the () operator */
   int operator()(Interface1D &)
   {
     result = false;
@@ -182,12 +182,12 @@ class FalseUP1D : public UnaryPredicate1D {
 };
 
 // QuantitativeInvisibilityUP1D
-/*! Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the
+/** Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the
  * QuantitativeInvisibilityF1D functor, equals a certain user-defined value.
  */
 class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
  public:
-  /*! Builds the Predicate.
+  /** Builds the Predicate.
    *  \param qi:
    *    The Quantitative Invisibility you want the Interface1D to have
    */
@@ -195,13 +195,13 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
   {
   }
 
-  /*! Returns the string "QuantitativeInvisibilityUP1D" */
+  /** Returns the string "QuantitativeInvisibilityUP1D" */
   string getName() const
   {
     return "QuantitativeInvisibilityUP1D";
   }
 
-  /*! the () operator */
+  /** the () operator */
   int operator()(Interface1D &inter)
   {
     Functions1D::QuantitativeInvisibilityF1D func;
@@ -217,7 +217,7 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
 };
 
 // ContourUP1D
-/*! Returns true if the Interface1D is a contour.
+/** Returns true if the Interface1D is a contour.
  *  An Interface1D is a contour if it is bordered by a different shape on each of its sides.
  */
 class ContourUP1D : public UnaryPredicate1D {
@@ -225,13 +225,13 @@ class ContourUP1D : public UnaryPredicate1D {
   Functions1D::CurveNatureF1D _getNature;
 
  public:
-  /*! Returns the string "ContourUP1D"*/
+  /** Returns the string "ContourUP1D"*/
   string getName() const
   {
     return "ContourUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     if (_getNature(inter) < 0) {
@@ -252,7 +252,7 @@ class ContourUP1D : public UnaryPredicate1D {
 };
 
 // ExternalContourUP1D
-/*! Returns true if the Interface1D is an external contour.
+/** Returns true if the Interface1D is an external contour.
  *  An Interface1D is an external contour if it is bordered by no shape on one of its sides.
  */
 class ExternalContourUP1D : public UnaryPredicate1D {
@@ -260,13 +260,13 @@ class ExternalContourUP1D : public UnaryPredicate1D {
   Functions1D::CurveNatureF1D _getNature;
 
  public:
-  /*! Returns the string "ExternalContourUP1D" */
+  /** Returns the string "ExternalContourUP1D" */
   string getName() const
   {
     return "ExternalContourUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     if (_getNature(inter) < 0) {
@@ -289,7 +289,7 @@ class ExternalContourUP1D : public UnaryPredicate1D {
 };
 
 // EqualToTimeStampUP1D
-/*! Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
+/** Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
 class EqualToTimeStampUP1D : public UnaryPredicate1D {
  protected:
   unsigned _timeStamp;
@@ -300,13 +300,13 @@ class EqualToTimeStampUP1D : public UnaryPredicate1D {
     _timeStamp = ts;
   }
 
-  /*! Returns the string "EqualToTimeStampUP1D"*/
+  /** Returns the string "EqualToTimeStampUP1D"*/
   string getName() const
   {
     return "EqualToTimeStampUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     result = (inter.getTimeStamp() == _timeStamp);
@@ -315,7 +315,7 @@ class EqualToTimeStampUP1D : public UnaryPredicate1D {
 };
 
 // EqualToChainingTimeStampUP1D
-/*! Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
+/** Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
 class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
  protected:
   unsigned _timeStamp;
@@ -326,13 +326,13 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
     _timeStamp = ts;
   }
 
-  /*! Returns the string "EqualToChainingTimeStampUP1D"*/
+  /** Returns the string "EqualToChainingTimeStampUP1D"*/
   string getName() const
   {
     return "EqualToChainingTimeStampUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     ViewEdge *edge = dynamic_cast<ViewEdge *>(&inter);
@@ -346,14 +346,14 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
 };
 
 // ShapeUP1D
-/*! Returns true if the shape to which the Interface1D belongs to has the same Id as the one
+/** Returns true if the shape to which the Interface1D belongs to has the same Id as the one
  * specified by the user. */
 class ShapeUP1D : public UnaryPredicate1D {
  private:
   Id _id;
 
  public:
-  /*! Builds the Predicate.
+  /** Builds the Predicate.
    *  \param idFirst:
    *    The first Id component.
    *  \param idSecond:
@@ -364,13 +364,13 @@ class ShapeUP1D : public UnaryPredicate1D {
     _id = Id(idFirst, idSecond);
   }
 
-  /*! Returns the string "ShapeUP1D"*/
+  /** Returns the string "ShapeUP1D"*/
   string getName() const
   {
     return "ShapeUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     set<ViewShape *> shapes;
@@ -387,13 +387,13 @@ class ShapeUP1D : public UnaryPredicate1D {
 };
 
 // WithinImageBoundaryUP1D
-/*! Returns true if the Interface1D is (partly) within the image boundary. */
+/** Returns true if the Interface1D is (partly) within the image boundary. */
 class WithinImageBoundaryUP1D : public UnaryPredicate1D {
  private:
   real _xmin, _ymin, _xmax, _ymax;
 
  public:
-  /*! Builds the Predicate.
+  /** Builds the Predicate.
    *  \param xmin:
    *    The X lower bound of the image boundary.
    *  \param ymin:
@@ -408,13 +408,13 @@ class WithinImageBoundaryUP1D : public UnaryPredicate1D {
   {
   }
 
-  /*! Returns the string "WithinImageBoundaryUP1D" */
+  /** Returns the string "WithinImageBoundaryUP1D" */
   string getName() const
   {
     return "WithinImageBoundaryUP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &inter)
   {
     // 1st pass: check if a point is within the image boundary.
@@ -454,16 +454,16 @@ class WithinImageBoundaryUP1D : public UnaryPredicate1D {
 ///////////////////////////////////////////////////////////
 
 // TrueBP1D
-/*! Returns true. */
+/** Returns true. */
 class TrueBP1D : public BinaryPredicate1D {
  public:
-  /*! Returns the string "TrueBP1D" */
+  /** Returns the string "TrueBP1D" */
   string getName() const
   {
     return "TrueBP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/)
   {
     result = true;
@@ -472,16 +472,16 @@ class TrueBP1D : public BinaryPredicate1D {
 };
 
 // FalseBP1D
-/*! Returns false. */
+/** Returns false. */
 class FalseBP1D : public BinaryPredicate1D {
  public:
-  /*! Returns the string "FalseBP1D" */
+  /** Returns the string "FalseBP1D" */
   string getName() const
   {
     return "FalseBP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/)
   {
     result = false;
@@ -490,17 +490,17 @@ class FalseBP1D : public BinaryPredicate1D {
 };
 
 // Length2DBP1D
-/*! Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the
+/** Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the
  * Interface1D i2. */
 class Length2DBP1D : public BinaryPredicate1D {
  public:
-  /*! Returns the string "Length2DBP1D" */
+  /** Returns the string "Length2DBP1D" */
   string getName() const
   {
     return "Length2DBP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &i1, Interface1D &i2)
   {
     result = (i1.getLength2D() > i2.getLength2D());
@@ -509,16 +509,16 @@ class Length2DBP1D : public BinaryPredicate1D {
 };
 
 // SameShapeIdBP1D
-/*! Returns true if the Interface1D i1 and i2 belong to the same shape. */
+/** Returns true if the Interface1D i1 and i2 belong to the same shape. */
 class SameShapeIdBP1D : public BinaryPredicate1D {
  public:
-  /*! Returns the string "SameShapeIdBP1D" */
+  /** Returns the string "SameShapeIdBP1D" */
   string getName() const
   {
     return "SameShapeIdBP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &i1, Interface1D &i2)
   {
     set<ViewShape *> shapes1;
@@ -542,7 +542,7 @@ class SameShapeIdBP1D : public BinaryPredicate1D {
 };
 
 // ViewMapGradientNormBP1D
-/*! Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than
+/** Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than
  * for i2. */
 class ViewMapGradientNormBP1D : public BinaryPredicate1D {
  private:
@@ -554,13 +554,13 @@ class ViewMapGradientNormBP1D : public BinaryPredicate1D {
   {
   }
 
-  /*! Returns the string "ViewMapGradientNormBP1D" */
+  /** Returns the string "ViewMapGradientNormBP1D" */
   string getName() const
   {
     return "ViewMapGradientNormBP1D";
   }
 
-  /*! The () operator. */
+  /** The () operator. */
   int operator()(Interface1D &i1, Interface1D &i2)
   {
     if (_func(i1) < 0) {
diff --git a/source/blender/freestyle/intern/stroke/Stroke.h b/source/blender/freestyle/intern/stroke/Stroke.h
index 4a9ed7288c5..96a4d2d61ea 100644
--- a/source/blender/freestyle/intern/stroke/Stroke.h
+++ b/source/blender/freestyle/intern/stroke/Stroke.h
@@ -52,18 +52,18 @@ namespace Freestyle {
 //
 ////////////////////////////////////////////////////////
 
-/*! Class to define an attribute associated to a Stroke Vertex.
+/** Class to define an attribute associated to a Stroke Vertex.
  *  This attribute stores the color, alpha and thickness values for a Stroke Vertex.
  */
 class StrokeAttribute {
  public:
-  /*! default constructor */
+  /** default constructor */
   StrokeAttribute();
 
-  /*! Copy constructor */
+  /** Copy constructor */
   StrokeAttribute(const StrokeAttribute &iBrother);
 
-  /*! Builds a stroke vertex attribute from a set of parameters.
+  /** Builds a stroke vertex attribute from a set of parameters.
    *    \param iRColor:
    *      The Red Component value.
    *    \param iGColor:
@@ -84,7 +84,7 @@ class StrokeAttribute {
                   float iRThickness,
                   float iLThickness);
 
-  /*! Interpolation constructor.
+  /** Interpolation constructor.
    *  Builds a StrokeAttribute from two StrokeAttributes and an interpolation parameter.
    *  \param a1:
    *    The first Attribute.
@@ -95,15 +95,15 @@ class StrokeAttribute {
    */
   StrokeAttribute(const StrokeAttribute &a1, const StrokeAttribute &a2, float t);
 
-  /*! destructor */
+  /** destructor */
   virtual ~StrokeAttribute();
 
   /* operators */
-  /*! operator = */
+  /** operator = */
   StrokeAttribute &operator=(const StrokeAttribute &iBrother);
 
   /* accessors */
-  /*! Returns the attribute's color.
+  /** Returns the attribute's color.
    *  \return The array of 3 floats containing the R,G,B values of the attribute's color.
    */
   inline const float *getColor() const
@@ -111,37 +111,37 @@ class StrokeAttribute {
     return _color;
   }
 
-  /*! Returns the R color component. */
+  /** Returns the R color component. */
   inline const float getColorR() const
   {
     return _color[0];
   }
 
-  /*! Returns the G color component. */
+  /** Returns the G color component. */
   inline const float getColorG() const
   {
     return _color[1];
   }
 
-  /*! Returns the B color component. */
+  /** Returns the B color component. */
   inline const float getColorB() const
   {
     return _color[2];
   }
 
-  /*! Returns the RGB color components. */
+  /** Returns the RGB color components. */
   inline Vec3f getColorRGB() const
   {
     return Vec3f(_color[0], _color[1], _color[2]);
   }
 
-  /*! Returns the alpha color component. */
+  /** Returns the alpha color component. */
   inline float getAlpha() const
   {
     return _alpha;
   }
 
-  /*! Returns the attribute's thickness.
+  /** Returns the attribute's thickness.
    *  \return an array of 2 floats. the first value is the thickness on the right of the vertex
    * when following the stroke, the second one is the thickness on the left.
    */
@@ -150,60 +150,60 @@ class StrokeAttribute {
     return _thickness;
   }
 
-  /*! Returns the thickness on the right of the vertex when following the stroke. */
+  /** Returns the thickness on the right of the vertex when following the stroke. */
   inline const float getThicknessR() const
   {
     return _thickness[0];
   }
 
-  /*! Returns the thickness on the left of the vertex when following the stroke. */
+  /** Returns the thickness on the left of the vertex when following the stroke. */
   inline const float getThicknessL() const
   {
     return _thickness[1];
   }
 
-  /*! Returns the thickness on the right and on the left of the vertex when following the stroke.
+  /** Returns the thickness on the right and on the left of the vertex when following the stroke.
    */
   inline Vec2f getThicknessRL() const
   {
     return Vec2f(_thickness[0], _thickness[1]);
   }
 
-  /*! Returns true if the strokevertex is visible, false otherwise */
+  /** Returns true if the strokevertex is visible, false otherwise */
   inline bool isVisible() const
   {
     return _visible;
   }
 
-  /*! Returns an attribute of type real
+  /** Returns an attribute of type real
    *  \param iName:
    *    The name of the attribute
    */
   float getAttributeReal(const char *iName) const;
 
-  /*! Returns an attribute of type Vec2f
+  /** Returns an attribute of type Vec2f
    *  \param iName:
    *    The name of the attribute
    */
   Vec2f getAttributeVec2f(const char *iName) const;
 
-  /*! Returns an attribute of type Vec3f
+  /** Returns an attribute of type Vec3f
    *  \param iName:
    *    The name of the attribute
    */
   Vec3f getAttributeVec3f(const char *iName) const;
 
-  /*! Checks whether the attribute iName is available */
+  /** Checks whether the attribute iName is available */
   bool isAttributeAvailableReal(const char *iName) const;
 
-  /*! Checks whether the attribute iName is available */
+  /** Checks whether the attribute iName is available */
   bool isAttributeAvailableVec2f(const char *iName) const;
 
-  /*! Checks whether the attribute iName is available */
+  /** Checks whether the attribute iName is available */
   bool isAttributeAvailableVec3f(const char *iName) const;
 
   /* modifiers */
-  /*! sets the attribute's color.
+  /** sets the attribute's color.
    *    \param r:
    *      The new R value.
    *    \param g:
@@ -218,7 +218,7 @@ class StrokeAttribute {
     _color[2] = b;
   }
 
-  /*! sets the attribute's color.
+  /** sets the attribute's color.
    *    \param iRGB:
    *      The new RGB values.
    */
@@ -229,7 +229,7 @@ class StrokeAttribute {
     _color[2] = iRGB[2];
   }
 
-  /*! sets the attribute's alpha value.
+  /** sets the attribute's alpha value.
    *  \param alpha:
    *    The new alpha value.
    */
@@ -238,7 +238,7 @@ class StrokeAttribute {
     _alpha = alpha;
   }
 
-  /*! sets the attribute's thickness.
+  /** sets the attribute's thickness.
    *  \param tr:
    *    The thickness on the right of the vertex when following the stroke.
    *  \param tl:
@@ -250,7 +250,7 @@ class StrokeAttribute {
     _thickness[1] = tl;
   }
 
-  /*! sets the attribute's thickness.
+  /** sets the attribute's thickness.
    *  \param tRL:
    *    The thickness on the right and on the left of the vertex when following the stroke.
    */
@@ -260,13 +260,13 @@ class StrokeAttribute {
     _thickness[1] = tRL[1];
   }
 
-  /*! sets the visible flag. True means visible. */
+  /** sets the visible flag. True means visible. */
   inline void setVisible(bool iVisible)
   {
     _visible = iVisible;
   }
 
-  /*! Adds a user defined attribute of type real
+  /** 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:
@@ -276,7 +276,7 @@ class StrokeAttribute {
    */
   void setAttributeReal(const char *iName, float att);
 
-  /*! Adds a user defined attribute of type Vec2f
+  /** 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:
@@ -286,7 +286,7 @@ class StrokeAttribute {
    */
   void setAttributeVec2f(const char *iName, const Vec2f &att);
 
-  /*! Adds a user defined attribute of type Vec3f
+  /** 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:
@@ -322,10 +322,10 @@ class StrokeAttribute {
 //
 ////////////////////////////////////////////////////////
 
-/*! Class to define a stroke vertex. */
+/** Class to define a stroke vertex. */
 class StrokeVertex : public CurvePoint {
  public:  // Implementation of Interface0D
-  /*! Returns the string "StrokeVertex" */
+  /** Returns the string "StrokeVertex" */
   virtual string getExactTypeName() const
   {
     return "StrokeVertex";
@@ -337,129 +337,129 @@ class StrokeVertex : public CurvePoint {
   float _StrokeLength;         // stroke length
 
  public:
-  /*! default constructor */
+  /** default constructor */
   StrokeVertex();
 
-  /*! Copy constructor */
+  /** Copy constructor */
   StrokeVertex(const StrokeVertex &iBrother);
 
-  /*! Builds a stroke vertex from a SVertex */
+  /** Builds a stroke vertex from a SVertex */
   StrokeVertex(SVertex *iSVertex);
 
-  /*! Builds a stroke vertex from a CurvePoint */
+  /** Builds a stroke vertex from a CurvePoint */
   StrokeVertex(CurvePoint *iPoint);
 
-  /*! Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/
+  /** Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/
   StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3);
 
-  /*! Builds a stroke from a view vertex and an attribute */
+  /** Builds a stroke from a view vertex and an attribute */
   StrokeVertex(SVertex *iSVertex, const StrokeAttribute &iAttribute);
 
   /* operators */
-  /*! operator = */
+  /** operator = */
   StrokeVertex &operator=(const StrokeVertex &iBrother);
 
   /* accessors */
-  /*! Returns the 2D point x coordinate */
+  /** Returns the 2D point x coordinate */
   inline real x() const
   {
     return _Point2d[0];
   }
 
-  /*! Returns the 2D point y coordinate */
+  /** Returns the 2D point y coordinate */
   inline real y() const
   {
     return _Point2d[1];
   }
 
-  /*! Returns the 2D point coordinates as a Vec2r */
+  /** Returns the 2D point coordinates as a Vec2r */
   inline Vec2r getPoint() const
   {
     return getPoint2D();
   }
 
-  /*! Returns the ith 2D point coordinate (i=0 or 1)*/
+  /** Returns the ith 2D point coordinate (i=0 or 1)*/
   inline real operator[](const int i) const
   {
     return _Point2d[i];
   }
 
-  /*! Returns the StrokeAttribute for this StrokeVertex */
+  /** Returns the StrokeAttribute for this StrokeVertex */
   inline const StrokeAttribute &attribute() const
   {
     return _Attribute;
   }
 
-  /*! Returns a non-const reference to the StrokeAttribute of this StrokeVertex */
+  /** Returns a non-const reference to the StrokeAttribute of this StrokeVertex */
   inline StrokeAttribute &attribute()
   {
     return _Attribute;
   }
 
-  /*! Returns the curvilinear abscissa */
+  /** Returns the curvilinear abscissa */
   inline float curvilinearAbscissa() const
   {
     return _CurvilignAbscissa;
   }
 
-  /*! Returns the length of the Stroke to which this StrokeVertex belongs */
+  /** Returns the length of the Stroke to which this StrokeVertex belongs */
   inline float strokeLength() const
   {
     return _StrokeLength;
   }
 
-  /*! Returns the curvilinear abscissa of this StrokeVertex in the Stroke */
+  /** Returns the curvilinear abscissa of this StrokeVertex in the Stroke */
   inline float u() const
   {
     return _CurvilignAbscissa / _StrokeLength;
   }
 
   /* modifiers */
-  /*! sets the 2D x value */
+  /** sets the 2D x value */
   inline void setX(real x)
   {
     _Point2d[0] = x;
   }
 
-  /*! sets the 2D y value */
+  /** sets the 2D y value */
   inline void setY(real y)
   {
     _Point2d[1] = y;
   }
 
-  /*! sets the 2D x and y values */
+  /** sets the 2D x and y values */
   inline void setPoint(real x, real y)
   {
     _Point2d[0] = x;
     _Point2d[1] = y;
   }
 
-  /*! sets the 2D x and y values */
+  /** sets the 2D x and y values */
   inline void setPoint(const Vec2r &p)
   {
     _Point2d[0] = p[0];
     _Point2d[1] = p[1];
   }
 
-  /*! Returns a reference to the ith 2D point coordinate (i=0 or 1) */
+  /** Returns a reference to the ith 2D point coordinate (i=0 or 1) */
   inline real &operator[](const int i)
   {
     return _Point2d[i];
   }
 
-  /*! sets the attribute. */
+  /** sets the attribute. */
   inline void setAttribute(const StrokeAttribute &iAttribute)
   {
     _Attribute = iAttribute;
   }
 
-  /*! sets the curvilinear abscissa of this StrokeVertex in the Stroke */
+  /** sets the curvilinear abscissa of this StrokeVertex in the Stroke */
   inline void setCurvilinearAbscissa(float iAbscissa)
   {
     _CurvilignAbscissa = iAbscissa;
   }
 
-  /*! sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the
+  /** sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the
    * real Stroke's length.)
    */
   inline void setStrokeLength(float iLength)
@@ -492,7 +492,7 @@ class StrokeVertexIterator;
 
 }  // end of namespace StrokeInternal
 
-/*! Class to define a stroke.
+/** Class to define a stroke.
  *  A stroke is made of a set of 2D vertices (StrokeVertex), regularly spaced out.
  *  This set of vertices defines the stroke's backbone geometry.
  *  Each of these stroke vertices defines the stroke's shape and appearance at this vertex
@@ -500,7 +500,7 @@ class StrokeVertexIterator;
  */
 class Stroke : public Interface1D {
  public:  // Implementation of Interface1D
-  /*! Returns the string "Stroke" */
+  /** Returns the string "Stroke" */
   virtual string getExactTypeName() const
   {
     return "Stroke";
@@ -508,17 +508,17 @@ class Stroke : public Interface1D {
 
   // Data access methods
 
-  /*! Returns the Id of the Stroke */
+  /** Returns the Id of the Stroke */
   virtual Id getId() const
   {
     return _id;
   }
 
-  /*! The different blending modes available to similate the interaction media-medium. */
+  /** The different blending modes available to similate the interaction media-medium. */
   typedef enum {
-    DRY_MEDIUM,    /*!< To simulate a dry medium such as Pencil or Charcoal.*/
-    HUMID_MEDIUM,  /*!< To simulate ink painting (color subtraction blending).*/
-    OPAQUE_MEDIUM, /*!< To simulate an opaque medium (oil, spray...).*/
+    DRY_MEDIUM,    /**< To simulate a dry medium such as Pencil or Charcoal.*/
+    HUMID_MEDIUM,  /**< To simulate ink painting (color subtraction blending).*/
+    OPAQUE_MEDIUM, /**< To simulate an opaque medium (oil, spray...).*/
   } MediumType;
 
  public:
@@ -549,13 +549,13 @@ class Stroke : public Interface1D {
   Vec2r _extremityOrientations[2];  // the orientations of the first and last extermity
 
  public:
-  /*! default constructor */
+  /** default constructor */
   Stroke();
 
-  /*! copy constructor */
+  /** copy constructor */
   Stroke(const Stroke &iBrother);
 
-  /*! Builds a stroke from a set of StrokeVertex.
+  /** 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:
@@ -565,14 +565,14 @@ class Stroke : public Interface1D {
    */
   template<class InputVertexIterator> Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd);
 
-  /*! Destructor */
+  /** Destructor */
   virtual ~Stroke();
 
   /* operators */
-  /*! operator = */
+  /** operator = */
   Stroke &operator=(const Stroke &iBrother);
 
-  /*! Compute the sampling needed to get iNVertices vertices.
+  /** 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:
@@ -583,7 +583,7 @@ class Stroke : public Interface1D {
    */
   float ComputeSampling(int iNVertices);
 
-  /*! Resampling method.
+  /** Resampling method.
    *  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.
@@ -592,7 +592,7 @@ class Stroke : public Interface1D {
    */
   int Resample(int iNPoints);
 
-  /*! Resampling method.
+  /** Resampling method.
    *  Resamples the curve with a given sampling.
    *  If this sampling is < to the actual sampling value, no resampling is done.
    *  \param iSampling:
@@ -600,18 +600,18 @@ class Stroke : public Interface1D {
    */
   int Resample(float iSampling);
 
-  /*! Removes all vertices from the Stroke.
+  /** Removes all vertices from the Stroke.
    */
   void RemoveAllVertices();
 
-  /*! Removes the stroke vertex iVertex
+  /** Removes the stroke vertex iVertex
    *  from the stroke.
    *  The length and curvilinear abscissa are updated
    *  consequently.
    */
   void RemoveVertex(StrokeVertex *iVertex);
 
-  /*! Inserts the stroke vertex iVertex in the stroke before next.
+  /** Inserts the stroke vertex iVertex in the stroke before next.
    *  The length, curvilinear abscissa are updated consequently.
    *  \param iVertex:
    *    The StrokeVertex to insert in the Stroke.
@@ -620,7 +620,7 @@ class Stroke : public Interface1D {
    */
   void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);
 
-  /*! Updates the 2D length of the Stroke */
+  /** Updates the 2D length of the Stroke */
   void UpdateLength();
 
   /* Render method */
@@ -631,50 +631,50 @@ class Stroke : public Interface1D {
   /* Iterator definition */
 
   /* accessors */
-  /*! Returns the 2D length of the Stroke */
+  /** Returns the 2D length of the Stroke */
   inline real getLength2D() const
   {
     return _Length;
   }
 
-  /*! Returns a reference to the time stamp value of the stroke. */
-  /*! Returns the MediumType used for this Stroke. */
+  /** Returns a reference to the time stamp value of the stroke. */
+  /** Returns the MediumType used for this Stroke. */
   inline MediumType getMediumType() const
   {
     return _mediumType;
   }
 
-  /*! Returns the id of the texture used to simulate th marks system for this Stroke */
+  /** Returns the id of the texture used to simulate th marks system for this Stroke */
   inline unsigned int getTextureId()
   {
     return _textureId;
   }
 
-  /*! Returns the spacing of texture coordinates along the stroke length */
+  /** Returns the spacing of texture coordinates along the stroke length */
   inline float getTextureStep()
   {
     return _textureStep;
   }
 
-  /*! Returns the texture used at given index to simulate the marks system for this Stroke */
+  /** Returns the texture used at given index to simulate the marks system for this Stroke */
   inline MTex *getMTex(int idx)
   {
     return _mtex[idx];
   }
 
-  /*! Return the shader node tree to define textures. */
+  /** Return the shader node tree to define textures. */
   inline bNodeTree *getNodeTree()
   {
     return _nodeTree;
   }
 
-  /*! Returns true if this Stroke has textures assigned, false otherwise. */
+  /** Returns true if this Stroke has textures assigned, false otherwise. */
   inline bool hasTex() const
   {
     return (_mtex[0] != NULL) || _nodeTree;
   }
 
-  /*! Returns true if this Stroke uses a texture with tips, false otherwise. */
+  /** Returns true if this Stroke uses a texture with tips, false otherwise. */
   inline bool hasTips() const
   {
     return _tips;
@@ -742,34 +742,34 @@ class Stroke : public Interface1D {
   }
 
   /* modifiers */
-  /*! sets the Id of the Stroke. */
+  /** sets the Id of the Stroke. */
   inline void setId(const Id &id)
   {
     _id = id;
   }
 
-  /*! sets the 2D length of the Stroke. */
+  /** sets the 2D length of the Stroke. */
   void setLength(float iLength);
 
-  /*! sets the medium type that must be used for this Stroke. */
+  /** sets the medium type that must be used for this Stroke. */
   inline void setMediumType(MediumType iType)
   {
     _mediumType = iType;
   }
 
-  /*! sets the texture id to be used to simulate the marks system for this Stroke. */
+  /** sets the texture id to be used to simulate the marks system for this Stroke. */
   inline void setTextureId(unsigned int id)
   {
     _textureId = id;
   }
 
-  /*! sets the spacing of texture coordinates along the stroke length. */
+  /** sets the spacing of texture coordinates along the stroke length. */
   inline void setTextureStep(float step)
   {
     _textureStep = step;
   }
 
-  /*! assigns a blender texture to the first available slot. */
+  /** assigns a blender texture to the first available slot. */
   inline int setMTex(MTex *mtex)
   {
     for (int a = 0; a < MAX_MTEX; a++) {
@@ -781,13 +781,13 @@ class Stroke : public Interface1D {
     return -1; /* no free slots */
   }
 
-  /*! assigns a node tree (of new shading nodes) to define textures. */
+  /** assigns a node tree (of new shading nodes) to define textures. */
   inline void setNodeTree(bNodeTree *iNodeTree)
   {
     _nodeTree = iNodeTree;
   }
 
-  /*! sets the flag telling whether this stroke is using a texture with tips or not. */
+  /** sets the flag telling whether this stroke is using a texture with tips or not. */
   inline void setTips(bool iTips)
   {
     _tips = iTips;
@@ -836,7 +836,7 @@ class Stroke : public Interface1D {
   const_vertex_iterator vertices_end() const;
   vertex_iterator vertices_end();
 
-  /*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can
+  /** Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can
    * specify a sampling value to re-sample the Stroke on the fly if needed.
    *
    * \param t: The resampling value with which we want our Stroke to be resampled.
@@ -844,26 +844,26 @@ class Stroke : public Interface1D {
    */
   StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t = 0.0f);
 
-  /*! Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */
+  /** Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */
   StrokeInternal::StrokeVertexIterator strokeVerticesEnd();
 
-  /*! Returns the number of StrokeVertex constituting the Stroke. */
+  /** Returns the number of StrokeVertex constituting the Stroke. */
   inline unsigned int strokeVerticesSize() const
   {
     return _Vertices.size();
   }
 
-  /*! Returns the i-th StrokeVertex constituting the Stroke. */
+  /** Returns the i-th StrokeVertex constituting the Stroke. */
   inline StrokeVertex &strokeVerticeAt(unsigned int i)
   {
     return *(_Vertices.at(i));
   }
 
   // Iterator access (Interface1D)
-  /*! Returns an Interface0DIterator pointing on the first StrokeVertex of the Stroke. */
+  /** Returns an Interface0DIterator pointing on the first StrokeVertex of the Stroke. */
   virtual Interface0DIterator verticesBegin();
 
-  /*! Returns an Interface0DIterator pointing after the last StrokeVertex of the Stroke. */
+  /** Returns an Interface0DIterator pointing after the last StrokeVertex of the Stroke. */
   virtual Interface0DIterator verticesEnd();
 
   virtual Interface0DIterator pointsBegin(float t = 0.0f);
diff --git a/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h b/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
index 4256cdebe86..0fbf94f609e 100644
--- a/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
+++ b/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
@@ -158,7 +158,7 @@ class vertex_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTa
     return &(operator*());
   }
 
-  /*! accessors */
+  /** accessors */
   inline vertex_container_iterator it() const
   {
     return _it;
diff --git a/source/blender/freestyle/intern/stroke/StrokeIterators.h b/source/blender/freestyle/intern/stroke/StrokeIterators.h
index d4cbffd535e..20c29b21c22 100644
--- a/source/blender/freestyle/intern/stroke/StrokeIterators.h
+++ b/source/blender/freestyle/intern/stroke/StrokeIterators.h
@@ -32,7 +32,7 @@ namespace StrokeInternal {
 //
 /////////////////////////////////////////////////
 
-/*! Class defining an iterator designed to iterate over the StrokeVertex of a Stroke.
+/** Class defining an iterator designed to iterate over the StrokeVertex of a Stroke.
  *  An instance of a StrokeVertexIterator can only be obtained from a Stroke by calling
  * strokeVerticesBegin() or strokeVerticesEnd(). It is iterating over the same vertices as an
  * Interface0DIterator. The difference resides in the object access. Indeed, an Interface0DIterator
@@ -46,12 +46,12 @@ namespace StrokeInternal {
  */
 class StrokeVertexIterator : public Interface0DIteratorNested {
  public:
-  /*! Default constructor. */
+  /** Default constructor. */
   StrokeVertexIterator()
   {
   }
 
-  /*! Copy constructor. */
+  /** Copy constructor. */
   StrokeVertexIterator(const StrokeVertexIterator &vi)
   {
     _it = vi._it;
@@ -72,7 +72,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
   {
   }
 
-  /*! Casts this StrokeVertexIterator into an Interface0DIterator.
+  /** Casts this StrokeVertexIterator into an Interface0DIterator.
    *  Useful for any call to a function of the type UnaryFunction0D.
    */
   inline Interface0DIterator castToInterface0DIterator() const
@@ -81,7 +81,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return ret;
   }
 
-  /*! operator=
+  /** operator=
    *  \attention In the scripting language, you must call \code it2 = StrokeVertexIterator(it1)
    * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2
    * StrokeVertexIterator. Otherwise, incrementing \a it1 will also increment \a it2.
@@ -94,13 +94,13 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return *this;
   }
 
-  /*! Returns the string "StrokeVertexIterator". */
+  /** Returns the string "StrokeVertexIterator". */
   virtual string getExactTypeName() const
   {
     return "StrokeVertexIterator";
   }
 
-  /*! Returns a reference to the pointed StrokeVertex.
+  /** Returns a reference to the pointed StrokeVertex.
    *  In the scripting language, you must call "getObject()"instead.
    */
   virtual StrokeVertex &operator*()
@@ -108,7 +108,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return **_it;
   }
 
-  /*! Returns a pointer to the pointed StrokeVertex.
+  /** Returns a pointer to the pointed StrokeVertex.
    * Can't be called in the scripting language.
    */
   virtual StrokeVertex *operator->()
@@ -116,14 +116,14 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return &(operator*());
   }
 
-  /*! Increments. In the scripting language, call "increment()". */
+  /** Increments. In the scripting language, call "increment()". */
   virtual StrokeVertexIterator &operator++()
   {
     increment();
     return *this;
   }
 
-  /*! Increments. In the scripting language, call "increment()". */
+  /** Increments. In the scripting language, call "increment()". */
   virtual StrokeVertexIterator operator++(int)
   {
     StrokeVertexIterator ret(*this);
@@ -131,14 +131,14 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return ret;
   }
 
-  /*! Decrements. In the scripting language, call "decrement()". */
+  /** Decrements. In the scripting language, call "decrement()". */
   virtual StrokeVertexIterator &operator--()
   {
     decrement();
     return *this;
   }
 
-  /*! Decrements. In the scripting language, call "decrement()". */
+  /** Decrements. In the scripting language, call "decrement()". */
   virtual StrokeVertexIterator operator--(int)
   {
     StrokeVertexIterator ret(*this);
@@ -146,27 +146,27 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return ret;
   }
 
-  /*! Increments. */
+  /** Increments. */
   virtual int increment()
   {
     ++_it;
     return 0;
   }
 
-  /*! Decrements. */
+  /** Decrements. */
   virtual int decrement()
   {
     --_it;
     return 0;
   }
 
-  /*! Returns true if the pointed StrokeVertex is the first of the Stroke. */
+  /** Returns true if the pointed StrokeVertex is the first of the Stroke. */
   bool isBegin() const
   {
     return _it == _begin;
   }
 
-  /*! Returns true if the pointed StrokeVertex is the final valid StrokeVertex of the Stroke. */
+  /** Returns true if the pointed StrokeVertex is the final valid StrokeVertex of the Stroke. */
   bool atLast()
   {
     if (_it == _end) {
@@ -179,13 +179,13 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return result;
   }
 
-  /*! Returns true if the pointed StrokeVertex is after the last StrokeVertex of the Stroke. */
+  /** Returns true if the pointed StrokeVertex is after the last StrokeVertex of the Stroke. */
   bool isEnd() const
   {
     return _it == _end;
   }
 
-  /*! operator == */
+  /** operator == */
   virtual bool operator==(const Interface0DIteratorNested &it) const
   {
     const StrokeVertexIterator *it_exact = dynamic_cast<const StrokeVertexIterator *>(&it);
@@ -195,19 +195,19 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
     return (_it == it_exact->_it);
   }
 
-  /*! Returns the curvilinear abscissa of the current point */
+  /** Returns the curvilinear abscissa of the current point */
   virtual float t() const
   {
     return (*_it)->curvilinearAbscissa();
   }
 
-  /*! Returns the point's parameter in the stroke */
+  /** Returns the point's parameter in the stroke */
   virtual float u() const
   {
     return (*_it)->u();
   }
 
-  /*! Cloning method */
+  /** Cloning method */
   virtual StrokeVertexIterator *copy() const
   {
     return new StrokeVertexIterator(*this);
diff --git a/source/blender/freestyle/intern/stroke/StrokeLayer.h b/source/blender/freestyle/intern/stroke/StrokeLayer.h
index 2101e7732ce..3bcd675d295 100644
--- a/source/blender/freestyle/intern/stroke/StrokeLayer.h
+++ b/source/blender/freestyle/intern/stroke/StrokeLayer.h
@@ -55,15 +55,15 @@ class StrokeLayer {
 
   virtual ~StrokeLayer();
 
-  /*! Render method */
+  /** Render method */
   void ScaleThickness(float iFactor);
   void Render(const StrokeRenderer *iRenderer);
   void RenderBasic(const StrokeRenderer *iRenderer);
 
-  /*! clears the layer */
+  /** clears the layer */
   void clear();
 
-  /*! accessors */
+  /** accessors */
   inline stroke_container::iterator strokes_begin()
   {
     return _strokes.begin();
@@ -84,7 +84,7 @@ class StrokeLayer {
     return _strokes.empty();
   }
 
-  /*! modifiers */
+  /** modifiers */
   inline void setStrokes(stroke_container &iStrokes)
   {
     _strokes = iStrokes;
diff --git a/source/blender/freestyle/intern/stroke/StrokeRenderer.h b/source/blender/freestyle/intern/stroke/StrokeRenderer.h
index d3ed8bde8a3..61b530b9643 100644
--- a/source/blender/freestyle/intern/stroke/StrokeRenderer.h
+++ b/source/blender/freestyle/intern/stroke/StrokeRenderer.h
@@ -46,7 +46,7 @@ namespace Freestyle {
 /*                                */
 /**********************************/
 
-/*! Class to load textures */
+/** Class to load textures */
 class TextureManager {
  public:
   TextureManager();
@@ -117,13 +117,13 @@ class TextureManager {
 /*                                */
 /**********************************/
 
-/*! Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the
+/** Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the
  * first rendering */
 class StrokeRenderer {
  public:
   virtual ~StrokeRenderer();
 
-  /*! Renders a stroke rep */
+  /** Renders a stroke rep */
   virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const = 0;
   virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const = 0;
 
diff --git a/source/blender/freestyle/intern/stroke/StrokeRep.h b/source/blender/freestyle/intern/stroke/StrokeRep.h
index 09048b8e147..cc889aac364 100644
--- a/source/blender/freestyle/intern/stroke/StrokeRep.h
+++ b/source/blender/freestyle/intern/stroke/StrokeRep.h
@@ -197,13 +197,13 @@ class StrokeRep {
   StrokeRep(Stroke *iStroke);
   virtual ~StrokeRep();
 
-  /*! Creates the strips */
+  /** Creates the strips */
   virtual void create();
 
-  /*! Renders the stroke using a Renderer */
+  /** Renders the stroke using a Renderer */
   virtual void Render(const StrokeRenderer *iRenderer);
 
-  /*! accessors */
+  /** accessors */
   inline Stroke::MediumType getMediumType() const
   {
     return _strokeType;
@@ -249,7 +249,7 @@ class StrokeRep {
     return _stroke;
   }
 
-  /*! modifiers */
+  /** modifiers */
   inline void setMediumType(Stroke::MediumType itype)
   {
     _strokeType = itype;
diff --git a/source/blender/freestyle/intern/stroke/StrokeShader.h b/source/blender/freestyle/intern/stroke/StrokeShader.h
index f4984136747..e4a8412d52a 100644
--- a/source/blender/freestyle/intern/stroke/StrokeShader.h
+++ b/source/blender/freestyle/intern/stroke/StrokeShader.h
@@ -39,7 +39,7 @@ namespace Freestyle {
 
 class Stroke;
 
-/*! Base class for Stroke Shaders.
+/** Base class for Stroke Shaders.
  *  Any Stroke Shader must inherit from this class and overload the shade() method.
  *  A StrokeShader is designed to modify any Stroke's attribute such as Thickness, Color,
  *  Geometry, Texture, Blending mode...
@@ -65,24 +65,24 @@ class StrokeShader {
  public:
   void *py_ss;
 
-  /*! Default constructor. */
+  /** Default constructor. */
   StrokeShader()
   {
     py_ss = 0;
   }
 
-  /*! Destructor. */
+  /** Destructor. */
   virtual ~StrokeShader()
   {
   }
 
-  /*! Returns the string corresponding to the shader's name. */
+  /** Returns the string corresponding to the shader's name. */
   virtual string getName() const
   {
     return "StrokeShader";
   }
 
-  /*! The shading method. This method must be overloaded by inherited classes.
+  /** The shading method. This method must be overloaded by inherited classes.
    *  \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/stroke/StrokeTesselator.h b/source/blender/freestyle/intern/stroke/StrokeTesselator.h
index 0c1efb873bc..b03db823d18 100644
--- a/source/blender/freestyle/intern/stroke/StrokeTesselator.h
+++ b/source/blender/freestyle/intern/stroke/StrokeTesselator.h
@@ -43,10 +43,10 @@ class StrokeTesselator {
   {
   }
 
-  /*! Builds a line rep contained from a Stroke */
+  /** Builds a line rep contained from a Stroke */
   LineRep *Tesselate(Stroke *iStroke);
 
-  /*! Builds a set of lines rep contained under a a NodeShape, itself contained under a NodeGroup
+  /** Builds a set of lines rep contained under a a NodeShape, itself contained under a NodeGroup
    *  from a set of strokes.
    */
   template<class StrokeIterator> NodeGroup *Tesselate(StrokeIterator begin, StrokeIterator end);
diff --git a/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h
index bbc3b5058a3..09c597791a2 100644
--- a/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h
+++ b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h
@@ -54,7 +54,7 @@ class TextStrokeRenderer : public StrokeRenderer {
  public:
   TextStrokeRenderer(const char *iFileName = NULL);
 
-  /*! Renders a stroke rep */
+  /** Renders a stroke rep */
   virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
   virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;