Matrix4 Class Reference

4x4 matrix class with numerous operators, conversions, etc. More...

#include <Matrix4.h>

Public Member Functions
	Matrix4 (void)
	identity constructor More...
	Matrix4 (double f)
	const elements constructor More...
	Matrix4 (const double *m)
	construct from double array More...
	Matrix4 (const Matrix4 &m)
	copy constructor More...
	~Matrix4 (void)
	destructor More...
void	multpoint3d (const double[3], double[3]) const
	multiplies a 3D point (first arg) by the Matrix, returns in second arg More...
void	multnorm3d (const double[3], double[3]) const
	multiplies a 3D norm (first arg) by the Matrix, returns in second arg More...
void	multpoint4d (const double[4], double[4]) const
	multiplies a 4D point (first arg) by the Matrix, returns in second arg More...
void	identity (void)
	clears the matrix (resets it to identity) More...
void	constant (double)
	sets the matrix so all items are the given constant value More...
int	inverse (void)
void	transpose (void)
	transposes the matrix More...
void	loadmatrix (const Matrix4 &m)
	replaces this matrix with the given one More...
Matrix4 &	operator= (const Matrix4 &m)
void	multmatrix (const Matrix4 &)
	premultiply the matrix by the given matrix, this->other * this More...
void	rot (double, char)
	performs a left-handed rotation around an axis (char == 'x', 'y', or 'z') More...
void	rotate_axis (const double axis[3], double angle)
	apply a rotation around the given vector; angle in radians. More...
void	transvec (double x, double y, double z)
	apply a rotation such that 'x' is brought along the given vector. More...
void	transvecinv (double x, double y, double z)
	apply a rotation such that the given vector is brought along 'x'. More...
void	translate (double, double, double)
	performs a translation More...
void	translate (double d[3])
void	scale (double, double, double)
	performs scaling More...
void	scale (double f)
void	window (double, double, double, double, double, double)
	sets this matrix to represent a window perspective More...
void	ortho (double, double, double, double, double, double)
	sets this matrix to a 3D orthographic matrix More...
void	ortho2 (double, double, double, double)
	sets this matrix to a 2D orthographic matrix More...
void	lookat (double, double, double, double, double, double, short)

Public Attributes
double	mat [16]
	the matrix itself More...

Detailed Description

4x4 matrix class with numerous operators, conversions, etc.

Definition at line 26 of file Matrix4.h.

Constructor & Destructor Documentation

Matrix4() [1/4]

Matrix4::Matrix4 ( void  )

inline

identity constructor

Definition at line 28 of file Matrix4.h.

References identity().

Matrix4() [2/4]

Matrix4::Matrix4 ( double  f )

inline

const elements constructor

Definition at line 29 of file Matrix4.h.

References constant().

Matrix4() [3/4]

Matrix4::Matrix4

(

const double *

m

)

construct from double array

Definition at line 36 of file Matrix4.C.

References mat.

                                {
  memcpy((void *)mat, (const void *)m, 16*sizeof(double));
}

Matrix4() [4/4]

Matrix4::Matrix4 ( const Matrix4 &  m )

inline

copy constructor

Definition at line 31 of file Matrix4.h.

References loadmatrix().

~Matrix4()

Matrix4::~Matrix4 ( void  )

inline

destructor

Definition at line 32 of file Matrix4.h.

Member Function Documentation

constant()

void Matrix4::constant

(

double

f

)

sets the matrix so all items are the given constant value

Definition at line 102 of file Matrix4.C.

References mat.

Referenced by lookat(), Matrix4(), ortho(), ortho2(), and window().

                               {
  for (int i=0; i<16; mat[i++] = f); 
}

identity()

void Matrix4::identity

(

void

)

clears the matrix (resets it to identity)

Definition at line 92 of file Matrix4.C.

References mat.

Referenced by Matrix4().

                           {
  memset((void *)mat, 0, 16*sizeof(double));
  mat[0]=1.0;
  mat[5]=1.0;
  mat[10]=1.0;
  mat[15]=1.0;
}

inverse()

int Matrix4::inverse

(

void

)

inverts the matrix, that is, the inverse of the rotation, the inverse of the scaling, and the opposite of the translation vector. returns 0 if there were no problems, -1 if the matrix is singular

Definition at line 110 of file Matrix4.C.

References mat, and MATSWAP.

                         {

  double matr[4][4], ident[4][4];
  int i, j, k, l, ll;
  int icol=0, irow=0;
  int indxc[4], indxr[4], ipiv[4];
  double big, dum, pivinv, temp;
 
  for (i=0; i<4; i++) {
    for (j=0; j<4; j++) {
      matr[i][j] = mat[4*i+j];
      ident[i][j] = 0.0;
    }
    ident[i][i]=1.0;
  } 
  // Gauss-jordan elimination with full pivoting.  Yes, folks, a 
  // GL Matrix4 is inverted like any other, since the identity is 
  // still the identity.
  
  // from numerical recipies in C second edition, pg 39

  for(j=0;j<=3;j++) ipiv[j] = 0;
  for(i=0;i<=3;i++) {
    big=0.0;
    for (j=0;j<=3;j++) {
      if(ipiv[j] != 1) {
        for (k=0;k<=3;k++) {
          if(ipiv[k] == 0) {
            if(fabs(matr[j][k]) >= big) {
              big = (double) fabs(matr[j][k]);
              irow=j;
              icol=k;
            }
          } else if (ipiv[k] > 1) return 1;
        } 
      }
    }
    ++(ipiv[icol]);
    if (irow != icol) {
      for (l=0;l<=3;l++) MATSWAP(matr[irow][l],matr[icol][l]);
      for (l=0;l<=3;l++) MATSWAP(ident[irow][l],ident[icol][l]);
    }
    indxr[i]=irow;
    indxc[i]=icol;
    if(matr[icol][icol] == 0.0) return 1; 
    pivinv = 1.0 / matr[icol][icol];
    matr[icol][icol]=1.0;
    for (l=0;l<=3;l++) matr[icol][l] *= pivinv;
    for (l=0;l<=3;l++) ident[icol][l] *= pivinv;
    for (ll=0;ll<=3;ll++) {
      if (ll != icol) {
        dum=matr[ll][icol];
        matr[ll][icol]=0.0;
        for (l=0;l<=3;l++) matr[ll][l] -= matr[icol][l]*dum;
        for (l=0;l<=3;l++) ident[ll][l] -= ident[icol][l]*dum;
      }
    }
  }
  for (l=3;l>=0;l--) {
    if (indxr[l] != indxc[l]) {
      for (k=0;k<=3;k++) {
        MATSWAP(matr[k][indxr[l]],matr[k][indxc[l]]);
      }
    }
  }
  for (i=0; i<4; i++) 
    for (j=0; j<4; j++)
      mat[4*i+j] = matr[i][j];
  return 0;
}

loadmatrix()

void Matrix4::loadmatrix

(

const Matrix4 &

m

)

replaces this matrix with the given one

Definition at line 194 of file Matrix4.C.

References mat.

Referenced by Matrix4(), and operator=().

                                         {
  memcpy((void *)mat, (const void *)m.mat, 16*sizeof(double));
}

lookat()

void Matrix4::lookat	(	double	vx,
		double	vy,
		double	vz,
		double	px,
		double	py,
		double	pz,
		short	twist
	)

This subroutine defines a viewing transformation with the eye at point (vx,vy,vz) looking at the point (px,py,pz). Twist is the right-hand rotation about this line. The resultant matrix is multiplied with the top of the transformation stack and then replaces it. Precisely, lookat does: lookat=trans(-vx,-vy,-vz)*rotate(theta,y)*rotate(phi,x)*rotate(-twist,z)

Definition at line 336 of file Matrix4.C.

