a88bbedb3e6b0644c4f866bcc1ff951742696972
[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       IntPatch_Point& VTX   = svtx.ChangeValue(i);      
555       for(j=1; j<=nbvtx && SortIsOK; j++) {
556         if(i!=j) { 
557           IntPatch_Point& VTXM1 = svtx.ChangeValue(j);
558           Standard_Boolean kill   = Standard_False;
559           Standard_Boolean killm1 = Standard_False;
560           if(Abs(VTXM1.ParameterOnLine()-VTX.ParameterOnLine())<PrecisionPConfusion) { 
561             if(VTXM1.IsOnDomS1() && VTX.IsOnDomS1()) {  //-- OnS1    OnS1
562               if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) {    //-- OnS1 == OnS1
563                 if(VTXM1.IsOnDomS2()) {                 //-- OnS1 == OnS1  OnS2  
564                   if(VTX.IsOnDomS2()==Standard_False) {   //-- OnS1 == OnS1  OnS2 PasOnS2
565                     kill=Standard_True;   
566                   }
567                   else {
568                     if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) { //-- OnS1 == OnS1  OnS2 == OnS2
569                       if(VTXM1.IsVertexOnS2()) {                      
570                         kill=Standard_True;
571                       }
572                       else { 
573                         killm1=Standard_True;
574                       }
575                     }
576                   }
577                 }
578                 else {                                  //-- OnS1 == OnS1  PasOnS2  
579                   if(VTX.IsOnDomS2()) {                 //-- OnS1 == OnS1  PasOnS2  OnS2
580                     killm1=Standard_True;
581                   }
582                 }
583               }
584             }
585             else { //-- Pas OnS1  et  OnS1
586               if(VTXM1.IsOnDomS2()==Standard_False && VTX.IsOnDomS2()==Standard_False) { 
587                 if(VTXM1.IsOnDomS1() && VTX.IsOnDomS1()==Standard_False) { 
588                   kill=Standard_True;
589                 }
590                 else  if(VTX.IsOnDomS1() && VTXM1.IsOnDomS1()==Standard_False) { 
591                   killm1=Standard_True;
592                 }
593               }
594             }
595             
596             if(!(kill || killm1)) {
597               if(VTXM1.IsOnDomS2() && VTX.IsOnDomS2()) {  //-- OnS2    OnS2
598                 if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) {    //-- OnS2 == OnS2
599                   if(VTXM1.IsOnDomS1()) {                 //-- OnS2 == OnS2  OnS1  
600                     if(VTX.IsOnDomS1()==Standard_False) {   //-- OnS2 == OnS2  OnS1 PasOnS1
601                       kill=Standard_True;   
602                     }
603                     else {
604                       if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) { //-- OnS2 == OnS2  OnS1 == OnS1
605                         if(VTXM1.IsVertexOnS1()) {                    
606                           kill=Standard_True;                //-- OnS2 == OnS2  OnS1 == OnS1  Vtx PasVtx
607                         }
608                         else { 
609                           killm1=Standard_True;              //-- OnS2 == OnS2  OnS1 == OnS1  PasVtx Vtx
610                         } 
611                       }
612                     }
613                   }
614                   else {                                  //-- OnS2 == OnS2  PasOnS1  
615                     if(VTX.IsOnDomS1()) {                 //-- OnS2 == OnS2  PasOnS1  OnS1
616                       killm1=Standard_True;
617                     }
618                   }
619                 }
620               }
621               else { //-- Pas OnS2  et  OnS2
622                 if(VTXM1.IsOnDomS1()==Standard_False && VTX.IsOnDomS1()==Standard_False) { 
623                   if(VTXM1.IsOnDomS2() && VTX.IsOnDomS2()==Standard_False) { 
624                     kill=Standard_True;
625                   }
626                   else  if(VTX.IsOnDomS2() && VTXM1.IsOnDomS2()==Standard_False) { 
627                     killm1=Standard_True;
628                   }
629                 }
630               }
631             }
632             //-- On a j < i 
633             if(kill) { 
634               SortIsOK = Standard_False;
635               if(lapt) { if(indl>i) indl--; else if(indl==i) indl=j; } 
636               if(fipt) { if(indf>i) indf--; else if(indf==i) indf=j; } 
637               svtx.Remove(i);
638               nbvtx--;
639             }
640             else if(killm1) { 
641               SortIsOK = Standard_False;
642               if(lapt) { if(indl>j) indl--;  else if(indl==j) indl=i-1;} 
643               if(fipt) { if(indf>j) indf--;  else if(indf==j) indf=i-1;} 
644               svtx.Remove(j);
645               nbvtx--; 
646             }
647 //          else
648             else if(ArcType()==IntPatch_Circle || ArcType()==IntPatch_Ellipse) { // eap
649               //-- deux points de meme parametre qui ne peuvent etre confondus
650               //-- On change les parametres d un des points si les points UV sont
651               //-- differents. Ceci distingue le cas des aretes de couture.
652               // ==========================================================
653               //-- 2 points with the same parameters
654               //-- Change parametres of one point if points UV are
655               //-- different. This is the case of seam edge
656               Standard_Real ponline = VTX.ParameterOnLine();
657               // eap, =>>
658               Standard_Real newParam = ponline;
659               const Standard_Real PiPi = M_PI+M_PI;
660               Standard_Boolean is2PI = ( Abs(ponline-PiPi) <= PrecisionPConfusion );
661
662               if (nbvtx > 2 && // do this check if seam edge only gives vertices 
663                   !is2PI)      // but always change 2PI -> 0
664                 continue;
665               
666               if (is2PI)
667                 newParam = 0;
668               else if (Abs(ponline) <= PrecisionPConfusion)
669                 newParam = PiPi;
670               else 
671                 newParam -= PiPi;
672 //            if(  (Abs(ponline)<=PrecisionPConfusion)
673 //                 ||(Abs(ponline-M_PI-M_PI) <=PrecisionPConfusion)) 
674               // eap, <<=
675                 Standard_Real u1a,v1a,u2a,v2a,u1b,v1b,u2b,v2b; 
676                 VTXM1.Parameters(u1a,v1a,u2a,v2a);
677                 VTX.Parameters(u1b,v1b,u2b,v2b);
678                 Standard_Integer flag  = 0;
679                 
680                 if(   (Abs(u1a-u1b)<=PrecisionPConfusion) ) flag|=1;
681                 if(   (Abs(v1a-v1b)<=PrecisionPConfusion) ) flag|=2;
682                 if(   (Abs(u2a-u2b)<=PrecisionPConfusion) ) flag|=4;
683                 if(   (Abs(v2a-v2b)<=PrecisionPConfusion) ) flag|=8;
684                 Standard_Boolean TestOn1 = Standard_False;
685                 Standard_Boolean TestOn2 = Standard_False;
686                 switch(flag) { 
687                 case 3:   //-- meme point U1 V1  
688                 case 7:  //-- meme point U1 V1   meme U2            
689                 case 12:  //--                    meme U2 V2
690                 case 13:  //-- meme point U1      meme U2 V2
691                 case 10:  //-- meme point    V1   meme    V2   Test si U1a=U1b Mod 2PI et Test si U2a=U2b Mod 2PI
692                   break;
693                 case 11:   //-- meme point U1 V1   meme    V2   Test si U2a=U2b Mod 2PI   
694                   { TestOn2 = Standard_True; break; } 
695                 case 14:  //-- meme point    V1   meme U2 V2   Test si U1a=U1b Mod 2PI
696                   { TestOn1 = Standard_True; break; } 
697                 default: break;
698                 };
699                 // eap
700                 //if(ArcType()==IntPatch_Circle || ArcType()==IntPatch_Ellipse) {}
701                   if(TestOn1) { 
702                     //// modified by jgv, 2.11.01 for BUC61033 ////
703                     Standard_Real U1A = (u1a < u1b)? u1a : u1b;
704                     Standard_Real U1B = (u1a < u1b)? u1b : u1a;
705                     if (u1min == RealLast())
706                       {
707                         u1min = U1A;
708                         u1max = U1B;
709                       }
710                     else
711                       {
712                         if (Abs(U1A-u1min) > PrecisionPConfusion)
713                           ToBreak = Standard_True;
714                         if (Abs(U1B-u1max) > PrecisionPConfusion)
715                           ToBreak = Standard_True;
716                       }
717                     ///////////////////////////////////////////////
718                     // eap, =>>
719 //                    if (Abs(ponline) <= PrecisionPConfusion) { 
720 //                    const Standard_Real PiPi = M_PI+M_PI;
721                       if(newParam >= ParamMinOnLine && newParam <= ParamMaxOnLine
722                          /*PiPi >= ParamMinOnLine && PiPi<=ParamMaxOnLine*/) { 
723                         SortAgain = Standard_True;
724                         SortIsOK = Standard_False;
725                         if (newParam > ponline)
726                           if(u1a < u1b) { VTX.SetParameter(newParam); } 
727                           else          { VTXM1.SetParameter(newParam); }
728                         else
729                           if(u1a > u1b) { VTX.SetParameter(newParam); } 
730                           else          { VTXM1.SetParameter(newParam); } 
731                       }
732 //                  }
733 //                  else { 
734 //                    if(0.0 >= ParamMinOnLine && 0.0<=ParamMaxOnLine) { 
735 //                      SortAgain = Standard_True;
736 //                      SortIsOK = Standard_False;
737 //                      if(u1a > u1b) { VTX.SetParameter(0.0); } 
738 //                      else          { VTXM1.SetParameter(0.0); } 
739 //                    }
740 //                  }
741                     // eap, <<=
742                   }
743                   if(TestOn2) { 
744                     //// modified by jgv, 2.11.01 for BUC61033 ////
745                     Standard_Real U2A = (u2a < u2b)? u2a : u2b;
746                     Standard_Real U2B = (u2a < u2b)? u2b : u2a;
747                     if (u2min == RealLast())
748                       {
749                         u2min = U2A;
750                         u2max = U2B;
751                       }
752                     else
753                       {
754                         if (Abs(U2A-u2min) > PrecisionPConfusion)
755                           ToBreak = Standard_True;
756                         if (Abs(U2B-u2max) > PrecisionPConfusion)
757                           ToBreak = Standard_True;
758                       }
759                     ///////////////////////////////////////////////
760                     // eap, =>>
761 //                  if (Abs(ponline) <= PrecisionPConfusion) { 
762 //                    const Standard_Real PiPi = M_PI+M_PI;
763                       if(newParam >= ParamMinOnLine && newParam <= ParamMaxOnLine
764                          /*PiPi >= ParamMinOnLine && PiPi<=ParamMaxOnLine*/) {
765                         SortAgain = Standard_True;
766                         SortIsOK = Standard_False;
767                         if (newParam > ponline)
768                           if(u2a < u2b) { VTX.SetParameter(newParam); } 
769                           else          { VTXM1.SetParameter(newParam); }
770                         else
771                           if(u2a > u2b) { VTX.SetParameter(newParam); } 
772                           else          { VTXM1.SetParameter(newParam); } 
773                       }
774 //                  }
775 //                  else { 
776 //                    if(0.0 >= ParamMinOnLine && 0.0<=ParamMaxOnLine) {
777 //                      SortAgain = Standard_True;
778 //                      SortIsOK = Standard_False;
779 //                      if(u2a > u2b) { VTX.SetParameter(0.0); } 
780 //                      else          { VTXM1.SetParameter(0.0); } 
781 //                    }
782 //                  }
783 //                }
784 //              }
785               // eap, <<=
786               }
787             }
788           }
789         }
790       } //-- if(i!=j)
791     }
792   }
793   while(!SortIsOK);
794
795   //-- Recalcul de fipt et lapt
796   //-- 
797   nbvtx=NbVertex();
798   if(nbvtx)
799   {
800     do { 
801       SortIsOK = Standard_True;
802       for(i=2; i<=nbvtx; i++)
803       {
804         if(svtx.Value(i-1).ParameterOnLine()  > svtx.Value(i).ParameterOnLine())
805         {
806           SortIsOK = Standard_False;
807           svtx.Exchange(i-1,i);
808         }
809       }
810     }
811     while(!SortIsOK);
812     indl=nbvtx;
813     indf=1;
814   }
815 }