ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-28 01:50:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

move StdMeshers_Helper to SMESH_MesherHelper (for linear<->quadratic mesh conversion)

Browse Source
This commit is contained in:
eap 2006-04-26 12:03:26 +00:00
parent 572ca07c09
commit cb34f3c3c6
11 changed files with 842 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

611
src/SMESH/SMESH_MesherHelper.cxx Normal file
View File

@ -0,0 +1,611 @@
// File: SMESH_MesherHelper.cxx
// Created: 15.02.06 15:22:41
// Author: Sergey KUUL
// Copyright: Open CASCADE 2006
#include "SMESH_MesherHelper.hxx"
#include "SMDS_FacePosition.hxx"
#include "SMDS_EdgePosition.hxx".cxx
#include "SMESH_MeshEditor.hxx"
#include <BRepAdaptor_Surface.hxx>
#include <BRepTools.hxx>
#include <BRep_Tool.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_MapOfShape.hxx>
#include <gp_Pnt2d.hxx>
#include <ShapeAnalysis.hxx>
//=======================================================================
//function : CheckShape
//purpose :
//=======================================================================
bool SMESH_MesherHelper::IsQuadraticSubMesh(const TopoDS_Shape& aSh)
{
SMESHDS_Mesh* meshDS = GetMesh()->GetMeshDS();
myShapeID = meshDS->ShapeToIndex(aSh);
// we can create quadratic elements only if all elements
// created on subshapes of given shape are quadratic
// also we have to fill myNLinkNodeMap
myCreateQuadratic = true;
mySeamShapeIds.clear();
TopAbs_ShapeEnum subType( aSh.ShapeType()==TopAbs_FACE ? TopAbs_EDGE : TopAbs_FACE );
SMDSAbs_ElementType elemType( subType==TopAbs_FACE ? SMDSAbs_Face : SMDSAbs_Edge );
TopExp_Explorer exp( aSh, subType );
for (; exp.More() && myCreateQuadratic; exp.Next()) {
if ( SMESHDS_SubMesh * subMesh = meshDS->MeshElements( exp.Current() )) {
if ( SMDS_ElemIteratorPtr it = subMesh->GetElements() ) {
while(it->more()) {
const SMDS_MeshElement* e = it->next();
if ( e->GetType() != elemType || !e->IsQuadratic() ) {
myCreateQuadratic = false;
break;
}
else {
// fill NLinkNodeMap
switch ( e->NbNodes() ) {
case 3:
AddNLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(2)); break;
case 6:
AddNLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(3));
AddNLinkNode(e->GetNode(1),e->GetNode(2),e->GetNode(4));
AddNLinkNode(e->GetNode(2),e->GetNode(0),e->GetNode(5)); break;
case 8:
AddNLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(4));
AddNLinkNode(e->GetNode(1),e->GetNode(2),e->GetNode(5));
AddNLinkNode(e->GetNode(2),e->GetNode(3),e->GetNode(6));
AddNLinkNode(e->GetNode(3),e->GetNode(0),e->GetNode(7));
break;
default:
myCreateQuadratic = false;
break;
}
}
}
}
}
}
if(!myCreateQuadratic) {
myNLinkNodeMap.clear();
}
else {
// treatment of periodic faces
if ( aSh.ShapeType() == TopAbs_FACE ) {
const TopoDS_Face& face = TopoDS::Face( aSh );
BRepAdaptor_Surface surface( face );
if ( surface.IsUPeriodic() || surface.IsVPeriodic() ) {
// look for a seam edge
for ( exp.Init( face, TopAbs_EDGE ); exp.More(); exp.Next()) {
const TopoDS_Edge& edge = TopoDS::Edge( exp.Current() );
if ( BRep_Tool::IsClosed( edge, face )) {
// initialize myPar1, myPar2 and myParIndex
if ( mySeamShapeIds.empty() ) {
gp_Pnt2d uv1, uv2;
BRep_Tool::UVPoints( edge, face, uv1, uv2 );
if ( Abs( uv1.Coord(1) - uv2.Coord(1) ) < Abs( uv1.Coord(2) - uv2.Coord(2) ))
{
myParIndex = 1; // U periodic
myPar1 = surface.FirstUParameter();
myPar2 = surface.LastUParameter();
}
else {
myParIndex = 2; // V periodic
myPar1 = surface.FirstVParameter();
myPar2 = surface.LastVParameter();
}
}
// store shapes indices
mySeamShapeIds.insert( meshDS->ShapeToIndex( exp.Current() ));
for ( TopExp_Explorer v( exp.Current(), TopAbs_VERTEX ); v.More(); v.Next() )
mySeamShapeIds.insert( meshDS->ShapeToIndex( v.Current() ));
}
}
}
}
}
return myCreateQuadratic;
}
//=======================================================================
//function : IsMedium
//purpose :
//=======================================================================
bool SMESH_MesherHelper::IsMedium(const SMDS_MeshNode* node,
const SMDSAbs_ElementType typeToCheck)
{
return SMESH_MeshEditor::IsMedium( node, typeToCheck );
}
//=======================================================================
//function : AddNLinkNode
//purpose :
//=======================================================================
/*!
* Auxilary function for filling myNLinkNodeMap
*/
void SMESH_MesherHelper::AddNLinkNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n12)
{
NLink link( n1, n2 );
if ( n1 > n2 ) link = NLink( n2, n1 );
// add new record to map
myNLinkNodeMap.insert( make_pair(link,n12));
}
//=======================================================================
/*!
* \brief Select UV on either of 2 pcurves of a seam edge, closest to the given UV
* \param uv1 - UV on the seam
* \param uv2 - UV within a face
* \retval gp_Pnt2d - selected UV
*/
//=======================================================================
gp_Pnt2d SMESH_MesherHelper::GetUVOnSeam( const gp_Pnt2d& uv1, const gp_Pnt2d& uv2 ) const
{
double p1 = uv1.Coord( myParIndex );
double p2 = uv2.Coord( myParIndex );
double p3 = ( Abs( p1 - myPar1 ) < Abs( p1 - myPar2 )) ? myPar2 : myPar1;
if ( Abs( p2 - p1 ) > Abs( p2 - p3 ))
p1 = p3;
gp_Pnt2d result = uv1;
result.SetCoord( myParIndex, p1 );
return result;
}
//=======================================================================
/*!
* \brief Return node UV on face
* \param F - the face
* \param n - the node
* \param n2 - a medium node will be placed between n and n2
* \retval gp_XY - resulting UV
*
* Auxilary function called form GetMediumNode()
*/
//=======================================================================
gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face& F,
const SMDS_MeshNode* n,
const SMDS_MeshNode* n2)
{
gp_Pnt2d uv;
const SMDS_PositionPtr Pos = n->GetPosition();
if(Pos->GetTypeOfPosition()==SMDS_TOP_FACE) {
// node has position on face
const SMDS_FacePosition* fpos =
static_cast<const SMDS_FacePosition*>(n->GetPosition().get());
uv = gp_Pnt2d(fpos->GetUParameter(),fpos->GetVParameter());
}
else if(Pos->GetTypeOfPosition()==SMDS_TOP_EDGE) {
// node has position on edge => it is needed to find
// corresponding edge from face, get pcurve for this
// edge and recieve value from this pcurve
const SMDS_EdgePosition* epos =
static_cast<const SMDS_EdgePosition*>(n->GetPosition().get());
SMESHDS_Mesh* meshDS = GetMesh()->GetMeshDS();
int edgeID = Pos->GetShapeId();
TopoDS_Edge E = TopoDS::Edge(meshDS->IndexToShape(edgeID));
double f, l;
TopLoc_Location loc;
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
uv = C2d->Value( epos->GetUParameter() );
// for a node on a seam edge select one of UVs on 2 pcurves
if ( n2 && mySeamShapeIds.find( edgeID ) != mySeamShapeIds.end() )
uv = GetUVOnSeam( uv, GetNodeUV( F, n2, 0 ));
}
else if(Pos->GetTypeOfPosition()==SMDS_TOP_VERTEX) {
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
int vertexID = n->GetPosition()->GetShapeId();
const TopoDS_Vertex& V = TopoDS::Vertex(meshDS->IndexToShape(vertexID));
uv = BRep_Tool::Parameters( V, F );
if ( n2 && mySeamShapeIds.find( vertexID ) != mySeamShapeIds.end() )
uv = GetUVOnSeam( uv, GetNodeUV( F, n2, 0 ));
}
return uv.XY();
}
//=======================================================================
/*!
* \brief Return node U on edge
* \param E - the Edge
* \param n - the node
* \retval double - resulting U
*
* Auxilary function called form GetMediumNode()
*/
//=======================================================================
double SMESH_MesherHelper::GetNodeU(const TopoDS_Edge& E,
const SMDS_MeshNode* n)
{
double param = 0;
const SMDS_PositionPtr Pos = n->GetPosition();
if(Pos->GetTypeOfPosition()==SMDS_TOP_EDGE) {
const SMDS_EdgePosition* epos =
static_cast<const SMDS_EdgePosition*>(n->GetPosition().get());
param = epos->GetUParameter();
}
else if(Pos->GetTypeOfPosition()==SMDS_TOP_VERTEX) {
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
int vertexID = n->GetPosition()->GetShapeId();
const TopoDS_Vertex& V = TopoDS::Vertex(meshDS->IndexToShape(vertexID));
param = BRep_Tool::Parameter( V, E );
}
return param;
}
//=======================================================================
//function : GetMediumNode
//purpose :
//=======================================================================
/*!
* Special function for search or creation medium node
*/
const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
bool force3d)
{
//cout<<"n1: "<<n1;
//cout<<"n2: "<<n2;
NLink link(( n1 < n2 ? n1 : n2 ), ( n1 < n2 ? n2 : n1 ));
ItNLinkNode itLN = myNLinkNodeMap.find( link );
if ( itLN != myNLinkNodeMap.end() ) {
return (*itLN).second;
}
else {
// create medium node
SMDS_MeshNode* n12;
SMESHDS_Mesh* meshDS = GetMesh()->GetMeshDS();
int faceID = -1, edgeID = -1;
const SMDS_PositionPtr Pos1 = n1->GetPosition();
const SMDS_PositionPtr Pos2 = n2->GetPosition();
if( myShape.IsNull() )
{
if( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) {
faceID = Pos1->GetShapeId();
}
else if( Pos2->GetTypeOfPosition()==SMDS_TOP_FACE ) {
faceID = Pos2->GetShapeId();
}
if( Pos1->GetTypeOfPosition()==SMDS_TOP_EDGE ) {
edgeID = Pos1->GetShapeId();
}
if( Pos2->GetTypeOfPosition()==SMDS_TOP_EDGE ) {
edgeID = Pos2->GetShapeId();
}
}
if(!force3d) {
// we try to create medium node using UV parameters of
// nodes, else - medium between corresponding 3d points
if(faceID>-1 || myShape.ShapeType() == TopAbs_FACE) {
// obtaining a face and 2d points for nodes
TopoDS_Face F;
if( myShape.IsNull() )
F = TopoDS::Face(meshDS->IndexToShape(faceID));
else
F = TopoDS::Face(myShape);
gp_XY p1 = GetNodeUV(F,n1,n2);
gp_XY p2 = GetNodeUV(F,n2,n1);
//checking if surface is periodic
Handle(Geom_Surface) S = BRep_Tool::Surface(F);
Standard_Real UF,UL,VF,VL;
S->Bounds(UF,UL,VF,VL);
Standard_Real u,v;
Standard_Boolean isUPeriodic = S->IsUPeriodic();
if(isUPeriodic) {
Standard_Real UPeriod = S->UPeriod();
Standard_Real p2x = p2.X()+ShapeAnalysis::AdjustByPeriod(p2.X(),p1.X(),UPeriod);
Standard_Real pmid = (p1.X()+p2x)/2.;
u = pmid+ShapeAnalysis::AdjustToPeriod(pmid,UF,UL);
}
else
u= (p1.X()+p2.X())/2.;
Standard_Boolean isVPeriodic = S->IsVPeriodic();
if(isVPeriodic) {
Standard_Real VPeriod = S->VPeriod();
Standard_Real p2y = p2.Y()+ShapeAnalysis::AdjustByPeriod(p2.Y(),p1.Y(),VPeriod);
Standard_Real pmid = (p1.Y()+p2y)/2.;
v = pmid+ShapeAnalysis::AdjustToPeriod(pmid,VF,VL);
}
else
v = (p1.Y()+p2.Y())/2.;
gp_Pnt P = S->Value(u, v);
n12 = meshDS->AddNode(P.X(), P.Y(), P.Z());
meshDS->SetNodeOnFace(n12, faceID, u, v);
myNLinkNodeMap.insert(NLinkNodeMap::value_type(link,n12));
return n12;
}
if (edgeID>-1 || myShape.ShapeType() == TopAbs_EDGE) {
TopoDS_Edge E;
if( myShape.IsNull() )
E = TopoDS::Edge(meshDS->IndexToShape(edgeID));
else
E = TopoDS::Edge(myShape);
double p1 = GetNodeU(E,n1);
double p2 = GetNodeU(E,n2);
double f,l;
Handle(Geom_Curve) C = BRep_Tool::Curve(E, f, l);
if(!C.IsNull()) {
Standard_Boolean isPeriodic = C->IsPeriodic();
double u;
if(isPeriodic) {
Standard_Real Period = C->Period();
Standard_Real p = p2+ShapeAnalysis::AdjustByPeriod(p2,p1,Period);
Standard_Real pmid = (p1+p)/2.;
u = pmid+ShapeAnalysis::AdjustToPeriod(pmid,C->FirstParameter(),C->LastParameter());
}
else
u = (p1+p2)/2.;
gp_Pnt P = C->Value( u );
n12 = meshDS->AddNode(P.X(), P.Y(), P.Z());
meshDS->SetNodeOnEdge(n12, edgeID, u);
myNLinkNodeMap.insert(NLinkNodeMap::value_type(link,n12));
return n12;
}
}
}
// 3d variant
double x = ( n1->X() + n2->X() )/2.;
double y = ( n1->Y() + n2->Y() )/2.;
double z = ( n1->Z() + n2->Z() )/2.;
n12 = meshDS->AddNode(x,y,z);
if(edgeID>-1)
meshDS->SetNodeOnEdge(n12, edgeID);
else if(faceID>-1)
meshDS->SetNodeOnFace(n12, faceID);
else
meshDS->SetNodeInVolume(n12, myShapeID);
myNLinkNodeMap.insert(NLinkNodeMap::value_type(link,n12));
return n12;
}
}
//=======================================================================
//function : AddQuadraticEdge
//purpose :
//=======================================================================
/**
* Special function for creation quadratic edge
*/
SMDS_QuadraticEdge* SMESH_MesherHelper::AddQuadraticEdge(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const int id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
myCreateQuadratic = true;
if(id)
return (SMDS_QuadraticEdge*)(meshDS->AddEdgeWithID(n1, n2, n12, id));
else
return (SMDS_QuadraticEdge*)(meshDS->AddEdge(n1, n2, n12));
}
//=======================================================================
//function : AddFace
//purpose :
//=======================================================================
/*!
* Special function for creation quadratic triangle
*/
SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const int id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
if(!myCreateQuadratic) {
if(id)
return meshDS->AddFaceWithID(n1, n2, n3, id);
else
return meshDS->AddFace(n1, n2, n3);
}
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n31 = GetMediumNode(n3,n1,force3d);
if(id)
return meshDS->AddFaceWithID(n1, n2, n3, n12, n23, n31, id);
else
return meshDS->AddFace(n1, n2, n3, n12, n23, n31);
}
//=======================================================================
//function : AddFace
//purpose :
//=======================================================================
/*!
* Special function for creation quadratic quadrangle
*/
SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
if(!myCreateQuadratic) {
if(id)
return meshDS->AddFaceWithID(n1, n2, n3, n4, id);
else
return meshDS->AddFace(n1, n2, n3, n4);
}
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n34 = GetMediumNode(n3,n4,force3d);
const SMDS_MeshNode* n41 = GetMediumNode(n4,n1,force3d);
if(id)
return meshDS->AddFaceWithID(n1, n2, n3, n4, n12, n23, n34, n41, id);
else
return meshDS->AddFace(n1, n2, n3, n4, n12, n23, n34, n41);
}
//=======================================================================
//function : AddVolume
//purpose :
//=======================================================================
/*!
* Special function for creation quadratic volume
*/
SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const int id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
if(!myCreateQuadratic) {
if(id)
return meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, id);
else
return meshDS->AddVolume(n1, n2, n3, n4, n5, n6);
}
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n31 = GetMediumNode(n3,n1,force3d);
const SMDS_MeshNode* n45 = GetMediumNode(n4,n5,force3d);
const SMDS_MeshNode* n56 = GetMediumNode(n5,n6,force3d);
const SMDS_MeshNode* n64 = GetMediumNode(n6,n4,force3d);
const SMDS_MeshNode* n14 = GetMediumNode(n1,n4,force3d);
const SMDS_MeshNode* n25 = GetMediumNode(n2,n5,force3d);
const SMDS_MeshNode* n36 = GetMediumNode(n3,n6,force3d);
if(id)
return meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36, id);
else
return meshDS->AddVolume(n1, n2, n3, n4, n5, n6,
n12, n23, n31, n45, n56, n64, n14, n25, n36);
}
//=======================================================================
//function : AddVolume
//purpose :
//=======================================================================
/*!
* Special function for creation quadratic volume
*/
SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
if(!myCreateQuadratic) {
if(id)
return meshDS->AddVolumeWithID(n1, n2, n3, n4, id);
else
return meshDS->AddVolume(n1, n2, n3, n4);
}
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n31 = GetMediumNode(n3,n1,force3d);
const SMDS_MeshNode* n14 = GetMediumNode(n1,n4,force3d);
const SMDS_MeshNode* n24 = GetMediumNode(n2,n4,force3d);
const SMDS_MeshNode* n34 = GetMediumNode(n3,n4,force3d);
if(id)
return meshDS->AddVolumeWithID(n1, n2, n3, n4, n12, n23, n31, n14, n24, n34, id);
else
return meshDS->AddVolume(n1, n2, n3, n4, n12, n23, n31, n14, n24, n34);
}
//=======================================================================
//function : AddVolume
//purpose :
//=======================================================================
/*!
* Special function for creation quadratic volume
*/
SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const SMDS_MeshNode* n7,
const SMDS_MeshNode* n8,
const int id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMesh()->GetMeshDS();
if(!myCreateQuadratic) {
if(id)
return meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, id);
else
return meshDS->AddVolume(n1, n2, n3, n4, n5, n6, n7, n8);
}
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n34 = GetMediumNode(n3,n4,force3d);
const SMDS_MeshNode* n41 = GetMediumNode(n4,n1,force3d);
const SMDS_MeshNode* n56 = GetMediumNode(n5,n6,force3d);
const SMDS_MeshNode* n67 = GetMediumNode(n6,n7,force3d);
const SMDS_MeshNode* n78 = GetMediumNode(n7,n8,force3d);
const SMDS_MeshNode* n85 = GetMediumNode(n8,n5,force3d);
const SMDS_MeshNode* n15 = GetMediumNode(n1,n5,force3d);
const SMDS_MeshNode* n26 = GetMediumNode(n2,n6,force3d);
const SMDS_MeshNode* n37 = GetMediumNode(n3,n7,force3d);
const SMDS_MeshNode* n48 = GetMediumNode(n4,n8,force3d);
if(id)
return meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48, id);
else
return meshDS->AddVolume(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48);
}

218
src/SMESH/SMESH_MesherHelper.hxx Normal file
View File

@ -0,0 +1,218 @@
// File: SMESH_MesherHelper.hxx
// Created: 15.02.06 14:48:09
// Author: Sergey KUUL
// Copyright: Open CASCADE 2006
#ifndef SMESH_MesherHelper_HeaderFile
#define SMESH_MesherHelper_HeaderFile
#include <SMESH_Mesh.hxx>
#include <TopoDS_Shape.hxx>
#include <SMDS_MeshNode.hxx>
#include <TopoDS_Face.hxx>
#include <gp_Pnt2d.hxx>
#include <SMDS_QuadraticEdge.hxx>
#include <map>
typedef pair<const SMDS_MeshNode*, const SMDS_MeshNode*> NLink;
typedef map<NLink, const SMDS_MeshNode*> NLinkNodeMap;
typedef map<NLink, const SMDS_MeshNode*>::iterator ItNLinkNode;
/*!
* \brief It helps meshers to add elements
*
* It allow meshers not to care about creation of medium nodes
* when filling a quadratic mesh. Helper does it itself.
* It defines degree of elements to create when IsQuadraticSubMesh()
* is called.
*/
class SMESH_MesherHelper
{
public:
// ---------- PUBLIC METHODS ----------
/// Empty constructor
SMESH_MesherHelper(SMESH_Mesh& theMesh)
{ myMesh=(void *)&theMesh; myCreateQuadratic = false; }
SMESH_Mesh* GetMesh() const
{ return (SMESH_Mesh*)myMesh; }
/// Copy constructor
//Standard_EXPORT SMESH_MesherHelper (const SMESH_MesherHelper& theOther);
/// Destructor
//Standard_EXPORT virtual ~SMESH_MesherHelper ();
/**
* Check submesh for given shape
* Check if all elements on this shape
* are quadratic, if yes => set true to myCreateQuadratic
* (default value is false). Also fill myNLinkNodeMap
* Returns myCreateQuadratic
*/
bool IsQuadraticSubMesh(const TopoDS_Shape& theShape);
/*!
* \brief Returns true if given node is medium
* \param n - node to check
* \param typeToCheck - type of elements containing the node to ask about node status
* \retval bool - check result
*/
static bool IsMedium(const SMDS_MeshNode* node,
const SMDSAbs_ElementType typeToCheck = SMDSAbs_All);
/**
* Auxilary function for filling myNLinkNodeMap
*/
void AddNLinkNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n12);
/**
* Auxilary function for filling myNLinkNodeMap
*/
void AddNLinkNodeMap(const NLinkNodeMap& aMap)
{ myNLinkNodeMap.insert(aMap.begin(), aMap.end()); }
/**
* Returns myNLinkNodeMap
*/
const NLinkNodeMap& GetNLinkNodeMap() { return myNLinkNodeMap; }
/*!
* \brief Return node UV on face
* \param F - the face
* \param n - the node
* \param n2 - a medium node will be placed between n and n2
* \retval gp_XY - resulting UV
*
* Auxilary function called form GetMediumNode()
*/
gp_XY GetNodeUV(const TopoDS_Face& F,
const SMDS_MeshNode* n,
const SMDS_MeshNode* n2=0);
/*!
* \brief Return U on edge
* \param F - the edge
* \param n - the node
* \retval double - resulting U
*
* Auxilary function called from GetMediumNode()
*/
double GetNodeU(const TopoDS_Edge& E,
const SMDS_MeshNode* n);
/**
* Special function for search or creation medium node
*/
const SMDS_MeshNode* GetMediumNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const bool force3d);
/**
* Special function for creation quadratic edge
*/
SMDS_QuadraticEdge* AddQuadraticEdge(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const int id = 0,
const bool force3d = true);
/**
* Special function for creation quadratic triangle
*/
SMDS_MeshFace* AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const int id=0,
const bool force3d = false);
/**
* Special function for creation quadratic quadrangle
*/
SMDS_MeshFace* AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id = 0,
const bool force3d = false);
/**
* Special function for creation quadratic tetraahedron
*/
SMDS_MeshVolume* AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id = 0,
const bool force3d = true);
/**
* Special function for creation quadratic pentahedron
*/
SMDS_MeshVolume* AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const int id = 0,
const bool force3d = true);
/**
* Special function for creation quadratic hexahedron
*/
SMDS_MeshVolume* AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const SMDS_MeshNode* n7,
const SMDS_MeshNode* n8,
const int id = 0,
bool force3d = true);
void SetKeyIsQuadratic(const bool theKey)
{myCreateQuadratic = theKey;};
void SetSubShape(const TopoDS_Shape& subShape)
{myShape = subShape;};
protected:
/*!
* \brief Select UV on either of 2 pcurves of a seam edge, closest to the given UV
* \param uv1 - UV on the seam
* \param uv2 - UV within a face
* \retval gp_Pnt2d - selected UV
*/
gp_Pnt2d GetUVOnSeam( const gp_Pnt2d& uv1, const gp_Pnt2d& uv2 ) const;
private:
void* myMesh;
int myShapeID;
// Key for creation quadratic faces
bool myCreateQuadratic;
// special map for using during creation quadratic faces
NLinkNodeMap myNLinkNodeMap;
std::set< int > mySeamShapeIds;
double myPar1, myPar2; // bounds of a closed periodic surface
int myParIndex; // bounds' index (1-U, 2-V)
TopoDS_Shape myShape;
};
#endif

2
src/StdMeshers/Makefile.in
View File

@ -51,7 +51,6 @@ EXPORT_HEADERS = \
StdMeshers_AutomaticLength.hxx \
StdMeshers_Distribution.hxx \
StdMeshers_QuadranglePreference.hxx \
StdMeshers_Helper.hxx \
StdMeshers_QuadraticMesh.hxx
EXPORT_PYSCRIPTS =
@ -79,7 +78,6 @@ LIB_SRC = \
StdMeshers_AutomaticLength.cxx \
StdMeshers_Distribution.cxx \
StdMeshers_QuadranglePreference.cxx \
StdMeshers_Helper.cxx \
StdMeshers_QuadraticMesh.cxx
LIB_SERVER_IDL =

2
src/StdMeshers/StdMeshers_Hexa_3D.cxx
View File

@ -199,7 +199,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
//MESSAGE("---");
// tool for working with quadratic elements
StdMeshers_Helper aTool (aMesh);
SMESH_MesherHelper aTool (aMesh);
_quadraticMesh = aTool.IsQuadraticSubMesh(aShape);
// cube structure

2
src/StdMeshers/StdMeshers_Hexa_3D.hxx
View File

@ -34,7 +34,7 @@
#include "StdMeshers_Quadrangle_2D.hxx"
#include "Utils_SALOME_Exception.hxx"
#include "StdMeshers_Helper.hxx"
#include "SMESH_MesherHelper.hxx"
typedef struct point3Dstruct
{

6
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
View File

@ -217,7 +217,7 @@ bool StdMeshers_MEFISTO_2D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh
int iw = 1;
int nbpnt = 0;
myTool = new StdMeshers_Helper(aMesh);
myTool = new SMESH_MesherHelper(aMesh);
_quadraticMesh = myTool->IsQuadraticSubMesh(aShape);
if ( _quadraticMesh && _hypLengthFromEdges )
@ -431,7 +431,7 @@ static bool fixCommonVertexUV (gp_Pnt2d & theUV,
while ( nIt->more() ) {
const SMDS_MeshNode* node = nIt->next();
// check if node is medium
if ( CreateQuadratic && StdMeshers_Helper::IsMedium( node, SMDSAbs_Edge ))
if ( CreateQuadratic && SMESH_MesherHelper::IsMedium( node, SMDSAbs_Edge ))
continue;
const SMDS_EdgePosition* epos =
static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
@ -527,7 +527,7 @@ bool StdMeshers_MEFISTO_2D::LoadPoints(SMESH_Mesh & aMesh,
while ( nodeIt->more() )
{
node = nodeIt->next();
if ( _quadraticMesh && StdMeshers_Helper::IsMedium( node, SMDSAbs_Edge ))
if ( _quadraticMesh && SMESH_MesherHelper::IsMedium( node, SMDSAbs_Edge ))
continue;
const SMDS_EdgePosition* epos =
static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());

4
src/StdMeshers/StdMeshers_MEFISTO_2D.hxx
View File

@ -33,7 +33,7 @@
#include "SMESH_2D_Algo.hxx"
#include <TopoDS_Wire.hxx>
#include "StdMeshers_Helper.hxx"
#include "SMESH_MesherHelper.hxx"
class SMDS_MeshNode;
class TopTools_IndexedDataMapOfShapeListOfShape;
@ -98,7 +98,7 @@ protected:
TopoDS_Wire myOuterWire;
std::list<const SMDS_MeshNode*> myNodesOnCommonV;
StdMeshers_Helper* myTool; // toll for working with quadratic elements
SMESH_MesherHelper* myTool; // toll for working with quadratic elements
};
#endif

2
src/StdMeshers/StdMeshers_Penta_3D.cxx
View File

@ -108,7 +108,7 @@ bool StdMeshers_Penta_3D::Compute(SMESH_Mesh& aMesh,
return bOK;
}
myTool = new StdMeshers_Helper(aMesh);
myTool = new SMESH_MesherHelper(aMesh);
myCreateQuadratic = myTool->IsQuadraticSubMesh(aShape);
//

4
src/StdMeshers/StdMeshers_Penta_3D.hxx
View File

@ -43,7 +43,7 @@
#include "SMESH_Block.hxx"
#include "StdMeshers_Helper.hxx"
#include "SMESH_MesherHelper.hxx"
typedef std::map< double, std::vector<const SMDS_MeshNode*> > StdMeshers_IJNodeMap;
@ -256,7 +256,7 @@ class StdMeshers_Penta_3D {
vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
bool myCreateQuadratic;
StdMeshers_Helper* myTool; // toll for working with quadratic elements
SMESH_MesherHelper* myTool; // toll for working with quadratic elements
};
#endif

2
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

@ -133,7 +133,7 @@ bool StdMeshers_Quadrangle_2D::Compute (SMESH_Mesh& aMesh,
aMesh.GetSubMesh(aShape);
if ( !myTool )
myTool = new StdMeshers_Helper(aMesh);
myTool = new SMESH_MesherHelper(aMesh);
_quadraticMesh = myTool->IsQuadraticSubMesh(aShape);
//FaceQuadStruct *quad = CheckAnd2Dcompute(aMesh, aShape);

4
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -36,7 +36,7 @@
#include "gp_XY.hxx"
#include "StdMeshers_Helper.hxx"
#include "SMESH_MesherHelper.hxx"
//class SMDS_MeshNode;
@ -131,7 +131,7 @@ protected:
// is not the same in the case where the global number of nodes on edges is even
bool myQuadranglePreference;
StdMeshers_Helper* myTool; // toll for working with quadratic elements
SMESH_MesherHelper* myTool; // toll for working with quadratic elements
};
#endif