def plot3d(): fig = plt.figure() ax = Axes3D(fig) X_seq, T_seq = self.point_info_manager.X_seq, self.point_info_manager.T_seq if self.gt_available: c_true, lower, upper = normalization.zero_one_normalization(self.z) c_true = cm.bwr(c_true * 255) ax.scatter([x[0] for x in self.X_grid.astype(float)], [x[1] for x in self.X_grid.astype(float)], [x[2] for x in self.X_grid.astype(float)], c=c_true, marker='o', alpha=0.5, s=5) c = cm.bwr(normalization.zero_one_normalization(T_seq, self.z.min(), self.z.max())[0] * 255) else: c = cm.bwr(normalization.zero_one_normalization(T_seq)[0] * 255) ax.scatter([x[0] for x in X_seq], [x[1] for x in X_seq], [x[2] for x in X_seq], c='y', marker='o', alpha=0.5) if self.does_pairwise_sampling: ax.scatter(X_seq[-1][0], X_seq[-1][1], X_seq[-1][2], c='m', s=50, marker='o', alpha=1.0) ax.scatter(X_seq[-2][0], X_seq[-2][1], X_seq[-2][2], c='m', s=100, marker='o', alpha=1.0) else: ax.scatter(X_seq[-1][0], X_seq[-1][1], X_seq[-1][2], c='m', s=50, marker='o', alpha=1.0)
def plot_links( ax: Axes, points: array_like, score_matrix: np.ndarray, inside_spheres: np.ndarray ): """ Plot scored links between points. Parameters ---------- ax: Axes Matplotlib Axes object. points : (N, D) array_like Input points. score_matrix : (N, N) ndarray Score matrix. inside_spheres : (N,) ndarray Boolean array. Element i is True if position i is inside the combined sphere volume. """ for i, point_i in enumerate(points): for j, point_j in enumerate(points): if inside_spheres[i] and inside_spheres[j]: score = score_matrix[i, j] if score != 0: # Plot line coloured by score connect_points( ax, point_i, point_j, c=cm.bwr(score), linestyle='-', linewidth=0.75, )
def show_active_areas(finger_idx, part_idx, object_name, intent): filename = osp.join('data', 'object_models', f'{object_name}.ply') mesh = o3dio.read_triangle_mesh(filename) mesh.compute_vertex_normals() filename = osp.join( 'data', f'{object_name}_{intent}_{finger_idx}_{part_idx}_active_areas.npy') c = np.load(filename) mesh.vertex_colors = o3du.Vector3dVector(cm.bwr(c)[:, :3]) o3dv.draw_geometries([mesh])
def update_func(step, dual_graph, demvec, repvec, nodes): # the step parameter is mandatory for matplotlib # Set new value for figure data # update node color here value_map = [] for i in range(dual_graph.number_of_nodes()): if demvec[step][i] == 0 and repvec[step][i] == 0: value_map.append(0.5) else: value_map.append((repvec[step][i]/(demvec[step][i] + repvec[step][i]))) value_map = cm.bwr(np.array(value_map).astype(float)) nodes.set_color(value_map) return nodes
def plot_sh_in_spherical_coos(ell, m, args): # inspired by http://balbuceosastropy.blogspot.com/2015/06/spherical-harmonics-in-python.html #ensure valid input assert np.abs(m) <= ell outfile = args.outfile if outfile is None: outfile = 'l{0}m{1}_sp{2}.png'.format(ell, m, '_s' if args.square else '') PHI, THETA = np.mgrid[0:2 * np.pi:200j, 0:np.pi:100j] R = sp.sph_harm(m, ell, PHI, THETA) if args.square: R = abs(R) RS = R else: R = R.real RS = R**2 # Convert to cartesian coordinates for the 3D representation X = RS * np.sin(THETA) * np.cos(PHI) Y = RS * np.sin(THETA) * np.sin(PHI) Z = RS * np.cos(THETA) fig = plt.figure(figsize=(args.size, args.size), tight_layout={'pad': 0}) ax = fig.add_subplot(projection='3d') limit = max(X.max(), Y.max(), Z.max()) ax.set_xlim([-limit, limit]) ax.set_ylim([-limit, limit]) ax.set_zlim([-limit, limit]) ax.axis('off') ax.grid(b=None) ax.relim() norm = colors.Normalize() im = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.bwr(norm(R))) m = cm.ScalarMappable(cmap=cm.bwr) m.set_array(R) fig.savefig(outfile, dpi=args.dpi, bbox_inches=0) print('\nWrote ' + outfile)
def update(frame): scat._offsets3d = (avg[frame, :, 0], avg[frame, :, 1], avg[frame, :, 2]) # scat.set_offsets(avg[frame,:,[1,2]].T) cols = np.isin(np.unique(cond), pos_conds[PS[frame, :].argmax()]) scat._facecolor3d = cm.bwr(cols / cols.max()) # scat._facecolor = cm.bwr(cols/cols.max()) ax.title.set_text(str(pos_conds[PS[frame, :].argmax()])) # scat2._offsets3d # util.set_axes_equal(ax) # plt.draw() return fig,
def plot_bader_dos(self, **args): if 'types_to_plot' in args: types_to_plot = args['types_to_plot'] else: types_to_plot = self.atomtypes if 'range_to_plot' in args: range_to_plot = args['range_to_plot'] else: range_to_plot = [[] for i in range(3)] for i in range(3): tempvar = zeros(3) tempvar[i] += 1.0 range_to_plot[i].append(-1.5 * norm(dot(tempvar, self.lv))) range_to_plot[i].append(1.5 * norm(dot(tempvar, self.lv))) self.baderdosfig, self.baderdosax = plt.subplots(1, 1) atoms_to_plot = [] colorlist = [] for i in range(len(self.coord)): for j in range(len(self.atomtypes)): if i < sum(self.atomnums[:j + 1]): break if self.atomtypes[j] in types_to_plot: for k in range(3): if self.coord[i][k] < min( range_to_plot[k]) or self.coord[i][k] > max( range_to_plot[k]): break else: atoms_to_plot.append(i) colorlist.append(self.numvalence[j] - self.charges[i]) cnorm = Normalize(vmin=min(colorlist), vmax=max(colorlist)) for i, j in zip(atoms_to_plot, colorlist): tempy = zeros(len(self.energies)) for k in range(len(self.dos[i + 1])): tempy += self.dos[i + 1][k] self.baderdosax.plot(self.energies, tempy, color=bwr(cnorm(j))) self.baderdosax.set(xlabel='energy - $E_f$ / eV') self.baderdosax.set(ylabel='DOS / states $eV^{-1}$') self.baderdosax.set_facecolor('grey') cbar = plt.colorbar(ScalarMappable(norm=cnorm, cmap='bwr')) plt.set_cmap('bwr') cbar.set_label('net charge of {}'.format(', '.join(types_to_plot))) cbar.ax.yaxis.set_major_formatter(FormatStrFormatter('%+.3f')) plt.show() print('{} DOS curves plotted'.format(len(colorlist)))
def disp_one_line(self, ax, subtext, subvals, height): cl_s = cm.bwr(subvals) for i, (ch, cl) in enumerate(zip(subtext, cl_s)): ax.text(0.01 + i * self.font_rw, height, ch, fontname=self.fontname, fontsize=self.fontsize, bbox={ 'facecolor': cl, 'edgecolor': cl, 'alpha': 0.8, 'pad': 1 }) return ax
def plot_neurosynth(t_stat,pvals,topic_terms,title='',test='chi2',ax=None): if not ax: fig = plt.figure(figsize=(4,6)) ax = fig.add_subplot(1,1,1) colors=np.ones(len(topic_terms))*0.7 colors[pvals<0.05/len(topic_terms)]=1 cols=cm.bwr(colors) ordered_pvals=pvals[np.argsort(t_stat)] ax.barh(np.arange(len(t_stat)),np.sort(t_stat),color=cols[np.argsort(t_stat)]) topic_terms[np.argsort(pvals)],t_stat[np.argsort(pvals)],np.sort(pvals) ax.set_yticks(np.arange(len(topic_terms))) ax.set_yticklabels(topic_terms[np.argsort(t_stat)]) #plt.yticks(np.arange(len(topics))[ordered_pvals<0.05],topic_terms[np.argsort(t_stat)][ordered_pvals<0.05]) ax.set_title(title) ax.set_xlabel(test) return ax
def create_edge(x1, y1, x2, y2, weight, maximum, minimum): # scale weight to value between 0 and 1 scaled_weight = (weight - minimum) / (maximum - minimum) # map the weight to a color on red-blue color scale color = 'rgb' + str( tuple([i * 255 for i in cm.bwr(scaled_weight)[:-1]])) # return the edge that connects (x1, y1) to (x2, y2) return go.Scatter(x=[x1, x2], y=[y1, y2], line={ 'width': line_width, 'color': color }, mode='lines')
def onclick(self, event): if event.inaxes == self.ax: self.x = event.xdata self.y = event.ydata xlim0, xlim1 = self.ax.get_xlim() if self.x <= xlim0 + (xlim1 - xlim0) * self.clicklim: self.horizontal_line.set_ydata(self.y) self.text.set_text("{0:.2f}".format(self.y)) self.text.set_position((xlim0, self.y)) self.fig.canvas.draw() self.diff = (self.mean + (self.confint / 2)) - self.y self.diff[self.diff < 0] = 0 self.ax.bar(self.values, self.mean, yerr=self.confint, edgecolor='black', color=cm.bwr(tuple(self.diff / 10000))) plt.draw()
def __init__(self, ax, mean, confint, values, clicklim=0.05): self.fig = ax.figure self.diff = confint self.values = values self.ax = ax self.mean = mean self.confint = confint self.y = 0 self.x = 0 self.clicklim = clicklim self.horizontal_line = ax.axhline(y=0.5, color='black', alpha=0.5) self.text = ax.text(0, 0.5, "") print(self.horizontal_line) self.ax.bar(self.values, self.mean, yerr=self.confint, edgecolor='black', color=cm.bwr(tuple(self.diff / 10000))) self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def main(): """Make the dispersion plot.""" eq_pot_stdev = 0.05 file_name = 'files/simulationParameters.json' data = io.read_json_params(file_name, "Martin's experiment") time_end = 2 * (data["pot_rev"] - data["pot_start"]) / data["nu"] num_time_pts = int(np.ceil(200 * data["freq"] * time_end)) time_step = time_end / (num_time_pts - 1) time = np.linspace(0, time_end, num_time_pts) eq_pot_grid = gt.hermgauss_param(5, data["eq_pot"], eq_pot_stdev, False) color_scale = eq_pot_grid[0] # Rescale to [0,1] color_scale = (color_scale - np.min(color_scale))\ / (np.max(color_scale) - np.min(color_scale)) colors = [cm.bwr(x) for x in color_scale] #pylint: disable=no-member #Generate currents # Start with capacitive current eq_rate = data["eq_rate"] data["eq_rate"] = 0 cap_current, _ = st.solve_reaction_from_json(time_step, num_time_pts, data) data["eq_rate"] = eq_rate disp_current = np.zeros(num_time_pts) # Now, compute the component currents. for color, eq_pot, weight in zip(colors, *eq_pot_grid): data["eq_pot"] = eq_pot current, _ = st.solve_reaction_from_json(time_step, num_time_pts, data) current -= cap_current current *= weight plot_envelopes(time, current, color) disp_current += current plt.fill_between(time, disp_current, -disp_current) plt.show(block=True)
def make_colormaps(images, limit=1.0): """ input argments: - images: anomaly maps (# of images) by (height) by (width) - limit: lower or upper bound the magnitudes of the lower and upper bound set equally output arguments: - scaled: anomaly maps painted as red(excessive) or blue(insufficient) colors (# of images) by (rgb channel) by (height) by (width) if masks is not None, the pad information is also displayed """ images = images.double() images.clamp_(-limit, limit) scaled = (images+limit)/(2*limit) scaled = cm.bwr(scaled) scaled = torch.tensor(scaled)[:,:,:,:3] scaled = scaled.permute(0, 3, 1, 2) return scaled
def generate_pymol_image(self, g): """ This function generates the pymol image representing one ensemble. It scales the structure color with respect the variability of the residues among representative conformations using own pymol metric. :param g: graph of representative conformations of one ensemble """ # Load the structure conformations structure = PDBParser(QUIET=True).get_structure(self._id, self._path) # Creating pymol folder os.makedirs('data/pymol', exist_ok=True) # Build the matrix with the features of the representative conformations representative_features = [] first = True models = [int(m) for m in g.nodes()] for model in models: representative_features.append(self._features[model]) # If not done yet, open the structure for Pymol if first: print('\n\t- Model {} used for Pymol image'.format(model)) io = PDBIO() io.set_structure(structure[model]) io.save("data/pymol/{}.pdb".format(self._id)) first = False representative_features = np.matrix(representative_features) # Build feature matrices for representative conformations asa = extract_vectors_model_feature(self._residues, key='ASA', features=representative_features) ss = extract_vectors_model_feature(self._residues, key='SS', features=representative_features) temp_dist = extract_vectors_model_feature( self._residues, key='DIST', features=representative_features) # Reshape distance matrix (linear to square) dist = np.zeros( (len(representative_features), self._residues, self._residues)) for k in range(len(representative_features)): idx = np.triu_indices(self._residues, k=1) dist[k][idx] = temp_dist[k] dist[k] = dist[k] + dist[k].T # For each residue, determine the window around it and apply the metric residue_variability = [] window_size = 9 for residue in range(self._residues): start = max(0, residue - window_size) end = min(self._residues - 1, residue + window_size) residue_variability.append( self.pymol_metric(asa[:, start:end], ss[:, start:end], dist[:, start:end])) # Pymol image generation cmd.delete("all") cmd.load("data/pymol/{}.pdb".format(self._id), self._id) # Load from file cmd.remove("resn hoh") # Remove water molecules cmd.hide("lines", "all") # Hide lines cmd.show("cartoon", "all") # Show cartoon cmd.orient() cmd.zoom() norm = colors.Normalize(vmin=min(residue_variability), vmax=max(residue_variability)) # Changing of the residue color according to its window variability for i, residue in enumerate( Selection.unfold_entities(structure[0], "R")): rgb = cm.bwr(norm(residue_variability[i])) cmd.set_color("col_{}".format(i), list(rgb)[:3]) cmd.color("col_{}".format(i), "resi {}".format(residue.id[1])) # Pymol image saving cmd.png("{}/{}_pymol.png".format(self._output_folder, self._id), ray=1) print('\t- Successfully saved {}_pymol.png in {}'.format( self._id, self._output_folder)) # Showing Pymol image pymol_image = Image.open("{}/{}_pymol.png".format( self._output_folder, self._id)) fig, axes = plt.subplots() axes.imshow(pymol_image) axes.set_xticks([]) axes.set_yticks([]) plt.show()
def main(argv): parser = argparse.ArgumentParser(description='Plotting 3DConv 4 Model Activations') parser.add_argument('--mov_name', help='Name of movie to process') args = parser.parse_args() arg_dict = args.__dict__ if 'mov_name' in arg_dict.keys() and arg_dict['mov_name'] is not None: video_pattern = os.path.splitext(args.mov_name)[0] reader = imageio.get_reader(video_pattern+'.avi') writer = imageio.get_writer(video_pattern+'_out_Activations.avi', fps=30, codec='mpeg4', quality=10) im_iter = reader.iter_data() label_file = video_pattern+'_crop_raw.npy' label_data=[] with open(label_file,'rb') as file: while True: try: if sys.version_info[0]==2: label_data.append(np.load(file)) else: label_data.append(np.load(file, encoding = 'bytes', allow_pickle = False)) except IOError: break except ValueError: break label_data = np.reshape(label_data, [-1, np.shape(label_data)[-1]]) # Save the new format because it's that much faster np.save(label_file, label_data, allow_pickle=False) label_data = np.reshape(label_data, [-1, int(np.shape(label_data)[-1]/2), 2]) label_data_softmax = softmax(label_data) predictions_all = label_data_softmax[:,:,1] mean_pred = np.mean(predictions_all, axis=1) mean_pred = np.convolve(mean_pred, np.ones((46))/(46), mode='same') input_size = 112 time_depth = 16 frames = [np.zeros([input_size, input_size, 1]) for x in range(time_depth)] frame_num = 0 n_models = 4 prediction_size = 16 while True: try: frame = np.uint8(next(im_iter)) new_frame = np.copy(frame) new_frame = np.pad(new_frame, ((0,0),((1+n_models*prediction_size),0),(0,0)), 'constant', constant_values=0) # Plot the activations... predictions = predictions_all[frame_num,:] mean_cons = mean_pred[frame_num] # Black out the background behind... new_frame[0:(1+8*prediction_size+n_models*prediction_size),0:(1+n_models*prediction_size),:] = 0 for i in range(int(np.shape(predictions)[0]/n_models)): for j in range(n_models): cur_result = predictions[i*n_models+j] new_frame[(1+prediction_size*i):(prediction_size+prediction_size*i),(1+prediction_size*j):(prediction_size+prediction_size*j),:] = np.multiply(cm.bwr(cur_result)[0:3],255) # Consensus prediction if mean_cons > 0.4811055: new_frame[1+8*prediction_size:(8*prediction_size+n_models*prediction_size),1:n_models*prediction_size,:] = [200,0,0] else: new_frame[1+8*prediction_size:(8*prediction_size+n_models*prediction_size),1:n_models*prediction_size,:] = [0,0,200] writer.append_data(new_frame.astype('u1')) frame_num = frame_num + 1 except StopIteration: break reader.close() writer.close()
def plot_map(self, size, **args): if type(size) == int: size = (size, size) if 'cmap' in args: self.cmap = args['cmap'] if 'orbitals' in args: orbitals_to_plot = args['orbitals'] else: orbitals_to_plot = [i for i in range(len(self.orbitals))] if len(orbitals_to_plot) == len(self.orbitals): self.orbitals = ['all'] else: self.orbitals = [self.orbitals[i] for i in orbitals_to_plot] self.ldos = sum([self.ldos[i] for i in orbitals_to_plot]) if 'smear' in args: self.smear_ldos(float(args['smear'])) if 'normalize_ldos' in args: normalize_ldos = args['normalize_ldos'] else: normalize_ldos = True if 'show_charges' in args: show_charges = args['show_charges'] charge_list = [] for i in self.plot_atoms: for j in range(len(self.atomtypes)): if i < sum(self.atomnums[:j + 1]): break if self.atomtypes[j] in show_charges: charge_list.append(self.numvalence[j] - self.charges[i]) cnorm = Normalize(vmin=min(charge_list), vmax=max(charge_list)) else: show_charges = [] self.ldosfig, self.ldosax = plt.subplots(1, 1) #plots the ldos for i in range(size[0] + 1): for j in range(size[1] + 1): if normalize_ldos: ldosmap = self.ldosax.pcolormesh( self.x + self.lv[0][0] * i + self.lv[1][0] * j, self.y + self.lv[0][1] * i + self.lv[1][1] * j, self.ldos / max([max(i) for i in self.ldos]), cmap=self.cmap, shading='nearest') else: ldosmap = self.ldosax.pcolormesh( self.x + self.lv[0][0] * i + self.lv[1][0] * j, self.y + self.lv[0][1] * i + self.lv[1][1] * j, self.ldos, cmap=self.cmap, shading='nearest') if 'show_colorbar' in args: map_cbar = self.ldosfig.colorbar(ldosmap) #holds the position and color of each atom tempx = [] tempy = [] colors = [] sizes = [] counter = 0 #plots the overlaid atoms as a scatterplot for i in self.plot_atoms: for j in range(len(self.atomtypes)): if i < sum(self.atomnums[:j + 1]): break for k in range(size[0] + 1): for l in range(size[1] + 1): tempx.append(self.coord[i][0] + self.lv[0][0] * k + self.lv[1][0] * l) tempy.append(self.coord[i][1] + self.lv[0][1] * k + self.lv[1][1] * l) sizes.append(self.atom_sizes[j] / (max(size) + 1)) if self.atomtypes[j] in show_charges: colors.append(bwr(cnorm(charge_list[counter]))) else: colors.append(self.atom_colors[j]) if self.atomtypes[j] in show_charges: counter += 1 atom_scatter = self.ldosax.scatter(tempx, tempy, color=colors, s=sizes) self.ldosax.set(xlabel='x coordinate / $\AA$') self.ldosax.set(ylabel='y coordinate / $\AA$') self.ldosax.set( title= '{} to {} V | {} $\AA$ | $\phi$ = {} | $\sigma$ = {}\ncontributing orbitals: {}' .format(self.emin, self.emax, self.tip_disp, self.phi, self.sigma, ', '.join(self.orbitals))) patches = [] for i in range(len(self.atomtypes)): if self.atomtypes[i] not in show_charges: patches.append( mpatches.Patch(color=self.atom_colors[i], label=self.atomtypes[i])) #if bader charges are plotted, a colorbar is displayed if len(show_charges) > 0: cbar = self.ldosfig.colorbar(ScalarMappable(norm=cnorm, cmap=bwr)) cbar.set_label('net charge of {}'.format(', '.join(show_charges))) cbar.ax.yaxis.set_major_formatter(FormatStrFormatter('%+.3f')) self.ldosfig.legend(handles=patches) self.ldosfig.subplots_adjust(top=0.9) self.ldosax.set_aspect('equal') self.ldosfig.show()
#np.histogram2d()将两列数值转为矩阵 heatmap, xedges, yedges = np.histogram2d(x, y, bins = bins) #高斯锐化模糊对象 heatmap = gaussian_filter(heatmap, sigma = s) extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]] return heatmap.T, extent #读取森林地图底图 #Normalize归一化 #np.clip(x,a,b)将x中小于a的值设为a,大于b的值设为b #cm.bwr 蓝白红 bg = imread('erangel.jpg') hmap, extent = heatmap(plot_data_ev[:,0], plot_data_ev[:,1], 1.5, bins =800) alphas = np.clip(Normalize(0, hmap.max()/100, clip=True)(hmap)*1.5,0.0,1.) colors = Normalize(hmap.max()/100, hmap.max()/20, clip=True)(hmap) colors = cm.bwr(colors) colors[..., -1] = alphas hmap2, extent2 = heatmap(plot_data_ek[:,0],plot_data_ek[:,1],1.5, bins = 800) alphas2 = np.clip(Normalize(0, hmap2.max()/100, clip = True)(hmap2)*1.5, 0.0, 1.) colors2 = Normalize(hmap2.max()/100, hmap2.max()/20, clip=True)(hmap2) colors2 = cm.RdBu(colors2) colors2[...,-1] = alphas2 #'森林死亡率图' fig, ax = plt.subplots(figsize = (24,24)) ax.set_xlim(0, 4096);ax.set_ylim(0, 4096) ax.imshow(bg) ax.imshow(colors, extent = extent, origin = 'lower', cmap = cm.bwr, alpha = 1) #ax.imshow(colors2, extent = extent2, origin = 'lower', cmap = cm.RdBu, alpha = 0.5) plt.gca().invert_yaxis()
cmap='bwr', marker='o', s=100) axs[1].set_xlim([-this_range, this_range]) axs[1].set_ylim([-this_range, this_range]) dicplt.square_axis(axs[1]) an1 = dicplt.LineAnime(np.stack([ np.array(list(range(20)) + list(range(20, nepoch, 10))) for _ in range(3) ]), np.array(PS)[list(range(20)) + list(range(20, nepoch, 10)), :].T, ax=axs[0]) an2 = dicplt.LineAnime(weights_proj[:, :, 0].T, weights_proj[:, :, 1].T, colors=cm.bwr(grp / 1), ax=axs[1]) dicplt.AnimeCollection(an1, an2).save(SAVE_DIR + '/vidya/tempmovie.mp4', fps=30) #%% this_grp = 0 ax = dicplt.scatter3d(8 * inp_coefs.T, s=200, marker='*', c=cm.viridis(util.decimal(y_.T) / 7)) dicplt.LineAnime3D( weights_proj[:, grp == this_grp, 0].T, weights_proj[:, grp == this_grp, 1].T,
def cmap(x): return cm.bwr(1 - x)
def features_training(num_images=1): """ Function to analyse the features of the TRAINING set of the autoencoder """ norm_coef = [] losses_focus, peaks_focus, mins_focus = [], [], [] losses_defocus, peaks_defocus, mins_defocus = [], [], [] # ============================================================================================================ # ### Light Loss - see how the Low Orders modify the total intensity for j in range(N_ext): low_orders = ae_coefs[j, :N_low] norm_coef.append(np.linalg.norm(low_orders)) input_focus = train_noisy[j, :N_crop**2].reshape((N_crop, N_crop)) output_focus = train_clean[j, :N_crop**2].reshape((N_crop, N_crop)) removed_features_focus = input_focus - output_focus loss_focus = np.sum(removed_features_focus) losses_focus.append(loss_focus) peaks_focus.append(np.max(removed_features_focus)) mins_focus.append(np.min(removed_features_focus)) input_defocus = train_noisy[j, N_crop**2:].reshape( (N_crop, N_crop)) output_defocus = train_clean[j, N_crop**2:].reshape( (N_crop, N_crop)) removed_features_defocus = input_defocus - output_defocus loss_defocus = np.sum(removed_features_defocus) losses_defocus.append(loss_defocus) peaks_defocus.append(np.max(removed_features_defocus)) mins_defocus.append(np.min(removed_features_defocus)) norm_coef = np.array(norm_coef) f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, sharey=True) # Focused PSF p_sort = np.argsort(peaks_focus) ax1.scatter(norm_coef[p_sort], np.sort(peaks_focus), color=cm.bwr( np.linspace(0.5 + np.min(peaks_focus), 1, N_ext)), s=4, label='Maxima') m_sort = np.argsort(mins_focus) ax1.scatter(norm_coef[m_sort], np.sort(mins_focus), color=cm.bwr(np.linspace(0, 0.5, N_ext)), s=4, label='Minima') loss_sort = np.argsort(losses_focus) ax1.legend(loc=2) leg = ax1.get_legend() leg.legendHandles[0].set_color('red') leg.legendHandles[1].set_color('blue') ax1.axhline(y=0.0, linestyle='--', color='black') ax1.set_title('Nominal PSF') ax1.set_ylabel(r'Light loss') ax1.set_ylim([-0.5, 0.5]) ax3.scatter(norm_coef[loss_sort], np.sort(losses_focus), color='black', s=3, label='Total') ax3.legend(loc=2) ax3.axhline(y=0.0, linestyle='--', color='black') ax3.set_xlabel(r'Norm of low orders $\Vert a_{low} \Vert$') ax3.set_ylabel(r'Light loss') # Defocused PSF p_sort = np.argsort(losses_defocus) ax2.scatter(norm_coef[p_sort], np.sort(peaks_defocus), color=cm.bwr( np.linspace(0.5 + np.min(peaks_defocus), 1, N_ext)), s=4, label='Maxima') m_sort = np.argsort(mins_defocus) ax2.scatter(norm_coef[m_sort], np.sort(mins_defocus), color=cm.bwr(np.linspace(0, 0.5, N_ext)), s=4, label='Minima') loss_sort = np.argsort(losses_defocus) ax2.legend(loc=2) leg = ax2.get_legend() leg.legendHandles[0].set_color('red') leg.legendHandles[1].set_color('blue') ax2.axhline(y=0.0, linestyle='--', color='black') ax2.set_title('Defocused PSF') ax4.scatter(norm_coef[loss_sort], np.sort(losses_defocus), color='black', s=3, label='Total') ax4.legend(loc=2) ax4.axhline(y=0.0, linestyle='--', color='black') ax4.set_xlabel(r'Norm of low orders $\Vert a_{low} \Vert$') # ============================================================================================================ # ### PCA analysis of the removed features # Focused PSF N_comp = N_low removed_features = train_noisy[:, :N_crop**2] - train_clean[:, :N_crop **2] pca = PCA(n_components=N_comp) pca.fit(X=removed_features) components = pca.components_.reshape((N_comp, N_crop, N_crop)) variance_ratio = pca.explained_variance_ratio_ total_variance = np.sum(variance_ratio) plt.figure() for i in range(N_comp): ax = plt.subplot(2, N_comp, i + 1) plt.imshow(components[i], cmap='seismic', origin='lower') ax.set_title(r'PCA #%d [$\sigma^2_r=%.2f/%.2f$]' % (i + 1, variance_ratio[i], total_variance)) plt.colorbar(orientation="horizontal") cmin = min(components[i].min(), -components[i].max()) plt.clim(cmin, -cmin) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) removed_features_defocus = train_noisy[:, N_crop** 2:] - train_clean[:, N_crop**2:] pca_defocus = PCA(n_components=N_comp) pca_defocus.fit(X=removed_features_defocus) components_defocus = pca_defocus.components_.reshape( (N_comp, N_crop, N_crop)) variance_ratio_defocus = pca_defocus.explained_variance_ratio_ total_variance_defocus = np.sum(variance_ratio_defocus) for i in range(N_comp): ax = plt.subplot(2, N_comp, i + 1 + N_comp) plt.imshow(components_defocus[i], cmap='seismic', origin='lower') ax.set_title( r'PCA #%d [$\sigma^2_r=%.2f/%.2f$]' % (i + 1, variance_ratio_defocus[i], total_variance_defocus)) plt.colorbar(orientation="horizontal") cmin = min(components_defocus[i].min(), -components_defocus[i].max()) plt.clim(cmin, -cmin) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ### Least Squares fit of the removed features def residuals_lsq(x, image_data, pca_components): model_image = np.dot(x, pca_components) return image_data - model_image # ============================================================================================================ # ### Compare the removed features to the true difference random_images = np.random.randint(train_noisy.shape[0], size=num_images) for j in random_images: im = removed_features[j] res_lsq = lsq(fun=residuals_lsq, x0=np.zeros(N_comp), args=(im, pca.components_)) x_fit = res_lsq['x'] im_fit = (np.dot(x_fit, pca.components_)).reshape((N_crop, N_crop)) im = im.reshape((N_crop, N_crop)) vmin_im = min(im.min(), -im.max()) vmin_fit = min(im_fit.min(), -im_fit.max()) vmin = min(vmin_im, vmin_fit) error = np.sum(np.abs(im_fit - im)) / np.sum(np.abs(im)) plt.figure() cmap = 'seismic' ax1 = plt.subplot(1, 3, 1) plt.imshow(im, cmap=cmap) plt.colorbar(orientation="horizontal") plt.clim(vmin, -vmin) ax1.get_xaxis().set_visible(False) ax1.get_yaxis().set_visible(False) ax1.set_title( r'Removed features: $PSF(\Phi_{low} + \Phi_{high}) - PSF(\Phi_{high})$' ) ax2 = plt.subplot(1, 3, 2) plt.imshow(im_fit, cmap=cmap) plt.colorbar(orientation="horizontal") plt.clim(vmin, -vmin) ax2.get_xaxis().set_visible(False) ax2.get_yaxis().set_visible(False) ax2.set_title(r'Least-Squares fit from PCA: $x_{lsq} \cdot PCA$') res = im_fit - im ax3 = plt.subplot(1, 3, 3) plt.imshow(res, cmap='bwr') plt.colorbar(orientation="horizontal") min_res = min(res.min(), -res.max()) plt.clim(min_res, -min_res) ax3.get_xaxis().set_visible(False) ax3.get_yaxis().set_visible(False) ax3.set_title(r'Residuals ($\epsilon = %.2f$)' % error) # ============================================================================================================ # ### Show some examples of the true features random_images = np.random.choice(train_noisy.shape[0], size=48, replace=False) print(random_images) plt.figure() for i, img_j in enumerate(random_images): ax = plt.subplot(6, 8, i + 1) im = removed_features[img_j].reshape((N_crop, N_crop)) plt.imshow(im, cmap='seismic') min_im = min(im.min(), -im.max()) plt.clim(min_im, -min_im) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) plt.show() return pca
print("# width_out = " + str(np.round(p84_out, 2) - np.round(p16_out, 2))) ### plot figure = plt.figure(figsize=(10, 2)) gs = gridspec.GridSpec(nrows=8, ncols=17) plt.subplots_adjust(bottom=0.22, left=0.05, right=0.98, top=0.88) ax1 = plt.subplot(gs[0:8, 0:8]) ax2 = plt.subplot(gs[0:8, 9:17]) ax1.grid(axis="x") ax2.grid(axis="both") plt.rcParams["font.size"] = 11 plt.rcParams["legend.fontsize"] = 9 # ax1 ylim = [0.0001, np.r_[y_in, y_out].max() * 1.4] ax1.step(x_in, y_in, color=cm.bwr(1 / 1.), lw=1, alpha=1.0, where="mid") ax1.bar(x_in, y_in, lw=0, color=cm.bwr(1 / 1.), alpha=0.2, width=x_in[1] - x_in[0], align="center", label="inside mask") ax1.plot(p50_in_norm, ylim[1] * 0.95, "o", markeredgewidth=0, c=cm.bwr(1 / 1.), markersize=7, zorder=1)
esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] <= collEdgeCount.bins[1] and u not in remove and v not in remove] # print esmall # print remove # # sys.exit() # pos=nx.spring_layout(G, k=.5,iterations=20, weight=20) # positions for all nodes # pos = nx.graphviz_layout(G, prog='neato') pos = nx.spring_layout(G, weight=20) # positions for all nodes # pos=nx.circular_layout(G) # positions for all nodes G.remove_nodes_from(remove) # cm.Spectral(betc_value) node_color = [cm.bwr(G.degree(v)) for v in G] # nodes nx.draw_networkx_nodes(G, pos, node_size=[float(G.degree(v)) * 2.5 for v in G], alpha=0.6, node_color=node_color) # nx.draw_networkx_nodes(G,pos,nodelist=greater500Coll, node_size=[float(G.degree(v)) * 2.5 for v in G],alpha=0.6,node_color="#fdae61", with_labels=True, label=str(collSpecimenBreaks.bins[1]) + ' - ' + str(collSpecimenBreaks.bins[2] - 1)) # nx.draw_networkx_nodes(G,pos,nodelist=greater100Coll, node_size=[float(G.degree(v)) * 2.5 for v in G],alpha=0.6,node_color="#5e3c99", with_labels=True, label=str(collSpecimenBreaks.bins[1] -1) + ' - ' + str(collSpecimenBreaks.bins[0])) # nx.draw_networkx_nodes(G,pos,nodelist=less100Coll,node_size=[float(G.degree(v)) * 2.5 for v in G],alpha=0.6,node_color="#b2abd2", with_labels=True, label='<= ' + str(collSpecimenBreaks.bins[0] - 1)) print[float(G.degree(v)) * .8 for v in G] nx.draw_networkx_edges(G, pos, edgelist=slarge, width=[float(G.degree(v)) * .8 for v in G],
def initialize_fields(self): self.num_export_particles = ti.field(dtype=ti.i32, shape=()) self.num_export_TSDF_particles = ti.field(dtype=ti.i32, shape=()) self.num_export_ESDF_particles = ti.field(dtype=ti.i32, shape=()) self.input_R = ti.Matrix.field(3, 3, dtype=ti.f32, shape=()) self.input_T = ti.Vector.field(3, dtype=ti.f32, shape=()) self.export_x = ti.Vector.field(3, dtype=ti.f32, shape=self.max_disp_particles) self.export_color = ti.Vector.field(3, dtype=ti.f32, shape=self.max_disp_particles) self.export_TSDF = ti.field(dtype=ti.f32, shape=self.max_disp_particles) self.export_TSDF_xyz = ti.Vector.field(3, dtype=ti.f32, shape=self.max_disp_particles) self.export_ESDF = ti.field(dtype=ti.f32, shape=self.max_disp_particles) self.export_ESDF_xyz = ti.Vector.field(3, dtype=ti.f32, shape=self.max_disp_particles) self.voxel_size_ = ti.Vector([self.voxel_size, self.voxel_size, self.voxel_size]) self.map_size_ = ti.Vector([self.map_size_xy, self.map_size_xy, self.map_size_z]) self.NC_ = ti.Vector([self.N/2, self.N/2, self.Nz/2]) self.N_ = ti.Vector([self.N, self.N, self.Nz]) self.occupy = ti.field(dtype=ti.i32) self.TSDF = ti.field(dtype=ti.f32) self.W_TSDF = ti.field(dtype=ti.f32) self.ESDF = ti.field(dtype=ti.f32) self.observed = ti.field(dtype=ti.i8) self.TSDF_observed = ti.field(dtype=ti.i8) self.fixed = ti.field(dtype=ti.i8) self.parent_dir = ti.Vector.field(3, dtype=ti.i32) self.new_pcl_count = ti.field(dtype=ti.i32) self.new_pcl_sum_pos = ti.Vector.field(3, dtype=ti.f32) #position in sensor coor self.updated_TSDF = ti.field(dtype=ti.i32) if self.TEXTURE_ENABLED: self.color = ti.Vector.field(3, dtype=ti.f32) self.new_pcl_sum_color = ti.Vector.field(3, dtype=ti.f32) block_num_xy = self.block_num_xy block_num_z = self.block_num_z block_size = self.block_size self.max_queue_size = 1000000 self.raise_queue = ti.Vector.field(3, dtype=ti.i32, shape=self.max_queue_size) self.lower_queue = ti.Vector.field(3, dtype=ti.i32, shape=self.max_queue_size) self.num_raise_queue = ti.field(dtype=ti.i32, shape=()) self.num_lower_queue = ti.field(dtype=ti.i32, shape=()) self.head_lower_queue = ti.field(dtype=ti.i32, shape=()) self.head_raise_queue = ti.field(dtype=ti.i32, shape=()) self.B, self.Broot = self.data_structures(block_num_xy, block_num_z, block_size) self.B.place(self.occupy, self.W_TSDF,self.TSDF, self.TSDF_observed, self.ESDF, self.observed, self.fixed, self.parent_dir) if self.TEXTURE_ENABLED: self.B.place(self.color) self.T, self.Troot = self.data_structures_pointer(block_num_xy, block_num_z, block_size) self.T.place(self.updated_TSDF) self.PCL, self.PCLroot = self.data_structures_pointer(block_num_xy, block_num_z, block_size) self.PCL.place(self.new_pcl_count, self.new_pcl_sum_pos) if self.TEXTURE_ENABLED: self.PCL.place(self.new_pcl_sum_color) self.neighbors = [] for _di in range(-1, 2): for _dj in range(-1, 2): for _dk in range(-1, 2): if _di !=0 or _dj !=0 or _dk != 0: self.neighbors.append(ti.Vector([_di, _dj, _dk])) self.colormap = ti.Vector.field(3, float, shape=1024) self.color_rate = 2 for i in range(1024): self.colormap[i][0] = cm.bwr(i/1024.0)[0] self.colormap[i][1] = cm.bwr(i/1024.0)[1] self.colormap[i][2] = cm.bwr(i/1024.0)[2] self.init_fields()
def drawMarg(alphacolor, q, i, j, marg, J, hi, hj, score, margax, Cax, Jax): graytext = lambda x: { 'text': "{:.2f}".format(x), 'color': cm.gray_r(fnorm(x)) } bwrtext = lambda x: {'text': "{:.2f}".format(x), 'color': cm.bwr(fnorm(x))} rwbtext = lambda x: { 'text': "{:.2f}".format(x), 'color': cm.bwr_r(fnorm(x)) } mapi = alphacolor[i] mapj = alphacolor[j] for ax in (margax, Cax, Jax): ax.set_axis_off() ax.set_xlim(0, 6 + q) ax.set_ylim(0, 1 * (q + 5)) fnorm = Normalize(0, 0.1, clip=True) drawGrid(margax, 3, 1, 1, q, q, [[graytext(x) for x in r] for r in marg], mapi, mapj, '({}, {}) Bimarg'.format(i, j), list(map(graytext, sum(marg, axis=1))), list(map(graytext, sum(marg, axis=0))), labeltext=alphatext) fnorm = Normalize(-1, 1.0, clip=True) C = marg - outer(sum(marg, axis=1), sum(marg, axis=0)) Cmax = np.max(np.abs(C)) drawGrid(Cax, 3, 1, 1, q, q, [[rwbtext(x) for x in r] for r in C / Cmax], mapi, mapj, '({}, {}) C * {}'.format(i, j, str(Cmax)), None, None, labeltext=alphatext) fnorm = Normalize(-1, 1.0, clip=True) drawGrid(Jax, 3, 1, 1, q, q, [[bwrtext(x) for x in r] for r in J], mapi, mapj, '({}, {}) J score={:.2f}'.format(i, j, score), list(map(bwrtext, hi)), list(map(bwrtext, hj)), labeltext=alphatext)
def main(): # positions = [] # myfile = open("p2data.txt", "r") # for line in myfile: # positions.append((float(line[2:12]) - 0.5) * 2) # positions.append((float(line[14:24]) - 0.5) * 2) # positions.append((float(line[26:36]) - 0.5) * 2) # positions = np.array(positions, dtype=np.float32) data = np.loadtxt('p2data_v2.txt', dtype=np.float32) data[:, 0:3] = (data[:, 0:3] - 0.5) * 2 #Fake Point data[0, 0] = -0.2 data[0, 1] = 0.1 data[0, 2] = -1.0 myp = np.array([data[0, 0], data[0, 1], data[0, 2]]) data[0, 4] = 900 #End Fake Point pos = data[:, 0:3] norm = mpl.colors.Normalize(vmin=1, vmax=1000) data = np.append(data, cm.bwr(norm(data[:, 4])), axis=1) size0 = np.min(data[:, 3]) mass = size0 * np.sqrt(data[:, 3] / 30000) mass = mass.reshape(mass.shape[0], 1) mass = np.maximum(mass, 1) mass[0] = 20 data = np.delete(data, 3, 1) # drop mass data = np.delete(data, 3, 1) # drop age data = np.delete(data, 6, 1) # drop Alpha #m = np.ones((data.shape[0], 1)) #m = m * 80.0 #m[0::2] = 20.0 data = numpy.hstack((data, mass)) data = data.astype(numpy.float32) #yt region # norm = mpl.colors.Normalize(vmin=1, vmax=1000) # colors = cm.bwr(norm(age)) # colors = colors[:, 0:-1] # size0 = np.min(mass) # m = np.array(mass) / 30000 # m = size0 * np.sqrt(m) # m = np.maximum(m, 1) # m = m.reshape(m.shape[0], 1) # data = np.hstack((position, colors, m)) # data = data.astype(np.float32) pygame.init() #pygame.mouse.set_cursor(*pygame.cursors.diamond) display = (1000, 800) #display = (800, 600) aspect = display[0] / display[1] pygame.display.set_mode(display, DOUBLEBUF | OPENGL) myvao = glGenVertexArrays(1) glBindVertexArray(myvao) myvbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, myvbo) floatsize = 4 # 4 bytes, 32 bits size = floatsize * data.size glBufferData(GL_ARRAY_BUFFER, size, numpy.ravel(data), GL_STATIC_DRAW) glEnable(GL_PROGRAM_POINT_SIZE) vertexShaderSource = """ #version 330 in vec3 position; in vec3 vcolor; in float psize; uniform mat4 model; uniform mat4 view; uniform mat4 projection; uniform vec2 screenSize; uniform float spriteSize; out vec3 fcolor; void main() { gl_Position = projection * view * model * vec4(position, 1.0); gl_PointSize = psize; fcolor = vcolor; } """ fragmentShaderSource = """ #version 330 in vec3 fcolor; out vec4 FragColor; uniform sampler2D tex; void main() { vec4 texColor = texture(tex, gl_PointCoord); //texColor.a = 1.0 - texColor.r; FragColor = texColor * vec4(fcolor, 1.0); } """ shader = shaders.compileProgram( shaders.compileShader(vertexShaderSource, GL_VERTEX_SHADER), shaders.compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER)) positionAttrib = glGetAttribLocation(shader, "position") colorAttrib = glGetAttribLocation(shader, "vcolor") sizeAttrib = glGetAttribLocation(shader, "psize") #ctypes.c_void_p(offset) stride = 7 * floatsize glVertexAttribPointer(positionAttrib, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(0)) glVertexAttribPointer(colorAttrib, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(3 * floatsize)) glVertexAttribPointer(sizeAttrib, 1, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(6 * floatsize)) glEnableVertexAttribArray(positionAttrib) glEnableVertexAttribArray(colorAttrib) glEnableVertexAttribArray(sizeAttrib) numpos = int(data.shape[0]) glEnable(GL_POINT_SPRITE) #glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE) #texture textureobject = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, textureobject) #glEnable(GL_POINT_SPRITE) #glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_UPPER_LEFT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) image = Image.open("halo.jpg") width, height = image.size print(width, height) img_data = numpy.array(list(image.getdata()), numpy.uint8) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, img_data) #Rotation Around Cluster Vectors #cameraPos = Vec3(-0.739, -0.637, 0.7) #cameraTarget = Vec3(-0.739, -0.637, 0.638) deltaTime = 0.0 lastFrame = 0.0 #yaw = -90.0 yaw = 0.0 pitch = 0.0 xoffset = 0.0 yoffset = 0.0 lastX = display[0] / 2 lastY = display[1] / 2 fov = 45.0 #Initialize matrix: projection = perspective(fov, aspect, 0.1, 100) view = Mat4x4() model = Mat4x4() #Look at Vectors worldUp = Vec3(0.0, 1.0, 0.0) origin = Vec3(0.0, 0.0, 0.0) cameraPos = Vec3(0.0, 0.0, 5.0) focus = Vec3(0.0, 0.0, 0.0) frontX = math.cos(math.radians(yaw)) * math.cos(math.radians(pitch)) frontY = math.sin(math.radians(pitch)) frontZ = math.sin(math.radians(yaw)) * math.cos(math.radians(pitch)) cameraFront = Vec3(frontX, frontY, frontZ) cameraFront = normalizeVec(cameraFront) right = cross(cameraFront, worldUp) up = cross(right, cameraFront) #normalized internally delta = 0.0 delta2 = 0.0 d = 0.0 fovdelta = 0.0 pygame.mouse.set_visible(True) pygame.event.set_grab(True) middle = False #glEnable(GL_DEPTH_TEST) glEnable(GL_BLEND) #glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR) #glBlendFunc(GL_SRC_ALPHA, GL_ZERO) click = False moving = False ballradius = min(display[0] / 2, display[1] / 2) initial = True model = Mat4x4() newmodel = Mat4x4() oldmodel = Mat4x4() xoffset = 0.0 yoffset = 0.0 while True: timeValue = pygame.time.get_ticks() deltaTime = timeValue - lastFrame lastFrame = timeValue cameraSpeed = 0.009 * deltaTime #cameraSpeed = 0.2 for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() quit() if event.type == pygame.MOUSEMOTION and not initial: motion = True #print("I am moving") else: #print("NOT moving") motion = False if event.type == pygame.MOUSEMOTION and click and not moving: print("Start") moving = True xpos, ypos = pygame.mouse.get_pos() xpos = (xpos - (display[0] / 2)) ypos = ((display[1] / 2) - ypos) startRotationVector = convertXY(xpos, ypos, ballradius) startRotationVector = normalize(startRotationVector) if event.type == pygame.MOUSEBUTTONDOWN: if event.button == 1: #Left Click Down #Enable Rotate Mode print("Left Click down") click = True if event.button == 4: # ZOOM IN if middle: print("ZOOM IN") fovdelta = -.2 if event.button == 5: # ZOOM OUT if middle: print("ZOOM OUT") fovdelta = 0.2 if event.button == 2: middle = True if event.button == 3: #Reset initial conditions deltaTime = 0.0 lastFrame = 0.0 initial = True #yaw = -90.0 yaw = 0.0 pitch = 0.0 xoffset = 0.0 yoffset = 0.0 lastX = display[0] / 2 lastY = display[1] / 2 fov = 45.0 projection = perspective(fov, aspect, 0.1, 100) view = Mat4x4() model = Mat4x4() #Look at Vectors worldUp = Vec3(0.0, 1.0, 0.0) origin = Vec3(0.0, 0.0, 0.0) cameraPos = Vec3(0.0, 0.0, 5.0) focus = Vec3(0.0, 0.0, 0.0) frontX = math.cos(math.radians(yaw)) * math.cos( math.radians(pitch)) frontY = math.sin(math.radians(pitch)) frontZ = math.sin(math.radians(yaw)) * math.cos( math.radians(pitch)) cameraFront = Vec3(frontX, frontY, frontZ) cameraFront = normalizeVec(cameraFront) right = cross(cameraFront, worldUp) up = cross(right, cameraFront) #normalized internally delta = 0.0 delta2 = 0.0 d = 0.0 fovdelta = 0.0 middle = False click = False moving = False ballradius = min(display[0] / 2, display[1] / 2) initial = True model = Mat4x4() newmodel = Mat4x4() oldmodel = Mat4x4() xoffset = 0.0 yoffset = 0.0 #Right Click to exit #pygame.quit() #quit() if event.type == pygame.MOUSEBUTTONUP: if event.button == 1: #Left Click Up print("STOP") click = False moving = False initial = True if event.button == 2: middle = False print("DONE") fovdelta = 0 if event.type == pygame.KEYDOWN: if event.key == K_q: pygame.quit() quit() if event.key == pygame.K_LEFT: delta = right * 0.01 #delta = cross(cameraFront, up) * cameraSpeed * -1 #cameraPos -= cross(cameraFront, up) * cameraSpeed if event.key == pygame.K_RIGHT: delta = right * 0.01 * -1 #delta = cross(cameraFront, up) * cameraSpeed #cameraPos += cross(cameraFront, up) * cameraSpeed if event.key == pygame.K_UP: d = 0.01 delta2 = 0.01 * -1 * camFocus #delta = cameraSpeed * cameraFront #cameraPos += cameraSpeed * cameraFront if event.key == pygame.K_DOWN: d = 0.01 * -1 delta2 = 0.01 * camFocus #delta = cameraSpeed * cameraFront * -1 #cameraPos -= cameraSpeed * cameraFront if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT: #print(delta) delta = Vec3(0.0, 0.0, 0.0) if event.key == pygame.K_RIGHT: #print(delta) delta = Vec3(0.0, 0.0, 0.0) if event.key == pygame.K_UP: d = 0.0 delta2 = Vec3(0.0, 0.0, 0.0) if event.key == pygame.K_DOWN: d = 0.0 delta2 = Vec3(0.0, 0.0, 0.0) glClear(GL_COLOR_BUFFER_BIT) #glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) glUseProgram(shader) glBindTexture(GL_TEXTURE_2D, textureobject) #Ray Tracing xpos, ypos = pygame.mouse.get_pos() #OpenGL Viewport, lower left is (0,0) #In Window Coordinates top left is (0,0) ypos = display[1] - ypos #xpos = (xpos - (display[0] / 2)) #ypos = ((display[1] / 2) - ypos) #viewport = np.zeros((4, 1)) viewport = np.array(glGetIntegerv(GL_VIEWPORT)) m = convertnp(model) v = convertnp(view) mv = np.matmul(v, m) p = convertnp(projection) xyz_n = np.array(gluUnProject(xpos, ypos, 0.0, mv, p, viewport)) xyz_f = np.array(gluUnProject(xpos, ypos, 1.0, mv, p, viewport)) #Line Segment xyz_n and xyz_f #Pos: all points #Q: Points on line segment closest all points in Pos ray = xyz_f - xyz_n ray_dot = np.dot(ray, ray) p = pos - xyz_n p_ray_dot = np.dot(p, ray) t = p_ray_dot / ray_dot z = np.matmul(np.reshape(t, (t.shape[0], 1)), np.reshape(ray, (3, 1)).T) q = xyz_n + z dist = np.linalg.norm(q - pos, axis=1) mindist = np.min(dist) #print(mindist) if (mindist < 0.02): pygame.mouse.set_cursor(*pygame.cursors.diamond) else: pygame.mouse.set_cursor(*pygame.cursors.arrow) #pLine = getPoint(xyz_n, xyz_f, myp) #dist = pLine - myp #x = np.linalg.norm(dist) # print(x) # if(x < 0.02): # z = 5 # pygame.mouse.set_cursor(*pygame.cursors.diamond) # else: # pygame.mouse.set_cursor(*pygame.cursors.arrow) #Transform # xpos, ypos = pygame.mouse.get_pos() # #xpos = (xpos/ (display[0] / 2)) - 1 # #ypos = ((ypos / (display[1] / 2)) - 1) # screen_vec = np.zeros((4,1)) # screen_vec[0, 0] = xpos # screen_vec[1, 0] = ypos # screen_vec[2, 0] = 0.0 # screen_vec[3, 0] = 1.0 # #Front XYZ in world coordinates # p = convertnp(projection) # v = convertnp(view) # m = convertnp(model) # pi = np.linalg.inv(p) # vi = np.linalg.inv(v) # mi = np.linalg.inv(m) # z = np.matmul(mi, np.matmul(vi, np.matmul(pi, screen_vec) ) ) # print(z) #print(z[-1]) #z = z[:-1] #zg = z * -1 #z = z[:-1] / np.linalg.norm(z[:-1]) if moving: xoffset = 0.0 yoffset = 0.0 #update Rotation Vector xpos, ypos = pygame.mouse.get_pos() xpos = (xpos - (display[0] / 2)) ypos = ((display[1] / 2) - ypos) currentRotationVector = convertXY(xpos, ypos, ballradius) currentRotationVector = normalize(currentRotationVector) diff = currentRotationVector - startRotationVector mag = math.sqrt((diff.x) * (diff.x) + (diff.y) * (diff.y) + (diff.z) * (diff.z)) if mag > 1E-6: rotationAxis = cross(currentRotationVector, startRotationVector) #normalized val = dotVec(currentRotationVector, startRotationVector) if val > (1 - 1E-10): val = 1.0 rotationAngle = math.degrees(math.acos(val)) axis = Vec3(-rotationAxis.x, -rotationAxis.y, -rotationAxis.z) newmodel = Mat4x4() newmodel = rotate(newmodel, rotationAngle * 2, axis) else: oldmodel = model newmodel = Mat4x4() model = newmodel.__mul__(oldmodel) modelList = convert(model) modelLoc = glGetUniformLocation(shader, "model") glUniformMatrix4fv(modelLoc, 1, GL_FALSE, modelList) view = Mat4x4() #view = translate(view, Vec4(0.0, 0.0, -3.0, 0.0)) #view = translate(view, Vec4(0.739, 0.637, -0.7, 0.0)) #Rotation Around Cluster #radius = 0.2 #camX = -0.739 + math.sin(timeValue) * radius #camZ = 0.638 + math.cos(timeValue) * radius #cameraPos = Vec3(camX, -0.637, camZ) #view = lookAt(cameraPos, cameraTarget, up) if not moving: xpos, ypos = pygame.mouse.get_pos() if xpos > display[0] - 5 or ypos > display[ 1] - 5 or xpos < 5 or ypos < 5: pygame.mouse.set_pos(display[0] / 2, display[1] / 2) xoffset = 0 yoffset = 0 lastX = display[0] / 2 lastY = display[1] / 2 if initial: pygame.mouse.set_pos(display[0] / 2, display[1] / 2) xoffset = 0 yoffset = 0 lastX = display[0] / 2 lastY = display[1] / 2 initial = False oldV = Mat4x4() else: xoffset = xpos - lastX yoffset = ypos - lastY lastX = xpos lastY = ypos #xoffset, yoffset = pygame.mouse.get_rel() sensitivity = 0.3 xoffset *= sensitivity yoffset *= -1 yoffset *= sensitivity yaw = xoffset pitch = yoffset maxAngle = 89 if pitch > maxAngle: pitch = maxAngle if pitch < maxAngle * -1: pitch = maxAngle * -1 #cameraPos += delta #cameraPos = cameraPos + (d * cameraFront) frontX = math.cos(math.radians(yaw)) * math.cos(math.radians(pitch)) frontY = math.sin(math.radians(pitch)) frontZ = math.sin(math.radians(yaw)) * math.cos(math.radians(pitch)) #cameraFront = Vec3(frontX, frontY, frontZ) #cameraFront = near - cameraPos # print(near) # print(loc) #cameraFront = normalizeVec(cameraFront) #right = cross(cameraFront, worldUp) #normalized #up = cross(right, cameraFront) # # view = lookAt(cameraPos, normalizeVec(near), up) #view = lookAt(cameraPos, cameraPos + cameraFront, up) #viewList = convert(view) #viewLoc = glGetUniformLocation(shader, "view") #glUniformMatrix4fv(viewLoc, 1, GL_FALSE, viewList) #print(cameraSpeed) focus += delta cameraPos += delta + delta2 #print(cameraPos) camFocus = cameraPos - focus right = cross(normalizeVec(camFocus), worldUp) #print(focus) up = cross(right, normalizeVec(camFocus)) r = Mat4x4() r = rotate(r, yaw, up) r = rotate(r, pitch, right) r = convertnp(r) cf = np.array([camFocus.x, camFocus.y, camFocus.z, 1]) cf = np.matmul(r, cf.T) cf = Vec3(cf[0], cf[1], cf[2]) new_cameraPos = cf + focus view = lookAt(new_cameraPos, focus, up) cameraPos = new_cameraPos viewList = convert(view) viewLoc = glGetUniformLocation(shader, "view") glUniformMatrix4fv(viewLoc, 1, GL_FALSE, viewList) #Projection projection = Mat4x4() fov += fovdelta if fov <= 1.0: fov = 1.0 print("MAX ZOOM REACHED") if fov >= 45.0: fov = 45.0 projection = perspective(fov, aspect, 0.1, 100) projectionList = convert(projection) projectionLoc = glGetUniformLocation(shader, "projection") glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, projectionList) glBindVertexArray(myvao) #glPointSize(20.0) glDrawArrays(GL_POINTS, 0, numpos) #glDrawElements(GL_POINTS, 3 , GL_UNSIGNED_INT, 0) pygame.display.flip()
esmall=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] <= collEdgeCount.bins[1] and u not in remove and v not in remove] # print esmall # print remove # # sys.exit() # pos=nx.spring_layout(G, k=.5,iterations=20, weight=20) # positions for all nodes # pos = nx.graphviz_layout(G, prog='neato') pos=nx.spring_layout(G, weight=20) # positions for all nodes # pos=nx.circular_layout(G) # positions for all nodes G.remove_nodes_from(remove) # cm.Spectral(betc_value) node_color = [cm.bwr(G.degree(v)) for v in G] # nodes nx.draw_networkx_nodes(G,pos, node_size=[float(G.degree(v)) * 2.5 for v in G], alpha=0.6, node_color=node_color) # nx.draw_networkx_nodes(G,pos,nodelist=greater500Coll, node_size=[float(G.degree(v)) * 2.5 for v in G],alpha=0.6,node_color="#fdae61", with_labels=True, label=str(collSpecimenBreaks.bins[1]) + ' - ' + str(collSpecimenBreaks.bins[2] - 1)) # nx.draw_networkx_nodes(G,pos,nodelist=greater100Coll, node_size=[float(G.degree(v)) * 2.5 for v in G],alpha=0.6,node_color="#5e3c99", with_labels=True, label=str(collSpecimenBreaks.bins[1] -1) + ' - ' + str(collSpecimenBreaks.bins[0])) # nx.draw_networkx_nodes(G,pos,nodelist=less100Coll,node_size=[float(G.degree(v)) * 2.5 for v in G],alpha=0.6,node_color="#b2abd2", with_labels=True, label='<= ' + str(collSpecimenBreaks.bins[0] - 1)) print [float(G.degree(v)) * .8 for v in G] nx.draw_networkx_edges(G,pos,edgelist=slarge, width=[float(G.degree(v)) * .8 for v in G],alpha=0.6,edge_color='#E71D36', style='solid', label=str(collEdgeCount.bins[1]) + ' - ' + str(collEdgeCount.bins[0] + 1)) nx.draw_networkx_edges(G,pos,edgelist=elarge, width=.8,alpha=.4,edge_color='#FF9F1C', style='solid', label=str(collEdgeCount.bins[1]) + ' - ' + str(collEdgeCount.bins[0] + 1)) # edges nx.draw_networkx_edges(G,pos,edgelist=esmall, width=.7,alpha=0.3,edge_color='#32936F', style='dashed' , label='<= ' + str(collEdgeCount.bins[0]))
brain = Brain("fsaverage", "lh", "inflated", views=['lat', 'med'], background="white") CIs = np.loadtxt('/Volumes/neuro/Rest/ROIs/Gordon_consensus_CI') coords = np.loadtxt('/Volumes/neuro/Rest/ROIs/Gordon_coordinates') WMD = np.loadtxt('//Volumes/neuro/Rest/Thalamic_parcel/roiWMD') WMD = WMD/100 WMD = WMD+1.5 WMD[WMD<0] =0 WMD = WMD/3 WMD[WMD>1] = 1 from matplotlib import cm for i, coord in enumerate(coords): if CIs[i] != 0: if coord[0] < 0: #if wmd[i] > 80: brain.add_foci(coord, map_surface="white", color=cm.bwr(int(WMD[i]*255))[0:3]) brain.save_image("WMD_lat.tiff") ### to visualize hubs subject_id = "fsaverage" subjects_dir = os.environ["SUBJECTS_DIR"] brain = Brain("fsaverage", "rh", "inflated", views=['lat', 'med'], background="white") coords = np.loadtxt('/Volumes/neuro/Rest/ROIs/Gordon_coordinates') PC = np.loadtxt('//Volumes/neuro/Rest/Thalamic_parcel/roipc') wmd = np.loadtxt('//Volumes/neuro/Rest/Thalamic_parcel/wmdroi') for i, coord in enumerate(coords): if coord[0] > 0: if wmd[i] > 80:
def compute_fret_efficiency(self, image_manager, cells_manager): heatmap = np.zeros(image_manager.phase_image.shape) print "computing FRET Efficiency" cell_average_E = [] cyto_average_E = [] membrane_average_E = [] septum_average_E = [] membsept_average_E = [] for key in self.both_cells: ################################################################### # Whole Cell Calculations x0, y0, x1, y1 = cells_manager.cells[key].box cell_mask = cells_manager.cells[key].cell_mask donor_cell_image = image_manager.donor_image[x0:x1 + 1, y0:y1 + 1] * cell_mask donor_cell_image = donor_cell_image - self.autofluorescence_donor - cells_manager.cells[ key].stats["Baseline Donor"] donor_cell_image = donor_cell_image * (donor_cell_image > 0) nonzero_donor = np.nonzero(donor_cell_image) acceptor_cell_image = image_manager.acceptor_image[x0:x1 + 1, y0:y1 + 1] * cell_mask acceptor_cell_image = acceptor_cell_image - self.autofluorescence_acceptor - cells_manager.cells[ key].stats["Baseline Acceptor"] acceptor_cell_image = acceptor_cell_image * (acceptor_cell_image > 0) nonzero_acceptor = np.nonzero(acceptor_cell_image) fret_cell_image = image_manager.fret_image[x0:x1 + 1, y0:y1 + 1] * cell_mask fret_cell_image = fret_cell_image - self.autofluorescence_fret - cells_manager.cells[ key].stats["Baseline FRET"] fret_cell_image = fret_cell_image * (fret_cell_image > 0) nonzero_fret = np.nonzero(fret_cell_image) # TODO discuss if we shoudld use this pixels anyway cell_nonzero_ix = list( set(zip(list(nonzero_acceptor[0]), list(nonzero_acceptor[1]))).intersection( zip(list(nonzero_donor[0]), list(nonzero_donor[1]))).intersection( zip(list(nonzero_fret[0]), list(nonzero_fret[1])))) e_values = [] for ix in cell_nonzero_ix: Iaa = (self.fret_d * acceptor_cell_image[ix] - self.fret_c * fret_cell_image[ix]) / ( self.fret_d - self.fret_c * self.fret_a) Idd = (self.fret_a * donor_cell_image[ix] - self.fret_b * fret_cell_image[ix]) / ( self.fret_a - self.fret_b * self.fret_d) Fc = fret_cell_image[ix] - self.fret_a * Iaa - self.fret_d * Idd e = (Fc / self.fret_G) / (Idd + (Fc / self.fret_G)) e_values.append(e) x, y = ix heatmap[x0 + x, y0 + y] = e if len(e_values) > 0: average = np.average(e_values) cell_average_E.append(average) cells_manager.cells[key].stats["Cell E"] = average else: cells_manager.cells[key].stats["Cell E"] = 0 ################################################################### # Membrane Calculations cell_mask = cells_manager.cells[key].perim_mask donor_cell_image = image_manager.donor_image[x0:x1 + 1, y0:y1 + 1] * cell_mask donor_cell_image = donor_cell_image - self.autofluorescence_donor - cells_manager.cells[ key].stats["Baseline Donor"] donor_cell_image = donor_cell_image * (donor_cell_image > 0) nonzero_donor = np.nonzero(donor_cell_image) acceptor_cell_image = image_manager.acceptor_image[x0:x1 + 1, y0:y1 + 1] * cell_mask acceptor_cell_image = acceptor_cell_image - self.autofluorescence_acceptor - cells_manager.cells[ key].stats["Baseline Acceptor"] acceptor_cell_image = acceptor_cell_image * (acceptor_cell_image > 0) nonzero_acceptor = np.nonzero(acceptor_cell_image) fret_cell_image = image_manager.fret_image[x0:x1 + 1, y0:y1 + 1] * cell_mask fret_cell_image = fret_cell_image - self.autofluorescence_fret - cells_manager.cells[ key].stats["Baseline FRET"] fret_cell_image = fret_cell_image * (fret_cell_image > 0) nonzero_fret = np.nonzero(fret_cell_image) # TODO discuss if we shoudld use this pixels anyway membrane_nonzero_ix = list( set(zip(list(nonzero_acceptor[0]), list(nonzero_acceptor[1]))).intersection( zip(list(nonzero_donor[0]), list(nonzero_donor[1]))).intersection( zip(list(nonzero_fret[0]), list(nonzero_fret[1])))) membrane_e_values = [] for ix in membrane_nonzero_ix: Iaa = (self.fret_d * acceptor_cell_image[ix] - self.fret_c * fret_cell_image[ix]) / ( self.fret_d - self.fret_c * self.fret_a) Idd = (self.fret_a * donor_cell_image[ix] - self.fret_b * fret_cell_image[ix]) / ( self.fret_a - self.fret_b * self.fret_d) Fc = fret_cell_image[ix] - self.fret_a * Iaa - self.fret_d * Idd e = (Fc / self.fret_G) / (Idd + (Fc / self.fret_G)) membrane_e_values.append(e) x, y = ix if len(membrane_e_values) > 0: average = np.average(membrane_e_values) membrane_average_E.append(average) cells_manager.cells[key].stats["Membrane E"] = average else: cells_manager.cells[key].stats["Membrane E"] = 0 ################################################################### # Cytoplasm Calculations cell_mask = cells_manager.cells[key].cyto_mask donor_cell_image = image_manager.donor_image[x0:x1 + 1, y0:y1 + 1] * cell_mask donor_cell_image = donor_cell_image - self.autofluorescence_donor - cells_manager.cells[ key].stats["Baseline Donor"] donor_cell_image = donor_cell_image * (donor_cell_image > 0) nonzero_donor = np.nonzero(donor_cell_image) acceptor_cell_image = image_manager.acceptor_image[x0:x1 + 1, y0:y1 + 1] * cell_mask acceptor_cell_image = acceptor_cell_image - self.autofluorescence_acceptor - cells_manager.cells[ key].stats["Baseline Acceptor"] acceptor_cell_image = acceptor_cell_image * (acceptor_cell_image > 0) nonzero_acceptor = np.nonzero(acceptor_cell_image) fret_cell_image = image_manager.fret_image[x0:x1 + 1, y0:y1 + 1] * cell_mask fret_cell_image = fret_cell_image - self.autofluorescence_fret - cells_manager.cells[ key].stats["Baseline FRET"] fret_cell_image = fret_cell_image * (fret_cell_image > 0) nonzero_fret = np.nonzero(fret_cell_image) # TODO discuss if we shoudld use this pixels anyway cyto_nonzero_ix = list( set(zip(list(nonzero_acceptor[0]), list(nonzero_acceptor[1]))).intersection( zip(list(nonzero_donor[0]), list(nonzero_donor[1]))).intersection( zip(list(nonzero_fret[0]), list(nonzero_fret[1])))) cyto_e_values = [] for ix in cyto_nonzero_ix: Iaa = (self.fret_d * acceptor_cell_image[ix] - self.fret_c * fret_cell_image[ix]) / ( self.fret_d - self.fret_c * self.fret_a) Idd = (self.fret_a * donor_cell_image[ix] - self.fret_b * fret_cell_image[ix]) / ( self.fret_a - self.fret_b * self.fret_d) Fc = fret_cell_image[ix] - self.fret_a * Iaa - self.fret_d * Idd e = (Fc / self.fret_G) / (Idd + (Fc / self.fret_G)) cyto_e_values.append(e) x, y = ix if len(cyto_e_values) > 0: average = np.average(cyto_e_values) cyto_average_E.append(average) cells_manager.cells[key].stats["Cytoplasm E"] = average else: cells_manager.cells[key].stats["Cytoplasm E"] = 0 ################################################################### # Septum Calculations if cells_manager.cells[key].has_septum: x0, y0, x1, y1 = cells_manager.cells[key].box sept_mask = cells_manager.cells[key].sept_mask donor_cell_image = image_manager.donor_image[x0:x1 + 1, y0:y1 + 1] * sept_mask donor_cell_image = donor_cell_image - self.autofluorescence_donor - cells_manager.cells[ key].stats["Baseline Donor"] donor_cell_image = donor_cell_image * (donor_cell_image > 0) nonzero_donor = np.nonzero(donor_cell_image) acceptor_cell_image = image_manager.acceptor_image[ x0:x1 + 1, y0:y1 + 1] * sept_mask acceptor_cell_image = acceptor_cell_image - self.autofluorescence_acceptor - cells_manager.cells[ key].stats["Baseline Acceptor"] acceptor_cell_image = acceptor_cell_image * ( acceptor_cell_image > 0) nonzero_acceptor = np.nonzero(acceptor_cell_image) fret_cell_image = image_manager.fret_image[x0:x1 + 1, y0:y1 + 1] * sept_mask fret_cell_image = fret_cell_image - self.autofluorescence_fret - cells_manager.cells[ key].stats["Baseline FRET"] fret_cell_image = fret_cell_image * (fret_cell_image > 0) nonzero_fret = np.nonzero(fret_cell_image) # TODO discuss if we shoudld use this pixels anyway septum_nonzero_ix = list( set( zip(list(nonzero_acceptor[0]), list(nonzero_acceptor[1]))).intersection( zip(list(nonzero_donor[0]), list(nonzero_donor[1]))).intersection( zip(list(nonzero_fret[0]), list(nonzero_fret[1])))) septum_e_values = [] for ix in septum_nonzero_ix: Iaa = (self.fret_d * acceptor_cell_image[ix] - self.fret_c * fret_cell_image[ix]) / ( self.fret_d - self.fret_c * self.fret_a) Idd = (self.fret_a * donor_cell_image[ix] - self.fret_b * fret_cell_image[ix]) / ( self.fret_a - self.fret_b * self.fret_d) Fc = fret_cell_image[ ix] - self.fret_a * Iaa - self.fret_d * Idd e = (Fc / self.fret_G) / (Idd + (Fc / self.fret_G)) septum_e_values.append(e) if len(septum_e_values) > 0: average = np.average(septum_e_values) septum_average_E.append(average) cells_manager.cells[key].stats["Septum E"] = average else: cells_manager.cells[key].stats["Septum E"] = 0 ################################################################### # MembSept Calculations membsept_e_values = [] membsept_e_values.extend(membrane_e_values) membsept_e_values.extend(septum_e_values) if len(membsept_e_values) > 0: average = np.average(membsept_e_values) membsept_average_E.append(average) cells_manager.cells[key].stats["MembSept E"] = average else: cells_manager.cells[key].stats["MembSept E"] = 0 else: cells_manager.cells[key].stats["MembSept E"] = 0 phase_img = image_manager.phase_image phase_img = img_as_float(gray2rgb(phase_img)) ht_ix = np.nonzero(heatmap > 0) ht_ix = zip(list(ht_ix[0]), list(ht_ix[1])) min_val = 0 max_val = 100 for ix in ht_ix: cm_ix = int( ((heatmap[ix] + np.sqrt(min_val * min_val)) * 256) / (max_val + np.sqrt(min_val * min_val))) color = np.array(cm.bwr(cm_ix)[:3]) phase_img[ix] = color self.cell_E = np.median(cell_average_E) self.cyto_E = np.median(cyto_average_E) self.membrane_E = np.median(membrane_average_E) self.membsept_E = np.median(membsept_average_E) self.septum_E = np.median(septum_average_E) self.fret_heatmap = phase_img
axHist.text(-0.15, 0.95, 'c', transform=axHist.transAxes, fontsize=14, fontweight='bold') if len(zUppers) > 6: nOneSide = (len(zUppers) - 1) / 2 colorsOneSide = numpy.array( [cm.cool(x) for x in numpy.linspace(0.0, 1.0, nOneSide)]) #print colorsOneSide else: nOneSide = 2 colorsOneSide = numpy.flip( numpy.array([cm.bwr(x) for x in numpy.linspace(0.0, 1.0, nOneSide)]), 0) colors = numpy.vstack((colorsOneSide, [0, 0, 0, 1], numpy.flip(colorsOneSide, 0))) colors = numpy.vstack((colorsOneSide, [0, 0, 0, 1], numpy.flip(colorsOneSide, 0))) for zUpper in zUppers: iDepth = iDepth + 1 print "iDepth={}, zUpper={}".format(iDepth, zUpper) z = numpy.linspace(0., zLow, 1001) zLower = zUpper - 400. TRegional = numpy.zeros(z.shape)
def att2img(attribution): return np.uint8( cm.bwr((np.clip(to_numpy(attribution) / MAXV, -1, 1) + 1) / 2) * 255)[:, :, :3]
def analyze_features(self, coef_removed): N_train = self.train[0].shape[0] norm_coef = norm(coef_removed, axis=1) light_loss = np.zeros((N_train, 3, 2)) # [[MAX, MIN, TOT]_focus, [MAX, MIN, TOT]_defocus] train_noisy, train_clean = self.train for k in range(N_train): input_focus = train_noisy[k, :N_crop**2].reshape((N_crop, N_crop)) output_focus = train_clean[k, :N_crop**2].reshape((N_crop, N_crop)) feat_focus = input_focus - output_focus light_loss[k, :, 0] = np.array([feat_focus.max(), feat_focus.min(), np.sum(feat_focus)]) input_defocus = train_noisy[k, N_crop**2:].reshape((N_crop, N_crop)) output_defocus = train_clean[k, N_crop**2:].reshape((N_crop, N_crop)) feat_defocus = input_defocus - output_defocus light_loss[k, :, 1] = np.array([feat_defocus.max(), feat_defocus.min(), np.sum(feat_defocus)]) peaks_focus, mins_focus, losses_focus = light_loss[:, 0, 0], light_loss[:, 1, 0], light_loss[:, 2, 0] f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, sharey=True) # Focused PSF p_sort = np.argsort(peaks_focus) ax1.scatter(norm_coef[p_sort], np.sort(peaks_focus), color=cm.bwr(np.linspace(0.5 + np.min(peaks_focus), 1, N_train)), s=4, label='Maxima') m_sort = np.argsort(mins_focus) ax1.scatter(norm_coef[m_sort], np.sort(mins_focus), color=cm.bwr(np.linspace(0, 0.5, N_train)), s=4, label='Minima') loss_sort = np.argsort(losses_focus) ax1.legend(loc=2) leg = ax1.get_legend() leg.legendHandles[0].set_color('red') leg.legendHandles[1].set_color('blue') ax1.axhline(y=0.0, linestyle='--', color='black') ax1.set_title('Nominal PSF') ax1.set_ylabel(r'Light loss') ax1.set_ylim([-0.5, 0.5]) ax3.scatter(norm_coef[loss_sort], np.sort(losses_focus), color='black', s=3, label='Total') ax3.legend(loc=2) ax3.axhline(y=0.0, linestyle='--', color='black') ax3.set_xlabel(r'Norm of low orders $\Vert a_{low} \Vert$') ax3.set_ylabel(r'Light loss') # Defocused PSF peaks_defocus, mins_defocus, losses_defocus = light_loss[:, 0, 1], light_loss[:, 1, 1], light_loss[:, 2, 1] p_sort = np.argsort(losses_defocus) ax2.scatter(norm_coef[p_sort], np.sort(peaks_defocus), color=cm.bwr(np.linspace(0.5 + np.min(peaks_defocus), 1, N_train)), s=4, label='Maxima') m_sort = np.argsort(mins_defocus) ax2.scatter(norm_coef[m_sort], np.sort(mins_defocus), color=cm.bwr(np.linspace(0, 0.5, N_train)), s=4, label='Minima') loss_sort = np.argsort(losses_defocus) ax2.legend(loc=2) leg = ax2.get_legend() leg.legendHandles[0].set_color('red') leg.legendHandles[1].set_color('blue') ax2.axhline(y=0.0, linestyle='--', color='black') ax2.set_title('Defocused PSF') ax4.scatter(norm_coef[loss_sort], np.sort(losses_defocus), color='black', s=3, label='Total') ax4.legend(loc=2) ax4.axhline(y=0.0, linestyle='--', color='black') ax4.set_xlabel(r'Norm of low orders $\Vert a_{low} \Vert$')