matrix.h - Hosted on DriveHQ Cloud IT Platform

Up
Upload
Download
Share
Publish
New Folder
New File
Copy
Cut
Delete
Paste
Rate
Upgrade
- Rotate
- Effect
- Edit
- Slide
- History
//=============================================================================
#ifndef MATRIX_H
#define MATRIX_H

#include "pointSet.h"


class vectorN;

class matrix3x3
{
public:
  matrix3x3() : valid_(true) {};
  matrix3x3( const matrix3x3 &src );
  matrix3x3( float a11, float a12, float a13,
	     float a21, float a22, float a23,
	     float a31, float a32, float a33 );
  
  float *operator[](int i) { return &m_[i*3]; }
  const float *operator[](int i) const { return &m_[i*3]; }
  const matrix3x3 &operator=( const matrix3x3 &src);
  matrix3x3 operator*( const matrix3x3 &src) const;
  point3D operator*( const point3D &src) const;
  
  matrix3x3 transpose() const;
  
  void setValidity( bool flag ) { valid_=flag; }
  bool isValid() const { return valid_; }
  
private:
  float m_[9];
  bool valid_;
};


class matrix4x3
{
public:
  matrix4x3() : valid_(true) {};
  matrix4x3( const matrix4x3 &src );
  matrix4x3( float a11, float a12, float a13,
	     float a21, float a22, float a23,
	     float a31, float a32, float a33,
	     float a41, float a42, float a43 );
  
  float *operator[](int i) { return &m_[i*3]; }
  const float *operator[](int i) const { return &m_[i*3]; }
  const matrix4x3 &operator=( const matrix4x3 &src);
  
  void setValidity( bool flag ) { valid_=flag; }
  bool isValid() const { return valid_; }

private:
  float m_[12];
  bool valid_;
};


class matrix3x4
{
public:
  matrix3x4() : valid_(true) {};
  matrix3x4( const matrix3x4 &src );
  matrix3x4( float a11, float a12, float a13, float a14,
	     float a21, float a22, float a23, float a24,
	     float a31, float a32, float a33, float a34 );
  
  void makeZero();
  void setLeft3x3( const matrix3x3 &src );
  
  float *operator[](int i) { return &m_[i*4]; }
  const float *operator[](int i) const { return &m_[i*4]; }
  const matrix3x4 &operator=( const matrix3x4 &src);
  point3D operator*( const point3D &p ) const;
  
  void setValidity( bool flag ) { valid_=flag; }
  bool isValid() const { return valid_; }

private:
  float m_[12];
  bool valid_;
};


class matrix4x4
{
public:
  matrix4x4() : valid_(true) {};
  matrix4x4( const matrix4x4 &src );
  matrix4x4( float a11, float a12, float a13, float a14,
	     float a21, float a22, float a23, float a24,
	     float a31, float a32, float a33, float a34,
	     float a41, float a42, float a43, float a44 );
  
  float *operator[](int i) { return &m_[i*4]; }
  const float *operator[](int i) const { return &m_[i*4]; }
  const matrix4x4 &operator=( const matrix4x4 &src);
  
  void setValidity( bool flag ) { valid_=flag; }
  bool isValid() const { return valid_; }

private:
  float m_[16];
  bool valid_;
};


class matrixMxN
{
public:
  matrixMxN( int m, int n );
  matrixMxN( const matrix3x3 &src );
  matrixMxN( const matrix4x3 &src );
  matrixMxN( const matrix3x4 &src );
  matrixMxN( const matrix4x4 &src );
  matrixMxN( const matrixMxN &src );
  ~matrixMxN();
  
  void makeZero();
  void setDiagonal( const vectorN &diag );
  matrix3x3 extractUpperLeft3x3() const;
  
  float *operator[](int i) { return m_[i]; }
  const float *operator[](int i) const  { return m_[i]; }
  matrixMxN operator*( const matrixMxN &m ) const;
  vectorN operator*( const vectorN &v ) const;
  const matrixMxN &operator=( const matrixMxN &src);

