src/BOPInt/BOPInt_Context.cxx

   1 // Created by: Peter KURNEV
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and / or modify it
   7 // under the terms of the GNU Lesser General Public version 2.1 as published
   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.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 #include <BOPInt_Context.ixx>
  16
  17 #include <Precision.hxx>
  18
  19 #include <Geom_Curve.hxx>
  20 #include <Geom_BoundedCurve.hxx>
  21 #include <GeomAPI_ProjectPointOnCurve.hxx>
  22 #include <GeomAPI_ProjectPointOnSurf.hxx>
  23 #include <GeomAdaptor_Curve.hxx>
  24
  25 #include <Geom2dHatch_Intersector.hxx>
  26 #include <Geom2d_TrimmedCurve.hxx>
  27
  28 #include <TopAbs_State.hxx>
  29 #include <TopoDS.hxx>
  30 #include <TopExp_Explorer.hxx>
  31
  32 #include <BRep_Tool.hxx>
  33 #include <BRepAdaptor_Surface.hxx>
  34
  35 #include <IntTools_Tools.hxx>
  36 #include <IntTools_FClass2d.hxx>
  37 //
  38 #include <Extrema_LocateExtPC.hxx>
  39
  40 #include <Geom2d_Curve.hxx>
  41 #include <NCollection_IncAllocator.hxx>
  42 #include <IntTools_SurfaceRangeLocalizeData.hxx>
  43
  44
  45 //=======================================================================
  46 //function :
  47 //purpose  :
  48 //=======================================================================
  49   BOPInt_Context::BOPInt_Context()
  50 :
  51   myAllocator(new NCollection_IncAllocator()),
  52   myFClass2dMap(100, myAllocator),
  53   myProjPSMap(100, myAllocator),
  54   myProjPCMap(100, myAllocator),
  55   mySClassMap(100, myAllocator),
  56   myProjPTMap(100, myAllocator),
  57   myHatcherMap(100, myAllocator),
  58   myProjSDataMap(100, myAllocator),
  59   myCreateFlag(0)
  60 {
  61 }
  62 //=======================================================================
  63 //function :
  64 //purpose  :
  65 //=======================================================================
  66   BOPInt_Context::BOPInt_Context(const Handle(NCollection_BaseAllocator)& theAllocator)
  67 :
  68   myAllocator(theAllocator),
  69   myFClass2dMap(100, myAllocator),
  70   myProjPSMap(100, myAllocator),
  71   myProjPCMap(100, myAllocator),
  72   mySClassMap(100, myAllocator),
  73   myProjPTMap(100, myAllocator),
  74   myHatcherMap(100, myAllocator),
  75   myProjSDataMap(100, myAllocator),
  76   myCreateFlag(1)
  77 {
  78 }
  79 //=======================================================================
  80 //function : ~
  81 //purpose  :
  82 //=======================================================================
  83   BOPInt_Context::~BOPInt_Context()
  84 {
  85   Standard_Address anAdr;
  86   BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt;
  87   BOPCol_DataMapIteratorOfDataMapOfTransientAddress aIt1;
  88   //
  89   IntTools_FClass2d* pFClass2d;
  90   //
  91   aIt.Initialize(myFClass2dMap);
  92   for (; aIt.More(); aIt.Next()) {
  93     anAdr=aIt.Value();
  94     pFClass2d=(IntTools_FClass2d*)anAdr;
  95     (*pFClass2d).~IntTools_FClass2d();
  96     myAllocator->Free(anAdr);
  97   }
  98   myFClass2dMap.Clear();
  99   //
 100   GeomAPI_ProjectPointOnSurf* pProjPS;
 101   aIt.Initialize(myProjPSMap);
 102   for (; aIt.More(); aIt.Next()) {
 103     anAdr=aIt.Value();
 104     pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
 105     (*pProjPS).~GeomAPI_ProjectPointOnSurf();
 106     myAllocator->Free(anAdr);
 107   }
 108   myProjPSMap.Clear();
 109   //
 110   GeomAPI_ProjectPointOnCurve* pProjPC;
 111   aIt.Initialize(myProjPCMap);
 112   for (; aIt.More(); aIt.Next()) {
 113     anAdr=aIt.Value();
 114     pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
 115     (*pProjPC).~GeomAPI_ProjectPointOnCurve();
 116     myAllocator->Free(anAdr);
 117   }
 118   myProjPCMap.Clear();
 119   //
 120   //
 121   BRepClass3d_SolidClassifier* pSC;
 122   aIt.Initialize(mySClassMap);
 123   for (; aIt.More(); aIt.Next()) {
 124     anAdr=aIt.Value();
 125     pSC=(BRepClass3d_SolidClassifier*)anAdr;
 126     (*pSC).~BRepClass3d_SolidClassifier();
 127     myAllocator->Free(anAdr);
 128   }
 129   mySClassMap.Clear();
 130   //
 131   GeomAPI_ProjectPointOnCurve* pProjPT;
 132   aIt1.Initialize(myProjPTMap);
 133   for (; aIt1.More(); aIt1.Next()) {
 134     anAdr=aIt1.Value();
 135     pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
 136     (*pProjPT).~GeomAPI_ProjectPointOnCurve();
 137     myAllocator->Free(anAdr);
 138   }
 139   myProjPTMap.Clear();
 140   //
 141   Geom2dHatch_Hatcher* pHatcher;
 142   aIt.Initialize(myHatcherMap);
 143   for (; aIt.More(); aIt.Next()) {
 144     anAdr=aIt.Value();
 145     pHatcher=(Geom2dHatch_Hatcher*)anAdr;
 146     (*pHatcher).~Geom2dHatch_Hatcher();
 147     myAllocator->Free(anAdr);
 148   }
 149   myHatcherMap.Clear();
 150   //
 151   IntTools_SurfaceRangeLocalizeData* pSData = NULL;
 152   aIt.Initialize(myProjSDataMap);
 153   for (; aIt.More(); aIt.Next()) {
 154     anAdr=aIt.Value();
 155     pSData = (IntTools_SurfaceRangeLocalizeData*)anAdr;
 156     (*pSData).~IntTools_SurfaceRangeLocalizeData();
 157     myAllocator->Free(anAdr);
 158   }
 159   myProjSDataMap.Clear();
 160 }
 161 //=======================================================================
 162 //function : FClass2d
 163 //purpose  :
 164 //=======================================================================
 165   IntTools_FClass2d& BOPInt_Context::FClass2d(const TopoDS_Face& aF)
 166 {
 167   Standard_Address anAdr;
 168   IntTools_FClass2d* pFClass2d;
 169   //
 170   if (!myFClass2dMap.IsBound(aF)) {
 171     Standard_Real aTolF;
 172     TopoDS_Face aFF;
 173     //
 174     aFF=aF;
 175     aFF.Orientation(TopAbs_FORWARD);
 176     aTolF=BRep_Tool::Tolerance(aFF);
 177     //
 178     pFClass2d=(IntTools_FClass2d*)myAllocator->Allocate(sizeof(IntTools_FClass2d));
 179     new (pFClass2d) IntTools_FClass2d(aFF, aTolF);
 180     //
 181     anAdr=(Standard_Address)pFClass2d;
 182     myFClass2dMap.Bind(aFF, anAdr);
 183   }
 184   else {
 185     anAdr=myFClass2dMap.Find(aF);
 186     pFClass2d=(IntTools_FClass2d*)anAdr;
 187   }
 188   return *pFClass2d;
 189 }
 190 //=======================================================================
 191 //function : ProjPS
 192 //purpose  :
 193 //=======================================================================
 194   GeomAPI_ProjectPointOnSurf& BOPInt_Context::ProjPS(const TopoDS_Face& aF)
 195 {
 196   Standard_Address anAdr;
 197   GeomAPI_ProjectPointOnSurf* pProjPS;
 198
 199   if (!myProjPSMap.IsBound(aF)) {
 200     Standard_Real Umin, Usup, Vmin, Vsup, anEpsT=1.e-12 ;
 201     BRepAdaptor_Surface aBAS;
 202     //
 203     const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF);
 204     aBAS.Initialize (aF, Standard_True);
 205     //
 206     Umin=aBAS.FirstUParameter();
 207     Usup=aBAS.LastUParameter ();
 208     Vmin=aBAS.FirstVParameter();
 209     Vsup=aBAS.LastVParameter ();
 210     //
 211     pProjPS=(GeomAPI_ProjectPointOnSurf*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnSurf));
 212     new (pProjPS) GeomAPI_ProjectPointOnSurf();
 213     pProjPS->Init(aS ,Umin, Usup, Vmin, Vsup, anEpsT/*, Extrema_ExtAlgo_Tree*/);
 214     Extrema_ExtPS& anExtAlgo = const_cast<Extrema_ExtPS&>(pProjPS->Extrema());
 215     anExtAlgo.SetFlag(Extrema_ExtFlag_MIN);
 216     //
 217     anAdr=(Standard_Address)pProjPS;
 218     myProjPSMap.Bind(aF, anAdr);
 219   }
 220
 221   else {
 222     anAdr=myProjPSMap.Find(aF);
 223     pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
 224   }
 225   return *pProjPS;
 226 }
 227 //=======================================================================
 228 //function : ProjPC
 229 //purpose  :
 230 //=======================================================================
 231   GeomAPI_ProjectPointOnCurve& BOPInt_Context::ProjPC(const TopoDS_Edge& aE)
 232 {
 233   Standard_Address anAdr;
 234   GeomAPI_ProjectPointOnCurve* pProjPC;
 235
 236   if (!myProjPCMap.IsBound(aE)) {
 237     Standard_Real f, l;
 238     //
 239     Handle(Geom_Curve)aC3D=BRep_Tool::Curve (aE, f, l);
 240     //
 241     pProjPC=(GeomAPI_ProjectPointOnCurve*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnCurve));
 242     new (pProjPC) GeomAPI_ProjectPointOnCurve();
 243     pProjPC->Init(aC3D, f, l);
 244     //
 245     anAdr=(Standard_Address)pProjPC;
 246     myProjPCMap.Bind(aE, anAdr);
 247   }
 248
 249   else {
 250     anAdr=myProjPCMap.Find(aE);
 251     pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
 252   }
 253   return *pProjPC;
 254 }
 255
 256 //=======================================================================
 257 //function : ProjPT
 258 //purpose  :
 259 //=======================================================================
 260   GeomAPI_ProjectPointOnCurve& BOPInt_Context::ProjPT(const Handle(Geom_Curve)& aC3D)
 261
 262 {
 263   Standard_Address anAdr;
 264   GeomAPI_ProjectPointOnCurve* pProjPT;
 265
 266   if (!myProjPTMap.IsBound(aC3D)) {
 267     Standard_Real f, l;
 268     f=aC3D->FirstParameter();
 269     l=aC3D->LastParameter();
 270     //
 271     pProjPT=(GeomAPI_ProjectPointOnCurve*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnCurve));
 272     new (pProjPT) GeomAPI_ProjectPointOnCurve();
 273     pProjPT->Init(aC3D, f, l);
 274     //
 275     anAdr=(Standard_Address)pProjPT;
 276     myProjPTMap.Bind(aC3D, anAdr);
 277   }
 278
 279   else {
 280     anAdr=myProjPTMap.Find(aC3D);
 281     pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
 282   }
 283   return *pProjPT;
 284 }
 285 //=======================================================================
 286 //function : SolidClassifier
 287 //purpose  :
 288 //=======================================================================
 289   BRepClass3d_SolidClassifier& BOPInt_Context::SolidClassifier(const TopoDS_Solid& aSolid)
 290 {
 291   Standard_Address anAdr;
 292   BRepClass3d_SolidClassifier* pSC;
 293
 294   if (!mySClassMap.IsBound(aSolid)) {
 295     //
 296     pSC=(BRepClass3d_SolidClassifier*)myAllocator->Allocate(sizeof(BRepClass3d_SolidClassifier));
 297     new (pSC) BRepClass3d_SolidClassifier(aSolid);
 298     //
 299     anAdr=(Standard_Address)pSC;
 300     mySClassMap.Bind(aSolid, anAdr);
 301   }
 302
 303   else {
 304     anAdr=mySClassMap.Find(aSolid);
 305     pSC =(BRepClass3d_SolidClassifier*)anAdr;
 306   }
 307   return *pSC;
 308 }
 309
 310 //=======================================================================
 311 //function : Hatcher
 312 //purpose  :
 313 //=======================================================================
 314   Geom2dHatch_Hatcher& BOPInt_Context::Hatcher(const TopoDS_Face& aF)
 315 {
 316   Standard_Address anAdr;
 317   Geom2dHatch_Hatcher* pHatcher;
 318   //
 319   if (!myHatcherMap.IsBound(aF)) {
 320     Standard_Real aTolArcIntr, aTolTangfIntr, aTolHatch2D, aTolHatch3D;
 321     Standard_Real aU1, aU2, aEpsT;
 322     TopAbs_Orientation aOrE;
 323     Handle(Geom_Surface) aS;
 324     Handle(Geom2d_Curve) aC2D;
 325     Handle(Geom2d_TrimmedCurve) aCT2D;
 326     TopoDS_Face aFF;
 327     TopExp_Explorer aExp;
 328     //
 329     aTolHatch2D=1.e-8;
 330     aTolHatch3D=1.e-8;
 331     aTolArcIntr=1.e-10;
 332     aTolTangfIntr=1.e-10;
 333     aEpsT=Precision::PConfusion();
 334     //
 335     Geom2dHatch_Intersector aIntr(aTolArcIntr, aTolTangfIntr);
 336     pHatcher=new Geom2dHatch_Hatcher(aIntr,
 337                                      aTolHatch2D, aTolHatch3D,
 338                                      Standard_True, Standard_False);
 339
 340     //
 341     aFF=aF;
 342     aFF.Orientation(TopAbs_FORWARD);
 343     aS=BRep_Tool::Surface(aFF);
 344
 345     aExp.Init (aFF, TopAbs_EDGE);
 346     for (; aExp.More() ; aExp.Next()) {
 347       const TopoDS_Edge& aE=*((TopoDS_Edge*)&aExp.Current());
 348       aOrE=aE.Orientation();
 349       //
 350       aC2D=BRep_Tool::CurveOnSurface (aE, aFF, aU1, aU2);
 351       if (aC2D.IsNull() ) {
 352         continue;
 353       }
 354       if (fabs(aU1-aU2) < aEpsT) {
 355         continue;
 356       }
 357       //
 358       aCT2D=new Geom2d_TrimmedCurve(aC2D, aU1, aU2);
 359       pHatcher->AddElement(aCT2D, aOrE);
 360     }// for (; aExp.More() ; aExp.Next()) {
 361     //
 362     anAdr=(Standard_Address)pHatcher;
 363     myHatcherMap.Bind(aFF, anAdr);
 364   }//if (!myHatcherMap.IsBound(aF)) {
 365   //
 366   else {
 367     anAdr=myHatcherMap.Find(aF);
 368     pHatcher=(Geom2dHatch_Hatcher*)anAdr;
 369   }
 370
 371   return *pHatcher;
 372 }
 373
 374 //=======================================================================
 375 //function : SurfaceData
 376 //purpose  :
 377 //=======================================================================
 378   IntTools_SurfaceRangeLocalizeData& BOPInt_Context::SurfaceData(const TopoDS_Face& aF)
 379 {
 380   Standard_Address anAdr;
 381   IntTools_SurfaceRangeLocalizeData* pSData;
 382   //
 383   if (!myProjSDataMap.IsBound(aF)) {
 384     pSData=new IntTools_SurfaceRangeLocalizeData(3,
 385                                                  3,
 386                                                  10. * Precision::PConfusion(),
 387                                                  10. * Precision::PConfusion());
 388     //
 389     anAdr=(Standard_Address)pSData;
 390     myProjSDataMap.Bind(aF, anAdr);
 391   }
 392
 393   else {
 394     anAdr=myProjSDataMap.Find(aF);
 395     pSData=(IntTools_SurfaceRangeLocalizeData*)anAdr;
 396   }
 397   return *pSData;
 398
 399 }
 400
 401 //=======================================================================
 402 //function : ComputePE
 403 //purpose  :
 404 //=======================================================================
 405   Standard_Integer BOPInt_Context::ComputePE(const gp_Pnt& aP1,
 406                                              const Standard_Real aTolP1,
 407                                              const TopoDS_Edge& aE2,
 408                                              Standard_Real& aT)
 409 {
 410   if (!BRep_Tool::IsGeometric(aE2)) {
 411     return -2;
 412   }
 413   Standard_Real aDist, aTolE2, aTolSum;
 414   Standard_Integer aNbProj;
 415   //
 416   GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(aE2);
 417   aProjector.Perform(aP1);
 418
 419   aNbProj=aProjector.NbPoints();
 420   if (!aNbProj) {
 421     return -3;
 422   }
 423   //
 424   aDist=aProjector.LowerDistance();
 425   //
 426   aTolE2=BRep_Tool::Tolerance(aE2);
 427   aTolSum=aTolP1+aTolE2;
 428   //
 429   aT=aProjector.LowerDistanceParameter();
 430   if (aDist > aTolSum) {
 431     return -4;
 432   }
 433   return 0;
 434 }
 435 //=======================================================================
 436 //function : ComputeVE
 437 //purpose  :
 438 //=======================================================================
 439   Standard_Integer BOPInt_Context::ComputeVE(const TopoDS_Vertex& aV1,
 440                                              const TopoDS_Edge&   aE2,
 441                                              Standard_Real& aT)
 442 {
 443   if (BRep_Tool::Degenerated(aE2)) {
 444     return -1;
 445   }
 446   if (!BRep_Tool::IsGeometric(aE2)) {
 447     return -2;
 448   }
 449   Standard_Real aDist, aTolV1, aTolE2, aTolSum;
 450   Standard_Integer aNbProj;
 451   gp_Pnt aP;
 452   //
 453   aP=BRep_Tool::Pnt(aV1);
 454   //
 455   GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(aE2);
 456   aProjector.Perform(aP);
 457
 458   aNbProj=aProjector.NbPoints();
 459   if (!aNbProj) {
 460     return -3;
 461   }
 462   //
 463   aDist=aProjector.LowerDistance();
 464
 465   // tolerance of check for coincidence is sum of tolerances of edge and vertex
 466   // extended by additional Precision::Confusion() to allow for interference where
 467   // it is very close but not fit to tolerance (see #24108)
 468   aTolV1=BRep_Tool::Tolerance(aV1);
 469   aTolE2=BRep_Tool::Tolerance(aE2);
 470   aTolSum = aTolV1 + aTolE2 + Precision::Confusion();
 471   //
 472   aT=aProjector.LowerDistanceParameter();
 473   if (aDist > aTolSum) {
 474     return -4;
 475   }
 476   return 0;
 477 }
 478 //=======================================================================
 479 //function : ComputeVS
 480 //purpose  :
 481 //=======================================================================
 482   Standard_Integer BOPInt_Context::ComputeVF(const TopoDS_Vertex& aV1,
 483                                              const TopoDS_Face&   aF2,
 484                                              Standard_Real& U,
 485                                              Standard_Real& V)
 486 {
 487   Standard_Real aTolV1, aTolF2, aTolSum, aDist;
 488   gp_Pnt aP;
 489
 490   aP=BRep_Tool::Pnt(aV1);
 491   //
 492   // 1. Check if the point is projectable on the surface
 493   GeomAPI_ProjectPointOnSurf& aProjector=ProjPS(aF2);
 494   aProjector.Perform(aP);
 495   //
 496   if (!aProjector.IsDone()) { // the point is not  projectable on the surface
 497     return -1;
 498   }
 499   //
 500   // 2. Check the distance between the projection point and
 501   //    the original point
 502   aDist=aProjector.LowerDistance();
 503
 504   aTolV1=BRep_Tool::Tolerance(aV1);
 505   aTolF2=BRep_Tool::Tolerance(aF2);
 506   aTolSum=aTolV1+aTolF2;
 507   if (aDist > aTolSum) {
 508     // the distance is too large
 509     return -2;
 510   }
 511   aProjector.LowerDistanceParameters(U, V);
 512   //
 513   gp_Pnt2d aP2d(U, V);
 514   Standard_Boolean pri=IsPointInFace (aF2, aP2d);
 515   if (!pri) {//  the point lays on the surface but out of the face
 516     return -3;
 517   }
 518   return 0;
 519 }
 520 //=======================================================================
 521 //function : StatePointFace
 522 //purpose  :
 523 //=======================================================================
 524   TopAbs_State BOPInt_Context::StatePointFace(const TopoDS_Face& aF,
 525                                               const gp_Pnt2d& aP2d)
 526 {
 527   TopAbs_State aState;
 528   IntTools_FClass2d& aClass2d=FClass2d(aF);
 529   aState=aClass2d.Perform(aP2d);
 530   return aState;
 531 }
 532 //=======================================================================
 533 //function : IsPointInFace
 534 //purpose  :
 535 //=======================================================================
 536   Standard_Boolean BOPInt_Context::IsPointInFace(const TopoDS_Face& aF,
 537                                                  const gp_Pnt2d& aP2d)
 538 {
 539   TopAbs_State aState=StatePointFace(aF, aP2d);
 540   if (aState==TopAbs_OUT || aState==TopAbs_ON) {
 541     return Standard_False;
 542   }
 543   return Standard_True;
 544 }
 545 //=======================================================================
 546 //function : IsPointInOnFace
 547 //purpose  :
 548 //=======================================================================
 549   Standard_Boolean BOPInt_Context::IsPointInOnFace(const TopoDS_Face& aF,
 550                                                    const gp_Pnt2d& aP2d)
 551 {
 552   TopAbs_State aState=StatePointFace(aF, aP2d);
 553   if (aState==TopAbs_OUT) {
 554     return Standard_False;
 555   }
 556   return Standard_True;
 557 }
 558 //=======================================================================
 559 //function : IsValidPointForFace
 560 //purpose  :
 561 //=======================================================================
 562   Standard_Boolean BOPInt_Context::IsValidPointForFace(const gp_Pnt& aP,
 563                                                        const TopoDS_Face& aF,
 564                                                        const Standard_Real aTol)
 565 {
 566   Standard_Boolean bFlag;
 567   Standard_Real Umin, U, V;
 568
 569   GeomAPI_ProjectPointOnSurf& aProjector=ProjPS(aF);
 570   aProjector.Perform(aP);
 571
 572   bFlag=aProjector.IsDone();
 573   if (bFlag) {
 574
 575     Umin=aProjector.LowerDistance();
 576     //if (Umin > 1.e-3) { // it was
 577     if (Umin > aTol) {
 578       return !bFlag;
 579     }
 580     //
 581     aProjector.LowerDistanceParameters(U, V);
 582     gp_Pnt2d aP2D(U, V);
 583     bFlag=IsPointInOnFace (aF, aP2D);
 584   }
 585   return bFlag;
 586 }
 587 //=======================================================================
 588 //function : IsValidPointForFaces
 589 //purpose  :
 590 //=======================================================================
 591   Standard_Boolean BOPInt_Context::IsValidPointForFaces (const gp_Pnt& aP,
 592                                                          const TopoDS_Face& aF1,
 593                                                          const TopoDS_Face& aF2,
 594                                                          const Standard_Real aTol)
 595 {
 596   Standard_Boolean bFlag1, bFlag2;
 597
 598   bFlag1=IsValidPointForFace(aP, aF1, aTol);
 599   if (!bFlag1) {
 600     return bFlag1;
 601   }
 602   bFlag2=IsValidPointForFace(aP, aF2, aTol);
 603   return  bFlag2;
 604 }
 605 //=======================================================================
 606 //function : IsValidBlockForFace
 607 //purpose  :
 608 //=======================================================================
 609   Standard_Boolean BOPInt_Context::IsValidBlockForFace (const Standard_Real aT1,
 610                                                         const Standard_Real aT2,
 611                                                         const IntTools_Curve& aC,
 612                                                         const TopoDS_Face& aF,
 613                                                         const Standard_Real aTol)
 614 {
 615   Standard_Boolean bFlag;
 616   Standard_Real aTInterm;
 617   gp_Pnt aPInterm;
 618
 619   aTInterm=IntTools_Tools::IntermediatePoint(aT1, aT2);
 620
 621   Handle(Geom_Curve) aC3D=aC.Curve();
 622   // point 3D
 623   aC3D->D0(aTInterm, aPInterm);
 624   //
 625   bFlag=IsValidPointForFace (aPInterm, aF, aTol);
 626   return bFlag;
 627 }
 628 //=======================================================================
 629 //function : IsValidBlockForFaces
 630 //purpose  :
 631 //=======================================================================
 632   Standard_Boolean BOPInt_Context::IsValidBlockForFaces (const Standard_Real aT1,
 633                                                          const Standard_Real aT2,
 634                                                          const IntTools_Curve& aC,
 635                                                          const TopoDS_Face& aF1,
 636                                                          const TopoDS_Face& aF2,
 637                                                          const Standard_Real aTol)
 638 {
 639   Standard_Boolean bFlag1, bFlag2;
 640   //
 641   Handle(Geom2d_Curve) aPC1 = aC.FirstCurve2d();
 642   Handle(Geom2d_Curve) aPC2 = aC.SecondCurve2d();
 643   if( !aPC1.IsNull() && !aPC2.IsNull() ) {
 644     Standard_Real aMidPar = IntTools_Tools::IntermediatePoint(aT1, aT2);
 645     gp_Pnt2d aPnt2D;
 646
 647
 648     aPC1->D0(aMidPar, aPnt2D);
 649     bFlag1 = IsPointInOnFace(aF1, aPnt2D);
 650
 651     if( !bFlag1 )
 652       return bFlag1;
 653
 654     aPC2->D0(aMidPar, aPnt2D);
 655     bFlag2 = IsPointInOnFace(aF2, aPnt2D);
 656     return bFlag2;
 657   }
 658   //
 659
 660   bFlag1=IsValidBlockForFace (aT1, aT2, aC, aF1, aTol);
 661   if (!bFlag1) {
 662     return bFlag1;
 663   }
 664   bFlag2=IsValidBlockForFace (aT1, aT2, aC, aF2, aTol);
 665   return bFlag2;
 666 }
 667 //=======================================================================
 668 //function : IsVertexOnLine
 669 //purpose  :
 670 //=======================================================================
 671   Standard_Boolean BOPInt_Context::IsVertexOnLine (const TopoDS_Vertex& aV,
 672                                                    const IntTools_Curve& aC,
 673                                                    const Standard_Real aTolC,
 674                                                    Standard_Real& aT)
 675 {
 676   Standard_Boolean bRet;
 677   Standard_Real aTolV;
 678   //
 679   aTolV=BRep_Tool::Tolerance(aV);
 680   bRet=BOPInt_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT);
 681   //
 682   return bRet;
 683 }
 684 //=======================================================================
 685 //function : IsVertexOnLine
 686 //purpose  :
 687 //=======================================================================
 688   Standard_Boolean BOPInt_Context::IsVertexOnLine (const TopoDS_Vertex& aV,
 689                                                    const Standard_Real aTolV,
 690                                                    const IntTools_Curve& aC,
 691                                                    const Standard_Real aTolC,
 692                                                    Standard_Real& aT)
 693 {
 694   Standard_Real aFirst, aLast, aDist, aTolSum;
 695   Standard_Integer aNbProj;
 696   gp_Pnt aPv;
 697
 698   aPv=BRep_Tool::Pnt(aV);
 699
 700   Handle(Geom_Curve) aC3D=aC.Curve();
 701
 702
 703   aTolSum=aTolV+aTolC;
 704   //
 705   GeomAdaptor_Curve aGAC(aC3D);
 706   GeomAbs_CurveType aType=aGAC.GetType();
 707   if (aType==GeomAbs_BSplineCurve ||
 708       aType==GeomAbs_BezierCurve) {
 709     aTolSum=2.*aTolSum;
 710     if (aTolSum<1.e-5) {
 711       aTolSum=1.e-5;
 712     }
 713   }
 714   else {
 715     aTolSum=2.*aTolSum;//xft
 716     if(aTolSum < 1.e-6)
 717       aTolSum = 1.e-6;
 718   }
 719   //
 720   aFirst=aC3D->FirstParameter();
 721   aLast =aC3D->LastParameter();
 722   //
 723   //Checking extermities first
 724   if (!Precision::IsInfinite(aFirst)) {
 725     gp_Pnt aPCFirst=aC3D->Value(aFirst);
 726     aDist=aPv.Distance(aPCFirst);
 727     if (aDist < aTolSum) {
 728       aT=aFirst;
 729       //
 730       if(aDist > aTolV) {
 731         Extrema_LocateExtPC anExt(aPv, aGAC, aFirst, 1.e-10);
 732
 733         if(anExt.IsDone()) {
 734           Extrema_POnCurv aPOncurve = anExt.Point();
 735           aT = aPOncurve.Parameter();
 736
 737           if((aT > (aLast + aFirst) * 0.5) ||
 738              (aPv.Distance(aPOncurve.Value()) > aTolSum) ||
 739              (aPCFirst.Distance(aPOncurve.Value()) < Precision::Confusion()))
 740             aT = aFirst;
 741         }
 742       }
 743       //
 744       return Standard_True;
 745     }
 746   }
 747   //
 748   //if (!Precision::IsInfinite(aFirst)) {
 749   if (!Precision::IsInfinite(aLast)) {
 750     gp_Pnt aPCLast=aC3D->Value(aLast);
 751     aDist=aPv.Distance(aPCLast);
 752     if (aDist < aTolSum) {
 753       aT=aLast;
 754       //
 755       if(aDist > aTolV) {
 756         Extrema_LocateExtPC anExt(aPv, aGAC, aLast, 1.e-10);
 757
 758         if(anExt.IsDone()) {
 759           Extrema_POnCurv aPOncurve = anExt.Point();
 760           aT = aPOncurve.Parameter();
 761
 762           if((aT < (aLast + aFirst) * 0.5) ||
 763              (aPv.Distance(aPOncurve.Value()) > aTolSum) ||
 764              (aPCLast.Distance(aPOncurve.Value()) < Precision::Confusion()))
 765             aT = aLast;
 766         }
 767       }
 768       //
 769       return Standard_True;
 770     }
 771   }
 772   //
 773   GeomAPI_ProjectPointOnCurve& aProjector=ProjPT(aC3D);
 774   aProjector.Perform(aPv);
 775
 776   aNbProj=aProjector.NbPoints();
 777   if (!aNbProj) {
 778     Handle(Geom_BoundedCurve) aBC=
 779       Handle(Geom_BoundedCurve)::DownCast(aC3D);
 780     if (!aBC.IsNull()) {
 781       gp_Pnt aPStart=aBC->StartPoint();
 782       gp_Pnt aPEnd  =aBC->EndPoint();
 783
 784       aDist=aPv.Distance(aPStart);
 785       if (aDist < aTolSum) {
 786         aT=aFirst;
 787         return Standard_True;
 788       }
 789
 790       aDist=aPv.Distance(aPEnd);
 791       if (aDist < aTolSum) {
 792         aT=aLast;
 793         return Standard_True;
 794       }
 795     }
 796
 797     return Standard_False;
 798   }
 799
 800   aDist=aProjector.LowerDistance();
 801
 802   if (aDist > aTolSum) {
 803     return Standard_False;
 804   }
 805
 806   aT=aProjector.LowerDistanceParameter();
 807
 808   return Standard_True;
 809 }
 810 //=======================================================================
 811 //function : ProjectPointOnEdge
 812 //purpose  :
 813 //=======================================================================
 814   Standard_Boolean BOPInt_Context::ProjectPointOnEdge(const gp_Pnt& aP,
 815                                                       const TopoDS_Edge& anEdge,
 816                                                       Standard_Real& aT)
 817 {
 818   Standard_Integer aNbPoints;
 819
 820   GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(anEdge);
 821   aProjector.Perform(aP);
 822
 823   aNbPoints=aProjector.NbPoints();
 824   if (aNbPoints) {
 825     aT=aProjector.LowerDistanceParameter();
 826     return Standard_True;
 827   }
 828   return Standard_False;
 829 }
 830