def generate_matrix_visualization(known_words, bookmark_words): m = [] for i in range(0,100): m.append([]) for j in range (0, 100): if (i*100+j) in bookmark_words: m[i].append(0.65) elif (i*100+j) in known_words: m[i].append(0.4) else: m[i].append(0.2) m.reverse() # we need this next line to scale the color scheme m[0][0]=0 matrix = numpy.matrix(m) fig = plt.figure() ax = fig.add_subplot(1,1,1) ax.set_aspect('equal') plt.imshow(matrix, interpolation='none') plt.set_cmap('hot') plt.colorbar() plt.show()
def PlotMtxError(Corr_w): max_val = 1 min_val = -0.1 AvCorr = np.sum(Corr_w, axis=0) dCorr = Corr_w - AvCorr errCorr = np.log10(np.sqrt(np.einsum("i...,i...", dCorr, dCorr)) / np.absolute(AvCorr) / np.sqrt(Corr_w.shape[0])) # print errCorr.shape # print errCorr plt.rcParams.update({"font.size": 6, "font.weight": "bold"}) for i in xrange(errCorr.shape[0]): plt.subplot(2, 7, i + 1) plt.title("SITE " + str(i + 1) + ":: \nHistogram of errors in corr. mtx.") plt.hist(errCorr[0, :, :].flatten(), 256, range=(min_val, max_val)) plt.xlabel("log_10(sigma)") plt.ylabel("Count") plt.subplot(2, 7, i + 7 + 1) plt.imshow(errCorr[0, :, :], vmin=min_val, vmax=max_val) cbar = plt.colorbar(shrink=0.25, aspect=40) cbar.set_label("log_10(sigma)") plt.set_cmap("gist_yarg") plt.title("SITE " + str(i + 1) + ":: \nError in corr. matx. values") plt.xlabel("Site i") plt.ylabel("Site j") plt.show()
def display_data(x, **kwargs): plt.set_cmap('gray') nrows, ncols = x.shape example_width = int(kwargs.get('example_width', round(math.sqrt(ncols)))) example_height = int(ncols / example_width) display_rows = int(math.floor(math.sqrt(nrows))) display_cols = int(math.ceil(nrows/display_rows)) pad = 1 display_array = -np.ones( (pad + display_rows *(example_height + pad), pad + display_cols * (example_width + pad)) ); curr_ex = 0; for j in range(0, display_rows): for i in range(0, display_cols): if (curr_ex >= nrows): break; max_val = np.max(np.abs(x[curr_ex, :])) x_splice_start = pad + j*(example_height + pad) y_splice_start = pad + i*(example_width + pad) display_array[x_splice_start:(x_splice_start+example_height), y_splice_start:(y_splice_start+example_width)] = \ np.reshape(x[curr_ex,:], (example_height, example_width)) / max_val curr_ex += 1 if (curr_ex >= nrows): break plt.imshow(display_array) plt.show()
def histogram_plot(): global image, extension, image_count, log_path, max_image_count, view_value, plot_number if (image.max() != 0): if ( plot_number == 121 ): #because this function will be called two times in display_original() fig.clf() fig.add_subplot(plot_number) #dynamically changing the grid plot im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') image_histogram = np.zeros(256) #contains histogram of image #create the image histogram for i in range(image.shape[0]): for j in range(image.shape[1]): intensity_value = int( abs(image[i][j]) ) #abs() is taken in case of negative image intensities image_histogram[ intensity_value] = image_histogram[intensity_value] + 1 fig.add_subplot(plot_number + 1) plt.stem(np.arange(256), image_histogram, markerfmt=' ') #plots a stem image of histogram canvas.draw() view_value = "100" #set the callback so that the display image option is enabled var2.set(view_value) else: messagebox.showerror("Error", "Please load an image first.")
def plot_decision_surface(axes, clusters, X, Y=None): import matplotlib.pylab as pylab import numpy as np def kmeans_predict(clusters, X): from ..core import distance dist_m = distance.minkowski_dist(clusters, X) print 'dist_m:', dist_m.shape pred = np.argmin(dist_m, axis=0) print 'pred:', pred.shape return pred # step size in the mesh h = (np.max(X, axis=0) - np.min(X, axis=0)) / 100.0 # create a mesh to plot in x_min = np.min(X, axis=0) - 1 x_max = np.max(X, axis=0) + 1 xx, yy = np.meshgrid(np.arange(x_min[0], x_max[0], h[0]), np.arange(x_min[1], x_max[1], h[1])) Z = kmeans_predict(clusters, np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) pylab.set_cmap(pylab.cm.Paired) pylab.axes(axes) pylab.contourf(xx, yy, Z, cmap=pylab.cm.Paired) pylab.xlim(np.min(xx), np.max(xx)) pylab.ylim(np.min(yy), np.max(yy)) #pylab.axis('off') # Plot also the training points if Y is not None: pylab.scatter(X[:,0], X[:,1], c=Y) else: pylab.scatter(X[:,0], X[:,1]) pylab.scatter(clusters[:,0], clusters[:,1], s=200, marker='x', color='white')
def draw(self): plt.imshow(self._original_values.T, interpolation='none', origin='lower', extent=[self._origin[X], self._origin[X] + self._values.shape[0] * self._resolution, self._origin[Y], self._origin[Y] + self._values.shape[1] * self._resolution]) plt.set_cmap('gray_r')
def show_msk3D(self, what='amplitude'): """Show the amplitude/phase of the mask in 3D plot. :Args: - what : string= (amplitude/phase) to choose what to plot. .. Note:: This function needs matplotlib package :Returns: - none. """ if what == 'amplitude': msk = np.abs(self.Msk) elif what == 'phase': msk = np.angle(self.Msk) else: print('"what" must be "amplitude" or "phase"') sys.exit(1) fig = plt.figure() ax = fig.gca(projection='3d') X, Y = np.meshgrid(self.grid_x, self.grid_y) #we create a meshgrid for the plot #surf = ax.plot_surface(X, Y, np.abs(msk2), rstride=1,cmap=cm.jet ,cstride=1, linewidth=0) surf = ax.plot_surface(X, Y, msk, rstride=1, cstride=1, linewidth=0) plt.set_cmap('hot')
def setThreshold(fname, aviProps, bg, ths, morphDiameter): cap = cv2.VideoCapture(fname) sPlot = [221,222,223,224] nFrames = aviProps[6] frames = np.random.random_integers(int(nFrames/2), nFrames, 4) fig = plt.figure() cmap = colormap.gray cmap.set_over('r') for f in np.arange(0,4): cap.set(1,frames[f]) ret, frame = cap.read() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) bgSubGray = subtractBg(gray, bg) thsGray = applyThreshold(bgSubGray, ths) thsGray = erode(thsGray, morphDiameter) thsGray = dilate(thsGray, morphDiameter) gray[gray==255] = 254 gray[thsGray==255] = 255 cOm = ndimage.measurements.center_of_mass(thsGray) #if tFrame.sum()/255 < nestThreshold: cOm = nestPosition fig.add_subplot(sPlot[f]) plt.imshow(gray, vmax=254) plt.set_cmap(cmap) plt.plot(cOm[1],cOm[0], 'o') cap.release() plt.show() return ths, morphDiameter
def histogram_equalize(): global image, extension, image_count, log_path, max_image_count, max_image_count if (image.max() != 0): image = fun.histeq_im( image) #call the function with the current image in canvas ### #Some general steps being followed in a image processing functions: #(1)clear the canvas #(2)draw the image on the canvas #(3)increment the image count as this is a new image and store this new image based on image_count to log_folder #(4)increment max_image_count which will be used for redo and undo functionalities #(5)remove_files() will remove all the images with count greater than the current image_count in the log_folder. #this is required in case I have 5 images say, 1,2,3,4,5 I undo and go to 2. Then I do a processing task. #then the new processed image will be stored as 3, and 4,5 will be removed from log_folder. ### fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw() max_image_count = image_count + 1 image_count = image_count + 1 var.set(image_count) #store the image in log_folder current_file = log_path + "\\" + str(image_count) + "." + str( extension) cv2.imwrite(current_file, image) remove_files() else: messagebox.showerror("Error", "Please load an image first.")
def load_image(): global image, script_path, log_path, image_count, extension, max_image_count, view_value script_path = os.path.dirname(os.path.realpath(__file__)) log_path = script_path + "\log_folder" file_name = filedialog.askopenfilename( ) #opens up the file_system for user to select a file. returns file path #print(file_name) #prints the entire file path #print(os.path.basename(file_name)) #prints only the actual file name with extension if (not (file_name == "")): #in case user clicked on cancel or cross button if os.path.exists( log_path ): #if the log_folder already exists then delete it and create a new one shutil.rmtree(log_path, ignore_errors=True) #remove the log_folder os.makedirs(log_path) #image_count=0 else: os.makedirs(log_path) #image_count=0 image_count = 0 #as the image was just loaded max_image_count = 0 #as no processing has yet happened on original image view_value = "000" #initializing the values var.set( image_count ) #used to call the callback functions so as to set the proper visibility for the menu options var2.set(view_value) fig.clf() #clear the current canvas fig.add_subplot(111) #makes a 1x1 image plot #some validations in case a 'gif' file or some other non-image file was selected try: name, extension = os.path.basename(file_name).split(".") if (extension == "gif"): raise exception image = scipy.ndimage.imread( file_name, mode='L') #read the image into an numpy.ndarray im = plt.imshow( image, vmin=0, vmax=255 ) #vmin and vmax are required to specify the gray scales. plt.set_cmap('gray') #setting the colormap canvas.draw() #displaying the image on the canvas #increment the image_count and store the current image in the log_folder. #will be required for undo and redo operations. image_count = image_count + 1 var.set(image_count) #save current image in log_folder as 1.extension eg:1.jpg or 1.png current_file = log_path + "\\" + str(image_count) + "." + str( extension) cv2.imwrite( current_file, image ) #cv2.imwrite() is better compared to Image.fromarray() as it doesn't manipulate the image. #selected cv2 for the file write after I found some images getting manipulated by the rescaling required for Image.fromarray(). except Exception as e: messagebox.showerror( title="Can't identify file!!!!", message="This file format is currently not supported")
def visualize_attention_map_per_token(image, tokens, attention_map, pixel_upscale, smooth_attention=True, sigma=None, **kwargs): """ :param image: PIL image :param tokens: list of strings (each being a token) :param attention_map: (np.array) for each token an attention map over the image :param pixel_upscale: re-scale the KxK input attention_map by this amount (in pixels) :param smooth_attention: (opt, boolean) to smooth the displayed attention values :param sigma: (opt, float) control ammount of smoothing :param kwargs: common parameters for matplotlib {'figsize', 'fontsize'} :return: nothing """ figsize = kwargs.pop('figsize', 20) fontsize = kwargs.pop('fontsize', 14) plt.figure(figsize=(figsize, figsize)) n_tokens, h, w = attention_map.shape if n_tokens != len(tokens): raise ValueError('Each token is expected to have an attention map.') if h != w: warnings.warn('code has not been tested') new_im_size = [pixel_upscale * h, pixel_upscale * w] image = image.resize(new_im_size, Image.LANCZOS) for t in range(n_tokens): plt.subplot(np.ceil(n_tokens / 5.), 5, t + 1) plt.text(0, 1, '%s' % (tokens[t]), color='black', backgroundcolor='white', fontsize=fontsize) plt.imshow(image) current_alpha = attention_map[t][:] if smooth_attention: alpha = skimage.transform.pyramid_expand(current_alpha, upscale=pixel_upscale, sigma=sigma, multichannel=False) else: alpha = skimage.transform.resize(current_alpha, new_im_size) if t == 0: plt.imshow(alpha, alpha=0) else: plt.imshow(alpha, alpha=0.8) plt.set_cmap(cm.Greys_r) plt.axis('off') plt.show()
def ShowMatrix(X, title=''): plt.figure() plt.imshow(X, interpolation='nearest',vmax=5,vmin=0) plt.colorbar() plt.set_cmap('jet') plt.xlabel('profiles') plt.ylabel('features') plt.title(title) plt.show()
def make_image(data, outputname, size=(1, 1), dpi=100): fig = plt.figure() fig.set_size_inches(size) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() fig.add_axes(ax) plt.set_cmap('gray') ax.imshow(data, aspect='equal', interpolation='nearest') plt.savefig(outputname, dpi=dpi) plt.close()
def sitk_show(img, title=None, margin=0.05, dpi=40, cmap="gray"): nda = sitk.GetArrayFromImage(img) spacing = img.GetSpacing() figsize = (1 + margin) * nda.shape[0] / dpi, (1 + margin) * nda.shape[1] / dpi extent = (0, nda.shape[1]*spacing[1], nda.shape[0]*spacing[0], 0) fig = plt.figure(figsize=figsize, dpi=dpi) ax = fig.add_axes([margin, margin, 1 - 2*margin, 1 - 2*margin]) plt.set_cmap(cmap) ax.imshow(nda,extent=extent,interpolation=None) if title: plt.title(title)
def undo_all(): global image, extension, image_count, log_path image_count = 1 #set callback to affect the views accordingly var.set(image_count) first_file = log_path + "\\" + str(image_count) + "." + str(extension) image = scipy.ndimage.imread(first_file, mode='L') fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw()
def redo_all(): global image, extension, image_count, log_path image_count = max_image_count var.set(image_count) last_file = log_path + "\\" + str(image_count) + "." + str(extension) image = scipy.ndimage.imread(last_file, mode='L') fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw()
def butterworth_sharpen(): global image, extension, image_count, log_path, max_image_count, lab_5_data, lab_6_data, lab_7_data, error_flag_1, error_flag_2, error_flag_3, butter_width, butter_order, butter_a, popup_true if (image.max() != 0): #ask the user if he wishes to use the default parameter values answer = messagebox.askyesno( "Settings", "Do you want to use default settings?\n" + "width=3, order=2, a=0.5") if (answer == True): image = fun.butterworth_highpass_filter(image, 3, 2, 0.5) #general steps fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw() max_image_count = image_count + 1 image_count = image_count + 1 var.set(image_count) #store the image in log_folder current_file = log_path + "\\" + str(image_count) + "." + str( extension) cv2.imwrite(current_file, image) remove_files() else: ###initialize the variables before calling popup lab_5_data.set("") lab_6_data.set("") lab_7_data.set("") error_flag_1 = 0 error_flag_2 = 0 error_flag_3 = 0 butter_width = "" butter_order = "" butter_a = "" popup_true = 0 ### popupmsg() else: messagebox.showerror("Error", "Please load an image first.")
def diff_images(fname1, fname2, output="diff.png"): """ Creates a file `output` that represents a diff of two input images `fname1` and `fname`. If these are .pdf, they will be first converted to .png. Example: >>> utils.diff_images("examples/test1.pdf", "examples/test3.pdf", output="diff.png") >>> os.system("ic diff.png") """ import numpy as np import matplotlib.pylab as plt conversion_cmd = "gs -q -sDEVICE=pngalpha -o {outname} -sDEVICE=pngalpha -dUseCropBox -r{density} {inname}" # conversion_cmd = "convert -density {density} -trim {inname} -fuzz 1% {outname}" new_fnames = [] for fname in [fname1, fname2]: if fname.rsplit(".", 1)[-1] == "pdf": fname_in = fname fname_out = fname.replace(".pdf", ".png") os.system( conversion_cmd.format(density=75, inname=fname_in, outname=fname_out)) new_fnames.append(fname_out) if len(new_fnames) == 2: fname1, fname2 = new_fnames # img1 = plt.imread(fname1)[::2,::2] # downsample by factor of 2 # img2 = plt.imread(fname2)[::2,::2] img1 = plt.imread(fname1) img2 = plt.imread(fname2) # Calculate the absolute difference on each channel separately error_r = np.fabs(np.subtract(img2[:, :, 0], img1[:, :, 0])) error_g = np.fabs(np.subtract(img2[:, :, 1], img1[:, :, 1])) error_b = np.fabs(np.subtract(img2[:, :, 2], img1[:, :, 2])) lum_img = np.sqrt(error_r * error_r + error_g + error_g + error_b * error_b) / np.sqrt(3) # # # Calculate the maximum error for each pixel # lum_img = np.maximum(np.maximum(error_r, error_g), error_b) # plt.set_cmap('Spectral') plt.set_cmap('gray') plt.imsave(output, -lum_img)
def processLyrics(lyrics, name): arr1 = lyrics.split() length = len(arr1) song = [[0 for x in range(length)] for y in range(length)] for i in range(length): for j in range(length): if arr1[i] == arr1[j]: song[i][j] = colorIntensity(arr1[i]) song[j][i] = colorIntensity(arr1[i]) fig, ax0 = plt.subplots(1) plt.set_cmap(colorspace) plt.gca().invert_yaxis() ax0.pcolor(song) ax0.set_title(name) fig.tight_layout() plt.savefig(dirname + '/graphs/' + name[:-4] + '.png') plt.close()
def undo_last(): global image, extension, image_count, log_path image_count = image_count - 1 #image_count always holds the count of my current image displayed in canvas var.set( image_count ) #set callback to change the views of options that are affected by image_count change accordingly if (image_count == 1): #image_count=image_count+1 #messagebox.showwarning("Original image", "Can't undo further.") editmenu.entryconfigure('undo last', state="disabled") prev_file = log_path + "\\" + str(image_count) + "." + str(extension) image = scipy.ndimage.imread(prev_file, mode='L') fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw()
def plot_decision_surface(axes, clf, X, Y): import matplotlib.pylab as pylab import numpy as np # step size in the mesh h = (np.max(X, axis=0) - np.min(X, axis=0)) / 100.0 # create a mesh to plot in x_min = np.min(X, axis=0) - 1 x_max = np.max(X, axis=0) + 1 xx, yy = np.meshgrid(np.arange(x_min[0], x_max[0], h[0]), np.arange(x_min[1], x_max[1], h[1])) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) pylab.set_cmap(pylab.cm.Paired) pylab.axes(axes) pylab.contourf(xx, yy, Z, cmap=pylab.cm.Paired) #pylab.axis('off') # Plot also the training points pylab.scatter(X[:,0], X[:,1], c=Y)
def fourier_phase(): global image, extension, image_count, log_path, max_image_count, view_value, plot_number if (image.max() != 0): if ( plot_number == 121 ): #because this function will be called two times in display_original() fig.clf() fig.add_subplot(plot_number) #dynamically change the grid plot im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') phase_image = fun.find_fft_phase(image) fig.add_subplot(plot_number + 1) im = plt.imshow(phase_image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw() view_value = "001" #set the callback so that the display image option is enabled var2.set(view_value) else: messagebox.showerror("Error", "Please load an image first.")
def draw(self): plt.imshow( self._original_values.T, interpolation='none', origin='lower', extent=[ self._origin[X], self._origin[X] + self._values.shape[0] * self._resolution, self._origin[Y], self._origin[Y] + self._values.shape[1] * self._resolution ]) # # for debug # for i in range(self._values.shape[0]): # for j in range(self._values.shape[1]): # if np.random.rand() < 0.4: # pos = self.get_position(i, j) # if not self.is_free(pos): # plt.scatter(pos[0], pos[1], s=3, marker='o', color='red') # print(i) plt.set_cmap('gray_r')
def plot_gmm(axes, classifier, clusters, X, Y=None): import matplotlib.pylab as pl import numpy as np def make_ellipses(gmm, ax, cm): global pca import matplotlib as mpl #for n, color in enumerate('rgb'): for n in xrange(gmm.means.shape[0]): var = gmm.covars[n][np.identity(gmm.means.shape[1], dtype=bool)] v = pca.transform(var) #v, w = np.linalg.eigh(gmm.covars[n][:2, :2]) #u = w[0] / np.linalg.norm(w[0]) #angle = np.arctan(u[1] / u[0]) #angle = 180 * angle / np.pi # convert to degrees #v *= 9 #v /= 10.0 means = pca.transform(gmm.means[n, :]) ell = mpl.patches.Ellipse(means, v[0], v[1], 0, color=cm(n), alpha=0.5) ell.set_clip_box(ax.bbox) ell.set_alpha(0.5) ax.add_artist(ell) cm = pl.cm.Paired pl.set_cmap(cm) h = pl.subplot(1, 1, 1) make_ellipses(classifier, h, cm) # Plot also the training points if Y is not None: pl.scatter(X[:,0], X[:,1], c=Y) else: pl.scatter(X[:,0], X[:,1]) pl.xticks(()) pl.yticks(()) pl.scatter(clusters[:,0], clusters[:,1], s=200, marker='x', color='black')
def gamma_correct(): global image, extension, image_count, log_path, max_image_count, max_image_count if (image.max() != 0): #ask for a user defined gamma value gamma = simpledialog.askfloat("Input", "Enter gamma value:", parent=root, minvalue=0.0) if ( gamma is not None ): #None will be when user clicks cancel. in that case no processing is done. image_bkp = fun.gamma_im(image, gamma) if ( image_bkp is None ): #If user enters a high value of gamma then can give exception. Function returns None in case of such exception messagebox.showerror("Error", "Please use a lower value of gamma.") else: image = image_bkp #general steps fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw() max_image_count = image_count + 1 image_count = image_count + 1 var.set(image_count) #store the image in log_folder current_file = log_path + "\\" + str(image_count) + "." + str( extension) cv2.imwrite(current_file, image) remove_files() else: messagebox.showerror("Error", "Please load an image first.")
def log_transform(): global image, extension, image_count, log_path, max_image_count if (image.max() != 0): image = fun.log_trans_im(image) #general steps fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw() max_image_count = image_count + 1 image_count = image_count + 1 var.set(image_count) #store the image in log_folder current_file = log_path + "\\" + str(image_count) + "." + str( extension) cv2.imwrite(current_file, image) remove_files() else: messagebox.showerror("Error", "Please load an image first.")
def scaling_plot(df, zcol, title, zdas=None, xcol='numIsilonNodes', xlabel=None, ycol='numPhysicalComputeNodes', ylabel=None): if xlabel == None: xlabel = xcol if ylabel == None: ylabel = ycol x = df[xcol].values y = df[ycol].values z = df[zcol].values # Set up a regular grid of interpolation points xi, yi = np.linspace(x.min(), x.max(), 100), np.linspace(y.min(), y.max(), 100) xi, yi = np.meshgrid(xi, yi) # Interpolate zi = scipy.interpolate.griddata((x, y), z, (xi, yi), method='cubic') fig = plt.figure(title) fig.clf() plt.set_cmap(cm.jet) plt.imshow(zi, vmin=z.min(), vmax=z.max(), origin='lower', extent=[x.min(), x.max(), y.min(), y.max()], aspect='auto') # Draw circles on actual measurement points plt.scatter(x, y, c=z) plt.colorbar() CS = plt.contour(xi, yi, zi, colors='k') plt.clabel(CS, inline=1, fontsize=10, fmt='%1.0f') if zdas is not None: dasNodes = np.arange(df.numPhysicalComputeNodes.min(), 2 * df.numPhysicalComputeNodes.max() + 1) dasZ = zdas * dasNodes CS = plt.contour(xi, yi, zi, colors='k', linestyles='dashed', levels=dasZ) fmtdict = {x[1]: 'DAS ' + str(int(x[0])) for x in zip(dasNodes, dasZ)} plt.clabel(CS, inline=1, fontsize=10, fmt=fmtdict) plt.title(title) plt.ylabel(ylabel) plt.xlabel(xlabel) plt.show()
def popup_return(): global image, extension, image_count, log_path, max_image_count, lab_5_data, lab_6_data, lab_7_data, error_flag_1, error_flag_2, error_flag_3, butter_width, butter_order, butter_a, popup_true #print(butter_width) #print(butter_order) #print(butter_a) image = fun.butterworth_highpass_filter(image, butter_width, butter_order, butter_a) #general steps fig.clf() fig.add_subplot(111) im = plt.imshow(image, vmin=0, vmax=255) plt.set_cmap('gray') canvas.draw() max_image_count = image_count + 1 image_count = image_count + 1 var.set(image_count) #store the image in log_folder current_file = log_path + "\\" + str(image_count) + "." + str(extension) cv2.imwrite(current_file, image) remove_files()
def main(): hemi = 1 prop = 0.5 varthresh = 0 savefig = 1 # file i/o file_base = 'lgnROI{}_comVoxGroupCoords_'.format(hemi) analysis_extension = 'betaM-P_prop{}_varThresh{:0^3}'.format( int(prop*100), int(varthresh*1000)) data_path = glob.glob(file_base + analysis_extension + '*')[0] # import lgn data data = sio.loadmat(data_path) X = data['voxCoords'] Y = data['voxGroups'] Y = np.squeeze(Y) colors = np.array([[220, 20, 60],[0, 0, 205]]) colors = colors/255.0 cols = np.zeros((np.size(Y),3)) for c in np.arange(np.size(Y)): cols[c,] = colors[Y[c]-1,] # we create an instance of SVM and fit out data. We do not scale our # data since we want to plot the support vectors C = 1 # SVM regularization parameter lin_svc = svm.SVC(kernel='linear', C=C).fit(X, Y) rbf_svc = svm.SVC(kernel='rbf', gamma=0.7, C=C).fit(X, Y) poly3_svc = svm.SVC(kernel='poly', degree=3, C=C).fit(X, Y) poly2_svc = svm.SVC(kernel='poly', degree=2, C=C).fit(X, Y) # create a mesh to plot in x_min, x_max = X[:, 0].min(), X[:, 0].max() + 1 y_min, y_max = X[:, 1].min(), X[:, 1].max() + 1 z_min, z_max = X[:, 2].min(), X[:, 2].max() + 1 # make 3 3D meshgrid matrices. 3rd dimension is the z (inplane slice) dimension xx, yy, zz = np.mgrid[x_min:x_max, y_min:y_max, z_min:z_max] # add :30j to make 30 equally spaced points # title for the plots titles = ['SVC with linear kernel', 'SVC with RBF kernel', 'SVC with polynomial (degree 3) kernel', 'SVC with polynomial (degree 2) kernel'] # set plot parameters """ n_levels is the number of contour levels. eg. 1 draws 1 contour slice_dim is whether slices will be by y (coronal, slice_dime=1) or z (axial, slice_dim=2) """ n_levels = 1 slice_dim = 1 pl.set_cmap(pl.cm.RdBu) # turn interactive mode on, so that pl.show() won't wait for the figure to be closed before continuing # pl.ion() for i, clf in enumerate((lin_svc, rbf_svc, poly3_svc, poly2_svc)): # Plot the decision boundary. For that, we will asign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. fig = pl.figure() Z = clf.predict(np.c_[xx.ravel(), yy.ravel(), zz.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) if slice_dim == 2: if i==0: print 'slicing axial' slices = np.unique(X[:,2]) for j in np.arange(np.size(Z,2)): pl.subplot(2, 3, j + 1) in_slice = X[:,2]==slices[j] # Plot the contour and the training points pl.contourf(xx[:,:,j], yy[:,:,j], Z[:,:,j], n_levels) pl.scatter(X[in_slice, 0], X[in_slice, 1], c=cols[in_slice,]) elif slice_dim == 1: if i==0: print 'slicing coronal' slices = np.unique(X[:,1]) for j in np.arange(np.size(Z,1)): pl.subplot(3, 4, j + 1) in_slice = X[:,1]==slices[j] # Plot the contour and the training points pl.contourf(xx[:,j,:], zz[:,j,:], Z[:,j,:], n_levels) pl.scatter(X[in_slice, 0], X[in_slice, 2], c=cols[in_slice,]) pl.suptitle(titles[i]) pl.show() if i==0 and savefig: print 'saving fig' pl.savefig('figures/lgnROI{}MapCoronal_spatialSVMLin_{}_{:%Y%m%d}.png'.format( hemi, analysis_extension, datetime.datetime.today())) return lin_svc
def vPrep(fname, saveDir, check=True): fileName = va.getFileName(fname) aviProps = va.getAVIinfo(fname) plt.ion() # fBackground frames # ----------------- # Default values nFrames = 10 bgOK = False bgFile = saveDir + "/bg.npy" if os.path.isfile(bgFile): print("Background file exists, loading...") bg = np.load(bgFile) else: print("Generating background with default settings...") bg = va.getBg(fname, aviProps, nFrames) if check: while not bgOK: plt.figure() plt.imshow(bg) plt.set_cmap('gray') plt.show() uDecision = raw_input("Background OK? [y]es; [n]o ") if uDecision == 'y': bgOK = True else: uframes = raw_input("Select number of frames ") bg = va.getBg(fname, aviProps, int(uframes)) np.save(saveDir + 'bg', bg) print('Background file saved') # Threshold # -------------- # Default values ths = 40 morphDiameter = 10 pmtsFileExists = False thsOK = False pmtsFile = saveDir + "/pmts.npy" if os.path.isfile(pmtsFile): print("Parameters file exists, loading...") pmtsFileExists = True filePmts = np.load(pmtsFile) ths, morphDiameter = va.setThreshold(fname, aviProps, bg, filePmts[0][0], filePmts[1][0]) else: print("Generating threshold with default settings...") ths, morphDiameter = va.setThreshold(fname, aviProps, bg, ths, morphDiameter) if check: while not thsOK: uDecision = raw_input("Threshold OK? [y]es; [n]o ") if uDecision == 'y': thsOK = True else: while True: try: print "Current threshold is", ths uths = int(raw_input("Select new threshold ")) print "Current diameter is", morphDiameter umorph = int( raw_input( "Select new diameter to erode and dilate ")) break except ValueError: print("Invalid number, please try again ") ths, morphDiameter = va.setThreshold(fname, aviProps, bg, uths, umorph) # Arena areas # -------------- # Default values nestPos = [125, 220] nestArea = [(1, 320), (225, 320), (120, 125)] arenaCenter = [600, 244] foodArea = [(785, 360), (960, 360), (860, 185)] plt.ioff() arenaOk = False if pmtsFileExists: print("Using parameters file...") va.plotArena(aviProps, filePmts, bg) pmts = [[ths], [morphDiameter], filePmts[2], filePmts[3], filePmts[4], filePmts[5]] else: print("Generating arena with default settings...") pmts = [[ths], [morphDiameter], nestPos, nestArea, arenaCenter, foodArea] va.plotArena(aviProps, pmts, bg) if check: while not arenaOk: uDecision = raw_input("Arena OK? [y]es; [n]o ") if uDecision == 'y': arenaOk = True else: print("Select new arena ") points = va.setPoints(fname, aviProps, bg) pmts = [[ths], [morphDiameter], points[0], points[1], points[2], points[3]] #print pmts[0], pmts[1] #fsaveName = saveDir + fileName.rstrip(".avi") + "_pmts" np.save(saveDir + 'pmts', pmts) print('Parameters file saved')
import keras.backend as K from keras.models import model_from_json from keras import optimizers import matplotlib.pylab as plt import numpy as np import theano.tensor.nnet.abstract_conv as absconv import cv2 import os from PIL import Image from glob import glob #import imp #cmaps = imp.load_source('colormaps','/home/jmiller/Dropbox/cnn_stuff/colormap/colormaps.py') # colorScale='plasma' #plt.register_cmap(name=colorScale, cmap=cmaps.plasma) plt.set_cmap('jet') home = os.environ['HOME'] def get_img(img_path): # Load image print(img_path) original_image = cv2.imread(img_path) img = original_image if img.shape[0] != 256: img = cv2.resize(img, (256, 256), interpolation=cv2.INTER_AREA) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) X = img / 1. X = X.astype('float32') X = np.rollaxis(X, 2)
def vPrep(fname, saveDir, check=True): fileName = va.getFileName(fname) aviProps = va.getAVIinfo(fname) plt.ion() # fBackground frames # ----------------- # Default values nFrames = 10 bgOK = False bgFile = saveDir + "/bg.npy" if os.path.isfile(bgFile): print("Background file exists, loading...") bg = np.load(bgFile) else: print("Generating background with default settings...") bg = va.getBg(fname, aviProps, nFrames) if check: while not bgOK: plt.figure() plt.imshow(bg) plt.set_cmap('gray') plt.show() uDecision = raw_input("Background OK? [y]es; [n]o ") if uDecision=='y': bgOK = True else: uframes = raw_input("Select number of frames ") bg = va.getBg(fname, aviProps, int(uframes)) np.save(saveDir + 'bg', bg) print('Background file saved') # Threshold # -------------- # Default values ths = 40 morphDiameter = 10 pmtsFileExists = False thsOK = False pmtsFile = saveDir + "/pmts.npy" if os.path.isfile(pmtsFile): print("Parameters file exists, loading...") pmtsFileExists = True filePmts = np.load(pmtsFile) ths, morphDiameter = va.setThreshold(fname, aviProps, bg, filePmts[0][0], filePmts[1][0]) else: print("Generating threshold with default settings...") ths, morphDiameter = va.setThreshold(fname, aviProps, bg, ths, morphDiameter) if check: while not thsOK: uDecision = raw_input("Threshold OK? [y]es; [n]o ") if uDecision=='y': thsOK = True else: while True: try: print "Current threshold is", ths uths = int(raw_input("Select new threshold ")) print "Current diameter is", morphDiameter umorph = int(raw_input("Select new diameter to erode and dilate ")) break except ValueError: print("Invalid number, please try again ") ths, morphDiameter = va.setThreshold(fname, aviProps, bg, uths, umorph) # Arena areas # -------------- # Default values nestPos = [125, 220] nestArea = [(1,320),(225,320),(120,125)] arenaCenter = [600,244] foodArea = [(785,360),(960,360),(860,185)] plt.ioff() arenaOk = False if pmtsFileExists: print("Using parameters file...") va.plotArena(aviProps, filePmts, bg) pmts = [[ths], [morphDiameter], filePmts[2], filePmts[3], filePmts[4], filePmts[5]] else: print("Generating arena with default settings...") pmts = [[ths], [morphDiameter], nestPos, nestArea, arenaCenter, foodArea] va.plotArena(aviProps, pmts, bg) if check: while not arenaOk: uDecision = raw_input("Arena OK? [y]es; [n]o ") if uDecision=='y': arenaOk = True else: print("Select new arena ") points = va.setPoints(fname, aviProps, bg) pmts = [[ths], [morphDiameter], points[0], points[1], points[2], points[3]] #print pmts[0], pmts[1] #fsaveName = saveDir + fileName.rstrip(".avi") + "_pmts" np.save(saveDir + 'pmts', pmts) print('Parameters file saved')
Y_for_lasso = (observedX[1:, :] - observedX[:-1, :]) / ddt lasso = Lasso(alpha=0.01) lasso.fit(X_for_lasso, Y_for_lasso) plt.subplot(1, 2, 1) plt.plot(time_idxs, observedX) plt.legend([str(i + 1) for i in range(n)]) predicted = [i for e in lasso.coef_ for i in e] W0_plus_flat = [i for e in W0_plus for i in e] predicted_null = [ abs(predicted[i]) for i, v in enumerate(W0_plus_flat) if v == 0 ] predicted_not_nul = [ abs(predicted[i]) for i, v in enumerate(W0_plus_flat) if not v == 0 ] plt.subplot(1, 2, 2) plt.set_cmap('bwr') plt.plot(range(len(predicted_null)), predicted_null, 'o', color='#336688') plt.plot(range(len(predicted_not_nul)), predicted_not_nul, 'o', color='#FF9900') plt.title('Difference') plt.show()
mnist_path = os.path.join(os.environ['PYDEEP_HOME'], 'demo', 'mnist', 'train-images-idx3-ubyte.npy') data = np.load(mnist_path).astype('float') / 255 train = data tp = NetTrainParams() tp.maxepoch=200 tp.batchsize=100 tp.eta = scalar_schedule.ConstantSchedule(0.01) tp.mu = scalar_schedule.ConstantSchedule(0.5) arch = [784, 100, 784] lts=['Logistic', 'Linear'] regs = [NetReg() for lt in lts] for reg in regs: reg.dropout=True reg.drop_rate = 0.5 reg.max_constraint = True reg.max_unit_weight = 10 regs[0].drop_rate = 0.2 net = Net(arch, lts, regs) train_sgd(net, train, train, tp) Wimg = pydeep.utils.utils.tile_raster_images(net.layers[0].W.transpose(), (28,28), (10,10)) plt.figure(1) plt.imshow(Wimg) plt.set_cmap('gray') plt.axis('off') plt.show()
clf = LogisticRegression(penalty='l1',C=2) clf.fit(X_for_lasso,Y_for_lasso) plt.subplot(1,2,1) plt.plot(time_idxs,observedX) plt.legend([str(i+1) for i in range(n)]) predicted = [i for e in clf.coef_ for i in e] W0_plus_flat = [i for e in W0_plus for i in e] predicted_null = [abs(predicted[i]) for i,v in enumerate(W0_plus_flat) if v==0] predicted_not_nul = [abs(predicted[i]) for i,v in enumerate(W0_plus_flat) if not v==0] plt.subplot(1,2,2) plt.set_cmap('bwr') plt.plot(range(len(predicted_null)),predicted_null,'o',color='#336688') plt.plot(range(len(predicted_not_nul)),predicted_not_nul,'o',color='#FF9900') plt.title('Difference') plt.show()
def example2(): #---------------------------------------- #The connection matrix as shown in Figure 1a of the paper #---------------------------------------- A0 = [[0.0,0.7,0.32,0.0,0.0,0.04],[0.7,0.0,0.9,0.0,0.0,0.0],[0.845,0.91,0.75,0.11,0.0,0.0],[0.13,0.6,0.68,0.0,0.22,0.0],[0.69,0.0,0.0,0.0,0.0,0.0],[0.0,0.27,0.0,0.95,0.375,0.0]] #---------------------------------------- #This is the original time series data Figure 2, note that the initial conditions are randomly generated (from a normal distribution) so some of the values may vary #---------------------------------------- t = [0.0,0.2,0.4,0.6,0.8,1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0] x = [ [0.5688,0.4694,0.0119,0.3371,0.1622,0.7943], [0.4700,0.3889,0.0182,0.5690,0.2533,0.9345], [0.3890,0.3202,0.0205,0.7603,0.3307,1.0324], [0.3229,0.2629,0.0240,0.9173,0.3951,1.0819], [0.2689,0.2155,0.0297,1.0459,0.4483,1.0910], [0.2245,0.1766,0.0368,1.1508,0.4920,1.0744], [0.1880,0.1446,0.0444,1.2363,0.5278,1.0443], [0.1578,0.1184,0.0517,1.3058,0.5572,1.0085], [0.1327,0.0970,0.0585,1.3623,0.5813,0.9715], [0.1118,0.0794,0.0646,1.4081,0.6010,0.9358], [0.0944,0.0650,0.0699,1.4453,0.6171,0.9027], [0.0799,0.0532,0.0746,1.4753,0.6303,0.8726], [0.0677,0.0436,0.0786,1.4996,0.6411,0.8456], [0.0575,0.0357,0.0821,1.5192,0.6500,0.8219], [0.0490,0.0292,0.0850,1.5350,0.6572,0.8010], [0.0418,0.0239,0.0875,1.5478,0.6632,0.7829], [0.0358,0.0196,0.0896,1.5581,0.6680,0.7672], [0.0308,0.0160,0.0913,1.5664,0.6720,0.7536], [0.0266,0.0131,0.0928,1.5730,0.6753,0.7420], [0.0231,0.0107,0.0941,1.5784,0.6780,0.7320], [0.0201,0.0088,0.0951,1.5827,0.6801,0.7235] ] #Plot the time series by using import matplotlib.pylab as plt plt.plot(np.matrix(t).T,np.matrix(x)) plt.xlabel('Time') plt.ylabel('Gene regulation') plt.savefig('example2_time_series.png') #---------------------------------------- #the function for example 2 as shown in Eq.1 of the paper #---------------------------------------- def f(x): return - x def h(x,i,k): if k < 3: return x**5 / (1.0+x**5) else: return 1.0 / (1.0+x**5) reconstructed_A = network_reconstruction(x,A0,f,h,R=10) #Visualize the original adjacency matrix and the predicted one and compare you can use import matplotlib.pylab as plt fig, axes = plt.subplots(nrows=1, ncols=3) plt.set_cmap('bwr') vmin,vmax = -1,1 im = axes.flat[0].imshow(A0,interpolation='none', vmin=vmin, vmax=vmax) axes.flat[0].set_title('Original A') plt.set_cmap('bwr') im = axes.flat[1].imshow(reconstructed_A,interpolation='none', vmin=vmin, vmax=vmax) axes.flat[1].set_title('Reconstructed A') plt.set_cmap('bwr') im = axes.flat[2].imshow(np.abs(reconstructed_A-A0),interpolation='none', vmin=vmin, vmax=vmax) axes.flat[2].set_title('Difference') fig.subplots_adjust(right=0.8) cbar_ax = fig.add_axes([0.85, 0.35, 0.02, 0.3]) fig.colorbar(im, cax=cbar_ax) plt.savefig('example2_adjacency_matrix.png')
def __init__(self, orbit=8020, debug=False, digitization_db=None, load=True, auto=True, vmin=-16.0, vmax=-11.0, mobile=False, figure_number=1, timeseries_frequency=0.3): global ais_tool_instance ais_tool_instance = super(AISTool, self).__init__() # A few basic parameters self.status = None self.current_ionogram = None self.debug = debug self.orbit = None self.browsing = False self.minimum_interaction_mode = False self._initial_digitization_db = digitization_db self._digitization_saved = False self.load = load self.auto = auto self.ionospheric_model = celsius.mars.Morgan2008ChapmanLayer() np.seterr(all='ignore') self.params = dict(auto_refine=False, substitute_fp=ais.ne_to_fp(4.)) self._bad_keypress = False self._messages = [] self._message_counter = 0 plt.set_cmap('viridis') self.selected_plasma_lines = [] self.selected_cyclotron_lines = [] self.timeseries_frequency = timeseries_frequency self.vmin = vmin self.vmax = vmax mex.check_spice_furnsh() # Set up the figure # self.figure = plt.figure(figsize=(12, 6)) figsize = (20, 12) if mobile: figsize = (17, 8) plt.close(figure_number) self.figure = plt.figure(figure_number, figsize=figsize, facecolor='0.6') g = mpl.gridspec.GridSpec(6, 2, width_ratios=[1,0.34], height_ratios=[0.001, 0.001, 7,5,2,16], wspace=0.16, hspace=0.1, left=0.05, right=0.95, bottom=0.08, top=0.95) # self.stat_ax = plt.subplot(g[0,:]) # self.traj_ax = plt.subplot(g[1,:]) self.tser_ax = plt.subplot(g[2,:]) self.freq_ax = plt.subplot(g[3,:]) self.ig_ax = plt.subplot(g[5,0]) self.ne_ax = plt.subplot(g[5,1]) self.cbar_ax = plt.gcf().add_axes([0.45, 0.04, 0.3, 0.01]) # self.fp_local_figure_number = figure_number + 1 # self.td_cyclotron_figure_number = figure_number + 2 self.fp_local_figure_number = False self.td_cyclotron_figure_number = False self.stored_color = 'white' self.interactive_color = 'red' # All the connections get set up: self.cids = [] self.cids.append(self.figure.canvas.mpl_connect('key_press_event', self.on_keypress)) self.cids.append(self.figure.canvas.mpl_connect('button_press_event', self.on_click)) self.cids.append(self.figure.canvas.mpl_connect('button_release_event', self.on_release)) self.cids.append(self.figure.canvas.mpl_connect('motion_notify_event', self.on_move)) self.cids.append(self.figure.canvas.mpl_connect('scroll_event', self.on_scroll)) self.message("Initialized") plt.show() self.set_orbit(orbit) self.update()
def main(): hemi = 1 prop = 0.5 varthresh = 0 savefig = 1 # file i/o file_base = 'lgnROI{}_comVoxGroupCoords_'.format(hemi) analysis_extension = 'betaM-P_prop{}_varThresh{:0^3}'.format( int(prop * 100), int(varthresh * 1000)) data_path = glob.glob(file_base + analysis_extension + '*')[0] # import lgn data data = sio.loadmat(data_path) X = data['voxCoords'] Y = data['voxGroups'] Y = np.squeeze(Y) colors = np.array([[220, 20, 60], [0, 0, 205]]) colors = colors / 255.0 cols = np.zeros((np.size(Y), 3)) for c in np.arange(np.size(Y)): cols[c, ] = colors[Y[c] - 1, ] # we create an instance of SVM and fit out data. We do not scale our # data since we want to plot the support vectors C = 1 # SVM regularization parameter lin_svc = svm.SVC(kernel='linear', C=C).fit(X, Y) rbf_svc = svm.SVC(kernel='rbf', gamma=0.7, C=C).fit(X, Y) poly3_svc = svm.SVC(kernel='poly', degree=3, C=C).fit(X, Y) poly2_svc = svm.SVC(kernel='poly', degree=2, C=C).fit(X, Y) # create a mesh to plot in x_min, x_max = X[:, 0].min(), X[:, 0].max() + 1 y_min, y_max = X[:, 1].min(), X[:, 1].max() + 1 z_min, z_max = X[:, 2].min(), X[:, 2].max() + 1 # make 3 3D meshgrid matrices. 3rd dimension is the z (inplane slice) dimension xx, yy, zz = np.mgrid[x_min:x_max, y_min:y_max, z_min: z_max] # add :30j to make 30 equally spaced points # title for the plots titles = [ 'SVC with linear kernel', 'SVC with RBF kernel', 'SVC with polynomial (degree 3) kernel', 'SVC with polynomial (degree 2) kernel' ] # set plot parameters """ n_levels is the number of contour levels. eg. 1 draws 1 contour slice_dim is whether slices will be by y (coronal, slice_dime=1) or z (axial, slice_dim=2) """ n_levels = 1 slice_dim = 1 pl.set_cmap(pl.cm.RdBu) # turn interactive mode on, so that pl.show() won't wait for the figure to be closed before continuing # pl.ion() for i, clf in enumerate((lin_svc, rbf_svc, poly3_svc, poly2_svc)): # Plot the decision boundary. For that, we will asign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. fig = pl.figure() Z = clf.predict(np.c_[xx.ravel(), yy.ravel(), zz.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) if slice_dim == 2: if i == 0: print 'slicing axial' slices = np.unique(X[:, 2]) for j in np.arange(np.size(Z, 2)): pl.subplot(2, 3, j + 1) in_slice = X[:, 2] == slices[j] # Plot the contour and the training points pl.contourf(xx[:, :, j], yy[:, :, j], Z[:, :, j], n_levels) pl.scatter(X[in_slice, 0], X[in_slice, 1], c=cols[in_slice, ]) elif slice_dim == 1: if i == 0: print 'slicing coronal' slices = np.unique(X[:, 1]) for j in np.arange(np.size(Z, 1)): pl.subplot(3, 4, j + 1) in_slice = X[:, 1] == slices[j] # Plot the contour and the training points pl.contourf(xx[:, j, :], zz[:, j, :], Z[:, j, :], n_levels) pl.scatter(X[in_slice, 0], X[in_slice, 2], c=cols[in_slice, ]) pl.suptitle(titles[i]) pl.show() if i == 0 and savefig: print 'saving fig' pl.savefig( 'figures/lgnROI{}MapCoronal_spatialSVMLin_{}_{:%Y%m%d}.png'. format(hemi, analysis_extension, datetime.datetime.today())) return lin_svc
def main(): rc('xtick', labelsize=24) rc('ytick', labelsize=24) rcParams['font.family'] = 'serif' rcParams['font.sans-serif'] = ['Times New Roman'] rcParams['xtick.major.pad']='16' rcParams['ytick.major.pad']='16' folder = sys.argv[2] path = folder + "/output/Solution" with open(path, 'r') as f: odes = np.genfromtxt(f, skip_header=0) time = np.zeros(odes.shape[0], dtype=np.float64) f = open(sys.argv[1], "r") subspec = [] for line in f: subspec.append(line) f.close() subspecies = [] for i in range(0, len(subspec)): string = subspec[i].split("\n") subspecies.append(int(string[0])) ode1 = np.transpose(odes) ode = ode1[1::][:] time = ode1[0][:] alphabet1 = sys.argv[3] alphabet = [] if alphabet1 == "no": for i in range(0, len(subspec)): alphabet.append("X" + str(i)) else: f = open(alphabet1, "r") string = [] for line in f: string.append(line) f.close() alphabet = string[0].split("\t") verb = sys.argv[4] verbose = int(verb) if(verbose): print("\nPlotting solution...."); plt.set_cmap('winter') cmap = plt.get_cmap() plt.figure(figsize=(16, 9)) plt.ylabel('Molecular concentration', fontsize = 26) plt.xlabel('Time [s]', fontsize = 26) # colors = [0.0, 0.2, 0.4, 0.6] # for i in range(0, ode.shape[0]): # #s = alphabet[subspecies[i]] # s = "$X_" + str(i+1) + "$" # c = cmap(colors[i]) # plt.plot(time, ode[i][:], color=c, linewidth = 2.0, label=s) # path = folder + "/image/all.pdf" # lg = plt.legend(loc = 1, numpoints=1, borderaxespad=0, fontsize = 22) # lg.draw_frame(False) # plt.savefig(path, bbox_inches = 'tight', additional_artists=lg, dpi=300) for i in range(0, ode.shape[0]): s = alphabet[subspecies[i]] path = folder + "/image/" + s + ".pdf" plt.figure(255) plt.figure(figsize=(25, 15)) plt.figure(figsize=(16, 9)) plt.ylabel('Molecular concentration', fontsize = 26) plt.xlabel('Time [s]', fontsize = 26) dim_y = np.arange(min(ode[i][:]), max(ode[i][:])) plt.plot(time, ode[i][:], 'b', linewidth = 2.0, label=s) #plt.savefig(path, bbox_inches = 'tight', additional_artists=plt.legend(loc = 0, numpoints=1, borderaxespad=0.5, fontsize = 18), dpi=92) lg = plt.legend(loc = 0, numpoints=1, borderaxespad=0, fontsize = 22) lg.draw_frame(False) plt.savefig(path, bbox_inches = 'tight', additional_artists=lg, dpi=300) plt.close('all')
""" Author: Nesar Ramachandra Plots .data files """ #import matplotlib #matplotlib.use('GTKAgg') # On remote machine import numpy as np import matplotlib.pylab as plt plt.set_cmap('Set1_r') import sys import argparse parser = argparse.ArgumentParser() parser.add_argument("-i", "--file", dest="fileIn", help="input .data file", metavar="FILE") #parser.add_argument args = parser.parse_args() print print args.fileIn pixData = np.fromfile(str(args.fileIn), dtype=np.float32)
# signal. The higher carrier frequency (and subsequently doppler bandwidth)# # also results in a 14x increase in the number of synthetic aperture # # samples required to perform the frequency mapping prescribed by Soumekh # # as opposed to polar format mapping. # # # ############################################################################## from numpy import * import numpy as np import ritsar.signal as sig from scipy.fftpack import * from ritsar.signal import * import matplotlib.pylab as plt from scipy.interpolate import interp1d plt.set_cmap(cm.Greys) ########################################################## # PULSED SPOTLIGHT SAR SIMULATION AND RECONSTRUCTION # ########################################################## cmap = cm.Greys_r cj = 1j; pi2 = 2 * pi; # c = 3e8; # propagation speed f0 = 185e6 / 2; # baseband bandwidth is 2*f0 w0 = pi2 * f0; fc = 10.0e9; # carrier frequency wc = pi2 * fc;
# signal. The higher carrier frequency (and subsequently doppler bandwidth)# # also results in a 14x increase in the number of synthetic aperture # # samples required to perform the frequency mapping prescribed by Soumekh # # as opposed to polar format mapping. # # # ############################################################################## from numpy import * import numpy as np import ritsar.signal as sig from scipy.fftpack import * from ritsar.signal import * import matplotlib.pylab as plt from scipy.interpolate import interp1d plt.set_cmap(cm.Greys) ########################################################## # PULSED SPOTLIGHT SAR SIMULATION AND RECONSTRUCTION # ########################################################## cmap = cm.Greys_r cj = 1j pi2 = 2 * pi # c = 3e8 # propagation speed f0 = 185e6 / 2 # baseband bandwidth is 2*f0 w0 = pi2 * f0
def sub_lba_dist(lists_action, lists_cmd, options): # Local Variables: plot_fontsize, lists_action, i, idx_write, save_figure, lba_size_set, stat_record, idx_read, section_name, X, y, x, plot_figure, lba_stat_array, options, Y, lists_cmd # Function calls: subplot, plot, lba_size_dist, set, gcf, figure, title, zlabel, isfield, findall, mesh, sub_lba_dist, colorbar, meshgrid, xlabel, ylabel, generate_ppt, saveas, isempty, find #% stat_record=sub_lba_dist(lists_action,lists_cmd,options) #% --> calcuate the size distribution #% inputs #% lists_action: n samples x 2 array for arrival time and completion time; #% lists_cmd: n samples x 3 for LBA, size, flags ( (0 write, 1 read)) #% access_type: 0 write, 1 read, 2 all #% options: control parameters #% lba_size_set: how many LBA range sets #% #% outputs #% lba_stat_array: cells structure; LBA statistics for write/read/all #% #% contact [email protected] for questions if hasattr(options, 'plot_fontsize'): plot_fontsize = options.plot_fontsize else: plot_fontsize = 10 if hasattr(options, 'save_figure'): save_figure = options.save_figure else: save_figure = 1 if hasattr(options, 'plot_figure'): plot_figure = options.plot_figure else: plot_figure = 1 if hasattr(options, 'lba_size_set'): lba_size_set = options.lba_size_set else: options.lba_size_set = 50 plot_figure = options.plot_figure #%5: LBA vs time; if plot_figure == 1: idx_read = np.nonzero((lists_cmd[:, 2] == 1)) idx_write = np.nonzero((lists_cmd[:, 2] == 0)) plt.figure plt.subplot(2., 1., 1.) plt.plot(lists_action[(idx_read), 0], lists_cmd[(idx_read), 0], 'r*', markersize=1) plt.ylabel('LBA') plt.title('read') plt.subplot(2., 1., 2.) plt.plot(lists_action[(idx_write), 0], lists_cmd[(idx_write), 0], 'b+', markersize=1) plt.ylabel('LBA') plt.xlabel('time (s)') plt.title('write') plt.savefig('lba_all.eps') plt.savefig('lba_all.jpg') lba_stat_array = [] for i in np.arange(3): print(i) stat_record = lba_size_dist2(lists_cmd, i, options) if plot_figure == 1: x = np.arange(1, 1025) y = stat_record.lba_size_idx if len(y) <= 1: continue fig = plt.figure() ax = Axes3D(fig) [X, Y] = plt.meshgrid(x, y) ax.plot_surface(X, Y, (stat_record.lba_size_dist)) plt.set_cmap('hot') ax.set_ylabel('LBA Range') ax.set_xlabel('Request size') ax.set_zlabel('Frequency') if i == 0.: ax.set_title('LBA & Size Disribution - Write ') elif i == 1.: ax.set_title('LBA & Size Disribution - Read ') else: ax.set_title('LBA & Size Disribution - Combined ') # set((plt.gcf, '-property', 'FontSize'), 'FontSize', plot_fontsize) # plt.grid() if i == 1: plt.savefig('lba_size_freq_read.eps', format="eps") plt.savefig('lba_size_freq_read.jpg') elif i == 0: plt.savefig('lba_size_freq_write.eps', format="eps") plt.savefig('lba_size_freq_write.jpg') else: plt.savefig('lba_size_freq_com.eps', format="eps") plt.savefig('lba_size_freq_com.jpg') plt.show() lba_stat_array.append(stat_record) # if options.export_report: # options.section_name = 'LBA Distribution' # generate_ppt(options) return lba_stat_array
# old_ax = plt.gca() # plt.colorbar(cax=celsius.make_colorbar_cax(), ticks=[0,1,2], cmap=cmap) # plt.ylabel(r'log$_{10}$ Counts') # plt.sca(old_ax) # # # # if __name__ == '__main__': plt.close('all') fig, ax = plt.subplots(2,1, sharex=True) start = mex.orbits[8000].periapsis - 2.5 * 3600 finish = mex.orbits[8000].periapsis + 2.5 * 3600 verbose = True plt.set_cmap(plt.cm.Spectral_r) plt.sca(ax[0]) plot_aspera_els(start, finish, verbose=verbose) plt.sca(ax[1]) plot_aspera_ima(start, finish, verbose=verbose) plt.vlines((start, finish), *plt.ylim()) plt.xlim(start - 3600., finish + 3600.) plt.show()