pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-04 21:54:27 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
329bf48b77c5918ba76719776523917df336334e
rdkit/Projects/SDView4/SDView.py
Greg Landrum c1bc75dcfb lots of updates
2009-06-19 05:39:41 +00:00

571 lines
20 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python
# $Id$
#
# Copyright (c) 2008-2009, Novartis Institutes for BioMedical Research Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
# * Neither the name of Novartis Institutes for BioMedical Research Inc.
# nor the names of its contributors may be used to endorse or promote
# products derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Created by Greg Landrum
#
_version = "0.1.0"
import sys,cStringIO,math
from PyQt4 import QtCore, QtGui, QtSvg
from rdkit.sping.Qt.pidQt4 import QtCanvas
from rdkit.Chem.Draw.MolDrawing import MolDrawing
from rdkit.Chem.Draw.MolDrawing import registerCanvas
from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit.RDLogger import logger
logger = logger()
class SDUtils(object):
@staticmethod
def GetSDPropNames(fName=None,data=None,blockSize=1024,nBlocks=2):
if not (fName or data): raise ValueError,"provide at least one value"
import re
nRead=0
nmMatcher=re.compile(r'^> +<(\w+)>',re.M)
res=set()
if data:
res.update((x.group(1) for x in nmMatcher.finditer(data)))
else:
f = file(fName,'r')
lines = f.readlines(blockSize)
while lines and nBlocks:
res.update((x.group(1) for x in nmMatcher.finditer(''.join(lines))))
nBlocks-=1
lines = f.readlines(blockSize)
return res
from rdkit.Chem import PyMol
class Mol3DView(PyMol.MolViewer):
pass
class MolCanvasView(QtGui.QGraphicsView):
_mp=None
selectingMols=True
selectingAtoms=True
atomSelectPadding=5
def __init__(self,parent=None,scene=None,size=(300,300)):
QtGui.QGraphicsView.__init__(self,scene,parent)
scene = QtGui.QGraphicsScene(0,0,size[0],size[1])
self.setRenderHints(QtGui.QPainter.Antialiasing|QtGui.QPainter.TextAntialiasing)
self.setScene(scene)
self._scenes=[scene]
registerCanvas('sping')
self.molDrawer=MolDrawing()
self.molDrawer.atomLabelMinFontSize=6
self.mols=[]
def clearMols(self):
if self.mols:
self.molDrawer.canvas.clear()
self.scene().clear()
self.mols=[]
def addMol(self,mol):
if not hasattr(self.molDrawer,'canvas') or self.molDrawer.canvas is None:
self.molDrawer.canvas=QtCanvas(self.scene())
confId=-1
if mol.HasProp('_2DConfId'): confId=int(mol.GetProp('_2DConfId'))
self.molDrawer.AddMol(mol,confId=confId)
mol._bbox=self.molDrawer.boundingBoxes[mol]
mol._atomPs=self.molDrawer.atomPs[mol]
self.mols.append(mol)
def setMol(self,mol):
self.clearMols()
self.molDrawer.canvas=QtCanvas(self.scene())
self.addMol(mol)
def setMols(self,mols):
self.clearMols()
nMols = len(mols)
nCols = int(math.ceil(math.sqrt(nMols)))
nRows = int(math.ceil(1.*nMols/nCols))
sz = self.size()
self.scene().setSceneRect(0,0,sz.width(),sz.height())
w = 0.9*self.scene().width()/nCols
h = 0.9*self.scene().height()/nRows
self.scene().clear()
for i,mol in enumerate(mols):
rowIdx=i//nCols
colIdx=i%nCols
self.molDrawer.canvas=QtCanvas(self.scene(),size=(w,h))
confId=-1
if mol.HasProp('_2DConfId'): confId=int(mol.GetProp('_2DConfId'))
self.molDrawer.scaleAndCenter(mol,mol.GetConformer(confId),canvasSize=(w,h))
self.molDrawer.AddMol(mol,confId=confId,
drawingTrans=(w*colIdx+w/2,-h*rowIdx+h/2),
molTrans=self.molDrawer.molTrans,
centerIt=False)
mol._bbox=self.molDrawer.boundingBoxes[mol]
mol._atomPs=self.molDrawer.atomPs[mol]
self.mols.append(mol)
def mousePressEvent(self,evt):
if not self.selectingMols or not self.selectingAtoms:
return
self._mp=evt
evt.accept()
def mouseReleaseEvent(self,evt):
if not self._mp:
return
else:
mp = self._mp
self._mp=None
coords = self.mapToScene(mp.pos())
x,y = coords.x(),coords.y()
for mol in self.mols:
if x>mol._bbox[0] and x<mol._bbox[2] and \
y>mol._bbox[1] and y<mol._bbox[3] :
if self.selectingAtoms:
for atomIdx in range(mol.GetNumAtoms()):
px,py = mol._atomPs[atomIdx]
if x>px-self.atomSelectPadding and x<px+self.atomSelectPadding and\
y>py-self.atomSelectPadding and y<py+self.atomSelectPadding:
self.emit(QtCore.SIGNAL("atomSelected(PyQt_PyObject,int)"),mol,atomIdx)
break
if self.selectingMols:
self.emit(QtCore.SIGNAL("molSelected(PyQt_PyObject)"),mol)
break
print coords.x(),coords.y()
r=self.viewport().rect()
img = QtGui.QImage(r.width(),r.height(),QtGui.QImage.Format_RGB32)
img.fill(QtGui.QColor(255,255,255).rgb())
painter = QtGui.QPainter(img)
painter.setRenderHints(QtGui.QPainter.Antialiasing|QtGui.QPainter.TextAntialiasing|QtGui.QPainter.SmoothPixmapTransform)
self.render(painter)
clip=QtGui.QApplication.clipboard()
clip.setImage(img)
painter = None
img=None
evt.accept()
class MolTableView(QtGui.QTableView):
def __init__(self,parent=None):
QtGui.QTableView.__init__(self,parent)
class MolTableRedrawMode(object):
Never=0
Always=1
WhenNeeded=2
class MolTableModel(QtCore.QAbstractTableModel):
redrawMode=MolTableRedrawMode.WhenNeeded
kekulizeMode=True
nRows=0
nCols=0
_supplier=None
_propNames=None
_molCache=None
def flags(self,index):
return QtCore.Qt.ItemIsSelectable|QtCore.Qt.ItemIsEnabled
def rowCount(self,parent):
if parent.isValid(): return 0
return self.nRows
def columnCount(self,parent):
return len(self._propNames)
def canFetchMore(self,index):
if self._supplIter is not None:
return True
else:
return False
def fetchMore(self,index):
if self._supplIter is None:
return
maxRows=5
rowAdded=0
try:
m = self._supplIter.next()
except StopIteration:
self._supplIter=None
while rowAdded<maxRows and self._supplIter is not None:
rowAdded+=1
try:
m = self._supplIter.next()
except StopIteration:
self._supplIter=None
break
self.beginInsertRows(QtCore.QModelIndex(),self.nRows,self.nRows+rowAdded)
self.endInsertRows()
self.nRows += rowAdded
#print ' ',self.nRows
def data(self,index,role=QtCore.Qt.DisplayRole):
if not index.isValid() or role!=QtCore.Qt.DisplayRole \
or index.row()<0 or index.column()<0 or index.row()>=self.nRows :
return QtCore.QVariant()
row,col = index.row(),index.column()
pn = self._propNames[col]
mol = self.mol(index,role)
if not mol:
res='No mol'
elif mol.HasProp(pn):
res=mol.GetProp(pn)
else:
res='No prop'
return QtCore.QVariant(res)
def mol(self,index,role):
if not index.isValid() or role!=QtCore.Qt.DisplayRole:
return None
row = index.row()
if self._molCache is not None:
mol = self._molCache.get(row,None)
if not mol:
mol = self._supplier[row]
if self.redrawMode==MolTableRedrawMode.Always or \
(self.redrawMode==MolTableRedrawMode.WhenNeeded and \
( mol.GetNumConformers()==0 or mol.GetConformer().Is3D() )):
confId=AllChem.Compute2DCoords(mol,clearConfs=False)
mol.SetProp('_2DConfId',str(confId))
if self.kekulizeMode:
Chem.Kekulize(mol)
self._molCache[row]=mol
else:
mol = self._supplier[row]
return mol
def headerData(self,section,orientation,role):
if orientation==QtCore.Qt.Horizontal:
if role==QtCore.Qt.DisplayRole:
return QtCore.QVariant(self._propNames[section])
return QtCore.QVariant()
def setSupplier(self,supplier,propNames=None,nameProp='_Name',
maxMolsForProps=100):
self._supplier=supplier
if propNames:
self._propNames=propNames
else:
i=0
self._propNames=[nameProp]
if hasattr(supplier,'reset'):
lookin=supplier
else:
lookin=iter(supplier)
for m in lookin:
if m:
i+=1
for pn in m.GetPropNames():
if pn not in self._propNames:
self._propNames.append(pn)
if i==maxMolsForProps: break
if hasattr(supplier,'reset'):
supplier.reset()
self._supplIter=iter(self._supplier)
self._cache={}
def sort(self,col,order):
print 'SORT!',col,order
class SSSProxy(QtGui.QSortFilterProxyModel):
def filterAcceptsRow(self,row,index):
return row%2
class MainWindow(QtGui.QMainWindow):
_applicationName="SDView"
_vendorName="rdkit.org"
molCanvas=None
mol3DViewer=None
def __init__(self,filename):
QtGui.QMainWindow.__init__(self)
self.curFile = QtCore.QString()
self.createActions()
self.createMenus()
self.createStatusBar()
self.readSettings()
suppl=Chem.SDMolSupplier(filename)
pns = ['_Name']+list(SDUtils.GetSDPropNames(fName=filename))
self.sdModel=MolTableModel()
self.sdModel.setSupplier(suppl,propNames=pns)
self.sdModel._molCache={}
self.tblView = MolTableView()
self.tblView.setModel(self.sdModel)
self.setCentralWidget(self.tblView)
self.connect(self.tblView.selectionModel(),
QtCore.SIGNAL('selectionChanged(QItemSelection,QItemSelection)'),
self.changeCurrent)
if 0:
self.pModel=SSSProxy()
self.pModel.setSourceModel(self.sdModel)
self.filtView = MolTableView()
self.filtView.setModel(self.pModel)
self.filtView.setWindowTitle('filtered')
self.filtView.setVisible(True)
def attachMolCanvas(self,canvas=None):
if canvas is None:
self.molCanvas=MolCanvasView()
else:
self.molCanvas=canvas
self.connect(self.molCanvas,QtCore.SIGNAL('molSelected(PyQt_PyObject)'),self.molCanvasMolSelected)
self.connect(self.molCanvas,QtCore.SIGNAL('atomSelected(PyQt_PyObject,int)'),self.molCanvasAtomSelected)
self.molCanvas.show()
def molCanvasMolSelected(self,mol):
print 'mol: ',mol.GetProp('_Name')
def molCanvasAtomSelected(self,mol,atomIdx):
print 'Mol: ',mol.GetProp('_Name'),'Atom: ',atomIdx,mol.GetAtomWithIdx(atomIdx).GetSymbol()
def attachMol3DViewer(self,viewer=None):
if viewer is None:
self.mol3DViewer=Mol3DView()
else:
self.mol3DViewer=viewer
def changeCurrent(self,current,prev):
idxL = self.tblView.selectedIndexes()
if not len(idxL):
return
mols = []
for i,idx in enumerate(idxL):
mol = self.sdModel.mol(idx,QtCore.Qt.DisplayRole)
mols.append(mol)
if len(mols)==1:
if self.molCanvas:
self.molCanvas.setMol(mols[0])
if self.mol3DViewer:
self.mol3DViewer.ShowMol(mols[0],name=mols[0].GetProp('_Name'),
showOnly=True)
else:
if self.molCanvas:
self.molCanvas.setMols(mols)
if self.mol3DViewer:
self.mol3DViewer.DeleteAll()
for mol in mols:
self.mol3DViewer.ShowMol(mol,name=mol.GetProp('_Name'),
showOnly=False)
def closeEvent(self, event):
if self.maybeSave():
self.writeSettings()
self.molDrawer=None
self.molCanvas=None
event.accept()
else:
event.ignore()
def newFile(self):
if self.maybeSave():
pass
def open(self):
if self.maybeSave():
fileName = QtGui.QFileDialog.getOpenFileName(self)
if not fileName.isEmpty():
pass
def save(self):
if self.curFile.isEmpty():
return self.saveAs()
else:
return True
def saveAs(self):
fileName = QtGui.QFileDialog.getSaveFileName(self)
if fileName.isEmpty():
return False
return True
def about(self):
QtGui.QMessageBox.about(self, self.tr("About Application"),
self.tr("The <b>Application</b> example demonstrates how to "
"write modern GUI applications using Qt, with a menu bar, "
"toolbars, and a status bar."))
def documentWasModified(self):
#self.setWindowModified(self.textEdit.document().isModified())
pass
def createActions(self):
self.newAct = QtGui.QAction(self.tr("&New"), self)
self.newAct.setShortcut(self.tr("Ctrl+N"))
self.newAct.setStatusTip(self.tr("Create a new file"))
self.connect(self.newAct, QtCore.SIGNAL("triggered()"), self.newFile)
self.openAct = QtGui.QAction(self.tr("&Open..."), self)
self.openAct.setShortcut(self.tr("Ctrl+O"))
self.openAct.setStatusTip(self.tr("Open an existing file"))
self.connect(self.openAct, QtCore.SIGNAL("triggered()"), self.open)
self.saveAct = QtGui.QAction(self.tr("&Save"), self)
self.saveAct.setShortcut(self.tr("Ctrl+S"))
self.saveAct.setStatusTip(self.tr("Save the document to disk"))
self.connect(self.saveAct, QtCore.SIGNAL("triggered()"), self.save)
self.saveAsAct = QtGui.QAction(self.tr("Save &As..."), self)
self.saveAsAct.setStatusTip(self.tr("Save the document under a new name"))
self.connect(self.saveAsAct, QtCore.SIGNAL("triggered()"), self.saveAs)
self.exitAct = QtGui.QAction(self.tr("E&xit"), self)
self.exitAct.setShortcut(self.tr("Ctrl+Q"))
self.exitAct.setStatusTip(self.tr("Exit the application"))
self.connect(self.exitAct, QtCore.SIGNAL("triggered()"), self, QtCore.SLOT("close()"))
self.cutAct = QtGui.QAction(self.tr("Cu&t"), self)
self.cutAct.setShortcut(self.tr("Ctrl+X"))
self.cutAct.setStatusTip(self.tr("Cut the current selection's contents to the "
"clipboard"))
#self.connect(self.cutAct, QtCore.SIGNAL("triggered()"), self.textEdit, QtCore.SLOT("cut()"))
self.copyAct = QtGui.QAction(self.tr("&Copy"), self)
self.copyAct.setShortcut(self.tr("Ctrl+C"))
self.copyAct.setStatusTip(self.tr("Copy the current selection's contents to the "
"clipboard"))
#self.connect(self.copyAct, QtCore.SIGNAL("triggered()"), self.textEdit, QtCore.SLOT("copy()"))
self.pasteAct = QtGui.QAction(self.tr("&Paste"), self)
self.pasteAct.setShortcut(self.tr("Ctrl+V"))
self.pasteAct.setStatusTip(self.tr("Paste the clipboard's contents into the current "
"selection"))
#self.connect(self.pasteAct, QtCore.SIGNAL("triggered()"), self.textEdit, QtCore.SLOT("paste()"))
self.aboutAct = QtGui.QAction(self.tr("&About"), self)
self.aboutAct.setStatusTip(self.tr("Show the application's About box"))
self.connect(self.aboutAct, QtCore.SIGNAL("triggered()"), self.about)
self.aboutQtAct = QtGui.QAction(self.tr("About &Qt"), self)
self.aboutQtAct.setStatusTip(self.tr("Show the Qt library's About box"))
self.connect(self.aboutQtAct, QtCore.SIGNAL("triggered()"), QtGui.qApp, QtCore.SLOT("aboutQt()"))
self.cutAct.setEnabled(False)
self.copyAct.setEnabled(False)
self.pasteAct.setEnabled(False)
#self.connect(self.textEdit, QtCore.SIGNAL("copyAvailable(bool)"),
# self.cutAct, QtCore.SLOT("setEnabled(bool)"))
#self.connect(self.textEdit, QtCore.SIGNAL("copyAvailable(bool)"),
# self.copyAct, QtCore.SLOT("setEnabled(bool)"))
def createMenus(self):
self.fileMenu = self.menuBar().addMenu(self.tr("&File"))
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.saveAsAct)
self.fileMenu.addSeparator();
self.fileMenu.addAction(self.exitAct)
self.editMenu = self.menuBar().addMenu(self.tr("&Edit"))
self.editMenu.addAction(self.cutAct)
self.editMenu.addAction(self.copyAct)
self.editMenu.addAction(self.pasteAct)
self.menuBar().addSeparator()
self.helpMenu = self.menuBar().addMenu(self.tr("&Help"))
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
def createStatusBar(self):
self.statusBar().showMessage(self.tr("Ready"))
def readSettings(self):
settings = QtCore.QSettings(self._vendorName,self._applicationName)
pos = settings.value("pos", QtCore.QVariant(QtCore.QPoint(200, 200))).toPoint()
size = settings.value("size", QtCore.QVariant(QtCore.QSize(400, 400))).toSize()
self.resize(size)
self.move(pos)
def writeSettings(self):
settings = QtCore.QSettings(self._vendorName,self._applicationName)
settings.setValue("pos", QtCore.QVariant(self.pos()))
settings.setValue("size", QtCore.QVariant(self.size()))
def maybeSave(self):
if False:
ret = QtGui.QMessageBox.warning(self, self.tr("Application"),
self.tr("The document has been modified.\n"
"Do you want to save your changes?"),
QtGui.QMessageBox.Yes | QtGui.QMessageBox.Default,
QtGui.QMessageBox.No,
QtGui.QMessageBox.Cancel | QtGui.QMessageBox.Escape)
if ret == QtGui.QMessageBox.Yes:
return self.save()
elif ret == QtGui.QMessageBox.Cancel:
return False
return True
def loadFile(self, fileName):
file = QtCore.QFile(fileName)
if not file.open(QtCore.QFile.ReadOnly | QtCore.QFile.Text):
QtGui.QMessageBox.warning(self, self.tr("Application"),
self.tr("Cannot read file %1:\n%2.").arg(fileName).arg(file.errorString()))
return
def saveFile(self, fileName):
file = QtCore.QFile(fileName)
if not file.open(QtCore.QFile.WriteOnly | QtCore.QFile.Text):
QtGui.QMessageBox.warning(self, self.tr("Application"),
self.tr("Cannot write file %1:\n%2.").arg(fileName).arg(file.errorString()))
return False
return True
from optparse import OptionParser
import os
parser=OptionParser("This is SDView",version='%prog '+_version)
parser.add_option('--do3D','--3D','--3d','--do3d',default=False,action='store_true',
help='display the molecules in 3D using PyMol')
parser.add_option('--no2D','--no2d',dest='do2D',default=True,action='store_false',
help='skip the 2D display of the molecules')
parser.add_option('--redraw',default=False,action='store_true',
help='force the generation of new 2D coordinates for the molecules')
if __name__ == "__main__":
options,args = parser.parse_args()
if len(args)<1:
parser.error('no SD file provided')
app = QtGui.QApplication(sys.argv)
mainWin = MainWindow(args[0])
if options.do2D:
mainWin.attachMolCanvas()
if options.do3D:
mainWin.attachMol3DViewer()
if options.redraw:
mainWin.tblView.redrawMode=MolTableRedrawMode.Always
mainWin.show()
sys.exit(app.exec_())
Reference in New Issue View Git Blame Copy Permalink