Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Campbell Barton
2021-06-24 15:57:33 +10:00
parent 4b9ff3cd42
commit 1f778dbefc
88 changed files with 1359 additions and 1359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
source/blender/freestyle/intern/application/AppCanvas.h
View File

@@ -32,21 +32,21 @@ class AppCanvas : public Canvas {
AppCanvas(const AppCanvas &iBrother);
virtual ~AppCanvas();
/*! operations that need to be done before a draw */
/** operations that need to be done before a draw */
virtual void preDraw();
/*! operations that need to be done after a draw */
/** operations that need to be done after a draw */
virtual void postDraw();
/*! Erases the layers and clears the canvas */
/** Erases the layers and clears the canvas */
virtual void Erase();
/* init the canvas */
virtual void init();
/*! Reads a pixel area from the canvas */
/** Reads a pixel area from the canvas */
virtual void readColorPixels(int x, int y, int w, int h, RGBImage &oImage) const;
/*! Reads a depth pixel area from the canvas */
/** Reads a depth pixel area from the canvas */
virtual void readDepthPixels(int x, int y, int w, int h, GrayImage &oImage) const;
virtual BBox<Vec3r> scene3DBBox() const;
@@ -55,7 +55,7 @@ class AppCanvas : public Canvas {
virtual void RenderStroke(Stroke *);
virtual void update();
/*! accessors */
/** accessors */
virtual int width() const;
virtual int height() const;
virtual BBox<Vec2i> border() const;
@@ -67,7 +67,7 @@ class AppCanvas : public Canvas {
return _pViewer;
}
/*! modifiers */
/** modifiers */
void setViewer(AppView *iViewer);
/* soc */

10
source/blender/freestyle/intern/application/AppView.h
View File

@@ -83,7 +83,7 @@ class AppView {
float _thickness;
public:
/*! Sets the model to draw in the viewer
/** Sets the model to draw in the viewer
* iModel
* The Root Node of the model
*/
@@ -97,7 +97,7 @@ class AppView {
AddModel(iModel);
}
/*! Adds a model for displaying in the viewer */
/** Adds a model for displaying in the viewer */
inline void AddModel(NodeGroup *iModel)
{
_ModelRootNode->AddChild(iModel);
@@ -226,14 +226,14 @@ class AppView {
real zfar();
public:
/*! Core scene drawing */
/** Core scene drawing */
void DrawScene(SceneVisitor *iRenderer);
/*! 2D Scene Drawing */
/** 2D Scene Drawing */
void Draw2DScene(SceneVisitor *iRenderer);
protected:
/*! fabs or abs */
/** fabs or abs */
inline int rabs(int x)
{
return abs(x);

10
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.h
View File

@@ -80,28 +80,28 @@ struct LoaderState {
class BlenderFileLoader {
public:
/*! Builds a MaxFileLoader */
/** Builds a MaxFileLoader */
BlenderFileLoader(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph);
virtual ~BlenderFileLoader();
/*! Loads the 3D scene and returns a pointer to the scene root node */
/** Loads the 3D scene and returns a pointer to the scene root node */
NodeGroup *Load();
/*! Gets the number of read faces */
/** Gets the number of read faces */
inline unsigned int numFacesRead()
{
return _numFacesRead;
}
#if 0
/*! Gets the smallest edge size read */
/** Gets the smallest edge size read */
inline real minEdgeSize()
{
return _minEdgeSize;
}
#endif
/*! Modifiers */
/** Modifiers */
inline void setRenderMonitor(RenderMonitor *iRenderMonitor)
{
_pRenderMonitor = iRenderMonitor;

2
source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.h
View File

@@ -44,7 +44,7 @@ class BlenderStrokeRenderer : public StrokeRenderer {
BlenderStrokeRenderer(Render *re, int render_count);
virtual ~BlenderStrokeRenderer();
/*! Renders a stroke rep */
/** Renders a stroke rep */
virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;

10
source/blender/freestyle/intern/geometry/FastGrid.h
View File

@@ -25,7 +25,7 @@
namespace Freestyle {
/*! Class to define a regular grid used for ray casting computations
/** Class to define a regular grid used for ray casting computations
* We don't use a hashtable here. The grid is explicitly stored for faster computations.
* However, this might result in significant increase in memory usage
* (compared to the regular grid).
@@ -43,13 +43,13 @@ class FastGrid : public Grid {
clear();
}
/*!
/**
* clears the grid
* Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
/** Sets the different parameters of the grid
* orig
* The grid origin
* size
@@ -59,10 +59,10 @@ class FastGrid : public Grid {
*/
virtual void configure(const Vec3r &orig, const Vec3r &size, unsigned nb);
/*! returns the cell whose coordinates are passed as argument */
/** returns the cell whose coordinates are passed as argument */
Cell *getCell(const Vec3u &p);
/*! Fills the case p with the cell iCell */
/** Fills the case p with the cell iCell */
virtual void fillCell(const Vec3u &p, Cell &cell);
protected:

4
source/blender/freestyle/intern/geometry/FitCurve.h
View File

@@ -72,7 +72,7 @@ class FitCurveWrapper {
public:
~FitCurveWrapper();
/*! Fits a set of 2D data points to a set of Bezier Curve segments
/** Fits a set of 2D data points to a set of Bezier Curve segments
* data
* Input data points
* oCurve
@@ -90,7 +90,7 @@ class FitCurveWrapper {
*/
void FitCurve(Vector2 *d, int nPts, double error);
/*! Draws a Bezier curve segment
/** Draws a Bezier curve segment
* n
* degree of curve (=3)
* curve

2
source/blender/freestyle/intern/geometry/GeomCleaner.cpp
View File

@@ -180,7 +180,7 @@ void GeomCleaner::SortAndCompressIndexedVertexArray(const float *iVertices,
delete[] tmpIndices;
}
/*! Defines a hash table used for searching the Cells */
/** Defines a hash table used for searching the Cells */
struct GeomCleanerHasher {
#define _MUL 950706376UL
#define _MOD 2147483647UL

18
source/blender/freestyle/intern/geometry/GeomCleaner.h
View File

@@ -42,7 +42,7 @@ class GeomCleaner {
{
}
/*! Sorts an array of Indexed vertices
/** Sorts an array of Indexed vertices
* iVertices
* Array of vertices to sort.
* It is organized as a float series of vertex coordinates: XYZXYZXYZ...
@@ -70,7 +70,7 @@ class GeomCleaner {
float **oVertices,
unsigned **oIndices);
/*! Compress a SORTED indexed vertex array by eliminating multiple
/** Compress a SORTED indexed vertex array by eliminating multiple
* appearing occurrences of a single vertex.
* iVertices
* The SORTED vertex array to compress.
@@ -99,7 +99,7 @@ class GeomCleaner {
unsigned *oVSize,
unsigned **oIndices);
/*! Sorts and compress an array of indexed vertices.
/** Sorts and compress an array of indexed vertices.
* iVertices
* The vertex array to sort then compress. It is organized as a float series of
* vertex coordinates: XYZXYZXYZ...
@@ -127,7 +127,7 @@ class GeomCleaner {
unsigned *oVSize,
unsigned **oIndices);
/*! Cleans an indexed vertex array.
/** Cleans an indexed vertex array.
* (Identical to SortAndCompress except that we use here a hash table to create the new array.)
* iVertices
* The vertex array to sort then compress. It is organized as a float series of
@@ -161,10 +161,10 @@ class GeomCleaner {
#endif
};
/*! Binary operators */
/** Binary operators */
// inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
/*! Class Indexed Vertex. Used to represent an indexed vertex by storing the vertex coordinates as
/** Class Indexed Vertex. Used to represent an indexed vertex by storing the vertex coordinates as
* well as its index */
class IndexedVertex {
private:
@@ -182,7 +182,7 @@ class IndexedVertex {
_index = iIndex;
}
/*! accessors */
/** accessors */
inline const Vec3f &vector() const
{
return _Vector;
@@ -208,7 +208,7 @@ class IndexedVertex {
return _Vector[2];
}
/*! modifiers */
/** modifiers */
inline void setVector(const Vec3f &iVector)
{
_Vector = iVector;
@@ -219,7 +219,7 @@ class IndexedVertex {
_index = iIndex;
}
/*! operators */
/** operators */
IndexedVertex &operator=(const IndexedVertex &iv)
{
_Vector = iv._Vector;

32
source/blender/freestyle/intern/geometry/GeomUtils.h
View File

@@ -40,7 +40,7 @@ namespace GeomUtils {
//
/////////////////////////////////////////////////////////////////////////////
/*! Computes the distance from a point P to a segment AB */
/** Computes the distance from a point P to a segment AB */
template<class T> real distPointSegment(const T &P, const T &A, const T &B)
{
T AB, AP, BP;
@@ -97,16 +97,16 @@ intersection_test intersect2dSeg2dSegParametric(const Vec2r &p1,
real &u, // I = P3 + u * P3P4
real epsilon = M_EPSILON);
/*! check whether a 2D segment intersect a 2D region or not */
/** check whether a 2D segment intersect a 2D region or not */
bool intersect2dSeg2dArea(const Vec2r &min, const Vec2r &max, const Vec2r &A, const Vec2r &B);
/*! check whether a 2D segment is included in a 2D region or not */
/** check whether a 2D segment is included in a 2D region or not */
bool include2dSeg2dArea(const Vec2r &min, const Vec2r &max, const Vec2r &A, const Vec2r &B);
/*! Box-triangle overlap test, adapted from Tomas Akenine-Möller code */
/** Box-triangle overlap test, adapted from Tomas Akenine-Möller code */
bool overlapTriangleBox(Vec3r &boxcenter, Vec3r &boxhalfsize, Vec3r triverts[3]);
/*! Fast, Minimum Storage Ray-Triangle Intersection, adapted from Tomas Möller and Ben Trumbore
/** Fast, Minimum Storage Ray-Triangle Intersection, adapted from Tomas Möller and Ben Trumbore
* code. */
bool intersectRayTriangle(const Vec3r &orig,
const Vec3r &dir,
@@ -118,7 +118,7 @@ bool intersectRayTriangle(const Vec3r &orig,
real &v, // I = (1 - u - v) * v0 + u * v1 + v * v2
const real epsilon = M_EPSILON); // the epsilon to use
/*! Intersection between plane and ray adapted from Graphics Gems, Didier Badouel */
/** Intersection between plane and ray adapted from Graphics Gems, Didier Badouel */
intersection_test intersectRayPlane(const Vec3r &orig,
const Vec3r &dir, // ray origin and direction
// plane's normal and offset (plane = { P / P.N + d = 0 })
@@ -127,7 +127,7 @@ intersection_test intersectRayPlane(const Vec3r &orig,
real &t, // I = orig + t * dir
const real epsilon = M_EPSILON); // the epsilon to use
/*! Intersection Ray-Bounding box (axis aligned).
/** Intersection Ray-Bounding box (axis aligned).
* Adapted from Williams et al, "An Efficient Robust Ray-Box Intersection Algorithm", JGT 10:1
* (2005), pp. 49-54.
*/
@@ -142,7 +142,7 @@ bool intersectRayBBox(const Vec3r &orig,
real &tmax, // Imax = orig + tmax * dir is the second intersection
real epsilon = M_EPSILON); // the epsilon to use
/*! Checks whether 3D point P lies inside or outside of the triangle ABC */
/** Checks whether 3D point P lies inside or outside of the triangle ABC */
bool includePointTriangle(const Vec3r &P, const Vec3r &A, const Vec3r &B, const Vec3r &C);
void transformVertex(const Vec3r &vert, const Matrix44r &matrix, Vec3r &res);
@@ -156,7 +156,7 @@ Vec3r rotateVector(const Matrix44r &mat, const Vec3r &v);
//
/////////////////////////////////////////////////////////////////////////////
/*! From world to image
/** From world to image
* p
* point's coordinates expressed in world coordinates system
* q
@@ -176,7 +176,7 @@ void fromWorldToImage(const Vec3r &p,
const real projection_matrix[4][4],
const int viewport[4]);
/*! From world to image
/** From world to image
* p
* point's coordinates expressed in world coordinates system
* q
@@ -189,7 +189,7 @@ void fromWorldToImage(const Vec3r &p,
*/
void fromWorldToImage(const Vec3r &p, Vec3r &q, const real transform[4][4], const int viewport[4]);
/*! Projects from world coordinates to camera coordinates
/** Projects from world coordinates to camera coordinates
* Returns the point's coordinates expressed in the camera's
* coordinates system.
* p
@@ -202,7 +202,7 @@ void fromWorldToImage(const Vec3r &p, Vec3r &q, const real transform[4][4], cons
*/
void fromWorldToCamera(const Vec3r &p, Vec3r &q, const real model_view_matrix[4][4]);
/*! Projects from World Coordinates to retina coordinates
/** Projects from World Coordinates to retina coordinates
* Returns the point's coordinates expressed in Retina system.
* p
* point's coordinates expressed in camera system
@@ -214,7 +214,7 @@ void fromWorldToCamera(const Vec3r &p, Vec3r &q, const real model_view_matrix[4]
*/
void fromCameraToRetina(const Vec3r &p, Vec3r &q, const real projection_matrix[4][4]);
/*! From retina to image.
/** From retina to image.
* Returns the coordinates expressed in Image coordinates system.
* p
* point's coordinates expressed in retina system
@@ -225,7 +225,7 @@ void fromCameraToRetina(const Vec3r &p, Vec3r &q, const real projection_matrix[4
*/
void fromRetinaToImage(const Vec3r &p, Vec3r &q, const int viewport[4]);
/*! From image to retina
/** From image to retina
* p
* point's coordinates expressed in image system
* q
@@ -235,7 +235,7 @@ void fromRetinaToImage(const Vec3r &p, Vec3r &q, const int viewport[4]);
*/
void fromImageToRetina(const Vec3r &p, Vec3r &q, const int viewport[4]);
/*! computes the coordinates of q in the camera coordinates system,
/** computes the coordinates of q in the camera coordinates system,
* using the known z coordinates of the 3D point.
* That means that this method does not inverse any matrices,
* it only computes X and Y from x,y and Z)
@@ -249,7 +249,7 @@ void fromImageToRetina(const Vec3r &p, Vec3r &q, const int viewport[4]);
*/
void fromRetinaToCamera(const Vec3r &p, Vec3r &q, real focal, const real projection_matrix[4][4]);
/*! Projects from camera coordinates to world coordinates
/** Projects from camera coordinates to world coordinates
* Returns the point's coordinates expressed in the world's
* coordinates system.
* p

42
source/blender/freestyle/intern/geometry/Grid.h
View File

@@ -114,7 +114,7 @@ class GridVisitor {
#endif
};
/*! Gathers all the occluders belonging to the cells traversed by the ray */
/** Gathers all the occluders belonging to the cells traversed by the ray */
class allOccludersGridVisitor : public GridVisitor {
public:
allOccludersGridVisitor(OccludersSet &occluders) : GridVisitor(), occluders_(occluders)
@@ -137,7 +137,7 @@ class allOccludersGridVisitor : public GridVisitor {
OccludersSet &occluders_;
};
/*! Finds the first intersection and breaks.
/** Finds the first intersection and breaks.
* The occluder and the intersection information are stored and accessible.
*/
class firstIntersectionGridVisitor : public GridVisitor {
@@ -190,7 +190,7 @@ class firstIntersectionGridVisitor : public GridVisitor {
class Grid {
public:
/*! Builds a Grid. Must be followed by a call to configure() */
/** Builds a Grid. Must be followed by a call to configure() */
Grid()
{
}
@@ -200,12 +200,12 @@ class Grid {
clear();
}
/*! clears the grid
/** clears the grid
* Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
/** Sets the different parameters of the grid
* orig
* The grid origin
* size
@@ -215,7 +215,7 @@ class Grid {
*/
virtual void configure(const Vec3r &orig, const Vec3r &size, unsigned nb);
/*! returns a vector of integer containing the coordinates of the cell containing the point
/** returns a vector of integer containing the coordinates of the cell containing the point
* passed as argument
* p
* The point for which we're looking the cell
@@ -237,13 +237,13 @@ class Grid {
}
}
/*! Fills the case corresponding to coord with the cell */
/** Fills the case corresponding to coord with the cell */
virtual void fillCell(const Vec3u &coord, Cell &cell) = 0;
/*! returns the cell whose coordinates are passed as argument */
/** returns the cell whose coordinates are passed as argument */
virtual Cell *getCell(const Vec3u &coord) = 0;
/*! returns the cell containing the point passed as argument.
/** returns the cell containing the point passed as argument.
* If the cell is empty (contains no occluder), NULL is returned:
* p
* The point for which we're looking the cell
@@ -255,7 +255,7 @@ class Grid {
return getCell(coord);
}
/*! Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k)
/** Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k)
* is passed as argument:
* cell_coord
* i,j,k integer coordinates for the cell
@@ -269,7 +269,7 @@ class Grid {
}
}
/*! Retrieves the box corresponding to the cell whose coordinates are passed as argument:
/** Retrieves the box corresponding to the cell whose coordinates are passed as argument:
* cell_coord
* i,j,k integer coordinates for the cell
* min_out
@@ -283,19 +283,19 @@ class Grid {
max_out = min_out + _cell_size;
}
/*! inserts a convex polygon occluder
/** inserts a convex polygon occluder
* This method is quite coarse insofar as it adds all cells intersecting the polygon bounding
* box convex_poly The list of 3D points constituting a convex polygon
*/
void insertOccluder(Polygon3r *occluder);
/*! Adds an occluder to the list of occluders */
/** Adds an occluder to the list of occluders */
void addOccluder(Polygon3r *occluder)
{
_occluders.push_back(occluder);
}
/*! Casts a ray between a starting point and an ending point
/** Casts a ray between a starting point and an ending point
* Returns the list of occluders contained in the cells intersected by this ray
* Starts with a call to InitRay.
*/
@@ -304,7 +304,7 @@ class Grid {
// Prepares to cast ray without generating OccludersSet
void initAcceleratedRay(const Vec3r &orig, const Vec3r &end, unsigned timestamp);
/*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a
/** Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a
* given direction. Returns the list of occluders contained in the cells intersected by this ray
* Starts with a call to InitRay.
*/
@@ -316,22 +316,22 @@ class Grid {
// Prepares to cast ray without generating OccludersSet.
bool initAcceleratedInfiniteRay(const Vec3r &orig, const Vec3r &dir, unsigned timestamp);
/*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a
/** Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a
* given direction. Returns the first intersection (occluder,t,u,v) or null. Starts with a call
* to InitRay.
*/
Polygon3r *castRayToFindFirstIntersection(
const Vec3r &orig, const Vec3r &dir, double &t, double &u, double &v, unsigned timestamp);
/*! Init all structures and values for computing the cells intersected by this new ray */
/** Init all structures and values for computing the cells intersected by this new ray */
void initRay(const Vec3r &orig, const Vec3r &end, unsigned timestamp);
/*! Init all structures and values for computing the cells intersected by this infinite ray.
/** Init all structures and values for computing the cells intersected by this infinite ray.
* Returns false if the ray doesn't intersect the grid.
*/
bool initInfiniteRay(const Vec3r &orig, const Vec3r &dir, unsigned timestamp);
/*! Accessors */
/** Accessors */
inline const Vec3r &getOrigin() const
{
return _orig;
@@ -362,7 +362,7 @@ class Grid {
}
protected:
/*! Core of castRay and castInfiniteRay, find occluders along the given ray */
/** Core of castRay and castInfiniteRay, find occluders along the given ray */
inline void castRayInternal(GridVisitor &visitor)
{
Cell *current_cell = NULL;
@@ -383,7 +383,7 @@ class Grid {
} while ((!visitor.stop()) && (nextRayCell(_current_cell, _current_cell)));
}
/*! returns the cell next to the cell passed as argument. */
/** returns the cell next to the cell passed as argument. */
bool nextRayCell(Vec3u &current_cell, Vec3u &next_cell);
unsigned int _timestamp;

2
source/blender/freestyle/intern/geometry/GridHelpers.h
View File

@@ -38,7 +38,7 @@ namespace Freestyle {
namespace GridHelpers {
/*! Computes the distance from a point P to a segment AB */
/** Computes the distance from a point P to a segment AB */
template<class T> T closestPointToSegment(const T &P, const T &A, const T &B, real &distance)
{
T AB, AP, BP;

12
source/blender/freestyle/intern/geometry/HashGrid.h
View File

@@ -37,7 +37,7 @@
namespace Freestyle {
/*! Defines a hash table used for searching the Cells */
/** Defines a hash table used for searching the Cells */
struct GridHasher {
#define _MUL 950706376UL
#define _MOD 2147483647UL
@@ -51,7 +51,7 @@ struct GridHasher {
#undef _MOD
};
/*! Class to define a regular grid used for ray casting computations */
/** Class to define a regular grid used for ray casting computations */
class HashGrid : public Grid {
public:
typedef map<Vec3u, Cell *> GridHashTable;
@@ -65,12 +65,12 @@ class HashGrid : public Grid {
clear();
}
/*! clears the grid
/** clears the grid
* Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
*/
virtual void clear();
/*! Sets the different parameters of the grid
/** Sets the different parameters of the grid
* orig
* The grid origin
* size
@@ -80,7 +80,7 @@ class HashGrid : public Grid {
*/
virtual void configure(const Vec3r &orig, const Vec3r &size, unsigned nb);
/*! returns the cell whose coordinates are passed as argument */
/** returns the cell whose coordinates are passed as argument */
virtual Cell *getCell(const Vec3u &p)
{
Cell *found_cell = NULL;
@@ -92,7 +92,7 @@ class HashGrid : public Grid {
return found_cell;
}
/*! Fills the case p with the cell iCell */
/** Fills the case p with the cell iCell */
virtual void fillCell(const Vec3u &p, Cell &cell)
{
_cells[p] = &cell;

18
source/blender/freestyle/intern/geometry/Noise.h
View File

@@ -37,33 +37,33 @@ namespace Freestyle {
using namespace Geometry;
/*! Class to provide Perlin Noise functionalities */
/** Class to provide Perlin Noise functionalities */
class Noise {
public:
/*! Builds a Noise object */
/** Builds a Noise object */
Noise(long seed = -1);
/*! Destructor */
/** Destructor */
~Noise()
{
}
/*! Returns a noise value for a 1D element */
/** Returns a noise value for a 1D element */
float turbulence1(float arg, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 2D element */
/** Returns a noise value for a 2D element */
float turbulence2(Vec2f &v, float freq, float amp, unsigned oct = 4);
/*! Returns a noise value for a 3D element */
/** Returns a noise value for a 3D element */
float turbulence3(Vec3f &v, float freq, float amp, unsigned oct = 4);
/*! Returns a smooth noise value for a 1D element */
/** Returns a smooth noise value for a 1D element */
float smoothNoise1(float arg);
/*! Returns a smooth noise value for a 2D element */
/** Returns a smooth noise value for a 2D element */
float smoothNoise2(Vec2f &vec);
/*! Returns a smooth noise value for a 3D element */
/** Returns a smooth noise value for a 3D element */
float smoothNoise3(Vec3f &vec);
private:

2
source/blender/freestyle/intern/geometry/Polygon.h
View File

@@ -205,7 +205,7 @@ class Polygon3r : public Polygon<Vec3r> {
return _normal;
}
/*! Check whether the Polygon intersects with the ray or not */
/** Check whether the Polygon intersects with the ray or not */
inline bool rayIntersect(const Vec3r &orig,
const Vec3r &dir,
real &t,

8
source/blender/freestyle/intern/geometry/SweepLine.h
View File

@@ -30,7 +30,7 @@
namespace Freestyle {
/*! Class to define the intersection between two segments*/
/** Class to define the intersection between two segments*/
template<class Edge> class Intersection {
public:
template<class EdgeClass> Intersection(EdgeClass *eA, real ta, EdgeClass *eB, real tb)
@@ -51,7 +51,7 @@ template<class Edge> class Intersection {
userdata = 0;
}
/*! returns the parameter giving the intersection, for the edge iEdge */
/** returns the parameter giving the intersection, for the edge iEdge */
real getParameter(Edge *iEdge)
{
if (iEdge == EdgeA) {
@@ -144,7 +144,7 @@ template<class T, class Point> class Segment {
_Intersections.push_back(i);
}
/*! Checks for a common vertex with another edge */
/** Checks for a common vertex with another edge */
inline bool CommonVertex(const Segment<T, Point> &S, Point &CP)
{
if ((A == S[0]) || (A == S[1])) {
@@ -190,7 +190,7 @@ template<class T, class Point> class Segment {
# pragma warning(pop)
#endif
/*! defines a binary function that can be overload by the user to specify at each condition the
/** defines a binary function that can be overload by the user to specify at each condition the
* intersection between 2 edges must be computed
*/
template<class T1, class T2> struct binary_rule {

8
source/blender/freestyle/intern/image/GaussianFilter.h
View File

@@ -54,7 +54,7 @@ class GaussianFilter {
GaussianFilter &operator=(const GaussianFilter &);
virtual ~GaussianFilter();
/*! Returns the value for pixel x,y of image "map" after a gaussian blur, made using the sigma
/** Returns the value for pixel x,y of image "map" after a gaussian blur, made using the sigma
* value. The sigma value determines the mask size (~ 2 x sigma).
* \param map: The image we wish to work on.
* The Map template must implement the following methods:
@@ -70,12 +70,12 @@ class GaussianFilter {
*/
template<class Map> float getSmoothedPixel(Map *map, int x, int y);
/*! Compute the mask size and returns the REAL mask size ((2*_maskSize)-1)
/** Compute the mask size and returns the REAL mask size ((2*_maskSize)-1)
* This method is provided for convenience.
*/
static int computeMaskSize(float sigma);
/*! accessors */
/** accessors */
inline float sigma() const
{
return _sigma;
@@ -91,7 +91,7 @@ class GaussianFilter {
return _bound;
}
/*! modifiers */
/** modifiers */
void setSigma(float sigma);
#if 0
void SetMaskSize(int size)

36
source/blender/freestyle/intern/image/Image.h
View File

@@ -34,14 +34,14 @@ namespace Freestyle {
//
///////////////////////////////////////////////////////////////////////////////
/*! This class allows the storing of part of an image, while allowing a normal access to its pixel
/** This class allows the storing of part of an image, while allowing a normal access to its pixel
* values. You can for example only a rectangle of sw*sh, whose lower-left corner is at (ox, oy),
* of an image of size w*h, and access these pixels using x,y coordinates specified in the whole
* image coordinate system.
*/
class FrsImage {
public:
/*! Default constructor */
/** Default constructor */
FrsImage()
{
_storedWidth = 0;
@@ -52,7 +52,7 @@ class FrsImage {
_Oy = 0;
}
/*! Copy constructor */
/** Copy constructor */
FrsImage(const FrsImage &brother)
{
_storedWidth = brother._storedWidth;
@@ -63,7 +63,7 @@ class FrsImage {
_Oy = brother._Oy;
}
/*! Builds an FrsImage from its width and height.
/** Builds an FrsImage from its width and height.
* The memory is allocated consequently.
*/
FrsImage(unsigned w, unsigned h)
@@ -76,7 +76,7 @@ class FrsImage {
_Oy = 0;
}
/*! Builds a partial-storing image.
/** Builds a partial-storing image.
* \param w:
* The width of the complete image
* \param h:
@@ -100,7 +100,7 @@ class FrsImage {
_Oy = oy;
}
/*! Operator= */
/** Operator= */
FrsImage &operator=(const FrsImage &brother)
{
_width = brother._width;
@@ -112,27 +112,27 @@ class FrsImage {
return *this;
}
/*! Destructor */
/** Destructor */
virtual ~FrsImage()
{
}
/*! Returns the width of the complete image */
/** Returns the width of the complete image */
inline unsigned width() const
{
return _width;
}
/*! Returns the height of the complete image */
/** Returns the height of the complete image */
inline unsigned height() const
{
return _height;
}
/*! Returns the gray value for pixel x,y */
/** Returns the gray value for pixel x,y */
virtual float pixel(unsigned x, unsigned y) const = 0;
/*! Sets the array.
/** Sets the array.
* \param array:
* The array containing the values we wish to store.
* Its size is sw*sh.
@@ -160,7 +160,7 @@ class FrsImage {
unsigned y,
bool copy = true) = 0;
/*! Returns the array containing the pixels values.
/** Returns the array containing the pixels values.
* Its size is sw*sh, i.e. potentially a smaller rectangular part of the complete image.
*/
virtual float *getArray() = 0;
@@ -206,7 +206,7 @@ class RGBImage : public FrsImage {
memcpy(_rgb, rgb, 3 * _width * _height * sizeof(float));
}
/*! Builds an RGB partial image from the useful part buffer.
/** Builds an RGB partial image from the useful part buffer.
* \param rgb:
* The array of size 3*sw*sh containing the RGB values of the sw*sh pixels we need to stored.
* These sw*sh pixels constitute a rectangular part of a bigger
@@ -279,7 +279,7 @@ class RGBImage : public FrsImage {
return res / 32.0f;
}
/*! Sets the RGB array.
/** Sets the RGB array.
* copy
* If true, the array is copied, otherwise the pointer is copied
*/
@@ -333,7 +333,7 @@ class GrayImage : public FrsImage {
memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(*_lvl));
}
/*! Builds an empty gray image */
/** Builds an empty gray image */
GrayImage(unsigned w, unsigned h) : FrsImage(w, h)
{
_lvl = new float[_width * _height];
@@ -345,7 +345,7 @@ class GrayImage : public FrsImage {
memcpy(_lvl, lvl, _width * _height * sizeof(*_lvl));
}
/*! Builds a partial image from the useful part buffer.
/** Builds a partial image from the useful part buffer.
* \param lvl:
* The array of size sw*sh containing the gray values of the sw*sh pixels we need to stored.
* These sw*sh pixels constitute a rectangular part of a bigger
@@ -391,7 +391,7 @@ class GrayImage : public FrsImage {
return _lvl[(y - _Oy) * _storedWidth + (x - _Ox)];
}
/*! Sets the array.
/** Sets the array.
* copy
* If true, the array is copied, otherwise the pounsigneder is copied
*/
@@ -418,7 +418,7 @@ class GrayImage : public FrsImage {
memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
}
/*! Returns the array containing the gray values. */
/** Returns the array containing the gray values. */
virtual float *getArray()
{
return _lvl;

12
source/blender/freestyle/intern/image/ImagePyramid.h
View File

@@ -45,17 +45,17 @@ class ImagePyramid {
// ImagePyramid(const GrayImage& level0, unsigned nbLevels);
virtual ~ImagePyramid();
/*! Builds the pyramid.
/** Builds the pyramid.
* must be overloaded by inherited classes.
* if nbLevels==0, the complete pyramid is built
*/
virtual void BuildPyramid(const GrayImage &level0, unsigned nbLevels) = 0;
/*! Builds a pyramid without copying the base level */
/** Builds a pyramid without copying the base level */
virtual void BuildPyramid(GrayImage *level0, unsigned nbLevels) = 0;
virtual GrayImage *getLevel(int l);
/*! Returns the pixel x,y using bilinear interpolation.
/** Returns the pixel x,y using bilinear interpolation.
* \param x:
* the abscissa specified in the finest level coordinate system
* \param y:
@@ -65,13 +65,13 @@ class ImagePyramid {
*/
virtual float pixel(int x, int y, int level = 0);
/*! Returns the width of the level-th level image */
/** Returns the width of the level-th level image */
virtual int width(int level = 0);
/*! Returns the height of the level-th level image */
/** Returns the height of the level-th level image */
virtual int height(int level = 0);
/*! Returns the number of levels in the pyramid */
/** Returns the number of levels in the pyramid */
inline int getNumberOfLevels() const
{
return _levels.size();

2
source/blender/freestyle/intern/scene_graph/DrawingStyle.h
View File

@@ -50,7 +50,7 @@ class DrawingStyle {
{
}
/*! operators */
/** operators */
inline DrawingStyle &operator=(const DrawingStyle &ds);
inline void setStyle(const STYLE iStyle)

80
source/blender/freestyle/intern/scene_graph/FrsMaterial.h
View File

@@ -29,13 +29,13 @@
namespace Freestyle {
/*! Class defining a material */
/** Class defining a material */
class FrsMaterial {
public:
/*! Default constructor */
/** Default constructor */
inline FrsMaterial();
/*! Builds a Material from its line, diffuse, ambient, specular, emissive
/** Builds a Material from its line, diffuse, ambient, specular, emissive
* colors, a shininess coefficient and line color priority.
* \param iLine:
* A 4 element float-array containing the line color.
@@ -60,177 +60,177 @@ class FrsMaterial {
const float iShininess,
const int iPriority);
/*! Copy constructor */
/** Copy constructor */
inline FrsMaterial(const FrsMaterial &m);
/*! Destructor */
/** Destructor */
virtual ~FrsMaterial()
{
}
/*! Returns the line color as a 4 float array */
/** Returns the line color as a 4 float array */
inline const float *line() const
{
return Line;
}
/*! Returns the red component of the line color */
/** Returns the red component of the line color */
inline const float lineR() const
{
return Line[0];
}
/*! Returns the green component of the line color */
/** Returns the green component of the line color */
inline const float lineG() const
{
return Line[1];
}
/*! Returns the blue component of the line color */
/** Returns the blue component of the line color */
inline const float lineB() const
{
return Line[2];
}
/*! Returns the alpha component of the line color */
/** Returns the alpha component of the line color */
inline const float lineA() const
{
return Line[3];
}
/*! Returns the diffuse color as a 4 float array */
/** Returns the diffuse color as a 4 float array */
inline const float *diffuse() const
{
return Diffuse;
}
/*! Returns the red component of the diffuse color */
/** Returns the red component of the diffuse color */
inline const float diffuseR() const
{
return Diffuse[0];
}
/*! Returns the green component of the diffuse color */
/** Returns the green component of the diffuse color */
inline const float diffuseG() const
{
return Diffuse[1];
}
/*! Returns the blue component of the diffuse color */
/** Returns the blue component of the diffuse color */
inline const float diffuseB() const
{
return Diffuse[2];
}
/*! Returns the alpha component of the diffuse color */
/** Returns the alpha component of the diffuse color */
inline const float diffuseA() const
{
return Diffuse[3];
}
/*! Returns the specular color as a 4 float array */
/** Returns the specular color as a 4 float array */
inline const float *specular() const
{
return Specular;
}
/*! Returns the red component of the specular color */
/** Returns the red component of the specular color */
inline const float specularR() const
{
return Specular[0];
}
/*! Returns the green component of the specular color */
/** Returns the green component of the specular color */
inline const float specularG() const
{
return Specular[1];
}
/*! Returns the blue component of the specular color */
/** Returns the blue component of the specular color */
inline const float specularB() const
{
return Specular[2];
}
/*! Returns the alpha component of the specular color */
/** Returns the alpha component of the specular color */
inline const float specularA() const
{
return Specular[3];
}
/*! Returns the ambient color as a 4 float array */
/** Returns the ambient color as a 4 float array */
inline const float *ambient() const
{
return Ambient;
}
/*! Returns the red component of the ambient color */
/** Returns the red component of the ambient color */
inline const float ambientR() const
{
return Ambient[0];
}
/*! Returns the green component of the ambient color */
/** Returns the green component of the ambient color */
inline const float ambientG() const
{
return Ambient[1];
}
/*! Returns the blue component of the ambient color */
/** Returns the blue component of the ambient color */
inline const float ambientB() const
{
return Ambient[2];
}
/*! Returns the alpha component of the ambient color */
/** Returns the alpha component of the ambient color */
inline const float ambientA() const
{
return Ambient[3];
}
/*! Returns the emissive color as a 4 float array */
/** Returns the emissive color as a 4 float array */
inline const float *emission() const
{
return Emission;
}
/*! Returns the red component of the emissive color */
/** Returns the red component of the emissive color */
inline const float emissionR() const
{
return Emission[0];
}
/*! Returns the green component of the emissive color */
/** Returns the green component of the emissive color */
inline const float emissionG() const
{
return Emission[1];
}
/*! Returns the blue component of the emissive color */
/** Returns the blue component of the emissive color */
inline const float emissionB() const
{
return Emission[2];
}
/*! Returns the alpha component of the emissive color */
/** Returns the alpha component of the emissive color */
inline const float emissionA() const
{
return Emission[3];
}
/*! Returns the shininess coefficient */
/** Returns the shininess coefficient */
inline const float shininess() const
{
return Shininess;
}
/*! Returns the line color priority */
/** Returns the line color priority */
inline const int priority() const
{
return Priority;
}
/*! Sets the line color.
/** Sets the line color.
* \param r:
* Red component
* \param g:
@@ -242,7 +242,7 @@ class FrsMaterial {
*/
inline void setLine(const float r, const float g, const float b, const float a);
/*! Sets the diffuse color.
/** Sets the diffuse color.
* \param r:
* Red component
* \param g:
@@ -254,7 +254,7 @@ class FrsMaterial {
*/
inline void setDiffuse(const float r, const float g, const float b, const float a);
/*! Sets the specular color.
/** Sets the specular color.
* \param r:
* Red component
* \param g:
@@ -266,7 +266,7 @@ class FrsMaterial {
*/
inline void setSpecular(const float r, const float g, const float b, const float a);
/*! Sets the ambient color.
/** Sets the ambient color.
* \param r:
* Red component
* \param g:
@@ -278,7 +278,7 @@ class FrsMaterial {
*/
inline void setAmbient(const float r, const float g, const float b, const float a);
/*! Sets the emissive color.
/** Sets the emissive color.
* \param r:
* Red component
* \param g:
@@ -290,13 +290,13 @@ class FrsMaterial {
*/
inline void setEmission(const float r, const float g, const float b, const float a);
/*! Sets the shininess.
/** Sets the shininess.
* \param s:
* Shininess
*/
inline void setShininess(const float s);
/*! Sets the line color priority.
/** Sets the line color priority.
* \param priority:
* Priority
*/
@@ -308,7 +308,7 @@ class FrsMaterial {
inline bool operator==(const FrsMaterial &m) const;
private:
/*! Material properties */
/** Material properties */
float Line[4];
float Diffuse[4];
float Specular[4];

18
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h
View File

@@ -33,14 +33,14 @@ namespace Freestyle {
class IndexedFaceSet : public Rep {
public:
/*! Triangles description style:*/
/** Triangles description style:*/
enum TRIANGLES_STYLE {
TRIANGLE_STRIP,
TRIANGLE_FAN,
TRIANGLES,
};
/*! User-specified face and edge marks for feature edge detection */
/** User-specified face and edge marks for feature edge detection */
/* XXX Why in hell not use an enum here too? */
typedef unsigned char FaceEdgeMark;
static const FaceEdgeMark FACE_MARK = 1 << 0;
@@ -48,10 +48,10 @@ class IndexedFaceSet : public Rep {
static const FaceEdgeMark EDGE_MARK_V2V3 = 1 << 2;
static const FaceEdgeMark EDGE_MARK_V3V1 = 1 << 3;
/*! Builds an empty indexed face set. */
/** Builds an empty indexed face set. */
IndexedFaceSet();
/*! Builds an indexed face set
/** Builds an indexed face set
* iVertices
* The array of object vertices 3D coordinates (for all faces).
* If iCopy != 0, the array is copied; you must deallocate iVertices. Else you must not.
@@ -126,7 +126,7 @@ class IndexedFaceSet : public Rep {
unsigned iTISize,
unsigned iCopy = 1);
/*! Builds an indexed face set from an other indexed face set */
/** Builds an indexed face set from an other indexed face set */
IndexedFaceSet(const IndexedFaceSet &iBrother);
void swap(IndexedFaceSet &ioOther)
@@ -166,18 +166,18 @@ class IndexedFaceSet : public Rep {
return *this;
}
/*! Destructor
/** Destructor
* deallocates all the resources
*/
virtual ~IndexedFaceSet();
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! Compute the Bounding Box */
/** Compute the Bounding Box */
virtual void ComputeBBox();
/*! Accessors */
/** Accessors */
virtual const float *vertices() const
{
return _Vertices;

18
source/blender/freestyle/intern/scene_graph/LineRep.h
View File

@@ -32,10 +32,10 @@ using namespace std;
namespace Freestyle {
/*! Base class for all lines objects */
/** Base class for all lines objects */
class LineRep : public Rep {
public:
/*! Line description style */
/** Line description style */
enum LINES_STYLE {
LINES,
LINE_STRIP,
@@ -47,7 +47,7 @@ class LineRep : public Rep {
_width = 0.0f;
}
/*! Builds a single line from 2 vertices
/** Builds a single line from 2 vertices
* v1
* first vertex
* v2
@@ -61,7 +61,7 @@ class LineRep : public Rep {
_width = 0.0f;
}
/*! Builds a line rep from a vertex chain */
/** Builds a line rep from a vertex chain */
inline LineRep(const vector<Vec3r> &vertices) : Rep()
{
_vertices = vertices;
@@ -69,7 +69,7 @@ class LineRep : public Rep {
_width = 0.0f;
}
/*! Builds a line rep from a vertex chain */
/** Builds a line rep from a vertex chain */
inline LineRep(const list<Vec3r> &vertices) : Rep()
{
for (list<Vec3r>::const_iterator v = vertices.begin(), end = vertices.end(); v != end; ++v) {
@@ -84,7 +84,7 @@ class LineRep : public Rep {
_vertices.clear();
}
/*! accessors */
/** accessors */
inline const LINES_STYLE style() const
{
return _Style;
@@ -100,7 +100,7 @@ class LineRep : public Rep {
return _width;
}
/*! modifiers */
/** modifiers */
inline void setStyle(const LINES_STYLE iStyle)
{
_Style = iStyle;
@@ -127,14 +127,14 @@ class LineRep : public Rep {
_width = iWidth;
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v)
{
Rep::accept(v);
v.visitLineRep(*this);
}
/*! Computes the line bounding box.*/
/** Computes the line bounding box.*/
virtual void ComputeBBox();
private:

14
source/blender/freestyle/intern/scene_graph/Node.h
View File

@@ -52,7 +52,7 @@ class Node : public BaseObject {
{
}
/*! Accept the corresponding visitor
/** Accept the corresponding visitor
* Each inherited node must overload this method
*/
virtual void accept(SceneVisitor &v)
@@ -60,8 +60,8 @@ class Node : public BaseObject {
v.visitNode(*this);
}
/*! bounding box management */
/*! Returns the node bounding box
/** bounding box management */
/** Returns the node bounding box
* If no bounding box exists, an empty bbox is returned
*/
virtual const BBox<Vec3r> &bbox() const
@@ -69,13 +69,13 @@ class Node : public BaseObject {
return _BBox;
}
/*! Sets the Node bounding box */
/** Sets the Node bounding box */
virtual void setBBox(const BBox<Vec3r> &iBox)
{
_BBox = iBox;
}
/*! Makes the union of _BBox and iBox */
/** Makes the union of _BBox and iBox */
virtual void AddBBox(const BBox<Vec3r> &iBox)
{
if (iBox.empty()) {
@@ -90,13 +90,13 @@ class Node : public BaseObject {
}
}
/*! Updates the BBox */
/** Updates the BBox */
virtual const BBox<Vec3r> &UpdateBBox()
{
return _BBox;
}
/*! Clears the bounding box */
/** Clears the bounding box */
virtual void clearBBox()
{
_BBox.clear();

14
source/blender/freestyle/intern/scene_graph/NodeCamera.h
View File

@@ -43,7 +43,7 @@ class NodeCamera : public Node {
GENERIC,
} CameraType;
/*! Default matrices: Identity for both projection and modelview. */
/** Default matrices: Identity for both projection and modelview. */
NodeCamera(CameraType camera_type = GENERIC);
#if 0 /* UNUSED, gives warning in gcc */
NodeCamera(const NodeCamera &iBrother);
@@ -53,13 +53,13 @@ class NodeCamera : public Node {
{
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! Matrix is copied */
/** Matrix is copied */
void setModelViewMatrix(double modelview_matrix[16]);
/*! Matrix is copied */
/** Matrix is copied */
void setProjectionMatrix(double projection_matrix[16]);
double *modelViewMatrix()
@@ -89,7 +89,7 @@ class NodeOrthographicCamera : public NodeCamera {
public:
NodeOrthographicCamera();
/*! Builds a parallel projection matrix a la glOrtho.
/** Builds a parallel projection matrix a la glOrtho.
* A 0 0 tx
* 0 B 0 ty
* 0 0 C tz
@@ -155,7 +155,7 @@ class NodePerspectiveCamera : public NodeCamera {
public:
NodePerspectiveCamera();
/*! Builds a perspective projection matrix a la gluPerspective.
/** Builds a perspective projection matrix a la gluPerspective.
* Given f defined as follows:
* fovy
* f = cotangent(____)
@@ -177,7 +177,7 @@ class NodePerspectiveCamera : public NodeCamera {
*/
NodePerspectiveCamera(double fovy, double aspect, double zNear, double zFar);
/*! Builds a perspective projection matrix a la glFrustum.
/** Builds a perspective projection matrix a la glFrustum.
* ( 2*zNear )
* | __________ 0 A 0 |
* | right-left |

12
source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.h
View File

@@ -48,34 +48,34 @@ class NodeDrawingStyle : public NodeGroup {
_DrawingStyle = iDrawingStyle;
}
/*! Sets the style. Must be one of FILLED, LINES, POINTS, INVISIBLE. */
/** Sets the style. Must be one of FILLED, LINES, POINTS, INVISIBLE. */
inline void setStyle(const DrawingStyle::STYLE iStyle)
{
_DrawingStyle.setStyle(iStyle);
}
/*! Sets the line width in the LINES style case */
/** Sets the line width in the LINES style case */
inline void setLineWidth(const float iLineWidth)
{
_DrawingStyle.setLineWidth(iLineWidth);
}
/*! Sets the Point size in the POINTS style case */
/** Sets the Point size in the POINTS style case */
inline void setPointSize(const float iPointSize)
{
_DrawingStyle.setPointSize(iPointSize);
}
/*! Enables or disables the lighting. true = enable */
/** Enables or disables the lighting. true = enable */
inline void setLightingEnabled(const bool iEnableLighting)
{
_DrawingStyle.setLightingEnabled(iEnableLighting);
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! accessors */
/** accessors */
inline DrawingStyle::STYLE style() const
{
return _DrawingStyle.style();

2
source/blender/freestyle/intern/scene_graph/NodeGroup.cpp
View File

@@ -37,7 +37,7 @@ void NodeGroup::AddChild(Node *iChild)
int NodeGroup::destroy()
{
/*! Node::destroy makes a release on the object and then returns the reference counter.
/** Node::destroy makes a release on the object and then returns the reference counter.
* If the reference counter is equal to 0, that means that nobody else is linking this node
* group and that we can destroy the whole underlying tree. Else, one or several Node link this
* node group, and we only returns the reference counter decremented by Node::destroy();

18
source/blender/freestyle/intern/scene_graph/NodeGroup.h
View File

@@ -42,33 +42,33 @@ class NodeGroup : public Node {
{
}
/*! Adds a child. Makes a addRef on the iChild reference counter */
/** Adds a child. Makes a addRef on the iChild reference counter */
virtual void AddChild(Node *iChild);
/*! destroys all the underlying nodes
/** destroys all the underlying nodes
* Returns the reference counter after having done a release()
*/
virtual int destroy();
/*! Detaches all the children */
/** Detaches all the children */
virtual void DetachChildren();
/*! Detached the specified child */
/** Detached the specified child */
virtual void DetachChild(Node *iChild);
/*! Retrieve children */
/** Retrieve children */
virtual void RetrieveChildren(vector<Node *> &oNodes);
/*! Renders every children */
/** Renders every children */
// virtual void Render(Renderer *iRenderer);
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! Updates the BBox */
/** Updates the BBox */
virtual const BBox<Vec3r> &UpdateBBox();
/*! Returns the number of children */
/** Returns the number of children */
virtual int numberOfChildren()
{
return _Children.size();

16
source/blender/freestyle/intern/scene_graph/NodeLight.h
View File

@@ -40,10 +40,10 @@ class NodeLight : public Node {
{
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! Accessors for the light properties */
/** Accessors for the light properties */
inline const float *ambient() const
{
return Ambient;
@@ -78,24 +78,24 @@ class NodeLight : public Node {
// Data members
// ============
/*! on=true, the light is on */
/** on=true, the light is on */
bool on;
/*! The color definition */
/** The color definition */
float Ambient[4];
float Diffuse[4];
float Specular[4];
/*! Light position. if w = 0, the light is placed at infinite. */
/** Light position. if w = 0, the light is placed at infinite. */
float Position[4];
/*! used to manage the number of lights */
/*! numberOfLights
/** used to manage the number of lights */
/** numberOfLights
* the number of lights in the scene.
* Initially, 0.
*/
static int numberOfLights;
/*! The current lignt number */
/** The current lignt number */
int _number;
};

14
source/blender/freestyle/intern/scene_graph/NodeShape.h
View File

@@ -46,7 +46,7 @@ class NodeShape : public Node {
virtual ~NodeShape();
/*! Adds a Rep to the _Shapes list
/** Adds a Rep to the _Shapes list
* The delete of the rep is done when it is not used any more by the Scene Manager.
* So, it must not be deleted by the caller
*/
@@ -62,17 +62,17 @@ class NodeShape : public Node {
AddBBox(iRep->bbox());
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! Sets the shape material */
/** Sets the shape material */
inline void setFrsMaterial(const FrsMaterial &iMaterial)
{
_FrsMaterial = iMaterial;
}
/*! accessors */
/*! returns the shape's material */
/** accessors */
/** returns the shape's material */
inline FrsMaterial &frs_material()
{
return _FrsMaterial;
@@ -84,10 +84,10 @@ class NodeShape : public Node {
}
private:
/*! list of shapes */
/** list of shapes */
vector<Rep *> _Shapes;
/*! Shape Material */
/** Shape Material */
FrsMaterial _FrsMaterial;
};

18
source/blender/freestyle/intern/scene_graph/NodeTransform.h
View File

@@ -44,10 +44,10 @@ class NodeTransform : public NodeGroup {
{
}
/*! multiplies the current matrix by the x, y, z translation matrix. */
/** multiplies the current matrix by the x, y, z translation matrix. */
void Translate(real x, real y, real z);
/*! multiplies the current matrix by a rotation matrix
/** multiplies the current matrix by a rotation matrix
* iAngle
* The rotation angle
* x, y, z
@@ -55,32 +55,32 @@ class NodeTransform : public NodeGroup {
*/
void Rotate(real iAngle, real x, real y, real z);
/*! multiplies the current matrix by a scaling matrix.
/** multiplies the current matrix by a scaling matrix.
* x, y, z
* The scaling coefficients with respect to the x,y,z axis
*/
void Scale(real x, real y, real z);
/*! Multiplies the current matrix by iMatrix */
/** Multiplies the current matrix by iMatrix */
void MultiplyMatrix(const Matrix44r &iMatrix);
/*! Sets the current matrix to iMatrix */
/** Sets the current matrix to iMatrix */
void setMatrix(const Matrix44r &iMatrix);
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
/*! Overloads the Node::AddBBox in order to take care about the transformation */
/** Overloads the Node::AddBBox in order to take care about the transformation */
virtual void AddBBox(const BBox<Vec3r> &iBBox);
/*! Checks whether a matrix contains a scale factor or not.
/** Checks whether a matrix contains a scale factor or not.
* Returns true if yes.
* M
* The matrix to check
*/
bool isScaled(const Matrix44r &M);
/*! accessors */
/** accessors */
inline const Matrix44r &matrix() const
{
return _Matrix;

2
source/blender/freestyle/intern/scene_graph/NodeViewLayer.h
View File

@@ -49,7 +49,7 @@ class NodeViewLayer : public Node {
return _ViewLayer;
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
protected:

8
source/blender/freestyle/intern/scene_graph/OrientedLineRep.h
View File

@@ -32,7 +32,7 @@ class OrientedLineRep : public LineRep {
OrientedLineRep() : LineRep()
{
}
/*! Builds a single line from 2 vertices
/** Builds a single line from 2 vertices
* v1
* first vertex
* v2
@@ -42,12 +42,12 @@ class OrientedLineRep : public LineRep {
{
}
/*! Builds a line rep from a vertex chain */
/** Builds a line rep from a vertex chain */
inline OrientedLineRep(const vector<Vec3r> &vertices) : LineRep(vertices)
{
}
/*! Builds a line rep from a vertex chain */
/** Builds a line rep from a vertex chain */
inline OrientedLineRep(const list<Vec3r> &vertices) : LineRep(vertices)
{
}
@@ -56,7 +56,7 @@ class OrientedLineRep : public LineRep {
{
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v);
};

8
source/blender/freestyle/intern/scene_graph/Rep.h
View File

@@ -102,7 +102,7 @@ class Rep : public BaseObject {
}
}
/*! Accept the corresponding visitor
/** Accept the corresponding visitor
* Must be overload by inherited classes
*/
virtual void accept(SceneVisitor &v)
@@ -113,13 +113,13 @@ class Rep : public BaseObject {
v.visitRep(*this);
}
/*! Computes the rep bounding box.
/** Computes the rep bounding box.
* Each Inherited rep must compute its bbox depending on the way the data are stored. So, each
* inherited class must overload this method
*/
virtual void ComputeBBox() = 0;
/*! Returns the rep bounding box */
/** Returns the rep bounding box */
virtual const BBox<Vec3f> &bbox() const
{
return _BBox;
@@ -145,7 +145,7 @@ class Rep : public BaseObject {
return _FrsMaterial;
}
/*! Sets the Rep bounding box */
/** Sets the Rep bounding box */
virtual void setBBox(const BBox<Vec3f> &iBox)
{
_BBox = iBox;

14
source/blender/freestyle/intern/scene_graph/TriangleRep.h
View File

@@ -26,10 +26,10 @@
namespace Freestyle {
/*! Base class for all lines objects */
/** Base class for all lines objects */
class TriangleRep : public Rep {
public:
/*! Line description style */
/** Line description style */
enum TRIANGLE_STYLE {
FILL,
LINES,
@@ -46,7 +46,7 @@ class TriangleRep : public Rep {
_Style = FILL;
}
/*! Builds a triangle from 3 vertices
/** Builds a triangle from 3 vertices
* v0
* first vertex
* v1
@@ -83,7 +83,7 @@ class TriangleRep : public Rep {
{
}
/*! accessors */
/** accessors */
inline const TRIANGLE_STYLE style() const
{
return _Style;
@@ -99,7 +99,7 @@ class TriangleRep : public Rep {
return _colors[index];
}
/*! modifiers */
/** modifiers */
inline void setStyle(const TRIANGLE_STYLE iStyle)
{
_Style = iStyle;
@@ -129,14 +129,14 @@ class TriangleRep : public Rep {
_colors[2] = c2;
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v)
{
Rep::accept(v);
v.visitTriangleRep(*this);
}
/*! Computes the triangle bounding box.*/
/** Computes the triangle bounding box.*/
virtual void ComputeBBox();
};

8
source/blender/freestyle/intern/scene_graph/VertexRep.h
View File

@@ -47,17 +47,17 @@ class VertexRep : public Rep {
{
}
/*! Accept the corresponding visitor */
/** Accept the corresponding visitor */
virtual void accept(SceneVisitor &v)
{
Rep::accept(v);
v.visitVertexRep(*this);
}
/*! Computes the rep bounding box. */
/** Computes the rep bounding box. */
virtual void ComputeBBox();
/*! accessors */
/** accessors */
inline const int vid() const
{
return _vid;
@@ -88,7 +88,7 @@ class VertexRep : public Rep {
return _PointSize;
}
/*! modifiers */
/** modifiers */
inline void setVid(int id)
{
_vid = id;

48
source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
View File

@@ -36,13 +36,13 @@ namespace Freestyle {
namespace Functions0D {
// DensityF0D
/*! Returns the density of the (result) image evaluated at an Interface0D.
/** Returns the density of the (result) image evaluated at an Interface0D.
* This density is evaluated using a pixels square window around the evaluation point and
* integrating these values using a gaussian.
*/
class DensityF0D : public UnaryFunction0D<double> {
public:
/*! Builds the functor from the gaussian sigma value.
/** Builds the functor from the gaussian sigma value.
* \param sigma:
* sigma indicates the x value for which the gaussian function is 0.5.
* It leads to the window size value. (the larger, the smoother)
@@ -52,13 +52,13 @@ class DensityF0D : public UnaryFunction0D<double> {
_filter.setSigma((float)sigma);
}
/*! Returns the string "DensityF0D" */
/** Returns the string "DensityF0D" */
string getName() const
{
return "DensityF0D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface0DIterator &iter);
private:
@@ -66,7 +66,7 @@ class DensityF0D : public UnaryFunction0D<double> {
};
// LocalAverageDepthF0D
/*! Returns the average depth around a point.
/** Returns the average depth around a point.
* The result is obtained by querying the depth buffer on a window around that point.
*/
class LocalAverageDepthF0D : public UnaryFunction0D<double> {
@@ -74,31 +74,31 @@ class LocalAverageDepthF0D : public UnaryFunction0D<double> {
GaussianFilter _filter;
public:
/*! Builds the functor from the size of the mask that will be used. */
/** Builds the functor from the size of the mask that will be used. */
LocalAverageDepthF0D(real maskSize = 5.0f) : UnaryFunction0D<double>()
{
_filter.setSigma((float)maskSize / 2.0f);
}
/*! Returns the string "LocalAverageDepthF0D" */
/** Returns the string "LocalAverageDepthF0D" */
string getName() const
{
return "LocalAverageDepthF0D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface0DIterator &iter);
};
// ReadMapPixel
/*! Reads a pixel in a map. */
/** Reads a pixel in a map. */
class ReadMapPixelF0D : public UnaryFunction0D<float> {
private:
const char *_mapName;
int _level;
public:
/*! Builds the functor from name of the
/** Builds the functor from name of the
* Map that must be read.
* \param iMapName:
* The name of the map.
@@ -111,25 +111,25 @@ class ReadMapPixelF0D : public UnaryFunction0D<float> {
_level = level;
}
/*! Returns the string "ReadMapPixelF0D" */
/** Returns the string "ReadMapPixelF0D" */
string getName() const
{
return "ReadMapPixelF0D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface0DIterator &iter);
};
// ReadSteerableViewMapPixel
/*! Reads a pixel in one of the level of one of the steerable viewmaps. */
/** Reads a pixel in one of the level of one of the steerable viewmaps. */
class ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float> {
private:
unsigned _orientation;
int _level;
public:
/*! Builds the functor
/** Builds the functor
* \param nOrientation:
* The integer belonging to [0,4] indicating the orientation (E,NE,N,NW) we are interested in.
* \param level:
@@ -141,24 +141,24 @@ class ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float> {
_level = level;
}
/*! Returns the string "ReadSteerableViewMapPixelF0D" */
/** Returns the string "ReadSteerableViewMapPixelF0D" */
string getName() const
{
return "ReadSteerableViewMapPixelF0D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface0DIterator &iter);
};
// ReadCompleteViewMapPixel
/*! Reads a pixel in one of the level of the complete viewmap. */
/** Reads a pixel in one of the level of the complete viewmap. */
class ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float> {
private:
int _level;
public:
/*! Builds the functor
/** Builds the functor
* \param level:
* The level of the pyramid from which the pixel must be read.
*/
@@ -167,25 +167,25 @@ class ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float> {
_level = level;
}
/*! Returns the string "ReadCompleteViewMapPixelF0D" */
/** Returns the string "ReadCompleteViewMapPixelF0D" */
string getName() const
{
return "ReadCompleteViewMapPixelF0D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface0DIterator &iter);
};
// GetViewMapGradientNormF0D
/*! Returns the norm of the gradient of the global viewmap density image. */
/** Returns the norm of the gradient of the global viewmap density image. */
class GetViewMapGradientNormF0D : public UnaryFunction0D<float> {
private:
int _level;
float _step;
public:
/*! Builds the functor
/** Builds the functor
* \param level:
* The level of the pyramid from which the pixel must be read.
*/
@@ -195,13 +195,13 @@ class GetViewMapGradientNormF0D : public UnaryFunction0D<float> {
_step = (float)pow(2.0, _level);
}
/*! Returns the string "GetOccludeeF0D" */
/** Returns the string "GetOccludeeF0D" */
string getName() const
{
return "GetViewMapGradientNormF0D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface0DIterator &iter);
};

52
source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
View File

@@ -35,7 +35,7 @@ namespace Freestyle {
namespace Functions1D {
// DensityF1D
/*! Returns the density evaluated for an Interface1D.
/** Returns the density evaluated for an Interface1D.
* The density is evaluated for a set of points along the Interface1D (using the DensityF0D
* functor) with a user-defined sampling and then integrated into a single value using a
* user-defined integration method.
@@ -45,7 +45,7 @@ class DensityF1D : public UnaryFunction1D<double> {
float _sampling;
public:
/*! Builds the functor.
/** Builds the functor.
* \param sigma:
* Thesigma used in DensityF0D and determining the window size used in each density query.
* \param iType:
@@ -61,18 +61,18 @@ class DensityF1D : public UnaryFunction1D<double> {
_sampling = sampling;
}
/*! Destructor */
/** Destructor */
virtual ~DensityF1D()
{
}
/*! Returns the string "DensityF1D"*/
/** Returns the string "DensityF1D"*/
string getName() const
{
return "DensityF1D";
}
/*! the () operator.*/
/** the () operator.*/
int operator()(Interface1D &inter)
{
result = integrate(
@@ -85,14 +85,14 @@ class DensityF1D : public UnaryFunction1D<double> {
};
// LocalAverageDepthF1D
/*! Returns the average depth evaluated for an Interface1D.
/** Returns the average depth evaluated for an Interface1D.
* The average depth is evaluated for a set of points along the Interface1D (using the
* LocalAverageDepthF0D functor) with a user-defined sampling and then integrated into a single
* value using a user-defined integration method.
*/
class LocalAverageDepthF1D : public UnaryFunction1D<double> {
public:
/*! Builds the functor.
/** Builds the functor.
* \param sigma:
* The sigma used in DensityF0D and determining the window size used in each density query.
* \param iType:
@@ -103,13 +103,13 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> {
{
}
/*! Returns the string "LocalAverageDepthF1D" */
/** Returns the string "LocalAverageDepthF1D" */
string getName() const
{
return "LocalAverageDepthF1D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface1D &inter)
{
result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
@@ -121,14 +121,14 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> {
};
// GetCompleteViewMapDensity
/*! Returns the density evaluated for an Interface1D in the complete viewmap image.
/** Returns the density evaluated for an Interface1D in the complete viewmap image.
* The density is evaluated for a set of points along the Interface1D (using the
* ReadCompleteViewMapPixelF0D functor) and then integrated into a single value using a
* user-defined integration method.
*/
class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
public:
/*! Builds the functor.
/** Builds the functor.
* \param level:
* The level of the pyramid from which
* the pixel must be read.
@@ -147,13 +147,13 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
_sampling = sampling;
}
/*! Returns the string "GetCompleteViewMapDensityF1D" */
/** Returns the string "GetCompleteViewMapDensityF1D" */
string getName() const
{
return "GetCompleteViewMapDensityF1D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface1D &inter);
private:
@@ -162,7 +162,7 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
};
// GetDirectionalViewMapDensity
/*! Returns the density evaluated for an Interface1D in of the steerable viewmaps image.
/** Returns the density evaluated for an Interface1D in of the steerable viewmaps image.
* The direction telling which Directional map to choose is explicitly specified by the user.
* The density is evaluated for a set of points along the Interface1D
* (using the ReadSteerableViewMapPixelF0D functor)
@@ -170,7 +170,7 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
*/
class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
public:
/*! Builds the functor.
/** Builds the functor.
* \param iOrientation:
* The number of the directional map we must work with.
* \param level:
@@ -191,13 +191,13 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
_sampling = sampling;
}
/*! Returns the string "GetDirectionalViewMapDensityF1D" */
/** Returns the string "GetDirectionalViewMapDensityF1D" */
string getName() const
{
return "GetDirectionalViewMapDensityF1D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface1D &inter);
private:
@@ -206,7 +206,7 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
};
// GetSteerableViewMapDensityF1D
/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
/** Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
* evaluated in the proper steerable ViewMap depending on its orientation.
*/
class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
@@ -215,7 +215,7 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
float _sampling;
public:
/*! Builds the functor from the level of the pyramid from which the pixel must be read.
/** Builds the functor from the level of the pyramid from which the pixel must be read.
* \param level:
* The level of the pyramid from which the pixel must be read.
* \param iType:
@@ -232,23 +232,23 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
_sampling = sampling;
}
/*! Destructor */
/** Destructor */
virtual ~GetSteerableViewMapDensityF1D()
{
}
/*! Returns the string "GetSteerableViewMapDensityF1D" */
/** Returns the string "GetSteerableViewMapDensityF1D" */
string getName() const
{
return "GetSteerableViewMapDensityF1D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface1D &inter);
};
// GetViewMapGradientNormF1D
/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
/** Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
* evaluated in the proper steerable ViewMap depending on its orientation.
*/
class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
@@ -258,7 +258,7 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
Functions0D::GetViewMapGradientNormF0D _func;
public:
/*! Builds the functor from the level of the pyramid from which the pixel must be read.
/** Builds the functor from the level of the pyramid from which the pixel must be read.
* \param level:
* The level of the pyramid from which the pixel must be read.
* \param iType:
@@ -275,13 +275,13 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
_sampling = sampling;
}
/*! Returns the string "GetSteerableViewMapDensityF1D" */
/** Returns the string "GetSteerableViewMapDensityF1D" */
string getName() const
{
return "GetViewMapGradientNormF1D";
}
/*! the () operator. */
/** the () operator. */
int operator()(Interface1D &inter);
};

8
source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
View File

@@ -38,12 +38,12 @@ namespace Freestyle {
namespace Predicates1D {
// DensityLowerThanUP1D
/*! Returns true if the density evaluated for the
/** Returns true if the density evaluated for the
* Interface1D is less than a user-defined density value.
*/
class DensityLowerThanUP1D : public UnaryPredicate1D {
public:
/*! Builds the functor.
/** Builds the functor.
* \param threshold:
* The value of the threshold density.
* Any Interface1D having a density lower than this threshold will match.
@@ -56,13 +56,13 @@ class DensityLowerThanUP1D : public UnaryPredicate1D {
_sigma = sigma;
}
/*! Returns the string "DensityLowerThanUP1D" */
/** Returns the string "DensityLowerThanUP1D" */
string getName() const
{
return "DensityLowerThanUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
Functions1D::DensityF1D fun(_sigma);

26
source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
View File

@@ -25,14 +25,14 @@
namespace Freestyle {
/*! [ Thickness Shader ].
/** [ Thickness Shader ].
* Assigns thicknesses to the stroke vertices so that the stroke looks like made with a
* calligraphic tool. i.e. The stroke will be the thickest in a main direction, the thinnest in the
* direction perpendicular to this one, and an interpolation in between.
*/
class CalligraphicShader : public StrokeShader {
public:
/*! Builds the shader.
/** Builds the shader.
* \param iMinThickness:
* The minimum thickness in the direction perpendicular to the main direction.
* \param iMaxThickness:
@@ -47,12 +47,12 @@ class CalligraphicShader : public StrokeShader {
const Vec2f &iOrientation,
bool clamp);
/*! Destructor. */
/** Destructor. */
virtual ~CalligraphicShader()
{
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &ioStroke) const;
protected:
@@ -62,14 +62,14 @@ class CalligraphicShader : public StrokeShader {
bool _clamp;
};
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Spatial Noise stroke shader.
* Moves the vertices to make the stroke more noisy.
* \see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly
*/
class SpatialNoiseShader : public StrokeShader {
public:
/*! Builds the shader.
/** Builds the shader.
* \param iAmount:
* The amplitude of the noise.
* \param ixScale:
@@ -83,12 +83,12 @@ class SpatialNoiseShader : public StrokeShader {
*/
SpatialNoiseShader(float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom);
/*! Destructor. */
/** Destructor. */
virtual ~SpatialNoiseShader()
{
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &ioStroke) const;
protected:
@@ -99,7 +99,7 @@ class SpatialNoiseShader : public StrokeShader {
bool _pureRandom;
};
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Smooths the stroke.
* (Moves the vertices to make the stroke smoother).
* Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we
@@ -108,7 +108,7 @@ class SpatialNoiseShader : public StrokeShader {
*/
class SmoothingShader : public StrokeShader {
public:
/*! Builds the shader.
/** Builds the shader.
* \param iNbIteration:
* The number of iterations. (400)
* \param iFactorPoint:
@@ -135,12 +135,12 @@ class SmoothingShader : public StrokeShader {
real iAnisoCurvature,
real icarricatureFactor);
/*! Destructor. */
/** Destructor. */
virtual ~SmoothingShader()
{
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &ioStroke) const;
protected:
@@ -213,7 +213,7 @@ class Omitter : public Smoother {
real _lengthFlat;
};
/*! Omission shader */
/** Omission shader */
class OmissionShader : public StrokeShader {
public:
OmissionShader(real sizeWindow, real thrVari, real thrFlat, real lFlat);

102
source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
View File

@@ -47,12 +47,12 @@ namespace StrokeShaders {
//
//////////////////////////////////////////////////////
/*! [ Thickness Shader ].
/** [ Thickness Shader ].
* Assigns an absolute constant thickness to every vertices of the Stroke.
*/
class ConstantThicknessShader : public StrokeShader {
public:
/*! Builds the shader.
/** Builds the shader.
* \param thickness:
* The thickness that must be assigned to the stroke.
*/
@@ -61,18 +61,18 @@ class ConstantThicknessShader : public StrokeShader {
_thickness = thickness;
}
/*! Destructor. */
/** Destructor. */
virtual ~ConstantThicknessShader()
{
}
/*! Returns the string "ConstantThicknessShader".*/
/** Returns the string "ConstantThicknessShader".*/
virtual string getName() const
{
return "ConstantThicknessShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
private:
@@ -106,7 +106,7 @@ class ConstantExternThicknessShader : public StrokeShader {
float _thickness;
};
/*! [ Thickness Shader ].
/** [ Thickness Shader ].
* Assigns thicknesses values such as the thickness increases from a thickness value A to a
* thickness value B between the first vertex to the midpoint vertex and then decreases from B to a
* A between this midpoint vertex and the last vertex. The thickness is linearly interpolated from
@@ -114,7 +114,7 @@ class ConstantExternThicknessShader : public StrokeShader {
*/
class IncreasingThicknessShader : public StrokeShader {
public:
/*! Builds the shader.
/** Builds the shader.
* \param iThicknessMin:
* The first thickness value.
* \param iThicknessMax:
@@ -126,7 +126,7 @@ class IncreasingThicknessShader : public StrokeShader {
_ThicknessMax = iThicknessMax;
}
/*! Destructor.*/
/** Destructor.*/
virtual ~IncreasingThicknessShader()
{
}
@@ -136,7 +136,7 @@ class IncreasingThicknessShader : public StrokeShader {
return "IncreasingThicknessShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
private:
@@ -144,7 +144,7 @@ class IncreasingThicknessShader : public StrokeShader {
float _ThicknessMax;
};
/*! [ Thickness shader ].
/** [ Thickness shader ].
* Same as previous but here we allow the user to control the ratio thickness/length so that we
* don't get fat short lines
*/
@@ -155,7 +155,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader {
float _ratio;
public:
/*! Builds the shader.
/** Builds the shader.
* \param iThicknessMin:
* The first thickness value.
* \param iThicknessMax:
@@ -171,7 +171,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader {
_ratio = iRatio;
}
/*! Destructor.*/
/** Destructor.*/
virtual ~ConstrainedIncreasingThicknessShader()
{
}
@@ -181,7 +181,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader {
return "ConstrainedIncreasingThicknessShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
};
@@ -217,7 +217,7 @@ class LengthDependingThicknessShader : public StrokeShader {
virtual int shade(Stroke &stroke) const;
};
/*! [ Thickness Shader ].
/** [ Thickness Shader ].
* Adds some noise to the stroke thickness.
* \see \htmlonly <a href=noise/noise.html>noise/noise.html</a>\endhtmlonly
*/
@@ -229,7 +229,7 @@ class ThicknessNoiseShader : public StrokeShader {
public:
ThicknessNoiseShader();
/*! Builds a Thickness Noise Shader
/** Builds a Thickness Noise Shader
* \param iAmplitude:
* The amplitude of the noise signal
* \param iPeriod:
@@ -242,7 +242,7 @@ class ThicknessNoiseShader : public StrokeShader {
return "ThicknessNoiseShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
};
@@ -250,12 +250,12 @@ class ThicknessNoiseShader : public StrokeShader {
// Color shaders
//
/////////////////////////////////////////////////////////
/*! [ Color Shader ].
/** [ Color Shader ].
* Assigns a constant color to every vertices of the Stroke.
*/
class ConstantColorShader : public StrokeShader {
public:
/*! Builds the shader from a user-specified color.
/** Builds the shader from a user-specified color.
* \param iR:
* The red component
* \param iG:
@@ -278,14 +278,14 @@ class ConstantColorShader : public StrokeShader {
return "ConstantColorShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
private:
float _color[4];
};
/*! [ Color Shader ].
/** [ Color Shader ].
* Assigns a varying color to the stroke.
* The user specifies 2 colors A and B. The stroke color will change linearly from A to B between
* the first and the last vertex.
@@ -296,7 +296,7 @@ class IncreasingColorShader : public StrokeShader {
float _colorMax[4];
public:
/*! Builds the shader from 2 user-specified colors.
/** Builds the shader from 2 user-specified colors.
* \param iRm:
* The first color red component
* \param iGm:
@@ -340,7 +340,7 @@ class IncreasingColorShader : public StrokeShader {
return "IncreasingColorShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
};
@@ -366,7 +366,7 @@ class MaterialColorShader : public StrokeShader {
virtual int shade(Stroke &stroke) const;
};
/*! [ Color Shader ].
/** [ Color Shader ].
* Shader to add noise to the stroke colors.
*/
class ColorNoiseShader : public StrokeShader {
@@ -377,7 +377,7 @@ class ColorNoiseShader : public StrokeShader {
public:
ColorNoiseShader();
/*! Builds a Color Noise Shader
/** Builds a Color Noise Shader
* \param iAmplitude:
* The amplitude of the noise signal
* \param iPeriod:
@@ -390,7 +390,7 @@ class ColorNoiseShader : public StrokeShader {
return "ColorNoiseShader";
}
/*! The shading method. */
/** The shading method. */
virtual int shade(Stroke &stroke) const;
};
@@ -398,7 +398,7 @@ class ColorNoiseShader : public StrokeShader {
// Geometry Shaders
//
///////////////////////////////////////////////////////////////////////////////
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Stretches the stroke at its two extremities and following the respective directions: v(1)v(0)
* and v(n-1)v(n).
*/
@@ -407,7 +407,7 @@ class BackboneStretcherShader : public StrokeShader {
float _amount;
public:
/*! Builds the shader.
/** Builds the shader.
* \param iAmount:
* The stretching amount value.
*/
@@ -421,11 +421,11 @@ class BackboneStretcherShader : public StrokeShader {
return "BackboneStretcherShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};
/*! [ Geometry Shader. ]
/** [ Geometry Shader. ]
* Resamples the stroke.
* \see Stroke::Resample(float).
*/
@@ -434,7 +434,7 @@ class SamplingShader : public StrokeShader {
float _sampling;
public:
/*! Builds the shader.
/** Builds the shader.
* \param sampling:
* The sampling to use for the stroke resampling
*/
@@ -448,7 +448,7 @@ class SamplingShader : public StrokeShader {
return "SamplingShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};
@@ -471,7 +471,7 @@ class ExternalContourStretcherShader : public StrokeShader {
};
// Bezier curve stroke shader
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation
* of the original backbone geometry. \see \htmlonly <a
* href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
@@ -481,7 +481,7 @@ class BezierCurveShader : public StrokeShader {
float _error;
public:
/*! Builds the shader.
/** Builds the shader.
* \param error:
* The error we're allowing for the approximation.
* This error is the max distance allowed between the new curve and the original geometry.
@@ -496,11 +496,11 @@ class BezierCurveShader : public StrokeShader {
return "BezierCurveShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Shader to modify the Stroke geometry so that it looks more "polygonal".
* The basic idea is to start from the minimal stroke approximation consisting in a line joining
* the first vertex to the last one and to subdivide using the original stroke vertices until a
@@ -511,7 +511,7 @@ class PolygonalizationShader : public StrokeShader {
float _error;
public:
/*! Builds the shader.
/** Builds the shader.
* \param iError:
* The error we want our polygonal approximation to have with respect to the original
* geometry. The smaller, the closer the new stroke to the original one.
@@ -527,11 +527,11 @@ class PolygonalizationShader : public StrokeShader {
return "PolygonalizationShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Shader to modify the Stroke geometry so that it corresponds to its main direction line.
* This shader must be used together with the splitting operator using the curvature criterion.
* Indeed, the precision of the approximation will depend on the size of the stroke's pieces.
@@ -542,7 +542,7 @@ class GuidingLinesShader : public StrokeShader {
float _offset;
public:
/*! Builds a Guiding Lines shader
/** Builds a Guiding Lines shader
* \param iOffset:
* The line that replaces the stroke is initially in the middle of the initial stroke
* "bbox". iOffset is the value of the displacement which is applied to this line along its
@@ -558,27 +558,27 @@ class GuidingLinesShader : public StrokeShader {
return "GuidingLinesShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};
/*! [ Geometry Shader ].
/** [ Geometry Shader ].
* Removes the stroke's extremities.
*/
class TipRemoverShader : public StrokeShader {
public:
/*! Builds the shader.
/** Builds the shader.
* \param tipLength:
* The length of the piece of stroke we want to remove at each extremity.
*/
TipRemoverShader(real tipLength);
/*! Destructor. */
/** Destructor. */
virtual ~TipRemoverShader()
{
}
/*! The shading method */
/** The shading method */
virtual string getName() const
{
return "TipRemoverShader";
@@ -590,7 +590,7 @@ class TipRemoverShader : public StrokeShader {
real _tipLength;
};
/*! [ Texture Shader ].
/** [ Texture Shader ].
* Shader to assign texture to the Stroke material.
*/
@@ -600,7 +600,7 @@ class BlenderTextureShader : public StrokeShader {
bNodeTree *_nodeTree;
public:
/*! Builds the shader.
/** Builds the shader.
* \param mtex:
* The blender texture to use.
*/
@@ -610,7 +610,7 @@ class BlenderTextureShader : public StrokeShader {
_nodeTree = NULL;
}
/*! Builds the shader.
/** Builds the shader.
* \param nodetree:
* A node tree (of new shading nodes) to define textures.
*/
@@ -625,11 +625,11 @@ class BlenderTextureShader : public StrokeShader {
return "BlenderTextureShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};
/*! [ Texture Shader ].
/** [ Texture Shader ].
* Shader to assign texture to the Stroke material.
*/
@@ -638,7 +638,7 @@ class StrokeTextureStepShader : public StrokeShader {
float _step;
public:
/*! Builds the shader.
/** Builds the shader.
* \param id:
* The number of the preset to use.
*/
@@ -652,7 +652,7 @@ class StrokeTextureStepShader : public StrokeShader {
return "StrokeTextureStepShader";
}
/*! The shading method */
/** The shading method */
virtual int shade(Stroke &stroke) const;
};

18
source/blender/freestyle/intern/stroke/Canvas.h
View File

@@ -60,12 +60,12 @@ class ImagePyramid;
class SteerableViewMap;
class StyleModule;
/*! Class to define the canvas on which strokes are drawn.
/** Class to define the canvas on which strokes are drawn.
* It's used to store state information about the drawing.
*/
class Canvas {
public:
/*! Returns a pointer on the Canvas instance */
/** Returns a pointer on the Canvas instance */
static Canvas *getInstance()
{
return _pInstance;
@@ -136,7 +136,7 @@ class Canvas {
}
/* Maps management */
/*! Loads an image map. The map will be scaled
/** Loads an image map. The map will be scaled
* (without preserving the ratio in order to fit the actual canvas size.).
* The image must be a gray values image...
* \param iFileName:
@@ -152,7 +152,7 @@ class Canvas {
unsigned iNbLevels = 4,
float iSigma = 1.0f);
/*! Reads a pixel value in a map.
/** Reads a pixel value in a map.
* Returns a value between 0 and 1.
* \param iMapName:
* The name of the map
@@ -167,19 +167,19 @@ class Canvas {
*/
float readMapPixel(const char *iMapName, int level, int x, int y);
/*! Sets the steerable viewmap */
/** Sets the steerable viewmap */
void loadSteerableViewMap(SteerableViewMap *iSVM)
{
_steerableViewMap = iSVM;
}
/*! Returns the steerable VM */
/** Returns the steerable VM */
SteerableViewMap *getSteerableViewMap()
{
return _steerableViewMap;
}
/*! accessors */
/** accessors */
inline const FEdge *selectedFEdge() const
{
return _SelectedFEdge;
@@ -215,13 +215,13 @@ class Canvas {
return stroke_count;
}
/*! modifiers */
/** modifiers */
inline void setSelectedFEdge(FEdge *iFEdge)
{
_SelectedFEdge = iFEdge;
}
/*! inserts a shader at pos index+1 */
/** inserts a shader at pos index+1 */
void PushBackStyleModule(StyleModule *iStyleModule);
void InsertStyleModule(unsigned index, StyleModule *iStyleModule);
void RemoveStyleModule(unsigned index);

16
source/blender/freestyle/intern/stroke/Chain.h
View File

@@ -27,7 +27,7 @@
namespace Freestyle {
/*! Class to represent a 1D elements issued from the chaining process.
/** Class to represent a 1D elements issued from the chaining process.
* A Chain is the last step before the Stroke and is used in the Splitting and Creation processes.
*/
class Chain : public Curve {
@@ -38,28 +38,28 @@ class Chain : public Curve {
_fedgeB; // the last FEdge of the ViewEdge passed to the last call for push_viewedge_back().
public:
/*! Default constructor. */
/** Default constructor. */
Chain() : Curve()
{
_splittingId = 0;
_fedgeB = 0;
}
/*! Builds a chain from its Id. */
/** Builds a chain from its Id. */
Chain(const Id &id) : Curve(id)
{
_splittingId = 0;
_fedgeB = 0;
}
/*! Copy Constructor */
/** Copy Constructor */
Chain(const Chain &iBrother) : Curve(iBrother)
{
_splittingId = iBrother._splittingId;
_fedgeB = iBrother._fedgeB;
}
/*! Destructor. */
/** Destructor. */
virtual ~Chain()
{
// only the last splitted deletes this id
@@ -70,13 +70,13 @@ class Chain : public Curve {
}
}
/*! Returns the string "Chain" */
/** Returns the string "Chain" */
virtual string getExactTypeName() const
{
return "Chain";
}
/*! Adds a ViewEdge at the end of the chain
/** Adds a ViewEdge at the end of the chain
* \param iViewEdge:
* The ViewEdge that must be added.
* \param orientation:
@@ -84,7 +84,7 @@ class Chain : public Curve {
*/
void push_viewedge_back(ViewEdge *iViewEdge, bool orientation);
/*! Adds a ViewEdge at the beginning of the chain
/** Adds a ViewEdge at the beginning of the chain
* \param iViewEdge:
* The ViewEdge that must be added.
* \param orientation:

50
source/blender/freestyle/intern/stroke/ChainingIterators.h
View File

@@ -98,11 +98,11 @@ class AdjacencyIterator : public Iterator {
return _internalIterator.isBegin();
}
/*! Returns true if the current ViewEdge is coming towards the iteration vertex.
/** Returns true if the current ViewEdge is coming towards the iteration vertex.
* False otherwise. */
bool isIncoming() const;
/*! Returns a *pointer* to the pointed ViewEdge. */
/** Returns a *pointer* to the pointed ViewEdge. */
virtual ViewEdge *operator*();
virtual ViewEdge *operator->()
@@ -140,7 +140,7 @@ class AdjacencyIterator : public Iterator {
//
///////////////////////////////////////////////////////////
/*! Base class for chaining iterators.
/** Base class for chaining iterators.
* This class is designed to be overloaded in order to describe chaining rules.
* It makes the works of chaining rules description easier.
* The two main methods that need to overloaded are traverse() and init().
@@ -159,7 +159,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
ViewEdge *result;
void *py_c_it;
/*! Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation.
/** Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation.
* \param iRestrictToSelection:
* Indicates whether to force the chaining to stay within
* the set of selected ViewEdges or not.
@@ -183,7 +183,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
py_c_it = NULL;
}
/*! Copy constructor */
/** Copy constructor */
ChainingIterator(const ChainingIterator &brother) : ViewEdgeIterator(brother)
{
_restrictToSelection = brother._restrictToSelection;
@@ -192,19 +192,19 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
py_c_it = brother.py_c_it;
}
/*! Returns the string "ChainingIterator" */
/** Returns the string "ChainingIterator" */
virtual string getExactTypeName() const
{
return "ChainingIterator";
}
/*! Inits the iterator context.
/** Inits the iterator context.
* This method is called each time a new chain is started.
* It can be used to reset some history information that you might want to keep.
*/
virtual int init();
/*! This method iterates over the potential next ViewEdges and returns the one that will be
/** This method iterates over the potential next ViewEdges and returns the one that will be
* followed next. returns the next ViewEdge to follow or 0 when the end of the chain is reached.
* \param it:
* The iterator over the ViewEdges adjacent to the end vertex of the current ViewEdge.
@@ -214,11 +214,11 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
virtual int traverse(const AdjacencyIterator &it);
/* accessors */
/*! Returns true if the orientation of the current ViewEdge corresponds to its natural
/** Returns true if the orientation of the current ViewEdge corresponds to its natural
* orientation */
// inline bool getOrientation() const {}
/*! Returns the vertex which is the next crossing */
/** Returns the vertex which is the next crossing */
inline ViewVertex *getVertex()
{
if (_increment) {
@@ -239,7 +239,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
}
}
/*! Returns true if the current iteration is an incrementation */
/** Returns true if the current iteration is an incrementation */
inline bool isIncrementing() const
{
return _increment;
@@ -255,7 +255,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
//
///////////////////////////////////////////////////////////
/*! A ViewEdge Iterator used to follow ViewEdges the most naturally.
/** A ViewEdge Iterator used to follow ViewEdges the most naturally.
* For example, it will follow visible ViewEdges of same nature.
* As soon, as the nature or the visibility changes, the iteration stops (by setting the pointed
* ViewEdge to 0). In the case of an iteration over a set of ViewEdge that are both Silhouette
@@ -263,7 +263,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
*/
class ChainSilhouetteIterator : public ChainingIterator {
public:
/*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its
/** Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its
* orientation.
* \param iRestrictToSelection:
* Indicates whether to force the chaining to stay within the set of selected ViewEdges or
@@ -282,24 +282,24 @@ class ChainSilhouetteIterator : public ChainingIterator {
{
}
/*! Copy constructor */
/** Copy constructor */
ChainSilhouetteIterator(const ChainSilhouetteIterator &brother) : ChainingIterator(brother)
{
}
/*! Returns the string "ChainSilhouetteIterator" */
/** Returns the string "ChainSilhouetteIterator" */
virtual string getExactTypeName() const
{
return "ChainSilhouetteIterator";
}
/*! This method iterates over the potential next ViewEdges and returns the one that will be
/** This method iterates over the potential next ViewEdges and returns the one that will be
* followed next.
* When reaching the end of a chain, 0 is returned.
*/
virtual int traverse(const AdjacencyIterator &it);
/*! Inits the iterator context */
/** Inits the iterator context */
virtual int init()
{
return 0;
@@ -311,7 +311,7 @@ class ChainSilhouetteIterator : public ChainingIterator {
//
///////////////////////////////////////////////////////////
/*! A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a
/** A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a
* unary predicate and a binary predicate.
* First, the unary predicate is evaluated for all potential next ViewEdges in order to only
* keep the ones respecting a certain constraint.
@@ -327,7 +327,7 @@ class ChainPredicateIterator : public ChainingIterator {
UnaryPredicate1D *_unary_predicate; // the caller is responsible for the deletion of this object
public:
/*! Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
/** Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
* \param iRestrictToSelection:
* Indicates whether to force the chaining to stay
* within the set of selected ViewEdges or not.
@@ -350,7 +350,7 @@ class ChainPredicateIterator : public ChainingIterator {
_unary_predicate = 0;
}
/*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting
/** Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting
* ViewEdge and its orientation.
* \param iRestrictToSelection:
* Indicates whether to force the chaining to stay
@@ -381,32 +381,32 @@ class ChainPredicateIterator : public ChainingIterator {
_binary_predicate = &bpred;
}
/*! Copy constructor */
/** Copy constructor */
ChainPredicateIterator(const ChainPredicateIterator &brother) : ChainingIterator(brother)
{
_unary_predicate = brother._unary_predicate;
_binary_predicate = brother._binary_predicate;
}
/*! Destructor. */
/** Destructor. */
virtual ~ChainPredicateIterator()
{
_unary_predicate = 0;
_binary_predicate = 0;
}
/*! Returns the string "ChainPredicateIterator" */
/** Returns the string "ChainPredicateIterator" */
virtual string getExactTypeName() const
{
return "ChainPredicateIterator";
}
/*! This method iterates over the potential next ViewEdges and returns the one that will be
/** This method iterates over the potential next ViewEdges and returns the one that will be
* followed next. When reaching the end of a chain, 0 is returned.
*/
virtual int traverse(const AdjacencyIterator &it);
/*! Inits the iterator context */
/** Inits the iterator context */
virtual int init()
{
return 0;

18
source/blender/freestyle/intern/stroke/ContextFunctions.h
View File

@@ -33,34 +33,34 @@ namespace Freestyle {
// Context Functions definitions
//
///////////////////////////////////////////////////////////
/*! namespace containing all the Context related functions */
/** namespace containing all the Context related functions */
namespace ContextFunctions {
// GetTimeStamp
/*! Returns the system time stamp */
/** Returns the system time stamp */
unsigned GetTimeStampCF();
// GetCanvasWidth
/*! Returns the canvas width */
/** Returns the canvas width */
unsigned GetCanvasWidthCF();
// GetCanvasHeight
/*! Returns the canvas height */
/** Returns the canvas height */
unsigned GetCanvasHeightCF();
// GetBorder
/*! Returns the border */
/** Returns the border */
BBox<Vec2i> GetBorderCF();
// Load map
/*! Loads an image map for further reading */
/** Loads an image map for further reading */
void LoadMapCF(const char *iFileName,
const char *iMapName,
unsigned iNbLevels = 4,
float iSigma = 1.0f);
// ReadMapPixel
/*! Reads a pixel in a user-defined map
/** Reads a pixel in a user-defined map
* \return the floating value stored for that pixel
* \param iMapName:
* The name of the map
@@ -74,7 +74,7 @@ void LoadMapCF(const char *iFileName,
float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
// ReadCompleteViewMapPixel
/*! Reads a pixel in the complete view map
/** Reads a pixel in the complete view map
* \return the floating value stored for that pixel
* \param level:
* The level of the pyramid in which we wish to read the pixel
@@ -86,7 +86,7 @@ float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y);
// ReadOrientedViewMapPixel
/*! Reads a pixel in one of the oriented view map images
/** Reads a pixel in one of the oriented view map images
* \return the floating value stored for that pixel
* \param iOrientation:
* The number telling which orientation we want to check

2
source/blender/freestyle/intern/stroke/Curve.cpp
View File

@@ -573,7 +573,7 @@ Curve::~Curve()
}
}
/*! iterators access */
/** iterators access */
Curve::point_iterator Curve::points_begin(float step)
{
vertex_container::iterator second = _Vertices.begin();

98
source/blender/freestyle/intern/stroke/Curve.h
View File

@@ -52,7 +52,7 @@ using namespace Geometry;
/* */
/**********************************/
/*! Class to represent a point of a curve.
/** Class to represent a point of a curve.
* A CurvePoint can be any point of a 1D curve (it doesn't have to be a vertex of the curve).
* Any Interface1D is built upon ViewEdges, themselves built upon FEdges. Therefore, a curve is
* basically a polyline made of a list SVertex. Thus, a CurvePoint is built by linearly
@@ -61,56 +61,56 @@ using namespace Geometry;
*/
class CurvePoint : public Interface0D {
public: // Implementation of Interface0D
/*! Returns the string "CurvePoint"*/
/** Returns the string "CurvePoint"*/
virtual string getExactTypeName() const
{
return "CurvePoint";
}
// Data access methods
/*! Returns the 3D X coordinate of the point */
/** Returns the 3D X coordinate of the point */
virtual real getX() const
{
return _Point3d.x();
}
/*! Returns the 3D Y coordinate of the point */
/** Returns the 3D Y coordinate of the point */
virtual real getY() const
{
return _Point3d.y();
}
/*! Returns the 3D Z coordinate of the point */
/** Returns the 3D Z coordinate of the point */
virtual real getZ() const
{
return _Point3d.z();
}
/*! Returns the 3D point. */
/** Returns the 3D point. */
virtual Vec3r getPoint3D() const
{
return _Point3d;
}
/*! Returns the projected 3D X coordinate of the point */
/** Returns the projected 3D X coordinate of the point */
virtual real getProjectedX() const
{
return _Point2d.x();
}
/*! Returns the projected 3D Y coordinate of the point */
/** Returns the projected 3D Y coordinate of the point */
virtual real getProjectedY() const
{
return _Point2d.y();
}
/*! Returns the projected 3D Z coordinate of the point */
/** Returns the projected 3D Z coordinate of the point */
virtual real getProjectedZ() const
{
return _Point2d.z();
}
/*! Returns the 2D point. */
/** Returns the 2D point. */
virtual Vec2r getPoint2D() const
{
return Vec2r(_Point2d.x(), _Point2d.y());
@@ -118,7 +118,7 @@ class CurvePoint : public Interface0D {
virtual FEdge *getFEdge(Interface0D &inter);
/*! Returns the CurvePoint's Id */
/** Returns the CurvePoint's Id */
virtual Id getId() const
{
Id id;
@@ -131,7 +131,7 @@ class CurvePoint : public Interface0D {
return id;
}
/*! Returns the CurvePoint's Nature */
/** Returns the CurvePoint's Nature */
virtual Nature::VertexNature getNature() const
{
Nature::VertexNature nature = Nature::POINT;
@@ -144,7 +144,7 @@ class CurvePoint : public Interface0D {
return nature;
}
/*! Cast the Interface0D in SVertex if it can be. */
/** Cast the Interface0D in SVertex if it can be. */
virtual SVertex *castToSVertex()
{
if (_t2d == 0) {
@@ -156,7 +156,7 @@ class CurvePoint : public Interface0D {
return Interface0D::castToSVertex();
}
/*! Cast the Interface0D in ViewVertex if it can be. */
/** Cast the Interface0D in ViewVertex if it can be. */
virtual ViewVertex *castToViewVertex()
{
if (_t2d == 0) {
@@ -168,7 +168,7 @@ class CurvePoint : public Interface0D {
return Interface0D::castToViewVertex();
}
/*! Cast the Interface0D in NonTVertex if it can be. */
/** Cast the Interface0D in NonTVertex if it can be. */
virtual NonTVertex *castToNonTVertex()
{
if (_t2d == 0) {
@@ -180,7 +180,7 @@ class CurvePoint : public Interface0D {
return Interface0D::castToNonTVertex();
}
/*! Cast the Interface0D in TVertex if it can be. */
/** Cast the Interface0D in TVertex if it can be. */
virtual TVertex *castToTVertex()
{
if (_t2d == 0) {
@@ -204,10 +204,10 @@ class CurvePoint : public Interface0D {
Vec3r _Point3d;
public:
/*! Default Constructor. */
/** Default Constructor. */
CurvePoint();
/*! Builds a CurvePoint from two SVertex and an interpolation parameter.
/** Builds a CurvePoint from two SVertex and an interpolation parameter.
* \param iA:
* The first SVertex
* \param iB:
@@ -217,7 +217,7 @@ class CurvePoint : public Interface0D {
*/
CurvePoint(SVertex *iA, SVertex *iB, float t);
/*! Builds a CurvePoint from two CurvePoint and an interpolation parameter.
/** Builds a CurvePoint from two CurvePoint and an interpolation parameter.
* \param iA:
* The first CurvePoint
* \param iB:
@@ -229,35 +229,35 @@ class CurvePoint : public Interface0D {
// CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d);
/*! Copy Constructor. */
/** Copy Constructor. */
CurvePoint(const CurvePoint &iBrother);
/*! Operator = */
/** Operator = */
CurvePoint &operator=(const CurvePoint &iBrother);
/*! Destructor */
/** Destructor */
virtual ~CurvePoint() = default;
/*! Operator == */
/** Operator == */
bool operator==(const CurvePoint &b)
{
return ((__A == b.__A) && (__B == b.__B) && (_t2d == b._t2d));
}
/* accessors */
/*! Returns the first SVertex upon which the CurvePoint is built. */
/** Returns the first SVertex upon which the CurvePoint is built. */
inline SVertex *A()
{
return __A;
}
/*! Returns the second SVertex upon which the CurvePoint is built. */
/** Returns the second SVertex upon which the CurvePoint is built. */
inline SVertex *B()
{
return __B;
}
/*! Returns the interpolation parameter. */
/** Returns the interpolation parameter. */
inline float t2d() const
{
return _t2d;
@@ -271,19 +271,19 @@ class CurvePoint : public Interface0D {
#endif
/* modifiers */
/*! Sets the first SVertex upon which to build the CurvePoint. */
/** Sets the first SVertex upon which to build the CurvePoint. */
inline void setA(SVertex *iA)
{
__A = iA;
}
/*! Sets the second SVertex upon which to build the CurvePoint. */
/** Sets the second SVertex upon which to build the CurvePoint. */
inline void setB(SVertex *iB)
{
__B = iB;
}
/*! Sets the 2D interpolation parameter to use. */
/** Sets the 2D interpolation parameter to use. */
inline void setT2d(float t)
{
_t2d = t;
@@ -339,7 +339,7 @@ class CurvePoint : public Interface0D {
}
Vec3r curvature2d_as_vector() const;
/*! angle in radians */
/** angle in radians */
real curvature2d_as_angle() const;
real curvatureFredo() const;
@@ -368,7 +368,7 @@ class CurvePointIterator;
} // end of namespace CurveInternal
/*! Base class for curves made of CurvePoints.
/** Base class for curves made of CurvePoints.
* SVertex is the type of the initial curve vertices.
* A Chain is a specialization of a Curve.
*/
@@ -396,7 +396,7 @@ class Curve : public Interface1D {
unsigned _nSegments; // number of segments
public:
/*! Default Constructor. */
/** Default Constructor. */
Curve()
{
_Length = 0;
@@ -404,7 +404,7 @@ class Curve : public Interface1D {
_nSegments = 0;
}
/*! Builds a Curve from its id */
/** Builds a Curve from its id */
Curve(const Id &id)
{
_Length = 0;
@@ -412,7 +412,7 @@ class Curve : public Interface1D {
_nSegments = 0;
}
/*! Copy Constructor. */
/** Copy Constructor. */
Curve(const Curve &iBrother)
{
_Length = iBrother._Length;
@@ -421,10 +421,10 @@ class Curve : public Interface1D {
_nSegments = 0;
}
/*! Destructor. */
/** Destructor. */
virtual ~Curve();
/*! Returns the string "Curve" */
/** Returns the string "Curve" */
virtual string getExactTypeName() const
{
return "Curve";
@@ -435,7 +435,7 @@ class Curve : public Interface1D {
void computeCurvatureAndOrientation();
#endif
/*! Adds a single vertex (CurvePoint) at the end of the Curve */
/** Adds a single vertex (CurvePoint) at the end of the Curve */
inline void push_vertex_back(Vertex *iVertex)
{
if (!_Vertices.empty()) {
@@ -447,7 +447,7 @@ class Curve : public Interface1D {
_Vertices.push_back(new_vertex);
}
/*! Adds a single vertex (SVertex) at the end of the Curve */
/** Adds a single vertex (SVertex) at the end of the Curve */
inline void push_vertex_back(SVertex *iVertex)
{
if (!_Vertices.empty()) {
@@ -459,7 +459,7 @@ class Curve : public Interface1D {
_Vertices.push_back(new_vertex);
}
/*! Adds a single vertex (CurvePoint) at the front of the Curve */
/** Adds a single vertex (CurvePoint) at the front of the Curve */
inline void push_vertex_front(Vertex *iVertex)
{
if (!_Vertices.empty()) {
@@ -471,7 +471,7 @@ class Curve : public Interface1D {
_Vertices.push_front(new_vertex);
}
/*! Adds a single vertex (SVertex) at the front of the Curve */
/** Adds a single vertex (SVertex) at the front of the Curve */
inline void push_vertex_front(SVertex *iVertex)
{
if (!_Vertices.empty()) {
@@ -483,25 +483,25 @@ class Curve : public Interface1D {
_Vertices.push_front(new_vertex);
}
/*! Returns true is the Curve doesn't have any Vertex yet. */
/** Returns true is the Curve doesn't have any Vertex yet. */
inline bool empty() const
{
return _Vertices.empty();
}
/*! Returns the 2D length of the Curve. */
/** Returns the 2D length of the Curve. */
inline real getLength2D() const
{
return _Length;
}
/*! Returns the Id of the 1D element. */
/** Returns the Id of the 1D element. */
virtual Id getId() const
{
return _Id;
}
/*! Returns the number of segments in the polyline constituting the Curve. */
/** Returns the number of segments in the polyline constituting the Curve. */
inline unsigned int nSegments() const
{
return _nSegments;
@@ -549,7 +549,7 @@ class Curve : public Interface1D {
float local_depth_variance(int iCombination = 0) const;
real local_average_density(float sigma = 2.3f, int iCombination = 0) const;
Vec3r curvature2d_as_vector(int iCombination = 0) const;
/*! angle in radians */
/** angle in radians */
real curvature2d_as_angle(int iCombination = 0) const;
#endif
@@ -573,23 +573,23 @@ class Curve : public Interface1D {
CurveInternal::CurvePointIterator curveVerticesEnd();
// Iterators access
/*! Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can
/** Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can
* iterate over the \a vertices of the Curve.
*/
virtual Interface0DIterator verticesBegin();
/*! Returns an Interface0DIterator pointing after the last vertex of the Curve and that can
/** Returns an Interface0DIterator pointing after the last vertex of the Curve and that can
* iterate over the \a vertices of the Curve.
*/
virtual Interface0DIterator verticesEnd();
/*! Returns an Interface0DIterator pointing onto the first point of the Curve and that can
/** Returns an Interface0DIterator pointing onto the first point of the Curve and that can
* iterate over the \a points of the Curve at any resolution. At each iteration a virtual
* temporary CurvePoint is created.
*/
virtual Interface0DIterator pointsBegin(float t = 0.0f);
/*! Returns an Interface0DIterator pointing after the last point of the Curve and that can
/** Returns an Interface0DIterator pointing after the last point of the Curve and that can
* iterate over the \a points of the Curve at any resolution. At each iteration a virtual
* temporary CurvePoint is created.
*/

2
source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
View File

@@ -50,7 +50,7 @@ class CurvePoint_nonconst_traits : public Nonconst_traits<CurvePoint *> {
/* */
/**********************************/
/*! iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is
/** iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is
* instantiated and returned when the iterator is dereferenced.
*/
template<class Traits>

2
source/blender/freestyle/intern/stroke/CurveIterators.h
View File

@@ -28,7 +28,7 @@ namespace Freestyle {
namespace CurveInternal {
/*! iterator on a curve. Allows an iterating outside
/** iterator on a curve. Allows an iterating outside
* initial vertices. A CurvePoint is instantiated an returned
* when the iterator is dereferenced.
*/

12
source/blender/freestyle/intern/stroke/Modifiers.h
View File

@@ -35,16 +35,16 @@ namespace Freestyle {
* *
* ----------------------------------------- */
/*! Base class for modifiers.
/** Base class for modifiers.
* Modifiers are used in the Operators in order to "mark" the processed Interface1D.
*/
template<class Edge> struct EdgeModifier : public unary_function<Edge, void> {
/*! Default construction */
/** Default construction */
EdgeModifier() : unary_function<Edge, void>()
{
}
/*! the () operator */
/** the () operator */
virtual void operator()(Edge &iEdge)
{
}
@@ -54,14 +54,14 @@ template<class Edge> struct EdgeModifier : public unary_function<Edge, void> {
#endif
};
/*! Modifier that sets the time stamp of an Interface1D to the time stamp of the system. */
/** Modifier that sets the time stamp of an Interface1D to the time stamp of the system. */
template<class Edge> struct TimestampModifier : public EdgeModifier<Edge> {
/*! Default constructor */
/** Default constructor */
TimestampModifier() : EdgeModifier<Edge>()
{
}
/*! The () operator. */
/** The () operator. */
virtual void operator()(Edge &iEdge)
{
TimeStamp *timestamp = TimeStamp::instance();

24
source/blender/freestyle/intern/stroke/Operators.h
View File

@@ -41,7 +41,7 @@
namespace Freestyle {
/*! Class defining the operators used in a style module.
/** Class defining the operators used in a style module.
* There are 4 classes of operators: Selection, Chaining, Splitting and Creating.
* All these operators are user controlled in the scripting language through Functors, Predicates
* and Shaders that are taken as arguments.
@@ -57,12 +57,12 @@ class Operators {
//
////////////////////////////////////////////////
/*! Selects the ViewEdges of the ViewMap verifying a specified condition.
/** Selects the ViewEdges of the ViewMap verifying a specified condition.
* \param pred: The predicate expressing this condition
*/
static int select(UnaryPredicate1D &pred);
/*! Builds a set of chains from the current set of ViewEdges.
/** Builds a set of chains from the current set of ViewEdges.
* Each ViewEdge of the current list starts a new chain.
* The chaining operator then iterates over the ViewEdges
* of the ViewMap using the user specified iterator.
@@ -80,7 +80,7 @@ class Operators {
UnaryPredicate1D &pred,
UnaryFunction1D_void &modifier);
/*! Builds a set of chains from the current set of ViewEdges.
/** Builds a set of chains from the current set of ViewEdges.
* Each ViewEdge of the current list starts a new chain. The chaining operator then iterates
* over the ViewEdges
* of the ViewMap using the user specified iterator.
@@ -95,7 +95,7 @@ class Operators {
*/
static int chain(ViewEdgeInternal::ViewEdgeIterator &it, UnaryPredicate1D &pred);
/*! Builds a set of chains from the current set of ViewEdges.
/** Builds a set of chains from the current set of ViewEdges.
* Each ViewEdge of the current list potentially starts a new chain. The chaining operator then
* iterates over the ViewEdges of the ViewMap using the user specified iterator.
* This operator iterates both using the increment and decrement operators and is therefore
@@ -111,7 +111,7 @@ class Operators {
*/
static int bidirectionalChain(ChainingIterator &it, UnaryPredicate1D &pred);
/*! The only difference with the above bidirectional chaining algorithm is that we don't need to
/** The only difference with the above bidirectional chaining algorithm is that we don't need to
* pass a stopping criterion. This might be desirable when the stopping criterion is already
* contained in the iterator definition. Builds a set of chains from the current set of
* ViewEdges. Each ViewEdge of the current list potentially starts a new chain. The chaining
@@ -127,7 +127,7 @@ class Operators {
*/
static int bidirectionalChain(ChainingIterator &it);
/*! Splits each chain of the current set of chains in a sequential way.
/** Splits each chain of the current set of chains in a sequential way.
* The points of each chain are processed (with a specified sampling) sequentially.
* Each time a user specified starting condition is verified, a new chain begins and ends as
* soon as a user-defined stopping predicate is verified.
@@ -147,7 +147,7 @@ class Operators {
UnaryPredicate0D &stoppingPred,
float sampling = 0.0f);
/*! Splits each chain of the current set of chains in a sequential way.
/** Splits each chain of the current set of chains in a sequential way.
* The points of each chain are processed (with a specified sampling) sequentially and each time
* a user specified condition is verified, the chain is split into two chains.
* The resulting set of chains is a partition of the initial chain
@@ -160,7 +160,7 @@ class Operators {
*/
static int sequentialSplit(UnaryPredicate0D &pred, float sampling = 0.0f);
/*! Splits the current set of chains in a recursive way.
/** Splits the current set of chains in a recursive way.
* We process the points of each chain (with a specified sampling) to find the point
* minimizing a specified function. The chain is split in two at this point and the two new
* chains are processed in the same way. The recursivity level is controlled through a
@@ -181,7 +181,7 @@ class Operators {
UnaryPredicate1D &pred,
float sampling = 0);
/*! Splits the current set of chains in a recursive way.
/** Splits the current set of chains in a recursive way.
* We process the points of each chain (with a specified sampling) to find the point minimizing
* a specified function. The chain is split in two at this point and the two new chains are
* processed in the same way. The user can specify a 0D predicate to make a first selection on
@@ -210,14 +210,14 @@ class Operators {
UnaryPredicate1D &pred,
float sampling = 0.0f);
/*! Sorts the current set of chains (or viewedges)
/** Sorts the current set of chains (or viewedges)
* according to the comparison predicate given as argument.
* \param pred:
* The binary predicate used for the comparison
*/
static int sort(BinaryPredicate1D &pred);
/*! Creates and shades the strokes from the current set of chains.
/** Creates and shades the strokes from the current set of chains.
* A predicate can be specified to make a selection pass on the chains.
* \param pred:
* The predicate that a chain must verify in order to be transform as a stroke

2
source/blender/freestyle/intern/stroke/PSStrokeRenderer.h
View File

@@ -41,7 +41,7 @@ class PSStrokeRenderer : public StrokeRenderer {
public:
PSStrokeRenderer(const char *iFileName = NULL);
/*! Renders a stroke rep */
/** Renders a stroke rep */
virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;

36
source/blender/freestyle/intern/stroke/Predicates0D.h
View File

@@ -34,7 +34,7 @@ namespace Freestyle {
//
///////////////////////////////////////////////////////////
/*! Base class for Unary Predicates that work on Interface0DIterator.
/** Base class for Unary Predicates that work on Interface0DIterator.
* A UnaryPredicate0D is a functor that evaluates a condition on a Interface0DIterator and returns
* true or false depending on whether this condition is satisfied or not.
* The UnaryPredicate0D is used by calling its () operator.
@@ -45,24 +45,24 @@ class UnaryPredicate0D {
bool result;
void *py_up0D;
/*! Default constructor. */
/** Default constructor. */
UnaryPredicate0D()
{
py_up0D = 0;
}
/*! Destructor. */
/** Destructor. */
virtual ~UnaryPredicate0D()
{
}
/*! Returns the string of the name of the UnaryPredicate0D. */
/** Returns the string of the name of the UnaryPredicate0D. */
virtual string getName() const
{
return "UnaryPredicate0D";
}
/*! The () operator. Must be overload by inherited classes.
/** The () operator. Must be overload by inherited classes.
* \param it:
* The Interface0DIterator pointing onto the Interface0D at which we wish to evaluate the
* predicate. \return true if the condition is satisfied, false otherwise.
@@ -79,7 +79,7 @@ class UnaryPredicate0D {
//
///////////////////////////////////////////////////////////
/*! Base class for Binary Predicates working on Interface0D.
/** Base class for Binary Predicates working on Interface0D.
* A BinaryPredicate0D is typically an ordering relation between two Interface0D.
* It evaluates a relation between 2 Interface0D and returns true or false.
* It is used by calling the () operator.
@@ -89,24 +89,24 @@ class BinaryPredicate0D {
bool result;
void *py_bp0D;
/*! Default constructor. */
/** Default constructor. */
BinaryPredicate0D()
{
py_bp0D = 0;
}
/*! Destructor. */
/** Destructor. */
virtual ~BinaryPredicate0D()
{
}
/*! Returns the string of the name of the binary predicate. */
/** Returns the string of the name of the binary predicate. */
virtual string getName() const
{
return "BinaryPredicate0D";
}
/*! The () operator. Must be overload by inherited classes.
/** The () operator. Must be overload by inherited classes.
* It evaluates a relation between 2 Interface0D.
* \param inter1:
* The first Interface0D.
@@ -129,21 +129,21 @@ class BinaryPredicate0D {
namespace Predicates0D {
// TrueUP0D
/*! Returns true any time */
/** Returns true any time */
class TrueUP0D : public UnaryPredicate0D {
public:
/*! Default constructor. */
/** Default constructor. */
TrueUP0D()
{
}
/*! Returns the string "TrueUP0D"*/
/** Returns the string "TrueUP0D"*/
string getName() const
{
return "TrueUP0D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface0DIterator &)
{
result = true;
@@ -152,21 +152,21 @@ class TrueUP0D : public UnaryPredicate0D {
};
// FalseUP0D
/*! Returns false any time */
/** Returns false any time */
class FalseUP0D : public UnaryPredicate0D {
public:
/*! Default constructor. */
/** Default constructor. */
FalseUP0D()
{
}
/*! Returns the string "FalseUP0D"*/
/** Returns the string "FalseUP0D"*/
string getName() const
{
return "FalseUP0D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface0DIterator &)
{
result = false;

114
source/blender/freestyle/intern/stroke/Predicates1D.h
View File

@@ -41,7 +41,7 @@ namespace Freestyle {
//
///////////////////////////////////////////////////////////
/*! Base class for Unary Predicates that work on Interface1D.
/** Base class for Unary Predicates that work on Interface1D.
* A UnaryPredicate1D is a functor that evaluates a condition on a Interface1D and returns
* true or false depending on whether this condition is satisfied or not.
* The UnaryPredicate1D is used by calling its () operator.
@@ -52,24 +52,24 @@ class UnaryPredicate1D {
bool result;
void *py_up1D;
/*! Default constructor. */
/** Default constructor. */
UnaryPredicate1D()
{
py_up1D = NULL;
}
/*! Destructor. */
/** Destructor. */
virtual ~UnaryPredicate1D()
{
}
/*! Returns the string of the name of the UnaryPredicate1D. */
/** Returns the string of the name of the UnaryPredicate1D. */
virtual string getName() const
{
return "UnaryPredicate1D";
}
/*! The () operator. Must be overload by inherited classes.
/** The () operator. Must be overload by inherited classes.
* \param inter:
* The Interface1D on which we wish to evaluate the predicate.
* \return true if the condition is satisfied, false otherwise.
@@ -86,7 +86,7 @@ class UnaryPredicate1D {
//
///////////////////////////////////////////////////////////
/*! Base class for Binary Predicates working on Interface1D.
/** Base class for Binary Predicates working on Interface1D.
* A BinaryPredicate1D is typically an ordering relation between two Interface1D.
* It evaluates a relation between 2 Interface1D and returns true or false.
* It is used by calling the () operator.
@@ -96,24 +96,24 @@ class BinaryPredicate1D {
bool result;
void *py_bp1D;
/*! Default constructor. */
/** Default constructor. */
BinaryPredicate1D()
{
py_bp1D = NULL;
}
/*! Destructor. */
/** Destructor. */
virtual ~BinaryPredicate1D()
{
}
/*! Returns the string of the name of the binary predicate. */
/** Returns the string of the name of the binary predicate. */
virtual string getName() const
{
return "BinaryPredicate1D";
}
/*! The () operator. Must be overload by inherited classes.
/** The () operator. Must be overload by inherited classes.
* It evaluates a relation between 2 Interface1D.
* \param inter1:
* The first Interface1D.
@@ -136,21 +136,21 @@ class BinaryPredicate1D {
namespace Predicates1D {
// TrueUP1D
/*! Returns true */
/** Returns true */
class TrueUP1D : public UnaryPredicate1D {
public:
/*! Constructor */
/** Constructor */
TrueUP1D()
{
}
/*! Returns the string "TrueUP1D"*/
/** Returns the string "TrueUP1D"*/
string getName() const
{
return "TrueUP1D";
}
/*! the () operator */
/** the () operator */
int operator()(Interface1D &)
{
result = true;
@@ -159,21 +159,21 @@ class TrueUP1D : public UnaryPredicate1D {
};
// FalseUP1D
/*! Returns false */
/** Returns false */
class FalseUP1D : public UnaryPredicate1D {
public:
/*! Constructor */
/** Constructor */
FalseUP1D()
{
}
/*! Returns the string "FalseUP1D"*/
/** Returns the string "FalseUP1D"*/
string getName() const
{
return "FalseUP1D";
}
/*! the () operator */
/** the () operator */
int operator()(Interface1D &)
{
result = false;
@@ -182,12 +182,12 @@ class FalseUP1D : public UnaryPredicate1D {
};
// QuantitativeInvisibilityUP1D
/*! Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the
/** Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the
* QuantitativeInvisibilityF1D functor, equals a certain user-defined value.
*/
class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
public:
/*! Builds the Predicate.
/** Builds the Predicate.
* \param qi:
* The Quantitative Invisibility you want the Interface1D to have
*/
@@ -195,13 +195,13 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
{
}
/*! Returns the string "QuantitativeInvisibilityUP1D" */
/** Returns the string "QuantitativeInvisibilityUP1D" */
string getName() const
{
return "QuantitativeInvisibilityUP1D";
}
/*! the () operator */
/** the () operator */
int operator()(Interface1D &inter)
{
Functions1D::QuantitativeInvisibilityF1D func;
@@ -217,7 +217,7 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
};
// ContourUP1D
/*! Returns true if the Interface1D is a contour.
/** Returns true if the Interface1D is a contour.
* An Interface1D is a contour if it is bordered by a different shape on each of its sides.
*/
class ContourUP1D : public UnaryPredicate1D {
@@ -225,13 +225,13 @@ class ContourUP1D : public UnaryPredicate1D {
Functions1D::CurveNatureF1D _getNature;
public:
/*! Returns the string "ContourUP1D"*/
/** Returns the string "ContourUP1D"*/
string getName() const
{
return "ContourUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
if (_getNature(inter) < 0) {
@@ -252,7 +252,7 @@ class ContourUP1D : public UnaryPredicate1D {
};
// ExternalContourUP1D
/*! Returns true if the Interface1D is an external contour.
/** Returns true if the Interface1D is an external contour.
* An Interface1D is an external contour if it is bordered by no shape on one of its sides.
*/
class ExternalContourUP1D : public UnaryPredicate1D {
@@ -260,13 +260,13 @@ class ExternalContourUP1D : public UnaryPredicate1D {
Functions1D::CurveNatureF1D _getNature;
public:
/*! Returns the string "ExternalContourUP1D" */
/** Returns the string "ExternalContourUP1D" */
string getName() const
{
return "ExternalContourUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
if (_getNature(inter) < 0) {
@@ -289,7 +289,7 @@ class ExternalContourUP1D : public UnaryPredicate1D {
};
// EqualToTimeStampUP1D
/*! Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
/** Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
class EqualToTimeStampUP1D : public UnaryPredicate1D {
protected:
unsigned _timeStamp;
@@ -300,13 +300,13 @@ class EqualToTimeStampUP1D : public UnaryPredicate1D {
_timeStamp = ts;
}
/*! Returns the string "EqualToTimeStampUP1D"*/
/** Returns the string "EqualToTimeStampUP1D"*/
string getName() const
{
return "EqualToTimeStampUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
result = (inter.getTimeStamp() == _timeStamp);
@@ -315,7 +315,7 @@ class EqualToTimeStampUP1D : public UnaryPredicate1D {
};
// EqualToChainingTimeStampUP1D
/*! Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
/** Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */
class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
protected:
unsigned _timeStamp;
@@ -326,13 +326,13 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
_timeStamp = ts;
}
/*! Returns the string "EqualToChainingTimeStampUP1D"*/
/** Returns the string "EqualToChainingTimeStampUP1D"*/
string getName() const
{
return "EqualToChainingTimeStampUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
ViewEdge *edge = dynamic_cast<ViewEdge *>(&inter);
@@ -346,14 +346,14 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
};
// ShapeUP1D
/*! Returns true if the shape to which the Interface1D belongs to has the same Id as the one
/** Returns true if the shape to which the Interface1D belongs to has the same Id as the one
* specified by the user. */
class ShapeUP1D : public UnaryPredicate1D {
private:
Id _id;
public:
/*! Builds the Predicate.
/** Builds the Predicate.
* \param idFirst:
* The first Id component.
* \param idSecond:
@@ -364,13 +364,13 @@ class ShapeUP1D : public UnaryPredicate1D {
_id = Id(idFirst, idSecond);
}
/*! Returns the string "ShapeUP1D"*/
/** Returns the string "ShapeUP1D"*/
string getName() const
{
return "ShapeUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
set<ViewShape *> shapes;
@@ -387,13 +387,13 @@ class ShapeUP1D : public UnaryPredicate1D {
};
// WithinImageBoundaryUP1D
/*! Returns true if the Interface1D is (partly) within the image boundary. */
/** Returns true if the Interface1D is (partly) within the image boundary. */
class WithinImageBoundaryUP1D : public UnaryPredicate1D {
private:
real _xmin, _ymin, _xmax, _ymax;
public:
/*! Builds the Predicate.
/** Builds the Predicate.
* \param xmin:
* The X lower bound of the image boundary.
* \param ymin:
@@ -408,13 +408,13 @@ class WithinImageBoundaryUP1D : public UnaryPredicate1D {
{
}
/*! Returns the string "WithinImageBoundaryUP1D" */
/** Returns the string "WithinImageBoundaryUP1D" */
string getName() const
{
return "WithinImageBoundaryUP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &inter)
{
// 1st pass: check if a point is within the image boundary.
@@ -454,16 +454,16 @@ class WithinImageBoundaryUP1D : public UnaryPredicate1D {
///////////////////////////////////////////////////////////
// TrueBP1D
/*! Returns true. */
/** Returns true. */
class TrueBP1D : public BinaryPredicate1D {
public:
/*! Returns the string "TrueBP1D" */
/** Returns the string "TrueBP1D" */
string getName() const
{
return "TrueBP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/)
{
result = true;
@@ -472,16 +472,16 @@ class TrueBP1D : public BinaryPredicate1D {
};
// FalseBP1D
/*! Returns false. */
/** Returns false. */
class FalseBP1D : public BinaryPredicate1D {
public:
/*! Returns the string "FalseBP1D" */
/** Returns the string "FalseBP1D" */
string getName() const
{
return "FalseBP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/)
{
result = false;
@@ -490,17 +490,17 @@ class FalseBP1D : public BinaryPredicate1D {
};
// Length2DBP1D
/*! Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the
/** Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the
* Interface1D i2. */
class Length2DBP1D : public BinaryPredicate1D {
public:
/*! Returns the string "Length2DBP1D" */
/** Returns the string "Length2DBP1D" */
string getName() const
{
return "Length2DBP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &i1, Interface1D &i2)
{
result = (i1.getLength2D() > i2.getLength2D());
@@ -509,16 +509,16 @@ class Length2DBP1D : public BinaryPredicate1D {
};
// SameShapeIdBP1D
/*! Returns true if the Interface1D i1 and i2 belong to the same shape. */
/** Returns true if the Interface1D i1 and i2 belong to the same shape. */
class SameShapeIdBP1D : public BinaryPredicate1D {
public:
/*! Returns the string "SameShapeIdBP1D" */
/** Returns the string "SameShapeIdBP1D" */
string getName() const
{
return "SameShapeIdBP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &i1, Interface1D &i2)
{
set<ViewShape *> shapes1;
@@ -542,7 +542,7 @@ class SameShapeIdBP1D : public BinaryPredicate1D {
};
// ViewMapGradientNormBP1D
/*! Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than
/** Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than
* for i2. */
class ViewMapGradientNormBP1D : public BinaryPredicate1D {
private:
@@ -554,13 +554,13 @@ class ViewMapGradientNormBP1D : public BinaryPredicate1D {
{
}
/*! Returns the string "ViewMapGradientNormBP1D" */
/** Returns the string "ViewMapGradientNormBP1D" */
string getName() const
{
return "ViewMapGradientNormBP1D";
}
/*! The () operator. */
/** The () operator. */
int operator()(Interface1D &i1, Interface1D &i2)
{
if (_func(i1) < 0) {

202
source/blender/freestyle/intern/stroke/Stroke.h
View File

@@ -52,18 +52,18 @@ namespace Freestyle {
//
////////////////////////////////////////////////////////
/*! Class to define an attribute associated to a Stroke Vertex.
/** Class to define an attribute associated to a Stroke Vertex.
* This attribute stores the color, alpha and thickness values for a Stroke Vertex.
*/
class StrokeAttribute {
public:
/*! default constructor */
/** default constructor */
StrokeAttribute();
/*! Copy constructor */
/** Copy constructor */
StrokeAttribute(const StrokeAttribute &iBrother);
/*! Builds a stroke vertex attribute from a set of parameters.
/** Builds a stroke vertex attribute from a set of parameters.
* \param iRColor:
* The Red Component value.
* \param iGColor:
@@ -84,7 +84,7 @@ class StrokeAttribute {
float iRThickness,
float iLThickness);
/*! Interpolation constructor.
/** Interpolation constructor.
* Builds a StrokeAttribute from two StrokeAttributes and an interpolation parameter.
* \param a1:
* The first Attribute.
@@ -95,15 +95,15 @@ class StrokeAttribute {
*/
StrokeAttribute(const StrokeAttribute &a1, const StrokeAttribute &a2, float t);
/*! destructor */
/** destructor */
virtual ~StrokeAttribute();
/* operators */
/*! operator = */
/** operator = */
StrokeAttribute &operator=(const StrokeAttribute &iBrother);
/* accessors */
/*! Returns the attribute's color.
/** Returns the attribute's color.
* \return The array of 3 floats containing the R,G,B values of the attribute's color.
*/
inline const float *getColor() const
@@ -111,37 +111,37 @@ class StrokeAttribute {
return _color;
}
/*! Returns the R color component. */
/** Returns the R color component. */
inline const float getColorR() const
{
return _color[0];
}
/*! Returns the G color component. */
/** Returns the G color component. */
inline const float getColorG() const
{
return _color[1];
}
/*! Returns the B color component. */
/** Returns the B color component. */
inline const float getColorB() const
{
return _color[2];
}
/*! Returns the RGB color components. */
/** Returns the RGB color components. */
inline Vec3f getColorRGB() const
{
return Vec3f(_color[0], _color[1], _color[2]);
}
/*! Returns the alpha color component. */
/** Returns the alpha color component. */
inline float getAlpha() const
{
return _alpha;
}
/*! Returns the attribute's thickness.
/** Returns the attribute's thickness.
* \return an array of 2 floats. the first value is the thickness on the right of the vertex
* when following the stroke, the second one is the thickness on the left.
*/
@@ -150,60 +150,60 @@ class StrokeAttribute {
return _thickness;
}
/*! Returns the thickness on the right of the vertex when following the stroke. */
/** Returns the thickness on the right of the vertex when following the stroke. */
inline const float getThicknessR() const
{
return _thickness[0];
}
/*! Returns the thickness on the left of the vertex when following the stroke. */
/** Returns the thickness on the left of the vertex when following the stroke. */
inline const float getThicknessL() const
{
return _thickness[1];
}
/*! Returns the thickness on the right and on the left of the vertex when following the stroke.
/** Returns the thickness on the right and on the left of the vertex when following the stroke.
*/
inline Vec2f getThicknessRL() const
{
return Vec2f(_thickness[0], _thickness[1]);
}
/*! Returns true if the strokevertex is visible, false otherwise */
/** Returns true if the strokevertex is visible, false otherwise */
inline bool isVisible() const
{
return _visible;
}
/*! Returns an attribute of type real
/** Returns an attribute of type real
* \param iName:
* The name of the attribute
*/
float getAttributeReal(const char *iName) const;
/*! Returns an attribute of type Vec2f
/** Returns an attribute of type Vec2f
* \param iName:
* The name of the attribute
*/
Vec2f getAttributeVec2f(const char *iName) const;
/*! Returns an attribute of type Vec3f
/** Returns an attribute of type Vec3f
* \param iName:
* The name of the attribute
*/
Vec3f getAttributeVec3f(const char *iName) const;
/*! Checks whether the attribute iName is available */
/** Checks whether the attribute iName is available */
bool isAttributeAvailableReal(const char *iName) const;
/*! Checks whether the attribute iName is available */
/** Checks whether the attribute iName is available */
bool isAttributeAvailableVec2f(const char *iName) const;
/*! Checks whether the attribute iName is available */
/** Checks whether the attribute iName is available */
bool isAttributeAvailableVec3f(const char *iName) const;
/* modifiers */
/*! sets the attribute's color.
/** sets the attribute's color.
* \param r:
* The new R value.
* \param g:
@@ -218,7 +218,7 @@ class StrokeAttribute {
_color[2] = b;
}
/*! sets the attribute's color.
/** sets the attribute's color.
* \param iRGB:
* The new RGB values.
*/
@@ -229,7 +229,7 @@ class StrokeAttribute {
_color[2] = iRGB[2];
}
/*! sets the attribute's alpha value.
/** sets the attribute's alpha value.
* \param alpha:
* The new alpha value.
*/
@@ -238,7 +238,7 @@ class StrokeAttribute {
_alpha = alpha;
}
/*! sets the attribute's thickness.
/** sets the attribute's thickness.
* \param tr:
* The thickness on the right of the vertex when following the stroke.
* \param tl:
@@ -250,7 +250,7 @@ class StrokeAttribute {
_thickness[1] = tl;
}
/*! sets the attribute's thickness.
/** sets the attribute's thickness.
* \param tRL:
* The thickness on the right and on the left of the vertex when following the stroke.
*/
@@ -260,13 +260,13 @@ class StrokeAttribute {
_thickness[1] = tRL[1];
}
/*! sets the visible flag. True means visible. */
/** sets the visible flag. True means visible. */
inline void setVisible(bool iVisible)
{
_visible = iVisible;
}
/*! Adds a user defined attribute of type real
/** Adds a user defined attribute of type real
* If there is no attribute of name iName, it is added.
* Otherwise, the new value replaces the old one.
* \param iName:
@@ -276,7 +276,7 @@ class StrokeAttribute {
*/
void setAttributeReal(const char *iName, float att);
/*! Adds a user defined attribute of type Vec2f
/** Adds a user defined attribute of type Vec2f
* If there is no attribute of name iName, it is added.
* Otherwise, the new value replaces the old one.
* \param iName:
@@ -286,7 +286,7 @@ class StrokeAttribute {
*/
void setAttributeVec2f(const char *iName, const Vec2f &att);
/*! Adds a user defined attribute of type Vec3f
/** Adds a user defined attribute of type Vec3f
* If there is no attribute of name iName, it is added.
* Otherwise, the new value replaces the old one.
* \param iName:
@@ -322,10 +322,10 @@ class StrokeAttribute {
//
////////////////////////////////////////////////////////
/*! Class to define a stroke vertex. */
/** Class to define a stroke vertex. */
class StrokeVertex : public CurvePoint {
public: // Implementation of Interface0D
/*! Returns the string "StrokeVertex" */
/** Returns the string "StrokeVertex" */
virtual string getExactTypeName() const
{
return "StrokeVertex";
@@ -337,129 +337,129 @@ class StrokeVertex : public CurvePoint {
float _StrokeLength; // stroke length
public:
/*! default constructor */
/** default constructor */
StrokeVertex();
/*! Copy constructor */
/** Copy constructor */
StrokeVertex(const StrokeVertex &iBrother);
/*! Builds a stroke vertex from a SVertex */
/** Builds a stroke vertex from a SVertex */
StrokeVertex(SVertex *iSVertex);
/*! Builds a stroke vertex from a CurvePoint */
/** Builds a stroke vertex from a CurvePoint */
StrokeVertex(CurvePoint *iPoint);
/*! Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/
/** Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/
StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3);
/*! Builds a stroke from a view vertex and an attribute */
/** Builds a stroke from a view vertex and an attribute */
StrokeVertex(SVertex *iSVertex, const StrokeAttribute &iAttribute);
/* operators */
/*! operator = */
/** operator = */
StrokeVertex &operator=(const StrokeVertex &iBrother);
/* accessors */
/*! Returns the 2D point x coordinate */
/** Returns the 2D point x coordinate */
inline real x() const
{
return _Point2d[0];
}
/*! Returns the 2D point y coordinate */
/** Returns the 2D point y coordinate */
inline real y() const
{
return _Point2d[1];
}
/*! Returns the 2D point coordinates as a Vec2r */
/** Returns the 2D point coordinates as a Vec2r */
inline Vec2r getPoint() const
{
return getPoint2D();
}
/*! Returns the ith 2D point coordinate (i=0 or 1)*/
/** Returns the ith 2D point coordinate (i=0 or 1)*/
inline real operator[](const int i) const
{
return _Point2d[i];
}
/*! Returns the StrokeAttribute for this StrokeVertex */
/** Returns the StrokeAttribute for this StrokeVertex */
inline const StrokeAttribute &attribute() const
{
return _Attribute;
}
/*! Returns a non-const reference to the StrokeAttribute of this StrokeVertex */
/** Returns a non-const reference to the StrokeAttribute of this StrokeVertex */
inline StrokeAttribute &attribute()
{
return _Attribute;
}
/*! Returns the curvilinear abscissa */
/** Returns the curvilinear abscissa */
inline float curvilinearAbscissa() const
{
return _CurvilignAbscissa;
}
/*! Returns the length of the Stroke to which this StrokeVertex belongs */
/** Returns the length of the Stroke to which this StrokeVertex belongs */
inline float strokeLength() const
{
return _StrokeLength;
}
/*! Returns the curvilinear abscissa of this StrokeVertex in the Stroke */
/** Returns the curvilinear abscissa of this StrokeVertex in the Stroke */
inline float u() const
{
return _CurvilignAbscissa / _StrokeLength;
}
/* modifiers */
/*! sets the 2D x value */
/** sets the 2D x value */
inline void setX(real x)
{
_Point2d[0] = x;
}
/*! sets the 2D y value */
/** sets the 2D y value */
inline void setY(real y)
{
_Point2d[1] = y;
}
/*! sets the 2D x and y values */
/** sets the 2D x and y values */
inline void setPoint(real x, real y)
{
_Point2d[0] = x;
_Point2d[1] = y;
}
/*! sets the 2D x and y values */
/** sets the 2D x and y values */
inline void setPoint(const Vec2r &p)
{
_Point2d[0] = p[0];
_Point2d[1] = p[1];
}
/*! Returns a reference to the ith 2D point coordinate (i=0 or 1) */
/** Returns a reference to the ith 2D point coordinate (i=0 or 1) */
inline real &operator[](const int i)
{
return _Point2d[i];
}
/*! sets the attribute. */
/** sets the attribute. */
inline void setAttribute(const StrokeAttribute &iAttribute)
{
_Attribute = iAttribute;
}
/*! sets the curvilinear abscissa of this StrokeVertex in the Stroke */
/** sets the curvilinear abscissa of this StrokeVertex in the Stroke */
inline void setCurvilinearAbscissa(float iAbscissa)
{
_CurvilignAbscissa = iAbscissa;
}
/*! sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the
/** sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the
* real Stroke's length.)
*/
inline void setStrokeLength(float iLength)
@@ -492,7 +492,7 @@ class StrokeVertexIterator;
} // end of namespace StrokeInternal
/*! Class to define a stroke.
/** Class to define a stroke.
* A stroke is made of a set of 2D vertices (StrokeVertex), regularly spaced out.
* This set of vertices defines the stroke's backbone geometry.
* Each of these stroke vertices defines the stroke's shape and appearance at this vertex
@@ -500,7 +500,7 @@ class StrokeVertexIterator;
*/
class Stroke : public Interface1D {
public: // Implementation of Interface1D
/*! Returns the string "Stroke" */
/** Returns the string "Stroke" */
virtual string getExactTypeName() const
{
return "Stroke";
@@ -508,17 +508,17 @@ class Stroke : public Interface1D {
// Data access methods
/*! Returns the Id of the Stroke */
/** Returns the Id of the Stroke */
virtual Id getId() const
{
return _id;
}
/*! The different blending modes available to similate the interaction media-medium. */
/** The different blending modes available to similate the interaction media-medium. */
typedef enum {
DRY_MEDIUM, /*!< To simulate a dry medium such as Pencil or Charcoal.*/
HUMID_MEDIUM, /*!< To simulate ink painting (color subtraction blending).*/
OPAQUE_MEDIUM, /*!< To simulate an opaque medium (oil, spray...).*/
DRY_MEDIUM, /**< To simulate a dry medium such as Pencil or Charcoal.*/
HUMID_MEDIUM, /**< To simulate ink painting (color subtraction blending).*/
OPAQUE_MEDIUM, /**< To simulate an opaque medium (oil, spray...).*/
} MediumType;
public:
@@ -549,13 +549,13 @@ class Stroke : public Interface1D {
Vec2r _extremityOrientations[2]; // the orientations of the first and last extermity
public:
/*! default constructor */
/** default constructor */
Stroke();
/*! copy constructor */
/** copy constructor */
Stroke(const Stroke &iBrother);
/*! Builds a stroke from a set of StrokeVertex.
/** Builds a stroke from a set of StrokeVertex.
* This constructor is templated by an iterator type.
* This iterator type must allow the vertices parsing using the ++ operator.
* \param iBegin:
@@ -565,14 +565,14 @@ class Stroke : public Interface1D {
*/
template<class InputVertexIterator> Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd);
/*! Destructor */
/** Destructor */
virtual ~Stroke();
/* operators */
/*! operator = */
/** operator = */
Stroke &operator=(const Stroke &iBrother);
/*! Compute the sampling needed to get iNVertices vertices.
/** Compute the sampling needed to get iNVertices vertices.
* If the specified number of vertices is less than the actual number of vertices, the actual
* sampling value is returned. (To remove Vertices, use the RemoveVertex() method of this class).
* \param iNVertices:
@@ -583,7 +583,7 @@ class Stroke : public Interface1D {
*/
float ComputeSampling(int iNVertices);
/*! Resampling method.
/** Resampling method.
* Resamples the curve so that it eventually has iNPoints. That means it is going to add
* iNPoints-vertices_size, if vertices_size is the number of points we already have. If
* vertices_size >= iNPoints, no resampling is done.
@@ -592,7 +592,7 @@ class Stroke : public Interface1D {
*/
int Resample(int iNPoints);
/*! Resampling method.
/** Resampling method.
* Resamples the curve with a given sampling.
* If this sampling is < to the actual sampling value, no resampling is done.
* \param iSampling:
@@ -600,18 +600,18 @@ class Stroke : public Interface1D {
*/
int Resample(float iSampling);
/*! Removes all vertices from the Stroke.
/** Removes all vertices from the Stroke.
*/
void RemoveAllVertices();
/*! Removes the stroke vertex iVertex
/** Removes the stroke vertex iVertex
* from the stroke.
* The length and curvilinear abscissa are updated
* consequently.
*/
void RemoveVertex(StrokeVertex *iVertex);
/*! Inserts the stroke vertex iVertex in the stroke before next.
/** Inserts the stroke vertex iVertex in the stroke before next.
* The length, curvilinear abscissa are updated consequently.
* \param iVertex:
* The StrokeVertex to insert in the Stroke.
@@ -620,7 +620,7 @@ class Stroke : public Interface1D {
*/
void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);
/*! Updates the 2D length of the Stroke */
/** Updates the 2D length of the Stroke */
void UpdateLength();
/* Render method */
@@ -631,50 +631,50 @@ class Stroke : public Interface1D {
/* Iterator definition */
/* accessors */
/*! Returns the 2D length of the Stroke */
/** Returns the 2D length of the Stroke */
inline real getLength2D() const
{
return _Length;
}
/*! Returns a reference to the time stamp value of the stroke. */
/*! Returns the MediumType used for this Stroke. */
/** Returns a reference to the time stamp value of the stroke. */
/** Returns the MediumType used for this Stroke. */
inline MediumType getMediumType() const
{
return _mediumType;
}
/*! Returns the id of the texture used to simulate th marks system for this Stroke */
/** Returns the id of the texture used to simulate th marks system for this Stroke */
inline unsigned int getTextureId()
{
return _textureId;
}
/*! Returns the spacing of texture coordinates along the stroke length */
/** Returns the spacing of texture coordinates along the stroke length */
inline float getTextureStep()
{
return _textureStep;
}
/*! Returns the texture used at given index to simulate the marks system for this Stroke */
/** Returns the texture used at given index to simulate the marks system for this Stroke */
inline MTex *getMTex(int idx)
{
return _mtex[idx];
}
/*! Return the shader node tree to define textures. */
/** Return the shader node tree to define textures. */
inline bNodeTree *getNodeTree()
{
return _nodeTree;
}
/*! Returns true if this Stroke has textures assigned, false otherwise. */
/** Returns true if this Stroke has textures assigned, false otherwise. */
inline bool hasTex() const
{
return (_mtex[0] != NULL) || _nodeTree;
}
/*! Returns true if this Stroke uses a texture with tips, false otherwise. */
/** Returns true if this Stroke uses a texture with tips, false otherwise. */
inline bool hasTips() const
{
return _tips;
@@ -742,34 +742,34 @@ class Stroke : public Interface1D {
}
/* modifiers */
/*! sets the Id of the Stroke. */
/** sets the Id of the Stroke. */
inline void setId(const Id &id)
{
_id = id;
}
/*! sets the 2D length of the Stroke. */
/** sets the 2D length of the Stroke. */
void setLength(float iLength);
/*! sets the medium type that must be used for this Stroke. */
/** sets the medium type that must be used for this Stroke. */
inline void setMediumType(MediumType iType)
{
_mediumType = iType;
}
/*! sets the texture id to be used to simulate the marks system for this Stroke. */
/** sets the texture id to be used to simulate the marks system for this Stroke. */
inline void setTextureId(unsigned int id)
{
_textureId = id;
}
/*! sets the spacing of texture coordinates along the stroke length. */
/** sets the spacing of texture coordinates along the stroke length. */
inline void setTextureStep(float step)
{
_textureStep = step;
}
/*! assigns a blender texture to the first available slot. */
/** assigns a blender texture to the first available slot. */
inline int setMTex(MTex *mtex)
{
for (int a = 0; a < MAX_MTEX; a++) {
@@ -781,13 +781,13 @@ class Stroke : public Interface1D {
return -1; /* no free slots */
}
/*! assigns a node tree (of new shading nodes) to define textures. */
/** assigns a node tree (of new shading nodes) to define textures. */
inline void setNodeTree(bNodeTree *iNodeTree)
{
_nodeTree = iNodeTree;
}
/*! sets the flag telling whether this stroke is using a texture with tips or not. */
/** sets the flag telling whether this stroke is using a texture with tips or not. */
inline void setTips(bool iTips)
{
_tips = iTips;
@@ -836,7 +836,7 @@ class Stroke : public Interface1D {
const_vertex_iterator vertices_end() const;
vertex_iterator vertices_end();
/*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can
/** Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can
* specify a sampling value to re-sample the Stroke on the fly if needed.
*
* \param t: The resampling value with which we want our Stroke to be resampled.
@@ -844,26 +844,26 @@ class Stroke : public Interface1D {
*/
StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t = 0.0f);
/*! Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */
/** Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */
StrokeInternal::StrokeVertexIterator strokeVerticesEnd();
/*! Returns the number of StrokeVertex constituting the Stroke. */
/** Returns the number of StrokeVertex constituting the Stroke. */
inline unsigned int strokeVerticesSize() const
{
return _Vertices.size();
}
/*! Returns the i-th StrokeVertex constituting the Stroke. */
/** Returns the i-th StrokeVertex constituting the Stroke. */
inline StrokeVertex &strokeVerticeAt(unsigned int i)
{
return *(_Vertices.at(i));
}
// Iterator access (Interface1D)
/*! Returns an Interface0DIterator pointing on the first StrokeVertex of the Stroke. */
/** Returns an Interface0DIterator pointing on the first StrokeVertex of the Stroke. */
virtual Interface0DIterator verticesBegin();
/*! Returns an Interface0DIterator pointing after the last StrokeVertex of the Stroke. */
/** Returns an Interface0DIterator pointing after the last StrokeVertex of the Stroke. */
virtual Interface0DIterator verticesEnd();
virtual Interface0DIterator pointsBegin(float t = 0.0f);

2
source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
View File

@@ -158,7 +158,7 @@ class vertex_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTa
return &(operator*());
}
/*! accessors */
/** accessors */
inline vertex_container_iterator it() const
{
return _it;

42
source/blender/freestyle/intern/stroke/StrokeIterators.h
View File

@@ -32,7 +32,7 @@ namespace StrokeInternal {
//
/////////////////////////////////////////////////
/*! Class defining an iterator designed to iterate over the StrokeVertex of a Stroke.
/** Class defining an iterator designed to iterate over the StrokeVertex of a Stroke.
* An instance of a StrokeVertexIterator can only be obtained from a Stroke by calling
* strokeVerticesBegin() or strokeVerticesEnd(). It is iterating over the same vertices as an
* Interface0DIterator. The difference resides in the object access. Indeed, an Interface0DIterator
@@ -46,12 +46,12 @@ namespace StrokeInternal {
*/
class StrokeVertexIterator : public Interface0DIteratorNested {
public:
/*! Default constructor. */
/** Default constructor. */
StrokeVertexIterator()
{
}
/*! Copy constructor. */
/** Copy constructor. */
StrokeVertexIterator(const StrokeVertexIterator &vi)
{
_it = vi._it;
@@ -72,7 +72,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
{
}
/*! Casts this StrokeVertexIterator into an Interface0DIterator.
/** Casts this StrokeVertexIterator into an Interface0DIterator.
* Useful for any call to a function of the type UnaryFunction0D.
*/
inline Interface0DIterator castToInterface0DIterator() const
@@ -81,7 +81,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return ret;
}
/*! operator=
/** operator=
* \attention In the scripting language, you must call \code it2 = StrokeVertexIterator(it1)
* \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2
* StrokeVertexIterator. Otherwise, incrementing \a it1 will also increment \a it2.
@@ -94,13 +94,13 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return *this;
}
/*! Returns the string "StrokeVertexIterator". */
/** Returns the string "StrokeVertexIterator". */
virtual string getExactTypeName() const
{
return "StrokeVertexIterator";
}
/*! Returns a reference to the pointed StrokeVertex.
/** Returns a reference to the pointed StrokeVertex.
* In the scripting language, you must call "getObject()"instead.
*/
virtual StrokeVertex &operator*()
@@ -108,7 +108,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return **_it;
}
/*! Returns a pointer to the pointed StrokeVertex.
/** Returns a pointer to the pointed StrokeVertex.
* Can't be called in the scripting language.
*/
virtual StrokeVertex *operator->()
@@ -116,14 +116,14 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return &(operator*());
}
/*! Increments. In the scripting language, call "increment()". */
/** Increments. In the scripting language, call "increment()". */
virtual StrokeVertexIterator &operator++()
{
increment();
return *this;
}
/*! Increments. In the scripting language, call "increment()". */
/** Increments. In the scripting language, call "increment()". */
virtual StrokeVertexIterator operator++(int)
{
StrokeVertexIterator ret(*this);
@@ -131,14 +131,14 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return ret;
}
/*! Decrements. In the scripting language, call "decrement()". */
/** Decrements. In the scripting language, call "decrement()". */
virtual StrokeVertexIterator &operator--()
{
decrement();
return *this;
}
/*! Decrements. In the scripting language, call "decrement()". */
/** Decrements. In the scripting language, call "decrement()". */
virtual StrokeVertexIterator operator--(int)
{
StrokeVertexIterator ret(*this);
@@ -146,27 +146,27 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return ret;
}
/*! Increments. */
/** Increments. */
virtual int increment()
{
++_it;
return 0;
}
/*! Decrements. */
/** Decrements. */
virtual int decrement()
{
--_it;
return 0;
}
/*! Returns true if the pointed StrokeVertex is the first of the Stroke. */
/** Returns true if the pointed StrokeVertex is the first of the Stroke. */
bool isBegin() const
{
return _it == _begin;
}
/*! Returns true if the pointed StrokeVertex is the final valid StrokeVertex of the Stroke. */
/** Returns true if the pointed StrokeVertex is the final valid StrokeVertex of the Stroke. */
bool atLast()
{
if (_it == _end) {
@@ -179,13 +179,13 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return result;
}
/*! Returns true if the pointed StrokeVertex is after the last StrokeVertex of the Stroke. */
/** Returns true if the pointed StrokeVertex is after the last StrokeVertex of the Stroke. */
bool isEnd() const
{
return _it == _end;
}
/*! operator == */
/** operator == */
virtual bool operator==(const Interface0DIteratorNested &it) const
{
const StrokeVertexIterator *it_exact = dynamic_cast<const StrokeVertexIterator *>(&it);
@@ -195,19 +195,19 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
return (_it == it_exact->_it);
}
/*! Returns the curvilinear abscissa of the current point */
/** Returns the curvilinear abscissa of the current point */
virtual float t() const
{
return (*_it)->curvilinearAbscissa();
}
/*! Returns the point's parameter in the stroke */
/** Returns the point's parameter in the stroke */
virtual float u() const
{
return (*_it)->u();
}
/*! Cloning method */
/** Cloning method */
virtual StrokeVertexIterator *copy() const
{
return new StrokeVertexIterator(*this);

8
source/blender/freestyle/intern/stroke/StrokeLayer.h
View File

@@ -55,15 +55,15 @@ class StrokeLayer {
virtual ~StrokeLayer();
/*! Render method */
/** Render method */
void ScaleThickness(float iFactor);
void Render(const StrokeRenderer *iRenderer);
void RenderBasic(const StrokeRenderer *iRenderer);
/*! clears the layer */
/** clears the layer */
void clear();
/*! accessors */
/** accessors */
inline stroke_container::iterator strokes_begin()
{
return _strokes.begin();
@@ -84,7 +84,7 @@ class StrokeLayer {
return _strokes.empty();
}
/*! modifiers */
/** modifiers */
inline void setStrokes(stroke_container &iStrokes)
{
_strokes = iStrokes;

6
source/blender/freestyle/intern/stroke/StrokeRenderer.h
View File

@@ -46,7 +46,7 @@ namespace Freestyle {
/* */
/**********************************/
/*! Class to load textures */
/** Class to load textures */
class TextureManager {
public:
TextureManager();
@@ -117,13 +117,13 @@ class TextureManager {
/* */
/**********************************/
/*! Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the
/** Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the
* first rendering */
class StrokeRenderer {
public:
virtual ~StrokeRenderer();
/*! Renders a stroke rep */
/** Renders a stroke rep */
virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const = 0;
virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const = 0;

8
source/blender/freestyle/intern/stroke/StrokeRep.h
View File

@@ -197,13 +197,13 @@ class StrokeRep {
StrokeRep(Stroke *iStroke);
virtual ~StrokeRep();
/*! Creates the strips */
/** Creates the strips */
virtual void create();
/*! Renders the stroke using a Renderer */
/** Renders the stroke using a Renderer */
virtual void Render(const StrokeRenderer *iRenderer);
/*! accessors */
/** accessors */
inline Stroke::MediumType getMediumType() const
{
return _strokeType;
@@ -249,7 +249,7 @@ class StrokeRep {
return _stroke;
}
/*! modifiers */
/** modifiers */
inline void setMediumType(Stroke::MediumType itype)
{
_strokeType = itype;

10
source/blender/freestyle/intern/stroke/StrokeShader.h
View File

@@ -39,7 +39,7 @@ namespace Freestyle {
class Stroke;
/*! Base class for Stroke Shaders.
/** Base class for Stroke Shaders.
* Any Stroke Shader must inherit from this class and overload the shade() method.
* A StrokeShader is designed to modify any Stroke's attribute such as Thickness, Color,
* Geometry, Texture, Blending mode...
@@ -65,24 +65,24 @@ class StrokeShader {
public:
void *py_ss;
/*! Default constructor. */
/** Default constructor. */
StrokeShader()
{
py_ss = 0;
}
/*! Destructor. */
/** Destructor. */
virtual ~StrokeShader()
{
}
/*! Returns the string corresponding to the shader's name. */
/** Returns the string corresponding to the shader's name. */
virtual string getName() const
{
return "StrokeShader";
}
/*! The shading method. This method must be overloaded by inherited classes.
/** The shading method. This method must be overloaded by inherited classes.
* \param ioStroke:
* The stroke we wish to shade. this Stroke is modified by the Shader (which typically
* modifies the Stroke's attribute's values such as Color, Thickness, Geometry...)

4
source/blender/freestyle/intern/stroke/StrokeTesselator.h
View File

@@ -43,10 +43,10 @@ class StrokeTesselator {
{
}
/*! Builds a line rep contained from a Stroke */
/** Builds a line rep contained from a Stroke */
LineRep *Tesselate(Stroke *iStroke);
/*! Builds a set of lines rep contained under a a NodeShape, itself contained under a NodeGroup
/** Builds a set of lines rep contained under a a NodeShape, itself contained under a NodeGroup
* from a set of strokes.
*/
template<class StrokeIterator> NodeGroup *Tesselate(StrokeIterator begin, StrokeIterator end);

2
source/blender/freestyle/intern/stroke/TextStrokeRenderer.h
View File

@@ -54,7 +54,7 @@ class TextStrokeRenderer : public StrokeRenderer {
public:
TextStrokeRenderer(const char *iFileName = NULL);
/*! Renders a stroke rep */
/** Renders a stroke rep */
virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;

6
source/blender/freestyle/intern/system/BaseObject.h
View File

@@ -39,7 +39,7 @@ class BaseObject {
{
}
/*! At least makes a release on this.
/** At least makes a release on this.
* The BaseObject::destroy method must be explicitly called at the end of any overloaded destroy
*/
virtual int destroy()
@@ -47,13 +47,13 @@ class BaseObject {
return release();
}
/*! Increments the reference counter */
/** Increments the reference counter */
inline int addRef()
{
return ++_ref_counter;
}
/*! Decrements the reference counter */
/** Decrements the reference counter */
inline int release()
{
if (_ref_counter) {

26
source/blender/freestyle/intern/system/Id.h
View File

@@ -27,21 +27,21 @@
namespace Freestyle {
/*! Class used to tag any object by an id.
/** Class used to tag any object by an id.
* It is made of two unsigned integers.
*/
class Id {
public:
typedef unsigned id_type;
/*! Default constructor */
/** Default constructor */
Id()
{
_first = 0;
_second = 0;
}
/*! Builds an Id from an integer.
/** Builds an Id from an integer.
* The second number is set to 0.
*/
Id(id_type id)
@@ -50,21 +50,21 @@ class Id {
_second = 0;
}
/*! Builds the Id from the two numbers */
/** Builds the Id from the two numbers */
Id(id_type ifirst, id_type isecond)
{
_first = ifirst;
_second = isecond;
}
/*! Copy constructor */
/** Copy constructor */
Id(const Id &iBrother)
{
_first = iBrother._first;
_second = iBrother._second;
}
/*! Operator= */
/** Operator= */
Id &operator=(const Id &iBrother)
{
_first = iBrother._first;
@@ -72,43 +72,43 @@ class Id {
return *this;
}
/*! Returns the first Id number */
/** Returns the first Id number */
id_type getFirst() const
{
return _first;
}
/*! Returns the second Id number */
/** Returns the second Id number */
id_type getSecond() const
{
return _second;
}
/*! Sets the first number constituting the Id */
/** Sets the first number constituting the Id */
void setFirst(id_type first)
{
_first = first;
}
/*! Sets the second number constituting the Id */
/** Sets the second number constituting the Id */
void setSecond(id_type second)
{
_second = second;
}
/*! Operator== */
/** Operator== */
bool operator==(const Id &id) const
{
return ((_first == id._first) && (_second == id._second));
}
/*! Operator!= */
/** Operator!= */
bool operator!=(const Id &id) const
{
return !((*this) == id);
}
/*! Operator< */
/** Operator< */
bool operator<(const Id &id) const
{
if (_first < id._first) {

2
source/blender/freestyle/intern/system/ProgressBar.h
View File

@@ -64,7 +64,7 @@ class ProgressBar {
_label = s;
}
/*! accessors */
/** accessors */
inline unsigned int getTotalSteps() const
{
return _numtotalsteps;

12
source/blender/freestyle/intern/view_map/FEdgeXDetector.h
View File

@@ -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
*/

132
source/blender/freestyle/intern/view_map/Functions0D.h
View File

@@ -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);
};

164
source/blender/freestyle/intern/view_map/Functions1D.h
View File

@@ -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);
};

82
source/blender/freestyle/intern/view_map/Interface0D.h
View File

@@ -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();

40
source/blender/freestyle/intern/view_map/Interface1D.h
View File

@@ -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;

246
source/blender/freestyle/intern/view_map/Silhouette.h
View File

@@ -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;

16
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h
View File

@@ -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

2
source/blender/freestyle/intern/view_map/SphericalGrid.h
View File

@@ -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.

24
source/blender/freestyle/intern/view_map/SteerableViewMap.h
View File

@@ -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:

28
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h
View File

@@ -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

4
source/blender/freestyle/intern/view_map/ViewMap.cpp
View File

@@ -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());

238
source/blender/freestyle/intern/view_map/ViewMap.h
View File

@@ -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);

6
source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h
View File

@@ -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:

28
source/blender/freestyle/intern/view_map/ViewMapBuilder.h
View File

@@ -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

66
source/blender/freestyle/intern/view_map/ViewMapIterators.h
View File

@@ -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);

10
source/blender/freestyle/intern/view_map/ViewMapTesselator.h
View File

@@ -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()

8
source/blender/freestyle/intern/winged_edge/Curvature.cpp
View File

@@ -104,7 +104,7 @@ static real angle_from_cotan(WVertex *vo, WVertex *v1, WVertex *v2)
return (fabs(atan2(denom, udotv)));
}
/*! gts_vertex_mean_curvature_normal:
/** gts_vertex_mean_curvature_normal:
* \param v: a #WVertex.
* \param s: a #GtsSurface.
* \param Kh: the Mean Curvature Normal at \a v.
@@ -175,7 +175,7 @@ bool gts_vertex_mean_curvature_normal(WVertex *v, Vec3r &Kh)
return true;
}
/*! gts_vertex_gaussian_curvature:
/** gts_vertex_gaussian_curvature:
* \param v: a #WVertex.
* \param s: a #GtsSurface.
* \param Kg: the Discrete Gaussian Curvature approximation at \a v.
@@ -226,7 +226,7 @@ bool gts_vertex_gaussian_curvature(WVertex *v, real *Kg)
return true;
}
/*! gts_vertex_principal_curvatures:
/** gts_vertex_principal_curvatures:
* @Kh: mean curvature.
* @Kg: Gaussian curvature.
* @K1: first principal curvature.
@@ -279,7 +279,7 @@ static void eigenvector(real a, real b, real c, Vec3r e)
e[2] = 0.0;
}
/*! gts_vertex_principal_directions:
/** gts_vertex_principal_directions:
* \param v: a #WVertex.
* \param s: a #GtsSurface.
* \param Kh: mean curvature normal (a #Vec3r).

32
source/blender/freestyle/intern/winged_edge/Nature.h
View File

@@ -23,44 +23,44 @@
namespace Freestyle {
/*! Namespace gathering the different possible natures of 0D and 1D elements of the ViewMap */
/** Namespace gathering the different possible natures of 0D and 1D elements of the ViewMap */
namespace Nature {
/* XXX Why not using enums??? */
/* In order to optimize for space (enum is int) - T.K. */
typedef unsigned short VertexNature;
/*! true for any 0D element */
/** true for any 0D element */
static const VertexNature POINT = 0; // 0
/*! true for SVertex */
/** true for SVertex */
static const VertexNature S_VERTEX = (1 << 0); // 1
/*! true for ViewVertex */
/** true for ViewVertex */
static const VertexNature VIEW_VERTEX = (1 << 1); // 2
/*! true for NonTVertex */
/** true for NonTVertex */
static const VertexNature NON_T_VERTEX = (1 << 2); // 4
/*! true for TVertex */
/** true for TVertex */
static const VertexNature T_VERTEX = (1 << 3); // 8
/*! true for CUSP */
/** true for CUSP */
static const VertexNature CUSP = (1 << 4); // 16
typedef unsigned short EdgeNature;
/*! true for non feature edges (always false for 1D elements of the ViewMap) */
/** true for non feature edges (always false for 1D elements of the ViewMap) */
static const EdgeNature NO_FEATURE = 0; // 0
/*! true for silhouettes */
/** true for silhouettes */
static const EdgeNature SILHOUETTE = (1 << 0); // 1
/*! true for borders */
/** true for borders */
static const EdgeNature BORDER = (1 << 1); // 2
/*! true for creases */
/** true for creases */
static const EdgeNature CREASE = (1 << 2); // 4
/*! true for ridges */
/** true for ridges */
static const EdgeNature RIDGE = (1 << 3); // 8
/*! true for valleys */
/** true for valleys */
static const EdgeNature VALLEY = (1 << 4); // 16
/*! true for suggestive contours */
/** true for suggestive contours */
static const EdgeNature SUGGESTIVE_CONTOUR = (1 << 5); // 32
/*! true for material boundaries */
/** true for material boundaries */
static const EdgeNature MATERIAL_BOUNDARY = (1 << 6); // 64
/*! true for user-defined edge marks */
/** true for user-defined edge marks */
static const EdgeNature EDGE_MARK = (1 << 7); // 128
} // end of namespace Nature

2
source/blender/freestyle/intern/winged_edge/WEdge.cpp
View File

@@ -25,7 +25,7 @@
namespace Freestyle {
/*! Temporary structures */
/** Temporary structures */
class vertexdata {
public:
WVertex *_copy;

72
source/blender/freestyle/intern/winged_edge/WEdge.h
View File

@@ -76,14 +76,14 @@ class WVertex {
_Border = -1;
}
/*! Copy constructor */
/** Copy constructor */
WVertex(WVertex &iBrother);
virtual WVertex *duplicate();
virtual ~WVertex()
{
}
/*! accessors */
/** accessors */
inline Vec3f &GetVertex()
{
return _Vertex;
@@ -111,7 +111,7 @@ class WVertex {
bool isBoundary();
/*! modifiers */
/** modifiers */
inline void setVertex(const Vec3f &v)
{
_Vertex = v;
@@ -147,7 +147,7 @@ class WVertex {
}
}
/*! Adds an edge to the edges list */
/** Adds an edge to the edges list */
void AddEdge(WEdge *iEdge);
virtual void ResetUserData()
@@ -156,7 +156,7 @@ class WVertex {
}
public:
/*! Iterator to iterate over a vertex incoming edges in the CCW order*/
/** Iterator to iterate over a vertex incoming edges in the CCW order*/
#if defined(__GNUC__) && (__GNUC__ < 3)
class incoming_edge_iterator : public input_iterator<WOEdge *, ptrdiff_t>
#else
@@ -247,7 +247,7 @@ class WVertex {
#endif
};
/*! Iterator to iterate over a vertex faces in the CCW order */
/** Iterator to iterate over a vertex faces in the CCW order */
#if defined(__GNUC__) && (__GNUC__ < 3)
class face_iterator : public input_iterator<WFace *, ptrdiff_t>
#else
@@ -336,7 +336,7 @@ class WVertex {
};
public:
/*! iterators access */
/** iterators access */
virtual incoming_edge_iterator incoming_edges_begin();
virtual incoming_edge_iterator incoming_edges_end();
@@ -404,11 +404,11 @@ class WOEdge {
virtual ~WOEdge(){}; // soc
/*! copy constructor */
/** copy constructor */
WOEdge(WOEdge &iBrother);
virtual WOEdge *duplicate();
/*! accessors */
/** accessors */
#if 0
inline WOEdge *GetaCWEdge()
{
@@ -466,7 +466,7 @@ class WOEdge {
return _angle;
}
/*! modifiers */
/** modifiers */
#if 0
inline void SetaCWEdge(WOEdge *pe)
{
@@ -520,7 +520,7 @@ class WOEdge {
_pOwner = pe;
}
/*! Retrieves the list of edges in CW order */
/** Retrieves the list of edges in CW order */
inline void RetrieveCWOrderedEdges(vector<WEdge *> &oEdges);
WOEdge *twin();
@@ -579,7 +579,7 @@ class WEdge {
userdata = NULL;
}
/*! Copy constructor */
/** Copy constructor */
WEdge(WEdge &iBrother);
virtual WEdge *duplicate();
@@ -596,7 +596,7 @@ class WEdge {
}
}
/*! checks whether two WEdge have a common vertex.
/** checks whether two WEdge have a common vertex.
* Returns a pointer on the common vertex if it exists, NULL otherwise.
*/
static inline WVertex *CommonVertex(WEdge *iEdge1, WEdge *iEdge2)
@@ -619,7 +619,7 @@ class WEdge {
return NULL;
}
/*! accessors */
/** accessors */
inline WOEdge *GetaOEdge()
{
return _paOEdge;
@@ -675,7 +675,7 @@ class WEdge {
}
}
/*! modifiers */
/** modifiers */
inline void setaOEdge(WOEdge *iEdge)
{
_paOEdge = iEdge;
@@ -754,14 +754,14 @@ class WFace {
_FrsMaterialIndex = 0;
}
/*! copy constructor */
/** copy constructor */
WFace(WFace &iBrother);
virtual WFace *duplicate();
virtual ~WFace()
{
}
/*! accessors */
/** accessors */
inline const vector<WOEdge *> &getEdgeList()
{
return _OEdgeList;
@@ -794,7 +794,7 @@ class WFace {
const FrsMaterial &frs_material();
/*! The vertex of index i corresponds to the a vertex of the edge of index i */
/** The vertex of index i corresponds to the a vertex of the edge of index i */
inline WVertex *GetVertex(unsigned int index)
{
#if 0
@@ -805,7 +805,7 @@ class WFace {
return _OEdgeList[index]->GetaVertex();
}
/*! returns the index at which iVertex is stored in the array.
/** returns the index at which iVertex is stored in the array.
* returns -1 if iVertex doesn't belong to the face.
*/
inline int GetIndex(WVertex *iVertex)
@@ -868,19 +868,19 @@ class WFace {
return _VerticesTexCoords;
}
/*! Returns the normal of the vertex of index index */
/** Returns the normal of the vertex of index index */
inline Vec3f &GetVertexNormal(int index)
{
return _VerticesNormals[index];
}
/*! Returns the tex coords of the vertex of index index */
/** Returns the tex coords of the vertex of index index */
inline Vec2f &GetVertexTexCoords(int index)
{
return _VerticesTexCoords[index];
}
/*! Returns the normal of the vertex iVertex for that face */
/** Returns the normal of the vertex iVertex for that face */
inline Vec3f &GetVertexNormal(WVertex *iVertex)
{
int i = 0;
@@ -933,7 +933,7 @@ class WFace {
return _OEdgeList.size();
}
/*! Returns true if the face has one ot its edge which is a border edge */
/** Returns true if the face has one ot its edge which is a border edge */
inline bool isBorder() const
{
for (vector<WOEdge *>::const_iterator woe = _OEdgeList.begin(), woeend = _OEdgeList.end();
@@ -946,7 +946,7 @@ class WFace {
return false;
}
/*! modifiers */
/** modifiers */
inline void setEdgeList(const vector<WOEdge *> &iEdgeList)
{
_OEdgeList = iEdgeList;
@@ -982,13 +982,13 @@ class WFace {
_Mark = iMark;
}
/*! designed to build a specialized WEdge for use in MakeEdge */
/** designed to build a specialized WEdge for use in MakeEdge */
virtual WEdge *instanciateEdge() const
{
return new WEdge;
}
/*! Builds an oriented edge
/** Builds an oriented edge
* Returns the built edge.
* v1, v2
* Vertices at the edge's extremities
@@ -996,18 +996,18 @@ class WFace {
*/
virtual WOEdge *MakeEdge(WVertex *v1, WVertex *v2);
/*! Adds an edge to the edges list */
/** Adds an edge to the edges list */
inline void AddEdge(WOEdge *iEdge)
{
_OEdgeList.push_back(iEdge);
}
/*! For triangles, returns the edge opposite to the vertex in e.
/** For triangles, returns the edge opposite to the vertex in e.
* returns false if the face is not a triangle or if the vertex is not found
*/
bool getOppositeEdge(const WVertex *v, WOEdge *&e);
/*! compute the area of the face */
/** compute the area of the face */
float getArea();
WShape *getShape();
@@ -1057,7 +1057,7 @@ class WShape {
_SceneCurrentId++;
}
/*! copy constructor */
/** copy constructor */
WShape(WShape &iBrother);
virtual WShape *duplicate();
@@ -1088,7 +1088,7 @@ class WShape {
}
}
/*! accessors */
/** accessors */
inline vector<WEdge *> &getEdgeList()
{
return _EdgeList;
@@ -1144,7 +1144,7 @@ class WShape {
return _LibraryPath;
}
/*! modifiers */
/** modifiers */
static inline void setCurrentId(const unsigned id)
{
_SceneCurrentId = id;
@@ -1198,13 +1198,13 @@ class WShape {
_LibraryPath = path;
}
/*! designed to build a specialized WFace for use in MakeFace */
/** designed to build a specialized WFace for use in MakeFace */
virtual WFace *instanciateFace() const
{
return new WFace;
}
/*! adds a new face to the shape
/** adds a new face to the shape
* returns the built face.
* iVertexList
* List of face's vertices. These vertices are not added to the WShape vertex list; they are
@@ -1217,7 +1217,7 @@ class WShape {
vector<bool> &iFaceEdgeMarksList,
unsigned iMaterialIndex);
/*! adds a new face to the shape. The difference with the previous method is that this one is
/** adds a new face to the shape. The difference with the previous method is that this one is
* designed to build a WingedEdge structure for which there are per vertex normals, opposed to
* per face normals. returns the built face. iVertexList List of face's vertices. These vertices
* are not added to the WShape vertex list; they are supposed to be already stored when calling
@@ -1309,7 +1309,7 @@ class WShape {
#endif
protected:
/*!
/**
* Builds the face passed as argument (which as already been allocated)
* - iVertexList
* List of face's vertices. These vertices are not added to the WShape vertex list;

4
source/blender/freestyle/intern/winged_edge/WFillGrid.h
View File

@@ -47,7 +47,7 @@ class WFillGrid {
void fillGrid();
/*! Accessors */
/** Accessors */
WingedEdge *getWingedEdge()
{
return _winged_edge;
@@ -58,7 +58,7 @@ class WFillGrid {
return _grid;
}
/*! Modifiers */
/** Modifiers */
void setWingedEdge(WingedEdge *winged_edge)
{
if (winged_edge) {

4
source/blender/freestyle/intern/winged_edge/WSFillGrid.h
View File

@@ -43,7 +43,7 @@ class WSFillGrid {
void fillGrid();
/*! Accessors */
/** Accessors */
WingedEdge *getWingedEdge()
{
return _winged_edge;
@@ -54,7 +54,7 @@ class WSFillGrid {
return _grid;
}
/*! Modifiers */
/** Modifiers */
void setWingedEdge(WingedEdge *winged_edge)
{
if (winged_edge) {

42
source/blender/freestyle/intern/winged_edge/WXEdge.h
View File

@@ -52,7 +52,7 @@ class WXVertex : public WVertex {
_curvatures = NULL;
}
/*! Copy constructor */
/** Copy constructor */
WXVertex(WXVertex &iBrother) : WVertex(iBrother)
{
_curvatures = new CurvatureInfo(*iBrother._curvatures);
@@ -135,7 +135,7 @@ class WXEdge : public WEdge {
_order = 0;
}
/*! Copy constructor */
/** Copy constructor */
inline WXEdge(WXEdge &iBrother) : WEdge(iBrother)
{
_nature = iBrother.nature();
@@ -159,7 +159,7 @@ class WXEdge : public WEdge {
_nature = _nature & ~Nature::SUGGESTIVE_CONTOUR;
}
/*! accessors */
/** accessors */
inline WXNature nature()
{
return _nature;
@@ -175,7 +175,7 @@ class WXEdge : public WEdge {
return _order;
}
/*! modifiers */
/** modifiers */
inline void setFront(bool iFront)
{
_front = iFront;
@@ -209,7 +209,7 @@ class WXEdge : public WEdge {
* *
**********************************/
/*! Class to store a smooth edge (i.e Hertzman & Zorin smooth silhouette edges) */
/** Class to store a smooth edge (i.e Hertzman & Zorin smooth silhouette edges) */
class WXSmoothEdge {
public:
typedef unsigned short Configuration;
@@ -278,7 +278,7 @@ class WXSmoothEdge {
return _config;
}
/*! modifiers */
/** modifiers */
inline void setWOeA(WOEdge *iwoea)
{
_woea = iwoea;
@@ -439,15 +439,15 @@ class WXFaceLayer {
}
}
/*! If one of the face layer vertex has a DotP equal to 0, this method returns the vertex where
/** If one of the face layer vertex has a DotP equal to 0, this method returns the vertex where
* it happens */
unsigned int Get0VertexIndex() const;
/*! In case one of the edge of the triangle is a smooth edge, this method allows to retrieve the
/** In case one of the edge of the triangle is a smooth edge, this method allows to retrieve the
* concerned edge */
unsigned int GetSmoothEdgeIndex() const;
/*! retrieves the edges of the triangle for which the signs are different (a null value is not
/** retrieves the edges of the triangle for which the signs are different (a null value is not
* considered) for the dotp values at each edge extremity
*/
void RetrieveCuspEdgesIndices(vector<int> &oCuspEdges);
@@ -512,7 +512,7 @@ class WXFace : public WFace {
_front = false;
}
/*! Copy constructor */
/** Copy constructor */
WXFace(WXFace &iBrother) : WFace(iBrother)
{
_center = iBrother.center();
@@ -545,13 +545,13 @@ class WXFace : public WFace {
}
}
/*! designed to build a specialized WEdge for use in MakeEdge */
/** designed to build a specialized WEdge for use in MakeEdge */
virtual WEdge *instanciateEdge() const
{
return new WXEdge;
}
/*! accessors */
/** accessors */
inline Vec3f &center()
{
return _center;
@@ -590,7 +590,7 @@ class WXFace : public WFace {
return _SmoothLayers;
}
/*! retrieve the smooth edges that match the Nature given as argument */
/** retrieve the smooth edges that match the Nature given as argument */
void retrieveSmoothEdges(WXNature iNature, vector<WXSmoothEdge *> &oSmoothEdges)
{
for (vector<WXFaceLayer *>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
@@ -624,7 +624,7 @@ class WXFace : public WFace {
}
}
/*! modifiers */
/** modifiers */
inline void setCenter(const Vec3f &iCenter)
{
_center = iCenter;
@@ -674,7 +674,7 @@ class WXFace : public WFace {
_SmoothLayers = layersToKeep;
}
/*! Clears everything */
/** Clears everything */
inline void Clear()
{
for (vector<WXFaceLayer *>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
@@ -724,7 +724,7 @@ class WXShape : public WShape {
_computeViewIndependent = true;
}
/*! copy constructor */
/** copy constructor */
inline WXShape(WXShape &iBrother) : WShape(iBrother)
{
_computeViewIndependent = iBrother._computeViewIndependent;
@@ -750,13 +750,13 @@ class WXShape : public WShape {
_computeViewIndependent = iFlag;
}
/*! designed to build a specialized WFace for use in MakeFace */
/** designed to build a specialized WFace for use in MakeFace */
virtual WFace *instanciateFace() const
{
return new WXFace;
}
/*!
/**
* Adds a new face to the shape returns the built face.
* - iVertexList
* List of face's vertices.
@@ -768,7 +768,7 @@ class WXShape : public WShape {
vector<bool> &iFaceEdgeMarksList,
unsigned iMaterialIndex);
/*!
/**
* Adds a new face to the shape.
* The difference with the previous method is that this one is designed to build a WingedEdge
* structure for which there are per vertex normals, opposed to per face normals.
@@ -792,7 +792,7 @@ class WXShape : public WShape {
vector<bool> &iFaceEdgeMarksList,
unsigned iMaterialIndex);
/*! Reset all edges and vertices flags (which might have been set up on a previous pass) */
/** Reset all edges and vertices flags (which might have been set up on a previous pass) */
virtual void Reset()
{
// Reset Edges
@@ -807,7 +807,7 @@ class WXShape : public WShape {
((WXFace *)(*wf))->Reset();
}
}
/*! accessors */
/** accessors */
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:WXShape")