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 _BGFX_TUPLE_B3I64TUPLE_HXX
  21 #define _BGFX_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         B3I64Tuple aMin(
 225             (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
 226             (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY(),
 227             (rTupB.getZ() < rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ());
 228         return aMin;
 229     }
 230
 231     inline B3I64Tuple maximum(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 232     {
 233         B3I64Tuple aMax(
 234             (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
 235             (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY(),
 236             (rTupB.getZ() > rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ());
 237         return aMax;
 238     }
 239
 240     inline B3I64Tuple absolute(const B3I64Tuple& rTup)
 241     {
 242         B3I64Tuple aAbs(
 243             (0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
 244             (0 > rTup.getY()) ? -rTup.getY() : rTup.getY(),
 245             (0 > rTup.getZ()) ? -rTup.getZ() : rTup.getZ());
 246         return aAbs;
 247     }
 248
 249     inline B3DTuple interpolate(const B3I64Tuple& rOld1, const B3I64Tuple& rOld2, double t)
 250     {
 251         B3DTuple aInt(
 252             ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
 253             ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
 254             ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
 255         return aInt;
 256     }
 257
 258     inline B3DTuple average(const B3I64Tuple& rOld1, const B3I64Tuple& rOld2)
 259     {
 260         B3DTuple aAvg(
 261             (rOld1.getX() + rOld2.getX()) * 0.5,
 262             (rOld1.getY() + rOld2.getY()) * 0.5,
 263             (rOld1.getZ() + rOld2.getZ()) * 0.5);
 264         return aAvg;
 265     }
 266
 267     inline B3DTuple average(const B3I64Tuple& rOld1, const B3I64Tuple& rOld2, const B3I64Tuple& rOld3)
 268     {
 269         B3DTuple aAvg(
 270             (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
 271             (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
 272             (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
 273         return aAvg;
 274     }
 275
 276     inline B3I64Tuple operator+(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 277     {
 278         B3I64Tuple aSum(rTupA);
 279         aSum += rTupB;
 280         return aSum;
 281     }
 282
 283     inline B3I64Tuple operator-(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 284     {
 285         B3I64Tuple aSub(rTupA);
 286         aSub -= rTupB;
 287         return aSub;
 288     }
 289
 290     inline B3I64Tuple operator/(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 291     {
 292         B3I64Tuple aDiv(rTupA);
 293         aDiv /= rTupB;
 294         return aDiv;
 295     }
 296
 297     inline B3I64Tuple operator*(const B3I64Tuple& rTupA, const B3I64Tuple& rTupB)
 298     {
 299         B3I64Tuple aMul(rTupA);
 300         aMul *= rTupB;
 301         return aMul;
 302     }
 303
 304     inline B3I64Tuple operator*(const B3I64Tuple& rTup, sal_Int64 t)
 305     {
 306         B3I64Tuple aNew(rTup);
 307         aNew *= t;
 308         return aNew;
 309     }
 310
 311     inline B3I64Tuple operator*(sal_Int64 t, const B3I64Tuple& rTup)
 312     {
 313         B3I64Tuple aNew(rTup);
 314         aNew *= t;
 315         return aNew;
 316     }
 317
 318     inline B3I64Tuple operator/(const B3I64Tuple& rTup, sal_Int64 t)
 319     {
 320         B3I64Tuple aNew(rTup);
 321         aNew /= t;
 322         return aNew;
 323     }
 324
 325     inline B3I64Tuple operator/(sal_Int64 t, const B3I64Tuple& rTup)
 326     {
 327         B3I64Tuple aNew(t, t, t);
 328         B3I64Tuple aTmp(rTup);
 329         aNew /= aTmp;
 330         return aNew;
 331     }
 332 } // end of namespace basegfx
 333
 334 #endif /* _BGFX_TUPLE_B3I64TUPLE_HXX */
 335
 336 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */