[Chimera-users] matrixget/set, keyframes, and interpolation
Thomas Goddard
goddard at cgl.ucsf.edu
Fri Jun 16 10:22:54 PDT 2006
Hi Jonathan,
I just made an animation in Chimera that does more complicated motions
than rock and roll. It is the myosin thick filament analysis animation on
the Chimera animations page:
http://www.cgl.ucsf.edu/chimera/animations/animations.html
I created this with a Python script because it does many transitions
for which there is no Chimera command. I include my Python script
below (700 lines). It is messy but maybe you can mine it. The part
most relevant to your question is the move_model() function:
move_model(model_name, from_matrix, to_matrix, relative_to, fraction)
It moves a model a certain fraction (0-1) of the way from one position to
another position, with the positions given relative to a second model using
3 by 4 matrices. It uses positions relative to another model instead of
absolute positions because I was using this to fit a crystal structure into
a density map. If I later changed my viewpoint in Chimera I wanted it
to still work. To get these matrices I used the write_relative_transforms()
function called via a keyboard shortcut "wt". That wrote the matrices to
the Chimera reply log which I then copied into my script.
I think using the "matrixset <filename>" command for doing a smooth
transition is unwieldy. Every matrix would have to be in a separate file.
Two alternatives are to use a Python script to produce an animation as I
did, or to add a command to Chimera that does the smooth interpolation --
a Chimera command version of the above move_model() function. Using Python
requires more expertise. I think introducing the new Chimera command is
the way to go. There should also be a command to print the current matrices
like my "wt" shortcut. These two commands would be more usable versions
of matrixget/matrixset for the purpose of making smooth transitions.
If you would like I can write some Python code for these two commands
that you can drop into your existing Chimera.
Tom
----
Script that plays through myosin thick filament animation.
This will not run for you since you do not have the data files.
# -----------------------------------------------------------------------------
# Script that runs through animation of myosin thick filament density map.
#
# -----------------------------------------------------------------------------
#
def play():
from os.path import join, dirname, realpath
import myosinmovie
dir = join(dirname(realpath(myosinmovie.__path__[0])), 'data')
map_name = 'myosin2.mrc'
map_color = (.7, .7, .7, 1) # gray
map_color_t = map_color[:3] + (.7,) # transparent
head_color = (1,.7,0,1) # orange
subfil_color = (.980, .502, .447, 1) # salmon
map2 = map_name + ' <1>'
pdb1i84 = '1i84-notail.pdb'
tail = 'tail.cmm'
tailname = 'myosin tail'
subfil = map(lambda s: 'subfilament%d.mrc' % s, range(13))
sfpaths = map(lambda sf: join(dir,sf), subfil)
sfeven = subfil[::2]
sfodd = subfil[1::2]
sfocolor = (.7,.7,.3,1) # yellow
sf = 'subfilament9.mrc'
fc = 'subfilament0.mrc'
fc_color = (.8,.6,.4,1)
sfo = filter(lambda s: s != fc, subfil)
sf11= sfo[sfo.index(sf)+1:] + sfo[:sfo.index(sf)]
sf11r = list(sf11)
sf11r.reverse()
show_caption = '2dlabel change caption text "%s" color black xpos %f ypos .95 visibility show'
show_caption2 = '2dlabel change caption text "%s" color black xpos %f ypos .97 size %d visibility show'
caption_fade = '2dlabel change caption visibility hide frames 5'
caption_fade_delay = 15
# Position of 1i84 close to eye.
mt1 = ((-0.099649198789025978, 0.74111595074467951, 0.66394064850144952, -1008.6712224936828), (0.5863861489863087, -0.49534104948956315, 0.64092786565072368, -966.59941472485207), (0.80387892213797729, 0.45319354832389019, -0.38521978960054565, -124.9728590025926))
# Position of 1i84 to right of filament
mt2 = ((0.073345968301112466, 0.62005697667643067, 0.78112080666748807, -140.8575902922845), (0.55558955434916146, -0.6758394649115651, 0.48431525349317678, -344.80539061238528), (0.82821531984869479, 0.39845998963878676, -0.3940672793127869, -124.7725634028488))
# Position of 1i84 hand fit
mt3 = ((-0.011137186324278462, 0.57090152267568484, 0.8209430031904611, -117.86331645089319), (0.64007270897455237, -0.62668401091081916, 0.4444930569702038, -121.04296346830751), (0.76823361701162263, 0.53041361396114306, -0.35843898758075837, -132.97686247292341))
# Position of 1i84 computationally optimized
mt4 = ((0.067350631154440885, 0.35912771983826075, 0.93085507643610677, -94.436118828488432), (0.78371645512883981, -0.59642399619826492, 0.1733981969894075, -121.53565912095156), (0.61745640367833565, 0.71784796273491214, -0.32162383610975182, -142.36032454320915))
# Position of 1i84 backwards fit by hand
mt5 = ((0.040717288582604753, -0.68893892247763189, -0.72367483271552346, -41.989737858895808), (0.015968304931079015, 0.72463165183091871, -0.68895136432292714, -177.57106879703232), (0.9990430999952451, 0.016496371120766563, 0.040506222876700852, -112.28404385096682))
# Position of 1i84 backwards fit optimized
mt6 = ((0.075798794154165489, -0.41125005975496942, -0.90836552728310249, -50.078309013435728), (0.26520245923950292, 0.88648910828917349, -0.37921592331808268, -190.88698833314771), (0.96120871740641978, -0.21215666201229763, 0.17625933264853111, -90.233284436572831))
# Position of 1i84 forward and right of filament for float in.
mt7 = ((0.067350631154428922, 0.3591277198382945, 0.93085507643609822, -58.351913517245023), (0.78371645512883925, -0.59642399619825837, 0.17339819698943759, -483.01076846693888), (0.61745640367833865, 0.71784796273490414, -0.3216238361097708, -244.42186962044607))
# Position of subfilament tilted out.
sfmt1 = ((0.97415635283527546, -0.025843647164727198, -0.22439141278557448, -103.49134676516807), (-0.025843647164727226, 0.97415635283527724, -0.22439141278557453, -107.25466846571966), (0.22439141278557431, 0.2243914127855747, 0.94831270567054426, -10.644281176985976))
# Position of subfilament displaced out.
sfmt2 = ((0.9999957248565281, -4.2751434744161616e-06, -0.0029240811200199287, -214.50933693143944), (-4.275143474582695e-06, 0.9999957248565301, -0.0029240811200196941, -218.27265863199113), (0.0029240811200198034, 0.0029240811200199092, 0.99999144971304987, 11.974816324109245))
# Positioning of tail forward and right of filament for float in.
tmt1 = ((1.0000000000000038, 0.0, -1.262386893235071e-32, 36.084205311245618), (0.0, 1.0000000000000038, -1.4293409452891395e-31, -361.47510934598643), (-1.262386893235071e-32, -1.4293409452891395e-31, 1.0, -102.06154507723714))
from PDBmatrices import identity_matrix
identity = identity_matrix()
from chimera.statusline import show_status_line
from Accelerators.standard_accelerators import sphere_representation
from Accelerators.standard_accelerators import select_all, clear_selection
p = Player()
sequence = [
(show_status_line, {'show': False}), # Needed to set small window widths.
(set_window, {'size': (440,800), 'color':(1,1,1)}),
2, # Need window size update before setting label background.
(label_background, {'position': (0,.92), 'size': (1.0,.11),
'color': 'white'}),
'2dlabel create caption text "Myosin thick filament, EM map" color black xpos .1 ypos .95',
'open %s' % join(dir,map_name),
'scale 2',
(set_center_of_rotation, {'center': (0,0,0)}),
'turn x -90',
(set_map, {'map_name': map_name,'threshold': 0.2, 'style': 'surface'}),
'roll y 0.5 90',
75,
(duplicate_map, {'map_name': map_name}),
(set_map, {'map_name': map2, 'threshold': 0.15, 'style': 'surface',
'bounds':((0,0,41), (99,99,81),(1,1,1))}),
(set_map, {'map_name': map2, 'color': (.2,.2,.6,.0)},
{'color': (.2,.2,.6,.5)}, 30),
30,
caption_fade, caption_fade_delay,
show_caption % ('Symmetry: 90 degree rotation', .1),
(move_only, {'model_name': map2}),
'turn y 3 30',
50,
caption_fade, caption_fade_delay,
show_caption % ('Symmetry: 43.5 nm translation', .1),
'move y 7.5 58',
80,
caption_fade, caption_fade_delay,
show_caption % ('Four strand helix', .3),
'turn y -1 30',
'move y -5 29',
45,
'turn y -1 30',
'move y -5 29',
45,
'turn y -1 30',
'move y -5 29',
60,
(set_map, {'map_name': map2, 'color': (.2,.2,.6,.5)},
{'color': (.2,.2,.6,0)}, 20),
20,
(unshow_map, {'map_name': map2}),
(move_only, {'model_name': 'all'}),
caption_fade, caption_fade_delay,
show_caption % ("Myosin heads, 'J' shapes on surface", .02),
(cylinder_color,
{'model_name': map_name, 'colormap':((120, map_color),(121, map_color))},
{'colormap':((120, map_color),(121, head_color))}, 30),
60,
caption_fade, caption_fade_delay,
show_caption % ('Myosin tails make filament body', .1),
(cylinder_color,
{'model_name': map_name, 'colormap':((120, map_color),(121, head_color))},
{'colormap':((110, subfil_color),(111, map_color))}, 30),
60,
caption_fade, caption_fade_delay,
show_caption % ('Fit myosin model, hand placement', .05),
'open %s' % join(dir,pdb1i84),
'rainbow chain',
(sphere_representation, {}),
(place_model, {'model_name': pdb1i84, 'matrix': mt1, 'relative_to':map_name}),
(set_near_far, {'near': 577.7, 'far':-568.161},
{'near': 1700, 'far':-1700}, 10),
30,
(move_model, {'model_name': pdb1i84, 'relative_to':map_name,
'from_matrix': mt1, 'to_matrix': mt2, 'fraction':0},
{'fraction':1}, 30),
30,
(move_model, {'model_name': pdb1i84, 'relative_to':map_name,
'from_matrix': mt2, 'to_matrix': mt3, 'fraction':0},
{'fraction':1}, 30),
20,
'scale 1.02 25',
30,
caption_fade, caption_fade_delay,
show_caption % ('Computational fit optimization', .1),
(select_all, {}),
(cylinder_color,
{'model_name': map_name, 'colormap':((110, subfil_color),(111, map_color))},
{'colormap':((110, subfil_color),(111, map_color_t))}, 30),
(move_model, {'model_name': pdb1i84, 'relative_to':map_name,
'from_matrix': mt3, 'to_matrix': mt4, 'fraction':0},
{'fraction':1}, 30),
30,
(clear_selection, {}),
30,
caption_fade, caption_fade_delay,
show_caption % ('Flip and fit - wrong orientation', .1),
(move_model, {'model_name': pdb1i84, 'relative_to':map_name,
'from_matrix': mt4, 'to_matrix': mt5, 'fraction':0},
{'fraction':1}, 15),
15,
(move_model, {'model_name': pdb1i84, 'relative_to':map_name,
'from_matrix': mt5, 'to_matrix': mt6, 'fraction':0},
{'fraction':1}, 15),
45,
caption_fade, caption_fade_delay,
show_caption % ('Fitting with symmetric copies', .1),
(symmetric_copies, {'molecule_name': pdb1i84}),
(move_only, {'model_name': pdb1i84}), # Needed for sym copies to work
'rainbow chain',
15,
(move_model, {'model_name': pdb1i84, 'relative_to':map_name,
'from_matrix': mt6, 'to_matrix': mt4, 'fraction':0},
{'fraction':1}, 30),
60,
(symmetric_copies, {'molecule_name': pdb1i84, 'show': False}),
(move_only, {'model_name': 'all'}),
(cylinder_color,
{'model_name': map_name, 'colormap':((110, subfil_color),(111, map_color_t))},
{'colormap':((110, map_color_t),(111, map_color_t))}, 30),
30,
caption_fade, caption_fade_delay,
show_caption % ('Myosin tail, hand traced', .2),
'open %s' % join(dir,tail),
(show_atom_sequence, {'molecule_name': tailname, 'count': 1},
{'count': 10}, 60),
30,
'scale .975 30',
60,
(cylinder_color,
{'model_name': map_name, 'colormap':((110, map_color_t),(111, map_color_t))},
{'colormap':((110, map_color),(111, map_color))}, 15),
15,
(unshow_model, {'model_name': (pdb1i84, tailname)}),
caption_fade, caption_fade_delay,
show_caption % ('Filament has 12 subfilaments', .1),
(open_models, {'paths': sfpaths}),
(set_map, {'map_name': subfil, 'threshold': 0.2, 'style': 'surface', 'color': map_color}),
(set_map, {'map_name': fc, 'color': fc_color}),
(unshow_map, {'map_name': map_name}),
(set_map, {'map_name': sfodd, 'color': map_color},
{'color':sfocolor}, 60),
60,
(set_center_of_rotation, {'center': (0, 0, 0)}),
'roll y 3 15',
30,
(move_model, {'model_name': sf, 'relative_to': map_name,
'from_matrix': identity, 'to_matrix': sfmt1, 'fraction':0},
{'fraction':1}, 15),
15,
(move_model, {'model_name': sf, 'relative_to': map_name,
'from_matrix': sfmt1, 'to_matrix': sfmt2, 'fraction':0},
{'fraction':1}, 15),
25,
(set_center_of_rotation, {'center': (275, 10, 257)}),
(move_only, {'model_name': sf}),
'roll y 4 90',
90,
(move_only, {'model_name': 'all'}),
(set_center_of_rotation, {'center': (0, 0, 0)}),
(explode, {'model_names': sfo, 'factor': 1.03}, {}, 60),
45,
(set_map, {'map_name': sfo, 'opacity': 1.0}, {'opacity':0}, 15),
45,
caption_fade, caption_fade_delay,
show_caption % ('Filament core, contents unknown', .05),
'roll y -0.5 90',
'scale 1.01 60',
45,
(place_model, {'model_name': subfil, 'matrix': identity, 'relative_to':map_name}),
(set_map, {'map_name': sf11, 'opacity': 1.0}),
(place_model, {'model_name': sf11, 'matrix': identity, 'relative_to':map_name}),
(show_model_sequence, {'model_names': sf11r, 'count': 1},
{'count':11}, 45),
45,
caption_fade, caption_fade_delay,
show_caption2 % (' Animation created with UCSF Chimera.\\nData from John Woodhead and Roger Craig', .05, 18),
(set_map, {'map_name': sf, 'style': 'mesh', 'color': sfocolor,
'opacity': 0.0, 'square_mesh': True}, {'opacity':0.4}, 30),
(show_model, {'model_name': (pdb1i84, tailname)}),
(move_model, {'model_name': pdb1i84, 'relative_to': map_name,
'from_matrix': mt7, 'to_matrix': mt4, 'fraction':0},
{'fraction':1}, 30),
(move_model, {'model_name': tailname, 'relative_to': map_name,
'from_matrix': tmt1, 'to_matrix': identity, 'fraction':0},
{'fraction':1}, 30),
]
p.play_sequence(sequence)
# -----------------------------------------------------------------------------
#
class Player:
def __init__(self):
self.sequence = []
self.delay = 0
self.transitions = []
self.new_frame_handler = None
# ---------------------------------------------------------------------------
#
def play_sequence(self, sequence):
self.sequence = sequence
self.delay = 0
from chimera import triggers
h = triggers.addHandler('new frame', self.new_frame, None)
self.new_frame_handler = h
# ---------------------------------------------------------------------------
#
def new_frame(self, trigger_name, call_data, trigger_data):
t = 0
while t < len(self.transitions):
command, kw_begin, kw_end, frames, cur = self.transitions[t]
cur += 1
if cur > frames:
del self.transitions[t]
continue
self.transitions[t] = (command, kw_begin, kw_end, frames, cur)
kw = self.interpolate_parameters(kw_begin, kw_end, frames, cur)
command(**kw)
t += 1
while self.sequence:
if self.delay > 0:
self.delay -= 1
break
s = self.sequence[0]
del self.sequence[0]
if type(s) is int:
self.frame_delay(s)
elif type(s) is type(''):
run_command(s)
elif len(s) == 2:
command, kw = s
command(**kw)
elif len(s) == 4:
command, kw_begin, kw_end, frames = s
command(**kw_begin)
if frames > 1:
self.transitions.append((command, kw_begin, kw_end, frames, 1))
if (len(self.sequence) == 0 and
len(self.transitions) == 0 and
self.new_frame_handler):
from chimera import triggers
triggers.deleteHandler('new frame', self.new_frame_handler)
self.new_frame_handler = None
# ---------------------------------------------------------------------------
#
def frame_delay(self, frames):
self.delay = frames
# ---------------------------------------------------------------------------
#
def interpolate_parameters(self, kw_begin, kw_end, frames, cur):
kw = {}
kw.update(kw_begin)
f = float(cur) / frames
for key, value in kw_end.items():
kw[key] = self.interpolate_parameter(kw[key], value, f)
return kw
# ---------------------------------------------------------------------------
#
def interpolate_parameter(self, v0, v1, f):
if type(v0) in (int, float):
v = (1-f) * v0 + f * v1
return v
elif type(v0) in (tuple, list):
v = map(lambda e0, e1: self.interpolate_parameter(e0, e1, f), v0, v1)
return v
raise TypeError, 'Bad transition parameter of type ' + str(type(v0))
# -----------------------------------------------------------------------------
#
def set_window(size = None, color = None):
if size != None:
set_window_size(*size)
if color != None:
from Accelerators.standard_accelerators import set_background
set_background(color)
# -----------------------------------------------------------------------------
#
def set_window_size(width, height):
from chimera import viewer
viewer.windowSize = (width, height)
# -----------------------------------------------------------------------------
#
def run_command(command):
from chimera import runCommand
runCommand(command)
# -----------------------------------------------------------------------------
#
def move_only(model_name):
from chimera import openModels
mlist = openModels.list()
if model_name == 'all':
for m in mlist:
m.openState.active = True
else:
for m in mlist:
m.openState.active = False
for m in filter(lambda m: m.name == model_name, mlist):
m.openState.active = True
# -----------------------------------------------------------------------------
#
def set_map(map_name, style = None, threshold = None, color = None,
opacity = None, square_mesh = None, bounds = None):
if type(map_name) in (list, tuple):
for mname in map_name:
set_map(mname, style, threshold, color, opacity, square_mesh, bounds)
return
dr = find_map(map_name)
if style != None:
set_map_style(map_name, style)
if threshold != None:
set_map_threshold(map_name, threshold)
if color != None:
set_map_color(map_name, color)
if opacity != None:
set_map_opacity(map_name, opacity)
if square_mesh != None:
set_map_rendering_option(map_name, 'square_mesh', square_mesh)
if bounds != None:
set_map_bounds(map_name, bounds)
show_map(map_name)
# -----------------------------------------------------------------------------
#
def set_map_threshold(map_name, threshold):
dr = find_map(map_name)
dr.components[0].surface_levels = [threshold]
show_map(map_name)
# -----------------------------------------------------------------------------
#
def set_map_bounds(map_name, bounds):
dr = find_map(map_name)
dr.new_region(bounds)
show_map(map_name)
# -----------------------------------------------------------------------------
#
def set_map_style(map_name, style):
dr = find_map(map_name)
dr.representation = style
show_map(map_name)
# -----------------------------------------------------------------------------
#
def set_map_color(map_name, rgba):
dr = find_map(map_name)
for c in dr.components:
c.surface_colors = [rgba] * len(c.surface_colors)
show_map(map_name)
# -----------------------------------------------------------------------------
#
def set_map_opacity(map_name, opacity):
dr = find_map(map_name)
for c in dr.components:
c.surface_colors = map(lambda rgba: tuple(rgba[:3]) + (opacity,),
c.surface_colors)
show_map(map_name)
# -----------------------------------------------------------------------------
#
def set_map_rendering_option(map_name, option_name, value):
dr = find_map(map_name)
setattr(dr.rendering_options, option_name, value)
show_map(map_name)
# -----------------------------------------------------------------------------
#
def find_map(map_name):
dr = volume_dialog().find_data_by_name(map_name)
return dr
# -----------------------------------------------------------------------------
#
def show_map(map_name):
dr = find_map(map_name)
volume_dialog().show_data_regions([dr])
# -----------------------------------------------------------------------------
#
def unshow_map(map_name):
dr = find_map(map_name)
dr.unshow()
# -----------------------------------------------------------------------------
#
def volume_dialog():
import VolumeViewer
d = VolumeViewer.volume_dialog()
return d
# -----------------------------------------------------------------------------
#
def set_center_of_rotation(center):
from chimera import openModels, Point
if center == None:
openModels.cofrMethod = openModels.CenterOfModels
else:
openModels.cofr = Point(*center)
openModels.cofrMethod = openModels.Fixed
# -----------------------------------------------------------------------------
#
def duplicate_map(map_name):
dr = find_map(map_name)
d = volume_dialog()
dr2 = d.duplicate_region(dr)
d.show_data_regions([dr2])
# -----------------------------------------------------------------------------
#
def cylinder_color(model_name, colormap):
model = find_model_by_name(model_name)
from SurfaceColor import Color_Map, Cylinder_Color, color_surface
values = map(lambda vc: vc[0], colormap)
colors = map(lambda vc: vc[1], colormap)
color_source = Cylinder_Color()
color_source.colormap = Color_Map(values, colors)
color_surface(model, color_source, caps_only = False, auto_update = False)
# -----------------------------------------------------------------------------
#
def find_model_by_name(model_name):
from chimera import openModels
m = filter(lambda m: m.name == model_name, openModels.list())[0]
return m
# -----------------------------------------------------------------------------
#
def show_model(model_name, show = True):
if type(model_name) in (tuple, list):
for mname in model_name:
show_model(mname, show)
return
model = find_model_by_name(model_name)
model.display = show
# -----------------------------------------------------------------------------
#
def unshow_model(model_name):
show_model(model_name, show = False)
# -----------------------------------------------------------------------------
#
def place_model(model_name, matrix, relative_to):
if type(model_name) in (tuple, list):
for mname in model_name:
place_model(mname, matrix, relative_to)
return
model = find_model_by_name(model_name)
rmodel = find_model_by_name(relative_to)
from PDBmatrices import chimera_xform
xf = chimera_xform(matrix)
rxf = rmodel.openState.xform
xf.premultiply(rxf)
model.openState.xform = xf
# -----------------------------------------------------------------------------
#
def move_model(model_name, from_matrix, to_matrix, relative_to, fraction):
model = find_model_by_name(model_name)
rmodel = find_model_by_name(relative_to)
from PDBmatrices import chimera_xform
fxf = chimera_xform(from_matrix)
txf = chimera_xform(to_matrix)
rxf = rmodel.openState.xform
fxf.premultiply(rxf)
txf.premultiply(rxf)
# Find model center
have_box, bbox = model.bbox()
c = bbox.center()
cf = fxf.apply(c)
ct = txf.apply(c)
# Determine fractional translation
from chimera import Xform, Vector, Point
td = Xform.translation((ct-cf)*fraction)
# Determine fractional rotation
r = fxf.inverse()
r.premultiply(txf)
axis, angle = r.getRotation()
rd = Xform.rotation(axis, fraction*angle)
cv = Xform.translation(cf - Point())
cvi = Xform.translation(Point() - cf)
xf = Xform()
xf.multiply(fxf) # Apply start transform
xf.premultiply(cvi) # Shift to put model center at origin
xf.premultiply(rd) # Apply fractional rotation
xf.premultiply(cv) # Shift center back to from position
xf.premultiply(td) # Apply fractional translation
model.openState.xform = xf
# -----------------------------------------------------------------------------
#
def set_near_far(near, far):
from chimera import viewer
c = viewer.camera
c.nearFar = (near, far)
# -----------------------------------------------------------------------------
#
def symmetric_copies(molecule_name, show = True):
m = find_model_by_name(molecule_name)
if show:
run_command('sym #%d' % m.id)
else:
run_command('~sym #%d' % m.id)
# -----------------------------------------------------------------------------
#
def show_atom_sequence(molecule_name, count):
m = find_model_by_name(molecule_name)
count = int(count)
alist = m.atoms
for a in alist[:count]:
a.display = True
for a in alist[count:]:
a.display = False
# -----------------------------------------------------------------------------
#
def show_model_sequence(model_names, count):
mlist = map(find_model_by_name, model_names)
count = int(count)
for m in mlist[:count]:
m.display = True
for m in mlist[count:]:
m.display = False
# -----------------------------------------------------------------------------
#
def open_models(paths):
for path in paths:
run_command('open %s' % path)
# -----------------------------------------------------------------------------
#
def explode(model_names, factor):
mlist = map(find_model_by_name, model_names)
centers = map(lambda m: m.openState.xform.apply(m.bbox()[1].center()), mlist)
n = len(model_names)
from chimera import Point, Xform
c = Point(centers, [1.0/n]*n)
for k in range(len(mlist)):
delta = (centers[k] - c) * (factor - 1.0)
xf = Xform.translation(delta)
mlist[k].openState.globalXform(xf)
# -----------------------------------------------------------------------------
# Make a solid background for drawing labels.
# This hack uses several labels containing strings of ells.
#
def label_background(position, size, color):
import chimera
v = chimera.viewer
wsize = v.windowSize
fsize = int(size[1] * wsize[1]) # pixels
lcount = int(5 * float(wsize[0]) / fsize)
ells = 'l' * lcount
xstep = (.07 * fsize) / wsize[0]
for k in range(4):
run_command('2dlabel create bg%d text "%s" color %s xpos %f ypos %f size %d'
% (k, ells, color, position[0] + k*xstep, position[1], fsize))
# -----------------------------------------------------------------------------
#
def write_relative_transforms():
from chimera import openModels
mlist = openModels.list()
m0 = mlist[0]
print 'Matrices relative to', m0.name
xf_ref = m0.openState.xform
xf_ref_inv = xf_ref.inverse()
for m in mlist[1:]:
xf = m.openState.xform
xf.premultiply(xf_ref_inv)
from PDBmatrices import xform_matrix, is_identity_matrix
mt = xform_matrix(xf)
if not is_identity_matrix(mt):
print m.name, repr(mt)
# -----------------------------------------------------------------------------
#
from Accelerators import add_accelerator
add_accelerator('pm', 'Play myosin thick filament movie', play)
add_accelerator('wt', 'Write relative transformation matrices',
write_relative_transforms)
More information about the Chimera-users
mailing list