0028499: Checkshape incorrectly reports BRepCheck_NotClosed when gap is covered by...
[occt.git] / src / BRepCheck / BRepCheck_Wire.cxx
CommitLineData
b311480e 1// Created on: 1995-12-12
2// Created by: Jacques GOUSSARD
3// Copyright (c) 1995-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 8// This library is free software; you can redistribute it and/or modify it under
9// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
b311480e 16
7fd59977 17// Modified by dpf, Fri Dec 19 15:31:03 1997
0d969553 18// Processing of closing in 2d.
7fd59977 19// modified by eap Tue Dec 18 14:14:25 2001 (bug OCC23)
20// Check self-intersection in case of closed edge
7fd59977 21// modified by eap Fri Dec 21 17:36:55 2001 (bug OCC35)
22// Closed2d() added
7fd59977 23// Modified by skv - Wed Jul 23 12:22:20 2003 OCC1764
24
42cf5bc1 25#include <Bnd_Array1OfBox2d.hxx>
26#include <BndLib_Add2dCurve.hxx>
27#include <BRep_Tool.hxx>
28#include <BRepAdaptor_Curve.hxx>
29#include <BRepAdaptor_HSurface.hxx>
30#include <BRepAdaptor_Surface.hxx>
31#include <BRepCheck.hxx>
7fd59977 32#include <BRepCheck_ListIteratorOfListOfStatus.hxx>
42cf5bc1 33#include <BRepCheck_ListOfStatus.hxx>
34#include <BRepCheck_Wire.hxx>
35#include <BRepTools_WireExplorer.hxx>
36#include <ElCLib.hxx>
37#include <Geom2d_Curve.hxx>
38#include <Geom2dAdaptor_Curve.hxx>
39#include <Geom2dAdaptor_HCurve.hxx>
40#include <Geom2dInt_GInter.hxx>
41#include <Geom_Curve.hxx>
42#include <gp_Lin.hxx>
43#include <gp_Pnt.hxx>
44#include <gp_Pnt2d.hxx>
45#include <IntRes2d_Domain.hxx>
7fd59977 46#include <IntRes2d_Intersection.hxx>
47#include <IntRes2d_IntersectionPoint.hxx>
48#include <IntRes2d_IntersectionSegment.hxx>
49#include <IntRes2d_Transition.hxx>
42cf5bc1 50#include <Precision.hxx>
51#include <Standard_Type.hxx>
52#include <TColGeom2d_Array1OfCurve.hxx>
53#include <TopExp.hxx>
54#include <TopExp_Explorer.hxx>
55#include <TopLoc_Location.hxx>
7fd59977 56#include <TopoDS.hxx>
42cf5bc1 57#include <TopoDS_Edge.hxx>
58#include <TopoDS_Face.hxx>
59#include <TopoDS_Iterator.hxx>
60#include <TopoDS_Shape.hxx>
7fd59977 61#include <TopoDS_Vertex.hxx>
42cf5bc1 62#include <TopoDS_Wire.hxx>
63#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
64#include <TopTools_DataMapOfShapeListOfShape.hxx>
7fd59977 65#include <TopTools_HArray1OfShape.hxx>
42cf5bc1 66#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
67#include <TopTools_IndexedMapOfOrientedShape.hxx>
68#include <TopTools_IndexedMapOfShape.hxx>
69#include <TopTools_ListIteratorOfListOfShape.hxx>
70#include <TopTools_ListOfShape.hxx>
7fd59977 71#include <TopTools_MapIteratorOfMapOfOrientedShape.hxx>
42cf5bc1 72#include <TopTools_MapIteratorOfMapOfShape.hxx>
73#include <TopTools_MapOfOrientedShape.hxx>
74#include <TopTools_MapOfShape.hxx>
7fd59977 75
42cf5bc1 76#include <stdio.h>
92efcf78 77IMPLEMENT_STANDARD_RTTIEXT(BRepCheck_Wire,BRepCheck_Result)
78
7fd59977 79static void Propagate(const TopTools_IndexedDataMapOfShapeListOfShape&,
80 const TopoDS_Shape&, // edge
81 TopTools_MapOfShape&); // mapofedge
82
83
84static TopAbs_Orientation GetOrientation(const TopTools_MapOfShape&,
85 const TopoDS_Edge&);
86
87
88static
89 void ChoixUV(const TopoDS_Vertex&,
90 const TopoDS_Edge&,
91 const TopoDS_Face&,
92 TopTools_ListOfShape&);
93
94// 20/03/02 akm vvv (OCC234)
95// static
96// Standard_Boolean CheckLoopOrientation( const TopoDS_Vertex&,
97// const TopoDS_Edge&,
98// const TopoDS_Edge&,
99// const TopoDS_Face&,
100// TopTools_ListOfShape&);
101// 20/03/02 akm ^^^
102
103inline Standard_Boolean IsOriented(const TopoDS_Shape& S)
104{
105 return (S.Orientation() == TopAbs_FORWARD ||
106 S.Orientation() == TopAbs_REVERSED);
107}
108
109static
94f71cad 110 void CurveDirForParameter(const Geom2dAdaptor_Curve& aC2d,
7fd59977 111 const Standard_Real aPrm,
112 gp_Pnt2d& Pnt,
113 gp_Vec2d& aVec2d);
114
115// Modified by Sergey KHROMOV - Thu Jun 20 11:21:51 2002 OCC325 Begin
116static Standard_Boolean IsClosed2dForPeriodicFace
117 (const TopoDS_Face &theFace,
118 const gp_Pnt2d &theP1,
119 const gp_Pnt2d &theP2,
120 const TopoDS_Vertex &theVertex);
121
122static Standard_Boolean GetPnt2d(const TopoDS_Vertex &theVertex,
123 const TopoDS_Edge &theEdge,
124 const TopoDS_Face &theFace,
125 gp_Pnt2d &aPnt);
126// Modified by Sergey KHROMOV - Wed May 22 10:44:08 2002 End
127
128//=======================================================================
129//function : BRepCheck_Wire
130//purpose :
131//=======================================================================
132BRepCheck_Wire::BRepCheck_Wire(const TopoDS_Wire& W)
133{
134 Init(W);
135}
136//=======================================================================
137//function : Minimum
138//purpose :
139//=======================================================================
140void BRepCheck_Wire::Minimum()
141{
142 myCdone = Standard_False;
143 myGctrl = Standard_True;
144 if (!myMin) {
145 BRepCheck_ListOfStatus thelist;
146 myMap.Bind(myShape, thelist);
147 BRepCheck_ListOfStatus& lst = myMap(myShape);
148
0d969553 149 // check that the wire is "connex"
7fd59977 150 TopExp_Explorer exp(myShape,TopAbs_EDGE);
151 Standard_Integer nbedge = 0;
152 myMapVE.Clear();
153 // fill myMapVE
154 for (; exp.More(); exp.Next()) {
155 nbedge++;
156 TopExp_Explorer expv;
157 for (expv.Init(exp.Current(),TopAbs_VERTEX);
158 expv.More(); expv.Next()) {
159 const TopoDS_Shape& vtx = expv.Current();
160 Standard_Integer index = myMapVE.FindIndex(vtx);
161 if (index == 0) {
162 TopTools_ListOfShape theListOfShape;
163 index = myMapVE.Add(vtx, theListOfShape);
164 }
165 myMapVE(index).Append(exp.Current());
166 }
167 }
168 // wire must have at least one edge
169 if (nbedge == 0) {
170 BRepCheck::Add(lst,BRepCheck_EmptyWire);
171 }
172 // check if all edges are connected through vertices
173 else if (nbedge >= 2) {
174 TopTools_MapOfShape mapE;
175 exp.ReInit();
176 Propagate(myMapVE,exp.Current(),mapE);
177 for (exp.ReInit(); exp.More(); exp.Next()) {
178 if (!mapE.Contains(exp.Current())) {
179 BRepCheck::Add(lst,BRepCheck_NotConnected);
180 break;
181 }
182 }
183 }
184 if (lst.IsEmpty()) {
185 lst.Append(BRepCheck_NoError);
186 }
187 myMapVE.Clear();
188 myMin = Standard_True;
189 }
190}
191//=======================================================================
192//function : InContext
193//purpose :
194//=======================================================================
195void BRepCheck_Wire::InContext(const TopoDS_Shape& S)
196{
197
198 if (myMap.IsBound(S)) {
199 return;
200 }
201 BRepCheck_ListOfStatus thelist;
202 myMap.Bind(S, thelist);
203
204 BRepCheck_ListOfStatus& lst = myMap(S);
205
206 // check if my wire is in <S>
207 TopExp_Explorer exp(S,TopAbs_WIRE);
208 for ( ; exp.More(); exp.Next()) {
209 if (exp.Current().IsSame(myShape)) {
210 break;
211 }
212 }
213 if (!exp.More()) {
214 BRepCheck::Add(lst,BRepCheck_SubshapeNotInShape);
215 return;
216 }
217
218 BRepCheck_Status st = BRepCheck_NoError;
219 TopAbs_ShapeEnum styp = S.ShapeType();
220 switch (styp) {
221
222 case TopAbs_FACE:
223 {
0d969553 224 TopoDS_Edge ed1,ed2;
7fd59977 225 if (myGctrl)
226 st = SelfIntersect(TopoDS::Face(S),ed1,ed2,Standard_True);
227 if (st != BRepCheck_NoError) break;
228 st = Closed();
229 if (st != BRepCheck_NoError) break;
230 st = Orientation(TopoDS::Face(S));
231 if (st != BRepCheck_NoError) break;
232 st = Closed2d(TopoDS::Face(S));
233 }
234 break;
235 default:
236 break;
237 }
238
239 if (st != BRepCheck_NoError)
240 BRepCheck::Add(lst,st);
241
242 if (lst.IsEmpty())
243 lst.Append(BRepCheck_NoError);
244}
245//=======================================================================
246//function : Blind
247//purpose :
248//=======================================================================
249void BRepCheck_Wire::Blind()
250{
251 if (!myBlind) {
0d969553 252 // nothing more that the minimum
7fd59977 253 myBlind = Standard_True;
254 }
255}
256//=======================================================================
257//function : Closed
258//purpose :
259//=======================================================================
260BRepCheck_Status BRepCheck_Wire::Closed(const Standard_Boolean Update)
261{
262
263 if (myCdone) {
264 if (Update) {
265 BRepCheck::Add(myMap(myShape),myCstat);
266 }
267 return myCstat;
268 }
269
0d969553 270 myCdone = Standard_True;
7fd59977 271
272 BRepCheck_ListIteratorOfListOfStatus itl(myMap(myShape));
273 if (itl.Value() != BRepCheck_NoError) {
274 myCstat = itl.Value();
0d969553 275 return myCstat; // already saved
7fd59977 276 }
277
278 myCstat = BRepCheck_NoError;
279
280 TopExp_Explorer exp,expv;
281 TopTools_MapOfShape mapS;
282 TopTools_DataMapOfShapeListOfShape Cradoc;
283 myMapVE.Clear();
284 // Checks if the oriented edges of the wire give a "closed" wire,
285 // i-e if each oriented vertex on oriented edges is found 2 times...
286 // myNbori = 0;
287 for (exp.Init(myShape,TopAbs_EDGE);exp.More(); exp.Next()) {
288 if (IsOriented(exp.Current())) {
289 // myNbori++;
290 if (!Cradoc.IsBound(exp.Current())) {
291 TopTools_ListOfShape theListOfShape;
292 Cradoc.Bind(exp.Current(), theListOfShape);
293 }
294 Cradoc(exp.Current()).Append(exp.Current());
295
296 mapS.Add(exp.Current());
297 for (expv.Init(exp.Current(),TopAbs_VERTEX); expv.More(); expv.Next()) {
298 if (IsOriented(expv.Current())) {
299 Standard_Integer index = myMapVE.FindIndex(expv.Current());
300 if (index == 0) {
301 TopTools_ListOfShape theListOfShape1;
302 index = myMapVE.Add(expv.Current(), theListOfShape1);
303 }
304 myMapVE(index).Append(exp.Current());
305 }
306 }
307 }
308 }
309
310 Standard_Integer theNbori = mapS.Extent();
311 if (theNbori >= 2) {
312 mapS.Clear();
313 for (exp.ReInit(); exp.More(); exp.Next()) {
314 if (IsOriented(exp.Current())) {
315 break;
316 }
317 }
318 Propagate(myMapVE,exp.Current(),mapS);
319 }
320 if (theNbori != mapS.Extent()) {
321 myCstat = BRepCheck_NotConnected;
322 if (Update) {
323 BRepCheck::Add(myMap(myShape),myCstat);
324 }
325 return myCstat;
326 }
327
328 // Checks the number of occurence of an edge : maximum 2, and in this
329 // case, one time FORWARD and one time REVERSED
330
331 Standard_Boolean yabug = Standard_False;
332 for (TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itdm(Cradoc);
333 itdm.More(); itdm.Next()) {
334 if (itdm.Value().Extent() >= 3) {
335 yabug = Standard_True;
336 }
337 else if (itdm.Value().Extent() == 2) {
338 if (itdm.Value().First().Orientation() ==
339 itdm.Value().Last().Orientation()) {
340 yabug = Standard_True;
341 }
342 }
343 if (yabug) {
344 myCstat = BRepCheck_RedundantEdge;
345 if (Update) {
346 BRepCheck::Add(myMap(myShape),myCstat);
347 }
348 return myCstat;
349 }
350 }
351
352 for (Standard_Integer i = 1; i<= myMapVE.Extent(); i++) {
353 if (myMapVE(i).Extent()%2 != 0) {
354 myCstat=BRepCheck_NotClosed;
355 if (Update) {
356 BRepCheck::Add(myMap(myShape),myCstat);
357 }
358 return myCstat;
359 }
360 }
361
362 if (Update) {
363 BRepCheck::Add(myMap(myShape),myCstat);
364 }
365 return myCstat;
366}
3f257c62 367
368//=======================================================================
369//function : IsDistanceIn3DTolerance
370//purpose : Return Standard_True if distance between thePnt_f and
371// thePnt_l is not more, than aTol3d
372//=======================================================================
9e20ed57 373Standard_Boolean IsDistanceIn3DTolerance (const gp_Pnt& thePnt_f,
3f257c62 374 const gp_Pnt& thePnt_l,
375 const Standard_Real aTol3d)
376 {
377 Standard_Real Dist = thePnt_f.Distance(thePnt_l);
378
379 if (Dist < aTol3d)
380 return Standard_True;
381
0797d9d3 382#ifdef OCCT_DEBUG
3f257c62 383 cout << endl;
384 cout << "--------Function IsDistanceIn3DTolerance(...)----------" << endl;
385 cout << "--- BRepCheck Wire: Closed3d -> Error" << endl;
386 cout << "--- Dist (" << Dist << ") > Tol3d (" << aTol3d << ")" << endl;
387 cout << "Pnt1(" << thePnt_f.X() << "; " << thePnt_f.Y() << "; " << thePnt_f.Z() << ")" << endl;
388 cout << "Pnt2(" << thePnt_l.X() << "; " << thePnt_l.Y() << "; " << thePnt_l.Z() << ")" << endl;
389 cout << "------------------------------------------------------" << endl;
390#endif
391
392 return Standard_False;
393 }
394
395//=======================================================================
5d010b1d 396//function : IsDistanceIn2DTolerance
3f257c62 397//purpose :
398//=======================================================================
498ce76b 399static
3f257c62 400Standard_Boolean IsDistanceIn2DTolerance (const BRepAdaptor_Surface& aFaceSurface,
401 const gp_Pnt2d& thePnt,
402 const gp_Pnt2d& thePntRef,
403 const Standard_Real aTol3d,
0797d9d3 404#ifdef OCCT_DEBUG
3f257c62 405 const Standard_Boolean PrintWarnings = Standard_True)
498ce76b 406#else
407 const Standard_Boolean = Standard_True)
408#endif
409{
3f257c62 410 Standard_Real dumax = 0.01 * (aFaceSurface.LastUParameter() - aFaceSurface.FirstUParameter());
411 Standard_Real dvmax = 0.01 * (aFaceSurface.LastVParameter() - aFaceSurface.FirstVParameter());
412 Standard_Real dumin = Abs(thePnt.X() - thePntRef.X());
413 Standard_Real dvmin = Abs(thePnt.Y() - thePntRef.Y());
414
415 if((dumin < dumax) && (dvmin < dvmax))
416 return Standard_True;
417
0797d9d3 418#ifdef OCCT_DEBUG
3f257c62 419 if(PrintWarnings)
420 {
421 cout << endl;
422 cout << "--------Function IsDistanceIn2DTolerance(...)----------" << endl;
9e20ed57 423 cout << "--- BRepCheck Wire: Not closed in 2D" << endl;
3f257c62 424 cout << "*****************************************************" << endl;
425 cout << "*dumin = " << dumin << "; dumax = " << dumax << endl;
426 cout << "* dvmin = " << dvmin << "; dvmax = " << dvmax << endl;
427 cout << "* (dumin > dumax) or (dvmin > dvmax)." << endl;
428 cout << "*****************************************************" << endl;
429 cout << endl;
430 cout << "UFirst = " << aFaceSurface.FirstUParameter();
431 cout << "; ULast = " << aFaceSurface.LastUParameter() << endl;
432 cout << "VFirst = " << aFaceSurface.FirstVParameter();
433 cout << "; VLast = " << aFaceSurface.LastVParameter() << endl;
434 }
5d010b1d 435#endif
3f257c62 436 dumax = aFaceSurface.UResolution(aTol3d);
437 dvmax = aFaceSurface.VResolution(aTol3d);
5d010b1d 438 gp_Pnt aP;
439 gp_Vec aDU, aDV;
440 Standard_Real um = (thePnt.X() + thePntRef.X()) / 2.;
441 Standard_Real vm = (thePnt.Y() + thePntRef.Y()) / 2.;
442 aFaceSurface.D1(um, vm, aP, aDU, aDV);
443 Standard_Real aMDU = aDU.Magnitude();
444 if (aMDU > Precision::Confusion())
445 {
446 dumax = Max((aTol3d / aMDU), dumax);
447 }
448 Standard_Real aMDV = aDV.Magnitude();
449 if (aMDV > Precision::Confusion())
450 {
451 dvmax = Max((aTol3d / aMDV), dvmax);
452 }
3f257c62 453
5d010b1d 454#ifdef OCCT_DEBUG
3f257c62 455 if(PrintWarnings)
456 {
457 cout << "aTol3d = " << aTol3d <<"; URes = " << dumax << "; VRes = " << dvmax << endl;
458 cout << "thePnt(" << thePnt.X() << "; " << thePnt.Y() << ")" << endl;
459 cout << "thePntRef(" << thePntRef.X() << "; " << thePntRef.Y() << ")" << endl;
460 }
3f257c62 461#endif
462
463 Standard_Real aTol2d = 2*Max( dumax, dvmax);
464
0797d9d3 465#ifdef OCCT_DEBUG
3f257c62 466 if((aTol2d <= 0.0) && (PrintWarnings))
467 {
468 cout<<"BRepCheck_Wire : UResolution and VResolution = 0.0 (Face too small ?)"<<endl;
469 cout.flush();
470 }
471#endif
472
3f257c62 473 Standard_Real Dist = Max(dumin, dvmin);
474
475 if (Dist < aTol2d)
476 return Standard_True;
477
0797d9d3 478#ifdef OCCT_DEBUG
3f257c62 479 if(PrintWarnings)
480 {
481 cout << endl;
482 cout << "--------Function IsDistanceIn2DTolerance(...)----------" << endl;
ab87e6fc 483 cout << "--- BRepCheck Wire: Not closed in 2d" << endl;
3f257c62 484 cout << "*****************************************************" << endl;
485 cout << "* Dist = " << Dist << " > Tol2d = " << aTol2d << endl;
486 cout << "*****************************************************" << endl;
487 cout << "aTol3d = " << aTol3d <<"; URes = " << dumax << "; VRes = " << dvmax << endl;
488 cout << "thePnt(" << thePnt.X() << "; " << thePnt.Y() << ")" << endl;
489 cout << "thePntRef(" << thePntRef.X() << "; " << thePntRef.Y() << ")" << endl;
490 }
491#endif
492
493 return Standard_False;
494 }
495
7fd59977 496//=======================================================================
497//function : Closed2d
498//purpose : for periodic faces
499//=======================================================================
500BRepCheck_Status BRepCheck_Wire::Closed2d(const TopoDS_Face& theFace,
501 const Standard_Boolean Update)
3f257c62 502 {
503 // 3d closure checked too
7fd59977 504 BRepCheck_Status aClosedStat = Closed();
3f257c62 505 if (aClosedStat != BRepCheck_NoError)
506 {
507 if (Update)
7fd59977 508 BRepCheck::Add(myMap(myShape),aClosedStat);
3f257c62 509
7fd59977 510 return aClosedStat;
3f257c62 511 }
7fd59977 512
3f257c62 513// 20/03/02 akm vvv : (OCC234) Hence this method will be used to check
514// both periodic and non-periodic faces
515// // this check is for periodic faces
7fd59977 516 BRepAdaptor_Surface aFaceSurface (theFace, Standard_False);
3f257c62 517// if (!aFaceSurface.IsUPeriodic() && !aFaceSurface.IsVPeriodic())
518// {
519// if (Update)
520// BRepCheck::Add(myMap(myShape),aClosedStat);
521// return aClosedStat;
522// }
523// 20/03/02 akm ^^^
524
525// count edges having FORWARD or REVERSED orientation
7fd59977 526 Standard_Integer aNbOrirntedEdges = 0;
527 TopExp_Explorer anEdgeExp(myShape,TopAbs_EDGE);
3f257c62 528 for (;anEdgeExp.More(); anEdgeExp.Next())
529 {
7fd59977 530 if (IsOriented(anEdgeExp.Current()))
531 aNbOrirntedEdges++;
3f257c62 532 }
533
7fd59977 534 if (aNbOrirntedEdges==0)
3f257c62 535 {
536 if (Update)
7fd59977 537 BRepCheck::Add(myMap(myShape),aClosedStat);
3f257c62 538
7fd59977 539 return aClosedStat;
3f257c62 540 }
7fd59977 541
3f257c62 542// all those edges must form a closed 2d contour and be found by WireExplorer
7fd59977 543
3f257c62 544 Standard_Integer aNbFoundEdges = 0;
7fd59977 545 BRepTools_WireExplorer aWireExp(TopoDS::Wire(myShape), theFace);
546 TopoDS_Edge aFirstEdge = aWireExp.Current();
547 TopoDS_Vertex aFirstVertex = aWireExp.CurrentVertex();
548 TopoDS_Edge aLastEdge;
3f257c62 549
7fd59977 550 for (;aWireExp.More(); aWireExp.Next())
3f257c62 551 {
7fd59977 552 aNbFoundEdges++;
553 aLastEdge = aWireExp.Current();
3f257c62 554 }
7fd59977 555
556 if (aNbFoundEdges != aNbOrirntedEdges)
3f257c62 557 {
7fd59977 558 aClosedStat = BRepCheck_NotClosed;
559 if (Update)
560 BRepCheck::Add(myMap(myShape),aClosedStat);
7fd59977 561
3f257c62 562 return aClosedStat;
563 }
564
565// Check distance between 2d ends of first and last edges
7fd59977 566// Modified by Sergey KHROMOV - Mon May 13 12:42:10 2002 Begin
567// First check if first and last edges are infinite:
568 Standard_Real aF;
569 Standard_Real aL;
570 Standard_Boolean isFirstInfinite = Standard_False;
571 Standard_Boolean isLastInfinite = Standard_False;
572 TopAbs_Orientation anOri;
573
574 anOri = aFirstEdge.Orientation();
575 BRep_Tool::Range(aFirstEdge, aF, aL);
3f257c62 576 if ((anOri == TopAbs_FORWARD && Precision::IsNegativeInfinite( aF )) ||
577 (anOri == TopAbs_REVERSED && Precision::IsPositiveInfinite( aL )))
7fd59977 578 isFirstInfinite = Standard_True;
579
580 anOri = aLastEdge.Orientation();
581 BRep_Tool::Range(aLastEdge, aF, aL);
3f257c62 582
583 if ((anOri == TopAbs_FORWARD && Precision::IsPositiveInfinite( aL )) ||
584 (anOri == TopAbs_REVERSED && Precision::IsNegativeInfinite( aF )))
7fd59977 585 isLastInfinite = Standard_True;
586
3f257c62 587 if (isFirstInfinite && isLastInfinite)
588 {
589 if (Update)
7fd59977 590 BRepCheck::Add(myMap(myShape),aClosedStat);
3f257c62 591
7fd59977 592 return aClosedStat;
3f257c62 593 }
594 else if (aFirstVertex.IsNull())
595 {
7fd59977 596 aClosedStat = BRepCheck_NotClosed;
3f257c62 597
7fd59977 598 if (Update)
599 BRepCheck::Add(myMap(myShape),aClosedStat);
3f257c62 600
7fd59977 601 return aClosedStat;
3f257c62 602 }
7fd59977 603// Modified by Sergey KHROMOV - Mon May 13 12:42:10 2002 End
604
3f257c62 605 gp_Pnt2d aP_first, aP_last, aP_temp; // ends of prev edge, next edge, bidon
7fd59977 606
3f257c62 607// get last point
608 BRep_Tool::UVPoints(aLastEdge, theFace, aP_temp, aP_last);
609 if (aLastEdge.Orientation() == TopAbs_REVERSED)
610 aP_last = aP_temp;
611
7fd59977 612// Modified by Sergey KHROMOV - Mon Apr 22 10:36:33 2002 Begin
613// Standard_Real aTol, aUResol, aVResol;
7fd59977 614// // find 2d tolerance
615// aTol = BRep_Tool::Tolerance(aFirstVertex);
616// aUResol = 2*aFaceSurface.UResolution(aTol);
617// aVResol = 2*aFaceSurface.VResolution(aTol);
618
3f257c62 619// get first point
7fd59977 620 if (aFirstEdge.Orientation() == TopAbs_REVERSED)
3f257c62 621 BRep_Tool::UVPoints(aFirstEdge, theFace, aP_temp, aP_first);
7fd59977 622 else
3f257c62 623 BRep_Tool::UVPoints(aFirstEdge, theFace, aP_first, aP_temp);
7fd59977 624
625// Modified by Sergey KHROMOV - Thu Jun 20 10:55:42 2002 OCC325 Begin
626// Check 2d distance for periodic faces with seam edge
3f257c62 627 if (!IsClosed2dForPeriodicFace(theFace, aP_first, aP_last, aFirstVertex))
628 {
7fd59977 629 aClosedStat = BRepCheck_NotClosed;
3f257c62 630 if (Update)
7fd59977 631 BRepCheck::Add(myMap(myShape),aClosedStat);
3f257c62 632
7fd59977 633 return aClosedStat;
3f257c62 634 }
7fd59977 635// Modified by Sergey KHROMOV - Thu Jun 20 10:58:05 2002 End
636
3f257c62 637// check distance
7fd59977 638// Standard_Real dfUDist=Abs(p.X()-p1.X());
639// Standard_Real dfVDist=Abs(p.Y()-p1.Y());
640// if (dfUDist > aUResol || dfVDist > aVResol)
641// {
3f257c62 642
643 Standard_Real aTol3d = Max(BRep_Tool::Tolerance(aFirstVertex),BRep_Tool::Tolerance(aWireExp.CurrentVertex()));
644
645 gp_Pnt aPntRef = BRep_Tool::Pnt(aFirstVertex);
646 gp_Pnt aPnt = BRep_Tool::Pnt(aWireExp.CurrentVertex());
647
648 if (!(IsDistanceIn2DTolerance(aFaceSurface, aP_first, aP_last, aTol3d)))
7fd59977 649 aClosedStat = BRepCheck_NotClosed;
3f257c62 650
9e20ed57 651 if(!IsDistanceIn3DTolerance(aPntRef, aPnt, aTol3d))
3f257c62 652 aClosedStat = BRepCheck_NotClosed;
653
7fd59977 654 if (Update)
655 BRepCheck::Add(myMap(myShape),aClosedStat);
3f257c62 656
7fd59977 657 return aClosedStat;
3f257c62 658 }
7fd59977 659//=======================================================================
660//function : Orientation
661//purpose :
662//=======================================================================
663BRepCheck_Status BRepCheck_Wire::Orientation(const TopoDS_Face& F,
664 const Standard_Boolean Update)
665{
666 BRepCheck_Status theOstat = Closed();
667 if (theOstat != BRepCheck_NotClosed && theOstat != BRepCheck_NoError) {
668 if (Update) {
669 BRepCheck::Add(myMap(myShape),theOstat);
670 }
671 return theOstat;
672 }
673
674 theOstat = BRepCheck_NoError;
675
676 TopoDS_Vertex VF,VL;
7fd59977 677 TopAbs_Orientation orient, ortmp = TopAbs_FORWARD;
7fd59977 678 TopTools_ListOfShape ledge, ListOfPassedEdge;
679 TopExp_Explorer exp,vte;
680 TopTools_MapOfShape mapS;
681 TopoDS_Edge theEdge,theRef;
682
683 // Checks the orientation of the edges
684 for (exp.Init(myShape,TopAbs_EDGE); exp.More(); exp.Next()) {
685 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
686 orient = edg.Orientation();
687 if (IsOriented(edg)) {
688 mapS.Add(edg);
689 theEdge = edg;
690 theRef = edg;
691 for (vte.Init(edg,TopAbs_VERTEX);vte.More(); vte.Next()) {
692 TopAbs_Orientation vto = vte.Current().Orientation();
693 if (vto == TopAbs_FORWARD) {
694 VF = TopoDS::Vertex(vte.Current());
695 }
696 else if (vto == TopAbs_REVERSED) {
697 VL = TopoDS::Vertex(vte.Current());
698 }
699 if (!VF.IsNull() && !VL.IsNull()) {
700 break;
701 }
702 }
703 if (VF.IsNull() && VL.IsNull())
704 theOstat = BRepCheck_InvalidDegeneratedFlag;
705 break;
706 }
707 }
708
709 if (theOstat == BRepCheck_NoError) {
710 Standard_Integer Index = 1;
711 Standard_Integer nbOriNoDegen=myMapVE.Extent();
712// Modified by Sergey KHROMOV - Tue May 21 17:12:45 2002 Begin
713 Standard_Boolean isGoFwd = Standard_True;
714
715 if (VL.IsNull())
716 isGoFwd = Standard_False;
717// Modified by Sergey KHROMOV - Tue May 21 17:12:45 2002 End
718
719 while (Index < nbOriNoDegen) {
720 ledge.Clear();
721 ListOfPassedEdge.Clear();
0d969553
Y
722 // find edges that make a chain on VL if !VL.IsNull
723 // otherwise on VF.
7fd59977 724
725 Standard_Integer ind;
726 if (!VL.IsNull()) {
727 ind = myMapVE.FindIndex(VL);
728 }
729 else if (!VF.IsNull()) {
730 ind = myMapVE.FindIndex(VF);
731 }
732 else {
733 theOstat = BRepCheck_InvalidDegeneratedFlag;
734 break;
735 }
736
737 for (TopTools_ListIteratorOfListOfShape itls(myMapVE(ind));
738 itls.More(); itls.Next()) {
739 const TopoDS_Edge & edg = TopoDS::Edge(itls.Value());
740
741 orient = edg.Orientation();
742 if (mapS.Contains(edg)) ortmp = GetOrientation(mapS,edg);
743
744 //Add to list already passed outcoming edges
745 if (mapS.Contains(edg) && ortmp == orient && !edg.IsSame(theEdge))
746 for (vte.Init(edg,TopAbs_VERTEX); vte.More(); vte.Next())
747 {
748 TopAbs_Orientation vto = vte.Current().Orientation();
749 if (!VL.IsNull())
750 {
751 if (vto == TopAbs_FORWARD && VL.IsSame(vte.Current()))
752 {
753 ListOfPassedEdge.Append(edg);
754 break;
755 }
756 }
757 else // VF is not null
758 {
759 if (vto == TopAbs_REVERSED && VF.IsSame(vte.Current()))
760 {
761 ListOfPassedEdge.Append(edg);
762 break;
763 }
764 }
765 }
766
767 if (!mapS.Contains(edg) || ortmp != orient) {
768 for (vte.Init(edg,TopAbs_VERTEX);vte.More(); vte.Next()) {
769 TopAbs_Orientation vto = vte.Current().Orientation();
770 if (!VL.IsNull()) {
771 if (vto == TopAbs_FORWARD && VL.IsSame(vte.Current())) {
0d969553
Y
772 // If the processing is in 2d (face not null) or
773 // if the edge is not degenerated it is added
7fd59977 774 if (!F.IsNull() || !BRep_Tool::Degenerated(edg))
775 ledge.Append(edg);
776 break;
777 }
778 }
0d969553 779 else { // VF is not null
7fd59977 780 if (vto == TopAbs_REVERSED && VF.IsSame(vte.Current())) {
0d969553
Y
781 // // If the processing is in 2d (face not null) or
782 // if the edge is not degenerated it is added
7fd59977 783 if (!F.IsNull() || !BRep_Tool::Degenerated(edg))
784 ledge.Append(edg);
785 break;
786 }
787 }
788 }
789 }
790 }
791 Standard_Integer nbconnex = ledge.Extent();
792 Standard_Boolean Changedesens = Standard_False;
793 if (nbconnex == 0) {
794 if (myCstat == BRepCheck_NotClosed) {
795 if (VL.IsNull()) {
796 if (Update) {
797 BRepCheck::Add(myMap(myShape),theOstat);
798 }
0d969553 799 return theOstat; // leave
7fd59977 800 }
801 else {
0d969553
Y
802 Index--; // because after Index++ and if there is no chain,
803 VL.Nullify(); // chain on VF is forced
7fd59977 804 theEdge = theRef;
805 Changedesens = Standard_True;
806 }
807 }
808 else {
809 theOstat = BRepCheck_BadOrientationOfSubshape;
810 if (Update) {
811 BRepCheck::Add(myMap(myShape),theOstat);
812 }
813 return theOstat;
814 }
815 }
816
0d969553
Y
817 // JAG 03/07 else if (nbconnex >= 2 && !F.IsNull()) // Try to see in 2d
818 else if (!F.IsNull()) { // Try to see in 2d
7fd59977 819 TopoDS_Vertex pivot;
820 if (!VL.IsNull()) {
821 pivot = VL;
822 }
823 else {
824 pivot = VF;
825 }
826
827 ChoixUV(pivot,theEdge,F,ledge);
828 nbconnex = ledge.Extent();
829// 20/03/02 akm vvv : (OCC234) - The 2d exploration of wire with necessary
830// checks is performed in Closed2d, here it's useless
831// if (nbconnex == 1 && !CheckLoopOrientation( pivot, theEdge, TopoDS::Edge(ledge.First()), F, ListOfPassedEdge ))
832// {
833// theOstat = BRepCheck_BadOrientationOfSubshape;
834// if (Update)
835// BRepCheck::Add(myMap(myShape),theOstat);
836// return theOstat;
837// }
838// 20/03/02 akm ^^^
839 }
840
841 if (nbconnex >= 2) {
842 theOstat = BRepCheck_BadOrientationOfSubshape;
843 if (Update) {
844 BRepCheck::Add(myMap(myShape),theOstat);
845 }
846 return theOstat;
847 }
848 else if (nbconnex == 1) {
0d969553 849 // offset the vertex
7fd59977 850 for (vte.Init(ledge.First(),TopAbs_VERTEX);vte.More(); vte.Next()) {
851 TopAbs_Orientation vto = vte.Current().Orientation();
852 if (!VL.IsNull()) {
853 if (vto == TopAbs_REVERSED) {
854 VL = TopoDS::Vertex(vte.Current());
855 break;
856 }
857 }
0d969553 858 else { // VF is not null
7fd59977 859 if (vto == TopAbs_FORWARD) {
860 VF = TopoDS::Vertex(vte.Current());
861 break;
862 }
863 }
864 }
865 mapS.Add(ledge.First());
866 theEdge = TopoDS::Edge(ledge.First());
867 if (!vte.More()) {
868 if (!VL.IsNull()) {
869 VL.Nullify();
870 }
871 else {
872 VF.Nullify();
873 }
874 }
875 }
876 else if (!Changedesens) { //nbconnex == 0
877 theOstat = BRepCheck_NotClosed;
878 if (Update) {
879 BRepCheck::Add(myMap(myShape),theOstat);
880 }
881 return theOstat;
882 }
883
0d969553 884 // Check the closure of the wire in 2d (not done in Closed())
7fd59977 885
886 TopoDS_Vertex aVRef;
887 Standard_Boolean isCheckClose = Standard_False;
888
889 if (isGoFwd && !VF.IsNull()) {
890 aVRef = VF;
891 isCheckClose = Standard_True;
892 } else if (!isGoFwd && !VL.IsNull()) {
893 aVRef = VL;
894 isCheckClose = Standard_True;
895 }
896
897// if (Index==1 && myCstat!=BRepCheck_NotClosed &&
898// !VF.IsNull() && !F.IsNull()) {
899 if (Index==1 && myCstat!=BRepCheck_NotClosed &&
900 isCheckClose && !F.IsNull()) {
901 ledge.Clear();
902// ind = myMapVE.FindIndex(VF);
903 ind = myMapVE.FindIndex(aVRef);
904 for (TopTools_ListIteratorOfListOfShape itlsh(myMapVE(ind));
905 itlsh.More(); itlsh.Next()) {
906 const TopoDS_Edge & edg = TopoDS::Edge(itlsh.Value());
907 orient = edg.Orientation();
908 if (!theRef.IsSame(edg)) {
909 for (vte.Init(edg,TopAbs_VERTEX);vte.More(); vte.Next()) {
910 TopAbs_Orientation vto = vte.Current().Orientation();
911// if (vto == TopAbs_REVERSED && VF.IsSame(vte.Current())) {
912 if (vto == TopAbs_REVERSED && aVRef.IsSame(vte.Current())) {
913 ledge.Append(edg);
914 break;
915 }
916 }
917 }
918 }
919// ChoixUV(VF, theRef, F, ledge);
920 ChoixUV(aVRef, theRef, F, ledge);
921 if (ledge.Extent()==0) {
922 theOstat = BRepCheck_NotClosed;
923 if (Update) {
924 BRepCheck::Add(myMap(myShape),theOstat);
925 }
926 return theOstat;
927 }
928 }
0d969553 929 // End control closure 2d
7fd59977 930
931 Index ++;
932 }
933 }
934 if (Update) {
935 BRepCheck::Add(myMap(myShape),theOstat);
936 }
937 return theOstat;
938}
939//=======================================================================
940//function : SelfIntersect
941//purpose :
942//=======================================================================
943BRepCheck_Status BRepCheck_Wire::SelfIntersect(const TopoDS_Face& F,
944 TopoDS_Edge& retE1,
945 TopoDS_Edge& retE2,
946 const Standard_Boolean Update)
947{
948
949
7fd59977 950 Standard_Integer i,j,Nbedges;
951 Standard_Real first1,last1,first2,last2, tolint;
952 gp_Pnt2d pfirst1,plast1,pfirst2,plast2;
953 gp_Pnt P3d, P3d2;
954 Handle(BRepAdaptor_HSurface) HS;
955 Geom2dAdaptor_Curve C1, C2;
956 Geom2dInt_GInter Inter;
957 IntRes2d_Domain myDomain1;
958 TopTools_IndexedMapOfOrientedShape EMap;
959 TopTools_MapOfOrientedShape auxmape;
960 //
0d969553
Y
961 //-- check with proper tolerances if there is no
962 //-- point in the tolerance of a vertex.
7fd59977 963 tolint = 1.e-10;
964 HS = new BRepAdaptor_HSurface();
965 HS->ChangeSurface().Initialize(F,Standard_False);
966 //
967 for (TopoDS_Iterator Iter1(myShape);Iter1.More();Iter1.Next()) {
968 if (Iter1.Value().ShapeType() == TopAbs_EDGE) {
969 EMap.Add(Iter1.Value());
970 }
971 }
972 //
973 Nbedges=EMap.Extent();
974 if (!Nbedges) {
975 if (Update) {
976 BRepCheck::Add(myMap(myShape),BRepCheck_EmptyWire);
977 }
978 return(BRepCheck_EmptyWire);
979 }
980 //
981 IntRes2d_Domain *tabDom = new IntRes2d_Domain[Nbedges];
982 TColGeom2d_Array1OfCurve tabCur(1,Nbedges);
983 Bnd_Array1OfBox2d boxes(1,Nbedges);
984 //
985 for(i = 1; i <= Nbedges; i++) {
986 const TopoDS_Edge& E1 = TopoDS::Edge(EMap.FindKey(i));
987 if (i == 1) {
988 Handle(Geom2d_Curve) pcu = BRep_Tool::CurveOnSurface(E1, F, first1, last1);
989 if (pcu.IsNull()) {
990 retE1=E1;
991 if (Update) {
992 BRepCheck::Add(myMap(myShape),BRepCheck_SelfIntersectingWire);
993 }
994 delete [] tabDom;
995 return(BRepCheck_SelfIntersectingWire);
996 }
997 //
998 C1.Load(pcu);
999 // To avoid exeption in Segment if C1 is BSpline - IFV
1000 if(!C1.IsPeriodic()) {
1001 if(C1.FirstParameter() > first1) {
1002 first1 = C1.FirstParameter();
1003 }
1004 if(C1.LastParameter() < last1 ){
1005 last1 = C1.LastParameter();
1006 }
1007 }
1008 //
1009 BRep_Tool::UVPoints(E1, F, pfirst1, plast1);
1010 myDomain1.SetValues(pfirst1,first1,tolint, plast1,last1,tolint);
1011 //
1012 BndLib_Add2dCurve::Add(C1, first1, last1, Precision::PConfusion(), boxes(i));
1013 }//if (i == 1) {
1014 else {
1015 C1.Load(tabCur(i));
1016 myDomain1 = tabDom[i-1];
1017 }
1018 //
1019 // Self intersect of C1
1020 Inter.Perform(C1, myDomain1, tolint, tolint);
1021 //
1022 if(Inter.IsDone()) {
1023 Standard_Integer nbp = Inter.NbPoints();
6e6cd5d9 1024 //Standard_Integer nbs = Inter.NbSegments();
7fd59977 1025 //
1026 for(Standard_Integer p=1;p<=nbp;p++) {
1027 const IntRes2d_IntersectionPoint& IP=Inter.Point(p);
1028 const IntRes2d_Transition& Tr1 = IP.TransitionOfFirst();
1029 const IntRes2d_Transition& Tr2 = IP.TransitionOfSecond();
1030 if( Tr1.PositionOnCurve() == IntRes2d_Middle
1031 || Tr2.PositionOnCurve() == IntRes2d_Middle) {
0d969553
Y
1032 //-- Checking of points with true tolerances (ie Tol in 3d)
1033 //-- If the point of intersection is within the tolearnce of a vertex
1034 //-- this intersection is considered correct (no error)
7fd59977 1035 Standard_Boolean localok = Standard_False;
1036 Standard_Real f,l;
1037 TopLoc_Location L;
1038 const Handle(Geom_Curve) ConS = BRep_Tool::Curve(E1,L,f,l);
1039 if(!ConS.IsNull()) {
0d969553 1040 //-- try to test in 3d. (ParamOnSecond gives the same result)
7fd59977 1041 P3d = ConS->Value(IP.ParamOnFirst());
1042 P3d.Transform(L.Transformation());
1043 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 Begin
1044 }
1045 else {
1046 gp_Pnt2d aP2d = C1.Value(IP.ParamOnFirst());
1047 P3d = HS->Value(aP2d.X(), aP2d.Y());
1048 }
1049 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
1050 TopExp_Explorer ExplVtx;
1051 for(ExplVtx.Init(E1,TopAbs_VERTEX);
1052 localok==Standard_False && ExplVtx.More();
1053 ExplVtx.Next()) {
1054 gp_Pnt p3dvtt;
1055 Standard_Real tolvtt, p3dvttDistanceP3d;
1056 //
1057 const TopoDS_Vertex& vtt = TopoDS::Vertex(ExplVtx.Current());
1058 p3dvtt = BRep_Tool::Pnt(vtt);
1059 tolvtt = BRep_Tool::Tolerance(vtt);
1060 tolvtt=tolvtt*tolvtt;
1061 p3dvttDistanceP3d=p3dvtt.SquareDistance(P3d);
1062 if(p3dvttDistanceP3d <= tolvtt) {
1063 localok=Standard_True;
1064 }
1065 }
1066 if(localok==Standard_False) {
7fd59977 1067 retE1=E1;
1068 if (Update) {
1069 BRepCheck::Add(myMap(myShape),BRepCheck_SelfIntersectingWire);
1070 }
1071 delete [] tabDom;
0797d9d3 1072#ifdef OCCT_DEBUG
7fd59977 1073 static Standard_Integer numpoint=0;
1074 cout<<"point p"<<++numpoint<<" "<<P3d.X()<<" "<<P3d.Y()<<" "<<P3d.Z()<<endl;cout.flush();
1075#endif
1076 return(BRepCheck_SelfIntersectingWire);
1077 }
1078 }
1079 }
1080 }// if(Inter.IsDone()) {
1081 //
1082 for(j=i+1; j<=Nbedges; j++) {
1083 const TopoDS_Edge& E2 = TopoDS::Edge(EMap.FindKey(j));
1084 if (i == 1) {
1085 tabCur(j) = BRep_Tool::CurveOnSurface(E2,F,first2,last2);
1086 if (!tabCur(j).IsNull() && last2 > first2) {
1087 C2.Load(tabCur(j));
1088 // To avoid exeption in Segment if C2 is BSpline - IFV
1089 if(!C2.IsPeriodic()) {
1090 if(C2.FirstParameter() > first2) {
1091 first2 = C2.FirstParameter();
1092 }
1093 if(C2.LastParameter() < last2 ) {
1094 last2 = C2.LastParameter();
1095 }
1096 }
1097 //
1098 BRep_Tool::UVPoints(E2,F,pfirst2,plast2);
1099 tabDom[j-1].SetValues(pfirst2,first2,tolint,plast2,last2,tolint);
1100
1101 BndLib_Add2dCurve::Add( C2, first2, last2, Precision::PConfusion(), boxes(j) );
1102 }
1103 else {
1104 delete [] tabDom;
0797d9d3 1105#ifdef OCCT_DEBUG
7fd59977 1106 cout<<"BRepCheck_NoCurveOnSurface or BRepCheck_InvalidRange"<<endl;cout.flush();
1107#endif
1108 if(tabCur(j).IsNull()) {
1109 return(BRepCheck_NoCurveOnSurface);
1110 }
1111 return (BRepCheck_InvalidRange);
1112 }
1113 }// if (i == 1) {
1114 else {
1115 C2.Load(tabCur(j));
1116 }
1117 //
1118 if (boxes(i).IsOut( boxes(j))) {
1119 continue;
1120 }
1121 //modified by NIZNHY-PKV Fri Oct 29 10:09:01 2010f
1122 if (E1.IsSame(E2)) {
1123 continue;
1124 }
1125 //modified by NIZNHY-PKV Fri Oct 29 10:09:02 2010t
1126 //
1127 //-- ************************************************************
0d969553 1128 //-- ******* I n t e r s e c t i o n C 1 and C 2 ********
7fd59977 1129 //-- ************************************************************
1130 Inter.Perform(C1,myDomain1,C2,tabDom[j-1],tolint,tolint);
1131 //
1132 if(Inter.IsDone()) {
1133 Standard_Integer nbp, nbs;
1134 Standard_Real IP_ParamOnFirst, IP_ParamOnSecond;
1135 IntRes2d_Transition Tr1,Tr2;
1136 TopTools_ListOfShape CommonVertices;
1137 TopTools_ListIteratorOfListOfShape itl;
1138 TopTools_MapOfShape Vmap;
1139 //
1140 TopoDS_Iterator it( E1 );
1141 for (; it.More(); it.Next()) {
1142 Vmap.Add( it.Value() );
1143 }
1144 //
1145 it.Initialize( E2 );
1146 for (; it.More(); it.Next()) {
1147 const TopoDS_Shape& V = it.Value();
1148 if (Vmap.Contains( V )) {
1149 CommonVertices.Append( V );
1150 }
1151 }
1152 //
1153 nbp = Inter.NbPoints();
1154 nbs = Inter.NbSegments();
1155 IP_ParamOnFirst = 0.;
1156 IP_ParamOnSecond = 0.;
1157 //
1158 //// **** Points of intersection **** ////
1159 for (Standard_Integer p = 1; p <= nbp; p++) {
1160 const IntRes2d_IntersectionPoint& IP = Inter.Point(p);
1161 IP_ParamOnFirst = IP.ParamOnFirst();
1162 IP_ParamOnSecond = IP.ParamOnSecond();
1163 Tr1 = IP.TransitionOfFirst();
1164 Tr2 = IP.TransitionOfSecond();
1165 if( Tr1.PositionOnCurve() == IntRes2d_Middle
1166 || Tr2.PositionOnCurve() == IntRes2d_Middle) {
0d969553
Y
1167 //-- Checking of points with true tolerances (ie Tol in 3d)
1168 //-- If the point of intersection is within the tolerance of a vertex
1169 //-- this intersection is considered correct (no error)
7fd59977 1170 Standard_Boolean localok = Standard_False;
1171 Standard_Real f1,l1, f2, l2;
1172 TopLoc_Location L, L2;
1173 //
1174 const Handle(Geom_Curve) ConS = BRep_Tool::Curve(E1,L,f1,l1);
1175 const Handle(Geom_Curve) ConS2 = BRep_Tool::Curve(E2,L2,f2,l2);
1176 //gka protect against working out of edge range
1177 if ( f1-IP_ParamOnFirst > ::Precision::PConfusion() ||
1178 IP_ParamOnFirst-l1 > ::Precision::PConfusion() ||
1179 f2-IP_ParamOnSecond > ::Precision::PConfusion() ||
1180 IP_ParamOnSecond-l2 > ::Precision::PConfusion() )
1181 continue;
1d47d8d0 1182 Standard_Real tolvtt = 0.;
7fd59977 1183 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 Begin
1184 if (!ConS.IsNull()) {
1185 P3d = ConS->Value(IP_ParamOnFirst);
1186 P3d.Transform(L.Transformation());
1187 }
1188 else {
1189 gp_Pnt2d aP2d = C1.Value(IP_ParamOnFirst);
1190 P3d = HS->Value(aP2d.X(), aP2d.Y());
1191 }
1192 //
1193 if (!ConS2.IsNull()) {
1194 P3d2 = ConS2->Value(IP_ParamOnSecond);
1195 P3d2.Transform(L2.Transformation());
1196 }
1197 else {
1198 gp_Pnt2d aP2d = C2.Value(IP_ParamOnSecond);
1199 P3d2 = HS->Value(aP2d.X(), aP2d.Y());
1200 }
1201 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
1202 itl.Initialize( CommonVertices );
1203 for (; itl.More(); itl.Next()) {
1204 Standard_Real p3dvttDistanceP3d, p3dvttDistanceP3d2;
1205 gp_Pnt p3dvtt;
1206 //
1207 const TopoDS_Vertex& vtt = TopoDS::Vertex(itl.Value());
1208 p3dvtt = BRep_Tool::Pnt(vtt);
1209 tolvtt = BRep_Tool::Tolerance(vtt);
1210 tolvtt=1.1*tolvtt;
1211 tolvtt=tolvtt*tolvtt;
1212 p3dvttDistanceP3d = p3dvtt.SquareDistance(P3d);
1213 p3dvttDistanceP3d2 = p3dvtt.SquareDistance(P3d2);
1214 //
1215 if (p3dvttDistanceP3d<=tolvtt && p3dvttDistanceP3d2<=tolvtt) {
1216 localok = Standard_True;
1217 break;
1218 }
1219 }
1220
1221 //-- --------------------------------------------------------
0d969553 1222 //-- Check maximum yawn between 2 edges
7fd59977 1223 //--
0d969553
Y
1224 //-- Check distance from edges to the curve joining
1225 //-- the point of intersection with vertex (if exists)
7fd59977 1226 if (localok == Standard_False && !CommonVertices.IsEmpty()) {
0797d9d3 1227#ifdef OCCT_DEBUG
7fd59977 1228 cout << "\n------------------------------------------------------\n" <<endl;
1229 cout << "\n--- BRepCheck Wire: AutoIntersection Phase1 -> Erreur \n" <<endl;
1230
1231#endif
7fd59977 1232 Standard_Real distauvtxleplusproche,VParaOnEdge1,VParaOnEdge2;
1233 gp_Pnt VertexLePlusProche;
1234 //
7fd59977 1235 VParaOnEdge1 =0.;
1236 VParaOnEdge2 =0.;
1237 distauvtxleplusproche=RealLast();
1238 //Find the nearest common vertex
1239 itl.Initialize( CommonVertices );
1240 for (; itl.More(); itl.Next()) {
96a95605 1241 Standard_Real disptvtx;
7fd59977 1242 gp_Pnt p3dvtt;
1243 //
1244 const TopoDS_Vertex& vtt = TopoDS::Vertex(itl.Value());
1245 p3dvtt = BRep_Tool::Pnt(vtt);
7fd59977 1246 disptvtx = P3d.Distance(p3dvtt);
1247 if (disptvtx < distauvtxleplusproche) {
1248 VertexLePlusProche = p3dvtt;
1249 distauvtxleplusproche = disptvtx;
1250 VParaOnEdge1 = BRep_Tool::Parameter(vtt,E1);
1251 VParaOnEdge2 = BRep_Tool::Parameter(vtt,E2);
1252 }
1253 // eap: case of closed edge
1254 else if (IsEqual(distauvtxleplusproche, disptvtx)) {
1255 Standard_Real newVParaOnEdge1 = BRep_Tool::Parameter(vtt,E1);
1256 Standard_Real newVParaOnEdge2 = BRep_Tool::Parameter(vtt,E2);
1257 if (Abs(IP_ParamOnFirst - VParaOnEdge1) + Abs(IP_ParamOnSecond - VParaOnEdge2)
1258 >
1259 Abs(IP_ParamOnFirst - newVParaOnEdge1) + Abs(IP_ParamOnSecond - newVParaOnEdge2)) {
1260 VertexLePlusProche = p3dvtt;
1261 VParaOnEdge1 = newVParaOnEdge1;
1262 VParaOnEdge2 = newVParaOnEdge2;
1263 }
1264 }
1265 }
1266 //Patch: extraordinar situation (e.g. tolerance(v) == 0.)
1267 // Modified by skv - Wed Jul 23 12:28:11 2003 OCC1764 Begin
1268 // if (VertexLePlusProche.Distance( P3d ) <= gp::Resolution())
1269 if (VertexLePlusProche.Distance(P3d) <= gp::Resolution() ||
1270 VertexLePlusProche.Distance(P3d2) <= gp::Resolution()) {
1271 // Modified by skv - Wed Jul 23 12:28:12 2003 OCC1764 End
1272 localok = Standard_True;
1273 }
1274 else {
1275 gp_Lin Lig( VertexLePlusProche, gp_Vec(VertexLePlusProche,P3d) );
1276 Standard_Real du1 = 0.1*(IP_ParamOnFirst -VParaOnEdge1);
1277 Standard_Real du2 = 0.1*(IP_ParamOnSecond-VParaOnEdge2);
1278 Standard_Real maxd1 = 0., maxd2 = 0.;
1279 Standard_Integer k;
1280
1281 localok = Standard_True;
1282 Standard_Real tole1 = BRep_Tool::Tolerance(E1);
1283 for (k = 2; localok && k < 9; k++) {
0d969553 1284 Standard_Real u = VParaOnEdge1 + k*du1; // check if it works
7fd59977 1285 gp_Pnt P1;
1286 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 Begin
1287 if (!ConS.IsNull()) {
1288 P1 = ConS->Value(u);
1289 P1.Transform(L.Transformation());
1290 }
1291 else {
1292 gp_Pnt2d aP2d = C1.Value(u);
1293 P1 = HS->Value(aP2d.X(), aP2d.Y());
1294 }
1295 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
1296 Standard_Real d1 = Lig.Distance(P1);
1297 if (d1 > maxd1) {
1298 maxd1 = d1;
1299 }
1300 if (d1 > tole1*2.0){
1301 localok = Standard_False;
1302 }
1303 }
0d969553 1304 //-- same for edge2
7fd59977 1305 // Modified by skv - Wed Jul 23 12:22:20 2003 OCC1764 Begin
1306 gp_Dir aTmpDir(P3d2.XYZ().Subtracted(VertexLePlusProche.XYZ()));
1307
1308 Lig.SetDirection(aTmpDir);
1309 // Modified by skv - Wed Jul 23 12:22:23 2003 OCC1764 End
1310 Standard_Real tole2 = BRep_Tool::Tolerance(E2);
1311 for (k = 2; localok && k < 9; k++) {
0d969553 1312 Standard_Real u = VParaOnEdge2 + k*du2; // check if it works
7fd59977 1313 gp_Pnt P2;
1314 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 Begin
1315 if (!ConS2.IsNull()) {
1316 P2 = ConS2->Value(u);
1317 P2.Transform(L2.Transformation());
1318 }
1319 else {
1320 gp_Pnt2d aP2d = C2.Value(u);
1321 P2 = HS->Value(aP2d.X(), aP2d.Y());
1322 }
1323 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
1324 Standard_Real d2 = Lig.Distance(P2);
1325 if (d2 > maxd2) {
1326 maxd2 = d2;
1327 }
1328 if (d2 > tole2*2.0){
1329 localok = Standard_False;
1330 }
1331 }
0797d9d3 1332#ifdef OCCT_DEBUG
7fd59977 1333 if(localok) {
1334 printf("--- BRepCheck Wire: AutoIntersection Phase2 -> Bon \n");
1335 printf("--- distance Point Vertex : %10.7g (tol %10.7g)\n",distauvtxleplusproche,tolvtt);
1336 printf("--- Erreur Max sur E1 : %10.7g Tol_Edge:%10.7g\n",maxd1,tole1);
1337 printf("--- Erreur Max sur E2 : %10.7g Tol_Edge:%10.7g\n",maxd2,tole2);
1338 fflush(stdout);
1339 }
1340 else {
1341 printf("--- BRepCheck Wire: AutoIntersection Phase2 -> Erreur \n");
1342 printf("--- distance Point Vertex : %10.7g (tol %10.7g)\n",distauvtxleplusproche,tolvtt);
1343 printf("--- Erreur Max sur E1 : %10.7g Tol_Edge:%10.7g\n",maxd1,tole1);
1344 printf("--- Erreur Max sur E2 : %10.7g Tol_Edge:%10.7g\n",maxd2,tole2);
1345 fflush(stdout);
1346 }
1347#endif
1348 } //end of else (construction of the line Lig)
1349 } //end of if (localok == Standard_False && !CommonVertices.IsEmpty())
1350 //
1351 if(localok==Standard_False) {
7fd59977 1352 retE1=E1;
1353 retE2=E2;
1354 if (Update) {
1355 BRepCheck::Add(myMap(myShape),BRepCheck_SelfIntersectingWire);
1356 }
0797d9d3 1357#ifdef OCCT_DEBUG
7fd59977 1358 static Standard_Integer numpoint1=0;
1359 cout<<"point p"<<++numpoint1<<" "<<P3d.X()<<" "<<P3d.Y()<<" "<<P3d.Z()<<endl;
1360 cout.flush();
1361#endif
1362 delete [] tabDom;
1363 return(BRepCheck_SelfIntersectingWire);
1364 } //-- localok == False
1365 } //end of if(Tr1.PositionOnCurve() == IntRes2d_Middle || Tr2.PositionOnCurve() == IntRes2d_Middle)
1366 } //end of for (Standard_Integer p=1; p <= nbp; p++)
1367 ////
1368 //// **** Segments of intersection **** ////
1369 for (Standard_Integer s = 1; s <= nbs; ++s) {
1370 const IntRes2d_IntersectionSegment& Seg = Inter.Segment(s);
1371 if (Seg.HasFirstPoint() && Seg.HasLastPoint()) {
1372 Standard_Boolean localok;
1373 Standard_Integer k;
1374 IntRes2d_IntersectionPoint PSeg [2];
1375 IntRes2d_Position aPCR1, aPCR2;
1376 //
1377 localok = Standard_False;
1378 PSeg[0] = Seg.FirstPoint();
1379 PSeg[1] = Seg.LastPoint();
1380 // At least one of extremities of the segment must be inside
1381 // the tolerance of a common vertex
1382 for (k = 0; k < 2; ++k) {
1383 IP_ParamOnFirst = PSeg[k].ParamOnFirst();
1384 IP_ParamOnSecond = PSeg[k].ParamOnSecond();
1385 Tr1 = PSeg[k].TransitionOfFirst();
1386 Tr2 = PSeg[k].TransitionOfSecond();
1387 aPCR1=Tr1.PositionOnCurve();
1388 aPCR2=Tr2.PositionOnCurve();
1389 //
1390 if(aPCR1!=IntRes2d_Middle && aPCR2!=IntRes2d_Middle) {
1391 GeomAbs_CurveType aCT1, aCT2;
1392 //ZZ
1393 aCT1=C1.GetType();
1394 aCT2=C2.GetType();
1395 if (aCT1==GeomAbs_Line && aCT2==GeomAbs_Line) {
1396 // check for the two lines coincidence
1397 Standard_Real aPAR_T, aT11, aT12, aT21, aT22, aT1m, aT2m;
1398 Standard_Real aD2, aTolE1, aTolE2, aTol2, aDot;
1399 gp_Lin2d aL1, aL2;
1400 gp_Pnt2d aP1m;
1401 //
1402 aPAR_T=0.43213918;
1403 //
1404 aTolE1=BRep_Tool::Tolerance(E1);
1405 aTolE2=BRep_Tool::Tolerance(E2);
1406 aTol2=aTolE1+aTolE2;
1407 aTol2=aTol2*aTol2;
1408 //
1409 aL1=C1.Line();
1410 aL2=C2.Line();
1411 //
1412 aT11=PSeg[0].ParamOnFirst();
1413 aT12=PSeg[1].ParamOnFirst();
1414 aT21=PSeg[0].ParamOnSecond();
1415 aT22=PSeg[1].ParamOnSecond();
1416 //
1417 aT1m=(1.-aPAR_T)*aT11 + aPAR_T*aT12;
1418 aP1m=C1.Value(aT1m);
1419 //
1420 aD2=aL2.SquareDistance(aP1m);
1421 if (aD2<aTol2) {
1422 aT2m=ElCLib::Parameter(aL2, aP1m);
1423 if (aT2m>aT21 && aT2m<aT22) {
1424 const gp_Dir2d& aDir1=aL1.Direction();
1425 const gp_Dir2d& aDir2=aL2.Direction();
1426 aDot=aDir1*aDir2;
1427 if (aDot<0.) {
1428 aDot=-aDot;
1429 }
1430 //
1431 if ((1.-aDot)<5.e-11){//0.00001 rad
1432 localok = Standard_False;
1433 break;// from for (k = 0; k < 2; ++k){...
1434 }
1435 }//if (aT2m>aT21 && aT2m<aT22) {
1436 }//if (aD2<aTol2) {
1437 }//if (aCT1==GeomAbs_Line && aCT2==GeomAbs_Line) {
1438 //ZZ
1439 localok = Standard_True;
1440 break;
1441 }
1442 //
1443 Standard_Real f,l, tolvtt;
1444 TopLoc_Location L, L2;
1445 const Handle(Geom_Curve)& ConS = BRep_Tool::Curve(E1,L,f,l);
1446 const Handle(Geom_Curve)& ConS2 = BRep_Tool::Curve(E2,L2,f,l);
1447 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 Begin
1448 if (!ConS.IsNull()) {
1449 P3d = ConS->Value(IP_ParamOnFirst);
1450 P3d.Transform(L.Transformation());
1451 } else {
1452 gp_Pnt2d aP2d = C1.Value(IP_ParamOnFirst);
1453 P3d = HS->Value(aP2d.X(), aP2d.Y());
1454 }
1455 if (!ConS2.IsNull()) {
1456 P3d2 = ConS2->Value(IP_ParamOnSecond);
1457 P3d2.Transform(L2.Transformation());
1458 } else {
1459 gp_Pnt2d aP2d = C2.Value(IP_ParamOnSecond);
1460 P3d2 = HS->Value(aP2d.X(), aP2d.Y());
1461 }
1462 // Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
1463 itl.Initialize( CommonVertices );
1464 for (; itl.More(); itl.Next()) {
1465 Standard_Real p3dvttDistanceP3d, p3dvttDistanceP3d2;
1466 gp_Pnt p3dvtt;
1467 //
1468 const TopoDS_Vertex& vtt = TopoDS::Vertex(itl.Value());
1469 p3dvtt = BRep_Tool::Pnt(vtt);
1470 tolvtt = BRep_Tool::Tolerance(vtt);
1471 tolvtt=1.1*tolvtt;
1472 tolvtt=tolvtt*tolvtt;
1473 p3dvttDistanceP3d = p3dvtt.SquareDistance(P3d);
1474 p3dvttDistanceP3d2 = p3dvtt.SquareDistance(P3d2);
1475 if (p3dvttDistanceP3d <= tolvtt && p3dvttDistanceP3d2 <= tolvtt) {
1476 localok = Standard_True;
1477 break;
1478 }
1479 }
1480 if (localok == Standard_True) {
1481 break;
1482 }
1483 } //end of for (k = 0; k < 2; k++)
1484 //
1485 if(localok==Standard_False) {
7fd59977 1486 retE1=E1;
1487 retE2=E2;
1488 if (Update) {
1489 BRepCheck::Add(myMap(myShape),BRepCheck_SelfIntersectingWire);
1490 }
0797d9d3 1491#ifdef OCCT_DEBUG
7fd59977 1492 static Standard_Integer numpoint1=0;
1493 cout<<"point p"<<++numpoint1<<" "<<P3d.X()<<" "<<P3d.Y()<<" "<<P3d.Z()<<endl;
1494 cout.flush();
1495#endif
1496 delete [] tabDom;
1497 return(BRepCheck_SelfIntersectingWire);
1498 } //-- localok == False
1499 } //end of if(Seg.HasFirstPoint() && Seg.HasLastPoint())
1500 } //end of for (Standard_Integer s = 1; s <= nbs; p++)
1501 } //-- Inter.IsDone()
1502 } //end of for( j = i+1; j<=Nbedges; j++)
1503 } //end of for(i = 1; i <= Nbedges; i++)
1504 //
1505 delete [] tabDom;
1506 if (Update) {
1507 BRepCheck::Add(myMap(myShape),BRepCheck_NoError);
1508 }
1509 //
1510 return (BRepCheck_NoError);
1511}
52d45841 1512
1513//=======================================================================
1514//function : SetStatus
1515//purpose :
1516//=======================================================================
1517
1518void BRepCheck_Wire::SetStatus(const BRepCheck_Status theStatus)
1519{
1520 BRepCheck::Add(myMap(myShape),theStatus);
1521}
1522
7fd59977 1523//=======================================================================
1524//function : GeometricControls
1525//purpose :
1526//=======================================================================
1527void BRepCheck_Wire::GeometricControls(const Standard_Boolean B)
1528{
1529 if (myGctrl != B) {
1530 if (B) {
1531 myCdone = Standard_False;
1532 }
1533 myGctrl = B;
1534 }
1535}
1536//=======================================================================
1537//function : GeometricControls
1538//purpose :
1539//=======================================================================
1540Standard_Boolean BRepCheck_Wire::GeometricControls() const
1541{
1542 return myGctrl;
1543}
1544
7fd59977 1545//=======================================================================
1546//function : Propagate
1547//purpose : fill <mapE> with edges connected to <edg> through vertices
1548// contained in <mapVE>
1549//=======================================================================
1550static void Propagate(const TopTools_IndexedDataMapOfShapeListOfShape& mapVE,
22774b62 1551 const TopoDS_Shape& edg,
1552 TopTools_MapOfShape& mapE)
7fd59977 1553{
22774b62 1554 TopTools_ListOfShape currentEdges;
1555 currentEdges.Append(edg);
1556
1557 do
1558 {
1559 TopTools_ListOfShape nextEdges;
1560 TopTools_ListIteratorOfListOfShape itrc(currentEdges);
1561 for (; itrc.More(); itrc.Next())
1562 {
1563 const TopoDS_Shape& Edge = itrc.Value();
a61133c8 1564 if (!mapE.Contains(Edge))
1565 mapE.Add(Edge);
22774b62 1566
1567 TopExp_Explorer ex(Edge, TopAbs_VERTEX);
1568 for (; ex.More(); ex.Next())
1569 {
1570 const TopoDS_Vertex& vtx = TopoDS::Vertex(ex.Current());
1571 Standard_Integer indv = mapVE.FindIndex(vtx);
1572 if (indv != 0)
1573 {
1574 const TopTools_ListOfShape& edges = mapVE(indv);
1575
1576 TopTools_ListIteratorOfListOfShape itl(edges);
1577 for (; itl.More(); itl.Next())
1578 {
1579 const TopoDS_Shape& E = itl.Value();
1580 if (!Edge.IsSame(E) && !mapE.Contains(E))
a61133c8 1581 {
1582 mapE.Add(E);
22774b62 1583 nextEdges.Append(E);
a61133c8 1584 }
22774b62 1585 }
1586 }
7fd59977 1587 }
1588 }
22774b62 1589 currentEdges = nextEdges;
7fd59977 1590 }
22774b62 1591 while (!currentEdges.IsEmpty());
7fd59977 1592}
22774b62 1593
7fd59977 1594//=======================================================================
1595//function : GetOrientation
1596//purpose :
1597//=======================================================================
1598
1599static TopAbs_Orientation GetOrientation(const TopTools_MapOfShape& mapE,
1600 const TopoDS_Edge& edg)
1601{
1602 TopTools_MapIteratorOfMapOfShape itm(mapE);
1603 for ( ; itm.More(); itm.Next()) {
1604 if (itm.Key().IsSame(edg)) {
1605 break;
1606 }
1607 }
1608 return itm.Key().Orientation();
1609}
1610//=======================================================================
1611//function : ChoixUV
3f257c62 1612//purpose : For vertex theVertex given function find an edge along
1613// that we should go further.
7fd59977 1614//=======================================================================
3f257c62 1615void ChoixUV(const TopoDS_Vertex& theVertex,
1616 const TopoDS_Edge& theEdge,
1617 const TopoDS_Face& theFace,
1618 TopTools_ListOfShape& theLOfShape)
1619 {
1620 TopTools_ListIteratorOfListOfShape It( theLOfShape );
7fd59977 1621 while (It.More())
1622 {
3f257c62 1623 if (theEdge.IsSame( It.Value() ))
1624 theLOfShape.Remove( It );
1625 else
1626 It.Next();
7fd59977 1627 }
1628
3f257c62 1629 Standard_Real aTol3d = BRep_Tool::Tolerance(theVertex);
1630
1631 Standard_Integer anIndex = 0, anIndMin = 0;
1632 TopoDS_Edge anEFound;
1633 gp_Pnt2d aPntRef, aPnt;
1634 gp_Vec2d aDerRef, aDer;
1635 Standard_Real aMinAngle, aMaxAngle, anAngle;
1636 Standard_Real a_gpResolution=gp::Resolution();
1637 TopAbs_Orientation aVOrientation, anEdgOrientation;
1638 Standard_Real aParam = 0.0, aFirstParam = 0.0, aLastParam = 0.0, aParPiv = 0.0;
1639 BRepAdaptor_Surface aFaceSurface(theFace,Standard_False); // no restriction
1640
1641 Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(theEdge, theFace, aFirstParam, aLastParam);
1642 if (C2d.IsNull())// JAG 10.12.96
7fd59977 1643 return;
3f257c62 1644
1645 aVOrientation = theVertex.Orientation();
1646 anEdgOrientation = theEdge.Orientation();
7fd59977 1647
3f257c62 1648 aParPiv =(aVOrientation==anEdgOrientation) ? aFirstParam : aLastParam;
1649 aMinAngle = RealLast();
1650 aMaxAngle = RealFirst();
7fd59977 1651
3f257c62 1652 CurveDirForParameter(C2d, aParPiv, aPntRef, aDerRef);
1653
1654 if (aVOrientation != anEdgOrientation)
1655 aDerRef.Reverse();
7fd59977 1656
3f257c62 1657 It.Initialize(theLOfShape);
7fd59977 1658
3f257c62 1659 for (; It.More(); It.Next())
1660 {
1661 anIndex++;
1662 const TopoDS_Edge& anE=TopoDS::Edge(It.Value());
1663 C2d = BRep_Tool::CurveOnSurface(anE, theFace, aFirstParam, aLastParam);
1664 if(C2d.IsNull())
7fd59977 1665 continue;
94f71cad 1666 Geom2dAdaptor_Curve aCA(C2d);
7fd59977 1667
3f257c62 1668 aParam =(aVOrientation != anE.Orientation()) ? aFirstParam : aLastParam;
94f71cad 1669 aPnt = aCA.Value(aParam);
3f257c62 1670
1671 if(!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d, Standard_False))
7fd59977 1672 continue;
3f257c62 1673
94f71cad 1674 CurveDirForParameter(aCA, aParam, aPnt, aDer);
3f257c62 1675
1676 if (aVOrientation == anE.Orientation())
1677 aDer.Reverse();
1678
1679 if ((aDerRef.Magnitude() <= a_gpResolution) ||
1680 (aDer.Magnitude() <= a_gpResolution))
1681//Vector length is too small
7fd59977 1682 continue;
3f257c62 1683
1684 anAngle = -aDerRef.Angle( aDer );
1685
1686 if ( anAngle < 0. )
1687 anAngle += 2.*M_PI;
1688
1689 if ( theFace.Orientation() == TopAbs_FORWARD )
1690 {
1691 if ( anAngle < aMinAngle )
1692 {
1693 anIndMin = anIndex;
1694 aMinAngle = anAngle;
1695 }
7fd59977 1696 }
3f257c62 1697 else //theFace.Orientation() != TopAbs_FORWARD
1698 {
1699 if ( anAngle > aMaxAngle )
1700 {
1701 anIndMin = anIndex;
1702 aMaxAngle = anAngle;
1703 }
7fd59977 1704 }
3f257c62 1705 }//end of for
1706
1707// Update edge
1708 if (anIndMin == 0)
1709 if (theLOfShape.Extent() == 1)
1710 {
1711 Standard_Boolean IsFound = Standard_True; //all right
1712 anEFound = TopoDS::Edge(theLOfShape.First());
1713
1714 if(anEFound.IsNull() || BRep_Tool::Degenerated(theEdge) ||
1715 BRep_Tool::Degenerated(anEFound))
1716 IsFound = Standard_False; //bad
1717 else if (!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d))
1718 IsFound = Standard_False; //bad
1719 else
1720 // clousureness in 3D
1721 {
1722//IsDistanceIn3DTolerance
1723 BRepAdaptor_Curve bcEdg(theEdge, theFace);
1724 BRepAdaptor_Curve bcEvois(anEFound, theFace);
1725 gp_Pnt pEdg = bcEdg.Value(aParPiv);
1726 gp_Pnt pEFound = bcEvois.Value(aParam);
1727
9e20ed57 1728 if(!IsDistanceIn3DTolerance(pEdg, pEFound, aTol3d))
3f257c62 1729 IsFound = Standard_False;
1730 else
1731//angle was not defined but points are close
1732 IsFound = Standard_True; //all right
1733 }
1734
1735 if(!IsFound)
1736 {
1737 theLOfShape.Clear();
1738 }
1739 }//if (theLOfShape.Extent() == 1)
1740 else //if (anIndMin == 0)
1741 {
1742 theLOfShape.Clear();
7fd59977 1743 }
3f257c62 1744 else
1745 {
1746 anIndex = 1;
1747
1748 while (anIndex < anIndMin)
1749 {
1750 theLOfShape.RemoveFirst();
1751 anIndex++;
7fd59977 1752 }
3f257c62 1753
1754 It.Initialize(theLOfShape);
7fd59977 1755 It.Next();
3f257c62 1756
7fd59977 1757 while (It.More())
3f257c62 1758 theLOfShape.Remove(It);
1759 }
1760 }//End of function
1761
1762
7fd59977 1763//=======================================================================
1764//function : CurveDirForParameter
1765//purpose :
1766//=======================================================================
94f71cad 1767void CurveDirForParameter(const Geom2dAdaptor_Curve& aC2d,
1768 const Standard_Real aPrm,
1769 gp_Pnt2d& Pnt,
1770 gp_Vec2d& aVec2d)
7fd59977 1771{
1772 Standard_Real aTol=gp::Resolution();
1773 Standard_Integer i;
1774
94f71cad 1775 aC2d.D1(aPrm, Pnt, aVec2d);
7fd59977 1776 //
1777 if (aVec2d.Magnitude() <= aTol) {
1778 for (i = 2; i <= 100; i++){
94f71cad 1779 aVec2d = aC2d.DN(aPrm, i);
7fd59977 1780 if (aVec2d.Magnitude() > aTol) {
94f71cad 1781 break;
7fd59977 1782 }
1783 }
1784 }
1785}
1786
1787// Modified by Sergey KHROMOV - Wed May 22 10:44:06 2002 OCC325 Begin
1788//=======================================================================
1789//function : GetPnts2d
1790//purpose : this function returns the parametric points of theVertex on theFace.
1791// If theVertex is a start and end vertex of theEdge hasSecondPnt
1792// becomes Standard_True and aPnt2 returns the second parametric point.
1793// Returns Standard_True if paraametric points are successfully found.
1794//=======================================================================
1795
1796static Standard_Boolean GetPnt2d(const TopoDS_Vertex &theVertex,
1797 const TopoDS_Edge &theEdge,
1798 const TopoDS_Face &theFace,
1799 gp_Pnt2d &aPnt)
1800{
1801 Handle(Geom2d_Curve) aPCurve;
1802 Standard_Real aFPar;
1803 Standard_Real aLPar;
1804 Standard_Real aParOnEdge;
1805 TopoDS_Vertex aFirstVtx;
1806 TopoDS_Vertex aLastVtx;
1807
1808 TopExp::Vertices(theEdge, aFirstVtx, aLastVtx);
1809
1810 if (!theVertex.IsSame(aFirstVtx) && !theVertex.IsSame(aLastVtx))
1811 return Standard_False;
1812
1813 aPCurve = BRep_Tool::CurveOnSurface(theEdge, theFace, aFPar, aLPar);
1814
1815 if (aPCurve.IsNull())
1816 return Standard_False;
1817
1818 aParOnEdge = BRep_Tool::Parameter(theVertex, theEdge);
1819 aPnt = aPCurve->Value(aParOnEdge);
1820
1821 return Standard_True;
1822}
1823
1824//=======================================================================
1825//function : Closed2dForPeriodicFace
1826//purpose : Checks the distance between first point of the first edge
1827// and last point of the last edge in 2d for periodic face.
1828//=======================================================================
1829static Standard_Boolean IsClosed2dForPeriodicFace
1830 (const TopoDS_Face &theFace,
1831 const gp_Pnt2d &theP1,
1832 const gp_Pnt2d &theP2,
1833 const TopoDS_Vertex &theVertex)
1834{
1835// Check 2d distance for periodic faces with seam edge.
1836// Searching for seam edges
1837 TopTools_ListOfShape aSeamEdges;
1838 TopTools_MapOfShape NotSeams;
1839 TopTools_MapOfShape ClosedEdges;
1840 TopExp_Explorer anExp(theFace, TopAbs_EDGE);
1841
1842 for (;anExp.More(); anExp.Next()) {
1843 TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current());
1844
1845 if (NotSeams.Contains(anEdge))
1846 continue;
1847
1848 if (!IsOriented(anEdge) ||
1849 !BRep_Tool::IsClosed(anEdge, theFace)) {
1850 NotSeams.Add(anEdge);
1851 continue;
1852 }
1853
1854 if (!ClosedEdges.Add(anEdge))
1855 aSeamEdges.Append(anEdge);
1856 }
1857
1858 if (aSeamEdges.Extent() == 0)
1859 return Standard_True;
1860
1861// check if theVertex lies on one of the seam edges
1862 BRepAdaptor_Surface aFaceSurface (theFace, Standard_False);
1863 Standard_Real aTol = BRep_Tool::Tolerance(theVertex);
1864 Standard_Real aUResol = aFaceSurface.UResolution(aTol);
1865 Standard_Real aVResol = aFaceSurface.VResolution(aTol);
1866 Standard_Real aVicinity = Sqrt(aUResol*aUResol + aVResol*aVResol);
1867 Standard_Real aDistP1P2 = theP1.Distance(theP2);
1868
1869
1870 TopTools_ListIteratorOfListOfShape anIter(aSeamEdges);
1871
1872 for (; anIter.More(); anIter.Next()) {
1873 TopoDS_Edge aSeamEdge = TopoDS::Edge(anIter.Value());
1874
1875 anExp.Init(aSeamEdge, TopAbs_VERTEX);
1876 for (; anExp.More(); anExp.Next()) {
1877 const TopoDS_Shape &aVtx = anExp.Current();
1878
1879// We found an edge. Check the distance between two given points
1880// to be lower than the computed tolerance.
1881 if (IsOriented(aVtx) && aVtx.IsSame(theVertex)) {
1882 gp_Pnt2d aPnt1;
1883 gp_Pnt2d aPnt2;
1884 Standard_Real a2dTol;
1885
1886 if (!GetPnt2d(theVertex, aSeamEdge, theFace, aPnt1))
1887 continue;
1888
1889 aSeamEdge = TopoDS::Edge(aSeamEdge.Reversed());
1890
1891 if (!GetPnt2d(theVertex, aSeamEdge, theFace, aPnt2))
1892 continue;
1893
1894 a2dTol = aPnt1.Distance(aPnt2)*1.e-2;
1895 a2dTol = Max(a2dTol, aVicinity);
1896
1897 if (aDistP1P2 > a2dTol)
1898 return Standard_False;
1899 }
1900 }
1901 }
1902
1903 return Standard_True;
1904}
1905// Modified by Sergey KHROMOV - Thu Jun 20 10:58:05 2002 End