include/basegfx/tuple/b2dtuple.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 INCLUDED_BASEGFX_TUPLE_B2DTUPLE_HXX
  21 #define INCLUDED_BASEGFX_TUPLE_B2DTUPLE_HXX
  22
  23 #include <sal/types.h>
  24 #include <basegfx/numeric/ftools.hxx>
  25 #include <algorithm>
  26 #include <basegfx/basegfxdllapi.h>
  27
  28 namespace basegfx
  29 {
  30     class B2ITuple;
  31
  32     /** Base class for all Points/Vectors with two double values
  33
  34         This class provides all methods common to Point
  35         avd Vector classes which are derived from here.
  36
  37         @derive Use this class to implement Points or Vectors
  38         which are based on two double values
  39     */
  40     class SAL_WARN_UNUSED B2DTuple
  41     {
  42     protected:
  43         double                                      mfX;
  44         double                                      mfY;
  45
  46     public:
  47         /** Create a 2D Tuple
  48
  49             The tuple is initialized to (0.0, 0.0)
  50         */
  51         B2DTuple()
  52         :   mfX(0.0),
  53             mfY(0.0)
  54         {}
  55
  56         /** Create a 2D Tuple
  57
  58             @param fX
  59             This parameter is used to initialize the X-coordinate
  60             of the 2D Tuple.
  61
  62             @param fY
  63             This parameter is used to initialize the Y-coordinate
  64             of the 2D Tuple.
  65         */
  66         B2DTuple(double fX, double fY)
  67         :   mfX( fX ),
  68             mfY( fY )
  69         {}
  70
  71         /** Create a copy of a 2D integer Tuple
  72
  73             @param rTup
  74             The 2D Tuple which will be copied.
  75         */
  76         BASEGFX_DLLPUBLIC explicit B2DTuple(const B2ITuple& rTup);
  77
  78         /// Get X-Coordinate of 2D Tuple
  79         double getX() const
  80         {
  81             return mfX;
  82         }
  83
  84         /// Get Y-Coordinate of 2D Tuple
  85         double getY() const
  86         {
  87             return mfY;
  88         }
  89
  90         /// Set X-Coordinate of 2D Tuple
  91         void setX(double fX)
  92         {
  93             mfX = fX;
  94         }
  95
  96         /// Set Y-Coordinate of 2D Tuple
  97         void setY(double fY)
  98         {
  99             mfY = fY;
 100         }
 101
 102         /// Array-access to 2D Tuple
 103         const double& operator[] (int nPos) const
 104         {
 105             // Here, normally one if(...) should be used. In the assumption that
 106             // both double members can be accessed as an array a shortcut is used here.
 107             // if(0 == nPos) return mfX; return mfY;
 108             return *((&mfX) + nPos);
 109         }
 110
 111         /// Array-access to 2D Tuple
 112         double& operator[] (int nPos)
 113         {
 114             // Here, normally one if(...) should be used. In the assumption that
 115             // both double members can be accessed as an array a shortcut is used here.
 116             // if(0 == nPos) return mfX; return mfY;
 117             return *((&mfX) + nPos);
 118         }
 119
 120         // comparators with tolerance
 121
 122
 123         bool equalZero() const
 124         {
 125             return (this == &getEmptyTuple() ||
 126                     (fTools::equalZero(mfX) && fTools::equalZero(mfY)));
 127         }
 128
 129         bool equal(const B2DTuple& rTup) const
 130         {
 131             return (
 132                 this == &rTup ||
 133                 (fTools::equal(mfX, rTup.mfX) &&
 134                 fTools::equal(mfY, rTup.mfY)));
 135         }
 136
 137         // operators
 138
 139
 140         B2DTuple& operator+=( const B2DTuple& rTup )
 141         {
 142             mfX += rTup.mfX;
 143             mfY += rTup.mfY;
 144             return *this;
 145         }
 146
 147         B2DTuple& operator-=( const B2DTuple& rTup )
 148         {
 149             mfX -= rTup.mfX;
 150             mfY -= rTup.mfY;
 151             return *this;
 152         }
 153
 154         B2DTuple& operator/=( const B2DTuple& rTup )
 155         {
 156             mfX /= rTup.mfX;
 157             mfY /= rTup.mfY;
 158             return *this;
 159         }
 160
 161         B2DTuple& operator*=( const B2DTuple& rTup )
 162         {
 163             mfX *= rTup.mfX;
 164             mfY *= rTup.mfY;
 165             return *this;
 166         }
 167
 168         B2DTuple& operator*=(double t)
 169         {
 170             mfX *= t;
 171             mfY *= t;
 172             return *this;
 173         }
 174
 175         B2DTuple& operator/=(double t)
 176         {
 177             const double fVal(1.0 / t);
 178             mfX *= fVal;
 179             mfY *= fVal;
 180             return *this;
 181         }
 182
 183         B2DTuple operator-(void) const
 184         {
 185             return B2DTuple(-mfX, -mfY);
 186         }
 187
 188         bool operator==( const B2DTuple& rTup ) const
 189         {
 190             return mfX == rTup.mfX && mfY == rTup.mfY;
 191         }
 192
 193         bool operator!=( const B2DTuple& rTup ) const
 194         {
 195             return mfX != rTup.mfX || mfY != rTup.mfY;
 196         }
 197
 198         BASEGFX_DLLPUBLIC static const B2DTuple& getEmptyTuple();
 199     };
 200
 201     // external operators
 202
 203
 204     inline B2DTuple absolute(const B2DTuple& rTup)
 205     {
 206         B2DTuple aAbs(
 207             fabs(rTup.getX()),
 208             fabs(rTup.getY()));
 209         return aAbs;
 210     }
 211
 212     inline B2DTuple interpolate(const B2DTuple& rOld1, const B2DTuple& rOld2, double t)
 213     {
 214         if(rOld1 == rOld2)
 215         {
 216             return rOld1;
 217         }
 218         else if(0.0 >= t)
 219         {
 220             return rOld1;
 221         }
 222         else if(1.0 <= t)
 223         {
 224             return rOld2;
 225         }
 226         else
 227         {
 228             return B2DTuple(
 229                 ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
 230                 ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
 231         }
 232     }
 233
 234     inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2)
 235     {
 236         return B2DTuple(
 237             rtl::math::approxEqual(rOld1.getX(), rOld2.getX()) ? rOld1.getX() : (rOld1.getX() + rOld2.getX()) * 0.5,
 238             rtl::math::approxEqual(rOld1.getY(), rOld2.getY()) ? rOld1.getY() : (rOld1.getY() + rOld2.getY()) * 0.5);
 239     }
 240
 241     inline B2DTuple operator+(const B2DTuple& rTupA, const B2DTuple& rTupB)
 242     {
 243         B2DTuple aSum(rTupA);
 244         aSum += rTupB;
 245         return aSum;
 246     }
 247
 248     inline B2DTuple operator-(const B2DTuple& rTupA, const B2DTuple& rTupB)
 249     {
 250         B2DTuple aSub(rTupA);
 251         aSub -= rTupB;
 252         return aSub;
 253     }
 254
 255     inline B2DTuple operator/(const B2DTuple& rTupA, const B2DTuple& rTupB)
 256     {
 257         B2DTuple aDiv(rTupA);
 258         aDiv /= rTupB;
 259         return aDiv;
 260     }
 261
 262     inline B2DTuple operator*(const B2DTuple& rTupA, const B2DTuple& rTupB)
 263     {
 264         B2DTuple aMul(rTupA);
 265         aMul *= rTupB;
 266         return aMul;
 267     }
 268
 269     inline B2DTuple operator*(const B2DTuple& rTup, double t)
 270     {
 271         B2DTuple aNew(rTup);
 272         aNew *= t;
 273         return aNew;
 274     }
 275
 276     inline B2DTuple operator*(double t, const B2DTuple& rTup)
 277     {
 278         B2DTuple aNew(rTup);
 279         aNew *= t;
 280         return aNew;
 281     }
 282
 283     inline B2DTuple operator/(const B2DTuple& rTup, double t)
 284     {
 285         B2DTuple aNew(rTup);
 286         aNew /= t;
 287         return aNew;
 288     }
 289
 290     /** Round double to nearest integer for 2D tuple
 291
 292         @return the nearest integer for this tuple
 293     */
 294     BASEGFX_DLLPUBLIC B2ITuple fround(const B2DTuple& rTup);
 295 } // end of namespace basegfx
 296
 297 #endif // INCLUDED_BASEGFX_TUPLE_B2DTUPLE_HXX
 298
 299 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */