include/basegfx/range/b3drange.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 <basegfx/vector/b3dvector.hxx>
  23 #include <basegfx/point/b3dpoint.hxx>
  24 #include <basegfx/tuple/b3dtuple.hxx>
  25 #include <basegfx/range/basicrange.hxx>
  26 #include <basegfx/basegfxdllapi.h>
  27
  28 namespace basegfx
  29 {
  30     class B3DHomMatrix;
  31
  32     class SAL_WARN_UNUSED B3DRange
  33     {
  34         typedef ::basegfx::BasicRange< double, DoubleTraits >   MyBasicRange;
  35
  36         MyBasicRange            maRangeX;
  37         MyBasicRange            maRangeY;
  38         MyBasicRange            maRangeZ;
  39
  40     public:
  41         B3DRange() {}
  42
  43         explicit B3DRange(const B3DTuple& rTuple)
  44         :   maRangeX(rTuple.getX()),
  45             maRangeY(rTuple.getY()),
  46             maRangeZ(rTuple.getZ())
  47         {
  48         }
  49
  50         B3DRange(double x1,
  51                  double y1,
  52                  double z1,
  53                  double x2,
  54                  double y2,
  55                  double z2)
  56         :   maRangeX(x1),
  57             maRangeY(y1),
  58             maRangeZ(z1)
  59         {
  60             maRangeX.expand(x2);
  61             maRangeY.expand(y2);
  62             maRangeZ.expand(z2);
  63         }
  64
  65         B3DRange(const B3DTuple& rTuple1,
  66                  const B3DTuple& rTuple2)
  67         :   maRangeX(rTuple1.getX()),
  68             maRangeY(rTuple1.getY()),
  69             maRangeZ(rTuple1.getZ())
  70         {
  71             expand(rTuple2);
  72         }
  73
  74         bool isEmpty() const
  75         {
  76             return (
  77                 maRangeX.isEmpty()
  78                 || maRangeY.isEmpty()
  79                 || maRangeZ.isEmpty()
  80                 );
  81         }
  82
  83         void reset()
  84         {
  85             maRangeX.reset();
  86             maRangeY.reset();
  87             maRangeZ.reset();
  88         }
  89
  90         bool operator==( const B3DRange& rRange ) const
  91         {
  92             return (maRangeX == rRange.maRangeX
  93                 && maRangeY == rRange.maRangeY
  94                 && maRangeZ == rRange.maRangeZ);
  95         }
  96
  97         bool operator!=( const B3DRange& rRange ) const
  98         {
  99             return (maRangeX != rRange.maRangeX
 100                 || maRangeY != rRange.maRangeY
 101                 || maRangeZ != rRange.maRangeZ);
 102         }
 103
 104         double getMinX() const
 105         {
 106             return maRangeX.getMinimum();
 107         }
 108
 109         double getMinY() const
 110         {
 111             return maRangeY.getMinimum();
 112         }
 113
 114         double getMinZ() const
 115         {
 116             return maRangeZ.getMinimum();
 117         }
 118
 119         double getMaxX() const
 120         {
 121             return maRangeX.getMaximum();
 122         }
 123
 124         double getMaxY() const
 125         {
 126             return maRangeY.getMaximum();
 127         }
 128
 129         double getMaxZ() const
 130         {
 131             return maRangeZ.getMaximum();
 132         }
 133
 134         double getWidth() const
 135         {
 136             return maRangeX.getRange();
 137         }
 138
 139         double getHeight() const
 140         {
 141             return maRangeY.getRange();
 142         }
 143
 144         double getDepth() const
 145         {
 146             return maRangeZ.getRange();
 147         }
 148
 149         B3DVector getRange() const
 150         {
 151             return B3DVector(
 152                 maRangeX.getRange(),
 153                 maRangeY.getRange(),
 154                 maRangeZ.getRange()
 155                 );
 156         }
 157
 158         B3DPoint getCenter() const
 159         {
 160             return B3DPoint(
 161                 maRangeX.getCenter(),
 162                 maRangeY.getCenter(),
 163                 maRangeZ.getCenter()
 164                 );
 165         }
 166
 167         bool overlaps(const B3DRange& rRange) const
 168         {
 169             return (
 170                 maRangeX.overlaps(rRange.maRangeX)
 171                 && maRangeY.overlaps(rRange.maRangeY)
 172                 && maRangeZ.overlaps(rRange.maRangeZ)
 173                 );
 174         }
 175
 176         void expand(const B3DTuple& rTuple)
 177         {
 178             maRangeX.expand(rTuple.getX());
 179             maRangeY.expand(rTuple.getY());
 180             maRangeZ.expand(rTuple.getZ());
 181         }
 182
 183         void expand(const B3DRange& rRange)
 184         {
 185             maRangeX.expand(rRange.maRangeX);
 186             maRangeY.expand(rRange.maRangeY);
 187             maRangeZ.expand(rRange.maRangeZ);
 188         }
 189
 190         void grow(double fValue)
 191         {
 192             maRangeX.grow(fValue);
 193             maRangeY.grow(fValue);
 194             maRangeZ.grow(fValue);
 195         }
 196
 197         /// clamp value on range
 198         B3DTuple clamp(const B3DTuple& rTuple) const
 199         {
 200             return B3DTuple(
 201                 maRangeX.clamp(rTuple.getX()),
 202                 maRangeY.clamp(rTuple.getY()),
 203                 maRangeZ.clamp(rTuple.getZ()));
 204         }
 205
 206          BASEGFX_DLLPUBLIC void transform(const B3DHomMatrix& rMatrix);
 207
 208         /** Transform Range by given transformation matrix.
 209
 210             This operation transforms the Range by transforming all eight possible
 211             extrema points (corners) of the given range and building a new one.
 212             This means that the range will grow evtl. when a shear and/or rotation
 213             is part of the transformation.
 214         */
 215         B3DRange& operator*=( const ::basegfx::B3DHomMatrix& rMat );
 216
 217         /** Get a range filled with (0.0, 0.0, 0.0, 1.0, 1.0, 1.0) */
 218         static const B3DRange& getUnitB3DRange();
 219     };
 220
 221     /** Transform B3DRange by given transformation matrix (see operator*=())
 222     */
 223     B3DRange operator*( const B3DHomMatrix& rMat, const B3DRange& rB2DRange );
 224
 225 } // end of namespace basegfx
 226
 227 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */