aboutsummaryrefslogtreecommitdiff
path: root/plip/visualization
diff options
context:
space:
mode:
authorNavan Chauhan <navanchauhan@gmail.com>2020-07-02 20:48:33 +0530
committerNavan Chauhan <navanchauhan@gmail.com>2020-07-02 20:48:33 +0530
commit4be08f7bdd77991e9e453c1cda863c3f20c338d5 (patch)
tree083e8e91622221185a28fd50754abc2f86b1df43 /plip/visualization
initial commit
Diffstat (limited to 'plip/visualization')
-rw-r--r--plip/visualization/__init__.py0
-rw-r--r--plip/visualization/chimera.py221
-rw-r--r--plip/visualization/pymol.py450
-rw-r--r--plip/visualization/visualize.py111
4 files changed, 782 insertions, 0 deletions
diff --git a/plip/visualization/__init__.py b/plip/visualization/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/plip/visualization/__init__.py
diff --git a/plip/visualization/chimera.py b/plip/visualization/chimera.py
new file mode 100644
index 0000000..a37fffb
--- /dev/null
+++ b/plip/visualization/chimera.py
@@ -0,0 +1,221 @@
+class ChimeraVisualizer:
+ """Provides visualization for Chimera."""
+
+ def __init__(self, plcomplex, chimera_module, tid):
+ self.chimera = chimera_module
+ self.tid = tid
+ self.uid = plcomplex.uid
+ self.plipname = 'PLIP-%i' % self.tid
+ self.hetid, self.chain, self.pos = self.uid.split(':')
+ self.pos = int(self.pos)
+ self.colorbyname = self.chimera.colorTable.getColorByName
+ self.rc = self.chimera.runCommand
+ self.getPseudoBondGroup = self.chimera.misc.getPseudoBondGroup
+
+ if plcomplex is not None:
+ self.plcomplex = plcomplex
+ self.protname = plcomplex.pdbid # Name of protein with binding site
+ self.ligname = plcomplex.hetid # Name of ligand
+ self.metal_ids = plcomplex.metal_ids
+ self.water_ids = []
+ self.bs_res_ids = []
+ self.models = self.chimera.openModels
+
+ for md in self.models.list():
+ if md.name == self.plipname:
+ self.model = md
+
+ self.atoms = self.atom_by_serialnumber()
+
+ def set_initial_representations(self):
+ """Set the initial representations"""
+ self.update_model_dict()
+ self.rc("background solid white")
+ self.rc("setattr g display 0") # Hide all pseudobonds
+ self.rc("~display #%i & :/isHet & ~:%s" % (self.model_dict[self.plipname], self.hetid))
+
+ def update_model_dict(self):
+ """Updates the model dictionary"""
+ dct = {}
+ models = self.chimera.openModels
+ for md in models.list():
+ dct[md.name] = md.id
+ self.model_dict = dct
+
+ def atom_by_serialnumber(self):
+ """Provides a dictionary mapping serial numbers to their atom objects."""
+ atm_by_snum = {}
+ for atom in self.model.atoms:
+ atm_by_snum[atom.serialNumber] = atom
+ return atm_by_snum
+
+ def show_hydrophobic(self):
+ """Visualizes hydrophobic contacts."""
+ grp = self.getPseudoBondGroup("Hydrophobic Interactions-%i" % self.tid, associateWith=[self.model])
+ grp.lineType = self.chimera.Dash
+ grp.lineWidth = 3
+ grp.color = self.colorbyname('gray')
+ for i in self.plcomplex.hydrophobic_contacts.pairs_ids:
+ self.bs_res_ids.append(i[0])
+
+ def show_hbonds(self):
+ """Visualizes hydrogen bonds."""
+ grp = self.getPseudoBondGroup("Hydrogen Bonds-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ for i in self.plcomplex.hbonds.ldon_id:
+ b = grp.newPseudoBond(self.atoms[i[0]], self.atoms[i[1]])
+ b.color = self.colorbyname('blue')
+ self.bs_res_ids.append(i[0])
+ for i in self.plcomplex.hbonds.pdon_id:
+ b = grp.newPseudoBond(self.atoms[i[0]], self.atoms[i[1]])
+ b.color = self.colorbyname('blue')
+ self.bs_res_ids.append(i[1])
+
+ def show_halogen(self):
+ """Visualizes halogen bonds."""
+ grp = self.getPseudoBondGroup("HalogenBonds-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ for i in self.plcomplex.halogen_bonds:
+ b = grp.newPseudoBond(self.atoms[i[0]], self.atoms[i[1]])
+ b.color = self.colorbyname('turquoise')
+
+ self.bs_res_ids.append(i.acc_id)
+
+ def show_stacking(self):
+ """Visualizes pi-stacking interactions."""
+ grp = self.getPseudoBondGroup("pi-Stacking-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ grp.lineType = self.chimera.Dash
+ for i, stack in enumerate(self.plcomplex.pistacking):
+
+ m = self.model
+ r = m.newResidue("pseudoatoms", " ", 1, " ")
+ centroid_prot = m.newAtom("CENTROID", self.chimera.Element("CENTROID"))
+ x, y, z = stack.proteinring_center
+ centroid_prot.setCoord(self.chimera.Coord(x, y, z))
+ r.addAtom(centroid_prot)
+
+ centroid_lig = m.newAtom("CENTROID", self.chimera.Element("CENTROID"))
+ x, y, z = stack.ligandring_center
+ centroid_lig.setCoord(self.chimera.Coord(x, y, z))
+ r.addAtom(centroid_lig)
+
+ b = grp.newPseudoBond(centroid_lig, centroid_prot)
+ b.color = self.colorbyname('forest green')
+
+ self.bs_res_ids += stack.proteinring_atoms
+
+ def show_cationpi(self):
+ """Visualizes cation-pi interactions"""
+ grp = self.getPseudoBondGroup("Cation-Pi-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ grp.lineType = self.chimera.Dash
+ for i, cat in enumerate(self.plcomplex.pication):
+
+ m = self.model
+ r = m.newResidue("pseudoatoms", " ", 1, " ")
+ chargecenter = m.newAtom("CHARGE", self.chimera.Element("CHARGE"))
+ x, y, z = cat.charge_center
+ chargecenter.setCoord(self.chimera.Coord(x, y, z))
+ r.addAtom(chargecenter)
+
+ centroid = m.newAtom("CENTROID", self.chimera.Element("CENTROID"))
+ x, y, z = cat.ring_center
+ centroid.setCoord(self.chimera.Coord(x, y, z))
+ r.addAtom(centroid)
+
+ b = grp.newPseudoBond(centroid, chargecenter)
+ b.color = self.colorbyname('orange')
+
+ if cat.protcharged:
+ self.bs_res_ids += cat.charge_atoms
+ else:
+ self.bs_res_ids += cat.ring_atoms
+
+ def show_sbridges(self):
+ """Visualizes salt bridges."""
+ # Salt Bridges
+ grp = self.getPseudoBondGroup("Salt Bridges-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ grp.lineType = self.chimera.Dash
+ for i, sbridge in enumerate(self.plcomplex.saltbridges):
+
+ m = self.model
+ r = m.newResidue("pseudoatoms", " ", 1, " ")
+ chargecenter1 = m.newAtom("CHARGE", self.chimera.Element("CHARGE"))
+ x, y, z = sbridge.positive_center
+ chargecenter1.setCoord(self.chimera.Coord(x, y, z))
+ r.addAtom(chargecenter1)
+
+ chargecenter2 = m.newAtom("CHARGE", self.chimera.Element("CHARGE"))
+ x, y, z = sbridge.negative_center
+ chargecenter2.setCoord(self.chimera.Coord(x, y, z))
+ r.addAtom(chargecenter2)
+
+ b = grp.newPseudoBond(chargecenter1, chargecenter2)
+ b.color = self.colorbyname('yellow')
+
+ if sbridge.protispos:
+ self.bs_res_ids += sbridge.positive_atoms
+ else:
+ self.bs_res_ids += sbridge.negative_atoms
+
+ def show_wbridges(self):
+ """Visualizes water bridges"""
+ grp = self.getPseudoBondGroup("Water Bridges-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ for i, wbridge in enumerate(self.plcomplex.waterbridges):
+ c = grp.newPseudoBond(self.atoms[wbridge.water_id], self.atoms[wbridge.acc_id])
+ c.color = self.colorbyname('cornflower blue')
+ self.water_ids.append(wbridge.water_id)
+ b = grp.newPseudoBond(self.atoms[wbridge.don_id], self.atoms[wbridge.water_id])
+ b.color = self.colorbyname('cornflower blue')
+ self.water_ids.append(wbridge.water_id)
+ if wbridge.protisdon:
+ self.bs_res_ids.append(wbridge.don_id)
+ else:
+ self.bs_res_ids.append(wbridge.acc_id)
+
+ def show_metal(self):
+ """Visualizes metal coordination."""
+ grp = self.getPseudoBondGroup("Metal Coordination-%i" % self.tid, associateWith=[self.model])
+ grp.lineWidth = 3
+ for i, metal in enumerate(self.plcomplex.metal_complexes):
+ c = grp.newPseudoBond(self.atoms[metal.metal_id], self.atoms[metal.target_id])
+ c.color = self.colorbyname('magenta')
+
+ if metal.location == 'water':
+ self.water_ids.append(metal.target_id)
+
+ if metal.location.startswith('protein'):
+ self.bs_res_ids.append(metal.target_id)
+
+ def cleanup(self):
+ """Clean up the visualization."""
+
+ if not len(self.water_ids) == 0:
+ # Hide all non-interacting water molecules
+ water_selection = []
+ for wid in self.water_ids:
+ water_selection.append('serialNumber=%i' % wid)
+ self.rc("~display :HOH")
+ self.rc("display :@/%s" % " or ".join(water_selection))
+
+ # Show all interacting binding site residues
+ self.rc("~display #%i & ~:/isHet" % self.model_dict[self.plipname])
+ self.rc("display :%s" % ",".join([str(self.atoms[bsid].residue.id) for bsid in self.bs_res_ids]))
+ self.rc("color lightblue :HOH")
+
+ def zoom_to_ligand(self):
+ """Centers the view on the ligand and its binding site residues."""
+ self.rc("center #%i & :%s" % (self.model_dict[self.plipname], self.hetid))
+
+ def refinements(self):
+ """Details for the visualization."""
+ self.rc("setattr a color gray @CENTROID")
+ self.rc("setattr a radius 0.3 @CENTROID")
+ self.rc("represent sphere @CENTROID")
+ self.rc("setattr a color orange @CHARGE")
+ self.rc("setattr a radius 0.4 @CHARGE")
+ self.rc("represent sphere @CHARGE")
+ self.rc("display :pseudoatoms")
diff --git a/plip/visualization/pymol.py b/plip/visualization/pymol.py
new file mode 100644
index 0000000..b97912a
--- /dev/null
+++ b/plip/visualization/pymol.py
@@ -0,0 +1,450 @@
+import os
+import subprocess
+import sys
+from time import sleep
+
+from pymol import cmd
+
+
+class PyMOLVisualizer:
+
+ def __init__(self, plcomplex):
+ if plcomplex is not None:
+ self.plcomplex = plcomplex
+ self.protname = plcomplex.pdbid # Name of protein with binding site
+ self.hetid = plcomplex.hetid
+ self.ligandtype = plcomplex.ligandtype
+ self.ligname = "Ligand_" + self.hetid # Name of ligand
+ self.metal_ids = plcomplex.metal_ids
+
+ def set_initial_representations(self):
+ """General settings for PyMOL"""
+ self.standard_settings()
+ cmd.set('dash_gap', 0) # Show not dashes, but lines for the pliprofiler
+ cmd.set('ray_shadow', 0) # Turn on ray shadows for clearer ray-traced images
+ cmd.set('cartoon_color', 'mylightblue')
+
+ # Set clipping planes for full view
+ cmd.clip('far', -1000)
+ cmd.clip('near', 1000)
+
+ def make_initial_selections(self):
+ """Make empty selections for structures and interactions"""
+ for group in ['Hydrophobic-P', 'Hydrophobic-L', 'HBondDonor-P',
+ 'HBondDonor-L', 'HBondAccept-P', 'HBondAccept-L',
+ 'HalogenAccept', 'HalogenDonor', 'Water', 'MetalIons', 'StackRings-P',
+ 'PosCharge-P', 'PosCharge-L', 'NegCharge-P', 'NegCharge-L',
+ 'PiCatRing-P', 'StackRings-L', 'PiCatRing-L', 'Metal-M', 'Metal-P',
+ 'Metal-W', 'Metal-L', 'Unpaired-HBA', 'Unpaired-HBD', 'Unpaired-HAL',
+ 'Unpaired-RINGS']:
+ cmd.select(group, 'None')
+
+ def standard_settings(self):
+ """Sets up standard settings for a nice visualization."""
+ cmd.set('bg_rgb', [1.0, 1.0, 1.0]) # White background
+ cmd.set('depth_cue', 0) # Turn off depth cueing (no fog)
+ cmd.set('cartoon_side_chain_helper', 1) # Improve combined visualization of sticks and cartoon
+ cmd.set('cartoon_fancy_helices', 1) # Nicer visualization of helices (using tapered ends)
+ cmd.set('transparency_mode', 1) # Turn on multilayer transparency
+ cmd.set('dash_radius', 0.05)
+ self.set_custom_colorset()
+
+ def set_custom_colorset(self):
+ """Defines a colorset with matching colors. Provided by Joachim."""
+ cmd.set_color('myorange', '[253, 174, 97]')
+ cmd.set_color('mygreen', '[171, 221, 164]')
+ cmd.set_color('myred', '[215, 25, 28]')
+ cmd.set_color('myblue', '[43, 131, 186]')
+ cmd.set_color('mylightblue', '[158, 202, 225]')
+ cmd.set_color('mylightgreen', '[229, 245, 224]')
+
+ def select_by_ids(self, selname, idlist, selection_exists=False, chunksize=20, restrict=None):
+ """Selection with a large number of ids concatenated into a selection
+ list can cause buffer overflow in PyMOL. This function takes a selection
+ name and and list of IDs (list of integers) as input and makes a careful
+ step-by-step selection (packages of 20 by default)"""
+ idlist = list(set(idlist)) # Remove duplicates
+ if not selection_exists:
+ cmd.select(selname, 'None') # Empty selection first
+ idchunks = [idlist[i:i + chunksize] for i in range(0, len(idlist), chunksize)]
+ for idchunk in idchunks:
+ cmd.select(selname, '%s or (id %s)' % (selname, '+'.join(map(str, idchunk))))
+ if restrict is not None:
+ cmd.select(selname, '%s and %s' % (selname, restrict))
+
+ def object_exists(self, object_name):
+ """Checks if an object exists in the open PyMOL session."""
+ return object_name in cmd.get_names("objects")
+
+ def show_hydrophobic(self):
+ """Visualizes hydrophobic contacts."""
+ hydroph = self.plcomplex.hydrophobic_contacts
+ if not len(hydroph.bs_ids) == 0:
+ self.select_by_ids('Hydrophobic-P', hydroph.bs_ids, restrict=self.protname)
+ self.select_by_ids('Hydrophobic-L', hydroph.lig_ids, restrict=self.ligname)
+
+ for i in hydroph.pairs_ids:
+ cmd.select('tmp_bs', 'id %i & %s' % (i[0], self.protname))
+ cmd.select('tmp_lig', 'id %i & %s' % (i[1], self.ligname))
+ cmd.distance('Hydrophobic', 'tmp_bs', 'tmp_lig')
+ if self.object_exists('Hydrophobic'):
+ cmd.set('dash_gap', 0.5, 'Hydrophobic')
+ cmd.set('dash_color', 'grey50', 'Hydrophobic')
+ else:
+ cmd.select('Hydrophobic-P', 'None')
+
+ def show_hbonds(self):
+ """Visualizes hydrogen bonds."""
+ hbonds = self.plcomplex.hbonds
+ for group in [['HBondDonor-P', hbonds.prot_don_id],
+ ['HBondAccept-P', hbonds.prot_acc_id]]:
+ if not len(group[1]) == 0:
+ self.select_by_ids(group[0], group[1], restrict=self.protname)
+ for group in [['HBondDonor-L', hbonds.lig_don_id],
+ ['HBondAccept-L', hbonds.lig_acc_id]]:
+ if not len(group[1]) == 0:
+ self.select_by_ids(group[0], group[1], restrict=self.ligname)
+ for i in hbonds.ldon_id:
+ cmd.select('tmp_bs', 'id %i & %s' % (i[0], self.protname))
+ cmd.select('tmp_lig', 'id %i & %s' % (i[1], self.ligname))
+ cmd.distance('HBonds', 'tmp_bs', 'tmp_lig')
+ for i in hbonds.pdon_id:
+ cmd.select('tmp_bs', 'id %i & %s' % (i[1], self.protname))
+ cmd.select('tmp_lig', 'id %i & %s' % (i[0], self.ligname))
+ cmd.distance('HBonds', 'tmp_bs', 'tmp_lig')
+ if self.object_exists('HBonds'):
+ cmd.set('dash_color', 'blue', 'HBonds')
+
+ def show_halogen(self):
+ """Visualize halogen bonds."""
+ halogen = self.plcomplex.halogen_bonds
+ all_don_x, all_acc_o = [], []
+ for h in halogen:
+ all_don_x.append(h.don_id)
+ all_acc_o.append(h.acc_id)
+ cmd.select('tmp_bs', 'id %i & %s' % (h.acc_id, self.protname))
+ cmd.select('tmp_lig', 'id %i & %s' % (h.don_id, self.ligname))
+
+ cmd.distance('HalogenBonds', 'tmp_bs', 'tmp_lig')
+ if not len(all_acc_o) == 0:
+ self.select_by_ids('HalogenAccept', all_acc_o, restrict=self.protname)
+ self.select_by_ids('HalogenDonor', all_don_x, restrict=self.ligname)
+ if self.object_exists('HalogenBonds'):
+ cmd.set('dash_color', 'greencyan', 'HalogenBonds')
+
+ def show_stacking(self):
+ """Visualize pi-stacking interactions."""
+ stacks = self.plcomplex.pistacking
+ for i, stack in enumerate(stacks):
+ pires_ids = '+'.join(map(str, stack.proteinring_atoms))
+ pilig_ids = '+'.join(map(str, stack.ligandring_atoms))
+ cmd.select('StackRings-P', 'StackRings-P or (id %s & %s)' % (pires_ids, self.protname))
+ cmd.select('StackRings-L', 'StackRings-L or (id %s & %s)' % (pilig_ids, self.ligname))
+ cmd.select('StackRings-P', 'byres StackRings-P')
+ cmd.show('sticks', 'StackRings-P')
+
+ cmd.pseudoatom('ps-pistack-1-%i' % i, pos=stack.proteinring_center)
+ cmd.pseudoatom('ps-pistack-2-%i' % i, pos=stack.ligandring_center)
+ cmd.pseudoatom('Centroids-P', pos=stack.proteinring_center)
+ cmd.pseudoatom('Centroids-L', pos=stack.ligandring_center)
+
+ if stack.type == 'P':
+ cmd.distance('PiStackingP', 'ps-pistack-1-%i' % i, 'ps-pistack-2-%i' % i)
+ if stack.type == 'T':
+ cmd.distance('PiStackingT', 'ps-pistack-1-%i' % i, 'ps-pistack-2-%i' % i)
+ if self.object_exists('PiStackingP'):
+ cmd.set('dash_color', 'green', 'PiStackingP')
+ cmd.set('dash_gap', 0.3, 'PiStackingP')
+ cmd.set('dash_length', 0.6, 'PiStackingP')
+ if self.object_exists('PiStackingT'):
+ cmd.set('dash_color', 'smudge', 'PiStackingT')
+ cmd.set('dash_gap', 0.3, 'PiStackingT')
+ cmd.set('dash_length', 0.6, 'PiStackingT')
+
+ def show_cationpi(self):
+ """Visualize cation-pi interactions."""
+ for i, p in enumerate(self.plcomplex.pication):
+ cmd.pseudoatom('ps-picat-1-%i' % i, pos=p.ring_center)
+ cmd.pseudoatom('ps-picat-2-%i' % i, pos=p.charge_center)
+ if p.protcharged:
+ cmd.pseudoatom('Chargecenter-P', pos=p.charge_center)
+ cmd.pseudoatom('Centroids-L', pos=p.ring_center)
+ pilig_ids = '+'.join(map(str, p.ring_atoms))
+ cmd.select('PiCatRing-L', 'PiCatRing-L or (id %s & %s)' % (pilig_ids, self.ligname))
+ for a in p.charge_atoms:
+ cmd.select('PosCharge-P', 'PosCharge-P or (id %i & %s)' % (a, self.protname))
+ else:
+ cmd.pseudoatom('Chargecenter-L', pos=p.charge_center)
+ cmd.pseudoatom('Centroids-P', pos=p.ring_center)
+ pires_ids = '+'.join(map(str, p.ring_atoms))
+ cmd.select('PiCatRing-P', 'PiCatRing-P or (id %s & %s)' % (pires_ids, self.protname))
+ for a in p.charge_atoms:
+ cmd.select('PosCharge-L', 'PosCharge-L or (id %i & %s)' % (a, self.ligname))
+ cmd.distance('PiCation', 'ps-picat-1-%i' % i, 'ps-picat-2-%i' % i)
+ if self.object_exists('PiCation'):
+ cmd.set('dash_color', 'orange', 'PiCation')
+ cmd.set('dash_gap', 0.3, 'PiCation')
+ cmd.set('dash_length', 0.6, 'PiCation')
+
+ def show_sbridges(self):
+ """Visualize salt bridges."""
+ for i, saltb in enumerate(self.plcomplex.saltbridges):
+ if saltb.protispos:
+ for patom in saltb.positive_atoms:
+ cmd.select('PosCharge-P', 'PosCharge-P or (id %i & %s)' % (patom, self.protname))
+ for latom in saltb.negative_atoms:
+ cmd.select('NegCharge-L', 'NegCharge-L or (id %i & %s)' % (latom, self.ligname))
+ for sbgroup in [['ps-sbl-1-%i' % i, 'Chargecenter-P', saltb.positive_center],
+ ['ps-sbl-2-%i' % i, 'Chargecenter-L', saltb.negative_center]]:
+ cmd.pseudoatom(sbgroup[0], pos=sbgroup[2])
+ cmd.pseudoatom(sbgroup[1], pos=sbgroup[2])
+ cmd.distance('Saltbridges', 'ps-sbl-1-%i' % i, 'ps-sbl-2-%i' % i)
+ else:
+ for patom in saltb.negative_atoms:
+ cmd.select('NegCharge-P', 'NegCharge-P or (id %i & %s)' % (patom, self.protname))
+ for latom in saltb.positive_atoms:
+ cmd.select('PosCharge-L', 'PosCharge-L or (id %i & %s)' % (latom, self.ligname))
+ for sbgroup in [['ps-sbp-1-%i' % i, 'Chargecenter-P', saltb.negative_center],
+ ['ps-sbp-2-%i' % i, 'Chargecenter-L', saltb.positive_center]]:
+ cmd.pseudoatom(sbgroup[0], pos=sbgroup[2])
+ cmd.pseudoatom(sbgroup[1], pos=sbgroup[2])
+ cmd.distance('Saltbridges', 'ps-sbp-1-%i' % i, 'ps-sbp-2-%i' % i)
+
+ if self.object_exists('Saltbridges'):
+ cmd.set('dash_color', 'yellow', 'Saltbridges')
+ cmd.set('dash_gap', 0.5, 'Saltbridges')
+
+ def show_wbridges(self):
+ """Visualize water bridges."""
+ for bridge in self.plcomplex.waterbridges:
+ if bridge.protisdon:
+ cmd.select('HBondDonor-P', 'HBondDonor-P or (id %i & %s)' % (bridge.don_id, self.protname))
+ cmd.select('HBondAccept-L', 'HBondAccept-L or (id %i & %s)' % (bridge.acc_id, self.ligname))
+ cmd.select('tmp_don', 'id %i & %s' % (bridge.don_id, self.protname))
+ cmd.select('tmp_acc', 'id %i & %s' % (bridge.acc_id, self.ligname))
+ else:
+ cmd.select('HBondDonor-L', 'HBondDonor-L or (id %i & %s)' % (bridge.don_id, self.ligname))
+ cmd.select('HBondAccept-P', 'HBondAccept-P or (id %i & %s)' % (bridge.acc_id, self.protname))
+ cmd.select('tmp_don', 'id %i & %s' % (bridge.don_id, self.ligname))
+ cmd.select('tmp_acc', 'id %i & %s' % (bridge.acc_id, self.protname))
+ cmd.select('Water', 'Water or (id %i & resn HOH)' % bridge.water_id)
+ cmd.select('tmp_water', 'id %i & resn HOH' % bridge.water_id)
+ cmd.distance('WaterBridges', 'tmp_acc', 'tmp_water')
+ cmd.distance('WaterBridges', 'tmp_don', 'tmp_water')
+ if self.object_exists('WaterBridges'):
+ cmd.set('dash_color', 'lightblue', 'WaterBridges')
+ cmd.delete('tmp_water or tmp_acc or tmp_don')
+ cmd.color('lightblue', 'Water')
+ cmd.show('spheres', 'Water')
+
+ def show_metal(self):
+ """Visualize metal coordination."""
+ metal_complexes = self.plcomplex.metal_complexes
+ if not len(metal_complexes) == 0:
+ self.select_by_ids('Metal-M', self.metal_ids)
+ for metal_complex in metal_complexes:
+ cmd.select('tmp_m', 'id %i' % metal_complex.metal_id)
+ cmd.select('tmp_t', 'id %i' % metal_complex.target_id)
+ if metal_complex.location == 'water':
+ cmd.select('Metal-W', 'Metal-W or id %s' % metal_complex.target_id)
+ if metal_complex.location.startswith('protein'):
+ cmd.select('tmp_t', 'tmp_t & %s' % self.protname)
+ cmd.select('Metal-P', 'Metal-P or (id %s & %s)' % (metal_complex.target_id, self.protname))
+ if metal_complex.location == 'ligand':
+ cmd.select('tmp_t', 'tmp_t & %s' % self.ligname)
+ cmd.select('Metal-L', 'Metal-L or (id %s & %s)' % (metal_complex.target_id, self.ligname))
+ cmd.distance('MetalComplexes', 'tmp_m', 'tmp_t')
+ cmd.delete('tmp_m or tmp_t')
+ if self.object_exists('MetalComplexes'):
+ cmd.set('dash_color', 'violetpurple', 'MetalComplexes')
+ cmd.set('dash_gap', 0.5, 'MetalComplexes')
+ # Show water molecules for metal complexes
+ cmd.show('spheres', 'Metal-W')
+ cmd.color('lightblue', 'Metal-W')
+
+ def selections_cleanup(self):
+ """Cleans up non-used selections"""
+
+ if not len(self.plcomplex.unpaired_hba_idx) == 0:
+ self.select_by_ids('Unpaired-HBA', self.plcomplex.unpaired_hba_idx, selection_exists=True)
+ if not len(self.plcomplex.unpaired_hbd_idx) == 0:
+ self.select_by_ids('Unpaired-HBD', self.plcomplex.unpaired_hbd_idx, selection_exists=True)
+ if not len(self.plcomplex.unpaired_hal_idx) == 0:
+ self.select_by_ids('Unpaired-HAL', self.plcomplex.unpaired_hal_idx, selection_exists=True)
+
+ selections = cmd.get_names("selections")
+ for selection in selections:
+ try:
+ empty = len(cmd.get_model(selection).atom) == 0
+ except:
+ empty = True
+ if empty:
+ cmd.delete(selection)
+ cmd.deselect()
+ cmd.delete('tmp*')
+ cmd.delete('ps-*')
+
+ def selections_group(self):
+ """Group all selections"""
+ cmd.group('Structures', '%s %s %sCartoon' % (self.protname, self.ligname, self.protname))
+ cmd.group('Interactions', 'Hydrophobic HBonds HalogenBonds WaterBridges PiCation PiStackingP PiStackingT '
+ 'Saltbridges MetalComplexes')
+ cmd.group('Atoms', '')
+ cmd.group('Atoms.Protein', 'Hydrophobic-P HBondAccept-P HBondDonor-P HalogenAccept Centroids-P PiCatRing-P '
+ 'StackRings-P PosCharge-P NegCharge-P AllBSRes Chargecenter-P Metal-P')
+ cmd.group('Atoms.Ligand', 'Hydrophobic-L HBondAccept-L HBondDonor-L HalogenDonor Centroids-L NegCharge-L '
+ 'PosCharge-L NegCharge-L ChargeCenter-L StackRings-L PiCatRing-L Metal-L Metal-M '
+ 'Unpaired-HBA Unpaired-HBD Unpaired-HAL Unpaired-RINGS')
+ cmd.group('Atoms.Other', 'Water Metal-W')
+ cmd.order('*', 'y')
+
+ def additional_cleanup(self):
+ """Cleanup of various representations"""
+
+ cmd.remove('not alt ""+A') # Remove alternate conformations
+ cmd.hide('labels', 'Interactions') # Hide labels of lines
+ cmd.disable('%sCartoon' % self.protname)
+ cmd.hide('everything', 'hydrogens')
+
+ def zoom_to_ligand(self):
+ """Zoom in too ligand and its interactions."""
+ cmd.center(self.ligname)
+ cmd.orient(self.ligname)
+ cmd.turn('x', 110) # If the ligand is aligned with the longest axis, aromatic rings are hidden
+ if 'AllBSRes' in cmd.get_names("selections"):
+ cmd.zoom('%s or AllBSRes' % self.ligname, 3)
+ else:
+ if self.object_exists(self.ligname):
+ cmd.zoom(self.ligname, 3)
+ cmd.origin(self.ligname)
+
+ def save_session(self, outfolder, override=None):
+ """Saves a PyMOL session file."""
+ filename = '%s_%s' % (self.protname.upper(), "_".join(
+ [self.hetid, self.plcomplex.chain, self.plcomplex.position]))
+ if override is not None:
+ filename = override
+ cmd.save("/".join([outfolder, "%s.pse" % filename]))
+
+ def png_workaround(self, filepath, width=1200, height=800):
+ """Workaround for (a) severe bug(s) in PyMOL preventing ray-traced images to be produced in command-line mode.
+ Use this function in case neither cmd.ray() or cmd.png() work.
+ """
+ sys.stdout = sys.__stdout__
+ cmd.feedback('disable', 'movie', 'everything')
+ cmd.viewport(width, height)
+ cmd.zoom('visible', 1.5) # Adapt the zoom to the viewport
+ cmd.set('ray_trace_frames', 1) # Frames are raytraced before saving an image.
+ cmd.mpng(filepath, 1, 1) # Use batch png mode with 1 frame only
+ cmd.mplay() # cmd.mpng needs the animation to 'run'
+ cmd.refresh()
+ originalfile = "".join([filepath, '0001.png'])
+ newfile = "".join([filepath, '.png'])
+
+ #################################################
+ # Wait for file for max. 1 second and rename it #
+ #################################################
+
+ attempts = 0
+ while not os.path.isfile(originalfile) and attempts <= 10:
+ sleep(0.1)
+ attempts += 1
+ if os.name == 'nt': # In Windows, make sure there is no file of the same name, cannot be overwritten as in Unix
+ if os.path.isfile(newfile):
+ os.remove(newfile)
+ os.rename(originalfile, newfile) # Remove frame number in filename
+
+ # Check if imagemagick is available and crop + resize the images
+ if subprocess.call("type convert", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) == 0:
+ attempts, ecode = 0, 1
+ # Check if file is truncated and wait if that's the case
+ while ecode != 0 and attempts <= 10:
+ ecode = subprocess.call(['convert', newfile, '/dev/null'], stdout=open('/dev/null', 'w'),
+ stderr=subprocess.STDOUT)
+ sleep(0.1)
+ attempts += 1
+ trim = 'convert -trim ' + newfile + ' -bordercolor White -border 20x20 ' + newfile + ';' # Trim the image
+ os.system(trim)
+ getwidth = 'w=`convert ' + newfile + ' -ping -format "%w" info:`;' # Get the width of the new image
+ getheight = 'h=`convert ' + newfile + ' -ping -format "%h" info:`;' # Get the hight of the new image
+ newres = 'if [ "$w" -gt "$h" ]; then newr="${w%.*}x$w"; else newr="${h%.*}x$h"; fi;' # Set quadratic ratio
+ quadratic = 'convert ' + newfile + ' -gravity center -extent "$newr" ' + newfile # Fill with whitespace
+ os.system(getwidth + getheight + newres + quadratic)
+ else:
+ sys.stderr.write('Imagemagick not available. Images will not be resized or cropped.')
+
+ def save_picture(self, outfolder, filename):
+ """Saves a picture"""
+ self.set_fancy_ray()
+ self.png_workaround("/".join([outfolder, filename]))
+
+ def set_fancy_ray(self):
+ """Give the molecule a flat, modern look."""
+ cmd.set('light_count', 6)
+ cmd.set('spec_count', 1.5)
+ cmd.set('shininess', 4)
+ cmd.set('specular', 0.3)
+ cmd.set('reflect', 1.6)
+ cmd.set('ambient', 0)
+ cmd.set('direct', 0)
+ cmd.set('ray_shadow', 0) # Gives the molecules a flat, modern look
+ cmd.set('ambient_occlusion_mode', 1)
+ cmd.set('ray_opaque_background', 0) # Transparent background
+
+ def adapt_for_peptides(self):
+ """Adapt visualization for peptide ligands and interchain contacts"""
+ cmd.hide('sticks', self.ligname)
+ cmd.set('cartoon_color', 'lightorange', self.ligname)
+ cmd.show('cartoon', self.ligname)
+ cmd.show('sticks', "byres *-L")
+ cmd.util.cnc(self.ligname)
+ cmd.remove('%sCartoon and chain %s' % (self.protname, self.plcomplex.chain))
+ cmd.set('cartoon_side_chain_helper', 0)
+
+ def adapt_for_intra(self):
+ """Adapt visualization for intra-protein interactions"""
+
+ def refinements(self):
+ """Refinements for the visualization"""
+
+ # Show sticks for all residues interacing with the ligand
+ cmd.select('AllBSRes', 'byres (Hydrophobic-P or HBondDonor-P or HBondAccept-P or PosCharge-P or NegCharge-P or '
+ 'StackRings-P or PiCatRing-P or HalogenAcc or Metal-P)')
+ cmd.show('sticks', 'AllBSRes')
+ # Show spheres for the ring centroids
+ cmd.hide('everything', 'centroids*')
+ cmd.show('nb_spheres', 'centroids*')
+ # Show spheres for centers of charge
+ if self.object_exists('Chargecenter-P') or self.object_exists('Chargecenter-L'):
+ cmd.hide('nonbonded', 'chargecenter*')
+ cmd.show('spheres', 'chargecenter*')
+ cmd.set('sphere_scale', 0.4, 'chargecenter*')
+ cmd.color('yellow', 'chargecenter*')
+
+ cmd.set('valence', 1) # Show bond valency (e.g. double bonds)
+ # Optional cartoon representation of the protein
+ cmd.copy('%sCartoon' % self.protname, self.protname)
+ cmd.show('cartoon', '%sCartoon' % self.protname)
+ cmd.show('sticks', '%sCartoon' % self.protname)
+ cmd.set('stick_transparency', 1, '%sCartoon' % self.protname)
+
+ # Resize water molecules. Sometimes they are not heteroatoms HOH, but part of the protein
+ cmd.set('sphere_scale', 0.2, 'resn HOH or Water') # Needs to be done here because of the copy made
+ cmd.set('sphere_transparency', 0.4, '!(resn HOH or Water)')
+
+ if 'Centroids*' in cmd.get_names("selections"):
+ cmd.color('grey80', 'Centroids*')
+ cmd.hide('spheres', '%sCartoon' % self.protname)
+ cmd.hide('cartoon', '%sCartoon and resn DA+DG+DC+DU+DT+A+G+C+U+T' % self.protname) # Hide DNA/RNA Cartoon
+ if self.ligname == 'SF4': # Special case for iron-sulfur clusters, can't be visualized with sticks
+ cmd.show('spheres', '%s' % self.ligname)
+
+ cmd.hide('everything', 'resn HOH &!Water') # Hide all non-interacting water molecules
+ cmd.hide('sticks', '%s and !%s and !AllBSRes' %
+ (self.protname, self.ligname)) # Hide all non-interacting residues
+
+ if self.ligandtype in ['PEPTIDE', 'INTRA']:
+ self.adapt_for_peptides()
+
+ if self.ligandtype == 'INTRA':
+ self.adapt_for_intra()
diff --git a/plip/visualization/visualize.py b/plip/visualization/visualize.py
new file mode 100644
index 0000000..4cd7a14
--- /dev/null
+++ b/plip/visualization/visualize.py
@@ -0,0 +1,111 @@
+from pymol import cmd
+
+from plip.basic import config, logger
+from plip.basic.supplemental import start_pymol
+from plip.visualization.pymol import PyMOLVisualizer
+
+logger = logger.get_logger()
+
+
+def visualize_in_pymol(plcomplex):
+ """Visualizes the protein-ligand pliprofiler at one site in PyMOL."""
+
+ vis = PyMOLVisualizer(plcomplex)
+
+ #####################
+ # Set everything up #
+ #####################
+
+ pdbid = plcomplex.pdbid
+ lig_members = plcomplex.lig_members
+ chain = plcomplex.chain
+ if config.PEPTIDES:
+ vis.ligname = 'PeptideChain%s' % plcomplex.chain
+ if config.INTRA is not None:
+ vis.ligname = 'Intra%s' % plcomplex.chain
+
+ ligname = vis.ligname
+ hetid = plcomplex.hetid
+
+ metal_ids = plcomplex.metal_ids
+ metal_ids_str = '+'.join([str(i) for i in metal_ids])
+
+ ########################
+ # Basic visualizations #
+ ########################
+
+ start_pymol(run=True, options='-pcq', quiet=not config.VERBOSE and not config.SILENT)
+ vis.set_initial_representations()
+
+ cmd.load(plcomplex.sourcefile)
+ current_name = cmd.get_object_list(selection='(all)')[0]
+ logger.debug(f'setting current_name to {current_name} and pdbid to {pdbid}')
+ cmd.set_name(current_name, pdbid)
+ cmd.hide('everything', 'all')
+ if config.PEPTIDES:
+ cmd.select(ligname, 'chain %s and not resn HOH' % plcomplex.chain)
+ else:
+ cmd.select(ligname, 'resn %s and chain %s and resi %s*' % (hetid, chain, plcomplex.position))
+ logger.debug(f'selecting ligand for PDBID {pdbid} and ligand name {ligname}')
+ logger.debug(f'resn {hetid} and chain {chain} and resi {plcomplex.position}')
+
+ # Visualize and color metal ions if there are any
+ if not len(metal_ids) == 0:
+ vis.select_by_ids(ligname, metal_ids, selection_exists=True)
+ cmd.show('spheres', 'id %s and %s' % (metal_ids_str, pdbid))
+
+ # Additionally, select all members of composite ligands
+ if len(lig_members) > 1:
+ for member in lig_members:
+ resid, chain, resnr = member[0], member[1], str(member[2])
+ cmd.select(ligname, '%s or (resn %s and chain %s and resi %s)' % (ligname, resid, chain, resnr))
+
+ cmd.show('sticks', ligname)
+ cmd.color('myblue')
+ cmd.color('myorange', ligname)
+ cmd.util.cnc('all')
+ if not len(metal_ids) == 0:
+ cmd.color('hotpink', 'id %s' % metal_ids_str)
+ cmd.hide('sticks', 'id %s' % metal_ids_str)
+ cmd.set('sphere_scale', 0.3, ligname)
+ cmd.deselect()
+
+ vis.make_initial_selections()
+
+ vis.show_hydrophobic() # Hydrophobic Contacts
+ vis.show_hbonds() # Hydrogen Bonds
+ vis.show_halogen() # Halogen Bonds
+ vis.show_stacking() # pi-Stacking Interactions
+ vis.show_cationpi() # pi-Cation Interactions
+ vis.show_sbridges() # Salt Bridges
+ vis.show_wbridges() # Water Bridges
+ vis.show_metal() # Metal Coordination
+
+ vis.refinements()
+
+ vis.zoom_to_ligand()
+
+ vis.selections_cleanup()
+
+ vis.selections_group()
+ vis.additional_cleanup()
+ if config.DNARECEPTOR:
+ # Rename Cartoon selection to Line selection and change repr.
+ cmd.set_name('%sCartoon' % plcomplex.pdbid, '%sLines' % plcomplex.pdbid)
+ cmd.hide('cartoon', '%sLines' % plcomplex.pdbid)
+ cmd.show('lines', '%sLines' % plcomplex.pdbid)
+
+ if config.PEPTIDES:
+ filename = "%s_PeptideChain%s" % (pdbid.upper(), plcomplex.chain)
+ if config.PYMOL:
+ vis.save_session(config.OUTPATH, override=filename)
+ elif config.INTRA is not None:
+ filename = "%s_IntraChain%s" % (pdbid.upper(), plcomplex.chain)
+ if config.PYMOL:
+ vis.save_session(config.OUTPATH, override=filename)
+ else:
+ filename = '%s_%s' % (pdbid.upper(), "_".join([hetid, plcomplex.chain, plcomplex.position]))
+ if config.PYMOL:
+ vis.save_session(config.OUTPATH)
+ if config.PICS:
+ vis.save_picture(config.OUTPATH, filename)