basegfx/source/polygon/b2dpolygon.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 <osl/diagnose.h>
  21 #include <basegfx/polygon/b2dpolygon.hxx>
  22 #include <basegfx/point/b2dpoint.hxx>
  23 #include <basegfx/vector/b2dvector.hxx>
  24 #include <basegfx/matrix/b2dhommatrix.hxx>
  25 #include <basegfx/curve/b2dcubicbezier.hxx>
  26 #include <rtl/instance.hxx>
  27 #include <basegfx/polygon/b2dpolygontools.hxx>
  28 #include <boost/scoped_ptr.hpp>
  29 #include <vector>
  30 #include <algorithm>
  31
  32 struct CoordinateData2D : public basegfx::B2DPoint
  33 {
  34 public:
  35     CoordinateData2D() {}
  36
  37     explicit CoordinateData2D(const basegfx::B2DPoint& rData)
  38     :   B2DPoint(rData)
  39     {}
  40
  41     CoordinateData2D& operator=(const basegfx::B2DPoint& rData)
  42     {
  43         B2DPoint::operator=(rData);
  44         return *this;
  45     }
  46
  47     void transform(const basegfx::B2DHomMatrix& rMatrix)
  48     {
  49         *this *= rMatrix;
  50     }
  51 };
  52
  53 class CoordinateDataArray2D
  54 {
  55     typedef ::std::vector< CoordinateData2D > CoordinateData2DVector;
  56
  57     CoordinateData2DVector                          maVector;
  58
  59 public:
  60     explicit CoordinateDataArray2D(sal_uInt32 nCount)
  61     :   maVector(nCount)
  62     {
  63     }
  64
  65     explicit CoordinateDataArray2D(const CoordinateDataArray2D& rOriginal)
  66     :   maVector(rOriginal.maVector)
  67     {
  68     }
  69
  70     CoordinateDataArray2D(const CoordinateDataArray2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
  71     :   maVector(rOriginal.maVector.begin() + nIndex, rOriginal.maVector.begin() + (nIndex + nCount))
  72     {
  73     }
  74
  75     sal_uInt32 count() const
  76     {
  77         return maVector.size();
  78     }
  79
  80     bool operator==(const CoordinateDataArray2D& rCandidate) const
  81     {
  82         return (maVector == rCandidate.maVector);
  83     }
  84
  85     const basegfx::B2DPoint& getCoordinate(sal_uInt32 nIndex) const
  86     {
  87         return maVector[nIndex];
  88     }
  89
  90     void setCoordinate(sal_uInt32 nIndex, const basegfx::B2DPoint& rValue)
  91     {
  92         maVector[nIndex] = rValue;
  93     }
  94
  95     void reserve(sal_uInt32 nCount)
  96     {
  97         maVector.reserve(nCount);
  98     }
  99
 100     void append(const CoordinateData2D& rValue)
 101     {
 102         maVector.push_back(rValue);
 103     }
 104
 105     void insert(sal_uInt32 nIndex, const CoordinateData2D& rValue, sal_uInt32 nCount)
 106     {
 107         if(nCount)
 108         {
 109             // add nCount copies of rValue
 110             CoordinateData2DVector::iterator aIndex(maVector.begin());
 111             aIndex += nIndex;
 112             maVector.insert(aIndex, nCount, rValue);
 113         }
 114     }
 115
 116     void insert(sal_uInt32 nIndex, const CoordinateDataArray2D& rSource)
 117     {
 118         const sal_uInt32 nCount(rSource.maVector.size());
 119
 120         if(nCount)
 121         {
 122             // insert data
 123             CoordinateData2DVector::iterator aIndex(maVector.begin());
 124             aIndex += nIndex;
 125             CoordinateData2DVector::const_iterator aStart(rSource.maVector.begin());
 126             CoordinateData2DVector::const_iterator aEnd(rSource.maVector.end());
 127             maVector.insert(aIndex, aStart, aEnd);
 128         }
 129     }
 130
 131     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 132     {
 133         if(nCount)
 134         {
 135             // remove point data
 136             CoordinateData2DVector::iterator aStart(maVector.begin());
 137             aStart += nIndex;
 138             const CoordinateData2DVector::iterator aEnd(aStart + nCount);
 139             maVector.erase(aStart, aEnd);
 140         }
 141     }
 142
 143     void flip(bool bIsClosed)
 144     {
 145         if(maVector.size() > 1)
 146         {
 147             // to keep the same point at index 0, just flip all points except the
 148             // first one when closed
 149             const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
 150             CoordinateData2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
 151             CoordinateData2DVector::iterator aEnd(maVector.end() - 1);
 152
 153             for(sal_uInt32 a(0); a < nHalfSize; a++)
 154             {
 155                 ::std::swap(*aStart, *aEnd);
 156                 ++aStart;
 157                 --aEnd;
 158             }
 159         }
 160     }
 161
 162     void removeDoublePointsAtBeginEnd()
 163     {
 164         // remove from end as long as there are at least two points
 165         // and begin/end are equal
 166         while((maVector.size() > 1) && (maVector[0] == maVector[maVector.size() - 1]))
 167         {
 168             maVector.pop_back();
 169         }
 170     }
 171
 172     void removeDoublePointsWholeTrack()
 173     {
 174         sal_uInt32 nIndex(0);
 175
 176         // test as long as there are at least two points and as long as the index
 177         // is smaller or equal second last point
 178         while((maVector.size() > 1) && (nIndex <= maVector.size() - 2))
 179         {
 180             if(maVector[nIndex] == maVector[nIndex + 1])
 181             {
 182                 // if next is same as index, delete next
 183                 maVector.erase(maVector.begin() + (nIndex + 1));
 184             }
 185             else
 186             {
 187                 // if different, step forward
 188                 nIndex++;
 189             }
 190         }
 191     }
 192
 193     void transform(const basegfx::B2DHomMatrix& rMatrix)
 194     {
 195         CoordinateData2DVector::iterator aStart(maVector.begin());
 196         CoordinateData2DVector::iterator aEnd(maVector.end());
 197
 198         for(; aStart != aEnd; ++aStart)
 199         {
 200             aStart->transform(rMatrix);
 201         }
 202     }
 203 };
 204
 205 class ControlVectorPair2D
 206 {
 207     basegfx::B2DVector                          maPrevVector;
 208     basegfx::B2DVector                          maNextVector;
 209
 210 public:
 211     explicit ControlVectorPair2D() {}
 212
 213     const basegfx::B2DVector& getPrevVector() const
 214     {
 215         return maPrevVector;
 216     }
 217
 218     void setPrevVector(const basegfx::B2DVector& rValue)
 219     {
 220         if(rValue != maPrevVector)
 221             maPrevVector = rValue;
 222     }
 223
 224     const basegfx::B2DVector& getNextVector() const
 225     {
 226         return maNextVector;
 227     }
 228
 229     void setNextVector(const basegfx::B2DVector& rValue)
 230     {
 231         if(rValue != maNextVector)
 232             maNextVector = rValue;
 233     }
 234
 235     bool operator==(const ControlVectorPair2D& rData) const
 236     {
 237         return (maPrevVector == rData.getPrevVector() && maNextVector == rData.getNextVector());
 238     }
 239
 240     void flip()
 241     {
 242         ::std::swap(maPrevVector, maNextVector);
 243     }
 244 };
 245
 246 class ControlVectorArray2D
 247 {
 248     typedef ::std::vector< ControlVectorPair2D > ControlVectorPair2DVector;
 249
 250     ControlVectorPair2DVector                           maVector;
 251     sal_uInt32                                          mnUsedVectors;
 252
 253 public:
 254     explicit ControlVectorArray2D(sal_uInt32 nCount)
 255     :   maVector(nCount),
 256         mnUsedVectors(0)
 257     {}
 258
 259     ControlVectorArray2D(const ControlVectorArray2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 260     :   maVector(),
 261         mnUsedVectors(0)
 262     {
 263         ControlVectorPair2DVector::const_iterator aStart(rOriginal.maVector.begin());
 264         aStart += nIndex;
 265         ControlVectorPair2DVector::const_iterator aEnd(aStart);
 266         aEnd += nCount;
 267         maVector.reserve(nCount);
 268
 269         for(; aStart != aEnd; ++aStart)
 270         {
 271             if(!aStart->getPrevVector().equalZero())
 272                 mnUsedVectors++;
 273
 274             if(!aStart->getNextVector().equalZero())
 275                 mnUsedVectors++;
 276
 277             maVector.push_back(*aStart);
 278         }
 279     }
 280
 281     bool operator==(const ControlVectorArray2D& rCandidate) const
 282     {
 283         return (maVector == rCandidate.maVector);
 284     }
 285
 286     bool isUsed() const
 287     {
 288         return (0 != mnUsedVectors);
 289     }
 290
 291     const basegfx::B2DVector& getPrevVector(sal_uInt32 nIndex) const
 292     {
 293         return maVector[nIndex].getPrevVector();
 294     }
 295
 296     void setPrevVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 297     {
 298         bool bWasUsed(mnUsedVectors && !maVector[nIndex].getPrevVector().equalZero());
 299         bool bIsUsed(!rValue.equalZero());
 300
 301         if(bWasUsed)
 302         {
 303             if(bIsUsed)
 304             {
 305                 maVector[nIndex].setPrevVector(rValue);
 306             }
 307             else
 308             {
 309                 maVector[nIndex].setPrevVector(basegfx::B2DVector::getEmptyVector());
 310                 mnUsedVectors--;
 311             }
 312         }
 313         else
 314         {
 315             if(bIsUsed)
 316             {
 317                 maVector[nIndex].setPrevVector(rValue);
 318                 mnUsedVectors++;
 319             }
 320         }
 321     }
 322
 323     const basegfx::B2DVector& getNextVector(sal_uInt32 nIndex) const
 324     {
 325         return maVector[nIndex].getNextVector();
 326     }
 327
 328     void setNextVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 329     {
 330         bool bWasUsed(mnUsedVectors && !maVector[nIndex].getNextVector().equalZero());
 331         bool bIsUsed(!rValue.equalZero());
 332
 333         if(bWasUsed)
 334         {
 335             if(bIsUsed)
 336             {
 337                 maVector[nIndex].setNextVector(rValue);
 338             }
 339             else
 340             {
 341                 maVector[nIndex].setNextVector(basegfx::B2DVector::getEmptyVector());
 342                 mnUsedVectors--;
 343             }
 344         }
 345         else
 346         {
 347             if(bIsUsed)
 348             {
 349                 maVector[nIndex].setNextVector(rValue);
 350                 mnUsedVectors++;
 351             }
 352         }
 353     }
 354
 355     void append(const ControlVectorPair2D& rValue)
 356     {
 357         maVector.push_back(rValue);
 358
 359         if(!rValue.getPrevVector().equalZero())
 360             mnUsedVectors += 1;
 361
 362         if(!rValue.getNextVector().equalZero())
 363             mnUsedVectors += 1;
 364     }
 365
 366     void insert(sal_uInt32 nIndex, const ControlVectorPair2D& rValue, sal_uInt32 nCount)
 367     {
 368         if(nCount)
 369         {
 370             // add nCount copies of rValue
 371             ControlVectorPair2DVector::iterator aIndex(maVector.begin());
 372             aIndex += nIndex;
 373             maVector.insert(aIndex, nCount, rValue);
 374
 375             if(!rValue.getPrevVector().equalZero())
 376                 mnUsedVectors += nCount;
 377
 378             if(!rValue.getNextVector().equalZero())
 379                 mnUsedVectors += nCount;
 380         }
 381     }
 382
 383     void insert(sal_uInt32 nIndex, const ControlVectorArray2D& rSource)
 384     {
 385         const sal_uInt32 nCount(rSource.maVector.size());
 386
 387         if(nCount)
 388         {
 389             // insert data
 390             ControlVectorPair2DVector::iterator aIndex(maVector.begin());
 391             aIndex += nIndex;
 392             ControlVectorPair2DVector::const_iterator aStart(rSource.maVector.begin());
 393             ControlVectorPair2DVector::const_iterator aEnd(rSource.maVector.end());
 394             maVector.insert(aIndex, aStart, aEnd);
 395
 396             for(; aStart != aEnd; ++aStart)
 397             {
 398                 if(!aStart->getPrevVector().equalZero())
 399                     mnUsedVectors++;
 400
 401                 if(!aStart->getNextVector().equalZero())
 402                     mnUsedVectors++;
 403             }
 404         }
 405     }
 406
 407     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 408     {
 409         if(nCount)
 410         {
 411             const ControlVectorPair2DVector::iterator aDeleteStart(maVector.begin() + nIndex);
 412             const ControlVectorPair2DVector::iterator aDeleteEnd(aDeleteStart + nCount);
 413             ControlVectorPair2DVector::const_iterator aStart(aDeleteStart);
 414
 415             for(; mnUsedVectors && aStart != aDeleteEnd; ++aStart)
 416             {
 417                 if(!aStart->getPrevVector().equalZero())
 418                     mnUsedVectors--;
 419
 420                 if(mnUsedVectors && !aStart->getNextVector().equalZero())
 421                     mnUsedVectors--;
 422             }
 423
 424             // remove point data
 425             maVector.erase(aDeleteStart, aDeleteEnd);
 426         }
 427     }
 428
 429     void flip(bool bIsClosed)
 430     {
 431         if(maVector.size() > 1)
 432         {
 433             // to keep the same point at index 0, just flip all points except the
 434             // first one when closed
 435             const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
 436             ControlVectorPair2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
 437             ControlVectorPair2DVector::iterator aEnd(maVector.end() - 1);
 438
 439             for(sal_uInt32 a(0); a < nHalfSize; a++)
 440             {
 441                 // swap Prev and Next
 442                 aStart->flip();
 443                 aEnd->flip();
 444
 445                 // swap entries
 446                 ::std::swap(*aStart, *aEnd);
 447
 448                 ++aStart;
 449                 --aEnd;
 450             }
 451
 452             if(aStart == aEnd)
 453             {
 454                 // swap Prev and Next at middle element (if exists)
 455                 aStart->flip();
 456             }
 457
 458             if(bIsClosed)
 459             {
 460                 // swap Prev and Next at start element
 461                 maVector.begin()->flip();
 462             }
 463         }
 464     }
 465 };
 466
 467 class ImplBufferedData
 468 {
 469 private:
 470     // Possibility to hold the last subdivision
 471     boost::scoped_ptr< basegfx::B2DPolygon >        mpDefaultSubdivision;
 472
 473     // Possibility to hold the last B2DRange calculation
 474     boost::scoped_ptr< basegfx::B2DRange >          mpB2DRange;
 475
 476 public:
 477     ImplBufferedData()
 478     :   mpDefaultSubdivision(),
 479         mpB2DRange()
 480     {}
 481
 482     const basegfx::B2DPolygon& getDefaultAdaptiveSubdivision(const basegfx::B2DPolygon& rSource) const
 483     {
 484         if(!mpDefaultSubdivision)
 485         {
 486             const_cast< ImplBufferedData* >(this)->mpDefaultSubdivision.reset(new basegfx::B2DPolygon(basegfx::tools::adaptiveSubdivideByCount(rSource, 9)));
 487         }
 488
 489         return *mpDefaultSubdivision;
 490     }
 491
 492     const basegfx::B2DRange& getB2DRange(const basegfx::B2DPolygon& rSource) const
 493     {
 494         if(!mpB2DRange)
 495         {
 496             basegfx::B2DRange aNewRange;
 497             const sal_uInt32 nPointCount(rSource.count());
 498
 499             if(nPointCount)
 500             {
 501                 for(sal_uInt32 a(0); a < nPointCount; a++)
 502                 {
 503                     aNewRange.expand(rSource.getB2DPoint(a));
 504                 }
 505
 506                 if(rSource.areControlPointsUsed())
 507                 {
 508                     const sal_uInt32 nEdgeCount(rSource.isClosed() ? nPointCount : nPointCount - 1);
 509
 510                     if(nEdgeCount)
 511                     {
 512                         basegfx::B2DCubicBezier aEdge;
 513                         aEdge.setStartPoint(rSource.getB2DPoint(0));
 514
 515                         for(sal_uInt32 b(0); b < nEdgeCount; b++)
 516                         {
 517                             const sal_uInt32 nNextIndex((b + 1) % nPointCount);
 518                             aEdge.setControlPointA(rSource.getNextControlPoint(b));
 519                             aEdge.setControlPointB(rSource.getPrevControlPoint(nNextIndex));
 520                             aEdge.setEndPoint(rSource.getB2DPoint(nNextIndex));
 521
 522                             if(aEdge.isBezier())
 523                             {
 524                                 const basegfx::B2DRange aBezierRangeWithControlPoints(aEdge.getRange());
 525
 526                                 if(!aNewRange.isInside(aBezierRangeWithControlPoints))
 527                                 {
 528                                     // the range with control points of the current edge is not completely
 529                                     // inside the current range without control points. Expand current range by
 530                                     // subdividing the bezier segment.
 531                                     // Ideal here is a subdivision at the extreme values, so use
 532                                     // getAllExtremumPositions to get all extremas in one run
 533                                     ::std::vector< double > aExtremas;
 534
 535                                     aExtremas.reserve(4);
 536                                     aEdge.getAllExtremumPositions(aExtremas);
 537
 538                                     const sal_uInt32 nExtremaCount(aExtremas.size());
 539
 540                                     for(sal_uInt32 c(0); c < nExtremaCount; c++)
 541                                     {
 542                                         aNewRange.expand(aEdge.interpolatePoint(aExtremas[c]));
 543                                     }
 544                                 }
 545                             }
 546
 547                             // prepare next edge
 548                             aEdge.setStartPoint(aEdge.getEndPoint());
 549                         }
 550                     }
 551                 }
 552             }
 553
 554             const_cast< ImplBufferedData* >(this)->mpB2DRange.reset(new basegfx::B2DRange(aNewRange));
 555         }
 556
 557         return *mpB2DRange;
 558     }
 559 };
 560
 561 class ImplB2DPolygon
 562 {
 563 private:
 564     // The point vector. This vector exists always and defines the
 565     // count of members.
 566     CoordinateDataArray2D                           maPoints;
 567
 568     // The control point vectors. This vectors are created on demand
 569     // and may be zero.
 570     boost::scoped_ptr< ControlVectorArray2D >       mpControlVector;
 571
 572     // buffered data for e.g. default subdivision and range
 573     boost::scoped_ptr< ImplBufferedData >           mpBufferedData;
 574
 575     // flag which decides if this polygon is opened or closed
 576     bool                                            mbIsClosed;
 577
 578 public:
 579     const basegfx::B2DPolygon& getDefaultAdaptiveSubdivision(const basegfx::B2DPolygon& rSource) const
 580     {
 581         if(!mpControlVector || !mpControlVector->isUsed())
 582         {
 583             return rSource;
 584         }
 585
 586         if(!mpBufferedData)
 587         {
 588             const_cast< ImplB2DPolygon* >(this)->mpBufferedData.reset(new ImplBufferedData);
 589         }
 590
 591         return mpBufferedData->getDefaultAdaptiveSubdivision(rSource);
 592     }
 593
 594     const basegfx::B2DRange& getB2DRange(const basegfx::B2DPolygon& rSource) const
 595     {
 596         if(!mpBufferedData)
 597         {
 598             const_cast< ImplB2DPolygon* >(this)->mpBufferedData.reset(new ImplBufferedData);
 599         }
 600
 601         return mpBufferedData->getB2DRange(rSource);
 602     }
 603
 604     ImplB2DPolygon()
 605     :   maPoints(0),
 606         mpControlVector(),
 607         mpBufferedData(),
 608         mbIsClosed(false)
 609     {}
 610
 611     ImplB2DPolygon(const ImplB2DPolygon& rToBeCopied)
 612     :   maPoints(rToBeCopied.maPoints),
 613         mpControlVector(),
 614         mpBufferedData(),
 615         mbIsClosed(rToBeCopied.mbIsClosed)
 616     {
 617         // complete initialization using copy
 618         if(rToBeCopied.mpControlVector && rToBeCopied.mpControlVector->isUsed())
 619         {
 620             mpControlVector.reset( new ControlVectorArray2D(*rToBeCopied.mpControlVector) );
 621         }
 622     }
 623
 624     ImplB2DPolygon(const ImplB2DPolygon& rToBeCopied, sal_uInt32 nIndex, sal_uInt32 nCount)
 625     :   maPoints(rToBeCopied.maPoints, nIndex, nCount),
 626         mpControlVector(),
 627         mpBufferedData(),
 628         mbIsClosed(rToBeCopied.mbIsClosed)
 629     {
 630         // complete initialization using partly copy
 631         if(rToBeCopied.mpControlVector && rToBeCopied.mpControlVector->isUsed())
 632         {
 633             mpControlVector.reset( new ControlVectorArray2D(*rToBeCopied.mpControlVector, nIndex, nCount) );
 634
 635             if(!mpControlVector->isUsed())
 636                 mpControlVector.reset();
 637         }
 638     }
 639
 640     ImplB2DPolygon& operator=( const ImplB2DPolygon& ) SAL_DELETED_FUNCTION;
 641
 642     sal_uInt32 count() const
 643     {
 644         return maPoints.count();
 645     }
 646
 647     bool isClosed() const
 648     {
 649         return mbIsClosed;
 650     }
 651
 652     void setClosed(bool bNew)
 653     {
 654         if(bNew != mbIsClosed)
 655         {
 656             mpBufferedData.reset();
 657             mbIsClosed = bNew;
 658         }
 659     }
 660
 661     bool operator==(const ImplB2DPolygon& rCandidate) const
 662     {
 663         if(mbIsClosed == rCandidate.mbIsClosed)
 664         {
 665             if(maPoints == rCandidate.maPoints)
 666             {
 667                 bool bControlVectorsAreEqual(true);
 668
 669                 if(mpControlVector)
 670                 {
 671                     if(rCandidate.mpControlVector)
 672                     {
 673                         bControlVectorsAreEqual = ((*mpControlVector) == (*rCandidate.mpControlVector));
 674                     }
 675                     else
 676                     {
 677                         // candidate has no control vector, so it's assumed all unused.
 678                         bControlVectorsAreEqual = !mpControlVector->isUsed();
 679                     }
 680                 }
 681                 else
 682                 {
 683                     if(rCandidate.mpControlVector)
 684                     {
 685                         // we have no control vector, so it's assumed all unused.
 686                         bControlVectorsAreEqual = !rCandidate.mpControlVector->isUsed();
 687                     }
 688                 }
 689
 690                 if(bControlVectorsAreEqual)
 691                 {
 692                     return true;
 693                 }
 694             }
 695         }
 696
 697         return false;
 698     }
 699
 700     const basegfx::B2DPoint& getPoint(sal_uInt32 nIndex) const
 701     {
 702         return maPoints.getCoordinate(nIndex);
 703     }
 704
 705     void setPoint(sal_uInt32 nIndex, const basegfx::B2DPoint& rValue)
 706     {
 707         mpBufferedData.reset();
 708         maPoints.setCoordinate(nIndex, rValue);
 709     }
 710
 711     void reserve(sal_uInt32 nCount)
 712     {
 713         maPoints.reserve(nCount);
 714     }
 715
 716     void append(const basegfx::B2DPoint& rPoint)
 717     {
 718         mpBufferedData.reset(); // TODO: is this needed?
 719         const CoordinateData2D aCoordinate(rPoint);
 720         maPoints.append(aCoordinate);
 721
 722         if(mpControlVector)
 723         {
 724             const ControlVectorPair2D aVectorPair;
 725             mpControlVector->append(aVectorPair);
 726         }
 727     }
 728
 729     void insert(sal_uInt32 nIndex, const basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
 730     {
 731         if(nCount)
 732         {
 733             mpBufferedData.reset();
 734             CoordinateData2D aCoordinate(rPoint);
 735             maPoints.insert(nIndex, aCoordinate, nCount);
 736
 737             if(mpControlVector)
 738             {
 739                 ControlVectorPair2D aVectorPair;
 740                 mpControlVector->insert(nIndex, aVectorPair, nCount);
 741             }
 742         }
 743     }
 744
 745     const basegfx::B2DVector& getPrevControlVector(sal_uInt32 nIndex) const
 746     {
 747         if(mpControlVector)
 748         {
 749             return mpControlVector->getPrevVector(nIndex);
 750         }
 751         else
 752         {
 753             return basegfx::B2DVector::getEmptyVector();
 754         }
 755     }
 756
 757     void setPrevControlVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 758     {
 759         if(!mpControlVector)
 760         {
 761             if(!rValue.equalZero())
 762             {
 763                 mpBufferedData.reset();
 764                 mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
 765                 mpControlVector->setPrevVector(nIndex, rValue);
 766             }
 767         }
 768         else
 769         {
 770             mpBufferedData.reset();
 771             mpControlVector->setPrevVector(nIndex, rValue);
 772
 773             if(!mpControlVector->isUsed())
 774                 mpControlVector.reset();
 775         }
 776     }
 777
 778     const basegfx::B2DVector& getNextControlVector(sal_uInt32 nIndex) const
 779     {
 780         if(mpControlVector)
 781         {
 782             return mpControlVector->getNextVector(nIndex);
 783         }
 784         else
 785         {
 786             return basegfx::B2DVector::getEmptyVector();
 787         }
 788     }
 789
 790     void setNextControlVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 791     {
 792         if(!mpControlVector)
 793         {
 794             if(!rValue.equalZero())
 795             {
 796                 mpBufferedData.reset();
 797                 mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
 798                 mpControlVector->setNextVector(nIndex, rValue);
 799             }
 800         }
 801         else
 802         {
 803             mpBufferedData.reset();
 804             mpControlVector->setNextVector(nIndex, rValue);
 805
 806             if(!mpControlVector->isUsed())
 807                 mpControlVector.reset();
 808         }
 809     }
 810
 811     bool areControlPointsUsed() const
 812     {
 813         return (mpControlVector && mpControlVector->isUsed());
 814     }
 815
 816     void resetControlVectors()
 817     {
 818         mpBufferedData.reset();
 819         mpControlVector.reset();
 820     }
 821
 822     void setControlVectors(sal_uInt32 nIndex, const basegfx::B2DVector& rPrev, const basegfx::B2DVector& rNext)
 823     {
 824         setPrevControlVector(nIndex, rPrev);
 825         setNextControlVector(nIndex, rNext);
 826     }
 827
 828     void appendBezierSegment(const basegfx::B2DVector& rNext, const basegfx::B2DVector& rPrev, const basegfx::B2DPoint& rPoint)
 829     {
 830         mpBufferedData.reset();
 831         const sal_uInt32 nCount(maPoints.count());
 832
 833         if(nCount)
 834         {
 835             setNextControlVector(nCount - 1, rNext);
 836         }
 837
 838         insert(nCount, rPoint, 1);
 839         setPrevControlVector(nCount, rPrev);
 840     }
 841
 842     void insert(sal_uInt32 nIndex, const ImplB2DPolygon& rSource)
 843     {
 844         const sal_uInt32 nCount(rSource.maPoints.count());
 845
 846         if(nCount)
 847         {
 848             mpBufferedData.reset();
 849
 850             if(rSource.mpControlVector && rSource.mpControlVector->isUsed() && !mpControlVector)
 851             {
 852                 mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
 853             }
 854
 855             maPoints.insert(nIndex, rSource.maPoints);
 856
 857             if(rSource.mpControlVector)
 858             {
 859                 mpControlVector->insert(nIndex, *rSource.mpControlVector);
 860
 861                 if(!mpControlVector->isUsed())
 862                     mpControlVector.reset();
 863             }
 864             else if(mpControlVector)
 865             {
 866                 ControlVectorPair2D aVectorPair;
 867                 mpControlVector->insert(nIndex, aVectorPair, nCount);
 868             }
 869         }
 870     }
 871
 872     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 873     {
 874         if(nCount)
 875         {
 876             mpBufferedData.reset();
 877             maPoints.remove(nIndex, nCount);
 878
 879             if(mpControlVector)
 880             {
 881                 mpControlVector->remove(nIndex, nCount);
 882
 883                 if(!mpControlVector->isUsed())
 884                     mpControlVector.reset();
 885             }
 886         }
 887     }
 888
 889     void flip()
 890     {
 891         if(maPoints.count() > 1)
 892         {
 893             mpBufferedData.reset();
 894
 895             // flip points
 896             maPoints.flip(mbIsClosed);
 897
 898             if(mpControlVector)
 899             {
 900                 // flip control vector
 901                 mpControlVector->flip(mbIsClosed);
 902             }
 903         }
 904     }
 905
 906     bool hasDoublePoints() const
 907     {
 908         if(mbIsClosed)
 909         {
 910             // check for same start and end point
 911             const sal_uInt32 nIndex(maPoints.count() - 1);
 912
 913             if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
 914             {
 915                 if(mpControlVector)
 916                 {
 917                     if(mpControlVector->getNextVector(nIndex).equalZero() && mpControlVector->getPrevVector(0).equalZero())
 918                     {
 919                         return true;
 920                     }
 921                 }
 922                 else
 923                 {
 924                     return true;
 925                 }
 926             }
 927         }
 928
 929         // test for range
 930         for(sal_uInt32 a(0); a < maPoints.count() - 1; a++)
 931         {
 932             if(maPoints.getCoordinate(a) == maPoints.getCoordinate(a + 1))
 933             {
 934                 if(mpControlVector)
 935                 {
 936                     if(mpControlVector->getNextVector(a).equalZero() && mpControlVector->getPrevVector(a + 1).equalZero())
 937                     {
 938                         return true;
 939                     }
 940                 }
 941                 else
 942                 {
 943                     return true;
 944                 }
 945             }
 946         }
 947
 948         return false;
 949     }
 950
 951     void removeDoublePointsAtBeginEnd()
 952     {
 953         // Only remove DoublePoints at Begin and End when poly is closed
 954         if(mbIsClosed)
 955         {
 956             mpBufferedData.reset();
 957
 958             if(mpControlVector)
 959             {
 960                 bool bRemove;
 961
 962                 do
 963                 {
 964                     bRemove = false;
 965
 966                     if(maPoints.count() > 1)
 967                     {
 968                         const sal_uInt32 nIndex(maPoints.count() - 1);
 969
 970                         if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
 971                         {
 972                             if(mpControlVector)
 973                             {
 974                                 if(mpControlVector->getNextVector(nIndex).equalZero() && mpControlVector->getPrevVector(0).equalZero())
 975                                 {
 976                                     bRemove = true;
 977                                 }
 978                             }
 979                             else
 980                             {
 981                                 bRemove = true;
 982                             }
 983                         }
 984                     }
 985
 986                     if(bRemove)
 987                     {
 988                         const sal_uInt32 nIndex(maPoints.count() - 1);
 989
 990                         if(mpControlVector && !mpControlVector->getPrevVector(nIndex).equalZero())
 991                         {
 992                             mpControlVector->setPrevVector(0, mpControlVector->getPrevVector(nIndex));
 993                         }
 994
 995                         remove(nIndex, 1);
 996                     }
 997                 }
 998                 while(bRemove);
 999             }
1000             else
1001             {
1002                 maPoints.removeDoublePointsAtBeginEnd();
1003             }
1004         }
1005     }
1006
1007     void removeDoublePointsWholeTrack()
1008     {
1009         mpBufferedData.reset();
1010
1011         if(mpControlVector)
1012         {
1013             sal_uInt32 nIndex(0);
1014
1015             // test as long as there are at least two points and as long as the index
1016             // is smaller or equal second last point
1017             while((maPoints.count() > 1) && (nIndex <= maPoints.count() - 2))
1018             {
1019                 bool bRemove(maPoints.getCoordinate(nIndex) == maPoints.getCoordinate(nIndex + 1));
1020
1021                 if(bRemove)
1022                 {
1023                     if(mpControlVector)
1024                     {
1025                         if(!mpControlVector->getNextVector(nIndex).equalZero() || !mpControlVector->getPrevVector(nIndex + 1).equalZero())
1026                         {
1027                             bRemove = false;
1028                         }
1029                     }
1030                 }
1031
1032                 if(bRemove)
1033                 {
1034                     if(mpControlVector && !mpControlVector->getPrevVector(nIndex).equalZero())
1035                     {
1036                         mpControlVector->setPrevVector(nIndex + 1, mpControlVector->getPrevVector(nIndex));
1037                     }
1038
1039                     // if next is same as index and the control vectors are unused, delete index
1040                     remove(nIndex, 1);
1041                 }
1042                 else
1043                 {
1044                     // if different, step forward
1045                     nIndex++;
1046                 }
1047             }
1048         }
1049         else
1050         {
1051             maPoints.removeDoublePointsWholeTrack();
1052         }
1053     }
1054
1055     void transform(const basegfx::B2DHomMatrix& rMatrix)
1056     {
1057         mpBufferedData.reset();
1058
1059         if(mpControlVector)
1060         {
1061             for(sal_uInt32 a(0); a < maPoints.count(); a++)
1062             {
1063                 basegfx::B2DPoint aCandidate = maPoints.getCoordinate(a);
1064
1065                 if(mpControlVector->isUsed())
1066                 {
1067                     const basegfx::B2DVector& rPrevVector(mpControlVector->getPrevVector(a));
1068                     const basegfx::B2DVector& rNextVector(mpControlVector->getNextVector(a));
1069
1070                     if(!rPrevVector.equalZero())
1071                     {
1072                         basegfx::B2DVector aPrevVector(rMatrix * rPrevVector);
1073                         mpControlVector->setPrevVector(a, aPrevVector);
1074                     }
1075
1076                     if(!rNextVector.equalZero())
1077                     {
1078                         basegfx::B2DVector aNextVector(rMatrix * rNextVector);
1079                         mpControlVector->setNextVector(a, aNextVector);
1080                     }
1081                 }
1082
1083                 aCandidate *= rMatrix;
1084                 maPoints.setCoordinate(a, aCandidate);
1085             }
1086
1087             if(!mpControlVector->isUsed())
1088                 mpControlVector.reset();
1089         }
1090         else
1091         {
1092             maPoints.transform(rMatrix);
1093         }
1094     }
1095 };
1096
1097 namespace basegfx
1098 {
1099     namespace
1100     {
1101         struct DefaultPolygon: public rtl::Static<B2DPolygon::ImplType, DefaultPolygon> {};
1102     }
1103
1104     B2DPolygon::B2DPolygon()
1105     :   mpPolygon(DefaultPolygon::get())
1106     {}
1107
1108     B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon)
1109     :   mpPolygon(rPolygon.mpPolygon)
1110     {}
1111
1112     B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
1113     :   mpPolygon(ImplB2DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
1114     {
1115         // TODO(P2): one extra temporary here (cow_wrapper copies
1116         // given ImplB2DPolygon into its internal impl_t wrapper type)
1117         OSL_ENSURE(nIndex + nCount <= rPolygon.mpPolygon->count(), "B2DPolygon constructor outside range (!)");
1118     }
1119
1120     B2DPolygon::~B2DPolygon()
1121     {
1122     }
1123
1124     B2DPolygon& B2DPolygon::operator=(const B2DPolygon& rPolygon)
1125     {
1126         mpPolygon = rPolygon.mpPolygon;
1127         return *this;
1128     }
1129
1130     void B2DPolygon::makeUnique()
1131     {
1132         mpPolygon.make_unique();
1133     }
1134
1135     bool B2DPolygon::operator==(const B2DPolygon& rPolygon) const
1136     {
1137         if(mpPolygon.same_object(rPolygon.mpPolygon))
1138             return true;
1139
1140         return ((*mpPolygon) == (*rPolygon.mpPolygon));
1141     }
1142
1143     bool B2DPolygon::operator!=(const B2DPolygon& rPolygon) const
1144     {
1145         return !(*this == rPolygon);
1146     }
1147
1148     sal_uInt32 B2DPolygon::count() const
1149     {
1150         return mpPolygon->count();
1151     }
1152
1153     B2DPoint B2DPolygon::getB2DPoint(sal_uInt32 nIndex) const
1154     {
1155         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1156
1157         return mpPolygon->getPoint(nIndex);
1158     }
1159
1160     void B2DPolygon::setB2DPoint(sal_uInt32 nIndex, const B2DPoint& rValue)
1161     {
1162         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1163
1164         if(mpPolygon->getPoint(nIndex) != rValue)
1165         {
1166             mpPolygon->setPoint(nIndex, rValue);
1167         }
1168     }
1169
1170     void B2DPolygon::reserve(sal_uInt32 nCount)
1171     {
1172         mpPolygon->reserve(nCount);
1173     }
1174
1175     void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPoint& rPoint, sal_uInt32 nCount)
1176     {
1177         OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
1178
1179         if(nCount)
1180         {
1181             mpPolygon->insert(nIndex, rPoint, nCount);
1182         }
1183     }
1184
1185     void B2DPolygon::append(const B2DPoint& rPoint, sal_uInt32 nCount)
1186     {
1187         if(nCount)
1188         {
1189             mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
1190         }
1191     }
1192
1193     void B2DPolygon::append(const B2DPoint& rPoint)
1194     {
1195         mpPolygon->append(rPoint);
1196     }
1197
1198     B2DPoint B2DPolygon::getPrevControlPoint(sal_uInt32 nIndex) const
1199     {
1200         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1201
1202         if(mpPolygon->areControlPointsUsed())
1203         {
1204             return mpPolygon->getPoint(nIndex) + mpPolygon->getPrevControlVector(nIndex);
1205         }
1206         else
1207         {
1208             return mpPolygon->getPoint(nIndex);
1209         }
1210     }
1211
1212     B2DPoint B2DPolygon::getNextControlPoint(sal_uInt32 nIndex) const
1213     {
1214         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1215
1216         if(mpPolygon->areControlPointsUsed())
1217         {
1218             return mpPolygon->getPoint(nIndex) + mpPolygon->getNextControlVector(nIndex);
1219         }
1220         else
1221         {
1222             return mpPolygon->getPoint(nIndex);
1223         }
1224     }
1225
1226     void B2DPolygon::setPrevControlPoint(sal_uInt32 nIndex, const B2DPoint& rValue)
1227     {
1228         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1229         const basegfx::B2DVector aNewVector(rValue - mpPolygon->getPoint(nIndex));
1230
1231         if(mpPolygon->getPrevControlVector(nIndex) != aNewVector)
1232         {
1233             mpPolygon->setPrevControlVector(nIndex, aNewVector);
1234         }
1235     }
1236
1237     void B2DPolygon::setNextControlPoint(sal_uInt32 nIndex, const B2DPoint& rValue)
1238     {
1239         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1240         const basegfx::B2DVector aNewVector(rValue - mpPolygon->getPoint(nIndex));
1241
1242         if(mpPolygon->getNextControlVector(nIndex) != aNewVector)
1243         {
1244             mpPolygon->setNextControlVector(nIndex, aNewVector);
1245         }
1246     }
1247
1248     void B2DPolygon::setControlPoints(sal_uInt32 nIndex, const basegfx::B2DPoint& rPrev, const basegfx::B2DPoint& rNext)
1249     {
1250         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1251         const B2DPoint aPoint(mpPolygon->getPoint(nIndex));
1252         const basegfx::B2DVector aNewPrev(rPrev - aPoint);
1253         const basegfx::B2DVector aNewNext(rNext - aPoint);
1254
1255         if(mpPolygon->getPrevControlVector(nIndex) != aNewPrev || mpPolygon->getNextControlVector(nIndex) != aNewNext)
1256         {
1257             mpPolygon->setControlVectors(nIndex, aNewPrev, aNewNext);
1258         }
1259     }
1260
1261     void B2DPolygon::resetPrevControlPoint(sal_uInt32 nIndex)
1262     {
1263         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1264
1265         if(mpPolygon->areControlPointsUsed() && !mpPolygon->getPrevControlVector(nIndex).equalZero())
1266         {
1267             mpPolygon->setPrevControlVector(nIndex, B2DVector::getEmptyVector());
1268         }
1269     }
1270
1271     void B2DPolygon::resetNextControlPoint(sal_uInt32 nIndex)
1272     {
1273         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1274
1275         if(mpPolygon->areControlPointsUsed() && !mpPolygon->getNextControlVector(nIndex).equalZero())
1276         {
1277             mpPolygon->setNextControlVector(nIndex, B2DVector::getEmptyVector());
1278         }
1279     }
1280
1281     void B2DPolygon::resetControlPoints()
1282     {
1283         if(mpPolygon->areControlPointsUsed())
1284         {
1285             mpPolygon->resetControlVectors();
1286         }
1287     }
1288
1289     void B2DPolygon::appendBezierSegment(
1290         const B2DPoint& rNextControlPoint,
1291         const B2DPoint& rPrevControlPoint,
1292         const B2DPoint& rPoint)
1293     {
1294         const B2DVector aNewNextVector(mpPolygon->count() ? B2DVector(rNextControlPoint - mpPolygon->getPoint(mpPolygon->count() - 1)) : B2DVector::getEmptyVector());
1295         const B2DVector aNewPrevVector(rPrevControlPoint - rPoint);
1296
1297         if(aNewNextVector.equalZero() && aNewPrevVector.equalZero())
1298         {
1299             mpPolygon->insert(mpPolygon->count(), rPoint, 1);
1300         }
1301         else
1302         {
1303             mpPolygon->appendBezierSegment(aNewNextVector, aNewPrevVector, rPoint);
1304         }
1305     }
1306
1307     bool B2DPolygon::areControlPointsUsed() const
1308     {
1309         return mpPolygon->areControlPointsUsed();
1310     }
1311
1312     bool B2DPolygon::isPrevControlPointUsed(sal_uInt32 nIndex) const
1313     {
1314         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1315
1316         return (mpPolygon->areControlPointsUsed() && !mpPolygon->getPrevControlVector(nIndex).equalZero());
1317     }
1318
1319     bool B2DPolygon::isNextControlPointUsed(sal_uInt32 nIndex) const
1320     {
1321         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1322
1323         return (mpPolygon->areControlPointsUsed() && !mpPolygon->getNextControlVector(nIndex).equalZero());
1324     }
1325
1326     B2VectorContinuity B2DPolygon::getContinuityInPoint(sal_uInt32 nIndex) const
1327     {
1328         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1329
1330         if(mpPolygon->areControlPointsUsed())
1331         {
1332             const B2DVector& rPrev(mpPolygon->getPrevControlVector(nIndex));
1333             const B2DVector& rNext(mpPolygon->getNextControlVector(nIndex));
1334
1335             return getContinuity(rPrev, rNext);
1336         }
1337         else
1338         {
1339             return CONTINUITY_NONE;
1340         }
1341     }
1342
1343     void B2DPolygon::getBezierSegment(sal_uInt32 nIndex, B2DCubicBezier& rTarget) const
1344     {
1345         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1346         const bool bNextIndexValidWithoutClose(nIndex + 1 < mpPolygon->count());
1347
1348         if(bNextIndexValidWithoutClose || mpPolygon->isClosed())
1349         {
1350             const sal_uInt32 nNextIndex(bNextIndexValidWithoutClose ? nIndex + 1 : 0);
1351             rTarget.setStartPoint(mpPolygon->getPoint(nIndex));
1352             rTarget.setEndPoint(mpPolygon->getPoint(nNextIndex));
1353
1354             if(mpPolygon->areControlPointsUsed())
1355             {
1356                 rTarget.setControlPointA(rTarget.getStartPoint() + mpPolygon->getNextControlVector(nIndex));
1357                 rTarget.setControlPointB(rTarget.getEndPoint() + mpPolygon->getPrevControlVector(nNextIndex));
1358             }
1359             else
1360             {
1361                 // no bezier, reset control poins at rTarget
1362                 rTarget.setControlPointA(rTarget.getStartPoint());
1363                 rTarget.setControlPointB(rTarget.getEndPoint());
1364             }
1365         }
1366         else
1367         {
1368             // no valid edge at all, reset rTarget to current point
1369             const B2DPoint aPoint(mpPolygon->getPoint(nIndex));
1370             rTarget.setStartPoint(aPoint);
1371             rTarget.setEndPoint(aPoint);
1372             rTarget.setControlPointA(aPoint);
1373             rTarget.setControlPointB(aPoint);
1374         }
1375     }
1376
1377     B2DPolygon B2DPolygon::getDefaultAdaptiveSubdivision() const
1378     {
1379         return mpPolygon->getDefaultAdaptiveSubdivision(*this);
1380     }
1381
1382     B2DRange B2DPolygon::getB2DRange() const
1383     {
1384         return mpPolygon->getB2DRange(*this);
1385     }
1386
1387     void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
1388     {
1389         if(rPoly.count())
1390         {
1391             if(!nCount)
1392             {
1393                 nCount = rPoly.count();
1394             }
1395
1396             if(0 == nIndex && nCount == rPoly.count())
1397             {
1398                 mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
1399             }
1400             else
1401             {
1402                 OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
1403                 ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
1404                 mpPolygon->insert(mpPolygon->count(), aTempPoly);
1405             }
1406         }
1407     }
1408
1409     void B2DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
1410     {
1411         OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B2DPolygon Remove outside range (!)");
1412
1413         if(nCount)
1414         {
1415             mpPolygon->remove(nIndex, nCount);
1416         }
1417     }
1418
1419     void B2DPolygon::clear()
1420     {
1421         mpPolygon = DefaultPolygon::get();
1422     }
1423
1424     bool B2DPolygon::isClosed() const
1425     {
1426         return mpPolygon->isClosed();
1427     }
1428
1429     void B2DPolygon::setClosed(bool bNew)
1430     {
1431         if(isClosed() != bNew)
1432         {
1433             mpPolygon->setClosed(bNew);
1434         }
1435     }
1436
1437     void B2DPolygon::flip()
1438     {
1439         if(count() > 1)
1440         {
1441             mpPolygon->flip();
1442         }
1443     }
1444
1445     bool B2DPolygon::hasDoublePoints() const
1446     {
1447         return (mpPolygon->count() > 1 && mpPolygon->hasDoublePoints());
1448     }
1449
1450     void B2DPolygon::removeDoublePoints()
1451     {
1452         if(hasDoublePoints())
1453         {
1454             mpPolygon->removeDoublePointsAtBeginEnd();
1455             mpPolygon->removeDoublePointsWholeTrack();
1456         }
1457     }
1458
1459     void B2DPolygon::transform(const B2DHomMatrix& rMatrix)
1460     {
1461         if(mpPolygon->count() && !rMatrix.isIdentity())
1462         {
1463             mpPolygon->transform(rMatrix);
1464         }
1465     }
1466
1467 } // end of namespace basegfx
1468
1469 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */