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 : #include <rtl/instance.hxx>
21 : #include <basegfx/matrix/b3dhommatrix.hxx>
22 : #include <hommatrixtemplate.hxx>
23 : #include <basegfx/vector/b3dvector.hxx>
24 :
25 : namespace basegfx
26 : {
27 950274 : class Impl3DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 4 >
28 : {
29 : };
30 :
31 : namespace { struct IdentityMatrix : public rtl::Static< B3DHomMatrix::ImplType,
32 : IdentityMatrix > {}; }
33 :
34 231225 : B3DHomMatrix::B3DHomMatrix() :
35 231225 : mpImpl( IdentityMatrix::get() ) // use common identity matrix
36 : {
37 231225 : }
38 :
39 469562 : B3DHomMatrix::B3DHomMatrix(const B3DHomMatrix& rMat) :
40 469562 : mpImpl(rMat.mpImpl)
41 : {
42 469562 : }
43 :
44 700691 : B3DHomMatrix::~B3DHomMatrix()
45 : {
46 700691 : }
47 :
48 115040 : B3DHomMatrix& B3DHomMatrix::operator=(const B3DHomMatrix& rMat)
49 : {
50 115040 : mpImpl = rMat.mpImpl;
51 115040 : return *this;
52 : }
53 :
54 5824579 : double B3DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
55 : {
56 5824579 : return mpImpl->get(nRow, nColumn);
57 : }
58 :
59 632671 : void B3DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
60 : {
61 632671 : mpImpl->set(nRow, nColumn, fValue);
62 632671 : }
63 :
64 420167 : bool B3DHomMatrix::isLastLineDefault() const
65 : {
66 420167 : return mpImpl->isLastLineDefault();
67 : }
68 :
69 553368 : bool B3DHomMatrix::isIdentity() const
70 : {
71 553368 : if(mpImpl.same_object(IdentityMatrix::get()))
72 74801 : return true;
73 :
74 478567 : return mpImpl->isIdentity();
75 : }
76 :
77 8606 : void B3DHomMatrix::identity()
78 : {
79 8606 : mpImpl = IdentityMatrix::get();
80 8606 : }
81 :
82 19404 : bool B3DHomMatrix::invert()
83 : {
84 19404 : Impl3DHomMatrix aWork(*mpImpl);
85 19404 : sal_uInt16* pIndex = new sal_uInt16[mpImpl->getEdgeLength()];
86 : sal_Int16 nParity;
87 :
88 19404 : if(aWork.ludcmp(pIndex, nParity))
89 : {
90 19404 : mpImpl->doInvert(aWork, pIndex);
91 19404 : delete[] pIndex;
92 :
93 19404 : return true;
94 : }
95 :
96 0 : delete[] pIndex;
97 0 : return false;
98 : }
99 :
100 2671 : double B3DHomMatrix::determinant() const
101 : {
102 2671 : return mpImpl->doDeterminant();
103 : }
104 :
105 0 : B3DHomMatrix& B3DHomMatrix::operator+=(const B3DHomMatrix& rMat)
106 : {
107 0 : mpImpl->doAddMatrix(*rMat.mpImpl);
108 0 : return *this;
109 : }
110 :
111 0 : B3DHomMatrix& B3DHomMatrix::operator-=(const B3DHomMatrix& rMat)
112 : {
113 0 : mpImpl->doSubMatrix(*rMat.mpImpl);
114 0 : return *this;
115 : }
116 :
117 0 : B3DHomMatrix& B3DHomMatrix::operator*=(double fValue)
118 : {
119 0 : const double fOne(1.0);
120 :
121 0 : if(!fTools::equal(fOne, fValue))
122 0 : mpImpl->doMulMatrix(fValue);
123 :
124 0 : return *this;
125 : }
126 :
127 0 : B3DHomMatrix& B3DHomMatrix::operator/=(double fValue)
128 : {
129 0 : const double fOne(1.0);
130 :
131 0 : if(!fTools::equal(fOne, fValue))
132 0 : mpImpl->doMulMatrix(1.0 / fValue);
133 :
134 0 : return *this;
135 : }
136 :
137 226534 : B3DHomMatrix& B3DHomMatrix::operator*=(const B3DHomMatrix& rMat)
138 : {
139 226534 : if(!rMat.isIdentity())
140 194500 : mpImpl->doMulMatrix(*rMat.mpImpl);
141 :
142 226534 : return *this;
143 : }
144 :
145 16070 : bool B3DHomMatrix::operator==(const B3DHomMatrix& rMat) const
146 : {
147 16070 : if(mpImpl.same_object(rMat.mpImpl))
148 6894 : return true;
149 :
150 9176 : return mpImpl->isEqual(*rMat.mpImpl);
151 : }
152 :
153 9101 : bool B3DHomMatrix::operator!=(const B3DHomMatrix& rMat) const
154 : {
155 9101 : return !(*this == rMat);
156 : }
157 :
158 49628 : void B3DHomMatrix::rotate(double fAngleX,double fAngleY,double fAngleZ)
159 : {
160 49628 : if(!fTools::equalZero(fAngleX) || !fTools::equalZero(fAngleY) || !fTools::equalZero(fAngleZ))
161 : {
162 34880 : if(!fTools::equalZero(fAngleX))
163 : {
164 10926 : Impl3DHomMatrix aRotMatX;
165 10926 : double fSin(sin(fAngleX));
166 10926 : double fCos(cos(fAngleX));
167 :
168 10926 : aRotMatX.set(1, 1, fCos);
169 10926 : aRotMatX.set(2, 2, fCos);
170 10926 : aRotMatX.set(2, 1, fSin);
171 10926 : aRotMatX.set(1, 2, -fSin);
172 :
173 10926 : mpImpl->doMulMatrix(aRotMatX);
174 : }
175 :
176 34880 : if(!fTools::equalZero(fAngleY))
177 : {
178 24638 : Impl3DHomMatrix aRotMatY;
179 24638 : double fSin(sin(fAngleY));
180 24638 : double fCos(cos(fAngleY));
181 :
182 24638 : aRotMatY.set(0, 0, fCos);
183 24638 : aRotMatY.set(2, 2, fCos);
184 24638 : aRotMatY.set(0, 2, fSin);
185 24638 : aRotMatY.set(2, 0, -fSin);
186 :
187 24638 : mpImpl->doMulMatrix(aRotMatY);
188 : }
189 :
190 34880 : if(!fTools::equalZero(fAngleZ))
191 : {
192 1566 : Impl3DHomMatrix aRotMatZ;
193 1566 : double fSin(sin(fAngleZ));
194 1566 : double fCos(cos(fAngleZ));
195 :
196 1566 : aRotMatZ.set(0, 0, fCos);
197 1566 : aRotMatZ.set(1, 1, fCos);
198 1566 : aRotMatZ.set(1, 0, fSin);
199 1566 : aRotMatZ.set(0, 1, -fSin);
200 :
201 1566 : mpImpl->doMulMatrix(aRotMatZ);
202 : }
203 : }
204 49628 : }
205 :
206 72537 : void B3DHomMatrix::translate(double fX, double fY, double fZ)
207 : {
208 72537 : if(!fTools::equalZero(fX) || !fTools::equalZero(fY) || !fTools::equalZero(fZ))
209 : {
210 62761 : Impl3DHomMatrix aTransMat;
211 :
212 62761 : aTransMat.set(0, 3, fX);
213 62761 : aTransMat.set(1, 3, fY);
214 62761 : aTransMat.set(2, 3, fZ);
215 :
216 62761 : mpImpl->doMulMatrix(aTransMat);
217 : }
218 72537 : }
219 :
220 38753 : void B3DHomMatrix::scale(double fX, double fY, double fZ)
221 : {
222 38753 : const double fOne(1.0);
223 :
224 38753 : if(!fTools::equal(fOne, fX) || !fTools::equal(fOne, fY) ||!fTools::equal(fOne, fZ))
225 : {
226 38753 : Impl3DHomMatrix aScaleMat;
227 :
228 38753 : aScaleMat.set(0, 0, fX);
229 38753 : aScaleMat.set(1, 1, fY);
230 38753 : aScaleMat.set(2, 2, fZ);
231 :
232 38753 : mpImpl->doMulMatrix(aScaleMat);
233 : }
234 38753 : }
235 :
236 16 : void B3DHomMatrix::shearXY(double fSx, double fSy)
237 : {
238 : // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
239 16 : if(!fTools::equalZero(fSx) || !fTools::equalZero(fSy))
240 : {
241 16 : Impl3DHomMatrix aShearXYMat;
242 :
243 16 : aShearXYMat.set(0, 2, fSx);
244 16 : aShearXYMat.set(1, 2, fSy);
245 :
246 16 : mpImpl->doMulMatrix(aShearXYMat);
247 : }
248 16 : }
249 :
250 0 : void B3DHomMatrix::shearXZ(double fSx, double fSz)
251 : {
252 : // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
253 0 : if(!fTools::equalZero(fSx) || !fTools::equalZero(fSz))
254 : {
255 0 : Impl3DHomMatrix aShearXZMat;
256 :
257 0 : aShearXZMat.set(0, 1, fSx);
258 0 : aShearXZMat.set(2, 1, fSz);
259 :
260 0 : mpImpl->doMulMatrix(aShearXZMat);
261 : }
262 0 : }
263 448 : void B3DHomMatrix::frustum(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
264 : {
265 448 : const double fZero(0.0);
266 448 : const double fOne(1.0);
267 :
268 448 : if(!fTools::more(fNear, fZero))
269 : {
270 0 : fNear = 0.001;
271 : }
272 :
273 448 : if(!fTools::more(fFar, fZero))
274 : {
275 0 : fFar = fOne;
276 : }
277 :
278 448 : if(fTools::equal(fNear, fFar))
279 : {
280 0 : fFar = fNear + fOne;
281 : }
282 :
283 448 : if(fTools::equal(fLeft, fRight))
284 : {
285 0 : fLeft -= fOne;
286 0 : fRight += fOne;
287 : }
288 :
289 448 : if(fTools::equal(fTop, fBottom))
290 : {
291 0 : fBottom -= fOne;
292 0 : fTop += fOne;
293 : }
294 :
295 448 : Impl3DHomMatrix aFrustumMat;
296 :
297 448 : aFrustumMat.set(0, 0, 2.0 * fNear / (fRight - fLeft));
298 448 : aFrustumMat.set(1, 1, 2.0 * fNear / (fTop - fBottom));
299 448 : aFrustumMat.set(0, 2, (fRight + fLeft) / (fRight - fLeft));
300 448 : aFrustumMat.set(1, 2, (fTop + fBottom) / (fTop - fBottom));
301 448 : aFrustumMat.set(2, 2, -fOne * ((fFar + fNear) / (fFar - fNear)));
302 448 : aFrustumMat.set(3, 2, -fOne);
303 448 : aFrustumMat.set(2, 3, -fOne * ((2.0 * fFar * fNear) / (fFar - fNear)));
304 448 : aFrustumMat.set(3, 3, fZero);
305 :
306 448 : mpImpl->doMulMatrix(aFrustumMat);
307 448 : }
308 :
309 352 : void B3DHomMatrix::ortho(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
310 : {
311 352 : if(fTools::equal(fNear, fFar))
312 : {
313 0 : fFar = fNear + 1.0;
314 : }
315 :
316 352 : if(fTools::equal(fLeft, fRight))
317 : {
318 0 : fLeft -= 1.0;
319 0 : fRight += 1.0;
320 : }
321 :
322 352 : if(fTools::equal(fTop, fBottom))
323 : {
324 0 : fBottom -= 1.0;
325 0 : fTop += 1.0;
326 : }
327 :
328 352 : Impl3DHomMatrix aOrthoMat;
329 :
330 352 : aOrthoMat.set(0, 0, 2.0 / (fRight - fLeft));
331 352 : aOrthoMat.set(1, 1, 2.0 / (fTop - fBottom));
332 352 : aOrthoMat.set(2, 2, -1.0 * (2.0 / (fFar - fNear)));
333 352 : aOrthoMat.set(0, 3, -1.0 * ((fRight + fLeft) / (fRight - fLeft)));
334 352 : aOrthoMat.set(1, 3, -1.0 * ((fTop + fBottom) / (fTop - fBottom)));
335 352 : aOrthoMat.set(2, 3, -1.0 * ((fFar + fNear) / (fFar - fNear)));
336 :
337 352 : mpImpl->doMulMatrix(aOrthoMat);
338 352 : }
339 :
340 400 : void B3DHomMatrix::orientation(B3DPoint aVRP, B3DVector aVPN, B3DVector aVUV)
341 : {
342 400 : Impl3DHomMatrix aOrientationMat;
343 :
344 : // translate -VRP
345 400 : aOrientationMat.set(0, 3, -aVRP.getX());
346 400 : aOrientationMat.set(1, 3, -aVRP.getY());
347 400 : aOrientationMat.set(2, 3, -aVRP.getZ());
348 :
349 : // build rotation
350 400 : aVUV.normalize();
351 400 : aVPN.normalize();
352 :
353 : // build x-axis as peroendicular fron aVUV and aVPN
354 800 : B3DVector aRx(aVUV.getPerpendicular(aVPN));
355 400 : aRx.normalize();
356 :
357 : // y-axis perpendicular to that
358 800 : B3DVector aRy(aVPN.getPerpendicular(aRx));
359 400 : aRy.normalize();
360 :
361 : // the calculated normals are the line vectors of the rotation matrix,
362 : // set them to create rotation
363 400 : aOrientationMat.set(0, 0, aRx.getX());
364 400 : aOrientationMat.set(0, 1, aRx.getY());
365 400 : aOrientationMat.set(0, 2, aRx.getZ());
366 400 : aOrientationMat.set(1, 0, aRy.getX());
367 400 : aOrientationMat.set(1, 1, aRy.getY());
368 400 : aOrientationMat.set(1, 2, aRy.getZ());
369 400 : aOrientationMat.set(2, 0, aVPN.getX());
370 400 : aOrientationMat.set(2, 1, aVPN.getY());
371 400 : aOrientationMat.set(2, 2, aVPN.getZ());
372 :
373 800 : mpImpl->doMulMatrix(aOrientationMat);
374 400 : }
375 :
376 2671 : bool B3DHomMatrix::decompose(B3DTuple& rScale, B3DTuple& rTranslate, B3DTuple& rRotate, B3DTuple& rShear) const
377 : {
378 : // when perspective is used, decompose is not made here
379 2671 : if(!mpImpl->isLastLineDefault())
380 0 : return false;
381 :
382 : // If determinant is zero, decomposition is not possible
383 2671 : if(0.0 == determinant())
384 0 : return false;
385 :
386 : // isolate translation
387 2671 : rTranslate.setX(mpImpl->get(0, 3));
388 2671 : rTranslate.setY(mpImpl->get(1, 3));
389 2671 : rTranslate.setZ(mpImpl->get(2, 3));
390 :
391 : // correct translate values
392 2671 : rTranslate.correctValues();
393 :
394 : // get scale and shear
395 2671 : B3DVector aCol0(mpImpl->get(0, 0), mpImpl->get(1, 0), mpImpl->get(2, 0));
396 5342 : B3DVector aCol1(mpImpl->get(0, 1), mpImpl->get(1, 1), mpImpl->get(2, 1));
397 5342 : B3DVector aCol2(mpImpl->get(0, 2), mpImpl->get(1, 2), mpImpl->get(2, 2));
398 5342 : B3DVector aTemp;
399 :
400 : // get ScaleX
401 2671 : rScale.setX(aCol0.getLength());
402 2671 : aCol0.normalize();
403 :
404 : // get ShearXY
405 2671 : rShear.setX(aCol0.scalar(aCol1));
406 :
407 2671 : if(fTools::equalZero(rShear.getX()))
408 : {
409 2671 : rShear.setX(0.0);
410 : }
411 : else
412 : {
413 0 : aTemp.setX(aCol1.getX() - rShear.getX() * aCol0.getX());
414 0 : aTemp.setY(aCol1.getY() - rShear.getX() * aCol0.getY());
415 0 : aTemp.setZ(aCol1.getZ() - rShear.getX() * aCol0.getZ());
416 0 : aCol1 = aTemp;
417 : }
418 :
419 : // get ScaleY
420 2671 : rScale.setY(aCol1.getLength());
421 2671 : aCol1.normalize();
422 :
423 2671 : const double fShearX(rShear.getX());
424 :
425 2671 : if(!fTools::equalZero(fShearX))
426 : {
427 0 : rShear.setX(rShear.getX() / rScale.getY());
428 : }
429 :
430 : // get ShearXZ
431 2671 : rShear.setY(aCol0.scalar(aCol2));
432 :
433 2671 : if(fTools::equalZero(rShear.getY()))
434 : {
435 2671 : rShear.setY(0.0);
436 : }
437 : else
438 : {
439 0 : aTemp.setX(aCol2.getX() - rShear.getY() * aCol0.getX());
440 0 : aTemp.setY(aCol2.getY() - rShear.getY() * aCol0.getY());
441 0 : aTemp.setZ(aCol2.getZ() - rShear.getY() * aCol0.getZ());
442 0 : aCol2 = aTemp;
443 : }
444 :
445 : // get ShearYZ
446 2671 : rShear.setZ(aCol1.scalar(aCol2));
447 :
448 2671 : if(fTools::equalZero(rShear.getZ()))
449 : {
450 2671 : rShear.setZ(0.0);
451 : }
452 : else
453 : {
454 0 : aTemp.setX(aCol2.getX() - rShear.getZ() * aCol1.getX());
455 0 : aTemp.setY(aCol2.getY() - rShear.getZ() * aCol1.getY());
456 0 : aTemp.setZ(aCol2.getZ() - rShear.getZ() * aCol1.getZ());
457 0 : aCol2 = aTemp;
458 : }
459 :
460 : // get ScaleZ
461 2671 : rScale.setZ(aCol2.getLength());
462 2671 : aCol2.normalize();
463 :
464 2671 : const double fShearY(rShear.getY());
465 :
466 2671 : if(!fTools::equalZero(fShearY))
467 : {
468 0 : rShear.setY(rShear.getY() / rScale.getZ());
469 : }
470 :
471 2671 : const double fShearZ(rShear.getZ());
472 :
473 2671 : if(!fTools::equalZero(fShearZ))
474 : {
475 0 : rShear.setZ(rShear.getZ() / rScale.getZ());
476 : }
477 :
478 : // correct shear values
479 2671 : rShear.correctValues();
480 :
481 : // Coordinate system flip?
482 2671 : if(0.0 > aCol0.scalar(aCol1.getPerpendicular(aCol2)))
483 : {
484 550 : rScale = -rScale;
485 550 : aCol0 = -aCol0;
486 550 : aCol1 = -aCol1;
487 550 : aCol2 = -aCol2;
488 : }
489 :
490 : // correct scale values
491 2671 : rScale.correctValues(1.0);
492 :
493 : // Get rotations
494 : {
495 2671 : double fy=0;
496 2671 : double cy=0;
497 :
498 10684 : if( ::basegfx::fTools::equal( aCol0.getZ(), 1.0 )
499 10684 : || aCol0.getZ() > 1.0 )
500 : {
501 0 : fy = -F_PI/2.0;
502 0 : cy = 0.0;
503 : }
504 10684 : else if( ::basegfx::fTools::equal( aCol0.getZ(), -1.0 )
505 10684 : || aCol0.getZ() < -1.0 )
506 : {
507 0 : fy = F_PI/2.0;
508 0 : cy = 0.0;
509 : }
510 : else
511 : {
512 2671 : fy = asin( -aCol0.getZ() );
513 2671 : cy = cos(fy);
514 : }
515 :
516 2671 : rRotate.setY(fy);
517 2671 : if( ::basegfx::fTools::equalZero( cy ) )
518 : {
519 0 : if( aCol0.getZ() > 0.0 )
520 0 : rRotate.setX(atan2(-1.0*aCol1.getX(), aCol1.getY()));
521 : else
522 0 : rRotate.setX(atan2(aCol1.getX(), aCol1.getY()));
523 0 : rRotate.setZ(0.0);
524 : }
525 : else
526 : {
527 2671 : rRotate.setX(atan2(aCol1.getZ(), aCol2.getZ()));
528 2671 : rRotate.setZ(atan2(aCol0.getY(), aCol0.getX()));
529 : }
530 :
531 : // correct rotate values
532 2671 : rRotate.correctValues();
533 : }
534 :
535 5342 : return true;
536 : }
537 : } // end of namespace basegfx
538 :
539 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
