0024428: Implementation of LGPL license
[occt.git] / src / IntTools / IntTools_Tools.cxx
1 // Created on: 2000-11-16
2 // Created by: Peter KURNEV
3 // Copyright (c) 2000-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and / or modify it
8 // under the terms of the GNU Lesser General Public version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <IntTools_Tools.ixx>
17
18 #include <Precision.hxx>
19
20 #include <TopExp_Explorer.hxx>
21 #include <TopTools_IndexedDataMapOfShapeShape.hxx>
22
23 #include <TopoDS.hxx>
24 #include <TopoDS_Shape.hxx>
25 #include <TopoDS_Vertex.hxx>
26 #include <TopoDS_Edge.hxx>
27 #include <TopoDS_Face.hxx>
28 #include <TopoDS_Wire.hxx>
29 #include <TopLoc_Location.hxx>
30
31 #include <BRep_Builder.hxx>
32 #include <BRep_Tool.hxx>
33 #include <BRepAdaptor_Surface.hxx>
34 #include <BRepAdaptor_Curve.hxx>
35 #include <BRepAdaptor_Surface.hxx>
36
37 #include <gp_Pnt.hxx>
38 #include <gp_Pnt2d.hxx>
39 #include <gp.hxx>
40 #include <gp_Lin.hxx>
41 #include <gp_Dir.hxx>
42 #include <gp_Ax1.hxx>
43
44 #include <Geom_Curve.hxx>
45 #include <GeomAdaptor_Surface.hxx>
46 #include <Geom_Surface.hxx>
47 #include <GeomAPI_ProjectPointOnSurf.hxx>
48 #include <GeomAPI_ProjectPointOnCurve.hxx>
49 #include <GeomAdaptor_Curve.hxx>
50 #include <GeomAbs_CurveType.hxx>
51 #include <Geom_Line.hxx>
52 #include <Geom2d_Curve.hxx>
53 #include <Geom_BoundedCurve.hxx>
54 #include <Geom_Geometry.hxx>
55 #include <Geom_TrimmedCurve.hxx>
56 #include <Geom2d_TrimmedCurve.hxx>
57
58 #include <IntTools_FClass2d.hxx>
59 #include <IntTools_Curve.hxx>
60 #include <IntTools_SequenceOfCurves.hxx>
61
62 static
63   void ParabolaTolerance(const Handle(Geom_Curve)& ,
64                          const Standard_Real ,
65                          const Standard_Real ,
66                          const Standard_Real ,
67                          Standard_Real& ,
68                          Standard_Real& );
69
70 //=======================================================================
71 //function : HasInternalEdge
72 //purpose  : 
73 //=======================================================================
74   Standard_Boolean IntTools_Tools::HasInternalEdge(const TopoDS_Wire& aW)
75 {
76   Standard_Boolean bFlag=Standard_True;
77
78   TopExp_Explorer anExp(aW, TopAbs_EDGE);
79   for (; anExp.More(); anExp.Next()) {
80     const TopoDS_Edge& aE=TopoDS::Edge(anExp.Current());
81     TopAbs_Orientation anOr=aE.Orientation();
82     if (anOr==TopAbs_INTERNAL) {
83       return bFlag;
84     }
85   }
86   return !bFlag;
87 }
88
89 //=======================================================================
90 //function : IsClosed
91 //purpose  : 
92 //=======================================================================
93   Standard_Boolean IntTools_Tools::IsClosed (const Handle(Geom_Curve)& aC3D)
94 {
95   Standard_Boolean bRet;
96   Standard_Real aF, aL, aDist, aPC;
97   gp_Pnt aP1, aP2;
98   
99   Handle (Geom_BoundedCurve) aGBC=
100       Handle (Geom_BoundedCurve)::DownCast(aC3D);
101   if (aGBC.IsNull()) {
102     return Standard_False;
103   }
104   
105   aF=aC3D->FirstParameter();
106   aL=aC3D-> LastParameter();
107   
108   aC3D->D0(aF, aP1);
109   aC3D->D0(aL, aP2);
110
111   
112   //
113   //modified by NIZNHY-PKV Mon Jul 04 11:58:23 2011f
114   aPC=Precision::Confusion();
115   aPC=aPC*aPC;
116   aDist=aP1.SquareDistance(aP2);
117   bRet=aDist<aPC;
118   return bRet;
119   //
120   //aDist=aP1.Distance(aP2);
121   //return (aDist < Precision::Confusion()); 
122   //modified by NIZNHY-PKV Mon Jul 04 11:59:50 2011t
123 }
124
125 //=======================================================================
126 //function : RejectLines
127 //purpose  : 
128 //=======================================================================
129    void IntTools_Tools::RejectLines(const IntTools_SequenceOfCurves& aSIn,
130                                     IntTools_SequenceOfCurves& aSOut)
131 {
132   Standard_Integer i, j, aNb;
133   Standard_Boolean bFlag;
134   Handle (Geom_Curve) aC3D;
135
136   gp_Dir aD1, aD2;
137
138   aSOut.Clear();
139
140   aNb=aSIn.Length();
141   for (i=1; i<=aNb; i++) {
142     const IntTools_Curve& IC=aSIn(i);
143     aC3D=IC.Curve();
144     //
145     Handle (Geom_TrimmedCurve) aGTC=
146       Handle (Geom_TrimmedCurve)::DownCast(aC3D);
147     
148     if (!aGTC.IsNull()) {
149       aC3D=aGTC->BasisCurve();
150       IntTools_Curve* pIC=(IntTools_Curve*) &IC;
151       pIC->SetCurve(aC3D);
152     }
153     //
154     Handle (Geom_Line) aGLine=
155       Handle (Geom_Line)::DownCast(aC3D);
156     
157     if (aGLine.IsNull()) {
158       aSOut.Clear();
159       for (j=1; j<=aNb; j++) {
160         aSOut.Append(aSIn(j));
161       }
162       return;
163     }
164     //
165     gp_Lin aLin=aGLine->Lin();
166     aD2=aLin.Direction();
167     if (i==1) {
168       aSOut.Append(IC);
169       aD1=aD2;
170       continue;
171     }
172     
173     bFlag=IntTools_Tools::IsDirsCoinside(aD1, aD2);
174     if (!bFlag) {
175       aSOut.Append(IC);
176       return;
177     }
178   }
179 }
180
181 //=======================================================================
182 //function : IsDirsCoinside
183 //purpose  : 
184 //=======================================================================
185   Standard_Boolean IntTools_Tools::IsDirsCoinside  (const gp_Dir& D1, const gp_Dir& D2)
186 {
187   Standard_Boolean bFlag;
188   gp_Pnt P1(D1.X(), D1.Y(), D1.Z());  
189   gp_Pnt P2(D2.X(), D2.Y(), D2.Z());
190   Standard_Real dLim=0.0002, d;
191   d=P1.Distance (P2); 
192   bFlag= (d<dLim || fabs (2.-d)<dLim); 
193   return bFlag;
194 }
195   
196 //=======================================================================
197 //function : IsDirsCoinside
198 //purpose  : 
199 //=======================================================================
200   Standard_Boolean IntTools_Tools::IsDirsCoinside  (const gp_Dir& D1, 
201                                                     const gp_Dir& D2,
202                                                     const Standard_Real dLim)
203 {
204   Standard_Boolean bFlag;
205   Standard_Real d;
206   //
207   gp_Pnt P1(D1.X(), D1.Y(), D1.Z());  
208   gp_Pnt P2(D2.X(), D2.Y(), D2.Z());
209   d=P1.Distance (P2); 
210   bFlag= (d<dLim || fabs (2.-d)<dLim); 
211   return bFlag;
212 }
213 //=======================================================================
214 //function : SplitCurve
215 //purpose  : 
216 //=======================================================================
217   Standard_Integer IntTools_Tools::SplitCurve(const IntTools_Curve& IC,
218                                               IntTools_SequenceOfCurves& aCvs)
219 {
220   Handle (Geom_Curve) aC3D =IC.Curve();
221   if(aC3D.IsNull())
222     return 0;
223   //
224   Handle (Geom2d_Curve) aC2D1=IC.FirstCurve2d();
225   Handle (Geom2d_Curve) aC2D2=IC.SecondCurve2d();
226   Standard_Boolean bIsClosed;
227
228   bIsClosed=IntTools_Tools::IsClosed(aC3D);
229   if (!bIsClosed) {
230     return 0;
231   }
232
233   Standard_Real aF, aL, aMid;
234   
235   //
236   aF=aC3D->FirstParameter();
237   aL=aC3D->LastParameter();
238   aMid=0.5*(aF+aL);
239   GeomAdaptor_Curve aGAC(aC3D);
240   GeomAbs_CurveType aCT=aGAC.GetType();
241   if (aCT==GeomAbs_BSplineCurve ||
242       aCT==GeomAbs_BezierCurve) {
243     //aMid=0.5*aMid;
244     aMid=IntTools_Tools::IntermediatePoint(aF, aL);
245   }
246   //
247   Handle(Geom_Curve) aC3DNewF, aC3DNewL;
248   aC3DNewF =new Geom_TrimmedCurve  (aC3D, aF, aMid);
249   aC3DNewL =new Geom_TrimmedCurve  (aC3D, aMid, aL);
250
251   //
252   Handle (Geom2d_Curve) aC2D1F, aC2D1L, aC2D2F, aC2D2L;
253   //
254   if(!aC2D1.IsNull()) {
255     aC2D1F=new Geom2d_TrimmedCurve (aC2D1, aF, aMid);
256     aC2D1L=new Geom2d_TrimmedCurve (aC2D1, aMid, aL);
257   }
258
259   if(!aC2D2.IsNull()) {
260     aC2D2F=new Geom2d_TrimmedCurve (aC2D2, aF, aMid);
261     aC2D2L=new Geom2d_TrimmedCurve (aC2D2, aMid, aL);
262   }
263   // 
264   
265   IntTools_Curve aIC1(aC3DNewF, aC2D1F, aC2D2F);
266   IntTools_Curve aIC2(aC3DNewL, aC2D1L, aC2D2L);
267   //
268   aCvs.Append(aIC1);
269   //
270   aCvs.Append(aIC2);
271   //
272   return 2;
273 }
274
275 //=======================================================================
276 //function : IntermediatePoint
277 //purpose  : 
278 //=======================================================================
279   Standard_Real IntTools_Tools::IntermediatePoint (const Standard_Real aFirst,
280                                                    const Standard_Real aLast)
281 {
282   //define parameter division number as 10*e^(-M_PI) = 0.43213918
283   const Standard_Real PAR_T = 0.43213918;
284   Standard_Real aParm;
285   aParm=(1.-PAR_T)*aFirst + PAR_T*aLast;
286   return aParm;
287 }
288
289 //=======================================================================
290 //function : IsVertex
291 //purpose  : 
292 //=======================================================================
293   Standard_Boolean IntTools_Tools::IsVertex (const gp_Pnt& aP,
294                                              const Standard_Real aTolPV,
295                                              const TopoDS_Vertex& aV)
296 {
297   Standard_Boolean bRet;
298   Standard_Real aTolV, aD, dTol;
299   gp_Pnt aPv; 
300   
301   aTolV=BRep_Tool::Tolerance(aV);
302   //
303   dTol=Precision::Confusion();
304   aTolV=aTolV+aTolPV+dTol;
305   //
306   aPv=BRep_Tool::Pnt(aV);
307   //
308   //modified by NIZNHY-PKV Mon Jul 04 12:00:37 2011f
309   aD=aPv.SquareDistance(aP);
310   aTolV=aTolV*aTolV;
311   bRet=(aD<=aTolV);
312   return bRet;
313   //
314   //aD=aPv.Distance(aP);
315   //return (aD<=aTolV);
316   //modified by NIZNHY-PKV Mon Jul 04 12:00:40 2011t
317 }
318
319
320 //=======================================================================
321 //function : IsVertex
322 //purpose  : 
323 //=======================================================================
324   Standard_Boolean IntTools_Tools::IsVertex (const IntTools_CommonPrt& aCmnPrt)
325 {
326   Standard_Boolean anIsVertex;
327   Standard_Real aParam;
328
329   const TopoDS_Edge&    aE1=aCmnPrt.Edge1();
330   const IntTools_Range& aR1=aCmnPrt.Range1();
331   aParam=0.5*(aR1.First()+aR1.Last());
332   anIsVertex=IntTools_Tools::IsVertex (aE1, aParam);
333   
334   if (anIsVertex) {
335     return Standard_True;
336   }
337
338   const TopoDS_Edge&    aE2=aCmnPrt.Edge2();
339   const IntTools_SequenceOfRanges& aRs2=aCmnPrt.Ranges2();
340   const IntTools_Range& aR2=aRs2(1);
341   aParam=0.5*(aR2.First()+aR2.Last());
342   anIsVertex=IntTools_Tools::IsVertex (aE2, aParam);
343   if (anIsVertex) {
344     return Standard_True;
345   }
346   return Standard_False;
347 }
348
349 //=======================================================================
350 //function : IsVertex
351 //purpose  : 
352 //=======================================================================
353   Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
354                                              const TopoDS_Vertex& aV,
355                                              const Standard_Real t)
356 {
357   Standard_Real aTolV, aTolV2, d2;
358   gp_Pnt aPv, aPt; 
359   
360   BRepAdaptor_Curve aBAC(aE);
361   aBAC.D0(t, aPt);
362
363   aTolV=BRep_Tool::Tolerance(aV);
364   aTolV2=aTolV*aTolV;
365   aPv=BRep_Tool::Pnt(aV);
366   d2=aPv.SquareDistance (aPt);
367   if (d2 < aTolV2) {
368     return Standard_True;
369   }
370   return Standard_False;
371 }
372 //=======================================================================
373 //function : IsVertex
374 //purpose  : 
375 //=======================================================================
376   Standard_Boolean IntTools_Tools::IsVertex (const TopoDS_Edge& aE,
377                                              const Standard_Real t)
378 {
379   Standard_Real aTolV, aTolV2, d2;
380   TopoDS_Vertex aV;
381   gp_Pnt aPv, aPt; 
382   
383   BRepAdaptor_Curve aBAC(aE);
384   aBAC.D0(t, aPt);
385
386   TopExp_Explorer anExp(aE, TopAbs_VERTEX);
387   for (; anExp.More(); anExp.Next()) {
388     aV=TopoDS::Vertex (anExp.Current());
389     aTolV=BRep_Tool::Tolerance(aV);
390     aTolV2=aTolV*aTolV;
391     aTolV2=1.e-12;
392      aPv=BRep_Tool::Pnt(aV);
393      d2=aPv.SquareDistance (aPt);
394      if (d2 < aTolV2) {
395        return Standard_True;
396      }
397   }
398   return Standard_False;
399 }
400
401
402 //=======================================================================
403 //function : ComputeVV
404 //purpose  : 
405 //=======================================================================
406   Standard_Integer IntTools_Tools::ComputeVV(const TopoDS_Vertex& aV1, 
407                                              const TopoDS_Vertex& aV2)
408 {
409   Standard_Real aTolV1, aTolV2, aTolSum, d;
410   gp_Pnt aP1, aP2;
411
412   aTolV1=BRep_Tool::Tolerance(aV1);
413   aTolV2=BRep_Tool::Tolerance(aV2);
414   aTolSum=aTolV1+aTolV2;
415   
416   aP1=BRep_Tool::Pnt(aV1);
417   aP2=BRep_Tool::Pnt(aV2);
418   //modified by NIZNHY-PKV Mon Jul 04 11:55:52 2011f
419   aTolSum=aTolSum*aTolSum;
420   d=aP1.SquareDistance(aP2);
421   //d=aP1.Distance(aP2);
422   //modified by NIZNHY-PKV Mon Jul 04 11:55:53 2011t
423   if (d<aTolSum) {
424     return 0;
425   }
426   return -1;
427 }
428
429 //=======================================================================
430 //function : MakeFaceFromWireAndFace
431 //purpose  : 
432 //=======================================================================
433   void IntTools_Tools::MakeFaceFromWireAndFace(const TopoDS_Wire& aW,
434                                                const TopoDS_Face& aF,
435                                                TopoDS_Face& aFNew)
436 {
437   TopoDS_Face aFF;
438   aFF=aF;
439   aFF.Orientation(TopAbs_FORWARD);
440   aFNew=TopoDS::Face (aFF.EmptyCopied());
441   BRep_Builder BB;
442   BB.Add(aFNew, aW);
443 }
444
445 //=======================================================================
446 //function : ClassifyPointByFace
447 //purpose  : 
448 //=======================================================================
449   TopAbs_State IntTools_Tools::ClassifyPointByFace(const TopoDS_Face& aF,
450                                                    const gp_Pnt2d& aP2d)
451 {
452   Standard_Real aFaceTolerance;
453   TopAbs_State aState;
454   
455   aFaceTolerance=BRep_Tool::Tolerance(aF);
456   IntTools_FClass2d aClass2d(aF, aFaceTolerance);
457   aState=aClass2d.Perform(aP2d);
458   
459   return aState;
460 }
461
462 //=======================================================================
463 //function : IsMiddlePointsEqual
464 //purpose  : 
465 //=======================================================================
466   Standard_Boolean IntTools_Tools::IsMiddlePointsEqual(const TopoDS_Edge& aE1,
467                                                        const TopoDS_Edge& aE2)
468                                                        
469 {
470   Standard_Boolean bRet;
471   Standard_Real f1, l1, m1, f2, l2, m2, aTol1, aTol2, aSumTol, aD2;
472   gp_Pnt aP1, aP2;
473
474   aTol1=BRep_Tool::Tolerance(aE1);
475   Handle(Geom_Curve) C1=BRep_Tool::Curve(aE1, f1, l1);
476   m1=0.5*(f1+l1);
477   C1->D0(m1, aP1);
478
479   aTol2=BRep_Tool::Tolerance(aE2);
480   Handle(Geom_Curve) C2=BRep_Tool::Curve(aE2, f2, l2);
481   m2=0.5*(f2+l2);
482   C2->D0(m2, aP2);
483
484   aSumTol=aTol1+aTol2;
485   //modified by NIZNHY-PKV Mon Jul 04 12:02:20 2011f
486   aSumTol=aSumTol*aSumTol;
487   aD2=aP1.SquareDistance(aP2);
488   bRet=aD2<aSumTol;
489   return bRet;
490   //
491   //if (aP1.Distance(aP2) < aSumTol) {
492   //  return Standard_True;
493   //}
494   //return Standard_False;
495   //modified by NIZNHY-PKV Mon Jul 04 12:02:24 2011t
496 }
497
498 //=======================================================================
499 //function : CurveTolerance
500 //purpose  : 
501 //=======================================================================
502   Standard_Real IntTools_Tools::CurveTolerance(const Handle(Geom_Curve)& aC3D,
503                                                const Standard_Real aTolBase)
504 {
505   Standard_Real aTolReached, aTf, aTl, aTolMin, aTolMax;
506
507   aTolReached=aTolBase;
508   //
509   if (aC3D.IsNull()) {
510     return aTolReached;
511   }
512   //
513   Handle(Geom_TrimmedCurve) aCT3D=Handle(Geom_TrimmedCurve)::DownCast(aC3D);
514   if (aCT3D.IsNull()) {
515     return aTolReached;
516   }
517   //
518   aTolMin=aTolBase;
519   aTolMax=aTolBase;
520   //
521   aTf=aCT3D->FirstParameter();
522   aTl=aCT3D->LastParameter();
523   //
524   GeomAdaptor_Curve aGAC(aCT3D);
525   GeomAbs_CurveType aCType=aGAC.GetType();
526   //
527   if (aCType==GeomAbs_Parabola) {
528     Handle(Geom_Curve) aC3DBase=aCT3D->BasisCurve();
529     ParabolaTolerance(aC3DBase, aTf, aTl, aTolBase, aTolMin, aTolMax);
530     aTolReached=aTolMax;
531   }
532   //
533   return aTolReached;
534 }
535
536 #include <Geom_Parabola.hxx>
537 #include <gp_Parab.hxx>
538 //=======================================================================
539 //function : ParabolaTolerance
540 //purpose  : 
541 //=======================================================================
542 void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
543                        const Standard_Real aTf,
544                        const Standard_Real aTl,
545                        const Standard_Real aTol,
546                        Standard_Real& aTolMin,
547                        Standard_Real& aTolMax)
548 {
549   
550   aTolMin=aTol;
551   aTolMax=aTol;
552
553   Handle(Geom_Parabola) aGP=Handle(Geom_Parabola)::DownCast(aC3D);
554   if (aGP.IsNull()){
555     return;
556   }
557
558   Standard_Integer aNbPoints;
559   Standard_Real aFocal, aX1, aX2, aTol1, aTol2;
560   gp_Pnt aPf, aPl;
561   gp_Parab aParab=aGP->Parab();
562   gp_Ax1 aXAxis=aParab.XAxis();
563   Handle(Geom_Line) aGAxis=new Geom_Line(aXAxis);
564
565   aFocal=aGP->Focal();
566   if (aFocal==0.) {
567     return;
568   }
569   //
570   // aTol1
571   aTol1=aTol;
572   aX1=0.;
573   aGP->D0(aTf, aPf);
574   GeomAPI_ProjectPointOnCurve aProj1(aPf, aGAxis);
575   aNbPoints=aProj1.NbPoints();
576   if (aNbPoints) {
577     aX1=aProj1.LowerDistanceParameter();
578   }
579   if (aX1>=0.) {
580     aTol1=aTol*sqrt(0.5*aX1/aFocal);
581   }
582   if (aTol1==0.) {
583     aTol1=aTol;
584   }
585   //
586   // aTol2
587   aTol2=aTol;
588   aX2=0.;
589   aGP->D0(aTl, aPl);
590   GeomAPI_ProjectPointOnCurve aProj2(aPl, aGAxis);
591   aNbPoints=aProj2.NbPoints();
592   if (aNbPoints) {
593     aX2=aProj2.LowerDistanceParameter();
594   }
595   
596   if (aX2>=0.) {
597     aTol2=aTol*sqrt(0.5*aX2/aFocal);
598   }
599   if (aTol2==0.) {
600     aTol2=aTol;
601   }
602   //
603   aTolMax=(aTol1>aTol2) ? aTol1 : aTol2;
604   aTolMin=(aTol1<aTol2) ? aTol1 : aTol2;
605 }
606