src/HLRAlgo/HLRAlgo_PolyData.cxx

   1 // Created on: 1993-01-11
   2 // Created by: Christophe MARION
   3 // Copyright (c) 1993-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 #include <HLRAlgo_PolyData.hxx>
  18
  19 #include <HLRAlgo_EdgeStatus.hxx>
  20
  21 #include <Standard_Type.hxx>
  22
  23 IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyData,MMgt_TShared)
  24
  25 #define EMskGrALin1  ((Standard_Integer)   8)
  26 #define EMskGrALin2  ((Standard_Integer)  16)
  27 #define EMskGrALin3  ((Standard_Integer)  32)
  28 #define FMskHiding   ((Standard_Integer) 256)
  29
  30 #define FIndex  myIndices[0]
  31 #define MinFac  myIndices[1]
  32 #define MaxFac  myIndices[2]
  33
  34 #define TriNode1   ((Standard_Integer*)TriIndices)[0]
  35 #define TriNode2   ((Standard_Integer*)TriIndices)[1]
  36 #define TriNode3   ((Standard_Integer*)TriIndices)[2]
  37 #define TriFlags   ((Standard_Integer*)TriIndices)[3]
  38
  39 #define PntX1  ((Standard_Real*)Coordinates)[ 0]
  40 #define PntY1  ((Standard_Real*)Coordinates)[ 1]
  41 #define PntZ1  ((Standard_Real*)Coordinates)[ 2]
  42 #define PntX2  ((Standard_Real*)Coordinates)[ 3]
  43 #define PntY2  ((Standard_Real*)Coordinates)[ 4]
  44 #define PntZ2  ((Standard_Real*)Coordinates)[ 5]
  45 #define PntXP1 ((Standard_Real*)Coordinates)[ 6]
  46 #define PntYP1 ((Standard_Real*)Coordinates)[ 7]
  47 #define PntZP1 ((Standard_Real*)Coordinates)[ 8]
  48 #define PntXP2 ((Standard_Real*)Coordinates)[ 9]
  49 #define PntYP2 ((Standard_Real*)Coordinates)[10]
  50 #define PntZP2 ((Standard_Real*)Coordinates)[11]
  51
  52 #define XV1        ((Standard_Real*)RealPtr)[0]
  53 #define XV2        ((Standard_Real*)RealPtr)[1]
  54 #define XV3        ((Standard_Real*)RealPtr)[2]
  55 #define YV1        ((Standard_Real*)RealPtr)[3]
  56 #define YV2        ((Standard_Real*)RealPtr)[4]
  57 #define YV3        ((Standard_Real*)RealPtr)[5]
  58 #define Param      ((Standard_Real*)RealPtr)[6]
  59 #define TolParam   ((Standard_Real*)RealPtr)[7]
  60 #define TolAng     ((Standard_Real*)RealPtr)[8]
  61 #define Tolerance  ((Standard_Real*)RealPtr)[9]
  62
  63 #define TotXMin    ((Standard_Real*)TotMinMax)[0]
  64 #define TotYMin    ((Standard_Real*)TotMinMax)[1]
  65 #define TotZMin    ((Standard_Real*)TotMinMax)[2]
  66 #define TotXMax    ((Standard_Real*)TotMinMax)[3]
  67 #define TotYMax    ((Standard_Real*)TotMinMax)[4]
  68 #define TotZMax    ((Standard_Real*)TotMinMax)[5]
  69
  70 #define IndexTri   ((Standard_Integer*)MinMaxPtr)[0]
  71 #define MinTri     ((Standard_Integer*)MinMaxPtr)[1]
  72 #define MaxTri     ((Standard_Integer*)MinMaxPtr)[2]
  73
  74 #define APlan      ((Standard_Real*)PlanPtr)[0]
  75 #define BPlan      ((Standard_Real*)PlanPtr)[1]
  76 #define CPlan      ((Standard_Real*)PlanPtr)[2]
  77 #define DPlan      ((Standard_Real*)PlanPtr)[3]
  78
  79 #define ShapeIndex  ((Standard_Integer*)Indices)[0]
  80 #define FaceConex1  ((Standard_Integer*)Indices)[1]
  81 #define Face1Pt1    ((Standard_Integer*)Indices)[2]
  82 #define Face1Pt2    ((Standard_Integer*)Indices)[3]
  83 #define FaceConex2  ((Standard_Integer*)Indices)[4]
  84 #define Face2Pt1    ((Standard_Integer*)Indices)[5]
  85 #define Face2Pt2    ((Standard_Integer*)Indices)[6]
  86 #define MinSeg      ((Standard_Integer*)Indices)[7]
  87 #define MaxSeg      ((Standard_Integer*)Indices)[8]
  88 #define SegFlags    ((Standard_Integer*)Indices)[9]
  89 #ifdef OCCT_DEBUG
  90 static Standard_Integer ERROR = Standard_False;
  91 #endif
  92 //=======================================================================
  93 //function : PolyData
  94 //purpose  :
  95 //=======================================================================
  96
  97 HLRAlgo_PolyData::HLRAlgo_PolyData ()
  98 {}
  99
 100 //=======================================================================
 101 //function : HNodes
 102 //purpose  :
 103 //=======================================================================
 104
 105 void HLRAlgo_PolyData::HNodes(const Handle(TColgp_HArray1OfXYZ)& HNodes)
 106 { myHNodes = HNodes; }
 107
 108 //=======================================================================
 109 //function : HTData
 110 //purpose  :
 111 //=======================================================================
 112
 113 void HLRAlgo_PolyData::HTData(const Handle(HLRAlgo_HArray1OfTData)& HTData)
 114 { myHTData = HTData; }
 115
 116 //=======================================================================
 117 //function : HPHDat
 118 //purpose  :
 119 //=======================================================================
 120
 121 void HLRAlgo_PolyData::HPHDat(const Handle(HLRAlgo_HArray1OfPHDat)& HPHDat)
 122 { myHPHDat = HPHDat; }
 123
 124 //=======================================================================
 125 //function : UpdateGlobalMinMax
 126 //purpose  :
 127 //=======================================================================
 128
 129 void
 130 HLRAlgo_PolyData::UpdateGlobalMinMax (const Standard_Address TotMinMax)
 131 {
 132   Standard_Integer i;
 133   Standard_Real X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3;
 134   const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
 135   HLRAlgo_Array1OfTData&    TData = myHTData->ChangeArray1();
 136   Standard_Integer          nbT   = TData.Upper();
 137   HLRAlgo_TriangleData*     TD    = &(TData.ChangeValue(1));
 138
 139   for (i = 1; i <= nbT; i++) {
 140     const Standard_Address TriIndices = TD->Indices();
 141     if (TriFlags & FMskHiding) {
 142       const gp_XYZ& P1 = Nodes(TriNode1);
 143       const gp_XYZ& P2 = Nodes(TriNode2);
 144       const gp_XYZ& P3 = Nodes(TriNode3);
 145       X1 = P1.X();
 146       Y1 = P1.Y();
 147       Z1 = P1.Z();
 148       X2 = P2.X();
 149       Y2 = P2.Y();
 150       Z2 = P2.Z();
 151       X3 = P3.X();
 152       Y3 = P3.Y();
 153       Z3 = P3.Z();
 154       if      (TotXMin > X1) TotXMin = X1;
 155       else if (TotXMax < X1) TotXMax = X1;
 156       if      (TotYMin > Y1) TotYMin = Y1;
 157       else if (TotYMax < Y1) TotYMax = Y1;
 158       if      (TotZMin > Z1) TotZMin = Z1;
 159       else if (TotZMax < Z1) TotZMax = Z1;
 160       if      (TotXMin > X2) TotXMin = X2;
 161       else if (TotXMax < X2) TotXMax = X2;
 162       if      (TotYMin > Y2) TotYMin = Y2;
 163       else if (TotYMax < Y2) TotYMax = Y2;
 164       if      (TotZMin > Z2) TotZMin = Z2;
 165       else if (TotZMax < Z2) TotZMax = Z2;
 166       if      (TotXMin > X3) TotXMin = X3;
 167       else if (TotXMax < X3) TotXMax = X3;
 168       if      (TotYMin > Y3) TotYMin = Y3;
 169       else if (TotYMax < Y3) TotYMax = Y3;
 170       if      (TotZMin > Z3) TotZMin = Z3;
 171       else if (TotZMax < Z3) TotZMax = Z3;
 172     }
 173     TD++;
 174   }
 175 }
 176
 177 //=======================================================================
 178 //function : HideByPolyData
 179 //purpose  :
 180 //=======================================================================
 181
 182 void HLRAlgo_PolyData::HideByPolyData (const Standard_Address Coordinates,
 183                                        const Standard_Address RealPtr,
 184                                        const Standard_Address Indices,
 185                                        const Standard_Boolean HidingShell,
 186                                        HLRAlgo_EdgeStatus& status)
 187 {
 188   if (((MaxFac - MinSeg) & 0x80100200) == 0 &&
 189       ((MaxSeg - MinFac) & 0x80100000) == 0) {
 190     HLRAlgo_Array1OfPHDat& PHDat = myHPHDat->ChangeArray1();
 191     const HLRAlgo_Array1OfTData& TData = myHTData->Array1();
 192     Standard_Real d1,d2;
 193     Standard_Boolean NotConnex    = Standard_False;
 194     Standard_Boolean isCrossing   = Standard_False;
 195     Standard_Boolean toHideBefore = Standard_False;
 196     Standard_Integer TFlag = 0;
 197     Standard_Address PlanPtr,MinMaxPtr,TriIndices;
 198     Standard_Integer h,h2 = PHDat.Upper();
 199     HLRAlgo_PolyHidingData* PH = &(PHDat(1));
 200
 201     for (h = 1; h <= h2; h++) {
 202       MinMaxPtr = PH->IndexAndMinMax();
 203       if (((MaxTri - MinSeg) & 0x80100200) == 0 &&
 204           ((MaxSeg - MinTri) & 0x80100000) == 0) {
 205         TriIndices = TData(IndexTri).Indices();
 206         NotConnex = Standard_True;
 207         if (HidingShell) {
 208           if      (FIndex == FaceConex1) {
 209             if      (Face1Pt1 == TriNode1)
 210               NotConnex = Face1Pt2 != TriNode2 && Face1Pt2 != TriNode3;
 211             else if (Face1Pt1 == TriNode2)
 212               NotConnex = Face1Pt2 != TriNode3 && Face1Pt2 != TriNode1;
 213             else if (Face1Pt1 == TriNode3)
 214               NotConnex = Face1Pt2 != TriNode1 && Face1Pt2 != TriNode2;
 215           }
 216           else if (FIndex == FaceConex2) {
 217             if      (Face2Pt1 == TriNode1)
 218               NotConnex = Face2Pt2 != TriNode2 && Face2Pt2 != TriNode3;
 219             else if (Face2Pt1 == TriNode2)
 220               NotConnex = Face2Pt2 != TriNode3 && Face2Pt2 != TriNode1;
 221             else if (Face2Pt1 == TriNode3)
 222               NotConnex = Face2Pt2 != TriNode1 && Face2Pt2 != TriNode2;
 223           }
 224         }
 225         if (NotConnex) {
 226           PlanPtr = PH->Plan();
 227           d1 = APlan * PntXP1 + BPlan * PntYP1 + CPlan * PntZP1 - DPlan;
 228           d2 = APlan * PntXP2 + BPlan * PntYP2 + CPlan * PntZP2 - DPlan;
 229           if      (d1 >  Tolerance) {
 230             if    (d2 < -Tolerance) {
 231               Param = d1 / ( d1 - d2 );
 232               toHideBefore = Standard_False;
 233               isCrossing   = Standard_True;
 234               TFlag = TriFlags;
 235               const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
 236               const gp_XYZ            & P1    = Nodes(TriNode1);
 237               const gp_XYZ            & P2    = Nodes(TriNode2);
 238               const gp_XYZ            & P3    = Nodes(TriNode3);
 239               XV1 = P1.X();
 240               YV1 = P1.Y();
 241               XV2 = P2.X();
 242               YV2 = P2.Y();
 243               XV3 = P3.X();
 244               YV3 = P3.Y();
 245               hideByOneTriangle (Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
 246             }
 247           }
 248           else if (d1 < -Tolerance) {
 249             if    (d2 >  Tolerance) {
 250               Param = d1 / ( d1 - d2 );
 251               toHideBefore = Standard_True;
 252               isCrossing   = Standard_True;
 253               TFlag = TriFlags;
 254               const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
 255               const gp_XYZ            & P1    = Nodes(TriNode1);
 256               const gp_XYZ            & P2    = Nodes(TriNode2);
 257               const gp_XYZ            & P3    = Nodes(TriNode3);
 258               XV1 = P1.X();
 259               YV1 = P1.Y();
 260               XV2 = P2.X();
 261               YV2 = P2.Y();
 262               XV3 = P3.X();
 263               YV3 = P3.Y();
 264               hideByOneTriangle (Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
 265             }
 266             else {
 267               isCrossing = Standard_False;
 268               TFlag = TriFlags;
 269               const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
 270               const gp_XYZ            & P1    = Nodes(TriNode1);
 271               const gp_XYZ            & P2    = Nodes(TriNode2);
 272               const gp_XYZ            & P3    = Nodes(TriNode3);
 273               XV1 = P1.X();
 274               YV1 = P1.Y();
 275               XV2 = P2.X();
 276               YV2 = P2.Y();
 277               XV3 = P3.X();
 278               YV3 = P3.Y();
 279               hideByOneTriangle (Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
 280             }
 281           }
 282           else if (d2 < -Tolerance) {
 283             isCrossing = Standard_False;
 284             TFlag = TriFlags;
 285             const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
 286             const gp_XYZ            & P1    = Nodes(TriNode1);
 287             const gp_XYZ            & P2    = Nodes(TriNode2);
 288             const gp_XYZ            & P3    = Nodes(TriNode3);
 289             XV1 = P1.X();
 290             YV1 = P1.Y();
 291             XV2 = P2.X();
 292             YV2 = P2.Y();
 293             XV3 = P3.X();
 294             YV3 = P3.Y();
 295             hideByOneTriangle(Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
 296           }
 297         }
 298       }
 299       PH++;
 300     }
 301   }
 302 }
 303
 304 //=======================================================================
 305 //function : hideByOneTriangle
 306 //purpose  :
 307 //=======================================================================
 308
 309 void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
 310                                           const Standard_Address RealPtr,
 311                                           const Standard_Boolean Crossing,
 312                                           const Standard_Boolean HideBefore,
 313                                           const Standard_Integer TrFlags,
 314                                           HLRAlgo_EdgeStatus& status)
 315 {
 316   Standard_Boolean o[2],m[2];
 317   Standard_Integer l,n1=0,nn1,nn2,npi=-1,npiRej=0;
 318   Standard_Real a,b,c,da,db,d1,d2,p[2]={0.,0.},pd1,pd2,pdp,pp,psta=0.,pend=1.;
 319   Standard_Boolean CrosSeg;
 320
 321   da = XV2 - XV1;
 322   db = YV2 - YV1;
 323   a = -db;
 324   b =  da;
 325   c = sqrt( a * a + b * b);
 326   a /= c;
 327   b /= c;
 328   c  = a * XV1  + b * YV1;
 329   d1 = a * PntXP1 + b * PntYP1 - c;
 330   d2 = a * PntXP2 + b * PntYP2 - c;
 331   if      (d1 >  Tolerance) {
 332     if (d2 < -Tolerance) {
 333       n1 =  2;
 334       CrosSeg = Standard_True;
 335     }
 336     else
 337       CrosSeg = Standard_False;
 338   }
 339   else if (d1 < -Tolerance) {
 340     if (d2 >  Tolerance) {
 341       n1 = -1;
 342       CrosSeg = Standard_True;
 343     }
 344     else return;
 345   }
 346   else {
 347     if      (d2 >  Tolerance)
 348       CrosSeg = Standard_False;
 349     else if (d2 < -Tolerance) return;
 350     else {
 351       CrosSeg = Standard_False;
 352       if (TrFlags & EMskGrALin1) {
 353         pd1 = (PntXP1 - XV1) / da;
 354         pd2 = (PntXP2 - XV1) / da;
 355       }
 356       else {
 357         pd1 = (PntYP1 - YV1) / db;
 358         pd2 = (PntYP2 - YV1) / db;
 359       }
 360       if      (pd1      < -TolParam) nn1 = 1;
 361       else if (pd1      <  TolParam) nn1 = 2;
 362       else if (pd1 - 1. < -TolParam) nn1 = 3;
 363       else if (pd1 - 1. <  TolParam) nn1 = 4;
 364       else                           nn1 = 5;
 365       if      (pd2      < -TolParam) nn2 = 1;
 366       else if (pd2      <  TolParam) nn2 = 2;
 367       else if (pd2 - 1. < -TolParam) nn2 = 3;
 368       else if (pd2 - 1. <  TolParam) nn2 = 4;
 369       else                           nn2 = 5;
 370       if      (nn1 == 3) {
 371         if      (nn2 == 1) pend = pd1 / (pd1 - pd2);
 372         else if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 373       }
 374       else if (nn1 == 1) {
 375         if (nn2 <= 2) return;
 376         else {
 377           psta = - pd1 / (pd2 - pd1);
 378           if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 379         }
 380       }
 381       else if (nn1 == 5) {
 382         if (nn2 >= 4) return;
 383         else {
 384           psta = (pd1 - 1.) / (pd1 - pd2);
 385           if (nn2 == 1) pend = pd1 / (pd1 - pd2);
 386         }
 387       }
 388       else if (nn1 == 2) {
 389         if (nn2 == 1) return;
 390         else if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 391       }
 392       else if (nn1 == 4) {
 393         if (nn2 == 5) return;
 394         else if (nn2 == 1) pend = pd1 / (pd1 - pd2);
 395       }
 396     }
 397   }
 398   if (CrosSeg) {
 399     Standard_Real ad1 = d1;
 400     if (d1 < 0) ad1 = -d1;
 401     Standard_Real ad2 = d2;
 402     if (d2 < 0) ad2 = -d2;
 403     pp = ad1 / ( ad1 + ad2 );
 404     if (TrFlags & EMskGrALin1)
 405       pdp = (PntXP1 + (PntXP2 - PntXP1) * pp - XV1) / da;
 406     else
 407       pdp = (PntYP1 + (PntYP2 - PntYP1) * pp - YV1) / db;
 408     Standard_Boolean OutSideP = Standard_False;
 409     Standard_Boolean Multiple = Standard_False;
 410     if      (pdp      < -TolParam) OutSideP = Standard_True;
 411     else if (pdp      <  TolParam) {
 412       Multiple = Standard_True;
 413
 414       for (l = 0; l <= npi; l++) {
 415         if (m[l]) {
 416           OutSideP = Standard_True;
 417
 418           if (o[l] != (n1 == -1)) {
 419             if (l == 0 && npi == 1) {
 420               p[0] = p[1];
 421               o[0] = o[1];
 422               m[0] = m[1];
 423             }
 424             npi--;
 425             npiRej++;
 426           }
 427         }
 428       }
 429     }
 430     else if (pdp - 1. < -TolParam) {}
 431     else if (pdp - 1. <  TolParam) {
 432       Multiple = Standard_True;
 433
 434       for (l = 0; l <= npi; l++) {
 435         if (m[l]) {
 436           OutSideP = Standard_True;
 437           if (o[l] != (n1 == -1)) {
 438             if (l == 0 && npi == 1) {
 439               p[0] = p[1];
 440               o[0] = o[1];
 441               m[0] = m[1];
 442             }
 443             npi--;
 444             npiRej++;
 445           }
 446         }
 447       }
 448     }
 449     else                           OutSideP = Standard_True;
 450     if (OutSideP) npiRej++;
 451     else {
 452       npi++;
 453       if (npi < 2) {
 454         p[npi] = pp;
 455         o[npi] = n1 == -1;
 456         m[npi] = Multiple;
 457       }
 458 #ifdef OCCT_DEBUG
 459       else if (ERROR) {
 460         cout << " error : HLRAlgo_PolyData::HideByOneTriangle " << endl;
 461         cout << " ( more than 2 points )." << endl;
 462       }
 463 #endif
 464     }
 465   }
 466
 467   da = XV3 - XV2;
 468   db = YV3 - YV2;
 469   a = -db;
 470   b =  da;
 471   c = sqrt(a * a + b * b);
 472   a /= c;
 473   b /= c;
 474   c  = a * XV2  + b * YV2;
 475   d1 = a * PntXP1 + b * PntYP1 - c;
 476   d2 = a * PntXP2 + b * PntYP2 - c;
 477   if      (d1 >  Tolerance) {
 478     if (d2 < -Tolerance) {
 479       n1 =  2;
 480       CrosSeg = Standard_True;
 481     }
 482     else
 483       CrosSeg = Standard_False;
 484   }
 485   else if (d1 < -Tolerance) {
 486     if (d2 >  Tolerance) {
 487       n1 = -1;
 488       CrosSeg = Standard_True;
 489     }
 490     else return;
 491   }
 492   else {
 493     if      (d2 >  Tolerance)
 494       CrosSeg = Standard_False;
 495     else if (d2 < -Tolerance) return;
 496     else {
 497       CrosSeg = Standard_False;
 498       if (TrFlags & EMskGrALin2) {
 499         pd1 = (PntXP1 - XV2) / da;
 500         pd2 = (PntXP2 - XV2) / da;
 501       }
 502       else {
 503         pd1 = (PntYP1 - YV2) / db;
 504         pd2 = (PntYP2 - YV2) / db;
 505       }
 506       if      (pd1      < -TolParam) nn1 = 1;
 507       else if (pd1      <  TolParam) nn1 = 2;
 508       else if (pd1 - 1. < -TolParam) nn1 = 3;
 509       else if (pd1 - 1. <  TolParam) nn1 = 4;
 510       else                           nn1 = 5;
 511       if      (pd2      < -TolParam) nn2 = 1;
 512       else if (pd2      <  TolParam) nn2 = 2;
 513       else if (pd2 - 1. < -TolParam) nn2 = 3;
 514       else if (pd2 - 1. <  TolParam) nn2 = 4;
 515       else                           nn2 = 5;
 516       if      (nn1 == 3) {
 517         if      (nn2 == 1) pend = pd1 / (pd1 - pd2);
 518         else if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 519       }
 520       else if (nn1 == 1) {
 521         if (nn2 <= 2) return;
 522         else {
 523           psta = - pd1 / (pd2 - pd1);
 524           if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 525         }
 526       }
 527       else if (nn1 == 5) {
 528         if (nn2 >= 4) return;
 529         else {
 530           psta = (pd1 - 1.) / (pd1 - pd2);
 531           if (nn2 == 1) pend = pd1 / (pd1 - pd2);
 532         }
 533       }
 534       else if (nn1 == 2) {
 535         if (nn2 == 1) return;
 536         else if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 537       }
 538       else if (nn1 == 4) {
 539         if (nn2 == 5) return;
 540         else if (nn2 == 1) pend = pd1 / (pd1 - pd2);
 541       }
 542     }
 543   }
 544   if (CrosSeg) {
 545     Standard_Real ad1 = d1;
 546     if (d1 < 0) ad1 = -d1;
 547     Standard_Real ad2 = d2;
 548     if (d2 < 0) ad2 = -d2;
 549     pp = ad1 / ( ad1 + ad2 );
 550     if (TrFlags & EMskGrALin2)
 551       pdp = (PntXP1 + (PntXP2 - PntXP1) * pp - XV2) / da;
 552     else
 553       pdp = (PntYP1 + (PntYP2 - PntYP1) * pp - YV2) / db;
 554     Standard_Boolean OutSideP = Standard_False;
 555     Standard_Boolean Multiple = Standard_False;
 556     if      (pdp      < -TolParam) OutSideP = Standard_True;
 557     else if (pdp      <  TolParam) {
 558       Multiple = Standard_True;
 559
 560       for (l = 0; l <= npi; l++) {
 561         if (m[l]) {
 562           OutSideP = Standard_True;
 563           if (o[l] != (n1 == -1)) {
 564             if (l == 0 && npi == 1) {
 565               p[0] = p[1];
 566               o[0] = o[1];
 567               m[0] = m[1];
 568             }
 569             npi--;
 570             npiRej++;
 571           }
 572         }
 573       }
 574     }
 575     else if (pdp - 1. < -TolParam) {}
 576     else if (pdp - 1. <  TolParam) {
 577       Multiple = Standard_True;
 578
 579       for (l = 0; l <= npi; l++) {
 580         if (m[l]) {
 581           OutSideP = Standard_True;
 582           if (o[l] != (n1 == -1)) {
 583             if (l == 0 && npi == 1) {
 584               p[0] = p[1];
 585               o[0] = o[1];
 586               m[0] = m[1];
 587             }
 588             npi--;
 589             npiRej++;
 590           }
 591         }
 592       }
 593     }
 594     else                           OutSideP = Standard_True;
 595     if (OutSideP) npiRej++;
 596     else {
 597       npi++;
 598       if (npi < 2) {
 599         p[npi] = pp;
 600         o[npi] = n1 == -1;
 601         m[npi] = Multiple;
 602       }
 603 #ifdef OCCT_DEBUG
 604       else if (ERROR) {
 605         cout << " error : HLRAlgo_PolyData::HideByOneTriangle " << endl;
 606         cout << " ( more than 2 points )." << endl;
 607       }
 608 #endif
 609     }
 610   }
 611
 612   da = XV1 - XV3;
 613   db = YV1 - YV3;
 614   a = -db;
 615   b =  da;
 616   c = sqrt(a * a + b * b);
 617   a /= c;
 618   b /= c;
 619   c  = a * XV3  + b * YV3;
 620   d1 = a * PntXP1 + b * PntYP1 - c;
 621   d2 = a * PntXP2 + b * PntYP2 - c;
 622   if      (d1 >  Tolerance) {
 623     if (d2 < -Tolerance) {
 624       n1 =  2;
 625       CrosSeg = Standard_True;
 626     }
 627     else
 628       CrosSeg = Standard_False;
 629   }
 630   else if (d1 < -Tolerance) {
 631     if (d2 >  Tolerance) {
 632       n1 = -1;
 633       CrosSeg = Standard_True;
 634     }
 635     else return;
 636   }
 637   else {
 638     if      (d2 >  Tolerance)
 639       CrosSeg = Standard_False;
 640     else if (d2 < -Tolerance) return;
 641     else {
 642       CrosSeg = Standard_False;
 643       if (TrFlags & EMskGrALin3) {
 644         pd1 = (PntXP1 - XV3) / da;
 645         pd2 = (PntXP2 - XV3) / da;
 646       }
 647       else {
 648         pd1 = (PntYP1 - YV3) / db;
 649         pd2 = (PntYP2 - YV3) / db;
 650       }
 651       if      (pd1      < -TolParam) nn1 = 1;
 652       else if (pd1      <  TolParam) nn1 = 2;
 653       else if (pd1 - 1. < -TolParam) nn1 = 3;
 654       else if (pd1 - 1. <  TolParam) nn1 = 4;
 655       else                           nn1 = 5;
 656       if      (pd2      < -TolParam) nn2 = 1;
 657       else if (pd2      <  TolParam) nn2 = 2;
 658       else if (pd2 - 1. < -TolParam) nn2 = 3;
 659       else if (pd2 - 1. <  TolParam) nn2 = 4;
 660       else                           nn2 = 5;
 661       if      (nn1 == 3) {
 662         if      (nn2 == 1) pend = pd1 / (pd1 - pd2);
 663         else if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 664       }
 665       else if (nn1 == 1) {
 666         if (nn2 <= 2) return;
 667         else {
 668           psta = - pd1 / (pd2 - pd1);
 669           if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 670         }
 671       }
 672       else if (nn1 == 5) {
 673         if (nn2 >= 4) return;
 674         else {
 675           psta = (pd1 - 1.) / (pd1 - pd2);
 676           if (nn2 == 1) pend = pd1 / (pd1 - pd2);
 677         }
 678       }
 679       else if (nn1 == 2) {
 680         if (nn2 == 1) return;
 681         else if (nn2 == 5) pend = (1. - pd1) / (pd2 - pd1);
 682       }
 683       else if (nn1 == 4) {
 684         if (nn2 == 5) return;
 685         else if (nn2 == 1) pend = pd1 / (pd1 - pd2);
 686       }
 687     }
 688   }
 689   if (CrosSeg) {
 690     Standard_Real ad1 = d1;
 691     if (d1 < 0) ad1 = -d1;
 692     Standard_Real ad2 = d2;
 693     if (d2 < 0) ad2 = -d2;
 694     pp = ad1 / ( ad1 + ad2 );
 695     if (TrFlags & EMskGrALin3)
 696       pdp = (PntXP1 + (PntXP2 - PntXP1) * pp - XV3) / da;
 697     else
 698       pdp = (PntYP1 + (PntYP2 - PntYP1) * pp - YV3) / db;
 699     Standard_Boolean OutSideP = Standard_False;
 700     Standard_Boolean Multiple = Standard_False;
 701     if      (pdp      < -TolParam) OutSideP = Standard_True;
 702     else if (pdp      <  TolParam) {
 703       Multiple = Standard_True;
 704
 705       for (l = 0; l <= npi; l++) {
 706         if (m[l]) {
 707           OutSideP = Standard_True;
 708           if (o[l] != (n1 == -1)) {
 709             if (l == 0 && npi == 1) {
 710               p[0] = p[1];
 711               o[0] = o[1];
 712               m[0] = m[1];
 713             }
 714             npi--;
 715             npiRej++;
 716           }
 717         }
 718       }
 719     }
 720     else if (pdp - 1. < -TolParam) {}
 721     else if (pdp - 1. <  TolParam) {
 722       Multiple = Standard_True;
 723
 724       for (l = 0; l <= npi; l++) {
 725         if (m[l]) {
 726           OutSideP = Standard_True;
 727           if (o[l] != (n1 == -1)) {
 728             if (l == 0 && npi == 1) {
 729               p[0] = p[1];
 730               o[0] = o[1];
 731               m[0] = m[1];
 732             }
 733             npi--;
 734             npiRej++;
 735           }
 736         }
 737       }
 738     }
 739     else                           OutSideP = Standard_True;
 740     if (OutSideP) npiRej++;
 741     else {
 742       npi++;
 743       if (npi < 2) {
 744         p[npi] = pp;
 745         o[npi] = n1 == -1;
 746         m[npi] = Multiple;
 747       }
 748 #ifdef OCCT_DEBUG
 749       else if (ERROR) {
 750         cout << " error : HLRAlgo_PolyData::HideByOneTriangle " << endl;
 751         cout << " ( more than 2 points )." << endl;
 752       }
 753 #endif
 754     }
 755   }
 756
 757   if (npi == -1) {
 758     if (npiRej >= 2) return;
 759   }
 760   else if (npi == 0) {
 761     if (o[0]) {
 762       psta = p[0];
 763       pend = 1.;
 764     }
 765     else {
 766       psta = 0.;
 767       pend = p[0];
 768     }
 769   }
 770   else if (npi == 1) {
 771     if (p[0] > p[1]) {
 772       psta = p[1];
 773       pend = p[0];
 774     }
 775     else {
 776       psta = p[0];
 777       pend = p[1];
 778     }
 779   }
 780
 781   if (Crossing) {
 782     if (HideBefore) {
 783       if      (Param-psta < TolParam) return;
 784       else if (Param < pend)          pend   = Param;
 785     }
 786     else {
 787       if      (pend-Param < TolParam) return;
 788       else if (psta < Param)          psta   = Param;
 789     }
 790   }
 791
 792   Standard_Boolean total;
 793   if (psta > 0) total = psta <  TolParam;
 794   else          total = psta > -TolParam;
 795   if (total) {
 796     Standard_Real pfin = pend - 1.;
 797     if (pfin > 0) total = pfin <  TolParam;
 798     else          total = pfin > -TolParam;
 799   }
 800   if (total) status.HideAll();
 801   else       status.Hide(psta,(Standard_ShortReal)TolParam,pend,(Standard_ShortReal)TolParam,
 802                          Standard_False,Standard_False);
 803 }