0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Intf / Intf_Interference.cxx
1 // Created on: 1991-06-24
2 // Created by: Didier PIFFAULT
3 // Copyright (c) 1991-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
18 #include <gp_Pnt.hxx>
19 #include <gp_Pnt2d.hxx>
20 #include <Intf_Interference.hxx>
21 #include <Intf_SectionLine.hxx>
22 #include <Intf_SectionPoint.hxx>
23 #include <Intf_TangentZone.hxx>
24 #include <Standard_OutOfRange.hxx>
25
26 //=======================================================================
27 //function : Intf_Interference
28 //purpose  : Initialize for a deferred interference.
29 //=======================================================================
30 Intf_Interference::Intf_Interference (const Standard_Boolean Self)
31      : SelfIntf(Self),
32        Tolerance(0.0)
33 {
34 }
35
36
37 //=======================================================================
38 //function : SelfInterference
39 //purpose  : Reset interference before perform with a new...
40 //=======================================================================
41
42 void Intf_Interference::SelfInterference (const Standard_Boolean Self)
43 {
44   SelfIntf=Self;
45   mySPoins.Clear();
46   mySLines.Clear();
47   myTZones.Clear();
48 }
49
50
51 //=======================================================================
52 //function : Insert
53 //purpose  : Insert a tangent zone in the list of the interference
54 //=======================================================================
55
56 Standard_Boolean Intf_Interference::Insert(const Intf_TangentZone& LaZone)
57 {
58   if (myTZones.Length()<=0) return Standard_False;
59   Standard_Integer lzin=0;   // Index in the list of the zone of interest.
60   Standard_Integer lunp=0;   // Index of the 1st stop point in this zone.
61   Standard_Integer lotp=0;   // Index of the 2nd stop point in this zone.
62   Standard_Integer lunl=0;   // Index of the 1st point of the new zone.
63   Standard_Integer lotl=0;   // Index of the 2nd point of the new zone.
64   Standard_Boolean same=Standard_False;     // Search direction of the stop of the new zone.
65   Standard_Boolean Inserted=Standard_True;  // Has the insertion succeeded ?
66   Standard_Integer npcz=-1;  // Number of points in the current zone
67   Standard_Integer nplz=LaZone.NumberOfPoints(); // in the new zone
68
69 // Loop on TangentZone :
70   for (Standard_Integer Iz=1; Iz<=myTZones.Length(); Iz++) {
71
72 // Loop on edges of the TangentZone :
73     npcz=myTZones(Iz).NumberOfPoints();
74     Standard_Integer Ipz0, Ipz1, Ipz2;
75     for (Ipz1=1; Ipz1<=npcz; Ipz1++) {
76       Ipz0=Ipz1-1;
77       if (Ipz0<=0) Ipz0=npcz;
78       Ipz2=(Ipz1%npcz)+1;
79
80 // Loop on edges of the new TangentZone and search of the
81 // corresponding point or edge:
82       Standard_Integer Ilz1, Ilz2;
83       for (Ilz1=1; Ilz1<=nplz; Ilz1++) {
84         Ilz2=(Ilz1%nplz)+1;
85         
86         if ((myTZones(Iz).GetPoint(Ipz1)).IsEqual
87             (LaZone.GetPoint(Ilz1))) {
88           if ((myTZones(Iz).GetPoint(Ipz0)).IsEqual
89               (LaZone.GetPoint(Ilz2))) {
90             lzin=Iz;
91             lunp=Ipz0;
92             lotp=Ipz1;
93             lunl=Ilz1;
94             lotl=Ilz2;
95             same=Standard_False;
96             break;
97           }
98           else if ((myTZones(Iz).GetPoint(Ipz2)).IsEqual
99               (LaZone.GetPoint(Ilz2))) {
100             lzin=Iz;
101             lunp=Ipz1;
102             lotp=Ipz2;
103             lunl=Ilz1;
104             lotl=Ilz2;
105             same=Standard_True;
106             break;
107           }
108           else {
109             lzin=Iz;
110             lunp=Ipz1;
111             lunl=Ilz1;
112           }
113         }
114       }
115       if (lotp!=0) break;
116     }
117     if (lotp!=0) break;
118   }
119
120   Standard_Integer Ilc;
121   if (lotp!=0) {
122     for (Ilc=lotl+1; (((Ilc-1)%nplz)+1)!=lunl; Ilc++) {
123       myTZones(lzin).InsertBefore
124         (lotp, LaZone.GetPoint(((Ilc-1)%nplz)+1));
125       if (!same) lotp++;
126     }
127   }
128
129   else if (lunp>0) {
130     Standard_Boolean loop=Standard_False;
131     for (Ilc=lunl; ; Ilc++) {
132       myTZones(lzin).InsertBefore(lunp, 
133                                          LaZone.GetPoint((((Ilc-1)%nplz)+1)));
134       lunp++;
135       if (loop && (((Ilc-1)%nplz)+1)==lunl) break;
136       loop=Standard_True;
137     }
138   }
139
140   else {
141     Inserted =Standard_False;
142   }
143
144   if (Inserted) {
145     Intf_TangentZone theNew=myTZones(lzin);
146     myTZones.Remove(lzin);
147     if (!Insert(theNew))
148       myTZones.Append(theNew);
149   }
150   return Inserted;
151 }
152
153 //=======================================================================
154 //function : Insert
155 //purpose  : 
156 //=======================================================================
157
158 void Intf_Interference::Insert(const Intf_SectionPoint& pdeb,
159                                const Intf_SectionPoint& pfin) 
160 {
161   Standard_Boolean Inserted=Standard_False;
162   Standard_Integer TheLS=0;
163   Standard_Boolean Begin=Standard_False;
164   Intf_SectionPoint TheBout(pfin);
165   Standard_Integer ils, nd, nf;
166   
167   for (ils=1; ils<=mySLines.Length(); ils++) {
168     Intf_SectionLine& SL=mySLines(ils);
169     nd=SL.IsEnd(pdeb);
170     nf=SL.IsEnd(pfin);
171     if (nd==1) {
172       if (nf>1) SL.Close();
173       Inserted=Standard_True;
174       TheLS=ils;
175       Begin=Standard_True;
176       break;
177     }
178     else if (nd>1) {
179       if (nf==1) SL.Close();
180       Inserted=Standard_True;
181       TheLS=ils;
182       Begin=Standard_False;
183       break;
184     }
185     else if (nf==1) {
186       Inserted=Standard_True;
187       TheLS=ils;
188       Begin=Standard_True;
189       TheBout=pdeb;
190       break;
191     }
192     else if (nf>1) {
193       Inserted=Standard_True;
194       TheLS=ils;
195       Begin=Standard_False;
196       TheBout=pdeb;
197       break;
198     }
199   }
200   
201   if (!Inserted) {
202     Intf_SectionLine LaLS;
203     LaLS.Append(pdeb);
204     LaLS.Append(pfin);
205     mySLines.Append(LaLS);
206   }
207   else {
208     nd=0;
209     for (ils=1; ils<=mySLines.Length(); ils++) {
210       if (ils != TheLS) {
211         nd=mySLines(ils).IsEnd(TheBout);
212         if (nd==1) {
213           if (Begin) {
214             mySLines(TheLS).Reverse();
215           }
216           mySLines(ils).Prepend(mySLines(TheLS));
217           break;
218         }
219         else if (nd>1) {
220           if (!Begin) {
221             mySLines(TheLS).Reverse();
222           }
223           mySLines(ils).Append(mySLines(TheLS));
224           break;
225         }
226       }
227     }
228     if (nd>0) {
229       mySLines.Remove(TheLS);
230     }
231     else {
232       if (Begin)
233         mySLines(TheLS).Prepend(TheBout);
234       else
235         mySLines(TheLS).Append(TheBout);
236     }
237   }
238 }
239
240
241
242 //----------------------------------------------------
243 // 
244 //----------------------------------------------------
245 Standard_Boolean Intf_Interference::Contains
246   (const Intf_SectionPoint& LePnt) const
247 {
248   //-- LePnt.Dump(0);
249   for (Standard_Integer l=1; l<=mySLines.Length(); l++) {
250     if (mySLines(l).Contains(LePnt)) return Standard_True;
251   }
252   for (Standard_Integer t=1; t<=myTZones.Length(); t++) {
253     //-- myTZones(t).Dump(2);
254     if (myTZones(t).Contains(LePnt)) return Standard_True;
255   }
256   return Standard_False;
257 }
258
259
260 //----------------------------------------------------
261 // 
262 //----------------------------------------------------
263 void Intf_Interference::Dump() const
264 {
265   std::cout << "Mes SectionPoint :" << std::endl;
266   for (Standard_Integer p=1; p<=mySPoins.Length(); p++) {
267     mySPoins(p).Dump(2);
268   }
269   std::cout << "Mes SectionLine :" << std::endl;
270   for (Standard_Integer l=1; l<=mySLines.Length(); l++) {
271     mySLines(l).Dump(2);
272   }
273   std::cout << "Mes TangentZone :" << std::endl;
274   for (Standard_Integer t=1; t<=myTZones.Length(); t++) {
275     myTZones(t).Dump(2);
276   }
277 }