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