MeshCore::MeshKernel Class Reference

The MeshKernel class is the basic class that holds the data points, the edges and the facets describing a mesh object. More...

#include <MeshKernel.h>

Public Member Functions

 MeshKernel (const MeshKernel &rclMesh)
 Construction. More...
 
 MeshKernel (void)
 Construction. More...
 
 ~MeshKernel (void)
 Destruction. More...
 
I/O methods
void Write (std::ostream &rclOut) const
 Binary streaming of data. More...
 
void Read (std::istream &rclIn)
 
Querying
unsigned long CountFacets (void) const
 Returns the number of facets. More...
 
unsigned long CountEdges (void) const
 Returns the number of edge. More...
 
unsigned long CountPoints (void) const
 
unsigned int GetMemSize (void) const
 Returns the number of required memory in bytes. More...
 
const Base::BoundBox3fGetBoundBox (void) const
 Determines the bounding box. More...
 
void RecalcBoundBox (void)
 Forces a recalculation of the bounding box. More...
 
MeshPoint GetPoint (unsigned long ulIndex) const
 Returns the point at the given index. More...
 
std::vector< Base::Vector3fCalcVertexNormals () const
 Returns an array of the vertex normals of the mesh. More...
 
std::vector< Base::Vector3fGetFacetNormals (const std::vector< unsigned long > &) const
 
MeshGeomFacet GetFacet (unsigned long ulIndex) const
 Returns the facet at the given index. More...
 
MeshGeomFacet GetFacet (const MeshFacet &rclFacet) const
 
void GetFacetPoints (unsigned long ulFaIndex, unsigned long &rclP0, unsigned long &rclP1, unsigned long &rclP2) const
 Returns the point indices of the given facet index. More...
 
std::vector< unsigned long > GetFacetPoints (const std::vector< unsigned long > &) const
 Returns the point indices of the given facet indices. More...
 
std::vector< unsigned long > GetPointFacets (const std::vector< unsigned long > &) const
 Returns the facet indices that share the given point indices. More...
 
void GetFacetNeighbours (unsigned long ulIndex, unsigned long &rulNIdx0, unsigned long &rulNIdx1, unsigned long &rulNIdx2) const
 Returns the indices of the neighbour facets of the given facet index. More...
 
std::vector< unsigned long > HasFacets (const MeshPointIterator &rclIter) const
 Determines all facets that are associated to this point. More...
 
bool IsValid (void) const
 Returns true if the data structure is valid. More...
 
const MeshPointArrayGetPoints (void) const
 Returns the array of all data points. More...
 
MeshPointArray GetPoints (const std::vector< unsigned long > &) const
 Returns an array of points to the given indices. More...
 
MeshPointModifier ModifyPoints ()
 Returns a modifier for the point array. More...
 
const MeshFacetArrayGetFacets (void) const
 Returns the array of all facets. More...
 
MeshFacetArray GetFacets (const std::vector< unsigned long > &) const
 Returns an array of facets to the given indices. More...
 
MeshFacetModifier ModifyFacets ()
 Returns a modifier for the facet array. More...
 
void GetEdges (std::vector< MeshGeomEdge > &) const
 Returns the array of all edges. More...
 
Evaluation
float GetSurface () const
 Calculates the surface area of the mesh object. More...
 
float GetSurface (const std::vector< unsigned long > &aSegment) const
 Calculates the surface area of the segment defined by aSegment. More...
 
float GetVolume () const
 Calculates the volume of the mesh object. More...
 
bool HasOpenEdges () const
 Checks whether the mesh has open edges. More...
 
bool HasNonManifolds () const
 Checks whether the mesh has non.manifold edges. More...
 
bool HasSelfIntersections () const
 Checks whether the mesh intersects itself. More...
 
Facet visitors

The MeshKernel class provides different methods to visit "topologic connected" facets to a given start facet.

Two facets are regarded as "topologic connected" if they share a common edge or a common point. All methods expect a MeshFacetVisitor as argument that can decide to continue or to stop. If there is no topologic neighbour facet any more being not marked as "VISIT" the algorithm stops anyway.

See also
MeshFacetVisitor, MeshOrientationVisitor, MeshSearchNeighbourFacetsVisitor and MeshTopFacetVisitor.
unsigned long VisitNeighbourFacets (MeshFacetVisitor &rclFVisitor, unsigned long ulStartFacet) const
 This method visits all neighbour facets, i.e facets that share a common edge starting from the facet associated to index ulStartFacet. More...
 
unsigned long VisitNeighbourFacetsOverCorners (MeshFacetVisitor &rclFVisitor, unsigned long ulStartFacet) const
 Does basically the same as the method above unless the facets that share just a common point are regared as neighbours. More...
 
Point visitors

The MeshKernel class provides a method to visit neighbour points to a given start point.

Two points are regarded as neighbours if they share an edge. The method expects a MeshPointVisitor as argument that can decide to continue or to stop. If there is no topologic neighbour point any more being not marked as "VISIT" the algorithm stops anyway.

unsigned long VisitNeighbourPoints (MeshPointVisitor &rclPVisitor, unsigned long ulStartPoint) const
 This method visits all neighbour points starting from the point associated to index ulStartPoint. More...
 
Iterators

The iterator methods are provided for convenience.

They return an iterator object that points to the first element in the appropriate list.

// iterate over all facets
for ( MeshFacetIterator it = mesh.FacetIterator(); it.More(); it.Next() )
...
MeshKernel(void)
Construction.
Definition: MeshKernel.cpp:50
friend class MeshFacetIterator
Definition: MeshKernel.h:454
mesh
Definition: Mesh2Shape.py:8

An iterator can also be used in the following way

// iterate over all facets
MeshFacetIterator it(mesh);
for ( it.Init(); it.More(); it.Next() )
...
MeshFacetIterator FacetIterator () const
 Returns an iterator object to go over all facets. More...
 
MeshPointIterator PointIterator () const
 Returns an iterator object to go over all points. More...
 

Modification

class MeshPointIterator
 
class MeshFacetIterator
 
class MeshFastFacetIterator
 
class MeshAlgorithm
 
class MeshTopoAlgorithm
 
class MeshFixDuplicatePoints
 
class MeshBuilder
 
class MeshTrimming
 
MeshKerneloperator+= (const MeshGeomFacet &rclSFacet)
 Adds a single facet to the data structure. More...
 
void AddFacet (const MeshGeomFacet &rclSFacet)
 Adds a single facet to the data structure. More...
 
MeshKerneloperator+= (const std::vector< MeshGeomFacet > &rclFAry)
 Adds an array of facets to the data structure. More...
 
void AddFacets (const std::vector< MeshGeomFacet > &rclFAry)
 Adds an array of facets to the data structure. More...
 
unsigned long AddFacets (const std::vector< MeshFacet > &rclFAry, bool checkManifolds)
 Adds an array of topologic facets to the data structure without inserting new points. More...
 
unsigned long AddFacets (const std::vector< MeshFacet > &rclFAry, const std::vector< Base::Vector3f > &rclPAry, bool checkManifolds)
 Adds new points and facets to the data structure. More...
 
void Merge (const MeshKernel &rKernel)
 Adds all facets and referenced points to the underlying mesh structure. More...
 
void Merge (const MeshPointArray &rPoints, const MeshFacetArray &rFaces)
 This method is provided for convenience that directly accepts the point and facet arrays. More...
 
bool DeleteFacet (const MeshFacetIterator &rclIter)
 Deletes the facet the iterator points to. More...
 
bool DeleteFacet (unsigned long ulInd)
 Does basically the same as the method above unless that the index of the facet is given. More...
 
void DeleteFacets (const std::vector< unsigned long > &raulFacets)
 Removes several facets from the data structure. More...
 
bool DeletePoint (const MeshPointIterator &rclIter)
 Deletes the point the iterator points to. More...
 
bool DeletePoint (unsigned long ulInd)
 Does basically the same as the method above unless that the index of the facet is given. More...
 
void DeletePoints (const std::vector< unsigned long > &raulPoints)
 Removes several points from the data structure. More...
 
void RemoveInvalids ()
 Removes all as INVALID marked points and facets from the structure. More...
 
void RebuildNeighbours (void)
 Rebuilds the neighbour indices for all facets. More...
 
void Cleanup ()
 Removes unreferenced points or facets with invalid indices from the mesh. More...
 
void Clear (void)
 Clears the whole data structure. More...
 
MeshKerneloperator= (const std::vector< MeshGeomFacet > &rclFAry)
 Replaces the current data structure with the structure built up of the array of triangles given in rclFAry. More...
 
MeshKerneloperator= (const MeshKernel &rclMesh)
 Assignment operator. More...
 
void Assign (const MeshPointArray &rPoints, const MeshFacetArray &rFaces, bool checkNeighbourHood=false)
 This allows to assign the mesh structure directly. More...
 
void Adopt (MeshPointArray &rPoints, MeshFacetArray &rFaces, bool checkNeighbourHood=false)
 This method does basically the same as Assign() unless that it swaps the content of both arrays. More...
 
void Swap (MeshKernel &mesh)
 Swaps the content of this kernel and mesh. More...
 
void operator*= (const Base::Matrix4D &rclMat)
 Transform the data structure with the given transformation matrix. More...
 
void Transform (const Base::Matrix4D &rclMat)
 Transform the data structure with the given transformation matrix. More...
 
void MovePoint (unsigned long ulPtIndex, const Base::Vector3f &rclTrans)
 Moves the point at the given index along the vector rclTrans. More...
 
void SetPoint (unsigned long ulPtIndex, const Base::Vector3f &rPoint)
 Sets the point at the given index to the new rPoint. More...
 
void SetPoint (unsigned long ulPtIndex, float x, float y, float z)
 Sets the point at the given index to the new rPoint. More...
 
void Smooth (int iterations, float d_max)
 Smoothes the mesh kernel. More...
 
void CutFacets (const MeshFacetGrid &rclGrid, const Base::ViewProjMethod *pclP, const Base::Polygon2d &rclPoly, bool bCutInner, std::vector< MeshGeomFacet > &raclFacets)
 CheckFacets() is invoked within this method and all found facets get deleted from the mesh structure. More...
 
void CutFacets (const MeshFacetGrid &rclGrid, const Base::ViewProjMethod *pclP, const Base::Polygon2d &rclPoly, bool bCutInner, std::vector< unsigned long > &raclCutted)
 Does basically the same as method above unless that the facets to be deleted are returned with their index number in the facet array of the mesh structure. More...
 
void RebuildNeighbours (unsigned long)
 Rebuilds the neighbour indices for subset of all facets from index index on. More...
 
void ErasePoint (unsigned long ulIndex, unsigned long ulFacetIndex, bool bOnlySetInvalid=false)
 Checks if this point is associated to no other facet and deletes if so. More...
 
void AdjustNormal (MeshFacet &rclFacet, const Base::Vector3f &rclNormal)
 Adjusts the facet's orierntation to the given normal direction. More...
 
Base::Vector3f GetNormal (const MeshFacet &rclFacet) const
 Calculates the normal to the given facet. More...
 
Base::Vector3f GetGravityPoint (const MeshFacet &rclFacet) const
 Calculates the gravity point to the given facet. More...
 

Detailed Description

The MeshKernel class is the basic class that holds the data points, the edges and the facets describing a mesh object.

The bounding box is calculated during the buildup of the data structure and gets only re-caclulated after insertion of new facets but not after removal of facets.

This class provides only some rudimental querying methods.

Constructor & Destructor Documentation

◆ MeshKernel() [1/2]

MeshKernel::MeshKernel ( void  )

Construction.

◆ MeshKernel() [2/2]

MeshKernel::MeshKernel ( const MeshKernel rclMesh)

Construction.

◆ ~MeshKernel()

MeshCore::MeshKernel::~MeshKernel ( void  )

Destruction.

Member Function Documentation

◆ AddFacet()

void MeshKernel::AddFacet ( const MeshGeomFacet rclSFacet)

Adds a single facet to the data structure.

This method is very slow and should be called occasionally only. This does the same as the += operator above.

References AdjustNormal(), and MeshCore::MeshGeomFacet::GetNormal().

Referenced by operator+=().

◆ AddFacets() [1/3]

unsigned long MeshKernel::AddFacets ( const std::vector< MeshFacet > &  rclFAry,
bool  checkManifolds 
)

Adds an array of topologic facets to the data structure without inserting new points.

Facets which would create non-manifolds are not inserted. The client programmer must make sure that the referenced point indices are correct and that no geometric overlaps can be created. The method returns the total number of facets. This method might be useful to close gaps or fill up holes in a mesh.

Note
This method is quite expensive and should be rarely used.

References CountFacets(), CountPoints(), MeshCore::MeshPoint::INVALID, MeshCore::MeshFacet::INVALID, and RebuildNeighbours().

◆ AddFacets() [2/3]

unsigned long MeshKernel::AddFacets ( const std::vector< MeshFacet > &  rclFAry,
const std::vector< Base::Vector3f > &  rclPAry,
bool  checkManifolds 
)

Adds new points and facets to the data structure.

The client programmer must make sure that all new points are referenced by the new facets. All points in rclPAry get copied at the end of the internal point array to keep their order. The point indices of the facets must be related to the internal point array, not the passed array rclPAry.

Example: We have a mesh with p points and f facets where we want append new points and facets to. Let's assume that the first facet of rclFAry references the 1st, 2nd and 3rd points of rclPAry then its indices must be p, p+1, p+2 – not 0,1,2. This is due to the fact that facets of rclFAry can also reference point indices of the internal point array.

Note
This method is quite expensive and should be rarely used.

References AddFacets().

◆ AddFacets() [3/3]

void MeshKernel::AddFacets ( const std::vector< MeshGeomFacet > &  rclFAry)

Adds an array of facets to the data structure.

This method keeps temporarily set properties and flags. This does the same as the += operator above.

References Merge().

Referenced by AddFacets(), MeshPart::CurveProjectorWithToolMesh::Do(), MeshPart::MeshAlgos::LoftOnCurve(), and operator+=().

◆ AdjustNormal()

void MeshCore::MeshKernel::AdjustNormal ( MeshFacet rclFacet,
const Base::Vector3f rclNormal 
)
protected

Adjusts the facet's orierntation to the given normal direction.

References MeshCore::MeshFacet::FlipNormal().

Referenced by AddFacet().

◆ Adopt()

void MeshKernel::Adopt ( MeshPointArray rPoints,
MeshFacetArray rFaces,
bool  checkNeighbourHood = false 
)

This method does basically the same as Assign() unless that it swaps the content of both arrays.

These arrays may be empty after assigning to the kernel. This method is a convenient way to build up the mesh structure from outside and assign to a mesh kernel without copying the data. Especially for huge meshes this saves memory and increases speed.

References RebuildNeighbours(), and RecalcBoundBox().

Referenced by MeshPart::Mesher::createMesh(), MeshGui::SoFCMeshNode::readInstance(), Mesh::PropertyMeshKernel::Restore(), and MeshCore::MeshSimplify::simplify().

◆ Assign()

void MeshKernel::Assign ( const MeshPointArray rPoints,
const MeshFacetArray rFaces,
bool  checkNeighbourHood = false 
)

This allows to assign the mesh structure directly.

The caller must make sure that the point indices are correctly set but the neighbourhood gets checked and corrected if checkNeighbourHood is true.

References RebuildNeighbours(), and RecalcBoundBox().

◆ CalcVertexNormals()

std::vector< Base::Vector3f > MeshKernel::CalcVertexNormals ( ) const

Returns an array of the vertex normals of the mesh.

A vertex normal gets calculated by summarizing the normals of the associated facets.

References CountFacets(), CountPoints(), GetFacetPoints(), and GetPoint().

◆ Cleanup()

void MeshKernel::Cleanup ( )

Removes unreferenced points or facets with invalid indices from the mesh.

References MeshCore::MeshCleanup::RemoveInvalids().

◆ Clear()

void MeshKernel::Clear ( void  )

Clears the whole data structure.

◆ CountEdges()

unsigned long MeshKernel::CountEdges ( void  ) const

◆ CountFacets()

◆ CountPoints()

◆ CutFacets() [1/2]

void MeshKernel::CutFacets ( const MeshFacetGrid rclGrid,
const Base::ViewProjMethod pclP,
const Base::Polygon2d rclPoly,
bool  bCutInner,
std::vector< MeshGeomFacet > &  raclFacets 
)

CheckFacets() is invoked within this method and all found facets get deleted from the mesh structure.

The facets to be deleted are returned with their geometric representation.

See also
CheckFacets().

References DeleteFacets(), GetFacet(), and MeshAlgorithm.

◆ CutFacets() [2/2]

void MeshKernel::CutFacets ( const MeshFacetGrid rclGrid,
const Base::ViewProjMethod pclP,
const Base::Polygon2d rclPoly,
bool  bCutInner,
std::vector< unsigned long > &  raclCutted 
)

Does basically the same as method above unless that the facets to be deleted are returned with their index number in the facet array of the mesh structure.

References DeleteFacets(), and MeshAlgorithm.

◆ DeleteFacet() [1/2]

bool MeshKernel::DeleteFacet ( const MeshFacetIterator rclIter)

Deletes the facet the iterator points to.

The deletion of a facet requires the following steps:

  • Mark the neighbour index of all neighbour facets to the deleted facet as invalid
  • Adjust the indices of the neighbour facets of all facets.
  • If there is no neighbour facet check if the points can be deleted. True is returned if the facet could be deleted.
    Note
    This method is very slow and should only be called occasionally.
    After deletion of the facet rclIter becomes invalid and must not be used before setting to a new position.

References ErasePoint(), and MeshCore::MeshFacetIterator::Position().

Referenced by DeleteFacet(), and DeletePoint().

◆ DeleteFacet() [2/2]

bool MeshKernel::DeleteFacet ( unsigned long  ulInd)

Does basically the same as the method above unless that the index of the facet is given.

References DeleteFacet(), and MeshCore::MeshFacetIterator::Set().

◆ DeleteFacets()

void MeshKernel::DeleteFacets ( const std::vector< unsigned long > &  raulFacets)

Removes several facets from the data structure.

Note
This method overwrites the free usable property of each mesh point.
This method also removes points from the structure that are no longer referenced by the facets.
This method is very slow and should only be called occasionally.

References RecalcBoundBox(), RemoveInvalids(), and MeshCore::MeshFacet::SetInvalid().

Referenced by CutFacets().

◆ DeletePoint() [1/2]

bool MeshKernel::DeletePoint ( const MeshPointIterator rclIter)

Deletes the point the iterator points to.

The deletion of a point requires the following step:

  • Find all associated facets to this point.
  • Delete these facets. True is returned if the point could be deleted.
    Note
    This method is very slow and should only be called occasionally.
    After deletion of the point rclIter becomes invalid and must not be used before setting to a new position.

References MeshCore::MeshPointIterator::Begin(), DeleteFacet(), and MeshCore::MeshFacetIterator::End().

Referenced by DeletePoint().

◆ DeletePoint() [2/2]

bool MeshKernel::DeletePoint ( unsigned long  ulInd)

Does basically the same as the method above unless that the index of the facet is given.

References DeletePoint(), and MeshCore::MeshPointIterator::Set().

◆ DeletePoints()

void MeshKernel::DeletePoints ( const std::vector< unsigned long > &  raulPoints)

Removes several points from the data structure.

Note
This method overwrites the free usable property of each mesh point.

References MeshCore::MeshPoint::IsValid(), RecalcBoundBox(), RemoveInvalids(), and MeshCore::MeshPoint::SetInvalid().

◆ ErasePoint()

void MeshKernel::ErasePoint ( unsigned long  ulIndex,
unsigned long  ulFacetIndex,
bool  bOnlySetInvalid = false 
)
protected

Checks if this point is associated to no other facet and deletes if so.

The point indices of the facets get adjusted. ulIndex is the index of the point to be deleted. ulFacetIndex is the index of the quasi deleted facet and is ignored. If bOnlySetInvalid is true the point doesn't get deleted but marked as invalid.

Referenced by DeleteFacet().

◆ FacetIterator()

MeshFacetIterator MeshKernel::FacetIterator ( ) const

Returns an iterator object to go over all facets.

References MeshCore::MeshFacetIterator::Begin().

◆ GetBoundBox()

const Base::BoundBox3f& MeshCore::MeshKernel::GetBoundBox ( void  ) const

◆ GetEdges()

void MeshKernel::GetEdges ( std::vector< MeshGeomEdge > &  edges) const

Returns the array of all edges.

Notice: The Edgelist will be temporary generated. Changes on the mesh structure does not affect the Edgelist

◆ GetFacet() [1/2]

MeshGeomFacet MeshCore::MeshKernel::GetFacet ( const MeshFacet rclFacet) const

◆ GetFacet() [2/2]

◆ GetFacetNeighbours()

void MeshCore::MeshKernel::GetFacetNeighbours ( unsigned long  ulIndex,
unsigned long &  rulNIdx0,
unsigned long &  rulNIdx1,
unsigned long &  rulNIdx2 
) const

Returns the indices of the neighbour facets of the given facet index.

◆ GetFacetNormals()

std::vector< Base::Vector3f > MeshKernel::GetFacetNormals ( const std::vector< unsigned long > &  facets) const

◆ GetFacetPoints() [1/2]

std::vector< unsigned long > MeshKernel::GetFacetPoints ( const std::vector< unsigned long > &  facets) const

Returns the point indices of the given facet indices.

References GetFacetPoints().

◆ GetFacetPoints() [2/2]

void MeshCore::MeshKernel::GetFacetPoints ( unsigned long  ulFaIndex,
unsigned long &  rclP0,
unsigned long &  rclP1,
unsigned long &  rclP2 
) const

◆ GetFacets() [1/2]

MeshFacetArray MeshKernel::GetFacets ( const std::vector< unsigned long > &  indices) const

Returns an array of facets to the given indices.

The indices must not be out of range.

◆ GetFacets() [2/2]

◆ GetGravityPoint()

Base::Vector3f MeshCore::MeshKernel::GetGravityPoint ( const MeshFacet rclFacet) const
protected

Calculates the gravity point to the given facet.

References Base::Vector3< _Precision >::x, Base::Vector3< _Precision >::y, and Base::Vector3< _Precision >::z.

◆ GetMemSize()

unsigned int MeshCore::MeshKernel::GetMemSize ( void  ) const

Returns the number of required memory in bytes.

◆ GetNormal()

Base::Vector3f MeshCore::MeshKernel::GetNormal ( const MeshFacet rclFacet) const
protected

Calculates the normal to the given facet.

References Base::Vector3< _Precision >::Normalize().

◆ GetPoint()

MeshPoint MeshCore::MeshKernel::GetPoint ( unsigned long  ulIndex) const

Returns the point at the given index.

This method is rather slow and should be called occasionally only. For fast access the MeshPointIterator interfsce should be used.

Referenced by CalcVertexNormals().

◆ GetPointFacets()

std::vector< unsigned long > MeshKernel::GetPointFacets ( const std::vector< unsigned long > &  points) const

Returns the facet indices that share the given point indices.

References MeshCore::MeshPoint::IsFlag(), MeshAlgorithm, MeshCore::MeshPoint::SetFlag(), MeshCore::MeshPoint::TMP0, and MeshCore::MeshFacet::TMP0.

◆ GetPoints() [1/2]

MeshPointArray MeshKernel::GetPoints ( const std::vector< unsigned long > &  indices) const

Returns an array of points to the given indices.

The indices must not be out of range.

◆ GetPoints() [2/2]

◆ GetSurface() [1/2]

float MeshKernel::GetSurface ( ) const

◆ GetSurface() [2/2]

float MeshKernel::GetSurface ( const std::vector< unsigned long > &  aSegment) const

Calculates the surface area of the segment defined by aSegment.

References MeshCore::MeshGeomFacet::Area(), and MeshCore::MeshFacetIterator::Set().

◆ GetVolume()

float MeshKernel::GetVolume ( ) const

◆ HasFacets()

std::vector< unsigned long > MeshKernel::HasFacets ( const MeshPointIterator rclIter) const

Determines all facets that are associated to this point.

This method is very slow and should be called occasionally only.

References MeshCore::MeshPointIterator::Position().

◆ HasNonManifolds()

bool MeshKernel::HasNonManifolds ( ) const

Checks whether the mesh has non.manifold edges.

An edge is regarded as non-manifolds if it shares more than two facets.

References MeshCore::MeshEvalTopology::Evaluate().

◆ HasOpenEdges()

bool MeshKernel::HasOpenEdges ( ) const

Checks whether the mesh has open edges.

References MeshCore::MeshEvalSolid::Evaluate().

◆ HasSelfIntersections()

bool MeshKernel::HasSelfIntersections ( ) const

Checks whether the mesh intersects itself.

References MeshCore::MeshEvalSelfIntersection::Evaluate().

◆ IsValid()

bool MeshCore::MeshKernel::IsValid ( void  ) const

Returns true if the data structure is valid.

Referenced by RemoveInvalids().

◆ Merge() [1/2]

void MeshKernel::Merge ( const MeshKernel rKernel)

Adds all facets and referenced points to the underlying mesh structure.

The client programmer must be sure that both meshes don't have geometric overlaps, otherwise the resulting mesh might be invalid, i.e. has self-intersections.

Note
The method guarantees that the order of the arrays of the underlying mesh and of the given array is kept.
Not all points of rKernel are necessarily appended to the underlying mesh but only these points which are referenced by facets of rKernel.

Referenced by AddFacets(), and Mesh::MeshObject::meshFromSegment().

◆ Merge() [2/2]

void MeshKernel::Merge ( const MeshPointArray rPoints,
const MeshFacetArray rFaces 
)

This method is provided for convenience that directly accepts the point and facet arrays.

Note
Not all points of rPoints are necessarily appended to the underlying mesh but only these points which are referenced by facets of rFaces.

References RebuildNeighbours().

◆ ModifyFacets()

MeshFacetModifier MeshCore::MeshKernel::ModifyFacets ( )

Returns a modifier for the facet array.

◆ ModifyPoints()

MeshPointModifier MeshCore::MeshKernel::ModifyPoints ( )

Returns a modifier for the point array.

◆ MovePoint()

void MeshCore::MeshKernel::MovePoint ( unsigned long  ulPtIndex,
const Base::Vector3f rclTrans 
)

Moves the point at the given index along the vector rclTrans.

◆ operator*=()

void MeshKernel::operator*= ( const Base::Matrix4D rclMat)

Transform the data structure with the given transformation matrix.

References Transform().

◆ operator+=() [1/2]

MeshKernel & MeshKernel::operator+= ( const MeshGeomFacet rclSFacet)

Adds a single facet to the data structure.

This method is very slow and should be called occasionally only.

References AddFacet().

◆ operator+=() [2/2]

MeshKernel & MeshKernel::operator+= ( const std::vector< MeshGeomFacet > &  rclFAry)

Adds an array of facets to the data structure.

This method keeps temporarily set properties and flags.

References AddFacets().

◆ operator=() [1/2]

MeshKernel & MeshKernel::operator= ( const MeshKernel rclMesh)

Assignment operator.

◆ operator=() [2/2]

MeshKernel & MeshKernel::operator= ( const std::vector< MeshGeomFacet > &  rclFAry)

Replaces the current data structure with the structure built up of the array of triangles given in rclFAry.

References MeshCore::MeshBuilder::AddFacet(), MeshCore::MeshBuilder::Finish(), and MeshCore::MeshBuilder::Initialize().

◆ PointIterator()

MeshPointIterator MeshKernel::PointIterator ( ) const

Returns an iterator object to go over all points.

References MeshCore::MeshPointIterator::Begin().

◆ Read()

void MeshKernel::Read ( std::istream &  rclIn)

◆ RebuildNeighbours() [1/2]

void MeshKernel::RebuildNeighbours ( unsigned long  index)
protected

Rebuilds the neighbour indices for subset of all facets from index index on.

References MeshCore::Edge_Index::f, MeshCore::Edge_Index::p0, MeshCore::Edge_Index::p1, MeshCore::parallel_sort(), and MeshCore::MeshFacet::Side().

◆ RebuildNeighbours() [2/2]

void MeshKernel::RebuildNeighbours ( void  )

Rebuilds the neighbour indices for all facets.

Referenced by AddFacets(), Adopt(), Assign(), Merge(), and Mesh::MeshPy::rebuildNeighbourHood().

◆ RecalcBoundBox()

void MeshKernel::RecalcBoundBox ( void  )

Forces a recalculation of the bounding box.

This method should be called after the removal of points.or after a transformation of the data structure.

Referenced by Adopt(), Assign(), DeleteFacets(), and DeletePoints().

◆ RemoveInvalids()

void MeshKernel::RemoveInvalids ( )

Removes all as INVALID marked points and facets from the structure.

References IsValid().

Referenced by DeleteFacets(), and DeletePoints().

◆ SetPoint() [1/2]

void MeshCore::MeshKernel::SetPoint ( unsigned long  ulPtIndex,
const Base::Vector3f rPoint 
)

