Line data Source code
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_B3DTUPLE_HXX
21 : #define INCLUDED_BASEGFX_TUPLE_B3DTUPLE_HXX
22 :
23 : #include <sal/types.h>
24 : #include <basegfx/numeric/ftools.hxx>
25 : #include <algorithm>
26 : #include <basegfx/basegfxdllapi.h>
27 :
28 : namespace basegfx
29 : {
30 : class B3ITuple;
31 :
32 : /** Base class for all Points/Vectors with three double values
33 :
34 : This class provides all methods common to Point
35 : avd Vector classes which are derived from here.
36 :
37 : @derive Use this class to implement Points or Vectors
38 : which are based on three double values
39 : */
40 : class BASEGFX_DLLPUBLIC SAL_WARN_UNUSED B3DTuple
41 : {
42 : protected:
43 : double mfX;
44 : double mfY;
45 : double mfZ;
46 :
47 : public:
48 : /** Create a 3D Tuple
49 :
50 : The tuple is initialized to (0.0, 0.0, 0.0)
51 : */
52 864299 : B3DTuple()
53 : : mfX(0.0),
54 : mfY(0.0),
55 864299 : mfZ(0.0)
56 864299 : {}
57 :
58 : /** Create a 3D Tuple
59 :
60 : @param fX
61 : This parameter is used to initialize the X-coordinate
62 : of the 3D Tuple.
63 :
64 : @param fY
65 : This parameter is used to initialize the Y-coordinate
66 : of the 3D Tuple.
67 :
68 : @param fZ
69 : This parameter is used to initialize the Z-coordinate
70 : of the 3D Tuple.
71 : */
72 2022330 : B3DTuple(double fX, double fY, double fZ)
73 : : mfX(fX),
74 : mfY(fY),
75 2022330 : mfZ(fZ)
76 2022330 : {}
77 :
78 : /** Create a copy of a 3D Tuple
79 :
80 : @param rTup
81 : The 3D Tuple which will be copied.
82 : */
83 6374047 : B3DTuple(const B3DTuple& rTup)
84 : : mfX( rTup.mfX ),
85 : mfY( rTup.mfY ),
86 6374047 : mfZ( rTup.mfZ )
87 6374047 : {}
88 :
89 9253830 : ~B3DTuple()
90 9253830 : {}
91 :
92 : /// get X-Coordinate of 3D Tuple
93 4426238 : double getX() const
94 : {
95 4426238 : return mfX;
96 : }
97 :
98 : /// get Y-Coordinate of 3D Tuple
99 3946518 : double getY() const
100 : {
101 3946518 : return mfY;
102 : }
103 :
104 : /// get Z-Coordinate of 3D Tuple
105 3910277 : double getZ() const
106 : {
107 3910277 : return mfZ;
108 : }
109 :
110 : /// set X-Coordinate of 3D Tuple
111 23080 : void setX(double fX)
112 : {
113 23080 : mfX = fX;
114 23080 : }
115 :
116 : /// set Y-Coordinate of 3D Tuple
117 26954 : void setY(double fY)
118 : {
119 26954 : mfY = fY;
120 26954 : }
121 :
122 : /// set Z-Coordinate of 3D Tuple
123 18121 : void setZ(double fZ)
124 : {
125 18121 : mfZ = fZ;
126 18121 : }
127 :
128 : /// Array-access to 3D Tuple
129 : const double& operator[] (int nPos) const
130 : {
131 : // Here, normally two if(...)'s should be used. In the assumption that
132 : // both double members can be accessed as an array a shortcut is used here.
133 : // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ;
134 : return *((&mfX) + nPos);
135 : }
136 :
137 : /// Array-access to 3D Tuple
138 5643 : double& operator[] (int nPos)
139 : {
140 : // Here, normally two if(...)'s should be used. In the assumption that
141 : // both double members can be accessed as an array a shortcut is used here.
142 : // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ;
143 5643 : return *((&mfX) + nPos);
144 : }
145 :
146 : // comparators with tolerance
147 :
148 :
149 504284 : bool equalZero() const
150 : {
151 1154081 : return (this == &getEmptyTuple() ||
152 503884 : (::basegfx::fTools::equalZero(mfX)
153 284967 : && ::basegfx::fTools::equalZero(mfY)
154 656655 : && ::basegfx::fTools::equalZero(mfZ)));
155 : }
156 :
157 98531 : bool equal(const B3DTuple& rTup) const
158 : {
159 : return (
160 202997 : this == &rTup ||
161 111680 : (::basegfx::fTools::equal(mfX, rTup.mfX) &&
162 19564 : ::basegfx::fTools::equal(mfY, rTup.mfY) &&
163 104946 : ::basegfx::fTools::equal(mfZ, rTup.mfZ)));
164 : }
165 :
166 : // operators
167 :
168 :
169 114024 : B3DTuple& operator+=( const B3DTuple& rTup )
170 : {
171 114024 : mfX += rTup.mfX;
172 114024 : mfY += rTup.mfY;
173 114024 : mfZ += rTup.mfZ;
174 114024 : return *this;
175 : }
176 :
177 299789 : B3DTuple& operator-=( const B3DTuple& rTup )
178 : {
179 299789 : mfX -= rTup.mfX;
180 299789 : mfY -= rTup.mfY;
181 299789 : mfZ -= rTup.mfZ;
182 299789 : return *this;
183 : }
184 :
185 : B3DTuple& operator/=( const B3DTuple& rTup )
186 : {
187 : mfX /= rTup.mfX;
188 : mfY /= rTup.mfY;
189 : mfZ /= rTup.mfZ;
190 : return *this;
191 : }
192 :
193 34907 : B3DTuple& operator*=( const B3DTuple& rTup )
194 : {
195 34907 : mfX *= rTup.mfX;
196 34907 : mfY *= rTup.mfY;
197 34907 : mfZ *= rTup.mfZ;
198 34907 : return *this;
199 : }
200 :
201 80112 : B3DTuple& operator*=(double t)
202 : {
203 80112 : mfX *= t;
204 80112 : mfY *= t;
205 80112 : mfZ *= t;
206 80112 : return *this;
207 : }
208 :
209 0 : B3DTuple& operator/=(double t)
210 : {
211 0 : const double fVal(1.0 / t);
212 0 : mfX *= fVal;
213 0 : mfY *= fVal;
214 0 : mfZ *= fVal;
215 0 : return *this;
216 : }
217 :
218 4450 : B3DTuple operator-(void) const
219 : {
220 4450 : return B3DTuple(-mfX, -mfY, -mfZ);
221 : }
222 :
223 927831 : bool operator==( const B3DTuple& rTup ) const
224 : {
225 927831 : return mfX == rTup.mfX && mfY == rTup.mfY && mfZ == rTup.mfZ;
226 : }
227 :
228 250397 : bool operator!=( const B3DTuple& rTup ) const
229 : {
230 250397 : return mfX != rTup.mfX || mfY != rTup.mfY || mfZ != rTup.mfZ;
231 : }
232 :
233 3862191 : B3DTuple& operator=( const B3DTuple& rTup )
234 : {
235 3862191 : mfX = rTup.mfX;
236 3862191 : mfY = rTup.mfY;
237 3862191 : mfZ = rTup.mfZ;
238 3862191 : return *this;
239 : }
240 :
241 11660 : void correctValues(const double fCompareValue = 0.0)
242 : {
243 11660 : if(0.0 == fCompareValue)
244 : {
245 8745 : if(::basegfx::fTools::equalZero(mfX))
246 : {
247 4919 : mfX = 0.0;
248 : }
249 :
250 8745 : if(::basegfx::fTools::equalZero(mfY))
251 : {
252 6057 : mfY = 0.0;
253 : }
254 :
255 8745 : if(::basegfx::fTools::equalZero(mfZ))
256 : {
257 6481 : mfZ = 0.0;
258 : }
259 : }
260 : else
261 : {
262 2915 : if(::basegfx::fTools::equal(mfX, fCompareValue))
263 : {
264 1841 : mfX = fCompareValue;
265 : }
266 :
267 2915 : if(::basegfx::fTools::equal(mfY, fCompareValue))
268 : {
269 1841 : mfY = fCompareValue;
270 : }
271 :
272 2915 : if(::basegfx::fTools::equal(mfZ, fCompareValue))
273 : {
274 1841 : mfZ = fCompareValue;
275 : }
276 : }
277 11660 : }
278 :
279 : static const B3DTuple& getEmptyTuple();
280 : };
281 :
282 : // external operators
283 :
284 :
285 : inline B3DTuple minimum(const B3DTuple& rTupA, const B3DTuple& rTupB)
286 : {
287 : return B3DTuple(
288 : std::min(rTupB.getX(), rTupA.getX()),
289 : std::min(rTupB.getY(), rTupA.getY()),
290 : std::min(rTupB.getZ(), rTupA.getZ()));
291 : }
292 :
293 : inline B3DTuple maximum(const B3DTuple& rTupA, const B3DTuple& rTupB)
294 : {
295 : return B3DTuple(
296 : std::max(rTupB.getX(), rTupA.getX()),
297 : std::max(rTupB.getY(), rTupA.getY()),
298 : std::max(rTupB.getZ(), rTupA.getZ()));
299 : }
300 :
301 : inline B3DTuple absolute(const B3DTuple& rTup)
302 : {
303 : B3DTuple aAbs(
304 : fabs(rTup.getX()),
305 : fabs(rTup.getY()),
306 : fabs(rTup.getZ()));
307 : return aAbs;
308 : }
309 :
310 630536 : inline B3DTuple interpolate(const B3DTuple& rOld1, const B3DTuple& rOld2, double t)
311 : {
312 630536 : if(rOld1 == rOld2)
313 : {
314 4401 : return rOld1;
315 : }
316 626135 : else if(0.0 >= t)
317 : {
318 14027 : return rOld1;
319 : }
320 612108 : else if(1.0 <= t)
321 : {
322 2511 : return rOld2;
323 : }
324 : else
325 : {
326 : return B3DTuple(
327 609597 : ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
328 609597 : ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
329 1828791 : ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
330 : }
331 : }
332 :
333 124 : inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2)
334 : {
335 : return B3DTuple(
336 195 : rOld1.getX() == rOld2.getX() ? rOld1.getX() : (rOld1.getX() + rOld2.getX()) * 0.5,
337 197 : rOld1.getY() == rOld2.getY() ? rOld1.getY() : (rOld1.getY() + rOld2.getY()) * 0.5,
338 516 : rOld1.getZ() == rOld2.getZ() ? rOld1.getZ() : (rOld1.getZ() + rOld2.getZ()) * 0.5);
339 : }
340 :
341 : inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2, const B3DTuple& rOld3)
342 : {
343 : return B3DTuple(
344 : (rOld1.getX() == rOld2.getX() && rOld2.getX() == rOld3.getX()) ? rOld1.getX() : (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
345 : (rOld1.getY() == rOld2.getY() && rOld2.getY() == rOld3.getY()) ? rOld1.getY() : (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
346 : (rOld1.getZ() == rOld2.getZ() && rOld2.getZ() == rOld3.getZ()) ? rOld1.getZ() : (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
347 : }
348 :
349 79105 : inline B3DTuple operator+(const B3DTuple& rTupA, const B3DTuple& rTupB)
350 : {
351 79105 : B3DTuple aSum(rTupA);
352 79105 : aSum += rTupB;
353 79105 : return aSum;
354 : }
355 :
356 299777 : inline B3DTuple operator-(const B3DTuple& rTupA, const B3DTuple& rTupB)
357 : {
358 299777 : B3DTuple aSub(rTupA);
359 299777 : aSub -= rTupB;
360 299777 : return aSub;
361 : }
362 :
363 : inline B3DTuple operator/(const B3DTuple& rTupA, const B3DTuple& rTupB)
364 : {
365 : B3DTuple aDiv(rTupA);
366 : aDiv /= rTupB;
367 : return aDiv;
368 : }
369 :
370 34907 : inline B3DTuple operator*(const B3DTuple& rTupA, const B3DTuple& rTupB)
371 : {
372 34907 : B3DTuple aMul(rTupA);
373 34907 : aMul *= rTupB;
374 34907 : return aMul;
375 : }
376 :
377 80112 : inline B3DTuple operator*(const B3DTuple& rTup, double t)
378 : {
379 80112 : B3DTuple aNew(rTup);
380 80112 : aNew *= t;
381 80112 : return aNew;
382 : }
383 :
384 : inline B3DTuple operator*(double t, const B3DTuple& rTup)
385 : {
386 : B3DTuple aNew(rTup);
387 : aNew *= t;
388 : return aNew;
389 : }
390 :
391 0 : inline B3DTuple operator/(const B3DTuple& rTup, double t)
392 : {
393 0 : B3DTuple aNew(rTup);
394 0 : aNew /= t;
395 0 : return aNew;
396 : }
397 :
398 : inline B3DTuple operator/(double t, const B3DTuple& rTup)
399 : {
400 : B3DTuple aNew(rTup);
401 : aNew /= t;
402 : return aNew;
403 : }
404 :
405 : /** Round double to nearest integer for 3D tuple
406 :
407 : @return the nearest integer for this tuple
408 : */
409 : BASEGFX_DLLPUBLIC B3ITuple fround(const B3DTuple& rTup);
410 : } // end of namespace basegfx
411 :
412 : #endif // INCLUDED_BASEGFX_TUPLE_B3DTUPLE_HXX
413 :
414 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
