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