  matrixMxN transpose();
  
  int dimM() const { return dimM_; }
  int dimN() const { return dimN_; }
  void setValidity( bool flag ) { valid_=flag; }
  bool isValid() const { return valid_; }

  
private:
  float **m_;
  float *mBuf_;
  int dimN_, dimM_;
  bool valid_;
};


class vectorN
{
public:
  vectorN( int n );
  vectorN( const point3D &src );
  vectorN( const vectorN &src );
  ~vectorN();
  
  float &operator[](int i) { return v_[i]; }
  const float &operator[](int i) const { return v_[i]; }
  vectorN operator*( const matrixMxN &m ) const;
  float dot( const vectorN &v );
  const vectorN &operator=( const vectorN &src);
  
  int dim() const { return n_; }

  int smallestComponent();

private:
  float *v_;
  int n_;
};


inline
matrix3x3::matrix3x3( const matrix3x3 &src )
  : valid_(src.valid_)
{
  memcpy( m_,src.m_,sizeof(m_) );
}

inline
matrix4x3::matrix4x3( const matrix4x3 &src )
  : valid_(src.valid_)
{
  memcpy( m_,src.m_,sizeof(m_) );
}

inline
matrix3x4::matrix3x4( const matrix3x4 &src )
  : valid_(src.valid_)
{
  memcpy( m_,src.m_,sizeof(m_) );
}

inline
matrix4x4::matrix4x4( const matrix4x4 &src )
  : valid_(src.valid_)
{
  memcpy( m_,src.m_,sizeof(m_) );
}

inline const matrix3x3 &
matrix3x3::operator=( const matrix3x3 &src )
{
  valid_ = src.valid_;
  memcpy( m_,src.m_,sizeof(m_) );
  return *this;
}

inline const matrix4x3 &
matrix4x3::operator=( const matrix4x3 &src )
{
  valid_ = src.valid_;
  memcpy( m_,src.m_,sizeof(m_) );
  return *this;
}

inline const matrix3x4 &
matrix3x4::operator=( const matrix3x4 &src )
{
  valid_ = src.valid_;
  memcpy( m_,src.m_,sizeof(m_) );
  return *this;
}

inline const matrix4x4 &
matrix4x4::operator=( const matrix4x4 &src )
{
  valid_ = src.valid_;
  memcpy( m_,src.m_,sizeof(m_) );
  return *this;
}

inline 
vectorN::vectorN( int n )
  : n_(n)
{
  v_ = (float*)malloc( n_*sizeof(float) );
}

inline 
vectorN::vectorN( const vectorN &src )
  : n_(src.n_)
{
  v_ = (float*)malloc( n_*sizeof(float) );
  memcpy( v_, src.v_, n_*sizeof(float) );
}

inline const vectorN &
vectorN::operator=( const vectorN &src )
{
  memcpy( v_, src.v_, n_*sizeof(float) );
  return *this;
}
 
inline 
vectorN::vectorN( const point3D &src )
  : n_(3)
{
  v_ = (float*)malloc( n_*sizeof(float) );
  memcpy( v_, &src[0], n_*sizeof(float) );
}

inline 
vectorN::~vectorN()
{
  free(v_);
}

#endif // MATRIX_H
matrix.h
Page URL
File URL
Prev 21/50 Next
Download ( 5 KB )
Leading Cloud Surveillance, recording and storage service. IP camera remote viewing, live streaming, broadcasting
Leading Enterprise Cloud IT Service. Cloud File Server, Drive Mapping, FTP Hosting, Online Storage
Note: The DriveHQ service banners will NOT be displayed if the file owner is a paid member.
Comments
Total ratings: 0 Average rating:
Not Rated
Would you like to comment?

Join DriveHQ for a free account, or Logon if you are already a member.