transformation-matrix.hh

Go to the documentation of this file.

/*
 * lib-gmapkernel : Un noyau de 3-G-cartes et des opérations.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-gmapkernel
 *
 * This program 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

//******************************************************************************
#ifndef TRANSFORMATION_MATRIX_HH
#define TRANSFORMATION_MATRIX_HH
//******************************************************************************
#include "math-extension.hh"
#include "vertex.hh"
#include "inline-macro.hh"

#include <iostream>
//******************************************************************************

class CVector;

class CTransformationMatrix
{
private:
  TCoordinate FElements[4][4];

public:
  // @name Constantes
  // @{

  typedef enum { NullMatrix, IdentityMatrix, AnyMatrix } TMatrixType;

  // @}
  // @name Constructeurs et destructeur
  // @{

  CTransformationMatrix(TMatrixType AType = IdentityMatrix);

  CTransformationMatrix(const CTransformationMatrix& AMatrix);

  CTransformationMatrix(TCoordinate A00, TCoordinate A01,
            TCoordinate A02, TCoordinate A03,

            TCoordinate A10, TCoordinate A11,
            TCoordinate A12, TCoordinate A13,

            TCoordinate A20, TCoordinate A21,
            TCoordinate A22, TCoordinate A23,

            TCoordinate A30, TCoordinate A31,
            TCoordinate A32, TCoordinate A33);

  CTransformationMatrix(const CVertex& ALine1,
            const CVertex& ALine2,
            const CVertex& ALine3);

  ~CTransformationMatrix();

  // @}
  // @name Initialisations
  // @{

  void setToNull();

  void setToIdentity();

  CTransformationMatrix& operator=(const CTransformationMatrix& AMatrix);

  // @}
  // @name Accesseur aux éléments de la matrice
  // @{

  TCoordinate* operator[](int ARow) const;

  // @}
  // @name Fonctions mathématiques (produit, calcul de déterminant, ...)
  // @{

  CTransformationMatrix operator*(const CTransformationMatrix& AMatrix) const;

  CVector operator*(const CVector& AVector) const;

  // @}
  // @name Méthodes correspondant aux transformations géométriques
  // @{

  void translate(const CVertex& AVector);

  void rotate(const CVertex& AAxeDirection, TCoordinate AAngle);

  void rotate(const CVertex& AAxeVertex,
          const CVertex& AAxeDirection, TCoordinate AAngle);

  void rotate(const CVertex& AAngles);

  void rotate180(const CVertex& AAxeDirection);

  void scale(TCoordinate ACoef);

  void scale(const CVertex& ACoef);

  void scale(const CVertex& ACenter, TCoordinate ACoef);

  void scale(const CVertex& ACenter, const CVertex& ACoef);

  void axialScale(const CVertex& AAxeDirection, TCoordinate ACoef);

  void axialScale(const CVertex& AAxeVertex,
          const CVertex& AAxeDirection, TCoordinate ACoef);

  void planarScale(const CVertex& APlaneNormal, TCoordinate ACoef);

  void planarScale(const CVertex& APlaneVertex,
           const CVertex& APlaneNormal, TCoordinate ACoef);

  void orientate(const CVertex& AVector1, const CVertex& AVector2);

  void orientate(const CVertex& ACenter,
         const CVertex& AVector1, const CVertex& AVector2);

  void orientate(const CVertex& AVectorU1, const CVertex& AVectorV1,
         const CVertex& AVectorU2, const CVertex& AVectorV2);

  void transform(const CVertex& AOrigin1 ,
         const CVertex& AVectorU1, const CVertex& AVectorV1,
         const CVertex& AOrigin2 ,
         const CVertex& AVectorU2, const CVertex& AVectorV2,
         const CVertex& ACoef = CVertex(1,1,1));

  // @}
  // @name Application de la matrice sur un sommet
  // @{

  void applyOn(CVertex& AVertex) const;

  void applyOn(const CVertex& AVertex, CVertex& AResult) const;

  // @}
};

// @name Matrices de lissage
// @{

extern const CTransformationMatrix COONS     ;
extern const CTransformationMatrix HERMITE   ;
extern const CTransformationMatrix BEZIER    ;
extern const CTransformationMatrix OVERHAUSER;
extern const CTransformationMatrix SPLINE    ;

// @}
// @name Affichage
// @{

std::ostream& operator<<(std::ostream& AStream,
             const CTransformationMatrix& AMatrix);

// @}
//******************************************************************************
#include INCLUDE_INLINE("transformation-matrix.icc")
//******************************************************************************
#endif // TRANSFORMATION_MATRIX_HH
//******************************************************************************