xref: /AOO41X/main/basegfx/inc/basegfx/range/b3drange.hxx (revision ce9c7ef7bd056b6da7d6eeebb749fbf2160d647b) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #ifndef _BGFX_RANGE_B3DRANGE_HXX
25 #define _BGFX_RANGE_B3DRANGE_HXX
26 
27 #include <basegfx/vector/b3dvector.hxx>
28 #include <basegfx/point/b3dpoint.hxx>
29 #include <basegfx/tuple/b3dtuple.hxx>
30 #include <basegfx/range/basicrange.hxx>
31 
32 namespace basegfx
33 {
34     // predeclarations
35     class B3IRange;
36     class B3DHomMatrix;
37 
38     class B3DRange
39     {
40         typedef ::basegfx::BasicRange< double, DoubleTraits >   MyBasicRange;
41 
42         MyBasicRange            maRangeX;
43         MyBasicRange            maRangeY;
44         MyBasicRange            maRangeZ;
45 
46     public:
B3DRange()47         B3DRange()
48         {
49         }
50 
B3DRange(const B3DTuple & rTuple)51         explicit B3DRange(const B3DTuple& rTuple)
52         :   maRangeX(rTuple.getX()),
53             maRangeY(rTuple.getY()),
54             maRangeZ(rTuple.getZ())
55         {
56         }
57 
B3DRange(double x1,double y1,double z1,double x2,double y2,double z2)58         B3DRange(double x1,
59                  double y1,
60                  double z1,
61                  double x2,
62                  double y2,
63                  double z2)
64         :   maRangeX(x1),
65             maRangeY(y1),
66             maRangeZ(z1)
67         {
68             maRangeX.expand(x2);
69             maRangeY.expand(y2);
70             maRangeZ.expand(z2);
71         }
72 
B3DRange(const B3DTuple & rTuple1,const B3DTuple & rTuple2)73         B3DRange(const B3DTuple& rTuple1,
74                  const B3DTuple& rTuple2)
75         :   maRangeX(rTuple1.getX()),
76             maRangeY(rTuple1.getY()),
77             maRangeZ(rTuple1.getZ())
78         {
79             expand(rTuple2);
80         }
81 
B3DRange(const B3DRange & rRange)82         B3DRange(const B3DRange& rRange)
83         :   maRangeX(rRange.maRangeX),
84             maRangeY(rRange.maRangeY),
85             maRangeZ(rRange.maRangeZ)
86         {
87         }
88 
89         explicit B3DRange(const B3IRange& rRange);
90 
isEmpty() const91         bool isEmpty() const
92         {
93             return (
94                 maRangeX.isEmpty()
95                 || maRangeY.isEmpty()
96                 || maRangeZ.isEmpty()
97                 );
98         }
99 
reset()100         void reset()
101         {
102             maRangeX.reset();
103             maRangeY.reset();
104             maRangeZ.reset();
105         }
106 
operator ==(const B3DRange & rRange) const107         bool operator==( const B3DRange& rRange ) const
108         {
109             return (maRangeX == rRange.maRangeX
110                 && maRangeY == rRange.maRangeY
111                 && maRangeZ == rRange.maRangeZ);
112         }
113 
operator !=(const B3DRange & rRange) const114         bool operator!=( const B3DRange& rRange ) const
115         {
116             return (maRangeX != rRange.maRangeX
117                 || maRangeY != rRange.maRangeY
118                 || maRangeZ != rRange.maRangeZ);
119         }
120 
operator =(const B3DRange & rRange)121         B3DRange& operator=(const B3DRange& rRange)
122         {
123             maRangeX = rRange.maRangeX;
124             maRangeY = rRange.maRangeY;
125             maRangeZ = rRange.maRangeZ;
126             return *this;
127         }
128 
equal(const B3DRange & rRange) const129         bool equal(const B3DRange& rRange) const
130         {
131             return (maRangeX.equal(rRange.maRangeX)
132                     && maRangeY.equal(rRange.maRangeY)
133                     && maRangeZ.equal(rRange.maRangeZ));
134         }
135 
getMinX() const136         double getMinX() const
137         {
138             return maRangeX.getMinimum();
139         }
140 
getMinY() const141         double getMinY() const
142         {
143             return maRangeY.getMinimum();
144         }
145 
getMinZ() const146         double getMinZ() const
147         {
148             return maRangeZ.getMinimum();
149         }
150 
getMaxX() const151         double getMaxX() const
152         {
153             return maRangeX.getMaximum();
154         }
155 
getMaxY() const156         double getMaxY() const
157         {
158             return maRangeY.getMaximum();
159         }
160 
getMaxZ() const161         double getMaxZ() const
162         {
163             return maRangeZ.getMaximum();
164         }
165 
getWidth() const166         double getWidth() const
167         {
168             return maRangeX.getRange();
169         }
170 
getHeight() const171         double getHeight() const
172         {
173             return maRangeY.getRange();
174         }
175 
getDepth() const176         double getDepth() const
177         {
178             return maRangeZ.getRange();
179         }
180 
getMinimum() const181         B3DPoint getMinimum() const
182         {
183             return B3DPoint(
184                 maRangeX.getMinimum(),
185                 maRangeY.getMinimum(),
186                 maRangeZ.getMinimum()
187                 );
188         }
189 
getMaximum() const190         B3DPoint getMaximum() const
191         {
192             return B3DPoint(
193                 maRangeX.getMaximum(),
194                 maRangeY.getMaximum(),
195                 maRangeZ.getMaximum()
196                 );
197         }
198 
getRange() const199         B3DVector getRange() const
200         {
201             return B3DVector(
202                 maRangeX.getRange(),
203                 maRangeY.getRange(),
204                 maRangeZ.getRange()
205                 );
206         }
207 
getCenter() const208         B3DPoint getCenter() const
209         {
210             return B3DPoint(
211                 maRangeX.getCenter(),
212                 maRangeY.getCenter(),
213                 maRangeZ.getCenter()
214                 );
215         }
216 
getCenterX() const217         double getCenterX() const
218         {
219             return maRangeX.getCenter();
220         }
221 
getCenterY() const222         double getCenterY() const
223         {
224             return maRangeY.getCenter();
225         }
226 
getCenterZ() const227         double getCenterZ() const
228         {
229             return maRangeZ.getCenter();
230         }
231 
isInside(const B3DTuple & rTuple) const232         bool isInside(const B3DTuple& rTuple) const
233         {
234             return (
235                 maRangeX.isInside(rTuple.getX())
236                 && maRangeY.isInside(rTuple.getY())
237                 && maRangeZ.isInside(rTuple.getZ())
238                 );
239         }
240 
isInside(const B3DRange & rRange) const241         bool isInside(const B3DRange& rRange) const
242         {
243             return (
244                 maRangeX.isInside(rRange.maRangeX)
245                 && maRangeY.isInside(rRange.maRangeY)
246                 && maRangeZ.isInside(rRange.maRangeZ)
247                 );
248         }
249 
overlaps(const B3DRange & rRange) const250         bool overlaps(const B3DRange& rRange) const
251         {
252             return (
253                 maRangeX.overlaps(rRange.maRangeX)
254                 && maRangeY.overlaps(rRange.maRangeY)
255                 && maRangeZ.overlaps(rRange.maRangeZ)
256                 );
257         }
258 
expand(const B3DTuple & rTuple)259         void expand(const B3DTuple& rTuple)
260         {
261             maRangeX.expand(rTuple.getX());
262             maRangeY.expand(rTuple.getY());
263             maRangeZ.expand(rTuple.getZ());
264         }
265 
expand(const B3DRange & rRange)266         void expand(const B3DRange& rRange)
267         {
268             maRangeX.expand(rRange.maRangeX);
269             maRangeY.expand(rRange.maRangeY);
270             maRangeZ.expand(rRange.maRangeZ);
271         }
272 
intersect(const B3DRange & rRange)273         void intersect(const B3DRange& rRange)
274         {
275             maRangeX.intersect(rRange.maRangeX);
276             maRangeY.intersect(rRange.maRangeY);
277             maRangeZ.intersect(rRange.maRangeZ);
278         }
279 
grow(double fValue)280         void grow(double fValue)
281         {
282             maRangeX.grow(fValue);
283             maRangeY.grow(fValue);
284             maRangeZ.grow(fValue);
285         }
286 
287         void transform(const B3DHomMatrix& rMatrix);
288     };
289 
290     /** Round double to nearest integer for 3D range
291 
292         @return the nearest integer for this range
293     */
294     B3IRange fround(const B3DRange& rRange);
295 } // end of namespace basegfx
296 
297 
298 #endif /* _BGFX_RANGE_B3DRANGE_HXX */
299