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:
47 		B3DRange()
48 		{
49 		}
50 
51 		explicit B3DRange(const B3DTuple& rTuple)
52 		:	maRangeX(rTuple.getX()),
53 			maRangeY(rTuple.getY()),
54 			maRangeZ(rTuple.getZ())
55 		{
56 		}
57 
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 
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 
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 
91 		bool isEmpty() const
92 		{
93 			return (
94 				maRangeX.isEmpty()
95 				|| maRangeY.isEmpty()
96 				|| maRangeZ.isEmpty()
97 				);
98 		}
99 
100 		void reset()
101 		{
102 			maRangeX.reset();
103 			maRangeY.reset();
104 			maRangeZ.reset();
105 		}
106 
107 		bool operator==( const B3DRange& rRange ) const
108 		{
109 			return (maRangeX == rRange.maRangeX
110 				&& maRangeY == rRange.maRangeY
111 				&& maRangeZ == rRange.maRangeZ);
112 		}
113 
114 		bool operator!=( const B3DRange& rRange ) const
115 		{
116 			return (maRangeX != rRange.maRangeX
117 				|| maRangeY != rRange.maRangeY
118 				|| maRangeZ != rRange.maRangeZ);
119 		}
120 
121 		B3DRange& operator=(const B3DRange& rRange)
122 		{
123 			maRangeX = rRange.maRangeX;
124 			maRangeY = rRange.maRangeY;
125 			maRangeZ = rRange.maRangeZ;
126 			return *this;
127 		}
128 
129 		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 
136         double getMinX() const
137         {
138             return maRangeX.getMinimum();
139         }
140 
141         double getMinY() const
142         {
143             return maRangeY.getMinimum();
144         }
145 
146         double getMinZ() const
147         {
148             return maRangeZ.getMinimum();
149         }
150 
151         double getMaxX() const
152         {
153             return maRangeX.getMaximum();
154         }
155 
156         double getMaxY() const
157         {
158             return maRangeY.getMaximum();
159         }
160 
161         double getMaxZ() const
162         {
163             return maRangeZ.getMaximum();
164         }
165 
166         double getWidth() const
167         {
168             return maRangeX.getRange();
169         }
170 
171         double getHeight() const
172         {
173             return maRangeY.getRange();
174         }
175 
176         double getDepth() const
177         {
178             return maRangeZ.getRange();
179         }
180 
181 		B3DPoint getMinimum() const
182 		{
183 			return B3DPoint(
184 				maRangeX.getMinimum(),
185 				maRangeY.getMinimum(),
186 				maRangeZ.getMinimum()
187 				);
188 		}
189 
190 		B3DPoint getMaximum() const
191 		{
192 			return B3DPoint(
193 				maRangeX.getMaximum(),
194 				maRangeY.getMaximum(),
195 				maRangeZ.getMaximum()
196 				);
197 		}
198 
199 		B3DVector getRange() const
200 		{
201 			return B3DVector(
202 				maRangeX.getRange(),
203 				maRangeY.getRange(),
204 				maRangeZ.getRange()
205 				);
206 		}
207 
208 		B3DPoint getCenter() const
209 		{
210 			return B3DPoint(
211 				maRangeX.getCenter(),
212 				maRangeY.getCenter(),
213 				maRangeZ.getCenter()
214 				);
215 		}
216 
217 		double getCenterX() const
218 		{
219 			return maRangeX.getCenter();
220 		}
221 
222 		double getCenterY() const
223 		{
224 			return maRangeY.getCenter();
225 		}
226 
227 		double getCenterZ() const
228 		{
229 			return maRangeZ.getCenter();
230 		}
231 
232 		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 
241 		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 
250 		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 
259 		void expand(const B3DTuple& rTuple)
260 		{
261 			maRangeX.expand(rTuple.getX());
262 			maRangeY.expand(rTuple.getY());
263 			maRangeZ.expand(rTuple.getZ());
264 		}
265 
266 		void expand(const B3DRange& rRange)
267 		{
268 			maRangeX.expand(rRange.maRangeX);
269 			maRangeY.expand(rRange.maRangeY);
270 			maRangeZ.expand(rRange.maRangeZ);
271 		}
272 
273 		void intersect(const B3DRange& rRange)
274 		{
275 			maRangeX.intersect(rRange.maRangeX);
276 			maRangeY.intersect(rRange.maRangeY);
277 			maRangeZ.intersect(rRange.maRangeZ);
278 		}
279 
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