def draw(self): """ This function plots the NetworkX graph by using Matplotlib """ logging.info('\nDrawing....') if nx.number_of_nodes(self.resultGraph) > self.max_nodes: logging.info('The number of generated graph nodes %d exceed the max number of drawable nodes %s' % ( nx.number_of_nodes(self.resultGraph), self.max_nodes)) return def max_dist_mol(mol): max_dist = 0.0 conf = mol.GetConformer() for i in range(0, conf.GetNumAtoms()): crdi = np.array([conf.GetAtomPosition(i).x, conf.GetAtomPosition(i).y, conf.GetAtomPosition(i).z]) for j in range(i + 1, conf.GetNumAtoms()): crdj = np.array([conf.GetAtomPosition(j).x, conf.GetAtomPosition(i).y, conf.GetAtomPosition(j).z]) dist = np.linalg.norm(crdi - crdj) if dist > max_dist: max_dist = dist return max_dist # Determine the screen resolution by using dxpyinfo and removing massive qt dependency command = ('xdpyinfo | grep dimensions') p = subprocess.run(command, stdout=subprocess.PIPE, shell=True, executable='/bin/bash') width = int(p.stdout.split()[1].split(b'x')[0]) height = int(p.stdout.split()[1].split(b'x')[1]) # Canvas scale factor scale_canvas = 0.75 # Canvas resolution max_canvas_size = (int(width * scale_canvas), int(height * scale_canvas)) fig = plt.figure(1, facecolor='white') fig.set_dpi(100) fig.set_size_inches(max_canvas_size[0] / fig.get_dpi(), max_canvas_size[1] / fig.get_dpi(), forward=True) ax = plt.subplot(111) plt.axis('off') pos = nx.nx_agraph.graphviz_layout(self.resultGraph, prog="neato") strict_edges = [(u, v) for (u, v, d) in self.resultGraph.edges(data=True) if d['strict_flag'] == True] loose_edges = [(u, v) for (u, v, d) in self.resultGraph.edges(data=True) if d['strict_flag'] == False] node_labels = dict([(u, d['ID']) for u, d in self.resultGraph.nodes(data=True)]) # Draw nodes nx.draw_networkx_nodes(self.resultGraph, pos, node_size=500, node_color='r') # Draw node labels nx.draw_networkx_labels(self.resultGraph, pos, labels=node_labels, font_size=10) if self.edge_labels: edge_weight_strict = dict([((u, v,), d['similarity']) for u, v, d in self.resultGraph.edges(data=True) if d['strict_flag'] == True]) edge_weight_loose = dict([((u, v,), d['similarity']) for u, v, d in self.resultGraph.edges(data=True) if d['strict_flag'] == False]) for key in edge_weight_strict: edge_weight_strict[key] = round(edge_weight_strict[key], 2) for key in edge_weight_loose: edge_weight_loose[key] = round(edge_weight_loose[key], 2) # edge strict nx.draw_networkx_edge_labels(self.resultGraph, pos, edge_labels=edge_weight_strict, font_color='g') # edge loose nx.draw_networkx_edge_labels(self.resultGraph, pos, edge_labels=edge_weight_loose, font_color='r') # edges strict nx.draw_networkx_edges(self.resultGraph, pos, edgelist=strict_edges, edge_color='g') # edges loose nx.draw_networkx_edges(self.resultGraph, pos, edgelist=loose_edges, edge_color='r') if nx.number_of_nodes(self.resultGraph) <= self.max_images: trans = ax.transData.transform trans2 = fig.transFigure.inverted().transform cut = 1.0 frame = 10 xmax = cut * max(xx for xx, yy in pos.values()) + frame ymax = cut * max(yy for xx, yy in pos.values()) + frame xmin = cut * min(xx for xx, yy in pos.values()) - frame ymin = cut * min(yy for xx, yy in pos.values()) - frame plt.xlim(xmin, xmax) plt.ylim(ymin, ymax) h = 20 w = 20 mol_size = (200, 200) for each_node in self.resultGraph: id_mol = self.resultGraph.node[each_node]['ID'] # skip remove Hs by rdkit if Hs cannot be removed try: mol = AllChem.RemoveHs(self.dbase[id_mol].getMolecule()) except: ###### need to ask RDKit to fix this if possible, see the code # issue tracker for more details###### mol = self.dbase[id_mol].getMolecule() logging.info( "Error attempting to remove hydrogens for molecule %s using RDKit. RDKit cannot kekulize the molecule" % self.dbase[id_mol].getName()) # max_dist = max_dist_mol(mol) # if max_dist > 7.0: # continue AllChem.Compute2DCoords(mol) # add try exception for cases cannot be draw try: img_mol = Draw.MolToImage(mol, mol_size, kekulize=False) except Exception as ex: img_mol = None logging.exception( "This mol cannot be draw using the RDKit Draw function, need to check for more details...") xx, yy = trans(pos[each_node]) xa, ya = trans2((xx, yy)) nodesize_1 = (300.0 / (h * 100)) nodesize_2 = (300.0 / (w * 100)) p2_2 = nodesize_2 / 2 p2_1 = nodesize_1 / 2 a = plt.axes([xa - p2_2, ya - p2_1, nodesize_2, nodesize_1]) # self.resultGraph.node[id_mol]['image'] = img_mol # a.imshow(self.resultGraph.node[each_node]['image']) a.imshow(img_mol) a.axis('off') # plt.savefig('graph.png', facecolor=fig.get_facecolor()) # print 'Graph .png file has been generated...' plt.show() return
from rdkit.Chem.Draw import SimilarityMaps from io import BytesIO from functools import partial from PIL import Image from rdkit.Chem.Draw import rdDepictor rdDepictor.SetPreferCoordGen(True) #rfc = pickle.load(open('rf.pkl', 'rb')) #for streamlit app rfc = pickle.load(open('/app/chem_streamlit/chemstreamlit/rf.pkl', 'rb')) fpfunc = partial(SimilarityMaps.GetMorganFingerprint, radius=2) #mols = [m for m in Chem.SDMolSupplier('./solubility.test.sdf')] mols = [m for m in Chem.SDMolSupplier('/app/chem_streamlit/chemstreamlit/solubility.test.sdf')] option = st.selectbox( 'Please select index of test molecules', [i for i in range(len(mols))] ) st.write('you selected:', option, Chem.MolToSmiles(mols[option])) fp = [datamaker.mol2fp(mols[option])] kls = rfc.predict(fp) img = Draw.MolToImage(mols[option]) bio = BytesIO() img.save(bio, format='png') st.image(img) st.write('predicted class:', datamaker.rclasses[kls[0]])
suppl = Chem.SDMolSupplier(sys.argv[1]) # Path to a input SDF file. mols = [mol for mol in suppl if mol is not None] #for mol in mols: # AllChem.Compute2DCoords(mol) # Draw.MolToFile(mol, mol.GetProp("_Name") + "." + sys.argv[2]) # Supported file formats are pdf, svg, ps, png. mcs = rdFMCS.FindMCS(mols) ref = Chem.MolFromSmarts(mcs.smartsString) AllChem.Compute2DCoords(ref) refCnf = ref.GetConformer() molsPerRow = 3 subImgSize = (400, 400) nRows = 1 + (len(mols) - 1) // molsPerRow img = Image.new("RGBA", (molsPerRow * subImgSize[0], nRows * subImgSize[1]), (255, 255, 255, 0)) for k, mol in enumerate(mols): # AllChem.GenerateDepictionMatching2DStructure(mol, ref) coordMap = {} for i, idx in enumerate(mol.GetSubstructMatch(ref)): pt3 = refCnf.GetAtomPosition(i) coordMap[idx] = rdGeometry.Point2D(pt3.x, pt3.y) # pt3.z == 0.0 AllChem.Compute2DCoords(mol, clearConfs=True, canonOrient=False, coordMap=coordMap) row = k // molsPerRow col = k - molsPerRow * row img.paste(Draw.MolToImage(mol, subImgSize, legend=mol.GetProp("_Name")), (col * subImgSize[0], row * subImgSize[1])) img.save(sys.argv[2]) # Path to a output PNG or JPG file.
def show_mol(self): mol = Chem.MolFromSmiles(self.smiles) return Draw.MolToImage(mol)
def draw_2D(smi_list): for smi in smi_list: m = Chem.MolFromSmiles(smi) img = Draw.MolToImage(m) plt.title(smi) plt.imshow(img)
# product_smiles = Chem.MolToSmiles(Chem.MolFromSmarts(reaction_smiles.split('>>')[-1])) reaction_rxn.RemoveMappingNumbersFromReactions() products = reaction_rxn.GetProducts()[0] product_smiles = Chem.MolToSmiles(products) print ("products", product_smiles) product_rule_smiles = reaction_rule_smiles.split('>>')[-1] reactant_rule_smiles = reaction_rule_smiles.split(">>")[0] reactant_list = reaction_rule_smiles.split('.') synthesis_reaction_smiles = product_rule_smiles+'>>' + reactant_rule_smiles print ("reaction_rule_smiles", synthesis_reaction_smiles) print ('product_smiles', product_smiles) product_img = Draw.MolToImage(Chem.MolFromSmiles(product_smiles)) product_img.save('product.png') synthesis_rule = Reaction(synthesis_reaction_smiles) synthesis_rule.RemoveUnmappedProductTemplates() synthesis_rule.RemoveUnmappedReactantTemplates() # synthesis_rule_img = Draw.ReactionToImage(synthesis_rule.rxn) # synthesis_rule_img.show() predict_reactants_mol = synthesis_rule.RunReactants([Chem.MolFromSmiles(product_smiles)])[0] print ('result:', predict_reactants_mol) predict_reactant_smiles = [] for ii, mol in enumerate(predict_reactants_mol): predict_smiles = Chem.MolToSmiles(mol) predict_reactant_smiles.append(predict_smiles)
with open('KNApSAck_mol/C00015228.mol'as fi: mol = Chem.MolFromMolBlock(fi.read()) rdDepictor.Compute2DCoords(mol) filename = "Streptomyces/C00015228.png" Draw.MolToFile(mol, filename, size=(400, 400), transparent=True) # In[28]: from PIL import Image with open('KNApSAck_mol/C00015228.mol')as fi: mol = Chem.MolFromMolBlock(fi.read()) rdDepictor.Compute2DCoords(mol) filename = "Streptomyces/C00015228.png" im = Draw.MolToImage(mol, size=(500, 500)) trans = Image.new('RGBA', im.size, (0, 0, 0, 0)) width = im.size[0] height = im.size[1] for x in range(width): for y in range(height): pixel = im.getpixel( (x, y) ) # 白なら処理しない if pixel[0] == 255 and pixel[1] == 255 and pixel[2] == 255: continue # 白以外なら、用意した画像にピクセルを書き込み trans.putpixel( (x, y), pixel ) # 透過画像を保存 trans.save(filename)
def smiles2img(usr_smiles): _mol = Chem.MolFromSmiles(usr_smiles) _img = Draw.MolToImage(_mol, size=(900, 900)) _img.show() return _mol
def draw_mol( smiles, height=34, width=150, 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: rdMolDraw2D.PrepareMolForDrawing(mol, wedgeBonds=False) drawer = rdMolDraw2D.MolDraw2DSVG(height, width) drawopt = drawer.drawOptions() drawopt.clearBackground = False drawopt.fixedBondLength = 30 drawopt.padding = 0.01 drawopt.bondLineWidth = 1 drawopt.additionalAtomLabelPadding = 0.05 drawer.SetFontSize(1) drawer.DrawMolecule( mol, highlightAtoms=highlightAtoms, highlightAtomColors=atomcolors, highlightBonds=highlightBonds, highlightBondColors=bondcolors, ) drawer.FinishDrawing() return drawer.GetDrawingText().replace("svg:", "").replace( 'stroke-width:2px', 'stroke-width:1.5px')
mol, size=(300, 300), kekulize=True, wedgeBonds=True, fitImage=False, options=None, canvas=None, **kwargs ) # 1.3 分子对象转图片 opts = DrawingOptions() m = Chem.MolFromSmiles('OC1C2C1CC2') opts.includeAtomNumbers = True opts.bondLineWidth = 2.8 draw = Draw.MolToImage(m, options=opts) draw.save('/drug_development/studyRdkit/st_rdcit/img/mol10.jpg') # 1.4 多个分子按照grid显示 smis = [ 'COC1=C(C=CC(=C1)NS(=O)(=O)C)C2=CN=CN3C2=CC=C3', 'C1=CC2=C(C(=C1)C3=CN=CN4C3=CC=C4)ON=C2C5=CC=C(C=C5)F', 'COC(=O)C1=CC2=CC=CN2C=N1', 'C1=C2C=C(N=CN2C(=C1)Cl)C(=O)O', ] mols = [] for smi in smis: mol = Chem.MolFromSmiles(smi) mols.append(mol) img = Draw.MolsToGridImage(
def mol_view(smi): """Will pop-up image (PNG) of molecule in image viewing software like MS Paint. """ mol = Chem.MolFromSmiles(smi) img = Draw.MolToImage(mol) img.show()
def drawMoleculeQuery(self): size = (400, 400) # fig = Draw.MolToMPL(self.mol, size=size) img = Draw.MolToImage(self.mol, size=size) img.save('static/images/queryMolecule/queryMolecule.png') return
def visualize(iqspr_results, RDKit_FPs, mdls, data_ss, beta): # re-calculate the property values for the proposed molecules x_mean, x_std, y_mean, y_std = [], [], [], [] r_std = [] FPs_samples = [] for i, smis in enumerate(iqspr_results["samples"]): tmp_fps = RDKit_FPs.transform(smis) FPs_samples.append(tmp_fps) tmp1, tmp2 = mdls["E"].predict(tmp_fps, return_std=True) x_mean.append(tmp1) x_std.append(tmp2) tmp1, tmp2 = mdls["H**O-LUMO gap"].predict(tmp_fps, return_std=True) y_mean.append(tmp1) y_std.append(tmp2) r_std.append([np.sqrt(x_std[-1][i] ** 2 + y_std[-1][i] ** 2) for i in range(len(x_std[-1]))]) # flatten the list for max/min calculation flat_list = [item for sublist in r_std for item in sublist] print('Range of std. dev.: (%.4f,%.4f)' % (min(flat_list), max(flat_list))) # prepare a folder to save all the figures ini_dir = './iQSPR_tutorial_prd/' if not os.path.exists(ini_dir): os.makedirs(ini_dir) flat_list = np.asarray([item for sublist in r_std for item in sublist]) s_max, s_min = max(flat_list), min(flat_list) flat_list = np.concatenate((data_ss["E"], np.asarray([item for sublist in x_mean for item in sublist]))) x_max, x_min = max(flat_list), min(flat_list) flat_list = np.concatenate((data_ss["H**O-LUMO gap"], np.asarray([item for sublist in y_mean for item in sublist]))) y_max, y_min = max(flat_list), min(flat_list) tmp_beta = np.hstack([0, beta]) for i in range(len(r_std)): dot_size = 45 * ((np.asarray(r_std[i]) - s_min) / (s_max - s_min)) + 5 plt.figure(figsize=(5, 5)) rectangle = plt.Rectangle((0, 0), 200, 3, fc='y', alpha=0.1) plt.gca().add_patch(rectangle) plt.scatter(data_ss["E"], data_ss["H**O-LUMO gap"], s=3, c='b', alpha=0.2) plt.scatter(x_mean[i], y_mean[i], s=dot_size, c='r', alpha=0.5) plt.title('Step: %i (beta = %.3f)' % (i, tmp_beta[i])) plt.xlim(x_min, x_max) plt.ylim(y_min, y_max) plt.xlabel('Internal energy') plt.ylabel('H**O-LUMO gap') # plt.show() plt.savefig(ini_dir + 'Step_%02i.png' % i, dpi=500) plt.close() # prepare a folder to save all the figures ini_dir = './iQSPR_tutorial_smiles/' if not os.path.exists(ini_dir): os.makedirs(ini_dir) n_S = 25 for i, smis in enumerate(iqspr_results['samples']): tmp_smis = iqspr_results['samples'][i][ np.argsort(iqspr_results['loglike'][i])[::-1]] fig, ax = plt.subplots(5, 5) fig.set_size_inches(20, 20) fig.set_tight_layout(True) for j in range(n_S): xaxis = j // 5 yaxis = j % 5 try: img = Draw.MolToImage(Chem.MolFromSmiles(tmp_smis[j])) ax[xaxis, yaxis].clear() ax[xaxis, yaxis].set_frame_on(False) ax[xaxis, yaxis].imshow(img) except: pass ax[xaxis, yaxis].set_axis_off() fig.savefig(ini_dir + 'Step_%02i.png' % i, dpi=500) plt.close() target_smis = [Chem.MolToSmiles(Chem.MolFromSmiles(smi)) for i, smi in enumerate(data_ss['SMILES']) if ((data_ss['H**O-LUMO gap'].iloc[i] <= 3) and (data_ss['E'].iloc[i] <= 200))] # prepare a folder to save all the figures ini_dir = './iQSPR_tutorial_target_smiles/' if not os.path.exists(ini_dir): os.makedirs(ini_dir) n_S = 25 fig, ax = plt.subplots(5, 5) fig.set_size_inches(20, 20) fig.set_tight_layout(True) for j in range(n_S): xaxis = j // 5 yaxis = j % 5 try: img = Draw.MolToImage(Chem.MolFromSmiles(target_smis[j])) ax[xaxis, yaxis].clear() ax[xaxis, yaxis].set_frame_on(False) ax[xaxis, yaxis].imshow(img) except: pass ax[xaxis, yaxis].set_axis_off() fig.savefig(ini_dir + 'target_region.png', dpi=500) plt.close()
model = model_zoo.chem.GCNClassifier(in_feats=74, gcn_hidden_feats=[64 for _ in range(2)], n_tasks=12, classifier_hidden_feats=64) model.load_state_dict( torch.load("./model/early_stop_2020-06-10_14-46-25.pth") ['model_state_dict']) model.eval() with torch.no_grad(): samplename = input("Please input the compound's name\n") print(samplename) results = pc.get_compounds(samplename, 'name') if not results: print("No information") raise SystemExit print(results) for compound in results: testsample = compound.canonical_smiles if (testsample == 0): print("No information") raise SystemExit m = Chem.MolFromSmiles(testsample) a = Draw.MolToImage(m, (600, 600)) a.show() sample = smile_to_bigraph(testsample) atom_feature = sample.ndata.pop('h') predictions = model(sample, atom_feature) predictions = torch.nn.Sigmoid()(predictions) print(predictions)
def display_mol(self): highlight_lipinski = self.check_lipinski.isChecked() if self.curr_sdf_mol_index == 0: self.btn_prev.setEnabled(False) else: self.btn_prev.setEnabled(True) if self.curr_sdf_mol_index == self.curr_sdf_num_of_mols - 1: self.btn_next.setEnabled(False) else: self.btn_next.setEnabled(True) img_file = IO() # for structure depiction img = sdft.autocrop( Draw.MolToImage(self.curr_sdf[self.curr_sdf_mol_index]), "white") img.save(img_file, format='PNG') # qimg = QtGui.QImage.fromData(img_file.getvalue()) self.qpixmap = QtGui.QPixmap() self.qpixmap.loadFromData(img_file.getvalue(), "PNG") self.label_molimage.setPixmap(self.qpixmap) self.le_recnumber.setText("{} of {}".format( self.curr_sdf_mol_index + 1, self.curr_sdf_num_of_mols)) if self.SDF_CHANGED: # self.SDF_CHANGED = False # self.selected_fields = self.get_selected_fields() self.table_props.clear() self.table_props.setHorizontalHeaderLabels(["prop", "value"]) for row, prop in enumerate(self.curr_sdf_fields): tbl_item = QtGui.QTableWidgetItem(prop[2:]) # tbl_item.setFlags(QtCore.Qt.ItemIsEnabled) self.table_props.setItem(row, 0, tbl_item) if self.SDF_CHANGED: if self.selected_fields and prop in self.selected_fields: self.table_props.setItemSelected(tbl_item, True) if prop in self.curr_sdf[self.curr_sdf_mol_index].GetPropNames(): value = self.curr_sdf[self.curr_sdf_mol_index].GetProp(prop) tbl_item = QtGui.QTableWidgetItem(value) # QtCore.Qt.ItemIsEditable is required to edit the cells # tbl_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable) tbl_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable) if highlight_lipinski and prop in self.highlight_dict: if float(value) > self.highlight_dict[prop]: tbl_item.setBackgroundColor(QtGui.QColor(255, 0, 0)) else: tbl_item.setBackgroundColor(QtGui.QColor(0, 255, 0)) self.table_props.setItem(row, 1, tbl_item) else: tbl_item = QtGui.QTableWidgetItem("n.d.") # see above for flag QtCore.Qt.ItemIsEditable tbl_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable) self.table_props.setItem(row, 1, tbl_item) self.table_props.setRowHeight(row, 18) self.SDF_CHANGED = False if self.curr_sdf_mol_index in self.selected_recs: self.check_rec_selected.setChecked(True) else: self.check_rec_selected.setChecked(False)
def MolToImage(mol, max_size=(1000, 1000), kekulize=True, options=None, canvas=None, **kwargs): """Wrapper for RDKit's ``MolToImage``. Args: mol (Chem.Mol or str): Molecule or arrow to draw. max_size (2-tuple of (int, int), optional): Maximum image size to return. (default: {(1000, 1000)}) kekulize (bool, optional): Whether to kekulize the molecule. (default: {True}) options (None or ??, optional): RDKit drawing options. If None, will use defaults. (default: {None}) canvas (None or Draw.Canvas, optional): Canvas to draw image onto. (default: {None}) **kwargs: Additional optional arugments passed to RDKit's ``MolToImage``. Returns: PIL.Image: Drawn molecule. """ if not options: options = defaultDrawOptions() if mol == '->': subImgSize = (100, 100) img, canvas = Draw._createCanvas(subImgSize) p0 = (10, subImgSize[1] // 2) p1 = (subImgSize[0] - 10, subImgSize[1] // 2) p3 = (subImgSize[0] - 20, subImgSize[1] // 2 - 10) p4 = (subImgSize[0] - 20, subImgSize[1] // 2 + 10) canvas.addCanvasLine(p0, p1, lineWidth=2, color=(0, 0, 0)) canvas.addCanvasLine(p3, p1, lineWidth=2, color=(0, 0, 0)) canvas.addCanvasLine(p4, p1, lineWidth=2, color=(0, 0, 0)) if hasattr(canvas, 'flush'): canvas.flush() else: canvas.save() return img elif mol == '<-': # retro arrow or error subImgSize = (100, 100) (a, b) = subImgSize img, canvas = Draw._createCanvas(subImgSize) canvas.addCanvasLine((10, b // 2 - 7), (a - 17, b // 2 - 7), lineWidth=2, color=(0, 0, 0)) canvas.addCanvasLine((10, b // 2 + 7), (a - 17, b // 2 + 7), lineWidth=2, color=(0, 0, 0)) canvas.addCanvasLine((a - 24, b // 2 - 14), (a - 10, b // 2), lineWidth=2, color=(0, 0, 0)) canvas.addCanvasLine((a - 24, b // 2 + 14), (a - 10, b // 2), lineWidth=2, color=(0, 0, 0)) if hasattr(canvas, 'flush'): canvas.flush() else: canvas.save() return img elif mol is not None: return Draw.MolToImage(mol, size=max_size, kekulize=kekulize, options=options, canvas=canvas, **kwargs)
def smiles2image(smiles): mol = AllChem.MolFromSmiles(smiles) img = Draw.MolToImage(mol) # PIL image, save using img.save(filename) return img
def smiles_to_image(smiles): a = io.BytesIO() m = Chem.MolFromSmiles(smiles) z = Draw.MolToImage(m) z.save(a, format="PNG") return a.getvalue()
def testGithubIssue54(self): # Assert that radicals depict with PIL os.environ['RDKIT_CANVAS'] = 'sping' mol = Chem.MolFromSmiles('c1([O])ccc(O)cc1') img = Draw.MolToImage(mol) self.assertTrue(img)
def generate_sar_table(db_list, core, id_prop, act_prop, sort_reverse=True, dir_name="html/sar_table", color_prop="logp"): """core: smiles string; id_prop, act_prop: string colorprop_is_lin: whether or not the property used for coloring is linear (e.g. LogP or PercActivity) or needs to be logarithmitized (e.g. IC50_uM).""" tools.create_dir_if_not_exist(dir_name) tools.create_dir_if_not_exist(op.join(dir_name, "img")) db_list.sort_list(act_prop, reverse=sort_reverse) act_xy = np.zeros([55, 55], dtype=np.float) # coordinates for the activity # color_xy = np.zeros([55, 55], dtype=np.float) color_xy = np.full([55, 55], np.NaN, dtype=np.float) molid_xy = np.zeros([55, 55], dtype=np.int) # molid_xy = np.arange(900, dtype=np.int).reshape(30, 30) # coordinates for the molid rx_dict = {} # axes for the residues ry_dict = {} max_x = -1 # keep track of the arraysize max_y = -1 res_pos_x = -1 res_pos_y = -1 core_mol = Chem.MolFromSmiles(core) Draw.MolToFile(core_mol, "%s/img/core.png" % dir_name, [90, 90]) for idx, mol in enumerate(db_list): act = float(mol.GetProp(act_prop)) color = float(mol.GetProp(color_prop)) molid = int(mol.GetProp(id_prop)) tmp = Chem.ReplaceCore(mol, core_mol, labelByIndex=True) frag_mols = list(Chem.GetMolFrags(tmp, asMols=True)) frag_smiles = [Chem.MolToSmiles(m, True) for m in frag_mols] if len(frag_mols) == 1: # one of the two residues is H: pos = get_res_pos(frag_smiles[0]) if pos == res_pos_x: h_smiles = "[%d*]([H])" % res_pos_y frag_smiles.append(h_smiles) frag_mols.append(Chem.MolFromSmiles(h_smiles)) else: h_smiles = "[%d*]([H])" % res_pos_x frag_smiles.insert(0, h_smiles) frag_mols.insert(0, Chem.MolFromSmiles(h_smiles)) print(" adding H residue in pos {} to mol #{} (molid: {})".format( pos, idx, mol.GetProp(id_prop))) elif len(frag_mols) > 2: print( "* incorrect number of fragments ({}) in mol #{} (molid: {})". format(len(frag_mols), idx, mol.GetProp(id_prop))) continue if res_pos_x == -1: # print frag_smiles[0], frag_smiles[1] res_pos_x = get_res_pos(frag_smiles[0]) res_pos_y = get_res_pos(frag_smiles[1]) # print "res_pos_x: {} res_pos_y: {}".format(res_pos_x, res_pos_y) else: test_pos_x = get_res_pos(frag_smiles[0]) if test_pos_x != res_pos_x: # switch residues frag_smiles = frag_smiles[::-1] frag_mols = frag_mols[::-1] if frag_smiles[0] in rx_dict: curr_x = rx_dict[frag_smiles[0]] else: max_x += 1 rx_dict[frag_smiles[0]] = max_x curr_x = max_x Draw.MolToFile(frag_mols[0], "%s/img/frag_x_%02d.png" % (dir_name, max_x), [100, 100]) if frag_smiles[1] in ry_dict: curr_y = ry_dict[frag_smiles[1]] else: max_y += 1 ry_dict[frag_smiles[1]] = max_y curr_y = max_y Draw.MolToFile(frag_mols[1], "%s/img/frag_y_%02d.png" % (dir_name, max_y), [100, 100]) # draw thw whole molecule for the tooltip img_file = op.join(dir_name, "img/", "cpd_{}_{}.png".format(curr_x, curr_y)) img = tools.autocrop(Draw.MolToImage(mol), "white") img.save(img_file, format='PNG') act_xy[curr_x][curr_y] = act color_xy[curr_x][curr_y] = color molid_xy[curr_x][curr_y] = molid return act_xy, molid_xy, color_xy, max_x, max_y
from rdkit import Chem from rdkit.Chem import Descriptors from rdkit.Chem import rdMolDescriptors from rdkit.Chem import Draw smiles = open('rb/smiles.smi') line = smiles.readline() salida = open('rb/descriptors.csv','w') i = 0 while(line): mol = Chem.MolFromSmiles(line) img = Draw.MolToImage(mol,useSVG=False) img.save('./images/'+str(i)+'.png') #img = Draw.MolToImage(mol,useSVG=True) #img.save('./images/'+str(i)+'.svg') line = smiles.readline() i+=1 salida.close()
def core_table(mol, props=None, hist=None): if props is None: props = ["Cluster_No", "Num_Members", "Producers"] td_opt = {"align": "center"} header_opt = {"bgcolor": "#94CAEF", "align": "center"} table_list = [] cells = html.td(html.b("Molecule"), header_opt) for prop in props: pl = prop.lower() if (pl.endswith("min") or pl.endswith("max") or pl.endswith("mean") or pl.endswith("median") or pl.endswith("ic50") or pl.endswith("ic50)") or pl.endswith("activity") or pl.endswith("acctivity)")): pos = prop.rfind("_") if pos > 0: prop = prop[:pos] + "<br>" + prop[pos + 1:] cells.extend(html.td(html.b(prop), header_opt)) if hist is not None: header_opt["class"] = "histogram" cells.extend(html.td(html.b("Histogram"), header_opt)) rows = html.tr(cells) cells = [] if not mol: cells.extend(html.td("no structure")) else: mol_props = mol.GetPropNames() cl_no = mol.GetProp("Cluster_No") img_file = "img/core_{}.png".format(cl_no) img = tools.autocrop(Draw.MolToImage(mol)) img.save(img_file, format='PNG') img_src = img_file cell = html.img(img_src) cells.extend(html.td(cell, td_opt)) for prop in props: td_opt = {"align": "center"} if prop in mol_props: prop_val = mol.GetProp(prop) cells.extend(html.td(prop_val, td_opt)) else: cells.extend(html.td("", td_opt)) if hist is not None: td_opt["class"] = "histogram" if "img/" not in hist: hist = "img/" + hist img_opt = {"height": "220"} cell = html.img(hist, img_opt) cells.extend(html.td(cell, td_opt)) rows.extend(html.tr(cells)) table_list.extend(html.table(rows)) # print(table_list) return "".join(table_list)
def PrintAsBase64PNGString(x, renderer=None): '''returns the molecules as base64 encoded PNG image ''' return '<img src="data:image/png;base64,%s" alt="Mol"/>' % _get_image( Draw.MolToImage(x))
from rdkit import rdBase, Chem from rdkit.Chem import AllChem, Draw from rdkit.Chem.Draw import rdMolDraw2D from rdkit.Chem import rdDepictor from IPython.display import SVG m = Chem.MolFromSmiles("Cc1nc(Nc2ncc(s2)C(=O)Nc3c(C)cccc3Cl)cc(n1)N4CCN(CCO)CC4") mol = Draw.MolToImage(m)
f.write('Property:' + args.property_name + '\n') f.write('Validity: ' + str(np.mean(valid_ratio)) + '±' + str(np.std(valid_ratio)) + '\n') f.write('Average score: ' + str(np.mean(sorted_scores)) + '±' + str(np.std(sorted_scores)) + '\n') if args.save_smiles: f.write(str(sorted_smiles) + '\n') f.write(str(sorted_scores) + '\n') f.write('\n') if args.save_fig is not None: gen_dir = args.save_fig os.makedirs(gen_dir, exist_ok=True) for i in range(len(gen_mols)): filepath = os.path.join(gen_dir, 'generated_mols_{}.png'.format(i + 1)) img = Draw.MolToImage(gen_mols[i]) img.save(filepath) print('10 highest score:', sorted_scores[0:10]) print('==========================================') print('Average score:', str(np.mean(sorted_scores)), '±', str(np.std(sorted_scores))) print('==========================================') print("Validity: {:.3f}% ± {:.3f}%, vals={}".format( np.mean(valid_ratio), np.std(valid_ratio), valid_ratio)) print('------------------------------------------') print("Generation Time: {:.3f} ± {:.3f} seconds, vals={}".format( np.mean(gen_time), np.std(gen_time), gen_time)) print('==========================================')
def disp100mol(mol): im_mol=Draw.MolToImage(mol,size=(200,200)) display(im_mol.resize((150,150),resample=5))
def gen_plot( QCA, fnm): try: d = np.loadtxt( fnm, usecols=(5,2,6), skiprows=3) if d.size == 0: return except StopIteration: print("No data for", fnm) return entry = np.genfromtxt( fnm, usecols=(0,), skip_header=HEADER_LEN, dtype=np.dtype("str"))[0] smiles = np.genfromtxt( fnm, usecols=(7,), skip_header=HEADER_LEN, dtype=np.dtype("str"), comments=None)[0] scanned = np.genfromtxt( fnm, usecols=( 4,), skip_header=HEADER_LEN, dtype=np.dtype("str"))[0] scanned = eval('[' + scanned.replace('-',',') + ']') scanned = [x+1 for x in scanned] #print(scanned) print( fnm, smiles) mol_id = np.genfromtxt( fnm, usecols=(1,), skip_header=HEADER_LEN, dtype=np.dtype("str")) with open( fnm, 'r') as fd: ds_name = fd.readline().strip("\n") method = fd.readline().strip("\n") basis = fd.readline().strip("\n") scan = d[:,0] qm_abs_min = d[:,1].min() qmene = d[:,1] * const.hartree2kcalmol qmene -= qmene.min() mmene = d[:,2] mmene -= mmene.min() mm_min_pt = scan[ np.argsort(mmene)[0]] qm_min_pt = scan[ np.argsort(qmene)[0]] #AllChem.GenerateDepictionMatching3DStructure() qcmol = QCA.db.get( mol_id[0]).get( "data") try: mol = rdutil.mol.build_from_smiles( smiles) molnoindex = rdutil.mol.build_from_smiles( re.sub(":[1-9][0-9]*", "", smiles)) except Exception as e: print(e) return AllChem.ComputeGasteigerCharges( mol) totalcharge=0.0 for i, atom in enumerate( mol.GetAtoms()): totalcharge += float( atom.GetProp('_GasteigerCharge')) atom_map = rdutil.mol.atom_map( mol) inv = {val:key for key,val in atom_map.items()} #print(atom_map) scanned = [inv[i] for i in scanned] #scanned = [rdutil.mol.atom_map_invert( atom_map)[i] for i in scanned] #print(scanned) molflat = rdutil.mol.build_from_smiles( smiles) try: ret = rdutil.mol.embed_qcmol_3d( mol, qcmol) #print("EMBED WAS RET:", ret) #AllChem.GenerateDepictionMatching3DStructure(molflat, mol) AllChem.Compute2DCoords(molnoindex) except Exception as e: print( "Could not generate conformation:") print( e) return options = DrawingOptions() options.atomLabelFontSize = 110 options.atomLabelFontFace = "sans" options.dotsPerAngstrom = 400 options.bondLineWidth = 8 options.coordScale = 1 png = Draw.MolToImage(molnoindex, highlightAtoms=scanned, highlightColor=[0,.8,0], size=(500*12,500*4), fitImage=True, options=options) fig = plt.figure(figsize=(8,3.5), dpi=300, constrained_layout=True) matplotlib.rc("font", **{"size": 10}) gs = GridSpec(2, 2, figure=fig) ax1 = fig.add_subplot( gs[:2,0]) ax1.plot( scan, qmene, 'bo-', lw=1, ms=2, label="QM") ax1.plot( scan, mmene, 'ro-', lw=1, ms=2, label="MM") ax1.set_ylabel("Energy (kcal/mol)") ax1.set_xlabel("Scan value") ax1.spines['top'].set_visible(False) ax1.spines['right'].set_visible(False) ax1.legend(loc='best') ax2 = fig.add_subplot(gs[0,1]) ax2.imshow(png) ax2.axis( 'off') ax3 = fig.add_subplot(gs[1,1]) #ax3.text(.5,1.1,"{:^60s}".format(re.sub(":[1-9][0-9]*","",smiles)), fontsize=4, fontname="Monospace", ha='center') ax3.text(0,.9,"{:<16s}{:>39s}".format("QCA Dataset:", ds_name), fontsize=8, fontname="Monospace") ax3.text(0,.8,"{:<16s}{:>39s}".format("QCA Entry:", entry.split("-")[1]), fontsize=8, fontname="Monospace") ax3.text(0,.7,"{:<16s}{:>39s}".format("MM spec:", "Parsley unconstrained"), fontsize=8, fontname="Monospace") ax3.text(0,.6,"{:<16s}{:>39s}".format("MM charges:", "ANTECHAMBER AM1-BCC"), fontsize=8, fontname="Monospace") ax3.text(0,.5,"{:<16s}{:>39s}".format("Total charge", "{:6.2f}".format(totalcharge) ), fontsize=8, fontname="Monospace") ax3.text(0,.4,"{:<16s}{:>39s}".format("QM spec:", "{}/{}".format(method, basis)), fontsize=8, fontname="Monospace") ax3.text(0,.3,"{:<16s}{:>39s}".format("QM Absolute min:", "{:16.13e} au".format( qm_abs_min)), fontsize=8, fontname="Monospace") ax3.text(0,.2,"{:<16s}{:>39s}".format("QM Min point:", "{:8.2f}".format( qm_min_pt)), fontsize=8, fontname="Monospace") ax3.text(0,.1,"{:<16s}{:>39s}".format("MM Min point:", "{:8.2f}".format( mm_min_pt)), fontsize=8, fontname="Monospace") ax3.text(0,.0,"{:<16s}{:>39s}".format("OFFSB ver", "1.0"), fontsize=8, fontname="Monospace") ax3.axis('off') fig.savefig( re.sub( "\.*$", ".png", fnm)) fig = None plt.close("all") #plt.show() #plt.plot(scan, qmene, 'rx-', label="QM") #plt.plot(scan, mmene, 'bx-', label="MM") return
def visualize_molecule(smiles): figs = [] for smi in smiles: figs.append(Draw.MolToImage(MolFromSmiles(smi), size = (160, 160))) return figs
corr2 = np.corrcoef(np.log(y_test).reshape(1,-1), y_pred.reshape(1,-1))[0][1]**2 rmse = np.mean((np.log(y_test) - y_pred)**2)**0.5 print("R2 : %0.2F"%corr2) print("RMSE : %0.2F"%rmse) # Visualizing the Layers # It can be interesting to try and understand how the model "sees" the molecules. For this I’ll take an example molecule # and plot some of the outputs from the different layers. I’ve taken the compound with the lowest IC50, number 143 in the dataset. molnum = 143 molimage = np.array(list(data["molimage"][molnum:molnum+1])) mol = data["mol"][molnum] # The molecule looks like this from rdkit.Chem import Draw Draw.MolToImage(mol) # And has this “chemcepterized” image as shown below plt.imshow(molimage[0,:,:,:3]) # The first example is the third layer, which is the 1,1 convolution which feeds the 3,3 convolutional layer in tower 2. layer1_model = Model(inputs=model.input, outputs=model.layers[2].output) kernels1 = layer1_model.predict(molimage)[0] def plot_kernels(kernels): fig, axes = plt.subplots(2,3, figsize=(12,8)) for i,ax in enumerate(axes.flatten()): ax.matshow(kernels[:,:,i]) ax.set_title("Kernel %s"%i) plot_kernels(kernels1)
from rdkit import Chem from rdkit.Chem import AllChem from rdkit.Chem import Draw from Funcs import * from config import config dconfig = config() def mol_with_atom_index( mol ): atoms = mol.GetNumAtoms() for idx in range( atoms ): mol.GetAtomWithIdx( idx ).SetProp( 'molAtomMapNumber', str( mol.GetAtomWithIdx( idx ).GetIdx() ) ) return mol mol = Chem.MolFromSmiles('c1c[nH+]c2cc[nH]c2n1') data = smiles2data('c1c[nH+]c2cc[nH]c2n1',dconfig.max_atom_num,dconfig.possible_atoms,dconfig.possible_bonds,batch=False) Draw.MolToImage(mol_with_atom_index(mol)).show() print(data)