def get_glowing_image(smiles):
if '_' in smiles:
mol_smi = smiles.split('_')[0]
mol_subs = smiles.split('_')[1]
try:
mol = Chem.MolFromSmiles(mol_smi)
patt = Chem.MolFromSmiles(mol_subs)
matching = mol.GetSubstructMatch(patt)
d2d = rdMolDraw2D.MolDraw2DSVG(350, 300)
d2d.DrawMolecule(mol, highlightAtoms=matching)
d2d.FinishDrawing()
return Response(d2d.GetDrawingText(), mimetype='image/svg+xml')
except:
return send_file('./images/no_image_available.png',
mimetype='image/png')
else:
try:
mol = Chem.MolFromSmiles(smiles)
d2d = rdMolDraw2D.MolDraw2DSVG(350, 300)
d2d.DrawMolecule(mol)
d2d.FinishDrawing()
return Response(d2d.GetDrawingText(), mimetype='image/svg+xml')
except:
return send_file('./images/no_image_available.png',
mimetype='image/png')
def _draw_mol_structure(self, mol, figsize=(600, 300)):
from IPython.display import SVG
from rdkit import Chem
from rdkit.Chem import rdDepictor
from rdkit.Chem.Draw import rdMolDraw2D
self.logger.info(Chem.MolToSmiles(mol))
rdDepictor.Compute2DCoords(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(*figsize)
highlight_atoms, color_atoms = self._get_atoms_color()
highlight_bonds = []
color_bonds = {}
drawer.DrawMolecule(mol,
highlightAtoms=highlight_atoms,
highlightAtomColors=color_atoms,
highlightBonds=highlight_bonds,
highlightBondColors=color_bonds)
drawer.FinishDrawing()
svg = drawer.GetDrawingText().replace('svg:', '')
SVG(svg)
saved_filename = "{}_mol.svg".format(str(self.out_filename))
with open(saved_filename, "w") as f:
f.write(svg)
def do_a_picture(smi, smarts, label):
rdDepictor.SetPreferCoordGen(False)
mol = Chem.MolFromSmiles(smi)
mol = Draw.PrepareMolForDrawing(mol)
acols = {}
bcols = {}
h_rads = {}
h_lw_mult = {}
for i, smt in enumerate(smarts):
alist, blist = get_hit_atoms_and_bonds(mol, smt)
h_rads[alist[0]] = 0.4
h_lw_mult[blist[0]] = 2
col = i % 4
add_colours_to_map(alist, acols, col)
add_colours_to_map(blist, bcols, col)
d = rdMolDraw2D.MolDraw2DSVG(500, 500)
d.drawOptions().fillHighlights = False
d.DrawMoleculeWithHighlights(mol, label, acols, bcols, h_rads,
h_lw_mult, -1)
d.FinishDrawing()
return d.GetDrawingText()
def DrawMorganEnvs(envs,
molsPerRow=3,
subImgSize=(150, 150),
baseRad=0.3,
useSVG=True,
aromaticColor=(0.9, 0.9, 0.2),
ringColor=(0.8, 0.8, 0.8),
centerColor=(0.6, 0.6, 0.9),
extraColor=(0.9, 0.9, 0.9),
legends=None,
drawOptions=None,
**kwargs):
submols = []
highlightAtoms = []
atomColors = []
highlightBonds = []
bondColors = []
highlightRadii = []
for mol, atomId, radius in envs:
menv = _getMorganEnv(mol, atomId, radius, baseRad, aromaticColor,
ringColor, centerColor, extraColor, **kwargs)
submols.append(menv.submol)
highlightAtoms.append(menv.highlightAtoms)
atomColors.append(menv.atomColors)
highlightBonds.append(menv.highlightBonds)
bondColors.append(menv.bondColors)
highlightRadii.append(menv.highlightRadii)
if legends is None:
legends = [''] * len(envs)
nRows = len(envs) // molsPerRow
if len(envs) % molsPerRow:
nRows += 1
fullSize = (molsPerRow * subImgSize[0], nRows * subImgSize[1])
# Drawing
if useSVG:
drawer = rdMolDraw2D.MolDraw2DSVG(fullSize[0], fullSize[1],
subImgSize[0], subImgSize[1])
else:
drawer = rdMolDraw2D.MolDraw2DCairo(fullSize[0], fullSize[1],
subImgSize[0], subImgSize[1])
if drawOptions is None:
drawopt = drawer.drawOptions()
drawopt.continuousHighlight = False
else:
drawOptions.continuousHighlight = False
drawer.SetDrawOptions(drawOptions)
drawer.DrawMolecules(submols,
legends=legends,
highlightAtoms=highlightAtoms,
highlightAtomColors=atomColors,
highlightBonds=highlightBonds,
highlightBondColors=bondColors,
highlightAtomRadii=highlightRadii,
**kwargs)
drawer.FinishDrawing()
return drawer.GetDrawingText()
def DrawRDKitEnv(mol,
bondPath,
molSize=(150, 150),
baseRad=0.3,
useSVG=True,
aromaticColor=(0.9, 0.9, 0.2),
extraColor=(0.9, 0.9, 0.9),
nonAromaticColor=None,
drawOptions=None,
**kwargs):
menv = _getRDKitEnv(mol, bondPath, baseRad, aromaticColor, extraColor,
nonAromaticColor, **kwargs)
# Drawing
if useSVG:
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
else:
drawer = rdMolDraw2D.MolDraw2DCairo(molSize[0], molSize[1])
if drawOptions is None:
drawopt = drawer.drawOptions()
drawopt.continuousHighlight = False
else:
drawOptions.continuousHighlight = False
drawer.SetDrawOptions(drawOptions)
drawer.DrawMolecule(menv.submol,
highlightAtoms=menv.highlightAtoms,
highlightAtomColors=menv.atomColors,
highlightBonds=menv.highlightBonds,
highlightBondColors=menv.bondColors,
highlightAtomRadii=menv.highlightRadii,
**kwargs)
drawer.FinishDrawing()
return drawer.GetDrawingText()
def img_for_mol(mol, atom_weights=[]):
# print(atom_weights)
highlight_kwargs = {}
if len(atom_weights) > 0:
norm = matplotlib.colors.Normalize(vmin=-1, vmax=1)
cmap = cm.get_cmap('bwr')
plt_colors = cm.ScalarMappable(norm=norm, cmap=cmap)
atom_colors = {
i: plt_colors.to_rgba(atom_weights[i])
for i in range(len(atom_weights))
}
highlight_kwargs = {
'highlightAtoms': list(range(len(atom_weights))),
'highlightBonds': [],
'highlightAtomColors': atom_colors
}
# print(highlight_kwargs)
rdDepictor.Compute2DCoords(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(280, 280)
drawer.SetFontSize(1)
mol = rdMolDraw2D.PrepareMolForDrawing(mol)
drawer.DrawMolecule(mol, **highlight_kwargs)
# highlightAtoms=list(range(len(atom_weights))),
# highlightBonds=[],
# highlightAtomColors=atom_colors)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
svg = svg.replace('svg:', '')
svg2png(bytestring=svg, write_to='tmp.png', dpi=100)
img = imread('tmp.png')
os.remove('tmp.png')
return img
def smile_to_smile_to_image(mol,
molSize=(128, 128),
kekulize=True,
mol_name=''):
mol = Chem.MolFromSmiles(mol)
mc = Chem.Mol(mol.ToBinary())
if kekulize:
try:
Chem.Kekulize(mc)
except:
mc = Chem.Mol(mol.ToBinary())
if not mc.GetNumConformers():
rdDepictor.Compute2DCoords(mc)
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
drawer.DrawMolecule(mc)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
image = Image.open(
io.BytesIO(
cairosvg.svg2png(bytestring=svg,
parent_width=100,
parent_height=100,
scale=1)))
image.convert('RGB')
return ToTensor()(Invert()(image)).numpy()
def highlight_diff(prb_mol, ref_mol, width, height):
"""
Draw a molecule (prb_mol) with the differences from a reference model highlighted
:param prb_mol: smiles of the probe molecule
:param ref_mol: smiles of the reference molecule
:param width: output image width
:param height: output image height
:return: svg string of the image
"""
if not width:
width = 200
if not height:
height = 200
mols = [Chem.MolFromSmiles(prb_mol), Chem.MolFromSmiles(ref_mol)]
[Chem.Kekulize(m) for m in mols]
match = Chem.rdFMCS.FindMCS(mols,
ringMatchesRingOnly=True,
completeRingsOnly=True)
match_mol = Chem.MolFromSmarts(match.smartsString)
rdDepictor.Compute2DCoords(mols[0])
unconserved = [
i for i in range(mols[0].GetNumAtoms())
if i not in mols[0].GetSubstructMatch(match_mol)
]
drawer = rdMolDraw2D.MolDraw2DSVG(width, height)
drawer.DrawMolecule(mols[0], highlightAtoms=unconserved)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
return svg
def draw_fragment(fragment_name, color):
mol = Chem.MolFromSmarts(re.sub(' \|.*$', '', fragment_name))
mc = Chem.Mol(mol.ToBinary())
rdDepictor.Compute2DCoords(mc)
drawer = rdMolDraw2D.MolDraw2DSVG(80, 80)
center = int(
pd.Series({
atom.GetIdx(): len(atom.GetNeighbors())
for atom in mol.GetAtoms()
}).idxmax())
to_highlight = [center]
radius_dict = {center: 0.5}
color_dict = {center: color}
drawer.DrawMolecule(mc,
highlightAtoms=to_highlight,
highlightAtomColors=color_dict,
highlightAtomRadii=radius_dict,
highlightBonds=False)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
return svg.replace('svg:', '').replace(':svg', '')
def _MolsToGridSVG(mols, molsPerRow=3, subImgSize=(200, 200), legends=None, highlightAtomLists=None,
highlightBondLists=None, drawOptions=None, **kwargs):
""" returns an SVG of the grid
"""
if legends is None:
legends = [''] * len(mols)
nRows = len(mols) // molsPerRow
if len(mols) % molsPerRow:
nRows += 1
blocks = [''] * (nRows * molsPerRow)
fullSize = (molsPerRow * subImgSize[0], nRows * subImgSize[1])
d2d = rdMolDraw2D.MolDraw2DSVG(fullSize[0], fullSize[1], subImgSize[0], subImgSize[1])
if drawOptions is not None:
d2d.SetDrawOptions(drawOptions)
else:
dops = d2d.drawOptions()
for k, v in list(kwargs.items()):
if hasattr(dops, k):
setattr(dops, k, v)
del kwargs[k]
d2d.DrawMolecules(list(mols), legends=legends, highlightAtoms=highlightAtomLists,
highlightBonds=highlightBondLists, **kwargs)
d2d.FinishDrawing()
res = d2d.GetDrawingText()
return res
def moltosvg(mol, molSize=(500, 500), kekulize=True):
mc = mol
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
drawer.DrawMolecule(mc)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
return svg.replace('svg:', '')
def createImageHighlight(smiles, smarts):
from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit.Chem import rdDepictor
from rdkit.Chem.Draw import rdMolDraw2D
from rdkit.Chem.Draw.MolDrawing import DrawingOptions
mol = Chem.MolFromSmiles(smiles)
patt = Chem.MolFromSmarts(smarts)
hitatoms = mol.GetSubstructMatches(patt) #反応部位のアトムインデックス
hitatomslist = []
for x in hitatoms:
hitatomslist += x
hitatomsSum = tuple(hitatomslist)
tm = rdMolDraw2D.PrepareMolForDrawing(mol)
rdDepictor.Compute2DCoords(mol) # for generating conformer ID
# create a drawer container
drawer = rdMolDraw2D.MolDraw2DSVG(300, 300)
# define drawer options
drawer.drawOptions().updateAtomPalette(
{k: (0, 0, 0)
for k in DrawingOptions.elemDict.keys()})
drawer.SetLineWidth(2)
drawer.SetFontSize(1.0)
drawer.drawOptions().setHighlightColour((0.95, 0.7, 0.95)) #ハイライトの色指定
drawer.DrawMolecule(tm, highlightAtoms=hitatomsSum)
drawer.FinishDrawing()
# generate and write the svg strings
svg = drawer.GetDrawingText().replace('svg:', '')
# "*"記号はファイル名として使えないため、"^"に置換する
rSmarts = smarts.translate(str.maketrans({"*": "^"}))
with open("static/images/svgs/" + smiles + "_" + rSmarts + ".svg",
"w") as f:
f.write(svg)
def DrawMorganEnv(mol, atomId, radius, molSize=(150, 150), baseRad=0.3, useSVG=True,
aromaticColor=(0.9, 0.9, 0.2), ringColor=(0.8, 0.8, 0.8),
centerColor=(0.6, 0.6, 0.9), extraColor=(0.9, 0.9, 0.9), drawOptions=None,
**kwargs):
"""Get SMARTS and SVG image from given ceten and radius
*internal only*
"""
menv = _getMorganEnv(mol, atomId, radius, baseRad, aromaticColor, ringColor, centerColor,
extraColor, **kwargs)
submol = menv.submol
subMol = Chem.MolToSmiles(submol, isomericSmiles=False, allBondsExplicit=True, allHsExplicit=True)
# Drawing
if useSVG:
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
else:
drawer = rdMolDraw2D.MolDraw2DCairo(molSize[0], molSize[1])
if drawOptions is None:
drawopt = drawer.drawOptions()
drawopt.continuousHighlight = False
else:
drawOptions.continuousHighlight = False
drawer.SetDrawOptions(drawOptions)
drawer.DrawMolecule(menv.submol, highlightAtoms=menv.highlightAtoms,
highlightAtomColors=menv.atomColors, highlightBonds=menv.highlightBonds,
highlightBondColors=menv.bondColors, highlightAtomRadii=menv.highlightRadii,
**kwargs)
drawer.FinishDrawing()
return subMol, drawer.GetDrawingText().replace('\n', '')
def _mols2svg(mols,
size,
kekulize=False,
atomMapNumber=False,
computeCoords=False,
highlightAtomLists=None):
if not mols:
return ''
else:
# process only one molecule
mols = mols[0:1]
_call(mols, 'UpdatePropertyCache', strict=False)
_apply(mols, ct._sssr)
if computeCoords:
_apply(mols, _computeCoords, True)
if atomMapNumber:
_apply(mols, _atomMapNumber)
if kekulize:
_apply(mols, _kekulize)
if highlightAtomLists:
highlightAtomLists = highlightAtomLists[0]
drawer = rdMolDraw2D.MolDraw2DSVG(size, size)
opts = drawer.drawOptions()
opts.clearBackground = False
drawer.DrawMolecule(mols[0], highlightAtoms=highlightAtomLists)
drawer.FinishDrawing()
return drawer.GetDrawingText()
def VisualizeFragment(mol, highlightAtoms, figsize=[400, 200]):
from rdkit.Chem.Draw import IPythonConsole, rdMolDraw2D
from IPython.display import SVG
from rdkit.Chem import rdDepictor
"""
This function is used for show which part of fragment matched the SMARTS
Parameters:
-----------
mol: rdkit.Chem.rdchem.Mol
the molecule to be visualized
atoms: tuple
the index of atoms to be highlighted
Rrturn:
-----------
pic: IPython.core.display.SVG
a SVG file
Usage:
-----------
mol = Chem.MolFromSmiles('C1=CC=C2C(=O)CC(=O)C2=C1')
pic = VisualizeFragment(mol,(0, 1, 2, 6, 7, 8,10))
"""
rdDepictor.Compute2DCoords(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(*figsize)
drawer.DrawMolecule(mol, highlightAtoms=highlightAtoms)
drawer.FinishDrawing()
svg = drawer.GetDrawingText().replace('svg:', '')
fig = SVG(svg)
return fig
def testDrawMoleculesArgs(self):
smis = ['O=C1c2cccc3c(N4CCCCC4)ccc(c23)C(=O)N1c1ccccn1', 'Cc1ccc[n+](C2=Nc3ccccc3[N-]C2=C(C#N)C#N)c1', 'CC(=O)NC1=NN(C(C)=O)C(c2ccccn2)S1', 'COc1cc(Cc2nccc3cc(OC)c(OC)cc23)c(S(=O)(=O)O)cc1OC']
tms = [Chem.MolFromSmiles(x) for x in smis]
[rdMolDraw2D.PrepareMolForDrawing(x) for x in tms]
drawer = rdMolDraw2D.MolDraw2DSVG(600,600,300,300)
p = Chem.MolFromSmarts('c1ccccn1')
matches = [x.GetSubstructMatch(p) for x in tms]
acolors = []
for mv in matches:
clrs = {}
random.seed(0xf00d)
for idx in mv:
clrs[idx] = (random.random(),random.random(),random.random())
acolors.append(clrs)
# the bonds between the matching atoms too
bnds = []
for mol,mv in zip(tms,matches):
tmp = []
for bnd in p.GetBonds():
tmp.append(mol.GetBondBetweenAtoms(mv[bnd.GetBeginAtomIdx()],mv[bnd.GetEndAtomIdx()]).GetIdx())
bnds.append(tmp)
drawer.DrawMolecules(tms,highlightAtoms=matches,highlightBonds=bnds,highlightAtomColors=acolors)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
# 4 molecules, 6 bonds each:
self.assertEqual(svg.count('fill:none;fill-rule:evenodd;stroke:#FF7F7F'),24)
# 4 molecules, one atom each:
self.assertEqual(svg.count('fill:#DB2D2B;fill-rule:evenodd;stroke:#DB2D2B'), 4)
def smiles_to_svg(smiles, size=(350, 300), draw_options=None):
"""Create an SVG string from a SMILES string.
Parameters
----------
smiles : str
SMILES to create SVG image.
size : tuple, optional
Size of image, the default is (350, 300).
draw_options : rdMolDraw2D.MolDrawOptions
Options to pass to the drawer.
Returns
-------
svg : str
SVG text for molecule.
"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return ''
mol = _maybe_kekulize(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(*size)
if draw_options:
drawer.SetDrawOptions(draw_options)
rdMolDraw2D.PrepareAndDrawMolecule(drawer, mol)
drawer.FinishDrawing()
return drawer.GetDrawingText()
def mol_to_svg(mol, size=(400,200)):
"""
Returns a RDKit MolDraw2DSVG object containing an image of the given molecule's structure.
Args:
mol (rdkit.Chem.Mol): Object representing molecule.
size (tuple): Width and height of bounding box of image.
Returns:
RDKit.rdMolDraw2D.MolDraw2DSVG text (str): An SVG object containing an image of the molecule's structure.
"""
img_wd, img_ht = size
AllChem.Compute2DCoords(mol)
try:
mol.GetAtomWithIdx(0).GetExplicitValence()
except RuntimeError:
mol.UpdatePropertyCache(False)
try:
mc_mol = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=True)
except ValueError:
# can happen on a kekulization failure
mc_mol = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=False)
drawer = rdMolDraw2D.MolDraw2DSVG(img_wd, img_ht)
drawer.DrawMolecule(mc_mol)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
svg = svg.replace('svg:','')
svg = svg.replace('xmlns:svg','xmlns')
return svg
def draw_mol(
smiles,
height=200,
width=200,
img_type=None,
highlightAtoms=[],
atomcolors=[],
highlightBonds=[],
bondcolors={},
mol=None,
):
"""
Draw a molecule from a smiles
:param smiles: the SMILES to render
:param height: the height in px
:param width: the width in px
:return: an SVG as a string of the inage
"""
if mol is None:
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return "None Mol"
AllChem.Compute2DCoords(mol)
Chem.Kekulize(mol)
if not height:
height = 200
if not width:
width = 200
if img_type == "png":
img = Draw.MolToImage(
mol,
highlightBonds=highlightBonds,
highlightBondColors=bondcolors,
)
img = img.convert("RGBA")
datas = img.getdata()
newData = []
for item in datas:
if item[0] == 255 and item[1] == 255 and item[2] == 255:
newData.append((255, 255, 255, 0))
else:
newData.append(item)
img.putdata(newData)
response = HttpResponse(content_type="image/png")
img.save(response, "PNG")
return response
else:
drawer = rdMolDraw2D.MolDraw2DSVG(height, width)
drawopt = drawer.drawOptions()
drawopt.clearBackground = False
drawer.DrawMolecule(
mol,
highlightAtoms=highlightAtoms,
highlightAtomColors=atomcolors,
highlightBonds=highlightBonds,
highlightBondColors=bondcolors,
)
drawer.DrawMolecule(mol)
drawer.FinishDrawing()
return drawer.GetDrawingText().replace("svg:", "")
def moltosvg_interaction_known(mol, atom_list, atom_predictions,
molecule_prediction, molecule_experiment,
max_atom_pred, min_atom_pred, Number):
note = '(' + str(Number) + ') y-y\' : ' + str(round(
molecule_experiment, 2)) + '-' + str(round(molecule_prediction, 2))
norm = matplotlib.colors.Normalize(vmin=min_atom_pred * 0.9,
vmax=max_atom_pred * 1.1)
cmap = cm.get_cmap('gray_r')
plt_colors = cm.ScalarMappable(norm=norm, cmap=cmap)
atom_colors = {}
for i, atom in enumerate(atom_list):
atom_colors[atom] = plt_colors.to_rgba(atom_predictions[i])
rdDepictor.Compute2DCoords(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(280, 218)
op = drawer.drawOptions()
for i in range(mol.GetNumAtoms()):
op.atomLabels[i] = mol.GetAtomWithIdx(i).GetSymbol() + str(i)
mol = rdMolDraw2D.PrepareMolForDrawing(mol)
drawer.DrawMolecule(mol,
highlightAtoms=atom_list,
highlightBonds=[],
highlightAtomColors=atom_colors,
legend=note)
drawer.SetFontSize(68)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
return svg.replace('svg:', '')
def moldraw(smi, size=(450, 150), kekulize=True, highlight_atoms=None):
filename = os.path.join(IMAGEPATH, hashlib.sha1(smi).hexdigest() + '.svg')
mol = Chem.MolFromSmiles(smi)
mc = Chem.Mol(mol.ToBinary())
if kekulize:
try:
Chem.Kekulize(mc)
except:
mc = Chem.Mol(mol.ToBinary())
if not mc.GetNumConformers():
rdDepictor.Compute2DCoords(mc)
if highlight_atoms:
coord_ = _colorizer(mc, highlight_atoms)
else:
coord_ = None
if coord_ is not None:
dwr = rdMolDraw2D.MolDraw2DSVG(size[0], size[1])
dwr.DrawMolecule(mc, highlightAtoms=coord_)
dwr.FinishDrawing()
svg = dwr.GetDrawingText().replace('svg:', '')
svg_noframe = '\n'.join(
[line for line in svg.split('\n') if line[0:5] != '<rect'])
f = open(filename, 'w')
f.write(svg_noframe)
f.close()
return filename
def draw_mol_outlier(smiles, missing_atoms, missing_bonds, figsize=(300, 300)):
mol = Chem.MolFromSmiles(smiles)
missing_bonds_adjusted = []
for bond_index in missing_bonds:
if bond_index >= mol.GetNumBonds():
molH = Chem.AddHs(mol)
bond = molH.GetBondWithIdx(int(bond_index))
start_atom = mol.GetAtomWithIdx(bond.GetBeginAtomIdx())
mol = Chem.AddHs(mol, onlyOnAtoms=[start_atom.GetIdx()])
bond_index = mol.GetNumBonds() - 1
missing_bonds_adjusted += [int(bond_index)]
if not mol.GetNumConformers():
rdDepictor.Compute2DCoords(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(*figsize)
drawer.SetFontSize(.6)
drawer.DrawMolecule(mol,
highlightAtoms=[int(index) for index in missing_atoms],
highlightBonds=missing_bonds_adjusted)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
svg = svg.replace('svg:', '').replace(':svg', '')
if flask:
return Markup(svg)
else:
return svg
def drawTopicWeightsMolecule(mol, molID, topicID, topicModel, molSize=(450,200), kekulize=True,\
baseRad=0.1, color=(.9,.9,.9), fontSize=0.9):
# get the atom weights
atomWeights, maxWeightTopic = _getAtomWeights(mol, molID, topicID,
topicModel)
atRads = {}
atColors = {}
# color the atoms and set their highlight radius according to their weight
if np.sum(atomWeights) > 0:
for at, score in enumerate(atomWeights):
atColors[at] = color
atRads[at] = max(atomWeights[at] / maxWeightTopic, 0.0) * baseRad
if atRads[at] > 0 and atRads[at] < 0.2:
atRads[at] = 0.2
try:
mc = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=kekulize)
except ValueError: # <- can happen on a kekulization failure
mc = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=False)
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
drawer.SetFontSize(fontSize)
drawer.DrawMolecule(mc,
highlightAtoms=atColors.keys(),
highlightAtomColors=atColors,
highlightAtomRadii=atRads,
highlightBonds=[])
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
return svg.replace('svg:', '')
def _draw_mol_structure(self, mol, figsize=(600, 300)):
from IPython.display import SVG
from rdkit import Chem
from rdkit.Chem import rdDepictor
from rdkit.Chem.Draw import rdMolDraw2D
from rdkit.Chem.Draw.MolDrawing import DrawingOptions
self.logger.info(Chem.MolToSmiles(mol))
rdDepictor.Compute2DCoords(mol)
drawer = rdMolDraw2D.MolDraw2DSVG(*figsize)
drawer.drawOptions().updateAtomPalette({k: (0, 0, 0) for k in DrawingOptions.elemDict.keys()})
try:
drawer.SetLineWidth(3)
except AttributeError: # for RDkit bug : https://github.com/rdkit/rdkit/issues/2251
pass
drawer.SetFontSize(0.7)
highlight_atoms, color_atoms = self._get_atoms_color(mol.GetNumAtoms())
highlight_bonds = []
color_bonds = {}
drawer.DrawMolecule(mol,
highlightAtoms=highlight_atoms,
highlightAtomColors=color_atoms,
highlightBonds=highlight_bonds,
highlightBondColors=color_bonds)
drawer.FinishDrawing()
svg = drawer.GetDrawingText().replace('svg:', '')
SVG(svg)
saved_filename = f"{self.out_filename}_mol.svg"
with open(saved_filename, "w") as f:
f.write(svg)
self.logger.info(f"[SAVE] {saved_filename}")
def _moltoSVG(mol,
sz,
highlights,
legend,
kekulize,
drawOptions=None,
**kwargs):
try:
mol.GetAtomWithIdx(0).GetExplicitValence()
except RuntimeError:
mol.UpdatePropertyCache(False)
kekulize = _okToKekulizeMol(mol, kekulize)
try:
mc = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=kekulize)
except ValueError: # <- can happen on a kekulization failure
mc = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=False)
d2d = rdMolDraw2D.MolDraw2DSVG(sz[0], sz[1])
if drawOptions is not None:
d2d.SetDrawOptions(drawOptions)
d2d.DrawMolecule(mc, legend=legend, highlightAtoms=highlights)
d2d.FinishDrawing()
svg = d2d.GetDrawingText()
return svg
def show_predictions(mol, prob, cutoff=0.75, show_prob_label=False):
"""
Build 2D depiction of rdkit molecule
Label atoms with index number and SOM prediction probabilities if
above cutoff.
"""
prob_dict = dict([(int(a.split('.')[1]), b) for a, b in prob.items()])
Chem.rdDepictor.Compute2DCoords(mol)
for atom in mol.GetAtoms():
idx = atom.GetIdx() + 1
if show_prob_label:
atom.SetProp('molAtomMapNumber',
'{0}-{1:.2f}'.format(idx, prob_dict.get(idx, 0.0)))
else:
atom.SetProp('molAtomMapNumber', '{0}'.format(idx))
drawer = rdMolDraw2D.MolDraw2DSVG(350, 225)
drawer.DrawMolecule(
mol,
highlightAtoms=[i - 1 for i in prob_dict if prob_dict[i] >= cutoff])
drawer.FinishDrawing()
return drawer.GetDrawingText().replace('svg:', '')
def testExplictMethyl(self):
m = Chem.MolFromSmiles('CC')
d = rdMolDraw2D.MolDraw2DSVG(250, 200)
rdMolDraw2D.PrepareAndDrawMolecule(d, m)
d.FinishDrawing()
txt = d.GetDrawingText()
self.assertEqual(txt.find("class='atom-"), -1)
d = rdMolDraw2D.MolDraw2DSVG(250, 200)
do = rdMolDraw2D.MolDrawOptions()
do.explicitMethyl = True
d.SetDrawOptions(do)
rdMolDraw2D.PrepareAndDrawMolecule(d, m)
d.FinishDrawing()
txt = d.GetDrawingText()
self.assertNotEqual(txt.find("class='atom-"), -1)
def do_a_picture(smi, smarts, filename, label, fmt='svg'):
rdDepictor.SetPreferCoordGen(True)
mol = Chem.MolFromSmiles(smi)
mol = Draw.PrepareMolForDrawing(mol)
acols = {}
bcols = {}
h_rads = {}
h_lw_mult = {}
for i, smt in enumerate(smarts):
alist, blist = get_hit_atoms_and_bonds(mol, smt)
col = i % 4
add_colours_to_map(alist, acols, col)
add_colours_to_map(blist, bcols, col)
if fmt == 'svg':
d = rdMolDraw2D.MolDraw2DSVG(300, 300)
mode = 'w'
elif fmt == 'png':
d = rdMolDraw2D.MolDraw2DCairo(300, 300)
mode = 'wb'
else:
print('unknown format {}'.format(fmt))
return
d.drawOptions().fillHighlights = False
d.DrawMoleculeWithHighlights(mol, label, acols, bcols, h_rads, h_lw_mult,
-1)
d.FinishDrawing()
with open(filename, mode) as f:
f.write(d.GetDrawingText())
def mol_to_svg(mol, img_file, size=(400, 200)):
"""
Draw molecule mol's structure into an SVG file with path 'img_file' and with the
given size.
Args:
mol (rdkit.Chem.Mol): Object representing molecule.
img_file (str): Path to write SVG file to.
size (tuple): Width and height of bounding box of image.
"""
img_wd, img_ht = size
AllChem.Compute2DCoords(mol)
try:
mol.GetAtomWithIdx(0).GetExplicitValence()
except RuntimeError:
mol.UpdatePropertyCache(False)
try:
mc_mol = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=True)
except ValueError:
# can happen on a kekulization failure
mc_mol = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=False)
drawer = rdMolDraw2D.MolDraw2DSVG(img_wd, img_ht)
drawer.DrawMolecule(mc_mol)
drawer.FinishDrawing()
svg = drawer.GetDrawingText()
svg = svg.replace('svg:', '')
svg = svg.replace('xmlns:svg', 'xmlns')
with open(img_file, 'w') as img_out:
img_out.write(svg)
def mol2im(mc, molSize=(300, 120), kekulize=False, outfile=None, im_type="png"):
if kekulize:
try:
Chem.Kekulize(mc)
except:
pass
if not mc.GetNumConformers():
rdDepictor.Compute2DCoords(mc)
if im_type == "svg":
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
else:
drawer = rdMolDraw2D.MolDraw2DCairo(molSize[0], molSize[1])
drawer.SetFontSize(drawer.FontSize() * 0.8)
opts = drawer.drawOptions()
for i in range(mc.GetNumAtoms()):
opts.atomLabels[i] = mc.GetAtomWithIdx(i).GetSymbol() + str(i)
opts.padding = 0.1
drawer.DrawMolecule(mc)
drawer.FinishDrawing()
im = drawer.GetDrawingText()
if im_type == "svg":
im = im.replace('svg:', '')
if outfile:
with open(outfile, "w") as OUT:
OUT.write(im)
else:
if outfile:
drawer.WriteDrawingText(outfile)
return im
