Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <rtl/instance.hxx>
21 : #include <basegfx/polygon/b3dpolypolygontools.hxx>
22 : #include <basegfx/range/b3drange.hxx>
23 : #include <basegfx/polygon/b3dpolypolygon.hxx>
24 : #include <basegfx/polygon/b3dpolygon.hxx>
25 : #include <basegfx/polygon/b3dpolygontools.hxx>
26 : #include <numeric>
27 : #include <basegfx/matrix/b3dhommatrix.hxx>
28 : #include <basegfx/numeric/ftools.hxx>
29 : #include <com/sun/star/drawing/DoubleSequence.hpp>
30 :
31 :
32 : // predefines
33 : #define nMinSegments sal_uInt32(1)
34 : #define nMaxSegments sal_uInt32(512)
35 :
36 :
37 :
38 : namespace basegfx
39 : {
40 : namespace tools
41 : {
42 : // B3DPolyPolygon tools
43 0 : B3DRange getRange(const B3DPolyPolygon& rCandidate)
44 : {
45 0 : B3DRange aRetval;
46 0 : const sal_uInt32 nPolygonCount(rCandidate.count());
47 :
48 0 : for(sal_uInt32 a(0L); a < nPolygonCount; a++)
49 : {
50 0 : B3DPolygon aCandidate = rCandidate.getB3DPolygon(a);
51 0 : aRetval.expand(getRange(aCandidate));
52 0 : }
53 :
54 0 : return aRetval;
55 : }
56 :
57 : namespace
58 : {
59 : struct theUnitCubePolyPolygon : public rtl::StaticWithInit<B3DPolyPolygon,
60 : theUnitCubePolyPolygon>
61 : {
62 0 : B3DPolyPolygon operator()()
63 : {
64 0 : B3DPolyPolygon aRetval;
65 0 : B3DPolygon aTemp;
66 0 : aTemp.append(B3DPoint(0.0, 0.0, 1.0));
67 0 : aTemp.append(B3DPoint(0.0, 1.0, 1.0));
68 0 : aTemp.append(B3DPoint(1.0, 1.0, 1.0));
69 0 : aTemp.append(B3DPoint(1.0, 0.0, 1.0));
70 0 : aTemp.setClosed(true);
71 0 : aRetval.append(aTemp);
72 :
73 0 : aTemp.clear();
74 0 : aTemp.append(B3DPoint(0.0, 0.0, 0.0));
75 0 : aTemp.append(B3DPoint(0.0, 1.0, 0.0));
76 0 : aTemp.append(B3DPoint(1.0, 1.0, 0.0));
77 0 : aTemp.append(B3DPoint(1.0, 0.0, 0.0));
78 0 : aTemp.setClosed(true);
79 0 : aRetval.append(aTemp);
80 :
81 0 : aTemp.clear();
82 0 : aTemp.append(B3DPoint(0.0, 0.0, 0.0));
83 0 : aTemp.append(B3DPoint(0.0, 0.0, 1.0));
84 0 : aRetval.append(aTemp);
85 :
86 0 : aTemp.clear();
87 0 : aTemp.append(B3DPoint(0.0, 1.0, 0.0));
88 0 : aTemp.append(B3DPoint(0.0, 1.0, 1.0));
89 0 : aRetval.append(aTemp);
90 :
91 0 : aTemp.clear();
92 0 : aTemp.append(B3DPoint(1.0, 1.0, 0.0));
93 0 : aTemp.append(B3DPoint(1.0, 1.0, 1.0));
94 0 : aRetval.append(aTemp);
95 :
96 0 : aTemp.clear();
97 0 : aTemp.append(B3DPoint(1.0, 0.0, 0.0));
98 0 : aTemp.append(B3DPoint(1.0, 0.0, 1.0));
99 0 : aRetval.append(aTemp);
100 0 : return aRetval;
101 : }
102 : };
103 : }
104 :
105 0 : B3DPolyPolygon createUnitCubePolyPolygon()
106 : {
107 0 : return theUnitCubePolyPolygon::get();
108 : }
109 :
110 : namespace
111 : {
112 : struct theUnitCubeFillPolyPolygon : public rtl::StaticWithInit<B3DPolyPolygon,
113 : theUnitCubeFillPolyPolygon>
114 : {
115 0 : B3DPolyPolygon operator()()
116 : {
117 0 : B3DPolyPolygon aRetval;
118 0 : B3DPolygon aTemp;
119 :
120 : // all points
121 0 : const B3DPoint A(0.0, 0.0, 0.0);
122 0 : const B3DPoint B(0.0, 1.0, 0.0);
123 0 : const B3DPoint C(1.0, 1.0, 0.0);
124 0 : const B3DPoint D(1.0, 0.0, 0.0);
125 0 : const B3DPoint E(0.0, 0.0, 1.0);
126 0 : const B3DPoint F(0.0, 1.0, 1.0);
127 0 : const B3DPoint G(1.0, 1.0, 1.0);
128 0 : const B3DPoint H(1.0, 0.0, 1.0);
129 :
130 : // create bottom
131 0 : aTemp.append(D);
132 0 : aTemp.append(A);
133 0 : aTemp.append(E);
134 0 : aTemp.append(H);
135 0 : aTemp.setClosed(true);
136 0 : aRetval.append(aTemp);
137 :
138 : // create front
139 0 : aTemp.clear();
140 0 : aTemp.append(B);
141 0 : aTemp.append(A);
142 0 : aTemp.append(D);
143 0 : aTemp.append(C);
144 0 : aTemp.setClosed(true);
145 0 : aRetval.append(aTemp);
146 :
147 : // create left
148 0 : aTemp.clear();
149 0 : aTemp.append(E);
150 0 : aTemp.append(A);
151 0 : aTemp.append(B);
152 0 : aTemp.append(F);
153 0 : aTemp.setClosed(true);
154 0 : aRetval.append(aTemp);
155 :
156 : // create top
157 0 : aTemp.clear();
158 0 : aTemp.append(C);
159 0 : aTemp.append(G);
160 0 : aTemp.append(F);
161 0 : aTemp.append(B);
162 0 : aTemp.setClosed(true);
163 0 : aRetval.append(aTemp);
164 :
165 : // create right
166 0 : aTemp.clear();
167 0 : aTemp.append(H);
168 0 : aTemp.append(G);
169 0 : aTemp.append(C);
170 0 : aTemp.append(D);
171 0 : aTemp.setClosed(true);
172 0 : aRetval.append(aTemp);
173 :
174 : // create back
175 0 : aTemp.clear();
176 0 : aTemp.append(F);
177 0 : aTemp.append(G);
178 0 : aTemp.append(H);
179 0 : aTemp.append(E);
180 0 : aTemp.setClosed(true);
181 0 : aRetval.append(aTemp);
182 0 : return aRetval;
183 : }
184 : };
185 : }
186 :
187 0 : B3DPolyPolygon createUnitCubeFillPolyPolygon()
188 : {
189 0 : return theUnitCubeFillPolyPolygon::get();
190 : }
191 :
192 0 : B3DPolyPolygon createCubePolyPolygonFromB3DRange( const B3DRange& rRange)
193 : {
194 0 : B3DPolyPolygon aRetval;
195 :
196 0 : if(!rRange.isEmpty())
197 : {
198 0 : aRetval = createUnitCubePolyPolygon();
199 0 : B3DHomMatrix aTrans;
200 0 : aTrans.scale(rRange.getWidth(), rRange.getHeight(), rRange.getDepth());
201 0 : aTrans.translate(rRange.getMinX(), rRange.getMinY(), rRange.getMinZ());
202 0 : aRetval.transform(aTrans);
203 0 : aRetval.removeDoublePoints();
204 : }
205 :
206 0 : return aRetval;
207 : }
208 :
209 0 : B3DPolyPolygon createCubeFillPolyPolygonFromB3DRange( const B3DRange& rRange)
210 : {
211 0 : B3DPolyPolygon aRetval;
212 :
213 0 : if(!rRange.isEmpty())
214 : {
215 0 : aRetval = createUnitCubeFillPolyPolygon();
216 0 : B3DHomMatrix aTrans;
217 0 : aTrans.scale(rRange.getWidth(), rRange.getHeight(), rRange.getDepth());
218 0 : aTrans.translate(rRange.getMinX(), rRange.getMinY(), rRange.getMinZ());
219 0 : aRetval.transform(aTrans);
220 0 : aRetval.removeDoublePoints();
221 : }
222 :
223 0 : return aRetval;
224 : }
225 :
226 : // helper for getting the 3D Point from given cartesian coordiantes. fVer is defined from
227 : // [F_PI2 .. -F_PI2], fHor from [0.0 .. F_2PI]
228 0 : inline B3DPoint getPointFromCartesian(double fVer, double fHor)
229 : {
230 0 : const double fCosHor(cos(fHor));
231 0 : return B3DPoint(fCosHor * cos(fVer), sin(fHor), fCosHor * -sin(fVer));
232 : }
233 :
234 0 : B3DPolyPolygon createUnitSpherePolyPolygon(
235 : sal_uInt32 nHorSeg, sal_uInt32 nVerSeg,
236 : double fVerStart, double fVerStop,
237 : double fHorStart, double fHorStop)
238 : {
239 0 : B3DPolyPolygon aRetval;
240 : sal_uInt32 a, b;
241 :
242 0 : if(!nHorSeg)
243 : {
244 0 : nHorSeg = fround(fabs(fHorStop - fHorStart) / (F_2PI / 24.0));
245 : }
246 :
247 : // min/max limitations
248 0 : nHorSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nHorSeg));
249 :
250 0 : if(!nVerSeg)
251 : {
252 0 : nVerSeg = fround(fabs(fVerStop - fVerStart) / (F_2PI / 24.0));
253 : }
254 :
255 : // min/max limitations
256 0 : nVerSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nVerSeg));
257 :
258 : // create constants
259 0 : const double fVerDiffPerStep((fVerStop - fVerStart) / (double)nVerSeg);
260 0 : const double fHorDiffPerStep((fHorStop - fHorStart) / (double)nHorSeg);
261 0 : bool bHorClosed(fTools::equal(fHorStop - fHorStart, F_2PI));
262 0 : bool bVerFromTop(fTools::equal(fVerStart, F_PI2));
263 0 : bool bVerToBottom(fTools::equal(fVerStop, -F_PI2));
264 :
265 : // create horizontal rings
266 0 : const sal_uInt32 nLoopVerInit(bVerFromTop ? 1L : 0L);
267 0 : const sal_uInt32 nLoopVerLimit(bVerToBottom ? nVerSeg : nVerSeg + 1L);
268 0 : const sal_uInt32 nLoopHorLimit(bHorClosed ? nHorSeg : nHorSeg + 1L);
269 :
270 0 : for(a = nLoopVerInit; a < nLoopVerLimit; a++)
271 : {
272 0 : const double fVer(fVerStart + ((double)(a) * fVerDiffPerStep));
273 0 : B3DPolygon aNew;
274 :
275 0 : for(b = 0L; b < nLoopHorLimit; b++)
276 : {
277 0 : const double fHor(fHorStart + ((double)(b) * fHorDiffPerStep));
278 0 : aNew.append(getPointFromCartesian(fHor, fVer));
279 : }
280 :
281 0 : aNew.setClosed(bHorClosed);
282 0 : aRetval.append(aNew);
283 0 : }
284 :
285 : // create vertical half-rings
286 0 : for(a = 0L; a < nLoopHorLimit; a++)
287 : {
288 0 : const double fHor(fHorStart + ((double)(a) * fHorDiffPerStep));
289 0 : B3DPolygon aNew;
290 :
291 0 : if(bVerFromTop)
292 : {
293 0 : aNew.append(B3DPoint(0.0, 1.0, 0.0));
294 : }
295 :
296 0 : for(b = nLoopVerInit; b < nLoopVerLimit; b++)
297 : {
298 0 : const double fVer(fVerStart + ((double)(b) * fVerDiffPerStep));
299 0 : aNew.append(getPointFromCartesian(fHor, fVer));
300 : }
301 :
302 0 : if(bVerToBottom)
303 : {
304 0 : aNew.append(B3DPoint(0.0, -1.0, 0.0));
305 : }
306 :
307 0 : aRetval.append(aNew);
308 0 : }
309 :
310 0 : return aRetval;
311 : }
312 :
313 0 : B3DPolyPolygon createSpherePolyPolygonFromB3DRange( const B3DRange& rRange,
314 : sal_uInt32 nHorSeg, sal_uInt32 nVerSeg,
315 : double fVerStart, double fVerStop,
316 : double fHorStart, double fHorStop)
317 : {
318 0 : B3DPolyPolygon aRetval(createUnitSpherePolyPolygon(nHorSeg, nVerSeg, fVerStart, fVerStop, fHorStart, fHorStop));
319 :
320 0 : if(aRetval.count())
321 : {
322 : // move and scale whole construct which is now in [-1.0 .. 1.0] in all directions
323 0 : B3DHomMatrix aTrans;
324 0 : aTrans.translate(1.0, 1.0, 1.0);
325 0 : aTrans.scale(rRange.getWidth() / 2.0, rRange.getHeight() / 2.0, rRange.getDepth() / 2.0);
326 0 : aTrans.translate(rRange.getMinX(), rRange.getMinY(), rRange.getMinZ());
327 0 : aRetval.transform(aTrans);
328 : }
329 :
330 0 : return aRetval;
331 : }
332 :
333 0 : B3DPolyPolygon createUnitSphereFillPolyPolygon(
334 : sal_uInt32 nHorSeg, sal_uInt32 nVerSeg,
335 : bool bNormals,
336 : double fVerStart, double fVerStop,
337 : double fHorStart, double fHorStop)
338 : {
339 0 : B3DPolyPolygon aRetval;
340 :
341 0 : if(!nHorSeg)
342 : {
343 0 : nHorSeg = fround(fabs(fHorStop - fHorStart) / (F_2PI / 24.0));
344 : }
345 :
346 : // min/max limitations
347 0 : nHorSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nHorSeg));
348 :
349 0 : if(!nVerSeg)
350 : {
351 0 : nVerSeg = fround(fabs(fVerStop - fVerStart) / (F_2PI / 24.0));
352 : }
353 :
354 : // min/max limitations
355 0 : nVerSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nVerSeg));
356 :
357 : // vertical loop
358 0 : for(sal_uInt32 a(0L); a < nVerSeg; a++)
359 : {
360 0 : const double fVer(fVerStart + (((fVerStop - fVerStart) * a) / nVerSeg));
361 0 : const double fVer2(fVerStart + (((fVerStop - fVerStart) * (a + 1)) / nVerSeg));
362 :
363 : // horizontal loop
364 0 : for(sal_uInt32 b(0L); b < nHorSeg; b++)
365 : {
366 0 : const double fHor(fHorStart + (((fHorStop - fHorStart) * b) / nHorSeg));
367 0 : const double fHor2(fHorStart + (((fHorStop - fHorStart) * (b + 1)) / nHorSeg));
368 0 : B3DPolygon aNew;
369 :
370 0 : aNew.append(getPointFromCartesian(fHor, fVer));
371 0 : aNew.append(getPointFromCartesian(fHor2, fVer));
372 0 : aNew.append(getPointFromCartesian(fHor2, fVer2));
373 0 : aNew.append(getPointFromCartesian(fHor, fVer2));
374 :
375 0 : if(bNormals)
376 : {
377 0 : for(sal_uInt32 c(0L); c < aNew.count(); c++)
378 : {
379 0 : aNew.setNormal(c, ::basegfx::B3DVector(aNew.getB3DPoint(c)));
380 : }
381 : }
382 :
383 0 : aNew.setClosed(true);
384 0 : aRetval.append(aNew);
385 0 : }
386 : }
387 :
388 0 : return aRetval;
389 : }
390 :
391 0 : B3DPolyPolygon createSphereFillPolyPolygonFromB3DRange( const B3DRange& rRange,
392 : sal_uInt32 nHorSeg, sal_uInt32 nVerSeg,
393 : bool bNormals,
394 : double fVerStart, double fVerStop,
395 : double fHorStart, double fHorStop)
396 : {
397 0 : B3DPolyPolygon aRetval(createUnitSphereFillPolyPolygon(nHorSeg, nVerSeg, bNormals, fVerStart, fVerStop, fHorStart, fHorStop));
398 :
399 0 : if(aRetval.count())
400 : {
401 : // move and scale whole construct which is now in [-1.0 .. 1.0] in all directions
402 0 : B3DHomMatrix aTrans;
403 0 : aTrans.translate(1.0, 1.0, 1.0);
404 0 : aTrans.scale(rRange.getWidth() / 2.0, rRange.getHeight() / 2.0, rRange.getDepth() / 2.0);
405 0 : aTrans.translate(rRange.getMinX(), rRange.getMinY(), rRange.getMinZ());
406 0 : aRetval.transform(aTrans);
407 : }
408 :
409 0 : return aRetval;
410 : }
411 :
412 0 : B3DPolyPolygon applyDefaultNormalsSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter)
413 : {
414 0 : B3DPolyPolygon aRetval;
415 :
416 0 : for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
417 : {
418 0 : aRetval.append(applyDefaultNormalsSphere(rCandidate.getB3DPolygon(a), rCenter));
419 : }
420 :
421 0 : return aRetval;
422 : }
423 :
424 0 : B3DPolyPolygon invertNormals( const B3DPolyPolygon& rCandidate)
425 : {
426 0 : B3DPolyPolygon aRetval;
427 :
428 0 : for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
429 : {
430 0 : aRetval.append(invertNormals(rCandidate.getB3DPolygon(a)));
431 : }
432 :
433 0 : return aRetval;
434 : }
435 :
436 0 : B3DPolyPolygon applyDefaultTextureCoordinatesParallel( const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bChangeX, bool bChangeY)
437 : {
438 0 : B3DPolyPolygon aRetval;
439 :
440 0 : for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
441 : {
442 0 : aRetval.append(applyDefaultTextureCoordinatesParallel(rCandidate.getB3DPolygon(a), rRange, bChangeX, bChangeY));
443 : }
444 :
445 0 : return aRetval;
446 : }
447 :
448 0 : B3DPolyPolygon applyDefaultTextureCoordinatesSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX, bool bChangeY)
449 : {
450 0 : B3DPolyPolygon aRetval;
451 :
452 0 : for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
453 : {
454 0 : aRetval.append(applyDefaultTextureCoordinatesSphere(rCandidate.getB3DPolygon(a), rCenter, bChangeX, bChangeY));
455 : }
456 :
457 0 : return aRetval;
458 : }
459 :
460 0 : bool isInside(const B3DPolyPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder)
461 : {
462 0 : const sal_uInt32 nPolygonCount(rCandidate.count());
463 :
464 0 : if(1L == nPolygonCount)
465 : {
466 0 : return isInside(rCandidate.getB3DPolygon(0), rPoint, bWithBorder);
467 : }
468 : else
469 : {
470 0 : sal_Int32 nInsideCount(0);
471 :
472 0 : for(sal_uInt32 a(0); a < nPolygonCount; a++)
473 : {
474 0 : const B3DPolygon aPolygon(rCandidate.getB3DPolygon(a));
475 0 : const bool bInside(isInside(aPolygon, rPoint, bWithBorder));
476 :
477 0 : if(bInside)
478 : {
479 0 : nInsideCount++;
480 : }
481 0 : }
482 :
483 0 : return (nInsideCount % 2L);
484 : }
485 : }
486 :
487 : /// converters for com::sun::star::drawing::PolyPolygonShape3D
488 0 : B3DPolyPolygon UnoPolyPolygonShape3DToB3DPolyPolygon(
489 : const com::sun::star::drawing::PolyPolygonShape3D& rPolyPolygonShape3DSource,
490 : bool bCheckClosed)
491 : {
492 0 : B3DPolyPolygon aRetval;
493 0 : const sal_Int32 nOuterSequenceCount(rPolyPolygonShape3DSource.SequenceX.getLength());
494 :
495 0 : if(nOuterSequenceCount)
496 : {
497 : OSL_ENSURE(nOuterSequenceCount == rPolyPolygonShape3DSource.SequenceY.getLength()
498 : && nOuterSequenceCount == rPolyPolygonShape3DSource.SequenceZ.getLength(),
499 : "UnoPolyPolygonShape3DToB3DPolygon: Not all double sequences have the same length (!)");
500 :
501 0 : const com::sun::star::drawing::DoubleSequence* pInnerSequenceX = rPolyPolygonShape3DSource.SequenceX.getConstArray();
502 0 : const com::sun::star::drawing::DoubleSequence* pInnerSequenceY = rPolyPolygonShape3DSource.SequenceY.getConstArray();
503 0 : const com::sun::star::drawing::DoubleSequence* pInnerSequenceZ = rPolyPolygonShape3DSource.SequenceZ.getConstArray();
504 :
505 0 : for(sal_Int32 a(0); a < nOuterSequenceCount; a++)
506 : {
507 0 : basegfx::B3DPolygon aNewPolygon;
508 0 : const sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength());
509 : OSL_ENSURE(nInnerSequenceCount == pInnerSequenceY->getLength()
510 : && nInnerSequenceCount == pInnerSequenceZ->getLength(),
511 : "UnoPolyPolygonShape3DToB3DPolygon: Not all double sequences have the same length (!)");
512 :
513 0 : const double* pArrayX = pInnerSequenceX->getConstArray();
514 0 : const double* pArrayY = pInnerSequenceY->getConstArray();
515 0 : const double* pArrayZ = pInnerSequenceZ->getConstArray();
516 :
517 0 : for(sal_Int32 b(0); b < nInnerSequenceCount; b++)
518 : {
519 0 : aNewPolygon.append(basegfx::B3DPoint(*pArrayX++,*pArrayY++,*pArrayZ++));
520 : }
521 :
522 0 : pInnerSequenceX++;
523 0 : pInnerSequenceY++;
524 0 : pInnerSequenceZ++;
525 :
526 : // #i101520# correction is needed for imported polygons of old format,
527 : // see callers
528 0 : if(bCheckClosed)
529 : {
530 0 : basegfx::tools::checkClosed(aNewPolygon);
531 : }
532 :
533 0 : aRetval.append(aNewPolygon);
534 0 : }
535 : }
536 :
537 0 : return aRetval;
538 : }
539 :
540 0 : void B3DPolyPolygonToUnoPolyPolygonShape3D(
541 : const B3DPolyPolygon& rPolyPolygonSource,
542 : com::sun::star::drawing::PolyPolygonShape3D& rPolyPolygonShape3DRetval)
543 : {
544 0 : const sal_uInt32 nPolygonCount(rPolyPolygonSource.count());
545 :
546 0 : if(nPolygonCount)
547 : {
548 0 : rPolyPolygonShape3DRetval.SequenceX.realloc(nPolygonCount);
549 0 : rPolyPolygonShape3DRetval.SequenceY.realloc(nPolygonCount);
550 0 : rPolyPolygonShape3DRetval.SequenceZ.realloc(nPolygonCount);
551 :
552 0 : com::sun::star::drawing::DoubleSequence* pOuterSequenceX = rPolyPolygonShape3DRetval.SequenceX.getArray();
553 0 : com::sun::star::drawing::DoubleSequence* pOuterSequenceY = rPolyPolygonShape3DRetval.SequenceY.getArray();
554 0 : com::sun::star::drawing::DoubleSequence* pOuterSequenceZ = rPolyPolygonShape3DRetval.SequenceZ.getArray();
555 :
556 0 : for(sal_uInt32 a(0); a < nPolygonCount; a++)
557 : {
558 0 : const basegfx::B3DPolygon aPoly(rPolyPolygonSource.getB3DPolygon(a));
559 0 : const sal_uInt32 nPointCount(aPoly.count());
560 :
561 0 : if(nPointCount)
562 : {
563 0 : const bool bIsClosed(aPoly.isClosed());
564 0 : const sal_uInt32 nTargetCount(bIsClosed ? nPointCount + 1 : nPointCount);
565 0 : pOuterSequenceX->realloc(nTargetCount);
566 0 : pOuterSequenceY->realloc(nTargetCount);
567 0 : pOuterSequenceZ->realloc(nTargetCount);
568 :
569 0 : double* pInnerSequenceX = pOuterSequenceX->getArray();
570 0 : double* pInnerSequenceY = pOuterSequenceY->getArray();
571 0 : double* pInnerSequenceZ = pOuterSequenceZ->getArray();
572 :
573 0 : for(sal_uInt32 b(0); b < nPointCount; b++)
574 : {
575 0 : const basegfx::B3DPoint aPoint(aPoly.getB3DPoint(b));
576 :
577 0 : *pInnerSequenceX++ = aPoint.getX();
578 0 : *pInnerSequenceY++ = aPoint.getY();
579 0 : *pInnerSequenceZ++ = aPoint.getZ();
580 0 : }
581 :
582 0 : if(bIsClosed)
583 : {
584 0 : const basegfx::B3DPoint aPoint(aPoly.getB3DPoint(0));
585 :
586 0 : *pInnerSequenceX++ = aPoint.getX();
587 0 : *pInnerSequenceY++ = aPoint.getY();
588 0 : *pInnerSequenceZ++ = aPoint.getZ();
589 : }
590 : }
591 : else
592 : {
593 0 : pOuterSequenceX->realloc(0);
594 0 : pOuterSequenceY->realloc(0);
595 0 : pOuterSequenceZ->realloc(0);
596 : }
597 :
598 0 : pOuterSequenceX++;
599 0 : pOuterSequenceY++;
600 0 : pOuterSequenceZ++;
601 0 : }
602 : }
603 : else
604 : {
605 0 : rPolyPolygonShape3DRetval.SequenceX.realloc(0);
606 0 : rPolyPolygonShape3DRetval.SequenceY.realloc(0);
607 0 : rPolyPolygonShape3DRetval.SequenceZ.realloc(0);
608 : }
609 0 : }
610 :
611 : } // end of namespace tools
612 : } // end of namespace basegfx
613 :
614 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
