include/basegfx/tuple/b3i64tuple.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_B3I64TUPLE_HXX
  21 #define INCLUDED_BASEGFX_TUPLE_B3I64TUPLE_HXX
  22
  23 #include <sal/types.h>
  24 #include <basegfx/tuple/b3dtuple.hxx>
  25 #include <basegfx/basegfxdllapi.h>
  26
  27
  28 namespace basegfx
  29 {
  30     /** Base class for all Points/Vectors with three sal_Int64 values
  31
  32         This class provides all methods common to Point
  33         avd Vector classes which are derived from here.
  34
  35         @derive Use this class to implement Points or Vectors
  36         which are based on three sal_Int64 values
  37     */
  38     class BASEGFX_DLLPUBLIC SAL_WARN_UNUSED B3I64Tuple
  39     {
  40     protected:
  41         sal_Int64                                       mnX;
  42         sal_Int64                                       mnY;
  43         sal_Int64                                       mnZ;
  44
  45     public:
  46         /** Create a 3D Tuple
  47
  48             The tuple is initialized to (0, 0, 0)
  49         */
  50         B3I64Tuple()
  51         :   mnX(0),
  52             mnY(0),
  53             mnZ(0)
  54         {}
  55
  56         /** Create a 3D Tuple
  57
  58             @param nX
  59             This parameter is used to initialize the X-coordinate
  60             of the 3D Tuple.
  61
  62             @param nY
  63             This parameter is used to initialize the Y-coordinate
  64             of the 3D Tuple.
  65
  66             @param nZ
  67             This parameter is used to initialize the Z-coordinate
  68             of the 3D Tuple.
  69         */
  70         B3I64Tuple(sal_Int64 nX, sal_Int64 nY, sal_Int64 nZ)
  71         :   mnX(nX),
  72             mnY(nY),
  73             mnZ(nZ)
  74         {}
  75
  76         /** Create a copy of a 3D Tuple
  77
  78             @param rTup
  79             The 3D Tuple which will be copied.
  80         */
  81         B3I64Tuple(const B3I64Tuple& rTup)
  82         :   mnX( rTup.mnX ),
  83             mnY( rTup.mnY ),
  84             mnZ( rTup.mnZ )
  85         {}
  86
  87         ~B3I64Tuple()
  88         {}
  89
  90         /// get X-Coordinate of 3D Tuple
  91         sal_Int64 getX() const
  92         {
  93             return mnX;
  94         }
  95
  96         /// get Y-Coordinate of 3D Tuple
  97         sal_Int64 getY() const
  98         {
  99             return mnY;
 100         }
 101
 102         /// get Z-Coordinate of 3D Tuple
 103         sal_Int64 getZ() const
 104         {
 105             return mnZ;
 106         }
 107
 108         /// set X-Coordinate of 3D Tuple
 109         void setX(sal_Int64 nX)
 110         {
 111             mnX = nX;
 112         }
 113
 114         /// set Y-Coordinate of 3D Tuple
 115         void setY(sal_Int64 nY)
 116         {
 117             mnY = nY;
 118         }
 119
 120         /// set Z-Coordinate of 3D Tuple
 121         void setZ(sal_Int64 nZ)
 122         {
 123             mnZ = nZ;
 124         }
 125
 126         /// Array-access to 3D Tuple
 127         const sal_Int64& operator[] (int nPos) const
 128         {
 129             // Here, normally two if(...)'s should be used. In the assumption that
 130             // both sal_Int64 members can be accessed as an array a shortcut is used here.
 131             // if(0 == nPos) return mnX; if(1 == nPos) return mnY; return mnZ;
 132             return *((&mnX) + nPos);
 133         }
 134
 135         /// Array-access to 3D Tuple
 136         sal_Int64& operator[] (int nPos)
 137         {
 138             // Here, normally two if(...)'s should be used. In the assumption that
 139             // both sal_Int64 members can be accessed as an array a shortcut is used here.
 140             // if(0 == nPos) return mnX; if(1 == nPos) return mnY; return mnZ;
 141             return *((&mnX) + nPos);
 142         }
 143
 144         // operators
 145
 146
 147         B3I64Tuple& operator+=( const B3I64Tuple& rTup )
 148         {
 149             mnX += rTup.mnX;
 150             mnY += rTup.mnY;
 151             mnZ += rTup.mnZ;
 152             return *this;
 153         }
 154
 155         B3I64Tuple& operator-=( const B3I64Tuple& rTup )
 156         {
 157             mnX -= rTup.mnX;
 158             mnY -= rTup.mnY;
 159             mnZ -= rTup.mnZ;
 160             return *this;
 161         }
 162
 163         B3I64Tuple& operator/=( const B3I64Tuple& rTup )
 164         {
 165             mnX /= rTup.mnX;
 166             mnY /= rTup.mnY;
 167             mnZ /= rTup.mnZ;
 168             return *this;
 169         }
 170
 171         B3I64Tuple& operator*=( const B3I64Tuple& rTup )
 172         {
 173             mnX *= rTup.mnX;
 174             mnY *= rTup.mnY;
 175             mnZ *= rTup.mnZ;
 176             return *this;
 177         }
 178
 179         B3I64Tuple& operator*=(sal_Int64 t)
 180         {
 181             mnX *= t;
 182             mnY *= t;
 183             mnZ *= t;
 184             return *this;
 185         }
 186
 187         B3I64Tuple& operator/=(sal_Int64 t)
 188         {
 189             mnX /= t;
 190             mnY /= t;
 191             mnZ /= t;
 192             return *this;
 193         }
 194
 195         B3I64Tuple operator-(void) const
 196         {
 197             return B3I64Tuple(-mnX, -mnY, -mnZ);
 198         }
 199
 200         bool operator==( const B3I64Tuple& rTup ) const
 201         {
 202             return this == &rTup || (rTup.mnX == mnX && rTup.mnY == mnY && rTup.mnZ == mnZ);
 203         }
 204
 205         bool operator!=( const B3I64Tuple& rTup ) const
 206         {
 207             return !(*this == rTup);
 208         }
 209
 210         B3I64Tuple& operator=( const B3I64Tuple& rTup )
 211         {
 212             mnX = rTup.mnX;
 213             mnY = rTup.mnY;
 214             mnZ = rTup.mnZ;
 215             return *this;
 216         }
 217     };
 218
 219     // external operators
 220
 221
 222     inline B3I64Tuple minimum(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 223     {
 224         return B3I64Tuple(
 225             std::min(rTupB.getX(), rTupA.getX()),
 226             std::min(rTupB.getY(), rTupA.getY()),
 227             std::min(rTupB.getZ(), rTupA.getZ()));
 228     }
 229
 230     inline B3I64Tuple maximum(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 231     {
 232         return B3I64Tuple(
 233             std::max(rTupB.getX(), rTupA.getX()),
 234             std::max(rTupB.getY(), rTupA.getY()),
 235             std::max(rTupB.getZ(), rTupA.getZ()));
 236     }
 237
 238     inline B3I64Tuple absolute(const B3I64Tuple& rTup)
 239     {
 240         B3I64Tuple aAbs(
 241             (0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
 242             (0 > rTup.getY()) ? -rTup.getY() : rTup.getY(),
 243             (0 > rTup.getZ()) ? -rTup.getZ() : rTup.getZ());
 244         return aAbs;
 245     }
 246
 247     inline B3I64Tuple interpolate(const B3I64Tuple& rOld1, const B3I64Tuple& rOld2, double t)
 248     {
 249         if(rOld1 == rOld2)
 250         {
 251             return rOld1;
 252         }
 253         else if(0.0 >= t)
 254         {
 255             return rOld1;
 256         }
 257         else if(1.0 <= t)
 258         {
 259             return rOld2;
 260         }
 261         else
 262         {
 263             return B3I64Tuple(
 264                 basegfx::fround64(((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX()),
 265                 basegfx::fround64(((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY()),
 266                 basegfx::fround64(((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ()));
 267         }
 268     }
 269
 270     inline B3I64Tuple average(const B3I64Tuple& rOld1, const B3I64Tuple& rOld2)
 271     {
 272         return B3I64Tuple(
 273             rOld1.getX() == rOld2.getX() ? rOld1.getX() : basegfx::fround64((rOld1.getX() + rOld2.getX()) * 0.5),
 274             rOld1.getY() == rOld2.getY() ? rOld1.getY() : basegfx::fround64((rOld1.getY() + rOld2.getY()) * 0.5),
 275             rOld1.getZ() == rOld2.getZ() ? rOld1.getZ() : basegfx::fround64((rOld1.getZ() + rOld2.getZ()) * 0.5));
 276     }
 277
 278     inline B3I64Tuple average(const B3I64Tuple& rOld1, const B3I64Tuple& rOld2, const B3I64Tuple& rOld3)
 279     {
 280         return B3I64Tuple(
 281             (rOld1.getX() == rOld2.getX() && rOld2.getX() == rOld3.getX()) ? rOld1.getX() : basegfx::fround64((rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0)),
 282             (rOld1.getY() == rOld2.getY() && rOld2.getY() == rOld3.getY()) ? rOld1.getY() : basegfx::fround64((rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0)),
 283             (rOld1.getZ() == rOld2.getZ() && rOld2.getZ() == rOld3.getZ()) ? rOld1.getZ() : basegfx::fround64((rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0)));
 284     }
 285
 286     inline B3I64Tuple operator+(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 287     {
 288         B3I64Tuple aSum(rTupA);
 289         aSum += rTupB;
 290         return aSum;
 291     }
 292
 293     inline B3I64Tuple operator-(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 294     {
 295         B3I64Tuple aSub(rTupA);
 296         aSub -= rTupB;
 297         return aSub;
 298     }
 299
 300     inline B3I64Tuple operator/(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 301     {
 302         B3I64Tuple aDiv(rTupA);
 303         aDiv /= rTupB;
 304         return aDiv;
 305     }
 306
 307     inline B3I64Tuple operator*(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 308     {
 309         B3I64Tuple aMul(rTupA);
 310         aMul *= rTupB;
 311         return aMul;
 312     }
 313
 314     inline B3I64Tuple operator*(const B3I64Tuple& rTup, sal_Int64 t)
 315     {
 316         B3I64Tuple aNew(rTup);
 317         aNew *= t;
 318         return aNew;
 319     }
 320
 321     inline B3I64Tuple operator*(sal_Int64 t, const B3I64Tuple& rTup)
 322     {
 323         B3I64Tuple aNew(rTup);
 324         aNew *= t;
 325         return aNew;
 326     }
 327
 328     inline B3I64Tuple operator/(const B3I64Tuple& rTup, sal_Int64 t)
 329     {
 330         B3I64Tuple aNew(rTup);
 331         aNew /= t;
 332         return aNew;
 333     }
 334
 335     inline B3I64Tuple operator/(sal_Int64 t, const B3I64Tuple& rTup)
 336     {
 337         B3I64Tuple aNew(t, t, t);
 338         B3I64Tuple aTmp(rTup);
 339         aNew /= aTmp;
 340         return aNew;
 341     }
 342 } // end of namespace basegfx
 343
 344 #endif // INCLUDED_BASEGFX_TUPLE_B3I64TUPLE_HXX
 345
 346 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */