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