7fbca1d7e15658886f151d67fa913a6a7dd4b1d0
[occt.git] / src / IntTools / IntTools_EdgeEdge_1.cxx
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 //
41 #include <BRep_Tool.hxx>
42 #include <BRepAdaptor_Curve.hxx>
43
44 //=======================================================================
45 //class    : IntTools_ComparatorCurve
46 //purpose  : 
47 //=======================================================================
48 class IntTools_ComparatorCurve {
49  public: 
50   IntTools_ComparatorCurve() {
51     myT11=0.;
52     myT12=0.;
53     myT21=0.;
54     myT22=0.;
55     myIsSame=Standard_False;
56   };
57   //
58   virtual ~IntTools_ComparatorCurve(){
59   }; 
60   //
61   void SetCurve1(const BRepAdaptor_Curve& aBC3D) {
62     myBC1=aBC3D;
63   };
64   //
65   const BRepAdaptor_Curve& Curve1()const {
66     return myBC1;
67   };
68   //
69   void SetRange1(const Standard_Real aT1,
70                  const Standard_Real aT2) {
71     myT11=aT1;
72     myT12=aT2;
73   };
74   //
75   void Range1(Standard_Real& aT1, Standard_Real& aT2)const {
76     aT1=myT11;
77     aT2=myT12;
78   };
79   //
80   void SetCurve2(const BRepAdaptor_Curve& aBC3D){
81     myBC2=aBC3D;
82   };
83   //
84   const BRepAdaptor_Curve& Curve2()const{
85     return myBC2;
86   };
87   //
88   void SetRange2(const Standard_Real aT1,
89                  const Standard_Real aT2){
90     myT21=aT1;
91     myT22=aT2;
92   };
93   //
94   void Range2(Standard_Real& aT1, 
95               Standard_Real& aT2)const {
96     aT1=myT21;
97     aT2=myT22;
98   };
99   //
100   Standard_Boolean IsSame()const {
101     return myIsSame;
102   }; 
103   //
104   void Perform();
105   //
106   //--------------------------------------
107  protected:
108   //
109   void IsSameElipse();
110   //
111   void IsSameBSplineCurve();
112   //
113   static 
114     Standard_Boolean 
115       IsSameReal(const Standard_Real aR1, 
116                  const Standard_Real aR2);
117   //
118   static
119     Standard_Boolean 
120       IsSameAx2(const gp_Ax2& aAx21, 
121                 const gp_Ax2& aAx22);
122   //
123   static
124     Standard_Boolean
125       IsSameAx1(const gp_Ax1& aAx1, 
126                 const gp_Ax1& aAx2);
127   //
128   static
129     Standard_Boolean 
130       IsSamePnt(const gp_Pnt& aP1, 
131                 const gp_Pnt& aP2);
132   static
133     Standard_Boolean 
134       IsSameDir(const gp_Dir& aDir1, 
135                 const gp_Dir& aDir2);
136   //
137   static
138     Standard_Boolean 
139       IsSameXYZ(const gp_XYZ& aXYZ1, 
140                 const gp_XYZ& aXYZ2);
141   //
142   static
143     void GetCurveBase(const Handle(Geom_Curve)& aC3D,
144                       GeomAbs_CurveType& aTypeBase,
145                       Handle(Geom_Curve)& aCurveBase);
146   //
147   static
148     Standard_Boolean 
149       IsTypeBase(const Handle(Geom_Curve)& aC,
150                  GeomAbs_CurveType& aTypeB);
151   //
152  protected:
153   BRepAdaptor_Curve myBC1;
154   Standard_Real myT11;
155   Standard_Real myT12;
156   //
157   BRepAdaptor_Curve myBC2;
158   Standard_Real myT21;
159   Standard_Real myT22;
160   //
161   Standard_Boolean myIsSame;
162 };
163 //=======================================================================
164 //function : Perform
165 //purpose  : 
166 //=======================================================================
167 void IntTools_ComparatorCurve::Perform()
168 {
169   GeomAbs_CurveType aCurveType1, aCurveType2;
170   //
171   myIsSame=Standard_False;
172   //
173   aCurveType1=myBC1.GetType();
174   aCurveType2=myBC2.GetType();
175   //
176   myIsSame=(aCurveType1==aCurveType2);
177   if (!myIsSame) {
178     return; 
179   }
180   // 
181   myIsSame=IsSameReal(myT11, myT21);
182   if (!myIsSame) {
183     return;
184   }
185   //
186   myIsSame=IsSameReal(myT12, myT22);
187   if (!myIsSame) {
188     return;
189   }
190   //
191   if (aCurveType1==GeomAbs_Ellipse) {
192     IsSameElipse();
193     return;
194   } 
195   else if (aCurveType1==GeomAbs_BSplineCurve) {
196     IsSameBSplineCurve();
197     return ;
198   }
199   else {
200     myIsSame=Standard_False;
201     return;
202   }
203 }
204 //=======================================================================
205 //function : IsSameBSplineCurve
206 //purpose  : 
207 //=======================================================================
208 void IntTools_ComparatorCurve::IsSameBSplineCurve()
209 {
210   Standard_Boolean bIsRational, bIsPreiodic;
211   Standard_Integer iNbPoles, iNbKnots, iDegree;
212   //
213   bIsRational=myBC1.IsRational();
214   myIsSame=(bIsRational==myBC2.IsRational());
215   if (!myIsSame) {
216     return;
217   }
218   //
219   iNbPoles=myBC1.NbPoles();
220   myIsSame=(iNbPoles==myBC2.NbPoles());
221   if (!myIsSame) {
222     return;
223   }
224   //
225   iNbKnots=myBC1.NbKnots();
226   myIsSame=(iNbKnots==myBC2.NbKnots());
227   if (!myIsSame) {
228     return;
229   }
230   //
231   iDegree=myBC1.Degree();
232   myIsSame=(iDegree==myBC2.Degree());
233   if (!myIsSame) {
234     return;
235   } 
236   //
237   bIsPreiodic=myBC1.IsPeriodic();
238   myIsSame=(bIsPreiodic==myBC2.IsPeriodic());
239   if (!myIsSame) {
240     return;
241   }
242  
243   //-------------------------------------------
244   Standard_Integer i, j, aM[2];
245   Standard_Real aT1, aT2, aX0[4], aX1[4];
246   GeomAbs_CurveType aTypeBase;
247   gp_Pnt aP;
248   Handle(Geom_Curve) aC;
249   Handle(Geom_BSplineCurve) aBSp[2];
250   TopoDS_Edge aE1, aE2;
251   //
252   aE1=myBC1.Edge();
253   aE2=myBC2.Edge();
254   //
255   aC=BRep_Tool::Curve (aE1, aT1, aT2);
256   GetCurveBase(aC, aTypeBase, aBSp[0]);
257   //
258   aC=BRep_Tool::Curve (aE2, aT1, aT2);
259   GetCurveBase(aC, aTypeBase, aBSp[1]);
260   //
261   // Poles / Weights
262   for(i=1; i<=iNbPoles; ++i) {
263     aP=aBSp[0]->Pole(i);
264     aP.Coord(aX0[0], aX0[1], aX0[2]);
265     aX0[3]=aBSp[0]->Weight(i);
266     //
267     aP=aBSp[1]->Pole(i);
268     aP.Coord(aX1[0], aX1[1], aX1[2]);
269     aX1[3]=aBSp[1]->Weight(i);
270     //
271     for (j=0; j<4; ++j) {
272       myIsSame=IsSameReal(aX0[j], aX1[j]);
273       if(!myIsSame) {
274         return;
275       }
276     }
277   }//for(i=1; i<iNbPoles; ++i) {
278   //
279   // Knots / Multiplicities
280   for(i=1; i<=iNbKnots; ++i) {
281     aX0[0]=aBSp[0]->Knot(i);
282     aX0[1]=aBSp[1]->Knot(i);
283     myIsSame=IsSameReal(aX0[0], aX0[1]);
284     if(!myIsSame) {
285       return;
286     }
287     //
288     aM[0]=aBSp[0]->Multiplicity(i);
289     aM[1]=aBSp[1]->Multiplicity(i);
290     myIsSame=(aM[0]==aM[1]);
291     if(!myIsSame) {
292       return;
293     }
294   }
295 }
296 //=======================================================================
297 //function : GetCurveBase
298 //purpose  : 
299 //=======================================================================
300 void IntTools_ComparatorCurve::GetCurveBase(const Handle(Geom_Curve)& aC3D,
301                                             GeomAbs_CurveType& aTypeBase,
302                                             Handle(Geom_Curve)& aCurveBase)
303 {
304   Standard_Boolean bIsTypeBase;
305   Standard_Integer  iTrimmed, iOffset;
306   Standard_Real aOffsetBase;
307   GeomAbs_CurveType aTypeB;
308   Handle(Geom_Curve) aC3DB;
309   Handle(Geom_TrimmedCurve) aCT3D;
310   Handle(Geom_OffsetCurve) aCF3D;
311   //
312   aTypeBase=GeomAbs_OtherCurve;
313   aOffsetBase=0.;
314   //
315   aC3DB=aC3D;
316   bIsTypeBase=IsTypeBase(aC3DB, aTypeB);
317   if (bIsTypeBase) {
318     aTypeBase=aTypeB;
319     aCurveBase=aC3D;
320     return;
321   }
322   //
323   while(1) {
324     iTrimmed=0;
325     iOffset=0;
326     aCT3D=Handle(Geom_TrimmedCurve)::DownCast(aC3DB);
327     if (!aCT3D.IsNull()) {
328       aC3DB=aCT3D->BasisCurve();
329       ++iTrimmed;
330     }
331     //
332     aCF3D=Handle(Geom_OffsetCurve)::DownCast(aC3DB);
333     if (!aCF3D.IsNull()) {
334       Standard_Real aOffset;
335       //
336       aOffset=aCF3D->Offset();
337       aOffsetBase=aOffsetBase+aOffset;
338       //
339       aC3DB=aCF3D->BasisCurve();
340       ++iOffset;
341     }
342     //
343     if (!(iTrimmed || iOffset)) {
344       break;
345     }
346     //
347     bIsTypeBase=IsTypeBase(aC3DB, aTypeB);
348     if (bIsTypeBase) {
349       aTypeBase=aTypeB;
350       aCurveBase=aC3DB;
351       return;
352     }
353   }
354 }
355 //=======================================================================
356 //function : IsTypeBase
357 //purpose  : 
358 //=======================================================================
359 Standard_Boolean 
360   IntTools_ComparatorCurve::IsTypeBase(const Handle(Geom_Curve)& aC,
361                                        GeomAbs_CurveType& aTypeB)
362 {
363   Standard_Boolean bRet; 
364   Handle(Standard_Type) aType;
365   //
366   bRet=Standard_True;
367   //
368   aType=aC->DynamicType();
369   if (aType==STANDARD_TYPE(Geom_Line)) {
370     aTypeB=GeomAbs_Line;
371   }
372   else if (aType==STANDARD_TYPE(Geom_Circle)) {
373     aTypeB=GeomAbs_Circle;
374   }
375   else if (aType==STANDARD_TYPE(Geom_Ellipse)) {
376     aTypeB=GeomAbs_Ellipse;
377   }
378   else if (aType==STANDARD_TYPE(Geom_Parabola)) {
379     aTypeB=GeomAbs_Parabola;
380   }
381   else if (aType==STANDARD_TYPE(Geom_Hyperbola)) {
382     aTypeB=GeomAbs_Hyperbola;
383   }
384   else if (aType==STANDARD_TYPE(Geom_BezierCurve)) {
385     aTypeB=GeomAbs_BezierCurve;
386   }
387   else if (aType==STANDARD_TYPE(Geom_BSplineCurve)) {
388     aTypeB=GeomAbs_BSplineCurve;
389   }
390   else {
391     aTypeB=GeomAbs_OtherCurve;
392     bRet=!bRet;
393   }
394   return bRet;
395 }
396 //=======================================================================
397 //function : IsSameElipse
398 //purpose  : 
399 //=======================================================================
400 void IntTools_ComparatorCurve::IsSameElipse()
401 {
402   Standard_Real aR1, aR2;
403   gp_Elips aElips1, aElips2;
404   // 
405   myIsSame=Standard_False;
406   //
407   aElips1=myBC1.Ellipse();
408   aElips2=myBC2.Ellipse();
409   //
410   aR1=aElips1.MajorRadius();
411   aR2=aElips2.MajorRadius();
412   myIsSame=IsSameReal(aR1, aR2);
413   if (!myIsSame) {
414     return;
415   }
416   //
417   aR1=aElips1.MinorRadius();
418   aR2=aElips2.MinorRadius();
419   myIsSame=IsSameReal(aR1, aR2);
420   if (!myIsSame) {
421     return;
422   }
423   //
424   const gp_Ax2& aAx21=aElips1.Position();
425   const gp_Ax2& aAx22=aElips2.Position();
426   myIsSame=IsSameAx2(aAx21, aAx22);
427 }
428 //=======================================================================
429 //function : IsSameAx2
430 //purpose  : 
431 //=======================================================================
432 Standard_Boolean 
433   IntTools_ComparatorCurve::IsSameAx2(const gp_Ax2& aAx21, 
434                                       const gp_Ax2& aAx22)
435 {
436   Standard_Boolean bRet;
437   //
438   const gp_Ax1& aAx1=aAx21.Axis();
439   const gp_Ax1& aAx2=aAx22.Axis();
440   //
441   bRet=IsSameAx1(aAx1, aAx2);
442   if (!bRet) {
443     return bRet;
444   }
445   //
446   const gp_Dir& aDirX1=aAx21.XDirection();
447   const gp_Dir& aDirX2=aAx22.XDirection();
448   //
449   bRet=IsSameDir(aDirX1, aDirX2);
450   if (!bRet) {
451     return bRet;
452   }
453   //
454   //
455   const gp_Dir& aDirY1=aAx21.YDirection();
456   const gp_Dir& aDirY2=aAx22.YDirection();
457   //
458   bRet=IsSameDir(aDirY1, aDirY2);
459   //
460   return bRet;
461 }
462 //=======================================================================
463 //function : IsSamePnt
464 //purpose  : 
465 //=======================================================================
466 Standard_Boolean 
467   IntTools_ComparatorCurve::IsSamePnt(const gp_Pnt& aP1, 
468                                       const gp_Pnt& aP2)
469 {
470   const gp_XYZ& aXYZ1=aP1.XYZ();
471   const gp_XYZ& aXYZ2=aP2.XYZ();
472   return IsSameXYZ(aXYZ1, aXYZ2);
473 }
474 //=======================================================================
475 //function : IsSameAx1
476 //purpose  : 
477 //=======================================================================
478 Standard_Boolean 
479   IntTools_ComparatorCurve::IsSameAx1(const gp_Ax1& aAx1, 
480                                       const gp_Ax1& aAx2)
481 {
482   Standard_Boolean bRet;
483   //
484   const gp_Pnt& aP1=aAx1.Location();
485   const gp_Pnt& aP2=aAx2.Location();
486   //
487   bRet=IsSamePnt(aP1, aP2);
488   if (!bRet) {
489     return bRet;
490   }
491   //
492   const gp_Dir& aDir1=aAx1.Direction();
493   const gp_Dir& aDir2=aAx2.Direction();
494   //
495   bRet=IsSameDir(aDir1, aDir2);
496   return bRet;
497 }
498 //=======================================================================
499 //function : IsSameDir
500 //purpose  : 
501 //=======================================================================
502 Standard_Boolean 
503   IntTools_ComparatorCurve::IsSameDir(const gp_Dir& aDir1, 
504                                       const gp_Dir& aDir2)
505 {
506   const gp_XYZ& aXYZ1=aDir1.XYZ();
507   const gp_XYZ& aXYZ2=aDir2.XYZ();
508   return IsSameXYZ(aXYZ1, aXYZ2);
509 }
510 //=======================================================================
511 //function : IsSameXYZ
512 //purpose  : 
513 //=======================================================================
514 Standard_Boolean 
515   IntTools_ComparatorCurve::IsSameXYZ(const gp_XYZ& aXYZ1, 
516                                       const gp_XYZ& aXYZ2)
517 {
518   Standard_Boolean bRet;
519   Standard_Integer i;
520   Standard_Real aX1[3], aX2[3];
521   
522   aXYZ1.Coord(aX1[0], aX1[1], aX1[2]);
523   aXYZ2.Coord(aX2[0], aX2[1], aX2[2]);
524   //
525   for (i=0; i<3; ++i) {
526     bRet=IsSameReal(aX1[i], aX2[i]);
527     if(!bRet) {
528       break;
529     }
530   }
531   return bRet;
532 }
533 //=======================================================================
534 //function : IsSameReal
535 //purpose  : 
536 //=======================================================================
537 Standard_Boolean 
538   IntTools_ComparatorCurve::IsSameReal(const Standard_Real aR1, 
539                                        const Standard_Real aR2)
540 {
541   Standard_Boolean bRet;
542   Standard_Real aEpsilon;
543   //
544   aEpsilon=Epsilon(aR1);
545   bRet=(fabs(aR1-aR2)<aEpsilon);
546   return bRet;
547 }
548 //=======================================================================
549 //function : IsSameCurves
550 //purpose  : 
551 //=======================================================================
552 Standard_Boolean IntTools_EdgeEdge::IsSameCurves()
553 {
554   Standard_Boolean bRet;
555   IntTools_ComparatorCurve aICC;
556   //
557   aICC.SetCurve1(myCFrom);
558   aICC.SetRange1(myTminFrom, myTmaxFrom);
559   //
560   aICC.SetCurve2(myCTo);
561   aICC.SetRange2(myTminTo, myTmaxTo);
562   //
563   aICC.Perform();
564   bRet=aICC.IsSame();
565   //
566   return bRet;
567 }