OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0022564: BRepMesh_Classifier improvements

Browse Source
This commit is contained in:
EPA 2011-09-02 08:16:09 +00:00 committed by bugmaster
parent c99551fa0f
commit 2b59653e67
9 changed files with 568 additions and 1336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/BRepMesh/BRepMesh_Classifier.cdl
View File

@ -23,15 +23,6 @@ uses
is
Create (F : Face from TopoDS;
Tol : Real from Standard;
edges : DataMapOfShapePairOfPolygon from BRepMesh;
themap : IndexedMapOfInteger from TColStd;
Str : IndexedMapOfVertex from BRepMesh;
Umin, Umax, Vmin, Vmax: Real from Standard)
returns Classifier from BRepMesh;
Create (F : Face from TopoDS;
Tol : Real from Standard;
edges : DataMapOfShapePairOfPolygon from BRepMesh;
@ -49,10 +40,6 @@ is
returns Status from BRepMesh;
---C++: inline
NaturalRestriction(me)
returns Boolean from Standard;
---C++: inline
Destroy(me: in out);
---C++: alias ~
@ -76,6 +63,5 @@ fields
U2 : Real from Standard;
V2 : Real from Standard;
myState : Status from BRepMesh;
isnatural : Boolean from Standard;
end Classifier from BRepMesh;

532
src/BRepMesh/BRepMesh_Classifier.cxx
View File

@ -15,7 +15,7 @@
#include <ElCLib.hxx>
// Geometry
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pnt2d.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <GeomAbs_SurfaceType.hxx>
@ -88,8 +88,8 @@ static Standard_Boolean IsLine(const Handle(Geom2d_Curve)& C2d)
//=======================================================================
void BRepMesh_Classifier::AnalizeWire (const TColgp_SequenceOfPnt2d& theSeqPnt2d,
const Standard_Real Umin, const Standard_Real Umax,
const Standard_Real Vmin, const Standard_Real Vmax)
const Standard_Real Umin, const Standard_Real Umax,
const Standard_Real Vmin, const Standard_Real Vmax)
{
const Standard_Integer nbpnts = theSeqPnt2d.Length();
if (nbpnts < 2) return;
@ -140,350 +140,16 @@ void BRepMesh_Classifier::AnalizeWire (const TColgp_SequenceOfPnt2d& theSeqPnt2
//=======================================================================
BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
const Standard_Real TolUV,
const BRepMesh_DataMapOfShapePairOfPolygon& edges,
const TColStd_IndexedMapOfInteger& themap,
const BRepMesh_IndexedMapOfVertex& Str,
const Standard_Real Umin,
const Standard_Real Umax,
const Standard_Real Vmin,
const Standard_Real Vmax):
Toluv(TolUV), Face(aFace),
myState(BRepMesh_NoError),
isnatural(Standard_False)
{
//-- impasse sur les surfs definies sur plus d une periode
//-- once definition
Face.Orientation(TopAbs_FORWARD);
TopoDS_Edge edge;
BRepTools_WireExplorer WireExplorer;
//TopExp_Explorer FaceExplorer;
TopoDS_Iterator FaceExplorer;
TColgp_SequenceOfPnt2d aWirePoints, aWire;
TColStd_SequenceOfInteger aWireLength;
//-- twice definitions
TopAbs_Orientation anOr = TopAbs_FORWARD;
Standard_Boolean falsewire = Standard_False;
Standard_Integer i, index, firstindex = 0, lastindex = 0, nbedges = 0;
#ifdef DEB_MESH
debwire = 0;
#endif
for(FaceExplorer.Initialize(Face); FaceExplorer.More(); FaceExplorer.Next())
{
#ifdef DEB_MESH
if (debclass) { debwire++; cout <<endl; cout << "#wire no "<<debwire; debedge = 0;}
#endif
if(FaceExplorer.Value().ShapeType() != TopAbs_WIRE)
continue;
// For each wire we create a data map, linking vertices (only
// the ends of edges) with their positions in the sequence of
// all 2d points from this wire.
// When we meet some vertex for the second time - the piece
// of sequence is treated for a HOLE and quits the sequence.
// Actually, we must unbind the vertices belonging to the
// loop from the map, but since they can't appear twice on the
// valid wire, leave them for a little speed up.
nbedges = 0;
TColgp_SequenceOfPnt2d SeqPnt2d;
TColStd_DataMapOfIntegerInteger NodeInSeq;
// Start traversing the wire
for (WireExplorer.Init(TopoDS::Wire(FaceExplorer.Value()),Face); WireExplorer.More(); WireExplorer.Next())
{
edge = WireExplorer.Current();
#ifdef DEB_MESH
if (debclass) { debedge++; cout << endl; cout << "#edge no "<<debedge <<endl;}
#endif
anOr = edge.Orientation();
if (anOr != TopAbs_FORWARD && anOr != TopAbs_REVERSED) continue;
if (edges.IsBound(edge))
{
// Retrieve polygon
// Define the direction for adding points to SeqPnt2d
Standard_Integer iFirst,iLast,iIncr;
const BRepMesh_PairOfPolygon& pair = edges.Find(edge);
Handle(Poly_PolygonOnTriangulation) NOD;
if (anOr == TopAbs_FORWARD)
{
NOD = pair.First();
iFirst = 1;
iLast = NOD->NbNodes();
iIncr = 1;
}
else
{
NOD = pair.Last();
iFirst = NOD->NbNodes();
iLast = 1;
iIncr = -1;
}
const TColStd_Array1OfInteger& indices = NOD->Nodes();
// indexFirst and nodeLast are the indices of first and last
// vertices of the edge in IndexedMap <Str>
const Standard_Integer indexFirst = themap.FindKey(indices(iFirst));
const Standard_Integer indexLast = themap.FindKey(indices(iLast));
// Skip degenerated edge : OCC481(apo)
if (indexLast == indexFirst && (iLast-iFirst) == iIncr) continue;
// If there's a gap between edges -> raise <falsewire> flag
if (nbedges)
{
if (indexFirst != lastindex)
{
falsewire = Standard_True;
break;
}
}
else firstindex = indexFirst;
lastindex = indexLast;
// Record first vertex (to detect loops)
NodeInSeq.Bind(indexFirst,SeqPnt2d.Length()+1);
// Add vertices in sequence
for (i = iFirst; i != iLast; i += iIncr)
{
index = (i == iFirst)? indexFirst : themap.FindKey(indices(i));
gp_Pnt2d vp(Str(index).Coord());
SeqPnt2d.Append(vp);
#ifdef DEB_MESH
if (debclass) cout<<"point p"<<index<<" "<<vp.X()<<" "<< vp.Y()<<endl;
#endif
}
// Now, is there a loop?
if (NodeInSeq.IsBound(indexLast))
{
// Yes, treat it separately as a hole
// 1. Divide points into main wire and a loop
const Standard_Integer iWireStart = NodeInSeq(indexLast);
if(iWireStart < SeqPnt2d.Length()) {
SeqPnt2d.Split(iWireStart, aWire);
//OCC319-> the operation will be done later
// 2. Proceed the loop
//AnalizeWire(aLoop, Umin, Umax, Vmin, Vmax, aWirePoints, aWireLength, NbBiPoint);
aWireLength.Append(aWire.Length());
aWirePoints.Append(aWire);
//<-OCC319
}
}
nbedges++;
}
}
if (nbedges)
{
// Isn't it open?
if (falsewire || (firstindex != lastindex) || SeqPnt2d.Length() > 1)
{
myState = BRepMesh_OpenWire;
return;
}
}
else
{
#ifdef DEB_MESH
cout <<"Warning : empty wire" <<endl;
#endif
}
}
// Check natural restriction
const Standard_Integer nbwires = aWireLength.Length();
if (nbwires == 1 && nbedges == 4)
{
Handle(Geom2d_Curve) C2d;
Standard_Real pfbid, plbid;
isnatural = Standard_True;
for(FaceExplorer.Initialize(Face); FaceExplorer.More(); FaceExplorer.Next())
{
if(FaceExplorer.Value().ShapeType() != TopAbs_WIRE)
continue;
TopoDS_Iterator aEdgeIt(FaceExplorer.Value());
for( ; aEdgeIt.More(); aEdgeIt.Next())
{
edge = TopoDS::Edge(aEdgeIt.Value());
if(anOr == TopAbs_FORWARD || anOr == TopAbs_REVERSED)
{
C2d = BRep_Tool::CurveOnSurface(edge,Face,pfbid,plbid);
//OCC316(APO): if(!IsLine(C2d)) { isnatural = Standard_False; break; }
if(!C2d.IsNull() && !IsLine(C2d)) { isnatural = Standard_False; break; }
else
{ // sont-ce des isos:
gp_Pnt2d P1, P2;
C2d->D0(pfbid, P1);
C2d->D0(plbid, P2);
if ((Abs(P1.X()-P2.X()) > 1.e-04) && (Abs(P1.Y()-P2.Y()) > 1.e-04)) { isnatural = Standard_False; break; }
}
}
}
}
}
Standard_Integer NbBiPoint = aWirePoints.Length();
BRepMesh_Array1OfBiPoint BiPoints(0,NbBiPoint);
BRepMesh_BiPoint *BP;
Standard_Real *Coordinates1;
Standard_Real x1, y1, x2, y2, xstart, ystart;
Standard_Integer j, l = 1;
BP = &(BiPoints.ChangeValue(1));
// Fill array of segments (bi-points)
for (i = 1; i <= nbwires; i++)
{
const Standard_Integer len = aWireLength(i) + 1;
for (j = 1; j <= len; j++)
{
// Obtain last point of the segment
if (j == len)
{
x2 = xstart;
y2 = ystart;
}
else
{
const gp_Pnt2d& PT = aWirePoints(l); l++;
x2 = PT.X();
y2 = PT.Y();
}
// Build segment (bi-point)
if (j == 1)
{
xstart = x2;
ystart = y2;
}
else
{
Coordinates1 = ((Standard_Real*)(BP->Coordinates())); BP++;
Coordinates1[0] = x1;
Coordinates1[1] = y1;
Coordinates1[2] = x2;
Coordinates1[3] = y2;
Coordinates1[4] = x2 - x1;
Coordinates1[5] = y2 - y1;
}
x1 = x2;
y1 = y2;
}
}
Standard_Real *Coordinates2;
Standard_Real A1, B1, C1, A2, B2, C2, AB, BC, CA, xc, yc;
Standard_Real mu1, d, mu2;
Standard_Integer ik, ikEnd = 0, jk, jkEnd;
Standard_Real x11, x12, y11, y12, x21, x22, y21, y22;
for(i = 1; i <= nbwires; i++)
{
ik = ikEnd + 1; ikEnd += aWireLength(i);
// Explore first wire
for (; ik <= ikEnd; ik++)
{
Coordinates1 = ((Standard_Real*)(BiPoints.ChangeValue(ik).Coordinates()));
x11 = Coordinates1[0];
y11 = Coordinates1[1];
x12 = Coordinates1[2];
y12 = Coordinates1[3];
A1 = Coordinates1[5];
B1 = -Coordinates1[4];
C1 = - x11*A1 - y11*B1;
//mu1 = Sqrt(A1*A1+B1*B1);
mu1 = A1*A1+B1*B1;
for (j = i; j <= nbwires; j++)
{
//for i==j the algorithm check current wire on selfintersection
if (j == i)
{
jk = ik + 2; jkEnd = ikEnd;
}
else
{
jk = jkEnd + 1; jkEnd = jk + aWireLength(j) - 1;
}
// Explore second wire
for (; jk <= jkEnd; jk++)
{
// don't check end's segment of the wire on selfrestriction
if (jk == ikEnd) continue;
Coordinates2 = ((Standard_Real*)(BiPoints.ChangeValue(jk).Coordinates()));
x21 = Coordinates2[0];
y21 = Coordinates2[1];
x22 = Coordinates2[2];
y22 = Coordinates2[3];
A2 = Coordinates2[5];
B2 = -Coordinates2[4];
C2 = - x21*A2 - y21*B2;
//mu2 = Sqrt(A2*A2+B2*B2);
mu2 = A2*A2+B2*B2;
//different segments may have common vertex (see OCC287 bug for example)
//if(x22 == x11 && y22 == y11){ myState = BRepMesh_OpenWire; return;}
AB = A1*B2 - A2*B1;
//check on minimal of distance between current segment and points of another linear segments - OCC319
//d = Abs(A1*x22 + B1*y22 + C1);
d = A1*x22 + B1*y22 + C1;
if(i != j && // if compared wires are different &&
AB*AB > PARALL_COND*PARALL_COND*mu1*mu2 && // angle between two segments greater then PARALL_COND &&
d*d < MIN_DIST*MIN_DIST*mu1 && // distance between vertex of the segment and other one's less then MIN_DIST
(x22-x11)*(x22-x12) < 0.0 && (y22-y11)*(y22-y12) < 0.0)
{
myState = BRepMesh_SelfIntersectingWire; return;
}
//look for intersection of two linear segments
if(Abs(AB) <= RESOLUTION) continue; //current segments seem parallel - no intersection
//calculate coordinates of point of the intersection
BC = B1*C2 - B2*C1; xc = BC/AB;
CA = C1*A2 - C2*A1; yc = CA/AB;
if( Abs(xc-x11) > RESOLUTION && Abs(xc-x12) > RESOLUTION &&
Abs(yc-y11) > RESOLUTION && Abs(yc-y12) > RESOLUTION &&
Abs(xc-x21) > RESOLUTION && Abs(xc-x22) > RESOLUTION &&
Abs(yc-y21) > RESOLUTION && Abs(yc-y22) > RESOLUTION )
{
//check on belonging of intersection point to the both of segments
if((xc-x11)*(xc-x12) < 0.0 && (yc-y11)*(yc-y12) < 0.0 &&
(xc-x21)*(xc-x22) < 0.0 && (yc-y21)*(yc-y22) < 0.0)
{
//different segments may have common vertex (why "<" but "<=")
myState = BRepMesh_SelfIntersectingWire; return;
}
}
}
}
}
}
// Find holes
for (i = nbwires; i >= 1; i--)
{
NbBiPoint = aWirePoints.Length() - aWireLength(i) + 1;
aWirePoints.Split(NbBiPoint, aWire);
AnalizeWire(aWire, Umin, Umax, Vmin, Vmax);
}
}
//Wind code duplication
BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
const Standard_Real TolUV,
const BRepMesh_DataMapOfShapePairOfPolygon& edges,
const TColStd_IndexedMapOfInteger& themap,
const Handle(BRepMesh_DataStructureOfDelaun)& Str,
const Standard_Real Umin,
const Standard_Real Umax,
const Standard_Real Vmin,
const Standard_Real Vmax):
Toluv(TolUV), Face(aFace),
myState(BRepMesh_NoError),
isnatural(Standard_False)
const Standard_Real TolUV,
const BRepMesh_DataMapOfShapePairOfPolygon& edges,
const TColStd_IndexedMapOfInteger& themap,
const Handle(BRepMesh_DataStructureOfDelaun)& Str,
const Standard_Real Umin,
const Standard_Real Umax,
const Standard_Real Vmin,
const Standard_Real Vmax):
Toluv(TolUV), Face(aFace),
myState(BRepMesh_NoError)
{
//-- impasse sur les surfs definies sur plus d une periode
@ -537,50 +203,50 @@ BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
if (edges.IsBound(edge))
{
// Retrieve polygon
// Define the direction for adding points to SeqPnt2d
Standard_Integer iFirst,iLast,iIncr;
const BRepMesh_PairOfPolygon& pair = edges.Find(edge);
Handle(Poly_PolygonOnTriangulation) NOD;
// Define the direction for adding points to SeqPnt2d
Standard_Integer iFirst,iLast,iIncr;
const BRepMesh_PairOfPolygon& pair = edges.Find(edge);
Handle(Poly_PolygonOnTriangulation) NOD;
if (anOr == TopAbs_FORWARD)
{
NOD = pair.First();
iFirst = 1;
NOD = pair.First();
iFirst = 1;
iLast = NOD->NbNodes();
iIncr = 1;
}
else
{
NOD = pair.Last();
iFirst = NOD->NbNodes();
NOD = pair.Last();
iFirst = NOD->NbNodes();
iLast = 1;
iIncr = -1;
}
const TColStd_Array1OfInteger& indices = NOD->Nodes();
const TColStd_Array1OfInteger& indices = NOD->Nodes();
// indexFirst and nodeLast are the indices of first and last
// vertices of the edge in IndexedMap <Str>
const Standard_Integer indexFirst = themap.FindKey(indices(iFirst));
const Standard_Integer indexLast = themap.FindKey(indices(iLast));
// indexFirst and nodeLast are the indices of first and last
// vertices of the edge in IndexedMap <Str>
const Standard_Integer indexFirst = themap.FindKey(indices(iFirst));
const Standard_Integer indexLast = themap.FindKey(indices(iLast));
// Skip degenerated edge : OCC481(apo)
if (indexLast == indexFirst && (iLast-iFirst) == iIncr) continue;
// Skip degenerated edge : OCC481(apo)
if (indexLast == indexFirst && (iLast-iFirst) == iIncr) continue;
// If there's a gap between edges -> raise <falsewire> flag
if (nbedges)
// If there's a gap between edges -> raise <falsewire> flag
if (nbedges)
{
if (indexFirst != lastindex)
{
falsewire = Standard_True;
break;
}
}
else firstindex = indexFirst;
lastindex = indexLast;
}
else firstindex = indexFirst;
lastindex = indexLast;
// Record first vertex (to detect loops)
NodeInSeq.Bind(indexFirst,SeqPnt2d.Length()+1);
// Record first vertex (to detect loops)
NodeInSeq.Bind(indexFirst,SeqPnt2d.Length()+1);
// Add vertices in sequence
// Add vertices in sequence
for (i = iFirst; i != iLast; i += iIncr)
{
index = (i == iFirst)? indexFirst : themap.FindKey(indices(i));
@ -592,24 +258,23 @@ BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
#endif
}
// Now, is there a loop?
if (NodeInSeq.IsBound(indexLast))
// Now, is there a loop?
if (NodeInSeq.IsBound(indexLast))
{
// Yes, treat it separately as a hole
// 1. Divide points into main wire and a loop
const Standard_Integer iWireStart = NodeInSeq(indexLast);
if(iWireStart < SeqPnt2d.Length()) {
SeqPnt2d.Split(iWireStart, aWire);
//OCC319-> the operation will be done later
// 2. Proceed the loop
//AnalizeWire(aLoop, Umin, Umax, Vmin, Vmax, aWirePoints, aWireLength, NbBiPoint);
aWireLength.Append(aWire.Length());
aWirePoints.Append(aWire);
//<-OCC319
}
}
nbedges++;
// Yes, treat it separately as a hole
// 1. Divide points into main wire and a loop
const Standard_Integer iWireStart = NodeInSeq(indexLast);
if(iWireStart < SeqPnt2d.Length()) {
SeqPnt2d.Split(iWireStart, aWire);
//OCC319-> the operation will be done later
// 2. Proceed the loop
//AnalizeWire(aLoop, Umin, Umax, Vmin, Vmax, aWirePoints, aWireLength, NbBiPoint);
aWireLength.Append(aWire.Length());
aWirePoints.Append(aWire);
//<-OCC319
}
}
nbedges++;
}
}
@ -618,8 +283,8 @@ BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
// Isn't it open?
if (falsewire || (firstindex != lastindex) || SeqPnt2d.Length() > 1)
{
myState = BRepMesh_OpenWire;
return;
myState = BRepMesh_OpenWire;
return;
}
}
else
@ -630,38 +295,7 @@ BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
}
}
// Check natural restriction
const Standard_Integer nbwires = aWireLength.Length();
if (nbwires == 1 && nbedges == 4)
{
Handle(Geom2d_Curve) C2d;
Standard_Real pfbid, plbid;
isnatural = Standard_True;
for(FaceExplorer.Initialize(Face); FaceExplorer.More(); FaceExplorer.Next())
{
if(FaceExplorer.Value().ShapeType() != TopAbs_WIRE)
continue;
TopoDS_Iterator aEdgeIt(FaceExplorer.Value());
for( ; aEdgeIt.More(); aEdgeIt.Next())
{
edge = TopoDS::Edge(aEdgeIt.Value());
if(anOr == TopAbs_FORWARD || anOr == TopAbs_REVERSED)
{
C2d = BRep_Tool::CurveOnSurface(edge,Face,pfbid,plbid);
//OCC316(APO): if(!IsLine(C2d)) { isnatural = Standard_False; break; }
if(!C2d.IsNull() && !IsLine(C2d)) { isnatural = Standard_False; break; }
else
{ // sont-ce des isos:
gp_Pnt2d P1, P2;
C2d->D0(pfbid, P1);
C2d->D0(plbid, P2);
if ((Abs(P1.X()-P2.X()) > 1.e-04) && (Abs(P1.Y()-P2.Y()) > 1.e-04)) { isnatural = Standard_False; break; }
}
}
}
}
}
Standard_Integer NbBiPoint = aWirePoints.Length();
BRepMesh_Array1OfBiPoint BiPoints(0,NbBiPoint);
@ -734,7 +368,7 @@ BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
for (j = i; j <= nbwires; j++)
{
//for i==j the algorithm check current wire on selfintersection
if (j == i)
if (j == i)
{
jk = ik + 2; jkEnd = ikEnd;
}
@ -743,52 +377,52 @@ BRepMesh_Classifier::BRepMesh_Classifier(const TopoDS_Face& aFace,
jk = jkEnd + 1; jkEnd = jk + aWireLength(j) - 1;
}
// Explore second wire
for (; jk <= jkEnd; jk++)
for (; jk <= jkEnd; jk++)
{
// don't check end's segment of the wire on selfrestriction
if (jk == ikEnd) continue;
Coordinates2 = ((Standard_Real*)(BiPoints.ChangeValue(jk).Coordinates()));
x21 = Coordinates2[0];
if (jk == ikEnd) continue;
Coordinates2 = ((Standard_Real*)(BiPoints.ChangeValue(jk).Coordinates()));
x21 = Coordinates2[0];
y21 = Coordinates2[1];
x22 = Coordinates2[2];
y22 = Coordinates2[3];
A2 = Coordinates2[5];
A2 = Coordinates2[5];
B2 = -Coordinates2[4];
C2 = - x21*A2 - y21*B2;
//mu2 = Sqrt(A2*A2+B2*B2);
//mu2 = Sqrt(A2*A2+B2*B2);
mu2 = A2*A2+B2*B2;
//different segments may have common vertex (see OCC287 bug for example)
//if(x22 == x11 && y22 == y11){ myState = BRepMesh_OpenWire; return;}
AB = A1*B2 - A2*B1;
//check on minimal of distance between current segment and points of another linear segments - OCC319
//d = Abs(A1*x22 + B1*y22 + C1);
//different segments may have common vertex (see OCC287 bug for example)
//if(x22 == x11 && y22 == y11){ myState = BRepMesh_OpenWire; return;}
AB = A1*B2 - A2*B1;
//check on minimal of distance between current segment and points of another linear segments - OCC319
//d = Abs(A1*x22 + B1*y22 + C1);
d = A1*x22 + B1*y22 + C1;
if(i != j && // if compared wires are different &&
AB*AB > PARALL_COND*PARALL_COND*mu1*mu2 && // angle between two segments greater then PARALL_COND &&
d*d < MIN_DIST*MIN_DIST*mu1 && // distance between vertex of the segment and other one's less then MIN_DIST
(x22-x11)*(x22-x12) < 0.0 && (y22-y11)*(y22-y12) < 0.0)
if(i != j && // if compared wires are different &&
AB*AB > PARALL_COND*PARALL_COND*mu1*mu2 && // angle between two segments greater then PARALL_COND &&
d*d < MIN_DIST*MIN_DIST*mu1 && // distance between vertex of the segment and other one's less then MIN_DIST
(x22-x11)*(x22-x12) < 0.0 && (y22-y11)*(y22-y12) < 0.0)
{
myState = BRepMesh_SelfIntersectingWire; return;
}
//look for intersection of two linear segments
if(Abs(AB) <= RESOLUTION) continue; //current segments seem parallel - no intersection
//calculate coordinates of point of the intersection
BC = B1*C2 - B2*C1; xc = BC/AB;
CA = C1*A2 - C2*A1; yc = CA/AB;
//check on belonging of intersection point to the both of segments
myState = BRepMesh_SelfIntersectingWire; return;
}
//look for intersection of two linear segments
if(Abs(AB) <= RESOLUTION) continue; //current segments seem parallel - no intersection
//calculate coordinates of point of the intersection
BC = B1*C2 - B2*C1; xc = BC/AB;
CA = C1*A2 - C2*A1; yc = CA/AB;
//check on belonging of intersection point to the both of segments
if( Abs(xc-x11) > RESOLUTION && Abs(xc-x12) > RESOLUTION &&
Abs(yc-y11) > RESOLUTION && Abs(yc-y12) > RESOLUTION &&
Abs(xc-x21) > RESOLUTION && Abs(xc-x22) > RESOLUTION &&
Abs(yc-y21) > RESOLUTION && Abs(yc-y22) > RESOLUTION )
{
if((xc-x11)*(xc-x12) < 0.0 && (yc-y11)*(yc-y12) < 0.0 &&
(xc-x21)*(xc-x22) < 0.0 && (yc-y21)*(yc-y22) < 0.0)
(xc-x21)*(xc-x22) < 0.0 && (yc-y21)*(yc-y22) < 0.0)
{
//different segments may have common vertex (why "<" but "<=")
myState = BRepMesh_SelfIntersectingWire; return;
}
//different segments may have common vertex (why "<" but "<=")
myState = BRepMesh_SelfIntersectingWire; return;
}
}
}
}
}
}
}

10
src/BRepMesh/BRepMesh_Classifier.lxx
View File

@ -15,13 +15,3 @@ inline BRepMesh_Status BRepMesh_Classifier::State() const
{
return myState;
}
//=======================================================================
//function : NaturalRestriction
//purpose :
//=======================================================================
inline Standard_Boolean BRepMesh_Classifier::NaturalRestriction() const
{
return isnatural;
}

148
src/BRepMesh/BRepMesh_Delaun.cdl
View File

@ -3,7 +3,7 @@
-- Author: Didier PIFFAULT
-- <dpf@nonox>
---Copyright: Matra Datavision 1993, 1994
class Delaun from BRepMesh
@ -33,115 +33,95 @@ class Delaun from BRepMesh
is
-- Interface :
Create (Vertices : in out Array1OfVertexOfDelaun from BRepMesh;
ZPositive : in Boolean from Standard=Standard_True)
Create (Vertices : in out Array1OfVertexOfDelaun from BRepMesh;
ZPositive : in Boolean from Standard=Standard_True)
---Purpose: Creates the triangulation with an empty Mesh
-- data structure.
returns Delaun from BRepMesh;
Create (OldMesh : mutable DataStructureOfDelaun from BRepMesh;
Vertices : in out Array1OfVertexOfDelaun from BRepMesh;
ZPositive : in Boolean from Standard=Standard_True)
Create (OldMesh : mutable DataStructureOfDelaun from BRepMesh;
Vertices : in out Array1OfVertexOfDelaun from BRepMesh;
ZPositive : in Boolean from Standard=Standard_True)
---Purpose: Creates the triangulation with and existant
-- Mesh data structure.
returns Delaun from BRepMesh;
Create (OldMesh : mutable DataStructureOfDelaun from BRepMesh;
VertexIndices : in out Array1OfInteger from TColStd;
ZPositive : in Boolean from Standard=Standard_True)
Create (OldMesh : mutable DataStructureOfDelaun from BRepMesh;
VertexIndices : in out Array1OfInteger from TColStd;
ZPositive : in Boolean from Standard=Standard_True)
---Purpose: Creates the triangulation with and existant
-- Mesh data structure.
returns Delaun from BRepMesh;
AddVertex (me : in out;
theVertex : in Vertex from BRepMesh);
---Purpose: Adds a new vertex in the triangulation.
RemoveVertex (me : in out;
theVertex : in Vertex from BRepMesh);
RemoveVertex (me : in out;
theVertex : in Vertex from BRepMesh);
---Purpose: Removes a vertex in the triangulation.
AddVertices (me : in out;
Vertices : in out Array1OfVertexOfDelaun from BRepMesh);
AddVertices (me : in out;
Vertices : in out Array1OfVertexOfDelaun from BRepMesh);
---Purpose: Adds some vertices in the triangulation.
RevertDiagonal (me : in out;
theEdge : in Integer from Standard)
---Purpose: Substitutes the Edge beetween to triangles by the
-- other diagonal of the quadrilatere if it is
-- possible (convex polygon). Return True if done.
returns Boolean from Standard;
UseEdge (me : in out;
theEdge : in Integer from Standard)
UseEdge (me : in out;
theEdge : in Integer from Standard)
---Purpose: Modify mesh to use the edge. Return True if done.
returns Boolean from Standard;
SmoothMesh (me : in out;
Epsilon : in Real from Standard);
---Purpose: Smooths the mesh in 2d space. The method is to
-- move the free and OnSurface vertices at the
-- barycentre of their polygon.
Result (me)
Result (me)
---C++: return const &
---Purpose: Gives the Mesh data structure.
returns DataStructureOfDelaun from BRepMesh;
Frontier (me : in out)
Frontier (me : in out)
---Purpose: Gives the list of frontier edges
---C++: return const &
returns MapOfInteger from BRepMesh;
InternalEdges (me : in out)
InternalEdges (me : in out)
---Purpose: Gives the list of internal edges
---C++: return const &
returns MapOfInteger from BRepMesh;
FreeEdges (me : in out)
FreeEdges (me : in out)
---Purpose: Gives the list of free edges used only one time
---C++: return const &
returns MapOfInteger from BRepMesh;
GetVertex (me;
vIndex : in Integer from Standard)
GetVertex (me;
vIndex : in Integer from Standard)
---C++: return const &
---C++: inline
returns Vertex from BRepMesh;
GetEdge (me;
eIndex : in Integer from Standard)
GetEdge (me;
eIndex : in Integer from Standard)
---C++: return const &
---C++: inline
returns Edge from BRepMesh;
GetTriangle (me;
tIndex : in Integer from Standard)
GetTriangle (me;
tIndex : in Integer from Standard)
---C++: return const &
---C++: inline
returns Triangle from BRepMesh;
-- Implementation :
-- Implementation :
Init (me : in out;
Vertices : in out Array1OfVertexOfDelaun from BRepMesh);
---Purpose: Initializes the triangulation with an Array of
Init (me : in out;
Vertices : in out Array1OfVertexOfDelaun from BRepMesh);
---Purpose: Initializes the triangulation with an Array of
-- Vertex.
Compute (me : in out;
@ -149,14 +129,10 @@ class Delaun from BRepMesh
---Purpose: Computes the triangulation and add the vertices
-- edges and triangles to the Mesh data structure.
ReCompute (me : in out;
VertexIndices : in out Array1OfInteger from TColStd);
---Purpose: Clear the existing triangles and recomputes
-- the triangulation .
SuperMesh (me : in out;
theBox : Box2d from Bnd);
---Purpose: Build the super mesh .
theBox : Box2d from Bnd);
---Purpose: Build the super mesh .
FrontierAdjust (me : in out)
@ -164,9 +140,9 @@ class Delaun from BRepMesh
is private;
MeshLeftPolygonOf (me : in out;
EdgeIndex : Integer from Standard;
EdgeSens : Boolean from Standard)
MeshLeftPolygonOf (me : in out;
EdgeIndex : Integer from Standard;
EdgeSens : Boolean from Standard)
---Purpose: Find left polygon of the edge and call MeshPolygon.
is private;
@ -178,7 +154,7 @@ class Delaun from BRepMesh
CreateTriangles(me : in out;
vertexIndex : Integer from Standard;
vertexIndex : Integer from Standard;
--vertex : in Vertex from BRepMesh;
freeEdges: out MapOfIntegerInteger from BRepMesh)
---Purpose: Creates the triangles beetween the node
@ -194,34 +170,40 @@ class Delaun from BRepMesh
-- When an edge is suppressed more than one time
-- it is destroyed.
is private;
Perform (me: in out;
theBndBox : out Box2d from Bnd;
theVertexIndices: out Array1OfInteger from TColStd)
is private;
Contains (me;
TrianIndex : Integer from Standard;
theVertex : in Vertex from BRepMesh;
edgeOn : out Integer from Standard)
---Purpose: Test if triangle of index <TrianIndex>
-- contains geometricaly <theVertex>. If <EdgeOn>
-- is != 0 then theVertex is on Edge of index
-- <edgeOn>.
returns Boolean from Standard;
TriangleContaining
(me : in out;
theVertex : in Vertex from BRepMesh)
---Purpose: Gives the index of triangle containing
-- geometricaly <theVertex>.
returns Integer from Standard;
Contains (me;
TrianIndex : Integer from Standard;
theVertex : in Vertex from BRepMesh;
edgeOn : out Integer from Standard)
---Purpose: Test if triangle of index <TrianIndex>
-- contains geometricaly <theVertex>. If <EdgeOn>
-- is != 0 then theVertex is on Edge of index
-- <edgeOn>.
returns Boolean from Standard;
fields MeshData : DataStructureOfDelaun from BRepMesh;
PositiveOrientation : Boolean from Standard;
tCircles : CircleTool from BRepMesh;
supVert1 : Integer from Standard;
supVert2 : Integer from Standard;
supVert3 : Integer from Standard;
supTrian : Triangle from BRepMesh;
mapEdges : MapOfInteger from BRepMesh;
CreateTrianglesOnNewVertices(me : in out;
theVertexIndices: out Array1OfInteger from TColStd)
--vertex : in Vertex from BRepMesh;
---Purpose: Creates the triangles on new nodes
is private;
fields MeshData : DataStructureOfDelaun from BRepMesh;
PositiveOrientation : Boolean from Standard;
tCircles : CircleTool from BRepMesh;
supVert1 : Integer from Standard;
supVert2 : Integer from Standard;
supVert3 : Integer from Standard;
supTrian : Triangle from BRepMesh;
mapEdges : MapOfInteger from BRepMesh;
end Delaun;

