def register_seqalign_command(logger):
# REMINDER: update manager._builtin_subcommands as additional subcommands are added
from chimerax.core.commands import CmdDesc, register, create_alias, Or, EmptyArg, RestOfLine, ListOf
from chimerax.atomic import UniqueChainsArg
desc = CmdDesc(
required = [('chains', UniqueChainsArg)],
synopsis = 'show structure chain sequence'
)
register('sequence chain', desc, seqalign_chain, logger=logger)
desc = CmdDesc(
required = [('chains', UniqueChainsArg)],
optional = [('target', Or(AlignmentArg, AlignSeqPairArg))],
synopsis = 'associate chain(s) with sequence'
)
register('sequence associate', desc, seqalign_associate, logger=logger)
desc = CmdDesc(
required = [('chains', UniqueChainsArg)],
optional = [('alignment', AlignmentArg)],
synopsis = 'disassociate chain(s) from alignment'
)
register('sequence disassociate', desc, seqalign_disassociate, logger=logger)
create_alias('sequence dissociate', 'sequence disassociate $*', logger=logger,
url="help:user/commands/sequence.html#disassociate")
desc = CmdDesc(
required = [('alignments', Or(AlignmentArg,ListOf(AlignmentArg),EmptyArg)),
('subcommand_text', RestOfLine)],
synopsis = "send subcommand to header"
)
register('sequence header', desc, seqalign_header, logger=logger)
from . import manager
manager._register_viewer_subcommands(logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
from chimerax.core.commands import CenterArg, CoordSysArg, Or, EnumOf, FloatArg, AxisArg
from chimerax.core.commands import ModelsArg, BoolArg
offset_arg = Or(EnumOf(['off']), FloatArg)
desc = CmdDesc(optional=[],
keyword=[('near', offset_arg), ('far', offset_arg),
('front', offset_arg), ('back', offset_arg),
('position', CenterArg), ('axis', AxisArg),
('coordinate_system', CoordSysArg)],
synopsis='set clip planes')
register('clip', desc, clip, logger=logger)
register('clip off',
CmdDesc(synopsis='Turn off all clip planes'),
clip_off,
logger=logger)
register('clip list',
CmdDesc(synopsis='List active clip planes'),
clip_list,
logger=logger)
model_desc = CmdDesc(required=[('models', ModelsArg)],
optional=[('clipping', BoolArg)],
synopsis="Turn off clipping for individual models.")
register('clip model', model_desc, clip_model, logger=logger)
create_alias('~clip', 'clip off', logger=logger)
def register_mousemode_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias, NoArg, FloatArg
mode_arg = MouseModeArg(logger.session)
desc = CmdDesc(keyword=[
('left_mode', mode_arg),
('middle_mode', mode_arg),
('right_mode', mode_arg),
('wheel_mode', mode_arg),
('pause_mode', mode_arg),
('alt', NoArg),
('command', NoArg),
('control', NoArg),
('shift', NoArg),
],
synopsis='set mouse mode',
url="help:user/commands/ui.html#mousemode")
register('mousemode', desc, mousemode, logger=logger)
create_alias('ui mousemode',
'mousemode $*',
logger=logger,
url="help:user/commands/ui.html#mousemode")
desc = CmdDesc(optional=[('mode', mode_arg)],
keyword=[('speed', FloatArg)],
synopsis='set a mouse mode parameter',
url="help:user/commands/ui.html#mousemode")
register('mousemode setting', desc, mousemode_setting, logger=logger)
create_alias('ui mousemode setting',
'mousemode setting $*',
logger=logger,
url="help:user/commands/ui.html#mousemode")
def register_label_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias, ObjectsArg, StringArg, FloatArg
from chimerax.core.commands import Float3Arg, ColorArg, IntArg, BoolArg, EnumOf, Or, EmptyArg
otype = EnumOf(('atoms', 'residues', 'pseudobonds', 'bonds'))
desc = CmdDesc(required=[('objects', Or(ObjectsArg, EmptyArg))],
optional=[('object_type', otype)],
keyword=[('text', Or(DefArg, StringArg)),
('offset', Or(DefArg, Float3Arg)),
('color', Or(DefArg, ColorArg)),
('bg_color', Or(NoneArg, ColorArg)),
('size', Or(DefArg, IntArg)),
('height', Or(EnumOf(['fixed']), FloatArg)),
('default_height', FloatArg), ('font', StringArg),
('attribute', StringArg), ('on_top', BoolArg)],
synopsis='Create atom labels')
register('label', desc, label, logger=logger)
desc = CmdDesc(optional=[('orient', FloatArg)],
synopsis='Set label orientation updating')
register('label orient', desc, label_orient, logger=logger)
desc = CmdDesc(required=[('objects', Or(ObjectsArg, EmptyArg))],
optional=[('object_type', otype)],
synopsis='Delete atom labels')
register('label delete', desc, label_delete, logger=logger)
desc = CmdDesc(synopsis='List available fonts')
from .label2d import label_listfonts
register('label listfonts', desc, label_listfonts, logger=logger)
create_alias('~label', 'label delete $*', logger=logger)
def register_command(logger):
global _registered
if _registered:
# registration can be called for both main command and alias, so only do once...
return
_registered = True
from chimerax.core.commands import CmdDesc, register, FloatArg, StringArg, \
BoolArg, NoneArg, TopModelsArg, create_alias, Or, DynamicEnum
from chimerax.atomic import AtomsArg
from chimerax import sim_matrices
desc = CmdDesc(
required=[('match_atoms', AtomsArg)],
required_arguments=['to'],
keyword=[
('to', AtomsArg), ('pairing', StringArg), ('alg', StringArg),
('verbose', BoolArg), ('ss_fraction', Or(FloatArg, BoolArg)),
('matrix',
DynamicEnum(
lambda logger=logger: sim_matrices.matrices(logger).keys())),
('gap_open', FloatArg), ('hgap', FloatArg), ('sgap', FloatArg),
('ogap', FloatArg), ('cutoff_distance', Or(FloatArg, NoneArg)),
('gap_extend', FloatArg), ('bring', TopModelsArg),
('show_alignment', BoolArg), ('compute_ss', BoolArg),
('mat_hh', FloatArg), ('mat_ss', FloatArg), ('mat_oo', FloatArg),
('mat_hs', FloatArg), ('mat_ho', FloatArg), ('mat_so', FloatArg),
('keep_computed_ss', BoolArg)
],
synopsis='Align atomic structures using sequence alignment')
register('matchmaker', desc, cmd_match, logger=logger)
create_alias('mmaker',
"%s $*" % 'matchmaker',
logger=logger,
url="help:user/commands/matchmaker.html")
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
desc = CmdDesc(synopsis='exit application')
register('exit', desc, exit, logger=logger)
create_alias("quit",
"exit $*",
logger=logger,
url="help:user/commands/exit.html")
def register_command(command_name, logger):
# 'register_command' is lazily called when command is referenced
if command_name == "echo":
from chimerax.core.commands import create_alias
create_alias("echo", "log text $*", logger=logger)
elif command_name.startswith("log"):
from . import cmd
cmd.register_log_command(logger)
def register_functionkey_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias, StringArg, WholeRestOfLine
desc = CmdDesc(
optional = [('key_name', StringArg),
('command', CommandArg)],
synopsis = 'Assign a command to a function key'
)
register('ui functionkey', desc, functionkey, logger=logger)
create_alias('functionkey', 'ui functionkey $*', logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg
from chimerax.core.commands import FloatArg, IntArg, ColorArg, BoolArg, NoArg, create_alias
from chimerax.core.commands import SurfacesArg, EmptyArg, EnumOf, Or
from chimerax.atomic import AtomsArg
surface_desc = CmdDesc(optional=[('atoms', AtomsArg)],
keyword=[('enclose', AtomsArg),
('include', AtomsArg),
('probe_radius', FloatArg),
('grid_spacing', FloatArg),
('resolution', FloatArg),
('level', FloatArg), ('color', ColorArg),
('transparency', FloatArg),
('visible_patches', IntArg),
('sharp_boundaries', BoolArg),
('nthread', IntArg), ('replace', BoolArg),
('update', BoolArg)],
synopsis='create molecular surface')
register('surface', surface_desc, surface, logger=logger)
show_desc = CmdDesc(optional=[('objects', ObjectsArg)],
synopsis='Show patches of molecular surfaces')
register('surface showPatches',
show_desc,
surface_show_patches,
logger=logger)
hide_desc = CmdDesc(optional=[('objects', ObjectsArg)],
synopsis='Hide patches of molecular surfaces')
register('surface hidePatches',
hide_desc,
surface_hide_patches,
logger=logger)
create_alias('~surface', 'surface hidePatches $*', logger=logger)
close_desc = CmdDesc(optional=[('objects', ObjectsArg)],
synopsis='close molecular surfaces')
register('surface close', close_desc, surface_close, logger=logger)
style_desc = CmdDesc(required=[('surfaces', Or(SurfacesArg, EmptyArg)),
('style', EnumOf(
('mesh', 'dot', 'solid')))],
synopsis='Change surface style to mesh, dot or solid')
register('surface style', style_desc, surface_style, logger=logger)
cap_desc = CmdDesc(optional=[
('enable', BoolArg),
],
keyword=[('offset', FloatArg),
('subdivision', FloatArg), ('mesh', BoolArg)],
synopsis='Enable or disable clipping surface caps')
register('surface cap', cap_desc, surface_cap, logger=logger)
# Register surface operation subcommands.
from . import sop
sop.register_surface_subcommands(logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, EnumOf, EmptyArg, ObjectsArg, Or
from chimerax.core.commands import BoolArg, Float2Arg, Float3Arg, ModelArg, create_alias
methods = ('frontCenter', 'fixed', 'centerOfView')
desc = CmdDesc(optional=[('method', Or(EnumOf(methods), EmptyArg)),
('objects', Or(ObjectsArg, EmptyArg)),
('pivot', Float3Arg)],
keyword=[('coordinate_system', ModelArg),
('show_pivot', Or(Float2Arg, BoolArg))],
synopsis='set center of rotation method')
register('cofr', desc, cofr, logger=logger)
create_alias('~cofr', 'cofr frontCenter')
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
from chimerax.core.commands import BoolArg, Color8Arg, IntArg, FloatArg, Int2Arg
desc = CmdDesc(optional=[('enable', BoolArg)],
keyword=[('foreground_color', Color8Arg),
('saturation', IntArg),
('flip_horizontal', BoolArg),
('color_popup', BoolArg), ('size', Int2Arg),
('framerate', FloatArg)],
synopsis='Turn on webcam rendering')
register('webcam', desc, webcam, logger=logger)
create_alias('device webcam', 'webcam $*', logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg, EnumOf, EmptyArg, Or, \
NoArg, BoolArg, create_alias
desc = CmdDesc(optional=[('objects', Or(ObjectsArg, EmptyArg)),
('what', WhatArg)],
keyword=[('target', TargetArg), ('only', NoArg)],
hidden=['only'],
synopsis='show specified objects')
register('show', desc, show, logger=logger)
create_alias('display',
'show $*',
logger=logger,
url="help:user/commands/show.html")
def register_command(command_name, logger):
from . import cmd
from chimerax.core.commands import register
base_cmd = "nucleotides"
# for subcmd in ("", " style", " style list", " style delete"):
for subcmd in ("", ):
cmd_name = base_cmd + subcmd
func_name = cmd_name.replace(' ', '_')
func = getattr(cmd, func_name)
desc = getattr(cmd, func_name + "_desc")
register(cmd_name, desc, func)
from chimerax.core.commands import create_alias
create_alias("~" + base_cmd, base_cmd + " $* atoms", logger=logger)
def register_command(logger):
from chimerax.core.commands import register, CmdDesc, StringArg, ColorArg, NoArg, EnumOf
from chimerax.core.commands import Or, RestOfLine, create_alias
register(
'color list',
CmdDesc(
optional=[('which', EnumOf(["all", "custom", "builtin"]))],
synopsis='list colors'),
list_colors, logger=logger
)
register(
'color show',
CmdDesc(required=[('name', RestOfLine)],
synopsis="show color"),
show_color, logger=logger
)
register(
'color name',
CmdDesc(required=[('name', StringArg), ('color', ColorArg)],
synopsis="name a custom color"),
name_color, logger=logger
)
register(
'color delete',
CmdDesc(required=[('name', Or(EnumOf(['custom']), StringArg))],
synopsis="remove color definition"),
delete_color, logger=logger
)
create_alias('colordef', 'color name $*', logger=logger)
create_alias('~colordef', 'color delete $*', logger=logger)
create_alias('colourdef', 'color name $*', logger=logger,
url="help:user/commands/colordef.html")
create_alias('~colourdef', 'color delete $*', logger=logger,
url="help:user/commands/colordef.html")
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg, EnumOf, EmptyArg, Or, \
create_alias
from .show import WhatArg, TargetArg
desc = CmdDesc(optional=[('objects', Or(ObjectsArg, EmptyArg)),
('what', WhatArg)],
keyword=[('target', TargetArg)],
url='help:user/commands/show.html#hide',
synopsis='hide specified objects')
register('hide', desc, hide, logger=logger)
create_alias('~show', 'hide $*', logger=logger)
create_alias('~display',
'hide $*',
logger=logger,
url="help:user/commands/show.html")
def register_command(logger):
from chimerax.core.commands import register, Or, CmdDesc
from chimerax.core.commands import Bounded, FloatArg, EnumOf, BoolArg, IntArg, TupleOf, NoArg
from chimerax.atomic import AtomsArg, AtomicStructuresArg
desc = CmdDesc(optional=[("atoms", AtomsArg)],
keyword=[("smooth", Or(Bounded(FloatArg, 0.0, 1.0),
EnumOf(["default"]))),
("suppress_backbone_display", BoolArg),
("spine", BoolArg),
],
hidden=["spine"],
synopsis='display cartoon for specified residues')
register("cartoon", desc, cartoon, logger=logger)
desc = CmdDesc(optional=[("structures", AtomicStructuresArg)],
keyword=[("scale", Bounded(FloatArg, 0.0, 1.0)),
("shape", EnumOf(_TetherShapeMap.keys())),
("sides", Bounded(IntArg, 3, 24)),
("opacity", Bounded(FloatArg, 0.0, 1.0)),
],
synopsis='set cartoon tether options for specified structures')
register("cartoon tether", desc, cartoon_tether, logger=logger)
desc = CmdDesc(optional=[("atoms", AtomsArg)],
keyword=[("width", FloatArg),
("thickness", FloatArg),
("arrows", BoolArg),
("arrows_helix", BoolArg),
("arrow_scale", Bounded(FloatArg, 1.0, 5.0)),
("xsection", EnumOf(_XSectionMap.keys())),
("sides", Bounded(EvenIntArg, 3, 24)),
("divisions", Bounded(IntArg, 2, 40)),
("bar_scale", FloatArg),
("bar_sides", Bounded(EvenIntArg, 3, 24)),
("ss_ends", EnumOf(["default", "short", "long"])),
("mode_helix", EnumOf(list(_ModeHelixMap.keys()))),
("mode_strand", EnumOf(list(_ModeStrandMap.keys()))),
("radius", Or(FloatArg, EnumOf(["auto"]))),
("spline_normals", BoolArg),
],
hidden=["ss_ends", "mode_strand", "spline_normals"],
synopsis='set cartoon style for secondary structures in specified models')
register("cartoon style", desc, cartoon_style, logger=logger)
desc = CmdDesc(optional=[("atoms", AtomsArg)],
synopsis='undisplay cartoon for specified residues')
register("cartoon hide", desc, uncartoon, logger=logger)
from chimerax.core.commands import create_alias
create_alias("~cartoon", "cartoon hide $*", logger=logger)
def register_command(bi, ci, logger):
command_name = ci.name
if command_name == "blastpdb":
from chimerax.core.commands import create_alias
create_alias(command_name,
"blastprotein $*",
logger=logger,
url="help:user/commands/blastprotein.html")
return
from . import cmd
function_name = command_name.replace(' ', '_')
func = getattr(cmd, function_name)
desc = getattr(cmd, function_name + "_desc")
if desc.synopsis is None:
desc.synopsis = ci.synopsis
from chimerax.core.commands import register
register(command_name, desc, func, logger=logger)
def register_lookingglass_command(logger):
from chimerax.core.commands import register, create_alias, CmdDesc, BoolArg, IntArg, FloatArg
desc = CmdDesc(optional=[('enable', BoolArg)],
keyword=[
('device_number', IntArg),
('view_angle', FloatArg),
('field_of_view', FloatArg),
('depth_offset', FloatArg),
('verbose', BoolArg),
('quilt', BoolArg),
],
synopsis='Render to LookingGlass holographic display.',
url='help:user/commands/device.html#lookingglass')
register('lookingglass', desc, lookingglass, logger=logger)
create_alias('device lookingglass',
'lookingglass $*',
logger=logger,
url='help:user/commands/device.html#lookingglass')
def register_command(logger):
from chimerax.core.commands import create_alias, CmdDesc, register, Or, EmptyArg, StringArg, BoolArg
from chimerax.atomic import AtomsArg, BondsArg, PseudobondsArg
desc = CmdDesc(required=[('atoms', AtomsArg)],
keyword=[('attached_hyds', BoolArg)],
synopsis='delete atoms')
register('delete', desc, delete, logger=logger)
desc = CmdDesc(required=[('atoms', Or(AtomsArg, EmptyArg))],
keyword=[('attached_hyds', BoolArg)],
synopsis='delete atoms')
register('delete atoms', desc, delete_atoms, logger=logger)
desc = CmdDesc(required=[('bonds', Or(BondsArg, EmptyArg))],
synopsis='delete bonds')
register('delete bonds', desc, delete_bonds, logger=logger)
desc = CmdDesc(required=[('pbonds', Or(PseudobondsArg, EmptyArg))],
keyword=[('name', StringArg)],
synopsis='delete pseudobonds')
register('delete pbonds', desc, delete_pbonds, logger=logger)
create_alias('delete pseudobonds', 'delete pbonds $*', logger=logger)
def register_leapmotion_command(logger):
from chimerax.core.commands import register, create_alias, CmdDesc
from chimerax.core.commands import BoolArg, FloatArg, Float3Arg, Float2Arg, EnumOf
ModeArg = EnumOf(('mouse', 'vr'))
desc = CmdDesc(optional=[('enable', BoolArg)],
keyword=[('pointer_size', FloatArg), ('mode_left', ModeArg),
('mode_right', ModeArg), ('width', FloatArg),
('center', Float3Arg), ('facing', Float3Arg),
('cord', Float3Arg),
('pinch_thresholds', Float2Arg),
('max_delay', FloatArg), ('head_mounted', BoolArg),
('debug', BoolArg)],
synopsis='Enable leap motion hand tracker for mouse modes.',
url='help:user/commands/device.html#leapmotion')
register('leapmotion', desc, leapmotion, logger=logger)
create_alias('device leapmotion',
'leapmotion $*',
logger=logger,
url='help:user/commands/device.html#leapmotion')
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg, NoArg, create_alias, \
BoolArg, FloatArg, StringArg
from chimerax.atomic import AtomsArg
desc = CmdDesc(optional=[('objects', ObjectsArg)],
keyword=[('residues', BoolArg),
('polymer', AtomsArg),
('minimum_length', FloatArg),
('maximum_length', FloatArg),
('sequence', StringArg)],
synopsis='select specified objects')
register('select', desc, select, logger=logger)
desc = CmdDesc(optional=[('objects', ObjectsArg)],
keyword=[('residues', BoolArg)],
synopsis='add objects to selection')
register('select add', desc, select_add, logger=logger)
desc = CmdDesc(optional=[('objects', ObjectsArg)],
keyword=[('residues', BoolArg)],
synopsis='subtract objects from selection')
register('select subtract', desc, select_subtract, logger=logger)
desc = CmdDesc(required=[('objects', ObjectsArg)],
keyword=[('residues', BoolArg)],
synopsis='intersect objects with selection')
register('select intersect', desc, select_intersect, logger=logger)
desc = CmdDesc(synopsis='extend the selection up one level')
register('select up', desc, select_up, logger=logger)
desc = CmdDesc(synopsis='revert the selection down one level')
register('select down', desc, select_down, logger=logger)
desc = CmdDesc(synopsis='clear the selection')
register('select clear', desc, select_clear, logger=logger)
create_alias('~select', 'select subtract $*', logger=logger)
# Register "select zone" subcommand
from . import zonesel
zonesel.register_command(logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, IntArg, StringArg, BoolArg, \
RepeatOf, create_alias
desc = CmdDesc(
required=[('command', StringArg)],
keyword=[
('ranges',
RepeatOf(RangeArg)), # TODO: Allow multiple range arguments.
('frames', IntArg),
('interval', IntArg),
('format', StringArg), # TODO: Allow multiple format arguments.
('zero_pad_width', IntArg),
('show_commands', BoolArg)
],
synopsis='Run a command before each graphics frame is drawn')
register('perframe', desc, perframe, logger=logger)
desc = CmdDesc(synopsis='Stop all perframe commands')
register('perframe stop', desc, stop_perframe_callbacks, logger=logger)
create_alias('~perframe', 'perframe stop')
def register_rota(logger):
from chimerax.core.commands import (register, CmdDesc, BoolArg,
create_alias)
from chimerax.atomic import StructuresArg
desc = CmdDesc(
optional=[
('structures', StructuresArg),
],
keyword=[
('report', BoolArg),
],
synopsis=
'Add rotamer validator markup to models and optionally report current outliers'
)
register('rota', desc, rota, logger=logger)
undesc = CmdDesc(
optional=[('structures', StructuresArg)],
synopsis=
'Close the rotamer annotators for the given models (or all if no models given)'
)
register('rota stop', undesc, unrota, logger=logger)
create_alias('~rota', 'rota stop $*', logger=logger)
def register_struts_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
from chimerax.core.commands import FloatArg, ColorArg, BoolArg, StringArg, ModelIdArg
from chimerax.atomic import AtomsArg
desc = CmdDesc(
required = [('atoms', AtomsArg)],
keyword = [('length', FloatArg),
('loop', FloatArg),
('radius', FloatArg),
('color', ColorArg),
('fatten_ribbon', BoolArg),
('replace', BoolArg),
('name', StringArg),
('model_id', ModelIdArg)],
synopsis = 'Add bonds to atomic models to make them rigid for 3d printing'
)
register('struts', desc, struts, logger=logger)
desc = CmdDesc(optional = [('atoms', AtomsArg)],
synopsis = 'Delete bonds created with the struts command')
register('struts delete', desc, struts_delete, logger=logger)
create_alias('~struts', 'struts delete $*')
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
from chimerax.core.commands import BoolArg, FloatArg, IntArg, Int2Arg
desc = CmdDesc(optional=[('enable', BoolArg)],
keyword=[
('size', Int2Arg),
('dsize', Int2Arg),
('frames_per_second', IntArg),
('align', BoolArg),
('denoise', BoolArg),
('denoise_weight', FloatArg),
('denoise_color_tolerance', IntArg),
('projector', BoolArg),
('angstroms_per_meter', FloatArg),
('skip_frames', IntArg),
('set_window_size', BoolArg),
],
synopsis='Turn on RealSense camera rendering',
url='help:user/commands/device.html#realsense')
register('realsense', desc, device_realsense, logger=logger)
create_alias('device realsense',
'realsense $*',
logger=logger,
url='help:user/commands/device.html#realsense')
def register_surface_subcommands(logger):
# TODO: Port other subcommands from Chimera 1.
old_stuff = """
ops = {
'cap': (cap_op,
(('onoff', string_arg),),
(),
(('color', string_arg), # Can be "same"
('mesh', bool_arg),
('subdivision', float_arg, {'min':0}),
('offset', float_arg))),
'clip': (clip_op,
(('volumes', volumes_arg),),
(),
(('center', string_arg),
('coordinateSystem', openstate_arg),
('radius', float_arg, {'min':0}),
('color', color_arg),
('mesh', bool_arg),
('replace', bool_arg))),
'colorCopy': (color_copy_op,
(('surfaces', surface_pieces_arg),
('tosurfaces', surface_pieces_arg),),
(),
()),
'finerMesh': (subdivide_op,
(('surfaces', surface_pieces_arg),),
(),
(('spacing', float_arg),
('inPlace', bool_arg),
('modelId', model_id_arg))),
'hidePieces': (hide_pieces_op,
(('pieces', surface_pieces_arg),), (), ()),
'invertShown': (invert_shown_op,
(('pieces', surface_pieces_arg),), (), ()),
'showPieces': (show_pieces_op,
(('pieces', surface_pieces_arg),), (), ()),
'smooth': (smooth_op,
(('surfaces', surface_pieces_arg),),
(),
(('factor', float_arg),
('iterations', int_arg),
('inPlace', bool_arg),
('modelId', model_id_arg))),
'split': (split_op,
(('surfaces', surface_pieces_arg),),
(),
(('inPlace', bool_arg),
('modelId', model_id_arg))),
'transform': (transform_op,
(('surfaces', surface_pieces_arg),),
(),
(('scale', float_arg),
('radius', float_arg, {'min':0}),
('move', float3_arg),
('rotate', float_arg),
('axis', string_arg),
('center', string_arg),
('coordinateSystem', openstate_arg),)),
}
"""
from chimerax.core.commands import CmdDesc, register, SurfacesArg, FloatArg, \
IntArg, BoolArg, EnumOf
from chimerax.atomic import AtomsArg
from .dust import metrics
dust_desc = CmdDesc(required=[('surfaces', SurfacesArg)],
keyword=[('metric', EnumOf(metrics)),
('size', FloatArg), ('update', BoolArg)],
synopsis='hide small connected surface patches')
register('surface dust', dust_desc, surface_dust, logger=logger)
undust_desc = CmdDesc(required=[('surfaces', SurfacesArg)],
synopsis='reshow surface dust')
register('surface undust', undust_desc, surface_undust, logger=logger)
zone_desc = CmdDesc(required=[('surfaces', SurfacesArg)],
keyword=[('near_atoms', AtomsArg),
('distance', FloatArg),
('bond_point_spacing', FloatArg),
('max_components', IntArg),
('update', BoolArg)],
required_arguments=['near_atoms'],
synopsis='show surface near atoms')
register('surface zone', zone_desc, surface_zone, logger=logger)
unzone_desc = CmdDesc(required=[('surfaces', SurfacesArg)],
synopsis='show full surface without zone')
register('surface unzone', unzone_desc, surface_unzone, logger=logger)
from chimerax.core.commands import create_alias
create_alias('sop',
'surface $*',
logger=logger,
url="help:user/commands/surface.html#sop")
def register_tool_command(logger):
from chimerax.core.commands import create_alias
create_alias('tool', 'ui tool $*', logger=logger)
def register_command(command_name, logger):
# 'register_command' is lazily called when the command is referenced
from . import cmd
from chimerax.core.commands import register, create_alias
register('info', cmd.info_desc, cmd.info, logger=logger)
create_alias("listinfo", "info $*", logger=logger)
register("info bounds",
cmd.info_bounds_desc,
cmd.info_bounds,
logger=logger)
register("info models",
cmd.info_models_desc,
cmd.info_models,
logger=logger)
register("info chains",
cmd.info_chains_desc,
cmd.info_chains,
logger=logger)
register("info polymers",
cmd.info_polymers_desc,
cmd.info_polymers,
logger=logger)
register("info residues",
cmd.info_residues_desc,
cmd.info_residues,
logger=logger)
register("info atoms",
cmd.info_atoms_desc,
cmd.info_atoms,
logger=logger)
register("info selection",
cmd.info_selection_desc,
cmd.info_selection,
logger=logger)
register("info atomattr",
cmd.info_atomattr_desc,
cmd.info_atomattr,
logger=logger)
register("info bondattr",
cmd.info_bondattr_desc,
cmd.info_bondattr,
logger=logger)
register("info resattr",
cmd.info_resattr_desc,
cmd.info_resattr,
logger=logger)
register("info distmat",
cmd.info_distmat_desc,
cmd.info_distmat,
logger=logger)
register("info notify start",
cmd.info_notify_start_desc,
cmd.info_notify_start,
logger=logger)
register("info notify stop",
cmd.info_notify_stop_desc,
cmd.info_notify_stop,
logger=logger)
register("info notify suspend",
cmd.info_notify_suspend_desc,
cmd.info_notify_suspend,
logger=logger)
register("info notify resume",
cmd.info_notify_resume_desc,
cmd.info_notify_resume,
logger=logger)
register("info path", cmd.info_path_desc, cmd.info_path, logger=logger)
def initialize(command_name, logger):
from chimerax.core.commands import create_alias
create_alias(command_name,
"%s $*" % command_name.replace("ribbon", "cartoon"),
logger=logger,
url="help:user/commands/cartoon.html")
def register_cview_cmd(logger):
from chimerax.core.commands import create_alias
create_alias('cview', 'view $*; cofr center showpivot true', logger=logger)
