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