SMESH_Pattern Class Reference

#include <SMESH_Pattern.hxx>

Data Structures
struct	TPoint

Public Types
enum	ErrorCode {   ERR_OK , ERR_READ_NB_POINTS , ERR_READ_POINT_COORDS , ERR_READ_TOO_FEW_POINTS ,   ERR_READ_3D_COORD , ERR_READ_NO_KEYPOINT , ERR_READ_BAD_INDEX , ERR_READ_ELEM_POINTS ,   ERR_READ_NO_ELEMS , ERR_READ_BAD_KEY_POINT , ERR_SAVE_NOT_LOADED , ERR_LOAD_EMPTY_SUBMESH ,   ERR_LOADF_NARROW_FACE , ERR_LOADF_CLOSED_FACE , ERR_LOADF_CANT_PROJECT , ERR_LOADV_BAD_SHAPE ,   ERR_LOADV_COMPUTE_PARAMS , ERR_APPL_NOT_COMPUTED , ERR_APPL_NOT_LOADED , ERR_APPL_BAD_DIMENTION ,   ERR_APPL_BAD_NB_VERTICES , ERR_APPLF_BAD_TOPOLOGY , ERR_APPLF_BAD_VERTEX , ERR_APPLF_INTERNAL_EEROR ,   ERR_APPLV_BAD_SHAPE , ERR_APPLF_BAD_FACE_GEOM , ERR_MAKEM_NOT_COMPUTED , ERR_UNEXPECTED }

Public Member Functions
	SMESH_Pattern ()
void	Clear ()
bool	Load (const char *theFileContents)
bool	Load (SMESH_Mesh *theMesh, const TopoDS_Face &theFace, bool theProject=false, TopoDS_Vertex the1stVertex=TopoDS_Vertex(), bool theKeepNodes=false)
bool	Load (SMESH_Mesh *theMesh, const TopoDS_Shell &theBlock, bool theKeepNodes=false)
bool	Save (std::ostream &theFile)
bool	Apply (const TopoDS_Face &theFace, const TopoDS_Vertex &theVertexOnKeyPoint1, const bool theReverse)
bool	Apply (const TopoDS_Shell &theBlock, const TopoDS_Vertex &theVertex000, const TopoDS_Vertex &theVertex001)
bool	Apply (const SMDS_MeshFace *theFace, const int theNodeIndexOnKeyPoint1, const bool theReverse)
bool	Apply (SMESH_Mesh *theMesh, const SMDS_MeshFace *theFace, const TopoDS_Shape &theSurface, const int theNodeIndexOnKeyPoint1, const bool theReverse)
bool	Apply (SMESH_Mesh *theMesh, std::set< const SMDS_MeshFace * > &theFaces, const int theNodeIndexOnKeyPoint1, const bool theReverse)
bool	Apply (const SMDS_MeshVolume *theVolume, const int theNode000Index, const int theNode001Index)
bool	Apply (std::set< const SMDS_MeshVolume * > &theVolumes, const int theNode000Index, const int theNode001Index)
bool	GetMappedPoints (std::list< const gp_XYZ * > &thePoints) const
bool	MakeMesh (SMESH_Mesh *theMesh, const bool toCreatePolygons=false, const bool toCreatePolyedrs=false)
ErrorCode	GetErrorCode () const
bool	IsLoaded () const
bool	Is2D () const
bool	GetPoints (std::list< const gp_XYZ * > &thePoints) const
const std::list< int > &	GetKeyPointIDs () const
const std::list< std::list< int > > &	GetElementPointIDs (bool applied) const
void	GetInOutNodes (std::vector< const SMDS_MeshNode * > *&inNodes, std::vector< const SMDS_MeshNode * > *&outNodes)
void	DumpPoints () const
TopoDS_Shape	GetSubShape (const int i) const

Private Types
typedef std::list< std::list< TopoDS_Edge > >	TListOfEdgesList
typedef std::set< const SMDS_MeshNode * >	TNodeSet
typedef std::list< int >	TElemDef

Private Member Functions
bool	setErrorCode (const ErrorCode theErrorCode)
	set ErrorCode and return true if it is Ok More...
bool	setShapeToMesh (const TopoDS_Shape &theShape)
std::list< TPoint * > &	getShapePoints (const TopoDS_Shape &theShape)
std::list< TPoint * > &	getShapePoints (const int theShapeID)
bool	findBoundaryPoints ()
void	arrangeBoundaries (std::list< std::list< TPoint * > > &boundaryPoints)
void	computeUVOnEdge (const TopoDS_Edge &theEdge, const std::list< TPoint * > &ePoints)
bool	compUVByIsoIntersection (const std::list< std::list< TPoint * > > &boundaryPoints, const gp_XY &theInitUV, gp_XY &theUV, bool &theIsDeformed)
bool	compUVByElasticIsolines (const std::list< std::list< TPoint * > > &boundaryPoints, const std::list< TPoint * > &pointsToCompute)
double	setFirstEdge (std::list< TopoDS_Edge > &theWire, int theFirstEdgeID)
bool	sortSameSizeWires (TListOfEdgesList &theWireList, const TListOfEdgesList::iterator &theFromWire, const TListOfEdgesList::iterator &theToWire, const int theFirstEdgeID, std::list< std::list< TPoint * > > &theEdgesPointsList)
void	mergePoints (const bool uniteGroups)
void	makePolyElements (const std::vector< const SMDS_MeshNode * > &theNodes, const bool toCreatePolygons, const bool toCreatePolyedrs)
void	createElements (SMESH_Mesh *theMesh, const std::vector< const SMDS_MeshNode * > &theNodesVector, const std::list< std::list< int > > &theElemNodeIDs, const std::vector< const SMDS_MeshElement * > &theElements)
bool	getFacesDefinition (const SMDS_MeshNode **theBndNodes, const int theNbBndNodes, const std::vector< const SMDS_MeshNode * > &theNodes, std::list< int > &theFaceDefs, std::vector< int > &theQuantity)
bool	isReversed (const SMDS_MeshNode *theFirstNode, const std::list< int > &theIdsList) const
void	clearMesh (SMESH_Mesh *theMesh) const
bool	findExistingNodes (SMESH_Mesh *mesh, const TopoDS_Shape &S, const std::list< TPoint * > &points, std::vector< const SMDS_MeshNode * > &nodes)

Static Private Member Functions
static SMESHDS_SubMesh *	getSubmeshWithElements (SMESH_Mesh *theMesh, const TopoDS_Shape &theShape)

Private Attributes
bool	myIs2D
std::vector< TPoint >	myPoints
std::list< int >	myKeyPointIDs
std::list< TElemDef >	myElemPointIDs
ErrorCode	myErrorCode
bool	myIsComputed
bool	myIsBoundaryPointsFound
TopoDS_Shape	myShape
TopTools_IndexedMapOfOrientedShape	myShapeIDMap
std::map< int, std::list< TPoint * > >	myShapeIDToPointsMap
std::list< int >	myNbKeyPntInBoundary
bool	myToKeepNodes
std::vector< const SMDS_MeshNode * >	myInNodes
std::vector< const SMDS_MeshNode * >	myOutNodes
std::vector< gp_XYZ >	myXYZ
std::list< TElemDef >	myElemXYZIDs
std::map< int, const SMDS_MeshNode * >	myXYZIdToNodeMap
std::vector< const SMDS_MeshElement * >	myElements
std::vector< const SMDS_MeshNode * >	myOrderedNodes
std::vector< const SMDS_MeshElement * >	myPolyElems
std::list< TElemDef >	myPolyElemXYZIDs
std::list< std::vector< int > >	myPolyhedronQuantities
std::map< TNodeSet, std::list< std::list< int > > >	myIdsOnBoundary
std::map< int, std::list< TElemDef * > >	myReverseConnectivity

Friends
std::ostream &	operator<< (std::ostream &OS, const TPoint &p)

Member Typedef Documentation

TElemDef

typedef std::list< int > SMESH_Pattern::TElemDef

private

TListOfEdgesList

typedef std::list< std::list< TopoDS_Edge > > SMESH_Pattern::TListOfEdgesList

private

TNodeSet

typedef std::set<const SMDS_MeshNode*> SMESH_Pattern::TNodeSet

private

Member Enumeration Documentation

ErrorCode

enum SMESH_Pattern::ErrorCode

Enumerator
ERR_OK
ERR_READ_NB_POINTS
ERR_READ_POINT_COORDS
ERR_READ_TOO_FEW_POINTS
ERR_READ_3D_COORD
ERR_READ_NO_KEYPOINT
ERR_READ_BAD_INDEX
ERR_READ_ELEM_POINTS
ERR_READ_NO_ELEMS
ERR_READ_BAD_KEY_POINT
ERR_SAVE_NOT_LOADED
ERR_LOAD_EMPTY_SUBMESH
ERR_LOADF_NARROW_FACE
ERR_LOADF_CLOSED_FACE
ERR_LOADF_CANT_PROJECT
ERR_LOADV_BAD_SHAPE
ERR_LOADV_COMPUTE_PARAMS
ERR_APPL_NOT_COMPUTED
ERR_APPL_NOT_LOADED
ERR_APPL_BAD_DIMENTION
ERR_APPL_BAD_NB_VERTICES
ERR_APPLF_BAD_TOPOLOGY
ERR_APPLF_BAD_VERTEX
ERR_APPLF_INTERNAL_EEROR
ERR_APPLV_BAD_SHAPE
ERR_APPLF_BAD_FACE_GEOM
ERR_MAKEM_NOT_COMPUTED
ERR_UNEXPECTED

Constructor & Destructor Documentation

SMESH_Pattern()

SMESH_Pattern::SMESH_Pattern

(

)

Member Function Documentation

Apply() [1/7]

bool SMESH_Pattern::Apply	(	const SMDS_MeshFace *	theFace,
		const int	theNodeIndexOnKeyPoint1,
		const bool	theReverse
	)

References compUVByElasticIsolines(), compUVByIsoIntersection(), ERR_APPL_BAD_NB_VERTICES, ERR_APPL_NOT_LOADED, ERR_APPLF_BAD_FACE_GEOM, ERR_OK, findBoundaryPoints(), getShapePoints(), IsLoaded(), MESSAGE, SMESH_Pattern::TPoint::myInitU, myIsComputed, myKeyPointIDs, myNbKeyPntInBoundary, myOrderedNodes, SMESH_Pattern::TPoint::myUV, SMESH_Pattern::TPoint::myXYZ, SMDS_MeshCell::NbCornerNodes(), SMDS_MeshCell::nodeIterator(), and setErrorCode().

Apply() [2/7]

bool SMESH_Pattern::Apply	(	const SMDS_MeshVolume *	theVolume,
		const int	theNode000Index,
		const int	theNode001Index
	)

References SMESH_Block::EdgePoint(), ERR_APPLV_BAD_SHAPE, ERR_OK, SMESH_Block::FacePoint(), findBoundaryPoints(), getShapePoints(), SMESH_Block::ID_Shell, SMESH_Block::ID_V000, SMESH_Block::IsEdgeID(), SMESH_Block::IsFaceID(), SMESH_Block::IsVertexID(), SMESH_Block::LoadMeshBlock(), myIsComputed, myOrderedNodes, setErrorCode(), SMESH_Block::ShellPoint(), and SMESH_Block::VertexPoint().

Apply() [3/7]

bool SMESH_Pattern::Apply	(	const TopoDS_Face &	theFace,
		const TopoDS_Vertex &	theVertexOnKeyPoint1,
		const bool	theReverse
	)

References computeUVOnEdge(), compUVByElasticIsolines(), compUVByIsoIntersection(), ERR_APPL_BAD_NB_VERTICES, ERR_APPLF_BAD_VERTEX, ERR_APPLF_INTERNAL_EEROR, ERR_OK, Face, findBoundaryPoints(), SMESH_Block::GetOrderedEdges(), getShapePoints(), Handle(), MESSAGE, SMESH_Pattern::TPoint::myInitUV, myIsComputed, myNbKeyPntInBoundary, myShapeIDMap, myShapeIDToPointsMap, SMESH_Pattern::TPoint::myU, SMESH_Pattern::TPoint::myUV, SMESH_Pattern::TPoint::myXYZ, setErrorCode(), setFirstEdge(), setShapeToMesh(), and sortSameSizeWires().

Referenced by Apply(), SMESH_Pattern_i::ApplyTo3DBlock(), SMESH_Pattern_i::ApplyToFace(), SMESH_Pattern_i::ApplyToHexahedrons(), SMESH_Pattern_i::ApplyToMeshFaces(), and StdMeshers_Projection_2D::Compute().

Apply() [4/7]

bool SMESH_Pattern::Apply	(	const TopoDS_Shell &	theBlock,
		const TopoDS_Vertex &	theVertex000,
		const TopoDS_Vertex &	theVertex001
	)

References SMESH_Block::EdgePoint(), ERR_APPLV_BAD_SHAPE, ERR_OK, SMESH_Block::FacePoint(), findBoundaryPoints(), getShapePoints(), SMESH_Block::LoadBlockShapes(), myIsComputed, myShapeIDMap, setErrorCode(), setShapeToMesh(), SMESH_Block::ShellPoint(), and SMESH_Block::VertexPoint().

Apply() [5/7]

bool SMESH_Pattern::Apply	(	SMESH_Mesh *	theMesh,
		const SMDS_MeshFace *	theFace,
		const TopoDS_Shape &	theSurface,
		const int	theNodeIndexOnKeyPoint1,
		const bool	theReverse
	)

References Apply(), compUVByElasticIsolines(), compUVByIsoIntersection(), ERR_APPL_BAD_NB_VERTICES, ERR_APPL_NOT_LOADED, ERR_OK, Face, findBoundaryPoints(), SMESH_MeshEditor::FindShape(), SMESH_MesherHelper::GetNodeUV(), SMESH_MesherHelper::GetNodeUVneedInFaceNode(), getShapePoints(), Handle(), IsLoaded(), SMESH_MesherHelper::IsSeamShape(), MESSAGE, SMESH_Pattern::TPoint::myInitU, myIsComputed, myKeyPointIDs, myNbKeyPntInBoundary, myOrderedNodes, SMESH_Pattern::TPoint::myUV, SMESH_Pattern::TPoint::myXYZ, SMDS_MeshCell::NbNodes(), SMDS_MeshCell::nodesIterator(), setErrorCode(), SMESH_MesherHelper::SetSubShape(), and smdsNode.

Apply() [6/7]

bool SMESH_Pattern::Apply	(	SMESH_Mesh *	theMesh,
		std::set< const SMDS_MeshFace * > &	theFaces,
		const int	theNodeIndexOnKeyPoint1,
		const bool	theReverse
	)

References Apply(), ERR_APPL_BAD_NB_VERTICES, ERR_APPL_NOT_LOADED, findBoundaryPoints(), getShapePoints(), IsLoaded(), MESSAGE, myElements, myElemPointIDs, myElemXYZIDs, myIdsOnBoundary, myNbKeyPntInBoundary, myOrderedNodes, myPoints, myReverseConnectivity, myShape, myXYZ, myXYZIdToNodeMap, setErrorCode(), and undefinedXYZ().

Apply() [7/7]

bool SMESH_Pattern::Apply	(	std::set< const SMDS_MeshVolume * > &	theVolumes,
		const int	theNode000Index,
		const int	theNode001Index
	)

References Apply(), ERR_APPL_BAD_NB_VERTICES, ERR_APPL_NOT_LOADED, findBoundaryPoints(), SMESH_Block::GetEdgeVertexIDs(), SMESH_Block::GetFaceEdgesIDs(), getShapePoints(), SMESH_Block::ID_F1yz, SMESH_Block::ID_V000, SMESH_Block::IsEdgeID(), IsLoaded(), SMESH_Block::IsVertexID(), MESSAGE, myElements, myElemPointIDs, myElemXYZIDs, myIdsOnBoundary, myNbKeyPntInBoundary, myOrderedNodes, myPoints, myReverseConnectivity, myShape, myXYZ, myXYZIdToNodeMap, setErrorCode(), and undefinedXYZ().

arrangeBoundaries()

void SMESH_Pattern::arrangeBoundaries ( std::list< std::list< TPoint * > > &  boundaryPoints )

private

References SMESH_Pattern::TPoint::myInitUV, SMESH_Pattern::TPoint::myInitXYZ, myKeyPointIDs, myNbKeyPntInBoundary, myPoints, and reverse().

Referenced by findBoundaryPoints().

Clear()

void SMESH_Pattern::Clear

(

)

References myElements, myElemPointIDs, myElemXYZIDs, myIdsOnBoundary, myIsBoundaryPointsFound, myIsComputed, myKeyPointIDs, myNbKeyPntInBoundary, myOrderedNodes, myPoints, myPolyElems, myPolyElemXYZIDs, myPolyhedronQuantities, myReverseConnectivity, myShape, myShapeIDMap, myShapeIDToPointsMap, myXYZ, and myXYZIdToNodeMap.

Referenced by Load().

clearMesh()

void SMESH_Pattern::clearMesh ( SMESH_Mesh *  theMesh ) const

private

References clearSubMesh(), SMESH_Mesh::GetAncestors(), myIs2D, and myShape.

Referenced by MakeMesh().

computeUVOnEdge()

void SMESH_Pattern::computeUVOnEdge ( const TopoDS_Edge &  theEdge, const std::list< TPoint * > &  ePoints  )

private

References Face, Handle(), SMESH_Pattern::TPoint::myInitU, myShape, SMESH_Pattern::TPoint::myU, and SMESH_Pattern::TPoint::myUV.

Referenced by Apply(), setFirstEdge(), and sortSameSizeWires().

compUVByElasticIsolines()

bool SMESH_Pattern::compUVByElasticIsolines ( const std::list< std::list< TPoint * > > &  boundaryPoints, const std::list< TPoint * > &  pointsToCompute  )

private

WHAT IN THIS CASE ????????????? MAY BE THIS, I AM NOT SURE :(

References checkQuads(), compUVByIsoIntersection(), FIX_OLD, TIsoNode::GetBoundaryNode(), TIsoNode::GetNext(), MED::IsEqual(), TIsoNode::IsMovable(), TIsoNode::IsUVComputed(), MESSAGE, TIsoNode::myDir, TIsoNode::myInitUV, SMESH_Pattern::TPoint::myInitUV, TIsoNode::myNext, TIsoNode::myRatio, TIsoNode::myUV, SMESH_Pattern::TPoint::myUV, TIsoNode::SetBoundaryNode(), TIsoNode::SetNext(), and TIsoNode::SetNotMovable().

Referenced by Apply().

compUVByIsoIntersection()

bool SMESH_Pattern::compUVByIsoIntersection ( const std::list< std::list< TPoint * > > &  boundaryPoints, const gp_XY &  theInitUV, gp_XY &  theUV, bool &  theIsDeformed  )

private

References ERR_APPLF_BAD_TOPOLOGY, intersectIsolines(), MESSAGE, SMESH_Pattern::TPoint::myInitUV, SMESH_Pattern::TPoint::myUV, and setErrorCode().

Referenced by Apply(), compUVByElasticIsolines(), and sortSameSizeWires().

createElements()

void SMESH_Pattern::createElements ( SMESH_Mesh *  theMesh, const std::vector< const SMDS_MeshNode * > &  theNodesVector, const std::list< std::list< int > > &  theElemNodeIDs, const std::vector< const SMDS_MeshElement * > &  theElements  )

private

References SMESHDS_Mesh::AddFace(), SMESHDS_Mesh::AddPolygonalFace(), SMESHDS_Mesh::AddPolyhedralVolume(), SMESHDS_Mesh::AddVolume(), SMESH::aMainShape, SMESH_subMesh::CHECK_COMPUTE_STATE, SMESH_subMesh::ComputeStateEngine(), SMDS_MeshGroup::Contains(), SMESH_MeshEditor::FindShape(), SMESHDS_Mesh::GetGroups(), SMESH_Mesh::GetMeshDS(), SMESHDS_SubMesh::GetNodes(), SMDS_MeshElement::getshapeId(), SMESH_Mesh::GetSubMesh(), SMESH_Mesh::GetSubMeshContaining(), SMESHDS_Mesh::IndexToShape(), SMESHDS_Mesh::MeshElements(), myIs2D, myPolyhedronQuantities, myShape, myXYZIdToNodeMap, SMDS_MeshElement::nodesIterator(), SMESH_MeshEditor::Remove(), SMESHDS_Mesh::SetMeshElementOnShape(), SMESHDS_Mesh::SetNodeInVolume(), SMESHDS_Mesh::SetNodeOnFace(), SMESHDS_Mesh::ShapeToIndex(), SMESHDS_Mesh::ShapeToMesh(), SMDSAbs_Face, SMESHDS_Group::SMDSGroup(), and smdsNode.

Referenced by MakeMesh().

DumpPoints()

void SMESH_Pattern::DumpPoints

(

)

const

References myPoints.

findBoundaryPoints()

bool SMESH_Pattern::findBoundaryPoints ( )

private

References arrangeBoundaries(), ERR_READ_BAD_KEY_POINT, SMESH_Block::GetShapeIDByParams(), getShapePoints(), SMESH_Block::IsVertexID(), MESSAGE, myElemPointIDs, SMESH_Pattern::TPoint::myInitU, SMESH_Pattern::TPoint::myInitUV, SMESH_Pattern::TPoint::myInitXYZ, myIs2D, myIsBoundaryPointsFound, myKeyPointIDs, myNbKeyPntInBoundary, myPoints, and setErrorCode().

Referenced by Apply(), and Load().

findExistingNodes()

bool SMESH_Pattern::findExistingNodes ( SMESH_Mesh *  mesh, const TopoDS_Shape &  S, const std::list< TPoint * > &  points, std::vector< const SMDS_MeshNode * > &  nodes  )

private

References Edge, SMESH_Mesh::GetMeshDS(), SMESH_Algo::GetSortedNodesOnEdge(), myPoints, SMESH_Pattern::TPoint::myU, and SMESH_Algo::VertexNode().

Referenced by MakeMesh().

GetElementPointIDs()

const std::list< std::list< int > > & SMESH_Pattern::GetElementPointIDs

(

bool

applied

)

const

Referenced by SMESH_Pattern_i::GetElementPoints().

GetErrorCode()

ErrorCode SMESH_Pattern::GetErrorCode

(

)

const

Referenced by StdMeshers_Projection_2D::Compute(), and SMESH_Pattern_i::GetErrorCode().

getFacesDefinition()

bool SMESH_Pattern::getFacesDefinition ( const SMDS_MeshNode **  theBndNodes, const int  theNbBndNodes, const std::vector< const SMDS_MeshNode * > &  theNodes, std::list< int > &  theFaceDefs, std::vector< int > &  theQuantity  )

private

References SMDS_VolumeTool::GetFaceNodesIndices(), SMDS_VolumeTool::GetType(), isReversed(), myIdsOnBoundary, myIs2D, myReverseConnectivity, myXYZIdToNodeMap, SMDS_VolumeTool::NbFaceNodes(), SMDS_VolumeTool::NbFaces(), and SMDS_VolumeTool::UNKNOWN.

Referenced by makePolyElements().

GetInOutNodes()

void SMESH_Pattern::GetInOutNodes	(	std::vector< const SMDS_MeshNode * > *&	inNodes,
		std::vector< const SMDS_MeshNode * > *&	outNodes
	)

Referenced by StdMeshers_Projection_2D::Compute().

GetKeyPointIDs()

const std::list< int > & SMESH_Pattern::GetKeyPointIDs

(

)

const

Referenced by SMESH_Pattern_i::GetKeyPoints().

GetMappedPoints()

bool SMESH_Pattern::GetMappedPoints

(

std::list< const gp_XYZ * > &

thePoints

)

const

References isDefined(), myElements, myIsComputed, myKeyPointIDs, myPoints, and myXYZ.

Referenced by SMESH_Pattern_i::ApplyTo3DBlock(), SMESH_Pattern_i::ApplyToFace(), SMESH_Pattern_i::ApplyToHexahedrons(), and SMESH_Pattern_i::ApplyToMeshFaces().

GetPoints()

bool SMESH_Pattern::GetPoints

(

std::list< const gp_XYZ * > &

thePoints

)

const

References IsLoaded(), and myPoints.

Referenced by SMESH_Pattern_i::GetPoints().

getShapePoints() [1/2]

list< SMESH_Pattern::TPoint * > & SMESH_Pattern::getShapePoints ( const int  theShapeID )

private

References myShapeIDToPointsMap.

getShapePoints() [2/2]

list< SMESH_Pattern::TPoint * > & SMESH_Pattern::getShapePoints ( const TopoDS_Shape &  theShape )

private

References myShapeIDMap, and myShapeIDToPointsMap.

Referenced by Apply(), findBoundaryPoints(), Load(), setFirstEdge(), and sortSameSizeWires().

getSubmeshWithElements()

SMESHDS_SubMesh * SMESH_Pattern::getSubmeshWithElements ( SMESH_Mesh *  theMesh, const TopoDS_Shape &  theShape  )

staticprivate

References SMESH_Mesh::GetAncestors(), SMESHDS_SubMesh::GetElements(), SMESH_Mesh::GetMeshDS(), SMESHDS_SubMesh::GetNodes(), and SMESHDS_Mesh::MeshElements().

Referenced by Load().

GetSubShape()

TopoDS_Shape SMESH_Pattern::GetSubShape

(

const int

i

)

const

Is2D()

bool SMESH_Pattern::Is2D

(

)

const

Referenced by SMESH_Pattern_i::Is2D().

IsLoaded()

bool SMESH_Pattern::IsLoaded

(

)

const

Referenced by Apply(), SMESH_Pattern_i::GetKeyPoints(), GetPoints(), Save(), and setShapeToMesh().

isReversed()

bool SMESH_Pattern::isReversed ( const SMDS_MeshNode *  theFirstNode, const std::list< int > &  theIdsList  ) const

private

References myXYZ, myXYZIdToNodeMap, SMDS_MeshNode::X(), SMDS_MeshNode::Y(), and SMDS_MeshNode::Z().

Referenced by getFacesDefinition(), and makePolyElements().

Load() [1/3]

bool SMESH_Pattern::Load

(

const char *

theFileContents

)

References Clear(), ERR_OK, ERR_READ_3D_COORD, ERR_READ_BAD_INDEX, ERR_READ_ELEM_POINTS, ERR_READ_NB_POINTS, ERR_READ_NO_ELEMS, ERR_READ_NO_KEYPOINT, ERR_READ_POINT_COORDS, ERR_READ_TOO_FEW_POINTS, findBoundaryPoints(), MESSAGE, myElemPointIDs, SMESH_Pattern::TPoint::myInitUV, SMESH_Pattern::TPoint::myInitXYZ, myIs2D, myKeyPointIDs, myPoints, and setErrorCode().

Referenced by StdMeshers_Projection_2D::Compute(), SMESH_Pattern_i::LoadFrom3DBlock(), SMESH_Pattern_i::LoadFromFace(), and SMESH_Pattern_i::LoadFromFile().

Load() [2/3]

bool SMESH_Pattern::Load	(	SMESH_Mesh *	theMesh,
		const TopoDS_Face &	theFace,
		bool	theProject = false,
		TopoDS_Vertex	the1stVertex = TopoDS_Vertex(),
		bool	theKeepNodes = false
	)

References Clear(), SMDS_Mesh::elementsIterator(), ERR_LOAD_EMPTY_SUBMESH, ERR_LOADF_CANT_PROJECT, ERR_LOADF_NARROW_FACE, ERR_OK, ERR_UNEXPECTED, Face, SMESHDS_SubMesh::GetElements(), SMESH_Mesh::GetMeshDS(), SMDS_Mesh::GetMeshInfo(), SMDS_MeshElement::GetNode(), SMESHDS_SubMesh::GetNodes(), SMESH_MesherHelper::GetNodeUV(), SMESH_Block::GetOrderedEdges(), SMDS_MeshNode::GetPosition(), SMDS_MeshElement::getshapeId(), getShapePoints(), Handle(), SMESH_MesherHelper::HasSeam(), SMESH_Mesh::IsMainShape(), SMESH_MesherHelper::IsMedium(), isMeshBoundToShape(), SMESH_MesherHelper::IsRealSeam(), SMESH_MesherHelper::IsSeamShape(), SMESHDS_Mesh::MeshElements(), MESSAGE, myElemPointIDs, SMESH_Pattern::TPoint::myInitU, SMESH_Pattern::TPoint::myInitUV, SMESH_Pattern::TPoint::myInitXYZ, myInNodes, myIs2D, myIsBoundaryPointsFound, myKeyPointIDs, myNbKeyPntInBoundary, myPoints, myShapeIDMap, myToKeepNodes, SMDS_MeshElement::NbCornerNodes(), SMESHDS_SubMesh::NbElements(), SMDS_Mesh::NbFaces(), SMDS_MeshInfo::NbFaces(), SMDS_MeshNode::NbInverseElements(), SMESHDS_SubMesh::NbNodes(), SMDS_MeshElement::nodesIterator(), ORDER_QUADRATIC, project(), setErrorCode(), SMESH_MesherHelper::SetSubShape(), SMDSAbs_Face, smdsNode, SMESH_Algo::VertexNode(), SMESH_MesherHelper::WrapIndex(), SMDS_MeshNode::X(), SMDS_MeshNode::Y(), and SMDS_MeshNode::Z().

Load() [3/3]

bool SMESH_Pattern::Load	(	SMESH_Mesh *	theMesh,
		const TopoDS_Shell &	theBlock,
		bool	theKeepNodes = false
	)

References Clear(), SMESH_Block::ComputeParameters(), Edge, ERR_LOADV_BAD_SHAPE, ERR_LOADV_COMPUTE_PARAMS, ERR_OK, SMESH_Block::GetCoordIndOnEdge(), SMESHDS_SubMesh::GetElements(), SMDS_MeshElement::GetNode(), SMESHDS_SubMesh::GetNodes(), SMDS_MeshNode::GetPosition(), SMESH_Block::GetShapeCoef(), getShapePoints(), getSubmeshWithElements(), SMESH_Block::IsForwardEdge(), SMESH_MeshEditor::IsMedium(), SMESH_Block::IsVertexID(), SMESH_Block::LoadBlockShapes(), MESSAGE, myElemPointIDs, SMESH_Pattern::TPoint::myInitXYZ, myInNodes, myIs2D, myIsBoundaryPointsFound, myKeyPointIDs, myPoints, myShapeIDMap, myToKeepNodes, SMESH_Pattern::TPoint::myXYZ, SMDS_MeshElement::NbCornerNodes(), SMESHDS_SubMesh::NbNodes(), SMESH_Mesh::NbVolumes(), ORDER_QUADRATIC, setErrorCode(), SMDSAbs_Edge, SMDSAbs_Volume, smdsNode, SMDS_MeshNode::X(), SMDS_MeshNode::Y(), and SMDS_MeshNode::Z().

MakeMesh()

bool SMESH_Pattern::MakeMesh	(	SMESH_Mesh *	theMesh,
		const bool	toCreatePolygons = false,
		const bool	toCreatePolyedrs = false
	)

References SMESHDS_Mesh::AddNode(), SMESH_MesherHelper::CheckNodeU(), clearMesh(), SMESHDS_Mesh::CompactMesh(), createElements(), Edge, ERR_MAKEM_NOT_COMPUTED, ERR_OK, Face, findExistingNodes(), SMESH_MesherHelper::GetCommonAncestor(), SMESH_Mesh::GetMeshDS(), SMESH_MesherHelper::GetSubShapeByNode(), SMESH_Mesh::HasShapeToMesh(), isDefined(), SMESH_MesherHelper::IsSubShape(), makePolyElements(), mergePoints(), SMDS_Mesh::Modified(), myElements, myElemPointIDs, myElemXYZIDs, myIdsOnBoundary, myIsComputed, myOutNodes, myPoints, myPolyElems, myPolyElemXYZIDs, myShapeIDMap, myShapeIDToPointsMap, myToKeepNodes, SMESH_Pattern::TPoint::myU, SMESH_Pattern::TPoint::myUV, SMESH_Pattern::TPoint::myXYZ, myXYZ, myXYZIdToNodeMap, setErrorCode(), SMESHDS_Mesh::SetNodeInVolume(), SMESHDS_Mesh::SetNodeOnEdge(), SMESHDS_Mesh::SetNodeOnFace(), SMESHDS_Mesh::SetNodeOnVertex(), SMESH_MesherHelper::SetSubShape(), and SMESH_MesherHelper::ToFixNodeParameters().

Referenced by StdMeshers_Projection_2D::Compute(), and SMESH_Pattern_i::MakeMesh().

makePolyElements()

void SMESH_Pattern::makePolyElements ( const std::vector< const SMDS_MeshNode * > &  theNodes, const bool  toCreatePolygons, const bool  toCreatePolyedrs  )

private

References SMESH_MeshAlgos::FindFaceInSet(), SMDS_VolumeTool::GetFaceNodes(), getFacesDefinition(), SMDS_MeshNode::GetInverseElementIterator(), isReversed(), myElements, myIdsOnBoundary, myIs2D, myPolyElems, myPolyElemXYZIDs, myPolyhedronQuantities, myReverseConnectivity, myXYZ, myXYZIdToNodeMap, SMDS_VolumeTool::NbFaceNodes(), SMDS_VolumeTool::NbFaces(), SMDS_MeshElement::NbNodes(), SMDS_MeshElement::nodesIterator(), SMDS_VolumeTool::Set(), and smdsNode.

Referenced by MakeMesh().

mergePoints()

void SMESH_Pattern::mergePoints ( const bool  uniteGroups )

private

References isDefined(), myIdsOnBoundary, myReverseConnectivity, myXYZ, and undefinedXYZ().

Referenced by MakeMesh().

Save()

bool SMESH_Pattern::Save

(

std::ostream &

theFile

)

References ERR_OK, ERR_SAVE_NOT_LOADED, IsLoaded(), MESSAGE, myElemPointIDs, myIs2D, myKeyPointIDs, myPoints, and setErrorCode().

Referenced by SMESH_Pattern_i::GetString().

setErrorCode()

bool SMESH_Pattern::setErrorCode ( const ErrorCode  theErrorCode )

private

set ErrorCode and return true if it is Ok

References ERR_OK, and myErrorCode.

Referenced by Apply(), compUVByIsoIntersection(), findBoundaryPoints(), Load(), MakeMesh(), Save(), and setShapeToMesh().

setFirstEdge()

double SMESH_Pattern::setFirstEdge ( std::list< TopoDS_Edge > &  theWire, int  theFirstEdgeID  )

private

References computeUVOnEdge(), Face, getShapePoints(), Handle(), MESSAGE, myShape, SMESH_Pattern::TPoint::myUV, and SMESH_Pattern::TPoint::myXYZ.

Referenced by Apply(), and sortSameSizeWires().

setShapeToMesh()

bool SMESH_Pattern::setShapeToMesh ( const TopoDS_Shape &  theShape )

private

References Edge, ERR_APPL_BAD_DIMENTION, ERR_APPL_BAD_NB_VERTICES, ERR_APPL_NOT_LOADED, Face, IsLoaded(), MESSAGE, myElements, myElemXYZIDs, myIs2D, myKeyPointIDs, myShape, myShapeIDMap, and setErrorCode().

Referenced by Apply().

sortSameSizeWires()

bool SMESH_Pattern::sortSameSizeWires ( TListOfEdgesList &  theWireList, const TListOfEdgesList::iterator &  theFromWire, const TListOfEdgesList::iterator &  theToWire, const int  theFirstEdgeID, std::list< std::list< TPoint * > > &  theEdgesPointsList  )

private

References computeUVOnEdge(), compUVByIsoIntersection(), Face, getShapePoints(), MESSAGE, SMESH_Pattern::TPoint::myInitUV, myShape, SMESH_Pattern::TPoint::myUV, SMESH_Pattern::TPoint::myXYZ, setFirstEdge(), and SMESH::XY.

Referenced by Apply().

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  OS, const TPoint &  p  )

friend

Field Documentation

myElements

std::vector<const SMDS_MeshElement*> SMESH_Pattern::myElements

private

Referenced by Apply(), Clear(), GetMappedPoints(), MakeMesh(), makePolyElements(), and setShapeToMesh().

myElemPointIDs

std::list< TElemDef > SMESH_Pattern::myElemPointIDs

private

Referenced by Apply(), Clear(), findBoundaryPoints(), Load(), MakeMesh(), and Save().

myElemXYZIDs

std::list< TElemDef > SMESH_Pattern::myElemXYZIDs

private

Referenced by Apply(), Clear(), MakeMesh(), and setShapeToMesh().

myErrorCode

ErrorCode SMESH_Pattern::myErrorCode

private

Referenced by setErrorCode().

myIdsOnBoundary

std::map<TNodeSet,std::list<std::list<int> > > SMESH_Pattern::myIdsOnBoundary

private

Referenced by Apply(), Clear(), getFacesDefinition(), MakeMesh(), makePolyElements(), and mergePoints().

myInNodes

std::vector< const SMDS_MeshNode* > SMESH_Pattern::myInNodes

private

Referenced by Load().

myIs2D

bool SMESH_Pattern::myIs2D

private

Referenced by clearMesh(), createElements(), findBoundaryPoints(), getFacesDefinition(), Load(), makePolyElements(), Save(), and setShapeToMesh().

myIsBoundaryPointsFound

bool SMESH_Pattern::myIsBoundaryPointsFound

private

Referenced by Clear(), findBoundaryPoints(), and Load().

myIsComputed

bool SMESH_Pattern::myIsComputed

private

Referenced by Apply(), Clear(), GetMappedPoints(), and MakeMesh().

myKeyPointIDs

std::list< int > SMESH_Pattern::myKeyPointIDs

private

Referenced by Apply(), arrangeBoundaries(), Clear(), findBoundaryPoints(), GetMappedPoints(), Load(), Save(), and setShapeToMesh().

myNbKeyPntInBoundary

std::list< int > SMESH_Pattern::myNbKeyPntInBoundary

private

Referenced by Apply(), arrangeBoundaries(), Clear(), findBoundaryPoints(), and Load().

myOrderedNodes

std::vector<const SMDS_MeshNode*> SMESH_Pattern::myOrderedNodes

private

Referenced by Apply(), and Clear().

myOutNodes

std::vector< const SMDS_MeshNode* > SMESH_Pattern::myOutNodes

private

Referenced by MakeMesh().

myPoints

std::vector< TPoint > SMESH_Pattern::myPoints

private

Referenced by Apply(), arrangeBoundaries(), Clear(), DumpPoints(), findBoundaryPoints(), findExistingNodes(), GetMappedPoints(), GetPoints(), Load(), MakeMesh(), and Save().

myPolyElems

std::vector<const SMDS_MeshElement*> SMESH_Pattern::myPolyElems

private

Referenced by Clear(), MakeMesh(), and makePolyElements().

myPolyElemXYZIDs

std::list< TElemDef > SMESH_Pattern::myPolyElemXYZIDs

private

Referenced by Clear(), MakeMesh(), and makePolyElements().

myPolyhedronQuantities

std::list< std::vector<int> > SMESH_Pattern::myPolyhedronQuantities

private

Referenced by Clear(), createElements(), and makePolyElements().

myReverseConnectivity

std::map< int, std::list< TElemDef* > > SMESH_Pattern::myReverseConnectivity

private

Referenced by Apply(), Clear(), getFacesDefinition(), makePolyElements(), and mergePoints().

myShape

TopoDS_Shape SMESH_Pattern::myShape

private

Referenced by Apply(), Clear(), clearMesh(), computeUVOnEdge(), createElements(), setFirstEdge(), setShapeToMesh(), and sortSameSizeWires().

myShapeIDMap

TopTools_IndexedMapOfOrientedShape SMESH_Pattern::myShapeIDMap

private

Referenced by Apply(), Clear(), getShapePoints(), Load(), MakeMesh(), and setShapeToMesh().

myShapeIDToPointsMap

std::map< int, std::list< TPoint*> > SMESH_Pattern::myShapeIDToPointsMap

private

Referenced by Apply(), Clear(), getShapePoints(), and MakeMesh().

myToKeepNodes

bool SMESH_Pattern::myToKeepNodes

private

Referenced by Load(), and MakeMesh().

myXYZ

std::vector<gp_XYZ> SMESH_Pattern::myXYZ

private

Referenced by Apply(), Clear(), GetMappedPoints(), isReversed(), MakeMesh(), makePolyElements(), and mergePoints().

myXYZIdToNodeMap

std::map< int, const SMDS_MeshNode*> SMESH_Pattern::myXYZIdToNodeMap

private

Referenced by Apply(), Clear(), createElements(), getFacesDefinition(), isReversed(), MakeMesh(), and makePolyElements().