References constant(), mat, multmatrix(), rot(), and translate().

                                                 {
  Matrix4 m(0.0);
  double tmp;

  /* pre multiply stack by rotate(-twist,z) */
  rot(-twist / 10.0,'z');

  tmp = sqrtf((px-vx)*(px-vx) + (py-vy)*(py-vy) + (pz-vz)*(pz-vz));
  m.mat[0] = 1.0;
  m.mat[5] = sqrtf((px-vx)*(px-vx) + (pz-vz)*(pz-vz)) / tmp;
  m.mat[6] = (vy-py) / tmp;
  m.mat[9] = -m.mat[6];
  m.mat[10] = m.mat[5];
  m.mat[15] = 1.0;
  multmatrix(m);

  /* premultiply by rotate(theta,y) */
  m.constant(0.0);
  tmp = sqrtf((px-vx)*(px-vx) + (pz-vz)*(pz-vz));
  m.mat[0] = (vz-pz) / tmp;
  m.mat[5] = 1.0;
  m.mat[10] = m.mat[0];
  m.mat[15] = 1.0;
  m.mat[2] = -(px-vx) / tmp;
  m.mat[8] = -m.mat[2];
  multmatrix(m);

  /* premultiply by trans(-vx,-vy,-vz) */
  translate(-vx,-vy,-vz);
}

multmatrix()

void Matrix4::multmatrix

(

const Matrix4 &

m

)

premultiply the matrix by the given matrix, this->other * this

Definition at line 199 of file Matrix4.C.

References mat.

Referenced by lookat(), rot(), scale(), and translate().

                                         {
  double tmp[4];
  for (int j=0; j<4; j++) {
    tmp[0] = mat[j];
    tmp[1] = mat[4+j];
    tmp[2] = mat[8+j]; 
    tmp[3] = mat[12+j];
    for (int i=0; i<4; i++) {
      mat[4*i+j] = m.mat[4*i]*tmp[0] + m.mat[4*i+1]*tmp[1] +
        m.mat[4*i+2]*tmp[2] + m.mat[4*i+3]*tmp[3]; 
    }
  } 
}

multnorm3d()

void Matrix4::multnorm3d	(	const double	onorm[3],
		double	nnorm[3]
	)		const

multiplies a 3D norm (first arg) by the Matrix, returns in second arg

Definition at line 68 of file Matrix4.C.

References mat.

                                                                     {
  double tmp[4];

  tmp[0]=onorm[0]*mat[0] + onorm[1]*mat[4] + onorm[2]*mat[8];
  tmp[1]=onorm[0]*mat[1] + onorm[1]*mat[5] + onorm[2]*mat[9];
  tmp[2]=onorm[0]*mat[2] + onorm[1]*mat[6] + onorm[2]*mat[10];
  tmp[3]=onorm[0]*mat[3] + onorm[1]*mat[7] + onorm[2]*mat[11];
  double itmp = 1.0 / sqrtf(tmp[0]*tmp[0] + tmp[1]*tmp[1] + tmp[2]*tmp[2]);
  nnorm[0]=tmp[0]*itmp;
  nnorm[1]=tmp[1]*itmp;
  nnorm[2]=tmp[2]*itmp;
}

multpoint3d()

void Matrix4::multpoint3d	(	const double	opoint[3],
		double	npoint[3]
	)		const

multiplies a 3D point (first arg) by the Matrix, returns in second arg

Definition at line 41 of file Matrix4.C.

References mat.

                                                                        {
#if 0
    // should try re-testing this formulation to see if it outperforms
    // the old one, without introducing doubleing point imprecision
    double tmp[3];
    double itmp3 = 1.0 / (opoint[0]*mat[3] + opoint[1]*mat[7] + 
                          opoint[2]*mat[11] + mat[15]);
    npoint[0]=itmp3 * (opoint[0]*mat[0] + opoint[1]*mat[4] + opoint[2]*mat[ 8] + mat[12]);
    npoint[1]=itmp3 * (opoint[0]*mat[1] + opoint[1]*mat[5] + opoint[2]*mat[ 9] + mat[13]);
    npoint[2]=itmp3 * (opoint[0]*mat[2] + opoint[1]*mat[6] + opoint[2]*mat[10] + mat[14]);
#else
    double tmp[3];
    double itmp3 = 1.0 / (opoint[0]*mat[3] + opoint[1]*mat[7] +
                          opoint[2]*mat[11] + mat[15]);
    tmp[0] = itmp3*opoint[0];
    tmp[1] = itmp3*opoint[1];
    tmp[2] = itmp3*opoint[2];
    npoint[0]=tmp[0]*mat[0] + tmp[1]*mat[4] + tmp[2]*mat[ 8] + itmp3*mat[12];
    npoint[1]=tmp[0]*mat[1] + tmp[1]*mat[5] + tmp[2]*mat[ 9] + itmp3*mat[13];
    npoint[2]=tmp[0]*mat[2] + tmp[1]*mat[6] + tmp[2]*mat[10] + itmp3*mat[14];
#endif
}

