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