0029151: GCC 7.1 warnings "this statement may fall through" [-Wimplicit-fallthrough=]
[occt.git] / src / IntPatch / IntPatch_ImpPrmIntersection.cxx
1 // Created on: 1992-05-07
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1992-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <IntPatch_ImpPrmIntersection.hxx>
18
19 #include <Adaptor3d_HSurface.hxx>
20 #include <Adaptor3d_TopolTool.hxx>
21 #include <ElCLib.hxx>
22 #include <IntPatch_ArcFunction.hxx>
23 #include <IntPatch_PointLine.hxx>
24 #include <IntPatch_RLine.hxx>
25 #include <IntPatch_RstInt.hxx>
26 #include <IntPatch_SpecialPoints.hxx>
27 #include <IntPatch_TheIWLineOfTheIWalking.hxx>
28 #include <IntPatch_TheIWalking.hxx>
29 #include <IntPatch_TheSurfFunction.hxx>
30 #include <IntPatch_WLine.hxx>
31 #include <IntSurf.hxx>
32 #include <IntSurf_Quadric.hxx>
33 #include <IntSurf_QuadricTool.hxx>
34 #include <IntSurf_SequenceOfPathPoint.hxx>
35 #include <TopAbs_Orientation.hxx>
36 #include <TopTrans_CurveTransition.hxx>
37 #include <math_Matrix.hxx>
38 #include <math_Vector.hxx>
39
40 #ifndef OCCT_DEBUG
41 #define No_Standard_RangeError
42 #define No_Standard_OutOfRange
43 #endif
44
45 static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLine,
46                                         const Standard_Boolean       IsReversed,
47                                         const IntSurf_Quadric&       theQuad,
48                                         const Handle(Adaptor3d_TopolTool)& thePDomain,
49                                         const Handle(Adaptor3d_HSurface)&  theQSurf,
50                                         const Handle(Adaptor3d_HSurface)&  theOtherSurf,
51                                         const Standard_Real                theArcTol,
52                                         const Standard_Real                theTolTang,
53                                         IntPatch_SequenceOfLine&           theLines);
54 static 
55   void ComputeTangency (const IntPatch_TheSOnBounds& solrst,
56   IntSurf_SequenceOfPathPoint& seqpdep,
57   const Handle(Adaptor3d_TopolTool)& Domain,
58   IntPatch_TheSurfFunction& Func,
59   const Handle(Adaptor3d_HSurface)& PSurf,
60   TColStd_Array1OfInteger& Destination);
61 static 
62   void Recadre(const Standard_Boolean ,
63   GeomAbs_SurfaceType typeS1,
64   GeomAbs_SurfaceType typeS2,
65   IntPatch_Point&  pt,
66   const Handle(IntPatch_TheIWLineOfTheIWalking)& iwline,
67   Standard_Integer Param,
68   Standard_Real U1,
69   Standard_Real V1,
70   Standard_Real U2,
71   Standard_Real V2);
72
73 static 
74   Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
75                               const Handle(IntPatch_PointLine)& theLine,
76                               const Handle(Adaptor2d_HCurve2d)& theArc,
77                               const Standard_Boolean isTheSurface1Using,
78                               const Standard_Real theToler3D,
79                               const Standard_Real theToler2D,
80                               const Standard_Real thePeriod);
81
82 //=======================================================================
83 //function : IsSeamOrPole
84 //purpose  : 
85 //=======================================================================
86 static IntPatch_SpecPntType IsSeamOrPole(const Handle(Adaptor3d_HSurface)& theQSurf,
87                                          const Handle(IntSurf_LineOn2S)& theLine,
88                                          const Standard_Boolean IsReversed,
89                                          const Standard_Integer theRefIndex,
90                                          const Standard_Real theDeltaMax)
91 {
92   if((theRefIndex < 1) || (theRefIndex >= theLine->NbPoints()))
93     return IntPatch_SPntNone;
94
95   //Parameters on Quadric and on parametric for reference point
96   Standard_Real aUQRef, aVQRef, aUPRef, aVPRef;
97   Standard_Real aUQNext, aVQNext, aUPNext, aVPNext;
98
99   if(IsReversed)
100   {
101     theLine->Value(theRefIndex).Parameters  (aUPRef, aVPRef, aUQRef, aVQRef);
102     theLine->Value(theRefIndex+1).Parameters(aUPNext, aVPNext, aUQNext, aVQNext);
103   }
104   else
105   {
106     theLine->Value(theRefIndex).Parameters  (aUQRef, aVQRef, aUPRef, aVPRef);
107     theLine->Value(theRefIndex+1).Parameters(aUQNext, aVQNext, aUPNext, aVPNext);
108   }
109
110   const GeomAbs_SurfaceType aType = theQSurf->GetType();
111
112   const Standard_Real aDeltaU = Abs(aUQRef - aUQNext);
113
114   if((aType != GeomAbs_Torus) && (aDeltaU < theDeltaMax))
115     return IntPatch_SPntNone;
116
117   switch(aType)
118   {
119   case GeomAbs_Cylinder:
120     return IntPatch_SPntSeamU;
121
122   case GeomAbs_Torus:
123     {
124       const Standard_Real aDeltaV = Abs(aVQRef - aVQNext);
125
126       if((aDeltaU >= theDeltaMax) && (aDeltaV >= theDeltaMax))
127         return IntPatch_SPntSeamUV;
128
129       if(aDeltaU >= theDeltaMax)
130         return IntPatch_SPntSeamU;
131
132       if(aDeltaV >= theDeltaMax)
133         return IntPatch_SPntSeamV;
134     }
135
136     break;
137   case GeomAbs_Sphere:
138   case GeomAbs_Cone:
139     return IntPatch_SPntPoleSeamU;
140   default:
141     break;
142   }
143
144   return IntPatch_SPntNone;
145 }
146
147 //=======================================================================
148 //function : IntPatch_ImpPrmIntersection
149 //purpose  : 
150 //=======================================================================
151 IntPatch_ImpPrmIntersection::IntPatch_ImpPrmIntersection ()
152   : done(Standard_False),
153   empt(Standard_False),
154   myIsStartPnt(Standard_False),
155   myUStart(0.0),
156   myVStart(0.0)
157 { }
158
159
160 //=======================================================================
161 //function : IntPatch_ImpPrmIntersection
162 //purpose  : 
163 //=======================================================================
164
165 IntPatch_ImpPrmIntersection::IntPatch_ImpPrmIntersection
166   (const Handle(Adaptor3d_HSurface)&    Surf1,
167   const Handle(Adaptor3d_TopolTool)&   D1,
168   const Handle(Adaptor3d_HSurface)&    Surf2,
169   const Handle(Adaptor3d_TopolTool)&   D2,
170   const Standard_Real    TolArc,
171   const Standard_Real    TolTang,
172   const Standard_Real    Fleche,
173   const Standard_Real    Pas)
174   : done(Standard_False),
175   empt(Standard_False),
176   myIsStartPnt(Standard_False),
177   myUStart(0.0),
178   myVStart(0.0)
179 {
180   Perform(Surf1,D1,Surf2,D2,TolArc,TolTang,Fleche,Pas);
181 }
182
183
184 //=======================================================================
185 //function : SetStartPoint
186 //purpose  : 
187 //=======================================================================
188
189 void IntPatch_ImpPrmIntersection::SetStartPoint(const Standard_Real U,
190   const Standard_Real V)
191 {
192   myIsStartPnt = Standard_True;
193   myUStart = U; myVStart = V;
194 }
195
196 //=======================================================================
197 //function : ComputeTangency
198 //purpose  : 
199 //=======================================================================
200 void ComputeTangency (const IntPatch_TheSOnBounds& solrst,
201   IntSurf_SequenceOfPathPoint& seqpdep,
202   const Handle(Adaptor3d_TopolTool)& Domain,
203   IntPatch_TheSurfFunction& Func,
204   const Handle(Adaptor3d_HSurface)& PSurf,
205   TColStd_Array1OfInteger& Destination)
206 {
207   Standard_Integer i,k, NbPoints, seqlength;
208   Standard_Real theparam,test;
209   Standard_Boolean fairpt, ispassing;
210   TopAbs_Orientation arcorien,vtxorien;
211   Handle(Adaptor2d_HCurve2d) thearc;
212   Handle(Adaptor3d_HVertex) vtx,vtxbis;
213   //Standard_Boolean ispassing;
214   IntPatch_ThePathPointOfTheSOnBounds PStart;
215   IntSurf_PathPoint PPoint;
216   gp_Vec vectg;
217   gp_Dir2d dirtg;
218   gp_Pnt ptbid;
219   gp_Vec d1u,d1v,v1,v2;
220   gp_Pnt2d p2d;
221   gp_Vec2d d2d;
222   //
223   double aX[2], aF[1], aD[1][2];
224   math_Vector X(aX, 1, 2);
225   math_Vector F(aF, 1, 1);
226   math_Matrix D(aD, 1, 1, 1, 2); 
227   //
228   seqlength = 0;
229   NbPoints = solrst.NbPoints();
230   for (i=1; i<= NbPoints; i++) {
231     if (Destination(i) == 0) {
232       PStart = solrst.Point(i);
233       thearc   = PStart.Arc();
234       theparam = PStart.Parameter();
235       arcorien = Domain->Orientation(thearc);
236       ispassing = (arcorien == TopAbs_INTERNAL || 
237         arcorien == TopAbs_EXTERNAL);
238
239       thearc->D0(theparam,p2d);
240       X(1) = p2d.X(); 
241       X(2) = p2d.Y();
242       PPoint.SetValue(PStart.Value(),X(1),X(2));
243
244       Func.Values(X,F,D);
245       if (Func.IsTangent()) {
246         PPoint.SetTangency(Standard_True);
247         Destination(i) = seqlength+1;
248         if (!PStart.IsNew()) {
249           vtx = PStart.Vertex();
250           for (k=i+1; k<=NbPoints; k++) {
251             if (Destination(k) ==0) {
252               PStart = solrst.Point(k);
253               if (!PStart.IsNew()) {
254                 vtxbis = PStart.Vertex();
255                 if (Domain->Identical(vtx,vtxbis)) {
256                   thearc   = PStart.Arc();
257                   theparam = PStart.Parameter();
258                   arcorien = Domain->Orientation(thearc);
259                   ispassing = ispassing && (arcorien == TopAbs_INTERNAL ||
260                     arcorien == TopAbs_EXTERNAL);
261
262                   thearc->D0(theparam,p2d);
263                   PPoint.AddUV(p2d.X(),p2d.Y());
264                   Destination(k) = seqlength+1;
265                 }
266               }
267             }
268           }
269         }
270         PPoint.SetPassing(ispassing);
271         seqpdep.Append(PPoint);
272         seqlength++;
273       }
274       else { // on a un point de depart potentiel
275
276         vectg = Func.Direction3d();
277         dirtg = Func.Direction2d();
278
279         PSurf->D1(X(1),X(2),ptbid,d1u,d1v);
280         thearc->D1(theparam,p2d,d2d);
281         v2.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
282         v1 = d1u.Crossed(d1v);
283
284         test = vectg.Dot(v1.Crossed(v2));
285         if (PStart.IsNew()) {
286           if ((test < 0. && arcorien == TopAbs_FORWARD) ||
287             (test > 0. && arcorien == TopAbs_REVERSED)) {
288               vectg.Reverse();
289               dirtg.Reverse();
290           }
291           PPoint.SetDirections(vectg,dirtg);
292           PPoint.SetPassing(ispassing);
293           Destination(i) = seqlength+1;
294           seqpdep.Append(PPoint);
295           seqlength++;
296         }
297         else { // traiter la transition complexe
298           gp_Dir bidnorm(1.,1.,1.);
299           Standard_Real tole = 1.e-8;
300           TopAbs_Orientation LocTrans;
301           TopTrans_CurveTransition comptrans;
302           comptrans.Reset(vectg,bidnorm,0.);
303           if (arcorien == TopAbs_FORWARD || 
304             arcorien == TopAbs_REVERSED) {
305               // pour essai
306
307               vtx = PStart.Vertex();
308               vtxorien = Domain->Orientation(vtx);
309               if (Abs(test) <= tole) {
310                 LocTrans = TopAbs_EXTERNAL; // et pourquoi pas INTERNAL
311               }
312               else {
313                 if (((test > 0.)&& arcorien == TopAbs_FORWARD) ||
314                   ((test < 0.)&& arcorien == TopAbs_REVERSED)){
315                     LocTrans = TopAbs_FORWARD;
316                 }
317                 else {
318                   LocTrans = TopAbs_REVERSED;
319                 }
320                 if (arcorien == TopAbs_REVERSED) {v2.Reverse();}
321               }
322
323               comptrans.Compare(tole,v2,bidnorm,0.,LocTrans,vtxorien);
324           }
325           Destination(i) = seqlength+1;
326           for (k= i+1; k<=NbPoints; k++) {
327             if (Destination(k) == 0) {
328               PStart = solrst.Point(k);
329               if (!PStart.IsNew()) {
330                 vtxbis = PStart.Vertex();
331                 if (Domain->Identical(vtx,vtxbis)) {
332                   thearc   = PStart.Arc();
333                   theparam = PStart.Parameter();
334                   arcorien = Domain->Orientation(thearc);
335
336                   PPoint.AddUV(X(1),X(2));
337
338                   thearc->D1(theparam,p2d,d2d);
339                   PPoint.AddUV(p2d.X(),p2d.Y());
340
341                   if (arcorien == TopAbs_FORWARD || 
342                     arcorien == TopAbs_REVERSED) {
343                       ispassing = Standard_False;
344                       v2.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
345
346                       test = vectg.Dot(v1.Crossed(v2));
347                       vtxorien = Domain->Orientation(PStart.Vertex());
348                       if (Abs(test) <= tole) {
349                         LocTrans = TopAbs_EXTERNAL; // et pourquoi pas INTERNAL
350                       }
351                       else {
352                         if (((test > 0.)&& arcorien == TopAbs_FORWARD) ||
353                           ((test < 0.)&& arcorien == TopAbs_REVERSED)){
354                             LocTrans = TopAbs_FORWARD;
355                         }
356                         else {
357                           LocTrans = TopAbs_REVERSED;
358                         }
359                         if (arcorien == TopAbs_REVERSED) {v2.Reverse();}
360                       }
361
362                       comptrans.Compare(tole,v2,bidnorm,0.,LocTrans,vtxorien);
363                   }
364                   Destination(k) = seqlength+1;
365                 }
366               }
367             }
368           }
369           fairpt = Standard_True;
370           if (!ispassing) {
371             TopAbs_State Before = comptrans.StateBefore();
372             TopAbs_State After  = comptrans.StateAfter();
373             if ((Before == TopAbs_UNKNOWN)||(After == TopAbs_UNKNOWN)) {
374               fairpt = Standard_False;
375             }
376             else if (Before == TopAbs_IN) {
377               if (After == TopAbs_IN) {
378                 ispassing = Standard_True;
379               }
380               else {
381                 vectg.Reverse();
382                 dirtg.Reverse();
383               }
384             }
385             else {
386               if (After !=TopAbs_IN) {
387                 fairpt = Standard_False;
388               }
389             }
390           }
391           if (fairpt) {
392             PPoint.SetDirections(vectg,dirtg);
393             PPoint.SetPassing(ispassing);
394             seqpdep.Append(PPoint);
395             seqlength++;
396           }
397           else { // il faut remettre en "ordre" si on ne garde pas le point.
398             for (k=i; k <=NbPoints ; k++) {
399               if (Destination(k)==seqlength + 1) {
400                 Destination(k) = -Destination(k);
401               }
402             }
403           }
404         }
405       }
406     }
407   }
408 }
409 //=======================================================================
410 //function : Recadre
411 //purpose  : 
412 //=======================================================================
413 void Recadre(const Standard_Boolean ,
414   GeomAbs_SurfaceType typeS1,
415   GeomAbs_SurfaceType typeS2,
416   IntPatch_Point&  pt,
417   const Handle(IntPatch_TheIWLineOfTheIWalking)& iwline,
418   Standard_Integer Param,
419   Standard_Real U1,
420   Standard_Real V1,
421   Standard_Real U2,
422   Standard_Real V2)
423 {
424   Standard_Real U1p,V1p,U2p,V2p;
425   iwline->Line()->Value(Param).Parameters(U1p,V1p,U2p,V2p);
426   switch(typeS1)
427   {
428   case GeomAbs_Torus:
429     while(V1<(V1p-1.5*M_PI)) V1+=M_PI+M_PI;
430     while(V1>(V1p+1.5*M_PI)) V1-=M_PI+M_PI;
431     Standard_FALLTHROUGH
432   case GeomAbs_Cylinder:
433   case GeomAbs_Cone:
434   case GeomAbs_Sphere:
435     while(U1<(U1p-1.5*M_PI)) U1+=M_PI+M_PI;
436     while(U1>(U1p+1.5*M_PI)) U1-=M_PI+M_PI;
437   default:
438     break;
439   }
440   switch(typeS2)
441   { 
442   case GeomAbs_Torus:
443     while(V2<(V2p-1.5*M_PI)) V2+=M_PI+M_PI;
444     while(V2>(V2p+1.5*M_PI)) V2-=M_PI+M_PI;
445     Standard_FALLTHROUGH
446   case GeomAbs_Cylinder:
447   case GeomAbs_Cone:
448   case GeomAbs_Sphere:
449     while(U2<(U2p-1.5*M_PI)) U2+=M_PI+M_PI;
450     while(U2>(U2p+1.5*M_PI)) U2-=M_PI+M_PI;
451   default:
452     break;
453   }
454   pt.SetParameters(U1,V1,U2,V2);
455 }
456
457 //=======================================================================
458 //function : Perform
459 //purpose  : 
460 //=======================================================================
461 void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
462   const Handle(Adaptor3d_TopolTool)& D1,
463   const Handle(Adaptor3d_HSurface)& Surf2,
464   const Handle(Adaptor3d_TopolTool)& D2,
465   const Standard_Real TolArc,
466   const Standard_Real TolTang,
467   const Standard_Real Fleche,
468   const Standard_Real Pas)
469 {
470   Standard_Boolean reversed, procf, procl, dofirst, dolast;
471   Standard_Integer indfirst = 0, indlast = 0, ind2, NbSegm;
472   Standard_Integer NbPointIns, NbPointRst, Nblines, Nbpts, NbPointDep;
473   Standard_Real U1,V1,U2,V2,paramf,paraml,currentparam;
474
475   IntPatch_TheSegmentOfTheSOnBounds thesegm;
476   IntSurf_PathPoint PPoint;
477
478   Handle(IntPatch_RLine) rline;
479   Handle(IntPatch_WLine) wline;
480   IntPatch_ThePathPointOfTheSOnBounds PStart,PStartf,PStartl;
481   IntPatch_Point ptdeb,ptfin,ptbis;
482
483   IntPatch_IType typ;
484   IntSurf_Transition TLine,TArc;
485   IntSurf_TypeTrans trans1,trans2;
486   gp_Pnt valpt,ptbid;
487   gp_Vec tgline,tgrst,norm1,norm2,d1u,d1v;
488   gp_Dir DirNormale;
489   gp_Vec VecNormale;
490
491   gp_Pnt2d p2d;
492   gp_Vec2d d2d;
493
494   Handle(Adaptor2d_HCurve2d) currentarc;
495   GeomAbs_SurfaceType typeS1, typeS2;
496   IntSurf_Quadric Quad;
497   IntPatch_TheSurfFunction Func;
498   IntPatch_ArcFunction AFunc;
499   //
500   typeS1 = Surf1->GetType();
501   typeS2 = Surf2->GetType();
502
503   paramf =0.;
504   paraml =0.;
505   trans1 = IntSurf_Undecided;
506   trans2 = IntSurf_Undecided;
507   //
508   done = Standard_False;
509   empt = Standard_True;
510   slin.Clear();
511   spnt.Clear();
512   //
513   reversed = Standard_False;
514   switch (typeS1)
515   {
516   case GeomAbs_Plane:
517     Quad.SetValue(Surf1->Plane());
518     break;
519
520   case GeomAbs_Cylinder:
521     Quad.SetValue(Surf1->Cylinder());
522     break;
523
524   case GeomAbs_Sphere:
525     Quad.SetValue(Surf1->Sphere());
526     break;
527
528   case GeomAbs_Cone:
529     Quad.SetValue(Surf1->Cone());
530     break;
531
532   default:
533     {
534       reversed = Standard_True;
535       switch (typeS2)
536       {
537       case GeomAbs_Plane:
538         Quad.SetValue(Surf2->Plane());
539         break;
540
541       case GeomAbs_Cylinder:
542         Quad.SetValue(Surf2->Cylinder());
543         break;
544
545       case GeomAbs_Sphere:
546         Quad.SetValue(Surf2->Sphere());
547         break;
548
549       case GeomAbs_Cone:
550         Quad.SetValue(Surf2->Cone());
551         break;
552       default:
553         {
554           throw Standard_ConstructionError();
555           break;
556         }
557       } 
558     }
559     break;
560   }
561   //
562   Func.SetImplicitSurface(Quad);
563   Func.Set(IntSurf_QuadricTool::Tolerance(Quad));
564   AFunc.SetQuadric(Quad);
565   //
566   if (!reversed) {
567     Func.Set(Surf2);
568     AFunc.Set(Surf2);
569   }
570   else {
571     Func.Set(Surf1);
572     AFunc.Set(Surf1);
573   }
574   //
575   if (!reversed) {
576     solrst.Perform(AFunc,D2,TolArc,TolTang);
577   }
578   else {
579     solrst.Perform(AFunc,D1,TolArc,TolTang);
580   }
581   if (!solrst.IsDone()) {
582     return;
583   }
584   //
585   IntSurf_SequenceOfPathPoint seqpdep;
586   IntSurf_SequenceOfInteriorPoint seqpins;
587   //
588   NbPointRst = solrst.NbPoints();
589   TColStd_Array1OfInteger Destination(1,NbPointRst+1); Destination.Init(0);
590   if (NbPointRst) {
591     if (!reversed) {
592       ComputeTangency(solrst,seqpdep,D2,Func,Surf2,Destination);
593     }
594     else {
595       ComputeTangency(solrst,seqpdep,D1,Func,Surf1,Destination);
596     }
597   }
598   //
599   Standard_Boolean SearchIns = Standard_True;
600   if(Quad.TypeQuadric() == GeomAbs_Plane && solrst.NbSegments() > 0)
601   {
602     //For such kind of cases it is possible that whole surface is on one side of plane,
603     //plane only touches surface and does not cross it,
604     //so no inner points exist.
605     SearchIns = Standard_False;
606     Handle(Adaptor3d_TopolTool) T;
607     if(reversed)
608     {
609       T = D1;
610     }
611     else
612     {
613       T = D2;
614     }
615     Standard_Integer aNbSamples = 0;
616     aNbSamples = T->NbSamples();
617     gp_Pnt2d s2d;
618     gp_Pnt s3d;
619     Standard_Real aValf[1], aUVap[2];
620     math_Vector Valf(aValf,1,1), UVap(aUVap,1,2);
621     T->SamplePoint(1,s2d, s3d);
622     UVap(1)=s2d.X(); 
623     UVap(2)=s2d.Y();
624     Func.Value(UVap,Valf);
625     Standard_Real rvalf = Sign(1.,Valf(1));
626     for(Standard_Integer i = 2; i <= aNbSamples; ++i)
627     {
628       T->SamplePoint(i,s2d, s3d);
629       UVap(1)=s2d.X(); 
630       UVap(2)=s2d.Y();
631       Func.Value(UVap,Valf);
632       if(rvalf * Valf(1) < 0.)
633       {
634         SearchIns = Standard_True;
635         break;
636       }   
637     }
638   }
639   // Recherche des points interieurs
640   NbPointIns = 0;
641   if(SearchIns) {
642     if (!reversed) {
643       if (myIsStartPnt)
644         solins.Perform(Func,Surf2,myUStart,myVStart);
645       else
646         solins.Perform(Func,Surf2,D2,TolTang);
647     }
648     else {
649       if (myIsStartPnt)
650         solins.Perform(Func,Surf1,myUStart,myVStart);
651       else
652         solins.Perform(Func,Surf1,D1,TolTang);
653     }
654     NbPointIns = solins.NbPoints();
655     for (Standard_Integer i=1; i <= NbPointIns; i++) {
656       seqpins.Append(solins.Value(i));
657     }
658   }
659   //
660   NbPointDep=seqpdep.Length();
661   //
662   if (NbPointDep || NbPointIns) {
663     IntPatch_TheIWalking iwalk(TolTang,Fleche,Pas);
664     if (!reversed) {
665       iwalk.Perform(seqpdep,seqpins,Func,Surf2);
666     }
667     else {
668       iwalk.Perform(seqpdep,seqpins,Func,Surf1,Standard_True);
669     }
670     if(!iwalk.IsDone()) {
671       return;
672     }
673
674     Standard_Real Vmin, Vmax, TolV = 1.e-14;
675     if (!reversed) { //Surf1 is quadric
676       Vmin = Surf1->FirstVParameter();
677       Vmax = Surf1->LastVParameter();
678     }
679     else { //Surf2 is quadric
680       Vmin = Surf2->FirstVParameter();
681       Vmax = Surf2->LastVParameter();
682     }
683     //
684     Nblines = iwalk.NbLines();
685     for (Standard_Integer j=1; j<=Nblines; j++) {
686       const Handle(IntPatch_TheIWLineOfTheIWalking)&  iwline  = iwalk.Value(j);
687       const Handle(IntSurf_LineOn2S)&                 thelin  = iwline->Line();
688
689       Nbpts = thelin->NbPoints();
690       if(Nbpts>=2) { 
691         Standard_Integer k = 0;
692         tgline = iwline->TangentVector(k);      
693         if(k>=1 && k<=Nbpts) { } else { k=Nbpts>>1; } 
694         valpt = thelin->Value(k).Value();       
695
696         if (!reversed) {
697           thelin->Value(k).ParametersOnS2(U2,V2);
698           norm1 = Quad.Normale(valpt);
699           Surf2->D1(U2,V2,ptbid,d1u,d1v);
700           norm2 = d1u.Crossed(d1v);
701         }
702         else {
703           thelin->Value(k).ParametersOnS1(U2,V2);
704           norm2 = Quad.Normale(valpt);
705           Surf1->D1(U2,V2,ptbid,d1u,d1v);
706           norm1 = d1u.Crossed(d1v);
707         }
708         if (tgline.DotCross(norm2,norm1) > 0.) {
709           trans1 = IntSurf_Out;
710           trans2 = IntSurf_In;
711         }
712         else {
713           trans1 = IntSurf_In;
714           trans2 = IntSurf_Out;
715         }
716
717         //
718         Standard_Real AnU1,AnU2,AnV2;
719
720         GeomAbs_SurfaceType typQuad = Quad.TypeQuadric();
721         Standard_Boolean arecadr=Standard_False;
722         valpt = thelin->Value(1).Value();
723         Quad.Parameters(valpt,AnU1,V1);
724
725         if((V1 < Vmin) && (Vmin-V1 < TolV)) V1 = Vmin;
726         if((V1 > Vmax) && (V1-Vmax < TolV)) V1 = Vmax;
727
728         if(reversed) { 
729           thelin->SetUV(1,Standard_False,AnU1,V1); //-- on va lire u2,v2
730           thelin->Value(1).ParametersOnS1(AnU2,AnV2);
731         }
732         else { 
733           thelin->SetUV(1,Standard_True,AnU1,V1);  //-- on va lire u1,v1 
734           thelin->Value(1).ParametersOnS2(AnU2,AnV2);
735         }
736
737         if(typQuad==GeomAbs_Cylinder || 
738           typQuad==GeomAbs_Cone || 
739           typQuad==GeomAbs_Sphere) { 
740             arecadr=Standard_True; 
741         } 
742         //
743         for (k=2; k<=Nbpts; ++k) {
744           valpt = thelin->Value(k).Value();
745           Quad.Parameters(valpt,U1,V1);
746           //
747           if((V1 < Vmin) && (Vmin-V1 < TolV)) {
748             V1 = Vmin;
749           }
750           if((V1 > Vmax) && (V1-Vmax < TolV)) {
751             V1 = Vmax;
752           }
753           //
754           if(arecadr) {
755             //modified by NIZNHY-PKV Fri Mar 28 15:06:01 2008f
756             Standard_Real aCf, aTwoPI;
757             //
758             aCf=0.;
759             aTwoPI=M_PI+M_PI;
760             if ((U1-AnU1) >  1.5*M_PI) { 
761               while ((U1-AnU1) > (1.5*M_PI+aCf*aTwoPI)) {
762                 aCf=aCf+1.;
763               }
764               U1=U1-aCf*aTwoPI;
765             } 
766             //
767             else {
768               while ((U1-AnU1) < (-1.5*M_PI-aCf*aTwoPI)) {
769                 aCf=aCf+1.;
770               }
771               U1=U1+aCf*aTwoPI;
772             }
773             // was:
774             //if ((U1-AnU1) >  1.5*M_PI) { 
775             //  U1-=M_PI+M_PI;
776             //}
777             //else if ((U1-AnU1) < -1.5*M_PI) { 
778             //  U1+=M_PI+M_PI; 
779             //}
780             //modified by NIZNHY-PKV Fri Mar 28 15:06:11 2008t
781           }
782           //
783           if(reversed) { 
784             thelin->SetUV(k,Standard_False,U1,V1);
785
786             thelin->Value(k).ParametersOnS1(U2,V2);
787             switch(typeS1) { 
788             case GeomAbs_Cylinder:
789             case GeomAbs_Cone:
790             case GeomAbs_Sphere:
791             case GeomAbs_Torus:
792               while(U2<(AnU2-1.5*M_PI)) U2+=M_PI+M_PI;
793               while(U2>(AnU2+1.5*M_PI)) U2-=M_PI+M_PI;
794               break;
795             default: 
796               break;
797             }
798             if(typeS2==GeomAbs_Torus) { 
799               while(V2<(AnV2-1.5*M_PI)) V2+=M_PI+M_PI;
800               while(V2>(AnV2+1.5*M_PI)) V2-=M_PI+M_PI;
801             }
802             thelin->SetUV(k,Standard_True,U2,V2);
803           }
804           else { 
805             thelin->SetUV(k,Standard_True,U1,V1);
806
807             thelin->Value(k).ParametersOnS2(U2,V2);
808             switch(typeS2) { 
809             case GeomAbs_Cylinder:
810             case GeomAbs_Cone:
811             case GeomAbs_Sphere:
812             case GeomAbs_Torus:
813               while(U2<(AnU2-1.5*M_PI)) U2+=M_PI+M_PI;
814               while(U2>(AnU2+1.5*M_PI)) U2-=M_PI+M_PI;
815               break;
816             default: 
817               break;
818             }
819             if(typeS2==GeomAbs_Torus) { 
820               while(V2<(AnV2-1.5*M_PI)) V2+=M_PI+M_PI;
821               while(V2>(AnV2+1.5*M_PI)) V2-=M_PI+M_PI;
822             }
823             thelin->SetUV(k,Standard_False,U2,V2);
824
825           }
826
827           AnU1=U1;
828           AnU2=U2;
829           AnV2=V2;
830         }
831         // <-A
832         wline = new IntPatch_WLine(thelin,Standard_False,trans1,trans2);
833
834 #ifdef INTPATCH_IMPPRMINTERSECTION_DEBUG
835         wline->Dump(0);
836 #endif
837
838         if (   iwline->HasFirstPoint() 
839           && iwline->IsTangentAtBegining() == Standard_False) 
840         {
841           indfirst = iwline->FirstPointIndex();
842           PPoint = seqpdep(indfirst);
843           tgline = PPoint.Direction3d();
844           Standard_Integer themult = PPoint.Multiplicity();
845           for (Standard_Integer i=NbPointRst; i>=1; i--) {
846             if (Destination(i) == indfirst) {
847               if (!reversed) { //-- typeS1 = Pln || Cyl || Sph || Cone
848                 Quad.Parameters(PPoint.Value(),U1,V1);
849
850                 if((V1 < Vmin) && (Vmin-V1 < TolV)) V1 = Vmin;
851                 if((V1 > Vmax) && (V1-Vmax < TolV)) V1 = Vmax;
852
853                 PPoint.Parameters(themult,U2,V2);
854                 Surf2->D1(U2,V2,ptbid,d1u,d1v); //-- @@@@
855               }
856               else {  //-- typeS1 != Pln && Cyl && Sph && Cone
857                 Quad.Parameters(PPoint.Value(),U2,V2);
858
859                 if((V2 < Vmin) && (Vmin-V2 < TolV)) V2 = Vmin;
860                 if((V2 > Vmax) && (V2-Vmax < TolV)) V2 = Vmax;
861
862                 PPoint.Parameters(themult,U1,V1);
863                 Surf1->D1(U1,V1,ptbid,d1u,d1v); //-- @@@@
864               }
865
866               VecNormale = d1u.Crossed(d1v);                      
867               //-- Modif du 27 Septembre 94 (Recadrage des pts U,V) 
868               ptdeb.SetValue(PPoint.Value(),TolArc,Standard_False);
869               ptdeb.SetParameters(U1,V1,U2,V2);
870               ptdeb.SetParameter(1.);
871
872               Recadre(reversed,typeS1,typeS2,ptdeb,iwline,1,U1,V1,U2,V2);
873
874               currentarc = solrst.Point(i).Arc();
875               currentparam = solrst.Point(i).Parameter();
876               currentarc->D1(currentparam,p2d,d2d);
877               tgrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
878
879               Standard_Real squaremagnitudeVecNormale = VecNormale.SquareMagnitude();
880               if(squaremagnitudeVecNormale > 1e-13) { 
881                 DirNormale=VecNormale;
882                 IntSurf::MakeTransition(tgline,tgrst,DirNormale,TLine,TArc);
883               }
884               else { 
885                 TLine.SetValue(Standard_True,IntSurf_Undecided);
886                 TArc.SetValue(Standard_True,IntSurf_Undecided);
887               }
888
889               ptdeb.SetArc(reversed,currentarc,currentparam,TLine,TArc);
890               if (!solrst.Point(i).IsNew()) {
891                 ptdeb.SetVertex(reversed,solrst.Point(i).Vertex());
892               }
893               wline->AddVertex(ptdeb);
894               if (themult == 0) {
895                 wline->SetFirstPoint(wline->NbVertex());
896               }
897
898               themult--;
899             }
900           }
901         }
902         else if (iwline->IsTangentAtBegining()) 
903         {
904           gp_Pnt psol = thelin->Value(1).Value();
905           thelin->Value(1).ParametersOnS1(U1,V1);
906           thelin->Value(1).ParametersOnS2(U2,V2);
907           ptdeb.SetValue(psol,TolArc,Standard_True);
908           ptdeb.SetParameters(U1,V1,U2,V2);
909           ptdeb.SetParameter(1.);
910           wline->AddVertex(ptdeb);
911           wline->SetFirstPoint(wline->NbVertex());
912         }
913         else 
914         { 
915           gp_Pnt psol = thelin->Value(1).Value();
916           thelin->Value(1).ParametersOnS1(U1,V1);
917           thelin->Value(1).ParametersOnS2(U2,V2);
918           ptdeb.SetValue(psol,TolArc,Standard_False);
919           ptdeb.SetParameters(U1,V1,U2,V2);
920           ptdeb.SetParameter(1.);
921           wline->AddVertex(ptdeb);
922           wline->SetFirstPoint(wline->NbVertex());
923         }
924
925
926         if (   iwline->HasLastPoint() 
927           && iwline->IsTangentAtEnd() == Standard_False) 
928         {
929           indlast = iwline->LastPointIndex();
930           PPoint = seqpdep(indlast);
931           tgline = PPoint.Direction3d().Reversed();
932           Standard_Integer themult = PPoint.Multiplicity();
933           for (Standard_Integer i=NbPointRst; i >=1; i--) {
934             if (Destination(i) == indlast) {
935               if (!reversed) {
936                 Quad.Parameters(PPoint.Value(),U1,V1);
937
938                 if((V1 < Vmin) && (Vmin-V1 < TolV)) V1 = Vmin;
939                 if((V1 > Vmax) && (V1-Vmax < TolV)) V1 = Vmax;
940
941                 PPoint.Parameters(themult,U2,V2);
942                 Surf2->D1(U2,V2,ptbid,d1u,d1v); //-- @@@@
943                 VecNormale = d1u.Crossed(d1v);                    //-- @@@@
944               }
945               else {
946                 Quad.Parameters(PPoint.Value(),U2,V2);
947
948                 if((V2 < Vmin) && (Vmin-V2 < TolV)) V2 = Vmin;
949                 if((V2 > Vmax) && (V2-Vmax < TolV)) V2 = Vmax;
950
951                 PPoint.Parameters(themult,U1,V1);
952                 Surf1->D1(U1,V1,ptbid,d1u,d1v); //-- @@@@
953                 VecNormale = d1u.Crossed(d1v);                    //-- @@@@
954               }
955
956               ptfin.SetValue(PPoint.Value(),TolArc,Standard_False);
957               ptfin.SetParameters(U1,V1,U2,V2);
958               ptfin.SetParameter(Nbpts);
959
960               Recadre(reversed,typeS1,typeS2,ptfin,iwline,Nbpts-1,U1,V1,U2,V2);
961
962               currentarc = solrst.Point(i).Arc();
963               currentparam = solrst.Point(i).Parameter();
964               currentarc->D1(currentparam,p2d,d2d);
965               tgrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
966
967
968               Standard_Real squaremagnitudeVecNormale = VecNormale.SquareMagnitude();
969               if(squaremagnitudeVecNormale > 1e-13) { 
970                 DirNormale=VecNormale;
971                 IntSurf::MakeTransition(tgline,tgrst,DirNormale,TLine,TArc);
972               }
973               else { 
974                 TLine.SetValue(Standard_True,IntSurf_Undecided);
975                 TArc.SetValue(Standard_True,IntSurf_Undecided);
976               }
977
978
979               ptfin.SetArc(reversed,currentarc,currentparam,TLine,TArc);
980               if (!solrst.Point(i).IsNew()) {
981                 ptfin.SetVertex(reversed,solrst.Point(i).Vertex());
982               }
983               wline->AddVertex(ptfin);
984               if (themult == 0) {
985                 wline->SetLastPoint(wline->NbVertex());
986               }
987
988               themult--;
989             }
990           }
991         }
992         else if (iwline->IsTangentAtEnd()) 
993         {
994           gp_Pnt psol = thelin->Value(Nbpts).Value();
995           thelin->Value(Nbpts).ParametersOnS1(U1,V1);
996           thelin->Value(Nbpts).ParametersOnS2(U2,V2);
997           ptfin.SetValue(psol,TolArc,Standard_True);
998           ptfin.SetParameters(U1,V1,U2,V2);
999           ptfin.SetParameter(Nbpts);
1000           wline->AddVertex(ptfin);
1001           wline->SetLastPoint(wline->NbVertex());
1002         }
1003         else 
1004         { 
1005           gp_Pnt psol = thelin->Value(Nbpts).Value();
1006           thelin->Value(Nbpts).ParametersOnS1(U1,V1);
1007           thelin->Value(Nbpts).ParametersOnS2(U2,V2);
1008           ptfin.SetValue(psol,TolArc,Standard_False);
1009           ptfin.SetParameters(U1,V1,U2,V2);
1010           ptfin.SetParameter(Nbpts);
1011           wline->AddVertex(ptfin);
1012           wline->SetLastPoint(wline->NbVertex());
1013         }
1014         //
1015         // Il faut traiter les points de passage.
1016         slin.Append(wline);
1017       }// if(Nbpts>=2) {
1018     }// for (j=1; j<=Nblines; j++) {
1019
1020     // ON GERE LES RACCORDS ENTRE LIGNES. ELLE NE PEUVENT SE RACCORDER
1021     // QUE SUR DES POINTS DE TANGENCE
1022
1023
1024     Nblines = slin.Length();
1025     for (Standard_Integer j=1; j<=Nblines-1; j++) {
1026       dofirst = dolast = Standard_False;
1027       const  Handle(IntPatch_Line)& slinj = slin(j);
1028       Handle(IntPatch_WLine) wlin1 (Handle(IntPatch_WLine)::DownCast (slinj));
1029       if (wlin1->HasFirstPoint()) {
1030         ptdeb = wlin1->FirstPoint(indfirst);
1031         if (ptdeb.IsTangencyPoint()) {
1032           dofirst = Standard_True;
1033         }
1034       }
1035       if (wlin1->HasLastPoint()) {
1036         ptfin = wlin1->LastPoint(indlast);
1037         if (ptfin.IsTangencyPoint()) {
1038           dolast = Standard_True;
1039         }
1040       }
1041
1042       if (dofirst || dolast) {
1043         for (Standard_Integer k=j+1; k<=Nblines;k++) {
1044           const  Handle(IntPatch_Line)& slink = slin(k);
1045           Handle(IntPatch_WLine) wlin2 (Handle(IntPatch_WLine)::DownCast (slink));
1046           if (wlin2->HasFirstPoint()) {
1047             ptbis = wlin2->FirstPoint(ind2);
1048             if (ptbis.IsTangencyPoint()) {
1049               if (dofirst ) {
1050                 if (ptdeb.Value().Distance(ptbis.Value()) <= TolArc) {
1051                   ptdeb.SetMultiple(Standard_True);
1052                   if (!ptbis.IsMultiple()) {
1053                     ptbis.SetMultiple(Standard_True);
1054                     wlin2->Replace(ind2,ptbis);
1055                   }
1056                 }
1057               }
1058               if (dolast ) {
1059                 if (ptfin.Value().Distance(ptbis.Value()) <= TolArc) {
1060                   ptfin.SetMultiple(Standard_True);
1061                   if (!ptbis.IsMultiple()) {
1062                     ptbis.SetMultiple(Standard_True);
1063                     wlin2->Replace(ind2,ptbis);
1064                   }
1065                 }
1066               }
1067             }
1068           }
1069           if (wlin2->HasLastPoint()) {
1070             ptbis = wlin2->LastPoint(ind2);
1071             if (ptbis.IsTangencyPoint()) {
1072               if (dofirst ) {
1073                 if (ptdeb.Value().Distance(ptbis.Value()) <= TolArc) {
1074                   ptdeb.SetMultiple(Standard_True);
1075                   if (!ptbis.IsMultiple()) {
1076                     ptbis.SetMultiple(Standard_True);
1077                     wlin2->Replace(ind2,ptbis);
1078                   }
1079                 }
1080               }
1081               if (dolast ) {
1082                 if (ptfin.Value().Distance(ptbis.Value()) <= TolArc) {
1083                   ptfin.SetMultiple(Standard_True);
1084                   if (!ptbis.IsMultiple()) {
1085                     ptbis.SetMultiple(Standard_True);
1086                     wlin2->Replace(ind2,ptbis);
1087                   }
1088                 }
1089               }
1090             }
1091           }
1092         }
1093         if(dofirst) 
1094           wlin1->Replace(indfirst,ptdeb);
1095         if(dolast) 
1096           wlin1->Replace(indlast,ptfin);
1097       }
1098     }
1099   }// if (seqpdep.Length() != 0 || seqpins.Length() != 0) {
1100   //
1101   // Treatment the segments
1102   NbSegm = solrst.NbSegments();
1103   if (NbSegm) {
1104     for(Standard_Integer i=1; i<=NbSegm; i++) {
1105       thesegm = solrst.Segment(i);  
1106       //Check if segment is degenerated
1107       if(thesegm.HasFirstPoint() && thesegm.HasLastPoint())
1108       {
1109         Standard_Real tol2 = Precision::Confusion();
1110         tol2 *= tol2;
1111         const gp_Pnt& aPf = thesegm.FirstPoint().Value();
1112         const gp_Pnt& aPl = thesegm.LastPoint().Value();
1113         if(aPf.SquareDistance(aPl) <= tol2)
1114         {
1115           //segment can be degenerated - check inner point
1116           paramf = thesegm.FirstPoint().Parameter();
1117           paraml = thesegm.LastPoint().Parameter();
1118           gp_Pnt2d _p2d = 
1119             thesegm.Curve()->Value(.57735 * paramf + 0.42265 * paraml);
1120           gp_Pnt aPm;
1121           if(reversed)
1122           {
1123             Surf1->D0(_p2d.X(), _p2d.Y(), aPm);
1124           }
1125           else
1126           {
1127             Surf2->D0(_p2d.X(), _p2d.Y(), aPm);
1128           }
1129           if(aPm.SquareDistance(aPf) <= tol2)
1130           {
1131             //Degenerated
1132             continue;
1133           }
1134         }
1135       }
1136
1137
1138       //----------------------------------------------------------------------      
1139       // on cree une ligne d intersection contenant uniquement le segment.
1140       // VOIR POUR LA TRANSITION DE LA LIGNE
1141       // On ajoute aussi un polygone pour le traitement des intersections
1142       // entre ligne et restrictions de la surface implicite (PutVertexOnLine)
1143       //----------------------------------------------------------------------
1144       //-- Calcul de la transition sur la rline (12 fev 97)
1145       //-- reversed a le sens de OnFirst
1146       //--
1147       dofirst = dolast  = Standard_False;
1148       procf = Standard_False;
1149       procl = Standard_False;
1150       IntSurf_Transition TLineUnk,TArcUnk;
1151
1152       IntPatch_Point _thepointAtBeg;
1153       IntPatch_Point _thepointAtEnd;
1154
1155       Standard_Boolean TransitionOK=Standard_False;
1156
1157       if(thesegm.HasFirstPoint()) { 
1158         Standard_Real _u1,_v1,_u2,_v2;
1159
1160         dofirst = Standard_True;
1161         PStartf = thesegm.FirstPoint();
1162         paramf = PStartf.Parameter();
1163
1164         gp_Pnt2d _p2d     = thesegm.Curve()->Value(paramf);
1165         Handle(Adaptor3d_HVertex) _vtx;
1166         if(PStartf.IsNew()==Standard_False) 
1167           _vtx= PStartf.Vertex();
1168         const gp_Pnt& _Pp = PStartf.Value();
1169         _thepointAtBeg.SetValue(_Pp,PStartf.Tolerance(),Standard_False);
1170         if (!reversed) { //-- typeS1 = Pln || Cyl || Sph || Cone
1171           Quad.Parameters(_Pp,_u1,_v1);
1172           _u2=_p2d.X(); _v2=_p2d.Y();
1173         }
1174         else {  //-- typeS1 != Pln && Cyl && Sph && Cone
1175           Quad.Parameters(_Pp,_u2,_v2);
1176           _u1=_p2d.X(); _v1=_p2d.Y();
1177         }
1178         _thepointAtBeg.SetParameters(_u1,_v1,_u2,_v2);
1179         _thepointAtBeg.SetParameter(paramf);
1180         if(PStartf.IsNew()==Standard_False) 
1181           _thepointAtBeg.SetVertex(reversed,_vtx);
1182         _thepointAtBeg.SetArc(reversed,thesegm.Curve(),paramf,TLineUnk,TArcUnk);
1183
1184
1185         gp_Vec d1u1,d1v1,d1u2,d1v2; gp_Vec2d _d2d;
1186         Surf1->D1(_u1,_v1,ptbid,d1u1,d1v1);
1187         norm1 = d1u1.Crossed(d1v1);
1188         Surf2->D1(_u2,_v2,ptbid,d1u2,d1v2);
1189         norm2 = d1u2.Crossed(d1v2);
1190
1191         thesegm.Curve()->D1(paramf,_p2d,_d2d);
1192         if(reversed) { 
1193           tgline.SetLinearForm(_d2d.X(),d1u1,_d2d.Y(),d1v1);
1194         }
1195         else { 
1196           tgline.SetLinearForm(_d2d.X(),d1u2,_d2d.Y(),d1v2);
1197         }
1198         _u1=tgline.DotCross(norm2,norm1);
1199         TransitionOK=Standard_True;
1200         if (_u1 > 0.00000001) {
1201           trans1 = IntSurf_Out;
1202           trans2 = IntSurf_In;
1203         }
1204         else if(_u1 < -0.00000001) { 
1205           trans1 = IntSurf_In;
1206           trans2 = IntSurf_Out;
1207         }
1208         else { 
1209           TransitionOK=Standard_False;
1210         }
1211       }
1212       if(thesegm.HasLastPoint()) {  
1213         Standard_Real _u1,_v1,_u2,_v2;
1214
1215         dolast = Standard_True;
1216         PStartl = thesegm.LastPoint();
1217         paraml = PStartl.Parameter();
1218
1219         gp_Pnt2d _p2d = thesegm.Curve()->Value(paraml);
1220         Handle(Adaptor3d_HVertex) _vtx;
1221         if(PStartl.IsNew()==Standard_False) 
1222           _vtx = PStartl.Vertex();
1223         const gp_Pnt& _Pp = PStartl.Value();
1224         IntPatch_Point _thepoint;
1225         _thepointAtEnd.SetValue(_Pp,PStartl.Tolerance(),Standard_False);
1226         if (!reversed) { //-- typeS1 = Pln || Cyl || Sph || Cone
1227           Quad.Parameters(_Pp,_u1,_v1);
1228           _u2=_p2d.X(); _v2=_p2d.Y();
1229         }
1230         else {  //-- typeS1 != Pln && Cyl && Sph && Cone
1231           Quad.Parameters(_Pp,_u2,_v2);
1232           _u1=_p2d.X(); _v1=_p2d.Y();
1233         }
1234         _thepointAtEnd.SetParameters(_u1,_v1,_u2,_v2);
1235         _thepointAtEnd.SetParameter(paraml);
1236         if(PStartl.IsNew()==Standard_False)
1237           _thepointAtEnd.SetVertex(reversed,_vtx);
1238         _thepointAtEnd.SetArc(reversed,thesegm.Curve(),paraml,TLineUnk,TArcUnk);
1239
1240
1241
1242         gp_Vec d1u1,d1v1,d1u2,d1v2; gp_Vec2d _d2d;
1243         Surf1->D1(_u1,_v1,ptbid,d1u1,d1v1);
1244         norm1 = d1u1.Crossed(d1v1);
1245         Surf2->D1(_u2,_v2,ptbid,d1u2,d1v2);
1246         norm2 = d1u2.Crossed(d1v2);
1247
1248         thesegm.Curve()->D1(paraml,_p2d,_d2d);
1249         if(reversed) { 
1250           tgline.SetLinearForm(_d2d.X(),d1u1,_d2d.Y(),d1v1);
1251         }
1252         else { 
1253           tgline.SetLinearForm(_d2d.X(),d1u2,_d2d.Y(),d1v2);
1254         }
1255         _u1=tgline.DotCross(norm2,norm1);
1256         TransitionOK=Standard_True;
1257         if (_u1 > 0.00000001) {
1258           trans1 = IntSurf_Out;
1259           trans2 = IntSurf_In;
1260         }
1261         else if(_u1 < -0.00000001) { 
1262           trans1 = IntSurf_In;
1263           trans2 = IntSurf_Out;
1264         }
1265         else { 
1266           TransitionOK=Standard_False;
1267         }       
1268       }
1269       if(TransitionOK==Standard_False) { 
1270         //-- rline = new IntPatch_RLine (thesegm.Curve(),reversed,Standard_False);
1271         rline =  new IntPatch_RLine (Standard_False);
1272         if(reversed) { 
1273           rline->SetArcOnS1(thesegm.Curve());
1274         }
1275         else { 
1276           rline->SetArcOnS2(thesegm.Curve());
1277         }
1278       }
1279       else { 
1280         //-- rline = new IntPatch_RLine (thesegm.Curve(),reversed,Standard_False,trans1,trans2);
1281         rline =  new IntPatch_RLine (Standard_False,trans1,trans2);
1282         if(reversed) { 
1283           rline->SetArcOnS1(thesegm.Curve());
1284         }
1285         else { 
1286           rline->SetArcOnS2(thesegm.Curve());
1287         }
1288       }
1289
1290       //------------------------------
1291       //-- Ajout des points 
1292       //--
1293       if (thesegm.HasFirstPoint()) {
1294         rline->AddVertex(_thepointAtBeg);
1295         rline->SetFirstPoint(rline->NbVertex());
1296       }
1297
1298       if (thesegm.HasLastPoint()) {
1299         rline->AddVertex(_thepointAtEnd);
1300         rline->SetLastPoint(rline->NbVertex());
1301       }
1302
1303       // Polygone sur restriction solution
1304       if (dofirst && dolast) {
1305         Standard_Real prm;
1306         gp_Pnt ptpoly;
1307         IntSurf_PntOn2S p2s;
1308         Handle(IntSurf_LineOn2S) Thelin = new IntSurf_LineOn2S ();
1309         Handle(Adaptor2d_HCurve2d) arcsegm = thesegm.Curve();
1310         Standard_Integer nbsample = 100;
1311
1312         if (!reversed) {
1313           for (Standard_Integer j=1; j<=nbsample; j++) {
1314             prm = paramf + (j-1)*(paraml-paramf)/(nbsample-1);
1315             arcsegm->D0(prm,p2d);
1316             Surf2->D0(p2d.X(),p2d.Y(),ptpoly);
1317
1318             Quad.Parameters(ptpoly,U1,V1);
1319             p2s.SetValue(ptpoly,U1,V1,p2d.X(),p2d.Y());
1320             Thelin->Add(p2s);
1321           }
1322         }
1323         else {
1324           for (Standard_Integer j=1; j<=nbsample; j++) {
1325             prm = paramf + (j-1)*(paraml-paramf)/(nbsample-1);
1326             arcsegm->D0(prm,p2d);
1327             Surf1->D0(p2d.X(),p2d.Y(),ptpoly);
1328
1329             Quad.Parameters(ptpoly,U2,V2);
1330             p2s.SetValue(ptpoly,p2d.X(),p2d.Y(),U2,V2);
1331             Thelin->Add(p2s);
1332           }
1333         }
1334         rline->Add(Thelin);
1335       }
1336
1337       if (dofirst || dolast) {
1338         Nblines = slin.Length();
1339         for (Standard_Integer j=1; j<=Nblines; j++) {
1340           const Handle(IntPatch_Line)& slinj = slin(j);
1341           typ = slinj->ArcType();
1342           if (typ == IntPatch_Walking) {
1343             Nbpts = Handle(IntPatch_WLine)::DownCast (slinj)->NbVertex();
1344           }
1345           else {
1346             Nbpts = Handle(IntPatch_RLine)::DownCast (slinj)->NbVertex();
1347           }
1348           for (Standard_Integer k=1; k<=Nbpts;k++) {
1349             if (typ == IntPatch_Walking) {
1350               ptdeb = Handle(IntPatch_WLine)::DownCast (slinj)->Vertex(k);
1351             }
1352             else {
1353               ptdeb = Handle(IntPatch_RLine)::DownCast (slinj)->Vertex(k);
1354             }
1355             if (dofirst) {
1356
1357               if (ptdeb.Value().Distance(PStartf.Value()) <=TolArc) {
1358                 ptdeb.SetMultiple(Standard_True);
1359                 if (typ == IntPatch_Walking) {
1360                   Handle(IntPatch_WLine)::DownCast (slinj)->Replace(k,ptdeb);
1361                 }
1362                 else {
1363                   Handle(IntPatch_RLine)::DownCast (slinj)->Replace(k,ptdeb);
1364                 }
1365                 ptdeb.SetParameter(paramf);
1366                 rline->AddVertex(ptdeb);
1367                 if (!procf){
1368                   procf=Standard_True;
1369                   rline->SetFirstPoint(rline->NbVertex());
1370                 }
1371               }
1372             }
1373             if (dolast) {
1374               if(dofirst) { //-- on recharge le ptdeb
1375                 if (typ == IntPatch_Walking) {
1376                   ptdeb = Handle(IntPatch_WLine)::DownCast (slinj)->Vertex(k);
1377                 }
1378                 else {
1379                   ptdeb = Handle(IntPatch_RLine)::DownCast (slinj)->Vertex(k);
1380                 }
1381               }
1382               if (ptdeb.Value().Distance(PStartl.Value()) <=TolArc) {
1383                 ptdeb.SetMultiple(Standard_True);
1384                 if (typ == IntPatch_Walking) {
1385                   Handle(IntPatch_WLine)::DownCast (slinj)->Replace(k,ptdeb);
1386                 }
1387                 else {
1388                   Handle(IntPatch_RLine)::DownCast (slinj)->Replace(k,ptdeb);
1389                 }
1390                 ptdeb.SetParameter(paraml);
1391                 rline->AddVertex(ptdeb);
1392                 if (!procl){
1393                   procl=Standard_True;
1394                   rline->SetLastPoint(rline->NbVertex());
1395                 }
1396               }
1397             }
1398           }
1399         }
1400       }
1401       slin.Append(rline);
1402     }
1403   }// if (NbSegm) 
1404   //
1405   // on traite les restrictions de la surface implicite
1406
1407   for (Standard_Integer i=1, aNbLin = slin.Length(); i<=aNbLin; i++)
1408   {
1409     Handle(IntPatch_PointLine) aL = Handle(IntPatch_PointLine)::DownCast(slin(i));
1410     
1411     if (!reversed)
1412       IntPatch_RstInt::PutVertexOnLine(aL,Surf1,D1,Surf2,Standard_True,TolTang);
1413     else
1414       IntPatch_RstInt::PutVertexOnLine(aL,Surf2,D2,Surf1,Standard_False,TolTang);
1415
1416     if (aL->NbPnts() <= 2)
1417     {
1418       Standard_Boolean aCond = aL->NbPnts() < 2;
1419       if (!aCond)
1420         aCond = (aL->Point(1).IsSame(aL->Point(2), Precision::Confusion()));
1421
1422       if (aCond)
1423       {
1424         slin.Remove(i);
1425         i--;
1426         aNbLin--;
1427         continue;
1428       }
1429     }
1430
1431     if(aL->ArcType() == IntPatch_Walking)
1432     {
1433       const Handle(IntPatch_WLine) aWL = Handle(IntPatch_WLine)::DownCast(aL);
1434       slin.Append(aWL);
1435       slin.Remove(i);
1436       i--;
1437       aNbLin--;
1438     }
1439   }
1440
1441   // Now slin is filled as follows: lower indices correspond to Restriction line,
1442   // after (higher indices) - only Walking-line.
1443
1444   const Standard_Real aTol3d = Max(Func.Tolerance(), TolTang); 
1445   const Handle(Adaptor3d_HSurface)& aQSurf = (reversed) ? Surf2 : Surf1;
1446   const Handle(Adaptor3d_HSurface)& anOtherSurf = (reversed) ? Surf1 : Surf2;
1447
1448   for (Standard_Integer i = 1; i <= slin.Length(); i++)
1449   {
1450     const Handle(IntPatch_PointLine)& aL1 = Handle(IntPatch_PointLine)::DownCast(slin(i));
1451     const Handle(IntPatch_RLine)& aRL1 = Handle(IntPatch_RLine)::DownCast(aL1);
1452
1453     if(aRL1.IsNull())
1454     {
1455       //Walking-Walking cases are not supported
1456       break;
1457     }
1458
1459     const Handle(Adaptor2d_HCurve2d)& anArc = aRL1->IsArcOnS1() ? 
1460                                               aRL1->ArcOnS1() :
1461                                               aRL1->ArcOnS2();
1462     if(anArc->Curve2d().GetType() != GeomAbs_Line)
1463     {
1464       //Restriction line must be isoline.
1465       //Other cases are not supported by
1466       //existing algorithms.
1467
1468       break;
1469     }
1470
1471     Standard_Boolean isFirstDeleted = Standard_False;
1472
1473     for(Standard_Integer j = i + 1; j <= slin.Length(); j++)
1474     {
1475       Handle(IntPatch_PointLine) aL2 = Handle(IntPatch_PointLine)::DownCast(slin(j));
1476       Handle(IntPatch_RLine) aRL2 = Handle(IntPatch_RLine)::DownCast(aL2);
1477
1478       //Here aL1 (i-th line) is Restriction-line and aL2 (j-th line) is
1479       //Restriction or Walking
1480
1481       if(!aRL2.IsNull())
1482       {
1483         const Handle(Adaptor2d_HCurve2d)& anArc2 = aRL2->IsArcOnS1() ?
1484                                                    aRL2->ArcOnS1() :
1485                                                    aRL2->ArcOnS2();
1486         if(anArc2->Curve2d().GetType() != GeomAbs_Line)
1487         {
1488           //Restriction line must be isoline.
1489           //Other cases are not supported by
1490           //existing algorithms.
1491
1492           continue;
1493         }
1494       }
1495
1496       //aDir can be equal to one of following four values only
1497       //(because Reastriction line is boundary of rectangular surface):
1498       //either {0, 1} or {0, -1} or {1, 0} or {-1, 0}.
1499       const gp_Dir2d aDir = anArc->Curve2d().Line().Direction();
1500
1501       Standard_Real aTol2d = anOtherSurf->UResolution(aTol3d),
1502                     aPeriod = anOtherSurf->IsVPeriodic() ? anOtherSurf->VPeriod() : 0.0;
1503
1504       if(Abs(aDir.X()) < 0.5)
1505       {//Restriction directs along V-direction
1506         aTol2d = anOtherSurf->VResolution(aTol3d);
1507         aPeriod = anOtherSurf->IsUPeriodic() ? anOtherSurf->UPeriod() : 0.0;
1508       }
1509
1510       const Standard_Boolean isCoincide = IsCoincide(Func, aL2, anArc, aRL1->IsArcOnS1(),
1511                                                       aTol3d, aTol2d, aPeriod);
1512
1513       if(isCoincide)
1514       {
1515         if(aRL2.IsNull())
1516         {//Delete Walking-line
1517           slin.Remove(j);
1518           j--;
1519         }
1520         else
1521         {//Restriction-Restriction
1522           const Handle(Adaptor2d_HCurve2d)& anArc2 = aRL2->IsArcOnS1() ?
1523                                                      aRL2->ArcOnS1() :
1524                                                      aRL2->ArcOnS2();
1525
1526           const Standard_Real aRange2 = anArc2->LastParameter() - 
1527                                         anArc2->FirstParameter();
1528           const Standard_Real aRange1 = anArc->LastParameter() -
1529                                         anArc->FirstParameter();
1530
1531           if(aRange2 > aRange1)
1532           {
1533             isFirstDeleted = Standard_True;
1534             break;
1535           }
1536           else
1537           {//Delete j-th line
1538             slin.Remove(j);
1539             j--;
1540           }
1541         }
1542       }
1543     } //for(Standard_Integer j = i + 1; j <= slin.Length(); j++)
1544
1545     if(isFirstDeleted)
1546     {//Delete i-th line
1547       slin.Remove(i--);
1548     }
1549   }//for (Standard_Integer i = 1; i <= slin.Length(); i++)
1550
1551   empt = (slin.Length() == 0 && spnt.Length() == 0);
1552   done = Standard_True;
1553
1554
1555   if(slin.Length() == 0)
1556     return;
1557
1558   Standard_Boolean isDecomposeRequired =  (Quad.TypeQuadric() == GeomAbs_Cone) || 
1559                                           (Quad.TypeQuadric() == GeomAbs_Sphere) ||
1560                                           (Quad.TypeQuadric() == GeomAbs_Cylinder) ||
1561                                           (Quad.TypeQuadric() == GeomAbs_Torus);
1562
1563   if(!isDecomposeRequired)
1564     return;
1565
1566   // post processing for cones and spheres
1567
1568   const Handle(Adaptor3d_TopolTool)& PDomain = (reversed) ? D1 : D2;
1569
1570   IntPatch_SequenceOfLine dslin;
1571   Standard_Boolean isDecompose = Standard_False;
1572   for(Standard_Integer i = 1; i <= slin.Length(); i++ )
1573   {
1574     if(DecomposeResult( Handle(IntPatch_PointLine)::DownCast(slin(i)),
1575                                         reversed, Quad, PDomain, aQSurf,
1576                                         anOtherSurf, TolArc, aTol3d, dslin))
1577     {
1578       isDecompose = Standard_True;
1579     }
1580   }
1581
1582   if(!isDecompose)
1583     return;
1584
1585   slin.Clear();
1586   for(Standard_Integer i = 1; i <= dslin.Length(); i++ )
1587     slin.Append(dslin(i));
1588 }
1589
1590 // correct U parameter of the start point of line on Quadric
1591 // (change 0->2PI or vs, if necessary)
1592 static Standard_Real AdjustUFirst(Standard_Real U1,Standard_Real U2)
1593 {
1594   Standard_Real u = U1;
1595
1596   // case: no adjustment
1597   if( U1 > 0. && U1 < (2.*M_PI) )
1598     return u;
1599
1600   // case: near '0'
1601   if( U1 == 0. || fabs(U1) <= 1.e-9 ) {
1602     if( U2 > 0. && U2 < (2.*M_PI) )
1603       u = ( U2 < ((2.*M_PI)-U2) ) ? 0. : (2.*M_PI);
1604     else {
1605       Standard_Real uu = U2;
1606       if( U2 > (2.*M_PI) )
1607         while( uu > (2.*M_PI) )
1608           uu -= (2.*M_PI);
1609       else 
1610         while( uu < 0.)
1611           uu += (2.*M_PI);
1612
1613       u = ( uu < ((2.*M_PI)-uu) ) ? 0. : (2.*M_PI);
1614     }
1615   }
1616   // case: near '2PI'
1617   else if( U1 == (2.*M_PI) || fabs((2.*M_PI)-fabs(U1)) <= 1.e-9 ) {
1618     if( U2 > 0. && U2 < (2.*M_PI) )
1619       u = ( U2 < ((2.*M_PI)-U2) ) ? 0. : (2.*M_PI);
1620     else {
1621       Standard_Real uu = U2;
1622       if( U2 > (2.*M_PI) )
1623         while( uu > (2.*M_PI) )
1624           uu -= (2.*M_PI);
1625       else 
1626         while( uu < 0.)
1627           uu += (2.*M_PI);
1628
1629       u = ( uu < ((2.*M_PI)-uu) ) ? 0. : (2.*M_PI);
1630     }
1631   }
1632   // case: '<0. || >2PI'
1633   else {
1634     if(U1 < 0.)
1635       while(u < 0.)
1636         u += 2.*M_PI;
1637     if(U1 > (2.*M_PI))
1638       while(u > (2.*M_PI))
1639         u -= (2.*M_PI);
1640   }
1641
1642   return u;
1643 }
1644
1645 // collect vertices, reject equals
1646 static Handle(IntSurf_LineOn2S) GetVertices(const Handle(IntPatch_PointLine)& thePLine,
1647                                             const Standard_Real           TOL3D,
1648                                             const Standard_Real           TOL2D)
1649 {
1650   //  Standard_Real TOL3D = 1.e-12, TOL2D = 1.e-8;
1651
1652   Handle(IntSurf_LineOn2S) vertices = new IntSurf_LineOn2S();
1653
1654   Standard_Real U1 = 0., U2 = 0., V1 = 0., V2 = 0.;
1655   Standard_Integer i = 0, k = 0;
1656   Standard_Integer NbVrt = thePLine->NbVertex();
1657
1658   TColStd_Array1OfInteger anVrts(1,NbVrt);
1659   anVrts.Init(0);
1660
1661   // check equal vertices
1662   for(i = 1; i <= NbVrt; i++) {
1663
1664     if( anVrts(i) == -1 ) continue;
1665
1666     const IntPatch_Point& Pi = thePLine->Vertex(i);
1667
1668     for(k = (i+1); k <= NbVrt; k++) {
1669
1670       if( anVrts(k) == -1 ) continue;
1671
1672       const IntPatch_Point& Pk = thePLine->Vertex(k);
1673
1674       if(Pi.Value().Distance(Pk.Value()) <= TOL3D) {
1675         // suggest the points are equal;
1676         // test 2d parameters on surface
1677         Standard_Boolean sameU1 = Standard_False;
1678         Standard_Boolean sameV1 = Standard_False;
1679         Standard_Boolean sameU2 = Standard_False;
1680         Standard_Boolean sameV2 = Standard_False;
1681
1682         Pi.ParametersOnS1(U1,V1);
1683         Pk.ParametersOnS1(U2,V2);
1684         if(fabs(U1-U2) <= TOL2D) sameU1 = Standard_True;
1685         if(fabs(V1-V2) <= TOL2D) sameV1 = Standard_True;
1686
1687         Pi.ParametersOnS2(U1,V1);
1688         Pk.ParametersOnS2(U2,V2);
1689         if(fabs(U1-U2) <= TOL2D) sameU2 = Standard_True;
1690         if(fabs(V1-V2) <= TOL2D) sameV2 = Standard_True;
1691
1692         if((sameU1 && sameV1) && (sameU2 && sameV2))
1693           anVrts(k) = -1;
1694       }
1695     }
1696   }
1697
1698   // copy further processed vertices
1699   for(i = 1; i <= NbVrt; i++) {
1700     if( anVrts(i) == -1 ) continue;
1701     vertices->Add(thePLine->Vertex(i).PntOn2S());
1702   }
1703   return vertices;
1704 }
1705
1706 static void SearchVertices(const Handle(IntSurf_LineOn2S)& Line,
1707   const Handle(IntSurf_LineOn2S)& Vertices,
1708   TColStd_Array1OfInteger&        PTypes)
1709 {
1710   Standard_Integer nbp = Line->NbPoints(), nbv = Vertices->NbPoints();
1711   Standard_Integer ip = 0, iv = 0;
1712   for(ip = 1; ip <= nbp; ip++) {
1713     const IntSurf_PntOn2S& aP = Line->Value(ip);
1714     Standard_Integer type = 0;
1715     for(iv = 1; iv <= nbv; iv++) {
1716       const IntSurf_PntOn2S& aV = Vertices->Value(iv);
1717       if(aP.IsSame(aV, Precision::Confusion(), Precision::PConfusion())) {
1718         type = iv; 
1719         break;
1720       }
1721     }
1722     PTypes(ip) = type;
1723   }
1724 }
1725
1726 static inline Standard_Boolean IsSeamParameter(const Standard_Real U,
1727   const Standard_Real TOL2D)
1728 {
1729   return (fabs(U) <= TOL2D || fabs(2.*M_PI - U) <= TOL2D);
1730 }
1731
1732 static inline Standard_Real AdjustU(const Standard_Real U)
1733 {
1734   Standard_Real u = U, DBLPI = 2.*M_PI;
1735   if(u < 0. || u > DBLPI) {
1736     if(u < 0.)
1737       while(u < 0.)
1738         u += DBLPI;
1739     else
1740       while(u > DBLPI)
1741         u -= DBLPI;
1742   }
1743   return u;
1744 }
1745
1746 static inline void Correct2DBounds(const Standard_Real UF,
1747   const Standard_Real UL,
1748   const Standard_Real VF,
1749   const Standard_Real VL,
1750   const Standard_Real TOL2D,
1751   Standard_Real&      U,
1752   Standard_Real&      V)
1753 {
1754   Standard_Real Eps = 1.e-16;
1755   Standard_Real dUF = fabs(U - UF);
1756   Standard_Real dUL = fabs(U - UL);
1757   Standard_Real dVF = fabs(V - VF);
1758   Standard_Real dVL = fabs(V - VL);
1759   if(dUF <= TOL2D && dUF > Eps) U = UF;
1760   if(dUL <= TOL2D && dUL > Eps) U = UL;
1761   if(dVF <= TOL2D && dVF > Eps) V = VF;
1762   if(dVL <= TOL2D && dVL > Eps) V = VL;
1763 }
1764
1765 static void AdjustLine(Handle(IntSurf_LineOn2S)& Line,
1766   const Standard_Boolean    IsReversed,
1767   const Handle(Adaptor3d_HSurface)&         QSurf,
1768   const Standard_Real       TOL2D)
1769 {
1770   Standard_Real VF = QSurf->FirstVParameter();
1771   Standard_Real VL = QSurf->LastVParameter();
1772   Standard_Real UF = QSurf->FirstUParameter();
1773   Standard_Real UL = QSurf->LastUParameter();
1774
1775   Standard_Integer nbp = Line->NbPoints(), ip = 0;
1776   Standard_Real U = 0., V = 0.;
1777   for(ip = 1; ip <= nbp; ip++) {
1778     if(IsReversed) {
1779       Line->Value(ip).ParametersOnS2(U,V);
1780       U = AdjustU(U);
1781       Correct2DBounds(UF,UL,VF,VL,TOL2D,U,V);
1782       Line->SetUV(ip,Standard_False,U,V);
1783     }
1784     else {
1785       Line->Value(ip).ParametersOnS1(U,V);
1786       U = AdjustU(U);
1787       Correct2DBounds(UF,UL,VF,VL,TOL2D,U,V);
1788       Line->SetUV(ip,Standard_True,U,V);
1789     }
1790   }
1791 }
1792
1793 static Standard_Boolean InsertSeamVertices(Handle(IntSurf_LineOn2S)&       Line,
1794   const Standard_Boolean          IsReversed,
1795   Handle(IntSurf_LineOn2S)&       Vertices,
1796   const TColStd_Array1OfInteger&  PTypes,
1797   const Standard_Real             TOL2D)
1798 {
1799   Standard_Boolean result = Standard_False;
1800   Standard_Integer ip = 0, nbp = Line->NbPoints();
1801   Standard_Real U = 0., V = 0.;
1802   for(ip = 1; ip <= nbp; ip++) {
1803     Standard_Integer ipt = PTypes(ip);
1804     if(ipt != 0) {
1805       const IntSurf_PntOn2S& aP = Line->Value(ip);
1806       if(IsReversed)
1807         aP.ParametersOnS2(U,V); // S2 - quadric
1808       else
1809         aP.ParametersOnS1(U,V); // S1 - quadric
1810       U = AdjustU(U);
1811       if(IsSeamParameter(U,TOL2D)) {
1812         if(ip == 1 || ip == nbp) {
1813           Standard_Real U1 = 0., V1 = 0.;
1814           Standard_Integer ipp = (ip == 1) ? (ip+1) : (ip-1);
1815           if(IsReversed)
1816             Line->Value(ipp).ParametersOnS2(U1,V1); // S2 - quadric
1817           else
1818             Line->Value(ipp).ParametersOnS1(U1,V1); // S1 - quadric
1819           Standard_Real u = AdjustUFirst(U,U1);
1820           if(fabs(u-U) >= 1.5*M_PI) {
1821             Standard_Real U2 = 0., V2 = 0.;
1822             if(IsReversed) {
1823               Line->Value(ip).ParametersOnS1(U2,V2); // prm
1824               Line->SetUV(ip,Standard_False,u,V);
1825               Line->SetUV(ip,Standard_True,U2,V2);
1826             }
1827             else {
1828               Line->Value(ip).ParametersOnS2(U2,V2); // prm
1829               Line->SetUV(ip,Standard_True,u,V);
1830               Line->SetUV(ip,Standard_False,U2,V2);
1831             }
1832           }
1833         }
1834         else {
1835           Standard_Integer ipp = ip - 1;
1836           Standard_Integer ipn = ip + 1;
1837           Standard_Real U1 = 0., V1 = 0., U2 = 0., V2 = 0.;
1838           if(IsReversed) {
1839             Line->Value(ipp).ParametersOnS2(U1,V1); // quad
1840             Line->Value(ipn).ParametersOnS2(U2,V2); // quad
1841           }
1842           else {
1843             Line->Value(ipp).ParametersOnS1(U1,V1); // quad
1844             Line->Value(ipn).ParametersOnS1(U2,V2); // quad
1845           }
1846           U1 = AdjustU(U1);
1847           U2 = AdjustU(U2);
1848           Standard_Boolean pnearZero = (fabs(U1) < fabs(2.*M_PI-U1)) ? Standard_True : Standard_False;
1849           Standard_Boolean cnearZero = (fabs(U) < fabs(2.*M_PI-U)) ? Standard_True : Standard_False;
1850           if(pnearZero == cnearZero) {
1851             if(!IsSeamParameter(U2,TOL2D) && !IsSeamParameter(U1,TOL2D)) {
1852               Standard_Real nU = (cnearZero) ? (2.*M_PI) : 0.;
1853               IntSurf_PntOn2S nP;
1854               nP.SetValue(aP.Value());
1855               Standard_Real U3 = 0., V3 = 0.;
1856               if(IsReversed) {
1857                 Line->Value(ip).ParametersOnS1(U3,V3); // prm
1858                 nP.SetValue(Standard_False,nU,V);
1859                 nP.SetValue(Standard_True,U3,V3);
1860               }
1861               else {
1862                 Line->Value(ip).ParametersOnS2(U3,V3); // prm
1863                 nP.SetValue(Standard_True,nU,V);
1864                 nP.SetValue(Standard_False,U3,V3);
1865               }
1866               Line->InsertBefore(ipn,nP);
1867               Vertices->Add(nP);
1868               result = Standard_True;
1869               break;
1870             }
1871           }
1872           else {
1873             if(!IsSeamParameter(U2,TOL2D) && !IsSeamParameter(U1,TOL2D)) {
1874               Standard_Real nU = (cnearZero) ? (2.*M_PI) : 0.;
1875               IntSurf_PntOn2S nP;
1876               nP.SetValue(aP.Value());
1877               Standard_Real U3 = 0., V3 = 0.;
1878               if(IsReversed) {
1879                 Line->Value(ip).ParametersOnS1(U3,V3); // prm
1880                 nP.SetValue(Standard_False,nU,V);
1881                 nP.SetValue(Standard_True,U3,V3);
1882               }
1883               else {
1884                 Line->Value(ip).ParametersOnS2(U3,V3); // prm
1885                 nP.SetValue(Standard_True,nU,V);
1886                 nP.SetValue(Standard_False,U3,V3);
1887               }
1888               Line->InsertBefore(ip,nP);
1889               Vertices->Add(nP);
1890               result = Standard_True;
1891               break;
1892             }
1893             else {
1894               // Line->InsertBefore(ip,Line->Value(ipn));
1895               // Line->RemovePoint(ip+2);
1896               // result = Standard_True;
1897               // cout << "swap vertex " << endl;
1898               // break;
1899             }
1900           }
1901         }
1902       }
1903     }
1904   }
1905   return result;
1906 }
1907
1908 static void ToSmooth( const Handle(IntSurf_LineOn2S)& Line,
1909                       const Standard_Boolean          IsReversed,
1910                       const IntSurf_Quadric&          Quad,
1911                       const Standard_Boolean          IsFirst,
1912                       Standard_Real&                  D3D)
1913 {
1914   if(Line->NbPoints() <= 10)
1915     return;
1916
1917   D3D = 0.;
1918   Standard_Integer NbTestPnts = Line->NbPoints() / 5;
1919   if(NbTestPnts < 5) NbTestPnts = 5;
1920
1921   Standard_Integer startp = (IsFirst) ? 2 : (Line->NbPoints() - NbTestPnts - 2);
1922   Standard_Integer ip = 0;
1923   Standard_Real Uc = 0., Vc = 0., Un = 0., Vn = 0., DDU = 0., DDV = 0.;
1924
1925   for(ip = startp; ip <= NbTestPnts; ip++) {
1926     if(IsReversed) {
1927       Line->Value(ip).ParametersOnS2(Uc,Vc); // S2 - quadric
1928       Line->Value(ip+1).ParametersOnS2(Un,Vn);
1929     }
1930     else {
1931       Line->Value(ip).ParametersOnS1(Uc,Vc); // S1 - quadric
1932       Line->Value(ip+1).ParametersOnS1(Un,Vn);
1933     }
1934     DDU += fabs(fabs(Uc)-fabs(Un));
1935     DDV += fabs(fabs(Vc)-fabs(Vn));
1936
1937     if(ip > startp) {
1938       Standard_Real DP = Line->Value(ip).Value().Distance(Line->Value(ip-1).Value());
1939       D3D += DP;
1940     }
1941   }
1942
1943   DDU /= (Standard_Real) NbTestPnts + 1;
1944   DDV /= (Standard_Real) NbTestPnts + 1;
1945
1946   D3D /= (Standard_Real) NbTestPnts + 1;
1947
1948
1949   Standard_Integer Index1 = (IsFirst) ? 1 : (Line->NbPoints());
1950   Standard_Integer Index2 = (IsFirst) ? 2 : (Line->NbPoints()-1);
1951   Standard_Integer Index3 = (IsFirst) ? 3 : (Line->NbPoints()-2);
1952
1953   Standard_Boolean doU = Standard_False;
1954
1955   Standard_Real U1 = 0., U2 = 0., V1 = 0., V2 = 0., U3 = 0., V3 = 0.;
1956
1957   if(IsReversed) {
1958     Line->Value(Index1).ParametersOnS2(U1,V1); // S2 - quadric
1959     Line->Value(Index2).ParametersOnS2(U2,V2);
1960     Line->Value(Index3).ParametersOnS2(U3,V3);
1961   }
1962   else {
1963     Line->Value(Index1).ParametersOnS1(U1,V1); // S1 - quadric
1964     Line->Value(Index2).ParametersOnS1(U2,V2);
1965     Line->Value(Index3).ParametersOnS1(U3,V3);
1966   }
1967
1968   if(!doU && Quad.TypeQuadric() == GeomAbs_Sphere) {
1969     if(fabs(fabs(U1)-fabs(U2)) > (M_PI/16.)) doU = Standard_True;
1970
1971     if(doU && (fabs(U1) <= 1.e-9 || fabs(U1-2.*M_PI) <= 1.e-9)) {
1972       if(fabs(V1-M_PI/2.) <= 1.e-9 || fabs(V1+M_PI/2.) <= 1.e-9) {}
1973       else {
1974         doU = Standard_False;
1975       }
1976     }
1977   }
1978
1979   if(Quad.TypeQuadric() == GeomAbs_Cone) {
1980     Standard_Real Uapx = 0., Vapx = 0.;
1981     Quad.Parameters(Quad.Cone().Apex(),Uapx,Vapx);
1982
1983     if(fabs(fabs(U1)-fabs(U2)) > M_PI/32.) doU = Standard_True;
1984
1985     if(doU && (fabs(U1) <= 1.e-9 || fabs(U1-2.*M_PI) <= 1.e-9)) {
1986       if(fabs(V1-Vapx) <= 1.e-9) {}
1987       else {
1988         doU = Standard_False;
1989       }
1990     }
1991   }
1992
1993   if(doU) {
1994     Standard_Real dU = Min((DDU/10.),5.e-8);
1995     Standard_Real U = (U2 > U3) ? (U2 + dU) : (U2 - dU);
1996     if(IsReversed)
1997       Line->SetUV(Index1,Standard_False,U,V1);
1998     else
1999       Line->SetUV(Index1,Standard_True,U,V1);
2000     U1 = U;
2001   }
2002
2003
2004 static Standard_Boolean TestMiddleOnPrm(const IntSurf_PntOn2S& aP,
2005                                         const IntSurf_PntOn2S& aV,
2006                                         const Standard_Boolean IsReversed,
2007                                         const Standard_Real    ArcTol,
2008                                         const Handle(Adaptor3d_TopolTool)&  PDomain)
2009
2010 {
2011   Standard_Boolean result = Standard_False;
2012   Standard_Real Up = 0., Vp = 0., Uv = 0., Vv = 0.;
2013   if(IsReversed) {
2014     aP.ParametersOnS1(Up,Vp); //S1 - parametric
2015     aV.ParametersOnS1(Uv,Vv);
2016   }
2017   else {
2018     aP.ParametersOnS2(Up,Vp); // S2 - parametric
2019     aV.ParametersOnS2(Uv,Vv);
2020   }
2021   Standard_Real Um = (Up + Uv)*0.5, Vm = (Vp + Vv)*0.5;
2022   gp_Pnt2d a2DPntM(Um,Vm);
2023   TopAbs_State PosM = PDomain->Classify(a2DPntM,ArcTol);
2024   if(PosM == TopAbs_ON || PosM == TopAbs_IN )
2025     result = Standard_True;
2026   return result;
2027 }
2028
2029 static void VerifyVertices( const Handle(IntSurf_LineOn2S)&    Line,
2030                             const Standard_Boolean             IsReversed,
2031                             const Handle(IntSurf_LineOn2S)&    Vertices,
2032                             const Standard_Real                TOL2D,
2033                             const Standard_Real       ArcTol,
2034                             const Handle(Adaptor3d_TopolTool)& PDomain,
2035                             IntSurf_PntOn2S&          VrtF,
2036                             Standard_Boolean&         AddFirst,
2037                             IntSurf_PntOn2S&          VrtL,
2038                             Standard_Boolean&         AddLast)
2039 {
2040   Standard_Integer nbp = Line->NbPoints(), nbv = Vertices->NbPoints();
2041   Standard_Integer FIndexSame = 0, FIndexNear = 0, LIndexSame = 0, LIndexNear = 0;
2042   const IntSurf_PntOn2S& aPF = Line->Value(1);
2043   const IntSurf_PntOn2S& aPL = Line->Value(nbp);
2044   Standard_Real UF = 0., VF = 0., UL = 0., VL = 0.;
2045   if(IsReversed) {
2046     aPF.ParametersOnS2(UF,VF);
2047     aPL.ParametersOnS2(UL,VL);
2048   }
2049   else {
2050     aPF.ParametersOnS1(UF,VF);
2051     aPL.ParametersOnS1(UL,VL);
2052   }
2053   gp_Pnt2d a2DPF(UF,VF);
2054   gp_Pnt2d a2DPL(UL,VL);
2055   Standard_Real DistMinF = 1.e+100, DistMinL = 1.e+100;
2056   Standard_Integer FConjugated = 0, LConjugated = 0;
2057
2058   Standard_Integer iv = 0;
2059
2060   for(iv = 1; iv <= nbv; iv++) {
2061     Standard_Real Uv = 0., Vv = 0.;
2062     if(IsReversed) {
2063       Vertices->Value(iv).ParametersOnS2(Uv,Vv);
2064       Uv = AdjustU(Uv);
2065       Vertices->SetUV(iv,Standard_False,Uv,Vv);
2066     }
2067     else {
2068       Vertices->Value(iv).ParametersOnS1(Uv,Vv);
2069       Uv = AdjustU(Uv);
2070       Vertices->SetUV(iv,Standard_True,Uv,Vv);
2071     }
2072   }
2073
2074   for(iv = 1; iv <= nbv; iv++) {
2075     const IntSurf_PntOn2S& aV = Vertices->Value(iv);
2076     if(aPF.IsSame(aV, Precision::Confusion(), Precision::PConfusion())) {
2077       FIndexSame = iv;
2078       break;
2079     }
2080     else {
2081       Standard_Real Uv = 0., Vv = 0.;
2082       if(IsReversed)
2083         aV.ParametersOnS2(Uv,Vv);
2084       else
2085         aV.ParametersOnS1(Uv,Vv);
2086       gp_Pnt2d a2DV(Uv,Vv);
2087       Standard_Real Dist = a2DV.Distance(a2DPF);
2088       if(Dist < DistMinF) {
2089         DistMinF = Dist;
2090         FIndexNear = iv;
2091         if(FConjugated != 0)
2092           FConjugated = 0;
2093       }
2094       if(IsSeamParameter(Uv,TOL2D)) {
2095         Standard_Real Ucv = (fabs(Uv) < fabs(2.*M_PI-Uv)) ? (2.*M_PI) : 0.;
2096         gp_Pnt2d a2DCV(Ucv,Vv);
2097         Standard_Real CDist = a2DCV.Distance(a2DPF);
2098         if(CDist < DistMinF) {
2099           DistMinF = CDist;
2100           FConjugated = iv;
2101           FIndexNear = iv;
2102         }
2103       }
2104     }
2105   }
2106
2107   for(iv = 1; iv <= nbv; iv++) {
2108     const IntSurf_PntOn2S& aV = Vertices->Value(iv);
2109     if(aPL.IsSame(aV, Precision::Confusion(), Precision::PConfusion())) {
2110       LIndexSame = iv;
2111       break;
2112     }
2113     else {
2114       Standard_Real Uv = 0., Vv = 0.;
2115       if(IsReversed)
2116         aV.ParametersOnS2(Uv,Vv);
2117       else
2118         aV.ParametersOnS1(Uv,Vv);
2119       gp_Pnt2d a2DV(Uv,Vv);
2120       Standard_Real Dist = a2DV.Distance(a2DPL);
2121       if(Dist < DistMinL) {
2122         DistMinL = Dist;
2123         LIndexNear = iv;
2124         if(LConjugated != 0)
2125           LConjugated = 0;
2126       }
2127       if(IsSeamParameter(Uv,TOL2D)) {
2128         Standard_Real Ucv = (fabs(Uv) < fabs(2.*M_PI-Uv)) ? (2.*M_PI) : 0.;
2129         gp_Pnt2d a2DCV(Ucv,Vv);
2130         Standard_Real CDist = a2DCV.Distance(a2DPL);
2131         if(CDist < DistMinL) {
2132           DistMinL = CDist;
2133           LConjugated = iv;
2134           LIndexNear = iv;
2135         }
2136       }
2137     }
2138   }
2139
2140   AddFirst = Standard_False;
2141   AddLast  = Standard_False;
2142
2143   if(FIndexSame == 0) {
2144     if(FIndexNear != 0) {
2145       const IntSurf_PntOn2S& aV = Vertices->Value(FIndexNear);
2146       Standard_Real Uv = 0., Vv = 0.;
2147       if(IsReversed)
2148         aV.ParametersOnS2(Uv,Vv);
2149       else
2150         aV.ParametersOnS1(Uv,Vv);
2151       if(IsSeamParameter(Uv,TOL2D)) {
2152         Standard_Real Ucv = (fabs(Uv) < fabs(2.*M_PI-Uv)) ? (2.*M_PI) : 0.;
2153         Standard_Boolean test = TestMiddleOnPrm(aPF,aV,IsReversed,ArcTol,PDomain);
2154         if(test) {
2155           VrtF.SetValue(aV.Value());
2156           if(IsReversed) {
2157             Standard_Real U2 = 0., V2 = 0.;
2158             aV.ParametersOnS1(U2,V2); // S1 - prm
2159             VrtF.SetValue(Standard_True,U2,V2);
2160             if(FConjugated == 0)
2161               VrtF.SetValue(Standard_False,Uv,Vv);
2162             else
2163               VrtF.SetValue(Standard_False,Ucv,Vv);
2164           }
2165           else {
2166             Standard_Real U2 = 0., V2 = 0.;
2167             aV.ParametersOnS2(U2,V2); // S2 - prm
2168             VrtF.SetValue(Standard_False,U2,V2);
2169             if(FConjugated == 0)
2170               VrtF.SetValue(Standard_True,Uv,Vv);
2171             else
2172               VrtF.SetValue(Standard_True,Ucv,Vv);
2173           }
2174           Standard_Real Dist3D = VrtF.Value().Distance(aPF.Value());
2175           if(Dist3D > 1.5e-7 && DistMinF > TOL2D) {
2176             AddFirst = Standard_True;
2177           }
2178         }
2179       }
2180       else {
2181         // to do: analyze internal vertex
2182       }
2183     }
2184   }
2185
2186   if(LIndexSame == 0) {
2187     if(LIndexNear != 0) {
2188       const IntSurf_PntOn2S& aV = Vertices->Value(LIndexNear);
2189       Standard_Real Uv = 0., Vv = 0.;
2190       if(IsReversed)
2191         aV.ParametersOnS2(Uv,Vv);
2192       else
2193         aV.ParametersOnS1(Uv,Vv);
2194       if(IsSeamParameter(Uv,TOL2D)) {
2195         Standard_Real Ucv = (fabs(Uv) < fabs(2.*M_PI-Uv)) ? (2.*M_PI) : 0.;
2196         Standard_Boolean test = TestMiddleOnPrm(aPL,aV,IsReversed,ArcTol,PDomain);
2197         if(test) {
2198           VrtL.SetValue(aV.Value());
2199           if(IsReversed) {
2200             Standard_Real U2 = 0., V2 = 0.;
2201             aV.ParametersOnS1(U2,V2); // S1 - prm
2202             VrtL.SetValue(Standard_True,U2,V2);
2203             if(LConjugated == 0)
2204               VrtL.SetValue(Standard_False,Uv,Vv);
2205             else
2206               VrtL.SetValue(Standard_False,Ucv,Vv);
2207           }
2208           else {
2209             Standard_Real U2 = 0., V2 = 0.;
2210             aV.ParametersOnS2(U2,V2); // S2 - prm
2211             VrtL.SetValue(Standard_False,U2,V2);
2212             if(LConjugated == 0)
2213               VrtL.SetValue(Standard_True,Uv,Vv);
2214             else
2215               VrtL.SetValue(Standard_True,Ucv,Vv);
2216           }
2217           Standard_Real Dist3D = VrtL.Value().Distance(aPL.Value());
2218           if(Dist3D > 1.5e-7 && DistMinL > TOL2D) {
2219             AddLast = Standard_True;
2220           }
2221         }
2222       }
2223       else {
2224         // to do: analyze internal vertex
2225       }
2226     }
2227   }
2228 }
2229
2230 static Standard_Boolean AddVertices(Handle(IntSurf_LineOn2S)& Line,
2231   const IntSurf_PntOn2S&    VrtF,
2232   const Standard_Boolean    AddFirst,
2233   const IntSurf_PntOn2S&    VrtL,
2234   const Standard_Boolean    AddLast,
2235   const Standard_Real       D3DF,
2236   const Standard_Real       D3DL)
2237 {
2238   Standard_Boolean result = Standard_False;
2239   if(AddFirst) {
2240     Standard_Real DF = Line->Value(1).Value().Distance(VrtF.Value());
2241     if((D3DF*2.) > DF && DF > 1.5e-7) {
2242       Line->InsertBefore(1,VrtF);
2243       result = Standard_True;
2244     }
2245   }
2246   if(AddLast) {
2247     Standard_Real DL = Line->Value(Line->NbPoints()).Value().Distance(VrtL.Value());
2248     if((D3DL*2.) > DL && DL > 1.5e-7) {
2249       Line->Add(VrtL);
2250       result = Standard_True;
2251     }
2252   }
2253   return result;
2254 }
2255
2256
2257 static void PutIntVertices(const Handle(IntPatch_PointLine)&    Line,
2258   Handle(IntSurf_LineOn2S)& Result,
2259   Standard_Boolean          theIsReversed,
2260   Handle(IntSurf_LineOn2S)& Vertices,
2261   const Standard_Real       ArcTol)
2262 {
2263   Standard_Integer nbp = Result->NbPoints(), nbv = Vertices->NbPoints();
2264
2265   if(nbp < 3)
2266     return;
2267
2268   const Handle(IntPatch_RLine) aRLine = Handle(IntPatch_RLine)::DownCast(Line);
2269
2270   Standard_Integer ip = 0, iv = 0;
2271   gp_Pnt aPnt;
2272   IntPatch_Point thePnt;
2273   Standard_Real U1 = 0., V1 = 0., U2 = 0., V2 = 0.;
2274
2275   for(ip = 2; ip <= (nbp-1); ip++) {
2276     const IntSurf_PntOn2S& aP = Result->Value(ip);
2277     for(iv = 1; iv <= nbv; iv++) {
2278       const IntSurf_PntOn2S& aV = Vertices->Value(iv);
2279       if(aP.IsSame(aV, Precision::Confusion(), Precision::PConfusion())) {
2280         aPnt = Result->Value(ip).Value();
2281         Result->Value(ip).ParametersOnS1(U1,V1);
2282         Result->Value(ip).ParametersOnS2(U2,V2);
2283         thePnt.SetValue(aPnt,ArcTol,Standard_False);
2284         thePnt.SetParameters(U1,V1,U2,V2);
2285         
2286         Standard_Real aParam = (Standard_Real)ip;
2287
2288         if(!aRLine.IsNull())
2289         {
2290           //In fact, aRLine is always on the parametric surface.
2291           //If (theIsReversed == TRUE) then (U1, V1) - point on
2292           //parametric surface, otherwise - point on quadric.
2293           const Handle(Adaptor2d_HCurve2d)& anArc = aRLine->IsArcOnS1() ?
2294                                                     aRLine->ArcOnS1() :
2295                                                     aRLine->ArcOnS2();
2296
2297           const gp_Lin2d aLin(anArc->Curve2d().Line());
2298           gp_Pnt2d aPSurf;
2299
2300           if(theIsReversed)
2301           {
2302             aPSurf.SetCoord(U1, V1);
2303           }
2304           else
2305           {
2306             aPSurf.SetCoord(U2, V2);
2307           }
2308
2309           aParam = ElCLib::Parameter(aLin, aPSurf);
2310         }
2311         
2312         thePnt.SetParameter(aParam);
2313         Line->AddVertex(thePnt);
2314       }
2315     }
2316   }
2317 }
2318
2319 static Standard_Boolean HasInternals(Handle(IntSurf_LineOn2S)& Line,
2320   Handle(IntSurf_LineOn2S)& Vertices)
2321 {
2322   Standard_Integer nbp = Line->NbPoints(), nbv = Vertices->NbPoints();
2323   Standard_Integer ip = 0, iv = 0;
2324   Standard_Boolean result = Standard_False;
2325
2326   if(nbp < 3)
2327     return result;
2328
2329   for(ip = 2; ip <= (nbp-1); ip++) {
2330     const IntSurf_PntOn2S& aP = Line->Value(ip);
2331     for(iv = 1; iv <= nbv; iv++) {
2332       const IntSurf_PntOn2S& aV = Vertices->Value(iv);
2333       if(aP.IsSame(aV, Precision::Confusion(), Precision::PConfusion())) {
2334         result = Standard_True;
2335         break;
2336       }
2337     }
2338     if(result)
2339       break;
2340   }
2341
2342   return result;
2343 }
2344 static Handle(IntPatch_WLine) MakeSplitWLine (Handle(IntPatch_WLine)&        WLine,
2345   Standard_Boolean         Tang,
2346   IntSurf_TypeTrans        Trans1,
2347   IntSurf_TypeTrans        Trans2,
2348   Standard_Real            ArcTol,
2349   Standard_Integer         ParFirst,
2350   Standard_Integer         ParLast)
2351 {
2352   Handle(IntSurf_LineOn2S) SLine = WLine->Curve();
2353   Handle(IntSurf_LineOn2S) sline = new IntSurf_LineOn2S();
2354
2355   Standard_Integer ip = 0;
2356   for(ip = ParFirst; ip <= ParLast; ip++)
2357     sline->Add(SLine->Value(ip));
2358
2359   Handle(IntPatch_WLine) wline = new IntPatch_WLine(sline,Tang,Trans1,Trans2);
2360
2361   gp_Pnt aSPnt;
2362   IntPatch_Point TPntF,TPntL;
2363   Standard_Real uu1 = 0., vv1 = 0., uu2 = 0., vv2 = 0.;
2364
2365   aSPnt = sline->Value(1).Value();
2366   sline->Value(1).ParametersOnS1(uu1,vv1);
2367   sline->Value(1).ParametersOnS2(uu2,vv2);
2368   TPntF.SetValue(aSPnt,ArcTol,Standard_False);
2369   TPntF.SetParameters(uu1,vv1,uu2,vv2);
2370   TPntF.SetParameter(1.);
2371   wline->AddVertex(TPntF);
2372   wline->SetFirstPoint(1);
2373
2374   aSPnt =  sline->Value(sline->NbPoints()).Value();
2375   sline->Value(sline->NbPoints()).ParametersOnS1(uu1,vv1);
2376   sline->Value(sline->NbPoints()).ParametersOnS2(uu2,vv2);
2377   TPntL.SetValue(aSPnt,ArcTol,Standard_False);
2378   TPntL.SetParameters(uu1,vv1,uu2,vv2);
2379   TPntL.SetParameter((Standard_Real)sline->NbPoints());
2380   wline->AddVertex(TPntL);
2381   wline->SetLastPoint(wline->NbVertex());
2382
2383   return wline;
2384 }
2385
2386 static Standard_Boolean SplitOnSegments(Handle(IntPatch_WLine)&        WLine,
2387   Standard_Boolean         Tang,
2388   IntSurf_TypeTrans        Trans1,
2389   IntSurf_TypeTrans        Trans2,
2390   Standard_Real            ArcTol,
2391   IntPatch_SequenceOfLine& Segments)
2392 {
2393   Standard_Boolean result = Standard_False;
2394   Segments.Clear();
2395
2396   Standard_Integer nbv = WLine->NbVertex();
2397   if(nbv > 3) {
2398     Standard_Integer iv = 0;
2399     for(iv = 1; iv < nbv; iv++) {
2400       Standard_Integer firstPar = 
2401                     (Standard_Integer) WLine->Vertex(iv).ParameterOnLine();
2402       Standard_Integer lastPar  = 
2403                     (Standard_Integer) WLine->Vertex(iv+1).ParameterOnLine();
2404       if((lastPar - firstPar) <= 1)
2405         continue;
2406       else {
2407         Handle(IntPatch_WLine) splitwline = MakeSplitWLine(WLine,Tang,Trans1,Trans2,
2408                                                                 ArcTol,firstPar,lastPar);
2409         Segments.Append(splitwline);
2410         if(!result)
2411           result = Standard_True;
2412       }
2413     }
2414   }
2415   return result;
2416 }
2417
2418 //=======================================================================
2419 //function : DecomposeResult
2420 //purpose  : Split <theLine> in the places where it passes through seam edge
2421 //            or singularity (apex of cone or pole of sphere).
2422 //            This passage is detected by jump of U-parameter
2423 //            from point to point.
2424 //=======================================================================
2425 static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLine,
2426                                         const Standard_Boolean       IsReversed,
2427                                         const IntSurf_Quadric&       theQuad,
2428                                         const Handle(Adaptor3d_TopolTool)& thePDomain,
2429                                         const Handle(Adaptor3d_HSurface)&  theQSurf, //quadric
2430                                         const Handle(Adaptor3d_HSurface)&  thePSurf, //parametric
2431                                         const Standard_Real                theArcTol,
2432                                         const Standard_Real                theTolTang,
2433                                         IntPatch_SequenceOfLine&           theLines)
2434 {
2435   if(theLine->ArcType() == IntPatch_Restriction)
2436   {
2437     const Handle(IntPatch_RLine)& aRL = Handle(IntPatch_RLine)::DownCast(theLine);
2438     if(!aRL.IsNull())
2439     {
2440       const Handle(Adaptor2d_HCurve2d)& anArc = aRL->IsArcOnS1() ?
2441                                         aRL->ArcOnS1() :
2442                                         aRL->ArcOnS2();
2443       if(anArc->Curve2d().GetType() != GeomAbs_Line)
2444       {
2445         //Restriction line must be isoline.
2446         //Other cases are not supported by
2447         //existing algorithms.
2448
2449         return Standard_False;
2450       }
2451     }
2452   }
2453   
2454   const Standard_Real aDeltaUmax = M_PI_2;
2455   const Standard_Real aTOL3D = 1.e-10, 
2456                       aTOL2D = Precision::PConfusion(),
2457                       aTOL2DS = Precision::PConfusion();
2458
2459   const Handle(IntSurf_LineOn2S)& aSLine = theLine->Curve();
2460
2461   if(aSLine->NbPoints() <= 2)
2462   {
2463     return Standard_False;
2464   }
2465   
2466   //Deletes repeated vertices
2467   Handle(IntSurf_LineOn2S) aVLine = GetVertices(theLine,aTOL3D,aTOL2D);
2468   
2469   Handle(IntSurf_LineOn2S) aSSLine(aSLine);
2470
2471   if(aSSLine->NbPoints() <= 1)
2472     return Standard_False;
2473
2474   AdjustLine(aSSLine,IsReversed,theQSurf,aTOL2D);
2475
2476   if(theLine->ArcType() == IntPatch_Walking)
2477   {
2478     Standard_Boolean isInserted = Standard_True;
2479     while(isInserted)
2480     {
2481       const Standard_Integer aNbPnts = aSSLine->NbPoints();
2482       TColStd_Array1OfInteger aPTypes(1,aNbPnts);
2483       SearchVertices(aSSLine,aVLine,aPTypes);
2484       isInserted = InsertSeamVertices(aSSLine,IsReversed,aVLine,aPTypes,aTOL2D);
2485     }
2486   }
2487
2488   const Standard_Integer aLindex = aSSLine->NbPoints();
2489   Standard_Integer aFindex = 1, aBindex = 0;
2490
2491   // build WLine parts (if any)
2492   Standard_Boolean flNextLine = Standard_True;
2493   Standard_Boolean hasBeenDecomposed = Standard_False;
2494   IntPatch_SpecPntType aPrePointExist = IntPatch_SPntNone;
2495
2496   IntSurf_PntOn2S PrePoint;
2497   while(flNextLine)
2498   {
2499     // reset variables
2500     flNextLine = Standard_False;
2501     Standard_Boolean isDecomposited = Standard_False;
2502     Standard_Real U1 = 0., U2 = 0., V1 = 0., V2 = 0.;
2503
2504     Handle(IntSurf_LineOn2S) sline = new IntSurf_LineOn2S();
2505
2506     //if((Lindex-Findex+1) <= 2 )
2507     if((aLindex <= aFindex) && !aPrePointExist)
2508     {
2509       //break of "while(flNextLine)" cycle
2510       break;
2511     }
2512
2513     if(aPrePointExist)
2514     {
2515       const IntSurf_PntOn2S& aRefPt = aSSLine->Value(aFindex);
2516
2517       const Standard_Real aURes = theQSurf->UResolution(theArcTol),
2518                           aVRes = theQSurf->VResolution(theArcTol);
2519
2520       const Standard_Real aTol2d = (aPrePointExist == IntPatch_SPntPole) ? -1.0 : 
2521               (aPrePointExist == IntPatch_SPntSeamV)? aVRes :
2522               (aPrePointExist == IntPatch_SPntSeamUV)? Max(aURes, aVRes) : aURes;
2523
2524       if(IntPatch_SpecialPoints::ContinueAfterSpecialPoint(theQSurf, thePSurf, aRefPt,
2525                                                               aPrePointExist, aTol2d,
2526                                                               PrePoint, IsReversed))
2527       {
2528         sline->Add(PrePoint);
2529       }
2530       else
2531       {
2532         //break of "while(flNextLine)" cycle
2533         break;
2534       }
2535     }
2536
2537     aPrePointExist = IntPatch_SPntNone;
2538
2539     // analyze other points
2540     for(Standard_Integer k = aFindex; k <= aLindex; k++)
2541     {
2542       if( k == aFindex )
2543       {
2544         PrePoint = aSSLine->Value(k);
2545         sline->Add(PrePoint);
2546         continue;
2547       }
2548
2549       if(IsReversed)
2550       {
2551         aSSLine->Value(k).ParametersOnS2(U1,V1);   // S2 - quadric, set U,V by Pnt3D
2552       }
2553       else
2554       {
2555         aSSLine->Value(k).ParametersOnS1(U1,V1);    // S1 - quadric, set U,V by Pnt3D
2556       }
2557
2558       aPrePointExist = IsSeamOrPole(theQSurf, aSSLine, IsReversed, k-1, aDeltaUmax);
2559
2560       if(aPrePointExist != IntPatch_SPntNone)
2561       {
2562         aBindex = k;
2563         isDecomposited = Standard_True;
2564         ////
2565         const IntSurf_PntOn2S& aRefPt = aSSLine->Value(aBindex-1);
2566
2567         Standard_Real aCompareTol3D = Precision::Confusion();
2568         Standard_Real aCompareTol2D = Precision::PConfusion();
2569
2570         IntSurf_PntOn2S aNewPoint = aRefPt;
2571         IntPatch_SpecPntType aLastType = IntPatch_SPntNone;
2572
2573         if(aPrePointExist == IntPatch_SPntSeamUV)
2574         {
2575           aPrePointExist = IntPatch_SPntNone;
2576           aLastType = IntPatch_SPntSeamUV;
2577           IntPatch_SpecialPoints::AddCrossUVIsoPoint(theQSurf, thePSurf, 
2578                                                         aRefPt, theTolTang,
2579                                                         aNewPoint, IsReversed);
2580         }
2581         else if(aPrePointExist == IntPatch_SPntSeamV)
2582         {//WLine goes through seam
2583           aPrePointExist = IntPatch_SPntNone;
2584           aLastType = IntPatch_SPntSeamV;
2585
2586           //Not quadric point
2587           Standard_Real aU0 = 0.0, aV0 = 0.0;
2588           //Quadric point
2589           Standard_Real aUQuadRef = 0.0, aVQuadRef = 0.0;
2590
2591           if(IsReversed)
2592           {
2593             aRefPt.Parameters(aU0, aV0, aUQuadRef, aVQuadRef);
2594           }
2595           else
2596           {
2597             aRefPt.Parameters(aUQuadRef, aVQuadRef, aU0, aV0);
2598           }
2599
2600           math_Vector aTol(1, 3), aStartPoint(1,3),
2601             anInfBound(1, 3), aSupBound(1, 3);
2602
2603           //Parameters on parametric surface
2604           Standard_Real aUp = 0.0, aVp = 0.0;
2605           if(IsReversed)
2606           {
2607             aSSLine->Value(k).ParametersOnS1(aUp, aVp);
2608           }
2609           else
2610           {
2611             aSSLine->Value(k).ParametersOnS2(aUp, aVp);
2612           }
2613
2614           aTol(1) = thePSurf->UResolution(theArcTol);
2615           aTol(2) = thePSurf->VResolution(theArcTol);
2616           aTol(3) = theQSurf->UResolution(theArcTol);
2617           aStartPoint(1) = 0.5*(aU0 + aUp);
2618           aStartPoint(2) = 0.5*(aV0 + aVp);
2619           aStartPoint(3) = 0.5*(aUQuadRef + U1);
2620           anInfBound(1) = thePSurf->FirstUParameter();
2621           anInfBound(2) = thePSurf->FirstVParameter();
2622           anInfBound(3) = theQSurf->FirstUParameter();
2623           aSupBound(1) = thePSurf->LastUParameter();
2624           aSupBound(2) = thePSurf->LastVParameter();
2625           aSupBound(3) = theQSurf->LastUParameter();
2626
2627           IntPatch_SpecialPoints::
2628                       AddPointOnUorVIso(theQSurf, thePSurf, aRefPt, Standard_False,
2629                                         aTol, aStartPoint, anInfBound, aSupBound,
2630                                         aNewPoint, IsReversed);
2631         }
2632         else if(aPrePointExist == IntPatch_SPntPoleSeamU)
2633         {
2634           aPrePointExist = IntPatch_SPntNone;          
2635
2636           IntPatch_Point aVert;
2637           aVert.SetValue(aRefPt);
2638
2639           if(IntPatch_SpecialPoints::
2640                       AddSingularPole(theQSurf, thePSurf, aRefPt, theTolTang,
2641                                       aVert, aNewPoint, IsReversed))
2642           {
2643             aPrePointExist = IntPatch_SPntPole;
2644             aLastType = IntPatch_SPntPole;
2645             aCompareTol2D = -1.0;
2646           } //if(IntPatch_AddSpecialPoints::AddSingularPole(...))
2647           else
2648           {//Pole is not an intersection point
2649             aPrePointExist = IntPatch_SPntSeamU;
2650           }
2651         }
2652
2653         if(aPrePointExist == IntPatch_SPntSeamU)
2654         {//WLine goes through seam
2655           aPrePointExist = IntPatch_SPntNone;
2656           aLastType = IntPatch_SPntSeamU;
2657
2658           //Not quadric point
2659           Standard_Real aU0 = 0.0, aV0 = 0.0;
2660           //Quadric point
2661           Standard_Real aUQuadRef = 0.0, aVQuadRef = 0.0;
2662
2663           if(IsReversed)
2664           {
2665             aRefPt.Parameters(aU0, aV0, aUQuadRef, aVQuadRef);
2666           }
2667           else
2668           {
2669             aRefPt.Parameters(aUQuadRef, aVQuadRef, aU0, aV0);
2670           }
2671
2672           math_Vector aTol(1, 3), aStartPoint(1,3),
2673                       anInfBound(1, 3), aSupBound(1, 3);
2674           
2675           //Parameters on parametric surface
2676           Standard_Real aUp = 0.0, aVp = 0.0;
2677           if(IsReversed)
2678           {
2679             aSSLine->Value(k).ParametersOnS1(aUp, aVp);
2680           }
2681           else
2682           {
2683             aSSLine->Value(k).ParametersOnS2(aUp, aVp);
2684           }
2685
2686           aTol(1) = thePSurf->UResolution(theArcTol);
2687           aTol(2) = thePSurf->VResolution(theArcTol);
2688           aTol(3) = theQSurf->VResolution(theArcTol);
2689           aStartPoint(1) = 0.5*(aU0 + aUp);
2690           aStartPoint(2) = 0.5*(aV0 + aVp);
2691           aStartPoint(3) = 0.5*(aVQuadRef + V1);
2692           anInfBound(1) = thePSurf->FirstUParameter();
2693           anInfBound(2) = thePSurf->FirstVParameter();
2694           anInfBound(3) = theQSurf->FirstVParameter();
2695           aSupBound(1) = thePSurf->LastUParameter();
2696           aSupBound(2) = thePSurf->LastVParameter();
2697           aSupBound(3) = theQSurf->LastVParameter();
2698
2699           IntPatch_SpecialPoints::
2700                 AddPointOnUorVIso(theQSurf, thePSurf, aRefPt, Standard_True, aTol,
2701                                   aStartPoint, anInfBound, aSupBound, aNewPoint,
2702                                   IsReversed);
2703         }
2704
2705         if(!aNewPoint.IsSame(aRefPt, aCompareTol3D, aCompareTol2D))
2706         {
2707           sline->Add(aNewPoint);
2708           aPrePointExist = aLastType;
2709           PrePoint = aNewPoint;
2710         }
2711         else
2712         {
2713           if(sline->NbPoints() == 1)
2714           {
2715             //FIRST point of the sline is the pole of the quadric.
2716             //Therefore, there is no point in decomposition.
2717
2718             PrePoint = aRefPt;
2719             aPrePointExist = aLastType;
2720           }
2721         }
2722
2723         ////
2724         break;
2725       } //if(Abs(U1-AnU1) > aDeltaUmax)
2726
2727       sline->Add(aSSLine->Value(k));
2728       PrePoint = aSSLine->Value(k);
2729     } //for(Standard_Integer k = aFindex; k <= aLindex; k++)
2730
2731     //Creation of new line as part of existing theLine.
2732     //This part is defined by sline.
2733
2734     if(sline->NbPoints() == 1)
2735     {
2736       flNextLine = Standard_True;
2737       aFindex = aBindex;
2738
2739       //Go to the next part of aSSLine
2740       //because we cannot create the line
2741       //with single point.
2742
2743       continue;
2744     }
2745
2746     IntSurf_PntOn2S aVF, aVL;
2747     Standard_Boolean addVF = Standard_False, addVL = Standard_False;
2748     VerifyVertices(sline,IsReversed,aVLine,aTOL2DS,theArcTol,
2749                                     thePDomain,aVF,addVF,aVL,addVL);
2750
2751     Standard_Boolean hasInternals = HasInternals(sline,aVLine);
2752
2753     Standard_Real D3F = 0., D3L = 0.;
2754     ToSmooth(sline,IsReversed,theQuad,Standard_True,D3F);
2755     ToSmooth(sline,IsReversed,theQuad,Standard_False,D3L);
2756
2757     //if(D3F <= 1.5e-7 && sline->NbPoints() >=3) {
2758     //  D3F = sline->Value(2).Value().Distance(sline->Value(3).Value());
2759     //}
2760     //if(D3L <= 1.5e-7 && sline->NbPoints() >=3) {
2761     //  D3L = sline->Value(sline->NbPoints()-1).Value().Distance(sline->
2762     //                                  Value(sline->NbPoints()-2).Value());
2763     //}
2764
2765     if(addVF || addVL)
2766     {
2767       Standard_Boolean isAdded = AddVertices(sline,aVF,addVF,aVL,addVL,D3F,D3L);
2768       if(isAdded)
2769       {
2770         ToSmooth(sline,IsReversed,theQuad,Standard_True,D3F);
2771         ToSmooth(sline,IsReversed,theQuad,Standard_False,D3L);
2772       }
2773     }
2774
2775     if(theLine->ArcType() == IntPatch_Walking)
2776     {
2777       IntPatch_Point aTPntF, aTPntL;
2778
2779       Handle(IntPatch_WLine) wline = 
2780                           new IntPatch_WLine(sline,Standard_False,
2781                           theLine->TransitionOnS1(),theLine->TransitionOnS2());
2782
2783       gp_Pnt aSPnt(sline->Value(1).Value());
2784       sline->Value(1).ParametersOnS1(U1,V1);
2785       sline->Value(1).ParametersOnS2(U2,V2);
2786       aTPntF.SetValue(aSPnt,theArcTol,Standard_False);
2787       aTPntF.SetParameters(U1,V1,U2,V2);
2788       aTPntF.SetParameter(1.);
2789       wline->AddVertex(aTPntF);
2790       wline->SetFirstPoint(1);
2791
2792       if(hasInternals)
2793       {
2794         PutIntVertices(wline,sline,IsReversed,aVLine,theArcTol);
2795       }
2796
2797       aSPnt =  sline->Value(sline->NbPoints()).Value();
2798       sline->Value(sline->NbPoints()).ParametersOnS1(U1,V1);
2799       sline->Value(sline->NbPoints()).ParametersOnS2(U2,V2);
2800       aTPntL.SetValue(aSPnt,theArcTol,Standard_False);
2801       aTPntL.SetParameters(U1,V1,U2,V2);
2802       aTPntL.SetParameter(sline->NbPoints());
2803       wline->AddVertex(aTPntL);
2804       wline->SetLastPoint(wline->NbVertex());
2805
2806       IntPatch_SequenceOfLine segm;
2807       Standard_Boolean isSplited = SplitOnSegments(wline,Standard_False,
2808                       theLine->TransitionOnS1(),theLine->TransitionOnS2(),theArcTol,segm);
2809
2810       if(!isSplited)
2811       {
2812         theLines.Append(wline);
2813       }
2814       else
2815       {
2816         Standard_Integer nbsegms = segm.Length();
2817         Standard_Integer iseg = 0;
2818         for(iseg = 1; iseg <= nbsegms; iseg++)
2819           theLines.Append(segm(iseg));
2820       }
2821     }
2822     else
2823     {//theLine->ArcType() == IntPatch_Restriction
2824       if(!isDecomposited && !hasBeenDecomposed)
2825       {
2826         //The line has not been changed
2827         theLines.Append(Handle(IntPatch_RLine)::DownCast(theLine));
2828         return hasBeenDecomposed;
2829       }
2830
2831       IntPatch_Point aTPnt;
2832       gp_Pnt2d aPSurf;
2833       gp_Pnt aSPnt;
2834
2835       Handle(IntPatch_RLine) aRLine = new IntPatch_RLine(*Handle(IntPatch_RLine)::DownCast(theLine));
2836       
2837       aRLine->ClearVertexes();
2838       aRLine->SetCurve(sline);
2839
2840       if(hasInternals)
2841       {
2842         PutIntVertices(aRLine,sline,IsReversed,aVLine,theArcTol);
2843       }
2844
2845       const Handle(Adaptor2d_HCurve2d)& anArc = aRLine->IsArcOnS1() ?
2846                                                 aRLine->ArcOnS1() :
2847                                                 aRLine->ArcOnS2();
2848
2849       Standard_Real aFPar = anArc->FirstParameter(),
2850                     aLPar = anArc->LastParameter();
2851
2852       const IntSurf_PntOn2S &aRFirst = sline->Value(1),
2853                             &aRLast = sline->Value(sline->NbPoints());
2854
2855       const gp_Lin2d aLin(anArc->Curve2d().Line());
2856       
2857       for(Standard_Integer aFLIndex = 0; aFLIndex < 2; aFLIndex++)
2858       {
2859         if(aFLIndex == 0)
2860         {
2861           aRFirst.Parameters(U1, V1, U2, V2);
2862           aSPnt.SetXYZ(aRFirst.Value().XYZ());
2863         }
2864         else
2865         {
2866           aRLast.Parameters(U1, V1, U2, V2);
2867           aSPnt.SetXYZ(aRLast.Value().XYZ());
2868         }
2869
2870         if(IsReversed)
2871         {
2872           aPSurf.SetCoord(U1, V1);
2873         }
2874         else
2875         {
2876           aPSurf.SetCoord(U2, V2);
2877         }
2878
2879         Standard_Real aPar = ElCLib::Parameter(aLin, aPSurf);
2880
2881         if(aFLIndex == 0)
2882         {
2883           aFPar = Max(aFPar, aPar);
2884           aPar = aFPar;
2885         }
2886         else
2887         {
2888           aLPar = Min(aLPar, aPar);
2889           aPar = aLPar;
2890         }
2891
2892         aTPnt.SetParameter(aPar);
2893         aTPnt.SetValue(aSPnt,theArcTol,Standard_False);
2894         aTPnt.SetParameters(U1, V1, U2, V2);
2895
2896         aRLine->AddVertex(aTPnt);
2897       }
2898
2899       if(aLPar - aFPar > Precision::PConfusion())
2900       {
2901         aRLine->SetFirstPoint(1);
2902         aRLine->SetLastPoint(aRLine->NbVertex());
2903
2904         anArc->Trim(aFPar, aLPar, theArcTol);
2905
2906         theLines.Append(aRLine);
2907       }
2908     }
2909
2910     if(isDecomposited)
2911     {
2912       aFindex = aBindex;
2913       flNextLine = hasBeenDecomposed = Standard_True;
2914     }
2915   }
2916
2917   return hasBeenDecomposed;
2918 }
2919
2920 //=======================================================================
2921 //function : CheckSegmSegm
2922 //purpose  : Returns TRUE if the segment [theParF, theParL] is included
2923 //            in the segment [theRefParF, theRefParL] segment.
2924 //=======================================================================
2925 static Standard_Boolean CheckSegmSegm(const Standard_Real theRefParF,
2926                                       const Standard_Real theRefParL,
2927                                       const Standard_Real theParF,
2928                                       const Standard_Real theParL)
2929 {
2930   if((theParF < theRefParF) || (theParF > theRefParL))
2931   {
2932     return Standard_False;
2933   }
2934
2935   if((theParL < theRefParF) || (theParL > theRefParL))
2936   {
2937     return Standard_False;
2938   }
2939
2940   return Standard_True;
2941 }
2942
2943 //=======================================================================
2944 //function : IsCoincide
2945 //purpose  : Check, if theLine is coincided with theArc (in 2d-space).
2946 //
2947 // Attention!!!
2948 //            Cases when theArc is not 2d-line adaptor are suppored by
2949 //          TopOpeBRep classes only (i.e. are archaic).
2950 //=======================================================================
2951 Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
2952                             const Handle(IntPatch_PointLine)& theLine,
2953                             const Handle(Adaptor2d_HCurve2d)& theArc,
2954                             const Standard_Boolean isTheSurface1Using, //Surf1 is parametric?
2955                             const Standard_Real theToler3D,
2956                             const Standard_Real theToler2D,
2957                             const Standard_Real thePeriod) // Period of parametric surface in direction which is perpendicular to theArc direction.
2958 {
2959   if(theLine->ArcType() == IntPatch_Restriction)
2960   {//Restriction-restriction processing
2961     const Handle(IntPatch_RLine)& aRL2 = Handle(IntPatch_RLine)::DownCast(theLine);
2962     const Handle(Adaptor2d_HCurve2d)& anArc = aRL2->IsArcOnS1() ? aRL2->ArcOnS1() : aRL2->ArcOnS2();
2963     
2964     if(anArc->Curve2d().GetType() != GeomAbs_Line)
2965     {
2966       //Restriction line must be isoline.
2967       //Other cases are not supported by
2968       //existing algorithms.
2969
2970       return Standard_False;
2971     }
2972
2973     const gp_Lin2d aLin1(theArc->Curve2d().Line()),
2974                    aLin2(anArc->Curve2d().Line());
2975
2976     if(!aLin1.Direction().IsParallel(aLin2.Direction(), Precision::Angular()))
2977     {
2978       return Standard_False;
2979     }
2980
2981     const Standard_Real aDist = 
2982             theArc->Curve2d().Line().Distance(anArc->Curve2d().Line());
2983     if((aDist < theToler2D) || (Abs(aDist - thePeriod) < theToler2D))
2984     {
2985       const Standard_Real aRf = theArc->FirstParameter(),
2986                           aRl = theArc->LastParameter();
2987       const Standard_Real aParf = anArc->FirstParameter(),
2988                           aParl = anArc->LastParameter();
2989       const gp_Pnt2d aP1(ElCLib::Value(aParf, aLin2)),
2990                      aP2(ElCLib::Value(aParl, aLin2));
2991
2992       Standard_Real aParam1 = ElCLib::Parameter(aLin1, aP1),
2993                     aParam2 = ElCLib::Parameter(aLin1, aP2);
2994
2995       if(CheckSegmSegm(aRf, aRl, aParam1, aParam2))
2996         return Standard_True;
2997
2998       //Lines are parallel. Therefore, there is no point in
2999       //projecting points to another line in order to check
3000       //if segment second line is included in segment of first one.
3001
3002       return CheckSegmSegm(aParam1, aParam2, aRf, aRl);
3003     }
3004
3005     return Standard_False;
3006   }
3007
3008   const Standard_Integer aNbPnts = theLine->NbPnts();
3009   const Standard_Real aUAf = theArc->FirstParameter(),
3010                       aUAl = theArc->LastParameter();
3011   const gp_Lin2d anArcLin(theArc->Curve2d().Line());
3012
3013   math_Vector aX(1, 2), aVal(1, 1);
3014
3015   for(Standard_Integer aPtID = 1; aPtID <= aNbPnts; aPtID++)
3016   {
3017     Standard_Real aUf = 0.0, aVf = 0.0;
3018     if(isTheSurface1Using)
3019       theLine->Point(aPtID).ParametersOnS1(aUf, aVf);
3020     else
3021       theLine->Point(aPtID).ParametersOnS2(aUf, aVf);
3022
3023     //Take 2d-point in parametric surface (because theArc is
3024     //2d-line in parametric surface).
3025     const gp_Pnt2d aPloc(aUf, aVf);
3026
3027     const Standard_Real aRParam = ElCLib::Parameter(anArcLin, aPloc);
3028
3029     if((aRParam < aUAf) || (aRParam > aUAl))
3030       return Standard_False;
3031
3032     const gp_Pnt2d aPmin(ElCLib::Value(aRParam, anArcLin));
3033     
3034     const Standard_Real aDist = aPloc.Distance(aPmin);
3035     if((aDist < theToler2D) || (Abs(aDist - thePeriod) < theToler2D))
3036     {//Considered point is in Restriction line.
3037      //Go to the next point.
3038       continue;
3039     }
3040
3041     //Check if intermediate points between aPloc and theArc are
3042     //intersection point (i.e. if aPloc is in tangent zone between
3043     //two intersected surfaces).
3044
3045     const Standard_Real aUl = aPmin.X(), aVl = aPmin.Y();
3046
3047     const Standard_Integer aNbPoints = 4;
3048     const Standard_Real aStepU = (aUl - aUf)/aNbPoints,
3049                         aStepV = (aVl - aVf)/aNbPoints;
3050
3051     Standard_Real aU = aUf+aStepU, aV = aVf+aStepV;
3052     for(Standard_Integer i = 1; i < aNbPoints; i++)
3053     {
3054       aX.Value(1) = aU;
3055       aX.Value(2) = aV;
3056
3057       if(!theFunc.Value(aX, aVal))
3058       {
3059         return Standard_False;
3060       }
3061
3062       if(Abs(aVal(1)) > theToler3D)
3063       {
3064         return Standard_False;
3065       }
3066       
3067       aU += aStepU;
3068       aV += aStepV;
3069     }
3070   }
3071
3072   return Standard_True;
3073 }