multpoint4d()

void Matrix4::multpoint4d	(	const double	opoint[4],
		double	npoint[4]
	)		const

multiplies a 4D point (first arg) by the Matrix, returns in second arg

Definition at line 83 of file Matrix4.C.

References mat.

                                                                        {
  npoint[0]=opoint[0]*mat[0]+opoint[1]*mat[4]+opoint[2]*mat[8]+opoint[3]*mat[12];
  npoint[1]=opoint[0]*mat[1]+opoint[1]*mat[5]+opoint[2]*mat[9]+opoint[3]*mat[13];
  npoint[2]=opoint[0]*mat[2]+opoint[1]*mat[6]+opoint[2]*mat[10]+opoint[3]*mat[14];
  npoint[3]=opoint[0]*mat[3]+opoint[1]*mat[7]+opoint[2]*mat[11]+opoint[3]*mat[15];
}

operator=()

Matrix4& Matrix4::operator= ( const Matrix4 &  m )

inline

Definition at line 61 of file Matrix4.h.

References loadmatrix().

{loadmatrix(m); return *this;}

ortho()

void Matrix4::ortho	(	double	left,
		double	right,
		double	bottom,
		double	top,
		double	nearval,
		double	farval
	)

sets this matrix to a 3D orthographic matrix

Definition at line 303 of file Matrix4.C.

References constant(), and mat.

                                                                   {

  constant(0.0);                // initialize this matrix to 0
  mat[0] =  2.0 / (right-left);
  mat[5] =  2.0 / (top-bottom);
  mat[10] = -2.0 / (farval-nearval);
  mat[12] = -(right+left) / (right-left);
  mat[13] = -(top+bottom) / (top-bottom);
  mat[14] = -(farval+nearval) / (farval-nearval);
  mat[15] = 1.0;
}

ortho2()

void Matrix4::ortho2	(	double	left,
		double	right,
		double	bottom,
		double	top
	)

sets this matrix to a 2D orthographic matrix

Definition at line 318 of file Matrix4.C.

References constant(), and mat.

                                                                         {

  constant(0.0);                // initialize this matrix to 0
  mat[0] =  2.0 / (right-left);
  mat[5] =  2.0 / (top-bottom);
  mat[10] = -1.0;
  mat[12] = -(right+left) / (right-left);
  mat[13] = -(top+bottom) / (top-bottom);
  mat[15] =  1.0;
}

rot()

void Matrix4::rot	(	double	a,
		char	axis
	)

performs a left-handed rotation around an axis (char == 'x', 'y', or 'z')

Definition at line 215 of file Matrix4.C.

References DEGTORAD, mat, and multmatrix().

Referenced by lookat(), rotate_axis(), transvec(), and transvecinv().

                                     {
  Matrix4 m;                    // create identity matrix
  double angle;

  angle = (double)DEGTORAD(a);

  if (axis == 'x') {
    m.mat[0]=1.0;
    m.mat[5]=(double)cos(angle);
    m.mat[10]=m.mat[5];
    m.mat[6] = (double)sin(angle);
    m.mat[9] = -m.mat[6];
  } else if (axis == 'y') {
    m.mat[0] = (double)cos(angle);
    m.mat[5] = 1.0;
    m.mat[10] = m.mat[0];
    m.mat[2] = (double) -sin(angle);
    m.mat[8] = -m.mat[2];
  } else if (axis == 'z') {
    m.mat[0] = (double)cos(angle);
    m.mat[5] = m.mat[0];
    m.mat[10] = 1.0;
    m.mat[1] = (double)sin(angle);
    m.mat[4] = -m.mat[1];
  }
  // If there was an error, m is identity so we can multiply anyway.
  multmatrix(m);
}

rotate_axis()

void Matrix4::rotate_axis	(	const double	axis[3],
		double	angle
	)

apply a rotation around the given vector; angle in radians.

Definition at line 245 of file Matrix4.C.

References RADTODEG, rot(), transvec(), and transvecinv().

