basegfx/source/polygon/b2dpolypolygontools.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 <basegfx/polygon/b2dpolypolygontools.hxx>
  21 #include <osl/diagnose.h>
  22 #include <basegfx/polygon/b2dpolypolygon.hxx>
  23 #include <basegfx/polygon/b2dpolygon.hxx>
  24 #include <basegfx/polygon/b2dpolygontools.hxx>
  25 #include <basegfx/numeric/ftools.hxx>
  26 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  27 #include <numeric>
  28
  29 namespace basegfx
  30 {
  31     namespace utils
  32     {
  33         B2DPolyPolygon correctOrientations(const B2DPolyPolygon& rCandidate)
  34         {
  35             B2DPolyPolygon aRetval(rCandidate);
  36             const sal_uInt32 nCount(aRetval.count());
  37
  38             for(sal_uInt32 a(0); a < nCount; a++)
  39             {
  40                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
  41                 const B2VectorOrientation aOrientation(utils::getOrientation(aCandidate));
  42                 sal_uInt32 nDepth(0);
  43
  44                 for(sal_uInt32 b(0); b < nCount; b++)
  45                 {
  46                     if(b != a)
  47                     {
  48                         const B2DPolygon aCompare(rCandidate.getB2DPolygon(b));
  49
  50                         if(utils::isInside(aCompare, aCandidate, true))
  51                         {
  52                             nDepth++;
  53                         }
  54                     }
  55                 }
  56
  57                 const bool bShallBeHole((nDepth & 0x00000001) == 1);
  58                 const bool bIsHole(aOrientation == B2VectorOrientation::Negative);
  59
  60                 if(bShallBeHole != bIsHole && aOrientation != B2VectorOrientation::Neutral)
  61                 {
  62                     B2DPolygon aFlipped(aCandidate);
  63                     aFlipped.flip();
  64                     aRetval.setB2DPolygon(a, aFlipped);
  65                 }
  66             }
  67
  68             return aRetval;
  69         }
  70
  71         B2DPolyPolygon correctOutmostPolygon(const B2DPolyPolygon& rCandidate)
  72         {
  73             const sal_uInt32 nCount(rCandidate.count());
  74
  75             if(nCount > 1)
  76             {
  77                 for(sal_uInt32 a(0); a < nCount; a++)
  78                 {
  79                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
  80                     sal_uInt32 nDepth(0);
  81
  82                     for(sal_uInt32 b(0); b < nCount; b++)
  83                     {
  84                         if(b != a)
  85                         {
  86                             const B2DPolygon aCompare(rCandidate.getB2DPolygon(b));
  87
  88                             if(utils::isInside(aCompare, aCandidate, true))
  89                             {
  90                                 nDepth++;
  91                             }
  92                         }
  93                     }
  94
  95                     if(!nDepth)
  96                     {
  97                         B2DPolyPolygon aRetval(rCandidate);
  98
  99                         if(a != 0)
 100                         {
 101                             // exchange polygon a and polygon 0
 102                             aRetval.setB2DPolygon(0, aCandidate);
 103                             aRetval.setB2DPolygon(a, rCandidate.getB2DPolygon(0));
 104                         }
 105
 106                         // exit
 107                         return aRetval;
 108                     }
 109                 }
 110             }
 111
 112             return rCandidate;
 113         }
 114
 115         B2DPolyPolygon adaptiveSubdivideByDistance(const B2DPolyPolygon& rCandidate, double fDistanceBound)
 116         {
 117             if(rCandidate.areControlPointsUsed())
 118             {
 119                 const sal_uInt32 nPolygonCount(rCandidate.count());
 120                 B2DPolyPolygon aRetval;
 121
 122                 for(sal_uInt32 a(0); a < nPolygonCount; a++)
 123                 {
 124                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 125
 126                     if(aCandidate.areControlPointsUsed())
 127                     {
 128                         aRetval.append(utils::adaptiveSubdivideByDistance(aCandidate, fDistanceBound));
 129                     }
 130                     else
 131                     {
 132                         aRetval.append(aCandidate);
 133                     }
 134                 }
 135
 136                 return aRetval;
 137             }
 138             else
 139             {
 140                 return rCandidate;
 141             }
 142         }
 143
 144         B2DPolyPolygon adaptiveSubdivideByAngle(const B2DPolyPolygon& rCandidate, double fAngleBound)
 145         {
 146             if(rCandidate.areControlPointsUsed())
 147             {
 148                 const sal_uInt32 nPolygonCount(rCandidate.count());
 149                 B2DPolyPolygon aRetval;
 150
 151                 for(sal_uInt32 a(0); a < nPolygonCount; a++)
 152                 {
 153                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 154
 155                     if(aCandidate.areControlPointsUsed())
 156                     {
 157                         aRetval.append(utils::adaptiveSubdivideByAngle(aCandidate, fAngleBound));
 158                     }
 159                     else
 160                     {
 161                         aRetval.append(aCandidate);
 162                     }
 163                 }
 164
 165                 return aRetval;
 166             }
 167             else
 168             {
 169                 return rCandidate;
 170             }
 171         }
 172
 173         bool isInside(const B2DPolyPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder)
 174         {
 175             const sal_uInt32 nPolygonCount(rCandidate.count());
 176
 177             if(nPolygonCount == 1)
 178             {
 179                 return isInside(rCandidate.getB2DPolygon(0), rPoint, bWithBorder);
 180             }
 181             else
 182             {
 183                 sal_Int32 nInsideCount(0);
 184
 185                 for(sal_uInt32 a(0); a < nPolygonCount; a++)
 186                 {
 187                     const B2DPolygon aPolygon(rCandidate.getB2DPolygon(a));
 188                     const bool bInside(isInside(aPolygon, rPoint, bWithBorder));
 189
 190                     if(bInside)
 191                     {
 192                         nInsideCount++;
 193                     }
 194                 }
 195
 196                 return (nInsideCount % 2);
 197             }
 198         }
 199
 200         B2DRange getRange(const B2DPolyPolygon& rCandidate)
 201         {
 202             B2DRange aRetval;
 203             const sal_uInt32 nPolygonCount(rCandidate.count());
 204
 205             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 206             {
 207                 B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
 208                 aRetval.expand(utils::getRange(aCandidate));
 209             }
 210
 211             return aRetval;
 212         }
 213
 214         double getSignedArea(const B2DPolyPolygon& rCandidate)
 215         {
 216             double fRetval(0.0);
 217             const sal_uInt32 nPolygonCount(rCandidate.count());
 218
 219             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 220             {
 221                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 222
 223                 fRetval += utils::getSignedArea(aCandidate);
 224             }
 225
 226             return fRetval;
 227         }
 228
 229         double getArea(const B2DPolyPolygon& rCandidate)
 230         {
 231             return fabs(getSignedArea(rCandidate));
 232         }
 233
 234         void applyLineDashing(const B2DPolyPolygon& rCandidate, const std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, double fFullDashDotLen)
 235         {
 236             if(fFullDashDotLen == 0.0 && rDotDashArray.size())
 237             {
 238                 // calculate fFullDashDotLen from rDotDashArray
 239                 fFullDashDotLen = std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
 240             }
 241
 242             if(rCandidate.count() && fFullDashDotLen > 0.0)
 243             {
 244                 B2DPolyPolygon aLineTarget;
 245
 246                 for(sal_uInt32 a(0); a < rCandidate.count(); a++)
 247                 {
 248                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 249
 250                     applyLineDashing(
 251                         aCandidate,
 252                         rDotDashArray,
 253                         pLineTarget ? &aLineTarget : nullptr,
 254                         nullptr,
 255                         fFullDashDotLen);
 256
 257                     if(pLineTarget)
 258                     {
 259                         pLineTarget->append(aLineTarget);
 260                     }
 261                 }
 262             }
 263         }
 264
 265         bool isInEpsilonRange(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance)
 266         {
 267             const sal_uInt32 nPolygonCount(rCandidate.count());
 268
 269             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 270             {
 271                 B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 272
 273                 if(isInEpsilonRange(aCandidate, rTestPosition, fDistance))
 274                 {
 275                     return true;
 276                 }
 277             }
 278
 279             return false;
 280         }
 281
 282         B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate)
 283         {
 284             const sal_uInt32 nPolygonCount(rCandidate.count());
 285             B3DPolyPolygon aRetval;
 286
 287             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 288             {
 289                 B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 290
 291                 aRetval.append(createB3DPolygonFromB2DPolygon(aCandidate, fZCoordinate));
 292             }
 293
 294             return aRetval;
 295         }
 296
 297         B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat)
 298         {
 299             const sal_uInt32 nPolygonCount(rCandidate.count());
 300             B2DPolyPolygon aRetval;
 301
 302             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 303             {
 304                 B3DPolygon aCandidate(rCandidate.getB3DPolygon(a));
 305
 306                 aRetval.append(createB2DPolygonFromB3DPolygon(aCandidate, rMat));
 307             }
 308
 309             return aRetval;
 310         }
 311
 312         double getSmallestDistancePointToPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rPolygonIndex, sal_uInt32& rEdgeIndex, double& rCut)
 313         {
 314             double fRetval(DBL_MAX);
 315             const double fZero(0.0);
 316             const sal_uInt32 nPolygonCount(rCandidate.count());
 317
 318             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 319             {
 320                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 321                 sal_uInt32 nNewEdgeIndex;
 322                 double fNewCut(0.0);
 323                 const double fNewDistance(getSmallestDistancePointToPolygon(aCandidate, rTestPoint, nNewEdgeIndex, fNewCut));
 324
 325                 if(fRetval == DBL_MAX || fNewDistance < fRetval)
 326                 {
 327                     fRetval = fNewDistance;
 328                     rPolygonIndex = a;
 329                     rEdgeIndex = nNewEdgeIndex;
 330                     rCut = fNewCut;
 331
 332                     if(fTools::equal(fRetval, fZero))
 333                     {
 334                         // already found zero distance, cannot get better. Ensure numerical zero value and end loop.
 335                         fRetval = 0.0;
 336                         break;
 337                     }
 338                 }
 339             }
 340
 341             return fRetval;
 342         }
 343
 344         B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight)
 345         {
 346             const sal_uInt32 nPolygonCount(rCandidate.count());
 347             B2DPolyPolygon aRetval;
 348
 349             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 350             {
 351                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 352
 353                 aRetval.append(distort(aCandidate, rOriginal, rTopLeft, rTopRight, rBottomLeft, rBottomRight));
 354             }
 355
 356             return aRetval;
 357         }
 358
 359         B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate)
 360         {
 361             const sal_uInt32 nPolygonCount(rCandidate.count());
 362             B2DPolyPolygon aRetval;
 363
 364             for(sal_uInt32 a(0); a < nPolygonCount; a++)
 365             {
 366                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
 367
 368                 aRetval.append(expandToCurve(aCandidate));
 369             }
 370
 371             return aRetval;
 372         }
 373
 374         B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue)
 375         {
 376             if(fValue != 0.0)
 377             {
 378                 B2DPolyPolygon aRetval;
 379
 380                 for(sal_uInt32 a(0); a < rCandidate.count(); a++)
 381                 {
 382                     aRetval.append(growInNormalDirection(rCandidate.getB2DPolygon(a), fValue));
 383                 }
 384
 385                 return aRetval;
 386             }
 387             else
 388             {
 389                 return rCandidate;
 390             }
 391         }
 392
 393         B2DPolyPolygon reSegmentPolyPolygon(const B2DPolyPolygon& rCandidate, sal_uInt32 nSegments)
 394         {
 395             B2DPolyPolygon aRetval;
 396
 397             for(sal_uInt32 a(0); a < rCandidate.count(); a++)
 398             {
 399                 aRetval.append(reSegmentPolygon(rCandidate.getB2DPolygon(a), nSegments));
 400             }
 401
 402             return aRetval;
 403         }
 404
 405         B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t)
 406         {
 407             OSL_ENSURE(rOld1.count() == rOld2.count(), "B2DPolyPolygon interpolate: Different geometry (!)");
 408             B2DPolyPolygon aRetval;
 409
 410             for(sal_uInt32 a(0); a < rOld1.count(); a++)
 411             {
 412                 aRetval.append(interpolate(rOld1.getB2DPolygon(a), rOld2.getB2DPolygon(a), t));
 413             }
 414
 415             return aRetval;
 416         }
 417
 418         bool isRectangle( const B2DPolyPolygon& rPoly )
 419         {
 420             // exclude some cheap cases first
 421             if( rPoly.count() != 1 )
 422                 return false;
 423
 424             return isRectangle( rPoly.getB2DPolygon(0) );
 425         }
 426
 427         // #i76891#
 428         B2DPolyPolygon simplifyCurveSegments(const B2DPolyPolygon& rCandidate)
 429         {
 430             if(rCandidate.areControlPointsUsed())
 431             {
 432                 B2DPolyPolygon aRetval;
 433
 434                 for(sal_uInt32 a(0); a < rCandidate.count(); a++)
 435                 {
 436                     aRetval.append(simplifyCurveSegments(rCandidate.getB2DPolygon(a)));
 437                 }
 438
 439                 return aRetval;
 440             }
 441             else
 442             {
 443                 return rCandidate;
 444             }
 445         }
 446
 447         B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate)
 448         {
 449             B2DPolyPolygon aRetval;
 450
 451             for(sal_uInt32 a(0); a < rCandidate.count(); a++)
 452             {
 453                 aRetval.append(snapPointsOfHorizontalOrVerticalEdges(rCandidate.getB2DPolygon(a)));
 454             }
 455
 456             return aRetval;
 457         }
 458
 459         B2DPolyPolygon createSevenSegmentPolyPolygon(sal_Char nNumber, bool bLitSegments)
 460         {
 461             // config here
 462             // {
 463             const double fTotalSize=1.0;
 464             const double fPosMiddleSegment=0.6;
 465             const double fSegmentEndChopHoriz=0.08;
 466             const double fSegmentEndChopVert =0.04;
 467             // }
 468             // config here
 469
 470             const double fLeft=0.0;
 471             const double fRight=fTotalSize;
 472             const double fTop=0.0;
 473             const double fMiddle=fPosMiddleSegment;
 474             const double fBottom=fTotalSize;
 475
 476             // from 0 to 5: pair of segment corner coordinates
 477
 478             // segment corner indices are these:
 479
 480             //   0 - 1
 481             //   |   |
 482             //   2 - 3
 483             //   |   |
 484             //   4 - 5
 485
 486             static const double corners[] =
 487             {
 488                 fLeft,  fTop,
 489                 fRight, fTop,
 490                 fLeft,  fMiddle,
 491                 fRight, fMiddle,
 492                 fLeft,  fBottom,
 493                 fRight, fBottom
 494             };
 495
 496             // from 0 to 9: which segments are 'lit' for this number?
 497
 498             // array denotes graph edges to traverse, with -1 means
 499             // stop (the vertices are the corner indices from above):
 500             //     0
 501             //     -
 502             // 1 |   | 2
 503             //     - 3
 504             // 4 |   | 5
 505             //     -
 506             //     6
 507
 508             static const int numbers[] =
 509             {
 510                 1, 1, 1, 0, 1, 1, 1, // 0
 511                 0, 0, 1, 0, 0, 1, 0, // 1
 512                 1, 0, 1, 1, 1, 0, 1, // 2
 513                 1, 0, 1, 1, 0, 1, 1, // 3
 514                 0, 1, 1, 1, 0, 1, 0, // 4
 515                 1, 1, 0, 1, 0, 1, 1, // 5
 516                 1, 1, 0, 1, 1, 1, 1, // 6
 517                 1, 0, 1, 0, 0, 1, 0, // 1
 518                 1, 1, 1, 1, 1, 1, 1, // 8
 519                 1, 1, 1, 1, 0, 1, 1, // 9
 520                 0, 0, 0, 1, 0, 0, 0, // '-'
 521                 1, 1, 0, 1, 1, 0, 1, // 'E'
 522             };
 523
 524             // maps segment index to two corner ids:
 525             static const int index2corner[] =
 526             {
 527                 0, 2,  // 0
 528                 0, 4,  // 1
 529                 2, 6,  // 2
 530                 4, 6,  // 3
 531                 4, 8,  // 4
 532                 6, 10, // 5
 533                 8, 10, // 6
 534             };
 535
 536             B2DPolyPolygon aRes;
 537             if( nNumber == '-' )
 538             {
 539                 nNumber = 10;
 540             }
 541             else if( nNumber == 'E' )
 542             {
 543                 nNumber = 11;
 544             }
 545             else if( nNumber == '.' )
 546             {
 547                 if( bLitSegments )
 548                     aRes.append(createPolygonFromCircle(B2DPoint(fTotalSize/2, fTotalSize),
 549                                                         fSegmentEndChopHoriz));
 550                 return aRes;
 551             }
 552             else
 553             {
 554                 nNumber=clamp<sal_uInt32>(nNumber,'0','9') - '0';
 555             }
 556
 557             B2DPolygon aCurrSegment;
 558             const size_t sliceSize=SAL_N_ELEMENTS(numbers)/12;
 559             const int* pCurrSegment=numbers + nNumber*sliceSize;
 560             for( size_t i=0; i<sliceSize; i++, pCurrSegment++)
 561             {
 562                 if( !(*pCurrSegment ^ int(bLitSegments)) )
 563                 {
 564                     const size_t j=2*i;
 565                     aCurrSegment.clear();
 566                     B2DPoint start(corners[index2corner[j]],
 567                                    corners[index2corner[j]+1]  );
 568                     B2DPoint end  (corners[index2corner[j+1]],
 569                                    corners[index2corner[j+1]+1]);
 570
 571                     if( rtl::math::approxEqual(start.getX(), end.getX()) )
 572                     {
 573                         start.setY(start.getY()+fSegmentEndChopVert);
 574                         end.setY(end.getY()-fSegmentEndChopVert);
 575                     }
 576                     else
 577                     {
 578                         start.setX(start.getX()+fSegmentEndChopHoriz);
 579                         end.setX(end.getX()-fSegmentEndChopHoriz);
 580                     }
 581
 582                     aCurrSegment.append(start);
 583                     aCurrSegment.append(end);
 584                 }
 585                 aRes.append(aCurrSegment);
 586             }
 587
 588             return aRes;
 589         }
 590
 591         // converters for css::drawing::PointSequence
 592
 593         B2DPolyPolygon UnoPointSequenceSequenceToB2DPolyPolygon(
 594             const css::drawing::PointSequenceSequence& rPointSequenceSequenceSource)
 595         {
 596             B2DPolyPolygon aRetval;
 597             const css::drawing::PointSequence* pPointSequence = rPointSequenceSequenceSource.getConstArray();
 598             const css::drawing::PointSequence* pPointSeqEnd = pPointSequence + rPointSequenceSequenceSource.getLength();
 599
 600             for(;pPointSequence != pPointSeqEnd; pPointSequence++)
 601             {
 602                 const B2DPolygon aNewPolygon = UnoPointSequenceToB2DPolygon(*pPointSequence);
 603                 aRetval.append(aNewPolygon);
 604             }
 605
 606             return aRetval;
 607         }
 608
 609         void B2DPolyPolygonToUnoPointSequenceSequence(
 610             const B2DPolyPolygon& rPolyPolygon,
 611             css::drawing::PointSequenceSequence& rPointSequenceSequenceRetval)
 612         {
 613             const sal_uInt32 nCount(rPolyPolygon.count());
 614
 615             if(nCount)
 616             {
 617                 rPointSequenceSequenceRetval.realloc(nCount);
 618                 css::drawing::PointSequence* pPointSequence = rPointSequenceSequenceRetval.getArray();
 619
 620                 for(sal_uInt32 a(0); a < nCount; a++)
 621                 {
 622                     const B2DPolygon aPolygon(rPolyPolygon.getB2DPolygon(a));
 623
 624                     B2DPolygonToUnoPointSequence(aPolygon, *pPointSequence);
 625                     pPointSequence++;
 626                 }
 627             }
 628             else
 629             {
 630                 rPointSequenceSequenceRetval.realloc(0);
 631             }
 632         }
 633
 634         // converters for css::drawing::PolyPolygonBezierCoords (curved polygons)
 635
 636         B2DPolyPolygon UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
 637             const css::drawing::PolyPolygonBezierCoords& rPolyPolygonBezierCoordsSource)
 638         {
 639             B2DPolyPolygon aRetval;
 640             const sal_uInt32 nSequenceCount(static_cast<sal_uInt32>(rPolyPolygonBezierCoordsSource.Coordinates.getLength()));
 641
 642             if(nSequenceCount)
 643             {
 644                 OSL_ENSURE(nSequenceCount == static_cast<sal_uInt32>(rPolyPolygonBezierCoordsSource.Flags.getLength()),
 645                     "UnoPolyPolygonBezierCoordsToB2DPolyPolygon: unequal number of Points and Flags (!)");
 646                 const css::drawing::PointSequence* pPointSequence = rPolyPolygonBezierCoordsSource.Coordinates.getConstArray();
 647                 const css::drawing::FlagSequence* pFlagSequence = rPolyPolygonBezierCoordsSource.Flags.getConstArray();
 648
 649                 for(sal_uInt32 a(0); a < nSequenceCount; a++)
 650                 {
 651                     const B2DPolygon aNewPolygon(UnoPolygonBezierCoordsToB2DPolygon(
 652                         *pPointSequence,
 653                         *pFlagSequence));
 654
 655                     pPointSequence++;
 656                     pFlagSequence++;
 657                     aRetval.append(aNewPolygon);
 658                 }
 659             }
 660
 661             return aRetval;
 662         }
 663
 664         void B2DPolyPolygonToUnoPolyPolygonBezierCoords(
 665             const B2DPolyPolygon& rPolyPolygon,
 666             css::drawing::PolyPolygonBezierCoords& rPolyPolygonBezierCoordsRetval)
 667         {
 668             const sal_uInt32 nCount(rPolyPolygon.count());
 669
 670             if(nCount)
 671             {
 672                 // prepare return value memory
 673                 rPolyPolygonBezierCoordsRetval.Coordinates.realloc(static_cast<sal_Int32>(nCount));
 674                 rPolyPolygonBezierCoordsRetval.Flags.realloc(static_cast<sal_Int32>(nCount));
 675
 676                 // get pointers to arrays
 677                 css::drawing::PointSequence* pPointSequence = rPolyPolygonBezierCoordsRetval.Coordinates.getArray();
 678                 css::drawing::FlagSequence*  pFlagSequence = rPolyPolygonBezierCoordsRetval.Flags.getArray();
 679
 680                 for(sal_uInt32 a(0); a < nCount; a++)
 681                 {
 682                     const B2DPolygon aSource(rPolyPolygon.getB2DPolygon(a));
 683
 684                     B2DPolygonToUnoPolygonBezierCoords(
 685                         aSource,
 686                         *pPointSequence,
 687                         *pFlagSequence);
 688                     pPointSequence++;
 689                     pFlagSequence++;
 690                 }
 691             }
 692             else
 693             {
 694                 rPolyPolygonBezierCoordsRetval.Coordinates.realloc(0);
 695                 rPolyPolygonBezierCoordsRetval.Flags.realloc(0);
 696             }
 697         }
 698
 699     } // end of namespace utils
 700 } // end of namespace basegfx
 701
 702 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */