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