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