Geom Software - C++ Programming and Geometry Libraries
Fade2D Documentation pages v1.55
GEOM_FADE2D::Fade_2D Class Reference

Delaunay triangulation - the main class. More...

#include <Fade_2D.h>

Public Member Functions

 Fade_2D (unsigned numExpectedVertices=1000)
 Constructor of the main triangulation class. More...
 
bool checkValidity (bool bCheckEmptyCircleProperty, const std::string &msg) const
 Checks if a triangulation is valid. More...
 
void statistics (const std::string &s) const
 Statistics. More...
 
void show (const std::string &postscriptFilename, bool bWithConstraints=true) const
 Draws the triangulation as postscript file. More...
 
void show (Visualizer2 *pVis, bool bWithConstraints=true) const
 Draws the triangulation as postscript file using an existing Visualizer2 object. More...
 
void remove (Point2 *pVertex)
 Remove a single point. More...
 
void getConvexHull (bool bAllVertices, std::vector< Point2 *> &vConvexHullPointsOut)
 Compute the convex hull. More...
 
Point2insert (const Point2 &p)
 Insert a single point. More...
 
void insert (const std::vector< Point2 > &vInputPoints)
 Insert a vector of points. More...
 
void insert (const std::vector< Point2 > &vInputPoints, std::vector< Point2 *> &vHandles)
 Insert points from a std::vector and store pointers in vHandles. More...
 
void insert (int numPoints, double *aCoordinates, Point2 **aHandles)
 Insert points from an array. More...
 
void enableMultithreading ()
 Enable multithreading. More...
 
Triangle2locate (const Point2 &p)
 Locate a triangle which contains p. More...
 
void refine (Zone2 *pZone, double minAngleDegree, double minEdgeLength, double maxEdgeLength, bool bAllowConstraintSplitting)
 Delaunay refinement. More...
 
void refineAdvanced (MeshGenParams *pParameters)
 Delaunay refinement. More...
 
size_t numberOfPoints () const
 Number of points. More...
 
size_t numberOfTriangles () const
 Number of triangles. More...
 
void getTrianglePointers (std::vector< Triangle2 *> &vAllTriangles) const
 Get pointers to all triangles. More...
 
void getVertexPointers (std::vector< Point2 *> &vAllPoints) const
 Get pointers to all vertices. More...
 
Triangle2getAdjacentTriangle (Point2 *p0, Point2 *p1) const
 Get adjacent triangle. More...
 
