0031939: Coding - correction of spelling errors in comments
[occt.git] / src / Intf / Intf_InterferencePolygonPolyhedron.gxx
1 // Created on: 1992-12-21
2 // Created by: Didier PIFFAULT
3 // Copyright (c) 1992-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 <gp_XYZ.hxx>
18 #include <gp_Vec.hxx>
19 #include <TColStd_ListOfInteger.hxx>
20 #include <TColStd_ListIteratorOfListOfInteger.hxx>
21 #include <Bnd_Box.hxx>
22 #include <Intf_Tool.hxx>
23 #include <Bnd_BoundSortBox.hxx>
24 #include <Intf_Array1OfLin.hxx>
25 #include <Intf_SectionPoint.hxx>
26 #include <Intf_SeqOfSectionPoint.hxx>
27 #include <Intf_TangentZone.hxx>
28 #include <Intf_SeqOfTangentZone.hxx>
29 #include <Intf.hxx>
30
31 #include <Extrema_ExtElC.hxx>
32 #include <Extrema_POnCurv.hxx>
33
34 static const int Pourcent3[4] = {0, 1, 2, 0};
35
36 static Standard_Boolean IsInSegment(const gp_Vec& P1P2,
37                                     const gp_Vec& P1P,
38                                     const Standard_Real NP1P2,
39                                     Standard_Real &Param,
40                                     const Standard_Real Tolerance) { 
41   Param = P1P2.Dot(P1P);
42   Param/= NP1P2;
43   if(Param > (NP1P2+Tolerance))
44     return(Standard_False);
45   if(Param < (-Tolerance))
46     return(Standard_False);
47   Param/=NP1P2;
48   if(Param<0.0) Param=0.0;
49   if(Param>1.0) Param=1.0;
50   return(Standard_True);
51 }
52     
53
54 //=======================================================================
55 //function : Intf_InterferencePolygonPolyhedron
56 //purpose  : Empty constructor
57 //=======================================================================
58
59 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron() 
60 : Intf_Interference (Standard_False),
61   BeginOfClosedPolygon (Standard_False),
62   iLin (0)
63 {} 
64
65 //=======================================================================
66 //function : Intf_InterferencePolygonPolyhedron
67 //purpose  : Construct and compute an interference between a Polygon3d
68 //           and a Polyhedron.
69 //=======================================================================
70
71 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
72   (const Polygon3d& thePolyg, const Polyhedron& thePolyh) 
73 : Intf_Interference (Standard_False),
74   BeginOfClosedPolygon (Standard_False),
75   iLin (0)
76 {
77   Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
78             ToolPolyh::DeflectionOverEstimation(thePolyh);
79   if (Tolerance==0.)
80     Tolerance=Epsilon(1000.);
81
82   if (!ToolPolygon3d::Bounding(thePolyg).IsOut(ToolPolyh::Bounding(thePolyh))) {
83     Interference(thePolyg, thePolyh);
84   }
85
86
87
88 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
89   (const Polygon3d& thePolyg, const Polyhedron& thePolyh,
90    Bnd_BoundSortBox &PolyhGrid) 
91 : Intf_Interference (Standard_False),
92   BeginOfClosedPolygon (Standard_False),
93   iLin (0)
94 {
95   Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
96             ToolPolyh::DeflectionOverEstimation(thePolyh);
97   if (Tolerance==0.)
98     Tolerance=Epsilon(1000.);
99
100   if (!ToolPolygon3d::Bounding(thePolyg).IsOut(ToolPolyh::Bounding(thePolyh))) {
101     Interference(thePolyg, thePolyh,PolyhGrid);
102   }
103
104
105 //=======================================================================
106 //function : Intf_InterferencePolygonPolyhedron
107 //purpose  : Construct and compute an interference between a Straight
108 //           Line and a Polyhedron.
109 //=======================================================================
110
111 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
112   (const gp_Lin& theLin, const Polyhedron& thePolyh) 
113 : Intf_Interference (Standard_False),
114   BeginOfClosedPolygon (Standard_False),
115   iLin (0)
116 {
117   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
118   if (Tolerance==0.)
119     Tolerance=Epsilon(1000.);
120
121   BeginOfClosedPolygon=Standard_False;
122
123   Bnd_BoundSortBox PolyhGrid;
124   PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
125                        ToolPolyh::ComponentsBounding(thePolyh));
126   Standard_Integer indTri;
127
128   iLin=0;
129
130   Bnd_Box bofLin;
131   Intf_Tool btoo;
132   btoo.LinBox(theLin, ToolPolyh::Bounding(thePolyh), bofLin);
133
134   TColStd_ListIteratorOfListOfInteger iCl(PolyhGrid.Compare(bofLin));
135   while (iCl.More()) {
136     indTri=iCl.Value();
137     Intersect
138         (theLin.Location(), 
139          theLin.Location().Translated(gp_Vec(theLin.Direction())),
140          Standard_True, indTri, thePolyh);
141     iCl.Next();
142   }
143 }
144
145
146 //=======================================================================
147 //function : Intf_InterferencePolygonPolyhedron
148 //purpose  : Construct and compute an interference between the Straights
149 //           Lines in <Obje> and the Polyhedron <thePolyh>.
150 //=======================================================================
151
152 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron 
153   (const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh) 
154 : Intf_Interference (Standard_False),
155   BeginOfClosedPolygon (Standard_False),
156   iLin (0)
157 {
158   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
159   if (Tolerance==0.)
160     Tolerance=Epsilon(1000.);
161
162   Bnd_Box bofLin;
163   Intf_Tool bToo;
164   BeginOfClosedPolygon=Standard_False;
165
166   Bnd_BoundSortBox PolyhGrid;
167   PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
168                        ToolPolyh::ComponentsBounding(thePolyh));
169
170   Standard_Integer indTri;
171
172   for (iLin=1; iLin<=theLins.Length(); iLin++) {
173
174
175     bToo.LinBox(theLins(iLin), ToolPolyh::Bounding(thePolyh), bofLin);
176
177     TColStd_ListIteratorOfListOfInteger ilC(PolyhGrid.Compare(bofLin));
178
179     while (ilC.More()) {
180       indTri=ilC.Value();
181       Intersect
182        (theLins(iLin).Location(), 
183         theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
184         Standard_True, indTri, thePolyh);
185       ilC.Next();
186     }
187   }
188 }
189
190
191 //=======================================================================
192 //function : Perform
193 //purpose  : 
194 //=======================================================================
195
196 void Intf_InterferencePolygonPolyhedron::Perform 
197   (const Polygon3d& thePolyg, const Polyhedron& thePolyh) 
198 {
199   SelfInterference(Standard_False);
200   Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
201             ToolPolyh::DeflectionOverEstimation(thePolyh);
202   if (Tolerance==0.)
203     Tolerance=Epsilon(1000.);
204
205   if (!ToolPolygon3d::Bounding(thePolyg).IsOut
206       (ToolPolyh::Bounding(thePolyh))) {
207     Interference(thePolyg, thePolyh);
208   }
209
210
211
212 //=======================================================================
213 //function : Perform
214 //purpose  : 
215 //=======================================================================
216
217 void Intf_InterferencePolygonPolyhedron::Perform 
218   (const gp_Lin& theLin, const Polyhedron& thePolyh) 
219 {
220   SelfInterference(Standard_False);
221   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
222   if (Tolerance==0.)
223     Tolerance=Epsilon(1000.);
224
225   BeginOfClosedPolygon=Standard_False;
226
227   Bnd_BoundSortBox PolyhGrid;
228   PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
229                        ToolPolyh::ComponentsBounding(thePolyh));
230
231   Standard_Integer indTri;
232
233   iLin=0;
234
235   Bnd_Box bofLin;
236   Intf_Tool btoo;
237   btoo.LinBox(theLin, ToolPolyh::Bounding(thePolyh), bofLin);
238
239   TColStd_ListIteratorOfListOfInteger lCi(PolyhGrid.Compare(bofLin));
240   while (lCi.More()) {
241     indTri=lCi.Value();
242     Intersect
243         (theLin.Location(), 
244          theLin.Location().Translated(gp_Vec(theLin.Direction())),
245          Standard_True, indTri, thePolyh);
246     lCi.Next();
247   }
248 }
249
250
251 //=======================================================================
252 //function : Perform
253 //purpose  : Compute an interference between the Straights
254 //           Lines in <Obje> and the Polyhedron <thePolyh>.
255 //=======================================================================
256
257 void Intf_InterferencePolygonPolyhedron::Perform  
258   (const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh) 
259 {
260   SelfInterference(Standard_False);
261   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
262   if (Tolerance==0.)
263     Tolerance=Epsilon(1000.);
264
265   Bnd_Box bofLin;
266   Intf_Tool Btoo;
267   BeginOfClosedPolygon=Standard_False;
268
269   Bnd_BoundSortBox PolyhGrid;
270   PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
271                        ToolPolyh::ComponentsBounding(thePolyh));
272
273   Standard_Integer indTri;
274
275   for (iLin=1; iLin<=theLins.Length(); iLin++) {
276
277     Btoo.LinBox(theLins(iLin), ToolPolyh::Bounding(thePolyh), bofLin);
278
279     TColStd_ListIteratorOfListOfInteger tlC(PolyhGrid.Compare(bofLin));
280
281     while (tlC.More()) {
282       indTri=tlC.Value();
283       Intersect
284        (theLins(iLin).Location(), 
285         theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
286         Standard_True, indTri, thePolyh);
287       tlC.Next();
288     }
289   }
290 }
291
292
293 //=======================================================================
294 //function : Interference
295 //purpose  : Compare the boundings between  the segment of  <Obje>
296 //           and the facets of <thePolyh>.
297 //=======================================================================
298
299 void Intf_InterferencePolygonPolyhedron::Interference 
300   (const Polygon3d& thePolyg, const Polyhedron& thePolyh)
301 {
302
303   Bnd_Box bofSeg;
304
305   Bnd_BoundSortBox PolyhGrid;
306   PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
307                        ToolPolyh::ComponentsBounding(thePolyh));
308
309   Standard_Integer indTri;
310   BeginOfClosedPolygon=ToolPolygon3d::Closed(thePolyg);
311
312   Standard_Real defPh = ToolPolyh::DeflectionOverEstimation(thePolyh);
313
314   for (iLin=1; iLin<=ToolPolygon3d::NbSegments(thePolyg); iLin++) {
315
316     bofSeg.SetVoid();
317     bofSeg.Add(ToolPolygon3d::BeginOfSeg(thePolyg, iLin));
318     bofSeg.Add(ToolPolygon3d::EndOfSeg(thePolyg, iLin));
319     bofSeg.Enlarge(ToolPolygon3d::DeflectionOverEstimation(thePolyg));
320
321     TColStd_ListOfInteger maliste;
322     maliste = PolyhGrid.Compare(bofSeg);
323     TColStd_ListIteratorOfListOfInteger clt(maliste);
324     for (; clt.More(); clt.Next()) {
325       indTri=clt.Value();
326       gp_Pnt p1 = ToolPolygon3d::BeginOfSeg(thePolyg, iLin);
327       gp_Pnt p2 = ToolPolygon3d::EndOfSeg(thePolyg, iLin);
328       Standard_Integer pTri0, pTri1, pTri2;
329       ToolPolyh::Triangle(thePolyh, indTri, pTri0, pTri1, pTri2);
330       gp_Pnt Pa=ToolPolyh::Point(thePolyh, pTri0);
331       gp_Pnt Pb=ToolPolyh::Point(thePolyh, pTri1);
332       gp_Pnt Pc=ToolPolyh::Point(thePolyh, pTri2);
333       gp_Vec PaPb(Pa,Pb);
334       gp_Vec PaPc(Pa,Pc);
335       gp_Vec Normale = PaPb.Crossed(PaPc);
336       Standard_Real Norm_Normale=Normale.Magnitude();
337       if(Norm_Normale<1e-14)
338         continue;
339       Normale.Multiply(defPh/Norm_Normale);
340       gp_Pnt p1m = p1.Translated(-Normale);
341       gp_Pnt p1p = p1.Translated( Normale);
342       gp_Pnt p2m = p2.Translated(-Normale);
343       gp_Pnt p2p = p2.Translated( Normale);
344       Intersect(p1m, 
345                 p2p,
346                 Standard_False, indTri, thePolyh);
347       Intersect(p1p, 
348                 p2m,
349                 Standard_False, indTri, thePolyh);
350 //      Intersect(ToolPolygon3d::BeginOfSeg(thePolyg, iLin), 
351 //              ToolPolygon3d::EndOfSeg(thePolyg, iLin),
352 //              Standard_False, indTri, thePolyh);
353     }
354     BeginOfClosedPolygon=Standard_False;
355   }
356 }
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377 //=======================================================================
378 //function : Intf_InterferencePolygonPolyhedron
379 //purpose  : Construct and compute an interference between a Straight
380 //           Line and a Polyhedron.
381 //=======================================================================
382
383 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
384   (const gp_Lin& theLin, const Polyhedron& thePolyh,
385    Bnd_BoundSortBox &PolyhGrid) 
386 : Intf_Interference(Standard_False)
387 {
388   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
389   if (Tolerance==0.)
390     Tolerance=Epsilon(1000.);
391
392   BeginOfClosedPolygon=Standard_False;
393
394   Standard_Integer indTri;
395
396   iLin=0;
397
398   Bnd_Box bofLin;
399   Intf_Tool btoo;
400   btoo.LinBox(theLin, ToolPolyh::Bounding(thePolyh), bofLin);
401
402   TColStd_ListIteratorOfListOfInteger iCl(PolyhGrid.Compare(bofLin));
403   while (iCl.More()) {
404     indTri=iCl.Value();
405     Intersect
406         (theLin.Location(), 
407          theLin.Location().Translated(gp_Vec(theLin.Direction())),
408          Standard_True, indTri, thePolyh);
409     iCl.Next();
410   }
411 }
412
413
414 //=======================================================================
415 //function : Intf_InterferencePolygonPolyhedron
416 //purpose  : Construct and compute an interference between the Straights
417 //           Lines in <Obje> and the Polyhedron <thePolyh>.
418 //=======================================================================
419
420 Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron 
421   (const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh,
422    Bnd_BoundSortBox &PolyhGrid) 
423 : Intf_Interference(Standard_False)
424 {
425   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
426   if (Tolerance==0.)
427     Tolerance=Epsilon(1000.);
428
429   Bnd_Box bofLin;
430   Intf_Tool bToo;
431   BeginOfClosedPolygon=Standard_False;
432
433   Standard_Integer indTri;
434
435   for (iLin=1; iLin<=theLins.Length(); iLin++) {
436
437
438     bToo.LinBox(theLins(iLin), ToolPolyh::Bounding(thePolyh), bofLin);
439
440     TColStd_ListIteratorOfListOfInteger ilC(PolyhGrid.Compare(bofLin));
441
442     while (ilC.More()) {
443       indTri=ilC.Value();
444       Intersect
445        (theLins(iLin).Location(), 
446         theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
447         Standard_True, indTri, thePolyh);
448       ilC.Next();
449     }
450   }
451 }
452
453
454 //=======================================================================
455 //function : Perform
456 //purpose  : 
457 //=======================================================================
458
459 void Intf_InterferencePolygonPolyhedron::Perform 
460   (const Polygon3d& thePolyg, const Polyhedron& thePolyh,
461    Bnd_BoundSortBox &PolyhGrid) 
462 {
463   SelfInterference(Standard_False);
464   Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
465             ToolPolyh::DeflectionOverEstimation(thePolyh);
466   if (Tolerance==0.)
467     Tolerance=Epsilon(1000.);
468
469   if (!ToolPolygon3d::Bounding(thePolyg).IsOut
470       (ToolPolyh::Bounding(thePolyh))) {
471     Interference(thePolyg, thePolyh,PolyhGrid);
472   }
473
474
475
476 //=======================================================================
477 //function : Perform
478 //purpose  : 
479 //=======================================================================
480
481 void Intf_InterferencePolygonPolyhedron::Perform 
482   (const gp_Lin& theLin, const Polyhedron& thePolyh,
483    Bnd_BoundSortBox &PolyhGrid) 
484 {
485   SelfInterference(Standard_False);
486   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
487   if (Tolerance==0.)
488     Tolerance=Epsilon(1000.);
489
490   BeginOfClosedPolygon=Standard_False;
491
492   Standard_Integer indTri;
493
494   iLin=0;
495
496   Bnd_Box bofLin;
497   Intf_Tool btoo;
498   btoo.LinBox(theLin, ToolPolyh::Bounding(thePolyh), bofLin);
499
500   TColStd_ListIteratorOfListOfInteger lCi(PolyhGrid.Compare(bofLin));
501   while (lCi.More()) {
502     indTri=lCi.Value();
503     Intersect
504         (theLin.Location(), 
505          theLin.Location().Translated(gp_Vec(theLin.Direction())),
506          Standard_True, indTri, thePolyh);
507     lCi.Next();
508   }
509 }
510
511
512 //=======================================================================
513 //function : Perform
514 //purpose  : Compute an interference between the Straights
515 //           Lines in <Obje> and the Polyhedron <thePolyh>.
516 //=======================================================================
517
518 void Intf_InterferencePolygonPolyhedron::Perform  
519   (const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh,
520    Bnd_BoundSortBox &PolyhGrid) 
521 {
522   SelfInterference(Standard_False);
523   Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
524   if (Tolerance==0.)
525     Tolerance=Epsilon(1000.);
526
527   Bnd_Box bofLin;
528   Intf_Tool Btoo;
529   BeginOfClosedPolygon=Standard_False;
530
531   Standard_Integer indTri;
532
533   for (iLin=1; iLin<=theLins.Length(); iLin++) {
534
535     Btoo.LinBox(theLins(iLin), ToolPolyh::Bounding(thePolyh), bofLin);
536
537     TColStd_ListIteratorOfListOfInteger tlC(PolyhGrid.Compare(bofLin));
538
539     while (tlC.More()) {
540       indTri=tlC.Value();
541       Intersect
542        (theLins(iLin).Location(), 
543         theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
544         Standard_True, indTri, thePolyh);
545       tlC.Next();
546     }
547   }
548 }
549
550
551
552 //=======================================================================
553 //function : Interference
554 //purpose  : Compare the boundings between  the segment of  <Obje>
555 //           and the facets of <thePolyh>.
556 //=======================================================================
557
558 void Intf_InterferencePolygonPolyhedron::Interference 
559   (const Polygon3d& thePolyg, const Polyhedron& thePolyh,
560    Bnd_BoundSortBox &PolyhGrid)
561 {
562   Bnd_Box bofSeg;
563
564   Standard_Integer indTri;
565   BeginOfClosedPolygon=ToolPolygon3d::Closed(thePolyg);
566
567   for (iLin=1; iLin<=ToolPolygon3d::NbSegments(thePolyg); iLin++) {
568
569     bofSeg.SetVoid();
570     bofSeg.Add(ToolPolygon3d::BeginOfSeg(thePolyg, iLin));
571     bofSeg.Add(ToolPolygon3d::EndOfSeg(thePolyg, iLin));
572     bofSeg.Enlarge(ToolPolygon3d::DeflectionOverEstimation(thePolyg));
573
574     //  Modified by MKK - Thu Oct  25 12:40:11 2007
575     Standard_Real defPh = ToolPolyh::DeflectionOverEstimation(thePolyh);
576     TColStd_ListOfInteger maliste;
577     maliste = PolyhGrid.Compare(bofSeg);
578     TColStd_ListIteratorOfListOfInteger clt(maliste);
579     //  Modified by MKK - Thu Oct  25 12:40:11 2007 Begin
580     gp_Pnt p1, Beg0;
581     gp_Pnt p2, End0;
582     if ( !maliste.IsEmpty() ) {
583       p1 = ToolPolygon3d::BeginOfSeg(thePolyg, iLin);
584       p2 = ToolPolygon3d::EndOfSeg(thePolyg, iLin);
585       Beg0 = p1;
586       End0 = p2;
587     }
588     //  Modified by MKK - Thu Oct  25 12:40:11 2007 End
589     while (clt.More()) {
590       indTri=clt.Value();
591       //  Modified by MKK - Thu Oct  25 12:40:11 2007 Begin
592
593       Standard_Integer pTri[3];
594       ToolPolyh::Triangle(thePolyh, indTri, pTri[0], pTri[1], pTri[2]);
595       gp_XYZ triNor;                                   // Vecteur normal.
596       Standard_Real triDp = 0.;                        // Distance polaire.
597       
598       Intf::PlaneEquation(ToolPolyh::Point(thePolyh, pTri[0]),
599                           ToolPolyh::Point(thePolyh, pTri[1]),
600                           ToolPolyh::Point(thePolyh, pTri[2]),
601                           triNor, triDp);
602
603       // enlarge boundary segment
604       if ( iLin == 1 ) {
605         gp_XYZ dif = p1.XYZ() - p2.XYZ();
606         Standard_Real dist = dif.Modulus();
607         if ( dist > gp::Resolution() ) {
608           dif /= dist;
609           Standard_Real aCos = dif * triNor;
610           aCos = fabs(aCos);
611           if ( aCos > gp::Resolution() ) {
612             Standard_Real shift = defPh / aCos;
613             Beg0.SetXYZ( p1.XYZ() + dif * shift );
614           }
615         }
616       }
617       else if ( iLin == ToolPolygon3d::NbSegments(thePolyg) ) {
618         gp_XYZ dif = p2.XYZ() - p1.XYZ();
619         Standard_Real dist = dif.Modulus();
620         if ( dist > gp::Resolution() ) {
621           dif /= dist;
622           Standard_Real aCos = dif * triNor;
623           aCos = fabs(aCos);
624           if ( aCos > gp::Resolution() ) {
625             Standard_Real shift = defPh / aCos;
626             End0.SetXYZ( p2.XYZ() + dif * shift );
627           }
628         }
629       }
630       Standard_Real dBegTri=(triNor*Beg0.XYZ())-triDp; // Distance <p1> plane
631       Standard_Real dEndTri=(triNor*End0.XYZ())-triDp; // Distance <p2> plane
632
633       Intersect(Beg0, End0, Standard_False, indTri, thePolyh, triNor, triDp, dBegTri, dEndTri);
634
635       //  Modified by MKK - Thu Oct  25 12:40:11 2007 End
636       clt.Next();
637     }
638     BeginOfClosedPolygon=Standard_False;
639   }
640 }
641
642
643 //=======================================================================
644 //function : Intersect
645 //purpose  : Compute the intersection between the segment or the line 
646 //           and the triangle <TTri>.
647 //=======================================================================
648 #if 0 
649 void Intf_InterferencePolygonPolyhedron::Intersect 
650 (const gp_Pnt& BegO, const gp_Pnt& EndO, const Standard_Boolean Infinite,
651  const Standard_Integer TTri, const Polyhedron& thePolyh)
652 {
653   Standard_Integer pTri0,pTri1,pTri2;
654   ToolPolyh::Triangle(thePolyh, TTri, pTri0, pTri1, pTri2);
655   gp_Pnt Pa=ToolPolyh::Point(thePolyh, pTri0);
656   gp_Pnt Pb=ToolPolyh::Point(thePolyh, pTri1);
657   gp_Pnt Pc=ToolPolyh::Point(thePolyh, pTri2);
658   gp_Vec PaPb(Pa,Pb);
659   gp_Vec PaPc(Pa,Pc);
660   gp_Vec Normale = PaPb.Crossed(PaPc);
661   Standard_Real Norm_Normale=Normale.Magnitude();
662   if(Norm_Normale<1e-14)
663     return;
664   
665   //-- Equation du Plan 
666   Standard_Real A=Normale.X()/Norm_Normale;
667   Standard_Real B=Normale.Y()/Norm_Normale;
668   Standard_Real C=Normale.Z()/Norm_Normale;
669   Standard_Real D=-(A*Pa.X()+B*Pa.Y()+C*Pa.Z());
670   
671   gp_Vec BegOEndO(BegO,EndO);
672   Standard_Real Norm_BegOEndO=BegOEndO.Magnitude();
673   if(Norm_BegOEndO<1e-14) 
674     return;
675   Standard_Real Lx=BegOEndO.X()/Norm_BegOEndO;
676   Standard_Real Ly=BegOEndO.Y()/Norm_BegOEndO;
677   Standard_Real Lz=BegOEndO.Z()/Norm_BegOEndO;
678   
679   Standard_Real Vd=A*Lx+B*Ly+C*Lz;  //-- DirLigne . NormalePlan
680   
681   if(Vd==0) { //-- Droite parallele au plan 
682     return;
683   }
684   
685   
686   //-- Calcul du parametre sur la ligne 
687   Standard_Real t=-(A*BegO.X()+B*BegO.Y()+C*BegO.Z()+D) / Vd;
688   
689   Standard_Real tol=1e-8; //-- Deflection sur le triangle
690   if(t<-tol || t>(Norm_BegOEndO+tol)) { 
691     if(Infinite==Standard_False) {
692       return;
693     }
694   }
695   //-- On a une intersection droite plan 
696   //-- On teste si c est dans le triangle 
697   gp_Pnt PRes(BegO.X()+t*Lx,BegO.Y()+t*Ly,BegO.Z()+t*Lz);
698   
699   Standard_Real AbsA=A; if(AbsA<0) AbsA=-AbsA;
700   Standard_Real AbsB=B; if(AbsB<0) AbsB=-AbsB;
701   Standard_Real AbsC=C; if(AbsC<0) AbsC=-AbsC;
702   
703   Standard_Real Au,Av,Bu,Bv,Cu,Cv,Pu,Pv;
704   if(AbsA>AbsB) { 
705     if(AbsA>AbsC) { 
706       //-- Projeter selon X
707       Au=Pa.Y(); Bu=Pb.Y(); Cu=Pc.Y(); Pu=PRes.Y();
708       Av=Pa.Z(); Bv=Pb.Z(); Cv=Pc.Z(); Pv=PRes.Z();
709     }
710     else { 
711       //-- Projeter selon Z
712       Au=Pa.Y(); Bu=Pb.Y(); Cu=Pc.Y(); Pu=PRes.Y();
713       Av=Pa.X(); Bv=Pb.X(); Cv=Pc.X(); Pv=PRes.X();
714     }
715   }
716   else { 
717     if(AbsB>AbsC) { 
718       //-- projeter selon Y
719       Au=Pa.Z(); Bu=Pb.Z(); Cu=Pc.Z(); Pu=PRes.Z();
720       Av=Pa.X(); Bv=Pb.X(); Cv=Pc.X(); Pv=PRes.X();
721     }
722     else { 
723       //-- projeter selon Z
724       Au=Pa.Y(); Bu=Pb.Y(); Cu=Pc.Y(); Pu=PRes.Y();
725       Av=Pa.X(); Bv=Pb.X(); Cv=Pc.X(); Pv=PRes.X();
726     }
727   }
728
729   Standard_Real ABu=Bu-Au; Standard_Real ABv=Bv-Av;
730   Standard_Real ACu=Cu-Au; Standard_Real ACv=Cv-Av;
731   Standard_Real BCu=Cu-Bu; Standard_Real BCv=Cv-Bv;
732   
733   Standard_Real t1,t2;
734   //-- Test sur AB et C
735   t1=-ABv*Cu + ABu*Cv;
736   t2=-ABv*Pu + ABu*Pv;
737   if(t1<0) { if(t2>0) return; } else { if(t2<0) return; } 
738
739   //-- Test sur AC et B
740   t1=-ACv*Bu + ACu*Bv;
741   t2=-ACv*Pu + ACu*Pv;
742   if(t1<0) { if(t2>0) return; } else { if(t2<0) return; } 
743
744   //-- Test sur BC et A
745   t1=-BCv*Au + BCu*Av;
746   t2=-BCv*Pu + BCu*Pv;
747   if(t1<0) { if(t2>0) return; } else { if(t2<0) return; } 
748
749
750   Intf_SectionPoint SP(PRes,
751                        Intf_EDGE, 
752                        0, 
753                        iLin, //-- !!!!! VARIABLE STATIQUE 
754                        t / Norm_BegOEndO, 
755                        Intf_FACE, 
756                        TTri, 0, 0.,1.);
757   mySPoins.Append(SP);
758 }
759 #else 
760 void Intf_InterferencePolygonPolyhedron::Intersect 
761   (const gp_Pnt& BegO, const gp_Pnt& EndO, const Standard_Boolean Infinite,
762    const Standard_Integer TTri, const Polyhedron& thePolyh)
763 {
764   Intf_PIType typOnG=Intf_EDGE;
765   Standard_Real t;
766   Standard_Integer pTri[3];
767   ToolPolyh::Triangle(thePolyh, TTri, pTri[0], pTri[1], pTri[2]);
768   gp_XYZ triNor;                                   // Vecteur normal.
769   Standard_Real triDp;                             // Distance polaire.
770
771   Intf::PlaneEquation(ToolPolyh::Point(thePolyh, pTri[0]),
772                       ToolPolyh::Point(thePolyh, pTri[1]),
773                       ToolPolyh::Point(thePolyh, pTri[2]),
774                       triNor, triDp);
775
776
777   Standard_Real dBegTri=(triNor*BegO.XYZ())-triDp; // Distance <BegO> plan
778   Standard_Real dEndTri=(triNor*EndO.XYZ())-triDp; // Distance <EndO> plan
779   gp_XYZ segO=EndO.XYZ()-BegO.XYZ();
780   segO.Normalize();
781   Standard_Boolean NoIntersectionWithTriangle = Standard_False;
782
783   Standard_Real param;
784   t = dBegTri-dEndTri;
785   if (t >= 1.e-16 || t<=-1.e-16)  
786     param = dBegTri/t;
787   else param = dBegTri;
788   Standard_Real floatgap=Epsilon(1000.);
789   
790   if (!Infinite) {
791     if (dBegTri<=floatgap && dBegTri>=-floatgap ) {
792       param=0.;typOnG=Intf_VERTEX;
793       if (BeginOfClosedPolygon) 
794         NoIntersectionWithTriangle = Standard_False;
795     }
796     else if (dEndTri<=floatgap && dEndTri>=-floatgap) {
797       param=1.;typOnG=Intf_VERTEX;
798       NoIntersectionWithTriangle = Standard_False;
799     }
800     if (param<0. || param>1.) {
801       NoIntersectionWithTriangle = Standard_True;
802     }
803   }
804   if(NoIntersectionWithTriangle == Standard_False) { 
805     gp_XYZ spLieu=BegO.XYZ()+((EndO.XYZ()-BegO.XYZ())*param);
806     Standard_Real dPiE[3] = { 0.0, 0.0, 0.0 }, dPtPi[3], sigd;
807     Standard_Integer is = 0;
808     Standard_Integer sEdge=-1;
809     Standard_Integer sVertex=-1;
810     Standard_Integer tbreak=0;
811     { //-- is = 0
812       gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[1]).XYZ()-
813                   ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
814       gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
815       dPtPi[0]=vecP.Modulus();
816       if (dPtPi[0]<=floatgap) {
817         sVertex=0;
818         is=0;
819         tbreak=1;
820       }
821       else { 
822         gp_XYZ segT_x_vecP(segT^vecP);
823         Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
824         sigd = segT_x_vecP*triNor;
825         if(sigd>floatgap) 
826           sigd = 1.0;
827         else if(sigd<-floatgap)
828           sigd = -1.0;
829         else {
830           sigd = 0.0;
831         }
832         dPiE[0]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
833         if (dPiE[0]<=floatgap && dPiE[0]>=-floatgap) {
834           sEdge=0;
835           is=0;
836           tbreak=1;
837         }
838       }
839     }
840
841     if(tbreak==0) { //-- is = 1 
842       gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[2]).XYZ()-
843                   ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
844       gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
845       dPtPi[1]=vecP.Modulus();
846       if (dPtPi[1]<=floatgap) {
847         sVertex=1;
848         is=1;
849         tbreak=1;
850       }
851       else { 
852         gp_XYZ segT_x_vecP(segT^vecP);
853         Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
854         sigd = segT_x_vecP*triNor;
855         if(sigd>floatgap) 
856           sigd = 1.0;
857         else if(sigd<-floatgap)
858           sigd = -1.0;
859         else {
860           sigd = 0.0;
861         }
862         dPiE[1]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
863         if (dPiE[1]<=floatgap && dPiE[1]>=-floatgap) {
864           sEdge=1;
865           is=1;
866           tbreak=1;
867         }
868       }
869     }
870     if(tbreak==0) { //-- is = 2
871       gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[0]).XYZ()-
872                   ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
873       gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
874       dPtPi[2]=vecP.Modulus();
875       if (dPtPi[2]<=floatgap) {
876         sVertex=2;
877         is=2;
878       }
879       gp_XYZ segT_x_vecP(segT^vecP);
880       Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
881       sigd = segT_x_vecP*triNor;
882       if(sigd>floatgap) 
883         sigd = 1.0;
884       else if(sigd<-floatgap)
885         sigd = -1.0;
886       else {
887         sigd = 0.0;
888       }
889       dPiE[2]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
890       if (dPiE[2]<=floatgap && dPiE[2]>=-floatgap) {
891         sEdge=2;
892         is=2;
893       }
894     }
895     //-- fin for i=0 to 2
896     // !!cout<<endl;
897     
898     Standard_Integer triCon, pedg;
899     if      (sVertex>-1) {
900       triCon=TTri;
901       pedg=pTri[Pourcent3[sVertex+1]];
902 //--      while (triCon!=0) {
903 //--    ToolPolyh::TriConnex(thePolyh, triCon,pTri[sVertex],pedg,triCon,pedg);
904 //--    //-- if (triCon<TTri) return;
905 //--    if (triCon==TTri) break;
906 //--      }
907       Intf_SectionPoint SP(spLieu,
908                            typOnG, 0, iLin, param, 
909                            Intf_VERTEX, pTri[is], 0, 0.,
910                            1.);
911       mySPoins.Append(SP);
912     }
913     else if (sEdge>-1) {
914       ToolPolyh::TriConnex(thePolyh, TTri, pTri[sEdge], pTri[Pourcent3[sEdge+1]],
915                            triCon, pedg);
916       //-- if (triCon<=TTri) return; ???????????????????? LBR 
917       // !!cout<<" sEdge "<<endl;
918       Intf_SectionPoint SP(spLieu,
919                            typOnG, 0, iLin, param, 
920                            Intf_EDGE, Min(pTri[sEdge], pTri[Pourcent3[sEdge+1]]),
921                            Max(pTri[sEdge], pTri[Pourcent3[sEdge+1]]), 0.,
922                            1.);
923       mySPoins.Append(SP);
924     }
925     else if (dPiE[0]>0. && dPiE[1]>0. && dPiE[2]>0.) {
926       // !!cout<<" 3 Positifs "<<endl;
927       Intf_SectionPoint SP(spLieu,
928                            typOnG, 0, iLin, param, 
929                            Intf_FACE, TTri, 0, 0.,
930                            1.);
931       mySPoins.Append(SP);
932     }
933 //  Modified by Sergey KHROMOV - Fri Dec  7 14:40:11 2001 Begin
934     // Sometimes triangulation doesn't cover whole the face. In this
935     // case it is necessary to take into account the deflection between boundary
936     // isolines of the surface and boundary trianles. Computed value of this
937     // deflection is contained in thePolyh.
938     else {
939       Standard_Integer i;
940
941       for (i = 1; i <= 3; i++) {
942         Standard_Integer indP1 = (i == 3) ? pTri[0] : pTri[i];
943         Standard_Integer indP2 = pTri[i - 1];
944
945         if (ToolPolyh::IsOnBound(thePolyh, indP1, indP2)) {
946           // For boundary line it is necessary to check the border deflection.
947           Standard_Real  Deflection = ToolPolyh::GetBorderDeflection(thePolyh);
948           const gp_Pnt  &BegP       = ToolPolyh::Point(thePolyh, indP1);
949           const gp_Pnt  &EndP       = ToolPolyh::Point(thePolyh, indP2);
950           gp_Vec         VecTri(BegP,EndP);
951           gp_Dir         DirTri(VecTri);
952           gp_Lin         LinTri(BegP,DirTri);
953           gp_Pnt         aPOnE(spLieu);
954           Standard_Real  aDist = LinTri.Distance(aPOnE);
955
956           if (aDist <= Deflection) {
957             gp_Vec        aVLocPOnE(BegP, aPOnE);
958             gp_Vec        aVecDirTri(DirTri);
959             Standard_Real aPar    = aVLocPOnE*aVecDirTri;
960             Standard_Real aMaxPar = VecTri.Magnitude();
961
962             if (aPar >= 0 && aPar <= aMaxPar) {
963               Intf_SectionPoint SP(spLieu,
964                                    typOnG, 0, iLin, param, 
965                                    Intf_FACE, TTri, 0, 0.,
966                                    1.);
967               mySPoins.Append(SP);
968             }
969           }
970         }
971       }
972     }
973 //  Modified by Sergey KHROMOV - Fri Dec  7 14:40:29 2001 End
974   } //---- if(NoIntersectionWithTriangle == Standard_False)
975   
976   //---------------------------------------------------------------------------
977   //-- On teste la distance entre les cotes du triangle et le polygone 
978   //-- 
979   //-- Si cette distance est inferieure a Tolerance, on cree un SP.
980   //--    
981   //-- printf("\nIntf_InterferencePolygPolyh : dBegTri=%g dEndTri=%g Tolerance=%g\n",dBegTri,dEndTri,Tolerance);
982 //  if(Abs(dBegTri) <= Tolerance || Abs(dEndTri) <= Tolerance)
983   {
984     gp_Vec VecPol(BegO,EndO);
985     Standard_Real NVecPol = VecPol.Magnitude();
986     gp_Dir DirPol(VecPol);
987     gp_Lin LinPol(BegO,DirPol);
988     Standard_Real dist2,ParamOnO,ParamOnT;
989     
990     for (Standard_Integer i=0; i<3; i++) {
991       Standard_Integer pTri_ip1pc3 = pTri[Pourcent3[i+1]];
992       Standard_Integer pTri_i      = pTri[i];
993       const gp_Pnt& BegT = ToolPolyh::Point(thePolyh, pTri_ip1pc3);
994       const gp_Pnt& EndT = ToolPolyh::Point(thePolyh, pTri_i);
995       gp_Vec  VecTri(BegT,EndT);
996       Standard_Real NVecTri = VecTri.Magnitude();
997       gp_Dir  DirTri(VecTri);
998       gp_Lin  LinTri(BegT,DirTri);
999       Extrema_ExtElC Extrema(LinPol,LinTri,0.00000001);
1000       if(Extrema.IsDone()) { 
1001         if(Extrema.IsParallel() == Standard_False) { 
1002           if(Extrema.NbExt()) { 
1003             dist2 = Extrema.SquareDistance();
1004             if(dist2<=Tolerance * Tolerance) {
1005               Extrema_POnCurv POnC1,POnC2;
1006               Extrema.Points(1,POnC1,POnC2);
1007               const gp_Pnt& PO = POnC1.Value();
1008               const gp_Pnt& PT = POnC2.Value();
1009               //--cout<<" ** Nouveau "<<dist2<<endl;
1010               if(IsInSegment(VecPol,gp_Vec(BegO,PO),NVecPol,ParamOnO,Tolerance)) {
1011                 if(IsInSegment(VecTri,gp_Vec(BegT,PT),NVecTri,ParamOnT,Tolerance)) {
1012                   //-- cout<<" * "<<endl;
1013                   gp_XYZ spLieu=BegT.XYZ()+((EndT.XYZ()-BegT.XYZ())*param);
1014                   Standard_Integer tmin,tmax;
1015                   if(pTri_i>pTri_ip1pc3) { 
1016                     tmin=pTri_ip1pc3; tmax=pTri_i; 
1017                   }
1018                   else { 
1019                     tmax=pTri_ip1pc3; tmin=pTri_i; 
1020                   }
1021                   Intf_SectionPoint SP(spLieu,
1022                                        typOnG, 0, iLin, ParamOnO, 
1023                                        Intf_EDGE, 
1024                                        tmin, 
1025                                        tmax, 0.,
1026                                        1.);
1027                   mySPoins.Append(SP);
1028                 }
1029               }
1030             }
1031           }
1032         }
1033       }
1034     }
1035   } 
1036 }
1037
1038 #endif
1039
1040 void Intf_InterferencePolygonPolyhedron::Intersect (const gp_Pnt& BegO, 
1041                                                     const gp_Pnt& EndO, 
1042                                                     const Standard_Boolean Infinite,
1043                                                     const Standard_Integer TTri, 
1044                                                     const Polyhedron& thePolyh, 
1045                                                     const gp_XYZ& TriNormal,
1046                                                     const Standard_Real /*TriDp*/, 
1047                                                     const Standard_Real dBegTri, 
1048                                                     const Standard_Real dEndTri)
1049 {
1050   Intf_PIType typOnG=Intf_EDGE;
1051   Standard_Real t;
1052   Standard_Integer pTri[3];
1053   ToolPolyh::Triangle(thePolyh, TTri, pTri[0], pTri[1], pTri[2]);
1054   gp_XYZ triNor = TriNormal;                                   // Vecteur normal.
1055   //Standard_Real triDp = TriDp;                             // Distance polaire.
1056
1057
1058 //   Standard_Real dBegTri=(triNor*BegO.XYZ())-triDp; // Distance <BegO> plan
1059 //   Standard_Real dEndTri=(triNor*EndO.XYZ())-triDp; // Distance <EndO> plan
1060
1061   Standard_Boolean NoIntersectionWithTriangle = Standard_False;
1062
1063   Standard_Real param;
1064   t = dBegTri-dEndTri;
1065   if (t >= 1.e-16 || t<=-1.e-16)  
1066     param = dBegTri/t;
1067   else param = dBegTri;
1068   Standard_Real floatgap=Epsilon(1000.);
1069   
1070   if (!Infinite) {
1071     if (dBegTri<=floatgap && dBegTri>=-floatgap ) {
1072       param=0.;typOnG=Intf_VERTEX;
1073       if (BeginOfClosedPolygon) 
1074         NoIntersectionWithTriangle = Standard_False;
1075     }
1076     else if (dEndTri<=floatgap && dEndTri>=-floatgap) {
1077       param=1.;typOnG=Intf_VERTEX;
1078       NoIntersectionWithTriangle = Standard_False;
1079     }
1080     if (param<0. || param>1.) {
1081       NoIntersectionWithTriangle = Standard_True;
1082     }
1083   }
1084   if(NoIntersectionWithTriangle == Standard_False) { 
1085     gp_XYZ spLieu=BegO.XYZ()+((EndO.XYZ()-BegO.XYZ())*param);
1086     Standard_Real dPiE[3] = { 0.0, 0.0, 0.0 }, dPtPi[3], sigd;
1087     Standard_Integer is = 0;
1088     Standard_Integer sEdge=-1;
1089     Standard_Integer sVertex=-1;
1090     Standard_Integer tbreak=0;
1091     { //-- is = 0
1092       gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[1]).XYZ()-
1093                   ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
1094       gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
1095       dPtPi[0]=vecP.Modulus();
1096       if (dPtPi[0]<=floatgap) {
1097         sVertex=0;
1098         is=0;
1099         tbreak=1;
1100       }
1101       else { 
1102         gp_XYZ segT_x_vecP(segT^vecP);
1103         Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
1104         sigd = segT_x_vecP*triNor;
1105         if(sigd>floatgap) 
1106           sigd = 1.0;
1107         else if(sigd<-floatgap)
1108           sigd = -1.0;
1109         else {
1110           sigd = 0.0;
1111         }
1112         dPiE[0]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
1113         if (dPiE[0]<=floatgap && dPiE[0]>=-floatgap) {
1114           sEdge=0;
1115           is=0;
1116           tbreak=1;
1117         }
1118       }
1119     }
1120     
1121     if(tbreak==0) { //-- is = 1 
1122       gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[2]).XYZ()-
1123                   ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
1124       gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
1125       dPtPi[1]=vecP.Modulus();
1126       if (dPtPi[1]<=floatgap) {
1127         sVertex=1;
1128         is=1;
1129         tbreak=1;
1130       }
1131       else { 
1132         gp_XYZ segT_x_vecP(segT^vecP);
1133         Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
1134         sigd = segT_x_vecP*triNor;
1135         if(sigd>floatgap) 
1136           sigd = 1.0;
1137         else if(sigd<-floatgap)
1138           sigd = -1.0;
1139         else {
1140           sigd = 0.0;
1141         }
1142         dPiE[1]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
1143         if (dPiE[1]<=floatgap && dPiE[1]>=-floatgap) {
1144           sEdge=1;
1145           is=1;
1146           tbreak=1;
1147         }
1148       }
1149     }
1150     if(tbreak==0) { //-- is = 2
1151       gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[0]).XYZ()-
1152                   ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
1153       gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
1154       dPtPi[2]=vecP.Modulus();
1155       if (dPtPi[2]<=floatgap) {
1156         sVertex=2;
1157         is=2;
1158       }
1159       gp_XYZ segT_x_vecP(segT^vecP);
1160       Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
1161       sigd = segT_x_vecP*triNor;
1162       if(sigd>floatgap) 
1163         sigd = 1.0;
1164       else if(sigd<-floatgap)
1165         sigd = -1.0;
1166       else {
1167         sigd = 0.0;
1168       }
1169       dPiE[2]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
1170       if (dPiE[2]<=floatgap && dPiE[2]>=-floatgap) {
1171         sEdge=2;
1172         is=2;
1173       }
1174     }
1175     //-- fin for i=0 to 2
1176     // !!cout<<endl;
1177     
1178     Standard_Integer triCon, pedg;
1179     if      (sVertex>-1) {
1180       triCon=TTri;
1181       pedg=pTri[Pourcent3[sVertex+1]];
1182 //--      while (triCon!=0) {
1183 //--    ToolPolyh::TriConnex(thePolyh, triCon,pTri[sVertex],pedg,triCon,pedg);
1184 //--    //-- if (triCon<TTri) return;
1185 //--    if (triCon==TTri) break;
1186 //--      }
1187       Intf_SectionPoint SP(spLieu,
1188                            typOnG, 0, iLin, param, 
1189                            Intf_VERTEX, pTri[is], 0, 0.,
1190                            1.);
1191       mySPoins.Append(SP);
1192     }
1193     else if (sEdge>-1) {
1194       ToolPolyh::TriConnex(thePolyh, TTri, pTri[sEdge], pTri[Pourcent3[sEdge+1]],
1195                            triCon, pedg);
1196       //-- if (triCon<=TTri) return; ???????????????????? LBR 
1197       // !!cout<<" sEdge "<<endl;
1198       Intf_SectionPoint SP(spLieu,
1199                            typOnG, 0, iLin, param, 
1200                            Intf_EDGE, Min(pTri[sEdge], pTri[Pourcent3[sEdge+1]]),
1201                            Max(pTri[sEdge], pTri[Pourcent3[sEdge+1]]), 0.,
1202                            1.);
1203       mySPoins.Append(SP);
1204     }
1205     else if (dPiE[0]>0. && dPiE[1]>0. && dPiE[2]>0.) {
1206       // !!cout<<" 3 Positifs "<<endl;
1207       Intf_SectionPoint SP(spLieu,
1208                            typOnG, 0, iLin, param, 
1209                            Intf_FACE, TTri, 0, 0.,
1210                            1.);
1211       mySPoins.Append(SP);
1212     }
1213 //  Modified by Sergey KHROMOV - Fri Dec  7 14:40:11 2001 Begin
1214     // Sometimes triangulation doesn't cover whole the face. In this
1215     // case it is necessary to take into account the deflection between boundary
1216     // isolines of the surface and boundary trianles. Computed value of this
1217     // deflection is contained in thePolyh.
1218     else {
1219       Standard_Integer i;
1220
1221       for (i = 1; i <= 3; i++) {
1222         Standard_Integer indP1 = (i == 3) ? pTri[0] : pTri[i];
1223         Standard_Integer indP2 = pTri[i - 1];
1224
1225         if (ToolPolyh::IsOnBound(thePolyh, indP1, indP2)) {
1226           // For boundary line it is necessary to check the border deflection.
1227           Standard_Real  Deflection = ToolPolyh::GetBorderDeflection(thePolyh);
1228           const gp_Pnt  &BegP       = ToolPolyh::Point(thePolyh, indP1);
1229           const gp_Pnt  &EndP       = ToolPolyh::Point(thePolyh, indP2);
1230           gp_Vec         VecTri(BegP,EndP);
1231           gp_Dir         DirTri(VecTri);
1232           gp_Lin         LinTri(BegP,DirTri);
1233           gp_Pnt         aPOnE(spLieu);
1234           Standard_Real  aDist = LinTri.Distance(aPOnE);
1235
1236           if (aDist <= Deflection) {
1237             gp_Vec        aVLocPOnE(BegP, aPOnE);
1238             gp_Vec        aVecDirTri(DirTri);
1239             Standard_Real aPar    = aVLocPOnE*aVecDirTri;
1240             Standard_Real aMaxPar = VecTri.Magnitude();
1241
1242             if (aPar >= 0 && aPar <= aMaxPar) {
1243               Intf_SectionPoint SP(spLieu,
1244                                    typOnG, 0, iLin, param, 
1245                                    Intf_FACE, TTri, 0, 0.,
1246                                    1.);
1247               mySPoins.Append(SP);
1248             }
1249           }
1250         }
1251       }
1252     }
1253 //  Modified by Sergey KHROMOV - Fri Dec  7 14:40:29 2001 End
1254   } //---- if(NoIntersectionWithTriangle == Standard_False)
1255   
1256   //---------------------------------------------------------------------------
1257   //-- On teste la distance entre les cotes du triangle et le polygone 
1258   //-- 
1259   //-- Si cette distance est inferieure a Tolerance, on cree un SP.
1260   //--    
1261   //-- printf("\nIntf_InterferencePolygPolyh : dBegTri=%g dEndTri=%g Tolerance=%g\n",dBegTri,dEndTri,Tolerance);
1262 //  if (Abs(dBegTri) <= Tolerance || Abs(dEndTri) <= Tolerance)
1263   {
1264     gp_Vec VecPol(BegO,EndO);
1265     Standard_Real NVecPol = VecPol.Magnitude();
1266     gp_Dir DirPol(VecPol);
1267     gp_Lin LinPol(BegO,DirPol);
1268     Standard_Real dist2,ParamOnO,ParamOnT;
1269     
1270     for (Standard_Integer i=0; i<3; i++) {
1271       Standard_Integer pTri_ip1pc3 = pTri[Pourcent3[i+1]];
1272       Standard_Integer pTri_i      = pTri[i];
1273       const gp_Pnt& BegT = ToolPolyh::Point(thePolyh, pTri_ip1pc3);
1274       const gp_Pnt& EndT = ToolPolyh::Point(thePolyh, pTri_i);
1275       gp_Vec  VecTri(BegT,EndT);
1276       Standard_Real NVecTri = VecTri.Magnitude();
1277       gp_Dir  DirTri(VecTri);
1278       gp_Lin  LinTri(BegT,DirTri);
1279       Extrema_ExtElC Extrema(LinPol,LinTri,0.00000001);
1280       if(Extrema.IsDone()) { 
1281         if(Extrema.IsParallel() == Standard_False) { 
1282           if(Extrema.NbExt()) { 
1283             dist2 = Extrema.SquareDistance();
1284             if(dist2<=Tolerance * Tolerance) {
1285               Extrema_POnCurv POnC1,POnC2;
1286               Extrema.Points(1,POnC1,POnC2);
1287               const gp_Pnt& PO = POnC1.Value();
1288               const gp_Pnt& PT = POnC2.Value();
1289               //--cout<<" ** Nouveau "<<dist2<<endl;
1290               if(IsInSegment(VecPol,gp_Vec(BegO,PO),NVecPol,ParamOnO,Tolerance)) {
1291                 if(IsInSegment(VecTri,gp_Vec(BegT,PT),NVecTri,ParamOnT,Tolerance)) {
1292                   //-- cout<<" * "<<endl;
1293                   gp_XYZ spLieu=BegT.XYZ()+((EndT.XYZ()-BegT.XYZ())*param);
1294                   Standard_Integer tmin,tmax;
1295                   if(pTri_i>pTri_ip1pc3) { 
1296                     tmin=pTri_ip1pc3; tmax=pTri_i; 
1297                   }
1298                   else { 
1299                     tmax=pTri_ip1pc3; tmin=pTri_i; 
1300                   }
1301                   Intf_SectionPoint SP(spLieu,
1302                                        typOnG, 0, iLin, ParamOnO, 
1303                                        Intf_EDGE, 
1304                                        tmin, 
1305                                        tmax, 0.,
1306                                        1.);
1307                   mySPoins.Append(SP);
1308                 }
1309               }
1310             }
1311           }
1312         }
1313       }
1314     }
1315   } 
1316 }