projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0026506: Change class BRepLib_CheckCurveOnSurface
[occt.git] / src / IntTools / IntTools_Context.cxx
CommitLineData
b311480e 1// Created by: Peter KURNEV
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
b311480e 5//
d5f74e42 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
973c2be1 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.
b311480e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
7fd59977 14
7fd59977 15
42cf5bc1 16#include <Bnd_Box.hxx>
7fd59977 17#include <BRep_Tool.hxx>
18#include <BRepAdaptor_Surface.hxx>
f47b8d2b 19#include <BRepBndLib.hxx>
42cf5bc1 20#include <BRepClass3d_SolidClassifier.hxx>
7fd59977 21#include <Extrema_LocateExtPC.hxx>
7fd59977 22#include <Geom2d_Curve.hxx>
42cf5bc1 23#include <Geom2d_TrimmedCurve.hxx>
24#include <Geom2dHatch_Hatcher.hxx>
25#include <Geom2dHatch_Intersector.hxx>
26#include <Geom_BoundedCurve.hxx>
27#include <Geom_Curve.hxx>
28#include <GeomAdaptor_Curve.hxx>
29#include <GeomAPI_ProjectPointOnCurve.hxx>
30#include <GeomAPI_ProjectPointOnSurf.hxx>
31#include <gp_Pnt.hxx>
32#include <gp_Pnt2d.hxx>
33#include <IntTools_Context.hxx>
34#include <IntTools_Curve.hxx>
35#include <IntTools_FClass2d.hxx>
4e57c75e 36#include <IntTools_SurfaceRangeLocalizeData.hxx>
42cf5bc1 37#include <IntTools_Tools.hxx>
38#include <NCollection_IncAllocator.hxx>
39#include <Precision.hxx>
40#include <Standard_Type.hxx>
41#include <TopAbs_State.hxx>
42#include <TopExp_Explorer.hxx>
43#include <TopoDS.hxx>
44#include <TopoDS_Edge.hxx>
45#include <TopoDS_Face.hxx>
46#include <TopoDS_Shape.hxx>
47#include <TopoDS_Solid.hxx>
48#include <TopoDS_Vertex.hxx>
4e57c75e 49
42cf5bc1 50//
7fd59977 51//=======================================================================
52//function :
53//purpose :
54//=======================================================================
1e143abb 55IntTools_Context::IntTools_Context()
4e57c75e 56:
57 myAllocator(new NCollection_IncAllocator()),
58 myFClass2dMap(100, myAllocator),
59 myProjPSMap(100, myAllocator),
60 myProjPCMap(100, myAllocator),
61 mySClassMap(100, myAllocator),
62 myProjPTMap(100, myAllocator),
63 myHatcherMap(100, myAllocator),
64 myProjSDataMap(100, myAllocator),
f47b8d2b 65 myBndBoxDataMap(100, myAllocator),
b285c9fe 66 myCreateFlag(0),
67 myPOnSTolerance(1.e-12)
4e57c75e 68{
69}
70//=======================================================================
71//function :
72//purpose :
73//=======================================================================
1e143abb 74IntTools_Context::IntTools_Context
75 (const Handle(NCollection_BaseAllocator)& theAllocator)
4e57c75e 76:
77 myAllocator(theAllocator),
78 myFClass2dMap(100, myAllocator),
79 myProjPSMap(100, myAllocator),
80 myProjPCMap(100, myAllocator),
81 mySClassMap(100, myAllocator),
82 myProjPTMap(100, myAllocator),
83 myHatcherMap(100, myAllocator),
84 myProjSDataMap(100, myAllocator),
f47b8d2b 85 myBndBoxDataMap(100, myAllocator),
b285c9fe 86 myCreateFlag(1),
87 myPOnSTolerance(1.e-12)
7fd59977 88{
89}
90//=======================================================================
91//function : ~
92//purpose :
93//=======================================================================
1e143abb 94IntTools_Context::~IntTools_Context()
7fd59977 95{
96 Standard_Address anAdr;
4e57c75e 97 BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt;
98 BOPCol_DataMapIteratorOfDataMapOfTransientAddress aIt1;
3f524765 99 //
7fd59977 100 IntTools_FClass2d* pFClass2d;
4e57c75e 101 //
102 aIt.Initialize(myFClass2dMap);
103 for (; aIt.More(); aIt.Next()) {
104 anAdr=aIt.Value();
7fd59977 105 pFClass2d=(IntTools_FClass2d*)anAdr;
4e57c75e 106 (*pFClass2d).~IntTools_FClass2d();
107 myAllocator->Free(anAdr);
7fd59977 108 }
109 myFClass2dMap.Clear();
110 //
b285c9fe 111 clearCachedPOnSProjectors();
7fd59977 112 //
113 GeomAPI_ProjectPointOnCurve* pProjPC;
4e57c75e 114 aIt.Initialize(myProjPCMap);
115 for (; aIt.More(); aIt.Next()) {
116 anAdr=aIt.Value();
7fd59977 117 pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
4e57c75e 118 (*pProjPC).~GeomAPI_ProjectPointOnCurve();
119 myAllocator->Free(anAdr);
7fd59977 120 }
121 myProjPCMap.Clear();
122 //
4e57c75e 123 //
124 BRepClass3d_SolidClassifier* pSC;
125 aIt.Initialize(mySClassMap);
126 for (; aIt.More(); aIt.Next()) {
127 anAdr=aIt.Value();
128 pSC=(BRepClass3d_SolidClassifier*)anAdr;
129 (*pSC).~BRepClass3d_SolidClassifier();
130 myAllocator->Free(anAdr);
131 }
132 mySClassMap.Clear();
133 //
7fd59977 134 GeomAPI_ProjectPointOnCurve* pProjPT;
4e57c75e 135 aIt1.Initialize(myProjPTMap);
136 for (; aIt1.More(); aIt1.Next()) {
137 anAdr=aIt1.Value();
7fd59977 138 pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
4e57c75e 139 (*pProjPT).~GeomAPI_ProjectPointOnCurve();
140 myAllocator->Free(anAdr);
7fd59977 141 }
142 myProjPTMap.Clear();
143 //
4e57c75e 144 Geom2dHatch_Hatcher* pHatcher;
145 aIt.Initialize(myHatcherMap);
146 for (; aIt.More(); aIt.Next()) {
147 anAdr=aIt.Value();
148 pHatcher=(Geom2dHatch_Hatcher*)anAdr;
149 (*pHatcher).~Geom2dHatch_Hatcher();
150 myAllocator->Free(anAdr);
7fd59977 151 }
4e57c75e 152 myHatcherMap.Clear();
7fd59977 153 //
154 IntTools_SurfaceRangeLocalizeData* pSData = NULL;
4e57c75e 155 aIt.Initialize(myProjSDataMap);
156 for (; aIt.More(); aIt.Next()) {
157 anAdr=aIt.Value();
7fd59977 158 pSData = (IntTools_SurfaceRangeLocalizeData*)anAdr;
4e57c75e 159 (*pSData).~IntTools_SurfaceRangeLocalizeData();
160 myAllocator->Free(anAdr);
7fd59977 161 }
162 myProjSDataMap.Clear();
f47b8d2b 163 //
164 Bnd_Box* pBox;
165 aIt.Initialize(myBndBoxDataMap);
166 for (; aIt.More(); aIt.Next()) {
167 anAdr=aIt.Value();
168 pBox=(Bnd_Box*)anAdr;
169 (*pBox).~Bnd_Box();
170 myAllocator->Free(anAdr);
171 }
172 myBndBoxDataMap.Clear();
173}
174//=======================================================================
175//function : BndBox
176//purpose :
177//=======================================================================
178Bnd_Box& IntTools_Context::BndBox(const TopoDS_Shape& aS)
179{
180 Standard_Address anAdr;
181 Bnd_Box* pBox;
182 //
183 if (!myBndBoxDataMap.IsBound(aS)) {
184 //
185 pBox=(Bnd_Box*)myAllocator->Allocate(sizeof(Bnd_Box));
186 new (pBox) Bnd_Box();
187 //
188 Bnd_Box &aBox=*pBox;
189 BRepBndLib::Add(aS, aBox);
190 //
191 anAdr=(Standard_Address)pBox;
192 myBndBoxDataMap.Bind(aS, anAdr);
193 }
194 else {
195 anAdr=myBndBoxDataMap.Find(aS);
196 pBox=(Bnd_Box*)anAdr;
197 }
198 return *pBox;
199}
200//=======================================================================
201//function : IsInfiniteFace
202//purpose :
203//=======================================================================
204Standard_Boolean IntTools_Context::IsInfiniteFace
205 (const TopoDS_Face& aFace)
206{
207 Standard_Boolean bRet;
208 Standard_Integer i;
209 Standard_Real aX[6];
210 //
211 bRet=Standard_False;
212 //
213 if (!BRep_Tool::NaturalRestriction(aFace)) {
214 return bRet;
215 }
216 //
217 Bnd_Box& aBox=BndBox(aFace);
218 //
219 aBox.Get(aX[0], aX[1], aX[2], aX[3], aX[4], aX[5]);
220 //
221 for (i=0; (i<6) && (!bRet); ++i) {
222 bRet=Precision::IsInfinite(aX[i]);
223 }
224 //
225 return bRet;
7fd59977 226}
227//=======================================================================
228//function : FClass2d
229//purpose :
230//=======================================================================
1e143abb 231IntTools_FClass2d& IntTools_Context::FClass2d(const TopoDS_Face& aF)
7fd59977 232{
233 Standard_Address anAdr;
234 IntTools_FClass2d* pFClass2d;
cf8e963a 235 //
4e57c75e 236 if (!myFClass2dMap.IsBound(aF)) {
7fd59977 237 Standard_Real aTolF;
4e57c75e 238 TopoDS_Face aFF;
239 //
240 aFF=aF;
7fd59977 241 aFF.Orientation(TopAbs_FORWARD);
242 aTolF=BRep_Tool::Tolerance(aFF);
243 //
4e57c75e 244 pFClass2d=(IntTools_FClass2d*)myAllocator->Allocate(sizeof(IntTools_FClass2d));
245 new (pFClass2d) IntTools_FClass2d(aFF, aTolF);
7fd59977 246 //
247 anAdr=(Standard_Address)pFClass2d;
4e57c75e 248 myFClass2dMap.Bind(aFF, anAdr);
7fd59977 249 }
7fd59977 250 else {
4e57c75e 251 anAdr=myFClass2dMap.Find(aF);
252 pFClass2d=(IntTools_FClass2d*)anAdr;
7fd59977 253 }
7fd59977 254 return *pFClass2d;
255}
256//=======================================================================
257//function : ProjPS
258//purpose :
259//=======================================================================
1e143abb 260GeomAPI_ProjectPointOnSurf& IntTools_Context::ProjPS(const TopoDS_Face& aF)
7fd59977 261{
262 Standard_Address anAdr;
263 GeomAPI_ProjectPointOnSurf* pProjPS;
4e57c75e 264
265 if (!myProjPSMap.IsBound(aF)) {
b285c9fe 266 Standard_Real Umin, Usup, Vmin, Vsup;
7fd59977 267 BRepAdaptor_Surface aBAS;
268 //
269 const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF);
270 aBAS.Initialize (aF, Standard_True);
271 //
272 Umin=aBAS.FirstUParameter();
273 Usup=aBAS.LastUParameter ();
274 Vmin=aBAS.FirstVParameter();
275 Vsup=aBAS.LastVParameter ();
276 //
4e57c75e 277 pProjPS=(GeomAPI_ProjectPointOnSurf*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnSurf));
278 new (pProjPS) GeomAPI_ProjectPointOnSurf();
b285c9fe 279 pProjPS->Init(aS ,Umin, Usup, Vmin, Vsup, myPOnSTolerance/*, Extrema_ExtAlgo_Tree*/);
d633fd70 280 Extrema_ExtPS& anExtAlgo = const_cast<Extrema_ExtPS&>(pProjPS->Extrema());
281 anExtAlgo.SetFlag(Extrema_ExtFlag_MIN);
7fd59977 282 //
283 anAdr=(Standard_Address)pProjPS;
4e57c75e 284 myProjPSMap.Bind(aF, anAdr);
7fd59977 285 }
286
287 else {
4e57c75e 288 anAdr=myProjPSMap.Find(aF);
289 pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
7fd59977 290 }
291 return *pProjPS;
292}
293//=======================================================================
294//function : ProjPC
295//purpose :
296//=======================================================================
1e143abb 297GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPC(const TopoDS_Edge& aE)
7fd59977 298{
299 Standard_Address anAdr;
300 GeomAPI_ProjectPointOnCurve* pProjPC;
4e57c75e 301
302 if (!myProjPCMap.IsBound(aE)) {
7fd59977 303 Standard_Real f, l;
304 //
305 Handle(Geom_Curve)aC3D=BRep_Tool::Curve (aE, f, l);
306 //
4e57c75e 307 pProjPC=(GeomAPI_ProjectPointOnCurve*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnCurve));
308 new (pProjPC) GeomAPI_ProjectPointOnCurve();
7fd59977 309 pProjPC->Init(aC3D, f, l);
310 //
311 anAdr=(Standard_Address)pProjPC;
4e57c75e 312 myProjPCMap.Bind(aE, anAdr);
7fd59977 313 }
4e57c75e 314
7fd59977 315 else {
4e57c75e 316 anAdr=myProjPCMap.Find(aE);
317 pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
7fd59977 318 }
319 return *pProjPC;
320}
4e57c75e 321
7fd59977 322//=======================================================================
323//function : ProjPT
324//purpose :
325//=======================================================================
1e143abb 326GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPT
327 (const Handle(Geom_Curve)& aC3D)
4e57c75e 328
7fd59977 329{
330 Standard_Address anAdr;
331 GeomAPI_ProjectPointOnCurve* pProjPT;
4e57c75e 332
333 if (!myProjPTMap.IsBound(aC3D)) {
7fd59977 334 Standard_Real f, l;
335 f=aC3D->FirstParameter();
336 l=aC3D->LastParameter();
337 //
4e57c75e 338 pProjPT=(GeomAPI_ProjectPointOnCurve*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnCurve));
339 new (pProjPT) GeomAPI_ProjectPointOnCurve();
7fd59977 340 pProjPT->Init(aC3D, f, l);
341 //
342 anAdr=(Standard_Address)pProjPT;
4e57c75e 343 myProjPTMap.Bind(aC3D, anAdr);
7fd59977 344 }
345
346 else {
4e57c75e 347 anAdr=myProjPTMap.Find(aC3D);
348 pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
7fd59977 349 }
350 return *pProjPT;
351}
352//=======================================================================
4e57c75e 353//function : SolidClassifier
7fd59977 354//purpose :
355//=======================================================================
1e143abb 356BRepClass3d_SolidClassifier& IntTools_Context::SolidClassifier
357 (const TopoDS_Solid& aSolid)
7fd59977 358{
359 Standard_Address anAdr;
4e57c75e 360 BRepClass3d_SolidClassifier* pSC;
361
362 if (!mySClassMap.IsBound(aSolid)) {
7fd59977 363 //
4e57c75e 364 pSC=(BRepClass3d_SolidClassifier*)myAllocator->Allocate(sizeof(BRepClass3d_SolidClassifier));
365 new (pSC) BRepClass3d_SolidClassifier(aSolid);
7fd59977 366 //
4e57c75e 367 anAdr=(Standard_Address)pSC;
368 mySClassMap.Bind(aSolid, anAdr);
7fd59977 369 }
370
371 else {
4e57c75e 372 anAdr=mySClassMap.Find(aSolid);
373 pSC =(BRepClass3d_SolidClassifier*)anAdr;
7fd59977 374 }
4e57c75e 375 return *pSC;
7fd59977 376}
4e57c75e 377
7fd59977 378//=======================================================================
4e57c75e 379//function : Hatcher
7fd59977 380//purpose :
381//=======================================================================
1e143abb 382Geom2dHatch_Hatcher& IntTools_Context::Hatcher(const TopoDS_Face& aF)
7fd59977 383{
384 Standard_Address anAdr;
4e57c75e 385 Geom2dHatch_Hatcher* pHatcher;
cf8e963a 386 //
4e57c75e 387 if (!myHatcherMap.IsBound(aF)) {
388 Standard_Real aTolArcIntr, aTolTangfIntr, aTolHatch2D, aTolHatch3D;
389 Standard_Real aU1, aU2, aEpsT;
390 TopAbs_Orientation aOrE;
391 Handle(Geom_Surface) aS;
392 Handle(Geom2d_Curve) aC2D;
393 Handle(Geom2d_TrimmedCurve) aCT2D;
394 TopoDS_Face aFF;
395 TopExp_Explorer aExp;
7fd59977 396 //
4e57c75e 397 aTolHatch2D=1.e-8;
398 aTolHatch3D=1.e-8;
399 aTolArcIntr=1.e-10;
400 aTolTangfIntr=1.e-10;
401 aEpsT=Precision::PConfusion();
7fd59977 402 //
4e57c75e 403 Geom2dHatch_Intersector aIntr(aTolArcIntr, aTolTangfIntr);
404 pHatcher=new Geom2dHatch_Hatcher(aIntr,
405 aTolHatch2D, aTolHatch3D,
406 Standard_True, Standard_False);
407
408 //
409 aFF=aF;
410 aFF.Orientation(TopAbs_FORWARD);
411 aS=BRep_Tool::Surface(aFF);
412
413 aExp.Init (aFF, TopAbs_EDGE);
414 for (; aExp.More() ; aExp.Next()) {
415 const TopoDS_Edge& aE=*((TopoDS_Edge*)&aExp.Current());
416 aOrE=aE.Orientation();
417 //
418 aC2D=BRep_Tool::CurveOnSurface (aE, aFF, aU1, aU2);
419 if (aC2D.IsNull() ) {
420 continue;
421 }
422 if (fabs(aU1-aU2) < aEpsT) {
423 continue;
424 }
425 //
426 aCT2D=new Geom2d_TrimmedCurve(aC2D, aU1, aU2);
543a9964 427 Geom2dAdaptor_Curve aGAC (aCT2D);
428 pHatcher->AddElement(aGAC, aOrE);
4e57c75e 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;
7fd59977 438 }
4e57c75e 439
440 return *pHatcher;
441}
442
443//=======================================================================
444//function : SurfaceData
445//purpose :
446//=======================================================================
1e143abb 447IntTools_SurfaceRangeLocalizeData& IntTools_Context::SurfaceData
448 (const TopoDS_Face& aF)
4e57c75e 449{
450 Standard_Address anAdr;
451 IntTools_SurfaceRangeLocalizeData* pSData;
452 //
453 if (!myProjSDataMap.IsBound(aF)) {
1e143abb 454 pSData=new IntTools_SurfaceRangeLocalizeData
455 (3,
456 3,
457 10. * Precision::PConfusion(),
458 10. * Precision::PConfusion());
4e57c75e 459 //
460 anAdr=(Standard_Address)pSData;
461 myProjSDataMap.Bind(aF, anAdr);
462 }
463
7fd59977 464 else {
4e57c75e 465 anAdr=myProjSDataMap.Find(aF);
466 pSData=(IntTools_SurfaceRangeLocalizeData*)anAdr;
7fd59977 467 }
4e57c75e 468 return *pSData;
469
7fd59977 470}
4e57c75e 471
7fd59977 472//=======================================================================
4e57c75e 473//function : ComputePE
7fd59977 474//purpose :
475//=======================================================================
1e143abb 476Standard_Integer IntTools_Context::ComputePE
477 (const gp_Pnt& aP1,
478 const Standard_Real aTolP1,
479 const TopoDS_Edge& aE2,
480 Standard_Real& aT)
7fd59977 481{
4e57c75e 482 if (!BRep_Tool::IsGeometric(aE2)) {
483 return -2;
484 }
485 Standard_Real aDist, aTolE2, aTolSum;
486 Standard_Integer aNbProj;
7fd59977 487 //
4e57c75e 488 GeomAPI_ProjectPointOnCurve& aProjector=ProjPC(aE2);
489 aProjector.Perform(aP1);
490
491 aNbProj=aProjector.NbPoints();
492 if (!aNbProj) {
493 return -3;
494 }
7fd59977 495 //
4e57c75e 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;
7fd59977 506}
507//=======================================================================
508//function : ComputeVE
509//purpose :
510//=======================================================================
1e143abb 511Standard_Integer IntTools_Context::ComputeVE
512 (const TopoDS_Vertex& aV1,
513 const TopoDS_Edge& aE2,
514 Standard_Real& aT)
7fd59977 515{
7fd59977 516 if (BRep_Tool::Degenerated(aE2)) {
517 return -1;
518 }
4e57c75e 519 if (!BRep_Tool::IsGeometric(aE2)) {
520 return -2;
521 }
522 Standard_Real aDist, aTolV1, aTolE2, aTolSum;
7fd59977 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);
4e57c75e 530
7fd59977 531 aNbProj=aProjector.NbPoints();
532 if (!aNbProj) {
533 return -3;
534 }
535 //
536 aDist=aProjector.LowerDistance();
42ff8f5b 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)
7fd59977 541 aTolV1=BRep_Tool::Tolerance(aV1);
542 aTolE2=BRep_Tool::Tolerance(aE2);
42ff8f5b 543 aTolSum = aTolV1 + aTolE2 + Precision::Confusion();
7fd59977 544 //
545 aT=aProjector.LowerDistanceParameter();
546 if (aDist > aTolSum) {
547 return -4;
548 }
7fd59977 549 return 0;
550}
7fd59977 551//=======================================================================
552//function : ComputeVS
553//purpose :
554//=======================================================================
1e143abb 555Standard_Integer IntTools_Context::ComputeVF
556 (const TopoDS_Vertex& aV1,
557 const TopoDS_Face& aF2,
558 Standard_Real& U,
559 Standard_Real& V)
7fd59977 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 //
4e57c75e 570 if (!aProjector.IsDone()) { // the point is not projectable on the surface
7fd59977 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);
4e57c75e 589 if (!pri) {// the point lays on the surface but out of the face
7fd59977 590 return -3;
591 }
592 return 0;
593}
594//=======================================================================
595//function : StatePointFace
596//purpose :
597//=======================================================================
1e143abb 598TopAbs_State IntTools_Context::StatePointFace
599 (const TopoDS_Face& aF,
600 const gp_Pnt2d& aP2d)
7fd59977 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//=======================================================================
1e143abb 611Standard_Boolean IntTools_Context::IsPointInFace
612 (const TopoDS_Face& aF,
613 const gp_Pnt2d& aP2d)
7fd59977 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//=======================================================================
bd28b2af 622//function : IsPointInFace
623//purpose :
624//=======================================================================
625Standard_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//=======================================================================
7fd59977 651//function : IsPointInOnFace
652//purpose :
653//=======================================================================
1e143abb 654 Standard_Boolean IntTools_Context::IsPointInOnFace(const TopoDS_Face& aF,
4e57c75e 655 const gp_Pnt2d& aP2d)
7fd59977 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//=======================================================================
1e143abb 667Standard_Boolean IntTools_Context::IsValidPointForFace
668 (const gp_Pnt& aP,
669 const TopoDS_Face& aF,
670 const Standard_Real aTol)
7fd59977 671{
672 Standard_Boolean bFlag;
96a95605 673 Standard_Real Umin, U, V;
7fd59977 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//=======================================================================
1e143abb 697Standard_Boolean IntTools_Context::IsValidPointForFaces
698 (const gp_Pnt& aP,
699 const TopoDS_Face& aF1,
700 const TopoDS_Face& aF2,
701 const Standard_Real aTol)
7fd59977 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//=======================================================================
1e143abb 716Standard_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)
7fd59977 722{
723 Standard_Boolean bFlag;
96a95605 724 Standard_Real aTInterm;
7fd59977 725 gp_Pnt aPInterm;
726
727 aTInterm=IntTools_Tools::IntermediatePoint(aT1, aT2);
728
729 Handle(Geom_Curve) aC3D=aC.Curve();
7fd59977 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//=======================================================================
1e143abb 740Standard_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)
7fd59977 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//=======================================================================
1e143abb 780Standard_Boolean IntTools_Context::IsVertexOnLine
781 (const TopoDS_Vertex& aV,
782 const IntTools_Curve& aC,
783 const Standard_Real aTolC,
784 Standard_Real& aT)
7fd59977 785{
786 Standard_Boolean bRet;
787 Standard_Real aTolV;
788 //
789 aTolV=BRep_Tool::Tolerance(aV);
1e143abb 790 bRet=IntTools_Context::IsVertexOnLine(aV, aTolV, aC, aTolC , aT);
7fd59977 791 //
792 return bRet;
793}
794//=======================================================================
795//function : IsVertexOnLine
796//purpose :
797//=======================================================================
1e143abb 798Standard_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)
7fd59977 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) {
4e57c75e 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 }
7fd59977 853 }
854 //
855 return Standard_True;
856 }
857 }
858 //
4e57c75e 859 //if (!Precision::IsInfinite(aFirst)) {
7fd59977 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) {
4e57c75e 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 }
7fd59977 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) {
4e57c75e 897 aT=aFirst;
898 return Standard_True;
7fd59977 899 }
900
901 aDist=aPv.Distance(aPEnd);
902 if (aDist < aTolSum) {
4e57c75e 903 aT=aLast;
904 return Standard_True;
7fd59977 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//=======================================================================
1e143abb 925Standard_Boolean IntTools_Context::ProjectPointOnEdge
926 (const gp_Pnt& aP,
927 const TopoDS_Edge& anEdge,
928 Standard_Real& aT)
7fd59977 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
b285c9fe 943//=======================================================================
944//function : SetPOnSProjectionTolerance
945//purpose :
946//=======================================================================
947void IntTools_Context::SetPOnSProjectionTolerance(const Standard_Real theValue)
948{
949 myPOnSTolerance = theValue;
950 clearCachedPOnSProjectors();
951}
952
953//=======================================================================
954//function : clearCachedPOnSProjectors
955//purpose :
956//=======================================================================
957void IntTools_Context::clearCachedPOnSProjectors()
958{
959 GeomAPI_ProjectPointOnSurf* pProjPS;
960 BOPCol_DataMapIteratorOfDataMapOfShapeAddress aIt(myProjPSMap);
961 for (; aIt.More(); aIt.Next()) {
962 Standard_Address anAdr=aIt.Value();
963 pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
964 (*pProjPS).~GeomAPI_ProjectPointOnSurf();
965 myAllocator->Free(anAdr);
966 }
967 myProjPSMap.Clear();
968}
Open CASCADE Technology repository