transform.h

Go to the documentation of this file.

/*
 * Author: Steven Ludtke (sludtke@bcm.edu)
 * Copyright (c) 2000-2006 Baylor College of Medicine
 *
 * This software is issued under a joint BSD/GNU license. You may use the
 * source code in this file under either license. However, note that the
 * complete EMAN2 and SPARX software packages have some GPL dependencies,
 * so you are responsible for compliance with the licenses of these packages
 * if you opt to use BSD licensing. The warranty disclaimer below holds
 * in either instance.
 *
 * This complete copyright notice must be included in any revised version of the
 * source code. Additional authorship citations may be added, but existing
 * author citations must be preserved.
 *
 * This program 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.
 *
 * 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
 *
 * */
 
 
#ifndef eman__transform_h__
#define eman__transform_h__ 1
 
#include "vec3.h"
#include "emobject.h"
#include <cstdio>
// #include <vector>
// using std::vector;
//
// #include <map>
// using std::map;
//
// #include <string>
// using std::string;
 
 
 
namespace EMAN
{
        class Transform {
//              friend Transform EMAN::operator*(const Transform & M2, const Transform & M1);
                public:
                        static const float ERR_LIMIT;
 
                        Transform();
 
                        Transform( const Transform& rhs );
 
                        Transform& operator=(const Transform& that);
 
                        bool operator==(const Transform& rhs) const;
 
                        bool operator!=(const Transform& rhs) const;
 
                        Transform(const Dict& d);
 
                        Transform(const float array[12]);
 
                        Transform(const vector<float> array);
 
 
                        ~Transform() { }
 
                        void set_rotation( const Dict &rotation );
 
                        void set_rotation(const Vec3f & v);
 
                        void rotate_origin(const Transform& by);
                        
                        void rotate_origin_newBasis(const Transform& tcs, const float& omega, const float& n1, const float& n2, const float& n3);
                        
                        void rotate(const Transform& by);       
                        
                        Dict get_rotation(const string& euler_type = "eman") const;
 
 
                        Transform get_rotation_transform() const;
 
                        Transform get_hflip_transform() const;
 
                        Transform get_vflip_transform() const;
 
                        void set_params(const Dict& d);
 
                        void set_params_inverse(const Dict& d);
 
                        Dict get_params(const string& euler_type) const;
 
                        Dict get_params_inverse(const string& euler_type) const;
 
                        //=============== set and get post trans =============
                        void set_trans(const float& x, const float& y, const float& z=0);
 
                        inline void set_trans(const Vec3f& v) { set_trans(v[0],v[1],v[2]); }
 
                        inline void set_trans(const Vec2f& v) { set_trans(v[0],v[1]); }
 
                        Vec3f get_trans() const;
 
                        void translate(const float& tx, const float& ty, const float& tz=0);
                        
                        inline void translate(const Vec3f& v) { translate(v[0],v[1],v[2]); }
                        
                        inline void translate(const Vec2f& v) { translate(v[0],v[1]); }
                        
                        void translate_newBasis(const Transform& tcs, const float& tx, const float& ty, const float& tz=0);
                        
                        inline void translate(const Transform& tcs, const Vec3f& v) { translate_newBasis(tcs, v[0],v[1],v[2]); }
                        
                        Vec2f get_trans_2d() const;
 
                        //================= get pre trans is supported =========
 
                        Vec3f get_pre_trans() const;
 
                        Vec2f get_pre_trans_2d() const;
 
                        template<typename type>
                        void set_pre_trans(const type& v);
 
                        //=============== set and get scale =============
                        void set_scale(const float& scale);
 
                        float get_scale() const;
 
                        void scale(const float& scale);
                        
                        //=============== set and get post x mirror =============
                        bool get_mirror() const;
 
                        void set_mirror(const bool x_mirror);
 
                        //=============== other stuff ============================
                        void get_scale_and_mirror(float& scale, bool& x_mirror) const;
 
                        void to_identity();
 
                        bool is_identity() const;
 
                        bool is_rot_identity() const;
                        
                        void orthogonalize();
 
                        float get_determinant() const;
 
                        void printme() const {
                                printf("%8.6f %8.6f %8.6f %8.6f\n",matrix[0][0],matrix[0][1],matrix[0][2],matrix[0][3]);
                                printf("%8.6f %8.6f %8.6f %8.6f\n",matrix[1][0],matrix[1][1],matrix[1][2],matrix[1][3]);
                                printf("%8.6f %8.6f %8.6f %8.6f\n",matrix[2][0],matrix[2][1],matrix[2][2],matrix[2][3]);
                                printf("%8.6f %8.6f %8.6f %8.6f\n",0.0,0.0,0.0,1.0);
 
                        }
 
                        //=============== get set matrix ============================
                        void set_matrix(const vector<float>& v);
 
                        // returns a Python/JSON string representation of the matrix form
                        string get_matrix_string(int precision);
                        
                        vector<float> get_matrix() const;
 
                        vector<float> get_matrix_4x4() const;
                        
                        void invert();
 
                        Transform inverse() const;
 
                        void transpose_inplace();
 
                        Transform transpose() const;
 
                        inline float at(int r,int c) const { return matrix[r][c]; }
 
                        inline void set(int r, int c, float value) { matrix[r][c] = value; }
 
                        inline float * operator[] (int i) { return matrix[i]; }
 
                        inline const float * operator[] (int i) const { return matrix[i]; }
 
                        inline Vec2f transform(const float& x, const float& y) const {
//                              assert_valid_2d();
                                Vec2f ret;
                                ret[0] = matrix[0][0]*x + matrix[0][1]*y + matrix[0][3];
                                ret[1] = matrix[1][0]*x + matrix[1][1]*y + matrix[1][3];
                                return ret;
                        }
 
                        template<typename Type>
                        inline Vec2f transform(const Vec2<Type>& v) const {
                                return transform(v[0],v[1]);
                        }
 
                        inline Vec3f transform(const float& x, const float& y, const float& z) const {
//                              assert_consistent_type(THREED);
                                Vec3f ret;
                                ret[0] = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z + matrix[0][3];
                                ret[1] = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z + matrix[1][3];
                                ret[2] = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z + matrix[2][3];
                                return ret;
                        }
 
                        template<typename Type>
                        inline Vec3f transform(const Vec3<Type>& v) const {
//                              assert_consistent_type(THREED); // Transform does the assertion
                                return transform(v[0],v[1],v[2]);
                        }
 
 
                        inline Vec3f get_matrix3_row(int i) const {
                                return Vec3f(matrix[i][0], matrix[i][1], matrix[i][2]);
                        }
 
                        static int get_nsym(const string & sym);
                        
                        Transform get_sym(const string & sym, int n) const;
                        // The next two are used solely in sparx, mainly to deal with tet.
                        Transform get_sym_sparx(const string & sym, int n) const;
                        vector<Transform > get_sym_proj(const string & sym) const;
 
                        void copy_matrix_into_array(float* const) const;
 
                        Transform negate() const;
 
                        static Transform tet_3_to_2();
 
                        static Transform icos_5_to_2();
 
                private:
                        float matrix[3][4];
 
                        void assert_valid_2d() const;
 
                        static vector<string> permissable_2d_not_rot;
                        static vector<string> permissable_3d_not_rot;
                        static map<string,vector<string> >  permissable_rot_keys;
 
                        void init_permissable_keys();
 
                        void detect_problem_keys(const Dict& d);
 
        };
        Transform operator*(const Transform & M2, const Transform & M1);
 
        template<typename Type>
        Vec3f operator*( const Transform& M, const Vec3<Type> & v)
        {
                return M.transform(v);
        }
 
