src/HLRAlgo/HLRAlgo_PolyAlgo.cxx

   1 // Created on: 1995-05-05
   2 // Created by: Christophe MARION
   3 // Copyright (c) 1995-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 under
   9 // the terms of the GNU Lesser General Public License 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 #ifndef No_Exception
  18 //#define No_Exception
  19 #endif
  20
  21
  22 #include <HLRAlgo_BiPoint.hxx>
  23 #include <HLRAlgo_EdgeStatus.hxx>
  24 #include <HLRAlgo_ListOfBPoint.hxx>
  25 #include <HLRAlgo_PolyAlgo.hxx>
  26 #include <HLRAlgo_PolyData.hxx>
  27 #include <HLRAlgo_PolyShellData.hxx>
  28 #include <Precision.hxx>
  29 #include <Standard_Type.hxx>
  30
  31 IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,MMgt_TShared)
  32
  33 #define EMskGrALin1  ((Standard_Integer)   8)
  34 #define EMskGrALin2  ((Standard_Integer)  16)
  35 #define EMskGrALin3  ((Standard_Integer)  32)
  36 #define FMskHiding   ((Standard_Integer) 256)
  37
  38 #define TriNode1 ((Standard_Integer*)TriIndices)[0]
  39 #define TriNode2 ((Standard_Integer*)TriIndices)[1]
  40 #define TriNode3 ((Standard_Integer*)TriIndices)[2]
  41 #define TriFlags ((Standard_Integer*)TriIndices)[3]
  42
  43 #define XV1          myRealPtr[0]
  44 #define XV2          myRealPtr[1]
  45 #define XV3          myRealPtr[2]
  46 #define YV1          myRealPtr[3]
  47 #define YV2          myRealPtr[4]
  48 #define YV3          myRealPtr[5]
  49 #define Param        myRealPtr[6]
  50 #define myTolParam   myRealPtr[7]
  51 #define myTolAngular myRealPtr[8]
  52 #define myTolerance  myRealPtr[9]
  53
  54 #define PntX1  ((Standard_Real*)Coordinates)[ 0]
  55 #define PntY1  ((Standard_Real*)Coordinates)[ 1]
  56 #define PntZ1  ((Standard_Real*)Coordinates)[ 2]
  57 #define PntX2  ((Standard_Real*)Coordinates)[ 3]
  58 #define PntY2  ((Standard_Real*)Coordinates)[ 4]
  59 #define PntZ2  ((Standard_Real*)Coordinates)[ 5]
  60 #define PntXP1 ((Standard_Real*)Coordinates)[ 6]
  61 #define PntYP1 ((Standard_Real*)Coordinates)[ 7]
  62 #define PntZP1 ((Standard_Real*)Coordinates)[ 8]
  63 #define PntXP2 ((Standard_Real*)Coordinates)[ 9]
  64 #define PntYP2 ((Standard_Real*)Coordinates)[10]
  65 #define PntZP2 ((Standard_Real*)Coordinates)[11]
  66
  67 #define TotXMin    ((Standard_Real*)TotMinMax)[0]
  68 #define TotYMin    ((Standard_Real*)TotMinMax)[1]
  69 #define TotZMin    ((Standard_Real*)TotMinMax)[2]
  70 #define TotXMax    ((Standard_Real*)TotMinMax)[3]
  71 #define TotYMax    ((Standard_Real*)TotMinMax)[4]
  72 #define TotZMax    ((Standard_Real*)TotMinMax)[5]
  73
  74 #define ShapeIndex ((Standard_Integer*)IndexPtr)[0]
  75 #define FaceConex1 ((Standard_Integer*)IndexPtr)[1]
  76 #define Face1Pt1   ((Standard_Integer*)IndexPtr)[2]
  77 #define Face1Pt2   ((Standard_Integer*)IndexPtr)[3]
  78 #define FaceConex2 ((Standard_Integer*)IndexPtr)[4]
  79 #define Face2Pt1   ((Standard_Integer*)IndexPtr)[5]
  80 #define Face2Pt2   ((Standard_Integer*)IndexPtr)[6]
  81 #define MinSeg     ((Standard_Integer*)IndexPtr)[7]
  82 #define MaxSeg     ((Standard_Integer*)IndexPtr)[8]
  83 #define SegFlags   ((Standard_Integer*)IndexPtr)[9]
  84
  85 #define MinShell ((Standard_Integer*)ShellIndices)[0]
  86 #define MaxShell ((Standard_Integer*)ShellIndices)[1]
  87
  88 #define FIndex   ((Standard_Integer*)PolyTIndices)[0]
  89 #define MinPolyT ((Standard_Integer*)PolyTIndices)[1]
  90 #define MaxPolyT ((Standard_Integer*)PolyTIndices)[2]
  91
  92 //static Standard_Integer ERROR = Standard_False;
  93
  94 //=======================================================================
  95 //function : HLRAlgo_PolyAlgo
  96 //purpose  :
  97 //=======================================================================
  98
  99 HLRAlgo_PolyAlgo::HLRAlgo_PolyAlgo ()
 100 {
 101   myTolParam   = 0.00000001;
 102   myTolAngular = 0.0001;
 103 }
 104
 105 //=======================================================================
 106 //function : Init
 107 //purpose  :
 108 //=======================================================================
 109
 110 void
 111 HLRAlgo_PolyAlgo::Init (const Handle(TColStd_HArray1OfTransient)& HShell)
 112 { myHShell = HShell; }
 113
 114 //=======================================================================
 115 //function : Clear
 116 //purpose  :
 117 //=======================================================================
 118
 119 void HLRAlgo_PolyAlgo::Clear ()
 120 {
 121   if (!myHShell.IsNull()) {
 122     myHShell.Nullify();
 123   }
 124   myNbrShell = 0;
 125 }
 126
 127 //=======================================================================
 128 //function : Update
 129 //purpose  :
 130 //=======================================================================
 131
 132 void HLRAlgo_PolyAlgo::Update ()
 133 {
 134   Standard_Integer i,j;
 135   Standard_Integer nxMin,nyMin,nzMin,nxMax,nyMax,nzMax;
 136   Standard_Real xShellMin,yShellMin,zShellMin;
 137   Standard_Real xShellMax,yShellMax,zShellMax;
 138   Standard_Real xPolyTMin,yPolyTMin,zPolyTMin;
 139   Standard_Real xPolyTMax,yPolyTMax,zPolyTMax;
 140   Standard_Real xTrianMin,yTrianMin,zTrianMin;
 141   Standard_Real xTrianMax,yTrianMax,zTrianMax;
 142   Standard_Real xSegmnMin,ySegmnMin,zSegmnMin;
 143   Standard_Real xSegmnMax,ySegmnMax,zSegmnMax;
 144   Standard_Real TotMinMax[6];
 145   Standard_Real Big = Precision::Infinite();
 146   TotMinMax[0] =  Big;
 147   TotMinMax[1] =  Big;
 148   TotMinMax[2] =  Big;
 149   TotMinMax[3] = -Big;
 150   TotMinMax[4] = -Big;
 151   TotMinMax[5] = -Big;
 152   TColStd_Array1OfTransient& Shell = myHShell->ChangeArray1();
 153   myNbrShell = Shell.Upper();
 154   Handle(HLRAlgo_PolyShellData)* psd1 =
 155     (Handle(HLRAlgo_PolyShellData)*)&(Shell.ChangeValue(1));
 156
 157   for (i = 1; i <= myNbrShell; i++) {
 158     (*psd1)->UpdateGlobalMinMax(&TotMinMax);
 159     psd1++;
 160   }
 161
 162   Standard_Real dx = TotMinMax[3] - TotMinMax[0];
 163   Standard_Real dy = TotMinMax[4] - TotMinMax[1];
 164   Standard_Real dz = TotMinMax[5] - TotMinMax[2];
 165   Standard_Real    precad = dx;
 166   if (precad < dy) precad = dy;
 167   if (precad < dz) precad = dz;
 168   myTolerance = precad * myTolParam;
 169   precad = precad * 0.01;
 170   Standard_Real SurDX = 1020 / (dx + precad);
 171   Standard_Real SurDY = 1020 / (dy + precad);
 172   Standard_Real SurDZ =  508 / (dz + precad);
 173   precad = precad * 0.5;
 174   Standard_Real DecaX = - TotMinMax[0] + precad;
 175   Standard_Real DecaY = - TotMinMax[1] + precad;
 176   Standard_Real DecaZ = - TotMinMax[2] + precad;
 177
 178   Handle(HLRAlgo_PolyShellData)* psd2 =
 179     (Handle(HLRAlgo_PolyShellData)*)&(Shell.ChangeValue(1));
 180
 181   for (i = 1; i <= myNbrShell; i++) {
 182     const Standard_Address ShellIndices = (*psd2)->Indices();
 183     xShellMin =  Big;
 184     yShellMin =  Big;
 185     zShellMin =  Big;
 186     xShellMax = -Big;
 187     yShellMax = -Big;
 188     zShellMax = -Big;
 189
 190     for (mySegListIt.Initialize((*psd2)->Edges());
 191          mySegListIt.More();
 192          mySegListIt.Next()) {
 193       HLRAlgo_BiPoint& BP = mySegListIt.Value();
 194       const Standard_Address Coordinates = BP.Coordinates();
 195       const Standard_Address IndexPtr    = BP.Indices();
 196       if (PntXP1 < PntXP2) { xSegmnMin = PntXP1; xSegmnMax = PntXP2; }
 197       else                 { xSegmnMin = PntXP2; xSegmnMax = PntXP1; }
 198       if (PntYP1 < PntYP2) { ySegmnMin = PntYP1; ySegmnMax = PntYP2; }
 199       else                 { ySegmnMin = PntYP2; ySegmnMax = PntYP1; }
 200       if (PntZP1 < PntZP2) { zSegmnMin = PntZP1; zSegmnMax = PntZP2; }
 201       else                 { zSegmnMin = PntZP2; zSegmnMax = PntZP1; }
 202       nxMin = (Standard_Integer)((DecaX + xSegmnMin) * SurDX);
 203       nyMin = (Standard_Integer)((DecaY + ySegmnMin) * SurDY);
 204       nzMin = (Standard_Integer)((DecaZ + zSegmnMin) * SurDZ);
 205       nxMax = (Standard_Integer)((DecaX + xSegmnMax) * SurDX);
 206       nyMax = (Standard_Integer)((DecaY + ySegmnMax) * SurDY);
 207       nzMax = (Standard_Integer)((DecaZ + zSegmnMax) * SurDZ);
 208       MinSeg = nyMin + (nxMin << 11);
 209       MinSeg <<= 10;
 210       MinSeg += nzMin;
 211       MaxSeg = nyMax + (nxMax << 11);
 212       MaxSeg <<= 10;
 213       MaxSeg += nzMax + 0x00000200;
 214       if (xShellMin > xSegmnMin) xShellMin = xSegmnMin;
 215       if (xShellMax < xSegmnMax) xShellMax = xSegmnMax;
 216       if (yShellMin > ySegmnMin) yShellMin = ySegmnMin;
 217       if (yShellMax < ySegmnMax) yShellMax = ySegmnMax;
 218       if (zShellMin > zSegmnMin) zShellMin = zSegmnMin;
 219       if (zShellMax < zSegmnMax) zShellMax = zSegmnMax;
 220     }
 221     TColStd_Array1OfTransient& Polyg = (*psd2)->PolyData();
 222     Standard_Integer nbFace = Polyg.Upper();
 223     Standard_Integer nbFaHi = 0;
 224     Handle(HLRAlgo_PolyData)* pd = NULL;
 225     if(nbFace > 0) pd = (Handle(HLRAlgo_PolyData)*)&(Polyg.ChangeValue(1));
 226
 227     for (j = 1; j <= nbFace; j++) {
 228       if ((*pd)->Hiding()) {
 229         nbFaHi++;
 230         xPolyTMin =  Big;
 231         yPolyTMin =  Big;
 232         zPolyTMin =  Big;
 233         xPolyTMax = -Big;
 234         yPolyTMax = -Big;
 235         zPolyTMax = -Big;
 236         Standard_Integer otheri,nbHide = 0;//min,max;
 237         Standard_Real X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3;
 238         Standard_Real dn,dnx,dny,dnz,dx1,dy1,dz1,dx2,dy2,dz2,dx3,dy3;
 239         Standard_Real adx1,ady1,adx2,ady2,adx3,ady3;
 240         Standard_Real a =0.,b =0.,c =0.,d =0.;
 241         const Standard_Address PolyTIndices = (*pd)->Indices();
 242         TColgp_Array1OfXYZ   & Nodes        = (*pd)->Nodes();
 243         HLRAlgo_Array1OfTData& TData        = (*pd)->TData();
 244         HLRAlgo_Array1OfPHDat& PHDat        = (*pd)->PHDat();
 245         Standard_Integer nbT = TData.Upper();
 246         HLRAlgo_TriangleData* TD = &(TData.ChangeValue(1));
 247
 248         for (otheri = 1; otheri <= nbT; otheri++) {
 249           const Standard_Address TriIndices = TD->Indices();
 250           if (TriFlags & FMskHiding) {
 251             const gp_XYZ& P1 = Nodes(TriNode1);
 252             const gp_XYZ& P2 = Nodes(TriNode2);
 253             const gp_XYZ& P3 = Nodes(TriNode3);
 254             X1 = P1.X();
 255             Y1 = P1.Y();
 256             Z1 = P1.Z();
 257             X2 = P2.X();
 258             Y2 = P2.Y();
 259             Z2 = P2.Z();
 260             X3 = P3.X();
 261             Y3 = P3.Y();
 262             Z3 = P3.Z();
 263             xTrianMax = xTrianMin = X1;
 264             yTrianMax = yTrianMin = Y1;
 265             zTrianMax = zTrianMin = Z1;
 266             if      (xTrianMin > X2) xTrianMin = X2;
 267             else if (xTrianMax < X2) xTrianMax = X2;
 268             if      (yTrianMin > Y2) yTrianMin = Y2;
 269             else if (yTrianMax < Y2) yTrianMax = Y2;
 270             if      (zTrianMin > Z2) zTrianMin = Z2;
 271             else if (zTrianMax < Z2) zTrianMax = Z2;
 272             if      (xTrianMin > X3) xTrianMin = X3;
 273             else if (xTrianMax < X3) xTrianMax = X3;
 274             if      (yTrianMin > Y3) yTrianMin = Y3;
 275             else if (yTrianMax < Y3) yTrianMax = Y3;
 276             if      (zTrianMin > Z3) zTrianMin = Z3;
 277             else if (zTrianMax < Z3) zTrianMax = Z3;
 278             nxMin = (Standard_Integer)((DecaX + xTrianMin) * SurDX);
 279             nyMin = (Standard_Integer)((DecaY + yTrianMin) * SurDY);
 280             nzMin = (Standard_Integer)((DecaZ + zTrianMin) * SurDZ);
 281             nxMax = (Standard_Integer)((DecaX + xTrianMax) * SurDX);
 282             nyMax = (Standard_Integer)((DecaY + yTrianMax) * SurDY);
 283             nzMax = (Standard_Integer)((DecaZ + zTrianMax) * SurDZ);
 284             Standard_Integer MinTrian,MaxTrian;
 285             MinTrian   = nyMin + (nxMin << 11);
 286             MinTrian <<= 10;
 287             MinTrian  += nzMin - 0x00000200;
 288             MaxTrian   = nyMax + (nxMax << 11);
 289             MaxTrian <<= 10;
 290             MaxTrian  += nzMax;
 291             dx1 = X2 - X1;
 292             dy1 = Y2 - Y1;
 293             dz1 = Z2 - Z1;
 294             dx2 = X3 - X2;
 295             dy2 = Y3 - Y2;
 296             dz2 = Z3 - Z2;
 297             dx3 = X1 - X3;
 298             dy3 = Y1 - Y3;
 299             dnx = dy1 * dz2 - dy2 * dz1;
 300             dny = dz1 * dx2 - dz2 * dx1;
 301             dnz = dx1 * dy2 - dx2 * dy1;
 302             dn = sqrt(dnx * dnx + dny * dny + dnz * dnz);
 303             if (dn > 0) {
 304               a = dnx / dn;
 305               b = dny / dn;
 306               c = dnz / dn;
 307             }
 308             d = a * X1 + b * Y1 + c * Z1;
 309             nbHide++;
 310             PHDat(nbHide).Set(otheri,MinTrian,MaxTrian,a,b,c,d);
 311             adx1 = dx1;
 312             ady1 = dy1;
 313             if (dx1 < 0) adx1 = -dx1;
 314             if (dy1 < 0) ady1 = -dy1;
 315             adx2 = dx2;
 316             ady2 = dy2;
 317             if (dx2 < 0) adx2 = -dx2;
 318             if (dy2 < 0) ady2 = -dy2;
 319             adx3 = dx3;
 320             ady3 = dy3;
 321             if (dx3 < 0) adx3 = -dx3;
 322             if (dy3 < 0) ady3 = -dy3;
 323             if (adx1 > ady1) TriFlags |=  EMskGrALin1;
 324             else             TriFlags &= ~EMskGrALin1;
 325             if (adx2 > ady2) TriFlags |=  EMskGrALin2;
 326             else             TriFlags &= ~EMskGrALin2;
 327             if (adx3 > ady3) TriFlags |=  EMskGrALin3;
 328             else             TriFlags &= ~EMskGrALin3;
 329             if (xPolyTMin > xTrianMin) xPolyTMin = xTrianMin;
 330             if (xPolyTMax < xTrianMax) xPolyTMax = xTrianMax;
 331             if (yPolyTMin > yTrianMin) yPolyTMin = yTrianMin;
 332             if (yPolyTMax < yTrianMax) yPolyTMax = yTrianMax;
 333             if (zPolyTMin > zTrianMin) zPolyTMin = zTrianMin;
 334             if (zPolyTMax < zTrianMax) zPolyTMax = zTrianMax;
 335           }
 336           TD++;
 337         }
 338         nxMin = (Standard_Integer)((DecaX + xPolyTMin) * SurDX);
 339         nyMin = (Standard_Integer)((DecaY + yPolyTMin) * SurDY);
 340         nzMin = (Standard_Integer)((DecaZ + zPolyTMin) * SurDZ);
 341         nxMax = (Standard_Integer)((DecaX + xPolyTMax) * SurDX);
 342         nyMax = (Standard_Integer)((DecaY + yPolyTMax) * SurDY);
 343         nzMax = (Standard_Integer)((DecaZ + zPolyTMax) * SurDZ);
 344         MinPolyT   = nyMin + (nxMin << 11);
 345         MinPolyT <<= 10;
 346         MinPolyT  += nzMin - 0x00000200;
 347         MaxPolyT   = nyMax + (nxMax << 11);
 348         MaxPolyT <<= 10;
 349         MaxPolyT  += nzMax;
 350         if (xShellMin > xPolyTMin) xShellMin = xPolyTMin;
 351         if (xShellMax < xPolyTMax) xShellMax = xPolyTMax;
 352         if (yShellMin > yPolyTMin) yShellMin = yPolyTMin;
 353         if (yShellMax < yPolyTMax) yShellMax = yPolyTMax;
 354         if (zShellMin > zPolyTMin) zShellMin = zPolyTMin;
 355         if (zShellMax < zPolyTMax) zShellMax = zPolyTMax;
 356       }
 357       pd++;
 358     }
 359     if (nbFaHi > 0) {
 360       nxMin = (Standard_Integer)((DecaX + xShellMin) * SurDX);
 361       nyMin = (Standard_Integer)((DecaY + yShellMin) * SurDY);
 362       nzMin = (Standard_Integer)((DecaZ + zShellMin) * SurDZ);
 363       nxMax = (Standard_Integer)((DecaX + xShellMax) * SurDX);
 364       nyMax = (Standard_Integer)((DecaY + yShellMax) * SurDY);
 365       nzMax = (Standard_Integer)((DecaZ + zShellMax) * SurDZ);
 366       MinShell   = nyMin + (nxMin << 11);
 367       MinShell <<= 10;
 368       MinShell  += nzMin - 0x00000200;
 369       MaxShell   = nyMax + (nxMax << 11);
 370       MaxShell <<= 10;
 371       MaxShell  += nzMax;
 372       (*psd2)->UpdateHiding(nbFaHi);
 373       TColStd_Array1OfTransient& PolHi = (*psd2)->HidingPolyData();
 374       pd = (Handle(HLRAlgo_PolyData)*)&(Polyg.ChangeValue(1));
 375       Handle(HLRAlgo_PolyData)* phd =
 376         (Handle(HLRAlgo_PolyData)*)&(PolHi.ChangeValue(1));
 377
 378       for (j = 1; j <= nbFace; j++) {
 379         if ((*pd)->Hiding()) {
 380           *phd = *pd;
 381           phd++;
 382         }
 383         pd++;
 384       }
 385     }
 386     else {
 387       (*psd2)->UpdateHiding(0);
 388       MinShell = 0;
 389       MaxShell = 0;
 390     }
 391     psd2++;
 392   }
 393 }
 394
 395 //=======================================================================
 396 //function : NextHide
 397 //purpose  :
 398 //=======================================================================
 399
 400 void HLRAlgo_PolyAlgo::NextHide ()
 401 {
 402   myFound = Standard_False;
 403   if (myCurShell != 0) {
 404     mySegListIt.Next();
 405     if (mySegListIt.More()) myFound = Standard_True;
 406   }
 407   if (!myFound) {
 408     myCurShell++;
 409
 410 //POP ADN pour que cela marche sur WNT
 411 //    while (myCurShell <= myNbrShell && !myFound) {
 412 //      mySegListIt.Initialize((*(Handle(HLRAlgo_PolyShellData)*)&
 413 //                            (myHShell->ChangeValue(myCurShell)))
 414 //                           ->Edges());
 415     while (myCurShell <= myNbrShell && !myFound) {
 416           Handle(HLRAlgo_PolyShellData) data =
 417                   Handle(HLRAlgo_PolyShellData)::DownCast(myHShell->Value(myCurShell));
 418       mySegListIt.Initialize(data->Edges());
 419       if (mySegListIt.More()) myFound = Standard_True;
 420       else                    myCurShell++;
 421     }
 422   }
 423 }
 424
 425 //=======================================================================
 426 //function : Hide
 427 //purpose  :
 428 //=======================================================================
 429
 430 void HLRAlgo_PolyAlgo::Hide (Standard_Address& Coordinates,
 431                              HLRAlgo_EdgeStatus& status,
 432                              Standard_Integer& Index,
 433                              Standard_Boolean& reg1,
 434                              Standard_Boolean& regn,
 435                              Standard_Boolean& outl,
 436                              Standard_Boolean& intl)
 437 {
 438   HLRAlgo_BiPoint& BP             = mySegListIt.Value();
 439   Coordinates                     = BP.Coordinates();
 440   const Standard_Address IndexPtr = BP.Indices();
 441   status = HLRAlgo_EdgeStatus(0.,(Standard_ShortReal)myTolParam,1.,(Standard_ShortReal)myTolParam);
 442   Index = ShapeIndex;
 443   reg1       = BP.Rg1Line();
 444   regn       = BP.RgNLine();
 445   outl       = BP.OutLine();
 446   intl       = BP.IntLine();
 447   if (BP.Hidden())
 448     status.HideAll();
 449   else {
 450     Standard_Boolean HidingShell;
 451     TColStd_Array1OfTransient& Shell = myHShell->ChangeArray1();
 452     Handle(HLRAlgo_PolyShellData)* psd =
 453       (Handle(HLRAlgo_PolyShellData)*)&(Shell.ChangeValue(1));
 454
 455     for (Standard_Integer s = 1; s <= myNbrShell; s++) {
 456       if ((*psd)->Hiding()) {
 457         const Standard_Address ShellIndices = (*psd)->Indices();
 458         if (((MaxShell - MinSeg) & 0x80100200) == 0 &&
 459             ((MaxSeg - MinShell) & 0x80100000) == 0) {
 460           HidingShell = (s == myCurShell);
 461           TColStd_Array1OfTransient& Face = (*psd)->HidingPolyData();
 462           Standard_Integer nbFace = Face.Upper();
 463           Handle(HLRAlgo_PolyData)* pd =
 464             (Handle(HLRAlgo_PolyData)*)&(Face.ChangeValue(1));
 465
 466           for (Standard_Integer f = 1; f <= nbFace; f++) {
 467             (*pd)->HideByPolyData(Coordinates,
 468                                   (Standard_Address)myRealPtr,
 469                                   IndexPtr,
 470                                   HidingShell,
 471                                   status);
 472             pd++;
 473           }
 474         }
 475       }
 476       psd++;
 477     }
 478   }
 479 }
 480
 481 //=======================================================================
 482 //function : NextShow
 483 //purpose  :
 484 //=======================================================================
 485
 486 void HLRAlgo_PolyAlgo::NextShow ()
 487 {
 488   myFound = Standard_False;
 489   if (myCurShell != 0) {
 490     mySegListIt.Next();
 491     if (mySegListIt.More()) myFound = Standard_True;
 492   }
 493   if (!myFound) {
 494     myCurShell++;
 495
 496     while (myCurShell <= myNbrShell && !myFound) {
 497       mySegListIt.Initialize((*(Handle(HLRAlgo_PolyShellData)*)&
 498                               (myHShell->ChangeValue(myCurShell)))
 499                              ->Edges());
 500       if (mySegListIt.More()) myFound = Standard_True;
 501       else                    myCurShell++;
 502     }
 503   }
 504 }
 505
 506 //=======================================================================
 507 //function : Show
 508 //purpose  :
 509 //=======================================================================
 510
 511 void HLRAlgo_PolyAlgo::Show (Standard_Address& Coordinates,
 512                              Standard_Integer& Index,
 513                              Standard_Boolean& reg1,
 514                              Standard_Boolean& regn,
 515                              Standard_Boolean& outl,
 516                              Standard_Boolean& intl)
 517 {
 518   HLRAlgo_BiPoint& BP = mySegListIt.Value();
 519   Standard_Address IndexPtr = BP.Indices();
 520   Coordinates = BP.Coordinates();
 521   Index = ShapeIndex;
 522   reg1  = BP.Rg1Line();
 523   regn  = BP.RgNLine();
 524   outl  = BP.OutLine();
 525   intl  = BP.IntLine();
 526 }
 527