0031939: Coding - correction of spelling errors in comments
[occt.git] / src / Intf / Intf_InterferencePolygon2d.cxx
1 // Created on: 1991-06-24
2 // Created by: Didier PIFFAULT
3 // Copyright (c) -1999 Matra Datavision
4 // Copyright (c) 1991-1999 Matra Datavision
5 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 //
7 // This file is part of Open CASCADE Technology software library.
8 //
9 // This library is free software; you can redistribute it and/or modify it under
10 // the terms of the GNU Lesser General Public License version 2.1 as published
11 // by the Free Software Foundation, with special exception defined in the file
12 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
13 // distribution for complete text of the license and disclaimer of any warranty.
14 //
15 // Alternatively, this file may be used under the terms of Open CASCADE
16 // commercial license or contractual agreement.
17
18
19 #include <Bnd_Box2d.hxx>
20 #include <gp_Pnt2d.hxx>
21 #include <Intf_InterferencePolygon2d.hxx>
22 #include <Intf_Polygon2d.hxx>
23 #include <Intf_SectionPoint.hxx>
24 #include <Intf_SeqOfSectionPoint.hxx>
25 #include <Intf_SeqOfTangentZone.hxx>
26 #include <Intf_TangentZone.hxx>
27 #include <Precision.hxx>
28 #include <Standard_OutOfRange.hxx>
29 #include <TColStd_ListOfInteger.hxx>
30
31 // Angular precision (sinus) below that value two right segments
32 // are considered as having a potential zone of tangency.
33 namespace
34 {
35   static const Standard_Real PRCANG = Precision::Angular();
36 }
37
38 //=======================================================================
39 //function : Intf_InterferencePolygon2d
40 //purpose  : constructor empty
41 //=======================================================================
42
43 Intf_InterferencePolygon2d::Intf_InterferencePolygon2d()
44 : Intf_Interference (Standard_False),
45   oClos (Standard_False),
46   tClos (Standard_False),
47   nbso (0)
48 {}
49
50 //=======================================================================
51 //function : Intf_InterferencePolygon2d
52 //purpose  : Constructor of the interference between two Polygon.
53 //=======================================================================
54
55 Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
56   (const Intf_Polygon2d& Obje1, const Intf_Polygon2d& Obje2)
57 : Intf_Interference (Standard_False),
58   oClos (Standard_False),
59   tClos (Standard_False),
60   nbso (0)
61 {
62   if (!Obje1.Bounding().IsOut(Obje2.Bounding())) {
63     Tolerance=Obje1.DeflectionOverEstimation()+
64               Obje2.DeflectionOverEstimation();
65     if (Tolerance==0.)
66       Tolerance=Epsilon(1000.);
67     nbso=Obje1.NbSegments();
68     oClos=Obje1.Closed();
69     tClos=Obje2.Closed();
70     Interference(Obje1, Obje2);
71     Clean();
72   }
73 }
74
75
76 //=======================================================================
77 //function : Intf_InterferencePolygon2d
78 //purpose  : Constructor of the auto interference of a Polygon.
79 //=======================================================================
80
81 Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
82   (const Intf_Polygon2d& Obje)
83 : Intf_Interference (Standard_True),
84   oClos (Standard_False),
85   tClos (Standard_False),
86   nbso (0)
87 {
88   Tolerance=Obje.DeflectionOverEstimation()*2;
89   if (Tolerance==0.)
90     Tolerance=Epsilon(1000.);
91   oClos=Obje.Closed();
92   tClos=oClos;
93   Interference(Obje);
94   Clean();
95 }
96
97 //=======================================================================
98 //function : Perform
99 //purpose  : 
100 //=======================================================================
101
102 void Intf_InterferencePolygon2d::Perform
103   (const Intf_Polygon2d& Obje1, const Intf_Polygon2d& Obje2)
104 {
105   SelfInterference(Standard_False);
106   if (!Obje1.Bounding().IsOut(Obje2.Bounding())) {
107     Tolerance=Obje1.DeflectionOverEstimation()+
108               Obje2.DeflectionOverEstimation();
109     if (Tolerance==0.)
110       Tolerance=Epsilon(1000.);
111     nbso=Obje1.NbSegments();
112     oClos=Obje1.Closed();
113     tClos=Obje2.Closed();
114     Interference(Obje1, Obje2);
115     Clean();
116   }
117 }
118
119 //=======================================================================
120 //function : Perform
121 //purpose  : 
122 //=======================================================================
123
124 void Intf_InterferencePolygon2d::Perform 
125   (const Intf_Polygon2d& Obje)
126 {
127   SelfInterference(Standard_True);
128   Tolerance=Obje.DeflectionOverEstimation()*2;
129   if (Tolerance==0.)
130     Tolerance=Epsilon(1000.);
131   oClos=Obje.Closed();
132   tClos=oClos;
133   Interference(Obje);
134   Clean();
135 }
136
137 //=======================================================================
138 //function : Pnt2dValue
139 //purpose  : Give the section point of range Index in the interference.
140 //=======================================================================
141
142 gp_Pnt2d Intf_InterferencePolygon2d::Pnt2dValue
143   (const Standard_Integer Index) const
144 {
145   return gp_Pnt2d((mySPoins(Index)).Pnt().X(),
146                   (mySPoins(Index)).Pnt().Y());
147 }
148
149
150 //=======================================================================
151 //function : Interference
152 //purpose  : 
153 //=======================================================================
154
155 void Intf_InterferencePolygon2d::Interference
156   (const Intf_Polygon2d& Obje1,
157    const Intf_Polygon2d& Obje2)
158 {
159   Bnd_Box2d bSO;
160   Bnd_Box2d bST;
161
162   Standard_Integer iObje1, iObje2, n1 = nbso, n2 = Obje2.NbSegments();
163   Standard_Real d1 = Obje1.DeflectionOverEstimation(),
164     d2 = Obje2.DeflectionOverEstimation();
165
166   gp_Pnt2d p1b, p1e, p2b, p2e;
167   for (iObje1=1; iObje1<=n1; iObje1++)
168   {
169     bSO.SetVoid();
170     Obje1.Segment(iObje1,p1b,p1e);
171     bSO.Add(p1b);
172     bSO.Add(p1e);
173     bSO.Enlarge(d1);
174     if (!Obje2.Bounding().IsOut(bSO)) {
175       for (iObje2=1; iObje2<=n2; iObje2++) {
176         bST.SetVoid();
177         Obje2.Segment(iObje2,p2b,p2e);
178         bST.Add(p2b);
179         bST.Add(p2e);
180         bST.Enlarge(d2);
181         if (!bSO.IsOut(bST))
182           Intersect(iObje1, iObje2, p1b, p1e, p2b, p2e);
183       }
184     }
185   }
186 }
187
188 //=======================================================================
189 //function : Interference
190 //purpose  : 
191 //=======================================================================
192
193 void Intf_InterferencePolygon2d::Interference
194   (const Intf_Polygon2d& Obje)
195 {
196   Bnd_Box2d bSO;
197   Bnd_Box2d bST;
198
199   Standard_Integer iObje1, iObje2, n = Obje.NbSegments();
200   Standard_Real d = Obje.DeflectionOverEstimation();
201
202   gp_Pnt2d p1b, p1e, p2b, p2e;
203   for (iObje1=1; iObje1<=n; iObje1++) {
204     bSO.SetVoid();
205     Obje.Segment(iObje1,p1b,p1e);
206     bSO.Add(p1b);
207     bSO.Add(p1e);
208     bSO.Enlarge(d);
209     if (!Obje.Bounding().IsOut(bSO)) {
210       for (iObje2=iObje1+1;iObje2<=n;iObje2++){
211         bST.SetVoid();
212         Obje.Segment(iObje2,p2b,p2e);
213         bST.Add(p2b);
214         bST.Add(p2e);
215         bST.Enlarge(d);
216         if (!bSO.IsOut(bST))
217           Intersect(iObje1, iObje2, p1b, p1e, p2b, p2e);
218       }
219     }
220   }
221 }
222
223
224 //=======================================================================
225 //function : Clean
226 //purpose  : 
227 //=======================================================================
228
229 void Intf_InterferencePolygon2d::Clean()
230 {
231
232 // The zones of tangency that concerns only one couple of segments are
233 // conserved if the angle between the segments is less than <PRCANG> and
234 // if there is no real point of intersection EDGE/EDGE:
235   Standard_Integer nbIt=myTZones.Length();
236   Standard_Integer decal=0;
237   Standard_Integer addr1, addr2;
238   Intf_PIType      dim1, dim2;
239   Standard_Real    par;
240   Standard_Integer tsp, tsps;
241   Standard_Integer lpi, ltz;
242   Standard_Boolean Only1Seg=Standard_False;
243
244 #define PI1 (myTZones(ltz-decal).GetPoint(lpi))
245 #define PI2 (myTZones(ltz-decal).GetPoint(tsp))
246
247   for (ltz=1; ltz<=nbIt; ltz++) {
248     tsp=tsps=0;
249     Standard_Real pr1mi,pr1ma,pr2mi,pr2ma,delta1,delta2;
250     myTZones(ltz-decal).ParamOnFirst(pr1mi,pr1ma);
251     delta1=pr1ma-pr1mi;
252     myTZones(ltz-decal).ParamOnSecond(pr2mi,pr2ma);
253     delta2=pr2ma-pr2mi;
254     if (delta1<1. && delta2<1.) Only1Seg=Standard_True;
255     if (delta1==0. || delta2==0.) Only1Seg=Standard_True;
256
257     for (lpi=1; lpi<=myTZones(ltz-decal).NumberOfPoints(); lpi++) {
258       if (PI1.Incidence()<=PRCANG) {tsp=tsps=0;break;}
259       PI1.InfoFirst(dim1,addr1,par);
260       PI1.InfoSecond(dim2,addr2,par);
261       if (dim1==Intf_EDGE && dim2==Intf_EDGE) {
262         tsps=0;
263         if (tsp>0) {
264           tsp=0;
265           Only1Seg=Standard_False;
266           break;
267         }
268         tsp=lpi;
269       }
270       else if (dim1!=Intf_EXTERNAL && dim2!=Intf_EXTERNAL) {
271         tsps=lpi;
272       }
273     }
274     if (tsp>0) {
275       mySPoins.Append(myTZones(ltz-decal).GetPoint(tsp));
276       myTZones.Remove(ltz-decal);
277       decal++;
278     }
279     else if (Only1Seg && tsps!=0) {
280       mySPoins.Append(myTZones(ltz-decal).GetPoint(tsps));
281       myTZones.Remove(ltz-decal);
282       decal++;
283     }
284   }
285
286
287 // The points of intersection located in the tangency zone are
288 // removed from the list :
289   nbIt=mySPoins.Length();
290   decal=0;
291
292   for (lpi=1; lpi<=nbIt; lpi++) {
293     for (ltz=1; ltz<=myTZones.Length(); ltz++) {
294       if (myTZones(ltz).RangeContains(mySPoins(lpi-decal))) {
295         mySPoins.Remove(lpi-decal);
296         decal++;
297         break;
298       }
299     }
300   }
301 }
302
303
304 //=======================================================================
305 //function : Intersect
306 //purpose  : 
307 //=======================================================================
308
309 void Intf_InterferencePolygon2d::Intersect
310   (const Standard_Integer iObje1, const Standard_Integer iObje2,
311    const gp_Pnt2d& BegO, const gp_Pnt2d& EndO,
312    const gp_Pnt2d& BegT, const gp_Pnt2d& EndT)
313 {
314   if(SelfIntf) { 
315     if(Abs(iObje1-iObje2)<=1) return;  //-- Ajout du 15 jan 98 
316   }
317
318   Standard_Integer nbpi=0;
319   Standard_Real parO[8];
320   Standard_Real parT[8];
321   Intf_SeqOfSectionPoint thePi;
322   gp_XY segT =EndT.XY()-BegT.XY();
323   gp_XY segO =EndO.XY()-BegO.XY();
324
325 // If the length of segment is zero, nothing is done
326   Standard_Real lgT =Sqrt(segT*segT);
327   if (lgT<=0.) return;
328   Standard_Real lgO =Sqrt(segO*segO);
329   if (lgO<=0.) return;
330
331 // Direction of parsing of segments
332   Standard_Real sigPS=(segO*segT)>0.0 ? 1.0 : -1.0;
333
334 // Precision of calculation
335   Standard_Real floatgap=Epsilon(lgO+lgT);
336
337 // Angle between two straight lines and radius of interference
338   Standard_Real sinTeta=(segO.CrossMagnitude(segT)/lgO)/lgT;
339   Standard_Real rayIntf=0.;
340   if (sinTeta>0.) rayIntf=Tolerance/sinTeta;
341           
342 // Interference <begO> <segT>
343   Standard_Real dbOT=((BegO.XY()-BegT.XY())^segT)/lgT;
344   Standard_Real dbObT=BegO.Distance(BegT);
345   Standard_Real dbOeT=BegO.Distance(EndT);
346   if (Abs(dbOT)<=Tolerance) {
347     if (dbObT<=Tolerance) {
348       nbpi++;
349       parO[nbpi]=0.;parT[nbpi]=0.;
350       thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
351                                      Intf_VERTEX,iObje2,0.,sinTeta));
352     }
353     if (dbOeT<=Tolerance) {
354       nbpi++;
355       parO[nbpi]=0.;parT[nbpi]=1.;
356       thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
357                                      Intf_VERTEX,iObje2+1,0.,sinTeta));
358     }
359     if (dbObT>Tolerance && dbOeT>Tolerance &&
360         dbObT+dbOeT<=(lgT+Tolerance)) {
361       nbpi++;
362       parO[nbpi]=0.;parT[nbpi]=dbObT/lgT;
363       thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
364                                      Intf_EDGE,iObje2,parT[nbpi],sinTeta));
365     }
366   }
367   
368 // Interference <endO> <segT>
369   Standard_Real deOT=((EndO.XY()-BegT.XY())^segT)/lgT;
370   Standard_Real deObT=EndO.Distance(BegT);
371   Standard_Real deOeT=EndO.Distance(EndT);
372   if (Abs(deOT)<=Tolerance) {
373     if (deObT<=Tolerance) {
374       nbpi++;
375       parO[nbpi]=1.;parT[nbpi]=0.;
376       thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
377                                      Intf_VERTEX,iObje2,0.,sinTeta));
378     }
379     if (deOeT<=Tolerance) {
380       nbpi++;
381       parO[nbpi]=1.;parT[nbpi]=1.;
382       thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
383                                      Intf_VERTEX,iObje2+1,0.,sinTeta));
384     }
385     if (deObT>Tolerance && deOeT>Tolerance &&
386         deObT+deOeT<=(lgT+Tolerance)) {
387       nbpi++;
388       parO[nbpi]=1.;parT[nbpi]=deObT/lgT;
389       thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
390                                      Intf_EDGE,iObje2,parT[nbpi],sinTeta));
391     }
392   }
393   
394 // Interference <begT> <segO>
395   Standard_Real dbTO=((BegT.XY()-BegO.XY())^segO)/lgO;
396   if (Abs(dbTO)<=Tolerance) {
397     if (dbObT>Tolerance && deObT>Tolerance &&
398         dbObT+deObT<=(lgO+Tolerance)) {
399       nbpi++;
400       parO[nbpi]=dbObT/lgO;parT[nbpi]=0.;
401       thePi.Append(Intf_SectionPoint(BegT,Intf_EDGE,iObje1,parO[nbpi],
402                                      Intf_VERTEX,iObje2,0.,sinTeta));
403     }
404   }
405
406 // Interference <endT> <segO>
407   Standard_Real deTO=((EndT.XY()-BegO.XY())^segO)/lgO;
408   if (Abs(deTO)<=Tolerance) {
409     if (dbOeT>Tolerance && deOeT>Tolerance &&
410         dbOeT+deOeT<=(lgO+Tolerance)) {
411       nbpi++;
412       parO[nbpi]=dbOeT/lgO;parT[nbpi]=1.;
413       thePi.Append(Intf_SectionPoint(EndT,Intf_EDGE,iObje1,parO[nbpi],
414                                      Intf_VERTEX,iObje2+1,0.,sinTeta));
415     }
416   }
417
418   Standard_Boolean edgeSP=Standard_False;
419   Standard_Real parOSP=0, parTSP=0;
420
421   if (Abs(dbOT-deOT)>floatgap && Abs(dbTO-deTO)>floatgap) {
422     parOSP=dbOT/(dbOT-deOT);
423     parTSP=dbTO/(dbTO-deTO);
424     if (dbOT*deOT<=0. && dbTO*deTO<=0.) {
425       edgeSP=Standard_True;
426     }
427     else if (nbpi==0) return;
428
429 // If there is no interference it is necessary to take the points segment by segment
430     if (nbpi==0 && sinTeta>PRCANG) {
431       nbpi++;
432       parO[nbpi]=parOSP;
433       parT[nbpi]=parTSP;
434       thePi.Append(Intf_SectionPoint(gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
435                                                BegO.Y()+ (segO.Y()*parOSP)),
436                                      Intf_EDGE,iObje1,parOSP,
437                                      Intf_EDGE,iObje2,parTSP,sinTeta));
438     }
439
440 // Otherwise it is required to check if there is no other
441     else if (rayIntf>=Tolerance) {
442       Standard_Real deltaO=rayIntf/lgO;
443       Standard_Real deltaT=rayIntf/lgT;
444       Standard_Real x, y;
445       Standard_Real parOdeb=parOSP-deltaO;
446       Standard_Real parOfin=parOSP+deltaO;
447       Standard_Real parTdeb=parTSP-sigPS*deltaT;
448       Standard_Real parTfin=parTSP+sigPS*deltaT;
449       if (nbpi==0) {
450         parO[1]=parOdeb;
451         parO[2]=parOfin;
452         parT[1]=parTdeb;
453         parT[2]=parTfin;
454         while (nbpi<2) {
455           nbpi++;
456           x=BegO.X()+ (segO.X()*parO[nbpi]);
457           y=BegO.Y()+ (segO.Y()*parO[nbpi]);
458           thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
459                                          Intf_EXTERNAL, iObje1, parO[nbpi],
460                                          Intf_EXTERNAL, iObje2, parT[nbpi],
461                                          sinTeta));
462         }
463       }
464       else {  //nbpi>0
465         if (nbpi==1) {
466           Standard_Boolean ok=Standard_True;
467           if (0.<parOdeb && parOdeb<1. && 0.<parTdeb && parTdeb<1. ) {
468             parO[nbpi+1]=parOdeb;
469             parT[nbpi+1]=parTdeb;
470           }
471           else if (0.<parOfin && parOfin<1. && 0.<parTfin && parTfin<1. ) {
472             parO[nbpi+1]= parOfin;
473             parT[nbpi+1]= parTfin;
474           }
475           else {
476             ok=Standard_False;
477           }
478
479           if (ok) {
480             x=BegO.X()+ (segO.X()*parO[nbpi+1]);
481             y=BegO.Y()+ (segO.Y()*parO[nbpi+1]);
482             if (thePi(1).Pnt().Distance(gp_Pnt(x, y, 0)) >= (Tolerance/4.)) {
483               nbpi++;
484               thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
485                                              Intf_EXTERNAL, iObje1, parO[nbpi],
486                                              Intf_EXTERNAL, iObje2, parT[nbpi],
487                                              sinTeta));
488             }
489           }
490         }
491         else { // plus d une singularite
492           Standard_Real parOmin=parO[1];
493           Standard_Real parOmax=parO[1];
494           Standard_Real parTmin=parT[1];
495           Standard_Real parTmax=parT[1];
496           for (Standard_Integer i=2; i<=nbpi; i++) {
497             parOmin=Min(parOmin, parO[i]);
498             parOmax=Max(parOmax, parO[i]);
499             parTmin=Min(parTmin, parT[i]);
500             parTmax=Max(parTmax, parT[i]);
501           }
502
503           Standard_Real    delta;
504           if (parOdeb<0.) {
505             delta=-parOdeb;
506             parOdeb=0.;
507             parTdeb=parTdeb+sigPS*(delta*(deltaT/deltaO));
508           }
509           if (parOfin>1.) {
510             delta=parOfin-1.;
511             parOfin=1.;
512             parTfin=parTfin-sigPS*(delta*(deltaT/deltaO));
513           }
514           if (sigPS>0.) {
515             if (parTdeb<0.) {
516               delta=-parTdeb;
517               parTdeb=0.;
518               parOdeb=parOdeb+delta*(deltaO/deltaT);
519             }
520             if (parTfin>1.) {
521               delta=parTfin-1.;
522               parTfin=1.;
523               parOfin=parOfin-delta*(deltaO/deltaT);
524             }
525           }
526           else {
527             if (parTdeb>1.) {
528               delta=parTdeb-1.;
529               parTdeb=1.;
530               parOdeb=parOdeb+delta*(deltaO/deltaT);
531             }
532             if (parTfin<0.) {
533               delta=-parTfin;
534               parTfin=0.;
535               parOfin=parOfin-delta*(deltaO/deltaT);
536             }
537           }
538
539           if ((parOdeb<parOmin && parOmin>0.) || 
540               (sigPS>0. && parTdeb<parTmin && parTmin>0.) || 
541               (sigPS<0. && parTdeb>parTmax && parTmax<1.)) {
542             nbpi++;
543             parO[nbpi]=Max(0., Min(1., parOdeb));
544             parT[nbpi]=Max(0., Min(1., parTdeb));
545             x=BegO.X()+ (segO.X()*parO[nbpi]);
546             y=BegO.Y()+ (segO.Y()*parO[nbpi]);
547             thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
548                                            Intf_EXTERNAL, iObje1, parO[nbpi],
549                                            Intf_EXTERNAL, iObje2, parT[nbpi],
550                                            sinTeta));
551           }
552
553           if ((parOfin>parOmax && parOmax<1.) || 
554               (sigPS<0. && parTfin<parTmin && parTmin>0.) || 
555               (sigPS>0. && parTfin>parTmax && parTmax<1.)) {
556             nbpi++;
557             parO[nbpi]=Min(1., Max(0., parOfin));
558             parT[nbpi]=Min(1., Max(0., parTfin));
559             x=BegO.X()+ (segO.X()*parO[nbpi]);
560             y=BegO.Y()+ (segO.Y()*parO[nbpi]);
561             thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
562                                            Intf_EXTERNAL, iObje1, parO[nbpi],
563                                            Intf_EXTERNAL, iObje2, parT[nbpi],
564                                            sinTeta));
565           }
566         }
567       }
568     }
569   }
570   
571   //-- lbr : The points too close to each other are suspended
572   Standard_Boolean suppr;
573   do { 
574     suppr=Standard_False;
575     for(Standard_Integer i=2; suppr==Standard_False && i<=nbpi; i++) { 
576       const gp_Pnt& Pim1 = thePi(i-1).Pnt();
577       const gp_Pnt& Pi   = thePi(i).Pnt();
578       Standard_Real d=Pi.Distance(Pim1);
579       d*=50.0;
580       if(d<lgT && d<lgO) { 
581         for(Standard_Integer j=i; j<nbpi; j++) { 
582           thePi(j)=thePi(j+1);
583         }
584         nbpi--;
585         suppr=Standard_True;
586       }
587     }
588   }
589   while(suppr==Standard_True);
590   
591   
592
593
594
595   
596   if (nbpi==1) {
597     if (edgeSP) {
598       thePi(1)=Intf_SectionPoint(gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
599                                            BegO.Y()+ (segO.Y()*parOSP)),
600                                  Intf_EDGE,iObje1,parOSP,
601                                  Intf_EDGE,iObje2,parTSP,sinTeta);
602       parO[1]=parOSP;
603       parT[1]=parTSP;
604     }
605     if (!SelfIntf) {
606       Standard_Boolean contains = Standard_False;
607       for (Standard_Integer i = 1; i <= mySPoins.Length(); i++)
608         if (thePi(1).IsEqual(mySPoins(i))) {
609           contains = Standard_True;
610           break;
611         }
612       if (!contains)
613         mySPoins.Append(thePi(1));
614     }
615     else if (iObje2-iObje1!=1 && 
616              (!oClos || (iObje1!=1 && iObje2!=nbso))) {
617       mySPoins.Append(thePi(1));
618     }
619   }
620
621   else if (nbpi>=2) {
622     Intf_TangentZone TheTZ;
623     if (nbpi==2) {
624       TheTZ.PolygonInsert(thePi(1));
625       TheTZ.PolygonInsert(thePi(2));
626     }
627     else {
628       Standard_Integer lpj;
629       Standard_Integer lmin=1;
630       Standard_Integer lmax=1;
631       for (lpj=2; lpj<=nbpi; lpj++) {
632         if      (parO[lpj]<parO[lmin]) lmin=lpj;
633         else if (parO[lpj]>parO[lmax]) lmax=lpj;
634       }
635       TheTZ.PolygonInsert(thePi(lmin));
636       TheTZ.PolygonInsert(thePi(lmax));
637
638       Standard_Integer ltmin=1;
639       Standard_Integer ltmax=1;
640       for (lpj=2; lpj<=nbpi; lpj++) {
641         if      (parT[lpj]<parT[ltmin]) ltmin=lpj;
642         else if (parT[lpj]>parT[ltmax]) ltmax=lpj;
643       }
644       if (ltmin!=lmin && ltmin!=lmax) TheTZ.PolygonInsert(thePi(ltmin));
645       if (ltmax!=lmin && ltmax!=lmax) TheTZ.PolygonInsert(thePi(ltmax));
646     }
647     
648     if (edgeSP) TheTZ.PolygonInsert(Intf_SectionPoint
649                                     (gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
650                                                BegO.Y()+ (segO.Y()*parOSP)),
651                                      Intf_EDGE,iObje1,parOSP,
652                                      Intf_EDGE,iObje2,parTSP,sinTeta));
653
654     Standard_Integer nbtz=myTZones.Length();
655 #if 0 
656     Standard_Integer decaltz=0;
657     for (Standard_Integer ltz=1; ltz<=nbtz; ltz++) {
658       if (TheTZ.HasCommonRange(myTZones(ltz-decaltz))) {
659         TheTZ.Append(myTZones(ltz-decaltz));
660         myTZones.Remove(ltz-decaltz);
661         decaltz++;
662       }
663     }
664     myTZones.Append(TheTZ);
665 #else 
666     TColStd_ListOfInteger LIndex;
667     for (Standard_Integer ltz=1; ltz<=nbtz; ltz++) {
668       if (TheTZ.HasCommonRange(myTZones(ltz))) {
669         LIndex.Append(ltz);
670       }
671     }
672     //------------------------------------------------------------------------
673     //--   The list is parsed in ascending order by index, zone and tg
674     //--
675     if(LIndex.IsEmpty()) { 
676       myTZones.Append(TheTZ);
677     }
678     else {
679       Standard_Integer indexfirst = LIndex.First();
680       LIndex.RemoveFirst();
681       Standard_Integer decal = 0;
682       myTZones(indexfirst).Append(TheTZ);
683       while(!LIndex.IsEmpty()) {
684         Standard_Integer index = LIndex.First();
685         LIndex.RemoveFirst();
686         myTZones(indexfirst).Append(myTZones(index-decal));
687         myTZones.Remove(index-decal);
688         decal++;
689       }
690     }
691 #endif
692   }
693 }