0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / IntPatch / IntPatch_Intersection.cxx
1 // Created by: Modelization
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 <stdio.h>
16 #include <IntPatch_Intersection.hxx>
17
18 #include <Adaptor3d_HSurface.hxx>
19 #include <Adaptor3d_TopolTool.hxx>
20 #include <IntPatch_ALine.hxx>
21 #include <IntPatch_ALineToWLine.hxx>
22 #include <IntPatch_GLine.hxx>
23 #include <IntPatch_ImpImpIntersection.hxx>
24 #include <IntPatch_ImpPrmIntersection.hxx>
25 #include <IntPatch_PrmPrmIntersection.hxx>
26 #include <IntPatch_WLine.hxx>
27 #include <IntPatch_WLineTool.hxx>
28
29 #include <ProjLib_ProjectOnPlane.hxx>
30 #include <Geom_Plane.hxx>
31 #include <GeomAdaptor_HSurface.hxx>
32 #include <GeomAdaptor_HCurve.hxx>
33 #include <ProjLib_ProjectedCurve.hxx>
34 #include <Geom2dInt_GInter.hxx>
35 #include <Geom2dAdaptor_Curve.hxx>
36 #include <ProjLib.hxx>
37
38 //======================================================================
39 // function: SequenceOfLine
40 //======================================================================
41 const IntPatch_SequenceOfLine& IntPatch_Intersection::SequenceOfLine() const { return(slin); }
42
43 //======================================================================
44 // function: IntPatch_Intersection
45 //======================================================================
46 IntPatch_Intersection::IntPatch_Intersection ()
47  : done(Standard_False),
48    empt(Standard_True),
49    tgte(Standard_False),
50    oppo(Standard_False),
51    myTolArc(0.0), myTolTang(0.0),
52    myUVMaxStep(0.0), myFleche(0.0),
53    myIsStartPnt(Standard_False),
54    myU1Start(0.0),
55    myV1Start(0.0),
56    myU2Start(0.0),
57    myV2Start(0.0)
58 {
59 }
60
61 //======================================================================
62 // function: IntPatch_Intersection
63 //======================================================================
64 IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)&  S1,
65                                              const Handle(Adaptor3d_TopolTool)& D1,
66                                              const Handle(Adaptor3d_HSurface)&  S2,
67                                              const Handle(Adaptor3d_TopolTool)& D2,
68                                              const Standard_Real TolArc,
69                                              const Standard_Real TolTang)
70  : done(Standard_False),
71    empt(Standard_True),
72    tgte(Standard_False),
73    oppo(Standard_False),
74    myTolArc(TolArc), myTolTang(TolTang),
75    myUVMaxStep(0.0), myFleche(0.0),
76    myIsStartPnt(Standard_False),
77    myU1Start(0.0),
78    myV1Start(0.0),
79    myU2Start(0.0),
80    myV2Start(0.0)
81 {
82   if(myTolArc<1e-8) myTolArc=1e-8;
83   if(myTolTang<1e-8) myTolTang=1e-8;
84   if(myTolArc>0.5) myTolArc=0.5;
85   if(myTolTang>0.5) myTolTang=0.5;
86   Perform(S1,D1,S2,D2,TolArc,TolTang);
87 }
88
89 //======================================================================
90 // function: IntPatch_Intersection
91 //======================================================================
92 IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)&  S1,
93                                              const Handle(Adaptor3d_TopolTool)& D1,
94                                              const Standard_Real TolArc,
95                                              const Standard_Real TolTang)
96  : done(Standard_False),
97    empt(Standard_True),
98    tgte(Standard_False),
99    oppo(Standard_False),
100    myTolArc(TolArc), myTolTang(TolTang),
101    myUVMaxStep(0.0), myFleche(0.0),
102    myIsStartPnt(Standard_False),
103    myU1Start(0.0),
104    myV1Start(0.0),
105    myU2Start(0.0),
106    myV2Start(0.0)
107 {
108   Perform(S1,D1,TolArc,TolTang);
109 }
110
111 //======================================================================
112 // function: SetTolerances
113 //======================================================================
114 void IntPatch_Intersection::SetTolerances(const Standard_Real TolArc,
115                                           const Standard_Real TolTang,
116                                           const Standard_Real UVMaxStep,
117                                           const Standard_Real Fleche)
118
119   myTolArc     = TolArc;
120   myTolTang    = TolTang;
121   myUVMaxStep  = UVMaxStep;
122   myFleche     = Fleche;
123   if(myTolArc<1e-8) myTolArc=1e-8;
124   if(myTolTang<1e-8) myTolTang=1e-8;
125   if(myTolArc>0.5) myTolArc=0.5;
126   if(myTolTang>0.5) myTolTang=0.5;  
127   if(myFleche<1.0e-3) myFleche=1e-3;
128   if(myUVMaxStep<1.0e-3) myUVMaxStep=1e-3;
129   if(myFleche>10) myFleche=10;
130   if(myUVMaxStep>0.5) myUVMaxStep=0.5;
131 }
132
133 //======================================================================
134 // function: Perform
135 //======================================================================
136 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  S1,
137                                     const Handle(Adaptor3d_TopolTool)& D1,
138                                     const Standard_Real TolArc,
139                                     const Standard_Real TolTang)
140 {
141   myTolArc = TolArc;
142   myTolTang = TolTang;
143   if(myFleche == 0.0)  myFleche = 0.01;
144   if(myUVMaxStep==0.0) myUVMaxStep = 0.01;
145
146   done = Standard_True;
147   spnt.Clear();
148   slin.Clear();
149   
150   empt = Standard_True;
151   tgte = Standard_False;
152   oppo = Standard_False;
153
154   switch (S1->GetType())
155   { 
156   case GeomAbs_Plane:
157   case GeomAbs_Cylinder:
158   case GeomAbs_Sphere:
159   case GeomAbs_Cone:
160   case GeomAbs_Torus:
161     break;
162   case GeomAbs_SurfaceOfExtrusion:
163     {
164       gp_Dir aDirection = S1->Direction();
165       gp_Ax3 anAxis(gp::Origin(), aDirection);
166       Handle(Adaptor3d_HCurve) aBasisCurve = S1->BasisCurve();
167       ProjLib_ProjectOnPlane Projector(anAxis);
168       Projector.Load(aBasisCurve, Precision::Confusion());
169       Handle(GeomAdaptor_HCurve) aProjCurve = Projector.GetResult();
170       Handle(Geom_Plane) aPlane = new Geom_Plane(anAxis);
171       Handle(GeomAdaptor_HSurface) aGAHsurf = new GeomAdaptor_HSurface(aPlane);
172       ProjLib_ProjectedCurve aProjectedCurve(aGAHsurf, aProjCurve);
173       Handle(Geom2d_Curve) aPCurve;
174       ProjLib::MakePCurveOfType(aProjectedCurve, aPCurve);
175       Geom2dAdaptor_Curve AC(aPCurve,
176                              aProjectedCurve.FirstParameter(),
177                              aProjectedCurve.LastParameter());
178       Geom2dInt_GInter Intersector(AC,
179                                    Precision::Confusion(),
180                                    Precision::Confusion());
181       if (Intersector.IsDone() && Intersector.IsEmpty())
182         break;
183     }
184     Standard_FALLTHROUGH
185   default:
186     {
187       IntPatch_PrmPrmIntersection interpp;
188       interpp.Perform(S1,D1,TolTang,TolArc,myFleche,myUVMaxStep);
189       if (interpp.IsDone())
190       {
191         done = Standard_True;
192         tgte = Standard_False;
193         empt = interpp.IsEmpty();
194         const Standard_Integer nblm = interpp.NbLines();
195         for (Standard_Integer i=1; i<=nblm; i++) slin.Append(interpp.Line(i));
196       }
197     }
198     break;
199   }
200 }
201
202 /////////////////////////////////////////////////////////////////////////////
203 //  These several support functions provide methods which can help basic   //
204 //  algorithm to intersect infinite surfaces of the following types:       //
205 //                                                                         //
206 //  a.) SurfaceOfExtrusion;                                                //
207 //  b.) SurfaceOfRevolution;                                               //
208 //  c.) OffsetSurface.                                                     //
209 //                                                                         //
210 /////////////////////////////////////////////////////////////////////////////
211 #include <TColgp_Array1OfXYZ.hxx>
212 #include <TColgp_Array1OfPnt.hxx>
213 #include <TColgp_SequenceOfPnt.hxx>
214 #include <Extrema_ExtPS.hxx>
215 #include <Extrema_POnSurf.hxx>
216 #include <Geom2d_Curve.hxx>
217 #include <Geom2dAPI_InterCurveCurve.hxx>
218 #include <GeomAdaptor.hxx>
219 #include <GeomAdaptor_HCurve.hxx>
220 #include <GeomAdaptor_Curve.hxx>
221 #include <GeomAdaptor_Surface.hxx>
222 #include <GeomAdaptor_HSurface.hxx>
223 #include <Geom_Plane.hxx>
224 #include <ProjLib_ProjectOnPlane.hxx>
225 #include <GeomProjLib.hxx>
226 #include <ElCLib.hxx>
227 #include <Geom_TrimmedCurve.hxx>
228 #include <Geom_Surface.hxx>
229 #include <Geom_SurfaceOfLinearExtrusion.hxx>
230 #include <Geom_OffsetSurface.hxx>
231 #include <Geom_SurfaceOfRevolution.hxx>
232 #include <Geom_RectangularTrimmedSurface.hxx>
233
234 //===============================================================
235 //function: FUN_GetMinMaxXYZPnt
236 //===============================================================
237 static void FUN_GetMinMaxXYZPnt( const Handle(Adaptor3d_HSurface)& S,
238                                  gp_Pnt& pMin, gp_Pnt& pMax )
239 {
240   const Standard_Real DU = 0.25 * Abs(S->LastUParameter() - S->FirstUParameter());
241   const Standard_Real DV = 0.25 * Abs(S->LastVParameter() - S->FirstVParameter());
242   Standard_Real tMinXYZ = RealLast();
243   Standard_Real tMaxXYZ = -tMinXYZ;
244   gp_Pnt PUV, ptMax, ptMin;
245   for(Standard_Real U = S->FirstUParameter(); U <= S->LastUParameter(); U += DU)
246   {
247     for(Standard_Real V = S->FirstVParameter(); V <= S->LastVParameter(); V += DV)
248     {
249       S->D0(U,V,PUV);
250       const Standard_Real cXYZ = PUV.XYZ().Modulus();
251       if(cXYZ > tMaxXYZ) { tMaxXYZ = cXYZ; ptMax = PUV; }
252       if(cXYZ < tMinXYZ) { tMinXYZ = cXYZ; ptMin = PUV; }
253     }
254   }
255   pMin = ptMin;
256   pMax = ptMax;
257 }
258 //==========================================================================
259 //function: FUN_TrimInfSurf
260 //==========================================================================
261 static void FUN_TrimInfSurf(const gp_Pnt& Pmin,
262                             const gp_Pnt& Pmax,
263                             const Handle(Adaptor3d_HSurface)& InfSurf,
264                             const Standard_Real& AlternativeTrimPrm,
265                             Handle(Adaptor3d_HSurface)& TrimS)
266 {
267   Standard_Real TP = AlternativeTrimPrm;
268   Extrema_ExtPS ext1(Pmin, InfSurf->Surface(), 1.e-7, 1.e-7);
269   Extrema_ExtPS ext2(Pmax, InfSurf->Surface(), 1.e-7, 1.e-7);
270   if(ext1.IsDone() || ext2.IsDone())
271   {
272     Standard_Real Umax = -1.e+100, Umin = 1.e+100, Vmax = -1.e+100, Vmin = 1.e+100, cU, cV;
273     if(ext1.IsDone())
274     {
275       for(Standard_Integer i = 1; i <= ext1.NbExt(); i++)
276       {
277         const Extrema_POnSurf & pons = ext1.Point(i);
278         pons.Parameter(cU,cV);
279         if(cU > Umax) Umax = cU;
280         if(cU < Umin) Umin = cU;
281         if(cV > Vmax) Vmax = cV;
282         if(cV < Vmin) Vmin = cV;
283       }
284     }
285     if(ext2.IsDone())
286     {
287       for(Standard_Integer i = 1; i <= ext2.NbExt(); i++)
288       {
289         const Extrema_POnSurf & pons = ext2.Point(i);
290         pons.Parameter(cU,cV);
291         if(cU > Umax) Umax = cU;
292         if(cU < Umin) Umin = cU;
293         if(cV > Vmax) Vmax = cV;
294         if(cV < Vmin) Vmin = cV;
295       }
296     }
297     TP = Max(Abs(Umin),Max(Abs(Umax),Max(Abs(Vmin),Abs(Vmax))));
298   }
299   if(TP == 0.) { TrimS = InfSurf; return; }
300   else
301   {
302     const Standard_Boolean Uinf = Precision::IsNegativeInfinite(InfSurf->FirstUParameter()); 
303     const Standard_Boolean Usup = Precision::IsPositiveInfinite(InfSurf->LastUParameter());
304     const Standard_Boolean Vinf = Precision::IsNegativeInfinite(InfSurf->FirstVParameter()); 
305     const Standard_Boolean Vsup = Precision::IsPositiveInfinite(InfSurf->LastVParameter());
306     Handle(Adaptor3d_HSurface) TmpSS;
307     Standard_Integer IsTrimed = 0;
308     const Standard_Real tp = 1000.0 * TP;
309     if(Vinf && Vsup) { TrimS = InfSurf->VTrim(-tp, tp, 1.0e-7); IsTrimed = 1; }
310     if(Vinf && !Vsup){ TrimS = InfSurf->VTrim(-tp, InfSurf->LastVParameter(), 1.0e-7); IsTrimed = 1; }
311     if(!Vinf && Vsup){ TrimS = InfSurf->VTrim(InfSurf->FirstVParameter(), tp, 1.0e-7); IsTrimed = 1; }
312     if(IsTrimed)
313     {
314       TmpSS = TrimS;
315       if(Uinf && Usup)  TrimS = TmpSS->UTrim(-tp, tp, 1.0e-7);
316       if(Uinf && !Usup) TrimS = TmpSS->UTrim(-tp, InfSurf->LastUParameter(), 1.0e-7);
317       if(!Uinf && Usup) TrimS = TmpSS->UTrim(InfSurf->FirstUParameter(), tp, 1.0e-7);
318     }
319     else
320     {
321       if(Uinf && Usup)  TrimS = InfSurf->UTrim(-tp, tp, 1.0e-7);
322       if(Uinf && !Usup) TrimS = InfSurf->UTrim(-tp, InfSurf->LastUParameter(), 1.0e-7);
323       if(!Uinf && Usup) TrimS = InfSurf->UTrim(InfSurf->FirstUParameter(), tp, 1.0e-7);
324     }
325   }
326 }
327 //================================================================================
328 //function: FUN_GetUiso
329 //================================================================================
330 static void FUN_GetUiso(const Handle(Geom_Surface)& GS,
331                         const GeomAbs_SurfaceType&  T,
332                         const Standard_Real&        FirstV,
333                         const Standard_Real&        LastV,
334                         const Standard_Boolean&     IsVC,
335                         const Standard_Boolean&     IsVP,
336                         const Standard_Real&        U,
337                         Handle(Geom_Curve)&         I)
338 {
339   if(T !=  GeomAbs_OffsetSurface)
340   {
341     Handle(Geom_Curve) gc = GS->UIso(U);
342     if(IsVP && (FirstV == 0.0 && LastV == (2.*M_PI))) I = gc;
343     else
344     {
345       Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstV,LastV);
346       //szv:I = Handle(Geom_Curve)::DownCast(gtc);
347       I = gtc;
348     }
349   }
350   else//OffsetSurface
351   {
352     const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (GS);
353     const Handle(Geom_Surface) bs = gos->BasisSurface();
354     Handle(Geom_Curve) gcbs = bs->UIso(U);
355     GeomAdaptor_Curve gac(gcbs);
356     const GeomAbs_CurveType GACT = gac.GetType();
357     if(IsVP || IsVC || GACT == GeomAbs_BSplineCurve || GACT == GeomAbs_BezierCurve || Abs(LastV - FirstV) < 1.e+5)
358     {
359       Handle(Geom_Curve) gc = gos->UIso(U);
360       if(IsVP && (FirstV == 0.0 && LastV == (2*M_PI))) I = gc;
361       else
362       {
363         Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstV,LastV);
364         //szv:I = Handle(Geom_Curve)::DownCast(gtc);
365         I = gtc;
366       }
367     }
368     else//Offset Line, Parab, Hyperb
369     {
370       Standard_Real VmTr, VMTr;
371       if(GACT != GeomAbs_Hyperbola)
372       {
373         if(FirstV >= 0. && LastV >= 0.){ VmTr = FirstV; VMTr = ((LastV - FirstV) > 1.e+4) ? (FirstV + 1.e+4) : LastV; }
374         else if(FirstV < 0. && LastV < 0.){ VMTr = LastV; VmTr = ((FirstV - LastV) < -1.e+4) ? (LastV - 1.e+4) : FirstV; }
375         else { VmTr = (FirstV < -1.e+4) ? -1.e+4 : FirstV; VMTr = (LastV > 1.e+4) ? 1.e+4 : LastV; }
376       }
377       else//Hyperbola
378       {
379         if(FirstV >= 0. && LastV >= 0.)
380         {
381           if(FirstV > 4.) return;
382           VmTr = FirstV; VMTr = (LastV > 4.) ? 4. : LastV;
383         }
384         else if(FirstV < 0. && LastV < 0.)
385         {
386           if(LastV < -4.) return;
387           VMTr = LastV; VmTr = (FirstV < -4.) ? -4. : FirstV;
388         }
389         else { VmTr = (FirstV < -4.) ? -4. : FirstV; VMTr = (LastV > 4.) ? 4. : LastV; }
390       }
391       //Make trimmed surface
392       Handle(Geom_RectangularTrimmedSurface) rts = new Geom_RectangularTrimmedSurface(gos,VmTr,VMTr,Standard_True);
393       I = rts->UIso(U);
394     }
395   }
396 }
397 //================================================================================
398 //function: FUN_GetViso
399 //================================================================================
400 static void FUN_GetViso(const Handle(Geom_Surface)& GS,
401                         const GeomAbs_SurfaceType&  T,
402                         const Standard_Real&        FirstU,
403                         const Standard_Real&        LastU,
404                         const Standard_Boolean&     IsUC,
405                         const Standard_Boolean&     IsUP,
406                         const Standard_Real&        V,
407                         Handle(Geom_Curve)&         I)
408 {
409   if(T !=  GeomAbs_OffsetSurface)
410   {
411     Handle(Geom_Curve) gc = GS->VIso(V);
412     if(IsUP && (FirstU == 0.0 && LastU == (2*M_PI))) I = gc;
413     else
414     {
415       Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstU,LastU);
416       //szv:I = Handle(Geom_Curve)::DownCast(gtc);
417       I = gtc;
418     }
419   }
420   else//OffsetSurface
421   {
422     const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (GS);
423     const Handle(Geom_Surface) bs = gos->BasisSurface();
424     Handle(Geom_Curve) gcbs = bs->VIso(V);
425     GeomAdaptor_Curve gac(gcbs);
426     const GeomAbs_CurveType GACT = gac.GetType();
427     if(IsUP || IsUC || GACT == GeomAbs_BSplineCurve || GACT == GeomAbs_BezierCurve || Abs(LastU - FirstU) < 1.e+5)
428     {
429       Handle(Geom_Curve) gc = gos->VIso(V);
430       if(IsUP && (FirstU == 0.0 && LastU == (2*M_PI))) I = gc;
431       else
432       {
433         Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstU,LastU);
434         //szv:I = Handle(Geom_Curve)::DownCast(gtc);
435         I = gtc;
436       }
437     }
438     else//Offset Line, Parab, Hyperb
439     {
440       Standard_Real UmTr, UMTr;
441       if(GACT != GeomAbs_Hyperbola)
442       {
443         if(FirstU >= 0. && LastU >= 0.){ UmTr = FirstU; UMTr = ((LastU - FirstU) > 1.e+4) ? (FirstU + 1.e+4) : LastU; }
444         else if(FirstU < 0. && LastU < 0.){ UMTr = LastU; UmTr = ((FirstU - LastU) < -1.e+4) ? (LastU - 1.e+4) : FirstU; }
445         else { UmTr = (FirstU < -1.e+4) ? -1.e+4 : FirstU; UMTr = (LastU > 1.e+4) ? 1.e+4 : LastU; }
446       }
447       else//Hyperbola
448       {
449         if(FirstU >= 0. && LastU >= 0.)
450         {
451           if(FirstU > 4.) return;
452           UmTr = FirstU; UMTr = (LastU > 4.) ? 4. : LastU;
453         }
454         else if(FirstU < 0. && LastU < 0.)
455         {
456           if(LastU < -4.) return;
457           UMTr = LastU; UmTr = (FirstU < -4.) ? -4. : FirstU;
458         }
459         else { UmTr = (FirstU < -4.) ? -4. : FirstU; UMTr = (LastU > 4.) ? 4. : LastU; }
460       }
461       //Make trimmed surface
462       Handle(Geom_RectangularTrimmedSurface) rts = new Geom_RectangularTrimmedSurface(gos,UmTr,UMTr,Standard_True);
463       I = rts->VIso(V);
464     }
465   }
466 }
467 //================================================================================
468 //function: FUN_PL_Intersection
469 //================================================================================
470 static void FUN_PL_Intersection(const Handle(Adaptor3d_HSurface)& S1,
471                                 const GeomAbs_SurfaceType&        T1,
472                                 const Handle(Adaptor3d_HSurface)& S2,
473                                 const GeomAbs_SurfaceType&        T2,
474                                 Standard_Boolean&                 IsOk,
475                                 TColgp_SequenceOfPnt&             SP,
476                                 gp_Vec&                           DV)
477 {
478   IsOk = Standard_False;
479   // 1. Check: both surfaces have U(V)isos - lines.
480   DV = gp_Vec(0.,0.,1.);
481   Standard_Boolean isoS1isLine[2] = {0, 0};
482   Standard_Boolean isoS2isLine[2] = {0, 0};
483   Handle(Geom_Curve) C1, C2;
484   const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
485   const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
486   const Handle(Geom_Surface) gs1 = gas1.Surface();
487   const Handle(Geom_Surface) gs2 = gas2.Surface();
488   Standard_Real MS1[2], MS2[2];
489   MS1[0] = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
490   MS1[1] = 0.5 * (S1->LastVParameter() + S1->FirstVParameter());
491   MS2[0] = 0.5 * (S2->LastUParameter() + S2->FirstUParameter());
492   MS2[1] = 0.5 * (S2->LastVParameter() + S2->FirstVParameter());
493   if(T1 == GeomAbs_SurfaceOfExtrusion) isoS1isLine[0] = Standard_True;
494   else if(!S1->IsVPeriodic() && !S1->IsVClosed()) {
495     if(T1 != GeomAbs_OffsetSurface) C1 = gs1->UIso(MS1[0]);
496     else {
497       const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (gs1);
498       const Handle(Geom_Surface) bs = gos->BasisSurface();
499       C1 = bs->UIso(MS1[0]);
500     }
501     GeomAdaptor_Curve gac(C1);
502     if(gac.GetType() == GeomAbs_Line) isoS1isLine[0] = Standard_True;
503   }
504   if(!S1->IsUPeriodic() && !S1->IsUClosed()) {
505     if(T1 != GeomAbs_OffsetSurface) C1 = gs1->VIso(MS1[1]);
506     else {
507       const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (gs1);
508       const Handle(Geom_Surface) bs = gos->BasisSurface();
509       C1 = bs->VIso(MS1[1]);
510     }
511     GeomAdaptor_Curve gac(C1);
512     if(gac.GetType() == GeomAbs_Line) isoS1isLine[1] = Standard_True;
513   }
514   if(T2 == GeomAbs_SurfaceOfExtrusion) isoS2isLine[0] = Standard_True;
515   else if(!S2->IsVPeriodic() && !S2->IsVClosed()) {
516     if(T2 != GeomAbs_OffsetSurface) C2 = gs2->UIso(MS2[0]);
517     else {
518       const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (gs2);
519       const Handle(Geom_Surface) bs = gos->BasisSurface();
520       C2 = bs->UIso(MS2[0]);
521     }
522     GeomAdaptor_Curve gac(C2);
523     if(gac.GetType() == GeomAbs_Line) isoS2isLine[0] = Standard_True;
524   }
525   if(!S2->IsUPeriodic() && !S2->IsUClosed()) {
526     if(T2 != GeomAbs_OffsetSurface) C2 = gs2->VIso(MS2[1]);
527     else {
528       const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (gs2);
529       const Handle(Geom_Surface) bs = gos->BasisSurface();
530       C2 = bs->VIso(MS2[1]);
531     }
532     GeomAdaptor_Curve gac(C2);
533     if(gac.GetType() == GeomAbs_Line) isoS2isLine[1] = Standard_True;
534   }
535   Standard_Boolean IsBothLines = ((isoS1isLine[0] || isoS1isLine[1]) &&
536                                   (isoS2isLine[0] || isoS2isLine[1]));
537   if(!IsBothLines){
538     return;
539   }
540   // 2. Check: Uiso lines of both surfaces are collinear.
541   gp_Pnt puvS1, puvS2;
542   gp_Vec derS1[2], derS2[2];
543   S1->D1(MS1[0], MS1[1], puvS1, derS1[0], derS1[1]);
544   S2->D1(MS2[0], MS2[1], puvS2, derS2[0], derS2[1]);
545   C1.Nullify(); C2.Nullify();
546   Standard_Integer iso = 0;
547   if(isoS1isLine[0] && isoS2isLine[0] &&
548      derS1[1].IsParallel(derS2[1],Precision::Angular())) {
549     iso = 1;
550     FUN_GetViso(gs1,T1,S1->FirstUParameter(),S1->LastUParameter(),
551                 S1->IsUClosed(),S1->IsUPeriodic(),MS1[1],C1);
552     FUN_GetViso(gs2,T2,S2->FirstUParameter(),S2->LastUParameter(),
553                 S2->IsUClosed(),S2->IsUPeriodic(),MS2[1],C2);
554   }
555   else if(isoS1isLine[0] && isoS2isLine[1] &&
556           derS1[1].IsParallel(derS2[0],Precision::Angular())) {
557     iso = 1;
558     FUN_GetViso(gs1,T1,S1->FirstUParameter(),S1->LastUParameter(),
559                 S1->IsUClosed(),S1->IsUPeriodic(),MS1[1],C1);
560     FUN_GetUiso(gs2,T2,S2->FirstVParameter(),S2->LastVParameter(),
561                 S2->IsVClosed(),S2->IsVPeriodic(),MS2[0],C2);
562   }
563   else if(isoS1isLine[1] && isoS2isLine[0] &&
564           derS1[0].IsParallel(derS2[1],Precision::Angular())) {
565     iso = 0;
566     FUN_GetUiso(gs1,T1,S1->FirstVParameter(),S1->LastVParameter(),
567                 S1->IsVClosed(),S1->IsVPeriodic(),MS1[0],C1);
568     FUN_GetViso(gs2,T2,S2->FirstUParameter(),S2->LastUParameter(),
569                 S2->IsUClosed(),S2->IsUPeriodic(),MS2[1],C2);
570   }
571   else if(isoS1isLine[1] && isoS2isLine[1] &&
572           derS1[0].IsParallel(derS2[0],Precision::Angular())) {
573     iso = 0;
574     FUN_GetUiso(gs1,T1,S1->FirstVParameter(),S1->LastVParameter(),
575                 S1->IsVClosed(),S1->IsVPeriodic(),MS1[0],C1);
576     FUN_GetUiso(gs2,T2,S2->FirstVParameter(),S2->LastVParameter(),
577                 S2->IsVClosed(),S2->IsVPeriodic(),MS2[0],C2);
578   }
579   else {
580     IsOk = Standard_False;
581     return;
582   }
583   IsOk = Standard_True;
584   // 3. Make intersections of V(U)isos
585   if(C1.IsNull() || C2.IsNull()) return;
586   DV = derS1[iso];
587   Handle(Geom_Plane) GPln = new Geom_Plane(gp_Pln(puvS1,gp_Dir(DV)));
588   Handle(Geom_Curve) C1Prj =
589     GeomProjLib::ProjectOnPlane(C1,GPln,gp_Dir(DV),Standard_True);
590   Handle(Geom_Curve) C2Prj =
591     GeomProjLib::ProjectOnPlane(C2,GPln,gp_Dir(DV),Standard_True);
592   if(C1Prj.IsNull() || C2Prj.IsNull()) return;
593   Handle(Geom2d_Curve) C1Prj2d = GeomProjLib::Curve2d (C1Prj,GPln);
594   Handle(Geom2d_Curve) C2Prj2d = GeomProjLib::Curve2d (C2Prj,GPln);
595   Geom2dAPI_InterCurveCurve ICC(C1Prj2d,C2Prj2d,1.0e-7);
596   if(ICC.NbPoints() > 0 )
597   {
598     for(Standard_Integer ip = 1; ip <= ICC.NbPoints(); ip++)
599     {
600       gp_Pnt2d P = ICC.Point(ip);
601       gp_Pnt P3d = ElCLib::To3d(gp_Ax2(puvS1,gp_Dir(DV)),P);
602       SP.Append(P3d);
603     }
604   }
605 }
606 //================================================================================
607 //function: FUN_NewFirstLast
608 //================================================================================
609 static void FUN_NewFirstLast(const GeomAbs_CurveType& ga_ct,
610                              const Standard_Real&     Fst,
611                              const Standard_Real&     Lst,
612                              const Standard_Real&     TrVal,
613                              Standard_Real&           NewFst,
614                              Standard_Real&           NewLst,
615                              Standard_Boolean&        NeedTr)
616 {
617   NewFst = Fst; NewLst = Lst; NeedTr = Standard_False;
618   switch (ga_ct)
619   {
620     case GeomAbs_Line:
621     case GeomAbs_Parabola:
622     {
623       if(Abs(Lst - Fst) > TrVal)
624       {
625         if(Fst >= 0. && Lst >= 0.)
626         {
627           NewFst = Fst;
628           NewLst = ((Fst + TrVal) < Lst) ? (Fst + TrVal) : Lst;
629         }
630         if(Fst < 0. && Lst < 0.)
631         {
632           NewLst = Lst;
633           NewFst = ((Lst - TrVal) > Fst) ? (Lst - TrVal) : Fst;
634         }
635         else
636         {
637           NewFst = (Fst < -TrVal) ? -TrVal : Fst;
638           NewLst = (Lst > TrVal) ? TrVal : Lst;
639         }
640         NeedTr = Standard_True;
641       }
642       break;
643     }
644     case GeomAbs_Hyperbola:
645     {
646       if(Abs(Lst - Fst) > 10.)
647       { 
648         if(Fst >= 0. && Lst >= 0.)
649         {
650           if(Fst > 4.) return;
651           NewFst = Fst;
652           NewLst = (Lst > 4.) ? 4. : Lst;
653         }
654         if(Fst < 0. && Lst < 0.)
655         {
656           if(Lst < -4.) return;
657           NewLst = Lst;
658           NewFst = (Fst < -4.) ? -4. : Fst;
659         }
660         else
661         {
662           NewFst = (Fst < -4.) ? -4. : Fst;
663           NewLst = (Lst > 4.) ? 4. : Lst;
664         }
665         NeedTr = Standard_True;
666       }
667       break;
668     }
669     default:
670     break;
671   }
672 }
673 //================================================================================
674 //function: FUN_TrimBothSurf
675 //================================================================================
676 static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
677                              const GeomAbs_SurfaceType&        T1,
678                              const Handle(Adaptor3d_HSurface)& S2,
679                              const GeomAbs_SurfaceType&        T2,
680                              const Standard_Real&              TV,
681                              Handle(Adaptor3d_HSurface)&       NS1,
682                              Handle(Adaptor3d_HSurface)&       NS2)
683 {
684   const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
685   const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
686   const Handle(Geom_Surface) gs1 = gas1.Surface();
687   const Handle(Geom_Surface) gs2 = gas2.Surface();
688   const Standard_Real UM1 = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
689   const Standard_Real UM2 = 0.5 * (S2->LastUParameter() + S2->FirstUParameter());
690   const Standard_Real VM1 = 0.5 * (S1->LastVParameter() + S1->FirstVParameter());
691   const Standard_Real VM2 = 0.5 * (S2->LastVParameter() + S2->FirstVParameter());
692   Handle(Geom_Curve) visoS1, visoS2, uisoS1, uisoS2;
693   if(T1 != GeomAbs_OffsetSurface){ visoS1 = gs1->VIso(VM1); uisoS1 = gs1->UIso(UM1); }
694   else
695   {
696     const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (gs1);
697     const Handle(Geom_Surface) bs = gos->BasisSurface();
698     visoS1 = bs->VIso(VM1); uisoS1 = bs->UIso(UM1);
699   }
700   if(T2 != GeomAbs_OffsetSurface){ visoS2 = gs2->VIso(VM2); uisoS2 = gs2->UIso(UM2); }
701   else
702   {
703     const Handle(Geom_OffsetSurface) gos = Handle(Geom_OffsetSurface)::DownCast (gs2);
704     const Handle(Geom_Surface) bs = gos->BasisSurface();
705     visoS2 = bs->VIso(VM2); uisoS2 = bs->UIso(UM2);
706   }
707   if(uisoS1.IsNull() || uisoS2.IsNull() || visoS1.IsNull() || visoS2.IsNull()){ NS1 = S1; NS2 = S2; return; }
708   GeomAdaptor_Curve gau1(uisoS1);
709   GeomAdaptor_Curve gav1(visoS1);
710   GeomAdaptor_Curve gau2(uisoS2);
711   GeomAdaptor_Curve gav2(visoS2);
712   GeomAbs_CurveType GA_U1 = gau1.GetType();
713   GeomAbs_CurveType GA_V1 = gav1.GetType();
714   GeomAbs_CurveType GA_U2 = gau2.GetType();
715   GeomAbs_CurveType GA_V2 = gav2.GetType();
716   Standard_Boolean TrmU1 = Standard_False;
717   Standard_Boolean TrmV1 = Standard_False;
718   Standard_Boolean TrmU2 = Standard_False;
719   Standard_Boolean TrmV2 = Standard_False;
720   Standard_Real V1S1,V2S1,U1S1,U2S1, V1S2,V2S2,U1S2,U2S2;
721   FUN_NewFirstLast(GA_U1,S1->FirstVParameter(),S1->LastVParameter(),TV,V1S1,V2S1,TrmV1);
722   FUN_NewFirstLast(GA_V1,S1->FirstUParameter(),S1->LastUParameter(),TV,U1S1,U2S1,TrmU1);
723   FUN_NewFirstLast(GA_U2,S2->FirstVParameter(),S2->LastVParameter(),TV,V1S2,V2S2,TrmV2);
724   FUN_NewFirstLast(GA_V2,S2->FirstUParameter(),S2->LastUParameter(),TV,U1S2,U2S2,TrmU2);
725   if(TrmV1) NS1 = S1->VTrim(V1S1, V2S1, 1.0e-7);
726   if(TrmV2) NS2 = S2->VTrim(V1S2, V2S2, 1.0e-7);
727   if(TrmU1)
728   {
729     if(TrmV1)
730     {
731       Handle(Adaptor3d_HSurface) TS = NS1;
732       NS1 = TS->UTrim(U1S1, U2S1, 1.0e-7);
733     }
734     else NS1 = S1->UTrim(U1S1, U2S1, 1.0e-7);
735   }
736   if(TrmU2)
737   {
738     if(TrmV2)
739     {
740       Handle(Adaptor3d_HSurface) TS = NS2;
741       NS2 = TS->UTrim(U1S2, U2S2, 1.0e-7);
742     }
743     else NS2 = S2->UTrim(U1S2, U2S2, 1.0e-7);
744   }
745 }
746
747 //=======================================================================
748 //function : Perform
749 //purpose  : 
750 //=======================================================================
751 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  theS1,
752                                     const Handle(Adaptor3d_TopolTool)& theD1,
753                                     const Handle(Adaptor3d_HSurface)&  theS2,
754                                     const Handle(Adaptor3d_TopolTool)& theD2,
755                                     const Standard_Real TolArc,
756                                     const Standard_Real TolTang,
757                                     const Standard_Boolean isGeomInt,
758                                     const Standard_Boolean theIsReqToKeepRLine,
759                                     const Standard_Boolean theIsReqToPostWLProc)
760 {
761   myTolArc = TolArc;
762   myTolTang = TolTang;
763   if(myFleche <= Precision::PConfusion())
764     myFleche = 0.01;
765   if(myUVMaxStep <= Precision::PConfusion())
766     myUVMaxStep = 0.01;
767
768   done = Standard_False;
769   spnt.Clear();
770   slin.Clear();
771   empt = Standard_True;
772   tgte = Standard_False;
773   oppo = Standard_False;
774
775   GeomAbs_SurfaceType typs1 = theS1->GetType();
776   GeomAbs_SurfaceType typs2 = theS2->GetType();
777   
778   //treatment of the cases with cone or torus
779   Standard_Boolean TreatAsBiParametric = Standard_False;
780   Standard_Integer bGeomGeom = 0;
781   //
782   if (typs1 == GeomAbs_Cone  || typs2 == GeomAbs_Cone ||
783       typs1 == GeomAbs_Torus || typs2 == GeomAbs_Torus) {
784     gp_Ax1 aCTAx, aGeomAx;
785     GeomAbs_SurfaceType aCTType;
786     Standard_Boolean bToCheck;
787     //
788     const Handle(Adaptor3d_HSurface)& aCTSurf = 
789       (typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS1 : theS2;
790     const Handle(Adaptor3d_HSurface)& aGeomSurf = 
791       (typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS2 : theS1;
792     //
793     aCTType = aCTSurf->GetType();
794     bToCheck = Standard_False;
795     //
796     if (typs1 == GeomAbs_Cone  || typs2 == GeomAbs_Cone) {
797       const gp_Cone aCon1 = (aCTType == GeomAbs_Cone) ? 
798         aCTSurf->Cone() : aGeomSurf->Cone();
799       Standard_Real a1 = Abs(aCon1.SemiAngle());
800       bToCheck = (a1 < 0.02) || (a1 > 1.55);
801       //
802       if (typs1 == typs2) {
803         const gp_Cone aCon2 = aGeomSurf->Cone();
804         Standard_Real a2 = Abs(aCon2.SemiAngle());
805         bToCheck = bToCheck || (a2 < 0.02) || (a2 > 1.55);
806         //
807         if (a1 > 1.55 && a2 > 1.55) {//quasi-planes: if same domain, treat as canonic
808           const gp_Ax1 A1 = aCon1.Axis(), A2 = aCon2.Axis();
809           if (A1.IsParallel(A2,Precision::Angular())) {
810             const gp_Pnt Apex1 = aCon1.Apex(), Apex2 = aCon2.Apex();
811             const gp_Pln Plan1( Apex1, A1.Direction() );
812             if (Plan1.Distance( Apex2 ) <= Precision::Confusion()) {
813               bToCheck = Standard_False;
814             }
815           }
816         }
817       }
818       //
819       TreatAsBiParametric = bToCheck;
820       if (aCTType == GeomAbs_Cone) {
821         aCTAx = aCon1.Axis();
822       }
823     }
824     //
825     if (typs1 == GeomAbs_Torus || typs2 == GeomAbs_Torus) {
826       const gp_Torus aTor1 = (aCTType == GeomAbs_Torus) ? 
827         aCTSurf->Torus() : aGeomSurf->Torus();
828       bToCheck = aTor1.MajorRadius() > aTor1.MinorRadius();
829       if (typs1 == typs2) {
830         const gp_Torus aTor2 = aGeomSurf->Torus();
831         bToCheck = aTor2.MajorRadius() > aTor2.MinorRadius();
832       }
833       //
834       if (aCTType == GeomAbs_Torus) {
835         aCTAx = aTor1.Axis();
836       }
837     }
838     //
839     if (bToCheck) {
840       const gp_Lin aL1(aCTAx);
841       //
842       switch (aGeomSurf->GetType()) {
843       case GeomAbs_Plane: {
844         aGeomAx = aGeomSurf->Plane().Axis();
845         if (aCTType == GeomAbs_Cone) {
846           bGeomGeom = 1;
847           if (Abs(aCTSurf->Cone().SemiAngle()) < 0.02) {
848             Standard_Real ps = Abs(aCTAx.Direction().Dot(aGeomAx.Direction()));
849             if(ps < 0.015) {
850               bGeomGeom = 0;
851             }
852           }
853         }
854         else {
855           if (aCTAx.IsParallel(aGeomAx, Precision::Angular()) ||
856               (aCTAx.IsNormal(aGeomAx, Precision::Angular()) && 
857                (aGeomSurf->Plane().Distance(aCTAx.Location()) < Precision::Confusion()))) {
858             bGeomGeom = 1;
859           }
860         }
861         bToCheck = Standard_False;
862         break;
863       }
864       case GeomAbs_Sphere: {
865         if (aL1.Distance(aGeomSurf->Sphere().Location()) < Precision::Confusion()) {
866           bGeomGeom = 1;
867         }
868         bToCheck = Standard_False;
869         break;
870       }
871       case GeomAbs_Cylinder:
872         aGeomAx = aGeomSurf->Cylinder().Axis();
873         break;
874       case GeomAbs_Cone: 
875         aGeomAx = aGeomSurf->Cone().Axis();
876         break;
877       case GeomAbs_Torus: 
878         aGeomAx = aGeomSurf->Torus().Axis();
879         break;
880       default: 
881         bToCheck = Standard_False;
882         break;
883       }
884       //
885       if (bToCheck) {
886         if (aCTAx.IsParallel(aGeomAx, Precision::Angular()) &&
887             (aL1.Distance(aGeomAx.Location()) <= Precision::Confusion())) {
888           bGeomGeom = 1;
889         }
890       }
891       //
892       if (bGeomGeom == 1) {
893         TreatAsBiParametric = Standard_False;
894       }
895     }
896   }
897   //
898
899   if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) {
900     TreatAsBiParametric= Standard_False;
901   }
902
903 //  Modified by skv - Mon Sep 26 14:58:30 2005 Begin
904 //   if(TreatAsBiParametric) { typs1 = typs2 = GeomAbs_BezierSurface; }
905   if(TreatAsBiParametric)
906   {
907     if (typs1 == GeomAbs_Cone && typs2 == GeomAbs_Plane)
908       typs1 = GeomAbs_BezierSurface; // Using Imp-Prm Intersector
909     else if (typs1 == GeomAbs_Plane && typs2 == GeomAbs_Cone)
910       typs2 = GeomAbs_BezierSurface; // Using Imp-Prm Intersector
911     else {
912       // Using Prm-Prm Intersector
913       typs1 = GeomAbs_BezierSurface;
914       typs2 = GeomAbs_BezierSurface;
915     }
916   }
917 //  Modified by skv - Mon Sep 26 14:58:30 2005 End
918
919   // Surface type definition
920   Standard_Integer ts1 = 0;
921   switch (typs1)
922   {
923     case GeomAbs_Plane:
924     case GeomAbs_Cylinder:
925     case GeomAbs_Sphere:
926     case GeomAbs_Cone: ts1 = 1; break;
927     case GeomAbs_Torus: ts1 = bGeomGeom; break;
928     default: break;
929   }
930
931   Standard_Integer ts2 = 0;
932   switch (typs2)
933   {
934     case GeomAbs_Plane:
935     case GeomAbs_Cylinder:
936     case GeomAbs_Sphere:
937     case GeomAbs_Cone: ts2 = 1; break;
938     case GeomAbs_Torus: ts2 = bGeomGeom; break;
939     default: break;
940   }
941   //
942   // treatment of the cases with torus and any other geom surface
943   //
944   // Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
945   //                              2. ts1 != ts2      <Geom-Param>
946   //                              3. ts1 == ts2 == 0 <Param-Param>
947
948   // Geom - Geom
949   if(ts1 == ts2 && ts1 == 1)
950   {
951     IntSurf_ListOfPntOn2S ListOfPnts;
952     ListOfPnts.Clear();
953     if(isGeomInt)
954     {
955       GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang,
956                      ListOfPnts, typs1, typs2, theIsReqToKeepRLine);
957     }
958     else
959     {
960       ParamParamPerfom(theS1, theD1, theS2, theD2, 
961               TolArc, TolTang, ListOfPnts, typs1, typs2);
962     }
963   }
964
965   // Geom - Param
966   if(ts1 != ts2)
967   {
968     GeomParamPerfom(theS1, theD1, theS2, theD2, ts1 == 0, typs1, typs2);
969   }
970
971   // Param - Param 
972   if(ts1 == ts2 && ts1 == 0)
973   {
974     IntSurf_ListOfPntOn2S ListOfPnts;
975     ListOfPnts.Clear();
976
977     ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc,
978                         TolTang, ListOfPnts, typs1, typs2);
979   }
980
981   if(!theIsReqToPostWLProc)
982     return;
983
984   for(Standard_Integer i = slin.Lower(); i <= slin.Upper(); i++)
985   {
986     Handle(IntPatch_WLine) aWL = Handle(IntPatch_WLine)::DownCast(slin.Value(i));
987
988     if(aWL.IsNull())
989       continue;
990
991     if (!aWL->IsPurgingAllowed())
992       continue;
993
994     Handle(IntPatch_WLine) aRW =
995       IntPatch_WLineTool::ComputePurgedWLine(aWL, theS1, theS2, theD1, theD2);
996
997     if(aRW.IsNull())
998       continue;
999
1000     slin.InsertAfter(i, aRW);
1001     slin.Remove(i);
1002   }
1003 }
1004
1005 //=======================================================================
1006 //function : Perform
1007 //purpose  : 
1008 //=======================================================================
1009 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  theS1,
1010                                     const Handle(Adaptor3d_TopolTool)& theD1,
1011                                     const Handle(Adaptor3d_HSurface)&  theS2,
1012                                     const Handle(Adaptor3d_TopolTool)& theD2,
1013                                     const Standard_Real TolArc,
1014                                     const Standard_Real TolTang,
1015                                     IntSurf_ListOfPntOn2S& ListOfPnts,
1016                                     const Standard_Boolean isGeomInt,
1017                                     const Standard_Boolean theIsReqToKeepRLine,
1018                                     const Standard_Boolean theIsReqToPostWLProc)
1019 {
1020   myTolArc = TolArc;
1021   myTolTang = TolTang;
1022   if(myFleche <= Precision::PConfusion())
1023     myFleche = 0.01;
1024   if(myUVMaxStep <= Precision::PConfusion())
1025     myUVMaxStep = 0.01;
1026     
1027   done = Standard_False;
1028   spnt.Clear();
1029   slin.Clear();
1030   empt = Standard_True;
1031   tgte = Standard_False;
1032   oppo = Standard_False;
1033
1034   GeomAbs_SurfaceType typs1 = theS1->GetType();
1035   GeomAbs_SurfaceType typs2 = theS2->GetType();
1036   //
1037   //treatment of the cases with cone or torus
1038   Standard_Boolean TreatAsBiParametric = Standard_False;
1039   Standard_Integer bGeomGeom = 0;
1040   //
1041   if (typs1 == GeomAbs_Cone  || typs2 == GeomAbs_Cone ||
1042       typs1 == GeomAbs_Torus || typs2 == GeomAbs_Torus) {
1043     gp_Ax1 aCTAx, aGeomAx;
1044     GeomAbs_SurfaceType aCTType;
1045     Standard_Boolean bToCheck;
1046     //
1047     const Handle(Adaptor3d_HSurface)& aCTSurf = 
1048       (typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS1 : theS2;
1049     const Handle(Adaptor3d_HSurface)& aGeomSurf = 
1050       (typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS2 : theS1;
1051     //
1052     aCTType = aCTSurf->GetType();
1053     bToCheck = Standard_False;
1054     //
1055     if (typs1 == GeomAbs_Cone  || typs2 == GeomAbs_Cone) {
1056       const gp_Cone aCon1 = (aCTType == GeomAbs_Cone) ? 
1057         aCTSurf->Cone() : aGeomSurf->Cone();
1058       Standard_Real a1 = Abs(aCon1.SemiAngle());
1059       bToCheck = (a1 < 0.02) || (a1 > 1.55);
1060       //
1061       if (typs1 == typs2) {
1062         const gp_Cone aCon2 = aGeomSurf->Cone();
1063         Standard_Real a2 = Abs(aCon2.SemiAngle());
1064         bToCheck = bToCheck || (a2 < 0.02) || (a2 > 1.55);
1065         //
1066         if (a1 > 1.55 && a2 > 1.55) {//quasi-planes: if same domain, treat as canonic
1067           const gp_Ax1 A1 = aCon1.Axis(), A2 = aCon2.Axis();
1068           if (A1.IsParallel(A2,Precision::Angular())) {
1069             const gp_Pnt Apex1 = aCon1.Apex(), Apex2 = aCon2.Apex();
1070             const gp_Pln Plan1( Apex1, A1.Direction() );
1071             if (Plan1.Distance( Apex2 ) <= Precision::Confusion()) {
1072               bToCheck = Standard_False;
1073             }
1074           }
1075         }
1076       }
1077       //
1078       TreatAsBiParametric = bToCheck;
1079       if (aCTType == GeomAbs_Cone) {
1080         aCTAx = aCon1.Axis();
1081       }
1082     }
1083     //
1084     if (typs1 == GeomAbs_Torus || typs2 == GeomAbs_Torus) {
1085       const gp_Torus aTor1 = (aCTType == GeomAbs_Torus) ? 
1086         aCTSurf->Torus() : aGeomSurf->Torus();
1087       bToCheck = aTor1.MajorRadius() > aTor1.MinorRadius();
1088       if (typs1 == typs2) {
1089         const gp_Torus aTor2 = aGeomSurf->Torus();
1090         bToCheck = (bToCheck && (aTor2.MajorRadius() > aTor2.MinorRadius())) ||
1091                    (Abs(aTor1.MajorRadius() - aTor2.MajorRadius()) < TolTang &&
1092                     Abs(aTor1.MinorRadius() - aTor2.MinorRadius()) < TolTang);
1093       }
1094       //
1095       if (aCTType == GeomAbs_Torus) {
1096         aCTAx = aTor1.Axis();
1097       }
1098     }
1099     //
1100     if (bToCheck) {
1101       const gp_Lin aL1(aCTAx);
1102       //
1103       switch (aGeomSurf->GetType()) {
1104       case GeomAbs_Plane: {
1105         aGeomAx = aGeomSurf->Plane().Axis();
1106         if (aCTType == GeomAbs_Cone) {
1107           bGeomGeom = 1;
1108           if (Abs(aCTSurf->Cone().SemiAngle()) < 0.02) {
1109             Standard_Real ps = Abs(aCTAx.Direction().Dot(aGeomAx.Direction()));
1110             if(ps < 0.015) {
1111               bGeomGeom = 0;
1112             }
1113           }
1114         }
1115         else {
1116           if (aCTAx.IsParallel(aGeomAx, Precision::Angular()) ||
1117               (aCTAx.IsNormal(aGeomAx, Precision::Angular()) && 
1118                (aGeomSurf->Plane().Distance(aCTAx.Location()) < Precision::Confusion()))) {
1119             bGeomGeom = 1;
1120           }
1121         }
1122         bToCheck = Standard_False;
1123         break;
1124       }
1125       case GeomAbs_Sphere: {
1126         if (aL1.Distance(aGeomSurf->Sphere().Location()) < Precision::Confusion()) {
1127           bGeomGeom = 1;
1128         }
1129         bToCheck = Standard_False;
1130         break;
1131       }
1132       case GeomAbs_Cylinder:
1133         aGeomAx = aGeomSurf->Cylinder().Axis();
1134         break;
1135       case GeomAbs_Cone: 
1136         aGeomAx = aGeomSurf->Cone().Axis();
1137         break;
1138       case GeomAbs_Torus: 
1139         aGeomAx = aGeomSurf->Torus().Axis();
1140         break;
1141       default: 
1142         bToCheck = Standard_False;
1143         break;
1144       }
1145       //
1146       if (bToCheck) {
1147         if (aCTAx.IsParallel(aGeomAx, Precision::Angular()) &&
1148             (aL1.Distance(aGeomAx.Location()) <= Precision::Confusion())) {
1149           bGeomGeom = 1;
1150         }
1151       }
1152       //
1153       if (bGeomGeom == 1) {
1154         TreatAsBiParametric = Standard_False;
1155       }
1156     }
1157   }
1158   //
1159
1160   if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) {
1161     TreatAsBiParametric= Standard_False;
1162   }
1163
1164   if(TreatAsBiParametric)
1165   {
1166     // Using Prm-Prm Intersector
1167     typs1 = GeomAbs_BezierSurface;
1168     typs2 = GeomAbs_BezierSurface;
1169   }
1170
1171   // Surface type definition
1172   Standard_Integer ts1 = 0;
1173   switch (typs1)
1174   {
1175     case GeomAbs_Plane:
1176     case GeomAbs_Cylinder:
1177     case GeomAbs_Sphere:
1178     case GeomAbs_Cone: ts1 = 1; break;
1179     case GeomAbs_Torus: ts1 = bGeomGeom; break;
1180     default: break;
1181   }
1182
1183   Standard_Integer ts2 = 0;
1184   switch (typs2)
1185   {
1186     case GeomAbs_Plane:
1187     case GeomAbs_Cylinder:
1188     case GeomAbs_Sphere:
1189     case GeomAbs_Cone: ts2 = 1; break;
1190     case GeomAbs_Torus: ts2 = bGeomGeom; break;
1191     default: break;
1192   }
1193   //
1194   // Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
1195   //                              2. ts1 != ts2      <Geom-Param>
1196   //                              3. ts1 == ts2 == 0 <Param-Param>
1197
1198   if(!isGeomInt)
1199   {
1200     ParamParamPerfom(theS1, theD1, theS2, theD2, 
1201                 TolArc, TolTang, ListOfPnts, typs1, typs2);
1202   }
1203   else if(ts1 != ts2)
1204   {
1205     GeomParamPerfom(theS1, theD1, theS2, theD2, ts1 == 0, typs1, typs2);
1206   }
1207   else if (ts1 == 0)
1208   {
1209     ParamParamPerfom(theS1, theD1, theS2, theD2,
1210                 TolArc, TolTang, ListOfPnts, typs1, typs2);
1211   }
1212   else if(ts1 == 1)
1213   {
1214     GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang,
1215                    ListOfPnts, typs1, typs2, theIsReqToKeepRLine);
1216   }
1217
1218   if(!theIsReqToPostWLProc)
1219     return;
1220
1221   for(Standard_Integer i = slin.Lower(); i <= slin.Upper(); i++)
1222   {
1223     Handle(IntPatch_WLine) aWL = Handle(IntPatch_WLine)::DownCast(slin.Value(i));
1224
1225     if(aWL.IsNull())
1226       continue;
1227
1228     if(!aWL->IsPurgingAllowed())
1229       continue;
1230
1231     Handle(IntPatch_WLine) aRW = 
1232       IntPatch_WLineTool::ComputePurgedWLine(aWL, theS1, theS2, theD1, theD2);
1233
1234     if(aRW.IsNull())
1235       continue;
1236
1237     slin.InsertAfter(i, aRW);
1238     slin.Remove(i);
1239   }
1240 }
1241
1242 //=======================================================================
1243 //function : ParamParamPerfom
1244 //purpose  : 
1245 //=======================================================================
1246 void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)&  theS1,
1247                                              const Handle(Adaptor3d_TopolTool)& theD1,
1248                                              const Handle(Adaptor3d_HSurface)&  theS2,
1249                                              const Handle(Adaptor3d_TopolTool)& theD2,
1250                                              const Standard_Real TolArc,
1251                                              const Standard_Real TolTang,
1252                                              IntSurf_ListOfPntOn2S& ListOfPnts,
1253                                              const GeomAbs_SurfaceType typs1,
1254                                              const GeomAbs_SurfaceType typs2)
1255 {
1256   IntPatch_PrmPrmIntersection interpp;
1257   if(!theD1->DomainIsInfinite() && !theD2->DomainIsInfinite())
1258   {
1259     Standard_Boolean ClearFlag = Standard_True;
1260     if(!ListOfPnts.IsEmpty())
1261     {
1262       interpp.Perform(theS1,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep, ListOfPnts);
1263       ClearFlag = Standard_False;
1264     }
1265     interpp.Perform(theS1,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep,ClearFlag);
1266   }
1267   else if((theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite()))
1268   {
1269     gp_Pnt pMaxXYZ, pMinXYZ;
1270     if(theD1->DomainIsInfinite())
1271     {
1272       FUN_GetMinMaxXYZPnt( theS2, pMinXYZ, pMaxXYZ );
1273       const Standard_Real MU = Max(Abs(theS2->FirstUParameter()),Abs(theS2->LastUParameter()));
1274       const Standard_Real MV = Max(Abs(theS2->FirstVParameter()),Abs(theS2->LastVParameter()));
1275       const Standard_Real AP = Max(MU, MV);
1276       Handle(Adaptor3d_HSurface) SS;
1277       FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS1, AP, SS);
1278       interpp.Perform(SS,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep);
1279     }
1280     else
1281     {
1282       FUN_GetMinMaxXYZPnt( theS1, pMinXYZ, pMaxXYZ );
1283       const Standard_Real MU = Max(Abs(theS1->FirstUParameter()),Abs(theS1->LastUParameter()));
1284       const Standard_Real MV = Max(Abs(theS1->FirstVParameter()),Abs(theS1->LastVParameter()));
1285       const Standard_Real AP = Max(MU, MV);
1286       Handle(Adaptor3d_HSurface) SS;
1287       FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS2, AP, SS);
1288       interpp.Perform(theS1, theD1, SS, theD2,TolTang, TolArc,myFleche,myUVMaxStep);
1289     }
1290   }//(theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite())
1291   else
1292   {
1293     if(typs1 == GeomAbs_OtherSurface || typs2 == GeomAbs_OtherSurface)
1294     {
1295       done = Standard_False;
1296       return;
1297     }
1298
1299     Standard_Boolean IsPLInt = Standard_False;
1300     TColgp_SequenceOfPnt sop;
1301     gp_Vec v;
1302     FUN_PL_Intersection(theS1,typs1,theS2,typs2,IsPLInt,sop,v);
1303
1304     if(IsPLInt)
1305     {
1306       if(sop.Length() > 0)
1307       {
1308         for(Standard_Integer ip = 1; ip <= sop.Length(); ip++)
1309         {
1310           gp_Lin lin(sop.Value(ip),gp_Dir(v));
1311           Handle(IntPatch_Line) gl = new IntPatch_GLine(lin,Standard_False);
1312           slin.Append(gl);
1313         }
1314
1315         done = Standard_True;
1316       }
1317       else
1318         done = Standard_False;
1319
1320       return;
1321     }// 'COLLINEAR LINES'
1322     else
1323     {
1324       Handle(Adaptor3d_HSurface) nS1 = theS1;
1325       Handle(Adaptor3d_HSurface) nS2 = theS2;
1326       FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+8,nS1,nS2);
1327       interpp.Perform(nS1,theD1,nS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep);
1328     }// 'NON - COLLINEAR LINES'
1329   }// both domains are infinite
1330
1331   if (interpp.IsDone())
1332   {
1333     done = Standard_True;
1334     tgte = Standard_False;
1335     empt = interpp.IsEmpty();
1336
1337     for(Standard_Integer i = 1; i <= interpp.NbLines(); i++)
1338     {
1339       if(interpp.Line(i)->ArcType() != IntPatch_Walking)
1340         slin.Append(interpp.Line(i));
1341     }
1342
1343     for (Standard_Integer i = 1; i <= interpp.NbLines(); i++)
1344     {
1345       if(interpp.Line(i)->ArcType() == IntPatch_Walking)
1346         slin.Append(interpp.Line(i));
1347     }
1348   }
1349 }
1350
1351 //=======================================================================
1352 ////function : GeomGeomPerfom
1353 //purpose  : 
1354 //=======================================================================
1355 void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& theS1,
1356                                            const Handle(Adaptor3d_TopolTool)& theD1,
1357                                            const Handle(Adaptor3d_HSurface)& theS2,
1358                                            const Handle(Adaptor3d_TopolTool)& theD2,
1359                                            const Standard_Real TolArc,
1360                                            const Standard_Real TolTang,
1361                                            IntSurf_ListOfPntOn2S& ListOfPnts,
1362                                            const GeomAbs_SurfaceType theTyps1,
1363                                            const GeomAbs_SurfaceType theTyps2,
1364                                            const Standard_Boolean theIsReqToKeepRLine)
1365 {
1366   IntPatch_ImpImpIntersection interii(theS1,theD1,theS2,theD2,
1367                                       myTolArc,myTolTang, theIsReqToKeepRLine);
1368
1369   if (!interii.IsDone())
1370   {
1371     done = Standard_False;
1372     ParamParamPerfom(theS1, theD1, theS2, theD2, 
1373                 TolArc, TolTang, ListOfPnts, theTyps1, theTyps2);
1374     return;
1375   }
1376
1377   done = (interii.GetStatus() == IntPatch_ImpImpIntersection::IntStatus_OK);
1378   empt = interii.IsEmpty();
1379
1380   if(empt)
1381   {
1382     return;
1383   }
1384
1385   const Standard_Integer aNbPointsInALine = 200;
1386
1387   tgte = interii.TangentFaces();
1388   if (tgte)
1389     oppo = interii.OppositeFaces();
1390
1391   Standard_Boolean isWLExist = Standard_False;
1392   IntPatch_ALineToWLine AToW(theS1, theS2, aNbPointsInALine);
1393
1394   for (Standard_Integer i = 1; i <= interii.NbLines(); i++)
1395   {
1396     const Handle(IntPatch_Line)& line = interii.Line(i);
1397     if (line->ArcType() == IntPatch_Analytic)
1398     {
1399       isWLExist = Standard_True;
1400       AToW.MakeWLine(Handle(IntPatch_ALine)::DownCast(line), slin);
1401     }
1402     else
1403     {
1404       if (line->ArcType() == IntPatch_Walking)
1405       {
1406         Handle(IntPatch_WLine)::DownCast(line)->EnablePurging(Standard_False);
1407       }
1408
1409       if((line->ArcType() != IntPatch_Restriction) || theIsReqToKeepRLine)
1410         slin.Append(line);
1411     }
1412   }
1413
1414   for (Standard_Integer i = 1; i <= interii.NbPnts(); i++)
1415   {
1416     spnt.Append(interii.Point(i));
1417   }
1418
1419   if((theTyps1 == GeomAbs_Cylinder) && (theTyps2 == GeomAbs_Cylinder))
1420   {
1421     IntPatch_WLineTool::JoinWLines(slin, spnt, theS1, theS2, TolTang);
1422   }
1423
1424   if(isWLExist)
1425   {
1426     Bnd_Box2d aBx1, aBx2;
1427     const Standard_Real aU1F = theS1->FirstUParameter(),
1428                         aU1L = theS1->LastUParameter(),
1429                         aV1F = theS1->FirstVParameter(),
1430                         aV1L = theS1->LastVParameter(),
1431                         aU2F = theS2->FirstUParameter(),
1432                         aU2L = theS2->LastUParameter(),
1433                         aV2F = theS2->FirstVParameter(),
1434                         aV2L = theS2->LastVParameter();
1435     aBx1.Add(gp_Pnt2d(aU1F, aV1F));
1436     aBx1.Add(gp_Pnt2d(aU1L, aV1F));
1437     aBx1.Add(gp_Pnt2d(aU1L, aV1L));
1438     aBx1.Add(gp_Pnt2d(aU1F, aV1L));
1439     aBx2.Add(gp_Pnt2d(aU2F, aV2F));
1440     aBx2.Add(gp_Pnt2d(aU2L, aV2F));
1441     aBx2.Add(gp_Pnt2d(aU2L, aV2L));
1442     aBx2.Add(gp_Pnt2d(aU2F, aV2L));
1443
1444     aBx1.Enlarge(Precision::PConfusion());
1445     aBx2.Enlarge(Precision::PConfusion());
1446
1447     const Standard_Real
1448             anArrOfPeriod[4] = {theS1->IsUPeriodic()? theS1->UPeriod() : 0.0,
1449                                 theS1->IsVPeriodic()? theS1->VPeriod() : 0.0,
1450                                 theS2->IsUPeriodic()? theS2->UPeriod() : 0.0,
1451                                 theS2->IsVPeriodic()? theS2->VPeriod() : 0.0};
1452
1453     NCollection_List<gp_Pnt> aListOfCriticalPoints;
1454
1455     if (theS1->GetType() == GeomAbs_Cone)
1456     {
1457       aListOfCriticalPoints.Append(theS1->Cone().Apex());
1458     }
1459     else if (theS1->GetType() == GeomAbs_Sphere)
1460     {
1461       aListOfCriticalPoints.Append(theS1->Value(0.0, M_PI_2));
1462       aListOfCriticalPoints.Append(theS1->Value(0.0, -M_PI_2));
1463     }
1464
1465     if (theS2->GetType() == GeomAbs_Cone)
1466     {
1467       aListOfCriticalPoints.Append(theS2->Cone().Apex());
1468     }
1469     else if (theS2->GetType() == GeomAbs_Sphere)
1470     {
1471       aListOfCriticalPoints.Append(theS2->Value(0.0, M_PI_2));
1472       aListOfCriticalPoints.Append(theS2->Value(0.0, -M_PI_2));
1473     }
1474
1475     IntPatch_WLineTool::ExtendTwoWLines(slin, theS1, theS2, TolTang,
1476                                         anArrOfPeriod, aBx1, aBx2,
1477                                         aListOfCriticalPoints);
1478   }
1479 }
1480
1481 //=======================================================================
1482 //function : GeomParamPerfom
1483 //purpose  : 
1484 //=======================================================================
1485 void IntPatch_Intersection::
1486   GeomParamPerfom(const Handle(Adaptor3d_HSurface)&  theS1,
1487                   const Handle(Adaptor3d_TopolTool)& theD1,
1488                   const Handle(Adaptor3d_HSurface)&  theS2,
1489                   const Handle(Adaptor3d_TopolTool)& theD2,
1490                   const Standard_Boolean isNotAnalitical,
1491                   const GeomAbs_SurfaceType typs1,
1492                   const GeomAbs_SurfaceType typs2)
1493 {
1494   IntPatch_ImpPrmIntersection interip;
1495   if (myIsStartPnt)
1496   {
1497     if (isNotAnalitical/*ts1 == 0*/)
1498       interip.SetStartPoint(myU1Start,myV1Start);
1499     else
1500       interip.SetStartPoint(myU2Start,myV2Start);
1501   }
1502
1503   if(theD1->DomainIsInfinite() && theD2->DomainIsInfinite())
1504   {
1505     Standard_Boolean IsPLInt = Standard_False;
1506     TColgp_SequenceOfPnt sop;
1507     gp_Vec v;
1508     FUN_PL_Intersection(theS1,typs1,theS2,typs2,IsPLInt,sop,v);
1509     
1510     if(IsPLInt)
1511     {
1512       if(sop.Length() > 0)
1513       {
1514         for(Standard_Integer ip = 1; ip <= sop.Length(); ip++)
1515         {
1516           gp_Lin lin(sop.Value(ip),gp_Dir(v));
1517           Handle(IntPatch_Line) gl = new IntPatch_GLine(lin,Standard_False);
1518           slin.Append(gl);
1519         }
1520
1521         done = Standard_True;
1522       }
1523       else
1524         done = Standard_False;
1525
1526       return;
1527     }
1528     else
1529     {
1530       Handle(Adaptor3d_HSurface) nS1 = theS1;
1531       Handle(Adaptor3d_HSurface) nS2 = theS2;
1532       FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+5,nS1,nS2);
1533       interip.Perform(nS1,theD1,nS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
1534     }
1535   }
1536   else
1537     interip.Perform(theS1,theD1,theS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
1538
1539   if (interip.IsDone()) 
1540   {
1541     done = Standard_True;
1542     empt = interip.IsEmpty();
1543
1544     if (!empt)
1545     {
1546       const Standard_Integer aNbLines = interip.NbLines();
1547       for(Standard_Integer i = 1; i <= aNbLines; i++)
1548       {
1549         if(interip.Line(i)->ArcType() != IntPatch_Walking)
1550           slin.Append(interip.Line(i));
1551       }
1552
1553       for(Standard_Integer i = 1; i <= aNbLines; i++)
1554       {
1555         if(interip.Line(i)->ArcType() == IntPatch_Walking)
1556           slin.Append(interip.Line(i));
1557       }
1558
1559       for (Standard_Integer i = 1; i <= interip.NbPnts(); i++)
1560         spnt.Append(interip.Point(i));
1561     }
1562   }
1563 }
1564
1565 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)&  S1,
1566                                     const Handle(Adaptor3d_TopolTool)& D1,
1567                                     const Handle(Adaptor3d_HSurface)&  S2,
1568                                     const Handle(Adaptor3d_TopolTool)& D2,
1569                                     const Standard_Real U1,
1570                                     const Standard_Real V1,
1571                                     const Standard_Real U2,
1572                                     const Standard_Real V2,
1573                                     const Standard_Real TolArc,
1574                                     const Standard_Real TolTang)
1575 {
1576   myTolArc = TolArc;
1577   myTolTang = TolTang;
1578   if(myFleche == 0.0) {
1579 #if DEBUG
1580     //std::cout<<" -- IntPatch_Intersection::myFleche fixe par defaut a 0.01 --"<<std::endl;
1581     //std::cout<<" -- Utiliser la Methode SetTolerances( ... ) "<<std::endl;
1582 #endif
1583     myFleche = 0.01;
1584   }
1585   if(myUVMaxStep==0.0) {
1586 #if DEBUG
1587     //std::cout<<" -- IntPatch_Intersection::myUVMaxStep fixe par defaut a 0.01 --"<<std::endl;
1588     //std::cout<<" -- Utiliser la Methode SetTolerances( ... ) "<<std::endl;
1589 #endif
1590     myUVMaxStep = 0.01;
1591   }
1592
1593   done = Standard_False;
1594   spnt.Clear();
1595   slin.Clear();
1596
1597   empt = Standard_True;
1598   tgte = Standard_False;
1599   oppo = Standard_False;
1600
1601   const GeomAbs_SurfaceType typs1 = S1->GetType();
1602   const GeomAbs_SurfaceType typs2 = S2->GetType();
1603   
1604   if(   typs1==GeomAbs_Plane 
1605      || typs1==GeomAbs_Cylinder
1606      || typs1==GeomAbs_Sphere
1607      || typs1==GeomAbs_Cone
1608      || typs2==GeomAbs_Plane 
1609      || typs2==GeomAbs_Cylinder
1610      || typs2==GeomAbs_Sphere
1611      || typs2==GeomAbs_Cone)
1612   {
1613     myIsStartPnt = Standard_True;
1614     myU1Start = U1; myV1Start = V1; myU2Start = U2; myV2Start = V2;
1615     Perform(S1,D1,S2,D2,TolArc,TolTang);
1616     myIsStartPnt = Standard_False;
1617   }
1618   else
1619   {
1620     IntPatch_PrmPrmIntersection interpp;
1621     interpp.Perform(S1,D1,S2,D2,U1,V1,U2,V2,TolTang,TolArc,myFleche,myUVMaxStep);
1622     if (interpp.IsDone())
1623     {
1624       done = Standard_True;
1625       tgte = Standard_False;
1626       empt = interpp.IsEmpty();
1627       const Standard_Integer nblm = interpp.NbLines();
1628       Standard_Integer i = 1;
1629       for (; i<=nblm; i++) slin.Append(interpp.Line(i));
1630     }
1631   }
1632
1633   for(Standard_Integer i = slin.Lower(); i <= slin.Upper(); i++)
1634   {
1635     Handle(IntPatch_WLine) aWL = Handle(IntPatch_WLine)::DownCast(slin.Value(i));
1636
1637     if(aWL.IsNull())
1638       continue;
1639
1640     if (!aWL->IsPurgingAllowed())
1641       continue;
1642
1643     Handle(IntPatch_WLine) aRW =
1644       IntPatch_WLineTool::ComputePurgedWLine(aWL, S1, S2, D1, D2);
1645
1646     if(aRW.IsNull())
1647       continue;
1648
1649     slin.InsertAfter(i, aRW);
1650     slin.Remove(i);
1651   }
1652 }
1653
1654 #ifdef DUMPOFIntPatch_Intersection
1655
1656 void IntPatch_Intersection__MAJ_R(Handle(Adaptor2d_HCurve2d) *R1,
1657                                   Handle(Adaptor2d_HCurve2d) *,
1658                                   int *NR1,
1659                                   int *,
1660                                   Standard_Integer nbR1,
1661                                   Standard_Integer ,
1662                                   const IntPatch_Point& VTX)
1663
1664   
1665   if(VTX.IsOnDomS1()) { 
1666     
1667     //-- long unsigned ptr= *((long unsigned *)(((Handle(Standard_Transient) *)(&(VTX.ArcOnS1())))));
1668     for(Standard_Integer i=0; i<nbR1;i++) { 
1669       if(VTX.ArcOnS1()==R1[i]) { 
1670         NR1[i]++;
1671         printf("\n ******************************");
1672         return;
1673       }
1674     }
1675     printf("\n R Pas trouvee  (IntPatch)\n");
1676     
1677   }
1678 }
1679 #endif
1680
1681 void IntPatch_Intersection::Dump(const Standard_Integer /*Mode*/,
1682                                  const Handle(Adaptor3d_HSurface)&  /*S1*/,
1683                                  const Handle(Adaptor3d_TopolTool)& /*D1*/,
1684                                  const Handle(Adaptor3d_HSurface)&  /*S2*/,
1685                                  const Handle(Adaptor3d_TopolTool)& /*D2*/) const 
1686
1687 #ifdef DUMPOFIntPatch_Intersection
1688   const int MAXR = 200;
1689   //-- ----------------------------------------------------------------------
1690   //--  construction de la liste des restrictions & vertex 
1691   //--
1692   int NR1[MAXR],NR2[MAXR];
1693   Handle(Adaptor2d_HCurve2d) R1[MAXR],R2[MAXR];
1694   Standard_Integer nbR1=0,nbR2=0;
1695   for(D1->Init();D1->More() && nbR1<MAXR; D1->Next()) { 
1696     R1[nbR1]=D1->Value(); 
1697     NR1[nbR1]=0;
1698     nbR1++;
1699   }
1700   for(D2->Init();D2->More() && nbR2<MAXR; D2->Next()) {
1701     R2[nbR2]=D2->Value();
1702     NR2[nbR2]=0;
1703     nbR2++;
1704   }
1705   
1706   printf("\nDUMP_INT:  ----empt:%2ud  tgte:%2ud  oppo:%2ud ---------------------------------",empt,tgte,empt);
1707   Standard_Integer i,nbr1,nbr2,nbgl,nbgc,nbge,nbgp,nbgh,nbl,nbr,nbg,nbw,nba;
1708   nbl=nbr=nbg=nbw=nba=nbgl=nbge=nbr1=nbr2=nbgc=nbgp=nbgh=0;
1709   nbl=NbLines();
1710   for(i=1;i<=nbl;i++) { 
1711     const Handle(IntPatch_Line)& line=Line(i);
1712     const IntPatch_IType IType=line->ArcType();
1713     if(IType == IntPatch_Walking) nbw++;
1714     else     if(IType == IntPatch_Restriction) { 
1715       nbr++;
1716       Handle(IntPatch_RLine) rlin (Handle(IntPatch_RLine)::DownCast (line));
1717       if(rlin->IsArcOnS1()) nbr1++;
1718       if(rlin->IsArcOnS2()) nbr2++;
1719     }
1720     else     if(IType == IntPatch_Analytic) nba++;
1721     else     { 
1722       nbg++; 
1723       if(IType == IntPatch_Lin) nbgl++;
1724       else if(IType == IntPatch_Circle) nbgc++;
1725       else if(IType == IntPatch_Parabola) nbgp++;
1726       else if(IType == IntPatch_Hyperbola) nbgh++;
1727       else if(IType == IntPatch_Ellipse) nbge++;
1728     }
1729   }
1730   
1731   
1732   printf("\nDUMP_INT:Lines:%2d Wlin:%2d Restr:%2d(On1:%2d On2:%2d) Ana:%2d Geom:%2d(L:%2d C:%2d E:%2d H:%2d P:%2d)",
1733          nbl,nbw,nbr,nbr1,nbr2,nba,nbg,nbgl,nbgc,nbge,nbgh,nbgp);
1734   
1735   IntPatch_LineConstructor LineConstructor(2);
1736   
1737   Standard_Integer nbllc=0;
1738   nbw=nbr=nbg=nba=0;
1739   Standard_Integer nbva,nbvw,nbvr,nbvg;
1740   nbva=nbvr=nbvw=nbvg=0;
1741   for (j=1; j<=nbl; j++) {
1742     Standard_Integer v,nbvtx;
1743     const Handle(IntPatch_Line)& intersLinej = Line(j);
1744     Standard_Integer NbLines;
1745     LineConstructor.Perform(SequenceOfLine(),intersLinej,S1,D1,S2,D2,1e-7);
1746     NbLines = LineConstructor.NbLines();
1747     
1748     for(Standard_Integer k=1;k<=NbLines;k++) { 
1749       nbllc++;
1750       const Handle(IntPatch_Line)& LineK = LineConstructor.Line(k);
1751       if (LineK->ArcType() == IntPatch_Analytic) { 
1752         Handle(IntPatch_ALine) alin (Handle(IntPatch_ALine)::DownCast (LineK));
1753         nbvtx=alin->NbVertex();
1754         nbva+=nbvtx;        nba++;
1755         for(v=1;v<=nbvtx;v++) { 
1756           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,alin->Vertex(v));
1757         }
1758       }
1759       else if (LineK->ArcType() == IntPatch_Restriction) {
1760         Handle(IntPatch_RLine) rlin (Handle(IntPatch_RLine)::DownCast (LineK));
1761         nbvtx=rlin->NbVertex();
1762         nbvr+=nbvtx;        nbr++;
1763         for(v=1;v<=nbvtx;v++) { 
1764           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,rlin->Vertex(v));
1765         }
1766       }
1767       else if (LineK->ArcType() == IntPatch_Walking) {
1768         Handle(IntPatch_WLine) wlin (Handle(IntPatch_WLine)::DownCast (LineK));
1769         nbvtx=wlin->NbVertex();
1770         nbvw+=nbvtx;        nbw++;
1771         for(v=1;v<=nbvtx;v++) { 
1772           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,wlin->Vertex(v));
1773         }
1774       }
1775       else { 
1776         Handle(IntPatch_GLine) glin (Handle(IntPatch_GLine)::DownCast (LineK));
1777         nbvtx=glin->NbVertex();
1778         nbvg+=nbvtx;        nbg++;
1779         for(v=1;v<=nbvtx;v++) { 
1780           IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,glin->Vertex(v));
1781         }
1782       }
1783     }
1784   }
1785   printf("\nDUMP_LC :Lines:%2d WLin:%2d Restr:%2d Ana:%2d Geom:%2d",
1786          nbllc,nbw,nbr,nba,nbg);
1787   printf("\nDUMP_LC :vtx          :%2d     r:%2d    :%2d     :%2d",
1788          nbvw,nbvr,nbva,nbvg);
1789
1790   printf("\n");
1791
1792 #endif 
1793 }