basegfx/source/tools/b2dclipstate.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/tools/b2dclipstate.hxx>
  21
  22 #include <basegfx/range/b2drange.hxx>
  23 #include <basegfx/range/b2dpolyrange.hxx>
  24 #include <basegfx/range/b2drangeclipper.hxx>
  25 #include <basegfx/polygon/b2dpolygon.hxx>
  26 #include <basegfx/polygon/b2dpolygontools.hxx>
  27 #include <basegfx/polygon/b2dpolypolygon.hxx>
  28 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  29 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  30
  31 namespace basegfx
  32 {
  33 namespace tools
  34 {
  35     class ImplB2DClipState
  36     {
  37     public:
  38         enum Operation {UNION, INTERSECT, XOR, SUBTRACT};
  39
  40         ImplB2DClipState() :
  41             maPendingPolygons(),
  42             maPendingRanges(),
  43             maClipPoly(),
  44             mePendingOps(UNION)
  45         {}
  46
  47         explicit ImplB2DClipState( const B2DPolyPolygon& rPoly ) :
  48             maPendingPolygons(),
  49             maPendingRanges(),
  50             maClipPoly(rPoly),
  51             mePendingOps(UNION)
  52         {}
  53
  54         bool isCleared() const
  55         {
  56             return !maClipPoly.count()
  57                 && !maPendingPolygons.count()
  58                 && !maPendingRanges.count();
  59         }
  60
  61         bool isNullClipPoly() const
  62         {
  63             return maClipPoly.count() == 1
  64                 && !maClipPoly.getB2DPolygon(0).count();
  65         }
  66
  67         bool isNull() const
  68         {
  69             return !maPendingPolygons.count()
  70                 && !maPendingRanges.count()
  71                 && isNullClipPoly();
  72         }
  73
  74         void makeNull()
  75         {
  76             maPendingPolygons.clear();
  77             maPendingRanges.clear();
  78             maClipPoly.clear();
  79             maClipPoly.append(B2DPolygon());
  80             mePendingOps = UNION;
  81         }
  82
  83         bool operator==(const ImplB2DClipState& rRHS) const
  84         {
  85             return maPendingPolygons == rRHS.maPendingPolygons
  86                 && maPendingRanges == rRHS.maPendingRanges
  87                 && maClipPoly == rRHS.maClipPoly
  88                 && mePendingOps == rRHS.mePendingOps;
  89         }
  90
  91         void addRange(const B2DRange& rRange, Operation eOp)
  92         {
  93             if( rRange.isEmpty() )
  94                 return;
  95
  96             commitPendingPolygons();
  97             if( mePendingOps != eOp )
  98                 commitPendingRanges();
  99
 100             mePendingOps = eOp;
 101             maPendingRanges.appendElement(
 102                 rRange,
 103                 ORIENTATION_POSITIVE);
 104         }
 105
 106         void addPolygon(B2DPolygon aPoly, Operation eOp)
 107         {
 108             commitPendingRanges();
 109             if( mePendingOps != eOp )
 110                 commitPendingPolygons();
 111
 112             mePendingOps = eOp;
 113             maPendingPolygons.append(aPoly);
 114         }
 115
 116         void addPolyPolygon(B2DPolyPolygon aPoly, Operation eOp)
 117         {
 118             commitPendingRanges();
 119             if( mePendingOps != eOp )
 120                 commitPendingPolygons();
 121
 122             mePendingOps = eOp;
 123             maPendingPolygons.append(aPoly);
 124         }
 125
 126         void unionRange(const B2DRange& rRange)
 127         {
 128             if( isCleared() )
 129                 return;
 130
 131             addRange(rRange,UNION);
 132         }
 133
 134         void unionPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 135         {
 136             if( isCleared() )
 137                 return;
 138
 139             addPolyPolygon(rPolyPoly,UNION);
 140         }
 141
 142         void intersectRange(const B2DRange& rRange)
 143         {
 144             if( isNull() )
 145                 return;
 146
 147             addRange(rRange,INTERSECT);
 148         }
 149
 150         void intersectPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 151         {
 152             if( isNull() )
 153                 return;
 154
 155             addPolyPolygon(rPolyPoly,INTERSECT);
 156         }
 157
 158         void subtractRange(const B2DRange& rRange )
 159         {
 160             if( isNull() )
 161                 return;
 162
 163             addRange(rRange,SUBTRACT);
 164         }
 165
 166         void subtractPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 167         {
 168             if( isNull() )
 169                 return;
 170
 171             addPolyPolygon(rPolyPoly,SUBTRACT);
 172         }
 173
 174         void xorRange(const B2DRange& rRange)
 175         {
 176             addRange(rRange,XOR);
 177         }
 178
 179         void xorPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 180         {
 181             addPolyPolygon(rPolyPoly,XOR);
 182         }
 183
 184         B2DPolyPolygon getClipPoly() const
 185         {
 186             commitPendingRanges();
 187             commitPendingPolygons();
 188
 189             return maClipPoly;
 190         }
 191
 192     private:
 193         void commitPendingPolygons() const
 194         {
 195             if( !maPendingPolygons.count() )
 196                 return;
 197
 198             // assumption: maClipPoly has kept polygons prepared for
 199             // clipping; i.e. no neutral polygons & correct
 200             // orientation
 201             maPendingPolygons = tools::prepareForPolygonOperation(maPendingPolygons);
 202             const bool bIsEmpty=isNullClipPoly();
 203             const bool bIsCleared=!maClipPoly.count();
 204             switch(mePendingOps)
 205             {
 206                 case UNION:
 207                     OSL_ASSERT( !bIsCleared );
 208
 209                     if( bIsEmpty )
 210                         maClipPoly = maPendingPolygons;
 211                     else
 212                         maClipPoly = tools::solvePolygonOperationOr(
 213                             maClipPoly,
 214                             maPendingPolygons);
 215                     break;
 216                 case INTERSECT:
 217                     OSL_ASSERT( !bIsEmpty );
 218
 219                     if( bIsCleared )
 220                         maClipPoly = maPendingPolygons;
 221                     else
 222                         maClipPoly = tools::solvePolygonOperationAnd(
 223                             maClipPoly,
 224                             maPendingPolygons);
 225                     break;
 226                 case XOR:
 227                     if( bIsEmpty )
 228                         maClipPoly = maPendingPolygons;
 229                     else if( bIsCleared )
 230                     {
 231                         // not representable, strictly speaking,
 232                         // using polygons with the common even/odd
 233                         // or nonzero winding number fill rule. If
 234                         // we'd want to represent it, fill rule
 235                         // would need to be "non-negative winding
 236                         // number" (and we then would return
 237                         // 'holes' here)
 238
 239                         // going for an ugly hack meanwhile
 240                         maClipPoly = tools::solvePolygonOperationXor(
 241                             B2DPolyPolygon(
 242                                 tools::createPolygonFromRect(B2DRange(-1E20,-1E20,1E20,1E20))),
 243                             maPendingPolygons);
 244                     }
 245                     else
 246                         maClipPoly = tools::solvePolygonOperationXor(
 247                             maClipPoly,
 248                             maPendingPolygons);
 249                     break;
 250                 case SUBTRACT:
 251                     OSL_ASSERT( !bIsEmpty );
 252
 253                     // first union all pending ones, subtract en bloc then
 254                     maPendingPolygons = solveCrossovers(maPendingPolygons);
 255                     maPendingPolygons = stripNeutralPolygons(maPendingPolygons);
 256                     maPendingPolygons = stripDispensablePolygons(maPendingPolygons, false);
 257
 258                     if( bIsCleared )
 259                     {
 260                         // not representable, strictly speaking,
 261                         // using polygons with the common even/odd
 262                         // or nonzero winding number fill rule. If
 263                         // we'd want to represent it, fill rule
 264                         // would need to be "non-negative winding
 265                         // number" (and we then would return
 266                         // 'holes' here)
 267
 268                         // going for an ugly hack meanwhile
 269                         maClipPoly = tools::solvePolygonOperationDiff(
 270                             B2DPolyPolygon(
 271                                 tools::createPolygonFromRect(B2DRange(-1E20,-1E20,1E20,1E20))),
 272                             maPendingPolygons);
 273                     }
 274                     else
 275                         maClipPoly = tools::solvePolygonOperationDiff(
 276                             maClipPoly,
 277                             maPendingPolygons);
 278                     break;
 279             }
 280
 281             maPendingPolygons.clear();
 282             mePendingOps = UNION;
 283         }
 284
 285         void commitPendingRanges() const
 286         {
 287             if( !maPendingRanges.count() )
 288                 return;
 289
 290             // use the specialized range clipper for the win
 291             B2DPolyPolygon aCollectedRanges;
 292             const bool bIsEmpty=isNullClipPoly();
 293             const bool bIsCleared=!maClipPoly.count();
 294             switch(mePendingOps)
 295             {
 296                 case UNION:
 297                     OSL_ASSERT( !bIsCleared );
 298
 299                     aCollectedRanges = maPendingRanges.solveCrossovers();
 300                     aCollectedRanges = stripNeutralPolygons(aCollectedRanges);
 301                     aCollectedRanges = stripDispensablePolygons(aCollectedRanges, false);
 302                     if( bIsEmpty )
 303                         maClipPoly = aCollectedRanges;
 304                     else
 305                         maClipPoly = tools::solvePolygonOperationOr(
 306                             maClipPoly,
 307                             aCollectedRanges);
 308                     break;
 309                 case INTERSECT:
 310                     OSL_ASSERT( !bIsEmpty );
 311
 312                     aCollectedRanges = maPendingRanges.solveCrossovers();
 313                     aCollectedRanges = stripNeutralPolygons(aCollectedRanges);
 314                     if( maPendingRanges.count() > 1 )
 315                         aCollectedRanges = stripDispensablePolygons(aCollectedRanges, true);
 316
 317                     if( bIsCleared )
 318                         maClipPoly = aCollectedRanges;
 319                     else
 320                         maClipPoly = tools::solvePolygonOperationAnd(
 321                             maClipPoly,
 322                             aCollectedRanges);
 323                     break;
 324                 case XOR:
 325                     aCollectedRanges = maPendingRanges.solveCrossovers();
 326                     aCollectedRanges = stripNeutralPolygons(aCollectedRanges);
 327                     aCollectedRanges = correctOrientations(aCollectedRanges);
 328
 329                     if( bIsEmpty )
 330                         maClipPoly = aCollectedRanges;
 331                     else if( bIsCleared )
 332                     {
 333                         // not representable, strictly speaking,
 334                         // using polygons with the common even/odd
 335                         // or nonzero winding number fill rule. If
 336                         // we'd want to represent it, fill rule
 337                         // would need to be "non-negative winding
 338                         // number" (and we then would return
 339                         // 'holes' here)
 340
 341                         // going for an ugly hack meanwhile
 342                         maClipPoly = tools::solvePolygonOperationXor(
 343                             B2DPolyPolygon(
 344                                 tools::createPolygonFromRect(B2DRange(-1E20,-1E20,1E20,1E20))),
 345                             aCollectedRanges);
 346                     }
 347                     else
 348                         maClipPoly = tools::solvePolygonOperationXor(
 349                             maClipPoly,
 350                             aCollectedRanges);
 351                     break;
 352                 case SUBTRACT:
 353                     OSL_ASSERT( !bIsEmpty );
 354
 355                     // first union all pending ranges, subtract en bloc then
 356                     aCollectedRanges = maPendingRanges.solveCrossovers();
 357                     aCollectedRanges = stripNeutralPolygons(aCollectedRanges);
 358                     aCollectedRanges = stripDispensablePolygons(aCollectedRanges, false);
 359
 360                     if( bIsCleared )
 361                     {
 362                         // not representable, strictly speaking,
 363                         // using polygons with the common even/odd
 364                         // or nonzero winding number fill rule. If
 365                         // we'd want to represent it, fill rule
 366                         // would need to be "non-negative winding
 367                         // number" (and we then would return
 368                         // 'holes' here)
 369
 370                         // going for an ugly hack meanwhile
 371                         maClipPoly = tools::solvePolygonOperationDiff(
 372                             B2DPolyPolygon(
 373                                 tools::createPolygonFromRect(B2DRange(-1E20,-1E20,1E20,1E20))),
 374                             aCollectedRanges);
 375                     }
 376                     else
 377                         maClipPoly = tools::solvePolygonOperationDiff(
 378                             maClipPoly,
 379                             aCollectedRanges);
 380                     break;
 381             }
 382
 383             maPendingRanges.clear();
 384             mePendingOps = UNION;
 385         }
 386
 387         mutable B2DPolyPolygon maPendingPolygons;
 388         mutable B2DPolyRange   maPendingRanges;
 389         mutable B2DPolyPolygon maClipPoly;
 390         mutable Operation      mePendingOps;
 391     };
 392
 393     B2DClipState::B2DClipState() :
 394         mpImpl()
 395     {}
 396
 397     B2DClipState::~B2DClipState()
 398     {}
 399
 400     B2DClipState::B2DClipState( const B2DClipState& rOrig ) :
 401         mpImpl(rOrig.mpImpl)
 402     {}
 403
 404     B2DClipState::B2DClipState( const B2DPolyPolygon& rPolyPoly ) :
 405         mpImpl( ImplB2DClipState(rPolyPoly) )
 406     {}
 407
 408     B2DClipState& B2DClipState::operator=( const B2DClipState& rRHS )
 409     {
 410         mpImpl = rRHS.mpImpl;
 411         return *this;
 412     }
 413
 414     void B2DClipState::makeNull()
 415     {
 416         mpImpl->makeNull();
 417     }
 418
 419     bool B2DClipState::isCleared() const
 420     {
 421         return mpImpl->isCleared();
 422     }
 423
 424     bool B2DClipState::operator==(const B2DClipState& rRHS) const
 425     {
 426         if(mpImpl.same_object(rRHS.mpImpl))
 427             return true;
 428
 429         return ((*mpImpl) == (*rRHS.mpImpl));
 430     }
 431
 432     bool B2DClipState::operator!=(const B2DClipState& rRHS) const
 433     {
 434         return !(*this == rRHS);
 435     }
 436
 437     void B2DClipState::unionRange(const B2DRange& rRange)
 438     {
 439         mpImpl->unionRange(rRange);
 440     }
 441
 442     void B2DClipState::unionPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 443     {
 444         mpImpl->unionPolyPolygon(rPolyPoly);
 445     }
 446
 447     void B2DClipState::intersectRange(const B2DRange& rRange)
 448     {
 449         mpImpl->intersectRange(rRange);
 450     }
 451
 452     void B2DClipState::intersectPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 453     {
 454         mpImpl->intersectPolyPolygon(rPolyPoly);
 455     }
 456
 457     void B2DClipState::subtractRange(const B2DRange& rRange)
 458     {
 459         mpImpl->subtractRange(rRange);
 460     }
 461
 462     void B2DClipState::subtractPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 463     {
 464         mpImpl->subtractPolyPolygon(rPolyPoly);
 465     }
 466
 467     void B2DClipState::xorRange(const B2DRange& rRange)
 468     {
 469         mpImpl->xorRange(rRange);
 470     }
 471
 472     void B2DClipState::xorPolyPolygon(const B2DPolyPolygon& rPolyPoly)
 473     {
 474         mpImpl->xorPolyPolygon(rPolyPoly);
 475     }
 476
 477     B2DPolyPolygon B2DClipState::getClipPoly() const
 478     {
 479         return mpImpl->getClipPoly();
 480     }
 481
 482 } // end of namespace tools
 483 } // end of namespace basegfx
 484
 485 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */