4e57c75e |
1 | // Created by: Peter KURNEV |
973c2be1 |
2 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
4e57c75e |
3 | // |
973c2be1 |
4 | // This file is part of Open CASCADE Technology software library. |
4e57c75e |
5 | // |
d5f74e42 |
6 | // This library is free software; you can redistribute it and/or modify it under |
7 | // the terms of the GNU Lesser General Public License version 2.1 as published |
973c2be1 |
8 | // by the Free Software Foundation, with special exception defined in the file |
9 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
10 | // distribution for complete text of the license and disclaimer of any warranty. |
4e57c75e |
11 | // |
973c2be1 |
12 | // Alternatively, this file may be used under the terms of Open CASCADE |
13 | // commercial license or contractual agreement. |
4e57c75e |
14 | |
15 | #include <BOPTools_AlgoTools.ixx> |
c26b5a34 |
16 | // |
17 | #include <gp_Pnt.hxx> |
18 | #include <gp_Pnt2d.hxx> |
19 | // |
20 | #include <Adaptor3d_HCurve.hxx> |
21 | #include <Adaptor3d_CurveOnSurface.hxx> |
22 | #include <Adaptor3d_HCurveOnSurface.hxx> |
23 | // |
4e57c75e |
24 | #include <Geom_Curve.hxx> |
25 | #include <Geom_Surface.hxx> |
26 | #include <Geom_Plane.hxx> |
27 | #include <Geom_TrimmedCurve.hxx> |
c26b5a34 |
28 | #include <Geom_RectangularTrimmedSurface.hxx> |
29 | // |
30 | #include <GeomAdaptor_Surface.hxx> |
4e57c75e |
31 | #include <GeomAdaptor_Curve.hxx> |
32 | #include <GeomAdaptor_HCurve.hxx> |
33 | #include <GeomAdaptor_HSurface.hxx> |
c26b5a34 |
34 | // |
4e57c75e |
35 | #include <Geom2d_Curve.hxx> |
c26b5a34 |
36 | #include <Geom2dInt_GInter.hxx> |
37 | #include <Geom2dAdaptor_Curve.hxx> |
4e57c75e |
38 | #include <Geom2dAdaptor_HCurve.hxx> |
4e57c75e |
39 | #include <Geom2dAdaptor.hxx> |
c26b5a34 |
40 | // |
4e57c75e |
41 | #include <GeomProjLib.hxx> |
c26b5a34 |
42 | // |
4e57c75e |
43 | #include <ProjLib_ProjectedCurve.hxx> |
44 | #include <Extrema_LocateExtPC.hxx> |
4e57c75e |
45 | // |
c26b5a34 |
46 | #include <IntRes2d_Domain.hxx> |
47 | #include <IntRes2d_IntersectionPoint.hxx> |
48 | // |
49 | #include <TopLoc_Location.hxx> |
50 | // |
51 | #include <TopoDS.hxx> |
52 | #include <TopoDS_Edge.hxx> |
53 | #include <TopoDS_Vertex.hxx> |
54 | #include <TopoDS_Face.hxx> |
4e57c75e |
55 | #include <TopoDS_Iterator.hxx> |
56 | #include <TopoDS_Wire.hxx> |
c26b5a34 |
57 | // |
58 | #include <BRep_TVertex.hxx> |
59 | #include <BRep_TEdge.hxx> |
60 | #include <BRep_TFace.hxx> |
4e57c75e |
61 | #include <BRep_Tool.hxx> |
c26b5a34 |
62 | #include <BRep_GCurve.hxx> |
63 | #include <BRep_ListIteratorOfListOfPointRepresentation.hxx> |
64 | #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx> |
65 | #include <BRep_CurveRepresentation.hxx> |
66 | #include <BRep_PointRepresentation.hxx> |
4e57c75e |
67 | #include <BRep_Builder.hxx> |
c26b5a34 |
68 | // |
69 | #include <BRepAdaptor_Surface.hxx> |
70 | // |
71 | #include <BRepTools_WireExplorer.hxx> |
72 | // |
73 | #include <TopExp.hxx> |
74 | #include <TopExp_Explorer.hxx> |
75 | #include <TopTools_IndexedMapOfShape.hxx> |
4e57c75e |
76 | #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx> |
77 | #include <TopTools_ListOfShape.hxx> |
78 | #include <TopTools_ListIteratorOfListOfShape.hxx> |
c26b5a34 |
79 | // |
1b7ae951 |
80 | #include <IntTools_Tools.hxx> |
81 | // |
c26b5a34 |
82 | #include <BOPCol_NCVector.hxx> |
c7b59798 |
83 | #include <BOPCol_Parallel.hxx> |
1b7ae951 |
84 | #include <BRepLib_CheckCurveOnSurface.hxx> |
4e57c75e |
85 | |
86 | static |
87 | void CheckEdge (const TopoDS_Edge& E, |
88 | const Standard_Real aMaxTol); |
89 | static |
90 | void CorrectEdgeTolerance (const TopoDS_Edge& myShape, |
91 | const TopoDS_Face& S, |
92 | const Standard_Real aMaxTol); |
93 | static |
94 | Standard_Boolean Validate(const Adaptor3d_Curve& CRef, |
95 | const Adaptor3d_Curve& Other, |
96 | const Standard_Real Tol, |
97 | const Standard_Boolean SameParameter, |
98 | Standard_Real& aNewTolerance); |
99 | |
100 | static |
101 | void CorrectVertexTolerance(const TopoDS_Edge& aE); |
102 | |
103 | static |
104 | void CorrectWires(const TopoDS_Face& aF); |
105 | |
c26b5a34 |
106 | |
107 | |
108 | static |
109 | void UpdateEdges(const TopoDS_Face& aF); |
110 | |
b4109929 |
111 | static |
112 | Standard_Real IntersectCurves2d(const gp_Pnt& aPV, |
113 | const TopoDS_Face& aF, |
c26b5a34 |
114 | const Handle(Geom_Surface)& aS, |
b4109929 |
115 | const TopoDS_Edge& aE1, |
116 | const TopoDS_Edge& aE2); |
117 | |
4e57c75e |
118 | |
4e57c75e |
119 | |
c26b5a34 |
120 | //======================================================================= |
121 | //class : BOPTools_CPC |
122 | //purpose : |
123 | //======================================================================= |
124 | class BOPTools_CPC { |
125 | public: |
126 | BOPTools_CPC() |
127 | : myMaxTol(1.e-7) { |
128 | } |
129 | // |
130 | ~BOPTools_CPC() { |
131 | } |
132 | // |
133 | void SetEdge(const TopoDS_Edge& aE) { |
134 | myEdge=aE; |
135 | } |
136 | // |
137 | const TopoDS_Edge& Edge()const { |
138 | return myEdge; |
139 | } |
140 | // |
141 | void SetMaxTol(const Standard_Real aMaxTol) { |
142 | myMaxTol=aMaxTol; |
143 | } |
144 | // |
145 | Standard_Real MaxTol()const { |
146 | return myMaxTol; |
147 | } |
148 | // |
149 | void Perform() { |
150 | CheckEdge(myEdge, myMaxTol); |
151 | } |
152 | |
153 | protected: |
154 | Standard_Real myMaxTol; |
155 | TopoDS_Edge myEdge; |
156 | }; |
157 | // |
158 | //======================================================================= |
159 | typedef BOPCol_NCVector<BOPTools_CPC> BOPTools_VectorOfCPC; |
160 | // |
c7b59798 |
161 | typedef BOPCol_Functor |
c26b5a34 |
162 | <BOPTools_CPC, |
163 | BOPTools_VectorOfCPC> BOPTools_CPCFunctor; |
164 | // |
c7b59798 |
165 | typedef BOPCol_Cnt |
c26b5a34 |
166 | <BOPTools_CPCFunctor, |
167 | BOPTools_VectorOfCPC> BOPTools_CPCCnt; |
168 | // |
169 | //======================================================================= |
170 | //class : BOPTools_CWT |
171 | //purpose : |
172 | //======================================================================= |
173 | class BOPTools_CWT { |
174 | public: |
175 | BOPTools_CWT() { |
176 | } |
177 | // |
178 | ~BOPTools_CWT() { |
179 | } |
180 | // |
181 | void SetFace(const TopoDS_Face& aF) { |
182 | myFace=aF; |
183 | } |
184 | // |
185 | void Perform() { |
186 | CorrectWires(myFace); |
187 | } |
188 | // |
189 | protected: |
190 | TopoDS_Face myFace; |
191 | }; |
192 | //======================================================================= |
193 | typedef BOPCol_NCVector<BOPTools_CWT> BOPTools_VectorOfCWT; |
194 | // |
c7b59798 |
195 | typedef BOPCol_Functor |
c26b5a34 |
196 | <BOPTools_CWT, |
197 | BOPTools_VectorOfCWT> BOPTools_CWTFunctor; |
198 | // |
c7b59798 |
199 | typedef BOPCol_Cnt |
c26b5a34 |
200 | <BOPTools_CWTFunctor, |
201 | BOPTools_VectorOfCWT> BOPTools_CWTCnt; |
202 | // |
203 | //======================================================================= |
204 | //class : BOPTools_CDT |
205 | //purpose : |
206 | //======================================================================= |
207 | class BOPTools_CDT { |
208 | public: |
209 | BOPTools_CDT() |
210 | : myMaxTol(1.e-7) { |
211 | } |
212 | // |
213 | ~BOPTools_CDT() { |
214 | } |
215 | // |
216 | void SetEdge(const TopoDS_Edge& aE) { |
217 | myEdge=aE; |
218 | } |
219 | // |
220 | void SetFace(const TopoDS_Face& aF) { |
221 | myFace=aF; |
222 | } |
223 | // |
224 | void SetMaxTol(const Standard_Real aMaxTol) { |
225 | myMaxTol=aMaxTol; |
226 | } |
227 | // |
228 | void Perform() { |
229 | CorrectEdgeTolerance (myEdge, myFace, myMaxTol); |
230 | } |
231 | // |
232 | protected: |
233 | Standard_Real myMaxTol; |
234 | TopoDS_Edge myEdge; |
235 | TopoDS_Face myFace; |
236 | }; |
237 | //======================================================================= |
238 | typedef BOPCol_NCVector<BOPTools_CDT> BOPTools_VectorOfCDT; |
239 | // |
c7b59798 |
240 | typedef BOPCol_Functor |
c26b5a34 |
241 | <BOPTools_CDT, |
242 | BOPTools_VectorOfCDT> BOPTools_CDTFunctor; |
243 | // |
c7b59798 |
244 | typedef BOPCol_Cnt |
c26b5a34 |
245 | <BOPTools_CDTFunctor, |
246 | BOPTools_VectorOfCDT> BOPTools_CDTCnt; |
247 | // |
248 | //======================================================================= |
249 | //class : BOPTools_CVT |
250 | //purpose : |
251 | //======================================================================= |
252 | class BOPTools_CVT { |
253 | public: |
254 | BOPTools_CVT() { |
255 | } |
256 | // |
257 | ~BOPTools_CVT() { |
258 | } |
259 | // |
260 | void SetEdge(const TopoDS_Edge& aE) { |
261 | myEdge=aE; |
262 | } |
263 | // |
264 | void Perform() { |
265 | CorrectVertexTolerance(myEdge); |
266 | } |
267 | // |
268 | protected: |
269 | TopoDS_Edge myEdge; |
270 | }; |
271 | // |
272 | //======================================================================= |
273 | typedef BOPCol_NCVector<BOPTools_CVT> BOPTools_VectorOfCVT; |
274 | // |
c7b59798 |
275 | typedef BOPCol_Functor |
c26b5a34 |
276 | <BOPTools_CVT, |
277 | BOPTools_VectorOfCVT> BOPTools_CVTFunctor; |
278 | // |
c7b59798 |
279 | typedef BOPCol_Cnt |
c26b5a34 |
280 | <BOPTools_CVTFunctor, |
281 | BOPTools_VectorOfCVT> BOPTools_CVTCnt; |
282 | // |
283 | //======================================================================= |
284 | //class : BOPTools_CET |
285 | //purpose : |
286 | //======================================================================= |
287 | class BOPTools_CET { |
288 | public: |
289 | BOPTools_CET() { |
290 | } |
291 | // |
292 | ~BOPTools_CET() { |
293 | } |
294 | // |
295 | void SetFace(const TopoDS_Face& aF) { |
296 | myFace=aF; |
297 | } |
298 | // |
299 | void Perform() { |
300 | UpdateEdges(myFace); |
301 | } |
302 | // |
303 | protected: |
304 | TopoDS_Face myFace; |
305 | }; |
306 | //======================================================================= |
307 | typedef BOPCol_NCVector<BOPTools_CET> BOPTools_VectorOfCET; |
308 | // |
c7b59798 |
309 | typedef BOPCol_Functor |
c26b5a34 |
310 | <BOPTools_CET, |
311 | BOPTools_VectorOfCET> BOPTools_CETFunctor; |
312 | // |
c7b59798 |
313 | typedef BOPCol_Cnt |
c26b5a34 |
314 | <BOPTools_CETFunctor, |
315 | BOPTools_VectorOfCET> BOPTools_CETCnt; |
316 | // |
e98e3990 |
317 | // |
318 | //======================================================================= |
c7b59798 |
319 | // |
4e57c75e |
320 | //======================================================================= |
321 | // Function : CorrectTolerances |
322 | // purpose : |
323 | //======================================================================= |
c26b5a34 |
324 | void BOPTools_AlgoTools::CorrectTolerances |
325 | (const TopoDS_Shape& aShape, |
326 | const Standard_Real aMaxTol, |
327 | const Standard_Boolean bRunParallel) |
4e57c75e |
328 | { |
c26b5a34 |
329 | BOPTools_AlgoTools::CorrectPointOnCurve(aShape, aMaxTol, bRunParallel); |
330 | BOPTools_AlgoTools::CorrectCurveOnSurface(aShape, aMaxTol, bRunParallel); |
4e57c75e |
331 | } |
c26b5a34 |
332 | // |
4e57c75e |
333 | //======================================================================= |
334 | // Function : CorrectPointOnCurve |
335 | // purpose : |
336 | //======================================================================= |
c26b5a34 |
337 | void BOPTools_AlgoTools::CorrectPointOnCurve |
338 | (const TopoDS_Shape& aS, |
339 | const Standard_Real aMaxTol, |
340 | const Standard_Boolean bRunParallel) |
4e57c75e |
341 | { |
c26b5a34 |
342 | TopExp_Explorer aExp; |
343 | BOPTools_VectorOfCPC aVCPC; |
344 | // |
345 | aExp.Init(aS, TopAbs_EDGE); |
346 | for(; aExp.More(); aExp.Next()) { |
347 | const TopoDS_Edge& aE=*((TopoDS_Edge*)&aExp.Current()); |
348 | BOPTools_CPC& aCPC=aVCPC.Append1(); |
349 | aCPC.SetEdge(aE); |
350 | aCPC.SetMaxTol(aMaxTol); |
351 | } |
352 | // |
353 | //====================================================== |
354 | BOPTools_CPCCnt::Perform(bRunParallel, aVCPC); |
355 | //====================================================== |
4e57c75e |
356 | } |
4e57c75e |
357 | //======================================================================= |
358 | // Function : CorrectCurveOnSurface |
359 | // purpose : |
360 | //======================================================================= |
c26b5a34 |
361 | void BOPTools_AlgoTools::CorrectCurveOnSurface |
362 | (const TopoDS_Shape& aS, |
363 | const Standard_Real aMaxTol, |
364 | const Standard_Boolean bRunParallel) |
4e57c75e |
365 | { |
c26b5a34 |
366 | TopExp_Explorer aExpF, aExpE; |
367 | BOPTools_VectorOfCWT aVCWT; |
368 | BOPTools_VectorOfCDT aVCDT; |
369 | // |
370 | aExpF.Init(aS, TopAbs_FACE); |
371 | for (; aExpF.More(); aExpF.Next()) { |
372 | const TopoDS_Face& aF=*((TopoDS_Face*)&aExpF.Current()); |
4e57c75e |
373 | // |
c26b5a34 |
374 | BOPTools_CWT& aCWT=aVCWT.Append1(); |
375 | aCWT.SetFace(aF); |
4e57c75e |
376 | // |
c26b5a34 |
377 | aExpE.Init(aF, TopAbs_EDGE); |
378 | for (; aExpE.More(); aExpE.Next()) { |
379 | const TopoDS_Edge& aE=*((TopoDS_Edge*)&aExpE.Current()); |
380 | // |
381 | BOPTools_CDT& aCDT=aVCDT.Append1(); |
382 | aCDT.SetEdge(aE); |
383 | aCDT.SetFace(aF); |
384 | aCDT.SetMaxTol(aMaxTol); |
4e57c75e |
385 | } |
386 | } |
c26b5a34 |
387 | // |
388 | //====================================================== |
389 | BOPTools_CWTCnt::Perform(bRunParallel, aVCWT); |
390 | //====================================================== |
391 | BOPTools_CDTCnt::Perform(bRunParallel, aVCDT); |
392 | //====================================================== |
393 | } |
394 | //======================================================================= |
395 | // Function : CorrectShapeTolerances |
396 | // purpose : |
397 | //======================================================================= |
398 | void BOPTools_AlgoTools::CorrectShapeTolerances |
399 | (const TopoDS_Shape& aShape, |
400 | const Standard_Boolean bRunParallel) |
401 | { |
402 | TopExp_Explorer aExp; |
403 | BOPTools_VectorOfCVT aVCVT; |
404 | BOPTools_VectorOfCET aVCET; |
405 | // |
406 | aExp.Init(aShape, TopAbs_EDGE); |
407 | for (; aExp.More(); aExp.Next()) { |
408 | const TopoDS_Edge& aE = *(TopoDS_Edge*)&aExp.Current(); |
409 | BOPTools_CVT& aCVT=aVCVT.Append1(); |
410 | aCVT.SetEdge(aE); |
411 | } |
412 | // |
413 | //====================================================== |
414 | BOPTools_CVTCnt::Perform(bRunParallel, aVCVT); |
415 | //====================================================== |
416 | // |
417 | aExp.Init(aShape, TopAbs_FACE); |
418 | for (; aExp.More(); aExp.Next()) { |
419 | const TopoDS_Face& aF = *(TopoDS_Face*)&aExp.Current(); |
420 | BOPTools_CET& aCET=aVCET.Append1(); |
421 | aCET.SetFace(aF); |
422 | } |
423 | // |
424 | //====================================================== |
425 | BOPTools_CETCnt::Perform(bRunParallel, aVCET); |
426 | //====================================================== |
427 | } |
428 | // |
429 | //======================================================================= |
430 | // Function : CheckEdge |
431 | // purpose : Correct tolerances for Vertices on Edge |
432 | //======================================================================= |
433 | void CheckEdge (const TopoDS_Edge& Ed, |
434 | const Standard_Real aMaxTol) |
435 | { |
436 | Standard_Real aTolE, aTol, aD2, aNewTolerance, dd; |
437 | gp_Pnt aPC; |
438 | TopLoc_Location L; |
439 | TopoDS_Edge aE; |
440 | TopoDS_Vertex aV; |
441 | TopoDS_Iterator aItS; |
442 | // |
443 | TopAbs_Orientation aOrV; |
444 | BRep_ListIteratorOfListOfPointRepresentation aItPR; |
445 | BRep_ListIteratorOfListOfCurveRepresentation aItCR; |
446 | // |
447 | aE=Ed; |
448 | aE.Orientation(TopAbs_FORWARD); |
449 | aTolE=BRep_Tool::Tolerance(aE); |
450 | // |
451 | Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&aE.TShape()); |
452 | // |
453 | aItS.Initialize(aE); |
454 | for (; aItS.More(); aItS.Next()) { |
455 | aV= TopoDS::Vertex(aItS.Value()); |
456 | // |
457 | Handle(BRep_TVertex)& TV=*((Handle(BRep_TVertex)*)&aV.TShape()); |
458 | const gp_Pnt& aPV = TV->Pnt(); |
459 | // |
460 | aTol=BRep_Tool::Tolerance(aV); |
461 | aTol=Max(aTol, aTolE); |
462 | dd=0.1*aTol; |
463 | aTol*=aTol; |
464 | // |
465 | const TopLoc_Location& Eloc = aE.Location(); |
466 | // |
467 | aItCR.Initialize(TE->Curves()); |
468 | while (aItCR.More()) { |
469 | const Handle(BRep_CurveRepresentation)& aCR = aItCR.Value(); |
470 | const TopLoc_Location& loc = aCR->Location(); |
471 | L = (Eloc * loc).Predivided(aV.Location()); |
472 | // |
473 | if (aCR->IsCurve3D()) { |
474 | const Handle(Geom_Curve)& aC = aCR->Curve3D(); |
475 | if (!aC.IsNull()) { |
476 | aItPR.Initialize(TV->Points()); |
477 | while (aItPR.More()) { |
478 | const Handle(BRep_PointRepresentation)& aPR=aItPR.Value(); |
479 | if (aPR->IsPointOnCurve(aC, L)) { |
480 | aPC = aC->Value(aPR->Parameter()); |
481 | aPC.Transform(L.Transformation()); |
482 | aD2=aPV.SquareDistance(aPC); |
483 | if (aD2 > aTol) { |
484 | aNewTolerance=sqrt(aD2)+dd; |
485 | if (aNewTolerance<aMaxTol) |
486 | TV->UpdateTolerance(aNewTolerance); |
487 | } |
488 | } |
489 | aItPR.Next(); |
490 | } |
491 | // |
492 | aOrV=aV.Orientation(); |
493 | if (aOrV==TopAbs_FORWARD || aOrV==TopAbs_REVERSED) { |
494 | const Handle(BRep_GCurve)& aGC=*((Handle(BRep_GCurve)*)&aCR); |
495 | |
496 | if (aOrV==TopAbs_FORWARD) { |
497 | aPC=aC->Value(aGC->First()); |
498 | } |
499 | else { |
500 | aPC=aC->Value(aGC->Last()); |
501 | } |
502 | aPC.Transform(L.Transformation()); |
503 | // |
504 | aD2=aPV.SquareDistance(aPC); |
505 | if (aD2 > aTol) { |
506 | aNewTolerance=sqrt(aD2)+dd; |
507 | if (aNewTolerance<aMaxTol) |
508 | TV->UpdateTolerance(aNewTolerance); |
509 | } |
510 | } |
511 | } |
512 | } |
513 | aItCR.Next(); |
514 | }// while (itcr.More()) { |
515 | } // for (; aVExp.More(); aVExp.Next()) { |
4e57c75e |
516 | } |
517 | //======================================================================= |
518 | // Function : CorrectWires |
519 | // purpose : |
520 | //======================================================================= |
521 | void CorrectWires(const TopoDS_Face& aFx) |
522 | { |
c26b5a34 |
523 | Standard_Boolean bIsPeriodic; |
4e57c75e |
524 | Standard_Integer i, aNbV; |
96a95605 |
525 | Standard_Real aTol, aTol2, aD2, aD2max, aT1, aT2, aT; |
4e57c75e |
526 | gp_Pnt aP, aPV; |
527 | gp_Pnt2d aP2D; |
528 | TopoDS_Face aF; |
c26b5a34 |
529 | TopoDS_Vertex aV11, aV12, aV21, aV22;; |
4e57c75e |
530 | TopTools_IndexedDataMapOfShapeListOfShape aMVE; |
b4109929 |
531 | TopTools_ListIteratorOfListOfShape aIt, aIt1; |
4e57c75e |
532 | // |
533 | aF=aFx; |
534 | aF.Orientation(TopAbs_FORWARD); |
b4109929 |
535 | const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aFx); |
c26b5a34 |
536 | GeomAdaptor_Surface aGAS (aS); |
4e57c75e |
537 | // |
c26b5a34 |
538 | bIsPeriodic=(aGAS.IsUPeriodic() || aGAS.IsVPeriodic()); |
539 | // |
540 | TopExp::MapShapesAndAncestors(aF, |
541 | TopAbs_VERTEX, |
542 | TopAbs_EDGE, |
543 | aMVE); |
4e57c75e |
544 | aNbV=aMVE.Extent(); |
545 | for (i=1; i<=aNbV; ++i) { |
c26b5a34 |
546 | const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMVE.FindKey(i)); |
4e57c75e |
547 | aPV=BRep_Tool::Pnt(aV); |
548 | aTol=BRep_Tool::Tolerance(aV); |
549 | aTol2=aTol*aTol; |
550 | // |
551 | aD2max=-1.; |
552 | const TopTools_ListOfShape& aLE=aMVE.FindFromIndex(i); |
553 | aIt.Initialize(aLE); |
554 | for (; aIt.More(); aIt.Next()) { |
b4109929 |
555 | const TopoDS_Edge& aE=*(TopoDS_Edge*)(&aIt.Value()); |
c26b5a34 |
556 | const Handle(Geom2d_Curve)& aC2D= |
557 | BRep_Tool::CurveOnSurface(aE, aF, aT1, aT2); |
4e57c75e |
558 | aT=BRep_Tool::Parameter(aV, aE); |
c26b5a34 |
559 | // |
4e57c75e |
560 | aC2D->D0(aT, aP2D); |
4e57c75e |
561 | aS->D0(aP2D.X(), aP2D.Y(), aP); |
562 | aD2=aPV.SquareDistance(aP); |
563 | if (aD2>aD2max) { |
564 | aD2max=aD2; |
565 | } |
b4109929 |
566 | //check self interference |
c26b5a34 |
567 | if (aNbV==2) { |
568 | continue; |
569 | } |
570 | // |
571 | if (bIsPeriodic) { |
b4109929 |
572 | continue; |
573 | } |
c26b5a34 |
574 | // |
575 | TopExp::Vertices(aE, aV11, aV12); |
576 | // |
b4109929 |
577 | aIt1 = aIt; |
578 | aIt1.Next(); |
579 | for (; aIt1.More(); aIt1.Next()) { |
580 | const TopoDS_Edge& aE1=*(TopoDS_Edge*)(&aIt1.Value()); |
c26b5a34 |
581 | // |
b4109929 |
582 | //do not perform check for edges that have two common vertices |
c26b5a34 |
583 | TopExp::Vertices(aE1, aV21, aV22); |
584 | if ((aV11.IsSame(aV21) && aV12.IsSame(aV22)) || |
585 | (aV12.IsSame(aV21) && aV11.IsSame(aV22))) { |
586 | continue; |
b4109929 |
587 | } |
c26b5a34 |
588 | // |
589 | aD2=IntersectCurves2d(aPV, aF, aS, aE, aE1); |
b4109929 |
590 | if (aD2>aD2max) { |
591 | aD2max=aD2; |
592 | } |
c26b5a34 |
593 | }// for (; aIt1.More(); aIt1.Next()) { |
594 | }// for (; aIt.More(); aIt.Next()) { |
4e57c75e |
595 | if (aD2max>aTol2) { |
c26b5a34 |
596 | BRep_Builder aBB; |
597 | // |
4e57c75e |
598 | aTol=sqrt(aD2max); |
599 | aBB.UpdateVertex(aV, aTol); |
600 | } |
c26b5a34 |
601 | }// for (i=1; i<=aNbV; ++i) { |
4e57c75e |
602 | } |
b4109929 |
603 | //======================================================================= |
604 | // Function : IntersectCurves2d |
605 | // purpose : Intersect 2d curves of edges |
606 | //======================================================================= |
607 | Standard_Real IntersectCurves2d(const gp_Pnt& aPV, |
608 | const TopoDS_Face& aF, |
c26b5a34 |
609 | const Handle(Geom_Surface)& aS, |
b4109929 |
610 | const TopoDS_Edge& aE1, |
611 | const TopoDS_Edge& aE2) |
612 | { |
b4109929 |
613 | Standard_Real aDist, aD, aT11, aT12, aT21, aT22, aTol2d; |
614 | Standard_Integer j, aNbPnt; |
615 | Geom2dInt_GInter aInter; |
616 | gp_Pnt aP; |
617 | gp_Pnt2d aP2D; |
618 | // |
619 | aDist = 0.; |
bd28b2af |
620 | aTol2d = 1.e-10;//Precision::Confusion(); |
b4109929 |
621 | // |
c26b5a34 |
622 | const Handle(Geom2d_Curve)& aC2D1= |
623 | BRep_Tool::CurveOnSurface(aE1, aF, aT11, aT12); |
624 | const Handle(Geom2d_Curve)& aC2D2= |
625 | BRep_Tool::CurveOnSurface(aE2, aF, aT21, aT22); |
b4109929 |
626 | // |
627 | Geom2dAdaptor_Curve aGAC1(aC2D1), aGAC2(aC2D2); |
c26b5a34 |
628 | IntRes2d_Domain aDom1(aC2D1->Value(aT11), aT11, aTol2d, |
629 | aC2D1->Value(aT12), aT12, aTol2d); |
630 | IntRes2d_Domain aDom2(aC2D2->Value(aT21), aT21, aTol2d, |
631 | aC2D2->Value(aT22), aT22, aTol2d); |
b4109929 |
632 | // |
633 | aInter.Perform(aGAC1, aDom1, aGAC2, aDom2, aTol2d, aTol2d); |
634 | if (aInter.IsDone()) { |
635 | if (aInter.NbSegments()) { |
636 | return aDist; |
637 | } |
638 | aNbPnt = aInter.NbPoints(); |
639 | if (aNbPnt) { |
bd28b2af |
640 | aDist = -Precision::Infinite(); |
b4109929 |
641 | for (j = 1; j <= aNbPnt; ++j) { |
642 | aP2D = aInter.Point(j).Value(); |
643 | aS->D0(aP2D.X(), aP2D.Y(), aP); |
644 | aD=aPV.SquareDistance(aP); |
bd28b2af |
645 | if (aD > aDist) { |
646 | aDist = 1.01 * aD; |
b4109929 |
647 | } |
648 | } |
649 | } |
650 | } |
651 | return aDist; |
652 | } |
4e57c75e |
653 | //======================================================================= |
654 | // Function : CorrectEdgeTolerance |
655 | // purpose : Correct tolerances for Edge |
656 | //======================================================================= |
657 | void CorrectEdgeTolerance (const TopoDS_Edge& myShape, |
658 | const TopoDS_Face& S, |
659 | const Standard_Real aMaxTol) |
660 | { |
661 | // |
662 | // 1. Minimum of conditions to Perform |
663 | Handle (BRep_CurveRepresentation) myCref; |
664 | Handle (Adaptor3d_HCurve) myHCurve; |
665 | |
666 | myCref.Nullify(); |
667 | |
668 | Handle(BRep_TEdge)& TEx = *((Handle(BRep_TEdge)*)&myShape.TShape()); |
669 | BRep_ListIteratorOfListOfCurveRepresentation itcrx(TEx->Curves()); |
670 | Standard_Boolean Degenerated, SameParameterx, SameRangex; |
671 | |
672 | Standard_Integer unique = 0; |
673 | |
674 | Degenerated = TEx->Degenerated(); |
675 | SameParameterx = TEx->SameParameter(); |
676 | SameRangex = TEx->SameRange(); |
677 | |
678 | if (!SameRangex && SameParameterx) { |
679 | return; |
680 | } |
681 | |
682 | Handle(Geom_Curve) C3d; |
683 | while (itcrx.More()) { |
684 | const Handle(BRep_CurveRepresentation)& cr = itcrx.Value(); |
685 | if (cr->IsCurve3D()) { |
686 | unique++; |
687 | if (myCref.IsNull() && !cr->Curve3D().IsNull()) { |
688 | myCref = cr; |
689 | } |
690 | } |
691 | itcrx.Next(); |
692 | } |
693 | |
694 | if (unique==0) { |
695 | return;//...No3DCurve |
696 | } |
697 | if (unique>1) { |
698 | return;//...Multiple3DCurve; |
699 | } |
700 | |
701 | if (myCref.IsNull() && !Degenerated) { |
702 | itcrx.Initialize(TEx->Curves()); |
703 | while (itcrx.More()) { |
704 | const Handle(BRep_CurveRepresentation)& cr = itcrx.Value(); |
705 | if (cr->IsCurveOnSurface()) { |
706 | myCref = cr; |
707 | break; |
708 | } |
709 | itcrx.Next(); |
710 | } |
711 | } |
712 | |
713 | else if (!myCref.IsNull() && Degenerated){ |
714 | return ;//...InvalidDegeneratedFlag; |
715 | } |
716 | |
717 | if (!myCref.IsNull()) { |
c26b5a34 |
718 | const Handle(BRep_GCurve)& GCref = |
719 | *((Handle(BRep_GCurve)*)&myCref); |
4e57c75e |
720 | Standard_Real First,Last; |
721 | GCref->Range(First,Last); |
722 | if (Last<=First) { |
723 | myCref.Nullify(); |
724 | return ;//InvalidRange; |
725 | } |
726 | |
727 | else { |
728 | if (myCref->IsCurve3D()) { |
729 | Handle(Geom_Curve) C3dx = Handle(Geom_Curve)::DownCast |
c26b5a34 |
730 | (myCref->Curve3D()->Transformed |
731 | (myCref->Location().Transformation())); |
4e57c75e |
732 | GeomAdaptor_Curve GAC3d(C3dx, First, Last); |
733 | myHCurve = new GeomAdaptor_HCurve(GAC3d); |
734 | } |
735 | else { // curve on surface |
736 | Handle(Geom_Surface) Sref = myCref->Surface(); |
c26b5a34 |
737 | Sref = Handle(Geom_Surface):: |
738 | DownCast(Sref->Transformed(myCref->Location().Transformation())); |
4e57c75e |
739 | const Handle(Geom2d_Curve)& PCref = myCref->PCurve(); |
c26b5a34 |
740 | Handle(GeomAdaptor_HSurface) GAHSref = |
741 | new GeomAdaptor_HSurface(Sref); |
742 | Handle(Geom2dAdaptor_HCurve) GHPCref = |
743 | new Geom2dAdaptor_HCurve(PCref, First, Last); |
4e57c75e |
744 | Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref); |
745 | myHCurve = new Adaptor3d_HCurveOnSurface(ACSref); |
746 | } |
747 | } |
748 | } |
749 | |
750 | //=============================================== |
751 | // 2. Tolerances in InContext |
752 | { |
753 | if (myCref.IsNull()) |
754 | return; |
755 | Standard_Boolean ok=Standard_True;; |
756 | |
757 | Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&myShape.TShape()); |
758 | Standard_Real Tol = BRep_Tool::Tolerance(TopoDS::Edge(myShape)); |
759 | Standard_Real aNewTol=Tol; |
760 | |
761 | Standard_Boolean SameParameter = TE->SameParameter(); |
762 | Standard_Boolean SameRange = TE->SameRange(); |
763 | Standard_Real First = myHCurve->FirstParameter(); |
764 | Standard_Real Last = myHCurve->LastParameter(); |
4e57c75e |
765 | Standard_Real Delta =1.e-12; |
766 | |
767 | Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &S.TShape()); |
768 | const TopLoc_Location& Floc = S.Location(); |
769 | const TopLoc_Location& TFloc = TF->Location(); |
770 | const Handle(Geom_Surface)& Su = TF->Surface(); |
771 | TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location()); |
4e57c75e |
772 | Standard_Boolean pcurvefound = Standard_False; |
773 | |
774 | BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves()); |
775 | while (itcr.More()) { |
776 | const Handle(BRep_CurveRepresentation)& cr = itcr.Value(); |
777 | if (cr != myCref && cr->IsCurveOnSurface(Su,L)) { |
778 | pcurvefound = Standard_True; |
779 | const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr); |
780 | Standard_Real f,l; |
781 | GC->Range(f,l); |
782 | if (SameRange && (f != First || l != Last)) { |
d3f26155 |
783 | return ;//BRepCheck_InvalidSameRangeFlag; |
4e57c75e |
784 | } |
c26b5a34 |
785 | |
4e57c75e |
786 | Handle(Geom_Surface) Sb = cr->Surface(); |
c26b5a34 |
787 | Sb = Handle(Geom_Surface):: |
788 | DownCast (Su->Transformed(L.Transformation())); |
4e57c75e |
789 | Handle(Geom2d_Curve) PC = cr->PCurve(); |
c26b5a34 |
790 | Handle(GeomAdaptor_HSurface) GAHS = |
791 | new GeomAdaptor_HSurface(Sb); |
792 | Handle(Geom2dAdaptor_HCurve) GHPC = |
793 | new Geom2dAdaptor_HCurve(PC,f,l); |
4e57c75e |
794 | Adaptor3d_CurveOnSurface ACS(GHPC,GAHS); |
c26b5a34 |
795 | ok = Validate(myHCurve->Curve(), ACS, |
796 | Tol, SameParameter, aNewTol); |
4e57c75e |
797 | if (ok) { |
4e57c75e |
798 | if (aNewTol<aMaxTol) { |
799 | TE->UpdateTolerance(aNewTol+Delta); |
800 | // |
801 | CorrectVertexTolerance(myShape); |
802 | } |
803 | } |
804 | |
805 | if (cr->IsCurveOnClosedSurface()) { |
806 | //checkclosed = Standard_True; |
807 | GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds |
808 | ACS.Load(GAHS); // sans doute inutile |
809 | ACS.Load(GHPC); // meme remarque... |
810 | ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol); |
811 | if (ok) { |
4e57c75e |
812 | if (aNewTol<aMaxTol) { |
813 | TE->UpdateTolerance(aNewTol+Delta); |
814 | CorrectVertexTolerance(myShape); |
815 | } |
816 | } |
817 | } |
818 | } |
819 | itcr.Next(); |
820 | } |
821 | |
822 | if (!pcurvefound) { |
823 | Handle(Geom_Plane) P; |
824 | Handle(Standard_Type) styp = Su->DynamicType(); |
825 | if (styp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) { |
c26b5a34 |
826 | P = Handle(Geom_Plane):: |
827 | DownCast(Handle(Geom_RectangularTrimmedSurface):: |
828 | DownCast(Su)->BasisSurface()); |
4e57c75e |
829 | } |
830 | else { |
831 | P = Handle(Geom_Plane)::DownCast(Su); |
832 | } |
833 | if (P.IsNull()) { // not a plane |
c26b5a34 |
834 | return; |
4e57c75e |
835 | } |
836 | |
837 | else {// on fait la projection a la volee, comme BRep_Tool |
c26b5a34 |
838 | P = Handle(Geom_Plane):: |
839 | DownCast(P->Transformed(L.Transformation())); |
4e57c75e |
840 | //on projette Cref sur ce plan |
841 | Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P); |
842 | |
843 | // Dub - Normalement myHCurve est une GeomAdaptor_HCurve |
c26b5a34 |
844 | GeomAdaptor_Curve& Gac = |
845 | Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve(); |
4e57c75e |
846 | Handle(Geom_Curve) C3dx = Gac.Curve(); |
c26b5a34 |
847 | Handle(Geom_Curve) ProjOnPlane = |
848 | GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3dx,First,Last), |
849 | P, |
850 | P->Position().Direction(), |
851 | Standard_True); |
4e57c75e |
852 | |
c26b5a34 |
853 | Handle(GeomAdaptor_HCurve) aHCurve = |
854 | new GeomAdaptor_HCurve(ProjOnPlane); |
4e57c75e |
855 | |
856 | ProjLib_ProjectedCurve proj(GAHS,aHCurve); |
857 | Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj); |
858 | Handle(Geom2dAdaptor_HCurve) GHPC = |
c26b5a34 |
859 | new Geom2dAdaptor_HCurve(PC, |
860 | myHCurve->FirstParameter(), |
861 | myHCurve->LastParameter()); |
4e57c75e |
862 | |
863 | Adaptor3d_CurveOnSurface ACS(GHPC,GAHS); |
864 | |
865 | Standard_Boolean okx = Validate(myHCurve->Curve(),ACS, |
c26b5a34 |
866 | Tol,Standard_True, aNewTol); |
4e57c75e |
867 | if (okx) { |
4e57c75e |
868 | if (aNewTol<aMaxTol) { |
869 | TE->UpdateTolerance(aNewTol+Delta); |
870 | CorrectVertexTolerance(myShape); |
871 | } |
872 | } |
873 | } |
4e57c75e |
874 | }//end of if (!pcurvefound) { |
875 | } // end of 2. Tolerances in InContext |
4e57c75e |
876 | } |
4e57c75e |
877 | //======================================================================= |
878 | //function : CorrectVertexTolerance |
879 | //purpose : |
880 | //======================================================================= |
881 | void CorrectVertexTolerance(const TopoDS_Edge& aE) |
882 | { |
4e57c75e |
883 | Standard_Real aTolE, aTolV; |
c26b5a34 |
884 | TopoDS_Iterator aIt; |
885 | // |
4e57c75e |
886 | aTolE=BRep_Tool::Tolerance(aE); |
c26b5a34 |
887 | aIt.Initialize(aE); |
888 | for(; aIt.More(); aIt.Next()) { |
889 | const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aIt.Value()); |
4e57c75e |
890 | aTolV=BRep_Tool::Tolerance(aV); |
891 | if (aTolV<aTolE) { |
c26b5a34 |
892 | Handle(BRep_TVertex)& aTV= *((Handle(BRep_TVertex)*)&aV.TShape()); |
4e57c75e |
893 | aTV->UpdateTolerance(aTolE); |
894 | } |
895 | } |
896 | } |
4e57c75e |
897 | //======================================================================= |
898 | //function : Validate |
899 | //purpose : |
900 | //======================================================================= |
901 | Standard_Boolean Validate(const Adaptor3d_Curve& CRef, |
902 | const Adaptor3d_Curve& Other, |
903 | const Standard_Real Tol, |
904 | const Standard_Boolean SameParameter, |
905 | Standard_Real& aNewTolerance) |
906 | { |
907 | Standard_Real First, Last, MaxDistance, aD, Tol2; |
908 | |
909 | First = CRef.FirstParameter(); |
910 | Last = CRef.LastParameter(); |
911 | MaxDistance = 0.; |
912 | Tol2 = Tol*Tol; |
c26b5a34 |
913 | // |
914 | Standard_Integer NCONTROL=23; |
4e57c75e |
915 | Standard_Integer i, aNC1=NCONTROL-1; |
916 | |
917 | Standard_Boolean aFlag=Standard_False; |
918 | Standard_Boolean proj = (!SameParameter || |
919 | First != Other.FirstParameter() || |
920 | Last != Other.LastParameter()); |
921 | // |
922 | // 1. |
923 | if (!proj) { |
924 | for (i = 0; i < NCONTROL; i++) { |
925 | Standard_Real prm = ((aNC1-i)*First + i*Last)/aNC1; |
926 | gp_Pnt pref = CRef.Value(prm); |
927 | gp_Pnt pother = Other.Value(prm); |
928 | |
929 | aD=pref.SquareDistance(pother); |
930 | |
931 | if (aD > Tol2) { |
932 | if (aD>MaxDistance) { |
933 | MaxDistance=aD; |
934 | } |
935 | aFlag=Standard_True; |
936 | } |
937 | } |
938 | |
939 | if (aFlag) { |
940 | aNewTolerance=sqrt(MaxDistance); |
941 | } |
942 | return aFlag; |
943 | } |
944 | |
945 | // |
946 | // 2. |
947 | else { |
948 | Extrema_LocateExtPC refd,otherd; |
949 | Standard_Real OFirst, OLast; |
950 | OFirst = Other.FirstParameter(); |
951 | OLast = Other.LastParameter(); |
952 | |
953 | gp_Pnt pd = CRef.Value(First); |
954 | gp_Pnt pdo = Other.Value(OFirst); |
955 | |
956 | aD = pd.SquareDistance(pdo); |
957 | if (aD > Tol2) { |
958 | if (aD>MaxDistance) { |
959 | MaxDistance=aD; |
960 | } |
961 | aFlag=Standard_True; |
962 | } |
963 | |
964 | pd = CRef.Value(Last); |
965 | pdo = Other.Value(OLast); |
966 | aD = pd.SquareDistance(pdo); |
967 | if (aD > Tol2 && aD > MaxDistance) { |
968 | MaxDistance=aD; |
969 | aFlag=Standard_True; |
970 | } |
971 | |
972 | refd.Initialize(CRef, First, Last, CRef.Resolution(Tol)); |
973 | otherd.Initialize(Other, OFirst, OLast, Other.Resolution(Tol)); |
974 | |
975 | for (i = 2; i< aNC1; i++) { |
976 | Standard_Real rprm = ((aNC1-i)*First + i*Last)/aNC1; |
977 | gp_Pnt pref = CRef.Value(rprm); |
978 | |
979 | Standard_Real oprm = ((aNC1-i)*OFirst + i*OLast)/aNC1; |
980 | gp_Pnt pother = Other.Value(oprm); |
981 | |
982 | refd.Perform(pother,rprm); |
983 | if (!refd.IsDone() || refd.SquareDistance() > Tol2) { |
984 | if (refd.IsDone()) { |
985 | aD=refd.SquareDistance(); |
986 | if (aD > Tol2 && aD>MaxDistance) { |
987 | aFlag=Standard_True; |
988 | MaxDistance=aD; |
989 | } |
990 | } |
991 | } |
992 | |
993 | otherd.Perform(pref,oprm); |
994 | if (!otherd.IsDone() || otherd.SquareDistance() > Tol2) { |
995 | |
996 | if (otherd.IsDone()) { |
997 | aD=otherd.SquareDistance(); |
998 | if (aD > Tol2 && aD>MaxDistance) { |
999 | aFlag=Standard_True; |
1000 | MaxDistance=aD; |
1001 | } |
1002 | } |
1003 | } |
1004 | } |
1005 | } |
1006 | |
1007 | aD=sqrt (MaxDistance); |
1008 | aNewTolerance=aD; |
4e57c75e |
1009 | return aFlag; |
4e57c75e |
1010 | } |
1011 | //======================================================================= |
1012 | // Function : UpdateEdges |
1013 | // purpose : |
1014 | //======================================================================= |
c26b5a34 |
1015 | void UpdateEdges(const TopoDS_Face& aF) |
4e57c75e |
1016 | { |
1017 | Standard_Real aTolF, aTolE, aTolV; |
1018 | TopoDS_Iterator aItF, aItW, aItE; |
1019 | BRep_Builder aBB; |
1020 | // |
c26b5a34 |
1021 | aTolE=aTolF= BRep_Tool::Tolerance(aF); |
4e57c75e |
1022 | aItF.Initialize(aF); |
1023 | for (; aItF.More(); aItF.Next()) { |
1024 | const TopoDS_Shape& aS = aItF.Value(); |
1025 | if (aS.ShapeType()==TopAbs_WIRE) { |
1026 | aItW.Initialize(aS); |
1027 | for (; aItW.More(); aItW.Next()) { |
c26b5a34 |
1028 | const TopoDS_Edge& aE=*((TopoDS_Edge*)&aItW.Value()); |
4e57c75e |
1029 | aTolE = BRep_Tool::Tolerance(aE); |
1030 | if (aTolE < aTolF) { |
1031 | aBB.UpdateEdge(aE, aTolF); |
1032 | aTolE = aTolF; |
1033 | } |
c26b5a34 |
1034 | //UpdateVertices(aE); |
4e57c75e |
1035 | } |
1036 | } |
1037 | else { |
c26b5a34 |
1038 | const TopoDS_Vertex& aV=*(TopoDS_Vertex*)&aItF.Value(); |
4e57c75e |
1039 | aTolV = BRep_Tool::Tolerance(aV); |
1040 | if (aTolV < aTolE) { |
1041 | aBB.UpdateVertex(aV, aTolF); |
1042 | } |
1043 | } |
1044 | } |
1045 | } |
e98e3990 |
1046 | //======================================================================= |
1047 | // Function : ComputeTolerance |
1048 | // purpose : |
1049 | //======================================================================= |
1050 | Standard_Boolean BOPTools_AlgoTools::ComputeTolerance |
1051 | (const TopoDS_Face& theFace, |
1052 | const TopoDS_Edge& theEdge, |
1053 | Standard_Real& theMaxDist, |
1b7ae951 |
1054 | Standard_Real& theMaxPar) |
e98e3990 |
1055 | { |
1b7ae951 |
1056 | BRepLib_CheckCurveOnSurface aCS; |
e98e3990 |
1057 | // |
1b7ae951 |
1058 | aCS.Init(theEdge, theFace); |
1059 | aCS.Perform(); |
1060 | if (!aCS.IsDone()) { |
1061 | return Standard_False; |
e98e3990 |
1062 | } |
1063 | // |
1b7ae951 |
1064 | theMaxDist = aCS.MaxDistance(); |
1065 | theMaxPar = aCS.MaxParameter(); |
c7b59798 |
1066 | // |
1b7ae951 |
1067 | return Standard_True; |
e98e3990 |
1068 | } |