---

transf3d.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef AMOD_MATH_LIB_INCTRANSF3D_H
#define AMOD_MATH_LIB_INCTRANSF3D_H

// DESCRIPTION:
//
// Declaration of class transf3d representing a general affine or projective 
// transformation in 3D space. The transform is represented by a 4x4 matrix,
// the last row being the projective coefficients and are set to (0,0,0,1) for 
// affine transformations.
//
// To transform a point or a vector, PREmultiply it by a transf3d matrix.
//

#include "point3d.H"
#include "line3d.H"

typedef Greal RAWmat[4][4];

template <class T, class P, class V, class L, class Q>
class _transf3d
{
protected:
    Greal _c[4][4];
    int    _perspective;

public:

    // The constructor creates an identity transform.
    //
    inline _transf3d() {
       _c[0][1] = _c[0][2] = _c[0][3] = _c[1][0] = _c[1][2] = _c[1][3] = 
       _c[2][0] = _c[2][1] = _c[2][3] = _c[3][0] = _c[3][1] = _c[3][2] = 0.0;
       _c[0][0] = _c[1][1] = _c[2][2] = _c[3][3] = 1;
       // isError = false;
       _perspective = 0;
    }

    // The constructor creates a rigid motion transform from an origin and 
    // directions of x, y and z axes.
    //
    _transf3d(const P&  origin, 
              const V&    xDir, 
              const V&    yDir, 
              const V&    zDir);

    // The constructor creates a linear map (no translation)
    // whose columns are the given vectors
    //
    _transf3d(const V&    col0, 
              const V&    col1, 
              const V&    col2);

    // The constructor creates a rigid motion transform from an origin and 
    // direction of x and y axis. If yDir is not perpendicular to xDir, yDir
    // will be adjusted.
    //
    _transf3d(const P&  origin, 
              const V&    xDir, 
              const V&    yDir);

    // The constructor creates a rigid motion transform from an origin 
    // (axis.point) and the direction of the z axis (axis.vector). The 
    // directions of the x and y axes are determined according to the 
    // AutoCAD's arbitrary axis algorithm.
    //
    _transf3d(const L& axis);

    // The constructor creates a rigid motion transform from an origin. The
    // x, y and z axis are aligned with the world x, y and z axis.
    //
    _transf3d(const P& origin);

    Greal& operator ()(int i1, int i2)       { return _c[i2][i1]; }
    Greal  operator ()(int i1, int i2) const { return _c[i2][i1]; }

    void    set_perspective(int p)  { _perspective = p;   }
    int     perspective()     const { return _perspective;}

    V        get_scale()const{return V(X().length(),Y().length(),Z().length());}
    void     getCoordSystem(P& o, V& x, V& y, V& z) const
                             { x = X(); y = Y(); z = Z(); o = origin(); }

    V        X()      const  { return V(_c[0][0],_c[0][1], _c[0][2]); }
    V        Y()      const  { return V(_c[1][0],_c[1][1], _c[1][2]); }
    V        Z()      const  { return V(_c[2][0],_c[2][1], _c[2][2]); }
    P        origin() const  { return P(_c[3][0],_c[3][1], _c[3][2]); }
    Greal  *matrix() const  { return (Greal *)_c; }
    void     vals(RAWmat &d, bool row=true) const 
                             { for (int i=0; i<4; i++)
                                  for (int j=0; j<4; j++)
                                     if (row)
                                          d[i][j] = _c[i][j];
                                     else d[j][i] = _c[i][j]; }

    // returns the rotation part of the transform
    T        rotation() const { return T(P(0,0,0), X(), Y(), Z()); }
    
    // Create special transformations
    //
    static T rotation   (const  Q& quat);
    static T rotation   (const  L& axis,    Greal   angle);
    static T rotation   (const  V& axis,    Greal   angle);
    static T shear      (const  V& normal,  const V& shearVec);
    static T scaling    (const  P& fixedPt, Greal   factor);
    static T scaling    (const  P& fixedPt, const V& xyzFactors);
    static T scaling    (const  V& xyzFactors);
    static T scaling    (Greal    factor);
    static T stretching (const  L& axis);
    static T translation(const  V&);

    // The transformation maps points as follows:
    //
    // point  src1             maps to point  dst1
    // vec    (src1,src2)      maps to vector (dst1,dst2)
    // plane  (src1,src2,src3) maps to plane  (dst1,dst2,dst3)
    //
    static T align(const P& src1, const P& src2, const P& src3,
                   const P& dst1, const P& dst2, const P& dst3);

    // The transformation maps points and vectors as follows:
    //
    // point  src1             maps to point  dst1
    // vec src2             maps to vector dst2
    // plane  (src1,src2,src3) maps to plane  (dst1,dst2,dst3)
    //
    static T align(const P&  src1, const V& src2, const V& src3,
                   const P&  dst1, const V& dst2, const V& dst3);

    static T align(const P&  src1, const V&    src2,
                   const P&  dst1, const V&    dst2);

    static T alignAndScale(const P& o, const V& x, const V& y, const V& z);

    T        transpose      ()          const;
    T        unscaled       ()          const;
    T        normalize_basis()          const;
    T        orthogonalize  ()          const;
    T        invert         ()          const;
    T        derivative(const P&)       const;

    bool     isValid                 () const;
    bool     isIdentity              () const;
    bool     isOrthogonal            () const;  // No shear
    bool     isEqualScalingOrthogonal() const;  // No shear, no nonequal scaling

    int operator != (const T &m) const { return !(*this == m); }
    int operator == (const T &m) const {
       return origin() == m.origin() &&
              X()      == m.X() &&
              Y()      == m.Y() &&
              Z()      == m.Z();
    }

}; // class transf3d

//
// ------------------- inline templated operators --------------
//

#define TPVLQ template <class T,class P,class V, class L, class Q>
TPVLQ ostream &operator <<(ostream &os, const _transf3d<T,P,V,L,Q> &x); 
TPVLQ istream &operator >>(istream &os,       _transf3d<T,P,V,L,Q> &x); 
TPVLQ T operator *(const _transf3d<T,P,V,L,Q> &, const _transf3d<T,P,V,L,Q>&);
TPVLQ P operator *(const _transf3d<T,P,V,L,Q> &, const _point3d<P,V> &);
TPVLQ V operator *(const _transf3d<T,P,V,L,Q> &, const _vec3d<V> &);
TPVLQ L operator *(const _transf3d<T,P,V,L,Q> &, const _line<L,P,V> &);
#undef TPVLQ

#ifdef GLUE_NEEDS_TEMPLATES_IN_H_FILE
#include "transf3d.C"
#endif

#endif

---