diff options
| author | Campbell Barton <ideasman42@gmail.com> | 2021-06-24 08:57:33 +0300 |
|---|---|---|
| committer | Campbell Barton <ideasman42@gmail.com> | 2021-06-24 08:59:34 +0300 |
| commit | 1f778dbefcaf825dcad1f70a9cc45e503ad74ed5 (patch) | |
| tree | d192550ac77a0f982fb43440d3c64d972cc2d011 /source/blender/freestyle/intern/view_map | |
| parent | 4b9ff3cd42be427e478743648e9951bf8c189a04 (diff) | |
Cleanup: use Blender's code style for doxygen commetns in freestyle
Diffstat (limited to 'source/blender/freestyle/intern/view_map')
16 files changed, 549 insertions, 549 deletions
diff --git a/source/blender/freestyle/intern/view_map/FEdgeXDetector.h b/source/blender/freestyle/intern/view_map/FEdgeXDetector.h index 2373451f47c..1a96cf3deea 100644 --- a/source/blender/freestyle/intern/view_map/FEdgeXDetector.h +++ b/source/blender/freestyle/intern/view_map/FEdgeXDetector.h @@ -42,7 +42,7 @@ namespace Freestyle { using namespace Geometry; -/*! This class takes as input a WXEdge structure and fills it */ +/** This class takes as input a WXEdge structure and fills it */ class FEdgeXDetector { public: FEdgeXDetector() @@ -69,7 +69,7 @@ class FEdgeXDetector { { } - /*! Process shapes from a WingedEdge containing a list of WShapes */ + /** Process shapes from a WingedEdge containing a list of WShapes */ virtual void processShapes(WingedEdge &); // GENERAL STUFF @@ -86,7 +86,7 @@ class FEdgeXDetector { virtual void processCreaseShape(WXShape *iWShape); virtual void ProcessCreaseEdge(WXEdge *iEdge); - /*! Sets the minimum angle for detecting crease edges + /** Sets the minimum angle for detecting crease edges * \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 @@ -121,7 +121,7 @@ class FEdgeXDetector { virtual void ProcessSuggestiveContourFace(WXFace *iFace); virtual void postProcessSuggestiveContourShape(WXShape *iShape); virtual void postProcessSuggestiveContourFace(WXFace *iFace); - /*! Sets the minimal derivative of the radial curvature for suggestive contours + /** Sets the minimal derivative of the radial curvature for suggestive contours * \param dkr: * The minimal derivative of the radial curvature */ @@ -144,7 +144,7 @@ class FEdgeXDetector { // EVERYBODY virtual void buildSmoothEdges(WXShape *iShape); - /*! Sets the current viewpoint */ + /** Sets the current viewpoint */ inline void setViewpoint(const Vec3f &ivp) { _Viewpoint = ivp; @@ -186,7 +186,7 @@ class FEdgeXDetector { } } - /*! Sets the radius of the geodesic sphere around each vertex (for the curvature computation) + /** Sets the radius of the geodesic sphere around each vertex (for the curvature computation) * \param r: * The radius of the sphere expressed as a ratio of the mean edge size */ diff --git a/source/blender/freestyle/intern/view_map/Functions0D.h b/source/blender/freestyle/intern/view_map/Functions0D.h index 0364069b631..7409e1737a4 100644 --- a/source/blender/freestyle/intern/view_map/Functions0D.h +++ b/source/blender/freestyle/intern/view_map/Functions0D.h @@ -52,7 +52,7 @@ using namespace Geometry; // /////////////////////////////////////////////////////////// -/*! Base class for Unary Functions (functors) working on Interface0DIterator. +/** Base class for Unary Functions (functors) working on Interface0DIterator. * A unary function will be used by calling its operator() on an Interface0DIterator. * \attention In the scripting language, there exists several prototypes depending on the returned * value type. For example, you would inherit from a UnaryFunction0DDouble if you wish to define a @@ -74,27 +74,27 @@ template<class T> class UnaryFunction0D { T result; void *py_uf0D; - /*! The type of the value returned by the functor. */ + /** The type of the value returned by the functor. */ typedef T ReturnedValueType; - /*! Default constructor. */ + /** Default constructor. */ UnaryFunction0D() { py_uf0D = NULL; } - /*! Destructor; */ + /** Destructor; */ virtual ~UnaryFunction0D() { } - /*! Returns the string "UnaryFunction0D" */ + /** Returns the string "UnaryFunction0D" */ virtual string getName() const { return "UnaryFunction0D"; } - /*! The operator (). + /** The operator (). * \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. @@ -139,16 +139,16 @@ class ViewShape; namespace Functions0D { // GetXF0D -/*! Returns the X 3D coordinate of an Interface0D. */ +/** Returns the X 3D coordinate of an Interface0D. */ class GetXF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "GetXF0D" */ + /** Returns the string "GetXF0D" */ string getName() const { return "GetXF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter->getX(); @@ -157,16 +157,16 @@ class GetXF0D : public UnaryFunction0D<double> { }; // GetYF0D -/*! Returns the Y 3D coordinate of an Interface0D. */ +/** Returns the Y 3D coordinate of an Interface0D. */ class GetYF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "GetYF0D" */ + /** Returns the string "GetYF0D" */ string getName() const { return "GetYF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter->getY(); @@ -175,16 +175,16 @@ class GetYF0D : public UnaryFunction0D<double> { }; // GetZF0D -/*! Returns the Z 3D coordinate of an Interface0D. */ +/** Returns the Z 3D coordinate of an Interface0D. */ class GetZF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "GetZF0D" */ + /** Returns the string "GetZF0D" */ string getName() const { return "GetZF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter->getZ(); @@ -193,16 +193,16 @@ class GetZF0D : public UnaryFunction0D<double> { }; // GetProjectedXF0D -/*! Returns the X 3D projected coordinate of an Interface0D. */ +/** Returns the X 3D projected coordinate of an Interface0D. */ class GetProjectedXF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "GetProjectedXF0D" */ + /** Returns the string "GetProjectedXF0D" */ string getName() const { return "GetProjectedXF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter->getProjectedX(); @@ -211,16 +211,16 @@ class GetProjectedXF0D : public UnaryFunction0D<double> { }; // GetProjectedYF0D -/*! Returns the Y projected 3D coordinate of an Interface0D. */ +/** Returns the Y projected 3D coordinate of an Interface0D. */ class GetProjectedYF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "GetProjectedYF0D" */ + /** Returns the string "GetProjectedYF0D" */ string getName() const { return "GetProjectedYF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter->getProjectedY(); @@ -229,16 +229,16 @@ class GetProjectedYF0D : public UnaryFunction0D<double> { }; // GetProjectedZF0D -/*! Returns the Z projected 3D coordinate of an Interface0D. */ +/** Returns the Z projected 3D coordinate of an Interface0D. */ class GetProjectedZF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "GetProjectedZF0D" */ + /** Returns the string "GetProjectedZF0D" */ string getName() const { return "GetProjectedZF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter->getProjectedZ(); @@ -247,16 +247,16 @@ class GetProjectedZF0D : public UnaryFunction0D<double> { }; // GetCurvilinearAbscissaF0D -/*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */ +/** Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */ class GetCurvilinearAbscissaF0D : public UnaryFunction0D<float> { public: - /*! Returns the string "GetCurvilinearAbscissaF0D" */ + /** Returns the string "GetCurvilinearAbscissaF0D" */ string getName() const { return "GetCurvilinearAbscissaF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter.t(); @@ -265,16 +265,16 @@ class GetCurvilinearAbscissaF0D : public UnaryFunction0D<float> { }; // GetParameterF0D -/*! Returns the parameter of an Interface0D in the context of its 1D element. */ +/** Returns the parameter of an Interface0D in the context of its 1D element. */ class GetParameterF0D : public UnaryFunction0D<float> { public: - /*! Returns the string "GetCurvilinearAbscissaF0D" */ + /** Returns the string "GetCurvilinearAbscissaF0D" */ string getName() const { return "GetParameterF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter) { result = iter.u(); @@ -283,93 +283,93 @@ class GetParameterF0D : public UnaryFunction0D<float> { }; // VertexOrientation2DF0D -/*! Returns a Vec2r giving the 2D oriented tangent to the 1D element to which the +/** Returns a Vec2r giving the 2D oriented tangent to the 1D element to which the * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this * Interface0DIterator&. */ class VertexOrientation2DF0D : public UnaryFunction0D<Vec2f> { public: - /*! Returns the string "VertexOrientation2DF0D" */ + /** Returns the string "VertexOrientation2DF0D" */ string getName() const { return "VertexOrientation2DF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // VertexOrientation3DF0D -/*! Returns a Vec3r giving the 3D oriented tangent to the 1D element to which the +/** Returns a Vec3r giving the 3D oriented tangent to the 1D element to which the * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this * Interface0DIterator&. */ class VertexOrientation3DF0D : public UnaryFunction0D<Vec3f> { public: - /*! Returns the string "VertexOrientation3DF0D" */ + /** Returns the string "VertexOrientation3DF0D" */ string getName() const { return "VertexOrientation3DF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // Curvature2DAngleF0D -/*! Returns a real giving the 2D curvature (as an angle) of the 1D element to which the +/** Returns a real giving the 2D curvature (as an angle) of the 1D element to which the * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this * Interface0DIterator&. */ class Curvature2DAngleF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "Curvature2DAngleF0D" */ + /** Returns the string "Curvature2DAngleF0D" */ string getName() const { return "Curvature2DAngleF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // ZDiscontinuity -/*! Returns a real giving the distance between and Interface0D and the shape that lies behind +/** Returns a real giving the distance between and Interface0D and the shape that lies behind * (occludee). This distance is evaluated in the camera space and normalized between 0 and 1. * Therefore, if no object is occluded by the shape to which the Interface0D belongs to, 1 is * returned. */ class ZDiscontinuityF0D : public UnaryFunction0D<double> { public: - /*! Returns the string "ZDiscontinuityF0D" */ + /** Returns the string "ZDiscontinuityF0D" */ string getName() const { return "ZDiscontinuityF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // Normal2DF0D -/*! Returns a Vec2f giving the normalized 2D normal to the 1D element to which the +/** Returns a Vec2f giving the normalized 2D normal to the 1D element to which the * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this * Interface0DIterator&. */ class Normal2DF0D : public UnaryFunction0D<Vec2f> { public: - /*! Returns the string "Normal2DF0D" */ + /** Returns the string "Normal2DF0D" */ string getName() const { return "Normal2DF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // MaterialF0D -/*! Returns the material of the object evaluated at the Interface0D. +/** Returns the material of the object evaluated at the Interface0D. * This evaluation can be ambiguous (in the case of a TVertex for example. * This functor tries to remove this ambiguity using the context offered by the 1D element to * which the Interface0DIterator& belongs to and by arbitrary choosing the material of the face @@ -379,18 +379,18 @@ class Normal2DF0D : public UnaryFunction0D<Vec2f> { */ class MaterialF0D : public UnaryFunction0D<FrsMaterial> { public: - /*! Returns the string "MaterialF0D" */ + /** Returns the string "MaterialF0D" */ string getName() const { return "MaterialF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // ShapeIdF0D -/*! Returns the Id of the Shape the Interface0D belongs to. +/** Returns the Id of the Shape the Interface0D belongs to. * This evaluation can be ambiguous (in the case of a TVertex for example). * This functor tries to remove this ambiguity using the context offered by the 1D element to * which the Interface0DIterator& belongs to. However, there still can be problematic cases, and @@ -399,18 +399,18 @@ class MaterialF0D : public UnaryFunction0D<FrsMaterial> { */ class ShapeIdF0D : public UnaryFunction0D<Id> { public: - /*! Returns the string "ShapeIdF0D" */ + /** Returns the string "ShapeIdF0D" */ string getName() const { return "ShapeIdF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // QiF0D -/*! Returns the quantitative invisibility of this Interface0D. +/** Returns the quantitative invisibility of this Interface0D. * This evaluation can be ambiguous (in the case of a TVertex for example). * This functor tries to remove this ambiguity using the context offered by the 1D element to * which the Interface0DIterator& belongs to. However, there still can be problematic cases, and @@ -419,69 +419,69 @@ class ShapeIdF0D : public UnaryFunction0D<Id> { */ class QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int> { public: - /*! Returns the string "QuantitativeInvisibilityF0D" */ + /** Returns the string "QuantitativeInvisibilityF0D" */ string getName() const { return "QuantitativeInvisibilityF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // CurveNatureF0D -/*! Returns the Nature::EdgeNature of the 1D element the Interface0DIterator& belongs to. */ +/** Returns the Nature::EdgeNature of the 1D element the Interface0DIterator& belongs to. */ class CurveNatureF0D : public UnaryFunction0D<Nature::EdgeNature> { public: - /*! Returns the string "QuantitativeInvisibilityF0D" */ + /** Returns the string "QuantitativeInvisibilityF0D" */ string getName() const { return "CurveNatureF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // GetShapeF0D -/*! Returns the ViewShape* containing the Interface0D */ +/** Returns the ViewShape* containing the Interface0D */ class GetShapeF0D : public UnaryFunction0D<ViewShape *> { public: - /*! Returns the string "GetShapeF0D" */ + /** Returns the string "GetShapeF0D" */ string getName() const { return "GetShapeF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // GetOccludersF0D -/*! Returns a vector containing the ViewShape* occluding the Interface0D */ +/** Returns a vector containing the ViewShape* occluding the Interface0D */ class GetOccludersF0D : public UnaryFunction0D<std::vector<ViewShape *>> { public: - /*! Returns the string "GetOccludersF0D" */ + /** Returns the string "GetOccludersF0D" */ string getName() const { return "GetOccludersF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // GetOccludeeF0D -/*! Returns the ViewShape* "occluded" by the Interface0D */ +/** Returns the ViewShape* "occluded" by the Interface0D */ class GetOccludeeF0D : public UnaryFunction0D<ViewShape *> { public: - /*! Returns the string "GetOccludeeF0D" */ + /** Returns the string "GetOccludeeF0D" */ string getName() const { return "GetOccludeeF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; diff --git a/source/blender/freestyle/intern/view_map/Functions1D.h b/source/blender/freestyle/intern/view_map/Functions1D.h index 9cf5527ee19..532e89261ce 100644 --- a/source/blender/freestyle/intern/view_map/Functions1D.h +++ b/source/blender/freestyle/intern/view_map/Functions1D.h @@ -42,7 +42,7 @@ namespace Freestyle { // /////////////////////////////////////////////////////////// -/*! Base class for Unary Functions (functors) working on Interface1D. +/** Base class for Unary Functions (functors) working on Interface1D. * A unary function will be used by calling its operator() on an Interface1D. * \attention In the scripting language, there exists several prototypes depending on the returned * value type. For example, you would inherit from a UnaryFunction1DDouble if you wish to define a @@ -61,16 +61,16 @@ template<class T> class UnaryFunction1D { T result; void *py_uf1D; - /*! The type of the value returned by the functor. */ + /** The type of the value returned by the functor. */ typedef T ReturnedValueType; - /*! Default constructor */ + /** Default constructor */ UnaryFunction1D() { _integration = MEAN; } - /*! Builds a UnaryFunction1D from an integration type. + /** Builds a UnaryFunction1D from an integration type. * \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. @@ -81,18 +81,18 @@ template<class T> class UnaryFunction1D { _integration = iType; } - /*! destructor. */ + /** destructor. */ virtual ~UnaryFunction1D() { } - /*! returns the string "UnaryFunction1D". */ + /** returns the string "UnaryFunction1D". */ virtual string getName() const { return "UnaryFunction1D"; } - /*! The operator (). + /** The operator (). * \param inter: * The Interface1D on which we wish to evaluate the function. * \return the result of the function of type T. @@ -103,13 +103,13 @@ template<class T> class UnaryFunction1D { return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inter); } - /*! Sets the integration method */ + /** Sets the integration method */ void setIntegrationType(IntegrationType integration) { _integration = integration; } - /*! Returns the integration method. */ + /** Returns the integration method. */ IntegrationType getIntegrationType() const { return _integration; @@ -178,13 +178,13 @@ class UnaryFunction1D_void { namespace Functions1D { // GetXF1D -/*! Returns the X 3D coordinate of an Interface1D. */ +/** Returns the X 3D coordinate of an Interface1D. */ class GetXF1D : public UnaryFunction1D<double> { private: Functions0D::GetXF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -192,24 +192,24 @@ class GetXF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "GetXF1D" */ + /** Returns the string "GetXF1D" */ string getName() const { return "GetXF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetYF1D -/*! Returns the Y 3D coordinate of an Interface1D. */ +/** Returns the Y 3D coordinate of an Interface1D. */ class GetYF1D : public UnaryFunction1D<double> { private: Functions0D::GetYF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -217,24 +217,24 @@ class GetYF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "GetYF1D" */ + /** Returns the string "GetYF1D" */ string getName() const { return "GetYF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetZF1D -/*! Returns the Z 3D coordinate of an Interface1D. */ +/** Returns the Z 3D coordinate of an Interface1D. */ class GetZF1D : public UnaryFunction1D<double> { private: Functions0D::GetZF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -242,24 +242,24 @@ class GetZF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "GetZF1D" */ + /** Returns the string "GetZF1D" */ string getName() const { return "GetZF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetProjectedXF1D -/*! Returns the projected X 3D coordinate of an Interface1D. */ +/** Returns the projected X 3D coordinate of an Interface1D. */ class GetProjectedXF1D : public UnaryFunction1D<double> { private: Functions0D::GetProjectedXF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -267,24 +267,24 @@ class GetProjectedXF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "GetProjectedXF1D" */ + /** Returns the string "GetProjectedXF1D" */ string getName() const { return "GetProjectedXF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetProjectedYF1D -/*! Returns the projected Y 3D coordinate of an Interface1D. */ +/** Returns the projected Y 3D coordinate of an Interface1D. */ class GetProjectedYF1D : public UnaryFunction1D<double> { private: Functions0D::GetProjectedYF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -292,24 +292,24 @@ class GetProjectedYF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "GetProjectedYF1D" */ + /** Returns the string "GetProjectedYF1D" */ string getName() const { return "GetProjectedYF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetProjectedZF1D -/*! Returns the projected Z 3D coordinate of an Interface1D. */ +/** Returns the projected Z 3D coordinate of an Interface1D. */ class GetProjectedZF1D : public UnaryFunction1D<double> { private: Functions0D::GetProjectedZF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -317,24 +317,24 @@ class GetProjectedZF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "GetProjectedZF1D" */ + /** Returns the string "GetProjectedZF1D" */ string getName() const { return "GetProjectedZF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // Orientation2DF1D -/*! Returns the 2D orientation as a Vec2f*/ +/** Returns the 2D orientation as a Vec2f*/ class Orientation2DF1D : public UnaryFunction1D<Vec2f> { private: Functions0D::VertexOrientation2DF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -342,24 +342,24 @@ class Orientation2DF1D : public UnaryFunction1D<Vec2f> { { } - /*! Returns the string "Orientation2DF1D" */ + /** Returns the string "Orientation2DF1D" */ string getName() const { return "Orientation2DF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // Orientation3DF1D -/*! Returns the 3D orientation as a Vec3f. */ +/** Returns the 3D orientation as a Vec3f. */ class Orientation3DF1D : public UnaryFunction1D<Vec3f> { private: Functions0D::VertexOrientation3DF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -367,18 +367,18 @@ class Orientation3DF1D : public UnaryFunction1D<Vec3f> { { } - /*! Returns the string "Orientation3DF1D" */ + /** Returns the string "Orientation3DF1D" */ string getName() const { return "Orientation3DF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // ZDiscontinuityF1D -/*! Returns a real giving the distance between and Interface1D and the shape that lies behind +/** Returns a real giving the distance between and Interface1D and the shape that lies behind * (occludee). This distance is evaluated in the camera space and normalized between 0 and 1. * Therefore, if no object is occluded by the shape to which the Interface1D belongs to, 1 is * returned. @@ -388,7 +388,7 @@ class ZDiscontinuityF1D : public UnaryFunction1D<double> { Functions0D::ZDiscontinuityF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -396,18 +396,18 @@ class ZDiscontinuityF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "ZDiscontinuityF1D" */ + /** Returns the string "ZDiscontinuityF1D" */ string getName() const { return "ZDiscontinuityF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // QuantitativeInvisibilityF1D -/*! Returns the Quantitative Invisibility of an Interface1D element. +/** Returns the Quantitative Invisibility of an Interface1D element. * If the Interface1D is a ViewEdge, then there is no ambiguity concerning the result. But, if the * Interface1D results of a chaining (chain, stroke), then it might be made of several 1D elements * of different Quantitative Invisibilities. @@ -417,7 +417,7 @@ class QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned> { Functions0D::QuantitativeInvisibilityF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -425,18 +425,18 @@ class QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned> { { } - /*! Returns the string "QuantitativeInvisibilityF1D" */ + /** Returns the string "QuantitativeInvisibilityF1D" */ string getName() const { return "QuantitativeInvisibilityF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // CurveNatureF1D -/*! Returns the nature of the Interface1D (silhouette, ridge, crease...). +/** Returns the nature of the Interface1D (silhouette, ridge, crease...). * Except if the Interface1D is a ViewEdge, this result might be ambiguous. * Indeed, the Interface1D might result from the gathering of several 1D elements, each one being * of a different nature. An integration method, such as the MEAN, might give, in this case, @@ -447,7 +447,7 @@ class CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature> { Functions0D::CurveNatureF0D _func; public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -455,63 +455,63 @@ class CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature> { { } - /*! Returns the string "CurveNatureF1D" */ + /** Returns the string "CurveNatureF1D" */ string getName() const { return "CurveNatureF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // TimeStampF1D -/*! Returns the time stamp of the Interface1D. */ +/** Returns the time stamp of the Interface1D. */ class TimeStampF1D : public UnaryFunction1D_void { public: - /*! Returns the string "TimeStampF1D" */ + /** Returns the string "TimeStampF1D" */ string getName() const { return "TimeStampF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // IncrementChainingTimeStampF1D -/*! Increments the chaining time stamp of the Interface1D. */ +/** Increments the chaining time stamp of the Interface1D. */ class IncrementChainingTimeStampF1D : public UnaryFunction1D_void { public: - /*! Returns the string "IncrementChainingTimeStampF1D" */ + /** Returns the string "IncrementChainingTimeStampF1D" */ string getName() const { return "IncrementChainingTimeStampF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // ChainingTimeStampF1D -/*! Sets the chaining time stamp of the Interface1D. */ +/** Sets the chaining time stamp of the Interface1D. */ class ChainingTimeStampF1D : public UnaryFunction1D_void { public: - /*! Returns the string "ChainingTimeStampF1D" */ + /** Returns the string "ChainingTimeStampF1D" */ string getName() const { return "ChainingTimeStampF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // Curvature2DAngleF1D -/*! Returns the 2D curvature as an angle for an Interface1D. */ +/** Returns the 2D curvature as an angle for an Interface1D. */ class Curvature2DAngleF1D : public UnaryFunction1D<double> { public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -519,13 +519,13 @@ class Curvature2DAngleF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "Curvature2DAngleF1D" */ + /** Returns the string "Curvature2DAngleF1D" */ string getName() const { return "Curvature2DAngleF1D"; } - /*! the () operator.*/ + /** the () operator.*/ int operator()(Interface1D &inter) { result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration); @@ -537,10 +537,10 @@ class Curvature2DAngleF1D : public UnaryFunction1D<double> { }; // Normal2DF1D -/*! Returns the 2D normal for an interface 1D. */ +/** Returns the 2D normal for an interface 1D. */ class Normal2DF1D : public UnaryFunction1D<Vec2f> { public: - /*! Builds the functor. + /** Builds the functor. * \param iType: * The integration method used to compute a single value from a set of values. */ @@ -548,13 +548,13 @@ class Normal2DF1D : public UnaryFunction1D<Vec2f> { { } - /*! Returns the string "Normal2DF1D" */ + /** Returns the string "Normal2DF1D" */ string getName() const { return "Normal2DF1D"; } - /*! the () operator.*/ + /** the () operator.*/ int operator()(Interface1D &inter) { result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration); @@ -566,59 +566,59 @@ class Normal2DF1D : public UnaryFunction1D<Vec2f> { }; // GetShapeF1D -/*! Returns list of shapes covered by this Interface1D. */ +/** Returns list of shapes covered by this Interface1D. */ class GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape *>> { public: - /*! Builds the functor. */ + /** Builds the functor. */ GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape *>>() { } - /*! Returns the string "GetShapeF1D" */ + /** Returns the string "GetShapeF1D" */ string getName() const { return "GetShapeF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetOccludersF1D -/*! Returns list of occluding shapes covered by this Interface1D. */ +/** Returns list of occluding shapes covered by this Interface1D. */ class GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape *>> { public: - /*! Builds the functor. */ + /** Builds the functor. */ GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape *>>() { } - /*! Returns the string "GetOccludersF1D" */ + /** Returns the string "GetOccludersF1D" */ string getName() const { return "GetOccludersF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetOccludeeF1D -/*! Returns list of occluded shapes covered by this Interface1D. */ +/** Returns list of occluded shapes covered by this Interface1D. */ class GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape *>> { public: - /*! Builds the functor. */ + /** Builds the functor. */ GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape *>>() { } - /*! Returns the string "GetOccludeeF1D" */ + /** Returns the string "GetOccludeeF1D" */ string getName() const { return "GetOccludeeF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; diff --git a/source/blender/freestyle/intern/view_map/Interface0D.h b/source/blender/freestyle/intern/view_map/Interface0D.h index 6b4682cc862..065319578e5 100644 --- a/source/blender/freestyle/intern/view_map/Interface0D.h +++ b/source/blender/freestyle/intern/view_map/Interface0D.h @@ -51,18 +51,18 @@ class ViewVertex; class NonTVertex; class TVertex; -/*! Base class for any 0D element. */ +/** Base class for any 0D element. */ class Interface0D { public: - /*! Default constructor */ + /** Default constructor */ Interface0D() { } - /*! Destructor */ + /** Destructor */ virtual ~Interface0D(){}; - /*! Returns the string "Interface0D". */ + /** Returns the string "Interface0D". */ virtual string getExactTypeName() const { return "Interface0D"; @@ -70,50 +70,50 @@ class Interface0D { // Data access methods - /*! Returns the 3D x coordinate of the point. */ + /** Returns the 3D x coordinate of the point. */ virtual real getX() const; - /*! Returns the 3D y coordinate of the point. */ + /** Returns the 3D y coordinate of the point. */ virtual real getY() const; - /*! Returns the 3D z coordinate of the point. */ + /** Returns the 3D z coordinate of the point. */ virtual real getZ() const; - /*! Returns the 3D point. */ + /** Returns the 3D point. */ virtual Geometry::Vec3r getPoint3D() const; - /*! Returns the 2D x coordinate of the point. */ + /** Returns the 2D x coordinate of the point. */ virtual real getProjectedX() const; - /*! Returns the 2D y coordinate of the point. */ + /** Returns the 2D y coordinate of the point. */ virtual real getProjectedY() const; - /*! Returns the 2D z coordinate of the point. */ + /** Returns the 2D z coordinate of the point. */ virtual real getProjectedZ() const; - /*! Returns the 2D point. */ + /** Returns the 2D point. */ virtual Geometry::Vec2r getPoint2D() const; - /*! Returns the FEdge that lies between this Interface0D and the Interface0D given as argument. + /** Returns the FEdge that lies between this Interface0D and the Interface0D given as argument. */ virtual FEdge *getFEdge(Interface0D &); - /*! Returns the Id of the point. */ + /** Returns the Id of the point. */ virtual Id getId() const; - /*! Returns the nature of the point. */ + /** Returns the nature of the point. */ virtual Nature::VertexNature getNature() const; - /*! Cast the Interface0D in SVertex if it can be. */ + /** Cast the Interface0D in SVertex if it can be. */ virtual SVertex *castToSVertex(); - /*! Cast the Interface0D in ViewVertex if it can be. */ + /** Cast the Interface0D in ViewVertex if it can be. */ virtual ViewVertex *castToViewVertex(); - /*! Cast the Interface0D in NonTVertex if it can be. */ + /** Cast the Interface0D in NonTVertex if it can be. */ virtual NonTVertex *castToNonTVertex(); - /*! Cast the Interface0D in TVertex if it can be. */ + /** Cast the Interface0D in TVertex if it can be. */ virtual TVertex *castToTVertex(); #ifdef WITH_CXX_GUARDEDALLOC @@ -159,10 +159,10 @@ class Interface0DIteratorNested : public Iterator { return !(*this == it); } - /*! Returns the curvilinear abscissa */ + /** Returns the curvilinear abscissa */ virtual float t() const = 0; - /*! Returns the point parameter 0<u<1 */ + /** Returns the point parameter 0<u<1 */ virtual float u() const = 0; virtual Interface0DIteratorNested *copy() const = 0; @@ -173,7 +173,7 @@ class Interface0DIteratorNested : public Iterator { // ////////////////////////////////////////////////// -/*! Class defining an iterator over Interface0D elements. +/** Class defining an iterator over Interface0D elements. * An instance of this iterator is always obtained from a 1D element. * \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1) * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2 Interface0DIterator. @@ -186,13 +186,13 @@ class Interface0DIterator : public Iterator { _iterator = it; } - /*! Copy constructor */ + /** Copy constructor */ Interface0DIterator(const Interface0DIterator &it) { _iterator = it._iterator->copy(); } - /*! Destructor */ + /** Destructor */ virtual ~Interface0DIterator() { if (_iterator) { @@ -200,7 +200,7 @@ class Interface0DIterator : public Iterator { } } - /*! Operator = + /** Operator = * \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1) * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2 * Interface0DIterator. Otherwise, incrementing \a it1 will also increment \a it2. @@ -214,7 +214,7 @@ class Interface0DIterator : public Iterator { return *this; } - /*! Returns the string "Interface0DIterator". */ + /** Returns the string "Interface0DIterator". */ virtual string getExactTypeName() const { if (!_iterator) { @@ -225,7 +225,7 @@ class Interface0DIterator : public Iterator { // FIXME test it != 0 (exceptions ?) - /*! Returns a reference to the pointed Interface0D. + /** Returns a reference to the pointed Interface0D. * In the scripting language, you must call "getObject()" instead using this operator. */ Interface0D &operator*() @@ -233,7 +233,7 @@ class Interface0DIterator : public Iterator { return _iterator->operator*(); } - /*! Returns a pointer to the pointed Interface0D. + /** Returns a pointer to the pointed Interface0D. * Can't be called in the scripting language. */ Interface0D *operator->() @@ -241,14 +241,14 @@ class Interface0DIterator : public Iterator { return &(operator*()); } - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ Interface0DIterator &operator++() { _iterator->increment(); return *this; } - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ Interface0DIterator operator++(int) { Interface0DIterator ret(*this); @@ -256,14 +256,14 @@ class Interface0DIterator : public Iterator { return ret; } - /*! Decrements. In the scripting language, call "decrement()". */ + /** Decrements. In the scripting language, call "decrement()". */ Interface0DIterator &operator--() { _iterator->decrement(); return *this; } - /*! Decrements. In the scripting language, call "decrement()". */ + /** Decrements. In the scripting language, call "decrement()". */ Interface0DIterator operator--(int) { Interface0DIterator ret(*this); @@ -271,19 +271,19 @@ class Interface0DIterator : public Iterator { return ret; } - /*! Increments. */ + /** Increments. */ virtual int increment() { return _iterator->increment(); } - /*! Decrements. */ + /** Decrements. */ virtual int decrement() { return _iterator->decrement(); } - /*! Returns true if the pointed Interface0D is the first of the 1D element containing the points + /** Returns true if the pointed Interface0D is the first of the 1D element containing the points * over which we're iterating. */ virtual bool isBegin() const @@ -291,14 +291,14 @@ class Interface0DIterator : public Iterator { return _iterator->isBegin(); } - /*! Returns true if the pointed Interface0D is after the after the last point of the 1D element + /** Returns true if the pointed Interface0D is after the after the last point of the 1D element * we're iterating from. */ virtual bool isEnd() const { return _iterator->isEnd(); } - /*! Returns true when the iterator is pointing to the final valid element. */ + /** Returns true when the iterator is pointing to the final valid element. */ virtual bool atLast() const { if (_iterator->isEnd()) { @@ -311,25 +311,25 @@ class Interface0DIterator : public Iterator { return result; } - /*! operator == . */ + /** operator == . */ bool operator==(const Interface0DIterator &it) const { return _iterator->operator==(*(it._iterator)); } - /*! operator != . */ + /** operator != . */ bool operator!=(const Interface0DIterator &it) const { return !(*this == it); } - /*! Returns the curvilinear abscissa. */ + /** Returns the curvilinear abscissa. */ inline float t() const { return _iterator->t(); } - /*! Returns the point parameter in the curve 0<=u<=1. */ + /** Returns the point parameter in the curve 0<=u<=1. */ inline float u() const { return _iterator->u(); diff --git a/source/blender/freestyle/intern/view_map/Interface1D.h b/source/blender/freestyle/intern/view_map/Interface1D.h index 778deb20a60..8d1879af31b 100644 --- a/source/blender/freestyle/intern/view_map/Interface1D.h +++ b/source/blender/freestyle/intern/view_map/Interface1D.h @@ -41,23 +41,23 @@ using namespace std; namespace Freestyle { // Integration method -/*! The different integration methods that can be invoked to integrate into a single value the set +/** The different integration methods that can be invoked to integrate into a single value the set * of values obtained from each 0D element of a 1D element. */ typedef enum { - MEAN, /*!< The value computed for the 1D element is the mean of the values obtained for the 0D + MEAN, /**< The value computed for the 1D element is the mean of the values obtained for the 0D elements.*/ - MIN, /*!< The value computed for the 1D element is the minimum of the values obtained for the 0D + MIN, /**< The value computed for the 1D element is the minimum of the values obtained for the 0D elements.*/ - MAX, /*!< The value computed for the 1D element is the maximum of the values obtained for the 0D + MAX, /**< The value computed for the 1D element is the maximum of the values obtained for the 0D elements.*/ - FIRST, /*!< The value computed for the 1D element is the first of the values obtained for the 0D + FIRST, /**< The value computed for the 1D element is the first of the values obtained for the 0D elements.*/ - LAST, /*!< The value computed for the 1D element is the last of the values obtained for the 0D + LAST, /**< The value computed for the 1D element is the last of the values obtained for the 0D elements.*/ } IntegrationType; -/*! Returns a single value from a set of values evaluated at each 0D element of this 1D element. +/** Returns a single value from a set of values evaluated at each 0D element of this 1D element. * \param fun: * The UnaryFunction0D used to compute a value at each Interface0D. * \param it: @@ -127,19 +127,19 @@ T integrate(UnaryFunction0D<T> &fun, // ////////////////////////////////////////////////// -/*! Base class for any 1D element. */ +/** Base class for any 1D element. */ class Interface1D { public: - /*! Default constructor */ + /** Default constructor */ Interface1D() { _timeStamp = 0; } - /*! Destructor */ + /** Destructor */ virtual ~Interface1D(){}; - /*! Returns the string "Interface1D". */ + /** Returns the string "Interface1D". */ virtual string getExactTypeName() const { return "Interface1D"; @@ -147,13 +147,13 @@ class Interface1D { // Iterator access - /*! Returns an iterator over the Interface1D vertices, pointing to the first vertex. */ + /** Returns an iterator over the Interface1D vertices, pointing to the first vertex. */ virtual Interface0DIterator verticesBegin(); - /*! Returns an iterator over the Interface1D vertices, pointing after the last vertex. */ + /** Returns an iterator over the Interface1D vertices, pointing after the last vertex. */ virtual Interface0DIterator verticesEnd(); - /*! Returns an iterator over the Interface1D points, pointing to the first point. The difference + /** 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. * @@ -161,7 +161,7 @@ class Interface1D { */ virtual Interface0DIterator pointsBegin(float t = 0.0f); - /*! Returns an iterator over the Interface1D points, pointing after the last point. The + /** 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. * @@ -171,23 +171,23 @@ class Interface1D { // Data access methods - /*! Returns the 2D length of the 1D element. */ + /** Returns the 2D length of the 1D element. */ virtual real getLength2D() const; - /*! Returns the Id of the 1D element. */ + /** Returns the Id of the 1D element. */ virtual Id getId() const; // FIXME: ce truc n'a rien a faire la...(c une requete complexe qui doit etre ds les Function1D) - /*! Returns the nature of the 1D element. */ + /** Returns the nature of the 1D element. */ virtual Nature::EdgeNature getNature() const; - /*! Returns the time stamp of the 1D element. Mainly used for selection. */ + /** Returns the time stamp of the 1D element. Mainly used for selection. */ virtual unsigned getTimeStamp() const { return _timeStamp; } - /*! Sets the time stamp for the 1D element. */ + /** Sets the time stamp for the 1D element. */ inline void setTimeStamp(unsigned iTimeStamp) { _timeStamp = iTimeStamp; diff --git a/source/blender/freestyle/intern/view_map/Silhouette.h b/source/blender/freestyle/intern/view_map/Silhouette.h index 28cd140185c..10544f5e883 100644 --- a/source/blender/freestyle/intern/view_map/Silhouette.h +++ b/source/blender/freestyle/intern/view_map/Silhouette.h @@ -66,86 +66,86 @@ class FEdge; class ViewVertex; class SShape; -/*! Class to define a vertex of the embedding. */ +/** Class to define a vertex of the embedding. */ class SVertex : public Interface0D { public: // Implementation of Interface0D - /*! Returns the string "SVertex". */ + /** Returns the string "SVertex". */ virtual string getExactTypeName() const { return "SVertex"; } // Data access methods - /*! Returns the 3D x coordinate of the vertex. */ + /** Returns the 3D x coordinate of the vertex. */ virtual real getX() const { return _Point3D.x(); } - /*! Returns the 3D y coordinate of the vertex. */ + /** Returns the 3D y coordinate of the vertex. */ virtual real getY() const { return _Point3D.y(); } - /*! Returns the 3D z coordinate of the vertex. */ + /** Returns the 3D z coordinate of the vertex. */ 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 vertex. */ + /** Returns the projected 3D x coordinate of the vertex. */ virtual real getProjectedX() const { return _Point2D.x(); } - /*! Returns the projected 3D y coordinate of the vertex. */ + /** Returns the projected 3D y coordinate of the vertex. */ virtual real getProjectedY() const { return _Point2D.y(); } - /*! Returns the projected 3D z coordinate of the vertex. */ + /** Returns the projected 3D z coordinate of the vertex. */ 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()); } - /*! Returns the FEdge that lies between this Svertex and the Interface0D given as argument. */ + /** Returns the FEdge that lies between this Svertex and the Interface0D given as argument. */ virtual FEdge *getFEdge(Interface0D &); - /*! Returns the Id of the vertex. */ + /** Returns the Id of the vertex. */ virtual Id getId() const { return _Id; } - /*! Returns the nature of the vertex. */ + /** Returns the nature of the vertex. */ virtual Nature::VertexNature getNature() const; - /*! Cast the Interface0D in SVertex if it can be. */ + /** Cast the Interface0D in SVertex if it can be. */ virtual SVertex *castToSVertex(); - /*! Cast the Interface0D in ViewVertex if it can be. */ + /** Cast the Interface0D in ViewVertex if it can be. */ virtual ViewVertex *castToViewVertex(); - /*! Cast the Interface0D in NonTVertex if it can be. */ + /** Cast the Interface0D in NonTVertex if it can be. */ virtual NonTVertex *castToNonTVertex(); - /*! Cast the Interface0D in TVertex if it can be. */ + /** Cast the Interface0D in TVertex if it can be. */ virtual TVertex *castToTVertex(); public: @@ -166,12 +166,12 @@ class SVertex : public Interface0D { CurvatureInfo *_curvature_info; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; - /*! Default constructor.*/ + /** Default constructor.*/ inline SVertex() { _Id = 0; @@ -181,7 +181,7 @@ class SVertex : public Interface0D { _curvature_info = 0; } - /*! Builds a SVertex from 3D coordinates and an Id. */ + /** Builds a SVertex from 3D coordinates and an Id. */ inline SVertex(const Vec3r &iPoint3D, const Id &id) { _Point3D = iPoint3D; @@ -192,7 +192,7 @@ class SVertex : public Interface0D { _curvature_info = 0; } - /*! Copy constructor. */ + /** Copy constructor. */ inline SVertex(SVertex &iBrother) { _Id = iBrother._Id; @@ -212,7 +212,7 @@ class SVertex : public Interface0D { userdata = 0; } - /*! Destructor. */ + /** Destructor. */ virtual ~SVertex() { if (_curvature_info) { @@ -220,14 +220,14 @@ class SVertex : public Interface0D { } } - /*! Cloning method. */ + /** Cloning method. */ virtual SVertex *duplicate() { SVertex *clone = new SVertex(*this); return clone; } - /*! operator == */ + /** operator == */ virtual bool operator==(const SVertex &iBrother) { return ((_Point2D == iBrother._Point2D) && (_Point3D == iBrother._Point3D)); @@ -244,7 +244,7 @@ class SVertex : public Interface0D { return _Point2D; } - /*! Returns the set of normals for this Vertex. + /** Returns the set of normals for this Vertex. * In a smooth surface, a vertex has exactly one normal. * In a sharp surface, a vertex can have any number of normals. */ @@ -253,7 +253,7 @@ class SVertex : public Interface0D { return _Normals; } - /*! Returns the number of different normals for this vertex. */ + /** Returns the number of different normals for this vertex. */ inline unsigned normalsSize() const { return _Normals.size(); @@ -284,7 +284,7 @@ class SVertex : public Interface0D { return _Point2D[2]; } - /*! If this SVertex is also a ViewVertex, this method returns a pointer onto this ViewVertex. + /** If this SVertex is also a ViewVertex, this method returns a pointer onto this ViewVertex. * 0 is returned otherwise. */ inline ViewVertex *viewvertex() @@ -292,20 +292,20 @@ class SVertex : public Interface0D { return _pViewVertex; } - /*! modifiers */ - /*! Sets the 3D coordinates of the SVertex. */ + /** modifiers */ + /** Sets the 3D coordinates of the SVertex. */ inline void setPoint3D(const Vec3r &iPoint3D) { _Point3D = iPoint3D; } - /*! Sets the 3D projected coordinates of the SVertex. */ + /** Sets the 3D projected coordinates of the SVertex. */ inline void setPoint2D(const Vec3r &iPoint2D) { _Point2D = iPoint2D; } - /*! Adds a normal to the Svertex's set of normals. If the same normal is already in the set, + /** Adds a normal to the Svertex's set of normals. If the same normal is already in the set, * nothing changes. */ inline void AddNormal(const Vec3r &iNormal) { @@ -348,7 +348,7 @@ class SVertex : public Interface0D { } #endif - /*! Sets the Id */ + /** Sets the Id */ inline void setId(const Id &id) { _Id = id; @@ -369,13 +369,13 @@ class SVertex : public Interface0D { _pViewVertex = iViewVertex; } - /*! Add an FEdge to the list of edges emanating from this SVertex. */ + /** Add an FEdge to the list of edges emanating from this SVertex. */ inline void AddFEdge(FEdge *iFEdge) { _FEdges.push_back(iFEdge); } - /*! Remove an FEdge from the list of edges emanating from this SVertex. */ + /** Remove an FEdge from the list of edges emanating from this SVertex. */ inline void RemoveFEdge(FEdge *iFEdge) { for (vector<FEdge *>::iterator fe = _FEdges.begin(), fend = _FEdges.end(); fe != fend; fe++) { @@ -447,7 +447,7 @@ class SVertex : public Interface0D { inline Vec3r orientation2d() const; inline Vec3r orientation3d() const; inline Vec3r curvature2d_as_vector() const; - /*! angle in radians */ + /** angle in radians */ inline real curvature2d_as_angle() const; #endif @@ -466,7 +466,7 @@ class SVertex : public Interface0D { class ViewEdge; -/*! Base Class for feature edges. +/** Base Class for feature edges. * This FEdge can represent a silhouette, a crease, a ridge/valley, a border or a suggestive * contour. For silhouettes, the FEdge is oriented such as, the visible face lies on the left of * the edge. For borders, the FEdge is oriented such as, the face lies on the left of the edge. An @@ -476,7 +476,7 @@ class ViewEdge; */ class FEdge : public Interface1D { public: // Implementation of Interface0D - /*! Returns the string "FEdge". */ + /** Returns the string "FEdge". */ virtual string getExactTypeName() const { return "FEdge"; @@ -484,7 +484,7 @@ class FEdge : public Interface1D { // Data access methods - /*! Returns the 2D length of the FEdge. */ + /** Returns the 2D length of the FEdge. */ virtual real getLength2D() const { if (!_VertexA || !_VertexB) { @@ -493,7 +493,7 @@ class FEdge : public Interface1D { return (_VertexB->getPoint2D() - _VertexA->getPoint2D()).norm(); } - /*! Returns the Id of the FEdge. */ + /** Returns the Id of the FEdge. */ virtual Id getId() const { return _Id; @@ -533,12 +533,12 @@ class FEdge : public Interface1D { bool _isTemporary; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; - /*! Default constructor */ + /** Default constructor */ inline FEdge() { userdata = NULL; @@ -555,7 +555,7 @@ class FEdge : public Interface1D { _isTemporary = false; } - /*! Builds an FEdge going from vA to vB. */ + /** Builds an FEdge going from vA to vB. */ inline FEdge(SVertex *vA, SVertex *vB) { userdata = NULL; @@ -572,7 +572,7 @@ class FEdge : public Interface1D { _isTemporary = false; } - /*! Copy constructor */ + /** Copy constructor */ inline FEdge(FEdge &iBrother) { _VertexA = iBrother.vertexA(); @@ -594,12 +594,12 @@ class FEdge : public Interface1D { userdata = 0; } - /*! Destructor */ + /** Destructor */ virtual ~FEdge() { } - /*! Cloning method. */ + /** Cloning method. */ virtual FEdge *duplicate() { FEdge *clone = new FEdge(*this); @@ -607,31 +607,31 @@ class FEdge : public Interface1D { } /* accessors */ - /*! Returns the first SVertex. */ + /** Returns the first SVertex. */ inline SVertex *vertexA() { return _VertexA; } - /*! Returns the second SVertex. */ + /** Returns the second SVertex. */ inline SVertex *vertexB() { return _VertexB; } - /*! Returns the first SVertex if i=0, the second SVertex if i=1. */ + /** Returns the first SVertex if i=0, the second SVertex if i=1. */ inline SVertex *operator[](const unsigned short int &i) const { return (i % 2 == 0) ? _VertexA : _VertexB; } - /*! Returns the nature of the FEdge. */ + /** Returns the nature of the FEdge. */ inline Nature::EdgeNature getNature() const { return _Nature; } - /*! Returns the FEdge following this one in the ViewEdge. + /** Returns the FEdge following this one in the ViewEdge. * If this FEdge is the last of the ViewEdge, 0 is returned. */ inline FEdge *nextEdge() @@ -639,7 +639,7 @@ class FEdge : public Interface1D { return _NextEdge; } - /*! Returns the Edge preceding this one in the ViewEdge. + /** Returns the Edge preceding this one in the ViewEdge. * If this FEdge is the first one of the ViewEdge, 0 is returned. */ inline FEdge *previousEdge() @@ -668,7 +668,7 @@ class FEdge : public Interface1D { } #endif - /*! Returns a pointer to the ViewEdge to which this FEdge belongs to. */ + /** Returns a pointer to the ViewEdge to which this FEdge belongs to. */ inline ViewEdge *viewedge() const { return _ViewEdge; @@ -716,7 +716,7 @@ class FEdge : public Interface1D { return _occludeeEmpty; } - /*! Returns true if this FEdge is a smooth FEdge. */ + /** Returns true if this FEdge is a smooth FEdge. */ inline bool isSmooth() const { return _isSmooth; @@ -733,37 +733,37 @@ class FEdge : public Interface1D { } /* modifiers */ - /*! Sets the first SVertex. */ + /** Sets the first SVertex. */ inline void setVertexA(SVertex *vA) { _VertexA = vA; } - /*! Sets the second SVertex. */ + /** Sets the second SVertex. */ inline void setVertexB(SVertex *vB) { _VertexB = vB; } - /*! Sets the FEdge Id . */ + /** Sets the FEdge Id . */ inline void setId(const Id &id) { _Id = id; } - /*! Sets the pointer to the next FEdge. */ + /** Sets the pointer to the next FEdge. */ inline void setNextEdge(FEdge *iEdge) { _NextEdge = iEdge; } - /*! Sets the pointer to the previous FEdge. */ + /** Sets the pointer to the previous FEdge. */ inline void setPreviousEdge(FEdge *iEdge) { _PreviousEdge = iEdge; } - /*! Sets the nature of this FEdge. */ + /** Sets the nature of this FEdge. */ inline void setNature(Nature::EdgeNature iNature) { _Nature = iNature; @@ -776,7 +776,7 @@ class FEdge : public Interface1D { } #endif - /*! Sets the ViewEdge to which this FEdge belongs to. */ + /** Sets the ViewEdge to which this FEdge belongs to. */ inline void setViewEdge(ViewEdge *iViewEdge) { _ViewEdge = iViewEdge; @@ -814,7 +814,7 @@ class FEdge : public Interface1D { _occludeeEmpty = iempty; } - /*! Sets the flag telling whether this FEdge is smooth or sharp. + /** Sets the flag telling whether this FEdge is smooth or sharp. * true for Smooth, false for Sharp. */ inline void setSmooth(bool iFlag) @@ -946,13 +946,13 @@ class FEdge : public Interface1D { #endif // Iterator access (Interface1D) - /*! Returns an iterator over the 2 (!) SVertex pointing to the first SVertex. */ + /** Returns an iterator over the 2 (!) SVertex pointing to the first SVertex. */ virtual inline Interface0DIterator verticesBegin(); - /*! Returns an iterator over the 2 (!) SVertex pointing after the last SVertex. */ + /** Returns an iterator over the 2 (!) SVertex pointing after the last SVertex. */ virtual inline Interface0DIterator verticesEnd(); - /*! Returns an iterator over the FEdge points, pointing to the first point. The difference with + /** 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: @@ -960,7 +960,7 @@ class FEdge : public Interface1D { */ virtual inline Interface0DIterator pointsBegin(float t = 0.0f); - /*! Returns an iterator over the FEdge points, pointing after the last point. The difference with + /** 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: @@ -1138,7 +1138,7 @@ Interface0DIterator FEdge::pointsEnd(float /*t*/) return verticesEnd(); } -/*! Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial edge of the input mesh. +/** Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial edge of the input mesh. * It can be a silhouette, a crease or a border. If it is a crease edge, then it is bordered * by two faces of the mesh. Face a lies on its right whereas Face b lies on its left. * If it is a border edge, then it doesn't have any face on its right, and thus Face a = 0. @@ -1153,27 +1153,27 @@ class FEdgeSharp : public FEdge { bool _bFaceMark; public: - /*! Returns the string "FEdgeSharp" . */ + /** Returns the string "FEdgeSharp" . */ virtual string getExactTypeName() const { return "FEdgeSharp"; } - /*! Default constructor. */ + /** Default constructor. */ inline FEdgeSharp() : FEdge() { _aFrsMaterialIndex = _bFrsMaterialIndex = 0; _aFaceMark = _bFaceMark = false; } - /*! Builds an FEdgeSharp going from vA to vB. */ + /** Builds an FEdgeSharp going from vA to vB. */ inline FEdgeSharp(SVertex *vA, SVertex *vB) : FEdge(vA, vB) { _aFrsMaterialIndex = _bFrsMaterialIndex = 0; _aFaceMark = _bFaceMark = false; } - /*! Copy constructor. */ + /** Copy constructor. */ inline FEdgeSharp(FEdgeSharp &iBrother) : FEdge(iBrother) { _aNormal = iBrother._aNormal; @@ -1184,19 +1184,19 @@ class FEdgeSharp : public FEdge { _bFaceMark = iBrother._bFaceMark; } - /*! Destructor. */ + /** Destructor. */ virtual ~FEdgeSharp() { } - /*! Cloning method. */ + /** Cloning method. */ virtual FEdge *duplicate() { FEdge *clone = new FEdgeSharp(*this); return clone; } - /*! Returns the normal to the face lying on the right of the FEdge. If this FEdge is a border, + /** Returns the normal to the face lying on the right of the FEdge. If this FEdge is a border, * it has no Face on its right and therefore, no normal. */ inline const Vec3r &normalA() @@ -1204,13 +1204,13 @@ class FEdgeSharp : public FEdge { return _aNormal; } - /*! Returns the normal to the face lying on the left of the FEdge. */ + /** Returns the normal to the face lying on the left of the FEdge. */ inline const Vec3r &normalB() { return _bNormal; } - /*! Returns the index of the material of the face lying on the + /** Returns the index of the material of the face lying on the * right of the FEdge. If this FEdge is a border, * it has no Face on its right and therefore, no material. */ @@ -1219,21 +1219,21 @@ class FEdgeSharp : public FEdge { return _aFrsMaterialIndex; } - /*! Returns the material of the face lying on the right of the FEdge. If this FEdge is a border, + /** Returns the material of the face lying on the right of the FEdge. If this FEdge is a border, * it has no Face on its right and therefore, no material. */ const FrsMaterial &aFrsMaterial() const; - /*! Returns the index of the material of the face lying on the left of the FEdge. */ + /** Returns the index of the material of the face lying on the left of the FEdge. */ inline unsigned bFrsMaterialIndex() const { return _bFrsMaterialIndex; } - /*! Returns the material of the face lying on the left of the FEdge. */ + /** Returns the material of the face lying on the left of the FEdge. */ const FrsMaterial &bFrsMaterial() const; - /*! Returns the face mark of the face lying on the right of the FEdge. + /** Returns the face mark of the face lying on the right of the FEdge. * If this FEdge is a border, it has no Face on its right and thus false is returned. */ inline bool aFaceMark() const @@ -1241,43 +1241,43 @@ class FEdgeSharp : public FEdge { return _aFaceMark; } - /*! Returns the face mark of the face lying on the left of the FEdge. */ + /** Returns the face mark of the face lying on the left of the FEdge. */ inline bool bFaceMark() const { return _bFaceMark; } - /*! Sets the normal to the face lying on the right of the FEdge. */ + /** Sets the normal to the face lying on the right of the FEdge. */ inline void setNormalA(const Vec3r &iNormal) { _aNormal = iNormal; } - /*! Sets the normal to the face lying on the left of the FEdge. */ + /** Sets the normal to the face lying on the left of the FEdge. */ inline void setNormalB(const Vec3r &iNormal) { _bNormal = iNormal; } - /*! Sets the index of the material lying on the right of the FEdge.*/ + /** Sets the index of the material lying on the right of the FEdge.*/ inline void setaFrsMaterialIndex(unsigned i) { _aFrsMaterialIndex = i; } - /*! Sets the index of the material lying on the left of the FEdge.*/ + /** Sets the index of the material lying on the left of the FEdge.*/ inline void setbFrsMaterialIndex(unsigned i) { _bFrsMaterialIndex = i; } - /*! Sets the face mark of the face lying on the right of the FEdge. */ + /** Sets the face mark of the face lying on the right of the FEdge. */ inline void setaFaceMark(bool iFaceMark) { _aFaceMark = iFaceMark; } - /*! Sets the face mark of the face lying on the left of the FEdge. */ + /** Sets the face mark of the face lying on the left of the FEdge. */ inline void setbFaceMark(bool iFaceMark) { _bFaceMark = iFaceMark; @@ -1288,7 +1288,7 @@ class FEdgeSharp : public FEdge { #endif }; -/*! Class defining a smooth edge. This kind of edge typically runs across a face of the input mesh. +/** Class defining a smooth edge. This kind of edge typically runs across a face of the input mesh. * It can be a silhouette, a ridge or valley, a suggestive contour. */ class FEdgeSmooth : public FEdge { @@ -1305,13 +1305,13 @@ class FEdgeSmooth : public FEdge { bool _FaceMark; public: - /*! Returns the string "FEdgeSmooth" . */ + /** Returns the string "FEdgeSmooth" . */ virtual string getExactTypeName() const { return "FEdgeSmooth"; } - /*! Default constructor. */ + /** Default constructor. */ inline FEdgeSmooth() : FEdge() { _Face = NULL; @@ -1320,7 +1320,7 @@ class FEdgeSmooth : public FEdge { _isSmooth = true; } - /*! Builds an FEdgeSmooth going from vA to vB. */ + /** Builds an FEdgeSmooth going from vA to vB. */ inline FEdgeSmooth(SVertex *vA, SVertex *vB) : FEdge(vA, vB) { _Face = NULL; @@ -1329,7 +1329,7 @@ class FEdgeSmooth : public FEdge { _isSmooth = true; } - /*! Copy constructor. */ + /** Copy constructor. */ inline FEdgeSmooth(FEdgeSmooth &iBrother) : FEdge(iBrother) { _Normal = iBrother._Normal; @@ -1339,12 +1339,12 @@ class FEdgeSmooth : public FEdge { _isSmooth = true; } - /*! Destructor. */ + /** Destructor. */ virtual ~FEdgeSmooth() { } - /*! Cloning method. */ + /** Cloning method. */ virtual FEdge *duplicate() { FEdge *clone = new FEdgeSmooth(*this); @@ -1356,25 +1356,25 @@ class FEdgeSmooth : public FEdge { return _Face; } - /*! Returns the face mark of the face it is running across. */ + /** Returns the face mark of the face it is running across. */ inline bool faceMark() const { return _FaceMark; } - /*! Returns the normal to the Face it is running across. */ + /** Returns the normal to the Face it is running across. */ inline const Vec3r &normal() { return _Normal; } - /*! Returns the index of the material of the face it is running across. */ + /** Returns the index of the material of the face it is running across. */ inline unsigned frs_materialIndex() const { return _FrsMaterialIndex; } - /*! Returns the material of the face it is running across. */ + /** Returns the material of the face it is running across. */ const FrsMaterial &frs_material() const; inline void setFace(void *iFace) @@ -1382,19 +1382,19 @@ class FEdgeSmooth : public FEdge { _Face = iFace; } - /*! Sets the face mark of the face it is running across. */ + /** Sets the face mark of the face it is running across. */ inline void setFaceMark(bool iFaceMark) { _FaceMark = iFaceMark; } - /*! Sets the normal to the Face it is running across. */ + /** Sets the normal to the Face it is running across. */ inline void setNormal(const Vec3r &iNormal) { _Normal = iNormal; } - /*! Sets the index of the material of the face it is running across. */ + /** Sets the index of the material of the face it is running across. */ inline void setFrsMaterialIndex(unsigned i) { _FrsMaterialIndex = i; @@ -1413,7 +1413,7 @@ class FEdgeSmooth : public FEdge { /* */ /**********************************/ -/*! Class to define a feature shape. It is the gathering of feature elements from an identified +/** Class to define a feature shape. It is the gathering of feature elements from an identified * input shape */ class SShape { private: @@ -1431,12 +1431,12 @@ class SShape { ViewShape *_ViewShape; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; // added by E.T. - /*! Default constructor */ + /** Default constructor */ inline SShape() { userdata = NULL; @@ -1444,7 +1444,7 @@ class SShape { _ViewShape = NULL; } - /*! Copy constructor */ + /** Copy constructor */ inline SShape(SShape &iBrother) { userdata = NULL; @@ -1528,14 +1528,14 @@ class SShape { } } - /*! Cloning method. */ + /** Cloning method. */ virtual SShape *duplicate() { SShape *clone = new SShape(*this); return clone; } - /*! Destructor. */ + /** Destructor. */ virtual inline ~SShape() { vector<SVertex *>::iterator sv, svend; @@ -1561,13 +1561,13 @@ class SShape { } } - /*! Adds a FEdge to the list of FEdges. */ + /** Adds a FEdge to the list of FEdges. */ inline void AddEdge(FEdge *iEdge) { _edgesList.push_back(iEdge); } - /*! Adds a SVertex to the list of SVertex of this Shape. + /** Adds a SVertex to the list of SVertex of this Shape. * The SShape attribute of the SVertex is also set to 'this'. */ inline void AddNewVertex(SVertex *iv) @@ -1589,7 +1589,7 @@ class SShape { return Ia; } - /*! Splits an edge into several edges. + /** Splits an edge into several edges. * The edge's vertices are passed rather than the edge itself. This way, all feature edges * (SILHOUETTE, CREASE, BORDER) are split in the same time. The processed edges are flagged as * done (using the user-data flag).One single new vertex is created whereas several split edges @@ -1773,13 +1773,13 @@ class SShape { return newEdge; } - /*! Sets the Bounding Box of the Shape */ + /** Sets the Bounding Box of the Shape */ inline void setBBox(const BBox<Vec3r> &iBBox) { _BBox = iBBox; } - /*! Compute the bbox of the sshape */ + /** Compute the bbox of the sshape */ inline void ComputeBBox() { if (0 == _verticesList.size()) { @@ -1853,13 +1853,13 @@ class SShape { } /* accessors */ - /*! Returns the list of SVertex of the Shape. */ + /** Returns the list of SVertex of the Shape. */ inline vector<SVertex *> &getVertexList() { return _verticesList; } - /*! Returns the list of FEdges of the Shape. */ + /** Returns the list of FEdges of the Shape. */ inline vector<FEdge *> &getEdgeList() { return _edgesList; @@ -1870,19 +1870,19 @@ class SShape { return _chains; } - /*! Returns the bounding box of the shape. */ + /** Returns the bounding box of the shape. */ inline const BBox<Vec3r> &bbox() { return _BBox; } - /*! Returns the ith material of the shape. */ + /** Returns the ith material of the shape. */ inline const FrsMaterial &frs_material(unsigned i) const { return _FrsMaterials[i]; } - /*! Returns the list of materials of the Shape. */ + /** Returns the list of materials of the Shape. */ inline const vector<FrsMaterial> &frs_materials() const { return _FrsMaterials; @@ -1898,44 +1898,44 @@ class SShape { return _importance; } - /*! Returns the Id of the Shape. */ + /** Returns the Id of the Shape. */ inline Id getId() const { return _Id; } - /*! Returns the name of the Shape. */ + /** Returns the name of the Shape. */ inline const string &getName() const { return _Name; } - /*! Returns the library path of the Shape. */ + /** Returns the library path of the Shape. */ inline const string &getLibraryPath() const { return _LibraryPath; } /* Modififers */ - /*! Sets the Id of the shape.*/ + /** Sets the Id of the shape.*/ inline void setId(Id id) { _Id = id; } - /*! Sets the name of the shape.*/ + /** Sets the name of the shape.*/ inline void setName(const string &name) { _Name = name; } - /*! Sets the library path of the shape.*/ + /** Sets the library path of the shape.*/ inline void setLibraryPath(const string &path) { _LibraryPath = path; } - /*! Sets the list of materials for the shape */ + /** Sets the list of materials for the shape */ inline void setFrsMaterials(const vector<FrsMaterial> &iMaterials) { _FrsMaterials = iMaterials; diff --git a/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h b/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h index 124ef35e5b9..25b2eacd507 100644 --- a/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h +++ b/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h @@ -68,7 +68,7 @@ class SilhouetteGeomEngine { static SilhouetteGeomEngine *_pInstance; public: - /*! retrieves an instance on the singleton */ + /** retrieves an instance on the singleton */ static SilhouetteGeomEngine *getInstance() { if (_pInstance == NULL) { @@ -77,13 +77,13 @@ class SilhouetteGeomEngine { return _pInstance; } - /*! Sets the current viewpoint */ + /** Sets the current viewpoint */ static inline void setViewpoint(const Vec3r &ivp) { _Viewpoint = ivp; } - /*! Sets the current transformation + /** Sets the current transformation * iModelViewMatrix * The 4x4 model view matrix, in column major order (openGL like). * iProjection matrix @@ -98,13 +98,13 @@ class SilhouetteGeomEngine { const int iViewport[4], real iFocal); - /*! Sets the current znear and zfar */ + /** Sets the current znear and zfar */ static void setFrustum(real iZNear, real iZFar); /* accessors */ static void retrieveViewport(int viewport[4]); - /*! Projects the silhouette in camera coordinates + /** Projects the silhouette in camera coordinates * This method modifies the ioEdges passed as argument. * ioVertices * The vertices to project. It is modified during the operation. @@ -112,7 +112,7 @@ class SilhouetteGeomEngine { static void ProjectSilhouette(std::vector<SVertex *> &ioVertices); static void ProjectSilhouette(SVertex *ioVertex); - /*! transforms the parameter t defining a 2D intersection for edge fe in order to obtain + /** transforms the parameter t defining a 2D intersection for edge fe in order to obtain * the parameter giving the corresponding 3D intersection. * Returns the 3D parameter * fe @@ -122,10 +122,10 @@ class SilhouetteGeomEngine { */ static real ImageToWorldParameter(FEdge *fe, real t); - /*! From world to image */ + /** From world to image */ static Vec3r WorldToImage(const Vec3r &M); - /*! From camera to image */ + /** From camera to image */ static Vec3r CameraToImage(const Vec3r &M); #ifdef WITH_CXX_GUARDEDALLOC diff --git a/source/blender/freestyle/intern/view_map/SphericalGrid.h b/source/blender/freestyle/intern/view_map/SphericalGrid.h index efa3530cb2a..ae052ff3e12 100644 --- a/source/blender/freestyle/intern/view_map/SphericalGrid.h +++ b/source/blender/freestyle/intern/view_map/SphericalGrid.h @@ -87,7 +87,7 @@ class SphericalGrid { }; public: - /*! Iterator needs to allow the user to avoid full 3D comparison in two cases: + /** Iterator needs to allow the user to avoid full 3D comparison in two cases: * * (1) Where (*current)->deepest < target[2], where the occluder is unambiguously in front of * the target point. diff --git a/source/blender/freestyle/intern/view_map/SteerableViewMap.h b/source/blender/freestyle/intern/view_map/SteerableViewMap.h index e03400dbbc0..d007a08c3fd 100644 --- a/source/blender/freestyle/intern/view_map/SteerableViewMap.h +++ b/source/blender/freestyle/intern/view_map/SteerableViewMap.h @@ -42,7 +42,7 @@ class FEdge; class ImagePyramid; class GrayImage; -/*! This class checks for every FEdge in which steerable it belongs and stores the mapping +/** This class checks for every FEdge in which steerable it belongs and stores the mapping * allowing to retrieve this information from the FEdge Id. */ class SteerableViewMap { @@ -62,31 +62,31 @@ class SteerableViewMap { SteerableViewMap(const SteerableViewMap &iBrother); virtual ~SteerableViewMap(); - /*! Resets everything */ + /** Resets everything */ virtual void Reset(); - /*! Adds a FEdge to steerable VM. + /** Adds a FEdge to steerable VM. * Returns the nbOrientations weights corresponding to the FEdge contributions to the * nbOrientations directional maps. */ double *AddFEdge(FEdge *iFEdge); - /*! Compute the weight of direction dir for orientation iNOrientation */ + /** Compute the weight of direction dir for orientation iNOrientation */ double ComputeWeight(const Vec2d &dir, unsigned iNOrientation); - /*! Returns the number of the SVM to which a direction belongs to. + /** Returns the number of the SVM to which a direction belongs to. * \param dir: * The direction */ unsigned getSVMNumber(Vec2f dir); - /*! Returns the number of the SVM to which a FEdge belongs most. + /** Returns the number of the SVM to which a FEdge belongs most. * \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 + /** Builds _nbOrientations+1 pyramids of images from the _nbOrientations+1 base images of the * steerable viewmap. * \param steerableBases: * The _nbOrientations+1 images constituting the basis for the steerable pyramid. @@ -105,7 +105,7 @@ class SteerableViewMap { unsigned iNbLevels = 4, float iSigma = 1.0f); - /*! Reads a pixel value in one of the VewMap density steerable pyramids. + /** Reads a pixel value in one of the VewMap density steerable pyramids. * Returns a value between 0 and 1. * \param iOrientation: * the number telling which orientation we need to check. @@ -126,23 +126,23 @@ class SteerableViewMap { */ float readSteerableViewMapPixel(unsigned iOrientation, int iLevel, int x, int y); - /*! Reads a pixel in the one of the level of the pyramid containing the images + /** Reads a pixel in the one of the level of the pyramid containing the images * of the complete ViewMap. * Returns a value between 0 and 1. * Equivalent to : readSteerableViewMapPixel(nbOrientations, x, y) */ float readCompleteViewMapPixel(int iLevel, int x, int y); - /*! Returns the number of levels in the pyramids */ + /** Returns the number of levels in the pyramids */ unsigned int getNumberOfPyramidLevels() const; - /*! Returns the number of orientations */ + /** Returns the number of orientations */ unsigned int getNumberOfOrientations() const { return _nbOrientations; } - /*! for debug purposes */ + /** for debug purposes */ void saveSteerableViewMap() const; protected: diff --git a/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h index 6bc9cd2da59..d181348b3da 100644 --- a/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h +++ b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h @@ -53,7 +53,7 @@ using namespace Geometry; class SVertex; -/*! Defines a hash table used for searching the SVertex */ +/** Defines a hash table used for searching the SVertex */ struct SVertexHasher { #define _MUL 950706376UL #define _MOD 2147483647UL @@ -81,7 +81,7 @@ typedef map<Vec3r, SVertex *> SVertexMap; class WXFaceLayer; -/*! class to describe an oriented smooth edge */ +/** class to describe an oriented smooth edge */ class OWXFaceLayer { public: WXFaceLayer *fl; @@ -123,7 +123,7 @@ class OWXFaceLayer { class WXEdge; -/*! class to describe an oriented sharp edge */ +/** class to describe an oriented sharp edge */ class OWXEdge { public: WXEdge *e; @@ -190,7 +190,7 @@ class ViewEdgeXBuilder { { } - /*! Builds a view shape from a WXShape in which the feature edges are flagged + /** Builds a view shape from a WXShape in which the feature edges are flagged * Builds chains of feature edges (so ViewEdges) from a WXShape * iWShape * The Winged Edge structure in which all silhouette edges and vertices are flagged. @@ -212,14 +212,14 @@ class ViewEdgeXBuilder { std::vector<FEdge *> &ioFEdges, std::vector<SVertex *> &ioSVertices); - /*! Builds a smooth view edge, starting the face iFace. */ + /** Builds a smooth view edge, starting the face iFace. */ ViewEdge *BuildSmoothViewEdge(const OWXFaceLayer &iFaceLayer); - /*! Makes a sharp viewedge. */ + /** Makes a sharp viewedge. */ ViewEdge *BuildSharpViewEdge(const OWXEdge &iWEdge); public: - /*! accessors */ + /** accessors */ inline int currentViewId() const { return _currentViewId; @@ -235,7 +235,7 @@ class ViewEdgeXBuilder { return _currentSVertexId; } - /*! modifiers */ + /** modifiers */ inline void setCurrentViewId(int id) { _currentViewId = id; @@ -252,18 +252,18 @@ class ViewEdgeXBuilder { } protected: - /*! Init the view edges building */ + /** Init the view edges building */ virtual void Init(ViewShape *oVShape); // SMOOTH // - /*! checks whether a face has already been processed or not */ + /** checks whether a face has already been processed or not */ bool stopSmoothViewEdge(WXFaceLayer *iFaceLayer); OWXFaceLayer FindNextFaceLayer(const OWXFaceLayer &iFaceLayer); OWXFaceLayer FindPreviousFaceLayer(const OWXFaceLayer &iFaceLayer); FEdge *BuildSmoothFEdge(FEdge *feprevious, const OWXFaceLayer &ifl); // SHARP // - /*! checks whether a WEdge has already been processed or not */ + /** checks whether a WEdge has already been processed or not */ bool stopSharpViewEdge(WXEdge *iEdge); int retrieveFaceMarks(WXEdge *iEdge); OWXEdge FindNextWEdge(const OWXEdge &iEdge); @@ -271,11 +271,11 @@ class ViewEdgeXBuilder { FEdge *BuildSharpFEdge(FEdge *feprevious, const OWXEdge &iwe); // GENERAL // - /*! Instantiate a SVertex */ + /** Instantiate a SVertex */ SVertex *MakeSVertex(Vec3r &iPoint); - /*! Instantiate a SVertex if it hasn't been already created */ + /** Instantiate a SVertex if it hasn't been already created */ SVertex *MakeSVertex(Vec3r &iPoint, bool shared); - /*! instantiate a ViewVertex from a SVertex, if it doesn't exist yet */ + /** instantiate a ViewVertex from a SVertex, if it doesn't exist yet */ ViewVertex *MakeViewVertex(SVertex *iSVertex); // oldtmp values diff --git a/source/blender/freestyle/intern/view_map/ViewMap.cpp b/source/blender/freestyle/intern/view_map/ViewMap.cpp index 13ee2851c6c..f1b00724793 100644 --- a/source/blender/freestyle/intern/view_map/ViewMap.cpp +++ b/source/blender/freestyle/intern/view_map/ViewMap.cpp @@ -432,7 +432,7 @@ void TVertex::Replace(ViewEdge *iOld, ViewEdge *iNew) } } -/*! iterators access */ +/** iterators access */ ViewVertex::edge_iterator TVertex::edges_begin() { // return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, _FrontEdgeA); @@ -584,7 +584,7 @@ void NonTVertex::AddIncomingViewEdge(ViewEdge *iVEdge) } } -/*! iterators access */ +/** iterators access */ ViewVertex::edge_iterator NonTVertex::edges_begin() { return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin()); diff --git a/source/blender/freestyle/intern/view_map/ViewMap.h b/source/blender/freestyle/intern/view_map/ViewMap.h index a6427f42b85..a3ef5eed6d8 100644 --- a/source/blender/freestyle/intern/view_map/ViewMap.h +++ b/source/blender/freestyle/intern/view_map/ViewMap.h @@ -56,7 +56,7 @@ class ViewEdge; class ViewShape; class TVertex; -/*! Class defining the ViewMap.*/ +/** Class defining the ViewMap.*/ class ViewMap { public: typedef vector<ViewEdge *> viewedges_container; @@ -79,29 +79,29 @@ class ViewMap { id_to_index_map _shapeIdToIndex; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; - /*! Default constructor. */ + /** Default constructor. */ ViewMap() { _pInstance = this; userdata = NULL; } - /*! Destructor. */ + /** Destructor. */ virtual ~ViewMap(); - /*! Gets the viewedge the nearest to the 2D position specified as argument */ + /** Gets the viewedge the nearest to the 2D position specified as argument */ const ViewEdge *getClosestViewEdge(real x, real y) const; - /*! Gets the Fedge the nearest to the 2D position specified as argument */ + /** Gets the Fedge the nearest to the 2D position specified as argument */ const FEdge *getClosestFEdge(real x, real y) const; /* accessors */ - /*! The ViewMap is a singleton class. This static method returns the instance of the ViewMap. */ + /** The ViewMap is a singleton class. This static method returns the instance of the ViewMap. */ static inline ViewMap *getInstance() { return _pInstance; @@ -160,7 +160,7 @@ class ViewMap { return _shapeIdToIndex; } - /*! Returns the scene 3D bounding box. */ + /** Returns the scene 3D bounding box. */ inline BBox<Vec3r> getScene3dBBox() const { return _scene3DBBox; @@ -189,7 +189,7 @@ class ViewMap { _SVertices.push_back(iSVertex); } - /*! Sets the scene 3D bounding box. */ + /** Sets the scene 3D bounding box. */ inline void setScene3dBBox(const BBox<Vec3r> &bbox) { _scene3DBBox = bbox; @@ -259,7 +259,7 @@ class orientedViewEdgeIterator; } // namespace ViewVertexInternal -/*! Class to define a view vertex. +/** Class to define a view vertex. * A view vertex is a feature vertex corresponding to a point of the image graph, where the * characteristics of an edge might change (nature, visibility, ...). A ViewVertex can be of two * kinds: a TVertex when it corresponds to the intersection between two ViewEdges or a NonTVertex @@ -269,7 +269,7 @@ class orientedViewEdgeIterator; */ class ViewVertex : public Interface0D { public: // Implementation of Interface0D - /*! Returns the string "ViewVertex". */ + /** Returns the string "ViewVertex". */ virtual string getExactTypeName() const { return "ViewVertex"; @@ -290,12 +290,12 @@ class ViewVertex : public Interface0D { Nature::VertexNature _Nature; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; - /*! Default constructor.*/ + /** Default constructor.*/ inline ViewVertex() { userdata = NULL; @@ -309,7 +309,7 @@ class ViewVertex : public Interface0D { } protected: - /*! Copy constructor. */ + /** Copy constructor. */ inline ViewVertex(ViewVertex &iBrother) { _Nature = iBrother._Nature; @@ -317,24 +317,24 @@ class ViewVertex : public Interface0D { userdata = NULL; } - /*! Cloning method. */ + /** Cloning method. */ virtual ViewVertex *duplicate() = 0; public: - /*! Destructor. */ + /** Destructor. */ virtual ~ViewVertex() { } /* accessors */ - /*! Returns the nature of the vertex. */ + /** Returns the nature of the vertex. */ virtual Nature::VertexNature getNature() const { return _Nature; } /* modifiers */ - /*! Sets the nature of the vertex. */ + /** Sets the nature of the vertex. */ inline void setNature(Nature::VertexNature iNature) { _Nature = iNature; @@ -357,18 +357,18 @@ class ViewVertex : public Interface0D { virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const = 0; // Iterator access - /*! Returns an iterator over the ViewEdges that goes to or comes from this ViewVertex pointing to + /** Returns an iterator over the ViewEdges that goes to or comes from this ViewVertex pointing to * the first ViewEdge of the list. The orientedViewEdgeIterator allows to iterate in CCW order * over these ViewEdges and to get the orientation for each ViewEdge (incoming/outgoing). */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() = 0; - /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after + /** Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after * the last ViewEdge. */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() = 0; - /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument. */ + /** Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument. */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) = 0; #ifdef WITH_CXX_GUARDEDALLOC @@ -384,7 +384,7 @@ class ViewVertex : public Interface0D { /* */ /**********************************/ -/*! class to define a T vertex, i.e. an intersection between two edges. +/** class to define a T vertex, i.e. an intersection between two edges. * It points towards 2 SVertex and 4 View edges. * Among these ViewEdges, 2 are front and 2 are back. * Basically the front edge hides part of the back edge. @@ -395,7 +395,7 @@ class TVertex : public ViewVertex { typedef vector<directedViewEdge *> edge_pointers_container; public: // Implementation of Interface0D - /*! Returns the string "TVertex". */ + /** Returns the string "TVertex". */ virtual string getExactTypeName() const { return "TVertex"; @@ -421,20 +421,20 @@ class TVertex : public ViewVertex { return _FrontSVertex->point3D().z(); } - /*! Returns the 3D point. */ + /** Returns the 3D point. */ virtual Vec3r getPoint3D() const { cerr << "Warning: getPoint3D() undefined for this point" << endl; return _FrontSVertex->getPoint3D(); } - /*! Returns the projected 3D x coordinate of the vertex. */ + /** Returns the projected 3D x coordinate of the vertex. */ virtual real getProjectedX() const { return _FrontSVertex->point2D().x(); } - /*! Returns the projected 3D y coordinate of the vertex. */ + /** Returns the projected 3D y coordinate of the vertex. */ virtual real getProjectedY() const { return _FrontSVertex->point2D().y(); @@ -445,26 +445,26 @@ class TVertex : public ViewVertex { return _FrontSVertex->point2D().z(); } - /*! Returns the 2D point. */ + /** Returns the 2D point. */ virtual Vec2r getPoint2D() const { return _FrontSVertex->getPoint2D(); } - /*! Returns the Id of the TVertex. */ + /** Returns the Id of the TVertex. */ virtual Id getId() const { return _Id; } - /*! Cast the Interface0D in SVertex if it can be. */ + /** Cast the Interface0D in SVertex if it can be. */ // it can't virtual ViewVertex *castToViewVertex() { return this; } - /*! Cast the Interface0D in TVertex if it can be. */ + /** Cast the Interface0D in TVertex if it can be. */ virtual TVertex *castToTVertex() { return this; @@ -483,7 +483,7 @@ class TVertex : public ViewVertex { _sortedEdges; // the list of the four ViewEdges, ordered in CCW order (in the image plan) public: - /*! Default constructor.*/ + /** Default constructor.*/ inline TVertex() : ViewVertex(Nature::T_VERTEX) { _FrontSVertex = NULL; @@ -507,7 +507,7 @@ class TVertex : public ViewVertex { } protected: - /*! Copy constructor. */ + /** Copy constructor. */ inline TVertex(TVertex &iBrother) : ViewVertex(iBrother) { _FrontSVertex = iBrother._FrontSVertex; @@ -519,7 +519,7 @@ class TVertex : public ViewVertex { _sortedEdges = iBrother._sortedEdges; } - /*! Cloning method. */ + /** Cloning method. */ virtual ViewVertex *duplicate() { TVertex *clone = new TVertex(*this); @@ -528,13 +528,13 @@ class TVertex : public ViewVertex { public: /* accessors */ - /*! Returns the SVertex that is closer to the viewpoint. */ + /** Returns the SVertex that is closer to the viewpoint. */ inline SVertex *frontSVertex() { return _FrontSVertex; } - /*! Returns the SVertex that is further away from the viewpoint. */ + /** Returns the SVertex that is further away from the viewpoint. */ inline SVertex *backSVertex() { return _BackSVertex; @@ -561,14 +561,14 @@ class TVertex : public ViewVertex { } /* modifiers */ - /*! Sets the SVertex that is closer to the viewpoint. */ + /** Sets the SVertex that is closer to the viewpoint. */ inline void setFrontSVertex(SVertex *iFrontSVertex) { _FrontSVertex = iFrontSVertex; _FrontSVertex->setViewVertex(this); } - /*! Sets the SVertex that is further away from the viewpoint. */ + /** Sets the SVertex that is further away from the viewpoint. */ inline void setBackSVertex(SVertex *iBackSVertex) { _BackSVertex = iBackSVertex; @@ -580,13 +580,13 @@ class TVertex : public ViewVertex { void setBackEdgeA(ViewEdge *iBackEdgeA, bool incoming = true); void setBackEdgeB(ViewEdge *iBackEdgeB, bool incoming = true); - /*! Sets the Id. */ + /** Sets the Id. */ inline void setId(const Id &iId) { _Id = iId; } - /*! Returns the SVertex (among the 2) belonging to the FEdge iFEdge */ + /** Returns the SVertex (among the 2) belonging to the FEdge iFEdge */ inline SVertex *getSVertex(FEdge *iFEdge) { const vector<FEdge *> &vfEdges = _FrontSVertex->fedges(); @@ -608,7 +608,7 @@ class TVertex : public ViewVertex { virtual void Replace(ViewEdge *iOld, ViewEdge *iNew); - /*! returns the mate edge of iEdgeA. + /** returns the mate edge of iEdgeA. * For example, if iEdgeA is frontEdgeA, then frontEdgeB is returned. If iEdgeA is frontEdgeB * then frontEdgeA is returned. Same for back edges */ @@ -637,18 +637,18 @@ class TVertex : public ViewVertex { virtual edge_iterator edges_iterator(ViewEdge *iEdge); virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const; - /*! Returns an iterator over the ViewEdges that goes to or comes from this ViewVertex pointing to + /** Returns an iterator over the ViewEdges that goes to or comes from this ViewVertex pointing to * the first ViewEdge of the list. The orientedViewEdgeIterator allows to iterate in CCW order * over these ViewEdges and to get the orientation for each ViewEdge (incoming/outgoing). */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin(); - /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after + /** Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after * the last ViewEdge. */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd(); - /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument. */ + /** Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument. */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge); #ifdef WITH_CXX_GUARDEDALLOC @@ -665,7 +665,7 @@ class TVertex : public ViewVertex { /**********************************/ // (non T vertex) -/*! View vertex for corners, cusps, etc... +/** View vertex for corners, cusps, etc... * Associated to a single SVertex. * Can be associated to 2 or several view edges */ @@ -674,80 +674,80 @@ class NonTVertex : public ViewVertex { typedef vector<directedViewEdge> edges_container; public: // Implementation of Interface0D - /*! Returns the string "ViewVertex". */ + /** Returns the string "ViewVertex". */ virtual string getExactTypeName() const { return "NonTVertex"; } // Data access methods - /*! Returns the 3D x coordinate of the vertex. */ + /** Returns the 3D x coordinate of the vertex. */ virtual real getX() const { return _SVertex->point3D().x(); } - /*! Returns the 3D y coordinate of the vertex. */ + /** Returns the 3D y coordinate of the vertex. */ virtual real getY() const { return _SVertex->point3D().y(); } - /*! Returns the 3D z coordinate of the vertex. */ + /** Returns the 3D z coordinate of the vertex. */ virtual real getZ() const { return _SVertex->point3D().z(); } - /*! Returns the 3D point. */ + /** Returns the 3D point. */ virtual Vec3r getPoint3D() const { return _SVertex->getPoint3D(); } - /*! Returns the projected 3D x coordinate of the vertex. */ + /** Returns the projected 3D x coordinate of the vertex. */ virtual real getProjectedX() const { return _SVertex->point2D().x(); } - /*! Returns the projected 3D y coordinate of the vertex. */ + /** Returns the projected 3D y coordinate of the vertex. */ virtual real getProjectedY() const { return _SVertex->point2D().y(); } - /*! Returns the projected 3D z coordinate of the vertex. */ + /** Returns the projected 3D z coordinate of the vertex. */ virtual real getProjectedZ() const { return _SVertex->point2D().z(); } - /*! Returns the 2D point. */ + /** Returns the 2D point. */ virtual Vec2r getPoint2D() const { return _SVertex->getPoint2D(); } - /*! Returns the Id of the vertex. */ + /** Returns the Id of the vertex. */ virtual Id getId() const { return _SVertex->getId(); } - /*! Cast the Interface0D in SVertex if it can be. */ + /** Cast the Interface0D in SVertex if it can be. */ virtual SVertex *castToSVertex() { return _SVertex; } - /*! Cast the Interface0D in ViewVertex if it can be. */ + /** Cast the Interface0D in ViewVertex if it can be. */ virtual ViewVertex *castToViewVertex() { return this; } - /*! Cast the Interface0D in NonTVertex if it can be. */ + /** Cast the Interface0D in NonTVertex if it can be. */ virtual NonTVertex *castToNonTVertex() { return this; @@ -758,13 +758,13 @@ class NonTVertex : public ViewVertex { edges_container _ViewEdges; public: - /*! Default constructor.*/ + /** Default constructor.*/ inline NonTVertex() : ViewVertex(Nature::NON_T_VERTEX) { _SVertex = NULL; } - /*! Builds a NonTVertex from a SVertex. */ + /** Builds a NonTVertex from a SVertex. */ inline NonTVertex(SVertex *iSVertex) : ViewVertex(Nature::NON_T_VERTEX) { _SVertex = iSVertex; @@ -772,7 +772,7 @@ class NonTVertex : public ViewVertex { } protected: - /*! Copy constructor. */ + /** Copy constructor. */ inline NonTVertex(NonTVertex &iBrother) : ViewVertex(iBrother) { _SVertex = iBrother._SVertex; @@ -780,7 +780,7 @@ class NonTVertex : public ViewVertex { _ViewEdges = iBrother._ViewEdges; } - /*! Cloning method. */ + /** Cloning method. */ virtual ViewVertex *duplicate() { NonTVertex *clone = new NonTVertex(*this); @@ -788,13 +788,13 @@ class NonTVertex : public ViewVertex { } public: - /*! destructor. */ + /** destructor. */ virtual ~NonTVertex() { } /* accessors */ - /*! Returns the SVertex on top of which this NonTVertex is built. */ + /** Returns the SVertex on top of which this NonTVertex is built. */ inline SVertex *svertex() { return _SVertex; @@ -806,7 +806,7 @@ class NonTVertex : public ViewVertex { } /* modifiers */ - /*! Sets the SVertex on top of which this NonTVertex is built. */ + /** Sets the SVertex on top of which this NonTVertex is built. */ inline void setSVertex(SVertex *iSVertex) { _SVertex = iSVertex; @@ -857,18 +857,18 @@ class NonTVertex : public ViewVertex { virtual edge_iterator edges_iterator(ViewEdge *iEdge); virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const; - /*! Returns an iterator over the ViewEdges that goes to or comes from this ViewVertex pointing to + /** Returns an iterator over the ViewEdges that goes to or comes from this ViewVertex pointing to * the first ViewEdge of the list. The orientedViewEdgeIterator allows to iterate in CCW order * over these ViewEdges and to get the orientation for each ViewEdge (incoming/outgoing). */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin(); - /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after + /** Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after * the last ViewEdge. */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd(); - /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument. */ + /** Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument. */ virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge); #ifdef WITH_CXX_GUARDEDALLOC @@ -902,25 +902,25 @@ template<class Traits> class vertex_iterator_base; } // end of namespace ViewEdgeInternal -/*! Class defining a ViewEdge. A ViewEdge in an edge of the image graph. it connects two +/** Class defining a ViewEdge. A ViewEdge in an edge of the image graph. it connects two * ViewVertex. It is made by connecting a set of FEdges. */ class ViewEdge : public Interface1D { public: // Implementation of Interface0D - /*! Returns the string "ViewEdge". */ + /** Returns the string "ViewEdge". */ virtual string getExactTypeName() const { return "ViewEdge"; } // Data access methods - /*! Returns the Id of the vertex. */ + /** Returns the Id of the vertex. */ virtual Id getId() const { return _Id; } - /*! Returns the nature of the ViewEdge. */ + /** Returns the nature of the ViewEdge. */ virtual Nature::EdgeNature getNature() const { return _Nature; @@ -960,12 +960,12 @@ class ViewEdge : public Interface1D { Id *_splittingId; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; - /*! Default constructor. */ + /** Default constructor. */ inline ViewEdge() { __A = NULL; @@ -1028,7 +1028,7 @@ class ViewEdge : public Interface1D { } // soc protected: - /*! Copy constructor. */ + /** Copy constructor. */ inline ViewEdge(ViewEdge &iBrother) { __A = iBrother.__A; @@ -1047,7 +1047,7 @@ class ViewEdge : public Interface1D { userdata = NULL; } - /*! Cloning method. */ + /** Cloning method. */ virtual ViewEdge *duplicate() { ViewEdge *clone = new ViewEdge(*this); @@ -1055,7 +1055,7 @@ class ViewEdge : public Interface1D { } public: - /*! Destructor. */ + /** Destructor. */ virtual ~ViewEdge() { #if 0 @@ -1073,37 +1073,37 @@ class ViewEdge : public Interface1D { } /* accessors */ - /*! Returns the first ViewVertex. */ + /** Returns the first ViewVertex. */ inline ViewVertex *A() { return __A; } - /*! Returns the second ViewVertex. */ + /** Returns the second ViewVertex. */ inline ViewVertex *B() { return __B; } - /*! Returns the first FEdge that constitutes this ViewEdge. */ + /** Returns the first FEdge that constitutes this ViewEdge. */ inline FEdge *fedgeA() { return _FEdgeA; } - /*! Returns the last FEdge that constitutes this ViewEdge. */ + /** Returns the last FEdge that constitutes this ViewEdge. */ inline FEdge *fedgeB() { return _FEdgeB; } - /*! Returns the ViewShape to which this ViewEdge belongs to. */ + /** Returns the ViewShape to which this ViewEdge belongs to. */ inline ViewShape *viewShape() { return _Shape; } - /*! Returns the shape that is occluded by the ViewShape to which this ViewEdge belongs to. If no + /** Returns the shape that is occluded by the ViewShape to which this ViewEdge belongs to. If no * object is occluded, NULL is returned. \return The occluded ViewShape. */ inline ViewShape *aShape() @@ -1111,7 +1111,7 @@ class ViewEdge : public Interface1D { return _aShape; } - /*! Tells whether this ViewEdge forms a closed loop or not. */ + /** Tells whether this ViewEdge forms a closed loop or not. */ inline bool isClosed() { if (!__B) { @@ -1120,7 +1120,7 @@ class ViewEdge : public Interface1D { return false; } - /*! Returns the time stamp of this ViewEdge. */ + /** Returns the time stamp of this ViewEdge. */ inline unsigned getChainingTimeStamp() { return _ChainingTimeStamp; @@ -1152,64 +1152,64 @@ class ViewEdge : public Interface1D { } /* modifiers */ - /*! Sets the first ViewVertex of the ViewEdge. */ + /** Sets the first ViewVertex of the ViewEdge. */ inline void setA(ViewVertex *iA) { __A = iA; } - /*! Sets the last ViewVertex of the ViewEdge. */ + /** Sets the last ViewVertex of the ViewEdge. */ inline void setB(ViewVertex *iB) { __B = iB; } - /*! Sets the nature of the ViewEdge. */ + /** Sets the nature of the ViewEdge. */ inline void setNature(Nature::EdgeNature iNature) { _Nature = iNature; } - /*! Sets the first FEdge of the ViewEdge. */ + /** Sets the first FEdge of the ViewEdge. */ inline void setFEdgeA(FEdge *iFEdge) { _FEdgeA = iFEdge; } - /*! Sets the last FEdge of the ViewEdge. */ + /** Sets the last FEdge of the ViewEdge. */ inline void setFEdgeB(FEdge *iFEdge) { _FEdgeB = iFEdge; } - /*! Sets the ViewShape to which this ViewEdge belongs to.*/ + /** Sets the ViewShape to which this ViewEdge belongs to.*/ inline void setShape(ViewShape *iVShape) { _Shape = iVShape; } - /*! Sets the ViewEdge id. */ + /** Sets the ViewEdge id. */ inline void setId(const Id &id) { _Id = id; } - /*! Sets Viewedge to this for all embedded fedges */ + /** Sets Viewedge to this for all embedded fedges */ void UpdateFEdges(); - /*! Sets the occluded ViewShape */ + /** Sets the occluded ViewShape */ inline void setaShape(ViewShape *iShape) { _aShape = iShape; } - /*! Sets the quantitative invisibility value. */ + /** Sets the quantitative invisibility value. */ inline void setQI(int qi) { _qi = qi; } - /*! Sets the time stamp value. */ + /** Sets the time stamp value. */ inline void setChainingTimeStamp(unsigned ts) { _ChainingTimeStamp = ts; @@ -1279,7 +1279,7 @@ class ViewEdge : public Interface1D { float viewedge_length() const; #endif - /*! Returns the 2D length of the Viewedge. */ + /** Returns the 2D length of the Viewedge. */ real getLength2D() const; #if 0 @@ -1366,24 +1366,24 @@ class ViewEdge : public Interface1D { vertex_iterator vertices_end(); // Iterator access (Interface1D) - /*! Returns an Interface0DIterator to iterate over the SVertex constituting the embedding of this + /** Returns an Interface0DIterator to iterate over the SVertex constituting the embedding of this * ViewEdge. The returned Interface0DIterator points to the first SVertex of the ViewEdge. */ virtual Interface0DIterator verticesBegin(); - /*! Returns an Interface0DIterator to iterate over the SVertex constituting the embedding of this + /** Returns an Interface0DIterator to iterate over the SVertex constituting the embedding of this * ViewEdge. The returned Interface0DIterator points after the last SVertex of the ViewEdge. */ virtual Interface0DIterator verticesEnd(); - /*! Returns an Interface0DIterator to iterate over the points of this ViewEdge at a given + /** 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: * the sampling value. */ virtual Interface0DIterator pointsBegin(float t = 0.0f); - /*! Returns an Interface0DIterator to iterate over the points of this ViewEdge at a given + /** 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: * the sampling value. @@ -1403,7 +1403,7 @@ class ViewEdge : public Interface1D { /* */ /**********************************/ -/*! Class gathering the elements of the ViewMap (ViewVertex, ViewEdge) that are issued from the +/** Class gathering the elements of the ViewMap (ViewVertex, ViewEdge) that are issued from the * same input shape. */ class ViewShape { private: @@ -1412,19 +1412,19 @@ class ViewShape { SShape *_SShape; public: - /*! A field that can be used by the user to store any data. + /** A field that can be used by the user to store any data. * This field must be reset afterwards using ResetUserData(). */ void *userdata; - /*! Default constructor.*/ + /** Default constructor.*/ inline ViewShape() { userdata = NULL; _SShape = NULL; } - /*! Builds a ViewShape from a SShape. */ + /** Builds a ViewShape from a SShape. */ inline ViewShape(SShape *iSShape) { userdata = NULL; @@ -1432,7 +1432,7 @@ class ViewShape { //_SShape->setViewShape(this); } - /*! Copy constructor. */ + /** Copy constructor. */ inline ViewShape(ViewShape &iBrother) { userdata = NULL; @@ -1519,14 +1519,14 @@ class ViewShape { } } - /*! Cloning method. */ + /** Cloning method. */ virtual ViewShape *duplicate() { ViewShape *clone = new ViewShape(*this); return clone; } - /*! Destructor. */ + /** Destructor. */ virtual ~ViewShape(); /* splits a view edge into several view edges. @@ -1545,75 +1545,75 @@ class ViewShape { vector<ViewEdge *> &ioNewViewEdges); /* accessors */ - /*! Returns the SShape on top of which this ViewShape is built. */ + /** Returns the SShape on top of which this ViewShape is built. */ inline SShape *sshape() { return _SShape; } - /*! Returns the SShape on top of which this ViewShape is built. */ + /** Returns the SShape on top of which this ViewShape is built. */ inline const SShape *sshape() const { return _SShape; } - /*! Returns the list of ViewVertex contained in this ViewShape. */ + /** Returns the list of ViewVertex contained in this ViewShape. */ inline vector<ViewVertex *> &vertices() { return _Vertices; } - /*! Returns the list of ViewEdge contained in this ViewShape. */ + /** Returns the list of ViewEdge contained in this ViewShape. */ inline vector<ViewEdge *> &edges() { return _Edges; } - /*! Returns the ViewShape id. */ + /** Returns the ViewShape id. */ inline Id getId() const { return _SShape->getId(); } - /*! Returns the ViewShape name. */ + /** Returns the ViewShape name. */ inline const string &getName() const { return _SShape->getName(); } - /*! Returns the ViewShape library path. */ + /** Returns the ViewShape library path. */ inline const string &getLibraryPath() const { return _SShape->getLibraryPath(); } /* modifiers */ - /*! Sets the SShape on top of which the ViewShape is built. */ + /** Sets the SShape on top of which the ViewShape is built. */ inline void setSShape(SShape *iSShape) { _SShape = iSShape; } - /*! Sets the list of ViewVertex contained in this ViewShape. */ + /** Sets the list of ViewVertex contained in this ViewShape. */ inline void setVertices(const vector<ViewVertex *> &iVertices) { _Vertices = iVertices; } - /*! Sets the list of ViewEdge contained in this ViewShape. */ + /** Sets the list of ViewEdge contained in this ViewShape. */ inline void setEdges(const vector<ViewEdge *> &iEdges) { _Edges = iEdges; } - /*! Adds a ViewVertex to the list. */ + /** Adds a ViewVertex to the list. */ inline void AddVertex(ViewVertex *iVertex) { _Vertices.push_back(iVertex); //_SShape->AddNewVertex(iVertex->svertex()); } - /*! Adds a ViewEdge to the list */ + /** Adds a ViewEdge to the list */ inline void AddEdge(ViewEdge *iEdge) { _Edges.push_back(iEdge); diff --git a/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h b/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h index 5cb52b6a0f3..b33bc4f281f 100644 --- a/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h +++ b/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h @@ -363,9 +363,9 @@ class edge_iterator_base : public IteratorBase<Traits, InputIteratorTag_Traits> namespace ViewEdgeInternal { -/*!----------------------*/ -/*! Iterators definition */ -/*!----------------------*/ +/**----------------------*/ +/** Iterators definition */ +/**----------------------*/ template<class Traits> class edge_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTag_Traits> { public: diff --git a/source/blender/freestyle/intern/view_map/ViewMapBuilder.h b/source/blender/freestyle/intern/view_map/ViewMapBuilder.h index 6d919f5561a..4f26ec82eb6 100644 --- a/source/blender/freestyle/intern/view_map/ViewMapBuilder.h +++ b/source/blender/freestyle/intern/view_map/ViewMapBuilder.h @@ -107,28 +107,28 @@ class ViewMapBuilder { } /* Build Grid for ray casting */ - /*! Build non-culled Grid in camera space for ray casting */ + /** Build non-culled Grid in camera space for ray casting */ void BuildGrid(WingedEdge &we, const BBox<Vec3r> &bbox, unsigned int sceneNumFaces); - /*! Compute Shapes from a WingedEdge containing a list of WShapes */ + /** Compute Shapes from a WingedEdge containing a list of WShapes */ void computeInitialViewEdges(WingedEdge &); - /*! Compute Cusps */ + /** Compute Cusps */ void computeCusps(ViewMap *ioViewMap); - /*! Detects cusps (for a single ViewEdge) among SVertices and builds a ViewVertex on top of each + /** Detects cusps (for a single ViewEdge) among SVertices and builds a ViewVertex on top of each * cusp SVertex We use a hysteresis approach to avoid noise. */ void DetectCusps(ViewEdge *ioEdge); - /*! Sets the current viewpoint */ + /** Sets the current viewpoint */ inline void setViewpoint(const Vec3r &ivp) { _viewpoint = ivp; SilhouetteGeomEngine::setViewpoint(ivp); } - /*! Sets the current transformation + /** Sets the current transformation * iModelViewMatrix * The 4x4 model view matrix, in column major order (openGL like). * iProjection matrix @@ -153,7 +153,7 @@ class ViewMapBuilder { SilhouetteGeomEngine::setFrustum(iZnear, iZfar); } - /*! Builds the scene view map returns the list the view map + /** Builds the scene view map returns the list the view map * it is up to the caller to delete this ViewMap * iWRoot * The root group node containing the WEdge structured scene @@ -169,7 +169,7 @@ class ViewMapBuilder { real occluderProscenium[4], bool extensiveFEdgeSearch = true); - /*! computes the intersection between all 2D feature edges of the scene. + /** computes the intersection between all 2D feature edges of the scene. * ioViewMap * The view map. It is modified by the method. * The list of all features edges of the scene. @@ -181,7 +181,7 @@ class ViewMapBuilder { intersection_algo iAlgo = sweep_line, real epsilon = 1.0e-06); - /*! Computes the 2D scene silhouette edges visibility + /** Computes the 2D scene silhouette edges visibility * iGrid * For the Ray Casting algorithm. */ @@ -197,9 +197,9 @@ class ViewMapBuilder { _Grid = iGrid; } - /*! accessors */ + /** accessors */ - /*! Modifiers */ + /** Modifiers */ inline void setProgressBar(ProgressBar *iProgressBar) { _pProgressBar = iProgressBar; @@ -216,10 +216,10 @@ class ViewMapBuilder { } protected: - /*! Computes intersections on all edges of the scene using a sweep line algorithm */ + /** Computes intersections on all edges of the scene using a sweep line algorithm */ void ComputeSweepLineIntersections(ViewMap *ioViewMap, real epsilon = 1.0e-6); - /*! Computes the 2D scene silhouette edges visibility using a ray casting. On each edge, a ray is + /** Computes the 2D scene silhouette edges visibility using a ray casting. On each edge, a ray is * cast to check its quantitative invisibility. The list of occluders are each time stored in the * tested edge. ioViewMap The view map. The 2D scene silhouette edges as FEdges. These edges have * already been splitted at their intersections points. Thus, these edges do not intersect @@ -242,7 +242,7 @@ class ViewMapBuilder { bool cull, GridDensityProviderFactory &factory); - /*! Compute the visibility for the FEdge fe. + /** Compute the visibility for the FEdge fe. * The occluders are added to fe occluders list. * fe * The FEdge diff --git a/source/blender/freestyle/intern/view_map/ViewMapIterators.h b/source/blender/freestyle/intern/view_map/ViewMapIterators.h index 9956d47469d..7f98c2745f4 100644 --- a/source/blender/freestyle/intern/view_map/ViewMapIterators.h +++ b/source/blender/freestyle/intern/view_map/ViewMapIterators.h @@ -45,7 +45,7 @@ namespace Freestyle { namespace ViewVertexInternal { -/*! Class representing an iterator over oriented ViewEdges around a ViewVertex. This iterator +/** Class representing an iterator over oriented ViewEdges around a ViewVertex. This iterator * allows a CCW iteration (in the image plane). An instance of an orientedViewEdgeIterator can only * be obtained from a ViewVertex by calling edgesBegin() or edgesEnd(). */ @@ -73,7 +73,7 @@ class orientedViewEdgeIterator : public Iterator { edges_container::iterator _nontvertex_iter; public: - /*! Default constructor */ + /** Default constructor */ inline orientedViewEdgeIterator() { } @@ -83,7 +83,7 @@ class orientedViewEdgeIterator : public Iterator { _Nature = iNature; } - /*! Copy constructor */ + /** Copy constructor */ orientedViewEdgeIterator(const orientedViewEdgeIterator &iBrother) { _Nature = iBrother._Nature; @@ -125,7 +125,7 @@ class orientedViewEdgeIterator : public Iterator { } public: - /*! Tells whether the ViewEdge pointed by this iterator is the first one of the iteration list or + /** Tells whether the ViewEdge pointed by this iterator is the first one of the iteration list or * not. */ virtual bool isBegin() const { @@ -137,7 +137,7 @@ class orientedViewEdgeIterator : public Iterator { } } - /*! Tells whether the ViewEdge pointed by this iterator is after the last one of the iteration + /** Tells whether the ViewEdge pointed by this iterator is after the last one of the iteration * list or not. */ virtual bool isEnd() const { @@ -150,7 +150,7 @@ class orientedViewEdgeIterator : public Iterator { } // operators - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ // operator corresponding to ++i virtual orientedViewEdgeIterator &operator++() { @@ -168,7 +168,7 @@ class orientedViewEdgeIterator : public Iterator { } // comparibility - /*! operator != */ + /** operator != */ virtual bool operator!=(const orientedViewEdgeIterator &b) const { if (_Nature & Nature::T_VERTEX) { @@ -179,14 +179,14 @@ class orientedViewEdgeIterator : public Iterator { } } - /*! operator == */ + /** operator == */ virtual bool operator==(const orientedViewEdgeIterator &b) const { return !(*this != b); } // dereferencing - /*! Returns a reference to the pointed orientedViewEdge. + /** Returns a reference to the pointed orientedViewEdge. * In the scripting language, you must call "getObject()" instead. */ virtual ViewVertex::directedViewEdge &operator*() const @@ -199,7 +199,7 @@ class orientedViewEdgeIterator : public Iterator { return (*_nontvertex_iter); } } - /*! Returns a pointer to the pointed orientedViewEdge. + /** Returns a pointer to the pointed orientedViewEdge. * Can't be called in the scripting language. */ virtual ViewVertex::directedViewEdge *operator->() const @@ -208,7 +208,7 @@ class orientedViewEdgeIterator : public Iterator { } public: - /*! increments.*/ + /** increments.*/ virtual inline int increment() { if (_Nature & Nature::T_VERTEX) { @@ -415,14 +415,14 @@ class SVertexIterator : public Interface0DIteratorNested { // /////////////////////////////////////////////////////////// -/*! Base class for iterators over ViewEdges of the ViewMap Graph. +/** Base class for iterators over ViewEdges of the ViewMap Graph. * Basically the "increment()" operator of this class should be able to take the decision of * "where" (on which ViewEdge) to go when pointing on a given ViewEdge. * ::Caution::: the dereferencing operator returns a *pointer* to the pointed ViewEdge. */ class ViewEdgeIterator : public Iterator { public: - /*! Builds a ViewEdgeIterator from a starting ViewEdge and its orientation. + /** Builds a ViewEdgeIterator from a starting ViewEdge and its orientation. * \param begin: * The ViewEdge from where to start the iteration. * \param orientation: @@ -437,7 +437,7 @@ class ViewEdgeIterator : public Iterator { _begin = begin; } - /*! Copy constructor */ + /** Copy constructor */ ViewEdgeIterator(const ViewEdgeIterator &it) { _orientation = it._orientation; @@ -449,55 +449,55 @@ class ViewEdgeIterator : public Iterator { { } - /*! Returns the string "ViewEdgeIterator" */ + /** Returns the string "ViewEdgeIterator" */ virtual string getExactTypeName() const { return "ViewEdgeIterator"; } - /*! Returns the current pointed ViewEdge. */ + /** Returns the current pointed ViewEdge. */ ViewEdge *getCurrentEdge() { return _edge; } - /*! Sets the current pointed ViewEdge. */ + /** Sets the current pointed ViewEdge. */ void setCurrentEdge(ViewEdge *edge) { _edge = edge; } - /*! Returns the first ViewEdge used for the iteration. */ + /** Returns the first ViewEdge used for the iteration. */ ViewEdge *getBegin() { return _begin; } - /*! Sets the first ViewEdge used for the iteration. */ + /** Sets the first ViewEdge used for the iteration. */ void setBegin(ViewEdge *begin) { _begin = begin; } - /*! Gets the orientation of the pointed ViewEdge in the iteration. */ + /** Gets the orientation of the pointed ViewEdge in the iteration. */ bool getOrientation() const { return _orientation; } - /*! Sets the orientation of the pointed ViewEdge in the iteration. */ + /** Sets the orientation of the pointed ViewEdge in the iteration. */ void setOrientation(bool orientation) { _orientation = orientation; } - /*! Changes the current orientation. */ + /** Changes the current orientation. */ void changeOrientation() { _orientation = !_orientation; } - /*! Returns a *pointer* to the pointed ViewEdge. */ + /** Returns a *pointer* to the pointed ViewEdge. */ virtual ViewEdge *operator*() { return _edge; @@ -508,14 +508,14 @@ class ViewEdgeIterator : public Iterator { return operator*(); } - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ virtual ViewEdgeIterator &operator++() { increment(); return *this; } - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ virtual ViewEdgeIterator operator++(int) { ViewEdgeIterator tmp(*this); @@ -523,21 +523,21 @@ class ViewEdgeIterator : public Iterator { return tmp; } - /*! increments. */ + /** increments. */ virtual int increment() { cerr << "Warning: method increment() not implemented" << endl; return 0; } - /*! Decrements. In the scripting language, call "decrement()". */ + /** Decrements. In the scripting language, call "decrement()". */ virtual ViewEdgeIterator &operator--() { decrement(); return *this; } - /*! Decrements. In the scripting language, call "decrement()". */ + /** Decrements. In the scripting language, call "decrement()". */ virtual ViewEdgeIterator operator--(int) { ViewEdgeIterator tmp(*this); @@ -545,32 +545,32 @@ class ViewEdgeIterator : public Iterator { return tmp; } - /*! decrements. */ + /** decrements. */ virtual int decrement() { cerr << "Warning: method decrement() not implemented" << endl; return 0; } - /*! Returns true if the pointed ViewEdge is the first one used for the iteration. */ + /** Returns true if the pointed ViewEdge is the first one used for the iteration. */ virtual bool isBegin() const { return _edge == _begin; } - /*! Returns true if the pointed ViewEdge* equals 0. */ + /** Returns true if the pointed ViewEdge* equals 0. */ virtual bool isEnd() const { return !_edge; } - /*! operator == */ + /** operator == */ virtual bool operator==(ViewEdgeIterator &it) const { return _edge == it._edge; } - /*! operator != */ + /** operator != */ virtual bool operator!=(ViewEdgeIterator &it) const { return !(*this == it); diff --git a/source/blender/freestyle/intern/view_map/ViewMapTesselator.h b/source/blender/freestyle/intern/view_map/ViewMapTesselator.h index c6690b1d9dc..ff709879e74 100644 --- a/source/blender/freestyle/intern/view_map/ViewMapTesselator.h +++ b/source/blender/freestyle/intern/view_map/ViewMapTesselator.h @@ -56,17 +56,17 @@ class ViewMapTesselator { { } - /*! 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 ViewMap */ NodeGroup *Tesselate(ViewMap *iViewMap); - /*! 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 view edges */ template<class ViewEdgesIterator> NodeGroup *Tesselate(ViewEdgesIterator begin, ViewEdgesIterator end); - /*! Builds a set of lines rep contained among a NodeShape, from a WShape */ + /** Builds a set of lines rep contained among a NodeShape, from a WShape */ NodeGroup *Tesselate(WShape *iWShape); inline void setNature(Nature::EdgeNature iNature) @@ -103,7 +103,7 @@ class ViewMapTesselator { #endif }; -/*! Class to tesselate the 2D projected silhouette */ +/** Class to tesselate the 2D projected silhouette */ class ViewMapTesselator2D : public ViewMapTesselator { public: inline ViewMapTesselator2D() : ViewMapTesselator() @@ -124,7 +124,7 @@ class ViewMapTesselator2D : public ViewMapTesselator { #endif }; -/*! Class to tesselate the 3D silhouette */ +/** Class to tesselate the 3D silhouette */ class ViewMapTesselator3D : public ViewMapTesselator { public: inline ViewMapTesselator3D() : ViewMapTesselator() |