---

gul_matrix.h

Go to the documentation of this file.

/* LIBGUL - Geometry Utility Library
 * Copyright (C) 1998-1999 Norbert Irmer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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 GUL_MATRIX_H
#define GUL_MATRIX_H

namespace gul {

template< class T >
mat4x4<T> operator*( mat4x4<T> a, mat4x4<T> b )
{
  int i,j,k;
  mat4x4<T> c;
  T sum;
  
  for( i = 0; i < 4; i++)
  {
    for( j =0; j < 4; j++)
    {
      sum = (T)0.0;

      for( k = 0; k < 4; k++)
        sum += a[i][k]*b[k][j];

      c[i][j] = sum;
    }
  }    
  return c;
}

template< class T, class T2 >
void MCopy( int m, int n, const Ptr< Ptr<T2> >& A, Ptr< Ptr<T> >& C )
{
  int i,j;
  
  for( i = 0; i < m; i++)
    for( j =0; j < n; j++)
      C[i][j] = (T)A[i][j];  
}
template< class T, class T2 >
void MCopy( int m, int n, const Ptr< Ptr<T2> >& A, Ptr<T>& C )
{
  int i,j;
  
  for( i = 0; i < m; i++)
    for( j =0; j < n; j++)
      C[i*n+j] = (T)A[i][j];  
}
template< class T, class T2 >
void MCopy( int m, int n, const Ptr<T2>& A, Ptr< Ptr<T> >& C )
{
  int i,j;
  
  for( i = 0; i < m; i++)
    for( j =0; j < n; j++)
      C[i][j] = (T)A[i*n+j];  
}


template< class T >
void MMProduct( int r, int s, int t, 
                Ptr< Ptr<T> >& A, Ptr< Ptr<T> >& B, Ptr< Ptr<T> >& C )
{
  int i,j,k;
  T sum;
  
  for( i = 0; i < r; i++)
  {
    for( j =0; j < t; j++)
    {
      sum = (T)0.0;

      for( k = 0; k < s; k++)
        sum += A[i][k]*B[k][j];

      C[i][j] = sum;
    }
  }    
}

template< class T >
void MMProduct( int r, int s, int t, Ptr<T>& A, Ptr<T>& B, Ptr<T>& C )
{
  int i,j,k;
  T sum;
  
  for( i = 0; i < r; i++)
  {
    for( j =0; j < t; j++)
    {
      sum = (T)0.0;

      for( k = 0; k < s; k++)
        sum += A[i*s+k]*B[k*t+j];

      C[i*t+j] = sum;
    }
  }    
}


template< class T >
vec4<T> operator*( mat4x4<T> a, vec4<T> b )
{
  int i,k;
  vec4<T> c;
  T sum;
  
  for( i = 0; i < 4; i++)
  {
    sum = (T)0.0;

    for( k = 0; k < 4; k++)
      sum += a[i][k]*b[k];

    c[i] = sum;
  }
  return c;
}

template< class T >
void MVProduct( int n, int m, Ptr< Ptr<T> >& A, Ptr<T>& x, Ptr<T>& b )
{
  int i,k;
  T sum;
  
  for( i = 0; i < n; i++)
  {
    sum = (T)0.0;

    for( k = 0; k < m; k++)
      sum += A[i][k]*x[k];

    b[i] = sum;
  }
}

template< class T >
void VMProduct( int n, int m, const Ptr<T>& x, const Ptr< Ptr<T> >& A, Ptr<T>& b )
{
  int i,k;
  T sum;
  
  for( i = 0; i < m; i++)
  {
    sum = (T)0.0;

    for( k = 0; k < n; k++)
      sum += x[k]*A[k][i];

    b[i] = sum;
  }
}

template< class T >
void VMProduct( int n, int m, const Ptr<T>& x, const Ptr<T>& A, Ptr<T>& b )
{
  int i,k;
  T sum;
  
  for( i = 0; i < m; i++)
  {
    sum = (T)0.0;

    for( k = 0; k < n; k++)
      sum += x[k]*A[k*m+i];

    b[i] = sum;
  }
}


template< class T >
vec4<T> operator*( vec4<T> b, mat4x4<T> a )
{
  int i,k;
  vec4<T> c;
  T sum;
  
  for( i = 0; i < 4; i++)
  {
    sum = (T)0.0;

    for( k = 0; k < 4; k++)
      sum += b[k] * a[k][i];

    c[i] = sum;
  }
  return c;
}

template< class T >
void CubeVerts( const T& xmin, const T& xmax,
                const T& ymin, const T& ymax,
                const T& zmin, const T& zmax,
                vec4<T> *v )
{
  v[0][0] = xmin;
  v[0][1] = ymin;
  v[0][2] = zmin;
  v[0][3] = (T)1.0;

  v[1][0] = xmax;
  v[1][1] = ymin;
  v[1][2] = zmin;
  v[1][3] = (T)1.0;

  v[2][0] = xmax;
  v[2][1] = ymax;
  v[2][2] = zmin;
  v[2][3] = (T)1.0;

  v[3][0] = xmin;
  v[3][1] = ymax;
  v[3][2] = zmin;
  v[3][3] = (T)1.0;


  v[4][0] = xmin;
  v[4][1] = ymin;
  v[4][2] = zmax;
  v[4][3] = (T)1.0;

  v[5][0] = xmax;
  v[5][1] = ymin;
  v[5][2] = zmax;
  v[5][3] = (T)1.0;

  v[6][0] = xmax;
  v[6][1] = ymax;
  v[6][2] = zmax;
  v[6][3] = (T)1.0;

  v[7][0] = xmin;
  v[7][1] = ymax;
  v[7][2] = zmax;
  v[7][3] = (T)1.0;
}

template< class T >
void CubeVerts( const T& xmin, const T& xmax,
                const T& ymin, const T& ymax,
                const T& zmin, const T& zmax,
                point<T> *v )
{
  v[0].x = xmin;
  v[0].y = ymin;
  v[0].z = zmin;

  v[1].x = xmax;
  v[1].y = ymin;
  v[1].z = zmin;

  v[2].x = xmax;
  v[2].y = ymax;
  v[2].z = zmin;

  v[3].x = xmin;
  v[3].y = ymax;
  v[3].z = zmin;

  v[4].x = xmin;
  v[4].y = ymin;
  v[4].z = zmax;

  v[5].x = xmax;
  v[5].y = ymin;
  v[5].z = zmax;

  v[6].x = xmax;
  v[6].y = ymax;
  v[6].z = zmax;

  v[7].x = xmin;
  v[7].y = ymax;
  v[7].z = zmax;
}

template< class T >
void CubeVerts( const Ptr<T>& bb, Ptr< point<T> >& v )
{
  CubeVerts<T>( bb[0], bb[1], bb[2], bb[3], bb[4], bb[5], &v[0] );
}



}

#endif

---