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