0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / IntWalk / IntWalk_IWalking_1.gxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifdef CHRONO
16 #include <OSD_Chronometer.hxx>
17 OSD_Chronometer Chronrsnld;
18
19 #endif
20
21 #include <NCollection_IncAllocator.hxx>
22 #include <Precision.hxx>
23
24 //==================================================================================
25 // function : IsTangentExtCheck
26 // purpose  : Additional check if the point (theU, theV) in parametric surface
27 //            is a tangent point.
28 //            If that is TRUE then we can go along any (!) direction in order to
29 //            obtain next intersection point. At present, this case is difficult
30 //            for processing. Therefore, we will return an empty intersection line
31 //            in this case.
32 //==================================================================================
33 static Standard_Boolean IsTangentExtCheck(TheIWFunction& theFunc,
34                                           const Standard_Real theU,
35                                           const Standard_Real theV,
36                                           const Standard_Real theStepU,
37                                           const Standard_Real theStepV,
38                                           const Standard_Real theUinf,
39                                           const Standard_Real theUsup,
40                                           const Standard_Real theVinf,
41                                           const Standard_Real theVsup)
42 {
43   const Standard_Real aTol = theFunc.Tolerance();
44   const Standard_Integer aNbItems = 4;
45   const Standard_Real aParU[aNbItems] = { Min(theU + theStepU, theUsup),
46                                           Max(theU - theStepU, theUinf),
47                                           theU, theU};
48   const Standard_Real aParV[aNbItems] = { theV, theV,
49                                           Min(theV + theStepV, theVsup),
50                                           Max(theV - theStepV, theVinf)};
51
52   math_Vector aX(1, 2), aVal(1, 1);
53
54   for(Standard_Integer i = 0; i < aNbItems; i++)
55   {
56     aX.Value(1) = aParU[i];
57     aX.Value(2) = aParV[i];
58
59     if(!theFunc.Value(aX, aVal))
60       continue;
61
62     if(aVal(1) > aTol)
63       return Standard_False;
64   }
65
66   return Standard_True;
67 }
68
69
70
71 IntWalk_IWalking::IntWalk_IWalking (const Standard_Real Epsilon,
72                                     const Standard_Real Deflection,
73                                     const Standard_Real Increment,
74                                     const Standard_Boolean theToFillHoles) :
75       done(Standard_False),
76       fleche(Deflection),
77       pas(Increment),
78       tolerance(1,2),
79       epsilon(Epsilon*Epsilon),
80       reversed(Standard_False),
81       wd1 (IntWalk_VectorOfWalkingData::allocator_type (new NCollection_IncAllocator)),
82       wd2 (wd1.get_allocator()),
83       nbMultiplicities (wd1.get_allocator()),
84       Um(0.0),
85       UM(0.0),
86       Vm(0.0),
87       VM(0.0),
88       ToFillHoles(theToFillHoles)
89 {
90 }
91
92     
93 //=======================================================================
94 //function : Reset
95 //purpose  : Clears NCollection_Vector-based containers and adds
96 //           dummy data to maintain start index of 1 and consistent with
97 //           previous TCollection_Sequence-based implementation and other
98 //           used TCollection-based containers
99 //=======================================================================
100
101 void IntWalk_IWalking::Clear()
102 {
103   wd1.clear();
104   wd2.clear();
105   IntWalk_WalkingData aDummy;
106   aDummy.etat = -10;
107   aDummy.ustart = aDummy.vstart = 0.;
108   wd1.push_back (aDummy);
109   wd2.push_back (aDummy);
110   nbMultiplicities.clear();
111   nbMultiplicities.push_back (-1);
112   
113   done = Standard_False;
114   seqAjout.Clear();
115   lines.Clear();
116 }
117
118 // ***************************************************************************
119      //  etat1=12 not tangent, not passes
120      //  etat1=11 tangent, not passes
121      //  etat1=2  not tangent, passes
122      //  etat1=1  tangent, passes
123      //  after a point is processed its state becomes negative.
124 // ***************************************************************************
125      //  etat2=13  interior start point on closed line
126      //  etat2=12  interior start point on open line 
127      //            (line initially closed -> la line s is open)       
128      //  after a point is processed (or if it is passed over during
129      //  routing) its state becomes negative.
130 // ****************************************************************************
131
132 //
133 // Perform with interior points
134 //
135 void IntWalk_IWalking::Perform(const ThePOPIterator& Pnts1,
136                                const ThePOLIterator& Pnts2,
137                                TheIWFunction& Func,
138                                const ThePSurface& Caro,
139                                const Standard_Boolean Reversed)
140
141 {
142   Standard_Integer I;
143   Standard_Boolean Rajout = Standard_False;
144   Standard_Integer nbPnts1 = Pnts1.Length();
145   Standard_Integer nbPnts2 = Pnts2.Length();
146   Standard_Real U,V;
147
148   Clear();
149   reversed = Reversed;
150
151   Um = ThePSurfaceTool::FirstUParameter(Caro);
152   Vm = ThePSurfaceTool::FirstVParameter(Caro);
153   UM = ThePSurfaceTool::LastUParameter(Caro);
154   VM = ThePSurfaceTool::LastVParameter(Caro);
155
156   if (UM < Um) {
157     Standard_Real utemp = UM;
158     UM = Um;
159     Um = utemp;
160   }
161   if (VM < Vm) {
162     Standard_Real vtemp = VM;
163     VM = Vm;
164     Vm = vtemp;
165   }
166
167   const Standard_Real aStepU = pas*(UM-Um), aStepV = pas*(VM-Vm);
168
169   // Loading of etat1 and etat2  as well as  ustart and vstart.
170
171   TColStd_SequenceOfReal Umult;
172   TColStd_SequenceOfReal Vmult;
173
174   Standard_Integer decal=0;
175   wd1.reserve (nbPnts1+decal);
176   nbMultiplicities.reserve (nbPnts1+decal);
177   for (I=1;I <= nbPnts1+decal; I++) {
178     const ThePointOfPath& PathPnt = Pnts1.Value(I-decal);
179     IntWalk_WalkingData aWD1;
180     aWD1.etat = 1;
181     if (!ThePointOfPathTool::IsPassingPnt(PathPnt)) 
182       aWD1.etat = 11;
183     if (!ThePointOfPathTool::IsTangent(PathPnt))   
184       ++aWD1.etat;
185
186     if(aWD1.etat==2) {   
187       aWD1.etat=11;
188     }      
189
190     ThePointOfPathTool::Value2d(PathPnt, aWD1.ustart, aWD1.vstart);
191     mySRangeU.Add(aWD1.ustart);
192     mySRangeV.Add(aWD1.vstart);
193
194     wd1.push_back (aWD1);
195     Standard_Integer aNbMult = ThePointOfPathTool::Multiplicity(PathPnt);
196     nbMultiplicities.push_back(aNbMult);
197
198     for (Standard_Integer J = 1; J <= aNbMult; J++) {
199       ThePointOfPathTool::Parameters(PathPnt, J, U, V);
200       Umult.Append(U);
201       Vmult.Append(V);
202     }
203   }
204
205   wd2.reserve (nbPnts2);
206   for (I = 1; I <= nbPnts2; I++) {
207     IntWalk_WalkingData aWD2;
208     aWD2.etat = 1;
209     const IntSurf_InteriorPoint& anIP = Pnts2.Value(I);
210     ThePointOfLoopTool::Value2d(anIP, aWD2.ustart, aWD2.vstart);
211     mySRangeU.Add(aWD2.ustart);
212     mySRangeV.Add(aWD2.vstart);
213
214     if (!IsTangentExtCheck(Func, aWD2.ustart, aWD2.vstart, aStepU, aStepV, Um, UM, Vm, VM))
215       aWD2.etat = 13;
216     
217     wd2.push_back (aWD2);
218   }
219
220   tolerance(1) = ThePSurfaceTool::UResolution(Caro,Precision::Confusion());
221   tolerance(2) = ThePSurfaceTool::VResolution(Caro,Precision::Confusion());
222
223   Func.Set(Caro);
224
225   if (mySRangeU.Delta() > Max(tolerance(1), Precision::PConfusion()))
226   {
227     mySRangeU.Enlarge(mySRangeU.Delta());
228     mySRangeU.Common(Bnd_Range(Um, UM));
229   }
230   else
231   {
232     mySRangeU = Bnd_Range(Um, UM);
233   }
234
235   if (mySRangeV.Delta() > Max(tolerance(2), Precision::PConfusion()))
236   {
237     mySRangeV.Enlarge(mySRangeV.Delta());
238     mySRangeV.Common(Bnd_Range(Vm, VM));
239   }
240   else
241   {
242     mySRangeV = Bnd_Range(Vm, VM);
243   }
244
245   // calculation of all open lines   
246   if (nbPnts1 != 0)
247     ComputeOpenLine(Umult,Vmult,Pnts1,Func,Rajout); 
248
249   // calculation of all closed lines 
250   if (nbPnts2 != 0)
251     ComputeCloseLine(Umult,Vmult,Pnts1,Pnts2,Func,Rajout);
252
253   if (ToFillHoles)
254   {
255     Standard_Integer MaxNbIter = 10, nb_iter = 0;
256     while (seqAlone.Length() > 1 && nb_iter < MaxNbIter)
257     {
258       nb_iter++;
259       IntSurf_SequenceOfInteriorPoint PntsInHoles;
260       TColStd_SequenceOfInteger CopySeqAlone = seqAlone;
261       FillPntsInHoles(Func, CopySeqAlone, PntsInHoles);
262       wd2.clear();
263       IntWalk_WalkingData aDummy;
264       aDummy.etat = -10;
265       aDummy.ustart = aDummy.vstart = 0.;
266       wd2.push_back (aDummy);
267       Standard_Integer nbHoles = PntsInHoles.Length();
268       wd2.reserve(nbHoles);
269       for (I = 1; I <= nbHoles; I++)
270       {
271         IntWalk_WalkingData aWD2;
272         aWD2.etat = 13;
273         const IntSurf_InteriorPoint& anIP = PntsInHoles.Value(I);
274         ThePointOfLoopTool::Value2d(anIP, aWD2.ustart, aWD2.vstart);
275         wd2.push_back (aWD2);
276       }
277       ComputeCloseLine(Umult,Vmult,Pnts1,PntsInHoles,Func,Rajout);
278     }
279   }
280   
281   for (I = 1; I <= nbPnts1; I++) { 
282     if (wd1[I].etat >0) seqSingle.Append(Pnts1(I));
283   }
284   done = Standard_True;
285 }
286
287
288
289 //
290 // Perform without interior point
291 //
292
293 void IntWalk_IWalking::Perform(const ThePOPIterator& Pnts1,
294                                TheIWFunction& Func,
295                                const ThePSurface& Caro,
296                                const Standard_Boolean Reversed)
297
298 {
299   Standard_Integer I;
300   Standard_Boolean Rajout = Standard_False;
301   Standard_Integer nbPnts1 = Pnts1.Length();
302   Standard_Real U,V;
303
304   reversed = Reversed;
305
306
307   // Loading of etat1 as well as ustart1 and vstart1.
308
309   TColStd_SequenceOfReal Umult;
310   TColStd_SequenceOfReal Vmult;
311
312   wd1.reserve (nbPnts1);
313   for (I=1;I <= nbPnts1; I++) {
314     const ThePointOfPath& PathPnt = Pnts1.Value(I);
315     IntWalk_WalkingData aWD1;
316     aWD1.etat = 1;
317     if (!ThePointOfPathTool::IsPassingPnt(PathPnt)) aWD1.etat = 11; 
318     if (!ThePointOfPathTool::IsTangent(PathPnt))   ++aWD1.etat;
319     ThePointOfPathTool::Value2d(PathPnt, aWD1.ustart, aWD1.vstart);
320     wd1.push_back (aWD1);
321     Standard_Integer aNbMult = ThePointOfPathTool::Multiplicity(PathPnt);
322     nbMultiplicities.push_back(aNbMult);
323
324     for (Standard_Integer J = 1; J <= aNbMult; J++) {
325       ThePointOfPathTool::Parameters(PathPnt, J, U, V);
326       Umult.Append(U);
327       Vmult.Append(V);
328     }
329   }
330
331   tolerance(1) = ThePSurfaceTool::UResolution(Caro,Precision::Confusion());
332   tolerance(2) = ThePSurfaceTool::VResolution(Caro,Precision::Confusion());
333
334   Um = ThePSurfaceTool::FirstUParameter(Caro);
335   Vm = ThePSurfaceTool::FirstVParameter(Caro);
336   UM = ThePSurfaceTool::LastUParameter(Caro);
337   VM = ThePSurfaceTool::LastVParameter(Caro);
338
339   if (UM < Um) {
340     Standard_Real utemp = UM;
341     UM = Um;
342     Um = utemp;
343   }
344   if (VM < Vm) {
345     Standard_Real vtemp = VM;
346     VM = Vm;
347     Vm = vtemp;
348   }
349
350   Func.Set(Caro);
351
352   // calcul de toutes les lignes ouvertes   
353   if (nbPnts1 != 0) ComputeOpenLine(Umult,Vmult,Pnts1,Func,Rajout); 
354
355   for (I = 1; I <= nbPnts1; I++) { 
356     if (wd1[I].etat >0) seqSingle.Append(Pnts1(I));
357   }
358   done = Standard_True;
359 }
360
361
362