glfMatrix.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS 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 BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef __glfMatrix_hh__
#define __glfMatrix_hh__

#include "glfCommon.hh"
#include <Base/Math/Matrix3x3.hh>
#include <Base/Math/Matrix4x4.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <Base/Math/Utils.hh>

namespace BIAS {

  /**
   * \brief A 4x4 matrix in native OpenGL format.
   * \ingroup g_openglframework
   * \author jkollmann
   */
  class BIASOpenGLFramework_EXPORT glfMatrix {
  public:

    /**
     * The constructor leaves the matrix undefined!
     */
    glfMatrix();

    /**
     * Constructor that initializes the entries of the matrix.
     */
    glfMatrix(GLfloat m0, GLfloat m1, GLfloat m2, GLfloat m3,
              GLfloat m4, GLfloat m5, GLfloat m6, GLfloat m7,
              GLfloat m8, GLfloat m9, GLfloat m10, GLfloat m11,
              GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15);
    
    virtual ~glfMatrix() {}

    /**
     * \name Initialization methods similar to glIdentity, glRotate etc.
     */
    //@{
    void MakeIdentity();
    void MakeRotation(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
    void MakeTranslation(GLfloat x, GLfloat y, GLfloat z);
    void MakeScalation(GLfloat x, GLfloat y, GLfloat z);
    void MakeFrustum(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat nearVal, GLfloat farVal);
    void MakeOrtho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat nearVal, GLfloat farVal);
    void MakePerspective(GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar);
    void MakeLookAt(GLfloat eyeX, GLfloat eyeY, GLfloat eyeZ,
                    GLfloat centerX, GLfloat centerY, GLfloat centerZ,
                    GLfloat upX, GLfloat upY, GLfloat upZ);
    //@}

    static unsigned int Matrix2DIndexToRep(unsigned int row, unsigned int column);
    
    /**
     * Initializes the glf matrix from a BIAS matrix.
     */
    //@{
    void Make(const Matrix4x4<float>& a);
    void Make(const Matrix4x4<double>& a);
    //@}

    /**
     * Initializes the render matrix as an affine mapping.
     */
    //@{
    void MakeAffine(const Matrix3x3<float>& r, const Vector3<float>& t);
    void MakeAffine(const Matrix3x3<double>& r, const Vector3<double>& t);
    //@}

    /**
     * Computes the inverse of the matrix, assuming it is an affine transformation
     * with an orthonormal linear part.
     */
    void MakeAffineInverse(const glfMatrix& a);

    /**
     * Conversion from <code>ProjectionParametersPerspective</code>.
     */
    //@{
    /** \param flip has to be used if a gl rendered texture is used but 
     *  BIAS ProjectionParameters, since up and down interpretation is
     *  the other way around (got it?). flip does not have to be true
     *  if an BIAS image is uploaded without a previous call to 
     *  BIAS::ImageBase::Flip(). (However it afterall depends on what you want to
     *  achieve!)
     */
    void MakeTextureMatrix(const ProjectionParametersPerspective& params,
                           bool flip = false);
    void MakeViewMatrix(const ProjectionParametersBase& params);
    void MakeViewMatrixNew(const ProjectionParametersBase& params);
    void MakeProjectionMatrix(const ProjectionParametersPerspective& params,
                              GLfloat nearZZ, GLfloat farZ, bool useIdealK = false);
    void MakeProjectionMatrix(ProjectionParametersPerspective params,
                              GLfloat nearZ, GLfloat farZ,
                              unsigned int x0, unsigned int y0,
                              unsigned int width, unsigned int height, 
                              bool useIdealK = false);
    void MakeProjectionMatrixNew(const ProjectionParametersPerspective& params,
                                 GLfloat nearZ, GLfloat farZ,
                                 unsigned int x0, unsigned int y0,
                                 unsigned int width, unsigned int height,
                                 bool useIdealK = false, bool flip = false);
    void MakeProjectionMatrixNew(const ProjectionParametersPerspective& params,
                                 GLfloat nearZ, GLfloat farZ, bool flip = false);
    void MakeTextureMatrixNew(const ProjectionParametersPerspective& params, bool flip);
    //@}

    /**
     * Transforms a point by the matrix.
     */
    //@{
    void TransformPoint(const Vector3<float>& in, Vector3<float>& out) const;
    void TransformPoint(const Vector3<double>& in, Vector3<double>& out) const;
    //@}

    /**
     * \name Matrix multiplications.
     */
    //@{
    void Multiply(const glfMatrix& a);
    void operator*=(const glfMatrix& a);
    glfMatrix operator*(const glfMatrix& a);
    void Multiply(Vector4<float> vIn, Vector4<float>& vOut);
    void Multiply(Vector4<double> vIn, Vector4<double>& vOut);
    //@}

    /**
     * Loads the matrix in OpenGL.
     */
    virtual void Load() const;

    /**
     * The identity matrix.
     */
    static const glfMatrix IDENTITY;

    inline friend std::ostream& operator<<(std::ostream& s, const glfMatrix& m) 
    {
      for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
          s << m.m[i+j*4] << " ";
        }
        s << std::endl;
      }
      return s;
    }

    const GLfloat* GetArray() const { return m; }

  private:
    GLfloat m[16];
  };
  
} // namespace BIAS

#endif // __glfMatrix_hh__