def test_interpolate3D(self):
     mat1=rotax([0,0,0], [0,0,1],30.0*degtorad)
     mat2=rotax([0,0,0], [0,0,1],60.0*degtorad)
     mat3=rotax([0,0,0], [0,0,1],90.0*degtorad)
     # add translation (0,1,0) to mat2 
     mat2 = N.array([
            [ 0.5       ,  0.86602539,  0.        ,  0.        ],
            [-0.86602539,  0.5       ,  0.        ,  0.        ],
            [ 0.        ,  0.        ,  1.        ,  0.        ],
            [ 0.        ,  1.        ,  0.        ,  1.        ]],'f')
 
     matList=[mat1, mat2, mat3]
     indexList = [0.33333333, 0.66666666667, 1.0]
     data = [[0.,0.,0.,1.],[1.0, 0.0, 0.0,1.0],[2.,0.,0.,1.]]
     p=0.5
     M = interpolate3DTransform(matList, indexList, p)
     
     res=N.dot(data, M)[1]
     
     self.assertEqual( self.diff(res[0], 0.70710677 ),True)
     self.assertEqual(self.diff(res[1], 1.20710677 ),True) # 50% translation along Y axis
     self.assertEqual(self.diff(res[2], 0.0),True)
 
     p=1.5
     M = interpolate3DTransform(matList, indexList, p)
     res=N.dot(data, M)[1]
     self.assertEqual(self.diff(res[0], -0.70710677 ),True)
     self.assertEqual(self.diff(res[1],  0.70710677 ),True)
     self.assertEqual(self.diff(res[2],  0.0),True)
Пример #2
0
    def test_interpolate3D(self):
        mat1 = rotax([0, 0, 0], [0, 0, 1], 30.0 * degtorad)
        mat2 = rotax([0, 0, 0], [0, 0, 1], 60.0 * degtorad)
        mat3 = rotax([0, 0, 0], [0, 0, 1], 90.0 * degtorad)
        # add translation (0,1,0) to mat2
        mat2 = N.array([[0.5, 0.86602539, 0., 0.], [-0.86602539, 0.5, 0., 0.],
                        [0., 0., 1., 0.], [0., 1., 0., 1.]], 'f')

        matList = [mat1, mat2, mat3]
        indexList = [0.33333333, 0.66666666667, 1.0]
        data = [[0., 0., 0., 1.], [1.0, 0.0, 0.0, 1.0], [2., 0., 0., 1.]]
        p = 0.5
        M = interpolate3DTransform(matList, indexList, p)

        res = N.dot(data, M)[1]

        self.assertEqual(self.diff(res[0], 0.70710677), True)
        self.assertEqual(self.diff(res[1], 1.20710677),
                         True)  # 50% translation along Y axis
        self.assertEqual(self.diff(res[2], 0.0), True)

        p = 1.5
        M = interpolate3DTransform(matList, indexList, p)
        res = N.dot(data, M)[1]
        self.assertEqual(self.diff(res[0], -0.70710677), True)
        self.assertEqual(self.diff(res[1], 0.70710677), True)
        self.assertEqual(self.diff(res[2], 0.0), True)
Пример #3
0
    def __applyTorsion(self, node, parent_mtx):
        """Transform the subtree rooted at node.

        The new torsion angle must be pre-set.
        Children of the node are transformed recursively.
        """
        # get rotation matrix for node
        # my_mtx = self.rotax(node)
        mtx = rotax( Numeric.array(node.a.coords),
                     Numeric.array(node.b.coords),
                     node.angle * self.rads_per_degree, transpose=1)

        # node_mtx = Numeric.dot(parent_mtx, mtx)
        node_mtx = self.mult4_3Mat(parent_mtx, mtx)

        # set-up for the transformation
        mm11 = node_mtx[0][0]; mm12 = node_mtx[0][1]; mm13 = node_mtx[0][2]
        mm21 = node_mtx[1][0]; mm22 = node_mtx[1][1]; mm23 = node_mtx[1][2]
        mm31 = node_mtx[2][0]; mm32 = node_mtx[2][1]; mm33 = node_mtx[2][2]
        mm41 = node_mtx[3][0]; mm42 = node_mtx[3][1]; mm43 = node_mtx[3][2]
        atomSet = node.atomSet        
        # transform the coordinates for the node
        for i in node.atomRange:
            x,y,z = node.coords[i][:3] # get origin-subtracted originals
            c = atomSet[i].coords
            c[0] = x*mm11 + y*mm21 + z*mm31 + mm41
            c[1] = x*mm12 + y*mm22 + z*mm32 + mm42
            c[2] = x*mm13 + y*mm23 + z*mm33 + mm43

        # recurse through children
        for child in node.children:
            self.__applyTorsion(child, node_mtx)
