def name_and_group_models(models, name_arg, path_info): if len(models) > 1: # name arg only applies to group, not underlings if name_arg: names = [name_arg] * len(models) elif len(path_info) == len(models): names = [model_name_from_path(p) for p in path_info] else: names = [model_name_from_path(path_info[0])] * len(models) for m, pn in zip(models, names): if name_arg or not m.name: m.name = pn from chimerax.core.models import Model names = set([m.name for m in models]) if len(names) == 1: group_name = names.pop() + " group" elif len(path_info) == 1: group_name = model_name_from_path(path_info[0]) else: group_name = "group" group = Model(group_name, models[0].session) group.add(models) return group model = models[0] if name_arg: model.name = name_arg else: if not model.name: model.name = model_name_from_path(path_info[0]) return model
def delete(self): self.session.triggers.remove_handler(self._new_frame_handler) self._new_frame_handler = None from ._leap import leap_close leap_close(self._connection) self._connection = None Model.delete(self)
def _transform_schematic(session, transform, center, from_rgba, to_rgba, length, width, thickness): axis, rot_center, angle_deg, shift = transform.axis_center_angle_shift() # Align rot_center at same position along axis as center. from chimerax.geometry import inner_product rot_center += inner_product(center - rot_center, axis) * axis width_axis = center - rot_center varray, narray, tarray = _axis_square(axis, rot_center, width_axis, length, width, thickness) from chimerax.core.models import Model, Surface s1 = Surface('slab 1', session) s1.set_geometry(varray, narray, tarray) s1.color = from_rgba s2 = Surface('slab 2', session) from chimerax.geometry import rotation, translation rot2 = translation(shift * axis) * rotation( axis, angle_deg, center=rot_center) varray2 = rot2 * varray narray2 = rot2.transform_vectors(narray) s2.set_geometry(varray2, narray2, tarray) s2.color = to_rgba m = Model('transform schematic', session) m.add([s1, s2]) return m
def __init__(self, session): Model.__init__(self, 'labels', session) self.on_top = True # Should labels always appear above other graphics self._window_size = session.main_view.window_size self._labels = [] # list of ObjectLabel self._object_label = { } # Map object (Atom, Residue, Pseudobond, Bond) to ObjectLabel self._num_pixel_labels = 0 # Number of labels sized in pixels. t = session.triggers self._update_graphics_handler = t.add_handler( 'graphics update', self._update_graphics_if_needed) self._model_display_handler = t.add_handler( 'model display changed', self._model_display_changed) from chimerax.core.core_settings import settings as core_settings self._background_color_handler = core_settings.triggers.add_handler( 'setting changed', self._background_changed_cb) from chimerax.atomic import get_triggers ta = get_triggers() self._structure_change_handler = ta.add_handler( 'changes', self._structure_changed) self.use_lighting = False Model.set_color(self, (255, 255, 255, 255)) # Do not modulate texture colors self._texture_width = 2048 # Pixels. self._texture_needs_update = True # Has text, color, size, font changed. self._positions_need_update = True # Has label position changed relative to atom? self._visibility_needs_update = True # Does an atom hide require a label to hide?
def __init__(self, atomic_structure, hide_favored = False, ignore_ribbon_hides = True): ''' Create the validator object, and add it as a child model to the target structure. Args: * atomic_structure: - a :py:class:`ChimeraX.AtomicStructure` instance * hide_favored: - if True, indicators will only appear for non-favored residues. (this can be changed at any time later) * ignore_ribbon_hides: - if True, the :attr:`chimerax.HIDE_RIBBON` bit will be ignored when deciding when to display a particular annotation. This is needed because the default ChimeraX ribbon representation hides the CA for any residue whose sidechain is un-displayed or missing (meaning that the glycine CA is always hidden). ''' structure = self._atomic_structure = atomic_structure session = structure.session Model.__init__(self, 'Ramachandran Validation', session) structure.add([self]) self._ignore_ribbon_hides = ignore_ribbon_hides self._hide_favored = hide_favored from .. import molobject mgr = self._mgr = molobject.get_ramachandran_mgr(session) self._ca_radius = 0.5 self._prepare_drawings() # self._prepare_ca_display() self.track_whole_model = True t = structure.triggers self._structure_change_handler = t.add_handler('changes', self._update_graphics_if_needed)
def __init__(self, name, session, foreground_color=(0, 255, 0, 255), saturation=10, color_popup=False, flip_horizontal=True, size=None, framerate=25): Model.__init__(self, name, session) self._camera = None # QCamera self.camera_name = '' self._capture = None # VideoCapture instance self.size = None # Width, height in pixels self._requested_size = size self.framerate = None # Frames per second, float self._requested_framerate = framerate self._first_image = True # Whether first image has been acquired self._last_image = None # Numpy color array (h,w,3) uint8 self.foreground_color = foreground_color # What color pixels to put in front of models self.saturation = saturation # How saturated pixel color must be to be foreground self.color_popup = color_popup self._flip_horizontal = flip_horizontal self._start_video()
def test_ra(session): from chimerax.core.models import Model, Drawing m = Model('test', session) d = Drawing('ring') d.set_geometry(*ring_arrow_with_post(0.5, 0.05, 4, 6, 0.3, 0.1, 0.05, 1)) m.add_drawing(d) session.models.add([m])
def __init__(self, session, pointer_size=1.0, hand='right', emulate='mouse', tracking_space=TrackingSpace(), pinch_thresholds=(0.9, 0.6)): self._emulate = emulate # 'mouse' or 'vr' for 2d or 6d mouse mode events self._hand = hand # 'left' or 'right' self._tracking_space = tracking_space # Maps device hand position to screen. self._pinch = False # Are thumb and index finger touching? self._pinch_thresholds = pinch_thresholds # Pinch strength on and off thresholds self._last_hand_pose = None # Used for mouse mode drag events, leap device coordinates self._window_xy = None name = self._hand + ' hand' Model.__init__(self, name, session) self._set_pointer_shape(cross_diameter=pointer_size, stick_diameter=0.1 * pointer_size) if hand == 'right': self._unpinch_color = (0, 255, 0, 255) self._pinch_color = (0, 255, 255, 255) else: self._unpinch_color = (255, 255, 0, 255) self._pinch_color = (255, 0, 255, 255) self.color = self._unpinch_color
def __init__(self, session, name='Head', size=0.3, image_file=None): Model.__init__(self, name, session) self.room_position = None r = size / 2 from chimerax.surface import box_geometry va, na, ta = box_geometry((-r, -r, -0.1 * r), (r, r, 0.1 * r)) if image_file is None: from os.path import join, dirname image_file = join(dirname(__file__), self.default_face_file) from PyQt5.QtGui import QImage qi = QImage(image_file) aspect = qi.width() / qi.height() va[:, 0] *= aspect from chimerax.graphics import qimage_to_numpy, Texture rgba = qimage_to_numpy(qi) from numpy import zeros, float32 tc = zeros((24, 2), float32) tc[:] = 0.5 tc[8:12, :] = ((0, 0), (1, 0), (0, 1), (1, 1)) self.set_geometry(va, na, ta) self.color = (255, 255, 255, 255) self.texture = Texture(rgba) self.texture_coordinates = tc
def __init__(self, atomic_structure): ''' Create the validator object, and add it as a child model to the target structure. Args: * atomic_structure: - a :py:class:`ChimeraX.AtomicStructure` instance ''' structure = self._atomic_structure = atomic_structure session = structure.session Model.__init__(self, 'Rotamer Validation', session) from .. import molobject mgr = self._mgr = molobject.get_rotamer_mgr(session) self._MAX_SCALE = 2 # maximum scale factor for annotation drawings self._hide_favored = True d = self._drawing = self._rota_indicator() self.add_drawing(d) structure.add([self]) self.track_whole_model = True t = structure.triggers self._structure_change_handler = t.add_handler('changes', self._update_graphics_if_needed) self.update_graphics() self._update_needed = False
def _group_subunit_models(session, subunit_models, name): from chimerax.core.models import Model group = Model(name, session) for i,m in enumerate(subunit_models): m.name = 'subunit %d' % (i+1) group.add(subunit_models) return group
def __init__(self, session, pointer_size=1.0, mode_left='vr', mode_right='vr', pinch_thresholds=(0.9, 0.6), max_delay=0.2, tracking_space=TrackingSpace(), head_mounted=False, debug=False): Model.__init__(self, 'Leap Motion', session) self._tracking_space = tracking_space self._max_delay = max_delay # Don't use hand positions older than this (seconds). self._hands = [ LeapHand(session, hand=hand, emulate=mode, pointer_size=pointer_size, tracking_space=tracking_space, pinch_thresholds=pinch_thresholds) for hand, mode in (('left', mode_left), ('right', mode_right)) ] self.add(self._hands) # Add hand models as children from ._leap import leap_open self._connection = leap_open(head_mounted=head_mounted, debug=debug) self._new_frame_handler = session.triggers.add_handler( 'new frame', self._new_frame)
def _add_surface(surface): session = surface.session models = session.models if models.have_model(surface): # Reusing existing model. return # Check if request model id is already being used. model_id = surface.id if model_id: if models.have_id(model_id): from chimerax.core.errors import UserError id_string = '.'.join('%d'%i for i in model_id) raise UserError('Model id #%s already in use' % id_string) # If parent models don't exist create grouping models. p = None for i in range(1,len(model_id)): if not models.have_id(model_id[:i]): from chimerax.core.models import Model m = Model('shape', session) m.id = model_id[:i] models.add([m], parent = p) p = m # Add surface. models.add([surface])
def __init__(self, session, name, number, color, contour_info): Model.__init__(self, name, session) self.roi_number = number opacity = 255 self.color = tuple(color) + (opacity, ) va, ta = self._contour_lines(contour_info) self.set_geometry(va, None, ta) self.display_style = self.Mesh self.use_lighting = False
def _add_provenance(self, name, p): """Add a Model containing provenance information keyed by the given name (usually a filename)""" if self._provenance is None or self._provenance.was_deleted: self._provenance = Model('Provenance', self.session) self.add([self._provenance]) self._provenance_map[name] = p self._provenance.add([p]) return self._provenance
def __init__(self, session, label): name = label.name if label.name else label.text Model.__init__(self, name, session) self.label = label self._window_size = None # Full window size in render pixels self._texture_size = None # Label image size in render pixels self._texture_pixel_scale = 1 # Converts label.size from logical pixels to render pixels self._aspect = 1 # Scale y label positioning for image saving at non-screen aspect ratio self.needs_update = True
def __init__(self, session): Model.__init__(self, '2D labels', session) self._labels = [] self._named_labels = {} # Map label name to Label object from chimerax.core.core_settings import settings self.handler = settings.triggers.add_handler( 'setting changed', self._background_color_changed) session.main_view.add_overlay(self) self.model_panel_show_expanded = False
def restore_snapshot(session, data): from chimerax.core.models import Model sh = data['symmetry manager'] if sh is None: return None mmgr = MapMgr(sh, auto_add=False) Model.set_state_from_snapshot(mmgr, session, data['model state']) session.triggers.add_handler('end restore session', mmgr._end_restore_session_cb) return mmgr
def set_state_from_snapshot(self, session, data): Model.set_state_from_snapshot(self, session, data['model state']) self.rmf_filename = data['rmf_filename'] self.rmf_features = data['rmf_features'] self.rmf_provenance = data['rmf_provenance'] self.rmf_hierarchy = data['rmf_hierarchy'] self._provenance_map = data['provenance_map'] self._rmf_resolutions = data['rmf_resolutions'] self._selected_rmf_resolutions = data['selected_rmf_resolutions'] self._rmf_chains = data['rmf_chains']
def restore_snapshot(cls, session, data): from chimerax.core.models import Model dtype = data['hkl data type'] container = data['container'] hklinfo = container.hklinfo hkldata = data['hkl data'] clipper_array = dtype(hklinfo) clipper_array.set_data(*hkldata) rd = cls('', session, clipper_array) Model.set_state_from_snapshot(rd, session, data['model state']) return rd
def delete(self): if self._global_group: pbm = self.session.pb_manager pbm._delete_group(self) else: s = self._structure if s and not s.deleted: s._delete_pseudobond_group(self) self._structure = None Model.delete(self) self._pbond_drawing = None
def restore_snapshot(session, data): if data['structure'] is not None: grp = data['structure'].pseudobond_group(data['category'], create_type=None) else: grp = session.pb_manager.get_group(data['category'], create=False) if 'model state' in data: Model.set_state_from_snapshot(grp, session, data['model state']) grp._dashes = data['dashes'] from .molobject import set_custom_attrs set_custom_attrs(grp, data) return grp
def __init__(self, session, name, room_to_scene, color=(0, 255, 0, 255)): Model.__init__(self, name, session) self._head = h = VRHeadModel(session) self.add([h]) self._hands = [] self._color = color self._gui = None # Last room to scene transformation for this peer. # Used if we are not using VR camera so have no room coordinates. self._room_to_scene = room_to_scene
def restore_snapshot(session, data): from chimerax.core.models import Model cm = data['crystal manager'] if cm is None: return None xmapset = XmapSet(cm, auto_add_to_session=False) Model.set_state_from_snapshot(xmapset, session, data['model state']) xmapset._f_sigf_data_name = data['F/sigF'] xmapset._session_restore_live_update = data['live update'] session.triggers.add_handler('end restore session', xmapset._end_restore_session_cb) return xmapset
def restore_snapshot(session, data): v = data.get('volume') if v is None: return None s = FastVolumeSurface(v, data['level'], data['rgba'], data.get('show_mesh', False)) from chimerax.core.models import Model Model.set_state_from_snapshot(s, session, data['model state']) if v._style_when_shown == 'image': s.display = False v._surfaces.append(s) return s
def __init__(self, name, session, color, center, radius): self._num_triangles = 1000 Model.__init__(self, name, session) from chimerax.surface import sphere_geometry2 va, na, ta = sphere_geometry2(self._num_triangles) self._unit_vertices = va self.set_geometry(radius * va, na, ta) self.color = color from chimerax.geometry import translation self.position = translation(center) self._radius = radius session.models.add([self])
def __init__(self, session, name, radius=1, height=3, color=(0, 255, 0, 255)): Model.__init__(self, name, session) from chimerax.surface import cone_geometry va, na, ta = cone_geometry(radius=radius, height=height) va[:, 2] -= 0.5 * height # Place tip of cone at origin self.set_geometry(va, na, ta) self.color = color
def draw(self, renderer, draw_pass): '''Render a color and depth texture pair.''' if self._first_image: return draw = ((draw_pass == self.OPAQUE_DRAW_PASS and self.opaque_texture) or (draw_pass == self.TRANSPARENT_DRAW_PASS and not self.opaque_texture)) if not draw: return r = renderer r.disable_shader_capabilities(r.SHADER_LIGHTING | r.SHADER_STEREO_360 | # Avoid geometry shift r.SHADER_DEPTH_CUE | r.SHADER_SHADOW | r.SHADER_MULTISHADOW | r.SHADER_CLIP_PLANES) r.enable_capabilities |= r.SHADER_ALPHA_DEPTH # If the desired field of view of the texture does not match the camera field of view # then adjust projection size. Also if the apect ratio of the target framebuffer and # the aspect ratio of the texture don't match adjust the projection size. w, h = r.render_size() vw, vh = self.size if vw * h > vh * w: # Video aspect is wider than window aspect. Fit height, clip width. sx = (vw / vh) / (w / h) sy = 1 else: # Video aspect is narrower than window aspect. Fit width, clip height. sx = 1 sy = (w / h) / (vw / vh) cur_proj = r.current_projection_matrix proj = ((sx, 0, 0, 0), (0, sy, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)) r.set_projection_matrix(proj) from chimerax.geometry import place p0 = place.identity() cur_view = r.current_view_matrix r.set_view_matrix(p0) r.set_model_matrix(p0) r.enable_blending(False) Model.draw(self, r, draw_pass) # Restore view and projection matrices since drawings are not supposed to change these. r.set_projection_matrix(cur_proj) r.set_view_matrix(cur_view) r.enable_capabilities &= ~r.SHADER_ALPHA_DEPTH r.disable_shader_capabilities(0)
def restore_snapshot(session, data): from chimerax.core.models import Model rdc = ReflectionDataContainer(session) Model.set_state_from_snapshot(rdc, session, data['model state']) rdc.filename = data['original filename'] from chimerax.clipper.clipper_python import (Resolution, Spgr_descr, Spacegroup, Cell_descr, Cell, HKL_info) res = Resolution(data['resolution']) cell = Cell(Cell_descr(*data['cell dim'], *data['cell angles'])) spgr_descr = Spgr_descr(data['hall symbol'], Spgr_descr.Hall) rdc._hklinfo = HKL_info(Spacegroup(spgr_descr), cell, res, True) return rdc
def __init__(self, name, session, data): ''' Args: name: A descriptive name. session: The ChimeraX session. data: A Clipper HKL_data_Flag or HKL_data_Flag_bool object. ''' Model.__init__(self, name, session) self._data = data