src/common/matrix.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/common/matrix.cpp
// Purpose:     wxTransformMatrix class
// Author:      Chris Breeze, Julian Smart
// Modified by: Klaas Holwerda
// Created:     01/02/97
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// Note: this is intended to be used in wxDC at some point to replace
// the current system of scaling/translation. It is not yet used.

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/matrix.h"

#ifndef WX_PRECOMP
    #include "wx/math.h"
#endif

static const double pi = M_PI;

wxTransformMatrix::wxTransformMatrix(void)
{
    m_isIdentity = false;

    Identity();
}

wxTransformMatrix::wxTransformMatrix(const wxTransformMatrix& mat)
    : wxObject()
{
    (*this) = mat;
}

double wxTransformMatrix::GetValue(int col, int row) const
{
    if (row < 0 || row > 2 || col < 0 || col > 2)
        return 0.0;

    return m_matrix[col][row];
}

void wxTransformMatrix::SetValue(int col, int row, double value)
{
    if (row < 0 || row > 2 || col < 0 || col > 2)
        return;

    m_matrix[col][row] = value;
    m_isIdentity = IsIdentity1();
}

void wxTransformMatrix::operator = (const wxTransformMatrix& mat)
{
    int i, j;
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            m_matrix[i][j] = mat.m_matrix[i][j];
        }
    }
    m_isIdentity = mat.m_isIdentity;
}

bool wxTransformMatrix::operator == (const wxTransformMatrix& mat) const
{
    if (m_isIdentity && mat.m_isIdentity)
        return true;

    int i, j;
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            if ( !wxIsSameDouble(m_matrix[i][j], mat.m_matrix[i][j]) )
                return false;
        }
    }
    return true;
}

bool wxTransformMatrix::operator != (const wxTransformMatrix& mat) const
{
    return (! ((*this) == mat));
}

double& wxTransformMatrix::operator()(int col, int row)
{
    if (row < 0 || row > 2 || col < 0 || col > 2)
        return m_matrix[0][0];

    return m_matrix[col][row];
}

double wxTransformMatrix::operator()(int col, int row) const
{
    if (row < 0 || row > 2 || col < 0 || col > 2)
        return 0.0;

    return m_matrix[col][row];
}

// Invert matrix
bool wxTransformMatrix::Invert(void)
{
    double inverseMatrix[3][3];

    // calculate the adjoint
    inverseMatrix[0][0] =  wxCalculateDet(m_matrix[1][1],m_matrix[2][1],m_matrix[1][2],m_matrix[2][2]);
    inverseMatrix[0][1] = -wxCalculateDet(m_matrix[0][1],m_matrix[2][1],m_matrix[0][2],m_matrix[2][2]);
    inverseMatrix[0][2] =  wxCalculateDet(m_matrix[0][1],m_matrix[1][1],m_matrix[0][2],m_matrix[1][2]);

    inverseMatrix[1][0] = -wxCalculateDet(m_matrix[1][0],m_matrix[2][0],m_matrix[1][2],m_matrix[2][2]);
    inverseMatrix[1][1] =  wxCalculateDet(m_matrix[0][0],m_matrix[2][0],m_matrix[0][2],m_matrix[2][2]);
    inverseMatrix[1][2] = -wxCalculateDet(m_matrix[0][0],m_matrix[1][0],m_matrix[0][2],m_matrix[1][2]);

    inverseMatrix[2][0] =  wxCalculateDet(m_matrix[1][0],m_matrix[2][0],m_matrix[1][1],m_matrix[2][1]);
    inverseMatrix[2][1] = -wxCalculateDet(m_matrix[0][0],m_matrix[2][0],m_matrix[0][1],m_matrix[2][1]);
    inverseMatrix[2][2] =  wxCalculateDet(m_matrix[0][0],m_matrix[1][0],m_matrix[0][1],m_matrix[1][1]);

    // now divide by the determinant
    double det = m_matrix[0][0] * inverseMatrix[0][0] + m_matrix[0][1] * inverseMatrix[1][0] + m_matrix[0][2] * inverseMatrix[2][0];
    if ( wxIsNullDouble(det) )
        return false;

    inverseMatrix[0][0] /= det; inverseMatrix[1][0] /= det; inverseMatrix[2][0] /= det;
    inverseMatrix[0][1] /= det; inverseMatrix[1][1] /= det; inverseMatrix[2][1] /= det;
    inverseMatrix[0][2] /= det; inverseMatrix[1][2] /= det; inverseMatrix[2][2] /= det;

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            m_matrix[i][j] = inverseMatrix[i][j];
        }
    }
    m_isIdentity = IsIdentity1();
    return true;
}

// Make into identity matrix
bool wxTransformMatrix::Identity(void)
{
    m_matrix[0][0] = m_matrix[1][1] = m_matrix[2][2] = 1.0;
    m_matrix[1][0] = m_matrix[2][0] = m_matrix[0][1] = m_matrix[2][1] = m_matrix[0][2] = m_matrix[1][2] = 0.0;
    m_isIdentity = true;

    return true;
}

// Scale by scale (isotropic scaling i.e. the same in x and y):
//           | scale  0      0      |
// matrix' = |  0     scale  0      | x matrix
//           |  0     0      scale  |
//
bool wxTransformMatrix::Scale(double scale)
{
    int i, j;
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            m_matrix[i][j] *= scale;
        }
    }
    m_isIdentity = IsIdentity1();

    return true;
}


// scale a matrix in 2D
//
//     xs    0      xc(1-xs)
//     0    ys      yc(1-ys)
//     0     0      1
//
wxTransformMatrix&  wxTransformMatrix::Scale(const double &xs, const double &ys,const double &xc, const double &yc)
{
    double r00,r10,r20,r01,r11,r21;

    if (m_isIdentity)
    {
        double tx = xc*(1-xs);
        double ty = yc*(1-ys);
        r00 = xs;
        r10 = 0;
        r20 = tx;
        r01 = 0;
        r11 = ys;
        r21 = ty;
    }
    else if ( !wxIsNullDouble(xc) || !wxIsNullDouble(yc) )
    {
        double tx = xc*(1-xs);
        double ty = yc*(1-ys);
        r00 = xs * m_matrix[0][0];
        r10 = xs * m_matrix[1][0];
        r20 = xs * m_matrix[2][0] + tx;
        r01 = ys * m_matrix[0][1];
        r11 = ys * m_matrix[1][1];
        r21 = ys * m_matrix[2][1] + ty;
    }
    else
    {
        r00 = xs * m_matrix[0][0];
        r10 = xs * m_matrix[1][0];
        r20 = xs * m_matrix[2][0];
        r01 = ys * m_matrix[0][1];
        r11 = ys * m_matrix[1][1];
        r21 = ys * m_matrix[2][1];
    }

    m_matrix[0][0] = r00;
    m_matrix[1][0] = r10;
    m_matrix[2][0] = r20;
    m_matrix[0][1] = r01;
    m_matrix[1][1] = r11;
    m_matrix[2][1] = r21;

/* or like this
    // first translate to origin O
    (*this).Translate(-x_cen, -y_cen);

    // now do the scaling
    wxTransformMatrix scale;
    scale.m_matrix[0][0] = x_fac;
    scale.m_matrix[1][1] = y_fac;
   scale.m_isIdentity = IsIdentity1();

    *this = scale * (*this);

    // translate back from origin to x_cen, y_cen
    (*this).Translate(x_cen, y_cen);
*/

    m_isIdentity = IsIdentity1();

    return *this;
}


// mirror a matrix in x, y
//
//     -1      0      0     Y-mirror
//      0     -1      0     X-mirror
//      0      0     -1     Z-mirror
wxTransformMatrix&  wxTransformMatrix::Mirror(bool x, bool y)
{
    wxTransformMatrix temp;
    if (x)
    {
        temp.m_matrix[1][1] = -1;
        temp.m_isIdentity=false;
    }
    if (y)
    {
        temp.m_matrix[0][0] = -1;
        temp.m_isIdentity=false;
    }

    *this = temp * (*this);
    m_isIdentity = IsIdentity1();
    return *this;
}

// Translate by dx, dy:
//           | 1  0 dx |
// matrix' = | 0  1 dy | x matrix
//           | 0  0  1 |
//
bool wxTransformMatrix::Translate(double dx, double dy)
{
    int i;
    for (i = 0; i < 3; i++)
        m_matrix[i][0] += dx * m_matrix[i][2];
    for (i = 0; i < 3; i++)
        m_matrix[i][1] += dy * m_matrix[i][2];

    m_isIdentity = IsIdentity1();

    return true;
}

// Rotate clockwise by the given number of degrees:
//           |  cos sin 0 |
// matrix' = | -sin cos 0 | x matrix
//           |   0   0  1 |
bool wxTransformMatrix::Rotate(double degrees)
{
    Rotate(-degrees,0,0);
    return true;
}

// counter clockwise rotate around a point
//
//  cos(r) -sin(r)    x(1-cos(r))+y(sin(r)
//  sin(r)  cos(r)    y(1-cos(r))-x(sin(r)
//    0      0        1
wxTransformMatrix&  wxTransformMatrix::Rotate(const double &degrees, const double &x, const double &y)
{
    double angle = degrees * pi / 180.0;
    double c = cos(angle);
    double s = sin(angle);
    double r00,r10,r20,r01,r11,r21;

    if (m_isIdentity)
    {
        double tx = x*(1-c)+y*s;
        double ty = y*(1-c)-x*s;
        r00 = c ;
        r10 = -s;
        r20 = tx;
        r01 = s;
        r11 = c;
        r21 = ty;
    }
    else if ( !wxIsNullDouble(x) || !wxIsNullDouble(y) )
    {
        double tx = x*(1-c)+y*s;
        double ty = y*(1-c)-x*s;
        r00 = c * m_matrix[0][0] - s * m_matrix[0][1] + tx * m_matrix[0][2];
        r10 = c * m_matrix[1][0] - s * m_matrix[1][1] + tx * m_matrix[1][2];
        r20 = c * m_matrix[2][0] - s * m_matrix[2][1] + tx;// * m_matrix[2][2];
        r01 = c * m_matrix[0][1] + s * m_matrix[0][0] + ty * m_matrix[0][2];
        r11 = c * m_matrix[1][1] + s * m_matrix[1][0] + ty * m_matrix[1][2];
        r21 = c * m_matrix[2][1] + s * m_matrix[2][0] + ty;// * m_matrix[2][2];
    }
    else
    {
        r00 = c * m_matrix[0][0] - s * m_matrix[0][1];
        r10 = c * m_matrix[1][0] - s * m_matrix[1][1];
        r20 = c * m_matrix[2][0] - s * m_matrix[2][1];
        r01 = c * m_matrix[0][1] + s * m_matrix[0][0];
        r11 = c * m_matrix[1][1] + s * m_matrix[1][0];
        r21 = c * m_matrix[2][1] + s * m_matrix[2][0];
    }

    m_matrix[0][0] = r00;
    m_matrix[1][0] = r10;
    m_matrix[2][0] = r20;
    m_matrix[0][1] = r01;
    m_matrix[1][1] = r11;
    m_matrix[2][1] = r21;

/* or like this
    wxTransformMatrix rotate;
    rotate.m_matrix[2][0] = tx;
    rotate.m_matrix[2][1] = ty;

    rotate.m_matrix[0][0] = c;
    rotate.m_matrix[0][1] = s;

    rotate.m_matrix[1][0] = -s;
    rotate.m_matrix[1][1] = c;

   rotate.m_isIdentity=false;
   *this = rotate * (*this);
*/
    m_isIdentity = IsIdentity1();

    return *this;
}

// Transform a point from logical to device coordinates
bool wxTransformMatrix::TransformPoint(double x, double y, double& tx, double& ty) const
{
    if (IsIdentity())
    {
        tx = x; ty = y; return true;
    }

    tx = x * m_matrix[0][0] + y * m_matrix[1][0] + m_matrix[2][0];
    ty = x * m_matrix[0][1] + y * m_matrix[1][1] + m_matrix[2][1];

    return true;
}

// Transform a point from device to logical coordinates.

// Example of use:
//   wxTransformMatrix mat = dc.GetTransformation();
//   mat.Invert();
//   mat.InverseTransformPoint(x, y, x1, y1);
// OR (shorthand:)
//   dc.LogicalToDevice(x, y, x1, y1);
// The latter is slightly less efficient if we're doing several
// conversions, since the matrix is inverted several times.
bool wxTransformMatrix::InverseTransformPoint(double x, double y, double& tx, double& ty) const
{
    if (IsIdentity())
    {
        tx = x;
        ty = y;
        return true;
    }

    const double z = (1.0 - m_matrix[0][2] * x - m_matrix[1][2] * y) / m_matrix[2][2];
    if ( wxIsNullDouble(z) )
        return false;

    tx = x * m_matrix[0][0] + y * m_matrix[1][0] + z * m_matrix[2][0];
    ty = x * m_matrix[0][1] + y * m_matrix[1][1] + z * m_matrix[2][1];
    return true;
}

wxTransformMatrix& wxTransformMatrix::operator*=(const double& t)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            m_matrix[i][j]*= t;
    m_isIdentity = IsIdentity1();
    return *this;
}

wxTransformMatrix& wxTransformMatrix::operator/=(const double& t)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            m_matrix[i][j]/= t;
    m_isIdentity = IsIdentity1();
    return *this;
}

wxTransformMatrix& wxTransformMatrix::operator+=(const wxTransformMatrix& mat)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            m_matrix[i][j] += mat.m_matrix[i][j];
    m_isIdentity = IsIdentity1();
    return *this;
}

wxTransformMatrix& wxTransformMatrix::operator-=(const wxTransformMatrix& mat)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            m_matrix[i][j] -= mat.m_matrix[i][j];
    m_isIdentity = IsIdentity1();
    return *this;
}

wxTransformMatrix& wxTransformMatrix::operator*=(const wxTransformMatrix& mat)
{

    if (mat.m_isIdentity)
        return *this;
    if (m_isIdentity)
    {
        *this = mat;
        return *this;
    }
    else
    {
        wxTransformMatrix  result;
        for (int i = 0; i < 3; i++)
        {
           for (int j = 0; j < 3; j++)
           {
               double sum = 0;
               for (int k = 0; k < 3; k++)
                   sum += m_matrix[k][i] * mat.m_matrix[j][k];
               result.m_matrix[j][i] = sum;
           }
        }
        *this = result;
    }

    m_isIdentity = IsIdentity1();
    return *this;
}


// constant operators
wxTransformMatrix  wxTransformMatrix::operator*(const double& t) const
{
    wxTransformMatrix result = *this;
    result *= t;
    result.m_isIdentity = result.IsIdentity1();
    return result;
}

wxTransformMatrix  wxTransformMatrix::operator/(const double& t) const
{
    wxTransformMatrix result = *this;
//    wxASSERT(t!=0);
    result /= t;
    result.m_isIdentity = result.IsIdentity1();
    return result;
}

wxTransformMatrix  wxTransformMatrix::operator+(const wxTransformMatrix& m) const
{
    wxTransformMatrix result = *this;
    result += m;
    result.m_isIdentity = result.IsIdentity1();
    return result;
}

wxTransformMatrix  wxTransformMatrix::operator-(const wxTransformMatrix& m) const
{
    wxTransformMatrix result = *this;
    result -= m;
    result.m_isIdentity = result.IsIdentity1();
    return result;
}


wxTransformMatrix  wxTransformMatrix::operator*(const wxTransformMatrix& m) const
{
    wxTransformMatrix result = *this;
    result *= m;
    result.m_isIdentity = result.IsIdentity1();
    return result;
}


wxTransformMatrix  wxTransformMatrix::operator-() const
{
    wxTransformMatrix result = *this;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            result.m_matrix[i][j] = -(this->m_matrix[i][j]);
    result.m_isIdentity = result.IsIdentity1();
    return result;
}

static double CheckInt(double getal)
{
    // check if the number is very close to an integer
    if ( (ceil(getal) - getal) < 0.0001)
        return ceil(getal);

    else if ( (getal - floor(getal)) < 0.0001)
        return floor(getal);

    return getal;

}

double wxTransformMatrix::Get_scaleX()
{
    double scale_factor;
    double rot_angle = CheckInt(atan2(m_matrix[1][0],m_matrix[0][0])*180/pi);
    if ( !wxIsSameDouble(rot_angle, 90) && !wxIsSameDouble(rot_angle, -90) )
        scale_factor = m_matrix[0][0]/cos((rot_angle/180)*pi);
    else
        scale_factor = m_matrix[0][0]/sin((rot_angle/180)*pi);  // er kan nl. niet door 0 gedeeld worden !

    scale_factor = CheckInt(scale_factor);
    if (scale_factor < 0)
        scale_factor = -scale_factor;

    return scale_factor;
}

double wxTransformMatrix::Get_scaleY()
{
    double scale_factor;
    double rot_angle = CheckInt(atan2(m_matrix[1][0],m_matrix[0][0])*180/pi);
    if ( !wxIsSameDouble(rot_angle, 90) && !wxIsSameDouble(rot_angle, -90) )
       scale_factor = m_matrix[1][1]/cos((rot_angle/180)*pi);
    else
       scale_factor = m_matrix[1][1]/sin((rot_angle/180)*pi);   // er kan nl. niet door 0 gedeeld worden !

    scale_factor = CheckInt(scale_factor);
    if (scale_factor < 0)

        scale_factor = -scale_factor;

    return scale_factor;

}

double wxTransformMatrix::GetRotation()
{
    double temp1 = GetValue(0,0);   // for angle calculation
    double temp2 = GetValue(0,1);   //

    // Rotation
    double rot_angle = atan2(temp2,temp1)*180/pi;

    rot_angle = CheckInt(rot_angle);
    return rot_angle;
}

