base/Transform

Go to the documentation of this file.

/* **-*-c++-*-**************************************************************
  Copyright (C)1996 David Jung <opensim@pobox.com>

  This program/file is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 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 General Public License for more details. (http://www.gnu.org)
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  $Id: Transform 1029 2004-02-11 20:45:54Z jungd $
  $Revision: 1.3 $
  $Date: 2004-02-11 15:45:54 -0500 (Wed, 11 Feb 2004) $
  $Author: jungd $
 
****************************************************************************/

#ifndef _BASE_TRANSFORM_
#define _BASE_TRANSFORM_

#include <base/base>
#include <base/Matrix4>
#include <base/Orient>
#include <base/Quat4>
#include <base/Point4>


namespace base {

//
// A 3D geometric transformation 
//

class Transform
{

public:
  Transform() : isIdentity(true) {}
  explicit Transform(const Vector3& translation);
  Transform(const Orient& rotation);
  Transform(const Quat4& rotation);
  Transform(const Matrix3& rotation);
  Transform(const Vector3& translation, const Orient& rotation);
  Transform(const Vector3& translation, const Quat4& rotation);
  Transform(const Vector3& translation, const Matrix3& rotation);
  Transform(const Matrix4& t);
  Transform(const Transform& tr);
  ~Transform() {}

  Transform& operator=(const Transform& t);
  
  bool operator==(const Transform& rhs) const;
  bool equals(const Transform& rhs, Real epsilon = consts::epsilon) const throw();
 

  Matrix4 getTransform() const;

  void setIdentity() { isIdentity=true; }
  void setToRotation(const Vector3& axis, Real angle);
  void setToRotation(const Quat4& orient);
  void setRotationComponent(const Vector3& axis, Real angle);
  void setRotationComponent(const Quat4& orient);
  void setRotationComponent(const Orient& orient);
  void setRotationComponent(const Matrix3& rotation);
  void setToTranslation(const Vector3& trans);
  void setTranslationComponent(const Vector3& trans);
  void setTransform(const Matrix4& m);

  const Vector3& getTranslation() const;
  const Orient& getRotation() const;

  bool identity() const;
  bool isTransRotationOnly() const;
  bool containsRotation() const;
  bool containsTranslation() const;

  Transform& invert(); ///< inverse transformation

  void transformPoint(Point3& p) const;
  void transformPoint(Point4& p) const;
  Point3 transform(const Point3& p) const;
  Point4 transform(const Point4& p) const;

  Point3 rotate(const Point3& p) const;
  Point3 translate(const Point3& p) const;

  Point3 operator()(const Point3& p) const 
    { Point3 ret(p); transform(ret); return ret; }

  Transform& operator*=(const Transform& rhs);

protected:

  bool isIdentity;                 ///< identity transform
  bool isPureTranslationRotation;  ///< is not an arbitrary transform in t
  bool hasTranslation;             ///< transform includes translation in trans (if not arbitrary)
  bool hasRotation;                ///< transform includes rotation in axis & angle (if not arbitrary)

  mutable Orient orient;
  mutable Vector3 trans;
  Matrix4 t;
};


// implementation


inline const Vector3& Transform::getTranslation() const
{
  if (isIdentity || (isPureTranslationRotation && !hasTranslation)) 
    trans.setZero();

  if (!isPureTranslationRotation)
    trans = Vector3(t.e(1,4),t.e(2,4),t.e(3,4));

  return trans;
}

inline const Orient& Transform::getRotation() const
{
  if (isIdentity || (isPureTranslationRotation && !hasRotation)) 
    orient.setIdentity();

  if (!isPureTranslationRotation)
    orient.setFromRotationComponent(t);

  return orient;
}

inline bool Transform::identity() const 
{
  return isIdentity;
}

inline bool Transform::isTransRotationOnly() const
{
  return isIdentity || isPureTranslationRotation;
}

inline bool Transform::containsRotation() const
{
  return !isIdentity && ( (isPureTranslationRotation && hasRotation) || !isPureTranslationRotation);
}

inline bool Transform::containsTranslation() const
{
  return !isIdentity && ( (isPureTranslationRotation && hasTranslation) || !isPureTranslationRotation);
}



inline Point3 Transform::transform(const Point3& p) const
{
  Point3 r(p); transformPoint(r); return r;
}

inline Point4 Transform::transform(const Point4& p) const
{
  Point4 r(p); transformPoint(r); return r;
}



/*
inline void Transform::transform(Triangle3& t) const
{
  if (isIdentity) return;
  if (isPureTranslationRotation) {
    if (hasRotation) {
      t.setp1(orient.rotate(t.p1()));
      t.setp2(orient.rotate(t.p2()));
      t.setp3(orient.rotate(t.p3()));
    }
    if (hasTranslation) {
      t.setp1(t.p1()+trans);
      t.setp2(t.p2()+trans);
      t.setp3(t.p3()+trans);
    }
  }
  else {
    t.setp1(this->t*t.p1());
    t.setp2(this->t*t.p2());
    t.setp3(this->t*t.p3());
  }
  
}
*/


inline Transform operator*(const Transform& t1, const Transform& t2)
{
  Transform r(t1); r*=t2; return r;
}


inline Point3 operator*(const Transform& t, const Point3& p)
{
  return t.transform(p);
}

inline Point4 operator*(const Transform& t, const Point4& p)
{
  return t.transform(p);
}


inline Transform inverse(const Transform& t)
{
  Transform r(t); r.invert(); return r;
}


std::ostream& operator<<(std::ostream& out, const Transform& t); // Output


} // base

#endif

---