bool is2D () const
 Check if the triangulation contains triangles (which is the case if at least 3 non-collinear points exist in the triangulation. More...
 
ConstraintGraph2createConstraint (std::vector< Segment2 > &vSegments, ConstraintInsertionStrategy cis, bool bOrientedSegments=false)
 Add constraint edges (edges, polyline, polygon) More...
 
Zone2createZone (ConstraintGraph2 *pConstraintGraph, ZoneLocation zoneLoc, bool bVerbose=true)
 Create a zone. More...
 
Zone2createZone (const std::vector< ConstraintGraph2 *> &vConstraintGraphs, ZoneLocation zoneLoc, const Point2 &startPoint, bool bVerbose=true)
 Create a zone limited by multiple ConstraintGraph2 objects by growing from a start point. More...
 
Zone2createZone (ConstraintGraph2 *pConstraintGraph, ZoneLocation zoneLoc, const Point2 &startPoint, bool bVerbose=true)
 Create a zone limited by a ConstraintGraph by growing from a start point. More...
 
Zone2createZone (std::vector< Triangle2 *> &vTriangles, bool bVerbose=true)
 Create a zone defined by a vector of triangles. More...
 
void deleteZone (Zone2 *pZone)
 Delete a Zone2 object. More...
 
void applyConstraintsAndZones ()
 Apply all formerly defined constraints and zones. More...
 
Bbox2 computeBoundingBox () const
 Compute the axis-aligned bounding box of the points. More...
 
bool isConstraint (Triangle2 *pT, int ith) const
 Check if an edge is a constraint edge. More...
 
ConstraintSegment2getConstraintSegment (Point2 *p0, Point2 *p1) const
 Retrieve a ConstraintSegment2. More...
 
void getIncidentTriangles (Point2 *pVtx, std::vector< Triangle2 *> &vIncidentT) const
 Get incident triangles. More...
 
void writeObj (const std::string &filename) const
 Write the current triangulation to an *.obj file. More...
 
void writeObj (const std::string &filename, Zone2 *pZone) const
 Write a zone to an *.obj file. More...
 
void writeWebScene (const char *path) const
 Write the current triangulation to an *.obj file. More...
 
void writeWebScene (const char *path, Zone2 *pZone) const
 Write a zone to an *.obj file. More...
 
void subscribe (MsgType msgType, MsgBase *pMsg)
 Register a message receiver. More...
 
void unsubscribe (MsgType msgType, MsgBase *pMsg)
 Unregister a message receiver. More...
 
bool isConstraint (Point2 *p0, Point2 *p1) const
 Check if an edge is a constraint edge. More...
 
bool isConstraint (Point2 *pVtx) const
 Check if a vertex is a constraint vertex. More...
 
void printLicense () const
 
bool checkZoneQuality (Zone2 *pZone, double minAngle, const std::string &name, const AcceptExperimentalFeature &accept)
 Development feature. More...
 
void setName (const std::string &s)
 Development feature. More...
 
std::string getName () const
 Development feature. More...
 
Zone2importTriangles (std::vector< Point2 > &vPoints, bool bReorientIfNeeded, bool bCreateExtendedBoundingBox)
 Import triangles. More...
 
Orientation2 getOrientation (const Point2 &p0, const Point2 &p1, const Point2 &p2)
 Compute the orientation of 3 points. More...
 
void cutTriangles (const Point2 &knifeStart, const Point2 &knifeEnd, bool bTurnEdgesIntoConstraints)
 Cut through a triangulation. More...
 
void cutTriangles (std::vector< Segment2 > &vSegments, bool bTurnEdgesIntoConstraints)
 Cut through a triangulation. More...
 

Detailed Description

Fade_2D represents a Delaunay triangulation in 2D or 2.5D (depends on the used namespace)

Constructor & Destructor Documentation

◆ Fade_2D()

GEOM_FADE2D::Fade_2D::Fade_2D ( unsigned  numExpectedVertices = 1000)
inlineexplicit
Parameters
numExpectedVerticesspecifies the number of points that will probably be inserted.

By default, the internal data structures are initialized for 1000 points and they are automatically reconfigured later if necessary. Specifying numExpectedVertices saves memory but is not required.

Member Function Documentation

◆ applyConstraintsAndZones()

void GEOM_FADE2D::Fade_2D::applyConstraintsAndZones ( )

For technical reasons all defined constraints are inserted at the end of the triangulation process. This step must be triggered manually, i.e., it is up to the user to call applyConstraintsAndZones() before the resulting triangulation is used. If afterwards more points are inserted, applyConstraintsAndZones() must be called again.

Since version 1.33 of Fade intersecting constraint segments are supported. They are automatically subdivided and connected at their intersection points. The /e exact intersection point of two segments may not exist in IEEE754 double precision arithmetic. In this case the coordinates are rounded.

◆ checkValidity()

bool GEOM_FADE2D::Fade_2D::checkValidity ( bool  bCheckEmptyCircleProperty,
const std::string &  msg 
) const

Checks the validity of the data structure.

Parameters
bCheckEmptyCirclePropertyspecifies if (slow!) multiprecision arithmetic shall be used to recheck the empty circle property
msgis a debug string that will be shown in terminal output so that you know which checkValidity call currently runs.

This method is thought for development purposes. Don't call it method unless you assume that something is wrong with the code.

◆ checkZoneQuality()

bool GEOM_FADE2D::Fade_2D::checkZoneQuality ( Zone2 pZone,
double  minAngle,
const std::string &  name,
const AcceptExperimentalFeature &  accept 
)

No documentation, this is a development tool.

◆ computeBoundingBox()

Bbox2 GEOM_FADE2D::Fade_2D::computeBoundingBox ( ) const

If no points have been inserted yet, then the returned Bbox2 object is invalid and its member function Bbox2::isValid() returns false.

◆ createConstraint()

ConstraintGraph2* GEOM_FADE2D::Fade_2D::createConstraint ( std::vector< Segment2 > &  vSegments,
ConstraintInsertionStrategy  cis,
bool  bOrientedSegments = false 
)

Parameters
vSegmentscontains line segments which shall appear as edges of the triangulation. The order of the segments is not important.
cis
  • CIS_CONSTRAINED_DELAUNAY inserts the segments without subdivision unless required (which is the case if existing vertices or constraint segments are crossed).
  • CIS_CONFORMING_DELAUNAY subdivides the segments if necessary to maintain the empty circle property of the surrounding triangles. In general this insertion strategy creates more but better shaped triangles than CIS_CONSTRAINED_DELAUNAY.
bOrientedSegmentsUsed to specify if the segments in vSegments are oriented (oriented, not ordered) in counterclockwise direction. A Zone2 object can later be made from the returned ConstrainedGraph2 object only if this value is true or if vSegments forms a closed simple polygon (in this case the segments are internally reoriented). To maintain backwards compatibility bOrientedSegments is a default parameter and it defaults to false.
Returns
a pointer to the new ConstraintGraph2 object

crop_bareBike.jpg
Figure 3: Delaunay triangulation without constraints
crop_ignoreBike.jpg
Figure 4: Constraint insertion with CIS_CONSTRAINED_DELAUNAY.
crop_keepBike.jpg
Figure 5: Constraint insertion with CIS_CONFORMING_DELAUNAY. The inserted segments are automatically subdivided.

◆ createZone() [1/4]

Zone2* GEOM_FADE2D::Fade_2D::createZone ( ConstraintGraph2 pConstraintGraph,
ZoneLocation  zoneLoc,
bool  bVerbose = true 
)

A Zone2 object is an area of a triangulation, possibly bounded by a ConstraintGraph.

Parameters
zoneLocis ZL_INSIDE, ZL_OUTSIDE or ZL_GLOBAL.
pConstraintGraphpoints to a formerly created ConstraintGraph2 object (which must contain a simple polygon) or is NULL in case of zoneLoc==ZL_GLOBAL.
bVerboseis by default true and causes a warning if NULL is returned.
Returns
a pointer to the new Zone2 object or NULL if no triangles exist or pConstraintGraph->isOriented() returns false.
See also
deleteZone(Zone2* pZone).

bikeZones.jpg
Figure 6: Zones in a triangulation

◆ createZone() [2/4]

Zone2* GEOM_FADE2D::Fade_2D::createZone ( const std::vector< ConstraintGraph2 *> &  vConstraintGraphs,
ZoneLocation  zoneLoc,
const Point2 startPoint,
bool  bVerbose = true 
)

A Zone2 object is an area of the traingulation, see createZone

Parameters
vConstraintGraphsis a vector of ConstraintGraph objects
zoneLocmust be ZL_GROW
startPointis the point from which the area is grown until the borders specified in vConstraintGraphs are reached
bVerboseis by default true and causes a warning if NULL is returned.
Returns
a pointer to the new Zone2 object (or NULL if zoneLoc!=ZL_GROW or no triangles exist)

◆ createZone() [3/4]

Zone2* GEOM_FADE2D::Fade_2D::createZone ( ConstraintGraph2 pConstraintGraph,
ZoneLocation  zoneLoc,
const Point2 startPoint,
bool  bVerbose = true 
)

A Zone2 object is an area of the traingulation, see createZone

Parameters
pConstraintGraphis a constraint whose edges specify the area's border
zoneLocmust be ZL_GROW
startPointis the point from which the area is grown until the borders specified in pConstraint are reached
bVerboseis by default true and causes a warning if NULL is returned.
Returns
a pointer to the new Zone2 object (or NULL if zoneLoc!=ZL_GROW or no triangles exist)

◆ createZone() [4/4]

Zone2* GEOM_FADE2D::Fade_2D::createZone ( std::vector< Triangle2 *> &  vTriangles,
bool  bVerbose = true 
)

A Zone2 object is an area of the traingulation, see createZone

Parameters
vTriangles
bVerboseis by default true and causes a warning if NULL is returned.
Returns
a pointer to the new Zone2 object (or NULL if vTriangles is empty)

◆ cutTriangles() [1/2]

void GEOM_FADE2D::Fade_2D::cutTriangles ( const Point2 knifeStart,
const Point2 knifeEnd,
bool  bTurnEdgesIntoConstraints 
)
Parameters
knifeStartis one point of the knife segment
knifeEndis the second point of the knife segment
bTurnEdgesIntoConstraintsturns all 3 edges of each intersected triangle into constraint segments.

This method inserts a constraint edge knife(knifeStart,knifeEnd). If existing edges E are intersected by knife, then knife is subdivided at the intersection points P.

In any case knife will exist (in a possibly subdivided form) in the result. But a consequence of the insertion of the points P is that the edges E and even edges which are not intersected by knife may disappear. Use bTurnEdgesIntoConstraints=true to avoid that.

Note
The method calls applyConstraintsAndZones() internally to apply pre-existing constraint segments before the cut operation is performed.
The intersection point of two line segments may not be exactly representable in double precision floating point arithmetic and thus tiny rounding errors may occur. As a consequence two very close intersection points may be rounded to the same coordinates.
When more than one knife segment is inserted then the method void cutTriangles(std::vector<Segment2>& vSegments,bool bTurnEdgesIntoConstraints) should be used. The reason is that each individual cut operation changes the triangulation and thus iterative calls to the present version of the method can lead to a different result.

◆ cutTriangles() [2/2]

void GEOM_FADE2D::Fade_2D::cutTriangles ( std::vector< Segment2 > &  vSegments,
bool  bTurnEdgesIntoConstraints 
)
Parameters
vSegmentsare the knife segments
bTurnEdgesIntoConstraintsspecifies if intersected edges shall automatically be turned into constraints

Same method as void cutTriangles(const Point2& knifeStart,const Point2& knifeEnd,bool bTurnEdgesIntoConstraints) but it takes a vector of segments instead of a single segment. This is the recommended method to cut through a triangulation when more than one knife segment exists.

◆ deleteZone()

void GEOM_FADE2D::Fade_2D::deleteZone ( Zone2 pZone)

Zone2 objects are automatically destroyed with their Fade_2D objects. In addition this method provides the possibility to eliminate Zone2 objects earlier.

◆ enableMultithreading()

void GEOM_FADE2D::Fade_2D::enableMultithreading ( )

This is a feature for Linux systems: Fade2D can be executed on multiple CPU cores. The speed up is currently only 20% as the algorithm is only partially parallelized.

Note
Due to compatibility issues we had to deactivate the method, i.e., you can call it but it has no effect. Multithreading is currently revised and will be enabled for Linux and Windows as soon as possible.

◆ getAdjacentTriangle()

Triangle2* GEOM_FADE2D::Fade_2D::getAdjacentTriangle ( Point2 p0,
Point2 p1 
) const
Returns
the triangle that has the edge (p0,p1) or NULL if no such edge is present
Note
Recall the counter-clockwise enumeration of vertices in a triangle. If (p0,p1) is used, the unique triangle with the CCW oriented edge (p0,p1) is returned, using (p1,p0) one gets the other adjacent triangle.

◆ getConstraintSegment()

ConstraintSegment2* GEOM_FADE2D::Fade_2D::getConstraintSegment ( Point2 p0,
Point2 p1 
) const
Returns
a pointer to the ConstraintSegment2 between p0 and p1 or NULL if the segment is not a constraint edge.
Note
ConstraintSegment2s that have been splitted are dead. They are not returned by this method.

◆ getConvexHull()

void GEOM_FADE2D::Fade_2D::getConvexHull ( bool  bAllVertices,
std::vector< Point2 *> &  vConvexHullPointsOut 
)
Parameters
bAllVerticesdetermines if all convex hull points are returned or if collinear ones shall be removed.
[out]vConvexHullPointsOutis used to return the convex hull vertices in counterclockwise order. The start vertex is the leftmost vertex. If more than one leftmost vertex exists, the bottommost of them is the start vertex.

◆ getIncidentTriangles()

void GEOM_FADE2D::Fade_2D::getIncidentTriangles ( Point2 pVtx,
std::vector< Triangle2 *> &  vIncidentT 
) const

Stores pointers to all triangles around pVtx into vIncidentT

◆ getName()

std::string GEOM_FADE2D::Fade_2D::getName ( ) const

No documentation, this is a development tool

◆ getOrientation()

Orientation2 GEOM_FADE2D::Fade_2D::getOrientation ( const Point2 p0,
const Point2 p1,
const Point2 p2 
)
Returns
ORIENTATION2_COLLINEAR, ORIENTATION2_CW (clockwise) or ORENTATION2_CCW (counterclockwise)

◆ getTrianglePointers()

void GEOM_FADE2D::Fade_2D::getTrianglePointers ( std::vector< Triangle2 *> &  vAllTriangles) const

This command fetches the existing triangles

Parameters
vAllTrianglesis an empty vector of Triangle2 pointers.

If is2D()==true then pointers to all existing triangles are stored in vAllTriangles. If is2D()==false then no triangles exist at all.

◆ getVertexPointers()

void GEOM_FADE2D::Fade_2D::getVertexPointers ( std::vector< Point2 *> &  vAllPoints) const
Parameters
vAllPointsis an empty vector of Point2 pointers.

Stores pointers to all vertices of the triangulation in vAllPoints. The order in which the points are stored is not necessarily the insertion order. For geometrically identical points which have been inserted multiple times, only one pointer exists. Thus vAllPoints.size() can be smaller than the number of inserted points.

◆ importTriangles()

Zone2* GEOM_FADE2D::Fade_2D::importTriangles ( std::vector< Point2 > &  vPoints,
bool  bReorientIfNeeded,
bool  bCreateExtendedBoundingBox 
)

This method imports triangles into an empty Fade object. Triangles do not necessarily need to satisfy the empty circle property.

Parameters
vPointscontains the input vertices (3 subsequent ones per triangle)
bReorientIfNeededspecifies if the orientations of the point triples shall be checked and corrected. If the point triples are certainly oriented in counterclockwise order then the orientation test can be skipped.
bCreateExtendedBoundingBoxcan be used to insert 4 dummy points of an extended bounding box. This is convenient in some cases. Use false if you are not sure.
Returns
a pointer to a Zone2 object or NULL if the input data is invalid
Note
Imported triangles may change if points or constraint segments are inserted afterwards.

◆ insert() [1/4]

Point2* GEOM_FADE2D::Fade_2D::insert ( const Point2 p)
Parameters
pis the point to be inserted.
Returns
a pointer to the point in the triangulation

The triangulation keeps a copy of p. The return value is a pointer to this copy. If duplicate points are inserted, the triangulation does not create new copies but returns a pointer to the copy of the very first insertion.

Note
This method offers a very good performance but it is still faster if all points are passed at once, if possible.

◆ insert() [2/4]

void GEOM_FADE2D::Fade_2D::insert ( const std::vector< Point2 > &  vInputPoints)
Parameters
vInputPointscontains the points to be inserted.

◆ insert() [3/4]

void GEOM_FADE2D::Fade_2D::insert ( const std::vector< Point2 > &  vInputPoints,
std::vector< Point2 *> &  vHandles 
)
Parameters
vInputPointscontains the points to be inserted.
vHandles(empty) is used by Fade to return Point2 pointers

Internally, the triangulation keeps copies of the inserted points which are returned in vHandles (in the same order). If duplicate points are contained in vInputPoints then only one copy will be made and a pointer to this unique copy will be stored in vHandles for every occurance.

◆ insert() [4/4]

void GEOM_FADE2D::Fade_2D::insert ( int  numPoints,
double *  aCoordinates,
Point2 **  aHandles 
)
Parameters
numPointsis the number of points to be inserted
aCoordinatesis an array of 2n double values, e.g. {x0,y0,x1,y1,...,xn,yn}
aHandlesis an empty array with size n where pointers to the inserted points will be stored by Fade

◆ is2D()

bool GEOM_FADE2D::Fade_2D::is2D ( ) const

As long as all inserted points are collinear the triangulation does not contain triangles. This is clearly the case as long as less than three input points are present but it may also be the case when 3 or more points have been inserted when all these points are collinear. These points are then in a pending state, i.e. they will be triangulated as soon as the first non-collinear point is inserted.

coll.jpg
Figure 2: Triangles are generated as soon as the first non-collinear point is inserted.
Returns
true if at least one triangle exists
false otherwise

◆ isConstraint() [1/3]

bool GEOM_FADE2D::Fade_2D::isConstraint ( Triangle2 pT,
int  ith 
) const

Returns whether the edge in triangle pT which is opposite to the ith vertex is a constraint edge.

◆ isConstraint() [2/3]

bool GEOM_FADE2D::Fade_2D::isConstraint ( Point2 p0,
Point2 p1 
) const

Returns whether the edge (p0,p1) is a constraint edge.

◆ isConstraint() [3/3]

bool GEOM_FADE2D::Fade_2D::isConstraint ( Point2 pVtx) const

Returns whether the vertex pVtx belongs to a constraint edge.

◆ locate()

Triangle2* GEOM_FADE2D::Fade_2D::locate ( const Point2 p)
locate.jpg
Figure 1: Point location

The Fade_2D class can be used as a data structure for point location. This method returns a pointer to a triangle which contains p.

Parameters
pis the query point
Returns
a pointer to a Triangle2 object (or NULL if is2D()==false or if p is outside the triangulation)

◆ numberOfPoints()

size_t GEOM_FADE2D::Fade_2D::numberOfPoints ( ) const
Returns
the number of points in the triangulation
Note
Due to possibly duplicate input points the number of points is not stored somewhere but freshly computed in O(n) time. This is fast but you are adviced to avoid calling this method over-frequently in a loop. Duplicate point insertions count only once.

◆ numberOfTriangles()

size_t GEOM_FADE2D::Fade_2D::numberOfTriangles ( ) const
Returns
the number of triangles in the triangulation (or 0 as long as is2D() is false).

◆ printLicense()

void GEOM_FADE2D::Fade_2D::printLicense ( ) const

Prints informations about the currently used license

◆ refine()

void GEOM_FADE2D::Fade_2D::refine ( Zone2 pZone,
double  minAngleDegree,
double  minEdgeLength,
double  maxEdgeLength,
bool  bAllowConstraintSplitting 
)

Creates a mesh inside the area given by a Zone2 object.

Parameters
pZoneis the zone whose triangles are refined. Allowed zoneLocation values are ZL_INSIDE and ZL_BOUNDED.
minAngleDegree(up to 30) is the minimum interior triangle angle
minEdgeLengthis a lower threshold on the edge length. Triangles with smaller edges are not refined.
maxEdgeLengthis an upper threshold on the edge length. Triangles with larger edges are always refined.
bAllowConstraintSplittingspecifies if constraint edges may be splitted
Note
The behavior of the present method had to be changed in Fade v1.39: Only ZL_INSIDE and ZL_BOUNDED zones are accepted. But you can easily convert other types of zones to ZL_BOUNDED using Zone2::convertToBoundedZone().

◆ refineAdvanced()

void GEOM_FADE2D::Fade_2D::refineAdvanced ( MeshGenParams pParameters)

This is an advanced mesh generation method. The parameters are encapsulated in the MeshGenParams class which provides default parameters and which is intended as base class. Client code can derive from MeshGenParams and overwrite the methods and parameters to gain control over the mesh generation process.

◆ remove()

void GEOM_FADE2D::Fade_2D::remove ( Point2 pVertex)
Parameters
pVertexis the point to be removed

◆ setName()

void GEOM_FADE2D::Fade_2D::setName ( const std::string &  s)

No documentation, this is a development tool

◆ show() [1/2]

void GEOM_FADE2D::Fade_2D::show ( const std::string &  postscriptFilename,
bool  bWithConstraints = true 
) const

show() is a convenience function for quick outputs with a default look. It is also possible to use the Visualizer2 class directly to draw arbitrary circles, line segments, vertices and labels with custom colors.

Parameters
postscriptFilenameis the output name, i.e. "myFile.ps"
bWithConstraintsspecifies if constraint segments shall be shown (default: true)

◆ show() [2/2]

void GEOM_FADE2D::Fade_2D::show ( Visualizer2 pVis,
bool  bWithConstraints = true 
) const

This overload of the show() method allows to add further geometric primitives to the Visualizer2 object before it is finally written.

Parameters
pVisis the pointer of a Visualizer2 object that may already contain geometric primitives or that may later be used to draw further elements
bWithConstraintsspecifies if constraint segments shall be shown (default: true)
Note
The postscript file must be finalized with Visualizer2::writeFile().

◆ statistics()

void GEOM_FADE2D::Fade_2D::statistics ( const std::string &  s) const

Prints mesh statistics to stdout.

◆ subscribe()

void GEOM_FADE2D::Fade_2D::subscribe ( MsgType  msgType,
MsgBase pMsg 
)
Parameters
msgTypeis the type of message the subscriber shall receive, e.g. MSG_PROGRESS or MSG_WARNING
pMsgis a pointer to a custom class derived from MsgBase

◆ unsubscribe()

void GEOM_FADE2D::Fade_2D::unsubscribe ( MsgType  msgType,
MsgBase pMsg 
)
Parameters
msgTypeis the type of message the subscriber shall not receive anymore
pMsgis a pointer to a custom class derived from MsgBase

◆ writeObj() [1/2]

void GEOM_FADE2D::Fade_2D::writeObj ( const std::string &  filename) const

Makes most sense in 2.5D but works also for 2D (all heights are set to zero then)

◆ writeObj() [2/2]

void GEOM_FADE2D::Fade_2D::writeObj ( const std::string &  filename,
Zone2 pZone 
) const

Makes most sense in 2.5D but works also for 2D (all heights are set to zero then)

◆ writeWebScene() [1/2]

void GEOM_FADE2D::Fade_2D::writeWebScene ( const char *  path) const

Made for terrain visualizations in 2.5D but will work also for 2D.

◆ writeWebScene() [2/2]

void GEOM_FADE2D::Fade_2D::writeWebScene ( const char *  path,
Zone2 pZone 
) const

Made for terrain visualizations in 2.5D but will work also for 2D.


The documentation for this class was generated from the following file: