[Chimera-users] orientation matrix

[Eric Pettersen]

On Oct 31, 2004, at 7:28 AM, Miguel Ortiz Lombardía wrote:

> Hi all,
>
> Sorry, this question may be very simple, but I didn't manage to find 
> an answer in the documentation.
>
> Is it possible to read a transformation (rotation + translation) 
> matrix so that the molecule is displayed exactly in the orientation 
> you wish?

This is discussed a little in the programmer's FAQ, question #4 
(http://www.cgl.ucsf.edu/chimera/docs/ProgrammersGuide/faq.html).  But 
that question doesn't talk about how to use an _arbitrary_ 
rotation/translation matrix to set a model's transformation.  
Nonetheless, you should look at it to get the general idea of how to 
set a model's transformation matrix.  At the end of this mail I've 
appended the definition of the Xform class, as our Python-wrapping 
program sees it (therefore, functions that are commented out [with 
'//'] are in the C++ code put not the Python layer).  The routine you 
want is the constructor 'xform' that takes 12 numeric arguments 
defining the transformation matrix and an 'orthogonalize' boolean.  So 
you would generate your transform with:

xf = chimera.Xform(..12 numbers..., orthogonalize=True)

You want 'orthogonalize' to be True so that Chimera will correct for 
any roundoff in your numeric arguments and produce an orthonormal 
matrix that is suitable for use as a transformation matrix.  You then 
use the same general procedures as in FAQ question 4 to set the model 
transform.

Now, this would be much easier if the Midas matrixget/matrixset 
commands were implemented in Chimera.  I will work on that and let you 
know when it's done.  Until then, you will need to use the Xform 
constructor.

                         Eric Pettersen
                         UCSF Computer Graphics Lab
                         pett at cgl.ucsf.edu
                         http://www.cgl.ucsf.edu

class Xform
{
         // WRAP CLASS
         // DON'T CACHE
public:
         Xform();        // same as identity
         // The following static routines are the constructors:
         static Xform    xform(Real r00, Real r01, Real r02, Real t03,
                                 Real r10, Real r11, Real r12, Real t13,
                                 Real r20, Real r21, Real r22, Real t23,
                                 bool orthogonalize = false);
         static Xform    coordFrame(const Vector &x, const Vector &y,
                                 const Vector &z, const Point &origin,
                                 bool orthogonalize = false);
         static Xform    identity();
         static Xform    translation(Real x, Real y, Real z);
         static Xform    translation(const Vector &v);
         static Xform    xRotation(Real angle);
         static Xform    yRotation(Real angle);
         static Xform    zRotation(Real angle);
         static Xform    rotation(Real x, Real y, Real z, Real angle);
         static Xform    rotation(const Vector &axis, Real angle);
         //static Xform  rotation(const Real mat[3][3], bool 
orthogonalize = fals
e);
         static Xform    zAlign(const Point &p0, const Point &p1);
         static Xform    zAlign(const Point &p0, const Vector &v);
         static Xform    lookAt(const Point &eye, const Point &at, const 
Point &u
p);
         static Xform    lookAt(const Point &eye, const Point &at, const 
Vector &
up);
         void            invert();
         void            translate(Real x, Real y, Real z);
         void            translate(const Vector &xyz);
         void            xRotate(Real angle);
         void            yRotate(Real angle);
         void            zRotate(Real angle);
         void            rotate(Real x, Real y, Real z, Real angle);
         void            rotate(const Vector &xyz, Real angle);
         Point           apply(const Point &pt) const;
         Vector          apply(const Vector &vec) const;
         void            premultiply(const Xform &xf);
         void            multiply(const Xform &xf);
         bool            isIdentity() const;
         void            getRotation(/*OUT*/ Vector *axis, /*OUT*/ Real 
*angle) c
onst;
         void    getCoordFrame(/*OUT*/ Vector *x = NULL,
                         /*OUT*/ Vector *y = NULL, /*OUT*/ Vector *z = 
NULL,
                         /*OUT*/ Point *origin = NULL) const;
         void            getTranslation(/*OUT*/ Vector *trans) const;
         //void          get4by4(/*OUT*/ Real mat[4][4]) const;
};