basegfx/source/polygon/b3dpolypolygontools.cxx

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