Referenced by obj_transabout().

                                                            {
  transvec(axis[0], axis[1], axis[2]);
  rot((double) (RADTODEG(angle)), 'x');
  transvecinv(axis[0], axis[1], axis[2]);
}

scale() [1/2]

void Matrix4::scale	(	double	x,
		double	y,
		double	z
	)

performs scaling

Definition at line 279 of file Matrix4.C.

References mat, and multmatrix().

                                                {
  Matrix4 m;            // create identity matrix
  m.mat[0] = x;
  m.mat[5] = y;
  m.mat[10] = z;
  multmatrix(m);
}

scale() [2/2]

void Matrix4::scale ( double  f )

inline

Definition at line 84 of file Matrix4.h.

References scale().

Referenced by scale().

{ scale(f, f, f); }

translate() [1/2]

void Matrix4::translate	(	double	x,
		double	y,
		double	z
	)

performs a translation

Definition at line 270 of file Matrix4.C.

References mat, and multmatrix().

Referenced by lookat().

                                                    {
  Matrix4 m;            // create identity matrix
  m.mat[12] = x;
  m.mat[13] = y;
  m.mat[14] = z;
  multmatrix(m);
}

translate() [2/2]

void Matrix4::translate ( double  d[3] )

inline

Definition at line 80 of file Matrix4.h.

References translate().

Referenced by translate().

{ translate(d[0], d[1], d[2]); }

transpose()

void Matrix4::transpose

(

void

)

transposes the matrix

Definition at line 181 of file Matrix4.C.

References mat.

                        {
  double tmp[16];
  int i,j;
  for(i=0;i<4;i++) {
    for(j=0;j<4;j++) {
      tmp[4*i+j] = mat[i+4*j];
    }
  }
  for(i=0;i<16;i++)
    mat[i] = tmp[i];
}

transvec()

void Matrix4::transvec	(	double	x,
		double	y,
		double	z
	)

apply a rotation such that 'x' is brought along the given vector.

Definition at line 252 of file Matrix4.C.

References RADTODEG, and rot().

Referenced by obj_transvec(), and rotate_axis().

                                                   {
  double theta = atan2(y,x);
  double length = sqrt(y*y + x*x);
  double phi = atan2((double) z, length);
  rot((double) RADTODEG(theta), 'z');
  rot((double) RADTODEG(-phi), 'y');
}

transvecinv()

void Matrix4::transvecinv	(	double	x,
		double	y,
		double	z
	)

apply a rotation such that the given vector is brought along 'x'.

Definition at line 261 of file Matrix4.C.

References RADTODEG, and rot().

Referenced by obj_transvecinv(), and rotate_axis().

                                                      {
  double theta = atan2(y,x);
  double length = sqrt(y*y + x*x);
  double phi = atan2((double) z, length);
  rot((double) RADTODEG(phi), 'y');
  rot((double) RADTODEG(-theta), 'z');
}

window()

void Matrix4::window	(	double	left,
		double	right,
		double	bottom,
		double	top,
		double	nearval,
		double	farval
	)

sets this matrix to represent a window perspective

Definition at line 288 of file Matrix4.C.

References constant(), and mat.

                                                                    {

  constant(0.0);                // initialize this matrix to 0
  mat[0] = (2.0*nearval) / (right-left);
  mat[5] = (2.0*nearval) / (top-bottom);
  mat[8] = (right+left) / (right-left);
  mat[9] = (top+bottom) / (top-bottom);
  mat[10] = -(farval+nearval) / (farval-nearval);
  mat[11] = -1.0;
  mat[14] = -(2.0*farval*nearval) / (farval-nearval);
}

Member Data Documentation

mat

double Matrix4::mat[16]

the matrix itself

Definition at line 33 of file Matrix4.h.

Referenced by constant(), identity(), inverse(), loadmatrix(), lookat(), Matrix4(), multmatrix(), multnorm3d(), multpoint3d(), multpoint4d(), obj_transabout(), obj_transvec(), obj_transvecinv(), ortho(), ortho2(), print_Matrix4(), rot(), scale(), trans_from_rotate(), translate(), transpose(), and window().

---

The documentation for this class was generated from the following files:

• Matrix4.h
• Matrix4.C