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