945
src/BRepMesh/BRepMesh_Delaun.cxx
View File

File diff suppressed because it is too large Load Diff

12
src/BRepMesh/BRepMesh_FastDiscret.cdl
View File

@ -128,6 +128,18 @@ is
last : Real from Standard)
returns Boolean is private;
RelativeEdgeDeflection(myclass;
edge : Edge from TopoDS;
defle : Real from Standard;
dtotale : Real from Standard;
cdef : out Real from Standard)
---Purpose: Returns computed relative deflection for edge
returns Real from Standard;
BoxMaxDimension(myclass;
box : in Box from Bnd;
maxdim : out Real from Standard);
---Purpose: Returns the maximal dimension of Bnd_Box
InternalVertices
(me : mutable;

91
src/BRepMesh/BRepMesh_FastDiscret.cxx
View File

@ -126,16 +126,8 @@ BRepMesh_FastDiscret::BRepMesh_FastDiscret(const Standard_Real theDefle,
myInshape(theInshape)
{
myAllocator = new NCollection_IncAllocator(64000);
if (theRelative)
{
Standard_Real TXmin, TYmin, TZmin, TXmax, TYmax, TZmax;
theBox.Get(TXmin, TYmin, TZmin, TXmax, TYmax, TZmax);
myDtotale = TXmax-TXmin;
const Standard_Real dy = TYmax-TYmin;
const Standard_Real dz = TZmax-TZmin;
if (dy > myDtotale) myDtotale = dy;
if (dz > myDtotale) myDtotale = dz;
}
if(myRelative)
BoxMaxDimension(theBox, myDtotale);
}
//=======================================================================
@ -156,19 +148,57 @@ BRepMesh_FastDiscret::BRepMesh_FastDiscret(const Standard_Real theDefle,
myInshape(theInshape)
{
myAllocator = new NCollection_IncAllocator(64000);
if (theRelative)
{
Standard_Real TXmin, TYmin, TZmin, TXmax, TYmax, TZmax;
theBox.Get(TXmin, TYmin, TZmin, TXmax, TYmax, TZmax);
myDtotale = TXmax-TXmin;
const Standard_Real dy = TYmax-TYmin;
const Standard_Real dz = TZmax-TZmin;
if (dy > myDtotale) myDtotale = dy;
if (dz > myDtotale) myDtotale = dz;
}
if(myRelative)
BoxMaxDimension(theBox, myDtotale);
Perform(theShape);
}
//=======================================================================
//function : BoxMaxDimension
//purpose :
//=======================================================================
void BRepMesh_FastDiscret::BoxMaxDimension(const Bnd_Box& theBox, Standard_Real& theMaxDim)
{
if(theBox.IsVoid())
return;
Standard_Real TXmin, TYmin, TZmin, TXmax, TYmax, TZmax;
theBox.Get(TXmin, TYmin, TZmin, TXmax, TYmax, TZmax);
theMaxDim = TXmax-TXmin;
const Standard_Real dy = TYmax-TYmin;
const Standard_Real dz = TZmax-TZmin;
if (dy > theMaxDim) theMaxDim = dy;
if (dz > theMaxDim) theMaxDim = dz;
}
//=======================================================================
//function : RelativeEdgeDeflection
//purpose :
//=======================================================================
Standard_Real BRepMesh_FastDiscret::RelativeEdgeDeflection(const TopoDS_Edge& theEdge,
const Standard_Real theDefle,
const Standard_Real theDTotale,
Standard_Real& theDefCoef)
{
theDefCoef = 1.;
Standard_Real defedge = theDefle;
if(theEdge.IsNull())
return defedge;
Bnd_Box B;
BRepBndLib::Add(theEdge, B);
BoxMaxDimension(B, defedge);
// adjusted in relation to the total size:
theDefCoef = theDTotale/(2*defedge);
if (theDefCoef < 0.5) theDefCoef = 0.5;
if (theDefCoef > 2.) theDefCoef = 2.;
defedge = theDefCoef * defedge * theDefle;
return defedge;
}
//=======================================================================
//function : Perform(shape)
//purpose :
@ -270,7 +300,6 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface)
i = 1;
Standard_Real defedge, defface;
Standard_Real dx, dy, dz;
Standard_Integer nbEdge = 0;
Standard_Real savangle = myAngle;
Standard_Real cdef;
@ -301,20 +330,7 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface)
defedge = P->Deflection();
}
else {
Bnd_Box B;
BRepBndLib::Add(edge, B);
B.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dx = aXmax-aXmin;
dy = aYmax-aYmin;
dz = aZmax-aZmin;
defedge = dx;
if (defedge < dy) defedge = dy;
if (defedge < dz) defedge = dz;
// adjusted in relation to the total size:
cdef = myDtotale/(2*defedge);
if (cdef < 0.5) cdef = 0.5;
if (cdef > 2.) cdef = 2.;
defedge = cdef * defedge * myDeflection;
defedge = RelativeEdgeDeflection(edge, myDeflection, myDtotale, cdef);
myAngle = savangle * cdef;
}
defface = defface + defedge;
@ -510,7 +526,7 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface)
BS.D0 (myumin, myvmin, P11);
BS.D0 (myumin, dfvave, P21);
BS.D0 (myumin, myvmax, P31);
for (i1=0, dfucur=myumin; i1 <= 20; i1++, dfucur+=du) {
for (i1=1, dfucur=myumin+du; i1 <= 20; i1++, dfucur+=du) {
BS.D0 (dfucur, myvmin, P12);
BS.D0 (dfucur, dfvave, P22);
BS.D0 (dfucur, myvmax, P32);
@ -523,7 +539,7 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface)
BS.D0(myumin, myvmin, P11);
BS.D0(dfuave, myvmin, P21);
BS.D0(myumax, myvmin, P31);
for (i1=0, dfvcur=myvmin; i1 <= 20; i1++, dfvcur+=dv) {
for (i1=1, dfvcur=myvmin+dv; i1 <= 20; i1++, dfvcur+=dv) {
BS.D0 (myumin, dfvcur, P12);
BS.D0 (dfuave, dfvcur, P22);
BS.D0 (myumax, dfvcur, P32);
@ -663,7 +679,6 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface)
myStructure.Nullify();
}
//=======================================================================
//function : Add
//purpose :

28
src/BRepMesh/BRepMesh_FastDiscretFace.cxx
View File

@ -217,16 +217,13 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face& theFace
tabvert_corr(i) = i;
}
myStructure->ReplaceNodes(aMoveNodes);
Standard_Boolean rajout;
BRepMesh_ClassifierPtr& classifier = theAttrib->GetClassifier();
switch (thetype)
{
case GeomAbs_Plane:
rajout = !classifier->NaturalRestriction();
break;
case GeomAbs_Sphere:
case GeomAbs_Torus:
rajout = Standard_True;
@ -617,26 +614,9 @@ void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurfac
Standard_Real deltaX = myAttrib->GetDeltaX();
Standard_Real deltaY = myAttrib->GetDeltaY();
if (thetype == GeomAbs_Plane && !theClassifier->NaturalRestriction())
{
// rajout d`un seul point au milieu.
const Standard_Real U = 0.5*(umin+umax);
const Standard_Real V = 0.5*(vmin+vmax);
if (theClassifier->Perform(gp_Pnt2d(U, V)) == TopAbs_IN)
{
// Record 3d point
BRepMesh_GeomTool::D0(theCaro, U, V, p3d);
myNbLocat++;
myLocation3d.Bind(myNbLocat, p3d);
// Record 2d point
p2d.SetCoord((U-umin)/deltaX, (V-vmin)/deltaY);
newV.Initialize(p2d.XY(), myNbLocat, BRepMesh_Free);
theInternalV.Append(newV);
}
}
else if (thetype == GeomAbs_Sphere)
{
gp_Sphere S = BS.Sphere();
if (thetype == GeomAbs_Sphere)
{
gp_Sphere S = BS.Sphere();
const Standard_Real R = S.Radius();
// Calculate parameters for iteration in V direction

124
src/BRepMesh/BRepMesh_IncrementalMesh.cxx
View File

@ -178,20 +178,11 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Shape& S)
myModified = Standard_False;
TopExp_Explorer ex;
Standard_Real TXmin, TYmin, TZmin, TXmax, TYmax, TZmax;
Standard_Real dx, dy, dz;
//AGV 080407: Since version 6.2.0 there would be exception without this check
if (myBox.IsVoid())
return;
myBox.Get(TXmin, TYmin, TZmin, TXmax, TYmax, TZmax);
dx = TXmax-TXmin;
dy = TYmax-TYmin;
dz = TZmax-TZmin;
mydtotale = dx;
if (dy > mydtotale) mydtotale = dy;
if (dz > mydtotale) mydtotale = dz;
BRepMesh_FastDiscret::BoxMaxDimension(myBox, mydtotale);
for (ex.Init(S, TopAbs_EDGE); ex.More(); ex.Next()) {
if(BRep_Tool::IsGeometric(TopoDS::Edge(ex.Current()))) {
@ -231,7 +222,7 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Shape& S)
Standard_Real f, l, defedge;
Standard_Integer i, nbNodes;
TopLoc_Location L;
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
Standard_Real cdef = 1.;
ex.Init(S ,TopAbs_EDGE, TopAbs_FACE);
while (ex.More()) {
@ -242,23 +233,11 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Shape& S)
continue;
}
if (myRelative) {
Bnd_Box B;
BRepBndLib::Add(E, B);
B.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dx = aXmax-aXmin;
dy = aYmax-aYmin;
dz = aZmax-aZmin;
defedge = dx;
if (defedge < dy) defedge = dy;
if (defedge < dz) defedge = dz;
// ajustement par rapport a la taille totale:
Standard_Real cdef = mydtotale/(2*defedge);
if (cdef < 0.5) cdef = 0.5;
if (cdef > 2.) cdef = 2.;
defedge = cdef * defedge * myDeflection;
}
else defedge = myDeflection;
if (myRelative)
defedge = BRepMesh_FastDiscret::RelativeEdgeDeflection(E, myDeflection,
mydtotale, cdef);
else
defedge = myDeflection;
Handle(Poly_Polygon3D) P3D = BRep_Tool::Polygon3D(E, L);
Standard_Boolean maill = Standard_False;
@ -279,8 +258,8 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Shape& S)
TColgp_Array1OfPnt Nodes(1, nbNodes);
TColStd_Array1OfReal UVNodes(1, nbNodes);
for ( i = 1; i <= nbNodes; i++) {
Nodes(i) = TD.Value(i);
UVNodes(i) = TD.Parameter(i);
Nodes(i) = TD.Value(i);
UVNodes(i) = TD.Parameter(i);
}
BRep_Builder B;
@ -305,6 +284,7 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Edge& E)
Handle(Poly_PolygonOnTriangulation) Poly, NullPoly;
Standard_Boolean found = Standard_False;
Standard_Real defedge;
Standard_Real cdef = 1.;
BRep_Builder B;
Standard_Boolean defined = Standard_False;
@ -313,33 +293,20 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Edge& E)
i++;
if (!T.IsNull() && !Poly.IsNull()) {
if (!defined) {
if (myRelative) {
Bnd_Box aBox;
BRepBndLib::Add(E, aBox);
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dx, dy, dz;
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dx = aXmax-aXmin;
dy = aYmax-aYmin;
dz = aZmax-aZmin;
defedge = dx;
if (defedge < dy) defedge = dy;
if (defedge < dz) defedge = dz;
// ajustement par rapport a la taille totale:
Standard_Real cdef = mydtotale/(2*defedge);
if (cdef < 0.5) cdef = 0.5;
if (cdef > 2.) cdef = 2.;
defedge = cdef * defedge * myDeflection;
}
else defedge = myDeflection;
mymapedge.Bind(E, defedge);
defined = Standard_True;
if (myRelative)
defedge = BRepMesh_FastDiscret::RelativeEdgeDeflection(E, myDeflection,
mydtotale, cdef);
else
defedge = myDeflection;
mymapedge.Bind(E, defedge);
defined = Standard_True;
}
if ((!myRelative && Poly->Deflection() <= 1.1*defedge) ||
(myRelative && Poly->Deflection() <= 1.1*defedge))
found = Standard_True;
(myRelative && Poly->Deflection() <= 1.1*defedge))
found = Standard_True;
else {
myModified = Standard_True;
B.UpdateEdge(E, NullPoly, T, l);
myModified = Standard_True;
B.UpdateEdge(E, NullPoly, T, l);
}
}
} while (!Poly.IsNull());
@ -369,7 +336,7 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Face& F)
BRep_Builder B;
TopExp_Explorer ex;
Standard_Real defedge, defface;
Standard_Real defedge, defface, cdef = 1.;
Standard_Integer nbEdge = 0;
if (myRelative) {
defface = 0.;
@ -378,25 +345,10 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Face& F)
const TopoDS_Edge& edge = TopoDS::Edge(ex.Current());
nbEdge++;
if (mymapedge.IsBound(edge)) {
defedge = mymapedge(edge);
}
else {
Bnd_Box aBox;
BRepBndLib::Add(edge, aBox);
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dx, dy, dz;
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dx = aXmax-aXmin;
dy = aYmax-aYmin;
dz = aZmax-aZmin;
defedge = dx;
if (defedge < dy) defedge = dy;
if (defedge < dz) defedge = dz;
// ajustement par rapport a la taille totale:
Standard_Real cdef = mydtotale/(2*defedge);
if (cdef < 0.5) cdef = 0.5;
if (cdef > 2.) cdef = 2.;
defedge = cdef * defedge * myDeflection;
defedge = mymapedge(edge);
}
else
defedge = BRepMesh_FastDiscret::RelativeEdgeDeflection(edge, myDeflection, mydtotale, cdef);
defface = defface + defedge;
}
if (nbEdge != 0) defface = defface / nbEdge;
@ -407,18 +359,16 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Face& F)
if (!T.IsNull()) {
if ((!myRelative && T->Deflection() <= 1.1*defface) ||
(myRelative && T->Deflection() <= 1.1*defface)) {
for (ex.Init(F, TopAbs_EDGE);
ex.More();
ex.Next()) {
const TopoDS_Shape& E = ex.Current();
Poly = BRep_Tool::PolygonOnTriangulation(TopoDS::Edge(E), T, l);
if (Poly.IsNull() || myMap.Contains(E)) {
WillBeTriangulated = Standard_True;
// cas un peu special. la triangulation est bonne, mais
// l'edge n'a pas de representation polygonalisee sur celle-ci.
break;
}
(myRelative && T->Deflection() <= 1.1*defface)) {
for (ex.Init(F, TopAbs_EDGE); ex.More(); ex.Next()) {
const TopoDS_Shape& E = ex.Current();
Poly = BRep_Tool::PolygonOnTriangulation(TopoDS::Edge(E), T, l);
if (Poly.IsNull() || myMap.Contains(E)) {
WillBeTriangulated = Standard_True;
// cas un peu special. la triangulation est bonne, mais
// l'edge n'a pas de representation polygonalisee sur celle-ci.
break;
}
}
}
else WillBeTriangulated = Standard_True;
@ -428,8 +378,8 @@ void BRepMesh_IncrementalMesh::Update(const TopoDS_Face& F)
myModified = Standard_True;
if (!T.IsNull()) {
for (ex.Init(F, TopAbs_EDGE); ex.More(); ex.Next()) {
B.UpdateEdge(TopoDS::Edge(ex.Current()), NullPoly, T, l);
myMap.Remove(ex.Current());
B.UpdateEdge(TopoDS::Edge(ex.Current()), NullPoly, T, l);
myMap.Remove(ex.Current());
}
B.UpdateFace(F, TNull);
}