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 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
def _toPNG(mol):
if hasattr(mol, '__sssAtoms'):
highlightAtoms = mol.__sssAtoms
else:
highlightAtoms = []
try:
mol.GetAtomWithIdx(0).GetExplicitValence()
except RuntimeError:
mol.UpdatePropertyCache(False)
if not hasattr(rdMolDraw2D, 'MolDraw2DCairo'):
mc = copy.deepcopy(mol)
try:
img = Draw.MolToImage(mc, size=molSize, kekulize=kekulizeStructures,
highlightAtoms=highlightAtoms)
except ValueError: # <- can happen on a kekulization failure
mc = copy.deepcopy(mol)
img = Draw.MolToImage(mc, size=molSize, kekulize=False, highlightAtoms=highlightAtoms)
bio = BytesIO()
img.save(bio, format='PNG')
return bio.getvalue()
else:
nmol = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=kekulizeStructures)
d2d = rdMolDraw2D.MolDraw2DCairo(molSize[0], molSize[1])
d2d.DrawMolecule(nmol, highlightAtoms=highlightAtoms)
d2d.FinishDrawing()
return d2d.GetDrawingText()
async def popochem(self, ctx, *, name: str):
outstr = ""
properties = [
"IUPACName", "MolecularFormula", "MolecularWeight",
"CanonicalSMILES"
]
translator = Translator()
name = translator.translate(text=name, dest="en").text
rslt = pcp.get_properties(properties, name, "name")
if rslt == []:
outstr += "検索した分子は見つかりませんでした．\nタイプミス等の可能性があります．"
await ctx.send(outstr)
else:
smiles = rslt[0].get("CanonicalSMILES")
if rslt[0].get("IUPACName") is not None:
iupac_name = "IUPAC名: " + rslt[0].get("IUPACName") + "\n"
else:
iupac_name = ""
mol_info = "分子式 (分子量): " + rslt[0].get("MolecularFormula") + \
" (" + rslt[0].get("MolecularWeight") + ")"
outstr += iupac_name + mol_info
view = rdMolDraw2D.MolDraw2DCairo(330, 300)
options = view.drawOptions()
options.legendFontSize = 24
options.multipleBondOffset = 0.1
options.useBWAtomPalette()
struct = rdMolDraw2D.PrepareMolForDrawing(
Chem.MolFromSmiles(smiles))
view.DrawMolecule(struct)
view.FinishDrawing()
view.WriteDrawingText("structure.png")
img_path = discord.File("structure.png")
await ctx.send(outstr, file=img_path)
os.remove("structure.png")
def _MolsToGridImage(mols, molsPerRow=3, subImgSize=(200, 200), legends=None,
highlightAtomLists=None, highlightBondLists=None, **kwargs):
""" returns a PIL Image of the grid
"""
if legends is None:
legends = [''] * len(mols)
nRows = len(mols) // molsPerRow
if len(mols) % molsPerRow:
nRows += 1
if not hasattr(rdMolDraw2D, 'MolDraw2DCairo'):
try:
import Image
except ImportError:
from PIL import Image
res = Image.new("RGBA", (molsPerRow * subImgSize[0], nRows * subImgSize[1]), (255, 255, 255, 0))
for i, mol in enumerate(mols):
row = i // molsPerRow
col = i % molsPerRow
highlights = None
if highlightAtomLists and highlightAtomLists[i]:
highlights = highlightAtomLists[i]
if mol is not None:
img = _moltoimg(mol, subImgSize, highlights, legends[i], **kwargs)
res.paste(img, (col * subImgSize[0], row * subImgSize[1]))
else:
fullSize = (molsPerRow * subImgSize[0], nRows * subImgSize[1])
d2d = rdMolDraw2D.MolDraw2DCairo(fullSize[0],fullSize[1],subImgSize[0], subImgSize[1])
d2d.DrawMolecules(list(mols),legends=legends,highlightAtoms=highlightAtomLists,
highlightBonds=highlightBondLists,**kwargs)
d2d.FinishDrawing()
res = _drawerToImage(d2d)
return res
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 sim_map_mf(results, query, fp_func, metric, out_file):
file_counter = 1
for m in query:
mol_keys = []
for i in results:
if results[i]["q_num"] == m:
Chem.Compute2DCoords(results[i]["mol"])
try:
fig, maxweight = SimilarityMaps.GetSimilarityMapForFingerprint(
query[results[i]["q_num"]]["mol"],
results[i]["mol"],
fp_func,
metric=fpsearch.sim_dict[metric])
fig.set_figwidth(3.255)
fig.set_figheight(3.255)
filename = f"{i}.png"
fig.savefig(filename, bbox_inches="tight")
mol_keys.append(i)
except:
d = rdMolDraw2D.MolDraw2DCairo(600, 600)
d.DrawMolecule(results[i]["mol"])
d.FinishDrawing()
d.WriteDrawingText(f"{i}.png")
mol_keys.append(i)
pages = gen_pdf_pages(mol_keys, results)
export_pdf(pages, f"{out_file}_{file_counter}.pdf")
file_counter += 1
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),
**kwargs):
menv = _getMorganEnv(mol, atomId, radius, baseRad, aromaticColor,
ringColor, centerColor, extraColor, **kwargs)
# Drawing
if useSVG:
drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0], molSize[1])
else:
drawer = rdMolDraw2D.MolDraw2DCairo(molSize[0], molSize[1])
drawopt = drawer.drawOptions()
drawopt.continuousHighlight = False
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 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 _mols2imageStream(mols, f, format, size, legend, highlightAtomLists=None, kekulize=True):
labels = [x for x in islice(cycle(legend), len(mols))] if isinstance(legend, (list, tuple)) else \
[x for x in islice(cycle([legend]), len(mols))]
legends = [x.GetProp("_Name") if (x.HasProp("_Name") and x.GetProp("_Name")) else labels[idx]
for idx, x in enumerate(mols)]
molsPerRow = min(len(mols), 4)
nRows = len(mols) // molsPerRow
if len(mols) % molsPerRow:
nRows += 1
_call(mols, 'UpdatePropertyCache', strict=False)
if kekulize:
_apply(mols, _kekulize)
highlightBondLists = []
if highlightAtomLists:
for mol, highlightAtomList in zip(mols, highlightAtomLists):
highlightBondList = []
for bnd in mol.GetBonds():
if bnd.GetBeginAtomIdx() in highlightAtomList and bnd.GetEndAtomIdx() in highlightAtomList:
highlightBondList.append(bnd.GetIdx())
highlightBondLists.append(highlightBondList)
if not highlightBondLists:
highlightBondLists = None
panelx = size
panely = size
canvasx = panelx * molsPerRow
canvasy = panely * nRows
drawer = rdMolDraw2D.MolDraw2DCairo(canvasx, canvasy, panelx, panely)
drawer.DrawMolecules(mols, highlightAtoms=highlightAtomLists, highlightBonds=highlightBondLists, legends=legends)
drawer.FinishDrawing()
f.write(drawer.GetDrawingText())
def plot_mol_with_color(smi, x_with_w_norm, save_name):
mol = Chem.MolFromSmiles(smi)
atoms = mol.GetNumAtoms()
#for i in range( atoms ):
#mol.GetAtomWithIdx(i).SetProp(
#'molAtomMapNumber', str(mol.GetAtomWithIdx(i).GetIdx()))
d = rdMolDraw2D.MolDraw2DCairo(500, 500)
atom_list = list(range(atoms))
atom_cols = {}
for index, i in enumerate(list(x_with_w_norm)):
atom_cols[index] = (0, 0, i)
rdMolDraw2D.PrepareAndDrawMolecule(
d,
mol,
highlightAtoms=atom_list,
highlightAtomColors=atom_cols,
)
with open(save_name, 'wb') as f:
f.write(d.GetDrawingText())
return mol
def render_rdkit_modern_rendering(mol, highlight, options, frmt, size, colors,
legend):
if frmt == 'png':
drawer = rdMolDraw2D.MolDraw2DCairo(size, size)
elif frmt == 'svg':
drawer = rdMolDraw2D.MolDraw2DSVG(size, size)
else:
return
opts = drawer.drawOptions()
if hasattr(options, 'bgColor') and options.bgColor:
opts.setBackgroundColour(options.bgColor)
else:
opts.clearBackground = False
if not colors:
opts.useBWAtomPalette()
else:
opts.useDefaultAtomPalette()
Chem.GetSSSR(mol)
drawer.DrawMolecule(mol, highlightAtoms=highlight, legend=legend)
drawer.FinishDrawing()
return drawer.GetDrawingText()
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 _moltoimg(mol, sz, highlights, legend, returnPNG=False, **kwargs):
try:
mol.GetAtomWithIdx(0).GetExplicitValence()
except RuntimeError:
mol.UpdatePropertyCache(False)
kekulize = _okToKekulizeMol(mol, kwargs.get('kekulize', True))
try:
mc = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=kekulize)
except ValueError: # <- can happen on a kekulization failure
mc = rdMolDraw2D.PrepareMolForDrawing(mol, kekulize=False)
if not hasattr(rdMolDraw2D, 'MolDraw2DCairo'):
img = MolToImage(mc, sz, legend=legend, highlightAtoms=highlights, **kwargs)
if returnPNG:
bio = BytesIO()
img.save(bio, format='PNG')
img = bio.getvalue()
else:
d2d = rdMolDraw2D.MolDraw2DCairo(sz[0], sz[1])
d2d.DrawMolecule(mc, legend=legend, highlightAtoms=highlights)
d2d.FinishDrawing()
if returnPNG:
img = d2d.GetDrawingText()
else:
img = _drawerToImage(d2d)
return img
def _draw_mol(self, mol, kekulize=True, add_chiral_hs=True):
if mol is None:
raise ValueError(
'Expected a rdkit molecule instance but got \'None\'')
mol = rdMolDraw2D.PrepareMolForDrawing(mol,
kekulize=kekulize,
addChiralHs=add_chiral_hs)
mol = SlideGenerator._scale_bond_length(mol)
drawer = rdMolDraw2D.MolDraw2DCairo(self.image_width,
self.molecule_image_height)
drawer.SetFontSize(self.font_size)
opts = drawer.drawOptions()
opts.clearBackground = False
opts.bondLineWidth = self.bond_width
opts.fixedBondLength = self.bond_length
opts.minFontSize = self.font_size
opts.maxFontSize = self.font_size
opts.fontFile = self.font_path
drawer.DrawMolecule(mol)
drawer.FinishDrawing()
png = drawer.GetDrawingText()
mol_image = Image.open(BytesIO(png))
mol_image.load()
return mol_image
def _moltoimg(mol,
sz,
highlights,
legend,
returnPNG=False,
drawOptions=None,
**kwargs):
try:
blocker = rdBase.BlockLogs()
mol.GetAtomWithIdx(0).GetExplicitValence()
except RuntimeError:
mol.UpdatePropertyCache(False)
kekulize = _okToKekulizeMol(mol, kwargs.get('kekulize', True))
wedge = kwargs.get('wedgeBonds', True)
try:
blocker = rdBase.BlockLogs()
mc = rdMolDraw2D.PrepareMolForDrawing(mol,
kekulize=kekulize,
wedgeBonds=wedge)
except ValueError: # <- can happen on a kekulization failure
mc = rdMolDraw2D.PrepareMolForDrawing(mol,
kekulize=False,
wedgeBonds=wedge)
if not hasattr(rdMolDraw2D, 'MolDraw2DCairo'):
img = MolToImage(mc,
sz,
legend=legend,
highlightAtoms=highlights,
**kwargs)
if returnPNG:
bio = BytesIO()
img.save(bio, format='PNG')
img = bio.getvalue()
else:
d2d = rdMolDraw2D.MolDraw2DCairo(sz[0], sz[1])
if drawOptions is not None:
d2d.SetDrawOptions(drawOptions)
if 'highlightColor' in kwargs:
d2d.drawOptions().setHighlightColor(kwargs['highlightColor'])
# we already prepared the molecule:
d2d.drawOptions().prepareMolsBeforeDrawing = False
bondHighlights = kwargs.get('highlightBonds', None)
if bondHighlights is not None:
d2d.DrawMolecule(mc,
legend=legend or "",
highlightAtoms=highlights or [],
highlightBonds=bondHighlights)
else:
d2d.DrawMolecule(mc,
legend=legend or "",
highlightAtoms=highlights or [])
d2d.FinishDrawing()
if returnPNG:
img = d2d.GetDrawingText()
else:
img = _drawerToImage(d2d)
return img
def draw_mol(smiles,
imgpath="structure.png",
width=800,
height=200,
show=False):
"""
Generate structure from SMILES
"""
# addAtomIndices -- https://www.rdkit.org/docs/GettingStartedInPython.html#drawing-molecules
# includeAtomNumbers? -- https://stackoverflow.com/a/53581867
# example 5? https://www.programcreek.com/python/example/119298/rdkit.Chem.Draw.MolToImage
# https://www.rdkit.org/docs/source/rdkit.Chem.Draw.rdMolDraw2D.html#rdkit.Chem.Draw.rdMolDraw2D.MolDrawOptions.addAtomIndices
# mol2 = Chem.MolFromSmiles(reactant, sanitize=False)
# mol = Chem.AddHs(mol) # probably unnecessary
# TODO: extra arg idx -- include idx in img
if ">>" not in smiles:
mol = Chem.MolFromSmiles(smiles)
d = rdMolDraw2D.MolDraw2DCairo(width,
height) # or MolDraw2DSVG to get SVGs
# d.drawOptions().addAtomIndices = True
d.DrawMolecule(mol)
else:
# https://www.rdkit.org/docs/GettingStartedInPython.html#drawing-chemical-reactions
rxn = AllChem.ReactionFromSmarts(smiles, useSmiles=True)
d = rdMolDraw2D.MolDraw2DCairo(width, height)
d.DrawReaction(rxn)
d.FinishDrawing()
png = d.GetDrawingText()
# TODO: annotate png
# print(png)
# draw = ImageDraw.Draw(png)
# draw.text((0, 0),"Sample Text",(255,255,255))
open(imgpath, "wb+").write(png)
# d.WriteDrawingText(imgpath)
if show:
show_img(imgpath)
def _mol_repr_pretty_(self, p, cycle):
p.color_results = False
drawer = rdMolDraw2D.MolDraw2DCairo(300, 300)
if self.GetNumConformers() == 0:
Compute2DCoords(self)
drawer.DrawMolecule(self, highlightAtoms=getattr(self, "__sssAtoms", None))
drawer.FinishDrawing()
p.text(display_image_bytes(drawer.GetDrawingText()))
def _moltopng(mol, molSize=(450, 200), drawer=None, **kwargs):
if drawer is None:
tgt = request.get_json()
if tgt is None:
tgt = request.values
if _stringtobool(tgt.get('useGrid', '0')):
nMols = len(Chem.GetMolFrags(mol))
nCols = int(tgt.get('molsPerRow', 3))
nRows = nMols // nCols
if nMols % nCols:
nRows += 1
drawer = rdMolDraw2D.MolDraw2DCairo(molSize[0] * nCols,
molSize[1] * nRows, molSize[0],
molSize[1])
else:
drawer = rdMolDraw2D.MolDraw2DCairo(molSize[0], molSize[1])
_drawHelper(mol, drawer, **kwargs)
return drawer.GetDrawingText()
def _MolsToGridImage(mols,
molsPerRow=3,
subImgSize=(200, 200),
legends=None,
highlightAtomLists=None,
highlightBondLists=None,
drawOptions=None,
returnPNG=False,
**kwargs):
""" returns a PIL Image of the grid
"""
if legends is None:
legends = [''] * len(mols)
nRows = len(mols) // molsPerRow
if len(mols) % molsPerRow:
nRows += 1
if not hasattr(rdMolDraw2D, 'MolDraw2DCairo'):
from PIL import Image
res = Image.new("RGBA",
(molsPerRow * subImgSize[0], nRows * subImgSize[1]),
(255, 255, 255, 0))
for i, mol in enumerate(mols):
row = i // molsPerRow
col = i % molsPerRow
highlights = None
if highlightAtomLists and highlightAtomLists[i]:
highlights = highlightAtomLists[i]
if mol is not None:
img = _moltoimg(mol, subImgSize, highlights, legends[i],
**kwargs)
res.paste(img, (col * subImgSize[0], row * subImgSize[1]))
else:
fullSize = (molsPerRow * subImgSize[0], nRows * subImgSize[1])
d2d = rdMolDraw2D.MolDraw2DCairo(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 or None,
highlightAtoms=highlightAtomLists,
highlightBonds=highlightBondLists,
**kwargs)
d2d.FinishDrawing()
if not returnPNG:
res = _drawerToImage(d2d)
else:
res = d2d.GetDrawingText()
return res
def draw_moleculeModules(smi, comms, molName):
if type(comms) == str:
comms = comms.strip().split(',')
map_object = map(int, comms)
comms = list(map_object)
m = Chem.MolFromSmiles(smi)
atomcomm = comms
molatms = list(m.GetAtoms())
#molbonds=list(m.GetBonds())
#hit_ats=[]
#hit_bonds=[]
#hit_ats=[0,1,6]
#hit_bonds=[0,5]
athighlights2 = defaultdict(list)
arads2 = {}
bndhighlights2 = defaultdict(list)
for bond in m.GetBonds():
beginid = bond.GetBeginAtomIdx()
endid = bond.GetEndAtomIdx()
aid1 = molatms[beginid].GetIdx()
aid2 = molatms[endid].GetIdx()
bid = m.GetBondBetweenAtoms(aid1, aid2).GetIdx()
#print('bondid:',bid)
#print('s,t:', beginid, endid)
if atomcomm[beginid] == atomcomm[endid]:
atcomm = atomcomm[beginid]
#hit_ats.append(aid1)
#hit_ats.append(aid2)
#print(atcomm)
#print(colors(atcomm))
#hit_bonds.append(bid)
athighlights2[aid1].append(colors(atcomm))
athighlights2[aid2].append(colors(atcomm))
arads2[aid1] = 0.3
arads2[aid2] = 0.3
bndhighlights2[bid].append(colors(atcomm))
else:
bndhighlights2[bid].append((0.6, 0.6, 0.6))
dm2 = Draw.PrepareMolForDrawing(m)
d3d = rdMolDraw2D.MolDraw2DCairo(400, 400)
dos2 = d3d.drawOptions()
dos2.atomHighlightsAreCircles = False
dos2.fillHighlights = True
#dos2.addAtomIndices=True
#dos2.highlightBondWidthMultiplier=2
d3d.DrawMoleculeWithHighlights(dm2, molName, dict(athighlights2),
dict(bndhighlights2), arads2, {})
#dict(bndhighlights2)
d3d.FinishDrawing()
outputf2 = d3d.WriteDrawingText(molName + '.png')
return outputf2
def image_for_protein(molecule):
mol = Chem.MolFromSmiles(Chem.MolToSmiles(Chem.MolFromFASTA(molecule)))
d = rdMolDraw2D.MolDraw2DCairo(250, 200) # or MolDraw2DSVG to get SVGs
mol.GetAtomWithIdx(2).SetProp('atomNote', 'foo')
mol.GetBondWithIdx(0).SetProp('bondNote', 'bar')
d.drawOptions().addStereoAnnotation = True
d.drawOptions().addAtomIndices = True
d.DrawMolecule(mol)
d.FinishDrawing()
with open('atom_annotation_1' + '.jpeg', 'wb') as f:
f.write(d.GetDrawingText())
def _get_img_html_markup(self, mol) -> str:
d2d = rdMolDraw2D.MolDraw2DCairo(300, 300)
opts = d2d.drawOptions()
opts.clearBackground = False
d2d.DrawMolecule(mol)
d2d.FinishDrawing()
im_data = d2d.GetDrawingText()
b64_str = base64.b64encode(im_data).decode()
data_url = 'data:image/png;base64,' + b64_str
htm = """<img src="{}"/> """.format(data_url)
return htm
def draw_reaction2(reactions):
for i, reaction in enumerate(reactions):
rxn = AllChem.ReactionFromSmarts(reaction, useSmiles=True)
drawer = rdMolDraw2D.MolDraw2DCairo(1000, 300)
drawer.DrawReaction(rxn)
drawer.FinishDrawing()
drawer.WriteDrawingText('path/' + str(i) + '.png')
img = Image.open('path/' + str(i) + '.png')
draw = ImageDraw.Draw(img)
font = ImageFont.truetype("arial.ttf", 20)
draw.text((10, 0), "", (0, 0, 0), font=font)
img.save('path/' + str(i) + '.png')
def DrawMol(mol, out_path, size=(500, 500)):
drawer = rdMolDraw2D.MolDraw2DCairo(size[0], size[1])
tm = rdMolDraw2D.PrepareMolForDrawing(mol)
option = drawer.drawOptions()
option.addAtomIndices = True
drawer.DrawMolecule(tm)
drawer.FinishDrawing()
img = drawer.GetDrawingText()
with open(out_path, mode="wb") as f:
f.write(img)
def ReactionToImage(rxn, subImgSize=(200, 200), useSVG=False, **kwargs):
if not useSVG and not hasattr(rdMolDraw2D, 'MolDraw2DCairo'):
return _legacyReactionToImage(rxn, subImgSize=subImgSize, **kwargs)
else:
width = subImgSize[0] * (rxn.GetNumReactantTemplates() + rxn.GetNumProductTemplates() + 1)
if useSVG:
d = rdMolDraw2D.MolDraw2DSVG(width, subImgSize[1])
else:
d = rdMolDraw2D.MolDraw2DCairo(width, subImgSize[1])
d.DrawReaction(rxn, **kwargs)
d.FinishDrawing()
if useSVG:
return d.GetDrawingText()
else:
return _drawerToImage(d)
def drawmol_with_hi(
mol,
legend,
atom_hi_dict,
bond_hi_dict,
atomrads_dict,
widthmults_dict,
width=350,
height=200,
):
d2d = rdMolDraw2D.MolDraw2DCairo(width, height)
d2d.ClearDrawing()
d2d.DrawMoleculeWithHighlights(mol, legend, atom_hi_dict, bond_hi_dict,
atomrads_dict, widthmults_dict)
d2d.FinishDrawing()
png = d2d.GetDrawingText()
return png
def gen_pdf_mf(query, results, out_file):
COLOR = [(0.8, 0.0, 0.0)]
file_counter = 1
for m in query:
mol_keys = []
for n in results:
if results[n]["q_num"] == m:
Chem.Compute2DCoords(results[n]["mol"])
acols = {}
bcols = {}
h_rads = {}
h_lw_mult = {}
alist = []
blist = []
try:
for match in results[n]["match"]:
alist.extend(match)
for bond in query[m]["mol"].GetBonds():
aid1 = alist[bond.GetBeginAtomIdx()]
aid2 = alist[bond.GetEndAtomIdx()]
blist.append(results[n]["mol"].GetBondBetweenAtoms(
aid1, aid2).GetIdx())
add_bonds = []
for ha1 in alist:
for ha2 in alist:
if ha1 > ha2:
b = results[n]["mol"].GetBondBetweenAtoms(
ha1, ha2)
if b:
add_bonds.append(b.GetIdx())
for bo2 in add_bonds:
if bo2 not in blist:
blist.append(bo2)
add_colours_to_map(alist, acols, 0, COLOR)
add_colours_to_map(blist, bcols, 0, COLOR)
except:
pass
d = rdMolDraw2D.MolDraw2DCairo(600, 600)
d.DrawMoleculeWithHighlights(results[n]["mol"], "", acols,
bcols, h_rads, h_lw_mult, -1)
d.FinishDrawing()
d.WriteDrawingText(f"{n}.png")
mol_keys.append(n)
pages = gen_pdf_pages(mol_keys, results)
export_pdf(pages, f"{out_file}_{file_counter}.pdf")
file_counter += 1
def draw_reaction(path):
src = path + 'src10.txt'
tgt = path + 'tgt10.txt'
src_file = open(src)
tgt_file = open(tgt)
srcs = [(l.split()[0][1:-1], ''.join(l.split()[1:]).strip())
for l in src_file]
tgts = [l.replace(' ', '').strip() for l in tgt_file]
rxns = []
for i in range(len(srcs)):
reaction_class, src = srcs[i]
tgt = tgts[i]
product = tgt.split(".")
# pic = [Draw.MolToImage(Chem.MolFromSmiles(e)) for e in product]
for i, c in enumerate(product):
try:
pic = Draw.MolToImage(Chem.MolFromSmiles(c))
c = c.replace("/", 'v')
c = c.replace(chr(92), 'w')
print(c)
pic.save("tmp/" + str(c) + ".png", transparent=True)
except:
pass
reaction = tgt + '>>' + src
print(reaction, "xxxx")
try:
rxns.append((reaction_class,
AllChem.ReactionFromSmarts(reaction,
useSmiles=True), product))
except:
print('invalid smiles ' + src)
print(rxns)
for i, (reaction_class, rxn, product) in enumerate(rxns):
# pic = [Draw.MolToImage(e) for e in product]
drawer = rdMolDraw2D.MolDraw2DCairo(1000, 300)
drawer.DrawReaction(rxn)
drawer.FinishDrawing()
drawer.WriteDrawingText(path + reaction_class + '_reaction_tmp.png')
img = Image.open(path + reaction_class + '_reaction_tmp.png')
draw = ImageDraw.Draw(img)
font = ImageFont.truetype("arial.ttf", 20)
draw.text((10, 0), reaction_class, (0, 0, 0), font=font)
img.save(path + reaction_class + '_reaction_tmp.png')
def _moltoimg(mol,sz,highlights,legend,**kwargs):
try:
import Image
except ImportError:
from PIL import Image
from rdkit.Chem.Draw import rdMolDraw2D
if not hasattr(rdMolDraw2D,'MolDraw2DCairo'):
img = MolToImage(mol,sz,legend=legend,highlightAtoms=highlights,
**kwargs)
else:
nmol = rdMolDraw2D.PrepareMolForDrawing(mol,kekulize=kwargs.get('kekulize',True))
d2d = rdMolDraw2D.MolDraw2DCairo(sz[0],sz[1])
d2d.DrawMolecule(nmol,legend=legend,highlightAtoms=highlights)
from io import BytesIO
d2d.FinishDrawing()
sio = BytesIO(d2d.GetDrawingText())
img = Image.open(sio)
return img
