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