void wxTransformMatrix::SetRotation(double rotation)
{
    double x=GetValue(2,0);
    double y=GetValue(2,1);
    Rotate(-GetRotation(), x, y);
    Rotate(rotation, x, y);
}
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/matrix.cpp
	3	// Purpose: wxTransformMatrix class
	4	// Author: Chris Breeze, Julian Smart
	5	// Modified by: Klaas Holwerda
	6	// Created: 01/02/97
	7	// Copyright: (c) Julian Smart
	8	// Licence: wxWindows licence
	9	///////////////////////////////////////////////////////////////////////////////
	10
	11	// Note: this is intended to be used in wxDC at some point to replace
	12	// the current system of scaling/translation. It is not yet used.
	13
	14	// For compilers that support precompilation, includes "wx.h".
	15	#include "wx/wxprec.h"
	16
	17	#ifdef __BORLANDC__
	18	#pragma hdrstop
	19	#endif
	20
	21	#include "wx/matrix.h"
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/math.h"
	25	#endif
	26
	27	static const double pi = M_PI;
	28
	29	wxTransformMatrix::wxTransformMatrix(void)
	30	{
	31	m_isIdentity = false;
	32
	33	Identity();
	34	}
	35
	36	wxTransformMatrix::wxTransformMatrix(const wxTransformMatrix& mat)
	37	: wxObject()
	38	{
	39	(*this) = mat;
	40	}
	41
	42	double wxTransformMatrix::GetValue(int col, int row) const
	43	{
	44	if (row < 0 \|\| row > 2 \|\| col < 0 \|\| col > 2)
	45	return 0.0;
	46
	47	return m_matrix[col][row];
	48	}
	49
	50	void wxTransformMatrix::SetValue(int col, int row, double value)
	51	{
	52	if (row < 0 \|\| row > 2 \|\| col < 0 \|\| col > 2)
	53	return;
	54
	55	m_matrix[col][row] = value;
	56	m_isIdentity = IsIdentity1();
	57	}
	58
	59	void wxTransformMatrix::operator = (const wxTransformMatrix& mat)
	60	{
	61	int i, j;
	62	for (i = 0; i < 3; i++)
	63	{
	64	for (j = 0; j < 3; j++)
	65	{
	66	m_matrix[i][j] = mat.m_matrix[i][j];
	67	}
	68	}
	69	m_isIdentity = mat.m_isIdentity;
	70	}
	71
	72	bool wxTransformMatrix::operator == (const wxTransformMatrix& mat) const
	73	{
	74	if (m_isIdentity && mat.m_isIdentity)
	75	return true;
	76
	77	int i, j;
	78	for (i = 0; i < 3; i++)
	79	{
	80	for (j = 0; j < 3; j++)
	81	{
	82	if ( !wxIsSameDouble(m_matrix[i][j], mat.m_matrix[i][j]) )
	83	return false;
	84	}
	85	}
	86	return true;
	87	}
	88
	89	bool wxTransformMatrix::operator != (const wxTransformMatrix& mat) const
	90	{
	91	return (! ((*this) == mat));
	92	}
	93
	94	double& wxTransformMatrix::operator()(int col, int row)
	95	{
	96	if (row < 0 \|\| row > 2 \|\| col < 0 \|\| col > 2)
	97	return m_matrix[0][0];
	98
	99	return m_matrix[col][row];
	100	}
	101
	102	double wxTransformMatrix::operator()(int col, int row) const
	103	{
	104	if (row < 0 \|\| row > 2 \|\| col < 0 \|\| col > 2)
	105	return 0.0;
	106
	107	return m_matrix[col][row];
	108	}
	109
	110	// Invert matrix
	111	bool wxTransformMatrix::Invert(void)
	112	{
	113	double inverseMatrix[3][3];
	114
	115	// calculate the adjoint
	116	inverseMatrix[0][0] = wxCalculateDet(m_matrix[1][1],m_matrix[2][1],m_matrix[1][2],m_matrix[2][2]);
	117	inverseMatrix[0][1] = -wxCalculateDet(m_matrix[0][1],m_matrix[2][1],m_matrix[0][2],m_matrix[2][2]);
	118	inverseMatrix[0][2] = wxCalculateDet(m_matrix[0][1],m_matrix[1][1],m_matrix[0][2],m_matrix[1][2]);
	119
	120	inverseMatrix[1][0] = -wxCalculateDet(m_matrix[1][0],m_matrix[2][0],m_matrix[1][2],m_matrix[2][2]);
	121	inverseMatrix[1][1] = wxCalculateDet(m_matrix[0][0],m_matrix[2][0],m_matrix[0][2],m_matrix[2][2]);
	122	inverseMatrix[1][2] = -wxCalculateDet(m_matrix[0][0],m_matrix[1][0],m_matrix[0][2],m_matrix[1][2]);
	123
	124	inverseMatrix[2][0] = wxCalculateDet(m_matrix[1][0],m_matrix[2][0],m_matrix[1][1],m_matrix[2][1]);
	125	inverseMatrix[2][1] = -wxCalculateDet(m_matrix[0][0],m_matrix[2][0],m_matrix[0][1],m_matrix[2][1]);
	126	inverseMatrix[2][2] = wxCalculateDet(m_matrix[0][0],m_matrix[1][0],m_matrix[0][1],m_matrix[1][1]);
	127
	128	// now divide by the determinant
	129	double det = m_matrix[0][0] * inverseMatrix[0][0] + m_matrix[0][1] * inverseMatrix[1][0] + m_matrix[0][2] * inverseMatrix[2][0];
	130	if ( wxIsNullDouble(det) )
	131	return false;
	132
	133	inverseMatrix[0][0] /= det; inverseMatrix[1][0] /= det; inverseMatrix[2][0] /= det;
	134	inverseMatrix[0][1] /= det; inverseMatrix[1][1] /= det; inverseMatrix[2][1] /= det;
	135	inverseMatrix[0][2] /= det; inverseMatrix[1][2] /= det; inverseMatrix[2][2] /= det;
	136
	137	for (int i = 0; i < 3; i++)
	138	{
	139	for (int j = 0; j < 3; j++)
	140	{
	141	m_matrix[i][j] = inverseMatrix[i][j];
	142	}
	143	}
	144	m_isIdentity = IsIdentity1();
	145	return true;
	146	}
	147
	148	// Make into identity matrix
	149	bool wxTransformMatrix::Identity(void)
	150	{
	151	m_matrix[0][0] = m_matrix[1][1] = m_matrix[2][2] = 1.0;
	152	m_matrix[1][0] = m_matrix[2][0] = m_matrix[0][1] = m_matrix[2][1] = m_matrix[0][2] = m_matrix[1][2] = 0.0;
	153	m_isIdentity = true;
	154
	155	return true;
	156	}
	157
	158	// Scale by scale (isotropic scaling i.e. the same in x and y):
	159	// \| scale 0 0 \|
	160	// matrix' = \| 0 scale 0 \| x matrix
	161	// \| 0 0 scale \|
	162	//
	163	bool wxTransformMatrix::Scale(double scale)
	164	{
	165	int i, j;
	166	for (i = 0; i < 3; i++)
	167	{
	168	for (j = 0; j < 3; j++)
	169	{
	170	m_matrix[i][j] *= scale;
	171	}
	172	}
	173	m_isIdentity = IsIdentity1();
	174
	175	return true;
	176	}
	177
	178
	179	// scale a matrix in 2D
	180	//
	181	// xs 0 xc(1-xs)
	182	// 0 ys yc(1-ys)
	183	// 0 0 1
	184	//
	185	wxTransformMatrix& wxTransformMatrix::Scale(const double &xs, const double &ys,const double &xc, const double &yc)
	186	{
	187	double r00,r10,r20,r01,r11,r21;
	188
	189	if (m_isIdentity)
	190	{
	191	double tx = xc*(1-xs);
	192	double ty = yc*(1-ys);
	193	r00 = xs;
	194	r10 = 0;
	195	r20 = tx;
	196	r01 = 0;
	197	r11 = ys;
	198	r21 = ty;
	199	}
	200	else if ( !wxIsNullDouble(xc) \|\| !wxIsNullDouble(yc) )
	201	{
	202	double tx = xc*(1-xs);
	203	double ty = yc*(1-ys);
	204	r00 = xs * m_matrix[0][0];
	205	r10 = xs * m_matrix[1][0];
	206	r20 = xs * m_matrix[2][0] + tx;
	207	r01 = ys * m_matrix[0][1];
	208	r11 = ys * m_matrix[1][1];
	209	r21 = ys * m_matrix[2][1] + ty;
	210	}
	211	else
	212	{
	213	r00 = xs * m_matrix[0][0];
	214	r10 = xs * m_matrix[1][0];
	215	r20 = xs * m_matrix[2][0];
	216	r01 = ys * m_matrix[0][1];
	217	r11 = ys * m_matrix[1][1];
	218	r21 = ys * m_matrix[2][1];
	219	}
	220
	221	m_matrix[0][0] = r00;
	222	m_matrix[1][0] = r10;
	223	m_matrix[2][0] = r20;
	224	m_matrix[0][1] = r01;
	225	m_matrix[1][1] = r11;
	226	m_matrix[2][1] = r21;
	227
	228	/* or like this
	229	// first translate to origin O
	230	(*this).Translate(-x_cen, -y_cen);
	231
	232	// now do the scaling
	233	wxTransformMatrix scale;
	234	scale.m_matrix[0][0] = x_fac;
	235	scale.m_matrix[1][1] = y_fac;
	236	scale.m_isIdentity = IsIdentity1();
	237
	238	this = scale (*this);
	239
	240	// translate back from origin to x_cen, y_cen
	241	(*this).Translate(x_cen, y_cen);
	242	*/
	243
	244	m_isIdentity = IsIdentity1();
	245
	246	return *this;
	247	}
	248
	249
	250	// mirror a matrix in x, y
	251	//
	252	// -1 0 0 Y-mirror
	253	// 0 -1 0 X-mirror
	254	// 0 0 -1 Z-mirror
	255	wxTransformMatrix& wxTransformMatrix::Mirror(bool x, bool y)
	256	{
	257	wxTransformMatrix temp;
	258	if (x)
	259	{
	260	temp.m_matrix[1][1] = -1;
	261	temp.m_isIdentity=false;
	262	}
	263	if (y)
	264	{
	265	temp.m_matrix[0][0] = -1;
	266	temp.m_isIdentity=false;
	267	}
	268
	269	this = temp (*this);
	270	m_isIdentity = IsIdentity1();
	271	return *this;
	272	}
	273
	274	// Translate by dx, dy:
	275	// \| 1 0 dx \|
	276	// matrix' = \| 0 1 dy \| x matrix
	277	// \| 0 0 1 \|
	278	//
	279	bool wxTransformMatrix::Translate(double dx, double dy)
	280	{
	281	int i;
	282	for (i = 0; i < 3; i++)
	283	m_matrix[i][0] += dx * m_matrix[i][2];
	284	for (i = 0; i < 3; i++)
	285	m_matrix[i][1] += dy * m_matrix[i][2];
	286
	287	m_isIdentity = IsIdentity1();
	288
	289	return true;
	290	}
	291
	292	// Rotate clockwise by the given number of degrees:
	293	// \| cos sin 0 \|
	294	// matrix' = \| -sin cos 0 \| x matrix
	295	// \| 0 0 1 \|
	296	bool wxTransformMatrix::Rotate(double degrees)
	297	{
	298	Rotate(-degrees,0,0);
	299	return true;
	300	}
	301
	302	// counter clockwise rotate around a point
	303	//
	304	// cos(r) -sin(r) x(1-cos(r))+y(sin(r)
	305	// sin(r) cos(r) y(1-cos(r))-x(sin(r)
	306	// 0 0 1
	307	wxTransformMatrix& wxTransformMatrix::Rotate(const double &degrees, const double &x, const double &y)
	308	{
	309	double angle = degrees * pi / 180.0;
	310	double c = cos(angle);
	311	double s = sin(angle);
	312	double r00,r10,r20,r01,r11,r21;
	313
	314	if (m_isIdentity)
	315	{
	316	double tx = x(1-c)+ys;
	317	double ty = y(1-c)-xs;
	318	r00 = c ;
	319	r10 = -s;
	320	r20 = tx;
	321	r01 = s;
	322	r11 = c;
	323	r21 = ty;
	324	}
	325	else if ( !wxIsNullDouble(x) \|\| !wxIsNullDouble(y) )
	326	{
	327	double tx = x(1-c)+ys;
	328	double ty = y(1-c)-xs;
	329	r00 = c * m_matrix[0][0] - s * m_matrix[0][1] + tx * m_matrix[0][2];
	330	r10 = c * m_matrix[1][0] - s * m_matrix[1][1] + tx * m_matrix[1][2];
	331	r20 = c * m_matrix[2][0] - s * m_matrix[2][1] + tx;// * m_matrix[2][2];
	332	r01 = c * m_matrix[0][1] + s * m_matrix[0][0] + ty * m_matrix[0][2];
	333	r11 = c * m_matrix[1][1] + s * m_matrix[1][0] + ty * m_matrix[1][2];
	334	r21 = c * m_matrix[2][1] + s * m_matrix[2][0] + ty;// * m_matrix[2][2];
	335	}
	336	else
	337	{
	338	r00 = c * m_matrix[0][0] - s * m_matrix[0][1];
	339	r10 = c * m_matrix[1][0] - s * m_matrix[1][1];
	340	r20 = c * m_matrix[2][0] - s * m_matrix[2][1];
	341	r01 = c * m_matrix[0][1] + s * m_matrix[0][0];
	342	r11 = c * m_matrix[1][1] + s * m_matrix[1][0];
	343	r21 = c * m_matrix[2][1] + s * m_matrix[2][0];
	344	}
	345
	346	m_matrix[0][0] = r00;
	347	m_matrix[1][0] = r10;
	348	m_matrix[2][0] = r20;
	349	m_matrix[0][1] = r01;
	350	m_matrix[1][1] = r11;
	351	m_matrix[2][1] = r21;
	352
	353	/* or like this
	354	wxTransformMatrix rotate;
	355	rotate.m_matrix[2][0] = tx;
	356	rotate.m_matrix[2][1] = ty;
	357
	358	rotate.m_matrix[0][0] = c;
	359	rotate.m_matrix[0][1] = s;
	360
	361	rotate.m_matrix[1][0] = -s;
	362	rotate.m_matrix[1][1] = c;
	363
	364	rotate.m_isIdentity=false;
	365	this = rotate (*this);
	366	*/
	367	m_isIdentity = IsIdentity1();
	368
	369	return *this;
	370	}
	371
	372	// Transform a point from logical to device coordinates
	373	bool wxTransformMatrix::TransformPoint(double x, double y, double& tx, double& ty) const
	374	{
	375	if (IsIdentity())
	376	{
	377	tx = x; ty = y; return true;
	378	}
	379
	380	tx = x * m_matrix[0][0] + y * m_matrix[1][0] + m_matrix[2][0];
	381	ty = x * m_matrix[0][1] + y * m_matrix[1][1] + m_matrix[2][1];
	382
	383	return true;
	384	}
	385
	386	// Transform a point from device to logical coordinates.
	387
	388	// Example of use:
	389	// wxTransformMatrix mat = dc.GetTransformation();
	390	// mat.Invert();
	391	// mat.InverseTransformPoint(x, y, x1, y1);
	392	// OR (shorthand:)
	393	// dc.LogicalToDevice(x, y, x1, y1);
	394	// The latter is slightly less efficient if we're doing several
	395	// conversions, since the matrix is inverted several times.
	396	bool wxTransformMatrix::InverseTransformPoint(double x, double y, double& tx, double& ty) const
	397	{
	398	if (IsIdentity())
	399	{
	400	tx = x;
	401	ty = y;
	402	return true;
	403	}
	404
	405	const double z = (1.0 - m_matrix[0][2] * x - m_matrix[1][2] * y) / m_matrix[2][2];
	406	if ( wxIsNullDouble(z) )
	407	return false;
	408
	409	tx = x * m_matrix[0][0] + y * m_matrix[1][0] + z * m_matrix[2][0];
	410	ty = x * m_matrix[0][1] + y * m_matrix[1][1] + z * m_matrix[2][1];
	411	return true;
	412	}
	413
	414	wxTransformMatrix& wxTransformMatrix::operator*=(const double& t)
	415	{
	416	for (int i = 0; i < 3; i++)
	417	for (int j = 0; j < 3; j++)
	418	m_matrix[i][j]*= t;
	419	m_isIdentity = IsIdentity1();
	420	return *this;
	421	}
	422
	423	wxTransformMatrix& wxTransformMatrix::operator/=(const double& t)
	424	{
	425	for (int i = 0; i < 3; i++)
	426	for (int j = 0; j < 3; j++)
	427	m_matrix[i][j]/= t;
	428	m_isIdentity = IsIdentity1();
	429	return *this;
	430	}
	431
	432	wxTransformMatrix& wxTransformMatrix::operator+=(const wxTransformMatrix& mat)
	433	{
	434	for (int i = 0; i < 3; i++)
	435	for (int j = 0; j < 3; j++)
	436	m_matrix[i][j] += mat.m_matrix[i][j];
	437	m_isIdentity = IsIdentity1();
	438	return *this;
	439	}
	440
	441	wxTransformMatrix& wxTransformMatrix::operator-=(const wxTransformMatrix& mat)
	442	{
	443	for (int i = 0; i < 3; i++)
	444	for (int j = 0; j < 3; j++)
	445	m_matrix[i][j] -= mat.m_matrix[i][j];
	446	m_isIdentity = IsIdentity1();
	447	return *this;
	448	}
	449
	450	wxTransformMatrix& wxTransformMatrix::operator*=(const wxTransformMatrix& mat)
	451	{
	452
	453	if (mat.m_isIdentity)
	454	return *this;
	455	if (m_isIdentity)
	456	{
	457	*this = mat;
	458	return *this;
	459	}
	460	else
	461	{
	462	wxTransformMatrix result;
	463	for (int i = 0; i < 3; i++)
	464	{
	465	for (int j = 0; j < 3; j++)
	466	{
	467	double sum = 0;
	468	for (int k = 0; k < 3; k++)
	469	sum += m_matrix[k][i] * mat.m_matrix[j][k];
	470	result.m_matrix[j][i] = sum;
	471	}
	472	}
	473	*this = result;
	474	}
	475
	476	m_isIdentity = IsIdentity1();
	477	return *this;
	478	}
	479
	480
	481	// constant operators
	482	wxTransformMatrix wxTransformMatrix::operator*(const double& t) const
	483	{
	484	wxTransformMatrix result = *this;
	485	result *= t;
	486	result.m_isIdentity = result.IsIdentity1();
	487	return result;
	488	}
	489
	490	wxTransformMatrix wxTransformMatrix::operator/(const double& t) const
	491	{
	492	wxTransformMatrix result = *this;
	493	// wxASSERT(t!=0);
	494	result /= t;
	495	result.m_isIdentity = result.IsIdentity1();
	496	return result;
	497	}
	498
	499	wxTransformMatrix wxTransformMatrix::operator+(const wxTransformMatrix& m) const
	500	{
	501	wxTransformMatrix result = *this;
	502	result += m;
	503	result.m_isIdentity = result.IsIdentity1();
	504	return result;
	505	}
	506
	507	wxTransformMatrix wxTransformMatrix::operator-(const wxTransformMatrix& m) const
	508	{
	509	wxTransformMatrix result = *this;
	510	result -= m;
	511	result.m_isIdentity = result.IsIdentity1();
	512	return result;
	513	}
	514
	515
	516	wxTransformMatrix wxTransformMatrix::operator*(const wxTransformMatrix& m) const
	517	{
	518	wxTransformMatrix result = *this;
	519	result *= m;
	520	result.m_isIdentity = result.IsIdentity1();
	521	return result;
	522	}
	523
	524
	525	wxTransformMatrix wxTransformMatrix::operator-() const
	526	{
	527	wxTransformMatrix result = *this;
	528	for (int i = 0; i < 3; i++)
	529	for (int j = 0; j < 3; j++)
	530	result.m_matrix[i][j] = -(this->m_matrix[i][j]);
	531	result.m_isIdentity = result.IsIdentity1();
	532	return result;
	533	}
	534
	535	static double CheckInt(double getal)
	536	{
	537	// check if the number is very close to an integer
	538	if ( (ceil(getal) - getal) < 0.0001)
	539	return ceil(getal);
	540
	541	else if ( (getal - floor(getal)) < 0.0001)
	542	return floor(getal);
	543
	544	return getal;
	545
	546	}
	547
	548	double wxTransformMatrix::Get_scaleX()
	549	{
	550	double scale_factor;
	551	double rot_angle = CheckInt(atan2(m_matrix[1][0],m_matrix[0][0])*180/pi);
	552	if ( !wxIsSameDouble(rot_angle, 90) && !wxIsSameDouble(rot_angle, -90) )
	553	scale_factor = m_matrix[0][0]/cos((rot_angle/180)*pi);
	554	else
	555	scale_factor = m_matrix[0][0]/sin((rot_angle/180)*pi); // er kan nl. niet door 0 gedeeld worden !
	556
	557	scale_factor = CheckInt(scale_factor);
	558	if (scale_factor < 0)
	559	scale_factor = -scale_factor;
	560
	561	return scale_factor;
	562	}
	563
	564	double wxTransformMatrix::Get_scaleY()
	565	{
	566	double scale_factor;
	567	double rot_angle = CheckInt(atan2(m_matrix[1][0],m_matrix[0][0])*180/pi);
	568	if ( !wxIsSameDouble(rot_angle, 90) && !wxIsSameDouble(rot_angle, -90) )
	569	scale_factor = m_matrix[1][1]/cos((rot_angle/180)*pi);
	570	else
	571	scale_factor = m_matrix[1][1]/sin((rot_angle/180)*pi); // er kan nl. niet door 0 gedeeld worden !
	572
	573	scale_factor = CheckInt(scale_factor);
	574	if (scale_factor < 0)
	575
	576	scale_factor = -scale_factor;
	577
	578	return scale_factor;
	579
	580	}
	581
	582	double wxTransformMatrix::GetRotation()
	583	{
	584	double temp1 = GetValue(0,0); // for angle calculation
	585	double temp2 = GetValue(0,1); //
	586
	587	// Rotation
	588	double rot_angle = atan2(temp2,temp1)*180/pi;
	589
	590	rot_angle = CheckInt(rot_angle);
	591	return rot_angle;
	592	}
	593
	594	void wxTransformMatrix::SetRotation(double rotation)
	595	{
	596	double x=GetValue(2,0);
	597	double y=GetValue(2,1);
	598	Rotate(-GetRotation(), x, y);
	599	Rotate(rotation, x, y);
	600	}