TopoDS_Vertex StdMeshers_Hexa_3D::OppositeVertex(const TopoDS_Vertex& aVertex,
const TopTools_IndexedMapOfShape& aQuads0Vertices,
FaceQuadStruct* aQuads[6])
{
int i, j;
for ( i = 1; i < 6; ++i )
{
TopoDS_Vertex VV[] = { aQuads[i]->side[0]->FirstVertex(),
aQuads[i]->side[0]->LastVertex() ,
aQuads[i]->side[2]->LastVertex() ,
aQuads[i]->side[2]->FirstVertex() };
for ( j = 0; j < 4; ++j )
if ( aVertex.IsSame( VV[ j ]))
break;
if ( j < 4 ) {
int jPrev = j ? j - 1 : 3;
int jNext = (j + 1) % 4;
if ( aQuads0Vertices.Contains( VV[ jPrev ] ))
return VV[ jNext ];
else
return VV[ jPrev ];
}
}
return TopoDS_Vertex();
}
void FaceTypedBase::boundarySplit(const FaceVectorType &facesIn, std::vector<EdgeVectorType> &boundariesOut) const
{
EdgeVectorType bEdges;
boundaryEdges(facesIn, bEdges);
std::list<TopoDS_Edge> edges;
std::copy(bEdges.begin(), bEdges.end(), back_inserter(edges));
while(!edges.empty())
{
TopoDS_Vertex destination = TopExp::FirstVertex(edges.front(), Standard_True);
TopoDS_Vertex lastVertex = TopExp::LastVertex(edges.front(), Standard_True);
EdgeVectorType boundary;
boundary.push_back(edges.front());
edges.pop_front();
//single edge closed check.
if (destination.IsSame(lastVertex))
{
boundariesOut.push_back(boundary);
continue;
}
bool closedSignal(false);
std::list<TopoDS_Edge>::iterator it;
for (it = edges.begin(); it != edges.end();)
{
TopoDS_Vertex currentVertex = TopExp::FirstVertex(*it, Standard_True);
if (lastVertex.IsSame(currentVertex))
{
boundary.push_back(*it);
lastVertex = TopExp::LastVertex(*it, Standard_True);
edges.erase(it);
it = edges.begin();
if (lastVertex.IsSame(destination))
{
closedSignal = true;
break;
}
continue;
}
++it;
}
if (closedSignal)
boundariesOut.push_back(boundary);
}
}
//=======================================================================
// function: PrepareEdges
// purpose:
//=======================================================================
void NMTTools_PaveFiller::PrepareEdges()
{
Standard_Integer i, nV, ii, aNBSuc, ip, aNbShapesObject;
Standard_Real aT;
TopAbs_Orientation anOr;
TopoDS_Edge aE;
TopoDS_Vertex aV;
//
aNbShapesObject=myDS->NumberOfShapesOfTheObject();
for (i=1; i<=myNbSources; ++i) {
if (myDS->GetShapeType(i)==TopAbs_EDGE) {
aE=TopoDS::Edge(myDS->Shape(i));
//
if (BRep_Tool::Degenerated(aE)){
continue;
}
//
BOPTools_PaveSet& aPaveSet=myPavePool(myDS->RefEdge(i));
//
// A <-
aNBSuc=myDS->NumberOfSuccessors(i);
for (ii=1; ii <=aNBSuc; ii++) {
nV=myDS->GetSuccessor(i, ii);
anOr=myDS->GetOrientation(i, ii);
aV=TopoDS::Vertex(myDS->Shape(nV));
aV.Orientation(anOr);
aT=BRep_Tool::Parameter(aV, aE);
//
ip=FindSDVertex(nV);
if (ip) {
aV=TopoDS::Vertex(myDS->Shape(ip));
aV.Orientation(anOr);// XX ? if the edge is closed it'll be amazing result
nV=ip;
}
//
BOPTools_Pave aPave(nV, aT);
aPaveSet.Append (aPave);
}
}
}
}
GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge & E1,
const TopoDS_Edge & E2)
{
TopoDS_Vertex V = TopExp::LastVertex (E1, true);
if ( !V.IsSame( TopExp::FirstVertex(E2, true )))
if ( !TopExp::CommonVertex( E1, E2, V ))
return GeomAbs_C0;
Standard_Real u1 = BRep_Tool::Parameter( V, E1 );
Standard_Real u2 = BRep_Tool::Parameter( V, E2 );
BRepAdaptor_Curve C1( E1 ), C2( E2 );
Standard_Real tol = BRep_Tool::Tolerance( V );
Standard_Real angTol = 2e-3;
try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
#endif
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
}
catch (Standard_Failure) {
}
return GeomAbs_C0;
}
bool operator () (const TopoDS_Vertex &rclV1, const TopoDS_Vertex &rclV2) const
{
if (rclV1.IsSame(rclV2) == Standard_True)
return false;
gp_XYZ clP1 = BRep_Tool::Pnt(rclV1).XYZ();
gp_XYZ clP2 = BRep_Tool::Pnt(rclV2).XYZ();
if (fabs(clP1.X() - clP2.X()) < dE)
{
if (fabs(clP1.Y() - clP2.Y()) < dE)
return clP1.Z() < clP2.Z();
else
return clP1.Y() < clP2.Y();
}
else
return clP1.X() < clP2.X();
}
void FaceTypedCylinder::boundarySplit(const FaceVectorType &facesIn, std::vector<EdgeVectorType> &boundariesOut) const
{
//get all the seam edges
EdgeVectorType seamEdges;
FaceVectorType::const_iterator faceIt;
for (faceIt = facesIn.begin(); faceIt != facesIn.end(); ++faceIt)
{
TopExp_Explorer explorer;
for (explorer.Init(*faceIt, TopAbs_EDGE); explorer.More(); explorer.Next())
{
ShapeAnalysis_Edge edgeCheck;
if(edgeCheck.IsSeam(TopoDS::Edge(explorer.Current()), *faceIt))
seamEdges.push_back(TopoDS::Edge(explorer.Current()));
}
}
//normal edges.
EdgeVectorType normalEdges;
ModelRefine::boundaryEdges(facesIn, normalEdges);
//put seam edges in front.the idea is that we always want to traverse along a seam edge if possible.
std::list<TopoDS_Edge> sortedEdges;
std::copy(normalEdges.begin(), normalEdges.end(), back_inserter(sortedEdges));
std::copy(seamEdges.begin(), seamEdges.end(), front_inserter(sortedEdges));
while (!sortedEdges.empty())
{
//detecting closed boundary works best if we start off of the seam edges.
TopoDS_Vertex destination = TopExp::FirstVertex(sortedEdges.back(), Standard_True);
TopoDS_Vertex lastVertex = TopExp::LastVertex(sortedEdges.back(), Standard_True);
bool closedSignal(false);
std::list<TopoDS_Edge> boundary;
boundary.push_back(sortedEdges.back());
sortedEdges.pop_back();
std::list<TopoDS_Edge>::iterator sortedIt;
for (sortedIt = sortedEdges.begin(); sortedIt != sortedEdges.end();)
{
TopoDS_Vertex currentVertex = TopExp::FirstVertex(*sortedIt, Standard_True);
//Seam edges lie on top of each other. i.e. same. and we remove every match from the list
//so we don't actually ever compare the same edge.
if ((*sortedIt).IsSame(boundary.back()))
{
++sortedIt;
continue;
}
if (lastVertex.IsSame(currentVertex))
{
boundary.push_back(*sortedIt);
lastVertex = TopExp::LastVertex(*sortedIt, Standard_True);
if (lastVertex.IsSame(destination))
{
closedSignal = true;
sortedEdges.erase(sortedIt);
break;
}
sortedEdges.erase(sortedIt);
sortedIt = sortedEdges.begin();
continue;
}
++sortedIt;
}
if (closedSignal)
{
EdgeVectorType temp;
std::copy(boundary.begin(), boundary.end(), std::back_inserter(temp));
boundariesOut.push_back(temp);
}
}
}
bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
const TopoDS_Face& theFace,
const TopoDS_Edge& theBaseEdge,
SMESHDS_Mesh* theMesh)
{
// get vertices of theBaseEdge
TopoDS_Vertex vfb, vlb, vft; // first and last, bottom and top vertices
TopoDS_Edge eFrw = TopoDS::Edge( theBaseEdge.Oriented( TopAbs_FORWARD ));
TopExp::Vertices( eFrw, vfb, vlb );
// find the other edges of theFace and orientation of e1
TopoDS_Edge e1, e2, eTop;
bool rev1, CumOri = false;
TopExp_Explorer exp( theFace, TopAbs_EDGE );
int nbEdges = 0;
for ( ; exp.More(); exp.Next() ) {
if ( ++nbEdges > 4 ) {
return false; // more than 4 edges in theFace
}
TopoDS_Edge e = TopoDS::Edge( exp.Current() );
if ( theBaseEdge.IsSame( e ))
continue;
TopoDS_Vertex vCommon;
if ( !TopExp::CommonVertex( theBaseEdge, e, vCommon ))
eTop = e;
else if ( vCommon.IsSame( vfb )) {
e1 = e;
vft = TopExp::LastVertex( e1, CumOri );
rev1 = vfb.IsSame( vft );
if ( rev1 )
vft = TopExp::FirstVertex( e1, CumOri );
}
else
e2 = e;
}
if ( nbEdges < 4 ) {
return false; // less than 4 edges in theFace
}
if ( e2.IsNull() && vfb.IsSame( vlb ))
e2 = e1;
// submeshes corresponding to shapes
SMESHDS_SubMesh* smFace = theMesh->MeshElements( theFace );
SMESHDS_SubMesh* smb = theMesh->MeshElements( theBaseEdge );
SMESHDS_SubMesh* smt = theMesh->MeshElements( eTop );
SMESHDS_SubMesh* sm1 = theMesh->MeshElements( e1 );
SMESHDS_SubMesh* sm2 = theMesh->MeshElements( e2 );
SMESHDS_SubMesh* smVfb = theMesh->MeshElements( vfb );
SMESHDS_SubMesh* smVlb = theMesh->MeshElements( vlb );
SMESHDS_SubMesh* smVft = theMesh->MeshElements( vft );
if (!smFace || !smb || !smt || !sm1 || !sm2 || !smVfb || !smVlb || !smVft ) {
RETURN_BAD_RESULT( "NULL submesh " <<smFace<<" "<<smb<<" "<<smt<<" "<<
sm1<<" "<<sm2<<" "<<smVfb<<" "<<smVlb<<" "<<smVft);
}
if ( smb->NbNodes() != smt->NbNodes() || sm1->NbNodes() != sm2->NbNodes() ) {
RETURN_BAD_RESULT(" Diff nb of nodes on opposite edges" );
}
if (smVfb->NbNodes() != 1 || smVlb->NbNodes() != 1 || smVft->NbNodes() != 1) {
RETURN_BAD_RESULT("Empty submesh of vertex");
}
// define whether mesh is quadratic
bool isQuadraticMesh = false;
SMDS_ElemIteratorPtr eIt = smFace->GetElements();
if ( !eIt->more() ) {
RETURN_BAD_RESULT("No elements on the face");
}
const SMDS_MeshElement* e = eIt->next();
isQuadraticMesh = e->IsQuadratic();
if ( sm1->NbNodes() * smb->NbNodes() != smFace->NbNodes() ) {
// check quadratic case
if ( isQuadraticMesh ) {
// what if there are quadrangles and triangles mixed?
// int n1 = sm1->NbNodes()/2;
// int n2 = smb->NbNodes()/2;
// int n3 = sm1->NbNodes() - n1;
// int n4 = smb->NbNodes() - n2;
// int nf = sm1->NbNodes()*smb->NbNodes() - n3*n4;
// if( nf != smFace->NbNodes() ) {
// MESSAGE( "Wrong nb face nodes: " <<
// sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
// return false;
// }
}
else {
RETURN_BAD_RESULT( "Wrong nb face nodes: " <<
sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
}
}
// IJ size
int vsize = sm1->NbNodes() + 2;
int hsize = smb->NbNodes() + 2;
if(isQuadraticMesh) {
vsize = vsize - sm1->NbNodes()/2 -1;
hsize = hsize - smb->NbNodes()/2 -1;
}
// load nodes from theBaseEdge
std::set<const SMDS_MeshNode*> loadedNodes;
const SMDS_MeshNode* nullNode = 0;
std::vector<const SMDS_MeshNode*> & nVecf = theParam2ColumnMap[ 0.];
nVecf.resize( vsize, nullNode );
loadedNodes.insert( nVecf[ 0 ] = smVfb->GetNodes()->next() );
std::vector<const SMDS_MeshNode*> & nVecl = theParam2ColumnMap[ 1.];
nVecl.resize( vsize, nullNode );
loadedNodes.insert( nVecl[ 0 ] = smVlb->GetNodes()->next() );
double f, l;
BRep_Tool::Range( eFrw, f, l );
double range = l - f;
SMDS_NodeIteratorPtr nIt = smb->GetNodes();
const SMDS_MeshNode* node;
while ( nIt->more() ) {
node = nIt->next();
if(IsMedium(node, SMDSAbs_Edge))
continue;
const SMDS_EdgePosition* pos =
dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() );
if ( !pos ) {
return false;
}
double u = ( pos->GetUParameter() - f ) / range;
std::vector<const SMDS_MeshNode*> & nVec = theParam2ColumnMap[ u ];
nVec.resize( vsize, nullNode );
loadedNodes.insert( nVec[ 0 ] = node );
}
if ( theParam2ColumnMap.size() != hsize ) {
RETURN_BAD_RESULT( "Wrong node positions on theBaseEdge" );
}
// load nodes from e1
std::map< double, const SMDS_MeshNode*> sortedNodes; // sort by param on edge
nIt = sm1->GetNodes();
while ( nIt->more() ) {
node = nIt->next();
if(IsMedium(node))
continue;
const SMDS_EdgePosition* pos =
dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() );
if ( !pos ) {
return false;
}
sortedNodes.insert( std::make_pair( pos->GetUParameter(), node ));
}
loadedNodes.insert( nVecf[ vsize - 1 ] = smVft->GetNodes()->next() );
std::map< double, const SMDS_MeshNode*>::iterator u_n = sortedNodes.begin();
int row = rev1 ? vsize - 1 : 0;
int dRow = rev1 ? -1 : +1;
for ( ; u_n != sortedNodes.end(); u_n++ ) {
row += dRow;
loadedNodes.insert( nVecf[ row ] = u_n->second );
}
// try to load the rest nodes
// get all faces from theFace
TIDSortedElemSet allFaces, foundFaces;
eIt = smFace->GetElements();
while ( eIt->more() ) {
const SMDS_MeshElement* e = eIt->next();
if ( e->GetType() == SMDSAbs_Face )
allFaces.insert( e );
}
// Starting from 2 neighbour nodes on theBaseEdge, look for a face
// the nodes belong to, and between the nodes of the found face,
// look for a not loaded node considering this node to be the next
// in a column of the starting second node. Repeat, starting
// from nodes next to the previous starting nodes in their columns,
// and so on while a face can be found. Then go the the next pair
// of nodes on theBaseEdge.
TParam2ColumnMap::iterator par_nVec_1 = theParam2ColumnMap.begin();
TParam2ColumnMap::iterator par_nVec_2 = par_nVec_1;
// loop on columns
int col = 0;
for ( par_nVec_2++; par_nVec_2 != theParam2ColumnMap.end(); par_nVec_1++, par_nVec_2++ ) {
col++;
row = 0;
const SMDS_MeshNode* n1 = par_nVec_1->second[ row ];
const SMDS_MeshNode* n2 = par_nVec_2->second[ row ];
const SMDS_MeshElement* face = 0;
bool lastColOnClosedFace = ( nVecf[ row ] == n2 );
do {
// look for a face by 2 nodes
face = SMESH_MeshEditor::FindFaceInSet( n1, n2, allFaces, foundFaces );
if ( face ) {
int nbFaceNodes = face->NbNodes();
if ( face->IsQuadratic() )
nbFaceNodes /= 2;
if ( nbFaceNodes>4 ) {
RETURN_BAD_RESULT(" Too many nodes in a face: " << nbFaceNodes );
}
// look for a not loaded node of the <face>
bool found = false;
const SMDS_MeshNode* n3 = 0; // a node defferent from n1 and n2
for ( int i = 0; i < nbFaceNodes && !found; ++i ) {
node = face->GetNode( i );
found = loadedNodes.insert( node ).second;
if ( !found && node != n1 && node != n2 )
n3 = node;
}
if ( lastColOnClosedFace && row + 1 < vsize ) {
node = nVecf[ row + 1 ];
found = ( face->GetNodeIndex( node ) >= 0 );
}
if ( found ) {
if ( ++row > vsize - 1 ) {
RETURN_BAD_RESULT( "Too many nodes in column "<< col <<": "<< row+1);
}
par_nVec_2->second[ row ] = node;
foundFaces.insert( face );
n2 = node;
if ( nbFaceNodes==4 ) {
n1 = par_nVec_1->second[ row ];
}
}
else if ( nbFaceNodes==3 && n3 == par_nVec_1->second[ row + 1 ] ) {
n1 = n3;
}
else {
RETURN_BAD_RESULT( "Not quad mesh, column "<< col );
}
}
}
while ( face && n1 && n2 );
if ( row < vsize - 1 ) {
MESSAGE( "Too few nodes in column "<< col <<": "<< row+1);
MESSAGE( "Base node 1: "<< par_nVec_1->second[0]);
MESSAGE( "Base node 2: "<< par_nVec_2->second[0]);
if ( n1 ) { MESSAGE( "Current node 1: "<< n1); }
else { MESSAGE( "Current node 1: NULL"); }
if ( n2 ) { MESSAGE( "Current node 2: "<< n2); }
else { MESSAGE( "Current node 2: NULL"); }
MESSAGE( "first base node: "<< theParam2ColumnMap.begin()->second[0]);
MESSAGE( "last base node: "<< theParam2ColumnMap.rbegin()->second[0]);
return false;
}
} // loop on columns
return true;
}
//----------------------------------------------------------------
// Function: TopoDS_Shape level function to update the core Surface
// for any movement or Boolean operation of the body.
// Author: Jane Hu
//----------------------------------------------------------------
CubitStatus OCCSurface::update_OCC_entity(TopoDS_Face& old_surface,
TopoDS_Shape& new_surface,
BRepBuilderAPI_MakeShape *op,
TopoDS_Vertex* removed_vertex,
LocOpe_SplitShape* sp)
{
//set the Wires
TopTools_IndexedMapOfShape M, M2;
TopoDS_Shape shape, shape2, shape_edge, shape_vertex;
TopExp::MapShapes(old_surface, TopAbs_WIRE, M);
TopTools_ListOfShape shapes;
BRepFilletAPI_MakeFillet2d* test_op = NULL;
for (int ii=1; ii<=M.Extent(); ii++)
{
TopoDS_Wire wire = TopoDS::Wire(M(ii));
TopTools_ListOfShape shapes;
if(op)
{
test_op = dynamic_cast<BRepFilletAPI_MakeFillet2d*>(op);
if(!test_op)
shapes.Assign(op->Modified(wire));
if(shapes.Extent() == 0)
shapes.Assign(op->Generated(wire));
if(!new_surface.IsNull())
TopExp::MapShapes(new_surface,TopAbs_WIRE, M2);
}
else if(sp)
shapes.Assign(sp->DescendantShapes(wire));
if (shapes.Extent() == 1)
{
shape = shapes.First();
if(M2.Extent() == 1)
{
shape2 = TopoDS::Wire(M2(1));
if(!shape.IsSame(shape2))
shape = shape2;
}
else if(M2.Extent() > 1)
shape.Nullify();
}
else if(shapes.Extent() > 1)
shape.Nullify();
else if(op->IsDeleted(wire) || shapes.Extent() == 0)
{
TopTools_IndexedMapOfShape M_new;
TopExp::MapShapes(new_surface, TopAbs_WIRE, M_new);
if (M_new.Extent()== 1)
shape = M_new(1);
else
shape.Nullify();
}
else
{
shape = wire;
continue;
}
//set curves
BRepTools_WireExplorer Ex;
for(Ex.Init(wire); Ex.More();Ex.Next())
{
TopoDS_Edge edge = Ex.Current();
if(op && !test_op)
{
shapes.Assign(op->Modified(edge));
if(shapes.Extent() == 0)
shapes.Assign(op->Generated(edge));
}
else if(sp)
shapes.Assign(sp->DescendantShapes(edge));
if (shapes.Extent() == 1)
{
//in fillet creating mothod, one edge could generated a face, so check
//it here.
TopAbs_ShapeEnum type = shapes.First().TShape()->ShapeType();
if(type != TopAbs_EDGE)
shape_edge.Nullify();
else
shape_edge = shapes.First();
}
else if (shapes.Extent() > 1)
{
//update all attributes first.
TopTools_ListIteratorOfListOfShape it;
it.Initialize(shapes);
for(; it.More(); it.Next())
{
shape_edge = it.Value();
OCCQueryEngine::instance()->copy_attributes(edge, shape_edge);
}
shape_edge.Nullify();
}
else if (op->IsDeleted(edge))
shape_edge.Nullify();
else if (test_op)
{
if(!test_op->IsModified(edge))
shape_edge = edge;
else
shape_edge = (test_op->Modified(edge)).First();
}
else
shape_edge = edge;
//update vertex
TopoDS_Vertex vertex = Ex.CurrentVertex();
shapes.Clear();
if(test_op)
assert(removed_vertex != NULL);
if(op && ! test_op )
shapes.Assign(op->Modified(vertex));
else if(sp)
shapes.Assign(sp->DescendantShapes(vertex));
if (shapes.Extent() == 1)
shape_vertex = shapes.First();
else if(shapes.Extent() > 1)
{
//update all attributes first.
TopTools_ListIteratorOfListOfShape it;
it.Initialize(shapes);
for(; it.More(); it.Next())
{
shape_vertex = it.Value();
OCCQueryEngine::instance()->copy_attributes(vertex, shape_vertex);
}
shape_vertex.Nullify() ;
}
else if(op->IsDeleted(vertex) || (test_op && vertex.IsSame( *removed_vertex)))
shape_vertex.Nullify() ;
else
shape_vertex = vertex;
if(!vertex.IsSame(shape_vertex) )
OCCQueryEngine::instance()->update_OCC_map(vertex, shape_vertex);
if (!edge.IsSame(shape_edge))
OCCQueryEngine::instance()->update_OCC_map(edge, shape_edge);
}
if (!wire.IsSame(shape))
OCCQueryEngine::instance()->update_OCC_map(wire, shape);
}
double dTOL = OCCQueryEngine::instance()->get_sme_resabs_tolerance();
if (!old_surface.IsSame(new_surface))
{
TopAbs_ShapeEnum shapetype = TopAbs_SHAPE;
if(!new_surface.IsNull())
shapetype = new_surface.TShape()->ShapeType();
if(shapetype == TopAbs_FACE || new_surface.IsNull())
OCCQueryEngine::instance()->update_OCC_map(old_surface, new_surface);
else
{
TopTools_IndexedMapOfShape M;
TopExp::MapShapes(new_surface, TopAbs_FACE, M);
TopoDS_Shape new_shape;
if(M.Extent() == 1)
new_shape = M(1);
else if(M.Extent() > 1)
{
for(int i = 1; i <= M.Extent(); i++)
{
GProp_GProps myProps;
BRepGProp::SurfaceProperties(old_surface, myProps);
double orig_mass = myProps.Mass();
gp_Pnt orig_pnt = myProps.CentreOfMass();
BRepGProp::SurfaceProperties(M(i), myProps);
double after_mass = myProps.Mass();
gp_Pnt after_pnt = myProps.CentreOfMass();
if(fabs(-after_mass + orig_mass) <= dTOL &&
orig_pnt.IsEqual(after_pnt, dTOL))
{
new_shape = M(i);
break;
}
}
}
OCCQueryEngine::instance()->update_OCC_map(old_surface, new_shape);
}
}
return CUBIT_SUCCESS;
}
//=======================================================================
//function : Execute
//purpose :
//=======================================================================
Standard_Integer GEOMImpl_Fillet1dDriver::Execute(TFunction_Logbook& log) const
{
if (Label().IsNull()) return 0;
Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction(Label());
GEOMImpl_IFillet1d aCI (aFunction);
Handle(GEOM_Function) aRefShape = aCI.GetShape();
TopoDS_Shape aShape = aRefShape->GetValue();
if (aShape.IsNull())
return 0;
if (aShape.ShapeType() != TopAbs_WIRE)
Standard_ConstructionError::Raise("Wrong arguments: polyline as wire must be given");
TopoDS_Wire aWire = TopoDS::Wire(aShape);
double rad = aCI.GetR();
if ( rad < Precision::Confusion())
return 0;
// collect vertices for make fillet
TopTools_ListOfShape aVertexList;
TopTools_MapOfShape mapShape;
int aLen = aCI.GetLength();
if ( aLen > 0 ) {
for (int ind = 1; ind <= aLen; ind++) {
TopoDS_Shape aShapeVertex;
if (GEOMImpl_ILocalOperations::GetSubShape
(aWire, aCI.GetVertex(ind), aShapeVertex))
if (mapShape.Add(aShapeVertex))
aVertexList.Append( aShapeVertex );
}
} else { // get all vertices from wire
TopExp_Explorer anExp( aWire, TopAbs_VERTEX );
for ( ; anExp.More(); anExp.Next() ) {
if (mapShape.Add(anExp.Current()))
aVertexList.Append( anExp.Current() );
}
}
if (aVertexList.IsEmpty())
Standard_ConstructionError::Raise("Invalid input no vertices to make fillet");
//INFO: this algorithm implemented in assumption that user can select both
// vertices of some edges to make fillet. In this case we should remember
// already modified initial edges to take care in next fillet step
TopTools_DataMapOfShapeShape anEdgeToEdgeMap;
//iterates on vertices, and make fillet on each couple of edges
//collect result fillet edges in list
TopTools_ListOfShape aListOfNewEdge;
// remember relation between initial and modified map
TopTools_IndexedDataMapOfShapeListOfShape aMapVToEdges;
TopExp::MapShapesAndAncestors( aWire, TopAbs_VERTEX, TopAbs_EDGE, aMapVToEdges );
TopTools_ListIteratorOfListOfShape anIt( aVertexList );
for ( ; anIt.More(); anIt.Next() ) {
TopoDS_Vertex aV = TopoDS::Vertex( anIt.Value() );
if ( aV.IsNull() || !aMapVToEdges.Contains( aV ) )
continue;
const TopTools_ListOfShape& aVertexEdges = aMapVToEdges.FindFromKey( aV );
if ( aVertexEdges.Extent() != 2 )
continue; // no input data to make fillet
TopoDS_Edge anEdge1 = TopoDS::Edge( aVertexEdges.First() );
TopoDS_Edge anEdge2 = TopoDS::Edge( aVertexEdges.Last() );
// check if initial edges already modified in previous fillet operation
if ( anEdgeToEdgeMap.IsBound( anEdge1 ) ) anEdge1 = TopoDS::Edge(anEdgeToEdgeMap.Find( anEdge1 ));
if ( anEdgeToEdgeMap.IsBound( anEdge2 ) ) anEdge2 = TopoDS::Edge(anEdgeToEdgeMap.Find( anEdge2 ));
if ( anEdge1.IsNull() || anEdge2.IsNull() || anEdge1.IsSame( anEdge2 ) )
continue; //no input data to make fillet
// create plane on 2 edges
gp_Pln aPlane;
if ( !takePlane(anEdge1, anEdge2, aV, aPlane) )
continue; // seems edges does not belong to same plane or parallel (fillet can not be build)
GEOMImpl_Fillet1d aFilletAlgo(anEdge1, anEdge2, aPlane);
if ( !aFilletAlgo.Perform(rad) )
continue; // can not create fillet with given radius
// take fillet result in given vertex
TopoDS_Edge aModifE1, aModifE2;
TopoDS_Edge aNewE = aFilletAlgo.Result(BRep_Tool::Pnt(aV), aModifE1, aModifE2);
if (aNewE.IsNull())
continue; // no result found
// add new created edges and take modified edges
aListOfNewEdge.Append( aNewE );
// check if face edges modified,
// if yes, than map to original edges (from vertex-edges list), because edges can be modified before
if (aModifE1.IsNull() || !anEdge1.IsSame( aModifE1 ))
addEdgeRelation( anEdgeToEdgeMap, TopoDS::Edge(aVertexEdges.First()), aModifE1 );
if (aModifE2.IsNull() || !anEdge2.IsSame( aModifE2 ))
addEdgeRelation( anEdgeToEdgeMap, TopoDS::Edge(aVertexEdges.Last()), aModifE2 );
}
if ( anEdgeToEdgeMap.IsEmpty() && aListOfNewEdge.IsEmpty() ) {
StdFail_NotDone::Raise("1D Fillet can't be computed on the given shape with the given radius");
return 0;
}
// create new wire instead of original
for ( TopExp_Explorer anExp( aWire, TopAbs_EDGE ); anExp.More(); anExp.Next() ) {
TopoDS_Shape anEdge = anExp.Current();
if ( !anEdgeToEdgeMap.IsBound( anEdge ) )
aListOfNewEdge.Append( anEdge );
else if (!anEdgeToEdgeMap.Find( anEdge ).IsNull())
aListOfNewEdge.Append( anEdgeToEdgeMap.Find( anEdge ) );
}
GEOMImpl_IShapesOperations::SortShapes( aListOfNewEdge );
BRepBuilderAPI_MakeWire aWireTool;
aWireTool.Add( aListOfNewEdge );
aWireTool.Build();
if (!aWireTool.IsDone())
return 0;
aWire = aWireTool.Wire();
aFunction->SetValue(aWire);
log.SetTouched(Label());
return 1;
}
void Tesselate_Presentation::tesselateShape(const TopoDS_Shape& aShape)
{
// setResultTitle("Tesselate shape");
TCollection_AsciiString aText = (
"/////////////////////////////////////////////////////////////////" EOL
"// Tesselate shape." EOL
"/////////////////////////////////////////////////////////////////" EOL EOL
) ;
Standard_Real aDeflection = DATA[myIndex][0];
Standard_Integer aNumOfFace = (Standard_Integer)DATA[myIndex][1];
Standard_Integer aNumOfEdge = (Standard_Integer)DATA[myIndex][2];
aText +=
"Standard_Real aDeflection;" EOL
"// aDeflection = ... ;" EOL EOL
"// removes all the triangulations of the faces ," EOL
"//and all the polygons on the triangulations of the edges:" EOL
"BRepTools::Clean(aShape);" EOL EOL
"// adds a triangulation of the shape aShape with the deflection aDeflection:" EOL
"BRepMesh::Mesh(aShape,aDeflection);" EOL EOL
"TopExp_Explorer aExpFace,aExpEdge;" EOL
"for(aExpFace.Init(aShape,TopAbs_FACE);aExpFace.More();aExpFace.Next())" EOL
"{ " EOL
" TopoDS_Face aFace = TopoDS::Face(aExpFace.Current());" EOL
" TopLoc_Location aLocation;" EOL EOL
" // takes the triangulation of the face aFace:" EOL
" Handle_Poly_Triangulation aTr = BRep_Tool::Triangulation(aFace,aLocation);" EOL EOL
" if(!aTr.IsNull()) // if this triangulation is not NULL" EOL
" { " EOL
" // takes the array of nodes for this triangulation:" EOL
" const TColgp_Array1OfPnt& aNodes = aTr->Nodes();" EOL
" // takes the array of triangles for this triangulation:" EOL
" const Poly_Array1OfTriangle& triangles = aTr->Triangles();" EOL EOL
" // create array of node points in absolute coordinate system" EOL
" TColgp_Array1OfPnt aPoints(1, aNodes.Length());" EOL
" for( Standard_Integer i = 1; i < aNodes.Length()+1; i++)" EOL
" aPoints(i) = aNodes(i).Transformed(aLocation);" EOL EOL
" // Takes the node points of each triangle of this triangulation." EOL
" // takes a number of triangles:" EOL
" Standard_Integer nnn = aTr->NbTriangles();" EOL
" Standard_Integer nt,n1,n2,n3;" EOL
" for( nt = 1 ; nt < nnn+1 ; nt++)" EOL
" {" EOL
" // takes the node indices of each triangle in n1,n2,n3:" EOL
" triangles(nt).Get(n1,n2,n3);" EOL
" // takes the node points:" EOL
" gp_Pnt aPnt1 = aPoints(n1);" EOL
" gp_Pnt aPnt2 = aPoints(n2);" EOL
" gp_Pnt aPnt3 = aPoints(n3);" EOL
" } " EOL EOL
" // Takes the polygon associated to an edge." EOL
" aExpEdge.Init(aFace,TopAbs_EDGE);" EOL
" TopoDS_Edge aEdge;" EOL
" // for example,working with the first edge:" EOL
" if(aExpEdge.More())" EOL
" aEdge = TopoDS::Edge(aExpEdge.Current());" EOL EOL
" if(!aEdge.IsNull()) // if this edge is not NULL" EOL
" {" EOL
" // takes the polygon associated to the edge aEdge:" EOL
" Handle_Poly_PolygonOnTriangulation aPol = " EOL
" BRep_Tool::PolygonOnTriangulation(aEdge,aTr,aEdge.Location());" EOL EOL
" if(!aPol.IsNull()) // if this polygon is not NULL" EOL
" // takes the array of nodes for this polygon" EOL
" // (indexes in the array of nodes for triangulation of theFace):" EOL
" const TColStd_Array1OfInteger& aNodesOfPol = aPol->Nodes();" EOL
" }" EOL
" }" EOL
"}" EOL EOL
"//==================================================" EOL EOL
;
aText += " Result with deflection = ";
aText += TCollection_AsciiString(aDeflection);
aText += " :" EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
//==========================================================================
BRepTools::Clean(aShape);
BRepMesh::Mesh(aShape,aDeflection);
BRep_Builder aBuilder,aBuild1,aBuild2;
TopoDS_Compound aCompound,aComp1,aComp2;
aBuilder.MakeCompound(aCompound);
aBuild1.MakeCompound(aComp1);
aBuild2.MakeCompound(aComp2);
TopTools_SequenceOfShape aVertices;
Standard_Integer aCount = 0;
Standard_Integer aNumOfNodes = 0;
Standard_Integer aNumOfTriangles = 0;
Handle_AIS_InteractiveObject aShowEdge,aShowFace,aShowShape;
TopExp_Explorer aExpFace,aExpEdge;
for(aExpFace.Init(aShape,TopAbs_FACE);aExpFace.More();aExpFace.Next())
{
aCount++;
TopoDS_Face aFace = TopoDS::Face(aExpFace.Current());
TopLoc_Location aLocation;
Handle_Poly_Triangulation aTr = BRep_Tool::Triangulation(aFace,aLocation);
if(!aTr.IsNull())
{
const TColgp_Array1OfPnt& aNodes = aTr->Nodes();
aNumOfNodes += aTr->NbNodes();
Standard_Integer aLower = aNodes.Lower();
Standard_Integer anUpper = aNodes.Upper();
const Poly_Array1OfTriangle& triangles = aTr->Triangles();
aNumOfTriangles += aTr->NbTriangles();
if(aCount == aNumOfFace)
{
Standard_Integer aNbOfNodesOfFace = aTr->NbNodes();
Standard_Integer aNbOfTrianglesOfFace = aTr->NbTriangles();
aExpEdge.Init(aFace,TopAbs_EDGE);
TopoDS_Edge aEdge;
for( Standard_Integer i = 0; aExpEdge.More() && i < aNumOfEdge ; aExpEdge.Next(), i++)
aEdge = TopoDS::Edge(aExpEdge.Current());
if(!aEdge.IsNull())
{
Handle_Poly_PolygonOnTriangulation aPol =
BRep_Tool::PolygonOnTriangulation(aEdge,aTr,aEdge.Location());
if(!aPol.IsNull())
{
const TColStd_Array1OfInteger& aNodesOfPol = aPol->Nodes();
Standard_Integer aNbOfNodesOfEdge = aPol->NbNodes();
aText += "Number of nodes of the edge = ";
aText += TCollection_AsciiString(aNbOfNodesOfEdge) + EOL;
aText += "Number of nodes of the face = ";
aText += TCollection_AsciiString(aNbOfNodesOfFace) + EOL;
aText += "Number of triangles of the face = ";
aText += TCollection_AsciiString(aNbOfTrianglesOfFace) + EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
Standard_Integer aLower = aNodesOfPol.Lower(), anUpper = aNodesOfPol.Upper();
for( int i = aLower; i < anUpper ; i++)
{
gp_Pnt aPnt1 = aNodes(aNodesOfPol(i)).Transformed(aLocation);
gp_Pnt aPnt2 = aNodes(aNodesOfPol(i+1)).Transformed(aLocation);
TopoDS_Vertex aVertex1 = BRepBuilderAPI_MakeVertex (aPnt1);
TopoDS_Vertex aVertex2 = BRepBuilderAPI_MakeVertex (aPnt2);
if(!aVertex1.IsNull() && !aVertex2.IsNull() && // if vertices are "alive"
!BRep_Tool::Pnt(aVertex1).IsEqual(
BRep_Tool::Pnt(aVertex2),Precision::Confusion())) // if they are different
{
aEdge = BRepBuilderAPI_MakeEdge (aVertex1,aVertex2);
aBuild2.Add(aComp2,aVertex1);
if(!aEdge.IsNull())
aBuild2.Add(aComp2,aEdge);
if(i == anUpper-1)
aBuild2.Add(aComp2,aVertex2);
}
}
getAISContext()->EraseAll();
aShowShape = drawShape(aShape);
if(WAIT_A_SECOND) return;
aShowEdge = drawShape(aComp2,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowShape);
if(WAIT_A_SECOND) return;
}
}
}
TopTools_DataMapOfIntegerShape aEdges;
TopTools_SequenceOfShape aVertices;
for( Standard_Integer i = 1; i < aNodes.Length()+1; i++)
{
gp_Pnt aPnt = aNodes(i).Transformed(aLocation);
TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex(aPnt);
if(!aVertex.IsNull())
{
aBuilder.Add(aCompound,aVertex);
if(aCount == aNumOfFace )
aBuild1.Add(aComp1,aVertex);
aVertices.Append(aVertex);
}
}
Standard_Integer nnn = aTr->NbTriangles();
Standard_Integer nt,n1,n2,n3;
for( nt = 1 ; nt < nnn+1 ; nt++)
{
triangles(nt).Get(n1,n2,n3);
Standard_Integer key[3];
TopoDS_Vertex aV1,aV2;
key[0] = _key(n1, n2);
if(!aEdges.IsBound(key[0]))
{
aV1 = TopoDS::Vertex(aVertices(n1));
aV2 = TopoDS::Vertex(aVertices(n2));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[0], aEdge);
aBuilder.Add(aCompound,aEdges(key[0]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[0]));
}
}
}
key[1] = _key(n2,n3);
if(!aEdges.IsBound(key[1]))
{
aV1 = TopoDS::Vertex(aVertices(n2));
aV2 = TopoDS::Vertex(aVertices(n3));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[1],aEdge);
aBuilder.Add(aCompound,aEdges(key[1]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[1]));
}
}
}
key[2] = _key(n3,n1);
if(!aEdges.IsBound(key[2]))
{
aV1 = TopoDS::Vertex(aVertices(n3));
aV2 = TopoDS::Vertex(aVertices(n1));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[2],aEdge);
aBuilder.Add(aCompound,aEdges(key[2]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[2]));
}
}
}
}
if(aCount == aNumOfFace)
{
aShowFace = drawShape(aComp1,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowEdge);
}
}
else
{
aText += "Can't compute a triangulation on face ";
aText += TCollection_AsciiString(aCount) + EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
}
}
aText += "Number of nodes of the shape = ";
aText += TCollection_AsciiString(aNumOfNodes) + EOL;
aText += "Number of triangles of the shape = ";
aText += TCollection_AsciiString(aNumOfTriangles) + EOL EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
if(WAIT_A_SECOND) return;
drawShape(aCompound,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowFace);
}
