include/basegfx/range/b2drange.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 #pragma once
  21
  22 #include <ostream>
  23 #include <vector>
  24
  25 #include <basegfx/vector/b2dvector.hxx>
  26 #include <basegfx/point/b2dpoint.hxx>
  27 #include <basegfx/tuple/b2dtuple.hxx>
  28 #include <basegfx/range/basicrange.hxx>
  29 #include <basegfx/basegfxdllapi.h>
  30
  31 namespace basegfx
  32 {
  33     class B2IRange;
  34     class B2DHomMatrix;
  35
  36     /** A two-dimensional interval over doubles
  37
  38         This is a set of real numbers, bounded by a lower and an upper
  39         pair. All inbetween values are included in the set (see also
  40         http://en.wikipedia.org/wiki/Interval_%28mathematics%29).
  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 B1DRange
  51      */
  52     class SAL_WARN_UNUSED B2DRange
  53     {
  54     public:
  55         typedef double          ValueType;
  56         typedef DoubleTraits    TraitsType;
  57
  58         B2DRange() {}
  59
  60         /// Create degenerate interval consisting of a single point
  61         explicit B2DRange(const B2DTuple& rTuple)
  62         :   maRangeX(rTuple.getX()),
  63             maRangeY(rTuple.getY())
  64         {
  65         }
  66
  67         /// Create proper interval between the two given double pairs
  68         B2DRange(double x1,
  69                  double y1,
  70                  double x2,
  71                  double 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         B2DRange(const B2DTuple& rTuple1,
  81                  const B2DTuple& rTuple2)
  82         :   maRangeX(rTuple1.getX()),
  83             maRangeY(rTuple1.getY())
  84         {
  85             expand( rTuple2 );
  86         }
  87
  88         BASEGFX_DLLPUBLIC explicit B2DRange(const B2IRange& rRange);
  89
  90         /** Check if the interval set is empty
  91
  92             @return false, if no value is in this set - having a
  93             single point included will already return true.
  94          */
  95         bool isEmpty() const
  96         {
  97             return (
  98                 maRangeX.isEmpty()
  99                 || maRangeY.isEmpty()
 100                 );
 101         }
 102
 103         /// reset the object to empty state again, clearing all values
 104         void reset()
 105         {
 106             maRangeX.reset();
 107             maRangeY.reset();
 108         }
 109
 110         bool operator==( const B2DRange& rRange ) const
 111         {
 112             return (maRangeX == rRange.maRangeX
 113                 && maRangeY == rRange.maRangeY);
 114         }
 115
 116         bool operator!=( const B2DRange& rRange ) const
 117         {
 118             return (maRangeX != rRange.maRangeX
 119                 || maRangeY != rRange.maRangeY);
 120         }
 121
 122         bool equal(const B2DRange& rRange) const
 123         {
 124             return (maRangeX.equal(rRange.maRangeX)
 125                     && maRangeY.equal(rRange.maRangeY));
 126         }
 127
 128         /// get lower bound of the set. returns arbitrary values for empty sets.
 129         double getMinX() const
 130         {
 131             return maRangeX.getMinimum();
 132         }
 133
 134         /// get lower bound of the set. returns arbitrary values for empty sets.
 135         double getMinY() const
 136         {
 137             return maRangeY.getMinimum();
 138         }
 139
 140         /// get upper bound of the set. returns arbitrary values for empty sets.
 141         double getMaxX() const
 142         {
 143             return maRangeX.getMaximum();
 144         }
 145
 146         /// get upper bound of the set. returns arbitrary values for empty sets.
 147         double getMaxY() const
 148         {
 149             return maRangeY.getMaximum();
 150         }
 151
 152         /// return difference between upper and lower X value. returns 0 for empty sets.
 153         double getWidth() const
 154         {
 155             return maRangeX.getRange();
 156         }
 157
 158         /// return difference between upper and lower Y value. returns 0 for empty sets.
 159         double getHeight() const
 160         {
 161             return maRangeY.getRange();
 162         }
 163
 164         /// get lower bound of the set. returns arbitrary values for empty sets.
 165         B2DPoint getMinimum() const
 166         {
 167             return B2DPoint(
 168                 maRangeX.getMinimum(),
 169                 maRangeY.getMinimum()
 170                 );
 171         }
 172
 173         /// get upper bound of the set. returns arbitrary values for empty sets.
 174         B2DPoint getMaximum() const
 175         {
 176             return B2DPoint(
 177                 maRangeX.getMaximum(),
 178                 maRangeY.getMaximum()
 179                 );
 180         }
 181
 182         /// return difference between upper and lower point. returns (0,0) for empty sets.
 183         B2DVector getRange() const
 184         {
 185             return B2DVector(
 186                 maRangeX.getRange(),
 187                 maRangeY.getRange()
 188                 );
 189         }
 190
 191         /// return center point of set. returns (0,0) for empty sets.
 192         B2DPoint getCenter() const
 193         {
 194             return B2DPoint(
 195                 maRangeX.getCenter(),
 196                 maRangeY.getCenter()
 197                 );
 198         }
 199
 200         /// return center X value of set. returns 0 for empty sets.
 201         double getCenterX() const
 202         {
 203             return maRangeX.getCenter();
 204         }
 205
 206         /// return center Y value of set. returns 0 for empty sets.
 207         double getCenterY() const
 208         {
 209             return maRangeY.getCenter();
 210         }
 211
 212         /// yields true if given point is contained in set
 213         bool isInside(const B2DTuple& rTuple) const
 214         {
 215             return (
 216                 maRangeX.isInside(rTuple.getX())
 217                 && maRangeY.isInside(rTuple.getY())
 218                 );
 219         }
 220
 221         /// yields true if rRange is inside, or equal to set
 222         bool isInside(const B2DRange& rRange) const
 223         {
 224             return (
 225                 maRangeX.isInside(rRange.maRangeX)
 226                 && maRangeY.isInside(rRange.maRangeY)
 227                 );
 228         }
 229
 230         /// yields true if rRange at least partly inside set
 231         bool overlaps(const B2DRange& rRange) const
 232         {
 233             return (
 234                 maRangeX.overlaps(rRange.maRangeX)
 235                 && maRangeY.overlaps(rRange.maRangeY)
 236                 );
 237         }
 238
 239         /// yields true if overlaps(rRange) does, and the overlap is larger than infinitesimal
 240         bool overlapsMore(const B2DRange& rRange) const
 241         {
 242             return (
 243                 maRangeX.overlapsMore(rRange.maRangeX)
 244                 && maRangeY.overlapsMore(rRange.maRangeY)
 245                 );
 246         }
 247
 248         /// add point to the set, expanding as necessary
 249         void expand(const B2DTuple& rTuple)
 250         {
 251             maRangeX.expand(rTuple.getX());
 252             maRangeY.expand(rTuple.getY());
 253         }
 254
 255         /// add rRange to the set, expanding as necessary
 256         void expand(const B2DRange& rRange)
 257         {
 258             maRangeX.expand(rRange.maRangeX);
 259             maRangeY.expand(rRange.maRangeY);
 260         }
 261
 262         /// calc set intersection
 263         void intersect(const B2DRange& rRange)
 264         {
 265             maRangeX.intersect(rRange.maRangeX);
 266             maRangeY.intersect(rRange.maRangeY);
 267         }
 268
 269         /// grow set by fValue on all sides
 270         void grow(double fValue)
 271         {
 272             maRangeX.grow(fValue);
 273             maRangeY.grow(fValue);
 274         }
 275
 276         /// clamp value on range
 277         B2DTuple clamp(const B2DTuple& rTuple) const
 278         {
 279             return B2DTuple(
 280                 maRangeX.clamp(rTuple.getX()),
 281                 maRangeY.clamp(rTuple.getY()));
 282         }
 283
 284         /** Transform Range by given transformation matrix. */
 285         BASEGFX_DLLPUBLIC void transform(const B2DHomMatrix& rMatrix);
 286
 287         /** Transform Range by given transformation matrix.
 288
 289             This operation transforms the Range by transforming all four possible
 290             extrema points (corners) of the given range and building a new one.
 291             This means that the range will grow evtl. when a shear and/or rotation
 292             is part of the transformation.
 293         */
 294         BASEGFX_DLLPUBLIC B2DRange& operator*=( const ::basegfx::B2DHomMatrix& rMat );
 295
 296         /** Get a range filled with (0.0, 0.0, 1.0, 1.0) */
 297         static const B2DRange& getUnitB2DRange();
 298
 299     private:
 300         typedef ::basegfx::BasicRange< ValueType, TraitsType >  MyBasicRange;
 301
 302         MyBasicRange        maRangeX;
 303         MyBasicRange        maRangeY;
 304     };
 305
 306     /** Transform B2DRange by given transformation matrix (see operator*=())
 307     */
 308     B2DRange operator*( const B2DHomMatrix& rMat, const B2DRange& rB2DRange );
 309
 310     /** Round double to nearest integer for 2D range
 311
 312         @return the nearest integer for this range
 313     */
 314     BASEGFX_DLLPUBLIC B2IRange fround(const B2DRange& rRange);
 315
 316     /** Compute the set difference of the two given ranges
 317
 318         This method calculates the symmetric difference (aka XOR)
 319         between the two given ranges, and returning the resulting
 320         ranges. Thus, the result will contain all areas where one, but
 321         not both ranges lie.
 322
 323         @param o_rResult
 324         Result vector. The up to four difference ranges are returned
 325         within this vector
 326
 327         @param rFirst
 328         The first range
 329
 330         @param rSecond
 331         The second range
 332
 333         @return the input vector
 334      */
 335     BASEGFX_DLLPUBLIC ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >&   o_rResult,
 336                                                      const B2DRange&            rFirst,
 337                                                      const B2DRange&            rSecond );
 338
 339     template< typename charT, typename traits >
 340     inline std::basic_ostream<charT, traits> & operator <<(
 341         std::basic_ostream<charT, traits> & stream, const B2DRange& range )
 342     {
 343         return stream << range.getWidth() << "x" << range.getHeight() << "@" << range.getMinimum();
 344     }
 345
 346 } // end of namespace basegfx
 347
 348 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */