def ClosestAtom():
"""ask for 2 molecules, compute for each atom
the distance to the closest atom in the other
molecule. After execution, each atom has a new
attribute 'closest' holding the distance"""
# it would be better to ask for the attribute's name also
from Pmv.guiTools import MoleculeChooser
p = MoleculeChooser(self, 'extended', 'Choose 2 molecules')
mols = p.go(modal=1)
mol1Atoms = mols[0].allAtoms
mol2Atoms = mols[1].allAtoms
def distanceToClosestPoint(point, setOfPoints):
"""computes the shortest distance between point and setOfPoints"""
diff = Numeric.array(point) - Numeric.array(setOfPoints)
diff = diff * diff
len = Numeric.sqrt(Numeric.sum(diff, 1))
return min(len)
for a in mol1Atoms:
a.closest = distanceToClosestPoint(a.coords, mol2Atoms.coords)
for a in mol2Atoms:
a.closest = distanceToClosestPoint(a.coords, mol1Atoms.coords)
def guiCallback(self):
if len(self.vf.Mols) == 0: return
self.chooser = MoleculeChooser(self.vf,
mode='extended',
title='Choose Molecules to delete')
self.undoableVar = Tkinter.IntVar()
self.undoableVar.set(1)
self.chooser.ipf.append({
'name': 'Undo',
'widgetType': Tkinter.Checkbutton,
'wcfg': {
'text': ' Undoable Delete',
'variable': self.undoableVar
},
'gridcfg': {
'sticky': Tkinter.E + Tkinter.W
}
})
self.chooser.ipf.append({
'name': 'Delete Button',
'widgetType': Tkinter.Button,
'text': 'Delete Molecule',
'wcfg': {
'bd': 6
},
'gridcfg': {
'sticky': Tkinter.E + Tkinter.W
},
'command': self.deleteMolecule_cb
})
self.form = self.chooser.go(modal=0, blocking=0)
def selectObject():
"""Bind trackball to a user specified object.
Only geometries related to this object move, scaling
is disabled"""
from Pmv.guiTools import MoleculeChooser
mol = MoleculeChooser(self).go(modal=0, blocking=1)
vi = self.GUI.VIEWER
vi.TransformRootOnly(yesno=0)
obj = mol.geomContainer.geoms['master']
vi.SetCurrentObject(obj)
vi.BindTrackballToObject(obj)
vi.currentTransfMode = 'Object'
def sesExposurePercent():
"""Compute the percentage of solvent exposed surface for each amino acide.
After running this macro, each residue has the 2 following members:
ses_area: total surface area for this residue
ses_ratio: percentage of residue surface exposed to solvent
The ratio is the percentage of SES area exposed to the solvent in each
residue, where 100 is the surface of that particular residue when all other
atoms are ignored
"""
import mslib
import numpy.oldnumeric as Numeric
from Pmv.guiTools import MoleculeChooser
mol = MoleculeChooser(self).go(modal=0, blocking=1)
allrads = mol.defaultRadii()
allResidues = mol.chains.residues
allAtoms = mol.allAtoms
# compute the surface
srf = mslib.MSMS(coords=allAtoms.coords, radii=allrads)
srf.compute()
srf.compute_ses_area()
# get surface areas per atom
ses_areas = []
for i in xrange(srf.nbat):
atm = srf.get_atm(i)
ses_areas.append(atm.get_ses_area(0))
# get surface areas to each atom
allAtoms.ses_area = ses_areas
# sum up ses areas over resdiues
for r in allResidues:
r.ses_area = Numeric.sum(r.atoms.ses_area)
# compute the surface for each residue independantly
# compute the % of ses
srfList = []
for r in allResidues:
coords = r.atoms.coords
rad = map(lambda x: x.radius, r.atoms)
m = mslib.MSMS(coords=coords, radii=rad)
m.compute()
m.compute_ses_area()
srfList.append(m)
if r.ses_area > 0.0:
r.ses_ratio = (r.ses_area * 100) / m.sesr.fst.a_ses_area
else:
r.ses_ratio = 0.0
def setMobSequence(self):
molName = MoleculeChooser(self.vf).go().name
self.vf.alnEditor.master.lift()
if molName not in self.vf.alignment.seqNames:
return
#recolor the previous reference sequence, if it exists
if hasattr(self,'mobMolName'):
uniqtag = self.mobMolName+'_name'
item = self.vf.alnEditor.canvas.find_withtag(uniqtag)
color = self.vf.alnEditor.colors['default']
self.vf.alnEditor.canvas.itemconfig(item,fill=color)
uniqtag = molName+'_name'
self.vf.alnEditor.colors['special'][uniqtag]='green'
item = self.vf.alnEditor.canvas.find_withtag(uniqtag)
self.vf.alnEditor.canvas.itemconfig(item,fill='green')
self.mobMolName = molName
def getSequence(self,mol=None):
if not mol:
mol = MoleculeChooser(self.vf).go()
if not mol:
return
self.vf.alnEditor.master.lift()
#for extracting sequence(s) from molecules
chains = mol.children
seqList = []
numbers = []
for chain in chains:
seqList = seqList+chain.children.type+['-','|','-']
for residue in chain.children:
numbers.append(chain.name + residue.type + residue.number)
molSequence = Sequence(sequence=seqList,numbers=numbers,name=mol.name)
seqName = mol.name
if seqName in self.vf.alignment.seqNames:
# if sequence with this molecule name is already in the alignment,
# only need to update the numbers
sequence = self.vf.alignment.sequences[seqName]
sequence.applyNumbers(numbers)
return
self.vf.alignment.addSequence(molSequence)
self.vf.alnEditor.redraw()
def guiCallback(self):
if not hasattr(self.vf, "SL"):
self.warningMsg(
"This command requires 'SLCommands' module. Load the module.")
return
file = self.vf.askFileOpen(types=[('BSPT file', '*.bsp')],
title="Read .bsp")
if file:
root = Tkinter.Toplevel()
root.withdraw()
from SimpleDialog import SimpleDialog
ans = SimpleDialog(root,
text="Bind object to molecule?",
buttons=["Yes", "No", "Cancel"],
default=0,
title="new data dialog").go()
root.destroy()
mol = None
if ans == 0:
from Pmv.guiTools import MoleculeChooser
ans = MoleculeChooser(self.vf).go()
if ans:
mol = ans.name
apply(self.doitWrapper, (file, mol), {})
def doSetOperation(self, name1, name2, opname, res_name, bindToMol):
""" Performs Bspt set operations. """
ex = 0.5
expon = 1.0
bspt_set1 = None
bspt_set2 = None
if name1 in self.setdict.keys():
#check if we need to recompute the Bspt for the object
if self.recomputeBSPT1.get():
if hasattr(self.obj_dict[name1]['obj'], "SLnewobj"):
# this object had been created by SL :
# do not recompute
bspt_set1 = self.setdict[name1]
else:
#remove the computed Bspt from self.setdict
# remove a copy of the object from
# self.obj_dict so that the function could use
# updated arrays of vertices and faces.
del (self.setdict[name1])
if self.obj_dict[name1].has_key('copy_obj'):
del (self.obj_dict[name1]['copy_obj'])
else:
bspt_set1 = self.setdict[name1]
if not geometrylib.Size_of_Set(bspt_set1):
bspt_set1 = None
if not bspt_set1:
if self.obj_dict[name1].has_key('copy_obj'):
object1 = self.obj_dict[name1]['copy_obj']
else:
## if isinstance(self.obj_dict[name1]['obj'], GleObject):
## object1 = self.obj_dict[name1]['obj']
## else:
object1 = self.obj_dict[name1]['obj'].asIndexedPolygons(
run=1, removeDupVerts=0)
self.obj_dict[name1]['copy_obj'] = object1
v1 = object1.vertexSet.vertices.array
#print "object1: ", object1
## if isinstance(object1, GleObject):
## f1 = self.triangulate_strips(object1.faceSet.faces.array)
## else:
f1 = object1.faceSet.faces.array
#print "obj1, verts: ", len(v1), "faces: ", len(f1)
brep_set1 = sl.buildBrepSet(v1, f1)
t1 = time()
bspt_set1 = sl.Brep_To_Bspt(brep_set1, expense=ex, exponent=expon)
t2 = time()
print "time to build bspt_set1(%s) is %.5f " % (name1, (t2 - t1))
if name2 in self.setdict.keys():
if self.recomputeBSPT2.get():
if hasattr(self.obj_dict[name2]['obj'], "SLnewobj"):
bspt_set2 = self.setdict[name2]
else:
del (self.setdict[name2])
if self.obj_dict[name2].has_key('copy_obj'):
del (self.obj_dict[name2]['copy_obj'])
else:
bspt_set2 = self.setdict[name2]
if not geometrylib.Size_of_Set(bspt_set2):
bspt_set2 = None
if not bspt_set2:
if self.obj_dict[name2].has_key('copy_obj'):
object2 = self.obj_dict[name2]['copy_obj']
else:
object2 = self.obj_dict[name2]['obj'].asIndexedPolygons(
run=1, removeDupVerts=0)
self.obj_dict[name2]['copy_obj'] = object2
#print "object2: ", object2
v2 = object2.vertexSet.vertices.array
## if isinstance(object2, GleObject):
## f2 = self.triangulate_strips(object2.faceSet.faces.array)
## else:
f2 = object2.faceSet.faces.array
brep_set2 = sl.buildBrepSet(v2, f2)
t1 = time()
bspt_set2 = sl.Brep_To_Bspt(brep_set2, expense=ex, exponent=expon)
t2 = time()
print "time to build bspt_set2(%s) is %.5f " % (name2, (t2 - t1))
rset = sl.operateBsptSets(bspt_set1,
bspt_set2,
opname,
expense=ex,
copy="duplicate")
brep_set = sl.convert_to_Brep(rset, expense=ex, duplicate=1)
verts, faces, vnorms, fnorms = sl.getBoundaries(brep_set,
has_vnormals=0,
has_fnormals=1)
vs, fs, vns, fns = sl.indexedFromArr(verts, faces, fnorms=fnorms)
#sl.discardSet(brep_set)
#brep_set = None
if find(res_name, "_"): #name should not contain "_"
res_name = replace(res_name, "_", "-")
## if vs:
## length = map( len, fs)
## mlength = max(length)
## for i in range(len(fs)):
## d = mlength-len(fs[i])
## if d:
## for j in range(d):
## fs[i].append(-1)
vi = self.vf.GUI.VIEWER
mol = None
res_fullname = 'root|' + res_name
if bindToMol:
from Pmv.guiTools import MoleculeChooser
mol = MoleculeChooser(self.vf).go()
if mol:
#mol_geom = self.vf.Mols.NodesFromName( molname )[0].geomContainer.masterGeom
mol_geom = mol.geomContainer.masterGeom
res_fullname = mol_geom.fullName + '|' + res_name
#find if an object with the same name already exists:
obj_fullnames = self.obj_dict.keys()
objnames = map(lambda x: split(x, '|')[-1], obj_fullnames)
overwrite = False
if res_name in objnames:
ind = objnames.index(res_name)
if res_fullname in obj_fullnames:
ipg = self.obj_dict[res_fullname]['obj']
if hasattr(ipg, "SLnewobj"): # the object is a result
# of SL operation
if ipg.SLnewobj:
overwrite = True # will overwrite the object's
# vertices and faces arrays
## if not overwrite:
## ipg = self.obj_dict[ obj_fullnames[ind] ]['obj']
## if isinstance(ipg, IndexedPolygons):
## #ask the user :
## root = Tkinter.Toplevel()
## root.withdraw()
## from SimpleDialog import SimpleDialog
## ans = SimpleDialog(root, text="Object %s exists. Overwrite it?"% (obj_fullnames[ind],),
## buttons=["Yes", "No"],
## default=0,
## title="overwrite dialog").go()
## root.destroy()
## if ans == 0:
## overwrite = True
if overwrite:
ipg.Set(vertices=vs,
faces=fs,
fnormals=fns,
freshape=True,
tagModified=False)
if mol:
cl_atoms = self.vf.bindGeomToMolecularFragment(ipg,
mol.name,
log=0)
#addToViewer=False, log=0)
if cl_atoms:
#self.vf.bindGeomToMolecule.data[res_name]['fns']=fns
self.vf.bindGeomToMolecularFragment.data[
ipg.fullName]['fns'] = fns
else:
ipg = IndexedPolygons(
res_name,
vertices=vs,
faces=fs, #fnormals=fns,
#materials=col2,
visible=1,
inheritMaterial=0,
protected=True,
)
if self.vf.userpref['Sharp Color Boundaries for MSMS'][
'value'] == 'blur':
ipg.Set(
inheritSharpColorBoundaries=False,
sharpColorBoundaries=False,
)
if mol:
cl_atoms = self.vf.bindGeomToMolecularFragment(ipg,
mol.name,
log=0)
if cl_atoms:
#self.vf.bindGeomToMolecule.data[res_name]['fns']=fns
self.vf.bindGeomToMolecularFragment.data[
ipg.fullName]['fns'] = fns
else:
vi.AddObject(ipg)
else:
vi.AddObject(ipg)
ipg.Set(frontPolyMode=GL.GL_FILL, shading=GL.GL_FLAT)
ipg.Set(fnormals=fns, tagModified=False)
self.setdict[ipg.fullName] = rset
ipg.SLnewobj = True
print "size of bspt_set1:", geometrylib.Size_of_Set(bspt_set1)
print "size of bspt_set2:", geometrylib.Size_of_Set(bspt_set2)
print "size of rset:", geometrylib.Size_of_Set(rset)
else:
print "Number of vertices of the resultant object is 0."
if name1 not in self.setdict.keys():
self.setdict[name1] = bspt_set1
if name2 not in self.setdict.keys():
self.setdict[name2] = bspt_set2