        template<typename Type>
        Vec2f operator*( const Transform& M, const Vec2<Type> & v)
        {
                return M.transform(v);
        }
 
        template<typename Type>
        Vec3f operator*(const Vec3<Type> & v, const Transform & M)
        {
                float x = v[0] * M[0][0] + v[1] * M[1][0] + v[2] * M[2][0] ;
                float y = v[0] * M[0][1] + v[1] * M[1][1] + v[2] * M[2][1];
                float z = v[0] * M[0][2] + v[1] * M[1][2] + v[2] * M[2][2];
                return Vec3f(x, y, z);
        }
 
        template<typename type>
        void Transform::set_pre_trans(const type& v) {
 
                Transform tmp;
                Dict rot = get_rotation("eman");
                tmp.set_rotation(rot);
 
                float scale = get_scale();
                if (scale != 1.0 ) tmp.set_scale(scale);
 
                Transform trans;
                trans.set_trans(v);
 
                trans = tmp*trans;
 
                Transform tmp2;
                tmp2.set_rotation(rot);
                tmp2.invert(); // invert
                if (scale != 1.0 ) tmp2.set_scale(1.0f/scale);
 
 
                trans = trans*tmp2;
 
                set_trans(trans.get_trans());
        }
 
//      class Transform3D
//      {
//      public:
//              static const float ERR_LIMIT;
//              enum EulerType
//              {
//                      UNKNOWN,
//                      EMAN,
//                      IMAGIC,
//                      SPIN,
//                      QUATERNION,
//                      SGIROT,
//                      SPIDER,
//                      MRC,
//                      XYZ,
//                      MATRIX
//              };
//
//              /** Default constructor
//               * Internal matrix is the identity
//               */
//              Transform3D();
//
//              /** Copy constructor
//               * @param rhs the object to be copied
//               */
//          Transform3D( const Transform3D& rhs );
//
//               /** Construct a Transform3D object describing a rotation, assuming the EMAN Euler type
//               * @param az EMAN - az
//               * @param alt EMAN - alt
//               * @param phi EMAN - phi
//               */
//              Transform3D(const float& az,const float& alt,const float& phi); // EMAN by default
//
//               /** Construct a Transform3D object describing a rotation (assuming the EMAN Euler type) and
//               * a post translation
//               * @param az EMAN - az
//               * @param alt EMAN - alt
//               * @param phi EMAN - phi
//               * @param posttrans the post translation vector
//               */
//              Transform3D(const float& az, const float& alt, const float& phi, const Vec3f& posttrans);
//
//               /** Construct a Transform3D object describing a pre trans, a rotation
//               * assuming the EMAN Euler type) and a post translation
//               * @param pretrans the pre translation vector
//               * @param az EMAN - az
//               * @param alt EMAN - alt
//               * @param phi EMAN - phi
//               * @param posttrans the post translation vector
//                */
//              Transform3D(const Vec3f & pretrans, const float& az,const float& alt,const float& phi, const Vec3f& posttrans);
//
//              /** Construct a Transform3D object describing a rotation, using a specific Euler type.
//               * works for EMAN, SPIDER, MRC, IMAGIC and  XYZ (Euler types required 3 parameters)
//               * @param euler_type the Euler type either  EMAN, SPIDER, MRC, IMAGIC and  XYZ
//               * @param a1 EMAN - az, SPIDER - phi, MRC - phi, IMAGIC - alpha, XYZ - xtilt
//               * @param a2 EMAN - alt, SPIDER - theta, MRC - theta, IMAGIC - beta, XYZ - ytilt
//               * @param a3 EMAN - phi, SPIDER - psi, MRC - omega, IMAGIC - gamma, XYZ - ztilt
//               */
//              Transform3D(EulerType euler_type, const float& a1, const float& a2, const float& a3) ;
//
//              /** Construct a Transform3D object describing a rotation, using a specific Euler type.
//               * Works for Euler types that require 4 parameters
//               * @param euler_type the Euler type either QUATERNION, SPIN or SGIROT
//               * @param a1 QUATERNION - e0, SPN and SGIROT - omega
//               * @param a2 QUATERNION - e1, SPN and SGIROT - n1
//               * @param a3 QUATERNION - e2, SPN and SGIROT - n2
//               * @param a4 QUATERNION - e3, SPN and SGIROT - n3
//              */
//              Transform3D(EulerType euler_type, const float& a1, const float& a2, const float& a3, const float& a4) ; // o
//
//              /** Construct a Transform3D object consisting only of a rotation, using a specific Euler type.
//               * Works for all Euler types
//               * @param euler_type any Euler type
//               * @param rotation a dictionary containing all key-entry pair required of the associated Euler type
//               */
//              Transform3D(EulerType euler_type, const Dict& rotation);
//
//              /** Construct a Transform3D object consisting only of a rotation by initializing the internal
//               * rotation matrix component wise
//               * @param mij the value to be placed in the internal transformation matrix at coordinate (i-1,j-1)
//               */
//              Transform3D(const float& m11, const float& m12, const float& m13,
//                                      const float& m21, const float& m22, const float& m23,
//                                      const float& m31, const float& m32, const float& m33);
//
//              /** Destructor
//               */
//              ~Transform3D();
//
//              /** FIXME insert comments
//               */
//              void apply_scale(const float& scale);
//
//              /** FIXME insert comments
//               */
//              void set_scale(const float& scale);
//
//              /** Reorthogonalize the matrix
//               */
//              void orthogonalize();
//
//              /**  create the transpose in place
//               */
//              void transpose();
//
//              void set_rotation(const float& az, const float& alt,const float& phi);
//
//              /** Sets the rotation as defined by the EulerType
//               * works for EMAN, SPIDER, MRC, IMAGIC and  XYZ
//               * @param euler_type the Euler type either  EMAN, SPIDER, MRC, IMAGIC and  XYZ
//               * @param a1 EMAN - az, SPIDER - phi, MRC - phi, IMAGIC - alpha, XYZ - xtilt
//               * @param a2 EMAN - alt, SPIDER - theta, MRC - theta, IMAGIC - beta, XYZ - ytilt
//               * @param a3 EMAN - phi, SPIDER - psi, MRC - omega, IMAGIC - gamma, XYZ - ztilt
//              */
//              void set_rotation(EulerType euler_type,const float& a1,const float& a2,const float& a3);
//
//              /** Set quaternion-based rotations
//               * Works for QUATERNION, SPIN and SGIROT
//               * @param euler_type the Euler type either QUATERNION, SPIN or SGIROT
//               * @param a1 QUATERNION - e0, SPN and SGIROT - omega
//               * @param a2 QUATERNION - e1, SPN and SGIROT - n1
//               * @param a3 QUATERNION - e2, SPN and SGIROT - n2
//               * @param a4 QUATERNION - e3, SPN and SGIROT - n3
//               */
//              void set_rotation(EulerType euler_type,const float& a1,const float& a2,const float& a3, const float& a4);
//
//              /** set the internal rotation matrix component wise
//               * @param mij the value to be placed in the internal transformation matrix at coordinate (i-1,j-1)
//               */
//              void set_rotation(const float& m11, const float& m12, const float& m13,
//                                                const float& m21, const float& m22, const float& m23,
//                                                const float& m31, const float& m32, const float& m33);
//
//
//              /** Set a rotation using a specific Euler type and the dictionary interface
//               * Works for all Euler types
//               * @param euler_type any Euler type
//               * @param rotation a dictionary containing all key-entry pair required of the associated Euler type
//               */
//              void set_rotation(EulerType euler_type, const Dict &rotation );
//
//              /** Get a rotation in any Euler format
//               * @param euler_type the requested Euler type
//               * @return a dictionary containing the key-entry pairs describing the rotations in terms of the requested Euler type
//               */
//              Dict get_rotation(EulerType euler_type=EMAN) const;
//
//              /** returns a rotation that maps a pair of unit vectors, a,b to a second  pair A,B
//               * @param eahat, ebhat, eAhat, eBhat are all unit vectors
//               * @return  a transform3D rotation
//               */
//              void set_rotation(const Vec3f & eahat, const Vec3f & ebhat,
//                                                  const Vec3f & eAhat, const Vec3f & eBhat);
//              /** returns the magnitude of the rotation
//              */
//              float get_mag() const;
//
//              /** returns the spin-axis (or finger) of the rotation
//              */
//              Vec3f get_finger() const;
//
//              /** Gets one of two pre translation vectors
//               * @param flag if 0 returns the pre translation vector, if 1 all translation is treated as pre
//               * @return the translation vector
//               */
//              Vec3f get_pretrans( int flag=0) const; // flag=1 => all trans is pre
//
//              /** Gets one of two post translation vectors.
//               * when the flag is 1 then the contents of the Transform3D matrix right column are returned
//               * @param flag if 0 returns the post translation vector, if 1 all translation is treated as post
//               * @return the translation vector
//               */
//              Vec3f get_posttrans(int flag=0) const; // flag=1 => all trans is post
//
//              /** Get the total translation as a post translation. Calls get_postrans(1)
//               * @return the translation vector
//               */
//              Vec3f get_total_posttrans() const;
//
//              /** Get the total translation as a pre translation. Calls get_pretrans(1)
//               * @return the translation vector
//               */
//              Vec3f get_total_pretrans() const;
//
//              /** This doesn't do anything, it returns an empty vector. Why is it being used?
//               */
//              Vec3f get_center() const; // This doesn't do anything
//
//              /** Get a matrix column as a Vec3f
//               * @param i the column number (starting at 0)
//               * @return the ith column
//               */
//              Vec3f get_matrix3_col(int i) const;
//
//              /** Get a matrix row as a Vec3f
//               * @param i the row number (starting at 0)
//               * @return the ith row
//               */
//              Vec3f get_matrix3_row(int i) const;
//
//              /** Perform a full transform a Vec3f using the internal transformation matrix
//               * @param v3f the vector to be transformed
//               * @return the transformed vector
//               */
//              Vec3f transform(const Vec3f & v3f) const;
//
//              /** Rotate a Vec3f using the internal rotation matrix
//               * @param v3f the vector to be rotated
//               * @return the rotated vector
//               */
//              Vec3f rotate(const Vec3f & v3f) const;
//
//              /** FIXME insert comments
//               */
//              Transform3D inverseUsingAngs() const;
//
//              /** FIXME insert comments
//               */
//              Transform3D inverse() const;
//
//
//              /** Print the Transform3D matrix
//               */
//              void printme() const {
//                      for (int i=0; i<3; i++) {
//                              printf("%6.15f\t%6.15f\t%6.15f\t%6.1f\n",
//                                         matrix[i][0],matrix[i][1],matrix[i][2],matrix[i][3]);
//                      }
//                      printf("%6.3f\t%6.3f\t%6.3f\t%6.3f\n",0.0,0.0,0.0,1.0);
//                      printf("\n");
//              }
//
//              /** Get the value stored in the internal transformation matrix at at coordinate (r,c)
//               */
//              inline float at(int r,int c) const { return matrix[r][c]; }
//
//              /** Set the value stored in the internal transformation matrix at at coordinate (r,c) to value
//               */
//              void set(int r, int c, float value) { matrix[r][c] = value; }
//
//              /** Operator[] convenience
//               * so Transform3D[2][2] etc terminology can be used
//               */
//              inline float * operator[] (int i) { return matrix[i]; }
//
//              /** Operator[] convenience
//               * so Transform3D[2][2] etc terminology can be used
//               */
//              inline const float * operator[] (int i) const { return matrix[i]; }
//
//              static int get_nsym(const string & sym);
//              Transform3D get_sym(const string & sym, int n) const;
//
//              /** Set functions FIXME insert more comments from here down
//               */
//              void set_center(const Vec3f & center);
//              void set_pretrans(const Vec3f & pretrans);
//              void set_pretrans(const float& dx, const float& dy, const float& dz);
//              void set_pretrans(const float& dx, const float& dy);
//              void set_pretrans(const Vec2f& pretrans);
//              void set_posttrans(const Vec3f & posttrans);
//              void set_posttrans(const float& dx, const float& dy, const float& dz);
//              void set_posttrans(const float& dx, const float& dy);
//              void set_posttrans(const Vec2f& posttrans);
//
//              void set_post_x_mirror(const bool b) { post_x_mirror = b; }
//              bool get_post_x_mirror() const { return post_x_mirror; }
//
//              float get_scale() const;
//
//              void to_identity();
//        bool is_identity();
//
//              /** Convert a list of euler angles to a vector of Transform3D objects.
//               *
//               *      @param[in] eulertype The type of Euler angles that is being passed in.
//               *      @param[in] angles A flat vector of angles.
//               *
//               *      @return Vector of pointers to Transform3D objects.
//               */
//              static vector<Transform3D*>
//                      angles2tfvec(EulerType eulertype, const vector<float> angles);
//
//              /** This added by d.woolford, will eventually be removed by author
//              */
//              void dsaw_zero_hack(){
//                      for (int j=0; j<4; ++j) {
//                              for (int i=0; i<4; i++) {
//                              if ( fabs(matrix[j][i]) < 0.000001 )
//                                      matrix[j][i] = 0.0;
//                              }
//                      }
//
//              }
//
//      protected:
//              enum SymType
//              {      CSYM,
//                      DSYM,
//                      TET_SYM,
//                      ICOS_SYM,
//                      OCT_SYM,
//                      ISYM,
//                      UNKNOWN_SYM
//              };
//
//              void init();
//
//              static SymType get_sym_type(const string & symname);
//
//              float matrix[4][4];
//
//              bool post_x_mirror;
//
//              Transform3D::EulerType s;
//      }; // ends Class
//
//      Transform3D operator*(const Transform3D & M1, const Transform3D & M2);
//      Vec3f operator*(const Vec3f & v    , const Transform3D & M);
//      Vec3f operator*(const Transform3D & M, const Vec3f & v    );
 
//      template<typename Type>
//      Vec3f operator*(const Vec3<Type> & v, const Transform3D & M)   // YYY
//      {
//              float x = v[0] * M[0][0] + v[1] * M[1][0] + v[2] * M[2][0] ;
//              float y = v[0] * M[0][1] + v[1] * M[1][1] + v[2] * M[2][1];
//              float z = v[0] * M[0][2] + v[1] * M[1][2] + v[2] * M[2][2];
//              return Vec3f(x, y, z);
//      }
//
//      template<typename Type>
//      Vec3f operator*( const Transform3D & M, const Vec3<Type> & v)      // YYY
//      {
//              float x = M[0][0] * v[0] + M[0][1] * v[1] + M[0][2] * v[2] + M[0][3];
//              float y = M[1][0] * v[0] + M[1][1] * v[1] + M[1][2] * v[2] + M[1][3];
//              float z = M[2][0] * v[0] + M[2][1] * v[1] + M[2][2] * v[2] + M[2][3];
//              return Vec3f(x, y, z);
//      }
//
//
//      template<typename Type>
//      Vec2f operator*( const Transform3D & M, const Vec2<Type> & v)      // YYY
//      {
//              float x = M[0][0] * v[0] + M[0][1] * v[1] + M[0][3] ;
//              float y = M[1][0] * v[0] + M[1][1] * v[1] + M[1][3];
//              return Vec2f(x, y);
//      }
 
}  // ends NameSpace EMAN
 
 
 
#endif