def __init__(self, text, xyz, color='red'): """ Displays a text in VMD. The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- text : str The text xyz : list The position of the text color : str Color of the text """ super().__init__(xyz) self._remember('draw materials off') self._remember('draw color {}'.format(color)) self._remember('draw text "{} {} {}" "{}"\n'.format( xyz[0], xyz[1], xyz[2], text)) self.script.write("\n") self.script.write("set htmd_graphics_mol({:d}) [molinfo top]".format( self.n)) cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def __init__(self, xyz, color='red', radius=1): """ Displays a sphere in VMD. The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- xyz : list The center of the sphere color : str Color of the sphere radius : float The radius of the sphere """ super().__init__(xyz) #self._remember('draw materials off') self._remember('draw color {}'.format(color)) self._remember('draw sphere "{} {} {}" radius {}\n'.format( xyz[0], xyz[1], xyz[2], radius)) self.script.write("\n") self.script.write("set htmd_graphics_mol({:d}) [molinfo top]".format( self.n)) cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def __init__(self, start, end, color='red', radius=1): """ Displays a cylinder in VMD. The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- start : list The starting coordinates of the cylinder end : list The ending coordinates of the cylinder color : str Color of the cylinder radius : float The radius of the cylinder """ super().__init__([start, end]) #self._remember('draw materials off') self._remember('draw color {}'.format(color)) self._remember('draw cylinder {{ {} }} {{ {} }} radius {}\n'.format( ' '.join(map(str, start)), ' '.join(map(str, end)), radius)) self.script.write("\n") self.script.write("set htmd_graphics_mol({:d}) [molinfo top]".format( self.n)) cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def __init__(self, xyz, color="red", radius=1): """Displays a sphere in VMD. The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- xyz : list The center of the sphere color : str Color of the sphere radius : float The radius of the sphere """ super().__init__(xyz) # self._remember('draw materials off') self._remember(f"draw color {color}") self._remember( f'draw sphere "{xyz[0]} {xyz[1]} {xyz[2]}" radius {radius}\n') self.script.write("\n") self.script.write(f"set htmd_graphics_mol({self.n}) [molinfo top]") cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def __init__(self, mol, style="", preamble="", solid=False): """Display the convex hull of the given molecule. For preamble and color, see http://www.ks.uiuc.edu/Research/vmd/vmd-1.9.2/ug/node129.html The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- m: Molecule The object of which to show the hull (only 1 frame) style: str Style for wireframe lines preamble: str Commands (material, color) to be prefixed to the output. E.g.: "draw color red; graphics top materials on; graphics top material Transparent". Note that this affects later preamble-less commands. solid: bool Solid or wireframe Examples -------- >>> from moleculekit.vmdgraphics import VMDConvexHull >>> m=Molecule("3PTB") >>> m.view() >>> mf=m.copy() >>> _ = mf.filter("protein ") >>> gh=VMDConvexHull(mf) # doctest: +ELLIPSIS >>> gh.delete() """ from scipy.spatial import ConvexHull if mol.coords.shape[2] != 1: raise Exception("Only one frame is supported") cc = mol.coords[:, :, 0] hull = ConvexHull(cc) super().__init__(hull) self.script.write(preamble + "\n") for i in range(hull.nsimplex): v1, v2, v3 = hull.simplices[i, :] c1s = VMDGraphicObject.tq(cc[v1, :]) c2s = VMDGraphicObject.tq(cc[v2, :]) c3s = VMDGraphicObject.tq(cc[v3, :]) if solid: self._remember(f"draw triangle {c1s} {c2s} {c3s}") else: self._remember(f"draw line {c1s} {c2s} {style}") self._remember(f"draw line {c1s} {c3s} {style}") self._remember(f"draw line {c2s} {c3s} {style}") self.script.write("\n") self.script.write(f"set htmd_graphics_mol({self.n}) [molinfo top]") cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def _prepareViewer(mol, ligandsel): mol.view(sel="protein", style="lines", hold=True) mol.view(sel=ligandsel, style="licorice", hold=True) mol.view() viewer = getCurrentViewer() viewer.send("draw color red") viewer.send("color Display Background black") viewer.send("draw materials off") return viewer
def _prepareViewer(mol, ligandsel): mol.view(sel='protein', style='lines', hold=True) mol.view(sel=ligandsel, style='licorice', hold=True) mol.view() viewer = getCurrentViewer() viewer.send('draw color red') viewer.send('color Display Background black') viewer.send('draw materials off') return viewer
def __init__(self, box, color='red'): """ Displays a box in VMD as lines of its edges. The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- box : list The min and max positions of the edges. Given as [xmin, xmax, ymin, ymax, zmin, zmax] color : str Color of the lines """ super().__init__(box) xmin, xmax, ymin, ymax, zmin, zmax = box mi = [xmin, ymin, zmin] ma = [xmax, ymax, zmax] self._remember('draw materials off') self._remember('draw color {}'.format(color)) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], mi[1], mi[2], ma[0], mi[1], mi[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], mi[1], mi[2], mi[0], ma[1], mi[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], mi[1], mi[2], mi[0], mi[1], ma[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( ma[0], mi[1], mi[2], ma[0], ma[1], mi[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( ma[0], mi[1], mi[2], ma[0], mi[1], ma[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], ma[1], mi[2], ma[0], ma[1], mi[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], ma[1], mi[2], mi[0], ma[1], ma[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], mi[1], ma[2], ma[0], mi[1], ma[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( mi[0], mi[1], ma[2], mi[0], ma[1], ma[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( ma[0], ma[1], ma[2], ma[0], ma[1], mi[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( ma[0], ma[1], ma[2], mi[0], ma[1], ma[2])) self._remember('draw line "{} {} {}" "{} {} {}"\n'.format( ma[0], ma[1], ma[2], ma[0], mi[1], ma[2])) self.script.write("\n") self.script.write("set htmd_graphics_mol({:d}) [molinfo top]".format( self.n)) cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def _drawForce(start, vec): assert start.ndim == 1 and vec.ndim == 1 from moleculekit.vmdviewer import getCurrentViewer vmd = getCurrentViewer() vmd.send(""" proc vmd_draw_arrow {start end} { # an arrow is made of a cylinder and a cone draw color green set middle [vecadd $start [vecscale 0.9 [vecsub $end $start]]] graphics top cylinder $start $middle radius 0.15 graphics top cone $middle $end radius 0.25 } """) vmd.send('vmd_draw_arrow {{ {} }} {{ {} }}'.format( ' '.join(map(str, start)), ' '.join(map(str, start + vec))))
def viewStates(self, protein=None, ligand=None, nsamples=20): from htmd.projections.metric import _singleMolfile from moleculekit.molecule import Molecule from moleculekit.vmdviewer import getCurrentViewer (single, molfile) = _singleMolfile(self.data.simlist) if not single: raise RuntimeError("Can" "t visualize states without unique molfile") viewer = getCurrentViewer() colors = [0, 1, 3, 4, 5, 6, 7, 9] print("Active set includes macrostates: {}".format( self.hmm.active_set)) # dtraj = np.vstack(self.hmm.discrete_trajectories_full) res = self.hmm.sample_by_observation_probabilities(nsamples) refmol = Molecule(molfile) for i, s in enumerate(self.hmm.active_set): mol = Molecule(molfile) mol.coords = [] mol.box = [] # idx = np.where(dtraj == i)[0] # samples = np.random.choice(idx, 20) # frames = self.data.abs2sim(samples) frames = self.data.rel2sim(res[i]) for f in frames: mol._readTraj(f.sim.trajectory[f.piece], frames=[f.frame], append=True) mol.wrap("protein") mol.align("protein", refmol=refmol) viewer.loadMol(mol, name="hmm macro " + str(s)) if ligand is not None: viewer.rep("ligand", sel=ligand, color=colors[np.mod(i, len(colors))]) if protein is not None: viewer.rep("protein") viewer.send("start_sscache")
def __init__(self, mol, selection, molid="top", textsize=0.5, textcolor="green"): """Displays labels on atoms in VMD. Examples -------- >>> from moleculekit.molecule import Molecule # doctest: +ELLIPSIS >>> from moleculekit.vmdgraphics import VMDLabels >>> mol = Molecule('3ptb') >>> mol.view() >>> x = VMDLabels(mol, 'resid 40') >>> y = VMDLabels(mol, 'resid 50') >>> y.delete() >>> x.delete() """ # TODO: After deleting labels it breaks. Better don't delete or fix the code super().__init__(None) idx = mol.atomselect(selection, indexes=True) cmd = """label textsize {s} color Labels Atoms {c} set molnum [molinfo {molid}] set i {start} foreach n [list {idx}] {{ label add Atoms $molnum/$n label textformat Atoms $i {{%a}} incr i }}""".format( s=textsize, c=textcolor, sel=selection, molid=molid, idx=" ".join(map(str, idx)), start=VMDLabels.count, ) self.labelidx = list(range(VMDLabels.count, VMDLabels.count + len(idx))) VMDLabels.count += len(idx) vmd = getCurrentViewer() vmd.send(cmd)
def __init__(self, text, xyz, color="red"): """Displays a text in VMD. The function returns an instance of VMDGraphicsObject. To delete it, use the delete() method. Parameters ---------- text : str The text xyz : list The position of the text color : str Color of the text """ super().__init__(xyz) self._remember("draw materials off") self._remember(f"draw color {color}") self._remember(f'draw text "{xyz[0]} {xyz[1]} {xyz[2]}" "{text}"\n') self.script.write("\n") self.script.write(f"set htmd_graphics_mol({self.n}) [molinfo top]") cmd = self.script.getvalue() vmd = getCurrentViewer() vmd.send(cmd)
def delete(self): vmd = getCurrentViewer() for i in self.labelidx[::-1]: vmd.send(f"label delete Atoms {i}") VMDLabels.count -= 1
def delete(self): vmd = getCurrentViewer() vmd.send(f"mol delete htmd_graphics_mol({self.n})")
def generateCrystalPacking(pdbid, hexagonal=False, visualize=False, viewerhandle=None): """ Generates the crystal packing of a PDB protein. It is possible to inspect it immediately with the visualize option. It can only be generated if there is crystallographic information in the PDB entry. Parameters ---------- pdbid : str ID from the Protein Databank hexagonal : bool # TODO: Undocumented visualize : bool If True, this function also visualizes the crystal packing viewerhandle : :class:`VMD <moleculekit.vmdviewer.VMD>` object, optional A specific viewer in which to visualize the molecule. If None it will use the current default viewer. Returns ------- mol : :class:`Molecule` Molecule object with the crystal packing """ if not isinstance(pdbid, str): raise ValueError('pdbid should be a string') filename, _ = _getPDB(pdbid) mol = Molecule(filename) if viewerhandle is not None and not visualize: logger.warning('A viewerhandle was passed. Setting visualize to True.') visualize = True if visualize and viewerhandle is None: from moleculekit.vmdviewer import getCurrentViewer viewerhandle = getCurrentViewer() if mol.crystalinfo is None or 'numcopies' not in mol.crystalinfo: raise RuntimeError('No crystallography data found in Molecule.') ci = mol.crystalinfo alpha, beta, gamma, a, b, c = ci['alpha'], ci['beta'], ci['gamma'], ci['a'], ci['b'], ci['c'] alpha = np.deg2rad(float(alpha)) beta = np.deg2rad(float(beta)) gamma = np.deg2rad(float(gamma)) caux = (np.cos(alpha) - np.cos(beta) * np.cos(gamma)) / np.sin(gamma) axes = np.array([[a, 0, 0], [b * np.cos(gamma), b * np.sin(gamma), 0], [c * np.cos(beta), c * caux, c * np.sqrt(1 - np.cos(beta) ** 2 - caux ** 2)]]) size = np.array([axes[0][0], axes[1][1], axes[2][2]]) molunit = Molecule() # Creates copies of the molecule and places them correctly inside the complete Unit Cell hexagonal_molunit = None for i in tqdm(range(ci['numcopies']), desc='Generating symmetry mates'): molecule = mol.copy() molecule.segid[:] = str(i+1) # apply SMTRY (Crystal Symmetry) operations molecule.rotateBy(ci['rotations'][i]) molecule.moveBy(ci['translations'][i]) # apply translation to inside of same Unit Cell. _place_crystal(molecule, size, [alpha, beta, gamma], axes) # pack copies to target Unit Cell molunit.append(molecule) if ci['sGroup'][0] == 'H' and hexagonal: hexagonal_molunit = Molecule() _build_hexagon(molunit, hexagonal_molunit) if hexagonal_molunit is not None: if visualize: hexagonal_molunit.view(style='NewCartoon', viewerhandle=viewerhandle) else: return hexagonal_molunit else: if visualize: molunit.view(style='NewCartoon', viewerhandle=viewerhandle) else: return molunit if visualize: _draw_cell(axes, ci['sGroup'], viewerhandle, hexagonal=hexagonal)
def test_crystalpacking_visualization(self): from moleculekit.vmdviewer import getCurrentViewer viewer = getCurrentViewer(dispdev='text') generateCrystalPacking('3ptb', visualize=True, viewerhandle=viewer)