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 <GeomAPI_ProjectPointOnCurve.hxx>
  42 //
  43 #include <BRep_Tool.hxx>
  44
  45
  46 //=======================================================================
  47 //class    : IntTools_ComparatorCurve
  48 //purpose  :
  49 //=======================================================================
  50 class 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 };
 165 //
 166 //=======================================================================
 167 //function : Perform
 168 //purpose  :
 169 //=======================================================================
 170 void 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 //=======================================================================
 211 void 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 //=======================================================================
 303 void 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   for(;;) {
 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 //=======================================================================
 362 Standard_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 //=======================================================================
 403 void 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 //=======================================================================
 435 Standard_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 //=======================================================================
 469 Standard_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 //=======================================================================
 481 Standard_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 //=======================================================================
 505 Standard_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 //=======================================================================
 517 Standard_Boolean
 518   IntTools_ComparatorCurve::IsSameXYZ(const gp_XYZ& aXYZ1,
 519                                       const gp_XYZ& aXYZ2)
 520 {
 521   Standard_Boolean bRet = Standard_False;
 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 //=======================================================================
 540 Standard_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 }
 551 //
 552 //modified by NIZNHY-PKV Tue Jan 15 07:44:33 2013f
 553 //=======================================================================
 554 // class: IntTools_DistCC
 555 // purpose  :
 556 //=======================================================================
 557 class 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 //=======================================================================
 680 void 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 //=======================================================================
 700 void 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 //=======================================================================
 719 void 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 //=======================================================================
 767 void 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   for(;;) {
 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 //=======================================================================
 837 Standard_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 //
 865 //=======================================================================
 866 //function : IsSameCurves
 867 //purpose  :
 868 //=======================================================================
 869 Standard_Boolean IntTools_EdgeEdge::IsSameCurves()
 870 {
 871   Standard_Boolean bRet, bIsBC;
 872   GeomAbs_CurveType aCT1, aCT2;
 873   IntTools_ComparatorCurve aICC;
 874   //
 875   // 1. Check letter
 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();
 884   if (bRet) {
 885     return bRet;
 886   }
 887   //
 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   }
 921   return bRet;
 922 }
 923