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 #pragma once
  21
  22 #include <sal/types.h>
  23 #include <basegfx/numeric/ftools.hxx>
  24 #include <basegfx/basegfxdllapi.h>
  25 #include <basegfx/utils/common.hxx>
  26
  27 namespace basegfx
  28 {
  29     class B2ITuple;
  30
  31     /** Base class for all Points/Vectors with two double values
  32
  33         This class provides all methods common to Point
  34         and Vector classes which are derived from here.
  35
  36         @derive Use this class to implement Points or Vectors
  37         which are based on two double values
  38     */
  39     class SAL_WARN_UNUSED B2DTuple
  40     {
  41     protected:
  42         double mfX;
  43         double mfY;
  44
  45     public:
  46
  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         double get(Axis2D eAxis)
 103         {
 104             return eAxis == Axis2D::X ? getX() : getY();
 105         }
 106
 107         void set(Axis2D eAxis, double fValue)
 108         {
 109             if (eAxis == Axis2D::X)
 110                 setX(fValue);
 111             else
 112                 setY(fValue);
 113         }
 114
 115         // comparators with tolerance
 116
 117         bool equalZero() const
 118         {
 119             return (this == &getEmptyTuple() ||
 120                     (fTools::equalZero(mfX) && fTools::equalZero(mfY)));
 121         }
 122
 123         bool equal(const B2DTuple& rTup) const
 124         {
 125             return (
 126                 this == &rTup ||
 127                 (fTools::equal(mfX, rTup.mfX) &&
 128                 fTools::equal(mfY, rTup.mfY)));
 129         }
 130
 131         // operators
 132
 133
 134         B2DTuple& operator+=( const B2DTuple& rTup )
 135         {
 136             mfX += rTup.mfX;
 137             mfY += rTup.mfY;
 138             return *this;
 139         }
 140
 141         B2DTuple& operator-=( const B2DTuple& rTup )
 142         {
 143             mfX -= rTup.mfX;
 144             mfY -= rTup.mfY;
 145             return *this;
 146         }
 147
 148         B2DTuple& operator/=( const B2DTuple& rTup )
 149         {
 150             mfX /= rTup.mfX;
 151             mfY /= rTup.mfY;
 152             return *this;
 153         }
 154
 155         B2DTuple& operator*=( const B2DTuple& rTup )
 156         {
 157             mfX *= rTup.mfX;
 158             mfY *= rTup.mfY;
 159             return *this;
 160         }
 161
 162         B2DTuple& operator*=(double t)
 163         {
 164             mfX *= t;
 165             mfY *= t;
 166             return *this;
 167         }
 168
 169         B2DTuple& operator/=(double t)
 170         {
 171             const double fVal(1.0 / t);
 172             mfX *= fVal;
 173             mfY *= fVal;
 174             return *this;
 175         }
 176
 177         B2DTuple operator-(void) const
 178         {
 179             return B2DTuple(-mfX, -mfY);
 180         }
 181
 182         bool operator==( const B2DTuple& rTup ) const
 183         {
 184             return mfX == rTup.mfX && mfY == rTup.mfY;
 185         }
 186
 187         bool operator!=( const B2DTuple& rTup ) const
 188         {
 189             return mfX != rTup.mfX || mfY != rTup.mfY;
 190         }
 191
 192         BASEGFX_DLLPUBLIC static const B2DTuple& getEmptyTuple();
 193     };
 194
 195     // external operators
 196
 197
 198     inline B2DTuple absolute(const B2DTuple& rTup)
 199     {
 200         B2DTuple aAbs(
 201             fabs(rTup.getX()),
 202             fabs(rTup.getY()));
 203         return aAbs;
 204     }
 205
 206     inline B2DTuple interpolate(const B2DTuple& rOld1, const B2DTuple& rOld2, double t)
 207     {
 208         if(rOld1 == rOld2)
 209         {
 210             return rOld1;
 211         }
 212         else if(0.0 >= t)
 213         {
 214             return rOld1;
 215         }
 216         else if(1.0 <= t)
 217         {
 218             return rOld2;
 219         }
 220         else
 221         {
 222             return B2DTuple(
 223                 ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
 224                 ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
 225         }
 226     }
 227
 228     inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2)
 229     {
 230         return B2DTuple(
 231             rtl_math_approxEqual(rOld1.getX(), rOld2.getX()) ? rOld1.getX() : (rOld1.getX() + rOld2.getX()) * 0.5,
 232             rtl_math_approxEqual(rOld1.getY(), rOld2.getY()) ? rOld1.getY() : (rOld1.getY() + rOld2.getY()) * 0.5);
 233     }
 234
 235     inline B2DTuple operator+(const B2DTuple& rTupA, const B2DTuple& rTupB)
 236     {
 237         B2DTuple aSum(rTupA);
 238         aSum += rTupB;
 239         return aSum;
 240     }
 241
 242     inline B2DTuple operator-(const B2DTuple& rTupA, const B2DTuple& rTupB)
 243     {
 244         B2DTuple aSub(rTupA);
 245         aSub -= rTupB;
 246         return aSub;
 247     }
 248
 249     inline B2DTuple operator/(const B2DTuple& rTupA, const B2DTuple& rTupB)
 250     {
 251         B2DTuple aDiv(rTupA);
 252         aDiv /= rTupB;
 253         return aDiv;
 254     }
 255
 256     inline B2DTuple operator*(const B2DTuple& rTupA, const B2DTuple& rTupB)
 257     {
 258         B2DTuple aMul(rTupA);
 259         aMul *= rTupB;
 260         return aMul;
 261     }
 262
 263     inline B2DTuple operator*(const B2DTuple& rTup, double t)
 264     {
 265         B2DTuple aNew(rTup);
 266         aNew *= t;
 267         return aNew;
 268     }
 269
 270     inline B2DTuple operator*(double t, const B2DTuple& rTup)
 271     {
 272         B2DTuple aNew(rTup);
 273         aNew *= t;
 274         return aNew;
 275     }
 276
 277     inline B2DTuple operator/(const B2DTuple& rTup, double t)
 278     {
 279         B2DTuple aNew(rTup);
 280         aNew /= t;
 281         return aNew;
 282     }
 283
 284     /** Round double to nearest integer for 2D tuple
 285
 286         @return the nearest integer for this tuple
 287     */
 288     BASEGFX_DLLPUBLIC B2ITuple fround(const B2DTuple& rTup);
 289 } // end of namespace basegfx
 290
 291 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */