def spine(operation,
regions,
spacing=None,
tipLength=None,
color=None,
showDiameter=False):
sel = parse_object_specifier(regions, 'segmentation region')
import Surface
plist = Surface.selected_surface_pieces(sel, include_outline_boxes=False)
from Segger.regions import Segmentation
rlist = [
p.region for p in plist
if (hasattr(p, 'region') and isinstance(p.model, Segmentation))
]
if len(rlist) == 0:
raise CommandError('No segmentation regions specified: "%s"' % regions)
if not (spacing is None or isinstance(spacing,
(int, float)) and spacing > 0):
raise CommandError('spacing must be positive numeric value')
if not (tipLength is None or isinstance(tipLength,
(int, float)) and tipLength > 0):
raise CommandError('tipLength must be positive numeric value')
if not color is None:
from Commands import parse_color
color = parse_color(color)
if showDiameter:
from _surface import SurfaceModel
diam_model = SurfaceModel()
diam_model.name = 'Diameters'
from chimera import openModels
openModels.add([diam_model], sameAs=rlist[0].segmentation)
else:
diam_model = None
import spine
from chimera import replyobj
from PathLength import path_length
for r in rlist:
mset = spine.trace_spine(r, spacing, tipLength, color)
slen = path_length([l.bond for l in mset.links()])
r.set_attribute('spine length', slen)
msg = 'Spine length for region %d is %.4g' % (r.rid, slen)
dmax, dmin = spine.measure_diameter(r, mset, diam_model)
if not dmax is None:
r.set_attribute('diameter1', dmax)
r.set_attribute('diameter2', dmin)
msg += ', diameters %.4g, %.4g' % (dmax, dmin)
kave, kmin, kmax = spine.measure_curvature(mset)
if not kmax is None:
r.set_attribute('curvature average', kave)
r.set_attribute('curvature minimum', kmin)
r.set_attribute('curvature maximum', kmax)
msg += ', curvature %.4g (ave), %.4g (max), %.4g (min)' % (
kave, kmax, kmin)
replyobj.info(msg + '\n')
def show_cb(self, event=None, model_id=None):
radius = self.radius.value(self.default_radius)
sphere_factor = self.sphere_factor.value(0)
surface_style = self.surface_style.get()
orientation = self.orientation_name()
subdivision_levels = self.subdivision_levels(radius)
if self.surface_model == None:
import _surface
sm = _surface.SurfaceModel()
sm.name = 'Icosahedron'
self.surface_model = sm
import chimera
chimera.addModelClosedCallback(sm, self.surface_closed_cb)
self.surface_piece = None
from Icosahedron import make_icosahedron_surface
p = make_icosahedron_surface(radius, orientation, subdivision_levels,
sphere_factor, surface_style,
self.color.rgba, self.surface_model)
if self.surface_piece:
self.surface_model.removePiece(self.surface_piece)
else:
from chimera import openModels as om
if model_id is None:
id = subid = om.Default
else:
id, subid = model_id
om.add([self.surface_model], baseId=id, subid=subid)
self.surface_piece = p
def make_molecule_map(atoms, resolution, step, pad, cutoff_range,
sigma_factor, display_threshold, model_id, replace,
show_dialog):
atoms = tuple(atoms)
grid, molecules = molecule_grid_data(atoms, resolution, step, pad,
cutoff_range, sigma_factor)
from chimera import openModels as om
if replace:
from VolumeViewer import volume_list
vlist = [v for v in volume_list()
if getattr(v, 'molmap_atoms', None) == atoms]
om.close(vlist)
from VolumeViewer import volume_from_grid_data
v = volume_from_grid_data(grid, open_model = False,
show_dialog = show_dialog)
v.initialize_thresholds(mfrac = (display_threshold, 1), replace = True)
v.show()
v.molmap_atoms = tuple(atoms) # Remember atoms used to calculate volume
v.molmap_parameters = (resolution, step, pad, cutoff_range, sigma_factor)
if len(molecules) == 1 and model_id is None:
om.add([v], sameAs = tuple(molecules)[0])
else:
if model_id is None:
model_id = (om.Default, om.Default)
om.add([v], baseId = model_id[0], subid = model_id[1])
v.openState.xform = atoms[0].molecule.openState.xform
return v
def subdivide_op(surfaces, spacing = None, inPlace = False, modelId = None):
from Commands import parse_surface_pieces, check_number, parse_model_id
plist = parse_surface_pieces(surfaces)
if len(plist) == 0:
raise CommandError, 'No surfaces specified'
if spacing is None:
raise CommandError, 'Must specify mesh spacing'
check_number(spacing, 'spacing', positive = True)
model_id = parse_model_id(modelId)
if inPlace:
s = None
else:
from _surface import SurfaceModel
s = SurfaceModel()
s.name = 'finer mesh'
from chimera import openModels as om
if model_id:
id, subid = model_id
else:
id, subid = om.Default, om.Default
om.add([s], baseId = id, subid = subid)
s.openState.xform = plist[0].model.openState.xform
from subdivide import subdivide
for p in plist:
np = subdivide(p, spacing, s)
if np != p:
np.save_in_session = True
def show_cb(self, event = None, model_id = None):
radius = self.radius.value(self.default_radius)
sphere_factor = self.sphere_factor.value(0)
surface_style = self.surface_style.get()
orientation = self.orientation_name()
subdivision_levels = self.subdivision_levels(radius)
if self.surface_model == None:
import _surface
sm = _surface.SurfaceModel()
sm.name = 'Icosahedron'
self.surface_model = sm
import chimera
chimera.addModelClosedCallback(sm, self.surface_closed_cb)
self.surface_piece = None
from Icosahedron import make_icosahedron_surface
p = make_icosahedron_surface(radius, orientation, subdivision_levels,
sphere_factor, surface_style, self.color.rgba,
self.surface_model)
if self.surface_piece:
self.surface_model.removePiece(self.surface_piece)
else:
from chimera import openModels as om
if model_id is None:
id = subid = om.Default
else:
id, subid = model_id
om.add([self.surface_model], baseId = id, subid = subid)
self.surface_piece = p
def split_molecules(cmdname, args):
fields = args.split()
from chimera import openModels, Molecule
if len(fields) >= 1:
from chimera import specifier
sel = specifier.evalSpec(fields[0])
mlist = sel.molecules()
else:
mlist = openModels.list(modelTypes=[Molecule])
if len(mlist) == 0:
from Midas.midas_text import error
error('%s: No molecules to split.' % cmdname)
return
slist = []
for m in mlist:
clist = split_molecule(m)
if clist:
openModels.add(clist, baseId=m.id, noprefs=True)
for c in clist:
c.openState.xform = m.openState.xform
slist.append(m)
from chimera import makeLongBondsDashed, makePseudoBondsToMetals
makePseudoBondsToMetals(clist)
makeLongBondsDashed(clist)
openModels.close(slist)
def create_patch(v, n, t, surf, color, offset = 0, slab = None):
from _surface import SurfaceModel
s = SurfaceModel()
s.name = 'contact patch'
from chimera import openModels as om
om.add([s])
s.openState.xform = surf.openState.xform
p = s.newPiece()
p.color = color
p.save_in_session = True
if offset:
vo = v.copy()
vo += n*offset
p.geometry = vo,t
p.normals = n
if slab:
from Mask import depthmask
vs, ns, ts = depthmask.slab_surface(v, t, n, slab, sharp_edges = True)
p.geometry = vs,ts
p.normals = ns
return p
def make_molecule_map(atoms, resolution, step, pad, cutoff_range, sigma_factor,
display_threshold, model_id, replace, show_dialog):
atoms = tuple(atoms)
grid, molecules = molecule_grid_data(atoms, resolution, step, pad,
cutoff_range, sigma_factor)
from chimera import openModels as om
if replace:
from VolumeViewer import volume_list
vlist = [
v for v in volume_list()
if getattr(v, 'molmap_atoms', None) == atoms
]
om.close(vlist)
from VolumeViewer import volume_from_grid_data
v = volume_from_grid_data(grid, open_model=False, show_dialog=show_dialog)
v.initialize_thresholds(mfrac=(display_threshold, 1), replace=True)
v.show()
v.molmap_atoms = tuple(atoms) # Remember atoms used to calculate volume
v.molmap_parameters = (resolution, step, pad, cutoff_range, sigma_factor)
if len(molecules) == 1 and model_id is None:
om.add([v], sameAs=tuple(molecules)[0])
else:
if model_id is None:
model_id = (om.Default, om.Default)
om.add([v], baseId=model_id[0], subid=model_id[1])
v.openState.xform = atoms[0].molecule.openState.xform
return v
def show_ellipsoid(axes, d2, center, model):
from math import sqrt
d = [sqrt(e) for e in d2]
sm = ellipsoid_surface(center, axes, d)
sm.name = 'inertia ellipsoid for %s' % m.name
from chimera import openModels as om
om.add([sm], sameAs=model)
def surface_model(surface, xf, name):
if surface is None:
import _surface
s = _surface.SurfaceModel()
s.name = name
from chimera import openModels as om
om.add([s])
s.openState.xform = xf
return s
return surface
def surface_model(surface, xf, name):
if surface is None:
import _surface
s = _surface.SurfaceModel()
s.name = name
from chimera import openModels as om
om.add([s])
s.openState.xform = xf
return s
return surface
def new_surface(name, align_to, model_id):
from _surface import SurfaceModel
s = SurfaceModel()
s.name = name
from chimera import openModels as om
if model_id:
id, subid = model_id
else:
id, subid = om.Default, om.Default
om.add([s], baseId=id, subid=subid)
s.openState.xform = align_to.openState.xform
return s
def create_symmetry_copies(mol,
csys,
tflist,
cdist,
rdist,
exclude_identity=True):
if exclude_identity:
from Matrix import is_identity_matrix
tflist = [tf for tf in tflist if not is_identity_matrix(tf)]
close_contacts = not cdist is None
close_centers = not rdist is None
if not close_contacts and not close_centers:
transforms = tflist # Use all transforms
elif close_contacts and not close_centers:
transforms = contacting_transforms(mol, csys, tflist, cdist)
elif close_centers and not close_contacts:
transforms = close_center_transforms(mol, csys, tflist, rdist)
else:
transforms = unique(
contacting_transforms(mol, csys, tflist, cdist) +
close_center_transforms(mol, csys, tflist, rdist))
if hasattr(mol, 'symmetry_copies'):
remove_symmetry_copies(mol)
copies = []
from chimera import openModels, replyobj
from PDBmatrices import copy_molecule
from Matrix import chimera_xform
for tf in transforms:
copy = copy_molecule(mol)
copy.symmetry_xform = chimera_xform(tf)
copies.append(copy)
replyobj.status('Created symmetry copy %d of %d' %
(len(copies), len(transforms)))
if len(copies) == 0:
return copies
openModels.add(copies)
replyobj.status('')
mol.symmetry_copies = copies
mol.symmetry_reference_model = csys
# TODO: Set xform before opening so that code that detects open sees
# the correct position. Currently not possible. Bug 4486.
update_symmetry_positions(mol)
return copies
def show_slabs(xf, color, center, os):
# Make schematic illustrating rotation
if color is None:
color = (.7, .7, .7, 1)
import MatchDomains
sm = MatchDomains.transform_schematic(xf, center, color, color)
if sm:
sm.name = 'slabs'
from chimera import openModels as om
om.add([sm])
sm.openState.xform = os.xform
return sm
def surface_model(model_id, shape_name, coord_xform = None):
s = find_surface_model(model_id)
if s is None:
from _surface import SurfaceModel
s = SurfaceModel()
s.name = shape_name
from chimera import openModels as om
if model_id is None:
model_id = (om.Default, om.Default)
om.add([s], baseId = model_id[0], subid = model_id[1])
if coord_xform:
s.openState.xform = coord_xform
return s
def marker_molecule(self, model_id=None):
if self.molecule == None:
from chimera import Molecule, openModels
m = Molecule()
m.name = self.name
if model_id == None:
id = subid = openModels.Default
else:
id, subid = model_id
self.set_marker_molecule(m)
openModels.add([m], baseId=id, subid=subid, noprefs=True)
return self.molecule
def surface_model(model_id, shape_name, coord_xform=None):
s = find_surface_model(model_id)
if s is None:
from _surface import SurfaceModel
s = SurfaceModel()
s.name = shape_name
from chimera import openModels as om
if model_id is None:
model_id = (om.Default, om.Default)
om.add([s], baseId=model_id[0], subid=model_id[1])
if coord_xform:
s.openState.xform = coord_xform
return s
def test():
from numpy import array, float32, int32
varray = array(((0, 0, 0), (5.1, 0, 0), (5.1, 8.5, 0)), float32)
narray = array(((0, 0, 1), (0, 0, 1), (0, 0, 1)), float32)
tarray = array(((0, 1, 2), ), int32)
elength = 1
va, ta = subdivided_geometry(varray, tarray, narray, elength)
import _surface
s = _surface.SurfaceModel()
color = (1, 1, 1, 1)
p = s.addPiece(va, ta, color)
p.displayStyle = p.Mesh
from chimera import openModels as om
om.add([s])
def create_surface(va, ta, color, v, model_id):
import _surface
s = _surface.SurfaceModel()
s.name = '%s field lines' % v.name
p = s.addPiece(va, ta, color)
p.save_in_session = True
from chimera import openModels, OpenModels
id, subid = ((OpenModels.Default,
OpenModels.Default) if model_id is None else model_id)
openModels.add([s], baseId=id, subid=subid)
s.openState.xform = v.openState.xform
return p
def distance(operation,
object1,
object2,
multiple=False,
show=False,
color=(0, 1, 1, 1)):
a1 = object1.atoms()
import Surface as s
s1 = s.selected_surface_pieces(object1, include_outline_boxes=False)
if len(a1) == 0 and len(s1) == 0:
raise CommandError('No atoms or surfaces specified')
a2 = object2.atoms()
s2 = s.selected_surface_pieces(object2, include_outline_boxes=False)
if len(a2) == 0 and len(s2) == 0:
raise CommandError('No target atoms or surfaces')
# Remove near stuff.
if a1:
a2 = list(set(a2).difference(a1))
if s1:
s2 = list(set(s2).difference(s1))
name2 = object_name(a2, s2)
xyz2 = point_array(a2, s2)
if show:
from Commands import parse_color
color = parse_color(color)
from _surface import SurfaceModel
surf = SurfaceModel()
surf.name = 'Distance measurement'
from chimera import openModels
openModels.add([surf])
else:
surf = None
if multiple:
pairs = [([a], []) for a in a1] + [([], [s]) for s in s1]
else:
pairs = [(a1, s1)]
for a, s in pairs:
name = object_name(a, s)
xyz = point_array(a, s)
report_distance(xyz, xyz2, name, name2, surf, color)
def place_copies(self):
from chimera import Molecule, openModels as om
from Molecule import copy_molecule
mxf_list = [(m,xf) for m,xf in self.model_xforms()
if isinstance(m, Molecule)]
copies = [copy_molecule(m) for m, xf in mxf_list]
if copies:
om.add(copies)
for c, (m,xf) in zip(copies, mxf_list):
c.openState.xform = xf
return copies
def make_molecule_copies(m, xflist, names):
from chimera import openModels
from PDBmatrices import copy_molecule
mclist = []
for c, xf in enumerate(xflist):
mc = copy_molecule(m)
mclist.append(mc)
mc.name = names[c]
openModels.add([mc])
mcxf = m.openState.xform
mcxf.multiply(xf)
mc.openState.xform = mcxf
return mclist
def make_molecule_copies(m, xflist, names):
from chimera import openModels
from PDBmatrices import copy_molecule
mclist = []
for c, xf in enumerate(xflist):
mc = copy_molecule(m)
mclist.append(mc)
mc.name = names[c]
openModels.add([mc])
mcxf = m.openState.xform
mcxf.multiply(xf)
mc.openState.xform = mcxf
return mclist
def create_symmetry_copies(mol, csys, tflist, cdist, rdist,
exclude_identity = True):
if exclude_identity:
from Matrix import is_identity_matrix
tflist = [tf for tf in tflist if not is_identity_matrix(tf)]
close_contacts = not cdist is None
close_centers = not rdist is None
if not close_contacts and not close_centers:
transforms = tflist # Use all transforms
elif close_contacts and not close_centers:
transforms = contacting_transforms(mol, csys, tflist, cdist)
elif close_centers and not close_contacts:
transforms = close_center_transforms(mol, csys, tflist, rdist)
else:
transforms = unique(contacting_transforms(mol, csys, tflist, cdist) +
close_center_transforms(mol, csys, tflist, rdist))
if hasattr(mol, 'symmetry_copies'):
remove_symmetry_copies(mol)
copies = []
from chimera import openModels, replyobj
from PDBmatrices import copy_molecule
from Matrix import chimera_xform
for tf in transforms:
copy = copy_molecule(mol)
copy.symmetry_xform = chimera_xform(tf)
copies.append(copy)
replyobj.status('Created symmetry copy %d of %d'
% (len(copies), len(transforms)))
if len(copies) == 0:
return copies
openModels.add(copies)
replyobj.status('')
mol.symmetry_copies = copies
mol.symmetry_reference_model = csys
# TODO: Set xform before opening so that code that detects open sees
# the correct position. Currently not possible. Bug 4486.
update_symmetry_positions(mol)
return copies
def show_slabs(xf, color, os):
# Make schematic illustrating rotation
if color is None:
color = (.7,.7,.7,1)
have_box, box = os.bbox()
if not have_box:
return
center = box.center().data()
import MatchDomains
sm = MatchDomains.transform_schematic(xf, center, color, color)
if sm:
sm.name = 'slabs'
from chimera import openModels as om
om.add([sm])
sm.openState.xform = os.xform
return sm
def create_volume_plane_surface(volume, height, interpolate = 'cubic',
mesh = 'isotropic', colormap = 'rainbow',
smoothing_factor = 0.3,
smoothing_iterations = 0,
color = (.7, .7, .7, 1),
replace = True):
m = volume.matrix()
axes = [a for a in range(3) if m.shape[2-a] == 1]
if len(axes) != 1:
from chimera.replyobj import warning
warning('Volume %s has more than one plane shown (%d,%d,%d)' %
((volume.name,) + tuple(reversed(m.shape))))
return
axis = axes[0]
m = m.squeeze() # Convert 3d array to 2d
tf = volume.matrix_indices_to_xyz_transform()
perm = {0: ((0,0,1,0),(1,0,0,0),(0,1,0,0)), # 2d matrix xyh -> 3d yzx
1: ((1,0,0,0),(0,0,1,0),(0,1,0,0)), # 2d matrix xyh -> 3d xzy
2: ((1,0,0,0),(0,1,0,0),(0,0,1,0))}[axis]
from Matrix import multiply_matrices
tf = multiply_matrices(tf, perm)
s = create_surface(m, height, tf, color, interpolate, mesh,
smoothing_factor, smoothing_iterations)
s.name = volume.name + ' height'
if colormap == 'rainbow':
invert = not height is None and height < 0
tf = volume.data.ijk_to_xyz_transform
normal = [tf[i][axis] for i in range(3)]
colormap_surface(s, normal, rainbow_colormap(invert))
from chimera import openModels
if replace:
openModels.close([m for m in openModels.list()
if getattr(m, 'topography_volume', None) == volume])
openModels.add([s])
s.openState.xform = volume.model_transform()
s.topography_volume = volume
return s
def create_object(self):
from _surface import SurfaceModel
sm = SurfaceModel()
sm.piecesAreSelectable = self.pieces_are_selectable
if self.version >= 2:
sm.oneTransparentLayer = self.one_transparent_layer
for ps in self.surface_piece_states:
ps.create_object(sm)
sms = self.surface_model
from SimpleSession import modelOffset
from chimera import openModels as om
om.add([sm], baseId = sms.id + modelOffset, subid = sms.subid)
sms.restore_state(sm)
return sm
def create_object(self):
from _surface import SurfaceModel
sm = SurfaceModel()
sm.piecesAreSelectable = self.pieces_are_selectable
if self.version >= 2:
sm.oneTransparentLayer = self.one_transparent_layer
for ps in self.surface_piece_states:
ps.create_object(sm)
sms = self.surface_model
from SimpleSession import modelOffset
from chimera import openModels as om
om.add([sm], baseId=sms.id + modelOffset, subid=sms.subid)
sms.restore_state(sm)
return sm
def createCN():
cn= Molecule() # create an instance of a molecule
# r = cn.newResidue(residue type, chain identifier, sequence number, insertion code)
r = cn.newResidue("cn", " ", 1, " ")
atomC = cn.newAtom("CE", Element("C")) # now create the atoms of the residue.
atomN = cn.newAtom("NF", Element("N"))
bondLength_cn = 1.156
atomC.setCoord(Coord(0, 0, 0))
atomN.setCoord(Coord(bondLength_cn, 0, 0))
r.addAtom(atomC)
r.addAtom(atomN)
cn.newBond(atomC, atomN)
openModels.add([cn])
def tube_surface_piece(ptlist,
pcolors,
radius,
circle_subdivisions,
surface_model=None,
model_id=None):
nz = len(ptlist)
nc = circle_subdivisions
height = 0
from Shape.shapecmd import cylinder_geometry
varray, tarray = cylinder_geometry(radius, height, nz, nc, caps=True)
tflist = extrusion_transforms(ptlist)
# Transform circles.
from _contour import affine_transform_vertices
for i in range(nz):
affine_transform_vertices(varray[nc * i:nc * (i + 1), :], tflist[i])
# Transform cap center points
affine_transform_vertices(varray[-2:-1, :], tflist[0])
affine_transform_vertices(varray[-1:, :], tflist[-1])
# Vertex colors.
from numpy import empty, float32
carray = empty((nz * nc + 2, 4), float32)
for i in range(nz):
carray[nc * i:nc * (i + 1), :] = pcolors[i]
carray[-2, :] = pcolors[0]
carray[-1, :] = pcolors[-1]
if surface_model is None:
import _surface
surface_model = _surface.SurfaceModel()
from chimera import openModels as om
if model_id is None:
model_id = (om.Default, om.Default)
om.add([surface_model], baseId=model_id[0], subid=model_id[1])
p = surface_model.addPiece(varray, tarray, (1, 1, 1, 1))
p.vertexColors = carray
if radius == 0:
p.displayStyle = p.Mesh
p.useLighting = False
return p
def show_outline_model(self, m, om=None):
from PDBmatrices import crystal_parameters, cell_origin
cp = crystal_parameters(pdb_headers(m))
if cp == None:
return
a, b, c, alpha, beta, gamma, space_group, zvalue = cp
from PDBmatrices.crystal import unit_cell_axes
axes = unit_cell_axes(a, b, c, alpha, beta, gamma)
from Molecule import molecule_center
mc = molecule_center(m)
origin = cell_origin(self.grid_origin(), axes, mc)
color = (1, 1, 1) # white
b = outline_box(origin, axes, color, om)
b.name = self.outline_model_name(m)
if om is None:
from chimera import openModels
openModels.add([b], sameAs=m)
def show_outline_model(self, m, om = None):
from PDBmatrices import crystal_parameters, cell_origin
cp = crystal_parameters(pdb_headers(m))
if cp == None:
return
a, b, c, alpha, beta, gamma, space_group, zvalue = cp
from PDBmatrices.crystal import unit_cell_axes
axes = unit_cell_axes(a, b, c, alpha, beta, gamma)
from Molecule import molecule_center
mc = molecule_center(m)
origin = cell_origin(self.grid_origin(), axes, mc)
color = (1,1,1) # white
b = outline_box(origin, axes, color, om)
b.name = self.outline_model_name(m)
if om is None:
from chimera import openModels
openModels.add([b], sameAs = m)
def illustrate_backbone_alignment():
# Find atom pairs
from chimera import selection
a1, a2 = backbone_atom_pairs(selection.currentAtoms())
if a1 == None:
return
# Compute alignment
from chimera import match
xform, rmsd = match.matchAtoms(a1, a2)
# Find aligning transformation to apply to molecule 2 object coordinates
m1 = a1[0].molecule
m2 = a2[0].molecule
xf = m1.openState.xform
xf.multiply(xform) # New m2 transform to align.
inv_xf2 = m2.openState.xform
inv_xf2.invert()
xf.premultiply(inv_xf2) # xform in m2 object coordinates
# Make schematic illustrating rotation
# alpha = .5
from_rgba = list(m2.color.rgba())
# from_rgba[3] = alpha
to_rgba = list(m1.color.rgba())
# to_rgba[3] = alpha
sm = transform_schematic(xf, center_of_atoms(a2), from_rgba, to_rgba)
if sm:
sm.name = 'Transform from %s to %s' % (m2.name, m1.name)
from chimera import openModels
openModels.add([sm], sameAs=m2)
# Report atom count, rmsd, and angle
axis, angle = xf.getRotation()
from chimera import replyobj
replyobj.status(
'RMSD between %d atom pairs is %.3f angstroms, rotation angle = %.2f degrees\n'
% (len(a1), rmsd, angle),
log=True)
def tube_surface_piece(ptlist, pcolors, radius, circle_subdivisions,
surface_model = None, model_id = None):
nz = len(ptlist)
nc = circle_subdivisions
height = 0
from Shape.shapecmd import cylinder_geometry
varray, tarray = cylinder_geometry(radius, height, nz, nc, caps = True)
tflist = extrusion_transforms(ptlist)
# Transform circles.
from _contour import affine_transform_vertices
for i in range(nz):
affine_transform_vertices(varray[nc*i:nc*(i+1),:], tflist[i])
# Transform cap center points
affine_transform_vertices(varray[-2:-1,:], tflist[0])
affine_transform_vertices(varray[-1:,:], tflist[-1])
# Vertex colors.
from numpy import empty, float32
carray = empty((nz*nc+2,4), float32)
for i in range(nz):
carray[nc*i:nc*(i+1),:] = pcolors[i]
carray[-2,:] = pcolors[0]
carray[-1,:] = pcolors[-1]
if surface_model is None:
import _surface
surface_model = _surface.SurfaceModel()
from chimera import openModels as om
if model_id is None:
model_id = (om.Default, om.Default)
om.add([surface_model], baseId = model_id[0], subid = model_id[1])
p = surface_model.addPiece(varray, tarray, (1,1,1,1))
p.vertexColors = carray
if radius == 0:
p.displayStyle = p.Mesh
p.useLighting = False
return p
def illustrate_backbone_alignment():
# Find atom pairs
from chimera import selection
a1, a2 = backbone_atom_pairs(selection.currentAtoms())
if a1 == None:
return
# Compute alignment
from chimera import match
xform, rmsd = match.matchAtoms(a1, a2)
# Find aligning transformation to apply to molecule 2 object coordinates
m1 = a1[0].molecule
m2 = a2[0].molecule
xf = m1.openState.xform
xf.multiply(xform) # New m2 transform to align.
inv_xf2 = m2.openState.xform
inv_xf2.invert()
xf.premultiply(inv_xf2) # xform in m2 object coordinates
# Make schematic illustrating rotation
# alpha = .5
from_rgba = list(m2.color.rgba())
# from_rgba[3] = alpha
to_rgba = list(m1.color.rgba())
# to_rgba[3] = alpha
sm = transform_schematic(xf, center_of_atoms(a2), from_rgba, to_rgba)
if sm:
sm.name = 'Transform from %s to %s' % (m2.name, m1.name)
from chimera import openModels
openModels.add([sm], sameAs = m2)
# Report atom count, rmsd, and angle
axis, angle = xf.getRotation()
from chimera import replyobj
replyobj.status('RMSD between %d atom pairs is %.3f angstroms, rotation angle = %.2f degrees\n'
% (len(a1), rmsd, angle), log = True)
def show_hk_lattice(h, k, radius, orientation = '222',
color_rgba = (1,1,1,1), mesh_line_thickness = 1,
sphere_factor = 0, replace = True):
varray, tarray, hex_edges = hk_icosahedron_lattice(h,k,radius,orientation)
interpolate_with_sphere(varray, radius, sphere_factor)
# Make new surface model or find an existing one.
sm = None
open = False
from chimera import openModels
from _surface import SurfaceModel
if replace:
mlist = openModels.list(modelTypes = [SurfaceModel])
mlist = [m for m in mlist if hasattr(m, 'hkcage')]
if mlist:
sm = mlist[0]
for p in sm.surfacePieces:
if hasattr(p, 'hkcage'):
sm.removePiece(p)
open = True
if sm is None:
sm = SurfaceModel()
sm.name = 'h = %d, k = %d lattice' % (h,k)
sm.hkcage = True
p = sm.addPiece(varray, tarray, color_rgba)
p.hkcage = True
p.lineThickness = mesh_line_thickness
p.displayStyle = p.Mesh
p.setEdgeMask(hex_edges) # Hide spokes of hexagons.
if not open:
openModels.add([sm])
return sm
def show_line_segments(v1, v2, color = (1,1,1,1), surface_model = None):
n = len(v1)
from numpy import empty, single as floatc, intc, arange
varray = empty((2*n,3), floatc)
tarray = empty((n,3), intc)
varray[:n,:] = v1
varray[n:,:] = v2
tarray[:,0] = tarray[:,2] = arange(n)
tarray[:,1] = tarray[:,0] + n
create_model = (surface_model is None)
if create_model:
from _surface import SurfaceModel
surface_model = SurfaceModel()
p = surface_model.addPiece(varray, tarray, color)
p.displayStyle = p.Mesh
if create_model:
from chimera import openModels as om
om.add([surface_model])
return p
class CombineDialog(ModelessDialog):
title = "Copy/Combine Molecular Models"
help = "UsersGuide/modelpanel.html#combine"
def __init__(self, models=None):
self.initModels = models
ModelessDialog.__init__(self)
def fillInUI(self, parent):
from chimera.widgets import MoleculeScrolledListBox
self.molListBox = MoleculeScrolledListBox(parent,
listbox_selectmode='extended', labelpos='w',
label_text="Molecules to combine/copy:")
if self.initModels:
self.molListBox.setvalue(self.initModels)
self.molListBox.grid(row=0, column=0, columnspan=2,
sticky="nsew")
parent.rowconfigure(0, weight=1)
parent.columnconfigure(1, weight=1)
from chimera.tkoptions import StringOption, IntOption
self.molNameEntry = StringOption(parent, 1, "New model's"
" name", "combination", None)
curIDs = set([i1 for i1, i2 in openModels.listIds()])
mid = 0
while mid in curIDs:
mid += 1
self.modelID = IntOption(parent, 2, "New model's ID", mid, None)
from chimera.widgets import MoleculeOptionMenu
self.refMolMenu = MoleculeOptionMenu(parent, labelpos='w',
label_text="Coordinate system of:",
initialitem=self.initModels[0])
self.refMolMenu.grid(row=3, column=0, columnspan=2, sticky='w')
import Pmw
chb = self.chainHandlingButtons = Pmw.RadioSelect(parent,
buttontype="radiobutton", labelpos='w',
label_text="If original molecules have duplicate\n"
"single-letter chain IDs, then:", orient="vertical")
self.buttonTexts = ["rename them uniquely",
"retain them (residues may be renumbered)"]
for bt in self.buttonTexts:
chb.add(bt)
chb.setvalue(self.buttonTexts[0])
chb.grid(row=4, column=0, columnspan=2)
import Tkinter
self.closeModelsVar = Tkinter.IntVar(parent)
self.closeModelsVar.set(False)
Tkinter.Checkbutton(parent, text="Close source models",
variable=self.closeModelsVar).grid(
row=5, column=0, columnspan=2)
def Apply(self):
mols = self.molListBox.getvalue()
from chimera import UserError
if not mols:
self.enter()
raise UserError("Must specify at least one molecular"
" model to combine/copy")
from chimera import suppressNewMoleculeProcessing, \
restoreNewMoleculeProcessing
suppressNewMoleculeProcessing()
newChainIDs = (self.chainHandlingButtons.getvalue()
== self.buttonTexts[0])
refMol = self.refMolMenu.getvalue()
from Combine import combine, CombineError
try:
m = combine(mols, refMol,
newChainIDs=newChainIDs, log=True)
except CombineError, v:
restoreNewMoleculeProcessing()
self.enter()
raise UserError(v)
m.name = self.molNameEntry.get()
openModels.add([m], baseId=self.modelID.get(), shareXform=False)
m.openState.xform = refMol.openState.xform
restoreNewMoleculeProcessing()
if self.closeModelsVar.get():
openModels.close(mols)
if refMol == None:
refMol = mols[:1]
if len(refMol) == 0:
raise MidasError("No reference molecule specified")
elif len(refMol) > 1:
raise MidasError("Multiple reference molecules specified")
refMol = refMol[0]
if modelId is not None and type(modelId) != int:
try:
modelId = int(modelId[1:])
except:
raise MidasError("modelId value must be integer")
from chimera import suppressNewMoleculeProcessing, \
restoreNewMoleculeProcessing
suppressNewMoleculeProcessing()
try:
m = combine(mols, refMol, newChainIDs=newChainIDs, log=log)
except CombineError, v:
restoreNewMoleculeProcessing()
raise MidasError(v)
from chimera import openModels
m.name = name
kw = {'shareXform': False}
if modelId != None:
kw['baseId'] = modelId
openModels.add([m], **kw)
m.openState.xform = refMol.openState.xform
restoreNewMoleculeProcessing()
if close:
openModels.close(mols)
if refMol == None:
refMol = mols[:1]
if len(refMol) == 0:
raise MidasError("No reference molecule specified")
elif len(refMol) > 1:
raise MidasError("Multiple reference molecules specified")
refMol = refMol[0]
if modelId is not None and type(modelId) != int:
try:
modelId = int(modelId[1:])
except:
raise MidasError("modelId value must be integer")
from chimera import suppressNewMoleculeProcessing, \
restoreNewMoleculeProcessing
suppressNewMoleculeProcessing()
try:
m = combine(mols, refMol, newChainIDs=newChainIDs, log=log)
except CombineError, v:
restoreNewMoleculeProcessing()
raise MidasError(v)
from chimera import openModels
m.name = name
kw = {'shareXform': False}
if modelId != None:
kw['baseId'] = modelId
openModels.add([m], **kw)
m.openState.xform = refMol.openState.xform
restoreNewMoleculeProcessing()
if close:
openModels.close(mols)
def showAniso(self, targets, color=None, scale=1.0, smoothing=1,
showEllipsoid=True, ellipsoidTransparency=None,
axisColor=None, axisFactor=None, axisThickness=0.01,
ellipseColor=None, ellipseFactor=None, ellipseThickness=0.02):
"""targets can be an iterable of atoms or molecules
color of None means match the atom color.
showing outer ellipsoid controlled with 'showEllipsoid'
if 'ellipsoidTransparency' is not None, then the color's
transparency is set to that fraction.
'axisFactor' is a multiplicative factor of how long the displayed
axes lengths are versus the ellipsoid axes. If 'axisFactor'
is None then no axes are displayed.
'ellipseFactor' is similar to 'axisFactor', but for the major
ellipses.
"""
molMap = self._makeMolMap(targets)
self.removeAniso(molMap)
noneShowing = not self._surfMap
newlyShown = 0
for m, atoms in molMap.items():
if not m.display:
continue
surfMap = self._surfMap.setdefault(m, {})
if surfMap:
model = surfMap["model"]
else:
import _surface
model = _surface.SurfaceModel()
surfMap["model"] = model
openModels.add([model], sameAs=m, hidden=True)
for a in atoms:
if not a.display or a.hide:
continue
if not hasattr(a, "anisoU"):
continue
noneColor = a.color
if noneColor is None:
noneColor = a.molecule.color
if showEllipsoid:
if color is None:
_ellipsoidColor = noneColor
else:
_ellipsoidColor = color
else:
_ellipsoidColor = None
if axisFactor is None:
_axisColor = None
elif axisColor is None:
_axisColor = noneColor
else:
_axisColor = axisColor
if ellipseFactor is None:
_ellipseColor = None
elif ellipseColor is None:
_ellipseColor = noneColor
else:
_ellipseColor = ellipseColor
surfMap[a] = self._makePieces(model, a, (_ellipsoidColor,
_axisColor, _ellipseColor), ellipsoidTransparency, scale,
smoothing, axisFactor, ellipseFactor, axisThickness,
ellipseThickness)
newlyShown += 1
# can't look up 'molecule' in deleted atoms,
# so remember it...
self._atomMolLookup[a] = a.molecule
if noneShowing and self._surfMap:
self._handlerID = triggers.addHandler('Atom',
self._atomCB, None)
return newlyShown
def open_model(self):
from chimera import openModels, addModelClosedCallback
openModels.add([self.volume], sameAs = self.attached_model)
addModelClosedCallback(self.volume, self.model_closed_cb)
def open_pqs(id):
models = read_pqs(id)
from chimera import openModels
openModels.add(models)
return models
def open_model(self):
from chimera import openModels, addModelClosedCallback
openModels.add([self.volume], sameAs=self.attached_model)
addModelClosedCallback(self.volume, self.model_closed_cb)
