strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/basegfx/source/matrix/b3dhommatrix.cxx
Oliver Bolte ee925ca2d7 INTEGRATION: CWS cowfixes01 (1.9.12); FILE MERGED 
2006/03/21 13:36:26 thb 1.9.12.3: #i63310# Removed silly self-referentiality for the static default objects (causing infinite loops)
2006/03/17 23:16:36 thb 1.9.12.2: #i63310# Moved BxD(Poly)Polygon to cow_wrapper; added makeUnique() to all classes using COW internally (to at least facilitate deliberate unsharing in multi-threaded uses)
2006/03/17 17:41:34 thb 1.9.12.1: #i63310# Added COW to B2DMultiRange (wasn't there before); moved BxDHomMatrix to cow_wrapper; added o3tl build dependency
2006-07-13 08:56:42 +00:00

477 lines
12 KiB
C++
Raw Blame History

/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: b3dhommatrix.cxx,v $
*
* $Revision: 1.10 $
*
* last change: $Author: obo $ $Date: 2006-07-13 09:56:42 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef INCLUDED_RTL_INSTANCE_HXX
#include <rtl/instance.hxx>
#endif
#ifndef _BGFX_MATRIX_B3DHOMMATRIX_HXX
#include <basegfx/matrix/b3dhommatrix.hxx>
#endif
#ifndef _HOMMATRIX_TEMPLATE_HXX
#include <hommatrixtemplate.hxx>
#endif
#ifndef _BGFX_VECTOR_B3DVECTOR_HXX
#include <basegfx/vector/b3dvector.hxx>
#endif
namespace basegfx
{
class Impl3DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 4 >
{
};
namespace { struct IdentityMatrix : public rtl::Static< B3DHomMatrix::ImplType,
IdentityMatrix > {}; }
B3DHomMatrix::B3DHomMatrix() :
mpImpl( IdentityMatrix::get() ) // use common identity matrix
{
}
B3DHomMatrix::B3DHomMatrix(const B3DHomMatrix& rMat) :
mpImpl(rMat.mpImpl)
{
}
B3DHomMatrix::~B3DHomMatrix()
{
}
B3DHomMatrix& B3DHomMatrix::operator=(const B3DHomMatrix& rMat)
{
mpImpl = rMat.mpImpl;
return *this;
}
void B3DHomMatrix::makeUnique()
{
mpImpl.make_unique();
}
double B3DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
{
return mpImpl->get(nRow, nColumn);
}
void B3DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
{
mpImpl->set(nRow, nColumn, fValue);
}
bool B3DHomMatrix::isLastLineDefault() const
{
return mpImpl->isLastLineDefault();
}
bool B3DHomMatrix::isIdentity() const
{
if(mpImpl.same_object(IdentityMatrix::get()))
return true;
return mpImpl->isIdentity();
}
void B3DHomMatrix::identity()
{
mpImpl = IdentityMatrix::get();
}
bool B3DHomMatrix::isInvertible() const
{
return mpImpl->isInvertible();
}
bool B3DHomMatrix::invert()
{
Impl3DHomMatrix aWork(*mpImpl);
sal_uInt16* pIndex = new sal_uInt16[mpImpl->getEdgeLength()];
sal_Int16 nParity;
if(aWork.ludcmp(pIndex, nParity))
{
mpImpl->doInvert(aWork, pIndex);
delete[] pIndex;
return true;
}
delete[] pIndex;
return false;
}
bool B3DHomMatrix::isNormalized() const
{
return mpImpl->isNormalized();
}
void B3DHomMatrix::normalize()
{
if(!const_cast<const B3DHomMatrix*>(this)->mpImpl->isNormalized())
mpImpl->doNormalize();
}
double B3DHomMatrix::determinant() const
{
return mpImpl->doDeterminant();
}
double B3DHomMatrix::trace() const
{
return mpImpl->doTrace();
}
void B3DHomMatrix::transpose()
{
mpImpl->doTranspose();
}
B3DHomMatrix& B3DHomMatrix::operator+=(const B3DHomMatrix& rMat)
{
mpImpl->doAddMatrix(*rMat.mpImpl);
return *this;
}
B3DHomMatrix& B3DHomMatrix::operator-=(const B3DHomMatrix& rMat)
{
mpImpl->doSubMatrix(*rMat.mpImpl);
return *this;
}
B3DHomMatrix& B3DHomMatrix::operator*=(double fValue)
{
const double fOne(1.0);
if(!fTools::equal(fOne, fValue))
mpImpl->doMulMatrix(fValue);
return *this;
}
B3DHomMatrix& B3DHomMatrix::operator/=(double fValue)
{
const double fOne(1.0);
if(!fTools::equal(fOne, fValue))
mpImpl->doMulMatrix(1.0 / fValue);
return *this;
}
B3DHomMatrix& B3DHomMatrix::operator*=(const B3DHomMatrix& rMat)
{
if(!rMat.isIdentity())
mpImpl->doMulMatrix(*rMat.mpImpl);
return *this;
}
bool B3DHomMatrix::operator==(const B3DHomMatrix& rMat) const
{
if(mpImpl.same_object(rMat.mpImpl))
return true;
return mpImpl->isEqual(*rMat.mpImpl);
}
bool B3DHomMatrix::operator!=(const B3DHomMatrix& rMat) const
{
return !(*this == rMat);
}
void B3DHomMatrix::rotate(double fAngleX,double fAngleY,double fAngleZ)
{
if(!fTools::equalZero(fAngleX) || !fTools::equalZero(fAngleY) || !fTools::equalZero(fAngleZ))
{
if(!fTools::equalZero(fAngleX))
{
Impl3DHomMatrix aRotMatX;
double fSin(sin(fAngleX));
double fCos(cos(fAngleX));
aRotMatX.set(1, 1, fCos);
aRotMatX.set(2, 2, fCos);
aRotMatX.set(2, 1, fSin);
aRotMatX.set(1, 2, -fSin);
mpImpl->doMulMatrix(aRotMatX);
}
if(!fTools::equalZero(fAngleY))
{
Impl3DHomMatrix aRotMatY;
double fSin(sin(fAngleY));
double fCos(cos(fAngleY));
aRotMatY.set(0, 0, fCos);
aRotMatY.set(2, 2, fCos);
aRotMatY.set(0, 2, fSin);
aRotMatY.set(2, 0, -fSin);
mpImpl->doMulMatrix(aRotMatY);
}
if(!fTools::equalZero(fAngleZ))
{
Impl3DHomMatrix aRotMatZ;
double fSin(sin(fAngleZ));
double fCos(cos(fAngleZ));
aRotMatZ.set(0, 0, fCos);
aRotMatZ.set(1, 1, fCos);
aRotMatZ.set(1, 0, fSin);
aRotMatZ.set(0, 1, -fSin);
mpImpl->doMulMatrix(aRotMatZ);
}
}
}
void B3DHomMatrix::translate(double fX, double fY, double fZ)
{
if(!fTools::equalZero(fX) || !fTools::equalZero(fY) || !fTools::equalZero(fZ))
{
Impl3DHomMatrix aTransMat;
aTransMat.set(0, 3, fX);
aTransMat.set(1, 3, fY);
aTransMat.set(2, 3, fZ);
mpImpl->doMulMatrix(aTransMat);
}
}
void B3DHomMatrix::scale(double fX, double fY, double fZ)
{
const double fOne(1.0);
if(!fTools::equal(fOne, fX) || !fTools::equal(fOne, fY) ||!fTools::equal(fOne, fZ))
{
Impl3DHomMatrix aScaleMat;
aScaleMat.set(0, 0, fX);
aScaleMat.set(1, 1, fY);
aScaleMat.set(2, 2, fZ);
mpImpl->doMulMatrix(aScaleMat);
}
}
void B3DHomMatrix::shearXY(double fSx, double fSy)
{
const double fOne(1.0);
if(!fTools::equal(fOne, fSx) || !fTools::equal(fOne, fSy))
{
Impl3DHomMatrix aShearXYMat;
aShearXYMat.set(0, 2, fSx);
aShearXYMat.set(1, 2, fSy);
mpImpl->doMulMatrix(aShearXYMat);
}
}
void B3DHomMatrix::shearYZ(double fSy, double fSz)
{
const double fOne(1.0);
if(!fTools::equal(fOne, fSy) || !fTools::equal(fOne, fSz))
{
Impl3DHomMatrix aShearYZMat;
aShearYZMat.set(1, 0, fSy);
aShearYZMat.set(2, 0, fSz);
mpImpl->doMulMatrix(aShearYZMat);
}
}
void B3DHomMatrix::shearXZ(double fSx, double fSz)
{
const double fOne(1.0);
if(!fTools::equal(fOne, fSx) || !fTools::equal(fOne, fSz))
{
Impl3DHomMatrix aShearXZMat;
aShearXZMat.set(0, 1, fSx);
aShearXZMat.set(2, 1, fSz);
mpImpl->doMulMatrix(aShearXZMat);
}
}
bool B3DHomMatrix::decompose(B3DTuple& rScale, B3DTuple& rTranslate, B3DTuple& rRotate, B3DTuple& rShear) const
{
// when perspective is used, decompose is not made here
if(!mpImpl->isLastLineDefault())
return false;
// If determinant is zero, decomposition is not possible
if(0.0 == determinant())
return false;
// isolate translation
rTranslate.setX(mpImpl->get(0, 3));
rTranslate.setY(mpImpl->get(1, 3));
rTranslate.setZ(mpImpl->get(2, 3));
// correct translate values
rTranslate.correctValues();
// get scale and shear
B3DVector aCol0(mpImpl->get(0, 0), mpImpl->get(1, 0), mpImpl->get(2, 0));
B3DVector aCol1(mpImpl->get(0, 1), mpImpl->get(1, 1), mpImpl->get(2, 1));
B3DVector aCol2(mpImpl->get(0, 2), mpImpl->get(1, 2), mpImpl->get(2, 2));
B3DVector aTemp;
// get ScaleX
rScale.setX(aCol0.getLength());
aCol0.normalize();
// get ShearXY
rShear.setX(aCol0.scalar(aCol1));
if(::basegfx::fTools::equalZero(rShear.getX()))
{
rShear.setX(0.0);
}
else
{
aTemp.setX(aCol1.getX() - rShear.getX() * aCol0.getX());
aTemp.setY(aCol1.getY() - rShear.getX() * aCol0.getY());
aTemp.setZ(aCol1.getZ() - rShear.getX() * aCol0.getZ());
aCol1 = aTemp;
}
// get ScaleY
rScale.setY(aCol1.getLength());
aCol1.normalize();
const double fShearX(rShear.getX());
if(!::basegfx::fTools::equalZero(fShearX))
{
rShear.setX(rShear.getX() / rScale.getY());
}
// get ShearXZ
rShear.setY(aCol0.scalar(aCol2));
if(::basegfx::fTools::equalZero(rShear.getY()))
{
rShear.setY(0.0);
}
else
{
aTemp.setX(aCol2.getX() - rShear.getY() * aCol0.getX());
aTemp.setY(aCol2.getY() - rShear.getY() * aCol0.getY());
aTemp.setZ(aCol2.getZ() - rShear.getY() * aCol0.getZ());
aCol2 = aTemp;
}
// get ShearYZ
rShear.setZ(aCol1.scalar(aCol2));
if(::basegfx::fTools::equalZero(rShear.getZ()))
{
rShear.setZ(0.0);
}
else
{
aTemp.setX(aCol2.getX() - rShear.getZ() * aCol1.getX());
aTemp.setY(aCol2.getY() - rShear.getZ() * aCol1.getY());
aTemp.setZ(aCol2.getZ() - rShear.getZ() * aCol1.getZ());
aCol2 = aTemp;
}
// get ScaleZ
rScale.setZ(aCol2.getLength());
aCol2.normalize();
const double fShearY(rShear.getY());
if(!::basegfx::fTools::equalZero(fShearY))
{
rShear.setY(rShear.getY() / rScale.getZ());
}
const double fShearZ(rShear.getZ());
if(!::basegfx::fTools::equalZero(fShearZ))
{
rShear.setZ(rShear.getZ() / rScale.getZ());
}
// correct shear values
rShear.correctValues();
// Coordinate system flip?
if(0.0 > aCol0.scalar(aCol1.getPerpendicular(aCol2)))
{
rScale = -rScale;
aCol0 = -aCol0;
aCol1 = -aCol1;
aCol2 = -aCol2;
}
// correct scale values
rScale.correctValues(1.0);
// Get rotations
rRotate.setY(asin(-aCol0.getZ()));
if(::basegfx::fTools::equalZero(cos(rRotate.getY())))
{
rRotate.setX(atan2(aCol1.getX(), aCol1.getY()));
rRotate.setZ(0.0);
}
else
{
rRotate.setX(atan2(aCol1.getZ(), aCol2.getZ()));
rRotate.setZ(atan2(aCol0.getY(), aCol0.getX()));
}
// corrcet rotate values
rRotate.correctValues();
return true;
}
} // end of namespace basegfx
// eof
Reference in a new issue View git blame Copy permalink