8c1b004098a3add44f50865dc9d9fa3fdc366337
[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 IntWalk_IWalking::IntWalk_IWalking (const Standard_Real Epsilon,
25                                     const Standard_Real Deflection,
26                                     const Standard_Real Increment ) :
27       done(Standard_False),
28       fleche(Deflection),
29       pas(Increment),
30       tolerance(1,2),
31       epsilon(Epsilon*Epsilon),
32       wd1 (IntWalk_VectorOfWalkingData::allocator_type (new NCollection_IncAllocator)),
33       wd2 (wd1.get_allocator()),
34       nbMultiplicities (wd1.get_allocator()),
35       NbPointsConfondusConsecutifs(0),
36       EpsilonSembleTropGrand(0)
37 {
38 }
39
40     
41 //=======================================================================
42 //function : Reset
43 //purpose  : Clears NCollection_Vector-based containers and adds
44 //           dummy data to maintain start index of 1 and consistent with
45 //           previous TCollection_Sequence-based implementation and other
46 //           used TCollection-based containers
47 //=======================================================================
48
49 void IntWalk_IWalking::Clear()
50 {
51   wd1.clear();
52   wd2.clear();
53   IntWalk_WalkingData aDummy;
54   aDummy.etat = -10;
55   aDummy.ustart = aDummy.vstart = 0.;
56   wd1.push_back (aDummy);
57   wd2.push_back (aDummy);
58   nbMultiplicities.clear();
59   nbMultiplicities.push_back (-1);
60   
61   done = Standard_False;
62   seqAjout.Clear();
63   lines.Clear();
64 }
65
66 // ***************************************************************************
67      //  etat1=12 not tangent, not passes
68      //  etat1=11 tangent, not passes
69      //  etat1=2  not tangent, passes
70      //  etat1=1  tangent, passes
71      //  after a point is processed its state becomes negative.
72 // ***************************************************************************
73      //  etat2=13  interior start point on closed line
74      //  etat2=12  interior start point on open line 
75      //            (line initially closed -> la line s is open)       
76      //  after a point is processed (or if it is passed over during
77      //  routing) its state becomes negative.
78 // ****************************************************************************
79
80 //
81 // Perform with interior points
82 //
83 void IntWalk_IWalking::Perform(const ThePOPIterator& Pnts1,
84                                const ThePOLIterator& Pnts2,
85                                TheIWFunction& Func,
86                                const ThePSurface& Caro,
87                                const Standard_Boolean Reversed)
88
89 {
90
91   Standard_Integer I;
92   Standard_Boolean Rajout = Standard_False;
93   Standard_Integer nbPnts1 = Pnts1.Length();
94   Standard_Integer nbPnts2 = Pnts2.Length();
95   Standard_Real U,V;
96
97   Clear();
98   reversed = Reversed;
99
100
101   // Loading of etat1 and etat2  as well as  ustart and vstart.
102
103   TColStd_SequenceOfReal Umult;
104   TColStd_SequenceOfReal Vmult;
105
106   Standard_Integer decal=0;
107   wd1.reserve (nbPnts1+decal);
108   nbMultiplicities.reserve (nbPnts1+decal);
109   for (I=1;I <= nbPnts1+decal; I++) {
110     const ThePointOfPath& PathPnt = Pnts1.Value(I-decal);
111     IntWalk_WalkingData aWD1;
112     aWD1.etat = 1;
113     if (!ThePointOfPathTool::IsPassingPnt(PathPnt)) 
114       aWD1.etat = 11;
115     if (!ThePointOfPathTool::IsTangent(PathPnt))   
116       ++aWD1.etat;
117
118     if(aWD1.etat==2) {   
119       aWD1.etat=11;
120     }      
121
122     ThePointOfPathTool::Value2d(PathPnt, aWD1.ustart, aWD1.vstart);
123     wd1.push_back (aWD1);
124     Standard_Integer aNbMult = ThePointOfPathTool::Multiplicity(PathPnt);
125     nbMultiplicities.push_back(aNbMult);
126
127     for (Standard_Integer J = 1; J <= aNbMult; J++) {
128       ThePointOfPathTool::Parameters(PathPnt, J, U, V);
129       Umult.Append(U);
130       Vmult.Append(V);
131     }
132   }
133
134   wd2.reserve (nbPnts2);
135   for (I = 1; I <= nbPnts2; I++) {
136     IntWalk_WalkingData aWD2;
137     aWD2.etat = 13;
138     ThePointOfLoopTool::Value2d(Pnts2.Value(I), aWD2.ustart, aWD2.vstart);
139     wd2.push_back (aWD2);
140   }
141
142   tolerance(1) = ThePSurfaceTool::UResolution(Caro,Precision::Confusion());
143   tolerance(2) = ThePSurfaceTool::VResolution(Caro,Precision::Confusion());
144
145   Um = ThePSurfaceTool::FirstUParameter(Caro);
146   Vm = ThePSurfaceTool::FirstVParameter(Caro);
147   UM = ThePSurfaceTool::LastUParameter(Caro);
148   VM = ThePSurfaceTool::LastVParameter(Caro);
149
150   if (UM < Um) {
151     Standard_Real utemp = UM;
152     UM = Um;
153     Um = utemp;
154   }
155   if (VM < Vm) {
156     Standard_Real vtemp = VM;
157     VM = Vm;
158     Vm = vtemp;
159   }
160
161   Func.Set(Caro);
162
163   // calculation of all open lines   
164   if (nbPnts1 != 0) ComputeOpenLine(Umult,Vmult,Pnts1,Func,Rajout); 
165   // calculation of all closed lines 
166   if (nbPnts2 != 0) ComputeCloseLine(Umult,Vmult,Pnts1,Pnts2,Func,Rajout); 
167   for (I = 1; I <= nbPnts1; I++) { 
168     if (wd1[I].etat >0) seqSingle.Append(Pnts1(I));
169   }
170   done = Standard_True;
171 }
172
173
174
175 //
176 // Perform without interior point
177 //
178
179 void IntWalk_IWalking::Perform(const ThePOPIterator& Pnts1,
180                                TheIWFunction& Func,
181                                const ThePSurface& Caro,
182                                const Standard_Boolean Reversed)
183
184 {
185   Standard_Integer I;
186   Standard_Boolean Rajout = Standard_False;
187   Standard_Integer nbPnts1 = Pnts1.Length();
188   Standard_Real U,V;
189
190   reversed = Reversed;
191
192
193   // Loading of etat1 as well as ustart1 and vstart1.
194
195   TColStd_SequenceOfReal Umult;
196   TColStd_SequenceOfReal Vmult;
197
198   wd1.reserve (nbPnts1);
199   for (I=1;I <= nbPnts1; I++) {
200     const ThePointOfPath& PathPnt = Pnts1.Value(I);
201     IntWalk_WalkingData aWD1;
202     aWD1.etat = 1;
203     if (!ThePointOfPathTool::IsPassingPnt(PathPnt)) aWD1.etat = 11; 
204     if (!ThePointOfPathTool::IsTangent(PathPnt))   ++aWD1.etat;
205     ThePointOfPathTool::Value2d(PathPnt, aWD1.ustart, aWD1.vstart);
206     wd1.push_back (aWD1);
207     Standard_Integer aNbMult = ThePointOfPathTool::Multiplicity(PathPnt);
208     nbMultiplicities.push_back(aNbMult);
209
210     for (Standard_Integer J = 1; J <= aNbMult; J++) {
211       ThePointOfPathTool::Parameters(PathPnt, J, U, V);
212       Umult.Append(U);
213       Vmult.Append(V);
214     }
215   }
216
217   tolerance(1) = ThePSurfaceTool::UResolution(Caro,Precision::Confusion());
218   tolerance(2) = ThePSurfaceTool::VResolution(Caro,Precision::Confusion());
219
220   Um = ThePSurfaceTool::FirstUParameter(Caro);
221   Vm = ThePSurfaceTool::FirstVParameter(Caro);
222   UM = ThePSurfaceTool::LastUParameter(Caro);
223   VM = ThePSurfaceTool::LastVParameter(Caro);
224
225   if (UM < Um) {
226     Standard_Real utemp = UM;
227     UM = Um;
228     Um = utemp;
229   }
230   if (VM < Vm) {
231     Standard_Real vtemp = VM;
232     VM = Vm;
233     Vm = vtemp;
234   }
235
236   Func.Set(Caro);
237
238   // calcul de toutes les lignes ouvertes   
239   if (nbPnts1 != 0) ComputeOpenLine(Umult,Vmult,Pnts1,Func,Rajout); 
240
241   for (I = 1; I <= nbPnts1; I++) { 
242     if (wd1[I].etat >0) seqSingle.Append(Pnts1(I));
243   }
244   done = Standard_True;
245 }
246
247
248