def draw_imgs(prefix, ratio, mode): lfw = load_lfw(prefix) frames = 0 _X = list() _Y = list() _Z = list() iters = list() threds = list() accs = list() alphas = list() betas = list() gammas = list() for _iter in xrange(1000, 200000 + 1, 1000): _iter1, _thred1, _acc1 = lfw[_iter / 10000] _iter2, _thred2, _acc2 = lfw[_iter / 10000 + 1] _thred = _thred1 + (_thred2 - _thred1) * (_iter - _iter1) / max( 1, (_iter2 - _iter1)) _acc = _acc1 + (_acc2 - _acc1) * (_iter - _iter1) / max( 1, (_iter2 - _iter1)) iters.append(_iter) threds.append(_thred) accs.append(_acc) log_file = "./data/%s_%d.txt" % (prefix, _iter) if not os.path.exists(log_file): print "miss: %s" % log_file continue lines = open(log_file).readlines() # pdf pdf = list() for line in lines[3:bins + 3]: item = line.strip().split() item = map(lambda x: float(x), item) pdf.append(item[1]) # clean pdf clean_pdf = list() for line in lines[bins + 3 + 1:bins + bins + 3 + 1]: item = line.strip().split() item = map(lambda x: float(x), item) clean_pdf.append(item[1]) # noise pdf noise_pdf = list() for line in lines[bins + bins + 3 + 1 + 1:bins + bins + bins + 3 + 1 + 1]: item = line.strip().split() item = map(lambda x: float(x), item) noise_pdf.append(item[1]) # pcf pcf = list() for line in lines[bins + bins + bins + 3 + 1 + 1 + 1:bins + bins + bins + bins + 3 + 1 + 1 + 1]: item = line.strip().split() item = map(lambda x: float(x), item) pcf.append(item[1]) # weight W = list() for line in lines[bins + bins + bins + bins + 3 + 1 + 1 + 1 + 1:bins + bins + bins + bins + bins + 3 + 1 + 1 + 1 + 1]: item = line.strip().split() item = map(lambda x: float(x), item) W.append(item[1]) X = list() for i in xrange(bins): X.append(i * 0.01 - 1.0) _X.append(X) _Y.append(bins * [_iter]) _Z.append(mean_filter(pdf)) if not choose_iter(_iter, 1000): continue titlesize = 44 asize = 44 glinewidth = 2 fig = plt.figure(0) fig.set_size_inches(24, 18) ax = Axes3D(fig) #ax.set_title(r"$The\ cos\theta\ distribution\ of\ $" + str(ratio) + "%" + r"$\ noisy\ training\ data\ over\ iteration$", fontsize=titlesize) ax.set_xlabel(r"$cos\theta$", fontsize=asize) ax.set_ylabel(r"$Iter$", fontsize=asize) ax.set_zlabel(r"$Numbers$", fontsize=asize) ax.tick_params(labelsize=32) ax.set_xlim(-1.0, 1.0) ax.set_ylim(0, 200000) ax.set_zlim(0.0, 6000.0) ax.grid(True, linewidth=glinewidth) surf = ax.plot_surface(_X, _Y, _Z, rstride=3, cstride=3, cmap=plt.cm.coolwarm, linewidth=0.1, antialiased=False) surf.set_clim([0, 6000]) cbar = fig.colorbar(surf, shrink=0.5, aspect=10, norm=plt.Normalize(0, 6000)) cbar.set_ticks([0, 1000, 2000, 3000, 4000, 5000, 6000]) cbar.set_ticklabels(["0", "1k", "2k", "3k", "4k", "5k", "6k"]) #cbar.locator = ticker.MaxNLocator(nbins=6) #cbar.update_ticks() cbar.ax.tick_params(labelsize=24) #print dir(ax) #_ax = ax.twiny() #_ax.set_ylim(0.0, 1.0) #_ax.plot(bins * [-1.0], iters, accs, label="LFW") #_ax.legend() #ax.plot(len(iters) * [-1.0], iters, 100.0 * np.array(accs), color="k", label="LFW") #ax.plot(len(iters) * [-1.0], iters, 60.0 * np.array(accs), color="k", label="LFW") #ax.legend() plt.savefig("./figures/%s_3D_dist_%d.jpg" % (prefix, _iter)) plt.close() frames += 1 print "frames:", frames print "processed:", _iter sys.stdout.flush()
def tecplot2data(f, oszb, st_sz, filtering, filter): print(f'Generating data from {f} with stencil {st_sz[0]}x{st_sz[1]}') if os.path.isfile(os.path.join(f, 'res', 'oscillation.dat')): file_name = os.path.join(f, 'res', 'oscillation.dat') elif os.path.isfile(os.path.join(f, 'res', 'staticbubble.dat')): file_name = os.path.join(f, 'res', 'staticbubble.dat') elif os.path.isfile(os.path.join(f, 'res', 'gravitational.dat')): file_name = os.path.join(f, 'res', 'gravitational.dat') else: print('file not found') with open(file_name, 'r') as myfile: data = myfile.read() # Append 'zone t' to file for capturing blocks later data = data + '\nZONE T' # Get variables variables = re.split( r'"\n"', re.search(r'(?<=VARIABLES = ")\w+("\n"\w+)+(?=")', data)[0]) # Bei StaticBubble müssen die nächsten beiden Zeilen auskommentiert werden # variables.remove('X') # variables.remove('Y') n_vars = len(variables) # Get gs gs = [ int(i) for i in re.findall(r'\d+', re.search(r'I=\d+, J=\d+, K=\d+', data)[0]) ] [gs[0], gs[1], gs[2]] = [gs[1], gs[0], gs[2]] # Get all timesteps (blocks) blocks = re.findall(r'ZONE\sT[\d\D]+?(?=ZONE\sT)', data) print(f'len(blocks):\t{len(blocks)}') # Remove first block (no information) # blocks = blocks[1:] # Get x/y from first block # coordinates = {} # block = blocks[1] block = blocks[0] numbers = np.array(re.findall(r'(\-?\d\.\d+E[\+\-]\d{2})', block)) # print(f'len(numbers):\t{len(numbers)}') print(f'gs:\t{gs}') coordinates = np.empty((2, gs[0], gs[1], gs[2])) # Get x coordinates coordinates[0, :, :, :] = np.reshape(numbers[:np.prod(gs)], (gs[0], gs[1], gs[2])) # Get y coordinates coordinates[1, :, :, :] = np.reshape( numbers[np.prod(gs):2 * np.prod(gs)], (gs[0], gs[1], gs[2])) max_x = np.max(coordinates[0, :, :, :]) max_y = np.max(coordinates[1, :, :, :]) delta = max_x / (gs[0] - 1) coordinates = np.reshape(coordinates[:, :, :, 0], (2, gs[0], gs[1])) # Coordinates are messed up, make own coordinate matrix coordinates = np.empty((2, gs[0] - 1, gs[1] - 1)) cord_vec = np.reshape(np.array(range(0, gs[0] - 1) * delta), (gs[0] - 1, 1)) print(f'cord_vec.shape:\t{cord_vec.shape}') coordinates[0, :, :] = cord_vec cord_vec = np.reshape(np.array(range(0, gs[1] - 1) * delta), (gs[1] - 1, 1)) coordinates[1, :, :] = np.flip(cord_vec.T) ''' cord_vec = np.reshape(np.array(range(0, gs[0]-1)*delta), (gs[0]-1, 1)) coordinates[0, :, :] = cord_vec.T coordinates[1, :, :] = np.flip(cord_vec) ''' # print('Blocks abgeschnitten!') # blocks = blocks[:1] print(f'len(numbers):\t{len(numbers)}') print(f'2*np.prod(gs):\t{2*np.prod(gs)}') values = np.empty((n_vars - 2, gs[0] - 1, gs[1] - 1)) for v in variables: # j = 0: concentration, j = 1: curvature j = variables.index(v) # Assign next 128*128 values to variable v if j >= 2: values[j-2, :, :] = np.reshape(numbers[ 2*np.prod(gs) + (j-2)*(gs[0]-1)*(gs[1]-1) :\ 2*np.prod(gs) + (j-2)*(gs[0]-1)*(gs[1]-1)+(gs[0]-1)*(gs[1]-1) ], (gs[0]-1, gs[1]-1)) # Filtering & weighting # Initialize kernel kernel = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) # kernel = kernel/np.sum(kernel) # mask = np.where(((values[0, :, :] <= 0.03) | (values[0, :, :] >= 0.97)) & (values[1, :, :] != 0), 1, 0) values[1, :, :] = np.where( (values[0, :, :] > 0.05) & (values[0, :, :] < 0.95), values[1, :, :], 0) # ''' # Weighten cuvature # Get weights in every cell weights = (1 - 2 * np.abs(0.5 - values[0, :, :])) * np.where( values[1, :, :] != 0, 1, 0) # Get sum of weights by folding with kernel weight_array = ndimage.convolve(weights, kernel, mode='constant', cval=0.0) # Weighten curvature by convolving values*weights with kernel values[1, :, :] = np.where( (values[0, :, :] > 0.05) & (values[0, :, :] < 0.95), ndimage.convolve( values[1, :, :] * weights, kernel, mode='constant', cval=0.0) / weight_array, 0) # ''' ''' # Filter curvature and expand to 0.0075 - 0.9925 # Get weights in every cell weights = np.where(values[1, :, :] != 0, 1, 0) # Get sum of weights by folding with kernel weight_array = ndimage.convolve(weights, kernel, mode='constant', cval=0.0) # Weighten curvature by convolving values*weights with kernel [lower, upper] = [0.0075, 0.9925] # [lower, upper] = [0.05, 0.95] values[1, :, :] = np.where((values[0, :, :] > lower) & (values[0, :, :] < upper), ndimage.convolve(values[1, :, :], kernel, mode='constant', cval=0.0)/weight_array, 0) # ''' if (0 == 1): # no export fig, ax = plt.subplots() # ax.imshow(values[0, :, :], cmap='Greys_r') ax.imshow(values[1, :, :], cmap='viridis', norm=plt.Normalize(-30, 100)) plt.show() else: # Make figure without border fig = plt.figure(frameon=False) fig.set_size_inches(10, 10) # Square # fig.set_size_inches(5,10) # For rising bubble # fig.set_size_inches(10,5) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() fig.add_axes(ax) ''' # Artefakt values = np.rot90(values, k=3, axes=(1, 2)) sqrsize = 45 xlower = 17 ylower = 68 # ''' ''' # Zebra values = np.rot90(values, k=1, axes=(1, 2)) sqrsize = 45 xlower = 10 ylower = 42 # ''' ''' # Falsche Werte values = np.rot90(values, k=1, axes=(1, 2)) sqrsize = 16 xlower = 64-16 ylower = 128-25 limits = [[xlower, xlower+sqrsize], [ylower, ylower+sqrsize]] # x, y # limits = [[0, 80], [0, 160]] # x, y # ''' # Horn ''' values = np.rot90(values, k=1, axes=(1, 2)) sqrsize = 20 xlower = 22 ylower = 47 limits = [[xlower, xlower+sqrsize], [ylower, ylower+int(sqrsize/2)]] # x, y # ''' # values = np.rot90(values, k=1, axes=(1, 2)) sqrsize = 128 xlower = 0 ylower = 0 limits = [[xlower, xlower + sqrsize], [ylower, ylower + sqrsize]] # x, y # ''' y, x = np.meshgrid( np.linspace(limits[1][0], limits[1][1], limits[1][1] - limits[1][0]), np.linspace(limits[0][0], limits[0][1], limits[0][1] - limits[0][0])) # For rising bubble # x = x.T # y = y.T # Krümmung oszillierende Blase (-30 - 100) # pcm = ax.pcolormesh(x, y, values[1, limits[0][0]:limits[0][1], limits[1][0]:limits[1][1]], cmap='RdBu', norm=colors.TwoSlopeNorm(vmin=-30, vcenter=0, vmax=100)) # Krümmung oszillierende Blase (-30 - 100) verzerrt # pcm = ax.pcolormesh(x, y, values[1, limits[0][0]:limits[0][1], limits[1][0]:limits[1][1]], cmap='Blues', vmin=50, vmax=100) # Krümmung statische Blase (-0.3 - 1) # pcm = ax.pcolormesh(y, x, values[1, limits[0][0]:limits[0][1], limits[1][0]:limits[1][1]], cmap='RdBu', norm=colors.TwoSlopeNorm(vmin=-0.3, vcenter=0, vmax=1)) # Konzentration verzerrte Skala # pcm = ax.pcolormesh(x, y, values[0, limits[1][0]:limits[1][1], limits[0][0]:limits[0][1]], cmap='Greys_r', norm=colors.TwoSlopeNorm(vmin=0, vcenter=0.1, vmax=1)) # Konzentration lineare Skala # pcm = ax.pcolormesh(x, y, values[0, limits[0][0]:limits[0][1], limits[1][0]:limits[1][1]], cmap='Greys_r', norm=colors.TwoSlopeNorm(vmin=0, vcenter=0.5, vmax=1)) pcm = ax.pcolormesh(y, x, weights[limits[1][0]:limits[1][1], limits[0][0]:limits[0][1]], cmap='Greys_r', norm=colors.TwoSlopeNorm(vmin=0, vcenter=0.5, vmax=1)) # Konzentration stark verzerrt um 0.5 # pcm = ax.pcolormesh(x, y, values[0, limits[0][0]:limits[0][1], limits[1][0]:limits[1][1]], cmap='Greys_r', norm=colors.TwoSlopeNorm(vmin=0.485, vcenter=0.5, vmax=0.505)) # tkz.save('result2d.tex', axis_height='7cm', axis_width='7cm') # ''' plt.savefig('result2d.eps') with open('result2d.eps', 'r') as myfile: data = myfile.read() data = re.sub(r'fill', 'gsave fill grestore stroke', data) with open('result2d.eps', 'w') as myfile: myfile.write(data)
if run == "Joint": y = d['-log10(pvalue)'] - 0.3 if name in joint_patch_coords: x, y = joint_patch_coords[name] else: x = d['Beta'] - 0.02 * len(name) elif run == "Population": y = d['-log10(pvalue)'] - 0.2 if name in pop_patch_coords: x, y = pop_patch_coords[name] else: x = d['Beta'] - 0.02 * len(name) elif run == "Obese": y = d['-log10(pvalue)'] - 0.2 if name == "IL_27": x, y = 0.43, 6.2 elif y > 5: x = d['Beta'] - 0.025 * len(name) else: x = d['Beta'] + 0.05 ax.text(x=x, y=y, s=name).set_backgroundcolor("#ffffff") # Patching: adding a synthetic colorbar to match existing hue_norm norm = plt.Normalize(*colorbar_limits) sm = plt.cm.ScalarMappable(cmap="vlag", norm=norm) sm.set_array([]) ax.figure.colorbar(sm) ax.set_title(run) plt.show() # TODO: do in R - ask Sara or Evelina is_fdr_significant, adj_pv = fdrcorrection(results["pvalue"])
lane1_all_data = lane1_all_data.append(sorted_by_veh_id[sorted_by_veh_id[2] == '1']) # plots # cf +lc lane0 with speed color:seismic_r fig, axs = plt.subplots(1, 1, sharex=True, sharey=True) for allVeh_0 in pd.unique(lane0_all_data[0]): veh_info = lane0_all_data.loc[lane0_all_data[0] == allVeh_0] veh_time = veh_info[1] veh_position_x = veh_info[3] veh_speed = veh_info[5] if len(veh_time) <= 1: continue points = np.array([veh_time, veh_position_x]).T.reshape(-1, 1, 2) segments = np.concatenate([points[:-1], points[1:]], axis=1) norm = plt.Normalize(0, 30) lc = LineCollection(segments, cmap='jet_r', norm=norm) lc.set_array(veh_speed) lc.set_linewidth(0.5) line = axs.add_collection(lc) fig.colorbar(line, ax=axs) axs.set_xlim(0, duration*1.1) axs.set_ylim(100, 1000) plt.ylabel('Position (m)') plt.xlabel('Time (s)') plt.title('Lane 0 trajectory plot - volume: ' + str(input_volume) +'/h/lane') plt.savefig(str(input_volume) + 'CF_LC_Lane0_position_with_speed', bbox_inches='tight', pad_inches=0.1) plt.close() # cf +lc lane1 with speed
_values = [] for i in range(_shape.GetFeatureCount()): _feature = _shape.GetFeature(i) _nhru = _feature['id'] #print _nhru _row = _HRU_outputs_on_date.loc[_HRU_outputs_on_date['nhru'] == _nhru] try: _values.append(float(_row[plotting_variable].values)) except: #_values.append(np.nan) continue _values = np.array(_values) # Floating colorbar #colors = cm.jet(plt.Normalize( min(_values), max(_values)) (_values) ) colors = cm.jet(plt.Normalize(_min, _max)(_values)) ax.cla() _polys = [] for i in range(_shape.GetFeatureCount()): _feature = _shape.GetFeature(i) _geometry = _feature.geometry() _boundary = _geometry.GetBoundary() _boundary_points = np.array(_boundary.GetPoints()) _x = _boundary_points[:, 0] / 1000. _y = _boundary_points[:, 1] / 1000. #plt.plot(_x, _y, 'k-') _polys.append( ax.fill(_x, _y, facecolor=colors[i], edgecolor='k')[0]) ax.set_title(plotting_variable + ': ' + date) ax.set_xlabel('E [km]', fontsize=16) ax.set_ylabel('N [km]', fontsize=16)
def cluster_data(data): names = data.columns edge_model = covariance.GraphLassoCV() data = np.array(data) X = data.copy().T X /= X.std(axis=0) edge_model.fit(X) _, labels = cluster.affinity_propagation(edge_model.covariance_) n_labels = labels.max() for i in range(n_labels + 1): print('Cluster %i: %s' % ((i + 1), ', '.join(names[labels == i]))) #Visualization node_position_model = manifold.LocallyLinearEmbedding(n_components=2, eigen_solver='dense', n_neighbors=6) embedding = node_position_model.fit_transform(X.T).T plt.figure(1, facecolor='w', figsize=(10, 8)) plt.clf() ax = plt.axes([0., 0., 1., 1.]) plt.axis('off') # Display a graph of the partial correlations partial_correlations = edge_model.precision_.copy() d = 1 / np.sqrt(np.diag(partial_correlations)) partial_correlations *= d partial_correlations *= d[:, np.newaxis] non_zero = (np.abs(np.triu(partial_correlations, k=1)) > 0.02) # Plot the nodes using the coordinates of our embedding plt.scatter(embedding[0], embedding[1], s=100 * d**2, c=labels, cmap=plt.cm.spectral) # Plot the edges start_idx, end_idx = np.where(non_zero) #a sequence of (*line0*, *line1*, *line2*), where:: # linen = (x0, y0), (x1, y1), ... (xm, ym) segments = [[embedding[:, start], embedding[:, stop]] for start, stop in zip(start_idx, end_idx)] values = np.abs(partial_correlations[non_zero]) lc = LineCollection(segments, zorder=0, cmap=plt.cm.hot_r, norm=plt.Normalize(0, .7 * values.max())) lc.set_array(values) lc.set_linewidths(15 * values) ax.add_collection(lc) # Add a label to each node. The challenge here is that we want to # position the labels to avoid overlap with other labels for index, (name, label, (x, y)) in enumerate(zip(names, labels, embedding.T)): name = str(name).decode('utf-8').encode('utf-8') dx = x - embedding[0] dx[index] = 1 dy = y - embedding[1] dy[index] = 1 this_dx = dx[np.argmin(np.abs(dy))] this_dy = dy[np.argmin(np.abs(dx))] if this_dx > 0: horizontalalignment = 'left' x = x + .002 else: horizontalalignment = 'right' x = x - .002 if this_dy > 0: verticalalignment = 'bottom' y = y + .002 else: verticalalignment = 'top' y = y - .002 plt.text(x, y, name, size=10, horizontalalignment=horizontalalignment, verticalalignment=verticalalignment, bbox=dict(facecolor='w', edgecolor=plt.cm.spectral(label / float(n_labels)), alpha=.6)) plt.xlim( embedding[0].min() - .15 * embedding[0].ptp(), embedding[0].max() + .10 * embedding[0].ptp(), ) plt.ylim(embedding[1].min() - .03 * embedding[1].ptp(), embedding[1].max() + .03 * embedding[1].ptp()) plt.show()
start = [0, *(idx + 1)] end = [*(idx + 1), len(x)] for s, e in zip(start, end): ax.plot(x[s:e], y[s:e], transform=ccrs.PlateCarree(), **kwargs) for x, y in zip(xx.transpose(), yy.transpose()): idx = np.argwhere(np.diff(np.sign(x % 360 - 180))).flatten() x360 = x % 360 idx = idx[(x360[idx] > 10) & (x360[idx] < 350)] start = [0, *(idx + 1)] end = [*(idx + 1), len(x)] for s, e in zip(start, end): ax.plot(x[s:e], y[s:e], transform=ccrs.PlateCarree(), **kwargs) cmap = plt.cm.get_cmap('cividis') norm = plt.Normalize(0, 3e-20) def enhance_gridbox_edges(box_xy: np.array, res): temp_proj = pyproj.Proj( ccrs.Gnomonic(central_longitude=np.mean(box_xy[:, 0]), central_latitude=np.mean(box_xy[:, 1])).proj4_init) new_x = [] new_y = [] for (seg_x0, seg_y0), (seg_x1, seg_y1) in zip(box_xy[:-1, :], box_xy[1:, :]): seg_length = np.sqrt((seg_x1 - seg_x0)**2 + (seg_y1 - seg_y0)**2) gx, gy = temp_proj([seg_x0, seg_x1], [seg_y0, seg_y1]) m = (gy[1] - gy[0]) / (gx[1] - gx[0]) b = gy[0] - m * gx[0] interped_gx = np.linspace(gx[0], gx[1], res)
def get_colors(inp, colormap, vmin=None, vmax=None): norm = plt.Normalize(vmin, vmax) return colormap(norm(inp))
plt.savefig('Tesla_Nickel_Price.ps') #Scatterplot for Tesla and NASDAQ Price and Volume, grouped in days #Reference for color bar: https://stackoverflow.com/questions/46106912/one-colorbar-for-multiple-scatter-plots #Reference for Z-values: https://stackoverflow.com/questions/64735131/multiple-scatter-plots-and-one-colorbar plt.figure() plt.style.use('seaborn') fig, ax = plt.subplots() z1 = merged_monday['Total Volume Tesla & NASDAQ'] z2 = merged_tuesday['Total Volume Tesla & NASDAQ'] z3 = merged_wednesday['Total Volume Tesla & NASDAQ'] z4 = merged_thursday['Total Volume Tesla & NASDAQ'] z5 = merged_friday['Total Volume Tesla & NASDAQ'] mini, maxi = 0, 2 norm = plt.Normalize(mini, maxi) zs = np.concatenate([z1, z2, z3, z4, z5], axis=0) min_, max_ = zs.min(), zs.max() mon_scat = plt.scatter(merged_monday['Percentage Change NASDAQ'], merged_monday['Percentage Change Tesla'], c=z1, cmap='viridis_r', norm=norm, marker='o', label='Monday', edgecolors='black') plt.clim(min_, max_) tue_scat = plt.scatter(merged_tuesday['Percentage Change NASDAQ'], merged_tuesday['Percentage Change Tesla'], c=z2,
gpdf = gpdf.to_crs(epsg=3857) fig, ax = plt.subplots(1, figsize=(20, 12)) plot = gpdf.plot(column='util', cmap='YlOrRd', linewidth=0.5, ax=ax, alpha=1) ax.set_title('Maricopa County Pedestrian & Bike Traffic', fontdict={ 'fontsize': '18', 'fontweight': '3' }) ctx.add_basemap(plot, source=ctx.providers.Stamen.TonerLite) sm = plt.cm.ScalarMappable(cmap='YlOrRd', norm=plt.Normalize(vmin=minfreq, vmax=maxfreq)) sm._A = [] cbar = fig.colorbar(sm) fig.savefig('result/network_usage.png', bbox_inches='tight') ######################################## # query = ''' # SELECT # nodes.point, # MIN(COUNT(*), 200) AS util # FROM links # INNER JOIN output_events # USING(link_id) # INNER JOIN nodes
def PlottingResults(video, tmpfolder, Dataframe, scorer, cfg, showfigures, suffix='.png'): ''' Plots poses vs time; pose x vs pose y; histogram of differences and likelihoods.''' plt.figure(figsize=(8, 6)) bodyparts2plot = cfg['bodyparts'] pcutoff = cfg['pcutoff'] colors = get_cmap(len(bodyparts2plot), name=cfg['colormap']) alphavalue = cfg['alphavalue'] for bpindex, bp in enumerate(bodyparts2plot): Index = Dataframe[scorer][bp]['likelihood'].values > pcutoff plt.plot(Dataframe[scorer][bp]['x'].values[Index], Dataframe[scorer][bp]['y'].values[Index], '.', color=colors(bpindex), alpha=alphavalue) plt.gca().invert_yaxis() sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(cfg['colormap']), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot) - 1)) sm._A = [] cbar = plt.colorbar(sm, ticks=range(len(bodyparts2plot))) cbar.set_ticklabels(bodyparts2plot) plt.xlabel('X position in pixels') plt.ylabel('Y position in pixels') plt.savefig(os.path.join(tmpfolder, "trajectory" + suffix)) plt.figure(figsize=(30, 10)) Time = np.arange(np.size(Dataframe[scorer][bodyparts2plot[0]]['x'].values)) for bpindex, bp in enumerate(bodyparts2plot): Index = Dataframe[scorer][bp]['likelihood'].values > pcutoff plt.plot(Time[Index], Dataframe[scorer][bp]['x'].values[Index], '--', color=colors(bpindex), alpha=alphavalue) plt.plot(Time[Index], Dataframe[scorer][bp]['y'].values[Index], '-', color=colors(bpindex), alpha=alphavalue) sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(cfg['colormap']), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot) - 1)) sm._A = [] cbar = plt.colorbar(sm, ticks=range(len(bodyparts2plot))) cbar.set_ticklabels(bodyparts2plot) plt.xlabel('Frame Index') plt.ylabel('X-(dashed) and Y- (solid) position in pixels') plt.savefig(os.path.join(tmpfolder, "plot" + suffix)) plt.figure(figsize=(30, 10)) for bpindex, bp in enumerate(bodyparts2plot): Index = Dataframe[scorer][bp]['likelihood'].values > pcutoff plt.plot(Time, Dataframe[scorer][bp]['likelihood'].values, '-', color=colors(bpindex), alpha=alphavalue) sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(cfg['colormap']), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot) - 1)) sm._A = [] cbar = plt.colorbar(sm, ticks=range(len(bodyparts2plot))) cbar.set_ticklabels(bodyparts2plot) plt.xlabel('Frame Index') plt.ylabel('Likelihood') plt.savefig(os.path.join(tmpfolder, "plot-likelihood" + suffix)) plt.figure() bins = np.linspace(0, np.amax(Dataframe.max()), 100) for bpindex, bp in enumerate(bodyparts2plot): Index = Dataframe[scorer][bp]['likelihood'].values < pcutoff X = Dataframe[scorer][bp]['x'].values X[Index] = np.nan Histogram(X, colors(bpindex), bins) Y = Dataframe[scorer][bp]['x'].values Y[Index] = np.nan Histogram(Y, colors(bpindex), bins) sm = plt.cm.ScalarMappable(cmap=plt.get_cmap(cfg['colormap']), norm=plt.Normalize(vmin=0, vmax=len(bodyparts2plot) - 1)) sm._A = [] cbar = plt.colorbar(sm, ticks=range(len(bodyparts2plot))) cbar.set_ticklabels(bodyparts2plot) plt.ylabel('Count') plt.xlabel('DeltaX and DeltaY') plt.savefig(os.path.join(tmpfolder, "hist" + suffix)) if showfigures != True: plt.close("all") else: plt.show()
def cov_from_segments(gene, seg_counts, edge_counts, edge_idx, ax, sample_idx=None, log=False, cmap_seg=None, cmap_edg=None, xlim=None, grid=False, order='C'): """This function takes a gene and its corresponding segment and edge counts to produce a coverage overview plot.""" if sample_idx is None: sample_idx = sp.arange(seg_counts.shape[1]) norm = plt.Normalize(0, sample_idx.shape[0]) if cmap_seg is None: cmap_seg = plt.get_cmap('jet') if cmap_edg is None: cmap_edg = plt.get_cmap('jet') ### iterate over samples for ii, i in enumerate(sample_idx): ### collect count information and add segment patches for j in range(gene.segmentgraph.segments.shape[1]): s = gene.segmentgraph.segments[:, j] if log: counts = sp.log10(seg_counts[j, i] + 1) else: counts = seg_counts[j, i] #ax.add_patch(patches.Rectangle((s[0], 0), s[1] - s[0], counts, fill=cmap_seg(norm(ii)), # edgecolor='none', alpha=0.5)) ax.plot(s, [counts, counts], '-', color=cmap_seg(norm(ii)), linewidth=2) for j in range(edge_idx.shape[0]): [s, t] = sp.unravel_index(edge_idx[j], gene.segmentgraph.seg_edges.shape, order=order) if log: counts = sp.log10(edge_counts[j, i] + 1) else: counts = edge_counts[j, i] add_intron_patch2(ax, gene.segmentgraph.segments[1, s], gene.segmentgraph.segments[0, t], counts, color=cmap_edg(norm(ii))) if xlim is not None: ax.set_xlim(xlim) ### draw grid if grid: ax.grid(b=True, which='major', linestyle='--', linewidth=0.2, color='#222222') ax.xaxis.grid(False) ax.set_ylim([0, ax.get_ylim()[1]])
wfc3 = 0.13 nircam_short = 0.031 nircam_long = 0.063 # Convert to physical kiloparsecs r_es = np.zeros(len(papers)) for (ind, r), z in zip(enumerate(r_es_arcs), zs): if r_es_type[ind] == "kpc": r_es[ind] = r else: r_es[ind] = r / cosmo.arcsec_per_kpc_proper(z).value if mags[ind] < 0: mags[ind] = M_to_m(mags[ind], cosmo, z) cmap = mpl.cm.get_cmap("plasma") norm = plt.Normalize(vmin=0, vmax=1) labels = { "C16": "Calvi+2016", "K18": "Kawamata+2018", "MO18": "Morishita+2018", "B19": "Bridge+2019", "G11": "Grazian+2011", "G12": "Grazian+2012", # "O16": "Oesch+2016", # "S18": "Salmon+2018", # "H20": "Holwerda+2020", "H07": "Hathi+2008" } markers = { "G11": "s",
[activations2d[:, 1][i] for i in vLD] + [activations2d[:, 1][i] for i in vLG], color=['black'] * len(montee) + ['red'] * len(ld) + ['sandybrown'] * len(vSD) + ['gold'] * len(vSG) + ['green'] * len(vLD) + ['violet'] * len(vLG)) # k-means kmeans = KMeans(n_clusters=7) kmeans.fit(activations2d) y_kmeans = kmeans.predict(activations2d) #fig,ax = plt.subplots() cvals = range(4) colors = ['black', 'blue', 'red', 'violet'] norm = plt.Normalize(min(cvals), max(cvals)) tuples = list(zip(map(norm, cvals), colors)) cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", tuples) ax.scatter(activations2d[:, 0], activations2d[:, 1], c=y_kmeans, s=50, cmap=cmap) for i in range(len(activationAalborg)): ax.annotate("A" + str(i), (activations2d[:, 0][i], activations2d[:, 1][i])) for i in range(len(activationAalborg), len(activationETrack2)): ax.annotate("E" + str(i - len(activationAalborg)), (activations2d[:, 0][i], activations2d[:, 1][i]))
# Read image and mask image = skimage.io.imread(os.path.join(IMAGES_DEST, image_fns[idx])) gt = skimage.io.imread(os.path.join(MASKS_DEST, gt_fns[idx])) # Test! assert image.shape[:2] == gt.shape, "Wrong image or ground truth!" assert image.dtype == gt.dtype, "Wrong data types!" print(image.shape, gt.shape) # Flatten to get unique -> different classes in the mask val1 = gt.flatten() print("Ground truth classes: ", np.unique(val1)) f, axarr = plt.subplots(1, 2, figsize=(16, 16)) norm = plt.Normalize(0, 4) # 5 classes including BG map_name = matplotlib.colors.LinearSegmentedColormap.from_list( "", ["black", "red", "yellow", "blue", "green"]) #map_name = 'magma' # idx = 154 all classes axarr[0].imshow(image, cmap=map_name, norm=norm) axarr[1].imshow(gt, cmap=map_name, norm=norm) # In[ ]: # If using this block of code, run the primary for loop for two or three folder, for experimentation. #f, axarr = plt.subplots(1,2, figsize=(16,16)) #ct = 3
dataAfterStim = [ np.transpose(np.multiply(np.transpose(connectivity[i, :, :]), myH[i, :])) for i in [ int(tmax / dt), int(tmax / dt + ((thetmax - tmax) / dt) / 3.), int(tmax / dt + ((thetmax - tmax) / dt) * 2. / 3.), -1 ] ] ax2A2.matshow(dataAfterStim[2], vmin=0, vmax=vmax) ax2A2.set_xticks([]) ax2A2.set_yticks([]) ax2A2.set_xlabel('After stimulation') sm = plt.cm.ScalarMappable(cmap=plt.cm.jet, norm=plt.Normalize(vmin=0., vmax=vmax)) # fake up the array of the scalar mappable. Urgh... sm._A = [] cax = fig.add_axes([1., 0.307, 0.02, 0.239]) # [left, bottom, width, height] myticks = [0.0, .5, 1., 1.5] cbar = fig.colorbar(sm, cax=cax, ticks=myticks, alpha=1.) cbar.ax.tick_params(labelsize=30) axSA.set_prop_cycle( plt.cycler('color', [colormap(i) for i in np.linspace(0, 0.9, n)])) axSA.plot(t_ret, phi(u_ret[:, :], theta, uc), lw=5) axSA.set_ylim([0, 1.2]) axSA.set_xlim([0, 220]) axSA.set_xticks([0, 100, 200]) axSA.set_yticks([0.5, 1]) axSA.set_xlabel('Time (ms)')
def plotManifoldDistances(self, segments: List[Union[MessageSegment, TypedSegment, RawMessage, Any]], distances: numpy.ndarray, labels: numpy.ndarray, templates: List = None, plotEdges=False, countMarkers=False): """ Plot distances of segments according to (presumably multidimensional) features. This function abstracts from the actual feature by directly taking a precomputed similarity matrix and arranging the segments relative to each other according to their distances using Multidimensional Scaling (MDS). See module `manifold` from package `sklearn`. If segments is a list of `TypedSegment` or `MessageSegment`, this function plots the feature values of each given segment overlaying each other besides the distances; they are colored according to the given labels. >>> from netzob.Model.Vocabulary.Messages.RawMessage import RawMessage >>> from utils.loader import BaseLoader >>> from inference.analyzers import Value >>> >>> bytedata = [ ... bytes([1, 2, 3, 4]), ... bytes([ 2, 3, 4]), ... bytes([ 1, 3, 4]), ... bytes([ 2, 4 ]), ... bytes([ 2, 3 ]), ... bytes([20, 30, 37, 50, 69, 2, 30]), ... bytes([ 37, 5, 69 ]), ... bytes([70, 2, 3, 4]), ... bytes([3, 2, 3, 4]) ... ] >>> messages = [RawMessage(bd) for bd in bytedata] >>> specimens = BaseLoader(messages) >>> analyzers = [Value(message) for message in messages] >>> segments = [TypedSegment(analyzer, 0, len(analyzer.message.data)) for analyzer in analyzers] >>> for seg in segments[:4]: ... seg.fieldtype = "ft1" >>> for seg in segments[4:6]: ... seg.fieldtype = "ft2" >>> for seg in segments[6:]: ... seg.fieldtype = "ft3" >>> DistanceCalculator.debug = False >>> dc = DistanceCalculator(segments, thresholdFunction=DistanceCalculator.neutralThreshold, thresholdArgs=None) Calculated distances for 37 segment pairs in ... seconds. >>> dp = DistancesPlotter(specimens, "test", False) >>> dp.plotManifoldDistances(segments, dc.distanceMatrix, numpy.array([1,2,3,1,1,0,1,0,2])) >>> # comment out writing of file for doctest >>> # dp.writeOrShowFigure() :param segments: If `segments` is a list of `TypedSegment`s, field types are marked as small markers within the label marker. labels containing "Noise" then are not explicitly marked like the other labeled segments :param distances: The precomputed similarity matrix: symmetric matrix, rows/columns in the order of `segments` :param labels: Labels of strings (or ints or any other printable type) identifying the cluster for each segment :param templates: Templates of clusters to be printed alongside with the feature values. CURRENTLY UNTESTED :param plotEdges: Plot of edges between each pair of segment markers. Caution: Adds n^2 lines which takes very long compared to the scatterplot and quickly becomes a huge load especially when rendering the plot as PDF. :param countMarkers: add text labels with information at positions with multiple markers """ from sklearn import manifold from sklearn.decomposition import PCA # plot configuration labsize = 150 # label markers: size factor typsize = 30 # type markers: size factor # self._cm # label color map fcm = cm.cubehelix # type color map # identify unique labels allabels = set(labels) if all( isinstance(l, numpy.integer) or l.isdigit() for l in allabels if l != "Noise"): ulab = sorted(allabels, key=lambda l: -1 if l == "Noise" else int(l)) else: ulab = sorted(allabels) # subsample if segment count is larger than maxSamples maxSamples = 1000 originalSegmentCount = len(segments) if originalSegmentCount > 2 * maxSamples: import math ratiorev = originalSegmentCount / maxSamples step2keep = math.floor(ratiorev) lab2idx = dict() for idx, lab in enumerate(labels): if lab not in lab2idx: lab2idx[lab] = list() lab2idx[lab].append(idx) # copy list to remove elements without side-effects segments = segments.copy() # to save the indices to be removed idx2rem = list() # determines a subset evenly distributed over all clusters while honoring the ratio to reduce to. for lab, ics in lab2idx.items(): keep = set(ics[::step2keep]) idx2rem.extend(set(ics) - keep) idx2rem = sorted(idx2rem, reverse=True) for idx in idx2rem: del segments[idx] labels = numpy.delete(labels, idx2rem, 0) distances = numpy.delete(numpy.delete(distances, idx2rem, 0), idx2rem, 1) else: idx2rem = None # prepare MDS seed = numpy.random.RandomState(seed=3) mds = manifold.MDS(n_components=2, max_iter=3000, eps=1e-9, random_state=seed, dissimilarity="precomputed", n_jobs=1) pos = mds.fit(distances).embedding_ # print(distances) # Rotate the data clf = PCA(n_components=2) pos = clf.fit_transform(pos) fig = self._fig axMDS, axSeg = self._axes # type: plt.Axes, plt.Axes if idx2rem is not None: axSeg.text( 0, -5, 'Subsampled: {} of {} segments'.format(len(segments), originalSegmentCount)) # omit noise in cluster labels if types are plotted anyway. if isinstance(segments[0], TypedSegment): for l in ulab: if isinstance(l, str) and "Noise" in l: ulab.remove(l) elif isinstance(segments[0], RawMessage) and segments[0].messageType != "Raw": for l in ulab: try: if int(l) == -1: ulab.remove(l) except ValueError as e: pass # not a problem, just keep the cluster, since its not noise. # prepare color space cIdx = [ int(round(each)) for each in numpy.linspace(2, self._cm.N - 2, len(ulab)) ] if templates is None: templates = ulab # iterate unique labels and scatter plot each of these clusters for c, (l, t) in enumerate(zip(ulab, templates)): # type: int, (Any, Template) # test with: # color = [list(numpy.random.randint(0, 10, 4) / 10)] # plt.scatter(numpy.random.randint(0,10,4), numpy.random.randint(0,10,4), c=color) lColor = self._cm(cIdx[c]) class_member_mask = (labels == l) try: x = list(compress(pos[:, 0].tolist(), class_member_mask)) y = list(compress(pos[:, 1].tolist(), class_member_mask)) # "If you want to specify the same RGB or RGBA value for all points, use a 2-D array with a single row." # see https://matplotlib.org/api/_as_gen/matplotlib.pyplot.scatter.html: axMDS.scatter( x, y, c=colors.to_rgba_array(lColor), alpha=.6, s=labsize, # s=s-(c*s/len(ulab)), # lw=0, label=str(l)) except IndexError as e: print(pos) print(distances) print(segments) raise e if isinstance(t, Template): axSeg.plot(t.values, c=lColor, linewidth=4) # include field type labels for TypedSegments input if isinstance(segments[0], (TypedSegment, RawMessage)): if isinstance(segments[0], TypedSegment): ftypes = numpy.array([seg.fieldtype for seg in segments]) # PP elif isinstance(segments[0], RawMessage) and segments[0].messageType != 'Raw': ftypes = numpy.array([msg.messageType for msg in segments]) # PP else: ftypes = set() # identify unique types utyp = sorted(set(ftypes)) # prepare color space # noinspection PyUnresolvedReferences cIdx = [ int(round(each)) for each in numpy.linspace(30, fcm.N - 30, len(utyp)) ] # iterate unique types and scatter plot each of these groups for n, ft in enumerate(utyp): # PP fColor = fcm(cIdx[n]) type_member_mask = (ftypes == ft) x = list(compress(pos[:, 0].tolist(), type_member_mask)) y = list(compress(pos[:, 1].tolist(), type_member_mask)) # "If you want to specify the same RGB or RGBA value for all points, use a 2-D array with a single row." # see https://matplotlib.org/api/_as_gen/matplotlib.pyplot.scatter.html: axMDS.scatter(x, y, c=colors.to_rgba_array(fColor), alpha=1, s=typsize, lw=0, label=str(ft)) if isinstance(segments[0], TypedSegment): for seg in compress(segments, type_member_mask): axSeg.plot(seg.values, c=fColor, alpha=0.05) elif isinstance(segments[0], MessageSegment): for c, l in enumerate(ulab): lColor = self._cm(cIdx[c]) class_member_mask = (labels == l) for seg in compress(segments, class_member_mask): axSeg.plot(seg.values, c=lColor, alpha=0.1) else: axSeg.text(.5, .5, 'nothing to plot\n(message alignment)', horizontalalignment='center') # place the label/type legend at the best position if isinstance(segments[0], RawMessage): axMDS.legend(bbox_to_anchor=(1.04, 1), scatterpoints=1, shadow=False) axSeg.patch.set_alpha(0.0) axSeg.axis('off') else: axMDS.legend(scatterpoints=1, loc='best', shadow=False) if plotEdges: # plotting of edges takes a long time compared to the scatterplot (and especially when rendering the PDF) from matplotlib.collections import LineCollection # Plot the edges lines = [[pos[i, :], pos[j, :]] for i in range(len(pos)) for j in range(len(pos))] values = numpy.abs(distances) # noinspection PyUnresolvedReferences lc = LineCollection(lines, zorder=0, cmap=plt.cm.Blues, norm=plt.Normalize(0, values.max())) # lc.set_alpha(.1) lc.set_array(distances.flatten()) lc.set_linewidths(0.5 * numpy.ones(len(segments))) axMDS.add_collection(lc) if countMarkers: # Count markers at identical positions and plot text with information about the markers at this position from collections import Counter import math if isinstance(segments[0], TypedSegment): coordCounter = Counter([ (posX, posY, seg.fieldtype) for seg, lab, posX, posY in zip( segments, labels, pos[:, 0].tolist(), pos[:, 1].tolist()) ]) else: coordCounter = Counter([ (posX, posY, lab) for lab, posX, posY in zip( labels, pos[:, 0].tolist(), pos[:, 1].tolist()) ]) for (posX, posY, lab), cnt in coordCounter.items(): if cnt > 1: theta = hash(str(lab)) % 360 r = 1 posXr = posX + r * math.cos(theta) posYr = posY + r * math.sin(theta) axMDS.text(posXr, posYr, "{}: {}".format(lab, cnt), withdash=True) fig.canvas.toolbar.update()
outer_x, outer_y = s.R * np.sin(s.alphaFromPhi), s.R * np.cos( s.alphaFromPhi) - s.F * (s.n2 - 1.) - s.S * (s.n1 - 1.) a, b = 93, 92 inner_x, inner_y = inner_x[:a], inner_y[:a] outer_x, outer_y = outer_x[:b], outer_y[:b] plt.plot(inner_x, inner_y, c=c, lw=2, label=str(s.F) + " " + str(s.S)) plt.plot(-inner_x, inner_y, c=c, lw=2) plt.plot(outer_x, outer_y, c=c, lw=2) plt.plot(-outer_x, outer_y, c=c, lw=2) ################################################################################### norm = plt.Normalize() colors = plt.cm.Greens(norm([1, 2, 3, 4, 5, 6])) #l0 = lens(n2 = 2.8) #l0.solveLens() #l0.plot(c=colors[1]) #l1 = lens(n2 = 3.0) #l1.solveLens() #l1.plot(c=colors[2]) #l2 = lens(n2 = 3.2) #l2.solveLens() #l2.plot(c=colors[3]) #l3 = lens(n2 = 3.4)
def visualize(model, graphs, res_dir, data_name, class_values, num=5, sort_by='prediction'): model.eval() model.to(device) R = [] Y = [] graph_loader = DataLoader(graphs, 50, shuffle=False) for data in tqdm(graph_loader): data = data.to(device) r = model(data).detach() y = data.y R.extend(r.view(-1).tolist()) Y.extend(y.view(-1).tolist()) if sort_by == 'true': # sort graphs by their true ratings order = np.argsort(Y).tolist() elif sort_by == 'prediction': order = np.argsort(R).tolist() elif sort_by == 'random': # randomly select graphs to visualize order = np.random.permutation(range(len(R))).tolist() highest = [PyGGraph_to_nx(graphs[i]) for i in order[-num:][::-1]] lowest = [PyGGraph_to_nx(graphs[i]) for i in order[:num]] highest_scores = [R[i] for i in order[-num:][::-1]] lowest_scores = [R[i] for i in order[:num]] highest_ys = [Y[i] for i in order[-num:][::-1]] lowest_ys = [Y[i] for i in order[:num]] scores = highest_scores + lowest_scores ys = highest_ys + lowest_ys type_to_label = {0: 'u0', 1: 'v0', 2: 'u1', 3: 'v1', 4: 'u2', 5: 'v2'} type_to_color = { 0: 'xkcd:red', 1: 'xkcd:blue', 2: 'xkcd:orange', 3: 'xkcd:lightblue', 4: 'y', 5: 'g' } plt.axis('off') f = plt.figure(figsize=(20, 10)) axs = f.subplots(2, num) cmap = plt.cm.get_cmap('rainbow') vmin, vmax = min(class_values), max(class_values) sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=vmin, vmax=vmax)) sm.set_array([]) for i, g in enumerate(highest + lowest): u_nodes = [x for x, y in g.nodes(data=True) if y['type'] % 2 == 0] u0, v0 = 0, len(u_nodes) pos = nx.drawing.layout.bipartite_layout(g, u_nodes) bottom_u_node = min(pos, key=lambda x: (pos[x][0], pos[x][1])) bottom_v_node = min(pos, key=lambda x: (-pos[x][0], pos[x][1])) # swap u0 and v0 with bottom nodes if they are not already if u0 != bottom_u_node: pos[u0], pos[bottom_u_node] = pos[bottom_u_node], pos[u0] if v0 != bottom_v_node: pos[v0], pos[bottom_v_node] = pos[bottom_v_node], pos[v0] labels = { x: type_to_label[y] for x, y in nx.get_node_attributes(g, 'type').items() } node_colors = [ type_to_color[y] for x, y in nx.get_node_attributes(g, 'type').items() ] edge_types = nx.get_edge_attributes(g, 'type') edge_types = [class_values[edge_types[x]] for x in g.edges()] axs[i // num, i % num].axis('off') nx.draw_networkx( g, pos, #labels=labels, with_labels=False, node_size=150, node_color=node_colors, edge_color=edge_types, ax=axs[i // num, i % num], edge_cmap=cmap, edge_vmin=vmin, edge_vmax=vmax, ) # make u0 v0 on top of other nodes nx.draw_networkx_nodes(g, {u0: pos[u0]}, nodelist=[u0], node_size=150, node_color='xkcd:red', ax=axs[i // num, i % num]) nx.draw_networkx_nodes(g, {v0: pos[v0]}, nodelist=[v0], node_size=150, node_color='xkcd:blue', ax=axs[i // num, i % num]) axs[i // num, i % num].set_title('{:.4f} ({:})'.format(scores[i], ys[i]), x=0.5, y=-0.05, fontsize=20) f.subplots_adjust(right=0.85) cbar_ax = f.add_axes([0.88, 0.15, 0.02, 0.7]) if len(class_values) > 20: class_values = np.linspace(min(class_values), max(class_values), 20, dtype=int).tolist() cbar = plt.colorbar(sm, cax=cbar_ax, ticks=class_values) cbar.ax.tick_params(labelsize=22) f.savefig(os.path.join( res_dir, "visualization_{}_{}.pdf".format(data_name, sort_by)), interpolation='nearest', bbox_inches='tight')
def main(): curve_score_methods = { "std": ("Standard deviation", (0.0, 1.0), lambda d, h, b: np.std(d)), # 1.5, "mean": ("Mean", (0.0, 4.0), lambda d, h, b: np.mean(d)), "cv": ( "Coefficient of variation", (0.3, 0.8), lambda d, h, b: scipy.stats.variation(d), ), # "skew": ("modern skew", # 0.0, 3.0, # lambda d, h, b: scipy.stats.skew(d)), "skew_normed": ( "Skew", (0.0, 2.9), lambda d, h, b: scipy.stats.skew(d, bias=False), ), # "mode": ("Mode", # 0.0, 3.5, # lambda d, h, b: b[h.argmax()]), # "num": ("# cells", # 0.0, 2000, # lambda d, h, b: len(d)), # "pearson_mode_mean": ("pearson Mode mean", # 0.0, 1.2, # joy_plots_of_gradients.pearson_mode_mean_skew), # "non_parameteric_skew": ("Non parameteric", # 0.0, 0.4, # joy_plots_of_gradients.non_parametric_skew), "kurtosis": ("Kurtosis", (0.0, 8.0), lambda d, h, b: scipy.stats.kurtosis(d)), } plot_colors = [ # "mean", # "std", "cv", # "skew", # "num", # "skew_normed", "skew_normed", # same as pandas # "pearson_mode_mean", # "non_parameteric_skew", # "kurtosis", ] # basedir = "../../data/bio_film_data/63xdatasets" #this_dir = os.path.dirname(__file__) this_dir = "/media/nmurphy/BF_Data_Orange/" #basedir = os.path.join(this_dir, "../../datasets/LSM700_63x_sigb") basedir = os.path.join(this_dir, "datasets/LSM700_63x_sigb") # cell_df = pd.read_hdf(os.path.join(basedir, "edge_redo_lh1segment_data_bg_back_bleed.h5"), "cells") # cell_df = pd.read_hdf(os.path.join(basedir, "new_edge_bgsubv2_maxnorm_lh1segment.h5"), "cells") cell_df = pd.read_hdf(os.path.join(basedir, "single_cell_data.h5"), "cells") # cell_df = pd.read_hdf(os.path.join(basedir, "edge_redo_lh1segment_data.h5"), "cells") # cell_df = pd.read_hdf(os.path.join(basedir, "lh1segment_bgsub_data.h5"), "cells") # cell_df = cell_df[cell_df["area"] > 140] cell_df = cell_df[cell_df["distance"] > 2] time = 48 # .0 location = "center" file_df = filedb.get_filedb(os.path.join(basedir, "file_list.tsv")) strain_map, des_strain_map = strainmap.load() # cbar_mins = {0: 0.5, 1:0.0} percentile = 0 # 99# # green_chan = "meannorm_green" # red_chan = "meannorm_red" rmax = 6.5 gmax = 6.5 # 0.4 green_chan = "green_raw_bg_mean" red_chan = "red_raw_bg_mean" rmax = 50000 gmax = 10000 strains = [ ("wt_sigar_sigby", red_chan, rmax, "WT\n P$_{sigA}$-RFP"), ("wt_sigar_sigby", green_chan, gmax, "WT\n P$_{\mathit{sigB}}$-YFP"), ( "delru_sigar_sigby", green_chan, gmax, "Δ$\mathit{rsbRU}$\n P$_{\mathit{sigB}}$-YFP", ), ( "delqp_sigar_sigby", green_chan, gmax, "Δ$\mathit{rsbQP}$\n P$_{\mathit{sigB}}$-YFP", ), ] # ("2xqp_sigar_sigby", green_chan, gmax, "2$\\times$rsbQP\n P$_{sigB}$-YFP")] fig, ax = plt.subplots(len(plot_colors), len(strains), sharey=True) for c, (strain, chan, max_val, name) in enumerate(strains): strain_num = des_strain_map[strain] distances, sbins, histograms, stats = joy_plots_of_gradients.get_strain_result( file_df, cell_df, time, location, strain_num, chan, max_val, percentile, curve_score_methods, ) for r, k in enumerate(plot_colors): color = figure_util.strain_color[strain_num.upper()] ax[r, c], mv, leglist = joy_plots_of_gradients.plot_curves( ax[r, c], color, distances, sbins, histograms, stats, k) if c == len(strains) - 1: posn = ax[r, c].get_position() cbax = fig.add_axes([ posn.x0 + posn.width + 0.0005, posn.y0, 0.015, posn.height ]) label = curve_score_methods[k][0] min_zval = curve_score_methods[k][1][0] max_zval = curve_score_methods[k][1][1] sm = plt.cm.ScalarMappable( cmap=plt.get_cmap("viridis"), norm=plt.Normalize(vmin=min_zval, vmax=max_zval), ) sm._A = [] _ = plt.colorbar(sm, cax=cbax) # , fig=fig) cbax.set_ylabel(label, rotation=-90, labelpad=8) cbax.tick_params(direction="out") if r == 0: ax[r, c].set_title(name, fontsize=6) ax[r, c].get_xaxis().set_ticklabels([]) ax[r, c].set_xlim(0, max_val) # this didnt return the right mode for some reason # leg = ax[0, -1].legend(leglist) leg = ax[0, -1].legend(leglist, ["Mode", "Mean"], loc="lower left", bbox_to_anchor=(0.84, 0.97)) leg.set_zorder(400) for a in ax.flatten(): a.tick_params(direction="out") ax[0, 0].annotate( "Distance from top of biofilm (μm)", xy=(0, 0), xytext=(0.02, 0.5), textcoords="figure fraction", # arrowprops=dict(facecolor='black', shrink=0.05), horizontalalignment="center", verticalalignment="center", fontsize="medium", color=mpl.rcParams["axes.labelcolor"], rotation=90, ) ax[1, 2].annotate( "Normalized fluoresence", xy=(0, 0), xytext=(0.5, 0.04), textcoords="figure fraction", # arrowprops=dict(facecolor='black', shrink=0.05), horizontalalignment="center", verticalalignment="center", fontsize="medium", color=mpl.rcParams["axes.labelcolor"], ) # for a in ax[:, 0].flatten(): # ticklabs = a.yaxis.get_ticklabels() # ticklabs = a.get_yticks()#.tolist() # ticklabs[-1] = '' letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] # letter_lab = (-0.13, 0.98) for a, l in zip(ax.flatten(), letters): a.annotate( l, xy=(0, 0), xytext=(-0.13, 0.95), textcoords="axes fraction", # arrowprops=dict(facecolor='black', shrink=0.05), horizontalalignment="center", verticalalignment="center", fontsize=figure_util.letter_font_size, color="black", ) # a.text(letter_lab[0], letter_lab[1], l, transform=a.transAxes, fontsize=8) filename = "sup_meta_histo" width, height = figure_util.get_figsize(figure_util.fig_width_medium_pt, wf=1.0, hf=0.6) fig.subplots_adjust(left=0.085, right=0.89, top=0.89, bottom=0.13, hspace=0.20, wspace=0.25) fig.set_size_inches(width, height) # common.cm2inch(width, height)) figure_util.save_figures(fig, filename, ["png", "pdf"], this_dir)
def test_nonuniformimage_setnorm(): ax = plt.gca() im = NonUniformImage(ax) im.set_norm(plt.Normalize())
plt.ylim(0, 1) plt.xlabel('x') plt.title('test') line_ani = animation.FuncAnimation(fig1, update_line, 25, fargs=(data, l), interval=50, blit=True) # To save the animation, use the command: line_ani.save('lines.mp4') fig2 = plt.figure() x = np.arange(-9, 10) y = np.arange(-9, 10).reshape(-1, 1) base = np.hypot(x, y) ims = [] for add in np.arange(15): ims.append((plt.pcolor(x, y, base + add, norm=plt.Normalize(0, 30)), )) im_ani = animation.ArtistAnimation(fig2, ims, interval=50, repeat_delay=3000, blit=True) # To save this second animation with some metadata, use the following command: # im_ani.save('im.mp4', metadata={'artist':'Guido'}) plt.show()
ax = plt.gca() ax.axis('equal') plt.plot(coordinates_center[0], coordinates_center[1], '--k', lw=0.5, alpha=0.5) plt.plot(coordinates_left[0], coordinates_left[1], 'k', lw=0.5, alpha=0.5) plt.plot(coordinates_right[0], coordinates_right[1], 'k', lw=0.5, alpha=0.5) # best trajectory #plt.plot(wx_nei[:-1], wy_nei[:-1], linestyle='', marker='D', ms=5) for i in range(no_of_trajs): trajectory = np.loadtxt("coordinates_nc{}.txt".format(i+1), delimiter=',') x = np.array(trajectory[0]) y = np.array(trajectory[1]) speed = np.array(trajectory[2]) points = np.array([x, y]).T.reshape(-1, 1, 2) segments = np.concatenate([points[:-1], points[1:]], axis=1) norm = plt.Normalize(speed.min(), speed.max()) lc = LineCollection(segments, cmap='viridis', norm=norm) lc.set_array(speed) lc.set_linewidth(line_width) line = ax.add_collection(lc) fig.colorbar(line, ax=ax) ax.set_xlabel('x [m]') ax.set_ylabel('y [m]') if SAVE_RESULTS: plt.savefig(filepath, dpi=600, bbox_inches='tight') ##################################################################### plt.show()
def _embedding_delay_plot(signal, metric_values, tau_sequence, tau=1, metric="Mutual Information", ax0=None, ax1=None, plot='2D'): """ """ # Prepare figure if ax0 is None and ax1 is None: fig = plt.figure(constrained_layout=False) spec = matplotlib.gridspec.GridSpec(ncols=1, nrows=2, height_ratios=[1, 3], width_ratios=[2]) ax0 = fig.add_subplot(spec[0]) if plot == '2D': ax1 = fig.add_subplot(spec[1]) elif plot == '3D': ax1 = fig.add_subplot(spec[1], projection='3d') else: fig = None ax0.set_title("Optimization of Delay (tau)") ax0.set_xlabel("Time Delay (tau)") ax0.set_ylabel(metric) ax0.plot(tau_sequence, metric_values, color='#FFC107') ax0.axvline(x=tau, color='#E91E63', label='Optimal delay: ' + str(tau)) ax0.legend(loc='upper right') ax1.set_title("Attractor") ax1.set_xlabel("Signal [i]") ax1.set_ylabel("Signal [i-" + str(tau) + "]") # Get data points, set axis limits embedded = complexity_embedding(signal, delay=tau, dimension=3) x = embedded[:, 0] y = embedded[:, 1] z = embedded[:, 2] ax1.set_xlim(x.min(), x.max()) ax1.set_ylim(x.min(), x.max()) # Colors norm = plt.Normalize(z.min(), z.max()) cmap = plt.get_cmap('plasma') colors = cmap(norm(x)) # Attractor for 2D vs 3D if plot == '2D': points = np.array([x, y]).T.reshape(-1, 1, 2) segments = np.concatenate([points[:-1], points[1:]], axis=1) lc = matplotlib.collections.LineCollection(segments, cmap='plasma', norm=norm) lc.set_array(z) line = ax1.add_collection(lc) elif plot == '3D': points = np.array([x, y, z]).T.reshape(-1, 1, 3) segments = np.concatenate([points[:-1], points[1:]], axis=1) for i in range(len(x) - 1): seg = segments[i] l, = ax1.plot(seg[:, 0], seg[:, 1], seg[:, 2], color=colors[i]) l.set_solid_capstyle('round') ax1.set_zlabel("Signal [i-" + str(2 * tau) + "]") return fig
def plot_network(wn, node_attribute=None, link_attribute=None, title=None, node_size=20, node_range=[None, None], node_alpha=1, node_cmap=None, node_labels=False, link_width=1, link_range=[None, None], link_alpha=1, link_cmap=None, link_labels=False, add_colorbar=True, node_colorbar_label='Node', link_colorbar_label='Link', directed=False, ax=None, filename=None): """ Plot network graphic Parameters ---------- wn : wntr WaterNetworkModel A WaterNetworkModel object node_attribute : None, str, list, pd.Series, or dict, optional - If node_attribute is a string, then a node attribute dictionary is created using node_attribute = wn.query_node_attribute(str) - If node_attribute is a list, then each node in the list is given a value of 1. - If node_attribute is a pd.Series, then it should be in the format {nodeid: x} where nodeid is a string and x is a float. - If node_attribute is a dict, then it should be in the format {nodeid: x} where nodeid is a string and x is a float link_attribute : None, str, list, pd.Series, or dict, optional - If link_attribute is a string, then a link attribute dictionary is created using edge_attribute = wn.query_link_attribute(str) - If link_attribute is a list, then each link in the list is given a value of 1. - If link_attribute is a pd.Series, then it should be in the format {linkid: x} where linkid is a string and x is a float. - If link_attribute is a dict, then it should be in the format {linkid: x} where linkid is a string and x is a float. title: str, optional Plot title node_size: int, optional Node size node_range: list, optional Node range ([None,None] indicates autoscale) node_alpha: int, optional Node transparency node_cmap: matplotlib.pyplot.cm colormap or list of named colors, optional Node colormap node_labels: bool, optional If True, the graph will include each node labelled with its name. link_width: int, optional Link width link_range : list, optional Link range ([None,None] indicates autoscale) link_alpha : int, optional Link transparency link_cmap: matplotlib.pyplot.cm colormap or list of named colors, optional Link colormap link_labels: bool, optional If True, the graph will include each link labelled with its name. add_colorbar: bool, optional Add colorbar node_colorbar_label: str, optional Node colorbar label link_colorbar_label: str, optional Link colorbar label directed: bool, optional If True, plot the directed graph ax: matplotlib axes object, optional Axes for plotting (None indicates that a new figure with a single axes will be used) filename : str, optional Filename used to save the figure Returns ------- ax : matplotlib axes object """ if ax is None: # create a new figure plt.figure(facecolor='w', edgecolor='k') ax = plt.gca() # Graph G = wn.get_graph() if not directed: G = G.to_undirected() # Position pos = nx.get_node_attributes(G, 'pos') if len(pos) == 0: pos = None # Define node properties add_node_colorbar = add_colorbar if node_attribute is not None: if isinstance(node_attribute, list): if node_cmap is None: node_cmap = ['red', 'red'] add_node_colorbar = False if node_cmap is None: node_cmap = plt.cm.Spectral_r elif isinstance(node_cmap, list): if len(node_cmap) == 1: node_cmap = node_cmap * 2 node_cmap = custom_colormap(len(node_cmap), node_cmap) node_attribute = _format_node_attribute(node_attribute, wn) nodelist, nodecolor = zip(*node_attribute.items()) else: nodelist = None nodecolor = 'k' add_link_colorbar = add_colorbar if link_attribute is not None: if isinstance(link_attribute, list): if link_cmap is None: link_cmap = ['red', 'red'] add_link_colorbar = False if link_cmap is None: link_cmap = plt.cm.Spectral_r elif isinstance(link_cmap, list): if len(link_cmap) == 1: link_cmap = link_cmap * 2 link_cmap = custom_colormap(len(link_cmap), link_cmap) link_attribute = _format_link_attribute(link_attribute, wn) # Replace link_attribute dictionary defined as # {link_name: attr} with {(start_node, end_node, link_name): attr} attr = {} for link_name, value in link_attribute.items(): link = wn.get_link(link_name) attr[(link.start_node_name, link.end_node_name, link_name)] = value link_attribute = attr linklist, linkcolor = zip(*link_attribute.items()) else: linklist = None linkcolor = 'k' if title is not None: ax.set_title(title) edge_background = nx.draw_networkx_edges(G, pos, edge_color='grey', width=0.5, ax=ax) nodes = nx.draw_networkx_nodes(G, pos, nodelist=nodelist, node_color=nodecolor, node_size=node_size, alpha=node_alpha, cmap=node_cmap, vmin=node_range[0], vmax=node_range[1], linewidths=0, ax=ax) edges = nx.draw_networkx_edges(G, pos, edgelist=linklist, edge_color=linkcolor, width=link_width, alpha=link_alpha, edge_cmap=link_cmap, edge_vmin=link_range[0], edge_vmax=link_range[1], ax=ax) if node_labels: labels = dict(zip(wn.node_name_list, wn.node_name_list)) nx.draw_networkx_labels(G, pos, labels, font_size=7, ax=ax) if link_labels: labels = {} for link_name in wn.link_name_list: link = wn.get_link(link_name) labels[(link.start_node_name, link.end_node_name)] = link_name nx.draw_networkx_edge_labels(G, pos, labels, font_size=7, ax=ax) if add_node_colorbar and node_attribute: clb = plt.colorbar(nodes, shrink=0.5, pad=0, ax=ax) clb.ax.set_title(node_colorbar_label, fontsize=10) if add_link_colorbar and link_attribute: if directed: vmin = min(map(abs, link_attribute.values())) vmax = max(map(abs, link_attribute.values())) sm = plt.cm.ScalarMappable(cmap=link_cmap, norm=plt.Normalize(vmin=vmin, vmax=vmax)) sm.set_array([]) clb = plt.colorbar(sm, shrink=0.5, pad=0.05, ax=ax) else: clb = plt.colorbar(edges, shrink=0.5, pad=0.05, ax=ax) clb.ax.set_title(link_colorbar_label, fontsize=10) ax.axis('off') if filename: plt.savefig(filename) return ax
['Model Response', 'Measured Data', 'Epoched Data', 'Filter Response']) fig.axes[0].set_ylabel('Filter Magnitude (dB) [invalid for other lines]') fig.axes[0].set_title('') ############################################################################### # Understanding the relation between stimulus presentation and response # --------------------------------------------------------------------- # # Here we look at the effect of the interstimulus interval on the # expected haemodynamic response. We choose a few different # maximum and minimum # values for the ISI. Two repeats are plotted per # ISI to illustrate the random selection. # Some common high pass filter values from literature are shown in red. sm = plt.cm.ScalarMappable(cmap='viridis', norm=plt.Normalize(vmin=0, vmax=60)) fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(20, 10)) for rep in range(2): for column, min_isi in enumerate([0, 15]): for row, max_isi in enumerate([15, 30, 45, 60]): if max_isi >= min_isi: if max_isi >= min_isi: raw = simulate_nirs_raw(sfreq=4., sig_dur=60 * 60, amplitude=1., stim_dur=5., isi_min=min_isi, isi_max=max_isi) raw._data[0] = raw._data[0] - np.mean(raw._data[0]) raw.pick(picks='hbo').plot_psd(average=True, fmax=2,
def map_show(combined_df, detail_level, data_option, display_value, path_object): color_min = 0 color_max = 200000 print("Putting lipstick on the pig...") # TODO: extract magic numbers fig, ax = plt.subplots(1, figsize=(6, 2)) ax.axis('off') map_title = "covid " + data_option + " by " + detail_level ax.set_title(map_title.title(), fontdict={ 'fontsize': '25', 'fontweight': '3' }) ax.annotate("Source: Harvard ", xy=(0.1, .08), xycoords='figure fraction', horizontalalignment='left', verticalalignment='top', fontsize=12, color='#555555') # Create colorbar as a legend # TODO: add second colorbar? sm = plt.cm.ScalarMappable(cmap='Greys', norm=plt.Normalize(vmin=color_min, vmax=color_max)) # empty array for the data range sm._A = [] # add the colorbar to the figure # TODO: pycharm tells me cbar is not used - what did I do? Is this not needed anymore? cbar = fig.colorbar(sm) # create map # TODO: extract magic numbers # ax=ax? that can't be right. rename? fig.tight_layout() # us_50_states_df.plot # combined_df.plot(cmap='Greys', linewidth=0.8, ax=ax, edgecolor='0.8') print("Painting base map...") combined_df.plot(cmap='Greys', linewidth=0.8, ax=ax) # TODO: splitting by election results with county data seems to be a problem # process stopped by operating system for memory issues several times # after adding 'del' statements to clean some memory, pycharm crashed # is there some way to make this part work, or just need a better computer? print("Making it political...") red_states_df = combined_df[combined_df.PARTY.eq('republican')] blue_states_df = combined_df[combined_df.PARTY.eq('democrat')] print("Freeing memory: combined_df") del combined_df print("Painting by election results...") red_states_df.plot(display_value, ax=ax, cmap='Reds') blue_states_df.plot(display_value, ax=ax, cmap='Blues') fig.tight_layout() # TODO: save map.png to an 'images' directory print("Saving map to file: ") map_name = display_value + " " + detail_level + " covid " + data_option + " choropleth.png" # Can't have / in filenames. map_name = map_name.replace(" ", "_") map_name = map_name.replace("/", "-") map_path = os.path.join(path_object.image_path, map_name) fig.savefig(map_path, dpi=300) print(map_name) print("Displaying the finished product...") plt.show() # Matplotlib gives you lots of freedom in how you save figures. # The code below will save the figure as a png, # but if you want to fiddle about some more with it in Illustrator you can also save as svg. # If you save as png, make sure to use a dpi of 200 or above. # Otherwise the map and text will look all blurry. Nobody wants that. # fig.savefig("map_export.png", dpi=300) return
def plot_tree(ax, tree, cm='cividis', median=None, ignore=None): def maybe_expand(x): a = np.asanyarray(x) return a if len(a.shape) else a[np.newaxis] tree = tree.map(maybe_expand) min_v, max_v, depth = tree.min(), tree.max(), tree.depth() extra_ticks = [min_v, max_v] min_v, max_v = get_value_range(median, min_v, max_v) # Normalize tree values to [0, 1] rng = max_v - min_v # if rng one of 0, +inf, -inf, or nan if rng == 0 or rng == float('inf') or rng == float('-inf') or rng != rng: rng = float('nan') tree = tree.map(lambda xs: [(x - min_v) / rng for x in xs]) acc = [] acc.append([0.5, 0, 1, 0, 2 * math.pi, 0]) # makes sure 2pi = one revolution draw_tree(acc, tree, 1, range_theta[0], range_theta[1], depth, False, False, ignore=ignore) acc = sorted(acc, key=lambda x: x[-1]) # sort by depth df = pd.DataFrame(acc, columns=['v', 'r', 'r0', 'theta', 'dtheta', 'depth']) cm = plt.cm.get_cmap(cm) if isinstance(cm, str) else cm plot = ax.bar(df['theta'], df['r'], width=df['dtheta'], bottom=df['r0'], color=cm(df['v']), align='edge') sm = plt.cm.ScalarMappable(cmap=cm, norm=plt.Normalize(min_v, max_v)) sm.set_array(df['v']) if display_colorbar: cbar = plt.colorbar(sm, ax=ax, shrink=0.8, orientation='horizontal', pad=0.0) cbar.ax.tick_params(labelsize='small') cbar.ax.ticklabel_format(style='sci', axis='x', scilimits=(-3, 3)) else: cbar = None ax.set_thetamin(range_theta[0] / 2 / math.pi * 360) ax.set_thetamax(range_theta[1] / 2 / math.pi * 360) ax.set_thetagrids([]) ax.set_rgrids([]) ax.grid(False) ax.set_axis_off() return plot, cbar
non_zero = (np.abs(np.triu(partial_correlations, k=1)) > 0.02) # Plot the nodes using the coordinates of our embedding plt.scatter(embedding[0], embedding[1], s=100 * d ** 2, c=labels, cmap=plt.cm.spectral) # Plot the edges start_idx, end_idx = np.where(non_zero) #a sequence of (*line0*, *line1*, *line2*), where:: # linen = (x0, y0), (x1, y1), ... (xm, ym) segments = [[embedding[:, start], embedding[:, stop]] for start, stop in zip(start_idx, end_idx)] values = np.abs(partial_correlations[non_zero]) lc = LineCollection(segments, zorder=0, cmap=plt.cm.hot_r, norm=plt.Normalize(0, .7 * values.max())) lc.set_array(values) lc.set_linewidths(15 * values) ax.add_collection(lc) # Add a label to each node. The challenge here is that we want to # position the labels to avoid overlap with other labels for index, (name, label, (x, y)) in enumerate( zip(names, labels, embedding.T)): dx = x - embedding[0] dx[index] = 1 dy = y - embedding[1] dy[index] = 1 this_dx = dx[np.argmin(np.abs(dy))] this_dy = dy[np.argmin(np.abs(dx))]
## Plot PFD average / cell and data loss / cell if plot_sky_grid: plt.close() fig = plt.figure(figsize=(12, 4)) val = pfd_avg.to_value(cnv.dB_W_m2) vmin, vmax = val.min(), val.max() val_norm = (val - vmin) / (vmax - vmin) plt.bar( grid_info['cell_lon_low'], height=grid_info['cell_lat_high'] - grid_info['cell_lat_low'], width=grid_info['cell_lon_high'] - grid_info['cell_lon_low'], bottom=grid_info['cell_lat_low'], color=plt.cm.viridis(val_norm), align='edge', ) sm = plt.cm.ScalarMappable(cmap=plt.cm.viridis, norm=plt.Normalize(vmin=vmin, vmax=vmax)) cbar = plt.colorbar(sm) cbar.set_label('PFD average / cell [dB(W/m2)]') plt.title('EPFD {:s} constellation: total data loss: {:.2f}'.format( constellation_name, data_loss )) plt.xlabel('Azimuth [deg]') plt.ylabel('Elevation [deg]') plt.xlim((0, 360)) plt.ylim((0, 90)) plt.savefig( pjoin(FIGPATH, '{:s}_skygrid_avg_pfd_horizontal.png'.format(fig_basename)), bbox_inches='tight', dpi=100, ) plt.savefig( pjoin(FIGPATH, '{:s}_skygrid_avg_pfd_horizontal.pdf'.format(fig_basename)),