14cdfbb12007028f70ce048698e85a431cac8df5
[occt.git] / src / IntPatch / IntPatch_WLine.cxx
1 // Created on: 1991-05-27
2 // Created by: Isabelle GRIGNON
3 // Copyright (c) 1991-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
9 // under the terms of the GNU Lesser General Public 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_WLine.ixx>
18
19 #define DEBUG 0
20 #define DEBUGV 0
21
22 #include <IntSurf_PntOn2S.hxx>
23 #include <Precision.hxx>
24 #include <stdio.h>
25
26
27 IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line,
28                                 const Standard_Boolean Tang,
29                                 const IntSurf_TypeTrans Trans1,
30                                 const IntSurf_TypeTrans Trans2) :
31   IntPatch_Line(Tang,Trans1,Trans2),fipt(Standard_False),lapt(Standard_False),
32   hasArcOnS1(Standard_False),hasArcOnS2(Standard_False)
33 {
34   typ = IntPatch_Walking;
35   curv = Line;
36   Buv1.SetWhole();
37   Buv2.SetWhole();
38   Bxyz.SetWhole();
39   u1period=v1period=u2period=v2period=0.0;
40 }
41
42
43 IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line,
44                                 const Standard_Boolean Tang,
45                                 const IntSurf_Situation Situ1,
46                                 const IntSurf_Situation Situ2) :
47   IntPatch_Line(Tang,Situ1,Situ2),fipt(Standard_False),lapt(Standard_False),
48   hasArcOnS1(Standard_False),hasArcOnS2(Standard_False)
49 {
50   typ = IntPatch_Walking;
51   curv = Line;
52   Buv1.SetWhole();
53   Buv2.SetWhole();
54   Bxyz.SetWhole();
55   u1period=v1period=u2period=v2period=0.0;
56 }
57
58
59 IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line,
60                                 const Standard_Boolean Tang) :
61   IntPatch_Line(Tang),fipt(Standard_False),lapt(Standard_False),
62   hasArcOnS1(Standard_False),hasArcOnS2(Standard_False)
63 {
64   typ = IntPatch_Walking;
65   curv = Line;
66   Buv1.SetWhole();
67   Buv2.SetWhole();
68   Bxyz.SetWhole();
69   u1period=v1period=u2period=v2period=0.0;
70 }
71
72
73 void IntPatch_WLine::SetPoint(const Standard_Integer Index,
74                               const IntPatch_Point& thepoint)
75 {
76   curv->Value(Index,thepoint.PntOn2S());
77 }
78
79
80 Handle(IntSurf_LineOn2S) IntPatch_WLine::Curve() const
81
82   return(curv);
83 }
84
85 static void RecadreMemePeriode(Standard_Real& u1,Standard_Real& v1,
86                                Standard_Real& u2,Standard_Real& v2,
87                                const Standard_Real anu1,const Standard_Real anv1,
88                                const Standard_Real anu2,const Standard_Real anv2,
89                                const Standard_Real U1Period,const Standard_Real V1Period,
90                                const Standard_Real U2Period,const Standard_Real V2Period) { 
91   if(U1Period) { 
92     while(anu1-u1 > 0.8*U1Period) { u1+=U1Period; }
93     while(u1-anu1 > 0.8*U1Period) { u1-=U1Period; }
94   }
95   if(U2Period) { 
96     while(anu2-u2 > 0.8*U2Period) { u2+=U2Period; }
97     while(u2-anu2 > 0.8*U2Period) { u2-=U2Period; }
98   }
99   if(V1Period) { 
100     while(anv1-v1 > 0.8*V1Period) { v1+=V1Period; }
101     while(v1-anv1 > 0.8*V1Period) { v1-=V1Period; }
102   }
103   if(V2Period) { 
104     while(anv2-v2 > 0.8*V2Period) { v2+=V2Period; }
105     while(v2-anv2 > 0.8*V2Period) { v2-=V2Period; }
106   }
107
108 }
109
110 static void RecadreMemePeriode(IntSurf_PntOn2S& POn2S,const IntSurf_PntOn2S& RefPOn2S,
111                                const Standard_Real up1,
112                                const Standard_Real vp1,
113                                const Standard_Real up2,
114                                const Standard_Real vp2) { 
115   Standard_Real u1,v1,u2,v2,pu1,pv1,pu2,pv2;
116   POn2S.Parameters(u1,v1,u2,v2);
117   RefPOn2S.Parameters(pu1,pv1,pu2,pv2);
118   RecadreMemePeriode(u1,v1,u2,v2,pu1,pv1,pu2,pv2,up1,vp1,up2,vp2);
119   POn2S.SetValue(u1,v1,u2,v2);
120 }
121
122 static Standard_Boolean CompareVertexAndPoint(const gp_Pnt& V,const gp_Pnt& P,const Standard_Real& Tol) { 
123   return(V.Distance(P)<=Tol);
124 }
125
126 void IntPatch_WLine::SetPeriod(const Standard_Real pu1,
127                                const Standard_Real pv1,
128                                const Standard_Real pu2,
129                                const Standard_Real pv2) { 
130   u1period=pu1; v1period=pv1; u2period=pu2; v2period=pv2;
131 }
132 Standard_Real IntPatch_WLine::U1Period() const {    return(u1period); }
133 Standard_Real IntPatch_WLine::V1Period() const {    return(v1period); }
134 Standard_Real IntPatch_WLine::U2Period() const {    return(u2period); }
135 Standard_Real IntPatch_WLine::V2Period() const {    return(v2period); }
136
137
138 //------------------------------------------------------------------------
139 //--  En Entree : Une ligne de cheminement     +    Une Liste de Vetex
140 //--
141 //--   LineOn2S   :       1------2-------3-------4-----5---- ----nbp
142 //-- 
143 //--   Vertex     :   a     b c          d    e      f
144 //--
145 //--
146 //--  En Sortie 
147 //--
148 //--                  1--2-3-4--5--------6----7--8--9--10--------
149 //--
150 //--  avec   a de parametre 1 
151 //--         b              3
152 //--
153 //--   etc ...
154 //--
155 //--
156 //-- !!!!!!!!!!!!!!! On considere que deux vertex ne peuvent pas etre 
157 //-- !!!!!!!!!!!!!!!  a une distance inferieure a Tol
158 //------------------------------------------------------------------------
159 //--
160 //-- On Teste si la LineOn2S contient des points confondus. 
161 //-- Dans ce cas, on remove ces points.
162 //--
163 //------------------------------------------------------------------------
164
165 Standard_Boolean SameVtxRst(const IntPatch_Point& vtx1,const IntPatch_Point& vtx2) { 
166   if(vtx1.IsOnDomS1()) { 
167     if(vtx2.IsOnDomS1()) { 
168       if(vtx1.ArcOnS1() == vtx2.ArcOnS1()) { 
169         if(vtx1.ParameterOnArc1() == vtx2.ParameterOnArc1()) { 
170           
171         }
172         else { 
173           return(Standard_False);
174         }
175       }
176       else { 
177         return(Standard_False); 
178       }
179     }
180     else { 
181       return(Standard_False);
182     }
183   }
184   else { 
185     if(vtx2.IsOnDomS1()) { 
186       return(Standard_False);
187     }
188   }
189   if(vtx1.IsOnDomS2()) { 
190     if(vtx2.IsOnDomS2()) { 
191       if(vtx1.ArcOnS2() == vtx2.ArcOnS2()) { 
192         if(vtx1.ParameterOnArc2() == vtx2.ParameterOnArc2()) { 
193           
194         }
195         else { 
196           return(Standard_False);
197         }
198       }
199       else { 
200         return(Standard_False); 
201       }
202     }
203     else { 
204       return(Standard_False);
205     }
206   }
207   else {
208     if(vtx2.IsOnDomS2()) {
209       return(Standard_False);
210     }
211   }
212   return(Standard_True);
213 }
214
215
216 static Standard_Boolean CompareVerticesOnSurf(const IntPatch_Point& vtx1,
217                                               const IntPatch_Point& vtx2,
218                                               const Standard_Boolean onFirst)
219 {
220   Standard_Real u1,v1,u2,v2, tolU, tolV;
221   if (onFirst) {
222     vtx1.ParametersOnS1(u1,v1);
223     vtx2.ParametersOnS1(u2,v2);
224   }
225   else {
226     vtx1.ParametersOnS2(u1,v1);
227     vtx2.ParametersOnS2(u2,v2);
228   }
229   tolU = Precision::PConfusion();
230   tolV = Precision::PConfusion();
231   return (Abs(u1-u2) <= tolU && Abs(v1-v2) <= tolV);
232 }
233
234 inline Standard_Boolean CompareVerticesOnS1(const IntPatch_Point& vtx1, const IntPatch_Point& vtx2)
235 {return CompareVerticesOnSurf (vtx1, vtx2, Standard_True);}
236
237 inline Standard_Boolean CompareVerticesOnS2(const IntPatch_Point& vtx1, const IntPatch_Point& vtx2)
238 {return CompareVerticesOnSurf (vtx1, vtx2, Standard_False);}
239
240
241 void IntPatch_WLine::ComputeVertexParameters(const Standard_Real RTol) { 
242
243   // MSV Oct 15, 2001: use tolerance of vertex instead of RTol where 
244   //                   it is possible
245
246   Standard_Integer i,j,k,nbvtx,nbponline;
247   Standard_Integer indicevertexonline;
248   Standard_Real    indicevertex;
249
250   Standard_Boolean APointDeleted = Standard_False;
251   //----------------------------------------------------------
252   //--     F i l t r e   s u r   r e s t r i c t i o n s   --
253   //----------------------------------------------------------
254   //-- deux vertex sur la meme restriction et seulement 
255   //-- sur celle ci ne doivent pas avoir le meme parametre
256   //--
257   Standard_Real Tol=RTol;
258   nbvtx = NbVertex();
259
260 #if DEBUGV  
261   cout<<"\n----------- avant ComputeVertexParameters -------------"<<endl;
262   for(i=1;i<=nbvtx;i++) { 
263     Vertex(i).Dump();
264     Standard_Real  polr = Vertex(i).ParameterOnLine();
265     Standard_Real pol = (Standard_Integer)polr;
266     if(pol>=1 && pol<=nbvtx) { 
267       cout<<"----> IntSurf_PntOn2S : "<<polr<<"  Pnt ("<<Vertex(pol).Value().X()
268         <<","<<Vertex(pol).Value().Y()
269           <<","<<Vertex(pol).Value().Z()<<")"<<endl;
270     }
271   }
272   cout<<"\n----------------------------------------------------------"<<endl;
273 #endif  
274
275   
276   //-- ----------------------------------------------------------------------
277   //-- Traitement des aretes de couture : On duplique les points situes
278   //-- sur des restrictions differentes
279   //-- 
280   //-- Phase Creation de nouveaux points sur S1 
281   Standard_Boolean encoreunefois;
282   do { 
283     nbvtx=NbVertex();
284     encoreunefois=Standard_False;
285     for(i=1; i<=nbvtx && encoreunefois==Standard_False; i++) { 
286       IntPatch_Point& VTXi   = svtx.ChangeValue(i);
287       for(j=1; j<=nbvtx && encoreunefois==Standard_False; j++) { 
288         if(i!=j) { 
289           IntPatch_Point& VTXj   = svtx.ChangeValue(j);
290           if(VTXi.ParameterOnLine() != VTXj.ParameterOnLine()) { 
291             Standard_Real d = VTXi.Value().Distance(VTXj.Value());
292             Standard_Real toli = VTXi.Tolerance();
293             Standard_Real tolj = VTXj.Tolerance();
294             Standard_Real maxtol = Max(toli,tolj);
295             // MSV Oct 30, 2001: compare in 2D space also;
296             //                   increase tolerances
297             if (d < maxtol ||
298                CompareVerticesOnS1(VTXi,VTXj) || CompareVerticesOnS2(VTXi,VTXj)) { 
299               //-- Creation Vtx (REF:S1(i)  S2(j))    (On Garde S1(i))
300               Standard_Real newtoli = Max (toli, tolj+d*1.01);
301               Standard_Real newtolj = Max (tolj, toli+d*1.01);
302               Standard_Boolean acreer=Standard_False;
303               if(VTXi.IsOnDomS1()) { 
304                 if(VTXj.IsOnDomS1()) { 
305                   if(VTXj.ArcOnS1() != VTXi.ArcOnS1()) { 
306                     acreer=Standard_True;
307                   }
308                 }
309                 else { 
310                   acreer=Standard_True;
311                 }
312               }
313               if(acreer) { 
314                 IntPatch_Point vtx;
315                 vtx = VTXj;
316                 vtx.SetArc(Standard_True,
317                            VTXi.ArcOnS1(),
318                            VTXi.ParameterOnArc1(),
319                            VTXi.TransitionLineArc1(),
320                            VTXi.TransitionOnS1());
321                 for(k=1; encoreunefois==Standard_False && k<=nbvtx; k++) { 
322                   const IntPatch_Point& VTXk   = svtx.Value(k);
323                   if(SameVtxRst(VTXk,vtx)) { 
324                     encoreunefois=Standard_True;
325                   }
326                 }
327                 if(encoreunefois==Standard_False) {
328                   VTXi.SetTolerance(newtoli);
329                   VTXj.SetTolerance(newtolj);
330                   vtx.SetTolerance(newtolj);
331                   svtx.Append(vtx);
332                   encoreunefois=Standard_True;
333                 }
334                 else { 
335                   encoreunefois=Standard_False;
336                 }
337               }
338               //-- -----------------------------------------------------
339               //-- Creation Vtx (REF:S2(i)  S1(j))    (On Garde S2(i))
340               acreer=Standard_False;
341               if(VTXi.IsOnDomS2()) { 
342                 if(VTXj.IsOnDomS2()) { 
343                   if(VTXj.ArcOnS2() != VTXi.ArcOnS2()) { 
344                     acreer=Standard_True;
345                   }
346                 }
347                 else { 
348                   acreer=Standard_True;
349                 }
350               }
351               if(acreer) { 
352                 IntPatch_Point vtx;
353                 vtx = VTXj;
354                 vtx.SetArc(Standard_False,
355                            VTXi.ArcOnS2(),
356                            VTXi.ParameterOnArc2(),
357                            VTXi.TransitionLineArc2(),
358                            VTXi.TransitionOnS2());
359                 for(k=1; encoreunefois==Standard_False && k<=nbvtx; k++) { 
360                   const IntPatch_Point& VTXk   = svtx.Value(k);
361                   if(SameVtxRst(VTXk,vtx)) { 
362                     encoreunefois=Standard_True;
363                   }
364                 }
365                 if(encoreunefois==Standard_False) {
366                   VTXi.SetTolerance(newtoli);
367                   VTXj.SetTolerance(newtolj);
368                   vtx.SetTolerance(newtolj);
369                   svtx.Append(vtx);
370                   encoreunefois=Standard_True;
371                 }
372                 else { 
373                   encoreunefois=Standard_False;
374                 }
375               }     
376             }
377           }
378         }
379       }
380     }
381   }
382   while(encoreunefois);
383   
384   
385
386   //-- ----------------------------------------------------------------------
387
388
389
390   do { 
391     APointDeleted = Standard_False;
392     for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { 
393       const IntPatch_Point& VTXi   = svtx.Value(i);
394       if(VTXi.Tolerance() > Tol)        Tol = VTXi.Tolerance(); //-- 9 oct 97 
395       if((VTXi.IsOnDomS1()==Standard_True) && (VTXi.IsOnDomS2()==Standard_False)) { 
396         for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) {
397           if(i!=j) { 
398             const IntPatch_Point& VTXj   = svtx.Value(j);
399             if((VTXj.IsOnDomS1()==Standard_True) && (VTXj.IsOnDomS2()==Standard_False)) {
400               if(VTXi.ParameterOnLine() == VTXj.ParameterOnLine()) { 
401                 if(VTXi.ArcOnS1() == VTXj.ArcOnS1()) { 
402                   svtx.Remove(j);
403                   nbvtx--;
404                   if(lapt) { if(indl>=j) indl--; } 
405                   if(fipt) { if(indf>=j) indf--; } 
406                   APointDeleted = Standard_True;
407                 }
408               }
409             }
410           }
411         }
412       }
413     }
414   }
415   while(APointDeleted == Standard_True);
416
417
418   do { 
419     APointDeleted = Standard_False;
420     for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { 
421       const IntPatch_Point& VTXi   = svtx.Value(i);
422       if((VTXi.IsOnDomS2()==Standard_True) && (VTXi.IsOnDomS1()==Standard_False)) { 
423         for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) {
424           if(i!=j) { 
425             const IntPatch_Point& VTXj   = svtx.Value(j);
426             if((VTXj.IsOnDomS2()==Standard_True) && (VTXj.IsOnDomS1()==Standard_False)) {
427               if(VTXi.ParameterOnLine() == VTXj.ParameterOnLine()) { 
428                 if(VTXi.ArcOnS2() == VTXj.ArcOnS2()) { 
429                   svtx.Remove(j);
430                   nbvtx--;
431                   if(lapt) { if(indl>=j) indl--; } 
432                   if(fipt) { if(indf>=j) indf--; } 
433                   APointDeleted = Standard_True;
434                 }
435               }
436             }
437           }
438         }
439       }
440     }
441   }
442   while(APointDeleted == Standard_True);
443         
444   nbvtx     = NbVertex();
445   nbponline = NbPnts();
446
447   //----------------------------------------------------
448   //-- On trie les Vertex 
449   Standard_Boolean SortIsOK;
450   do { 
451     SortIsOK = Standard_True;
452     for(i=2; i<=nbvtx; i++) { 
453       if(svtx.Value(i-1).ParameterOnLine()  > svtx.Value(i).ParameterOnLine()) { 
454         SortIsOK = Standard_False;
455         svtx.Exchange(i-1,i);
456       }
457     }
458   }
459   while(!SortIsOK);
460   
461   //----------------------------------------------------
462   //-- On detecte les points confondus dans la LineOn2S
463   Standard_Real dmini = Precision::Confusion();
464   dmini*=dmini;
465   for(i=2; i<=nbponline; i++) { 
466     //const IntSurf_PntOn2S& aPntOn2S1=curv->Value(i-1);
467     //const IntSurf_PntOn2S& aPntOn2S2=curv->Value(i);
468     Standard_Real d = (curv->Value(i-1).Value()).SquareDistance((curv->Value(i).Value()));
469     if(d < dmini) { 
470       curv->RemovePoint(i);
471       nbponline--;
472       //----------------------------------------------
473       //-- On recadre les Vertex si besoin 
474       //-- 
475       for(j=1; j<=nbvtx; j++) { 
476         indicevertex = svtx.Value(j).ParameterOnLine();
477         if(indicevertex >= i) {
478           svtx.ChangeValue(j).SetParameter(indicevertex-1.0);
479         }
480       }
481       //modified by NIZNHY-PKV Mon Feb 11 09:28:02 2002 f
482       i--;
483       //modified by NIZNHY-PKV Mon Feb 11 09:28:04 2002 t
484     }
485   }
486   //----------------------------------------------------
487   for(i=1; i<=nbvtx; i++) {
488     const gp_Pnt& P    = svtx.Value(i).Value();
489     Standard_Real vTol = svtx.Value(i).Tolerance();
490     indicevertex = svtx.Value(i).ParameterOnLine();
491     indicevertexonline = (Standard_Integer)indicevertex;
492     //--------------------------------------------------
493     //-- On Compare le vertex avec les points de la ligne
494     //-- d indice   indicevertexOnLine-1
495     //--            indicevertexOnLine
496     //--            indicevertexOnLine+1
497     //--------------------------------------------------
498     if(indicevertexonline<1) { 
499       if(CompareVertexAndPoint(P,curv->Value(1).Value(),vTol)) {
500         //-------------------------------------------------------
501         //-- On remplace le point cheminement(1) par vertex(i)
502         //-- et   vertex(i) prend pour parametre 1
503         //-------------------------------------------------------
504         
505         IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S();
506         RecadreMemePeriode(POn2S,curv->Value(1),U1Period(),V1Period(),U2Period(),V2Period());
507         curv->Value(1,POn2S);
508
509         //--curv->Value(1,svtx.Value(i).PntOn2S());
510         svtx.ChangeValue(i).SetParameter(1.0);
511       }
512       else { 
513         //-------------------------------------------------------
514         //-- On insere le point de cheminement Vertex(i)
515         //-- On recadre les parametres des autres vertex
516         //-------------------------------------------------------
517         IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S();
518         RecadreMemePeriode(POn2S,curv->Value(1),U1Period(),V1Period(),U2Period(),V2Period());
519         curv->InsertBefore(1,POn2S);
520
521         //-- curv->InsertBefore(1,svtx.Value(i).PntOn2S());
522         svtx.ChangeValue(i).SetParameter(1.0);
523         nbponline++;
524         for(j=1;j<=nbvtx;j++) {
525           if(j!=1) { 
526             Standard_Real t = svtx.Value(j).ParameterOnLine();
527             if(t>1.0) { 
528               svtx.ChangeValue(j).SetParameter(t+1.0);
529             }
530           }
531         }
532       }
533     } //--- fin : if(indicevertexonline<1) 
534     else { 
535       //---------------------------------------------------------
536       //-- vertex(i)   ==   cheminement (indicevertexonline-1)
537       //-- vertex(i)   ==   cheminement (indicevertexonline)
538       //-- vertex(i)   ==   cheminement (indicevertexonline+1)
539       //---------------------------------------------------------
540       Standard_Boolean Substitution = Standard_False;
541       //-- for(k=indicevertexonline+1; !Substitution && k>=indicevertexonline-1;k--) {   avant le 9 oct 97 
542       for(k=indicevertexonline+1; k>=indicevertexonline-1;k--) { 
543         if(k>0 && k<=nbponline) { 
544           if(CompareVertexAndPoint(P,curv->Value(k).Value(),vTol)) {
545             //-------------------------------------------------------
546             //-- On remplace le point cheminement(k) 
547             //-- par vertex(i)  et vertex(i) prend pour parametre k
548             //-------------------------------------------------------
549             IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S();
550             RecadreMemePeriode(POn2S,curv->Value(k),U1Period(),V1Period(),U2Period(),V2Period());
551             curv->Value(k,POn2S);
552             Standard_Real mu1,mv1,mu2,mv2;
553             POn2S.Parameters(mu1,mv1,mu2,mv2);
554             svtx.ChangeValue(i).SetParameter(k);
555             svtx.ChangeValue(i).SetParameters(mu1,mv1,mu2,mv2);
556             Substitution = Standard_True;
557           }
558         }
559       }
560
561       //Remove duplicating points
562       if (Substitution)
563       {
564         Standard_Integer ind_point;
565         for(ind_point = 2; (ind_point <= nbponline && nbponline > 2); ind_point++) { 
566           Standard_Real d = (curv->Value(ind_point-1).Value()).SquareDistance((curv->Value(ind_point).Value()));
567           if(d < dmini) { 
568             curv->RemovePoint(ind_point);
569             nbponline--;
570             //----------------------------------------------
571             //-- On recadre les Vertex si besoin 
572             //-- 
573             for(j=1; j<=nbvtx; j++) { 
574               indicevertex = svtx.Value(j).ParameterOnLine();
575               if(indicevertex >= ind_point) {
576                 svtx.ChangeValue(j).SetParameter(indicevertex-1.0);
577               }
578             }
579             //modified by NIZNHY-PKV Mon Feb 11 09:28:02 2002 f
580             ind_point--;
581             //modified by NIZNHY-PKV Mon Feb 11 09:28:04 2002 t
582           }
583         }
584       }
585       
586       //--static int deb6nov98=1;    Ne resout rien (a part partiellement BUC60409)
587       //--if(deb6nov98) { 
588       //--Substitution=Standard_True;
589       //-- }
590       
591       if(Substitution==Standard_False) { 
592         //-------------------------------------------------------
593         //-- On insere le point de cheminement Vertex(i)
594         //-- On recadre les parametres des autres vertex
595         //-------------------------------------------------------
596         IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S();
597         if(indicevertexonline >= nbponline) { 
598           RecadreMemePeriode(POn2S,curv->Value(nbponline),U1Period(),V1Period(),U2Period(),V2Period());
599           curv->Add(POn2S);
600         }
601         else { 
602           RecadreMemePeriode(POn2S,curv->Value(indicevertexonline+1),U1Period(),V1Period(),U2Period(),V2Period());
603           curv->InsertBefore(indicevertexonline+1,POn2S);
604         }
605         //-- curv->InsertBefore(indicevertexonline+1,svtx.Value(i).PntOn2S());
606         svtx.ChangeValue(i).SetParameter(indicevertexonline+1);
607         nbponline++;
608         for(j=1;j<=nbvtx;j++) { 
609           if(j!=i) { 
610             Standard_Real t = svtx.Value(j).ParameterOnLine();
611             if(t>(Standard_Real)indicevertexonline) { 
612               svtx.ChangeValue(j).SetParameter(t+1.0);
613             }
614           }
615         }
616       } //-- Substitution
617     } //-- indicevertexonline>=1
618
619   } //-- boucle i sur vertex
620
621   
622   
623   
624   do {  
625     APointDeleted = Standard_False;
626     for(i=1; i<=nbvtx && (APointDeleted == Standard_False); i++) { 
627       const IntPatch_Point& VTX   = svtx.Value(i);      
628       for(j=1; j<=nbvtx && (APointDeleted == Standard_False) ; j++) { 
629         if(i!=j) { 
630           const IntPatch_Point& VTXM1 = svtx.Value(j);
631           
632           Standard_Boolean kill   = Standard_False;
633           Standard_Boolean killm1 = Standard_False;
634           if(VTXM1.ParameterOnLine() == VTX.ParameterOnLine()) { 
635             if(VTXM1.IsOnDomS1() && VTX.IsOnDomS1()) {  //-- OnS1    OnS1
636               if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) {    //-- OnS1 == OnS1
637                 if(VTXM1.IsOnDomS2()) {                 //-- OnS1 == OnS1  OnS2  
638                   if(VTX.IsOnDomS2()==Standard_False) {   //-- OnS1 == OnS1  OnS2 PasOnS2
639                     kill=Standard_True;   
640                   }
641                   else {
642                     if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) { //-- OnS1 == OnS1  OnS2 == OnS2
643                       kill=Standard_True;
644                     }
645                   }
646                 }
647                 else {                                  //-- OnS1 == OnS1  PasOnS2  
648                   if(VTX.IsOnDomS2()) {                 //-- OnS1 == OnS1  PasOnS2  OnS2
649                     killm1=Standard_True;
650                   }
651                 }
652               }
653             }
654             
655             if(!(kill || killm1)) {
656               if(VTXM1.IsOnDomS2() && VTX.IsOnDomS2()) {  //-- OnS2    OnS2
657                 if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) {    //-- OnS2 == OnS2
658                   if(VTXM1.IsOnDomS1()) {                 //-- OnS2 == OnS2  OnS1  
659                     if(VTX.IsOnDomS1()==Standard_False) {   //-- OnS2 == OnS2  OnS1 PasOnS1
660                       kill=Standard_True;   
661                     }
662                     else {
663                       if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) { //-- OnS2 == OnS2  OnS1 == OnS1
664                         kill=Standard_True;
665                       }
666                     }
667                   }
668                   else {                                  //-- OnS2 == OnS2  PasOnS1  
669                     if(VTX.IsOnDomS1()) {                 //-- OnS2 == OnS2  PasOnS1  OnS1
670                       killm1=Standard_True;
671                     }
672                   }
673                 }
674               }
675             }
676             if(kill) { 
677               APointDeleted = Standard_True;
678               svtx.Remove(i);
679               nbvtx--;
680             }
681             else if(killm1) { 
682               APointDeleted = Standard_True;
683               svtx.Remove(j);
684               nbvtx--; 
685             }
686           }
687         }
688       }
689     }
690   }
691   while(APointDeleted == Standard_True);
692   
693   do {  
694     SortIsOK = Standard_True;
695     for(i=2; i<=nbvtx && SortIsOK; i++) {
696       const IntPatch_Point& Pim1=svtx.Value(i-1);
697       const IntPatch_Point& Pii  =svtx.Value(i);
698       if(Pim1.ParameterOnLine()==Pii.ParameterOnLine()) { 
699         if(   (Pii.IsOnDomS1() == Standard_False)
700            && (Pii.IsOnDomS2() == Standard_False)) { 
701           SortIsOK = Standard_False;
702           svtx.Remove(i);
703           nbvtx--;
704         }
705         else {
706           if(   (Pim1.IsOnDomS1() == Standard_False)
707              && (Pim1.IsOnDomS2() == Standard_False)) { 
708             SortIsOK = Standard_False;
709             svtx.Remove(i-1);
710             nbvtx--;
711           }       
712         }
713       }
714     }
715   }
716   while(!SortIsOK);
717   //-- ----------------------------------------------------------------------------
718   //-- On ajoute les vertex de debut et de fin de ligne s il ne sont pas presents.
719   //-- 
720   //-- Existe t il un vertex de debut de ligne, de fin .
721   //--
722   //-- Si Besoin : il faudra dedoubler les points de debut et de fin sur les periodiques ??????
723
724
725
726   
727   Standard_Boolean bFirst = Standard_False;
728   Standard_Boolean bLast  = Standard_False;
729   nbponline = NbPnts();
730   for(i=1;i<=nbvtx;i++) { 
731     Standard_Real pol = svtx.Value(i).ParameterOnLine();
732     if(pol==1.0)       {
733       bFirst = fipt = Standard_True;
734       indf   = i;
735     }
736     if(pol==nbponline) {
737       bLast = lapt = Standard_True;
738       indl  = i;
739     }
740   }
741   if(bFirst == Standard_False) { 
742     Standard_Real pu1,pv1,pu2,pv2;
743     Standard_Boolean vtxfound = Standard_False;
744     IntPatch_Point vtx;
745     curv->Value(1).Parameters(pu1,pv1,pu2,pv2);
746     for(i=1;
747         (vtxfound==Standard_False) && (i<=nbvtx);i++) { 
748       const IntPatch_Point&  V = svtx.Value(i);
749       Standard_Real vTol = V.Tolerance();
750       if(CompareVertexAndPoint(V.Value(),curv->Value(1).Value(),vTol)) { 
751         vtx = V;
752         vtx.SetParameters(pu1,pv1,pu2,pv2);
753         vtxfound = Standard_True;
754       }
755     }
756     if(vtxfound == Standard_False)  { 
757       vtx.SetValue(curv->Value(1).Value(),Tol,Standard_False);
758       vtx.SetParameters(pu1,pv1,pu2,pv2);
759     }
760     vtx.SetParameter(1);
761     svtx.Prepend(vtx);    nbvtx++;
762     fipt = Standard_True;
763     indf = 1;
764   }
765   if(bLast == Standard_False) { 
766     Standard_Real pu1,pv1,pu2,pv2;
767     Standard_Boolean vtxfound = Standard_False;    
768     IntPatch_Point vtx;
769     curv->Value(nbponline).Parameters(pu1,pv1,pu2,pv2);   
770     for(i=1;
771         (vtxfound==Standard_False) && (i<=nbvtx);i++) { 
772       const IntPatch_Point&  V = svtx.Value(i);
773       Standard_Real vTol = V.Tolerance();
774       if(CompareVertexAndPoint(V.Value(),curv->Value(nbponline).Value(),vTol)) { 
775         vtx = V;
776         vtx.SetParameters(pu1,pv1,pu2,pv2);
777         vtxfound = Standard_True;
778       }
779     }
780     if(vtxfound == Standard_False)  {     
781       vtx.SetValue(curv->Value(nbponline).Value(),Tol,Standard_False);
782       vtx.SetParameters(pu1,pv1,pu2,pv2);
783     }
784     vtx.SetParameter(nbponline);
785     svtx.Append(vtx); nbvtx++;
786     lapt = Standard_True;
787     indl = nbvtx; 
788   }
789   
790
791
792
793   //--------------------------------------------------------------
794   //-- ** Detection de points trouves sur une meme restriction 
795   //--    avec la meme transition et avec des params on line 
796   //--    voisins.   
797   //-- ** Dans ce cas (-> donnerait un baillemenmt) on supprime 
798   //--    le point 'intermediaire'. 
799   //-- ** (exemple Vtx(1)  .....  Vtx(204) Vtx(205))
800   //--    on supprime le Vtx(204)
801   //-- ** (exemple Vtx(1) Vtx(2)  .....  Vtx(205))
802   //--    on supprime le Vtx(2)
803   //-- ** (exemple Vtx(1)  ...  Vtx(100) Vtx(101) ... Vtx(205))
804   //--    on supprime le Vtx(100)  (Vtx(100)et101 sur m restr)
805
806   //--------------------------------------------------------------
807   nbvtx = NbVertex();
808   do { 
809     APointDeleted = Standard_False;
810     for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { 
811       const IntPatch_Point& VTXi   = svtx.Value(i);
812       if((VTXi.IsOnDomS1()==Standard_True) && (VTXi.IsOnDomS2()==Standard_False)) { 
813         for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) {
814           if(i!=j) { 
815             const IntPatch_Point& VTXj   = svtx.Value(j);
816             if((VTXj.IsOnDomS1()==Standard_True) && (VTXj.IsOnDomS2()==Standard_False)) {
817               if(   (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()+1)
818                  || (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()-1)) { 
819                 if(VTXi.ArcOnS1() == VTXj.ArcOnS1()) { 
820                   IntSurf_Transition t1 = VTXi.TransitionLineArc1();
821                   IntSurf_Transition t2 = VTXj.TransitionLineArc1();
822                   if(t1.TransitionType()==t2.TransitionType()) { 
823                     if((VTXj.ParameterOnLine()!=1) && (VTXj.ParameterOnLine()!=NbPnts())) {   
824                       svtx.Remove(j);
825                       nbvtx--;
826                       if(lapt) { if(indl>=j) indl--; } 
827                       if(fipt) { if(indf>=j) indf--; } 
828                       APointDeleted = Standard_True;
829                     }
830                   }
831                 }
832               }
833             }
834           }
835         }
836       }
837     }
838   }
839   
840   //-- meme traitement sur les restrictions du second shape
841
842   while(APointDeleted == Standard_True);
843   nbvtx = NbVertex();
844   do { 
845     APointDeleted = Standard_False;
846     for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { 
847       const IntPatch_Point& VTXi   = svtx.Value(i);
848       if((VTXi.IsOnDomS1()==Standard_False) && (VTXi.IsOnDomS2()==Standard_True)) { 
849         for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) {
850           if(i!=j) { 
851             const IntPatch_Point& VTXj   = svtx.Value(j);
852             if((VTXj.IsOnDomS1()==Standard_False) && (VTXj.IsOnDomS2()==Standard_True)) {
853               if(   (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()+1)
854                  || (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()-1)) { 
855                 if(VTXi.ArcOnS2() == VTXj.ArcOnS2()) { 
856                   IntSurf_Transition t1 = VTXi.TransitionLineArc2();
857                   IntSurf_Transition t2 = VTXj.TransitionLineArc2();
858                   if(t1.TransitionType()==t2.TransitionType()) { 
859                     if((VTXj.ParameterOnLine()!=1) && (VTXj.ParameterOnLine()!=NbPnts())) {   
860                       svtx.Remove(j);
861                       nbvtx--;
862                       if(lapt) { if(indl>=j) indl--; } 
863                       if(fipt) { if(indf>=j) indf--; } 
864                       APointDeleted = Standard_True;
865                     }
866                   }
867                 }
868               }
869             }
870           }
871         }
872       }
873     }
874   }
875   while(APointDeleted == Standard_True);
876   //--------------------------------------------------------------
877
878   //--------------------------------------------------------------
879   //-- dans le cas de lignes periodiques du type : 
880   //--    Un point sur restriction R1 de param p1  -> P3d1   Vtx1
881   //--    Un point sur restriction R2 de param p2  -> P3d1   Vtx2
882   //--    
883   //--    Un point sur restriction R1 de param p1  -> P3d1   Vtx3
884   //--    pas de point sur R2 
885   //--
886   //-- On doit dans ce cas creer un nouveau Vtx4 = Vtx3 sur la 
887   //-- restriction R2
888   //--
889   //-- Ce cas se produit qd on a corrige un baillement avec le filtre
890   //-- precedent
891   //-- 
892   
893
894
895
896   
897
898   nbvtx = NbVertex();
899   do { 
900     SortIsOK = Standard_True;
901     for(i=2; i<=nbvtx; i++) { 
902       if(svtx.Value(i-1).ParameterOnLine()  > svtx.Value(i).ParameterOnLine()) { 
903         SortIsOK = Standard_False;
904         svtx.Exchange(i-1,i);
905       }
906     }
907   }
908   while(!SortIsOK);
909   
910   //-- Dump();
911
912 #if DEBUGV  
913   cout<<"\n----------- apres ComputeVertexParameters -------------"<<endl;
914   for(i=1;i<=nbvtx;i++) { 
915     Vertex(i).Dump();
916     Standard_Real  polr = Vertex(i).ParameterOnLine();
917     Standard_Real pol = (Standard_Integer)polr;
918     if(pol>=1 && pol<=nbvtx) { 
919       cout<<"----> IntSurf_PntOn2S : "<<polr<<"  Pnt ("<<Vertex(pol).Value().X()
920         <<","<<Vertex(pol).Value().Y()
921           <<","<<Vertex(pol).Value().Z()<<")"<<endl;
922     }
923   }
924   cout<<"\n----------------------------------------------------------"<<endl;
925 #endif  
926
927
928 }
929
930
931
932 Standard_Boolean IntPatch_WLine::IsOutSurf1Box(const gp_Pnt2d& P1uv)  { 
933   if(Buv1.IsWhole()) {
934     Standard_Integer n=NbPnts();
935     Standard_Real pu1,pu2,pv1,pv2;
936     Buv1.SetVoid();
937     for(Standard_Integer i=1;i<=n;i++) { 
938       curv->Value(i).Parameters(pu1,pv1,pu2,pv2);
939       Buv1.Add(gp_Pnt2d(pu1,pv1));
940     }
941     Buv1.Get(pu1,pv1,pu2,pv2);
942     pu2-=pu1;
943     pv2-=pv1;
944     if(pu2>pv2) { 
945       Buv1.Enlarge(pu2*0.01);
946     }
947     else { 
948       Buv1.Enlarge(pv2*0.01);
949     }
950   }
951   Standard_Boolean out=Buv1.IsOut(P1uv);
952   return(out);
953 }
954
955 Standard_Boolean IntPatch_WLine::IsOutSurf2Box(const gp_Pnt2d& P2uv)  { 
956   if(Buv2.IsWhole()) { 
957     Standard_Integer n=NbPnts();
958     Standard_Real pu1,pu2,pv1,pv2;
959     Buv2.SetVoid();
960     for(Standard_Integer i=1;i<=n;i++) { 
961       curv->Value(i).Parameters(pu1,pv1,pu2,pv2);
962       Buv2.Add(gp_Pnt2d(pu2,pv2));
963     }
964     Buv2.Get(pu1,pv1,pu2,pv2);
965     pu2-=pu1;
966     pv2-=pv1;
967     if(pu2>pv2) { 
968       Buv2.Enlarge(pu2*0.01);
969     }
970     else { 
971       Buv2.Enlarge(pv2*0.01);
972     }    
973   }
974   Standard_Boolean out=Buv2.IsOut(P2uv);
975   return(out);
976 }
977
978 Standard_Boolean IntPatch_WLine::IsOutBox(const gp_Pnt& Pxyz)  { 
979   if(Bxyz.IsWhole()) { 
980     Standard_Integer n=NbPnts();
981     Bxyz.SetVoid();
982     for(Standard_Integer i=1;i<=n;i++) { 
983       gp_Pnt P=curv->Value(i).Value();
984       Bxyz.Add(P);
985     }
986     Standard_Real x0,y0,z0,x1,y1,z1;
987     Bxyz.Get(x0,y0,z0,x1,y1,z1);
988     x1-=x0; y1-=y0; z1-=z0;
989     if(x1>y1) {
990       if(x1>z1) {
991         Bxyz.Enlarge(x1*0.01);
992       }
993       else { 
994         Bxyz.Enlarge(z1*0.01);
995       }
996     }
997     else { 
998       if(y1>z1) { 
999         Bxyz.Enlarge(y1*0.01);
1000       }
1001       else { 
1002         Bxyz.Enlarge(z1*0.01);
1003       }
1004     }
1005   }
1006   Standard_Boolean out=Bxyz.IsOut(Pxyz);
1007   return(out);
1008 }
1009
1010
1011 Standard_Boolean IntPatch_WLine::HasArcOnS1() const  {
1012   return(hasArcOnS1);
1013 }
1014
1015 void IntPatch_WLine::SetArcOnS1(const Handle(Adaptor2d_HCurve2d)& A) { 
1016   hasArcOnS1=Standard_True;
1017   theArcOnS1=A;
1018 }
1019
1020 const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS1() const  { 
1021   return(theArcOnS1);
1022 }
1023
1024 Standard_Boolean IntPatch_WLine::HasArcOnS2() const  {
1025   return(hasArcOnS2);
1026 }
1027
1028 void IntPatch_WLine::SetArcOnS2(const Handle(Adaptor2d_HCurve2d)& A) { 
1029   hasArcOnS2=Standard_True;
1030   theArcOnS2=A;
1031 }
1032
1033 const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS2() const  { 
1034   return(theArcOnS2);
1035 }
1036
1037
1038 void IntPatch_WLine::Dump() const { 
1039   
1040   cout<<" ----------- D u m p    I n t P a t c h  _  W L i n e  --------------"<<endl;
1041   Standard_Integer i;
1042   Standard_Integer nbp = NbPnts();
1043   printf("Num    [X  Y  Z]     [U1  V1]   [U2  V2]\n");
1044 //  for(Standard_Integer i=1;i<=nbp;i++) { 
1045   for(i=1;i<=nbp;i++) {
1046     Standard_Real u1,v1,u2,v2;
1047     Point(i).Parameters(u1,v1,u2,v2);
1048     printf("%4d  [%+5.8e %+5.8e %+5.8e]  [%+5.8e %+5.8e]  [%+5.8e %+5.8e]\n",
1049            i,
1050            Point(i).Value().X(),
1051            Point(i).Value().Y(),
1052            Point(i).Value().Z(),
1053            u1,v1,u2,v2);
1054     
1055     
1056     //cout<<"IntSurf_PntOn2S : "<<i<<"  Pnt ("<<curv->Value(i).Value().X()
1057     //  <<","<<curv->Value(i).Value().Y()
1058     //  <<","<<curv->Value(i).Value().Z()<<")"<<endl;
1059     //cout<<"                :   u1("<<u1<<")   v1("<<v1<<")   u2("<<u2<<")   v2("<<v2<<")"<<endl; 
1060   }
1061   nbp = NbVertex();
1062   for(i=1;i<=nbp;i++) { 
1063     Vertex(i).Dump();
1064     Standard_Real  polr = Vertex(i).ParameterOnLine();
1065     Standard_Integer pol = (Standard_Integer)polr;
1066     if(pol>=1 && pol<=nbp) { 
1067       cout<<"----> IntSurf_PntOn2S : "<<polr<<"  Pnt ("<<Vertex(pol).Value().X()
1068         <<","<<Vertex(pol).Value().Y()
1069           <<","<<Vertex(pol).Value().Z()<<")"<<endl;
1070     }
1071   }
1072   cout<<"\n----------------------------------------------------------"<<endl;  
1073 }
1074