0027772: Foundation Classes - define Standard_Boolean using C++ type "bool" instead...
[occt.git] / 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] != (Standard_Boolean)(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] != (Standard_Boolean)(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] != (Standard_Boolean)(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] != (Standard_Boolean)(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] != (Standard_Boolean)(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] != (Standard_Boolean)(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 }