0024005: Intersecting a slightly off angle plane with a cylinder takes 7+ seconds
[occt.git] / src / IntPatch / IntPatch_GLine.cxx
1 // Created on: 1992-04-06
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1992-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22 #include <IntPatch_GLine.ixx>
23
24 #define DEBUG 0
25
26 //  modified by Edward AGAPOV (eap) Wed Mar 6 2002 (bug occ212)
27 //  -- case: points with equal params == PI/2 
28
29 //-- Precision::PConfusion()*1000.0  -> 1e-6
30 //#define PrecisionPConfusion ( Precision::PConfusion()*1000.0 )
31
32 #include <gp_Pln.hxx>
33
34 //=======================================================================
35 //function : IntPatch_GLine
36 //purpose  : Creates a Line as intersection line
37 //           when the transitions are In or Out.
38 //=======================================================================
39
40 IntPatch_GLine::IntPatch_GLine (const gp_Lin& L,
41                                 const Standard_Boolean Tang,
42                                 const IntSurf_TypeTrans Trans1,
43                                                                 const IntSurf_TypeTrans Trans2) :
44   IntPatch_Line(Tang,Trans1,Trans2),
45   par1(0.0), par2(0.0),
46   fipt(Standard_False),lapt(Standard_False),
47   indf(0), indl(0)
48 {
49   typ = IntPatch_Lin;
50   pos = gp_Pln(L.Location(),L.Direction()).Position().Ax2();
51 }
52
53 //=======================================================================
54 //function : IntPatch_GLine
55 //purpose  : Creates a Line as intersection line
56 //           when the transitions are Touch.
57 //=======================================================================
58
59 IntPatch_GLine::IntPatch_GLine (const gp_Lin& L,
60                                 const Standard_Boolean Tang,
61                                 const IntSurf_Situation Situ1,
62                                 const IntSurf_Situation Situ2) :
63   IntPatch_Line(Tang,Situ1,Situ2),
64   par1(0.0), par2(0.0),
65   fipt(Standard_False),lapt(Standard_False),
66   indf(0), indl(0)
67 {
68   typ = IntPatch_Lin;
69   pos = gp_Pln(L.Location(),L.Direction()).Position().Ax2();
70 }
71
72 //=======================================================================
73 //function : IntPatch_GLine
74 //purpose  : Creates a Line as intersection line
75 //           when the transitions are Undecided.
76 //=======================================================================
77
78 IntPatch_GLine::IntPatch_GLine (const gp_Lin& L,
79                                 const Standard_Boolean Tang) :
80   IntPatch_Line(Tang),
81   par1(0.0), par2(0.0),
82   fipt(Standard_False),lapt(Standard_False),
83   indf(0), indl(0)
84 {
85   typ = IntPatch_Lin;
86   pos = gp_Pln(L.Location(),L.Direction()).Position().Ax2();
87 }
88
89 //=======================================================================
90 //function : IntPatch_GLine
91 //purpose  : Creates a circle as intersection line
92 //           when the transitions are In or Out.
93 //=======================================================================
94
95 IntPatch_GLine::IntPatch_GLine (const gp_Circ& C,
96                                 const Standard_Boolean Tang,
97                                 const IntSurf_TypeTrans Trans1,
98                                 const IntSurf_TypeTrans Trans2) :
99   IntPatch_Line(Tang,Trans1,Trans2),
100   pos(C.Position()),
101   par1(C.Radius()), par2(0.0),
102   fipt(Standard_False),lapt(Standard_False),
103   indf(0), indl(0)
104 {
105   typ = IntPatch_Circle;
106 }
107
108 //=======================================================================
109 //function : IntPatch_GLine
110 //purpose  : Creates a circle as intersection line
111 //           when the transitions are Touch.
112 //=======================================================================
113
114 IntPatch_GLine::IntPatch_GLine (const gp_Circ& C,
115                                 const Standard_Boolean Tang,
116                                 const IntSurf_Situation Situ1,
117                                 const IntSurf_Situation Situ2) :
118   IntPatch_Line(Tang,Situ1,Situ2),
119   pos(C.Position()),
120   par1(C.Radius()), par2(0.0),
121   fipt(Standard_False),lapt(Standard_False),
122   indf(0), indl(0)
123 {
124   typ = IntPatch_Circle;
125 }
126
127 //=======================================================================
128 //function : IntPatch_GLine
129 //purpose  : Creates a circle as intersection line
130 //           when the transitions are Undecided.
131 //=======================================================================
132
133 IntPatch_GLine::IntPatch_GLine (const gp_Circ& C,
134                                 const Standard_Boolean Tang) :
135   IntPatch_Line(Tang),
136   pos(C.Position()),
137   par1(C.Radius()), par2(0.0),
138   fipt(Standard_False),lapt(Standard_False),
139   indf(0), indl(0)
140 {
141   typ = IntPatch_Circle;
142 }
143
144 //=======================================================================
145 //function : IntPatch_GLine
146 //purpose  : Creates an ellipse as intersection line
147 //           when the transitions are In or Out.
148 //=======================================================================
149
150 IntPatch_GLine::IntPatch_GLine (const gp_Elips& E,
151                                 const Standard_Boolean Tang,
152                                 const IntSurf_TypeTrans Trans1,
153                                 const IntSurf_TypeTrans Trans2) :
154   IntPatch_Line(Tang,Trans1,Trans2),
155   pos(E.Position()),
156   par1(E.MajorRadius()),
157   par2(E.MinorRadius()),
158   fipt(Standard_False),lapt(Standard_False),
159   indf(0), indl(0)
160 {
161   typ = IntPatch_Ellipse;
162 }
163
164 //=======================================================================
165 //function : IntPatch_GLine
166 //purpose  : Creates an ellispe as intersection line
167 //           when the transitions are Touch.
168 //=======================================================================
169
170 IntPatch_GLine::IntPatch_GLine (const gp_Elips& E,
171                                 const Standard_Boolean Tang,
172                                 const IntSurf_Situation Situ1,
173                                 const IntSurf_Situation Situ2) :
174   IntPatch_Line(Tang,Situ1,Situ2),
175   pos(E.Position()),
176   par1(E.MajorRadius()),
177   par2(E.MinorRadius()),
178   fipt(Standard_False),lapt(Standard_False),
179   indf(0), indl(0)
180 {
181   typ = IntPatch_Ellipse;
182 }
183
184 //=======================================================================
185 //function : IntPatch_GLine
186 //purpose  : Creates an ellipse as intersection line
187 //           when the transitions are Undecided.
188 //=======================================================================
189
190 IntPatch_GLine::IntPatch_GLine (const gp_Elips& E,
191                                 const Standard_Boolean Tang) :
192   IntPatch_Line(Tang),
193   pos(E.Position()),
194   par1(E.MajorRadius()),
195   par2(E.MinorRadius()),
196   fipt(Standard_False),lapt(Standard_False),
197   indf(0), indl(0)
198 {
199   typ = IntPatch_Ellipse;
200 }
201
202 //=======================================================================
203 //function : IntPatch_GLine
204 //purpose  : Creates a parabola as intersection line
205 //           when the transitions are In or Out.
206 //=======================================================================
207
208 IntPatch_GLine::IntPatch_GLine (const gp_Parab& P,
209                                 const Standard_Boolean Tang,
210                                 const IntSurf_TypeTrans Trans1,
211                                 const IntSurf_TypeTrans Trans2) :
212   IntPatch_Line(Tang,Trans1,Trans2),
213   pos(P.Position()),
214   par1(P.Focal()), par2(0.0),
215   fipt(Standard_False),lapt(Standard_False),
216   indf(0), indl(0)
217 {
218   typ = IntPatch_Parabola;
219 }
220
221 //=======================================================================
222 //function : IntPatch_GLine
223 //purpose  : Creates a parabola as intersection line
224 //           when the transitions are Touch.
225 //=======================================================================
226
227 IntPatch_GLine::IntPatch_GLine (const gp_Parab& P,
228                                 const Standard_Boolean Tang,
229                                 const IntSurf_Situation Situ1,
230                                 const IntSurf_Situation Situ2) :
231   IntPatch_Line(Tang,Situ1,Situ2),
232   pos(P.Position()),
233   par1(P.Focal()), par2(0.0),
234   fipt(Standard_False),lapt(Standard_False),
235   indf(0), indl(0)
236 {
237   typ = IntPatch_Parabola;
238 }
239
240 //=======================================================================
241 //function : IntPatch_GLine
242 //purpose  : Creates a parabola as intersection line 
243 //           when the transitions are Undecided.
244 //=======================================================================
245
246 IntPatch_GLine::IntPatch_GLine (const gp_Parab& P,
247                                 const Standard_Boolean Tang) :
248   IntPatch_Line(Tang),
249   pos(P.Position()),
250   par1(P.Focal()), par2(0.0),
251   fipt(Standard_False),lapt(Standard_False),
252   indf(0), indl(0)
253 {
254   typ = IntPatch_Parabola;
255 }
256
257 //=======================================================================
258 //function : IntPatch_GLine
259 //purpose  : Creates an hyperbola as intersection line
260 //           when the transitions are In or Out.
261 //=======================================================================
262
263 IntPatch_GLine::IntPatch_GLine (const gp_Hypr& H,
264                                 const Standard_Boolean Tang,
265                                 const IntSurf_TypeTrans Trans1,
266                                 const IntSurf_TypeTrans Trans2) :
267   IntPatch_Line(Tang,Trans1,Trans2),
268   pos(H.Position()),
269   par1(H.MajorRadius()),
270   par2(H.MinorRadius()),
271   fipt(Standard_False),lapt(Standard_False),
272   indf(0), indl(0)
273 {
274   typ = IntPatch_Hyperbola;
275 }
276
277 //=======================================================================
278 //function : IntPatch_GLine
279 //purpose  : Creates an hyperbola as intersection line
280 //           when the transitions are Touch.
281 //=======================================================================
282
283 IntPatch_GLine::IntPatch_GLine (const gp_Hypr& H,
284                                 const Standard_Boolean Tang,
285                                 const IntSurf_Situation Situ1,
286                                 const IntSurf_Situation Situ2) :
287   IntPatch_Line(Tang,Situ1,Situ2),
288   pos(H.Position()),
289   par1(H.MajorRadius()),
290   par2(H.MinorRadius()),
291   fipt(Standard_False),lapt(Standard_False),
292   indf(0), indl(0)
293 {
294   typ = IntPatch_Hyperbola;
295 }
296
297 //=======================================================================
298 //function : IntPatch_GLine
299 //purpose  : Creates an hyperbola as  intersection line
300 //           when the transitions are Undecided.
301 //=======================================================================
302
303 IntPatch_GLine::IntPatch_GLine (const gp_Hypr& H,
304                                 const Standard_Boolean Tang) :
305   IntPatch_Line(Tang),
306   pos(H.Position()),
307   par1(H.MajorRadius()),
308   par2(H.MinorRadius()),
309   fipt(Standard_False),lapt(Standard_False),
310   indf(0), indl(0)
311 {
312   typ = IntPatch_Hyperbola;
313 }
314
315 //=======================================================================
316 //function : Replace
317 //purpose  : To replace the element of range Index in the list
318 //           of points.
319 //=======================================================================
320
321 void IntPatch_GLine::Replace (const Standard_Integer /*Index*/,
322                               const IntPatch_Point& Pnt)
323 {
324   svtx.Append(Pnt);
325   //--   svtx(Index) = Pnt;
326 }
327
328 //=======================================================================
329 //function : AddVertex
330 //purpose  : To add a vertex in the list.
331 //=======================================================================
332
333 void IntPatch_GLine::AddVertex (const IntPatch_Point& Pnt)
334 {
335   //-- On detecte le cas de 2 points 3d identiques 
336   //-- pour les ramener au meme parametre sur la 
337   //-- GLine 
338   if (NbVertex())
339   {
340     const Standard_Real pf = (fipt? svtx.Value(indf).ParameterOnLine() : 0.0);
341     const Standard_Real pl = (lapt? svtx.Value(indl).ParameterOnLine() : 0.0);
342     Standard_Real par = Pnt.ParameterOnLine();
343     if(ArcType()==IntPatch_Circle || ArcType()==IntPatch_Ellipse)
344     {
345       if(fipt && lapt) {
346         while(par<pf) par+=M_PI+M_PI;
347         while(par>pl) par-=M_PI+M_PI;
348         if(par<pf) { 
349           const Standard_Real PrecisionPConfusion ( Precision::PConfusion()*1000.0 );
350           if((pf-par)>PrecisionPConfusion) {
351             return;
352           }
353         }
354         IntPatch_Point ParModif = Pnt;
355         ParModif.SetParameter(par);
356         svtx.Append(ParModif);
357         return; 
358       }
359     }
360     else
361     {
362       if(fipt && lapt) { 
363         if(pl<par || par<pf) 
364           return;
365       }
366     }
367   }
368   svtx.Append(Pnt);
369 }
370
371 //=======================================================================
372 //function : ComputeVertexParameters
373 //purpose  : Set the parameters of all the vertex on the line.
374 //           if a vertex is already in the line, 
375 //           its parameter is modified
376 //           else a new point in the line is inserted.
377 //=======================================================================
378
379 void IntPatch_GLine::ComputeVertexParameters(const Standard_Real /*Tol*/)
380
381   Standard_Boolean   SortIsOK,APointDeleted;
382   Standard_Boolean   SortAgain = Standard_True;
383   Standard_Integer   i,j;
384   const Standard_Real ParamMinOnLine = (fipt? Vertex(indf).ParameterOnLine() : -100000.0);
385   const Standard_Real ParamMaxOnLine = (lapt? Vertex(indl).ParameterOnLine() :  100000.0);
386
387   //----------------------------------------------------------
388   //--     F i l t r e   s u r   r e s t r i c t i o n s   --
389   //----------------------------------------------------------
390   //-- deux vertex sur la meme restriction et seulement 
391   //-- sur celle ci ne doivent pas avoir le meme parametre
392   //==========================================================
393   //-- 2 vertices on the same restriction and only
394   //-- on that one must not have the same parametres
395   
396   Standard_Integer nbvtx = NbVertex();
397
398   const Standard_Real PrecisionPConfusion ( Precision::PConfusion()*1000.0 );
399
400   do { 
401     APointDeleted = Standard_False;
402     for(i=1; (i<=nbvtx) && (!APointDeleted); i++)
403     { 
404       const IntPatch_Point& VTXi   = svtx.Value(i);
405       if(VTXi.IsOnDomS1() || VTXi.IsOnDomS2())
406       {
407         for(j=1; (j<=nbvtx) && (!APointDeleted); j++)
408         {
409           if(i!=j)
410           {
411             const IntPatch_Point& VTXj   = svtx.Value(j);
412             if((!VTXj.IsOnDomS1()) && (!VTXj.IsOnDomS2()))
413             {
414               if(Abs(VTXi.ParameterOnLine()-VTXj.ParameterOnLine())<=PrecisionPConfusion)
415               {
416                 svtx.Remove(j);
417                 nbvtx--;
418                 if(lapt) { if(indl>j) indl--; } 
419                 if(fipt) { if(indf>j) indf--; } 
420                 APointDeleted = Standard_True;
421               }
422             }
423           }
424         }
425       }
426     }
427   }
428   while(APointDeleted && nbvtx > 2);
429
430   do { 
431     APointDeleted = Standard_False;
432     for(i=1; (i<=nbvtx) && (!APointDeleted); i++)
433     {
434       const IntPatch_Point& VTXi   = svtx.Value(i);
435       if(VTXi.IsOnDomS1() && (!VTXi.IsOnDomS2()))
436       {
437         for(j=1; (j<=nbvtx) && (!APointDeleted); j++)
438         {
439           if(i!=j)
440           {
441             const IntPatch_Point& VTXj   = svtx.Value(j);
442             if(VTXj.IsOnDomS1() && (!VTXj.IsOnDomS2()))
443             {
444               if(Abs(VTXi.ParameterOnArc1()-VTXj.ParameterOnArc1())<=PrecisionPConfusion)
445               {
446                 if(VTXi.ArcOnS1() == VTXj.ArcOnS1())
447                 {
448                   if(VTXi.IsVertexOnS1())
449                   {
450                     svtx.Remove(j);
451                     nbvtx--;
452                     if(lapt) { if(indl>j) indl--; } 
453                     if(fipt) { if(indf>j) indf--; } 
454                   }
455                   else
456                   {
457                     svtx.Remove(i);
458                     nbvtx--;
459                     if(lapt) { if(indl>i) indl--; } 
460                     if(fipt) { if(indf>i) indf--; } 
461                   }
462                   APointDeleted = Standard_True;
463                 }
464               }
465             }
466           }
467         }
468       }
469     }
470   }
471   while(APointDeleted);
472
473   do { 
474     APointDeleted = Standard_False;
475     for(i=1; (i<=nbvtx) && (!APointDeleted); i++)
476     {
477       const IntPatch_Point& VTXi   = svtx.Value(i);
478       if(VTXi.IsOnDomS2() && (!VTXi.IsOnDomS1()))
479       {
480         for(j=1; (j<=nbvtx) && (!APointDeleted); j++)
481         {
482           if(i!=j)
483           {
484             const IntPatch_Point& VTXj   = svtx.Value(j);
485             if(VTXj.IsOnDomS2() && (!VTXj.IsOnDomS1()))
486             {
487               if(Abs(VTXi.ParameterOnArc2()-VTXj.ParameterOnArc2())<=PrecisionPConfusion)
488               {
489                 if(VTXi.ArcOnS2() == VTXj.ArcOnS2())
490                 {
491                   if(VTXi.IsVertexOnS1())
492                   {
493                     svtx.Remove(j);
494                     nbvtx--;
495                     if(lapt) { if(indl>j) indl--; } 
496                     if(fipt) { if(indf>j) indf--; } 
497                   }
498                   else
499                   {
500                     svtx.Remove(i);
501                     nbvtx--;
502                     if(lapt) { if(indl>i) indl--; } 
503                     if(fipt) { if(indf>i) indf--; }                 
504                   }
505                   APointDeleted = Standard_True;                  
506                 }
507               }
508             }
509           }
510         }
511       }
512     }
513   }
514   while(APointDeleted);
515         
516
517   //----------------------------------------------------------
518   //-- Tri des vertex et suppression des Vtx superflus
519   //-- 
520   //// modified by jgv, 2.11.01 for BUC61033 ////
521   Standard_Real u1min = RealLast(), u1max = RealFirst();
522   Standard_Real u2min = RealLast(), u2max = RealFirst();
523   Standard_Boolean ToBreak = Standard_False;
524   ///////////////////////////////////////////////
525   do { 
526     nbvtx     = NbVertex();
527     if(SortAgain)
528     { 
529       do
530       {
531         SortIsOK = Standard_True;
532         for(i=2; i<=nbvtx; i++)
533         {
534           if(svtx.Value(i-1).ParameterOnLine() > svtx.Value(i).ParameterOnLine())
535           {
536             SortIsOK = Standard_False;
537             svtx.Exchange(i-1,i);
538             if(fipt) { if(indf==i) indf=i-1; else if(indf==i-1) indf=i; }
539             if(lapt) { if(indl==i) indl=i-1; else if(indl==i-1) indl=i; }
540           }
541         }
542       }
543       while(!SortIsOK);
544     }
545
546     //// modified by jgv, 2.11.01 for BUC61033 ////
547     if (ToBreak)
548       break;
549     ///////////////////////////////////////////////
550
551     SortAgain = Standard_False;
552     SortIsOK = Standard_True; 
553     for(i=2; i<=nbvtx && SortIsOK; i++)
554     { 
555       IntPatch_Point& VTX   = svtx.ChangeValue(i);      
556       for(j=1; j<=nbvtx && SortIsOK; j++)
557       {
558         if(i!=j)
559         {
560           IntPatch_Point& VTXM1 = svtx.ChangeValue(j);
561           Standard_Boolean kill   = Standard_False;
562           Standard_Boolean killm1 = Standard_False;
563           if(Abs(VTXM1.ParameterOnLine()-VTX.ParameterOnLine())<PrecisionPConfusion)
564           {
565             if(VTXM1.IsOnDomS1() && VTX.IsOnDomS1()) //-- OnS1    OnS1
566             {
567               if(VTXM1.ArcOnS1() == VTX.ArcOnS1())//-- OnS1 == OnS1
568               {
569                 if(VTXM1.IsOnDomS2())             //-- OnS1 == OnS1  OnS2  
570                 {
571                   if(VTX.IsOnDomS2()==Standard_False)//-- OnS1 == OnS1  OnS2 PasOnS2
572                   {
573                     kill=Standard_True;
574                   }
575                   else
576                   {
577                     if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) //-- OnS1 == OnS1  OnS2 == OnS2
578                     {
579                       if(VTXM1.IsVertexOnS2())
580                       {
581                         kill=Standard_True;
582                       }
583                       else
584                       {
585                         killm1=Standard_True;
586                       }
587                     }
588                   }
589                 }
590                 else                    //-- OnS1 == OnS1  PasOnS2  
591                 {
592                   if(VTX.IsOnDomS2())   //-- OnS1 == OnS1  PasOnS2  OnS2
593                   {
594                     killm1=Standard_True;
595                   }
596                 }
597               }
598             }
599             else                        //-- Pas OnS1  et  OnS1
600             {
601               if(VTXM1.IsOnDomS2()==Standard_False && VTX.IsOnDomS2()==Standard_False)
602               {
603                 if(VTXM1.IsOnDomS1() && VTX.IsOnDomS1()==Standard_False)
604                 {
605                   kill=Standard_True;
606                 }
607                 else if(VTX.IsOnDomS1() && VTXM1.IsOnDomS1()==Standard_False)
608                 {
609                   killm1=Standard_True;
610                 }
611               }
612             }
613
614             if(!(kill || killm1))
615             {
616               if(VTXM1.IsOnDomS2() && VTX.IsOnDomS2())  //-- OnS2    OnS2
617               {
618                 if(VTXM1.ArcOnS2() == VTX.ArcOnS2())    //-- OnS2 == OnS2
619                 {
620                   if(VTXM1.IsOnDomS1())                 //-- OnS2 == OnS2  OnS1 
621                   {
622                     if(VTX.IsOnDomS1()==Standard_False) //-- OnS2 == OnS2  OnS1 PasOnS1
623                     {
624                       kill=Standard_True;
625                     }
626                     else
627                     {
628                       if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) //-- OnS2 == OnS2  OnS1 == OnS1
629                       {
630                         if(VTXM1.IsVertexOnS1())
631                         {
632                           kill=Standard_True;              //-- OnS2 == OnS2  OnS1 == OnS1  Vtx PasVtx
633                         }
634                         else
635                         {
636                           killm1=Standard_True;            //-- OnS2 == OnS2  OnS1 == OnS1  PasVtx Vtx
637                         }
638                       }
639                     }
640                   }
641                   else
642                   {                           //-- OnS2 == OnS2  PasOnS1
643                     if(VTX.IsOnDomS1())       //-- OnS2 == OnS2  PasOnS1  OnS1
644                     {
645                       killm1=Standard_True;
646                     }
647                   }
648                 }
649               }
650               else //-- Pas OnS2  et  OnS2
651               {
652                 if(VTXM1.IsOnDomS1()==Standard_False && VTX.IsOnDomS1()==Standard_False)
653                 {
654                   if(VTXM1.IsOnDomS2() && VTX.IsOnDomS2()==Standard_False)
655                   {
656                     kill=Standard_True;
657                   }
658                   else if(VTX.IsOnDomS2() && VTXM1.IsOnDomS2()==Standard_False)
659                   {
660                     killm1=Standard_True;
661                   }
662                 }
663               }
664             }
665
666             //-- On a j < i
667             if(kill)
668             {
669               SortIsOK = Standard_False;
670               if(lapt)
671               {
672                 if(indl>i)
673                   indl--;
674                 else if(indl==i)
675                   indl=j;
676               }
677
678               if(fipt)
679               {
680                 if(indf>i)
681                   indf--;
682                 else if(indf==i)
683                   indf=j;
684               }
685
686               svtx.Remove(i);
687               nbvtx--;
688             }
689             else if(killm1)
690             {
691               SortIsOK = Standard_False;
692               if(lapt)
693               {
694                 if(indl>j)
695                   indl--;
696                 else if(indl==j)
697                   indl=i-1;
698               } 
699
700               if(fipt)
701               {
702                 if(indf>j)
703                   indf--;
704                 else if(indf==j)
705                   indf=i-1;
706               }
707
708               svtx.Remove(j);
709               nbvtx--;
710             }//     else
711             else if(ArcType()==IntPatch_Circle || ArcType()==IntPatch_Ellipse) // eap
712             {
713               //-- deux points de meme parametre qui ne peuvent etre confondus
714               //-- On change les parametres d un des points si les points UV sont
715               //-- differents. Ceci distingue le cas des aretes de couture.
716               // ==========================================================
717               //-- 2 points with the same parameters
718               //-- Change parametres of one point if points UV are
719               //-- different. This is the case of seam edge
720
721               Standard_Real ponline = VTX.ParameterOnLine();
722               // eap, =>>
723               Standard_Real newParam = ponline;
724               const Standard_Real PiPi = M_PI+M_PI;
725               Standard_Boolean is2PI = ( Abs(ponline-PiPi) <= PrecisionPConfusion );
726
727               if (nbvtx > 2 && // do this check if seam edge only gives vertices 
728                   !is2PI)      // but always change 2PI -> 0
729                         continue;
730
731               if (is2PI)
732                 newParam = 0;
733               else if (Abs(ponline) <= PrecisionPConfusion)
734                 newParam = PiPi;
735               else
736                 newParam -= PiPi;
737
738               //              if(  (Abs(ponline)<=PrecisionPConfusion)
739               //                   ||(Abs(ponline-M_PI-M_PI) <=PrecisionPConfusion))
740               // eap, <<=
741
742               Standard_Real u1a,v1a,u2a,v2a,u1b,v1b,u2b,v2b;
743               VTXM1.Parameters(u1a,v1a,u2a,v2a);
744               VTX.Parameters(u1b,v1b,u2b,v2b);
745               Standard_Integer flag  = 0;
746
747               if(   (Abs(u1a-u1b)<=PrecisionPConfusion) )
748                 flag|=1;
749
750               if(   (Abs(v1a-v1b)<=PrecisionPConfusion) )
751                 flag|=2;
752               if(   (Abs(u2a-u2b)<=PrecisionPConfusion) )
753                 flag|=4;
754
755               if(   (Abs(v2a-v2b)<=PrecisionPConfusion) )
756                 flag|=8;
757
758               Standard_Boolean TestOn1 = Standard_False;
759               Standard_Boolean TestOn2 = Standard_False;
760
761               switch(flag)
762               { 
763               case 3:   //-- meme point U1 V1  
764               case 7:  //-- meme point U1 V1   meme U2
765               case 12:  //--                    meme U2 V2
766               case 13:  //-- meme point U1      meme U2 V2
767               case 10:  //-- meme point    V1   meme    V2   Test si U1a=U1b Mod 2PI et Test si U2a=U2b Mod 2PI
768                 break;
769               case 11:   //-- meme point U1 V1   meme    V2   Test si U2a=U2b Mod 2PI
770                 {
771                   TestOn2 = Standard_True;
772                   break;
773                 }
774
775               case 14:  //-- meme point    V1   meme U2 V2   Test si U1a=U1b Mod 2PI
776                 {
777                   TestOn1 = Standard_True;
778                   break;
779                 }
780               default:
781                 break;
782               };
783
784               // eap
785               //if(ArcType()==IntPatch_Circle || ArcType()==IntPatch_Ellipse) {}
786               if(TestOn1)
787               {
788                 //// modified by jgv, 2.11.01 for BUC61033 ////
789                 Standard_Real U1A = (u1a < u1b)? u1a : u1b;
790                 Standard_Real U1B = (u1a < u1b)? u1b : u1a;
791                 
792                 if (u1min == RealLast())
793                 {
794                   u1min = U1A;
795                   u1max = U1B;
796                 }
797                 else
798                 {
799                   if (Abs(U1A-u1min) > PrecisionPConfusion)
800                     ToBreak = Standard_True;
801                   if (Abs(U1B-u1max) > PrecisionPConfusion)
802                     ToBreak = Standard_True;
803                 }
804                     ///////////////////////////////////////////////
805                     // eap, =>>
806 //                    if (Abs(ponline) <= PrecisionPConfusion) { 
807 //                    const Standard_Real PiPi = M_PI+M_PI;
808                 if(newParam >= ParamMinOnLine && newParam <= ParamMaxOnLine
809                   /*PiPi >= ParamMinOnLine && PiPi<=ParamMaxOnLine*/)
810                 {
811                   SortAgain = Standard_True;
812                   SortIsOK = Standard_False;
813                   if (newParam > ponline)
814                   {
815                     if(u1a < u1b)
816                     {
817                       VTX.SetParameter(newParam);
818                     } 
819                     else
820                     {
821                       VTXM1.SetParameter(newParam);
822                     }
823                   }
824                   else
825                   {
826                     if(u1a > u1b)
827                     {
828                       VTX.SetParameter(newParam);
829                     }
830                     else
831                     {
832                       VTXM1.SetParameter(newParam);
833                     } 
834                   }
835                 }
836 //                  }
837 //                  else { 
838 //                    if(0.0 >= ParamMinOnLine && 0.0<=ParamMaxOnLine) { 
839 //                      SortAgain = Standard_True;
840 //                      SortIsOK = Standard_False;
841 //                      if(u1a > u1b) { VTX.SetParameter(0.0); } 
842 //                      else          { VTXM1.SetParameter(0.0); } 
843 //                    }
844 //                  }
845                     // eap, <<=
846               }
847
848               if(TestOn2)
849               {
850                 //// modified by jgv, 2.11.01 for BUC61033 ////
851                 Standard_Real U2A = (u2a < u2b)? u2a : u2b;
852                 Standard_Real U2B = (u2a < u2b)? u2b : u2a;
853                 if (u2min == RealLast())
854                 {
855                   u2min = U2A;
856                   u2max = U2B;
857                 }
858                 else
859                 {
860                   if (Abs(U2A-u2min) > PrecisionPConfusion)
861                     ToBreak = Standard_True;
862                   
863                   if (Abs(U2B-u2max) > PrecisionPConfusion)
864                     ToBreak = Standard_True;
865
866                 }
867                     ///////////////////////////////////////////////
868                     // eap, =>>
869 //                  if (Abs(ponline) <= PrecisionPConfusion) { 
870 //                    const Standard_Real PiPi = M_PI+M_PI;
871                 if(newParam >= ParamMinOnLine && newParam <= ParamMaxOnLine
872                   /*PiPi >= ParamMinOnLine && PiPi<=ParamMaxOnLine*/)
873                 {
874                   SortAgain = Standard_True;
875                   SortIsOK = Standard_False;
876                   if (newParam > ponline)
877                   {
878                     if(u2a < u2b)
879                     {
880                       VTX.SetParameter(newParam);
881                     }
882                     else
883                     {
884                       VTXM1.SetParameter(newParam);
885                     }
886                   }
887                   else
888                   {
889                     if(u2a > u2b)
890                     {
891                       VTX.SetParameter(newParam);
892                     }
893                     else
894                     {
895                       VTXM1.SetParameter(newParam);
896                     }
897                   }
898                 }
899 //                  }
900 //                  else { 
901 //                    if(0.0 >= ParamMinOnLine && 0.0<=ParamMaxOnLine) {
902 //                      SortAgain = Standard_True;
903 //                      SortIsOK = Standard_False;
904 //                      if(u2a > u2b) { VTX.SetParameter(0.0); } 
905 //                      else          { VTXM1.SetParameter(0.0); } 
906 //                    }
907 //                  }
908 //                }
909 //              }
910               // eap, <<=
911               }
912             }
913           }
914         }
915       } //-- if(i!=j)
916     }
917   }
918   while(!SortIsOK);
919
920   //-- Recalcul de fipt et lapt
921   //-- 
922   nbvtx=NbVertex();
923   if(nbvtx)
924   {
925     do { 
926       SortIsOK = Standard_True;
927       for(i=2; i<=nbvtx; i++)
928       {
929         if(svtx.Value(i-1).ParameterOnLine()  > svtx.Value(i).ParameterOnLine())
930         {
931           SortIsOK = Standard_False;
932           svtx.Exchange(i-1,i);
933         }
934       }
935     }
936     while(!SortIsOK);
937
938     indl=nbvtx;
939     indf=1;
940   }
941 }