projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0023704: The program hang-up during intersection of two edges.
[occt.git] / src / IntTools / IntTools_EdgeEdge_1.cxx
CommitLineData
e145f8c1 1// Created on: 2012-11-29
2// Created by: Peter KURNEV
3// Copyright (c) 2012 OPEN CASCADE SAS
4//
5// The content of this file is subject to the Open CASCADE Technology Public
6// License Version 6.5 (the "License"). You may not use the content of this file
7// except in compliance with the License. Please obtain a copy of the License
8// at http://www.opencascade.org and read it completely before using this file.
9//
10// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12//
13// The Original Code and all software distributed under the License is
14// distributed on an "AS IS" basis, without warranty of any kind, and the
15// Initial Developer hereby disclaims all such warranties, including without
16// limitation, any warranties of merchantability, fitness for a particular
17// purpose or non-infringement. Please see the License for the specific terms
18// and conditions governing the rights and limitations under the License.
19
20
21#include <IntTools_EdgeEdge.ixx>
22
23#include <gp_Elips.hxx>
24#include <gp_Ax1.hxx>
25#include <gp_Dir.hxx>
26#include <gp_XYZ.hxx>
27#include <gp_Ax2.hxx>
28#include <gp_Pnt.hxx>
29//
30#include <Geom_Curve.hxx>
31#include <Geom_Line.hxx>
32#include <Geom_Circle.hxx>
33#include <Geom_Ellipse.hxx>
34#include <Geom_Parabola.hxx>
35#include <Geom_Hyperbola.hxx>
36#include <Geom_BezierCurve.hxx>
37#include <Geom_BSplineCurve.hxx>
38#include <Geom_TrimmedCurve.hxx>
39#include <Geom_OffsetCurve.hxx>
40//
b3fb2d64 41#include <GeomAPI_ProjectPointOnCurve.hxx>
42//
e145f8c1 43#include <BRep_Tool.hxx>
b3fb2d64 44
e145f8c1 45
46//=======================================================================
47//class : IntTools_ComparatorCurve
48//purpose :
49//=======================================================================
50class IntTools_ComparatorCurve {
51 public:
52 IntTools_ComparatorCurve() {
53 myT11=0.;
54 myT12=0.;
55 myT21=0.;
56 myT22=0.;
57 myIsSame=Standard_False;
58 };
59 //
60 virtual ~IntTools_ComparatorCurve(){
61 };
62 //
63 void SetCurve1(const BRepAdaptor_Curve& aBC3D) {
64 myBC1=aBC3D;
65 };
66 //
67 const BRepAdaptor_Curve& Curve1()const {
68 return myBC1;
69 };
70 //
71 void SetRange1(const Standard_Real aT1,
72 const Standard_Real aT2) {
73 myT11=aT1;
74 myT12=aT2;
75 };
76 //
77 void Range1(Standard_Real& aT1, Standard_Real& aT2)const {
78 aT1=myT11;
79 aT2=myT12;
80 };
81 //
82 void SetCurve2(const BRepAdaptor_Curve& aBC3D){
83 myBC2=aBC3D;
84 };
85 //
86 const BRepAdaptor_Curve& Curve2()const{
87 return myBC2;
88 };
89 //
90 void SetRange2(const Standard_Real aT1,
91 const Standard_Real aT2){
92 myT21=aT1;
93 myT22=aT2;
94 };
95 //
96 void Range2(Standard_Real& aT1,
97 Standard_Real& aT2)const {
98 aT1=myT21;
99 aT2=myT22;
100 };
101 //
102 Standard_Boolean IsSame()const {
103 return myIsSame;
104 };
105 //
106 void Perform();
107 //
108 //--------------------------------------
109 protected:
110 //
111 void IsSameElipse();
112 //
113 void IsSameBSplineCurve();
114 //
115 static
116 Standard_Boolean
117 IsSameReal(const Standard_Real aR1,
118 const Standard_Real aR2);
119 //
120 static
121 Standard_Boolean
122 IsSameAx2(const gp_Ax2& aAx21,
123 const gp_Ax2& aAx22);
124 //
125 static
126 Standard_Boolean
127 IsSameAx1(const gp_Ax1& aAx1,
128 const gp_Ax1& aAx2);
129 //
130 static
131 Standard_Boolean
132 IsSamePnt(const gp_Pnt& aP1,
133 const gp_Pnt& aP2);
134 static
135 Standard_Boolean
136 IsSameDir(const gp_Dir& aDir1,
137 const gp_Dir& aDir2);
138 //
139 static
140 Standard_Boolean
141 IsSameXYZ(const gp_XYZ& aXYZ1,
142 const gp_XYZ& aXYZ2);
143 //
144 static
145 void GetCurveBase(const Handle(Geom_Curve)& aC3D,
146 GeomAbs_CurveType& aTypeBase,
147 Handle(Geom_Curve)& aCurveBase);
148 //
149 static
150 Standard_Boolean
151 IsTypeBase(const Handle(Geom_Curve)& aC,
152 GeomAbs_CurveType& aTypeB);
153 //
154 protected:
155 BRepAdaptor_Curve myBC1;
156 Standard_Real myT11;
157 Standard_Real myT12;
158 //
159 BRepAdaptor_Curve myBC2;
160 Standard_Real myT21;
161 Standard_Real myT22;
162 //
163 Standard_Boolean myIsSame;
164};
b3fb2d64 165//
e145f8c1 166//=======================================================================
167//function : Perform
168//purpose :
169//=======================================================================
170void IntTools_ComparatorCurve::Perform()
171{
172 GeomAbs_CurveType aCurveType1, aCurveType2;
173 //
174 myIsSame=Standard_False;
175 //
176 aCurveType1=myBC1.GetType();
177 aCurveType2=myBC2.GetType();
178 //
179 myIsSame=(aCurveType1==aCurveType2);
180 if (!myIsSame) {
181 return;
182 }
183 //
184 myIsSame=IsSameReal(myT11, myT21);
185 if (!myIsSame) {
186 return;
187 }
188 //
189 myIsSame=IsSameReal(myT12, myT22);
190 if (!myIsSame) {
191 return;
192 }
193 //
194 if (aCurveType1==GeomAbs_Ellipse) {
195 IsSameElipse();
196 return;
197 }
198 else if (aCurveType1==GeomAbs_BSplineCurve) {
199 IsSameBSplineCurve();
200 return ;
201 }
202 else {
203 myIsSame=Standard_False;
204 return;
205 }
206}
207//=======================================================================
208//function : IsSameBSplineCurve
209//purpose :
210//=======================================================================
211void IntTools_ComparatorCurve::IsSameBSplineCurve()
212{
213 Standard_Boolean bIsRational, bIsPreiodic;
214 Standard_Integer iNbPoles, iNbKnots, iDegree;
215 //
216 bIsRational=myBC1.IsRational();
217 myIsSame=(bIsRational==myBC2.IsRational());
218 if (!myIsSame) {
219 return;
220 }
221 //
222 iNbPoles=myBC1.NbPoles();
223 myIsSame=(iNbPoles==myBC2.NbPoles());
224 if (!myIsSame) {
225 return;
226 }
227 //
228 iNbKnots=myBC1.NbKnots();
229 myIsSame=(iNbKnots==myBC2.NbKnots());
230 if (!myIsSame) {
231 return;
232 }
233 //
234 iDegree=myBC1.Degree();
235 myIsSame=(iDegree==myBC2.Degree());
236 if (!myIsSame) {
237 return;
238 }
239 //
240 bIsPreiodic=myBC1.IsPeriodic();
241 myIsSame=(bIsPreiodic==myBC2.IsPeriodic());
242 if (!myIsSame) {
243 return;
244 }
245
246 //-------------------------------------------
247 Standard_Integer i, j, aM[2];
248 Standard_Real aT1, aT2, aX0[4], aX1[4];
249 GeomAbs_CurveType aTypeBase;
250 gp_Pnt aP;
251 Handle(Geom_Curve) aC;
252 Handle(Geom_BSplineCurve) aBSp[2];
253 TopoDS_Edge aE1, aE2;
254 //
255 aE1=myBC1.Edge();
256 aE2=myBC2.Edge();
257 //
258 aC=BRep_Tool::Curve (aE1, aT1, aT2);
259 GetCurveBase(aC, aTypeBase, aBSp[0]);
260 //
261 aC=BRep_Tool::Curve (aE2, aT1, aT2);
262 GetCurveBase(aC, aTypeBase, aBSp[1]);
263 //
264 // Poles / Weights
265 for(i=1; i<=iNbPoles; ++i) {
266 aP=aBSp[0]->Pole(i);
267 aP.Coord(aX0[0], aX0[1], aX0[2]);
268 aX0[3]=aBSp[0]->Weight(i);
269 //
270 aP=aBSp[1]->Pole(i);
271 aP.Coord(aX1[0], aX1[1], aX1[2]);
272 aX1[3]=aBSp[1]->Weight(i);
273 //
274 for (j=0; j<4; ++j) {
275 myIsSame=IsSameReal(aX0[j], aX1[j]);
276 if(!myIsSame) {
277 return;
278 }
279 }
280 }//for(i=1; i<iNbPoles; ++i) {
281 //
282 // Knots / Multiplicities
283 for(i=1; i<=iNbKnots; ++i) {
284 aX0[0]=aBSp[0]->Knot(i);
285 aX0[1]=aBSp[1]->Knot(i);
286 myIsSame=IsSameReal(aX0[0], aX0[1]);
287 if(!myIsSame) {
288 return;
289 }
290 //
291 aM[0]=aBSp[0]->Multiplicity(i);
292 aM[1]=aBSp[1]->Multiplicity(i);
293 myIsSame=(aM[0]==aM[1]);
294 if(!myIsSame) {
295 return;
296 }
297 }
298}
299//=======================================================================
300//function : GetCurveBase
301//purpose :
302//=======================================================================
303void IntTools_ComparatorCurve::GetCurveBase(const Handle(Geom_Curve)& aC3D,
304 GeomAbs_CurveType& aTypeBase,
305 Handle(Geom_Curve)& aCurveBase)
306{
307 Standard_Boolean bIsTypeBase;
308 Standard_Integer iTrimmed, iOffset;
309 Standard_Real aOffsetBase;
310 GeomAbs_CurveType aTypeB;
311 Handle(Geom_Curve) aC3DB;
312 Handle(Geom_TrimmedCurve) aCT3D;
313 Handle(Geom_OffsetCurve) aCF3D;
314 //
315 aTypeBase=GeomAbs_OtherCurve;
316 aOffsetBase=0.;
317 //
318 aC3DB=aC3D;
319 bIsTypeBase=IsTypeBase(aC3DB, aTypeB);
320 if (bIsTypeBase) {
321 aTypeBase=aTypeB;
322 aCurveBase=aC3D;
323 return;
324 }
325 //
326 while(1) {
327 iTrimmed=0;
328 iOffset=0;
329 aCT3D=Handle(Geom_TrimmedCurve)::DownCast(aC3DB);
330 if (!aCT3D.IsNull()) {
331 aC3DB=aCT3D->BasisCurve();
332 ++iTrimmed;
333 }
334 //
335 aCF3D=Handle(Geom_OffsetCurve)::DownCast(aC3DB);
336 if (!aCF3D.IsNull()) {
337 Standard_Real aOffset;
338 //
339 aOffset=aCF3D->Offset();
340 aOffsetBase=aOffsetBase+aOffset;
341 //
342 aC3DB=aCF3D->BasisCurve();
343 ++iOffset;
344 }
345 //
346 if (!(iTrimmed || iOffset)) {
347 break;
348 }
349 //
350 bIsTypeBase=IsTypeBase(aC3DB, aTypeB);
351 if (bIsTypeBase) {
352 aTypeBase=aTypeB;
353 aCurveBase=aC3DB;
354 return;
355 }
356 }
357}
358//=======================================================================
359//function : IsTypeBase
360//purpose :
361//=======================================================================
362Standard_Boolean
363 IntTools_ComparatorCurve::IsTypeBase(const Handle(Geom_Curve)& aC,
364 GeomAbs_CurveType& aTypeB)
365{
366 Standard_Boolean bRet;
367 Handle(Standard_Type) aType;
368 //
369 bRet=Standard_True;
370 //
371 aType=aC->DynamicType();
372 if (aType==STANDARD_TYPE(Geom_Line)) {
373 aTypeB=GeomAbs_Line;
374 }
375 else if (aType==STANDARD_TYPE(Geom_Circle)) {
376 aTypeB=GeomAbs_Circle;
377 }
378 else if (aType==STANDARD_TYPE(Geom_Ellipse)) {
379 aTypeB=GeomAbs_Ellipse;
380 }
381 else if (aType==STANDARD_TYPE(Geom_Parabola)) {
382 aTypeB=GeomAbs_Parabola;
383 }
384 else if (aType==STANDARD_TYPE(Geom_Hyperbola)) {
385 aTypeB=GeomAbs_Hyperbola;
386 }
387 else if (aType==STANDARD_TYPE(Geom_BezierCurve)) {
388 aTypeB=GeomAbs_BezierCurve;
389 }
390 else if (aType==STANDARD_TYPE(Geom_BSplineCurve)) {
391 aTypeB=GeomAbs_BSplineCurve;
392 }
393 else {
394 aTypeB=GeomAbs_OtherCurve;
395 bRet=!bRet;
396 }
397 return bRet;
398}
399//=======================================================================
400//function : IsSameElipse
401//purpose :
402//=======================================================================
403void IntTools_ComparatorCurve::IsSameElipse()
404{
405 Standard_Real aR1, aR2;
406 gp_Elips aElips1, aElips2;
407 //
408 myIsSame=Standard_False;
409 //
410 aElips1=myBC1.Ellipse();
411 aElips2=myBC2.Ellipse();
412 //
413 aR1=aElips1.MajorRadius();
414 aR2=aElips2.MajorRadius();
415 myIsSame=IsSameReal(aR1, aR2);
416 if (!myIsSame) {
417 return;
418 }
419 //
420 aR1=aElips1.MinorRadius();
421 aR2=aElips2.MinorRadius();
422 myIsSame=IsSameReal(aR1, aR2);
423 if (!myIsSame) {
424 return;
425 }
426 //
427 const gp_Ax2& aAx21=aElips1.Position();
428 const gp_Ax2& aAx22=aElips2.Position();
429 myIsSame=IsSameAx2(aAx21, aAx22);
430}
431//=======================================================================
432//function : IsSameAx2
433//purpose :
434//=======================================================================
435Standard_Boolean
436 IntTools_ComparatorCurve::IsSameAx2(const gp_Ax2& aAx21,
437 const gp_Ax2& aAx22)
438{
439 Standard_Boolean bRet;
440 //
441 const gp_Ax1& aAx1=aAx21.Axis();
442 const gp_Ax1& aAx2=aAx22.Axis();
443 //
444 bRet=IsSameAx1(aAx1, aAx2);
445 if (!bRet) {
446 return bRet;
447 }
448 //
449 const gp_Dir& aDirX1=aAx21.XDirection();
450 const gp_Dir& aDirX2=aAx22.XDirection();
451 //
452 bRet=IsSameDir(aDirX1, aDirX2);
453 if (!bRet) {
454 return bRet;
455 }
456 //
457 //
458 const gp_Dir& aDirY1=aAx21.YDirection();
459 const gp_Dir& aDirY2=aAx22.YDirection();
460 //
461 bRet=IsSameDir(aDirY1, aDirY2);
462 //
463 return bRet;
464}
465//=======================================================================
466//function : IsSamePnt
467//purpose :
468//=======================================================================
469Standard_Boolean
470 IntTools_ComparatorCurve::IsSamePnt(const gp_Pnt& aP1,
471 const gp_Pnt& aP2)
472{
473 const gp_XYZ& aXYZ1=aP1.XYZ();
474 const gp_XYZ& aXYZ2=aP2.XYZ();
475 return IsSameXYZ(aXYZ1, aXYZ2);
476}
477//=======================================================================
478//function : IsSameAx1
479//purpose :
480//=======================================================================
481Standard_Boolean
482 IntTools_ComparatorCurve::IsSameAx1(const gp_Ax1& aAx1,
483 const gp_Ax1& aAx2)
484{
485 Standard_Boolean bRet;
486 //
487 const gp_Pnt& aP1=aAx1.Location();
488 const gp_Pnt& aP2=aAx2.Location();
489 //
490 bRet=IsSamePnt(aP1, aP2);
491 if (!bRet) {
492 return bRet;
493 }
494 //
495 const gp_Dir& aDir1=aAx1.Direction();
496 const gp_Dir& aDir2=aAx2.Direction();
497 //
498 bRet=IsSameDir(aDir1, aDir2);
499 return bRet;
500}
501//=======================================================================
502//function : IsSameDir
503//purpose :
504//=======================================================================
505Standard_Boolean
506 IntTools_ComparatorCurve::IsSameDir(const gp_Dir& aDir1,
507 const gp_Dir& aDir2)
508{
509 const gp_XYZ& aXYZ1=aDir1.XYZ();
510 const gp_XYZ& aXYZ2=aDir2.XYZ();
511 return IsSameXYZ(aXYZ1, aXYZ2);
512}
513//=======================================================================
514//function : IsSameXYZ
515//purpose :
516//=======================================================================
517Standard_Boolean
518 IntTools_ComparatorCurve::IsSameXYZ(const gp_XYZ& aXYZ1,
519 const gp_XYZ& aXYZ2)
520{
521 Standard_Boolean bRet;
522 Standard_Integer i;
523 Standard_Real aX1[3], aX2[3];
524
525 aXYZ1.Coord(aX1[0], aX1[1], aX1[2]);
526 aXYZ2.Coord(aX2[0], aX2[1], aX2[2]);
527 //
528 for (i=0; i<3; ++i) {
529 bRet=IsSameReal(aX1[i], aX2[i]);
530 if(!bRet) {
531 break;
532 }
533 }
534 return bRet;
535}
536//=======================================================================
537//function : IsSameReal
538//purpose :
539//=======================================================================
540Standard_Boolean
541 IntTools_ComparatorCurve::IsSameReal(const Standard_Real aR1,
542 const Standard_Real aR2)
543{
544 Standard_Boolean bRet;
545 Standard_Real aEpsilon;
546 //
547 aEpsilon=Epsilon(aR1);
548 bRet=(fabs(aR1-aR2)<aEpsilon);
549 return bRet;
550}
b3fb2d64 551//
552//modified by NIZNHY-PKV Tue Jan 15 07:44:33 2013f
553//=======================================================================
554// class: IntTools_DistCC
555// purpose :
556//=======================================================================
557class IntTools_DistCC {
558 public:
559 IntTools_DistCC() {
560 myT11=0.;
561 myT12=0.;
562 myT21=0.;
563 myT21=0.;
564 myErrorStatus=1;
565 myThreshold=1.e-7;
566 myDx=0.;
567 myTx=0.;
568 myNbP=10;
569 myIndent=0.3;
570 myEps=0.001;
571 };
572 //
573 ~IntTools_DistCC() {
574 };
575 //-------- 1
576 void SetCurve1(const Handle(Geom_Curve)& aC1) {
577 myC1=aC1;
578 };
579 //
580 const Handle(Geom_Curve)& Curve1()const {
581 return myC1;
582 };
583 //
584 void SetRange1(const Standard_Real aT11,
585 const Standard_Real aT12) {
586 myT11=aT11;
587 myT12=aT12;
588 };
589 //
590 void Range1(Standard_Real& aT11,
591 Standard_Real& aT12)const {
592 aT11=myT11;
593 aT12=myT12;
594 };
595 //-------- 2
596 void SetCurve2(const Handle(Geom_Curve)& aC2) {
597 myC2=aC2;
598 };
599 //
600 const Handle(Geom_Curve)& Curve2()const {
601 return myC2;
602 };
603 //
604 void SetRange2(const Standard_Real aT21,
605 const Standard_Real aT22) {
606 myT21=aT21;
607 myT22=aT22;
608 };
609 //
610 void Range2(Standard_Real& aT21,
611 Standard_Real& aT22)const {
612 aT21=myT21;
613 aT22=myT22;
614 };
615 //
616 void SetThreshold(const Standard_Real aD) {
617 myThreshold=aD;
618 }
619 //
620 Standard_Real Threshold() const {
621 return myThreshold;
622 }
623 //
624 void Perform();
625 //
626 Standard_Integer ErrorStatus()const {
627 return myErrorStatus;
628 };
629 //
630 Standard_Real MaxDeviation()const {
631 return myDx;
632 }
633 //
634 Standard_Real MaxParameter()const {
635 return myTx;
636 }
637 //-----------------------------------------------------
638 protected :
639 //
640 void Init();
641 //
642 void CheckData();
643 //
644 Standard_Real Distance(const Standard_Real aT);
645 //
646 void FindMaxDeviation();
647 //
648 void FindMaxLocal (const Standard_Real aT11,
649 const Standard_Real aT12,
650 const Standard_Real aEps,
651 Standard_Real& aDx,
652 Standard_Real& aTx);
653
654 //
655 protected :
656 Standard_Real myT11;
657 Standard_Real myT12;
658 Handle(Geom_Curve) myC1;
659
660 Standard_Real myT21;
661 Standard_Real myT22;
662 Handle(Geom_Curve) myC2;
663 //
664 Standard_Real myThreshold;
665 Standard_Integer myErrorStatus;
666 //
667 Standard_Real myDx;
668 Standard_Real myTx;
669 //
670 Standard_Integer myNbP;
671 Standard_Real myIndent;
672 Standard_Real myEps;
673 GeomAPI_ProjectPointOnCurve myPPC2;
674};
675
676//=======================================================================
677//function : Perform
678//purpose :
679//=======================================================================
680void IntTools_DistCC::Perform()
681{
682 myErrorStatus=0;
683 //
684 CheckData();
685 if (myErrorStatus){
686 return;
687 }
688 // Init
689 myPPC2.Init(myC2, myT21, myT22);
690 //
691 FindMaxDeviation();
692 if (myErrorStatus){
693 return;
694 }
695}
696//=======================================================================
697//function : CheckData
698//purpose :
699//=======================================================================
700void IntTools_DistCC::CheckData()
701{
702 myErrorStatus=0;
703 //
704 if (myC1.IsNull()) {
705 myErrorStatus=2;
706 return;
707 }
708 //
709 if (myC2.IsNull()) {
710 myErrorStatus=3;
711 return;
712 }
713}
714//
715//=======================================================================
716//function : FindMaxDeviation
717//purpose :
718//=======================================================================
719void IntTools_DistCC::FindMaxDeviation()
720{
721 Standard_Integer i, aNbP1, aNbP2;
722 Standard_Real aTmax, aT, aT1, aT2, dT, aDmax, aEps, aD;
723 //
724 myErrorStatus=0;
725 myDx=0.;
726 myTx=0.;
727 //
728 aTmax=0;
729 aDmax=0.;
730 aEps=myEps*(myT12-myT11);
731 //
732 aNbP1=myNbP-1;
733 aNbP2=aNbP1-1;
734 dT=(myT12-myT11)/aNbP1;
735 for (i=0; i<aNbP1; ++i) {
736 aT1=myT11+i*dT;
737 aT2=aT1+dT;
738 //
739 if (!i) {
740 aT1=aT1+myIndent*dT;
741 }
742 else if (i==aNbP2) {
743 aT2=aT2-myIndent*dT;
744 if (aT2>myT12) {
745 aT2=myT12;
746 }
747 }
748 //
749 FindMaxLocal(aT1, aT2, aEps, aD, aT);
750 if (myErrorStatus) {
751 return ;
752 }
753 //
754 if (aD>aDmax) {
755 aDmax=aD;
756 aTmax=aT;
757 }
758 }
759 //
760 myTx=aTmax;
761 myDx=aDmax;
762}
763//=======================================================================
764//function : FindMaxLocal
765//purpose : Solver: Golden Mean
766//=======================================================================
767void IntTools_DistCC::FindMaxLocal(const Standard_Real aT11,
768 const Standard_Real aT12,
769 const Standard_Real aEps,
770 Standard_Real& aDx,
771 Standard_Real& aTx)
772{
773 Standard_Integer iErr;
774 Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
775 //
776 myErrorStatus=0;
777 iErr=0;
778 aDx=0.;
779 aTx=0.;
780 //
781 aCf=1.6180339887498948482045868343656;// =0.5*(1.+sqrt(5.));
782 //
783 aA=aT11;
784 aB=aT12;
785 //
786 aX1=aB-(aB-aA)/aCf;
787 aF1=Distance(aX1);
788 if (myErrorStatus) {
789 return ;
790 }
791 //
792 aX2=aA+(aB-aA)/aCf;
793 aF2=Distance(aX2);
794 if (myErrorStatus) {
795 return;
796 }
797 //
798 while(1) {
799 if (fabs(aA-aB)<aEps) {
800 aX=0.5*(aA+aB);
801 aF=Distance(aX);
802 if (myErrorStatus) {
803 return;
804 }
805 //
806 break;
807 }
808 if (aF1<aF2){
809 aA=aX1;
810 aX1=aX2;
811 aF1=aF2;
812 aX2=aA+(aB-aA)/aCf;
813 aF2=Distance(aX2);
814 if (myErrorStatus) {
815 return ;
816 }
817 }
818 else {
819 aB=aX2;
820 aX2=aX1;
821 aF2=aF1;
822 aX1=aB-(aB-aA)/aCf;
823 aF1=Distance(aX1);
824 if (myErrorStatus) {
825 return;
826 }
827 }
828 }
829 //
830 aDx=aF;
831 aTx=aX;
832}
833//=======================================================================
834//function : Distance
835//purpose :
836//=======================================================================
837Standard_Real IntTools_DistCC::Distance(const Standard_Real aT)
838{
839 Standard_Integer aNbP2;
840 Standard_Real aD;
841 gp_Pnt aP1;
842 //
843 aD=0.;
844 if (myErrorStatus) {
845 return aD;
846 }
847 //
848 myC1->D0(aT, aP1);
849 myPPC2.Perform(aP1);
850 //
851 aNbP2=myPPC2.NbPoints();
852 if (!aNbP2) {
853 myErrorStatus=4;
854 return aD;
855 }
856 //
857 aD=myPPC2.LowerDistance();
858 if (aD>myThreshold) {
859 myErrorStatus=10;
860 }
861 return aD;
862}
863//modified by NIZNHY-PKV Tue Jan 15 07:44:44 2013t
864//
e145f8c1 865//=======================================================================
866//function : IsSameCurves
867//purpose :
868//=======================================================================
869Standard_Boolean IntTools_EdgeEdge::IsSameCurves()
870{
b3fb2d64 871 Standard_Boolean bRet, bIsBC;
872 GeomAbs_CurveType aCT1, aCT2;
e145f8c1 873 IntTools_ComparatorCurve aICC;
874 //
b3fb2d64 875 // 1. Check letter
e145f8c1 876 aICC.SetCurve1(myCFrom);
877 aICC.SetRange1(myTminFrom, myTmaxFrom);
878 //
879 aICC.SetCurve2(myCTo);
880 aICC.SetRange2(myTminTo, myTmaxTo);
881 //
882 aICC.Perform();
883 bRet=aICC.IsSame();
b3fb2d64 884 if (bRet) {
885 return bRet;
886 }
e145f8c1 887 //
b3fb2d64 888 // 2. Check inwards
889 aCT1=myCFrom.GetType();
890 aCT2=myCTo.GetType();
891 bIsBC=(aCT1==GeomAbs_BSplineCurve ||
892 aCT1==GeomAbs_BezierCurve ||
893 aCT2==GeomAbs_BSplineCurve ||
894 aCT2==GeomAbs_BezierCurve);
895 //
896 if (bIsBC) {
897 Standard_Integer iErr;
898 Standard_Real aT11, aT12, aT21, aT22;
899 Handle(Geom_Curve) aC1, aC2;
900 IntTools_DistCC aDistCC;
901 //
902 const TopoDS_Edge& aE1=myCFrom.Edge();
903 aC1=BRep_Tool::Curve(aE1, aT11, aT12);
904 //
905 const TopoDS_Edge& aE2=myCTo.Edge();
906 aC2=BRep_Tool::Curve(aE2, aT21, aT22);
907 //
908 aDistCC.SetCurve1(aC1);
909 aDistCC.SetRange1(myTminFrom, myTmaxFrom);
910 aDistCC.SetCurve2(aC2);
911 aDistCC.SetRange2(myTminTo, myTmaxTo);
912 aDistCC.SetThreshold(myCriteria);
913 //
914 aDistCC.Perform();
915 //
916 iErr=aDistCC.ErrorStatus();
917 //
918 bRet=(!iErr);
919 //
920 }
e145f8c1 921 return bRet;
922}
b3fb2d64 923
Open CASCADE Technology repository