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