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 scale_op(volumes,
shift=0,
factor=1,
type=None,
subregion='all',
step=1,
modelId=None):
volumes = filter_volumes(volumes)
check_number(shift, 'shift')
check_number(factor, 'factor')
if not type is None:
import numpy as n
types = {
'int8': n.int8,
'uint8': n.uint8,
'int16': n.int16,
'uint16': n.uint16,
'int32': n.int32,
'uint32': n.uint32,
'float32': n.float32,
'float64': n.float64,
}
if type in types:
type = types[type]
else:
raise CommandError, ('Unknown data value type "%s", use %s' %
(type, ', '.join(types.keys())))
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from scale import scaled_volume
for v in volumes:
scaled_volume(v, factor, shift, type, step, subregion, modelId)
def tube_shape(atoms,
radius=1.0,
bandLength=0.0,
followBonds=False,
divisions=15,
segmentSubdivisions=10,
color=(.745, .745, .745, 1),
mesh=None,
linewidth=1,
modelName='tube',
modelId=None):
if len(atoms) == 0:
raise CommandError, 'No atoms specified'
check_number(radius, 'radius', nonnegative=True)
check_number(bandLength, 'bandLength', nonnegative=True)
check_number(divisions, 'divisions', positive=True)
check_number(divisions, 'segmentSubdivisions', positive=True)
check_number(linewidth, 'linewidth', nonnegative=True)
from Commands import parse_rgba
rgba = parse_rgba(color)
model_id = parse_model_id(modelId)
s = find_surface_model(model_id)
from VolumePath import tube
s, plist = tube.tube_through_atoms(atoms, radius, bandLength,
segmentSubdivisions, divisions,
followBonds, rgba, s, model_id)
for p in plist:
if mesh:
p.displayStyle = p.Mesh
p.lineThickness = linewidth
p.save_in_session = True
if s:
s.name = modelName
def tube_shape(atoms, radius = 1.0, bandLength = 0.0, followBonds = False,
divisions = 15, segmentSubdivisions = 10,
color = (.745,.745,.745,1), mesh = None, linewidth = 1,
modelName = 'tube', modelId = None):
if len(atoms) == 0:
raise CommandError, 'No atoms specified'
check_number(radius, 'radius', nonnegative = True)
check_number(bandLength, 'bandLength', nonnegative = True)
check_number(divisions, 'divisions', positive = True)
check_number(divisions, 'segmentSubdivisions', positive = True)
check_number(linewidth, 'linewidth', nonnegative = True)
from Commands import parse_rgba
rgba = parse_rgba(color)
model_id = parse_model_id(modelId)
s = find_surface_model(model_id)
from VolumePath import tube
s,plist = tube.tube_through_atoms(atoms, radius, bandLength,
segmentSubdivisions, divisions,
followBonds, rgba, s, model_id)
for p in plist:
if mesh:
p.displayStyle = p.Mesh
p.lineThickness = linewidth
p.save_in_session = True
if s:
s.name = modelName
def cover_op(volumes, atomBox = None, pad = 5.0,
box = None, x = None, y = None, z = None,
fBox = None, fx = None, fy = None, fz = None,
iBox = None, ix = None, iy = None, iz = None,
step = 1, modelId = None):
volumes = filter_volumes(volumes)
check_number(pad, 'pad')
if not atomBox is None and len(atomBox) == 0:
raise CommandError, 'No atoms specified'
box = parse_box(box, x, y, z, 'box', 'x', 'y', 'z')
fBox = parse_box(fBox, fx, fy, fz, 'fBox', 'fx', 'fy', 'fz')
iBox = parse_box(iBox, ix, iy, iz, 'iBox', 'ix', 'iy', 'iz')
bc = len([b for b in (box, fBox, iBox, atomBox) if b])
if bc == 0:
raise CommandError, 'Must specify box to cover'
if bc > 1:
raise CommandError, 'Specify covering box in one way'
step = parse_step(step, require_3_tuple = True)
modelId = parse_model_id(modelId)
from VolumeViewer import volume, volume_from_grid_data
for v in volumes:
g = v.grid_data(subregion = 'all', step = step, mask_zone = False)
ijk_min, ijk_max = cover_box_bounds(v, step,
atomBox, pad, box, fBox, iBox)
cg = volume.map_from_periodic_map(g, ijk_min, ijk_max)
cv = volume_from_grid_data(cg, model_id = modelId)
cv.copy_settings_from(v, copy_region = False)
cv.show()
def scale_op(volumes, shift = 0, factor = 1, type = None,
subregion = 'all', step = 1, modelId = None):
volumes = filter_volumes(volumes)
check_number(shift, 'shift')
check_number(factor, 'factor')
if not type is None:
import numpy as n
types = {'int8': n.int8,
'uint8': n.uint8,
'int16': n.int16,
'uint16': n.uint16,
'int32': n.int32,
'uint32': n.uint32,
'float32': n.float32,
'float64': n.float64,
}
if type in types:
type = types[type]
else:
raise CommandError, ('Unknown data value type "%s", use %s'
% (type, ', '.join(types.keys())))
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from scale import scaled_volume
for v in volumes:
scaled_volume(v, factor, shift, type, step, subregion, modelId)
def parse_offset(offset):
from Commands import check_number, parse_floats
if isinstance(offset, (basestring,tuple,list)):
o1, o2, n = parse_floats(offset, 'offset', 3)
if n <= 1:
raise CommandError, 'Offset count must be greater than 1'
offset = [o1 + (o2-o1)*float(i)/(n-1) for i in range(n)]
else:
check_number(offset, 'offset')
return offset
def parse_offset(offset):
from Commands import check_number, parse_floats
if isinstance(offset, (basestring, tuple, list)):
o1, o2, n = parse_floats(offset, 'offset', 3)
if n <= 1:
raise CommandError, 'Offset count must be greater than 1'
offset = [o1 + (o2 - o1) * float(i) / (n - 1) for i in range(n)]
else:
check_number(offset, 'offset')
return offset
def gaussian_op(volumes, sDev=1.0, subregion='all', step=1, modelId=None):
volumes = filter_volumes(volumes)
check_number(sDev, 'sDev', positive=True)
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from gaussian import gaussian_convolve
for v in volumes:
gaussian_convolve(v, sDev, step, subregion, modelId)
def gaussian_op(volumes, sDev = 1.0,
subregion = 'all', step = 1, modelId = None):
volumes = filter_volumes(volumes)
check_number(sDev, 'sDev', positive = True)
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from gaussian import gaussian_convolve
for v in volumes:
gaussian_convolve(v, sDev, step, subregion, modelId)
def boxes_op(volumes, markers, size = 0, useMarkerSize = False,
subregion = 'all', step = 1, modelId = None):
volumes = filter_volumes(volumes)
check_number(size, 'size')
if size <= 0 and not useMarkerSize:
raise CommandError, 'Must specify size or enable useMarkerSize'
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from boxes import boxes
for v in volumes:
boxes(v, markers, size, useMarkerSize, step, subregion, modelId)
def cylinder_shape(radius=10.0,
height=40.0,
center=None,
rotation=None,
qrotation=None,
coordinateSystem=None,
divisions=72,
color=(.745, .745, .745, 1),
mesh=False,
linewidth=1,
caps=False,
slab=None,
modelName='cylinder',
modelId=None):
check_number(radius, 'radius', nonnegative=True)
check_number(height, 'height', nonnegative=True)
check_number(divisions, 'divisions', positive=True)
check_number(linewidth, 'linewidth', nonnegative=True)
model_id = parse_model_id(modelId)
nz, nc = cylinder_divisions(radius, height, divisions)
varray, tarray = cylinder_geometry(radius, height, nz, nc, caps)
edge_mask = None
show_surface(varray, tarray, edge_mask, color, mesh, linewidth, center,
rotation, qrotation, coordinateSystem, slab, model_id,
modelName)
def morph_op(volumes, frames = 25, start = 0, playStep = 0.04,
playDirection = 1, playRange = None, addMode = False,
constantVolume = False, scaleFactors = None,
hideOriginalMaps = True, subregion = 'all', step = 1,
modelId = None):
volumes = filter_volumes(volumes)
check_number(frames, 'frames', int, nonnegative = True)
check_number(start, 'start')
check_number(playStep, 'playStep', nonnegative = True)
if playRange is None:
if addMode:
prange = (-1.0,1.0)
else:
prange = (0.0,1.0)
else:
prange = parse_floats(playRange, 'playRange', 2)
check_number(playDirection, 'playDirection')
sfactors = parse_floats(scaleFactors, 'scaleFactors', len(volumes))
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
vs = [tuple(v.matrix_size(step = step, subregion = subregion))
for v in volumes]
if len(set(vs)) > 1:
sizes = ' and '.join([str(s) for s in vs])
raise CommandError, "Volume grid sizes don't match: %s" % sizes
from MorphMap import morph_maps
morph_maps(volumes, frames, start, playStep, playDirection, prange,
addMode, constantVolume, sfactors,
hideOriginalMaps, subregion, step, modelId)
def subdivide_op(surfaces, spacing=None, inPlace=False, modelId=None):
from Commands import check_number, parse_model_id
if len(surfaces) == 0:
raise CommandError('No surfaces specified')
if spacing is None:
raise CommandError('Must specify mesh spacing')
check_number(spacing, 'spacing', positive=True)
plist = surfaces
s = None if inPlace else new_surface('finer mesh', plist[0].model, modelId)
from subdivide import subdivide
for p in plist:
np = subdivide(p, spacing, s)
if np != p:
np.save_in_session = True
def contact_area(operation,
surf1,
surf2,
distance,
show=True,
color=(1, 0, 0, 1),
offset=1,
slab=None,
smooth=False,
optimize=True):
plist = []
import Surface
for spec in (surf1, surf2):
s = parse_object_specifier(spec, 'surface')
p = Surface.selected_surface_pieces(s, include_outline_boxes=False)
if len(p) == 0:
raise CommandError('%s has no surface pieces' % spec)
elif len(p) > 1:
raise CommandError('%s has %d surface pieces, require 1' %
(spec, len(p)))
plist.append(p[0])
p1, p2 = plist
from Commands import parse_color
color = parse_color(color)
if not show:
color = None
from Commands import check_number
check_number(offset, 'offset')
if not slab is None:
if isinstance(slab, (float, int)):
slab = (-0.5 * slab, 0.5 * slab)
else:
from Commands import parse_floats
slab = parse_floats(slab, 'slab', 2)
offset = None
import contactarea as c
area = c.contact_area(p1, p2, distance, color, offset, slab, smooth,
optimize)
from chimera import replyobj
replyobj.info('Contact area on %s within distance %.4g\nof %s = %.4g\n' %
(p1.model.name, distance, p2.model.name, area))
replyobj.status('Contact area = %.4g' % area)
def octant_complement_op(volumes, center = None, iCenter = None,
subregion = 'all', step = 1, inPlace = False,
fillValue = 0, modelId = None):
volumes = filter_volumes(volumes)
center = parse_floats(center, 'center', 3)
iCenter = parse_floats(iCenter, 'iCenter', 3)
subregion = parse_subregion(subregion)
step = parse_step(step)
check_in_place(inPlace, volumes)
check_number(fillValue, 'fillValue')
modelId = parse_model_id(modelId)
outside = False
for v in volumes:
octant_operation(v, outside, center, iCenter, subregion, step,
inPlace, fillValue, modelId)
def median_op(volumes, binSize = 3, iterations = 1,
subregion = 'all', step = 1, modelId = None):
volumes = filter_volumes(volumes)
check_number(iterations, 'iterations', positive = True)
binSize = parse_step(binSize, 'binSize', require_3_tuple = True)
for b in binSize:
if b <= 0 or b % 2 == 0:
raise CommandError, 'Bin size must be positive odd integer, got %d' % b
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from median import median_filter
for v in volumes:
median_filter(v, binSize, iterations, step, subregion, modelId)
def tile(models, columns = None, spacingFactor = 1.0,
independentRotation = True, viewAll = True):
from Commands import CommandError, check_number
if len(models) == 0:
raise CommandError, 'No models specified'
check_number(columns, 'columns', type = int, allow_none = True,
positive = True)
check_number(spacingFactor, 'spacingFactor')
import base
base.tile(models, spacingFactor, columns, viewAll)
if independentRotation:
from chimera import openModels
openModels.cofrMethod = openModels.Independent
def tile(models,
columns=None,
spacingFactor=1.0,
independentRotation=True,
viewAll=True):
from Commands import CommandError, check_number
if len(models) == 0:
raise CommandError, 'No models specified'
check_number(columns, 'columns', type=int, allow_none=True, positive=True)
check_number(spacingFactor, 'spacingFactor')
import base
base.tile(models, spacingFactor, columns, viewAll)
if independentRotation:
from chimera import openModels
openModels.cofrMethod = openModels.Independent
def cover_op(volumes,
atomBox=None,
pad=5.0,
box=None,
x=None,
y=None,
z=None,
fBox=None,
fx=None,
fy=None,
fz=None,
iBox=None,
ix=None,
iy=None,
iz=None,
step=1,
modelId=None):
volumes = filter_volumes(volumes)
check_number(pad, 'pad')
if not atomBox is None and len(atomBox) == 0:
raise CommandError, 'No atoms specified'
box = parse_box(box, x, y, z, 'box', 'x', 'y', 'z')
fBox = parse_box(fBox, fx, fy, fz, 'fBox', 'fx', 'fy', 'fz')
iBox = parse_box(iBox, ix, iy, iz, 'iBox', 'ix', 'iy', 'iz')
bc = len([b for b in (box, fBox, iBox, atomBox) if b])
if bc == 0:
raise CommandError, 'Must specify box to cover'
if bc > 1:
raise CommandError, 'Specify covering box in one way'
step = parse_step(step, require_3_tuple=True)
modelId = parse_model_id(modelId)
from VolumeViewer import volume, volume_from_grid_data
for v in volumes:
g = v.grid_data(subregion='all', step=step, mask_zone=False)
ijk_min, ijk_max = cover_box_bounds(v, step, atomBox, pad, box, fBox,
iBox)
cg = volume.map_from_periodic_map(g, ijk_min, ijk_max)
cv = volume_from_grid_data(cg, model_id=modelId)
cv.copy_settings_from(v, copy_region=False)
cv.show()
def boxes_op(volumes,
markers,
size=0,
useMarkerSize=False,
subregion='all',
step=1,
modelId=None):
volumes = filter_volumes(volumes)
check_number(size, 'size')
if size <= 0 and not useMarkerSize:
raise CommandError, 'Must specify size or enable useMarkerSize'
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from boxes import boxes
for v in volumes:
boxes(v, markers, size, useMarkerSize, step, subregion, modelId)
def median_op(volumes,
binSize=3,
iterations=1,
subregion='all',
step=1,
modelId=None):
volumes = filter_volumes(volumes)
check_number(iterations, 'iterations', positive=True)
binSize = parse_step(binSize, 'binSize', require_3_tuple=True)
for b in binSize:
if b <= 0 or b % 2 == 0:
raise CommandError, 'Bin size must be positive odd integer, got %d' % b
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
from median import median_filter
for v in volumes:
median_filter(v, binSize, iterations, step, subregion, modelId)
def octant_complement_op(volumes,
center=None,
iCenter=None,
subregion='all',
step=1,
inPlace=False,
fillValue=0,
modelId=None):
volumes = filter_volumes(volumes)
center = parse_floats(center, 'center', 3)
iCenter = parse_floats(iCenter, 'iCenter', 3)
subregion = parse_subregion(subregion)
step = parse_step(step)
check_in_place(inPlace, volumes)
check_number(fillValue, 'fillValue')
modelId = parse_model_id(modelId)
outside = False
for v in volumes:
octant_operation(v, outside, center, iCenter, subregion, step, inPlace,
fillValue, modelId)
def sphere_shape(radius=10.0,
center=None,
rotation=None,
qrotation=None,
coordinateSystem=None,
divisions=72,
color=(.745, .745, .745, 1),
mesh=False,
linewidth=1,
slab=None,
modelName=None,
modelId=None):
try:
r = parse_floats(radius, 'radius', 3)
except CommandError:
check_number(radius, 'radius', nonnegative=True)
r = (radius, radius, radius)
check_number(divisions, 'divisions', positive=True)
check_number(linewidth, 'linewidth', nonnegative=True)
model_id = parse_model_id(modelId)
varray, tarray = icosahedral_geometry(1.0, divisions, sphere_factor=1)
for a in range(3):
varray[:, a] *= r[a]
edge_mask = None
if modelName is None:
modelName = 'sphere' if r[1] == r[0] and r[2] == r[0] else 'ellipsoid'
show_surface(varray, tarray, edge_mask, color, mesh, linewidth, center,
rotation, qrotation, coordinateSystem, slab, model_id,
modelName)
def sphere_shape(radius = 10.0, center = None, rotation = None,
qrotation = None, coordinateSystem = None,
divisions = 72,
color = (.745,.745,.745,1), mesh = False, linewidth = 1,
slab = None, modelName = None, modelId = None):
try:
r = parse_floats(radius, 'radius', 3)
except CommandError:
check_number(radius, 'radius', nonnegative = True)
r = (radius, radius, radius)
check_number(divisions, 'divisions', positive = True)
check_number(linewidth, 'linewidth', nonnegative = True)
model_id = parse_model_id(modelId)
varray, tarray = icosahedral_geometry(1.0, divisions, sphere_factor = 1)
for a in range(3):
varray[:,a] *= r[a]
edge_mask = None
if modelName is None:
modelName = 'sphere' if r[1] == r[0] and r[2] == r[0] else 'ellipsoid'
show_surface(varray, tarray, edge_mask, color, mesh, linewidth,
center, rotation, qrotation, coordinateSystem,
slab, model_id, modelName)
def icosahedron_shape(radius=10.0,
center=None,
rotation=None,
qrotation=None,
coordinateSystem=None,
divisions=72,
color=(.745, .745, .745, 1),
mesh=None,
linewidth=1,
sphereFactor=0.0,
orientation='222',
lattice=None,
slab=None,
modelName='icosahedron',
modelId=None):
check_number(radius, 'radius', nonnegative=True)
check_number(divisions, 'divisions', positive=True)
check_number(linewidth, 'linewidth', nonnegative=True)
check_number(sphereFactor, 'sphereFactor')
model_id = parse_model_id(modelId)
if orientation == 222:
orientation = '222'
from Icosahedron import coordinate_system_names as csnames
if not orientation in csnames:
raise CommandError, ('Unknown orientation "%s", use %s' %
(orientation, ', '.join(csnames)))
if not lattice is None and mesh is None:
mesh = True
from Commands import parse_ints
hk = parse_ints(lattice, 'lattice', 2)
if hk is None:
varray, tarray = icosahedral_geometry(radius, divisions, sphereFactor,
orientation)
edge_mask = None
else:
varray, tarray, edge_mask = hk_icosahedral_geometry(
radius, hk, sphereFactor, orientation)
show_surface(varray, tarray, edge_mask, color, mesh, linewidth, center,
rotation, qrotation, coordinateSystem, slab, model_id,
modelName)
def cylinder_shape(radius = 10.0, height = 40.0,
center = None, rotation = None, qrotation = None,
coordinateSystem = None,
divisions = 72, color = (.745,.745,.745,1),
mesh = False, linewidth = 1,
caps = False, slab = None,
modelName = 'cylinder', modelId = None):
check_number(radius, 'radius', nonnegative = True)
check_number(height, 'height', nonnegative = True)
check_number(divisions, 'divisions', positive = True)
check_number(linewidth, 'linewidth', nonnegative = True)
model_id = parse_model_id(modelId)
nz, nc = cylinder_divisions(radius, height, divisions)
varray, tarray = cylinder_geometry(radius, height, nz, nc, caps)
edge_mask = None
show_surface(varray, tarray, edge_mask, color, mesh, linewidth,
center, rotation, qrotation, coordinateSystem,
slab, model_id, modelName)
def morph_op(volumes,
frames=25,
start=0,
playStep=0.04,
playDirection=1,
playRange=None,
addMode=False,
constantVolume=False,
scaleFactors=None,
hideOriginalMaps=True,
subregion='all',
step=1,
modelId=None):
volumes = filter_volumes(volumes)
check_number(frames, 'frames', int, nonnegative=True)
check_number(start, 'start')
check_number(playStep, 'playStep', nonnegative=True)
if playRange is None:
if addMode:
prange = (-1.0, 1.0)
else:
prange = (0.0, 1.0)
else:
prange = parse_floats(playRange, 'playRange', 2)
check_number(playDirection, 'playDirection')
sfactors = parse_floats(scaleFactors, 'scaleFactors', len(volumes))
subregion = parse_subregion(subregion)
step = parse_step(step)
modelId = parse_model_id(modelId)
vs = [
tuple(v.matrix_size(step=step, subregion=subregion)) for v in volumes
]
if len(set(vs)) > 1:
sizes = ' and '.join([str(s) for s in vs])
raise CommandError, "Volume grid sizes don't match: %s" % sizes
from MorphMap import morph_maps
morph_maps(volumes, frames, start, playStep, playDirection, prange,
addMode, constantVolume, sfactors, hideOriginalMaps, subregion,
step, modelId)
def icosahedron_shape(radius = 10.0, center = None, rotation = None,
qrotation = None, coordinateSystem = None,
divisions = 72,
color = (.745,.745,.745,1), mesh = None, linewidth = 1,
sphereFactor = 0.0, orientation = '222', lattice = None,
slab = None, modelName = 'icosahedron', modelId = None):
check_number(radius, 'radius', nonnegative = True)
check_number(divisions, 'divisions', positive = True)
check_number(linewidth, 'linewidth', nonnegative = True)
check_number(sphereFactor, 'sphereFactor')
model_id = parse_model_id(modelId)
if orientation == 222:
orientation = '222'
from Icosahedron import coordinate_system_names as csnames
if not orientation in csnames:
raise CommandError, ('Unknown orientation "%s", use %s'
% (orientation, ', '.join(csnames)))
if not lattice is None and mesh is None:
mesh = True
from Commands import parse_ints
hk = parse_ints(lattice, 'lattice', 2)
if hk is None:
varray, tarray = icosahedral_geometry(radius, divisions,
sphereFactor, orientation)
edge_mask = None
else:
varray, tarray, edge_mask = hk_icosahedral_geometry(radius, hk,
sphereFactor,
orientation)
show_surface(varray, tarray, edge_mask, color, mesh, linewidth,
center, rotation, qrotation, coordinateSystem,
slab, model_id, modelName)
