}
// nb rows of nodes
- size_t prevNbRows = theParam2ColumnMap.begin()->second.size(); // current, at least 1 here
+ size_t prevNbRows = theParam2ColumnMap.begin()->second.size(); // current, at least 1 here
size_t expectNbRows = faceSubMesh->NbElements() / ( theParam2ColumnMap.size()-1 ); // to be added
// fill theParam2ColumnMap column by column by passing from nodes on
};
// is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
- int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
+ int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
#ifdef _DEBUG_
// check if functName is complete, compilation failure means that enum FunctorType changed
const int nbFunctors = sizeof(functName) / sizeof(const char*);
- int _assert[( nbFunctors == SMESH::FT_Undefined + 1 ) ? 2 : -1 ]; _assert[0]=_assert[1];
+ int _assert[( nbFunctors == SMESH::FT_Undefined + 1 ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
#endif
return functName;
const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
{ // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
const int nbNames = sizeof(typeNames) / sizeof(const char*);
- int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1];
+ int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
}
string groupName = "Gr";
SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( myCurrentStudy, theMeshesArray[i] );
## Return an element based on all given nodes.
# @ingroup l1_meshinfo
- def FindElementByNodes(self,nodes):
+ def FindElementByNodes(self, nodes):
return self.mesh.FindElementByNodes(nodes)
+ ## Return elements including all given nodes.
+ # @ingroup l1_meshinfo
+ def GetElementsByNodes(self, nodes, elemType=SMESH.ALL):
+ return self.mesh.GetElementsByNodes( nodes, elemType )
+
## Return true if the given element is a polygon
# @ingroup l1_meshinfo
def IsPoly(self, id):
*/
//================================================================================
-StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
- std::list<TopoDS_Edge>& theEdges,
- SMESH_Mesh* theMesh,
- const bool theIsForward,
- const bool theIgnoreMediumNodes,
- SMESH_MesherHelper* theFaceHelper,
- SMESH_ProxyMesh::Ptr theProxyMesh)
+StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
+ const std::list<TopoDS_Edge>& theEdges,
+ SMESH_Mesh* theMesh,
+ const bool theIsForward,
+ const bool theIgnoreMediumNodes,
+ SMESH_MesherHelper* theFaceHelper,
+ SMESH_ProxyMesh::Ptr theProxyMesh)
{
int nbEdges = theEdges.size();
myEdge.resize ( nbEdges );
SMESHDS_Mesh* meshDS = myProxyMesh->GetMeshDS();
int nbDegen = 0;
- std::list<TopoDS_Edge>::iterator edge = theEdges.begin();
+ std::list<TopoDS_Edge>::const_iterator edge = theEdges.begin();
for ( int index = 0; edge != theEdges.end(); ++index, ++edge )
{
int i = theIsForward ? index : nbEdges-index-1;
/*!
* \brief Wrap several edges. Edges must be properly ordered and oriented.
*/
- StdMeshers_FaceSide(const TopoDS_Face& theFace,
- std::list<TopoDS_Edge>& theEdges,
- SMESH_Mesh* theMesh,
- const bool theIsForward,
- const bool theIgnoreMediumNodes,
- SMESH_MesherHelper* theFaceHelper = NULL,
- SMESH_ProxyMesh::Ptr theProxyMesh = SMESH_ProxyMesh::Ptr());
+ StdMeshers_FaceSide(const TopoDS_Face& theFace,
+ const std::list<TopoDS_Edge>& theEdges,
+ SMESH_Mesh* theMesh,
+ const bool theIsForward,
+ const bool theIgnoreMediumNodes,
+ SMESH_MesherHelper* theFaceHelper = NULL,
+ SMESH_ProxyMesh::Ptr theProxyMesh = SMESH_ProxyMesh::Ptr());
/*!
* \brief Simulate a side from a vertex using data from other FaceSide
*/
{ return StdMeshers_FaceSidePtr
( new StdMeshers_FaceSide( Face,Edge,Mesh,IsForward,IgnoreMediumNodes,FaceHelper,ProxyMesh ));
}
- static StdMeshers_FaceSidePtr New (const TopoDS_Face& Face,
- std::list<TopoDS_Edge>& Edges,
- SMESH_Mesh* Mesh,
- const bool IsForward,
- const bool IgnoreMediumNodes,
- SMESH_MesherHelper* FaceHelper = NULL,
- SMESH_ProxyMesh::Ptr ProxyMesh = SMESH_ProxyMesh::Ptr())
+ static StdMeshers_FaceSidePtr New (const TopoDS_Face& Face,
+ const std::list<TopoDS_Edge>& Edges,
+ SMESH_Mesh* Mesh,
+ const bool IsForward,
+ const bool IgnoreMediumNodes,
+ SMESH_MesherHelper* FaceHelper = NULL,
+ SMESH_ProxyMesh::Ptr ProxyMesh = SMESH_ProxyMesh::Ptr())
{ return StdMeshers_FaceSidePtr
( new StdMeshers_FaceSide( Face,Edges,Mesh,IsForward,IgnoreMediumNodes,FaceHelper,ProxyMesh ));
}
( new StdMeshers_FaceSide( Side,Node,Pnt2d1,Pnt2d2,C2d,UFirst,ULast ));
}
static StdMeshers_FaceSidePtr New (UVPtStructVec& theSideNodes,
- const TopoDS_Face& theFace = TopoDS_Face())
+ const TopoDS_Face& theFace = TopoDS_Face(),
+ const TopoDS_Edge& theEdge = TopoDS_Edge(),
+ SMESH_Mesh* theMesh = 0)
{
- return StdMeshers_FaceSidePtr( new StdMeshers_FaceSide( theSideNodes, theFace ));
+ return StdMeshers_FaceSidePtr( new StdMeshers_FaceSide( theSideNodes, theFace, theEdge, theMesh ));
}
/*!
#include <Geom2d_Line.hxx>
#include <GeomLib_IsPlanarSurface.hxx>
#include <Geom_Curve.hxx>
+#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
// Projections on the top and bottom faces are taken from nodes existing
// on these faces; find correspondence between bottom and top nodes
- myUseBlock = false;
+ myUseBlock = false; // is set to true if projection is done using "block approach"
myBotToColumnMap.clear();
if ( !assocOrProjBottom2Top( bottomToTopTrsf, thePrism ) ) // it also fills myBotToColumnMap
return false;
// Create nodes inside the block
- // use transformation (issue 0020680, IPAL0052499)
- StdMeshers_Sweeper sweeper;
- double tol;
- bool allowHighBndError;
-
if ( !myUseBlock )
{
+ // use transformation (issue 0020680, IPAL0052499) or a "straight line" approach
+ StdMeshers_Sweeper sweeper;
+
// load boundary nodes into sweeper
bool dummy;
+ const SMDS_MeshNode* prevN0 = 0, *prevN1 = 0;
list< TopoDS_Edge >::const_iterator edge = thePrism.myBottomEdges.begin();
for ( ; edge != thePrism.myBottomEdges.end(); ++edge )
{
int edgeID = meshDS->ShapeToIndex( *edge );
TParam2ColumnMap* u2col = const_cast<TParam2ColumnMap*>
( myBlock.GetParam2ColumnMap( edgeID, dummy ));
- TParam2ColumnMap::iterator u2colIt = u2col->begin();
- for ( ; u2colIt != u2col->end(); ++u2colIt )
+
+ TParam2ColumnMap::iterator u2colIt = u2col->begin(), u2colEnd = u2col->end();
+ const SMDS_MeshNode* n0 = u2colIt->second[0];
+ const SMDS_MeshNode* n1 = u2col->rbegin()->second[0];
+ if ( n0 == prevN0 || n0 == prevN1 ) ++u2colIt;
+ if ( n1 == prevN0 || n1 == prevN1 ) --u2colEnd;
+ prevN0 = n0; prevN1 = n1;
+
+ for ( ; u2colIt != u2colEnd; ++u2colIt )
sweeper.myBndColumns.push_back( & u2colIt->second );
}
- // load node columns inside the bottom face
+ // load node columns inside the bottom FACE
TNode2ColumnMap::iterator bot_column = myBotToColumnMap.begin();
+ sweeper.myIntColumns.reserve( myBotToColumnMap.size() );
for ( ; bot_column != myBotToColumnMap.end(); ++bot_column )
sweeper.myIntColumns.push_back( & bot_column->second );
- tol = getSweepTolerance( thePrism );
- allowHighBndError = !isSimpleBottom( thePrism );
- }
+ myHelper->SetElementsOnShape( true );
- if ( !myUseBlock && sweeper.ComputeNodes( *myHelper, tol, allowHighBndError ))
- {
+ // If all "vertical" EDGEs are straight, then all nodes of an internal node column
+ // are located on a line connecting the top node and the bottom node.
+ bool isStrightColunm = allVerticalEdgesStraight( thePrism );
+ if ( !isStrightColunm )
+ {
+ double tol = getSweepTolerance( thePrism );
+ bool allowHighBndError = !isSimpleBottom( thePrism );
+ myUseBlock = !sweeper.ComputeNodes( *myHelper, tol, allowHighBndError );
+ }
+ else if ( sweeper.CheckSameZ() )
+ {
+ myUseBlock = !sweeper.ComputeNodesOnStraightSameZ( *myHelper );
+ }
+ else
+ {
+ myUseBlock = !sweeper.ComputeNodesOnStraight( *myHelper, thePrism.myBottom, thePrism.myTop );
+ }
+ myHelper->SetElementsOnShape( false );
}
- else // use block approach
+
+ if ( myUseBlock ) // use block approach
{
// loop on nodes inside the bottom face
Prism_3D::TNode prevBNode;
bool StdMeshers_Prism_3D::isSimpleBottom( const Prism_3D::TPrismTopo& thePrism )
{
- if ( thePrism.myBottomEdges.size() != 4 )
+ if ( thePrism.myNbEdgesInWires.front() != 4 )
return false;
// analyse angles between edges
return true;
}
+//=======================================================================
+//function : allVerticalEdgesStraight
+//purpose : Defines if all "vertical" EDGEs are straight
+//=======================================================================
+
+bool StdMeshers_Prism_3D::allVerticalEdgesStraight( const Prism_3D::TPrismTopo& thePrism )
+{
+ for ( size_t i = 0; i < thePrism.myWallQuads.size(); ++i )
+ {
+ const Prism_3D::TQuadList& quads = thePrism.myWallQuads[i];
+ Prism_3D::TQuadList::const_iterator quadIt = quads.begin();
+ TopoDS_Edge prevQuadEdge;
+ for ( ; quadIt != quads.end(); ++quadIt )
+ {
+ StdMeshers_FaceSidePtr rightSide = (*quadIt)->side[ QUAD_RIGHT_SIDE ];
+
+ if ( !prevQuadEdge.IsNull() &&
+ !SMESH_Algo::IsContinuous( rightSide->Edge( 0 ), prevQuadEdge ))
+ return false;
+
+ for ( int iE = 0; iE < rightSide->NbEdges(); ++iE )
+ {
+ const TopoDS_Edge & rightE = rightSide->Edge( iE );
+ if ( !SMESH_Algo::IsStraight( rightE, /*degenResult=*/true ))
+ return false;
+
+ if ( iE > 0 &&
+ !SMESH_Algo::IsContinuous( rightSide->Edge( iE-1 ), rightE ))
+ return false;
+
+ prevQuadEdge = rightE;
+ }
+ }
+ }
+ return true;
+}
+
//=======================================================================
//function : project2dMesh
//purpose : Project mesh faces from a source FACE of one prism (theSrcFace)
//================================================================================
/*!
- * \brief Creates internal nodes of the prism
+ * \brief Create internal nodes of the prism
*/
//================================================================================
return true;
}
+
+//================================================================================
+/*!
+ * \brief Check if all nodes of each layers have same logical Z
+ */
+//================================================================================
+
+bool StdMeshers_Sweeper::CheckSameZ()
+{
+ myZColumns.resize( myBndColumns.size() );
+ fillZColumn( myZColumns[0], *myBndColumns[0] );
+
+ bool sameZ = true;
+ const double tol = 0.1 * 1./ myBndColumns[0]->size();
+
+ // check columns based on VERTEXes
+
+ vector< int > vertexIndex;
+ vertexIndex.push_back( 0 );
+ for ( size_t iC = 1; iC < myBndColumns.size() && sameZ; ++iC )
+ {
+ if ( myBndColumns[iC]->front()->GetPosition()->GetDim() > 0 )
+ continue; // not on VERTEX
+
+ vertexIndex.push_back( iC );
+ fillZColumn( myZColumns[iC], *myBndColumns[iC] );
+
+ for ( size_t iZ = 0; iZ < myZColumns[0].size() && sameZ; ++iZ )
+ sameZ = ( Abs( myZColumns[0][iZ] - myZColumns[iC][iZ]) < tol );
+ }
+
+ // check columns based on EDGEs, one per EDGE
+
+ for ( size_t i = 1; i < vertexIndex.size() && sameZ; ++i )
+ {
+ if ( vertexIndex[i] - vertexIndex[i-1] < 2 )
+ continue;
+
+ int iC = ( vertexIndex[i] + vertexIndex[i-1] ) / 2;
+ fillZColumn( myZColumns[iC], *myBndColumns[iC] );
+
+ for ( size_t iZ = 0; iZ < myZColumns[0].size() && sameZ; ++iZ )
+ sameZ = ( Abs( myZColumns[0][iZ] - myZColumns[iC][iZ]) < tol );
+ }
+
+ if ( sameZ )
+ {
+ myZColumns.resize(1);
+ }
+ else
+ {
+ for ( size_t iC = 1; iC < myBndColumns.size(); ++iC )
+ fillZColumn( myZColumns[iC], *myBndColumns[iC] );
+ }
+
+ return sameZ;
+}
+
+//================================================================================
+/*!
+ * \brief Create internal nodes of the prism all located on straight lines with
+ * the same distribution along the lines.
+ */
+//================================================================================
+
+bool StdMeshers_Sweeper::ComputeNodesOnStraightSameZ( SMESH_MesherHelper& helper )
+{
+ TZColumn& z = myZColumns[0];
+
+ for ( size_t i = 0; i < myIntColumns.size(); ++i )
+ {
+ TNodeColumn& nodes = *myIntColumns[i];
+ SMESH_NodeXYZ n0( nodes[0] ), n1( nodes.back() );
+
+ for ( size_t iZ = 0; iZ < z.size(); ++iZ )
+ {
+ gp_XYZ p = n0 * ( 1 - z[iZ] ) + n1 * z[iZ];
+ nodes[ iZ+1 ] = helper.AddNode( p.X(), p.Y(), p.Z() );
+ }
+ }
+
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Create internal nodes of the prism all located on straight lines with
+ * different distributions along the lines.
+ */
+//================================================================================
+
+bool StdMeshers_Sweeper::ComputeNodesOnStraight( SMESH_MesherHelper& helper,
+ const TopoDS_Face& botFace,
+ const TopoDS_Face& topFace )
+{
+ // get data to create a Morph
+ UVPtStructVec botUV( myBndColumns.size() + 1 );
+ UVPtStructVec topUV( myBndColumns.size() + 1 );
+ for ( size_t i = 0; i < myBndColumns.size(); ++i )
+ {
+ TNodeColumn& nodes = *myBndColumns[i];
+ botUV[i].node = nodes[0];
+ botUV[i].SetUV( helper.GetNodeUV( botFace, nodes[0] ));
+ topUV[i].node = nodes.back();
+ topUV[i].SetUV( helper.GetNodeUV( topFace, nodes.back() ));
+ botUV[i].node->setIsMarked( true );
+ }
+ botUV.back() = botUV[0];
+ topUV.back() = topUV[0];
+
+ TopoDS_Edge dummyE;
+ TSideVector botWires( 1, StdMeshers_FaceSide::New( botUV, botFace, dummyE, helper.GetMesh() ));
+ TSideVector topWires( 1, StdMeshers_FaceSide::New( topUV, topFace, dummyE, helper.GetMesh() ));
+
+ // use Morph to make delauney mesh on the FACEs. Locating of a node within a
+ // delauney triangle will be used to get a weighted Z.
+ NSProjUtils::Morph botDelauney( botWires );
+ NSProjUtils::Morph topDelauney( topWires );
+
+ if ( helper.GetIsQuadratic() )
+ {
+ // mark all medium nodes of faces on botFace to avoid their treating
+ SMESHDS_SubMesh* smDS = helper.GetMeshDS()->MeshElements( botFace );
+ SMDS_ElemIteratorPtr eIt = smDS->GetElements();
+ while ( eIt->more() )
+ {
+ const SMDS_MeshElement* e = eIt->next();
+ for ( int i = e->NbCornerNodes(), nb = e->NbNodes(); i < nb; ++i )
+ e->GetNode( i )->setIsMarked( true );
+ }
+ }
+
+ // map to get a node column by a bottom node
+ TColStd_DataMapOfIntegerInteger iNode2iCol( myIntColumns.size() );
+
+ // un-mark nodes to treat (internal bottom nodes); later we will mark treated nodes
+ for ( size_t i = 0; i < myIntColumns.size(); ++i )
+ {
+ const SMDS_MeshNode* botNode = myIntColumns[i]->front();
+ botNode->setIsMarked( false );
+ iNode2iCol.Bind( botNode->GetID(), i );
+ }
+
+ const int botFaceID = helper.GetMesh()->GetSubMesh( botFace )->GetId();
+ const SMDS_MeshNode *botNode, *topNode;
+ const BRepMesh_Triangle *botTria, *topTria;
+ double botBC[3], topBC[3]; // barycentric coordinates
+ int botTriaNodes[3], topTriaNodes[3];
+ bool checkUV = true;
+
+ // a queue of bottom nodes with starting delauney triangles
+ NSProjUtils::Morph::TNodeTriaList botNoTriQueue;
+
+ size_t iBndN = 1; // index of a bottom boundary node
+ int nbNodesToProcess = myIntColumns.size();
+ while ( nbNodesToProcess > 0 )
+ {
+ while ( !botNoTriQueue.empty() ) // treat all nodes in the queue
+ {
+ botNode = botNoTriQueue.front().first;
+ botTria = botNoTriQueue.front().second;
+ botNoTriQueue.pop_front();
+ if ( botNode->isMarked() )
+ continue;
+ --nbNodesToProcess;
+ botNode->setIsMarked( true );
+
+ TNodeColumn* column = myIntColumns[ iNode2iCol( botNode->GetID() )];
+
+ // find a delauney triangle containing the botNode
+ gp_XY botUV = helper.GetNodeUV( botFace, botNode, NULL, &checkUV );
+ botUV *= botDelauney.GetScale();
+ botTria = botDelauney.FindTriangle( botUV, botTria, botBC, botTriaNodes );
+ if ( !botTria )
+ return false;
+
+ // find a delauney triangle containing the topNode
+ topNode = column->back();
+ gp_XY topUV = helper.GetNodeUV( topFace, topNode, NULL, &checkUV );
+ topUV *= topDelauney.GetScale();
+ // get a starting triangle basing on that top and bot boundary nodes have same index
+ topTria = topDelauney.GetTriangleNear( botTriaNodes[0] );
+ topTria = topDelauney.FindTriangle( topUV, topTria, topBC, topTriaNodes );
+ if ( !topTria )
+ return false;
+
+ // create nodes along a line
+ SMESH_NodeXYZ botP( botNode ), topP( topNode);
+ for ( size_t iZ = 0; iZ < myZColumns[0].size(); ++iZ )
+ {
+ // use barycentric coordinates as weight of Z of boundary columns
+ double botZ = 0, topZ = 0;
+ for ( int i = 0; i < 3; ++i )
+ {
+ botZ += botBC[i] * myZColumns[ botTriaNodes[i]-1 ][ iZ ];
+ topZ += topBC[i] * myZColumns[ topTriaNodes[i]-1 ][ iZ ];
+ }
+ double rZ = double( iZ + 1 ) / ( myZColumns[0].size() + 1 );
+ double z = botZ * ( 1 - rZ ) + topZ * rZ;
+ gp_XYZ p = botP * ( 1 - z ) + topP * z;
+ (*column)[ iZ+1 ] = helper.AddNode( p.X(), p.Y(), p.Z() );
+ }
+
+ // add neighbor nodes to the queue
+ botDelauney.AddCloseNodes( botNode, botTria, botFaceID, botNoTriQueue );
+ }
+
+ if ( nbNodesToProcess > 0 ) // fill the queue
+ {
+ // assure that all bot nodes are visited
+ for ( ; iBndN-1 < myBndColumns.size() && botNoTriQueue.empty(); ++iBndN )
+ {
+ botTria = botDelauney.GetTriangleNear( iBndN );
+ const SMDS_MeshNode* bndNode = botDelauney.GetBndNodes()[ iBndN ];
+ botDelauney.AddCloseNodes( bndNode, botTria, botFaceID, botNoTriQueue );
+ }
+ if ( botNoTriQueue.empty() )
+ {
+ for ( size_t i = 0; i < myIntColumns.size(); ++i )
+ {
+ botNode = myIntColumns[i]->front();
+ if ( !botNode->isMarked() )
+ botNoTriQueue.push_back( make_pair( botNode, botTria ));
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Compute Z of nodes of a straight column
+ */
+//================================================================================
+
+void StdMeshers_Sweeper::fillZColumn( TZColumn& zColumn,
+ TNodeColumn& nodes )
+{
+ if ( zColumn.size() == nodes.size() - 2 )
+ return;
+
+ gp_Pnt p0 = SMESH_NodeXYZ( nodes[0] );
+ gp_Vec line( p0, SMESH_NodeXYZ( nodes.back() ));
+ double len2 = line.SquareMagnitude();
+
+ zColumn.resize( nodes.size() - 2 );
+ for ( size_t i = 0; i < zColumn.size(); ++i )
+ {
+ gp_Vec vec( p0, SMESH_NodeXYZ( nodes[ i+1] ));
+ zColumn[i] = ( line * vec ) / len2; // param [0,1] on the line
+ }
+}
#include "SMESH_StdMeshers.hxx"
-#include "SMDS_MeshNode.hxx"
-#include "SMDS_TypeOfPosition.hxx"
#include "SMESHDS_Mesh.hxx"
-#include "SMESH_Algo.hxx"
#include "SMESH_Block.hxx"
-#include "SMESH_Comment.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_TypeDefs.hxx"
+#include "SMESH_Comment.hxx"
#include "SMESH_subMesh.hxx"
#include <Adaptor2d_Curve2d.hxx>
std::vector< TNodeColumn* > myBndColumns; // boundary nodes
std::vector< TNodeColumn* > myIntColumns; // internal nodes
+ typedef std::vector< double > TZColumn;
+ std::vector< TZColumn > myZColumns; // Z distribution of boundary nodes
+
bool ComputeNodes( SMESH_MesherHelper& helper,
const double tol,
const bool allowHighBndError );
+ bool CheckSameZ();
+
+ bool ComputeNodesOnStraightSameZ( SMESH_MesherHelper& helper );
+
+ bool ComputeNodesOnStraight( SMESH_MesherHelper& helper,
+ const TopoDS_Face& bottom,
+ const TopoDS_Face& top);
+
private:
gp_XYZ bndPoint( int iP, int z ) const
const double r,
std::vector< gp_XYZ >& toIntPoints,
std::vector< double >& int2BndDist);
+
+ static void fillZColumn( TZColumn& zColumn,
+ TNodeColumn& nodes );
};
// ===============================================
*/
bool isSimpleBottom( const Prism_3D::TPrismTopo& thePrism );
+ /*!
+ * \brief Defines if all "vertical" EDGEs are straight
+ */
+ bool allVerticalEdgesStraight( const Prism_3D::TPrismTopo& thePrism );
+
/*!
* \brief Project mesh faces from a source FACE of one prism to
* a source FACE of another prism
*/
//================================================================================
- typedef list< pair< const SMDS_MeshNode*, const BRepMesh_Triangle* > > TNodeTriaList;
-
- void addCloseNodes( const SMDS_MeshNode* srcNode,
- const BRepMesh_Triangle* bmTria,
- const int srcFaceID,
- TNodeTriaList & noTriQueue )
+ void Morph::AddCloseNodes( const SMDS_MeshNode* srcNode,
+ const BRepMesh_Triangle* bmTria,
+ const int srcFaceID,
+ TNodeTriaList & noTriQueue )
{
// find in-FACE nodes
SMDS_ElemIteratorPtr elems = srcNode->GetInverseElementIterator(SMDSAbs_Face);
for ( int i = 0, nb = elem->NbNodes(); i < nb; ++i )
{
const SMDS_MeshNode* n = elem->GetNode( i );
- if ( !n->isMarked() )
+ if ( !n->isMarked() /*&& n->getshapeId() == srcFaceID*/ )
noTriQueue.push_back( make_pair( n, bmTria ));
}
}
*/
//================================================================================
- const BRepMesh_Triangle* findTriangle( const gp_XY& uv,
- const BRepMesh_Triangle* bmTria,
- Handle(BRepMesh_DataStructureOfDelaun)& triaDS,
- double bc[3] )
+ const BRepMesh_Triangle* Morph::FindTriangle( const gp_XY& uv,
+ const BRepMesh_Triangle* bmTria,
+ double bc[3],
+ int triaNodes[3] )
{
int nodeIDs[3];
gp_XY nodeUVs[3];
{
// check bmTria
- triaDS->ElementNodes( *bmTria, nodeIDs );
- nodeUVs[0] = triaDS->GetNode( nodeIDs[0] ).Coord();
- nodeUVs[1] = triaDS->GetNode( nodeIDs[1] ).Coord();
- nodeUVs[2] = triaDS->GetNode( nodeIDs[2] ).Coord();
+ _triaDS->ElementNodes( *bmTria, nodeIDs );
+ nodeUVs[0] = _triaDS->GetNode( nodeIDs[0] ).Coord();
+ nodeUVs[1] = _triaDS->GetNode( nodeIDs[1] ).Coord();
+ nodeUVs[2] = _triaDS->GetNode( nodeIDs[2] ).Coord();
SMESH_MeshAlgos::GetBarycentricCoords( uv,
nodeUVs[0], nodeUVs[1], nodeUVs[2],
if ( bc[0] >= 0 && bc[1] >= 0 && bc[0] + bc[1] <= 1 )
{
bc[2] = 1 - bc[0] - bc[1];
+ triaNodes[0] = nodeIDs[0];
+ triaNodes[1] = nodeIDs[1];
+ triaNodes[2] = nodeIDs[2];
return bmTria;
}
gp_XY seg = uv - gc;
bmTria->Edges( linkIDs, ori );
- int triaID = triaDS->IndexOf( *bmTria );
+ int triaID = _triaDS->IndexOf( *bmTria );
bmTria = 0;
for ( int i = 0; i < 3; ++i )
{
- const BRepMesh_PairOfIndex & triIDs = triaDS->ElementsConnectedTo( linkIDs[i] );
+ const BRepMesh_PairOfIndex & triIDs = _triaDS->ElementsConnectedTo( linkIDs[i] );
if ( triIDs.Extent() < 2 )
continue; // no neighbor triangle
// check if a link intersects gc2uv
- const BRepMesh_Edge & link = triaDS->GetLink( linkIDs[i] );
- const BRepMesh_Vertex & n1 = triaDS->GetNode( link.FirstNode() );
- const BRepMesh_Vertex & n2 = triaDS->GetNode( link.LastNode() );
+ const BRepMesh_Edge & link = _triaDS->GetLink( linkIDs[i] );
+ const BRepMesh_Vertex & n1 = _triaDS->GetNode( link.FirstNode() );
+ const BRepMesh_Vertex & n2 = _triaDS->GetNode( link.LastNode() );
gp_XY uv1 = n1.Coord();
gp_XY lin = n2.Coord() - uv1; // link direction
double uSeg = ( uv1 - gc ) ^ lin / crossSegLin;
if ( 0. <= uSeg && uSeg <= 1. )
{
- bmTria = & triaDS->GetElement( triIDs.Index( 1 + ( triIDs.Index(1) == triaID )));
+ bmTria = & _triaDS->GetElement( triIDs.Index( 1 + ( triIDs.Index(1) == triaID )));
break;
}
}
return bmTria;
}
+ //================================================================================
+ /*!
+ * \brief Return a triangle sharing a given boundary node
+ * \param [in] iBndNode - index of the boundary node
+ * \return const BRepMesh_Triangle* - a found triangle
+ */
+ //================================================================================
+
+ const BRepMesh_Triangle* Morph::GetTriangleNear( int iBndNode )
+ {
+ const BRepMesh::ListOfInteger & linkIds = _triaDS->LinksConnectedTo( iBndNode );
+ const BRepMesh_PairOfIndex & triaIds = _triaDS->ElementsConnectedTo( linkIds.First() );
+ const BRepMesh_Triangle& tria = _triaDS->GetElement( triaIds.Index(1) );
+ return &tria;
+ }
+
//================================================================================
/*!
* \brief triangulate the srcFace in 2D
const SMDS_MeshNode *srcNode, *tgtNode;
const BRepMesh_Triangle *bmTria;
- // initialize a queue of nodes with starting triangles
- TNodeTriaList noTriQueue;
- size_t iBndSrcN = 1;
- for ( ; iBndSrcN < _bndSrcNodes.size() && noTriQueue.empty(); ++iBndSrcN )
- {
- // get a triangle
- const BRepMesh::ListOfInteger & linkIds = _triaDS->LinksConnectedTo( iBndSrcN );
- const BRepMesh_PairOfIndex & triaIds = _triaDS->ElementsConnectedTo( linkIds.First() );
- const BRepMesh_Triangle& tria = _triaDS->GetElement( triaIds.Index(1) );
-
- addCloseNodes( _bndSrcNodes[ iBndSrcN ], &tria, srcFaceID, noTriQueue );
- }
-
// un-mark internal src nodes; later we will mark moved nodes
int nbSrcNodes = 0;
SMDS_NodeIteratorPtr nIt = _srcSubMesh->GetSubMeshDS()->GetNodes();
bool checkUV = true;
const SMDS_FacePosition* pos;
+ // a queue of nodes with starting triangles
+ TNodeTriaList noTriQueue;
+ size_t iBndSrcN = 1;
+
while ( nbSrcNodes > 0 )
{
while ( !noTriQueue.empty() )
// find a delauney triangle containing the src node
gp_XY uv = tgtHelper.GetNodeUV( srcFace, srcNode, NULL, &checkUV );
uv *= _scale;
- bmTria = findTriangle( uv, bmTria, _triaDS, bc );
+ bmTria = FindTriangle( uv, bmTria, bc, nodeIDs );
if ( !bmTria )
continue;
// compute new coordinates for a corresponding tgt node
gp_XY uvNew( 0., 0. ), nodeUV;
- _triaDS->ElementNodes( *bmTria, nodeIDs );
for ( int i = 0; i < 3; ++i )
uvNew += bc[i] * tgtVert( nodeIDs[i]).Coord();
- uvNew.SetCoord( uvNew.X() / _scale.X(), uvNew.Y() / _scale.Y() );
+ uvNew.SetCoord( uvNew.X() / _scale.X(),
+ uvNew.Y() / _scale.Y() );
gp_Pnt xyz = tgtSurface->Value( uvNew );
// find and move tgt node
if (( pos = dynamic_cast< const SMDS_FacePosition* >( tgtNode->GetPosition() )))
const_cast<SMDS_FacePosition*>( pos )->SetParameters( uvNew.X(), uvNew.Y() );
- addCloseNodes( srcNode, bmTria, srcFaceID, noTriQueue );
+ AddCloseNodes( srcNode, bmTria, srcFaceID, noTriQueue );
}
if ( nbSrcNodes > 0 )
// assure that all src nodes are visited
for ( ; iBndSrcN < _bndSrcNodes.size() && noTriQueue.empty(); ++iBndSrcN )
{
- const BRepMesh::ListOfInteger & linkIds = _triaDS->LinksConnectedTo( iBndSrcN );
- const BRepMesh_PairOfIndex & triaIds = _triaDS->ElementsConnectedTo( linkIds.First() );
- const BRepMesh_Triangle& tria = _triaDS->GetElement( triaIds.Index(1) );
- addCloseNodes( _bndSrcNodes[ iBndSrcN ], &tria, srcFaceID, noTriQueue );
+ const BRepMesh_Triangle* tria = GetTriangleNear( iBndSrcN );
+ AddCloseNodes( _bndSrcNodes[ iBndSrcN ], tria, srcFaceID, noTriQueue );
}
if ( noTriQueue.empty() )
{
} // Morph::Perform
-gp_XY Morph::GetBndUV(const int iNode) const
-{
+ gp_XY Morph::GetBndUV(const int iNode) const
+ {
return _triaDS->GetNode( iNode ).Coord();
}
const TNodeNodeMap& src2tgtNodes,
const bool moveAll);
- // return source boundary nodes. 0-th node is zero
+ // find a triangle containing an UV starting from a given triangle;
+ // return barycentric coordinates of the UV in the found triangle
+ const BRepMesh_Triangle* FindTriangle( const gp_XY& uv,
+ const BRepMesh_Triangle* bmTria,
+ double bc[3],
+ int triaNodes[3]);
+
+ // return any delauney triangle neighboring a given boundary node
+ const BRepMesh_Triangle* GetTriangleNear( int iBndNode );
+
+ // return source boundary nodes. 0-th node is NULL so that indices of
+ // boundary nodes correspond to indices used by Delauney mesh
const std::vector< const SMDS_MeshNode* >& GetBndNodes() const { return _bndSrcNodes; }
// return UV of the i-th source boundary node
gp_XY GetBndUV(const int iNode) const;
+
+ // return scale factor to convert real UV to/from UV used for Delauney meshing:
+ // delauney_UV = real_UV * scale
+ const gp_XY& GetScale() const { return _scale; }
+
+ typedef std::list< std::pair< const SMDS_MeshNode*, const BRepMesh_Triangle* > > TNodeTriaList;
+
+ // add non-marked nodes surrounding a given one to a list
+ static void AddCloseNodes( const SMDS_MeshNode* node,
+ const BRepMesh_Triangle* bmTria,
+ const int faceID,
+ TNodeTriaList & noTriQueue );
};
/*!
{
SMESH_subMesh* faceSM = helper.GetMesh()->GetSubMesh( helper.GetSubShape() );
- if ( helper.IsDistorted2D( faceSM, /*checkUV=*/true ))
+ //if ( helper.IsDistorted2D( faceSM, /*checkUV=*/true ))
{
SMESH_MeshEditor editor( helper.GetMesh() );
SMESHDS_SubMesh* smDS = faceSM->GetSubMeshDS();