Пример #4
0
 def setValue(self, value):
     #print 'Rotate by', value
     mat = rotax((0, 0, 0), self.axis, value * math.pi / 180.)
     object = self.object
     object.ConcatRotation(mat.flatten())
     if isinstance(object, Camera):
         object.Redraw()
Пример #5
0
    def doit(self, atom1, atom2, angle, mov_atoms, returnVal=0):
        mol = atom1.top
        if mov_atoms is None:
            mov_atoms = mol.subTree(atom1, atom2, mol.allAtoms)
        assert len(mov_atoms)
        mov_coords = Numeric.array(mov_atoms.coords)
        lenCoords = len(mov_coords)
        x = Numeric.array(atom1.coords)
        y = Numeric.array(atom2.coords)
        rot = (angle * 3.14159 / 180.) % (2 * Numeric.pi)
        matrix = rotax(x, y, rot)
        _ones = Numeric.ones(lenCoords, 'f')
        _ones.shape = (lenCoords, 1)
        mov_coords = Numeric.concatenate((mov_coords, _ones), 1)
        newcoords = Numeric.dot(mov_coords, matrix)
        nc = newcoords[:, :3].astype('f')
        for i in range(lenCoords):
            at = mov_atoms[i]
            at._coords[at.conformation] = nc[i].tolist()

        event = EditAtomsEvent('coords', mov_atoms)
        self.vf.dispatchEvent(event)

        #have to return nc for setTorsionGC
        if returnVal:
            return nc
Пример #6
0
    def __applyTorsion(self, node, parent_mtx):
        """Transform the subtree rooted at node.

        The new torsion angle must be pre-set.
        Children of the node are transformed recursively.
        """
        # get rotation matrix for node
        # my_mtx = self.rotax(node)
        mtx = rotax( Numeric.array(node.a.coords),
                     Numeric.array(node.b.coords),
                     node.angle * self.rads_per_degree, transpose=1)

        # node_mtx = Numeric.dot(parent_mtx, mtx)
        node_mtx = self.mult4_3Mat(parent_mtx, mtx)

        # set-up for the transformation
        mm11 = node_mtx[0][0]; mm12 = node_mtx[0][1]; mm13 = node_mtx[0][2]
        mm21 = node_mtx[1][0]; mm22 = node_mtx[1][1]; mm23 = node_mtx[1][2]
        mm31 = node_mtx[2][0]; mm32 = node_mtx[2][1]; mm33 = node_mtx[2][2]
        mm41 = node_mtx[3][0]; mm42 = node_mtx[3][1]; mm43 = node_mtx[3][2]
        atomSet = node.atomSet        
        # transform the coordinates for the node
        for i in node.atomRange:
            x,y,z = node.coords[i][:3] # get origin-subtracted originals
            c = atomSet[i].coords
            c[0] = x*mm11 + y*mm21 + z*mm31 + mm41
            c[1] = x*mm12 + y*mm22 + z*mm32 + mm42
            c[2] = x*mm13 + y*mm23 + z*mm33 + mm43

        # recurse through children
        for child in node.children:
            self.__applyTorsion(child, node_mtx)
Пример #7
0
 def setValue(self, value):
     #print 'Rotate by', value
     mat = rotax( (0,0,0), self.axis, value*math.pi/180.)
     object = self.object
     object.ConcatRotation(mat.flatten())
     if isinstance(object, Camera):
         object.Redraw()
Пример #8
0
    def mouseMove(self, event):
        # simple trackball, only works inside cirle
        # creates an XY rotation defined by pts intersecting the spheres
        xc = event.x - self.xm
        yc = self.ym - event.y
        # compute the intersection point between
        xc2 = xc*xc
        yc2 = yc*yc
        z2 = self.r2-xc2-yc2

        if z2 < 0:
            lInvMag = 1./math.sqrt(xc2 + yc2)
            xc *= lInvMag * (self.r)
            yc *= lInvMag * (self.r)
            z2 = 0

        # compute rotation angle
	a = self.lastPt3D
	b = (xc, yc, math.sqrt(z2))
        ang = math.acos((a[0]*b[0]+a[1]*b[1]+a[2]*b[2])/self.r2)
        if self.mode=='XY':
	    #compute rotation axis
            rotaxis = Numeric.array( (a[1]*b[2] - a[2]*b[1],
				  a[2]*b[0] - a[0]*b[2],
				  a[0]*b[1] - a[1]*b[0] ), 'f' )
        elif self.mode=='X': rotaxis = Numeric.array( (1.,0.,0.), 'f')
        elif self.mode=='Y': rotaxis = Numeric.array( (0.,1.,0.), 'f')
        elif self.mode=='Z': rotaxis = Numeric.array( (0.,0.,1.), 'f')
        mat = rotax( self.zeros, rotaxis, ang )
        self.lastPt3D = b
        self.updateVector(mat)
    def mouseMove(self, event):
        # simple trackball, only works inside cirle
        # creates an XY rotation defined by pts intersecting the spheres
        xc = event.x - self.xm
        yc = self.ym - event.y
        # compute the intersection point between
        xc2 = xc * xc
        yc2 = yc * yc
        z2 = self.r2 - xc2 - yc2

        if z2 < 0:
            lInvMag = 1. / math.sqrt(xc2 + yc2)
            xc *= lInvMag * (self.r)
            yc *= lInvMag * (self.r)
            z2 = 0

        # compute rotation angle
        a = self.lastPt3D
        b = (xc, yc, math.sqrt(z2))
        ang = math.acos((a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) / self.r2)
        if self.mode == 'XY':
            #compute rotation axis
            rotaxis = numpy.array(
                (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2],
                 a[0] * b[1] - a[1] * b[0]), 'f')
        elif self.mode == 'X':
            rotaxis = numpy.array((1., 0., 0.), 'f')
        elif self.mode == 'Y':
            rotaxis = numpy.array((0., 1., 0.), 'f')
        elif self.mode == 'Z':
            rotaxis = numpy.array((0., 0., 1.), 'f')
        mat = rotax(self.zeros, rotaxis, ang)
        self.lastPt3D = b
        self.updateVector(mat)
    def doit(self, atom1, atom2, angle, mov_atoms, returnVal=0):
        mol = atom1.top
        if mov_atoms is None:
            mov_atoms = mol.subTree(atom1, atom2, mol.allAtoms)
        assert len(mov_atoms)
        mov_coords = Numeric.array(mov_atoms.coords)
        lenCoords = len(mov_coords)
        x = Numeric.array(atom1.coords)
        y = Numeric.array(atom2.coords)
        rot = (angle * 3.14159/180.)%(2 * Numeric.pi)
        matrix = rotax(x, y, rot)
        _ones = Numeric.ones(lenCoords, 'f')
        _ones.shape = (lenCoords,1)
        mov_coords = Numeric.concatenate((mov_coords, _ones),1)
        newcoords = Numeric.dot(mov_coords, matrix)
        nc = newcoords[:,:3].astype('f')
        for i in range(lenCoords):
            at = mov_atoms[i]
            at._coords[at.conformation] = nc[i].tolist()

        event = EditAtomsEvent('coords', mov_atoms)
        self.vf.dispatchEvent(event)

        #have to return nc for setTorsionGC
        if returnVal:
            return nc
Пример #11
0
def rotateObject():
    from mglutil.math.rotax import rotax
    from math import sin, cos, pi, sqrt, fabs
    import random

    degtorad = pi/180.
    point1 = [random.random()*8-4, random.random()*8-4.,random.random()*10-5]
    point2 = [random.random()*8-4, random.random()*8-4.,random.random()*10-5.]
    angle  = random.random()*360.
    transf = rotax(point1, point2, angle*degtorad, transpose=1)

    from mglutil.math.rotax import mat_to_axis_angle
    vector , pp, angle = mat_to_axis_angle(transf)

    from FlexTree.FTMotions import FTMotion_Hinge
    motion = FTMotion_Hinge(axis={'vector':vector,'point':pp})
    motion.configure(angle=angle)

    m1=Numeric.array(motion.getMatrix()).ravel()
    m2=transf.ravel()
    bSame = True
    for i in range(len(m1)):
        if fabs(m1[i]-m2[i]) > 1e-4:
            bSame = False
    assert (bSame, True)
Пример #12
0
    def getRotMatrix(self, shape=(4,4), transpose = None):
        """return the rotation matrix as a  array of shape shape.
        """
        try:
            assert( shape in [ (3,3), (4,4), (9,), (16,)] )
        except:
            raise ValueError('shape must be (3,3), (4,4), (9,) or (16,)')

        # get the inverse 4x4 from rotax
        mtx = rotax.rotax(numpy.array([0.,0.,0.],'f'),self.pure,2*numpy.arccos(self.real))

        # strip if necessary
        if shape in ((3,3),(9,)):
            mtx = [x[:3] for x in mtx]
            mtx = mtx[:3]

        if not transpose:
            return numpy.reshape(numpy.transpose(mtx),shape)
        else:
            return numpy.reshape(mtx,shape)
def setRelativeTorsion(atom1, atom2, angle): #mov_atoms=None):
    #rat1, rat2, ??30degrees??
    mol = atom1.top
    if mov_atoms is None:
        mov_atoms = mol.subTree(atom1, atom2, mol.allAtoms)
    assert len(mov_atoms)
    mov_coords = Numeric.array(mov_atoms.coords)
    lenCoords = len(mov_coords)
    x = Numeric.array(atom1.coords)
    y = Numeric.array(atom2.coords)
    rot = (angle * 3.14159/180.)%(2 * Numeric.pi)
    matrix = rotax(x, y, rot)
    _ones = Numeric.ones(lenCoords, 'f')
    _ones.shape = (lenCoords,1)
    mov_coords = Numeric.concatenate((mov_coords, _ones),1)
    newcoords = Numeric.dot(mov_coords, matrix)
    nc = newcoords[:,:3].astype('f')
    for i in range(lenCoords):
        at = mov_atoms[i]
        at._coords[at.conformation] = nc[i].tolist()
def setRelativeTorsion(atom1, atom2, angle):  #mov_atoms=None):
    #rat1, rat2, ??30degrees??
    mol = atom1.top
    if mov_atoms is None:
        mov_atoms = mol.subTree(atom1, atom2, mol.allAtoms)
    assert len(mov_atoms)
    mov_coords = Numeric.array(mov_atoms.coords)
    lenCoords = len(mov_coords)
    x = Numeric.array(atom1.coords)
    y = Numeric.array(atom2.coords)
    rot = (angle * 3.14159 / 180.) % (2 * Numeric.pi)
    matrix = rotax(x, y, rot)
    _ones = Numeric.ones(lenCoords, 'f')
    _ones.shape = (lenCoords, 1)
    mov_coords = Numeric.concatenate((mov_coords, _ones), 1)
    newcoords = Numeric.dot(mov_coords, matrix)
    nc = newcoords[:, :3].astype('f')
    for i in range(lenCoords):
        at = mov_atoms[i]
        at._coords[at.conformation] = nc[i].tolist()
Пример #15
0
    def getRotMatrix(self, shape=(4,4), transpose = None):
        """return the rotation matrix as a Numeric array of shape shape.
        """
        try:
            assert( shape in [ (3,3), (4,4), (9,), (16,)] )
        except:
            raise ValueError('shape must be (3,3), (4,4), (9,) or (16,)')

        # get the inverse 4x4 from rotax
        mtx = rotax.rotax(N.array([0.,0.,0.],'f'),self.pure,2*N.arccos(self.real))

        # strip if necessary
        if shape in ((3,3),(9,)):
            mtx = map(lambda x: x[:3],mtx)
            mtx = mtx[:3]

        if not transpose:
            return N.reshape(N.transpose(mtx),shape)
        else:
            return N.reshape(mtx,shape)
Пример #16
0
    def getMatrices(self):
        matrices = []
        r = self.hrise
        v = self.vector
        p = self.point
        rv = (r*v[0], r*v[1], r*v[2])

        ## does not work .. some weird problem with the angle (MS)
        # build one increment of transformation
##         R = Transformation(
##             trans=[rv[0], rv[1], rv[2]],
##             quaternion=[v[0], v[1], v[2], self.angle*180/math.pi])
##         T = Transformation(trans=self.point)
##         transform1 = T * R * T.inverse()
##         transform = T * R * T.inverse()
##         matrices.append( transform.getMatrix() )
##         for i in range(self.copies-1):
##             transform = transform*transform1
##             matrices.append( transform.getMatrix() )

        # build rotation and translation matrix about helical axis going
        # rot matrix C style
        R = rotax( p, [p[0]+v[0], p[1]+v[1], p[2]+v[2]],
                   self.angle, False)
        riseMat = Numeric.identity(4).astype('f')
        riseMat[:3, 3] = rv # add the rise
        transform = Numeric.dot(riseMat, R)
        N = Numeric

        matrices.append( N.identity(4).astype('f'))
        for i in range(1,self.copies):
            mat = matrices[i-1]
            mat = Numeric.dot(mat, transform)
            matrices.append(mat)

        return matrices
## Automatically adapted for numpy.oldnumeric Jul 23, 2007 by 

#
#  collection of standard 4x4 rotation matrices
#  about the X, Y and Z axis of 10, 30, 45, 90, 180 degrees
#
rotations = {
}

import math, numpy.oldnumeric as Numeric
from mglutil.math.rotax import rotax

orig = Numeric.array( (0,0,0), 'f')
X = Numeric.array( (1,0,0), 'f')
Y = Numeric.array( (0,1,0), 'f')
Z = Numeric.array( (0,0,1), 'f')

for angle in [1, 5, 10, 30, 45, 90, 180]:
    rotations['X'+str(angle)] = rotax( orig, X, angle*math.pi/180.)
    rotations['X-'+str(angle)] = rotax( orig, X, -angle*math.pi/180.)

for angle in [1, 5, 10, 30, 45, 90, 180]:
    rotations['Y'+str(angle)] = rotax( orig, Y, angle*math.pi/180.)
    rotations['Y-'+str(angle)] = rotax( orig, Y, -angle*math.pi/180.)

for angle in [1, 5, 10, 30, 45, 90, 180]:
    rotations['Z'+str(angle)] = rotax( orig, Z, angle*math.pi/180.)
    rotations['Z-'+str(angle)] = rotax( orig, Z, -angle*math.pi/180.)
Пример #18
0
    else:
        print 'Sorry! Unable to write this filetype->', filetype

    center = Numeric.add.reduce(mol.allAtoms.coords)/len(mol.allAtoms)
    crds = Numeric.array(mol.allAtoms.coords)
    center = Numeric.add.reduce(crds)/len(mol.allAtoms)
    crds = crds - center
    crds = crds.tolist()
    mol.allAtoms.updateCoords(crds)
    lenCoords = len(crds)
    #rotate the atoms here
    if axis is not None and angle is not None:
        rot = (float(angle)* 3.14159/180.)%(2 * Numeric.pi)
        x = Numeric.array([0.,0.,0.])
        y = Numeric.array(map(float,axis.split(',')))
        matrix = rotax(x,y, rot)
        _ones = Numeric.ones(lenCoords, 'f')
        _ones.shape = (lenCoords,1)
        mov_coords = Numeric.concatenate((crds, _ones),1)
        newcoords = Numeric.dot(mov_coords, matrix)
        nc = newcoords[:,:3].astype('f')
        for i in range(lenCoords):
            mol.allAtoms[i]._coords[0] = nc[i].tolist()
    else:
        if rotation=='z':
            #for rotation around z-axis:
            for a in mol.allAtoms:
                a._coords[0][0] = -1.*a._coords[0][0]
                a._coords[0][1] = -1.*a._coords[0][1]
        elif rotation=='y':
            #for rotation around y-axis:
Пример #19
0
    def getMatrices(self):
        pt1 = self.point
        v1 = self.vector
        r1 = self.hrise

        pt2 = self.point2
        v2 = self.vector2
        r2 = self.hrise2

        nbCopies = self.copies

        matrices1 = [] # overall helical transfomations
        matrices2 = [] # local helical transformations

        rv1 = (r1*v1[0], r1*v1[1], r1*v1[2]) # tanslation vector 1
        rv2 = (r2*v2[0], r2*v2[1], r2*v2[2]) # tanslation vector 2

        # rotation matrix for helix 1
        R = rotax( pt1, [pt1[0]+v1[0], pt1[1]+v1[1], pt1[2]+v1[2]],
                   self.angle, False)

        # rise transformation for helix 1
        riseMat1 = numpy.identity(4).astype('f')
        riseMat1[:3, 3] = rv1 # add the rise

        # helical step for helix 1
        transform1 = numpy.dot(riseMat1, R)

        # first transformation is didentity for both helices
        matrices1.append( numpy.identity(4).astype('f') )
        matrices2.append( numpy.identity(4).astype('f') )

        ang2 = self.angle2  # angle for helix 2
        # loop over number of copies
        for i in range(1,nbCopies):
            # take previous transfromation
            mat = matrices1[i-1]
            # add 1 helic step for overall helix
            mat = numpy.dot(mat, transform1)
            # save this in transformation for overall helix
            matrices1.append(mat)

            # move the point defining local helix along first helical axis
            p2t = (pt2[0]+(i*rv1[0]), pt2[1]+(i*rv1[1]), pt2[2]+(i*rv1[2]))

            # build local helix rotation
            R = rotax( p2t, [p2t[0]+v2[0], p2t[1]+v2[1], p2t[2]+v2[2]],
                       ang2, False)
            # build local helix raise
            riseMat2 = numpy.identity(4).astype('f')
            riseMat2[:3, 3] = rv2 # add the rise

            # build helical step for local helix 
            transform2 = numpy.dot(riseMat2, R)
            mat = matrices2[i-1]
            # apply step to previous helical step
            mat = numpy.dot(mat, transform2)
            matrices2.append(mat)

        # combine the overall helix wioth the local helix
        results = []
        results.append(numpy.identity(4).astype('f') )
        for i in range(1,nbCopies):
            results.append( numpy.dot(matrices2[i], matrices1[i]) )

        return results
Пример #20
0
    else:
        print('Sorry! Unable to write this filetype->', filetype)

    center = numpy.add.reduce(mol.allAtoms.coords) / len(mol.allAtoms)
    crds = numpy.array(mol.allAtoms.coords)
    center = numpy.add.reduce(crds) / len(mol.allAtoms)
    crds = crds - center
    crds = crds.tolist()
    mol.allAtoms.updateCoords(crds)
    lenCoords = len(crds)
    #rotate the atoms here
    if axis is not None and angle is not None:
        rot = (float(angle) * 3.14159 / 180.) % (2 * numpy.pi)
        x = numpy.array([0., 0., 0.])
        y = numpy.array(list(map(float, axis.split(','))))
        matrix = rotax(x, y, rot)
        _ones = numpy.ones(lenCoords, 'f')
        _ones.shape = (lenCoords, 1)
        mov_coords = numpy.concatenate((crds, _ones), 1)
        newcoords = numpy.dot(mov_coords, matrix)
        nc = newcoords[:, :3].astype('f')
        for i in range(lenCoords):
            mol.allAtoms[i]._coords[0] = nc[i].tolist()
    else:
        if rotation == 'z':
            #for rotation around z-axis:
            for a in mol.allAtoms:
                a._coords[0][0] = -1. * a._coords[0][0]
                a._coords[0][1] = -1. * a._coords[0][1]
        elif rotation == 'y':
            #for rotation around y-axis:
Пример #21
0
## Automatically adapted for numpy.oldnumeric Jul 23, 2007 by

#
#  collection of standard 4x4 rotation matrices
#  about the X, Y and Z axis of 10, 30, 45, 90, 180 degrees
#
rotations = {}

import math, numpy.oldnumeric as Numeric
from mglutil.math.rotax import rotax

orig = Numeric.array((0, 0, 0), 'f')
X = Numeric.array((1, 0, 0), 'f')
Y = Numeric.array((0, 1, 0), 'f')
Z = Numeric.array((0, 0, 1), 'f')

for angle in [1, 5, 10, 30, 45, 90, 180]:
    rotations['X' + str(angle)] = rotax(orig, X, angle * math.pi / 180.)
    rotations['X-' + str(angle)] = rotax(orig, X, -angle * math.pi / 180.)

for angle in [1, 5, 10, 30, 45, 90, 180]:
    rotations['Y' + str(angle)] = rotax(orig, Y, angle * math.pi / 180.)
    rotations['Y-' + str(angle)] = rotax(orig, Y, -angle * math.pi / 180.)

for angle in [1, 5, 10, 30, 45, 90, 180]:
    rotations['Z' + str(angle)] = rotax(orig, Z, angle * math.pi / 180.)
    rotations['Z-' + str(angle)] = rotax(orig, Z, -angle * math.pi / 180.)