def tmp(cm, acts): import matplotlib.pyplot as plt import numpy as np plt.imshow(cm, interpolation='nearest') plt.xticks(np.arange(0, len(acts)), acts) plt.yticks(np.arange(0, len(acts)), acts)
def test_psv_dataset_tfm_segmentation_cropped(): from psv.ptdataset import PsvDataset, TFM_SEGMENTATION_CROPPED ds = PsvDataset(transform=TFM_SEGMENTATION_CROPPED) assert len(ds) == 956, "The dataset should have this many entries" mb = ds[0] image = mb['image'] mask = mb['mask'] assert isinstance(image, torch.Tensor) assert isinstance(mask, torch.Tensor) assert mask.shape[-2:] == image.shape[-2:] # Hard to test due to randomness.... PLOT=True if PLOT: from matplotlib.pylab import plt import torchvision.transforms.functional as F a = ds.get_annotation(0) plt.figure() plt.suptitle('Visualizing test_psv_dataset_tfm_segmentation_cropped, close if ok') plt.subplot(121) plt.imshow(F.to_pil_image(image)) plt.title('image') plt.subplot(122) plt.imshow(a.colors[mask.numpy()]) plt.title('mask') plt.show()
def test_psv_dataset_crop_and_pad(): import psv.ptdataset as P TFM_SEGMENTATION_CROPPED = psv.transforms.Compose( psv.transforms.ToSegmentation(), # Crop in on the facades psv.transforms.SetCropToFacades(pad=20, pad_units='percent', skip_unlabeled=True, minsize=(512, 512)), psv.transforms.ApplyCrop('image'), psv.transforms.ApplyCrop('mask'), # Resize the height to fit in the net (with some wiggle room) # THIS is the test case -- the crops will not usually fit anymore psv.transforms.Resize('image', height=400), psv.transforms.Resize('mask', height=400, interpolation=P.Image.NEAREST), # Reandomly choose a subimage psv.transforms.SetRandomCrop(512, 512), psv.transforms.ApplyCrop('image'), psv.transforms.ApplyCrop('mask', fill=24), # 24 should be unlabeled psv.transforms.DropKey('annotation'), psv.transforms.ToTensor('image'), psv.transforms.ToTensor('mask', preserve_range=True), ) ds = P.PsvDataset(transform=TFM_SEGMENTATION_CROPPED) assert len(ds) == 956, "The dataset should have this many entries" mb = ds[0] image = mb['image'] mask = mb['mask'] assert isinstance(image, torch.Tensor) assert isinstance(mask, torch.Tensor) assert mask.shape[-2:] == image.shape[-2:] # Hard to test due to randomness.... PLOT=True if PLOT: from matplotlib.pylab import plt import torchvision.transforms.functional as F a = ds.get_annotation(0) plt.figure() plt.suptitle('Visualizing test_psv_dataset_tfm_segmentation_cropped,\n' 'close if ok \n ' 'confirm boundary is marked unlabeled') plt.subplot(121) plt.imshow(F.to_pil_image(image)) plt.title('image') plt.subplot(122) plt.imshow(a.colors[mask.numpy()]) plt.title('mask') plt.show()
def plot_gallery(images, titles, h, w, n_row=3,n_col=4): plt.figure(figsize=(1.8*n_col, 2.4*n_row)) plt.subplots_adjust(bottom=0,left=.01,right=.99,top=.90,hspace=.35) for i in range(n_row * n_col): plt.subplot(n_row,n_col,i+1) plt.imshow(images[i].reshape(h,w),cmap=plt.cm.gray) plt.title(titles[i],size=12) plt.xticks(()) plt.yticks(())
def display_digit(X_data, y_data=None, i=0): """Display the Xi image, optionally with the corresponding yi label.""" plt.close('all') Xi = X_data[i] side = np.sqrt(Xi.size).astype(int) data = np.array(Xi).reshape((side, side)) plt.imshow(data, cmap='Greys', interpolation='nearest') plt.title("y = " + str(y_data[i])) plt.show()
def f(self, **kwargs): kwargs['always_apply'] = True print(kwargs) aug = self.tfms(**kwargs) # Just copy all images, next step will be for continious albus image = aug(image=self.image.copy())['image'] plt.figure(figsize=(10, 10)) plt.imshow(image) plt.axis('off') plt.show()
def plotMagnitudePhaseImage(self, image): mag = absolute(image).astype('float') phase = angle(image).astype('float') plt.subplot(211) plt.imshow(mag, cmap = cm.Greys_r) plt.axis('off') plt.subplot(212) plt.imshow(phase, cmap = cm.Greys_r) plt.axis('off') plt.show()
def Brightness_map(image, image_name): # map = (image[:, :, 0] + image[:, :, 1] + image[:, :, 2]) / 3 map = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) map = map.reshape(image.shape[0] * image.shape[1], 1) km = KMeans(n_clusters=16).fit(map) map = km.labels_.reshape(image.shape[0], image.shape[1]) plt.imshow(map / map.max(), cmap='gray') plt.axis('off') plt.savefig(image_name + '_brightness_map') np.save(image_name + '_brightness_map.npy', map)
def saveMagPhaseImage(self, image, filename): mag = absolute(image).astype('float') phase = angle(image).astype('float') plt.subplot(211) plt.imshow(mag, cmap=cm.Greys_r) plt.title('Magnitude') plt.axis('off') plt.subplot(212) plt.imshow(phase, cmap=cm.Greys_r) plt.title('Phase') plt.axis('off') plt.savefig(filename)
def texture_ID(image, map, image_name): for ch in range(3): channel = map[:, :, ch, :] channel = channel.reshape(image.shape[0] * image.shape[1], map.shape[-1]) km = KMeans(n_clusters=64).fit(channel) T_channel = km.labels_.reshape(image.shape[0], image.shape[1]) image[:, :, ch] = T_channel plt.imshow(image/image.max()) plt.axis('off') plt.savefig(image_name + '_texture_map') np.save(image_name + '_texture_map.npy', image)
def save_plot(filter_bank, name): rows , cols = filter_bank.shape[0:2] plt.figure() sub = 1 for row in range(rows): for col in range(cols): plt.subplot(rows, cols, sub) plt.imshow(filter_bank[row][col], cmap='gray') plt.axis('off') sub += 1 plt.savefig(name)
def Color_map(image, image_name): for ch in range(3): channel = image[:, :, ch] channel = channel.reshape(image.shape[0] * image.shape[1], 1) km = KMeans(n_clusters=16).fit(channel) T_channel = km.labels_.reshape(image.shape[0], image.shape[1]) image[:, :, ch] = T_channel plt.imshow(image / image.max()) plt.axis('off') plt.savefig(image_name + '_color_map') np.save(image_name + '_color_map.npy', image)
def Gradient(image_name, map_name): mask_filters = Half_disk_masks(3, 8, plot=False) map = np.load(image_name + '_' + map_name + '_map.npy') # plt.imshow(map / map.max(), cmap='gray') # plt.savefig(image_name + '_map') gradients = [] for row in range(3): for col in range(4): left_mask = mask_filters[row][2 * col] right_mask = mask_filters[row][2 * col + 1] chi_sqr_dist = map * 0 k = map.max() + 1 for bin in range(k): bin_chi_dist = map * 0 temp = np.sign(-1 * (map - bin)) + 1 g_i = cv2.filter2D(temp, -1, left_mask) h_i = cv2.filter2D(temp, -1, right_mask) num = np.square(h_i - g_i) denom = 1. / (g_i + h_i + 0.000005) bin_chi_dist = np.multiply(num, denom) # for x in range(temp.shape[0]): # for y in range(temp.shape[1]): # for z in range(temp.shape[2]): # if g_i[x][y][z] + h_i[x][y][z] != 0: # bin_chi_dist[x][y][z] = (g_i[x][y][z] - h_i[x][y][z]) ** 2 / (g_i[x][y][z] + h_i[x][y][z]) chi_sqr_dist = chi_sqr_dist + bin_chi_dist / k gradients.append(chi_sqr_dist) gradient_map = np.mean(np.array(gradients), axis=0) if map_name == 'brightness': plt.imshow(gradient_map / gradient_map.max(), cmap='gray') else: plt.imshow(gradient_map / gradient_map.max()) plt.axis('off') plt.savefig(image_name + '_' + map_name + '_gradient_map') np.save(image_name + '_' + map_name + '_gradient.npy', gradient_map)
def show_failures(self, x_test, t_test): y = self.predict(x_test) y = np.argmax(y, axis=1) if t_test.ndim != 1: t_test = np.argmax(t_test, axis=1) failures = [] for idx in range(x_test.shape[0]): if y[idx] != t_test[idx]: failures.append((x_test[idx], y[idx], t_test[idx])) for i in range(min(len(failures), 60)): img, y, _ = failures[i] if (i % 10 == 0): print() print(y, end=", ") img = img.reshape(28, 28) plt.subplot(6, 10, i + 1) plt.imshow(img, cmap='gray') print() plt.show()
def visualize(img, G, vertices): plt.imshow(img, cmap='gray') # draw edges by pts for (s, e) in G.edges(): vals = flatten([[v] for v in G[s][e].values()]) for val in vals: ps = val.get('pts', []) plt.plot(ps[:, 1], ps[:, 0], 'green') # draw node by o node, nodes = G.node(), G.nodes # deg = G.degree # ps = np.array([node[i]['o'] for i in nodes]) ps = np.array(vertices) plt.plot(ps[:, 1], ps[:, 0], 'r.') # title and show plt.title('Build Graph') plt.show()
def augmentation_visualize_and_save(config, images, images_names, path, times: int = 2): """ Visualization of image enhancements. :param config: configuration from yaml file. :param images: images to be augmented. :param images_names: corresponding names of the images. :param path: the root where the augmented pictures will be saved. :param times: how many times each image getting augmented. :return: """ rows = len(images) cols = times + 1 for (index, image), name in zip(enumerate(images), images_names): plt.subplot(rows, cols, index * cols + 1) plt.axis('off') plt.title(name) _image = bgr2rgb_using_opencv(image) plt.imshow(_image) for col in range(1, cols): plt.subplot(rows, cols, index * cols + col + 1) plt.axis('off') plt.title("Augmented NO. " + str(col)) # augment image augmented_image = augment_image_using_imgaug(_image, config) plt.imshow(augmented_image) # Save the full figure isExists = os.path.exists(path) if not isExists: os.makedirs(path) now_time = datetime.datetime.now().strftime('%Y%m%d_%H%M%S') savefig(os.path.join(path, "%s_Comp.png" % now_time), dpi=600) # Clear the current figure plt.clf() plt.cla() plt.close()
def pb_lite(Sobel, Canny, image_name): B = np.load(image_name + '_brightness_gradient.npy') T = np.load(image_name + '_texture_gradient.npy') C = np.load(image_name + '_color_gradient.npy') B / B.max() T / T.max() C / C.max() w1 = 0.5 w2 = 0.5 features = (B + rgb2gray(T) + rgb2gray(C))/3 average = w1 * Canny + w2 * Sobel pb_edge = features * rgb2gray(average) plt.imshow(pb_edge, cmap='gray') plt.savefig(image_name + '_pb_edge') s = 1
def visualize(img, G, vertices, fn): plt.imshow(img) # draw edges by pts for (s, e) in G.edges(): vals = flatten([[v] for v in G[s][e].values()]) for val in vals: ps = val.get('pts', []) plt.plot(ps[:, 1], ps[:, 0], 'green') # draw node by o #node, nodes = G.node(), G.nodes # deg = G.degree # ps = np.array([node[i]['o'] for i in nodes]) ps = np.array(vertices) plt.plot(ps[:, 1], ps[:, 0], 'r.') # title and show img_name = fn.split('.')[0] + ".png" map_name = fn.split('.')[0] + "_roads.png" io.imsave(img_name, img) plt.savefig(map_name)
def reduce_opacity(image, opacity): assert opacity >= 0 and opacity <= 1 if image.mode != 'RGBA': image = image.convert('RGBA') else: image = image.copy() alpha = image.split() for i in alpha: plt.imshow(i) plt.show() # print type(alpha) # alpha = ImageEnhance.Brightness(alpha).enhance(opacity) # print alpha # image = image.putalpha(alpha) # print image # plt.imshow(image) # plt.show() # image.save("hahaha.JPG") image.getpixel((0, 0)) return image
def plotting(self, pressurelattice, invasionlattice, pressure, number_of_clusters): from matplotlib.pylab import plt #Plotting the invasionlattice plt.figure(2) plt.imshow(invasionlattice, cmap='Greys', interpolation='nearest') plt.title("Invasion lattice") plt.colorbar() plt.savefig(self.pathsimulation + "invasionlattice.png", bbox_inches="tight") plt.close() #plotting the pressure plt.figure(5) plt.plot(pressure) plt.xlabel('Time') plt.ylabel('Pressure') plt.title('P(t)') plt.savefig(self.pathsimulation + "pressure.png", bbox_inches="tight") plt.close() #plotting the clusterlattice plt.figure(6) plt.imshow(self.lw, interpolation='nearest') plt.title("Clusterlattice") plt.colorbar() plt.savefig(self.pathsimulation + "clusterlattice.png", bbox_inches="tight") plt.close() #Temporal diagram plt.figure(7) plt.imshow(self.temporalplot, interpolation='nearest') plt.title('Temporal diagram') plt.colorbar() plt.savefig(self.pathsimulation + "temporal.png", bbox_inches="tight") plt.close() #Plotting pressure distribution in the cell. plt.figure(3) plt.hist(pressurelattice.ravel(), bins=30, fc='k', ec='k') plt.savefig(self.pathsimulation + "pressuredistribution.png", bbox_inches="tight") plt.close() #Plotting the number of clusters as a function of interation. plt.figure(1) plt.plot(number_of_clusters) plt.xlabel('Iteration number/time') plt.ylabel('Number of clusters') plt.title('Number_of_cluster(t)') plt.savefig(self.pathsimulation + "clusterN.png", bbox_inches="tight") plt.close()
def plotting(self,pressurelattice,invasionlattice,pressure,number_of_clusters): from matplotlib.pylab import plt #Plotting the invasionlattice plt.figure(2) plt.imshow(invasionlattice, cmap='Greys',interpolation='nearest') plt.title("Invasion lattice") plt.colorbar() plt.savefig(self.pathsimulation + "invasionlattice.png", bbox_inches="tight") plt.close() #plotting the pressure plt.figure(5) plt.plot(pressure) plt.xlabel('Time') plt.ylabel('Pressure') plt.title('P(t)') plt.savefig(self.pathsimulation +"pressure.png", bbox_inches="tight") plt.close() #plotting the clusterlattice plt.figure(6) plt.imshow(self.lw, interpolation='nearest') plt.title("Clusterlattice") plt.colorbar() plt.savefig(self.pathsimulation +"clusterlattice.png", bbox_inches="tight") plt.close() #Temporal diagram plt.figure(7) plt.imshow(self.temporalplot,interpolation='nearest') plt.title('Temporal diagram') plt.colorbar() plt.savefig(self.pathsimulation +"temporal.png", bbox_inches="tight") plt.close() #Plotting pressure distribution in the cell. plt.figure(3) plt.hist(pressurelattice.ravel(), bins=30, fc='k', ec='k') plt.savefig(self.pathsimulation +"pressuredistribution.png", bbox_inches="tight") plt.close() #Plotting the number of clusters as a function of interation. plt.figure(1) plt.plot(number_of_clusters) plt.xlabel('Iteration number/time') plt.ylabel('Number of clusters') plt.title('Number_of_cluster(t)') plt.savefig(self.pathsimulation +"clusterN.png", bbox_inches="tight") plt.close()
def saveWaterFatImage(self, filename): mag = np.absolute(self.water).astype('float') phase = np.angle(self.water).astype('float') mag2 = np.absolute(self.fat).astype('float') phase2 = np.angle(self.fat).astype('float') plt.subplot(221) plt.imshow(mag, cmap=cm.Greys_r) plt.title('Water Magnitude') plt.axis('off') plt.subplot(222) plt.imshow(phase, cmap=cm.Greys_r) plt.title('Water Phase') plt.axis('off') plt.subplot(223) plt.imshow(mag2, cmap=cm.Greys_r) plt.title('Fat Magnitude') plt.axis('off') plt.subplot(224) plt.imshow(phase2, cmap=cm.Greys_r) plt.title('Fat Phase') plt.axis('off') plt.show()
def saveMagPhaseImage2(self, image1, image2, filename): mag = absolute(image1).astype('float') phase = angle(image1).astype('float') mag2 = absolute(image2).astype('float') phase2 = angle(image2).astype('float') plt.subplot(221) plt.imshow(mag, cmap=cm.Greys_r) plt.title('Magnitude') plt.axis('off') plt.subplot(222) plt.imshow(phase, cmap=cm.Greys_r) plt.title('Phase') plt.axis('off') plt.subplot(223) plt.imshow(mag2, cmap=cm.Greys_r) plt.title('Magnitude') plt.axis('off') plt.subplot(224) plt.imshow(phase2, cmap=cm.Greys_r) plt.title('Phase') plt.axis('off') plt.savefig(filename)
def show_img(self): """将图像展示出来,在测试的时候很需要""" plt.imshow(self.__img_mat) plt.show()
# import Dataset from keras.datasets import mnist ## Preprosessing the Dataset # Load Data (x_train, y_train), (x_test, y_test) = mnist.load_data() # parameters that describe the input data img_x = x_train.shape[1] img_y = x_train.shape[2] input_shape = (img_x, img_y, 1) num_classes = 10 # visualise data plt.imshow(x_train[0]) # explore the dataset print(y_train[1:10]) # convert data into a binary form y_train = np_utils.to_categorical(y_train, 10) # reshape data into a 4d tensor x_train = x_train.reshape(x_train.shape[0], img_x, img_y, 1) x_test = x_test.reshape(x_test.shape[0], img_x, img_y, 1) # change data type x_train = x_train.astype('float32') x_test = x_test.astype('float32')
def showTissueMask(self): #plt.imshow(self.mask) plt.imshow(self.mask, cmap = cm.Greys_r) plt.show()
""" import pandas as pd from pathlib import Path import cv2 from matplotlib.pylab import plt import numpy as np if __name__ == '__main__': root_dir = '/Users/avelinojaver/OneDrive - Nexus365/heba/WoundHealing/raw_separate_channels/' root_dir = Path(root_dir) GT_noisy = pd.read_excel(root_dir / 'groundTruthForAvelino_30.xlsx') img_ids = pd.read_excel(root_dir / 'imageIDsForAvelino_30.xlsx') #%% for _, row in img_ids.iterrows(): img_id = row['ImageNumber'] coords = GT_noisy[GT_noisy['ImageNumber'] == img_id] img_path = root_dir / 'nuclei' / row['Nuclear'] if not img_path.exists(): continue img = cv2.imread(str(img_path), -1) xx, yy = coords['Location_Center_X'], coords['Location_Center_Y'] plt.figure() plt.imshow(np.log(img + 1), 'gray') plt.plot(xx, yy, '.r')
for key in ('train_label', 'test_label'): dataset[key] = _load_label(files[key]) if normalize: for key in ('train_img', 'test_img'): dataset[key] = dataset[key].astype(np.float32) dataset[key] /= 255.0 if one_hot_label: for key in ('train_label', 'test_label'): dataset[key] = _change_one_hot_label(dataset[key]) if not flatten: dataset[key] = _change_one_hot_label(dataset[key]) return ((dataset['train_img'], dataset['train_label']), (dataset['test_img'], dataset['test_label'])) from matplotlib.pylab import plt (x_train, y_train), (x_test, y_test) = load_mnist() for i in range(10): img = x_train[i] label = np.argmax(y_train[i]) print(label, end=", ") img = img.reshape(28, 28) plt.subplot(1, 10, i + 1) plt.imshow(img) print() plt.show()
d.r2c_plan = d.cufft.plan( fft_extent, 'cufft_r2c') #cuFFT r2c plan single precision (double = cufft_d2z) d.c2c_plan = d.cufft.plan( fft_extent, 'cufft_c2c') #cuFFT c2c plan single precision (double = cufft_z2z) d.gray = d.malloc( shape=gray.shape, dtype=gray.dtype, fill=gray ) #Allocate space for input data and set gray array as default d.r2c_res = d.malloc((ny, (nx // 2 + 1)), 'c8') #Allocate space for r2c result d.r2c_full = d.malloc(gray.shape, 'c8', 1 + 0j) #Allocate space for full rest d.c2c_res = d.malloc(gray.shape, 'c8') #Allocate space for c2c result d.cufft.r2c(d.r2c_plan, d.gray, d.r2c_res) #r2c fft d.cufft.add_redundants(d.r2c_plan, d.r2c_res, d.r2c_full) #Fills in the redundant values d.cufft.c2c(d.c2c_plan, d.r2c_full, d.c2c_res, 'cufft_inverse') #c2c fft d.cublas.scal(1. / gray.size, d.c2c_res) #Scale c2c result using cuBLAS result = d.c2c_res.to_host() #Copy scaled c2c result back to host ## Using the device calls are all synchronous so the result will be ready ## by the time numpy operates on it. fig = plt.figure() plt.imshow(result.real) plt.colorbar() plt.show()
text = '' for i in range(0, len(f)): with open('D:\\视频\\tim专属文件\\yellow\\' + f[i], encoding='ansi') as x: for line in x.readlines(): line = line.strip('\n') line = line.replace('<br /><br /> ', '') line = line.replace('<br /> ', '') line = line.replace( '<br /><br /><br /><br /><br /><br /><br /><br />', '') line = line.replace('<BR> ', '') line = line.replace('<br /><br />', '') line = line.replace('<BR>', '') line = line.replace('nbsp', '') line = line.replace('br', '') print(0) text += ' '.join(jieba.cut(line)) a = Image.open('C:\\Users\\2271057973\\Pictures\\Saved Pictures\\太极.png') mask = np.array(a) wordcloud = WordCloud(font_path='./font/simhei.ttf', background_color='white', mask=mask, max_font_size=120, min_font_size=5).generate(text) plt.imshow(wordcloud) plt.axis('off') plt.show() wordcloud.to_file('C:\\Users\\2271057973\\Desktop\\2.png')
import matplotlib matplotlib.use('Agg') from matplotlib.pylab import plt from skimage.io import imread, imsave whole_set = '2.png' out_path = '22.png' data = imread(whole_set) plt.imshow(data, cmap=plt.cm.seismic) plt.axis('off') plt.savefig(out_path, dpi=300)