src/IntPatch/IntPatch_WLine.cxx

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