◆ SetPoint() [2/2]

void MeshCore::MeshKernel::SetPoint ( unsigned long  ulPtIndex,
float  x,
float  y,
float  z 
)

Sets the point at the given index to the new rPoint.

◆ Smooth()

void MeshKernel::Smooth ( int  iterations,
float  d_max 
)

Smoothes the mesh kernel.

References MeshCore::LaplaceSmoothing::Smooth().

◆ Swap()

void MeshKernel::Swap ( MeshKernel mesh)

Swaps the content of this kernel and mesh.

◆ Transform()

◆ VisitNeighbourFacets()

unsigned long MeshKernel::VisitNeighbourFacets ( MeshFacetVisitor rclFVisitor,
unsigned long  ulStartFacet 
) const

This method visits all neighbour facets, i.e facets that share a common edge starting from the facet associated to index ulStartFacet.

All facets having set the VISIT flag are ignored. Therefore the user have to set or unset this flag if needed. All facets that get visited during this algorithm are marked as VISIT and the Visit() method of the given MeshFacetVisitor gets invoked. If there are no unvisited neighbours any more the algorithms returns immediately and returns the number of visited facets.

Note
For the start facet ulStartFacet MeshFacetVisitor::Visit() does not get invoked though the facet gets marked as VISIT.

References MeshCore::MeshFacetVisitor::AllowVisit(), MeshCore::MeshFacet::VISIT, and MeshCore::MeshFacetVisitor::Visit().

Referenced by MeshGui::ViewProviderMesh::deselectComponent(), Mesh::SegmentByMesh::execute(), MeshCore::MeshSegmentAlgorithm::FindSegments(), and MeshGui::ViewProviderMesh::selectComponent().

◆ VisitNeighbourFacetsOverCorners()

unsigned long MeshKernel::VisitNeighbourFacetsOverCorners ( MeshFacetVisitor rclFVisitor,
unsigned long  ulStartFacet 
) const

Does basically the same as the method above unless the facets that share just a common point are regared as neighbours.

References MeshCore::MeshFacetArray::SetFlag(), MeshCore::MeshFacet::VISIT, and MeshCore::MeshFacetVisitor::Visit().

◆ VisitNeighbourPoints()

unsigned long MeshKernel::VisitNeighbourPoints ( MeshPointVisitor rclPVisitor,
unsigned long  ulStartPoint 
) const

This method visits all neighbour points starting from the point associated to index ulStartPoint.

All points having set the VISIT flag are ignored. Therefore the user have to set or unset this flag if needed before the algorithm starts. All points that get visited during this algorithm are marked as VISIT and the Visit() method of the given MeshPointVisitor gets invoked. If there are no unvisited neighbours any more the algorithms returns immediately and returns the number of visited points.

Note
For the start facet ulStartPoint MeshPointVisitor::Visit() does not get invoked though the point gets marked as VISIT.

References MeshCore::MeshPoint::VISIT, and MeshCore::MeshPointVisitor::Visit().

◆ Write()

void MeshKernel::Write ( std::ostream &  rclOut) const

Binary streaming of data.

References CountFacets(), and CountPoints().

Friends And Related Function Documentation

◆ MeshAlgorithm

friend class MeshAlgorithm
friend

Referenced by CutFacets(), and GetPointFacets().

◆ MeshBuilder

friend class MeshBuilder
friend

◆ MeshFacetIterator

friend class MeshFacetIterator
friend

◆ MeshFastFacetIterator

friend class MeshFastFacetIterator
friend

◆ MeshFixDuplicatePoints

friend class MeshFixDuplicatePoints
friend

◆ MeshPointIterator

friend class MeshPointIterator
friend

◆ MeshTopoAlgorithm

friend class MeshTopoAlgorithm
friend

◆ MeshTrimming

friend class MeshTrimming
friend

The documentation for this class was generated from the following files:
  • Sources/FreeCAD/src/Mod/Mesh/App/Core/MeshKernel.h
  • Sources/FreeCAD/src/Mod/Mesh/App/Core/Evaluation.cpp
  • Sources/FreeCAD/src/Mod/Mesh/App/Core/MeshKernel.cpp
  • Sources/FreeCAD/src/Mod/Mesh/App/Core/Visitor.cpp