4e57c75e |
1 | // Created by: Peter KURNEV |
973c2be1 |
2 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
4e57c75e |
3 | // |
973c2be1 |
4 | // This file is part of Open CASCADE Technology software library. |
4e57c75e |
5 | // |
973c2be1 |
6 | // This library is free software; you can redistribute it and / or modify it |
7 | // under the terms of the GNU Lesser General Public 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. |
4e57c75e |
11 | // |
973c2be1 |
12 | // Alternatively, this file may be used under the terms of Open CASCADE |
13 | // commercial license or contractual agreement. |
4e57c75e |
14 | |
15 | #include <BOPDS_PaveBlock.ixx> |
16 | #include <BOPDS_ListOfPave.hxx> |
17 | #include <Standard.hxx> |
18 | #include <NCollection_BaseAllocator.hxx> |
19 | |
20 | |
21 | #ifdef WNT |
22 | #pragma warning ( disable : 4291 ) |
23 | #endif |
24 | |
25 | static |
26 | void SortShell(const int n, BOPDS_Pave *a); |
27 | |
28 | //======================================================================= |
29 | //function : |
30 | //purpose : |
31 | //======================================================================= |
32 | BOPDS_PaveBlock::BOPDS_PaveBlock() |
33 | : |
34 | myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()), |
35 | myExtPaves(myAllocator) |
36 | { |
37 | myEdge=-1; |
38 | myOriginalEdge=-1; |
39 | myTS1=-99.; |
40 | myTS2=myTS1; |
41 | } |
42 | //======================================================================= |
43 | //function : |
44 | //purpose : |
45 | //======================================================================= |
46 | BOPDS_PaveBlock::BOPDS_PaveBlock(const Handle(NCollection_BaseAllocator)& theAllocator) |
47 | : |
48 | myAllocator(theAllocator), |
49 | myExtPaves(theAllocator), |
50 | myMFence(100, theAllocator) |
51 | { |
52 | myEdge=-1; |
53 | myOriginalEdge=-1; |
54 | myTS1=-99.; |
55 | myTS2=myTS1; |
56 | } |
57 | |
58 | //======================================================================= |
59 | //function : SetEdge |
60 | //purpose : |
61 | //======================================================================= |
62 | void BOPDS_PaveBlock::SetEdge(const Standard_Integer theEdge) |
63 | { |
64 | myEdge=theEdge; |
65 | } |
66 | //======================================================================= |
67 | //function : Edge |
68 | //purpose : |
69 | //======================================================================= |
70 | Standard_Integer BOPDS_PaveBlock::Edge()const |
71 | { |
72 | return myEdge; |
73 | } |
74 | //======================================================================= |
75 | //function : HasEdge |
76 | //purpose : |
77 | //======================================================================= |
78 | Standard_Boolean BOPDS_PaveBlock::HasEdge()const |
79 | { |
80 | return (myEdge>=0); |
81 | } |
82 | //======================================================================= |
83 | //function : HasEdge |
84 | //purpose : |
85 | //======================================================================= |
86 | Standard_Boolean BOPDS_PaveBlock::HasEdge(Standard_Integer& theEdge)const |
87 | { |
88 | theEdge=myEdge; |
89 | return (myEdge>=0); |
90 | } |
91 | |
92 | //======================================================================= |
93 | //function : SetOriginalEdge |
94 | //purpose : |
95 | //======================================================================= |
96 | void BOPDS_PaveBlock::SetOriginalEdge(const Standard_Integer theEdge) |
97 | { |
98 | myOriginalEdge=theEdge; |
99 | } |
100 | //======================================================================= |
101 | //function : OriginalEdge |
102 | //purpose : |
103 | //======================================================================= |
104 | Standard_Integer BOPDS_PaveBlock::OriginalEdge()const |
105 | { |
106 | return myOriginalEdge; |
107 | } |
108 | //======================================================================= |
109 | //function : IsSplitEdge |
110 | //purpose : |
111 | //======================================================================= |
112 | Standard_Boolean BOPDS_PaveBlock::IsSplitEdge()const |
113 | { |
114 | return (myEdge!=myOriginalEdge); |
115 | } |
116 | //======================================================================= |
117 | //function : SetPave1 |
118 | //purpose : |
119 | //======================================================================= |
120 | void BOPDS_PaveBlock::SetPave1(const BOPDS_Pave& thePave) |
121 | { |
122 | myPave1=thePave; |
123 | } |
124 | //======================================================================= |
125 | //function : Pave1 |
126 | //purpose : |
127 | //======================================================================= |
128 | const BOPDS_Pave& BOPDS_PaveBlock::Pave1()const |
129 | { |
130 | return myPave1; |
131 | } |
132 | //======================================================================= |
133 | //function : SetPave2 |
134 | //purpose : |
135 | //======================================================================= |
136 | void BOPDS_PaveBlock::SetPave2(const BOPDS_Pave& thePave) |
137 | { |
138 | myPave2=thePave; |
139 | } |
140 | //======================================================================= |
141 | //function : Pave2 |
142 | //purpose : |
143 | //======================================================================= |
144 | const BOPDS_Pave& BOPDS_PaveBlock::Pave2()const |
145 | { |
146 | return myPave2; |
147 | } |
148 | //======================================================================= |
149 | //function : Range |
150 | //purpose : |
151 | //======================================================================= |
152 | void BOPDS_PaveBlock::Range(Standard_Real& theT1, |
153 | Standard_Real& theT2)const |
154 | { |
155 | theT1=myPave1.Parameter(); |
156 | theT2=myPave2.Parameter(); |
157 | } |
158 | //======================================================================= |
159 | //function : Indices |
160 | //purpose : |
161 | //======================================================================= |
162 | void BOPDS_PaveBlock::Indices(Standard_Integer& theIndex1, |
163 | Standard_Integer& theIndex2)const |
164 | { |
165 | theIndex1=myPave1.Index(); |
166 | theIndex2=myPave2.Index(); |
167 | } |
168 | //======================================================================= |
169 | //function : HasSameBounds |
170 | //purpose : |
171 | //======================================================================= |
172 | Standard_Boolean BOPDS_PaveBlock::HasSameBounds(const Handle(BOPDS_PaveBlock)& theOther)const |
173 | { |
174 | Standard_Boolean bFlag1, bFlag2; |
175 | Standard_Integer n11, n12, n21, n22; |
176 | // |
177 | Indices(n11, n12); |
178 | theOther->Indices(n21, n22); |
179 | // |
180 | bFlag1=(n11==n21) && (n12==n22); |
181 | bFlag2=(n11==n22) && (n12==n21); |
182 | // |
183 | return (bFlag1 || bFlag2); |
184 | } |
185 | |
186 | |
187 | // |
188 | // Extras |
189 | // |
190 | //======================================================================= |
191 | //function : AppendExtPave |
192 | //purpose : |
193 | //======================================================================= |
194 | void BOPDS_PaveBlock::AppendExtPave(const BOPDS_Pave& thePave) |
195 | { |
196 | if (myMFence.Add(thePave.Index())) { |
197 | myExtPaves.Append(thePave); |
198 | } |
199 | } |
200 | //======================================================================= |
201 | //function : AppendExtPave1 |
202 | //purpose : |
203 | //======================================================================= |
204 | void BOPDS_PaveBlock::AppendExtPave1(const BOPDS_Pave& thePave) |
205 | { |
206 | myExtPaves.Append(thePave); |
207 | } |
208 | //======================================================================= |
209 | //function : ExtPaves |
210 | //purpose : |
211 | //======================================================================= |
212 | const BOPDS_ListOfPave& BOPDS_PaveBlock::ExtPaves()const |
213 | { |
214 | return myExtPaves; |
215 | } |
216 | //======================================================================= |
217 | //function : ChangeExtPaves |
218 | //purpose : |
219 | //======================================================================= |
220 | BOPDS_ListOfPave& BOPDS_PaveBlock::ChangeExtPaves() |
221 | { |
222 | return myExtPaves; |
223 | } |
224 | //======================================================================= |
225 | //function : IsToUpdate |
226 | //purpose : |
227 | //======================================================================= |
228 | Standard_Boolean BOPDS_PaveBlock::IsToUpdate()const |
229 | { |
230 | return !myExtPaves.IsEmpty(); |
231 | } |
232 | //======================================================================= |
233 | //function : ContainsParameter |
234 | //purpose : |
235 | //======================================================================= |
236 | Standard_Boolean BOPDS_PaveBlock::ContainsParameter(const Standard_Real theT, |
237 | const Standard_Real theTol)const |
238 | { |
239 | Standard_Boolean bRet; |
240 | Standard_Real dT; |
241 | BOPDS_ListIteratorOfListOfPave aIt; |
242 | // |
243 | bRet=Standard_False; |
244 | aIt.Initialize(myExtPaves); |
245 | for (; aIt.More(); aIt.Next()) { |
246 | dT=aIt.Value().Parameter()-theT; |
247 | if (dT<0.) { |
248 | dT=-dT; |
249 | } |
250 | if (dT<theTol) { |
251 | bRet=!bRet; |
252 | break; |
253 | } |
254 | } |
255 | return bRet; |
256 | } |
257 | //======================================================================= |
258 | //function : Update |
259 | //purpose : |
260 | //======================================================================= |
261 | void BOPDS_PaveBlock::Update(BOPDS_ListOfPaveBlock& theLPB, |
262 | const Standard_Boolean theFlag) |
263 | { |
264 | Standard_Integer i, aNb; |
265 | BOPDS_Pave *pPaves; |
266 | BOPDS_Pave aPave1, aPave2; |
267 | Handle(BOPDS_PaveBlock) aPB; |
268 | BOPDS_ListIteratorOfListOfPave aIt; |
269 | // |
270 | aNb=myExtPaves.Extent(); |
271 | if (theFlag) { |
272 | aNb=aNb+2; |
273 | } |
274 | // |
275 | pPaves=(BOPDS_Pave *)myAllocator->Allocate(aNb*sizeof(BOPDS_Pave)); |
276 | for (i=0; i<aNb; ++i) { |
277 | new (pPaves+i) BOPDS_Pave(); |
278 | } |
279 | // |
280 | i=0; |
281 | if (theFlag) { |
282 | pPaves[i]=myPave1; |
283 | ++i; |
284 | pPaves[i]=myPave2; |
285 | ++i; |
286 | } |
287 | // |
288 | aIt.Initialize(myExtPaves); |
289 | for (; aIt.More(); aIt.Next()) { |
290 | const BOPDS_Pave& aPave=aIt.Value(); |
291 | pPaves[i]=(aPave); |
292 | ++i; |
293 | } |
294 | myExtPaves.Clear(); |
295 | myMFence.Clear(); |
296 | // |
297 | SortShell(aNb, pPaves); |
298 | // |
299 | for (i=0; i<aNb; ++i) { |
300 | const BOPDS_Pave& aPave=pPaves[i]; |
301 | if (!i) { |
302 | aPave1=aPave; |
303 | continue; |
304 | } |
305 | // |
306 | aPave2=aPave; |
307 | aPB=new BOPDS_PaveBlock; |
308 | aPB->SetOriginalEdge(myOriginalEdge); |
309 | aPB->SetPave1(aPave1); |
310 | aPB->SetPave2(aPave2); |
311 | // |
312 | theLPB.Append(aPB); |
313 | // |
314 | aPave1=aPave2; |
315 | } |
316 | // |
317 | for (i=0; i<aNb; ++i) { |
318 | pPaves[i].~BOPDS_Pave(); |
319 | } |
320 | myAllocator->Free((Standard_Address&)pPaves); |
321 | } |
322 | |
323 | //======================================================================= |
324 | // function: SortShell |
325 | // purpose : |
326 | //======================================================================= |
327 | void SortShell(const int n, BOPDS_Pave *a) |
328 | { |
329 | int nd, i, j, l, d=1; |
330 | BOPDS_Pave x; |
331 | // |
332 | while(d<=n) { |
333 | d*=2; |
334 | } |
335 | // |
336 | while (d) { |
337 | d=(d-1)/2; |
338 | // |
339 | nd=n-d; |
340 | for (i=0; i<nd; ++i) { |
341 | j=i; |
342 | m30:; |
343 | l=j+d; |
344 | if (a[l] < a[j]){ |
345 | x=a[j]; |
346 | a[j]=a[l]; |
347 | a[l]=x; |
348 | j-=d; |
349 | if (j > -1) goto m30; |
350 | }//if (a[l] < a[j]){ |
351 | }//for (i=0; i<nd; ++i) |
352 | }//while (1) |
353 | } |
5a77460e |
354 | |
4e57c75e |
355 | // ShrunkData |
356 | //======================================================================= |
357 | //function : HasShrunkData |
358 | //purpose : |
359 | //======================================================================= |
360 | Standard_Boolean BOPDS_PaveBlock::HasShrunkData()const |
361 | { |
362 | return (!myShrunkBox.IsVoid()); |
363 | } |
364 | //======================================================================= |
365 | //function : SetShrunkData |
366 | //purpose : |
367 | //======================================================================= |
368 | void BOPDS_PaveBlock::SetShrunkData(const Standard_Real theT1, |
369 | const Standard_Real theT2, |
370 | const Bnd_Box& theBox) |
371 | { |
372 | myTS1=theT1; |
373 | myTS2=theT2; |
374 | myShrunkBox=theBox; |
375 | } |
376 | //======================================================================= |
377 | //function : ShrunkData |
378 | //purpose : |
379 | //======================================================================= |
380 | void BOPDS_PaveBlock::ShrunkData(Standard_Real& theT1, |
381 | Standard_Real& theT2, |
382 | Bnd_Box& theBox)const |
383 | { |
384 | theT1=myTS1; |
385 | theT2=myTS2; |
386 | theBox=myShrunkBox; |
387 | } |
388 | //======================================================================= |
389 | //function : Dump |
390 | //purpose : |
391 | //======================================================================= |
392 | void BOPDS_PaveBlock::Dump()const |
393 | { |
394 | printf(" PB:{ E:%d orE:%d", myEdge, myOriginalEdge); |
395 | printf(" Pave1:"); |
396 | myPave1.Dump(); |
397 | printf(" Pave2:"); |
398 | myPave2.Dump(); |
399 | printf(" }"); |
400 | } |