include/basegfx/range/b2irange.hxx

   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 #ifndef _BGFX_RANGE_B2IRANGE_HXX
  21 #define _BGFX_RANGE_B2IRANGE_HXX
  22
  23 #include <basegfx/point/b2ipoint.hxx>
  24 #include <basegfx/point/b2dpoint.hxx>
  25 #include <basegfx/tuple/b2ituple.hxx>
  26 #include <basegfx/tuple/b2i64tuple.hxx>
  27 #include <basegfx/range/basicrange.hxx>
  28 #include <vector>
  29 #include <basegfx/basegfxdllapi.h>
  30
  31
  32 namespace basegfx
  33 {
  34     /** A two-dimensional interval over integers
  35
  36         This is a set of real numbers, bounded by a lower and an upper
  37         pair. All inbetween values are included in the set (see also
  38         http://en.wikipedia.org/wiki/Interval_%28mathematics%29).
  39
  40         Probably you rather want B2IBox for integers.
  41
  42         The set is closed, i.e. the upper and the lower bound are
  43         included (if you're used to the notation - we're talking about
  44         [a,b] here, compared to half-open [a,b) or open intervals
  45         (a,b)).
  46
  47         That means, isInside(val) will return true also for values of
  48         val=a or val=b.
  49
  50         @see B2IBox
  51      */
  52     class B2IRange
  53     {
  54     public:
  55         typedef sal_Int32       ValueType;
  56         typedef Int32Traits     TraitsType;
  57
  58         B2IRange() {}
  59
  60         /// Create degenerate interval consisting of a single point
  61         explicit B2IRange(const B2ITuple& rTuple)
  62         :   maRangeX(rTuple.getX()),
  63             maRangeY(rTuple.getY())
  64         {
  65         }
  66
  67         /// Create proper interval between the two given integer pairs
  68         B2IRange(sal_Int32 x1,
  69                  sal_Int32 y1,
  70                  sal_Int32 x2,
  71                  sal_Int32 y2)
  72         :   maRangeX(x1),
  73             maRangeY(y1)
  74         {
  75             maRangeX.expand(x2);
  76             maRangeY.expand(y2);
  77         }
  78
  79         /// Create proper interval between the two given points
  80         B2IRange(const B2ITuple& rTuple1,
  81                  const B2ITuple& rTuple2)
  82         :   maRangeX(rTuple1.getX()),
  83             maRangeY(rTuple1.getY())
  84         {
  85             expand( rTuple2 );
  86         }
  87
  88         /** Check if the interval set is empty
  89
  90             @return false, if no value is in this set - having a
  91             single point included will already return true.
  92          */
  93         bool isEmpty() const
  94         {
  95             return maRangeX.isEmpty() || maRangeY.isEmpty();
  96         }
  97
  98         /// reset the object to empty state again, clearing all values
  99         void reset()
 100         {
 101             maRangeX.reset();
 102             maRangeY.reset();
 103         }
 104
 105         bool operator==( const B2IRange& rRange ) const
 106         {
 107             return (maRangeX == rRange.maRangeX
 108                 && maRangeY == rRange.maRangeY);
 109         }
 110
 111         bool operator!=( const B2IRange& rRange ) const
 112         {
 113             return (maRangeX != rRange.maRangeX
 114                 || maRangeY != rRange.maRangeY);
 115         }
 116
 117         /// get lower bound of the set. returns arbitrary values for empty sets.
 118         sal_Int32 getMinX() const
 119         {
 120             return maRangeX.getMinimum();
 121         }
 122
 123         /// get lower bound of the set. returns arbitrary values for empty sets.
 124         sal_Int32 getMinY() const
 125         {
 126             return maRangeY.getMinimum();
 127         }
 128
 129         /// get upper bound of the set. returns arbitrary values for empty sets.
 130         sal_Int32 getMaxX() const
 131         {
 132             return maRangeX.getMaximum();
 133         }
 134
 135         /// get upper bound of the set. returns arbitrary values for empty sets.
 136         sal_Int32 getMaxY() const
 137         {
 138             return maRangeY.getMaximum();
 139         }
 140
 141         /// return difference between upper and lower X value. returns 0 for empty sets.
 142         sal_Int64 getWidth() const
 143         {
 144             return maRangeX.getRange();
 145         }
 146
 147         /// return difference between upper and lower Y value. returns 0 for empty sets.
 148         sal_Int64 getHeight() const
 149         {
 150             return maRangeY.getRange();
 151         }
 152
 153         /// get lower bound of the set. returns arbitrary values for empty sets.
 154         B2IPoint getMinimum() const
 155         {
 156             return B2IPoint(
 157                 maRangeX.getMinimum(),
 158                 maRangeY.getMinimum()
 159                 );
 160         }
 161
 162         /// get upper bound of the set. returns arbitrary values for empty sets.
 163         B2IPoint getMaximum() const
 164         {
 165             return B2IPoint(
 166                 maRangeX.getMaximum(),
 167                 maRangeY.getMaximum()
 168                 );
 169         }
 170
 171         /// return difference between upper and lower point. returns (0,0) for empty sets.
 172         B2I64Tuple getRange() const
 173         {
 174             return B2I64Tuple(
 175                 maRangeX.getRange(),
 176                 maRangeY.getRange()
 177                 );
 178         }
 179
 180         /// return center point of set. returns (0,0) for empty sets.
 181         B2DPoint getCenter() const
 182         {
 183             return B2DPoint(
 184                 maRangeX.getCenter(),
 185                 maRangeY.getCenter()
 186                 );
 187         }
 188
 189         /// yields true if given point is contained in set
 190         bool isInside(const B2ITuple& rTuple) const
 191         {
 192             return (
 193                 maRangeX.isInside(rTuple.getX())
 194                 && maRangeY.isInside(rTuple.getY())
 195                 );
 196         }
 197
 198         /// yields true if rRange is inside, or equal to set
 199         bool isInside(const B2IRange& rRange) const
 200         {
 201             return (
 202                 maRangeX.isInside(rRange.maRangeX)
 203                 && maRangeY.isInside(rRange.maRangeY)
 204                 );
 205         }
 206
 207         /// yields true if rRange at least partly inside set
 208         bool overlaps(const B2IRange& rRange) const
 209         {
 210             return (
 211                 maRangeX.overlaps(rRange.maRangeX)
 212                 && maRangeY.overlaps(rRange.maRangeY)
 213                 );
 214         }
 215
 216         /// yields true if overlaps(rRange) does, and the overlap is larger than infinitesimal
 217         bool overlapsMore(const B2IRange& rRange) const
 218         {
 219             return (
 220                 maRangeX.overlapsMore(rRange.maRangeX)
 221                 && maRangeY.overlapsMore(rRange.maRangeY)
 222                 );
 223         }
 224
 225         /// add point to the set, expanding as necessary
 226         void expand(const B2ITuple& rTuple)
 227         {
 228             maRangeX.expand(rTuple.getX());
 229             maRangeY.expand(rTuple.getY());
 230         }
 231
 232         /// add rRange to the set, expanding as necessary
 233         void expand(const B2IRange& rRange)
 234         {
 235             maRangeX.expand(rRange.maRangeX);
 236             maRangeY.expand(rRange.maRangeY);
 237         }
 238
 239         /// calc set intersection
 240         void intersect(const B2IRange& rRange)
 241         {
 242             maRangeX.intersect(rRange.maRangeX);
 243             maRangeY.intersect(rRange.maRangeY);
 244         }
 245
 246         /// grow set by nValue on all sides
 247         void grow(sal_Int32 nValue)
 248         {
 249             maRangeX.grow(nValue);
 250             maRangeY.grow(nValue);
 251         }
 252
 253     private:
 254         typedef ::basegfx::BasicRange< ValueType, TraitsType >  MyBasicRange;
 255
 256         MyBasicRange        maRangeX;
 257         MyBasicRange        maRangeY;
 258     };
 259
 260     /** Compute the set difference of the two given ranges
 261
 262         This method calculates the symmetric difference (aka XOR)
 263         between the two given ranges, and returning the resulting
 264         ranges. Thus, the result will contain all areas where one, but
 265         not both ranges lie.
 266
 267         @param o_rResult
 268         Result vector. The up to four difference ranges are returned
 269         within this vector
 270
 271         @param rFirst
 272         The first range
 273
 274         @param rSecond
 275         The second range
 276
 277         @return the input vector
 278      */
 279     BASEGFX_DLLPUBLIC ::std::vector< B2IRange >& computeSetDifference( ::std::vector< B2IRange >&   o_rResult,
 280                                                      const B2IRange&            rFirst,
 281                                                      const B2IRange&            rSecond );
 282
 283 } // end of namespace basegfx
 284
 285 #endif /* _BGFX_RANGE_B2IRANGE_HXX */
 286
 287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */