d026b6e6cb151f47c4ea473f63775f610c723acd
[occt.git] / src / Intf / Intf_Interference.cxx
1 // File:        Intf_Interference.cxx
2 // Created:     Mon Jun 24 11:52:34 1991
3 // Author:      Didier PIFFAULT
4 //              <dpf@phobox>
5
6 #include <Intf_Interference.ixx>
7 #include <gp_Pnt2d.hxx>
8 #include <gp_Pnt.hxx>
9
10 //=======================================================================
11 //function : Intf_Interference
12 //purpose  : Initialize for a deferred interference.
13 //=======================================================================
14
15 Intf_Interference::Intf_Interference (const Standard_Boolean Self)
16      : SelfIntf(Self)
17 {}
18
19
20 //=======================================================================
21 //function : SelfInterference
22 //purpose  : Reset interference before perform with a new...
23 //=======================================================================
24
25 void Intf_Interference::SelfInterference (const Standard_Boolean Self)
26 {
27   SelfIntf=Self;
28   mySPoins.Clear();
29   mySLines.Clear();
30   myTZones.Clear();
31 }
32
33
34 //---------------------------------------------------------
35 // Return the number of sections points in an interference.
36 //---------------------------------------------------------
37 Standard_Integer Intf_Interference::NbSectionPoints () const
38 {
39   return mySPoins.Length();
40 }
41
42 //-----------------------------------------------------------
43 // Give the section point of range Index in the interference.
44 //-----------------------------------------------------------
45 const Intf_SectionPoint& Intf_Interference::PntValue 
46   (const Standard_Integer Index) const
47 {
48   return mySPoins(Index);
49 }
50
51 //--------------------------------------------------------
52 // Return the number of sections lines in an interference.
53 //--------------------------------------------------------
54 Standard_Integer Intf_Interference::NbSectionLines () const
55 {
56   return mySLines.Length();
57 }
58
59 //----------------------------------------------------------
60 // Give the section line of range Index in the interference.
61 //----------------------------------------------------------
62 const Intf_SectionLine& Intf_Interference::LineValue 
63   (const Standard_Integer Index) const
64 {
65   return mySLines(Index);
66 }
67
68
69 //---------------------------------------------------------------
70 // Return the number of sections TangentZones in an interference.
71 //---------------------------------------------------------------
72 Standard_Integer Intf_Interference::NbTangentZones () const
73 {
74   return myTZones.Length();
75 }
76
77 //---------------------------------------------------------
78 // Give the tangentzone of range Index in the interference.
79 //---------------------------------------------------------
80 const Intf_TangentZone& Intf_Interference::ZoneValue 
81   (const Standard_Integer Index) const
82 {
83   return myTZones(Index);
84 }
85
86 //=======================================================================
87 //function : GetTolerance
88 //purpose  : 
89 //=======================================================================
90
91 Standard_Real Intf_Interference::GetTolerance () const
92 {
93   return Tolerance;
94 }
95
96
97 //=======================================================================
98 //function : Insert
99 //purpose  : Insert a tangent zone in the list of the interference
100 //=======================================================================
101
102 Standard_Boolean Intf_Interference::Insert(const Intf_TangentZone& LaZone)
103 {
104   if (myTZones.Length()<=0) return Standard_False;
105   Standard_Integer lzin=0;   // Index in the list of the zone of interest.
106   Standard_Integer lunp=0;   // Index of the 1st stop point in this zone.
107   Standard_Integer lotp=0;   // Index of the 2nd stop point in this zone.
108   Standard_Integer lunl=0;   // Index of the 1st point of the new zone.
109   Standard_Integer lotl=0;   // Index of the 2nd point of the new zone.
110   Standard_Boolean same=Standard_False;     // Search direction of the stop of the new zone.
111   Standard_Boolean Inserted=Standard_True;  // Has the insertion succeeded ?
112   Standard_Integer npcz=-1;  // Number of points in the current zone
113   Standard_Integer nplz=LaZone.NumberOfPoints(); // in the new zone
114
115 // Loop on TangentZone :
116   for (Standard_Integer Iz=1; Iz<=myTZones.Length(); Iz++) {
117
118 // Loop on edges of the TangentZone :
119     npcz=myTZones(Iz).NumberOfPoints();
120     Standard_Integer Ipz0, Ipz1, Ipz2;
121     for (Ipz1=1; Ipz1<=npcz; Ipz1++) {
122       Ipz0=Ipz1-1;
123       if (Ipz0<=0) Ipz0=npcz;
124       Ipz2=(Ipz1%npcz)+1;
125
126 // Loop on edges of the new TangentZone and search of the
127 // corresponding point or edge:
128       Standard_Integer Ilz1, Ilz2;
129       for (Ilz1=1; Ilz1<=nplz; Ilz1++) {
130         Ilz2=(Ilz1%nplz)+1;
131         
132         if ((myTZones(Iz).GetPoint(Ipz1)).IsEqual
133             (LaZone.GetPoint(Ilz1))) {
134           if ((myTZones(Iz).GetPoint(Ipz0)).IsEqual
135               (LaZone.GetPoint(Ilz2))) {
136             lzin=Iz;
137             lunp=Ipz0;
138             lotp=Ipz1;
139             lunl=Ilz1;
140             lotl=Ilz2;
141             same=Standard_False;
142             break;
143           }
144           else if ((myTZones(Iz).GetPoint(Ipz2)).IsEqual
145               (LaZone.GetPoint(Ilz2))) {
146             lzin=Iz;
147             lunp=Ipz1;
148             lotp=Ipz2;
149             lunl=Ilz1;
150             lotl=Ilz2;
151             same=Standard_True;
152             break;
153           }
154           else {
155             lzin=Iz;
156             lunp=Ipz1;
157             lunl=Ilz1;
158           }
159         }
160       }
161       if (lotp!=0) break;
162     }
163     if (lotp!=0) break;
164   }
165
166   Standard_Integer Ilc;
167   if (lotp!=0) {
168     for (Ilc=lotl+1; (((Ilc-1)%nplz)+1)!=lunl; Ilc++) {
169       myTZones(lzin).InsertBefore
170         (lotp, LaZone.GetPoint(((Ilc-1)%nplz)+1));
171       if (!same) lotp++;
172     }
173   }
174
175   else if (lunp>0) {
176     Standard_Boolean loop=Standard_False;
177     for (Ilc=lunl; ; Ilc++) {
178       myTZones(lzin).InsertBefore(lunp, 
179                                          LaZone.GetPoint((((Ilc-1)%nplz)+1)));
180       lunp++;
181       if (loop && (((Ilc-1)%nplz)+1)==lunl) break;
182       loop=Standard_True;
183     }
184   }
185
186   else {
187     Inserted =Standard_False;
188   }
189
190   if (Inserted) {
191     Intf_TangentZone theNew=myTZones(lzin);
192     myTZones.Remove(lzin);
193     if (!Insert(theNew))
194       myTZones.Append(theNew);
195   }
196   return Inserted;
197 }
198
199 //=======================================================================
200 //function : Insert
201 //purpose  : 
202 //=======================================================================
203
204 void Intf_Interference::Insert(const Intf_SectionPoint& pdeb,
205                                const Intf_SectionPoint& pfin) 
206 {
207   Standard_Boolean Inserted=Standard_False;
208   Standard_Integer TheLS=0;
209   Standard_Boolean Begin=Standard_False;
210   Intf_SectionPoint TheBout(pfin);
211   Standard_Integer ils, nd, nf;
212   
213   for (ils=1; ils<=mySLines.Length(); ils++) {
214     Intf_SectionLine& SL=mySLines(ils);
215     nd=SL.IsEnd(pdeb);
216     nf=SL.IsEnd(pfin);
217     if (nd==1) {
218       if (nf>1) SL.Close();
219       Inserted=Standard_True;
220       TheLS=ils;
221       Begin=Standard_True;
222       break;
223     }
224     else if (nd>1) {
225       if (nf==1) SL.Close();
226       Inserted=Standard_True;
227       TheLS=ils;
228       Begin=Standard_False;
229       break;
230     }
231     else if (nf==1) {
232       Inserted=Standard_True;
233       TheLS=ils;
234       Begin=Standard_True;
235       TheBout=pdeb;
236       break;
237     }
238     else if (nf>1) {
239       Inserted=Standard_True;
240       TheLS=ils;
241       Begin=Standard_False;
242       TheBout=pdeb;
243       break;
244     }
245   }
246   
247   if (!Inserted) {
248     Intf_SectionLine LaLS;
249     LaLS.Append(pdeb);
250     LaLS.Append(pfin);
251     mySLines.Append(LaLS);
252   }
253   else {
254     nd=0;
255     for (ils=1; ils<=mySLines.Length(); ils++) {
256       if (ils != TheLS) {
257         nd=mySLines(ils).IsEnd(TheBout);
258         if (nd==1) {
259           if (Begin) {
260             mySLines(TheLS).Reverse();
261           }
262           mySLines(ils).Prepend(mySLines(TheLS));
263           break;
264         }
265         else if (nd>1) {
266           if (!Begin) {
267             mySLines(TheLS).Reverse();
268           }
269           mySLines(ils).Append(mySLines(TheLS));
270           break;
271         }
272       }
273     }
274     if (nd>0) {
275       mySLines.Remove(TheLS);
276     }
277     else {
278       if (Begin)
279         mySLines(TheLS).Prepend(TheBout);
280       else
281         mySLines(TheLS).Append(TheBout);
282     }
283   }
284 }
285
286
287
288 //----------------------------------------------------
289 // 
290 //----------------------------------------------------
291 Standard_Boolean Intf_Interference::Contains
292   (const Intf_SectionPoint& LePnt) const
293 {
294   //-- LePnt.Dump(0);
295   for (Standard_Integer l=1; l<=mySLines.Length(); l++) {
296     if (mySLines(l).Contains(LePnt)) return Standard_True;
297   }
298   for (Standard_Integer t=1; t<=myTZones.Length(); t++) {
299     //-- myTZones(t).Dump(2);
300     if (myTZones(t).Contains(LePnt)) return Standard_True;
301   }
302   return Standard_False;
303 }
304
305
306 //----------------------------------------------------
307 // 
308 //----------------------------------------------------
309 void Intf_Interference::Dump() const
310 {
311   cout << "Mes SectionPoint :" << endl;
312   for (Standard_Integer p=1; p<=mySPoins.Length(); p++) {
313     mySPoins(p).Dump(2);
314   }
315   cout << "Mes SectionLine :" << endl;
316   for (Standard_Integer l=1; l<=mySLines.Length(); l++) {
317     mySLines(l).Dump(2);
318   }
319   cout << "Mes TangentZone :" << endl;
320   for (Standard_Integer t=1; t<=myTZones.Length(); t++) {
321     myTZones(t).Dump(2);
322   }
323 }