def color_by_data(data): norm = matplotlib.colors.Normalize(vmin=data.min, vmax=data.max) colors = [] for i, d in enumerate(data.vals): rgb = [x for x in data.palette(norm(d))[0:3]] colors.append(rgb) return colors
def smart_colormap(clevs, name='jet', extend='both', minval=0.0, maxval=1.0): ''' Automatically grabs the colors to extend the colorbar from the colormap. ''' # Define number of colors if extend == 'both': nrColors = len(clevs)+1 elif (extend == 'min') | (extend == 'max'): nrColors = len(clevs) elif (extend == 'neither'): nrColors = len(clevs)-1 else: nrColors = len(clevs)-1 extend = 'neither' # Get colormap cmap = get_cmap(name, nrColors) # Truncate colormap if asked if (minval != 0.0) or (maxval != 1.0): cmap = truncate_colormap(cmap, minval=minval, maxval=maxval, n=nrColors/2) # Get the list of colors colors = [] for i in range(0, nrColors): colors.append(cmap(i/(nrColors-1))) # Use utility function to get cmap and norm at the same time cmap, norm = from_levels_and_colors(clevs, colors, extend=extend) return(cmap, norm)
def get_colormap_reds_blues(n): n = n // 2 reds = ['#ffebc0', '#f84627', '#950026'] blues = ['#0a2a6a', '#437aea', '#c8d9fd'] colors = blues[:n] colors.append(reds[:n]) return colors
def pie_plot_percent_mentions(mentions_percent, save_to = None): ''' Inputs: Dictionary with keys as pairs, values as percent of mentions ''' other = mentions_percent.pop("Other") swapped = {v:k for k, v in mentions_percent.items()} sizes = sorted(swapped) sizes.reverse() labels = [swapped[current_percent] for current_percent in sizes] sizes.append(other) labels.append("Other") N = len(labels) color_map = get_colormap(N-1) colors = [] for i in range(N-1): col = color_map(i) colors.append(col) colors.append("white") print(colors) plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90) # Set aspect ratio to be equal so that pie is drawn as a circle. plt.axis('equal') fig = plt.figure() ax = fig.gca() plt.show()
def update_data(self, change=None): ylist = [] colors = [] selection_was_list, [selections ] = vaex.utils.listify(self.model.selection) if self.dimension_groups == 'slice': y0 = self.model.grid if selection_was_list: y0 = y0[0] ylist.append(y0) colors.append(C0) if self.model.grid_sliced is not None: y1 = self.model.grid_sliced if selection_was_list: y1 = y1[0] ylist.append(y1) colors.append(C1) elif self.dimension_groups == 'selections': ylist = self.model.grid if selection_was_list: colors = colors_default[:len(ylist)] else: colors = [colors_default[0]] else: raise ValueError( f'Unknown action {self.dimension_groups} for dimension_groups') if self.normalize: ylist = [y / np.sum(y) for y in ylist] x = self.model.x.bin_centers self.plot.x_min = self.model.x.min self.plot.x_max = self.model.x.max self.plot.update_data(x, np.array(ylist), colors)
def smart_colormap(clevs, name='jet', extend='both', minval=0.0, maxval=1.0): ''' Automatically grabs the colors to extend the colorbar from the colormap. ''' # Define number of colors if extend == 'both': nrColors = len(clevs) + 1 elif (extend == 'min') | (extend == 'max'): nrColors = len(clevs) elif (extend == 'neither'): nrColors = len(clevs) - 1 else: nrColors = len(clevs) - 1 extend = 'neither' # Get colormap cmap = get_cmap(name, nrColors) # Truncate colormap if asked if (minval != 0.0) or (maxval != 1.0): cmap = truncate_colormap(cmap, minval=minval, maxval=maxval, n=nrColors / 2) # Get the list of colors colors = [] for i in range(0, nrColors): colors.append(cmap(i / (nrColors - 1))) # Use utility function to get cmap and norm at the same time cmap, norm = from_levels_and_colors(clevs, colors, extend=extend) return (cmap, norm)
def _highlight_allen_ids(self, allen_ids): weights = np.ones( (len(self.labels), ), dtype=np.float32) * self.off_weight # Background weights[0] = 0.0 for allen_id in allen_ids: labels_for_id = labels_for_allen_id(allen_id) weights[labels_for_id] = self.on_weight if not allen_ids: return surfaces = [structure_mesh(allen_id) for allen_id in allen_ids] self.itk_viewer.geometries = self.swc_geometries + surfaces self.itk_viewer.geometry_opacities = [1.0,]*len(self.swc_geometries) + \ [0.5,]*len(surfaces) colors = list( self.itk_viewer.geometry_colors)[:len(self.swc_geometries)] for allen_id in allen_ids: hex_color = '#' + allen_id_to_tree_node[allen_id].color_hex_triplet colors.append(matplotlib.colors.to_rgb(hex_color)) self.itk_viewer.geometry_colors = np.array(colors, dtype=np.float32) self.itk_viewer.label_image_weights = weights self.itk_viewer.ui_collapsed = True
def plot_peak_mobility_gate_voltage(analyzed_data, position="any"): """ This function plots the gate voltage at which peak mobility is achieved. """ exclude_ids = () c = {(None, 'H2O'): 'tab:red', ('tma', 'H2O'): 'tab:orange', ('tma', 'O3'): 'tab:olive', ('plasma', 'H2O'): 'tab:blue', ('plasma', 'O3'): 'tab:green'} m = {(None, 'H2O'): 'x', ('tma', 'H2O'): '^', ('tma', 'O3'): 'v', ('plasma', 'H2O'): 'd', ('plasma', 'O3'): 'o'} # Extract a list of peak mobilities and voltages colors = [] markers = [] voltages = [] mobilities = [] for sid, sample in analyzed_data.items(): if sid in exclude_ids: continue if position != "any": if sample.position != position: continue # Get the measured values from the measurements for this sample for measurement in sample.measurements: colors.append(c[(sample.treatment, sample.ald["oxidiser"])]) markers.append(m[(sample.treatment, sample.ald["oxidiser"])]) voltages.append(measurement.vg_at_peak) mobilities.append(measurement.mob_at_peak) fig, ax = plt.subplots() for volt, mob, col, mark in zip(voltages, mobilities, colors, markers): ax.scatter(x=volt, y=mob, c=col, marker=mark, alpha=1) ax.set_xlabel(r"Gate Voltage at Peak Mobility $\left(\si{\volt}\right)$") ax.set_ylabel(r"Peak Mobility $\left(\si[per-mode=fraction]{\square\centi\meter\per\volt\per\second}\right)$") ax.set_ylim(15000, 50000) fig.tight_layout() plt.show()
def plot_structure(type): for m in [100, 75, 50, 40, 30, 20, 10]: plt.close('all') rel_chunks = df.loc[df['length_of_chunk'] == m] colors = [] if type == "essays": all_docs = all_essays else: all_docs = all_summaries for c, thesis in enumerate(all_docs[0:13]): this_doc_len_m = rel_chunks.loc[rel_chunks['document'] == thesis] if this_doc_len_m.empty == True: continue ints = [] max_number_of_this_chunk = np.max( this_doc_len_m['number_of_chunk']) for i in this_doc_len_m['number_of_chunk']: # transform the chunk number into a percentage of how far in the document this chunk is ints.append(100 * int(i) / max_number_of_this_chunk) # have to apend color as well?! for i in range(len(ints)): colors.append(colors_list[c]) plt.plot(ints, this_doc_len_m['GFI'], '-o', color=colors_list[c]) # when the lines of all theses are there, we can combine them in one plot and store it plt.gcf().set_size_inches(14, 7) plt.ylabel('GFI') plt.xlabel("document's percentage of the chunk's end") #plt.suptitle('GFI for the chunks of size ' + str(m) + ' of document', fontsize=14) plt.savefig('Plots/German/assignments/' + type + '/structure/all' + str(m) + '_long_indicesOverNumberOfChunk.svg', bbox_inches='tight')
def plot_single_piechart(self, cluster_no, labels, pdf): cluster_label_dict = {} for label in labels: if label not in cluster_label_dict: cluster_label_dict[label] = 1 else: cluster_label_dict[label] += 1 distinct_labels = [] label_counts = [] colors = [] cmap = self.get_cmap(30) i = 0 for label,value in cluster_label_dict.iteritems(): colors.append(cmap(i)) distinct_labels.append(label) label_counts.append(value) i = i+1 matplotlib.rcParams['font.size'] = 5 plt.figure(figsize=(8,8)) plt.pie(label_counts, explode=None, labels=distinct_labels, colors=colors, autopct='%1.1f%%', shadow=True, startangle=90) # Set aspect ratio to be equal so that pie is drawn as a circle. plt.axis('equal') plt.suptitle("Cluster no " + str(cluster_no) + "\nNumber of docs in cluster: " + str(len(labels)),fontsize=10) pdf.savefig() plt.close()
def compute_color_histograms(cloud, using_hsv=False): # Convert each cloud point's color in float format to a three channel format # point format: [x, y, z, color_in_float] colors = [] cloud_points = pc2.read_points(cloud, skip_nans=True) for point in cloud_points: rgb_color = float_to_rgb(point[3]) if using_hsv: colors.append(rgb_to_hsv(rgb_color) * 255) else: colors.append(rgb_color) # Put each color channel in their own list ch1, ch2, ch3 = separate_channels(colors) # Concatenate each histogram and normalize the results features = get_normalized_feature_set(ch1, ch2, ch3, n_bins=64, range_bins=(0, 256)) return features
def make_image(neuron, A, scale_depth, index_neuron): normal_vectors = A[0:2,:] orthogonal_vector = A[2,:] depth = depth_points(neuron.location, orthogonal_vector) p = project_points(neuron.location, normal_vectors) m = min(depth) M = max(depth) depth = scale_depth * ((depth - m)/(M-m)) colors = [] lines = [] for i in range(len(neuron.nodes_list)): colors.append((depth[i],depth[i],depth[i],1)) j = neuron.parent_index[i] lines.append([(p[0,i],p[1,i]),(p[0,j],p[1,j])]) lc = mc.LineCollection(lines, colors=colors, linewidths=2) fig, ax = pl.subplots() ax.add_collection(lc) pl.axis('off') pl.xlim((min(p[0,:]),max(p[0,:]))) pl.ylim((min(p[1,:]),max(p[1,:]))) Name = "neuron" + str(index_neuron[0]+1) + "resample" + str(index_neuron[1]+1) + "angle" + str(index_neuron[2]+1) + ".png" fig.savefig(Name,figsize=(6, 6), dpi=80) img = Image.open(Name) img.load() data = np.asarray( img, dtype="int32" ) data = data[:,:,0] return data
def draw_trajectories(demos): all_thresholds = np.arange(len(demos)) envs = np.load("valid_environments.npy")[0] envs[0, 0] = 0 for i in range(len(demos)): temp_envs = np.array(envs) temp_demos = demos[0:i + 1] latest_demo = demos[i] goal = latest_demo[len(latest_demo) - 1, 0] start = latest_demo[0, 0] temp_envs[goal, 0] = 1 plt.figure(i, figsize=(24, 13.5), dpi=80) p1 = plt.subplot(1, 1, 1) colors = [] for c in range(0, i): colors.append('darkgrey') colors.append('yellow') #['blue','green','red','cyan','magenta','yellow','black','white','blue'] DrawTrajectory.draw_traj(p1, env=temp_envs, trajectories=temp_demos, grid_size=5, arrow_colors=colors, threshold_plt=False, temp_threshold=all_thresholds, width=0.015, legend_plot=True, start_state=start) plt.savefig("demo_plots/demos_" + str(i) + ".png") plt.close("all") pic_to_gif.convert_to_gif(len(demos))
def get_palette(groups): indexT, indexS = 0, 0 colors = [] for group in groups: color, indexT, indexS = get_color(group, indexT, indexS) colors.append(color) return colors
def _get_colors(num_colors): colors=[] for i in np.arange(0., 360., 360. / num_colors): hue = i/360. lightness = (50 + np.random.rand() * 10)/100. saturation = (90 + np.random.rand() * 10)/100. colors.append(colorsys.hls_to_rgb(hue, lightness, saturation)) return colors
def basic_FCA(G, kappa, its = int(pow(2,32)-1), verbose=True, timesec=0, tree=False, no_edges=0): # initial conditions blink = floor((kappa-1)/2) # blink color and lower bound on post-blink colors = [] init_col = G.get_colors() colors.append(init_col) if tree: parentlist = [None] * G.num_nodes() values = np.random.rand(G.num_nodes()) # local helper function def new_color(vertex): neighblist = G.get_neighbor_colors(vertex) if(G.get_color(vertex) > blink and \ any(np.array(neighblist) == blink)): return G.get_color(vertex) return (G.get_color(vertex) + 1) % kappa # initial coloring and start time current_col = G.get_colors() width_compute(current_col, kappa) s = time.time() for i in range(1, its+1): # perform updates for each vertex current_col = list(map(new_color, range(0, G.num_nodes()))) # check synchronization -> break and return final list and iterations width = width_compute(current_col,kappa) if(width < floor(kappa/2)): if verbose: print("Iterations: ",i) if no_edges: return np.array([-1, init_col, 1, colors, i]) return np.array([G.edges, init_col, 1, colors, i]) if timesec and time.time()-s > timesec: if verbose: print("Iterations: ",i) print("Time has been reached: ", timesec,"sec.") if no_edges: return np.array([-1, init_col, 0, colors, i]) return np.array([G.edges, init_col, 0, colors, i]) # update to new colors G.set_colors(current_col) colors.append(np.array(G.get_colors())) if tree: values, parentlist = tree_iter(G, values, parentlist) tree = not (len(G.edges) == G.num_nodes()-1) if (len(G.edges)<G.num_nodes()-1): print("deleted too many edges") if verbose: print("Max iterations reached: ", its) if no_edges: return np.array([-1, init_col, 0, colors, i]) return np.array([G.edges, init_col, 0, colors, i])
def transformColorList(colorList,alpha): colors = [] for rgb in colorList: rd = int(rgb.split()[0]) gn = int(rgb.split()[1]) bl = int(rgb.split()[2]) rgb_tuple = (rd/255.,gn/255.,bl/255.,alpha) colors.append(rgb_tuple) return colors
def show_colorchecker_swatches(): colors = [] fig,axs = plt.subplots(4,6) for i in range(len(refRGB)): colors.append(np.full((10,10,3),refRGB[i],dtype = np.uint8) / 255.0) m = i + 1 plt.subplot(4,6,m) plt.imshow(colors[i]) plt.show()
def float_list_type(mystring): """Convert string-form list of doubles into list of doubles.""" colors = [] for f in mystring.strip("(").strip(")").strip("[").strip("]").split(","): try: colors.append(float(f)) except: colors.append(f) return colors
def show_color_swatches(colorMatrix): colors = [] fig,axs = plt.subplots(4,6) for i in range(len(colorMatrix)): colors.append(np.full((10,10,3),colorMatrix[i],dtype = np.uint8) / 255.0) m = i + 1 plt.subplot(4,6,m) plt.imshow(colors[i]) plt.show()
def getColorMap( rgbFile = "medspiration.rgb" ): colors = [] rgbFile = os.path.join(os.path.dirname(__file__), rgbFile ) nbCol=0 for line in open( rgbFile ): r,g,b = [int(c) for c in line.split()] colors.append( [r/255.,g/255.,b/255.] ) nbCol += 1 return( matplotlib.colors.ListedColormap(colors, name="custom", N=nbCol) )
def getColorMap(rgbFile="medspiration.rgb"): colors = [] rgbFile = os.path.join(os.path.dirname(__file__), rgbFile) nbCol = 0 for line in open(rgbFile): r, g, b = [int(c) for c in line.split()] colors.append([r / 255., g / 255., b / 255.]) nbCol += 1 return (matplotlib.colors.ListedColormap(colors, name="custom", N=nbCol))
def _generate_colors(self): colors = [ 'blue', 'green', 'red', 'magenta', 'orange', 'black', 'brown', 'grey', 'olive' ] # strong colors for color in matplotlib.colors.cnames.keys(): if color not in colors and 'light' not in color: colors.append(color) return colors
def spiderweb_colormesh2d(data, axis, title='', fill_scheme='viridis', grid=False, norm=None, *args, **kwargs): """Prepare bar plot for 2D data visualization. matplotlib.pyplot.pcolormesh is used. Args: data(ndarray): 2D array of data. axis(axis): corresponding tomomak axis title(str, optional): Plot title. default: ''. fill_scheme(pyplot colormap, optional): pyplot colormap to be used in the plot. default: 'viridis'. grid(bool, optional): if True, grid is shown. default: False. *args, **kwargs: arguments will be passed to matplotlib.pyplot.pcolormesh Returns: plot: matplotlib pcolormesh . ax(axes.Axes ): axes.Axes object or array of Axes objects. See matplotlib Axes class fig(matplotlib.figure): The figure module. cb(matplotlib.pyplot.colorbar): colorbar on the right of the axis. """ x = axis.cell_edges2d() cmap = plt.get_cmap(fill_scheme) fig, ax = plt.subplots() colors = [] for i in range(len(x)): colors.append(data[i]) patches = [] for i in range(len(x)): polygon = Polygon(x[i]) patches.append(polygon) p = PatchCollection(patches, cmap=cmap, alpha=1.0) p.set_array(np.array(colors)) plot = ax.add_collection(p) cb = fig.colorbar(plot, ax=ax) ax.set_title(title) xlabel = "{}, {}".format(axis.name, axis.units) ylabel = "{}, {}".format(axis.name, axis.units) ax.set(xlabel=xlabel, ylabel=ylabel) if grid: ax.grid() return plot, ax, fig, cb
def get_n_colors2(num_colors): """http://stackoverflow.com/questions/470690/ how-to-automatically-generate-n-distinct-colors""" colors = [] for i in np.arange(0., 360., 360. / num_colors): hue = i / 360. lightness = (50 + np.random.rand() * 10) / 100. saturation = (90 + np.random.rand() * 10) / 100. colors.append(colorsys.hls_to_rgb(hue, lightness, saturation)) return colors
def make_IDLCB37(): #-- create a colors map ----------- CB37 = np.load(dir + '/IDLCB37.npz') R = CB37['R37'] G = CB37['G37'] B = CB37['B37'] colors = [(R[0], G[0], B[0])] for i in range(1, 256, 1): colors.append((R[i], G[i], B[i])) cmap = make_cmap(colors, bit=True) return cmap
def stackplot_percent_mentions_per_time(mentions_percent, candidate_list, title, save_to = None): ''' Generates and saves a stackplot with the percent mentions over time Inputs: mentions: Dictionary with keys as candidates, values as percent or number of mentions candidate_list : candidates to include title: string save_to: Directory as a string Returns: A saved file if save_to is not None. ''' num_candidates = len(candidate_list) all_ys = [0]*num_candidates for i, candidate in enumerate(candidate_list): times = mentions_percent[candidate] xs = sorted(times) ys = [] for x in xs: y = times[x] ys.append(y) all_ys[(num_candidates - 1) - i] = ys #num_candidates - 1 to account for lists starting at index = 0 stacked_ys = np.row_stack(tuple(all_ys)) color_map = get_colormap(num_candidates-1) colors = [] for i in range(num_candidates-1): col = color_map(i) colors.append(col) colors.append("white") print(colors) legend_colors = [mpatches.Patch(edgecolor = 'black', facecolor = color) for color in colors[::-1]] params = {'legend.fontsize': 8,'legend.linewidth': 2} plt.rcParams.update(params) fig, ax = plt.subplots() ax.stackplot(xs, stacked_ys, colors = colors) plt.xticks(fontsize = 8) plt.legend(legend_colors, candidate_list) plt.xlabel("Time (mins)") plt.ylabel("Percent of Tweets") plt.title(title) if save_to is None: plt.show() else: fig.savefig(save_to) #directory and filename
def get_rand_color(val): h,s,v = random()*6, 0.5, 243.2 colors = [] for i in range(val): h += 3.75#3.708 tmp = ((v, v-v*s*abs(1-h%2), v-v*s)*3)[5**int(h)/3%3::int(h)%2+1][:3] colors.append('#' + '%02x' *3%tmp) if i%5/4: s += 0.1 v -= 51.2 return colors
def vibrant_colors(n, is_int=False): colors = [] for i in np.arange(0., 360., 360. / n): hue = i / 360. lightness = (50 + np.random.rand() * 10) / 100. saturation = (90 + np.random.rand() * 10) / 100. colors.append(colorsys.hls_to_rgb(hue, lightness, saturation)) if is_int: colors = np.multiply(colors, 255).astype(np.int) return colors
def get_colors(n_colors, exclude_colors=None, return_excluded=False, pastel_factor=0, n_attempts=1000, colorblind_type=None): """ Generate a list of n visually distinct colours. :param n_colors: How many colours to generate :param exclude_colors: A pre-existing list of (r,g,b) colours that new colours should be distinct from. If exclude_colours=None then exclude_colours will be set to avoid white and black (exclude_colours=[(0,0,0), (1,1,1)]). (r,g,b) values should be floats between 0 and 1. :param return_excluded: If return_excluded=True then exclude_colors will be included in the returned color list. Otherwise only the newly generated colors are returned (default). :param pastel_factor: float between 0 and 1. If pastel_factor>0 paler colours will be generated. :param n_attempts: number of random colours to generated to find most distinct colour. :param colorblind_type: generate colours that are distinct with given type of colourblindness. Can be: 'Normal': Normal vision 'Protanopia': Red-green colorblindness (1% males) 'Protanomaly': Red-green colorblindness (1% males, 0.01% females) 'Deuteranopia': Red-green colorblindness (1% males) 'Deuteranomaly': Red-green colorblindness (most common type: 6% males, 0.4% females) 'Tritanopia': Blue-yellow colourblindness (<1% males and females) 'Tritanomaly' Blue-yellow colourblindness (0.01% males and females) 'Achromatopsia': Total colourblindness 'Achromatomaly': Total colourblindness :return: colors - A list of (r,g,b) colors that are visually distinct to each other and to the colours in exclude_colors. (r,g,b) values are floats between 0 and 1. """ if exclude_colors is None: exclude_colors = [WHITE, BLACK] colors = exclude_colors.copy() for i in range(n_colors): colors.append( distinct_color(colors, pastel_factor=pastel_factor, n_attempts=n_attempts, colorblind_type=colorblind_type)) if return_excluded: return colors else: return colors[len(exclude_colors):]
def get_grid_patch_collection(self, zpts, plotarray, **kwargs): """ Get a PatchCollection of plotarray in unmasked cells Parameters ---------- zpts : numpy.ndarray array of z elevations that correspond to the x, y, and horizontal distance along the cross-section (self.xpts). Constructed using plotutil.cell_value_points(). plotarray : numpy.ndarray Three-dimensional array to attach to the Patch Collection. **kwargs : dictionary keyword arguments passed to matplotlib.collections.PatchCollection Returns ------- patches : matplotlib.collections.PatchCollection """ from matplotlib.patches import Polygon from matplotlib.collections import PatchCollection rectcol = [] v = [] colors = [] for k in range(zpts.shape[0]-1): for idx in range(0, len(self.xpts)-1, 2): try: ll = ((self.xpts[idx][2], zpts[k+1, idx])) try: dx = self.xpts[idx+2][2] - self.xpts[idx][2] except: dx = self.xpts[idx+1][2] - self.xpts[idx][2] dz = zpts[k, idx] - zpts[k+1, idx] pts = (ll, (ll[0], ll[1]+dz), (ll[0]+dx, ll[1]+dz), (ll[0]+dx, ll[1])) #, ll) if np.isnan(plotarray[k, idx]): continue if plotarray[k, idx] is np.ma.masked: continue rectcol.append(Polygon(pts, closed=True)) colors.append(plotarray[k, idx]) except: pass if len(rectcol) > 0: patches = PatchCollection(rectcol, **kwargs) patches.set_array(np.array(colors)) else: patches = None return patches
def make_redblue(min, max): #-- create a colors map ----------- colors = [(255, 255, 255)] for i in range(1, 256, 1): colors.append((255, 255, 255)) #print(colors) #---------------------------------- # find the position of zero if min * max > 0: print('min*max >=0') print('Please check your setting !') print('Program STOP at make_redblue') exit() if min > max: print('min > max ?') print('Please check your setting !') print('Program STOP at make_redblue') exit() num_zero = int(256 * abs(min) / (max + abs(min))) num_zero1 = num_zero + 1 # color map for > 0 iR = 255 iG = 255 iB = 255 for i in range(num_zero1 + 1, 256, 1): #print(i) iG = iG - 6 if iG >= 0: colors[i] = (255, iG, 255) else: iB = iB - 6 if iB >= 0: colors[i] = (255, 0, iB) else: iR = iR - 1 colors[i] = (iR, 0, 0) # color map for < 0 iR = 255 iG = 255 iB = 255 for i in range(num_zero - 1, -1, -1): #print(i) iR = iR - 6 if iR >= 0: colors[i] = (iR, 255, 255) else: iG = iG - 6 if iG >= 0: colors[i] = (0, iG, 255) else: iB = iB - 1 colors[i] = (0, 0, iB) cmap = make_cmap(colors, bit=True) return cmap
def update_node_status(self, *args): colors = [] for i, module in enumerate(self.data_model.modules): if (i in self.data_model.input_nodes) and (len( module['config']['filelist']) == 0): colors.append('red') else: colors.append('green') #update plot with self.data_view.graph.batch_update(): self.data_view.node_status.marker.color = colors
def gen_circular_cmap(colors: List[str]): colors = list(colors) # `colors` has 12 distinct entries. # LinearSegmentedColormap(colors) takes a real number `x` between 0 and 1, # and maps x=0 to colors[0] and x=1 to colors[-1]. # pitch_cmap should be periodic, so `colors[0]` should appear at both x=0 and x=1. colors.append(colors[0]) cmap = matplotlib.colors.LinearSegmentedColormap.from_list( "12-tone spectrum", colors, N=256, gamma=1.0) return cmap
def list_by_values(*args): """ Returns a list of colors matching up with the range of numerical values provided refer to https://github.com/tomerburg/metlib/blob/master/colors/color_list.py Examples: This is the call to the list_by_values function. Input parameters are as many ranges as desired. In this example, there are 3 ranges, one starting from #00FFFF for a value of 25 and going to #0000FF for a value of 29. colors = list_by_values( [['#00FFFF',25.0],['#0000FF',29.0],1.0], [['#0000FF',29.0],['#0000AA',32.0],1.0], [['#0000AA',32.0],['#FF00FF',38.0],1.0]) print(colors) """ #Initialize an empty color list colors = [] #Loop through the passed lists #The format for each argument is: [['#00FFFF',25.0],['#0000FF',29.0],1.0] #['#00FFFF',25.0] = [start hex value, start value] #['#0000FF',29.0] = [end hex value, end value] #1.0 = interval of requested range between start & end values for arg in args: #Retrieve arguments start_hex = arg[1][0].lstrip('#') end_hex = arg[0][0].lstrip('#') start_value = arg[0][1] end_value = arg[1][1] interval = arg[2] #Calculate start and end RGB tuples start_rgb = tuple(int(start_hex[i:i + 2], 16) for i in (0, 2, 4)) end_rgb = tuple(int(end_hex[i:i + 2], 16) for i in (0, 2, 4)) #Loop through the number of colors to add into the list start_loop = start_value end_loop = end_value + interval if arg == args[-1] else end_value for x in np.arange(start_loop, end_loop, interval): #Get hex value for the color at this point in the range nrange_color = (end_value - start_value) idx = x - start_value hex_val = getColor(idx, nrange_color, start_rgb, end_rgb) #Append to list if this is different than the last color if len(colors) == 0 or colors[-1] != hex_val: colors.append(hex_val) #Return the list of colors return colors
def get_rand_color(val): h, s, v = random() * 6, 0.5, 243.2 colors = [] for i in range(val): h += 3.75 #3.708 tmp = ((v, v - v * s * abs(1 - h % 2), v - v * s) * 3)[5**int(h) / 3 % 3::int(h) % 2 + 1][:3] colors.append('#' + '%02x' * 3 % tmp) if i % 5 / 4: s += 0.1 v -= 51.2 return colors
def plot_spikes(nodes, spikes_file, save_file=None): import h5py spikes_h5 = h5py.File(spikes_file, 'r') spike_gids = np.array(spikes_h5['/spikes/gids'], dtype=np.uint) spike_times = np.array(spikes_h5['/spikes/timestamps'], dtype=np.float) spikes = np.rot90(np.vstack( (spike_gids, spike_times))) # Make array [[gid spiketime],[gid2 spiketime2]] #spikes = spikes[spikes[:,0].argsort()] # Sort by cell number """ Author: Tyler Banks Loop through all spike files, create a list of when each cell spikes, plot. """ cell_types = ['EC', 'CA3e', 'CA3o', 'CA3b', 'DGg', 'DGh', 'DGb'] cell_nums = [30, 63, 8, 8, 384, 32, 32] d = [[] for _ in range(sum(cell_nums))] color_picker = [ 'red', 'orange', 'yellow', 'green', 'blue', 'purple', 'black' ] colors = [] offset = 0 for i, row in enumerate(spikes): d[int(row[0]) + offset].append(row[1]) for i, n in enumerate(cell_nums): for _ in range(n): colors.append(color_picker[i]) fig, axs = plt.subplots(1, 1) axs.eventplot(d, colors=colors) axs.set_title('Hipp BMTK') axs.set_ylabel('Cell Number') axs.set_xlabel('Time (ms)') axs.legend(cell_types[::-1]) leg = axs.get_legend() for i, c in enumerate(color_picker): leg.legendHandles[-i - 1].set_color(c) #splt.savefig('raster3_after_pycvode_fixes.png') if save_file: plt.savefig(save_file) plt.draw() return
def convert_to_heatmap(weights, cm="Reds"): # 把权重转化为热力图,可是根据可视化需要选择colormap # https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html cmap = matplotlib.cm.get_cmap(cm) colors = [] for i in range(cmap.N): rgb = cmap(i)[:3] colors.append(matplotlib.colors.rgb2hex(rgb)) colors = np.array(colors) weights = np.uint8(255 * weights) heatmap = colors[weights] return heatmap
def add_edge(i, j,edge_points,edges,pointsTest,imgCirc,colors): """Add a line between the i-th and j-th points, if not in the list already""" if (i, j) in edges or (j, i) in edges: # already added colors.append(colorChoice(imgCirc[pointsTest[i,0],pointsTest[i,1]], imgCirc[pointsTest[j,0],pointsTest[j,1]])) return edge_points,edges,colors edges.add( (i, j) ) edge_points.append(pointsTest[[i, j]]) colors.append(colorChoice(imgCirc[pointsTest[i,0],pointsTest[i,1]], imgCirc[pointsTest[j,0],pointsTest[j,1]])) return edge_points,edges,colors
def stackplot_percent_mentions_per_time(mentions_percent, candidate_list, title): num_candidates = len(candidate_list) all_ys = [0]*num_candidates for i, candidate in enumerate(candidate_list): times = mentions_percent[candidate] xs = sorted(times) ys = [] for x in xs: y = times[x] ys.append(y) all_ys[(num_candidates - 1) - i] = ys #num_candidates - 1 to account for lists starting at index = 0 stacked_ys = np.row_stack(tuple(all_ys)) color_map = get_colormap(num_candidates-1) colors = [] for i in range(num_candidates-1): col = color_map(i) colors.append(col) colors.append("white") print(colors) legend_colors = [mpatches.Patch(edgecolor = 'black', facecolor = color) for color in colors[::-1]] params = {'legend.fontsize': 8,'legend.linewidth': 2} plt.rcParams.update(params) fig, ax = plt.subplots() ax.stackplot(xs, stacked_ys, colors = colors) #ax.set_xticks(pos + (bar_width/2)) plt.xticks(fontsize = 8) ax.set_xticklabels(x_labels, rotation = 60) plt.legend(legend_colors, candidate_list) plt.xlabel("Time (mins)") plt.ylabel("Percent of Tweets") plt.title(title) plt.show() ################################################ #Donald Trump, Carly Fiorina, Jeb Bush, Ben Carson, Ted Cruz, Rand Paul, and Marco Rubio
def deposit_cells(self): """ Deposit cells in a plane """ #coords = self.lattice.coordinates() #shape = coords.shape rho = numpy.mean(self.lattice.get_mesh_size()) print "Mean mesh size", rho nx = 40 x0 = 0.5-rho*nx/2.0 z0 = 0.5-rho*nx/2.0 print x0 y0 = 0.1 x = x0+numpy.linspace(0,nx*rho,nx) z = z0+numpy.linspace(0,nx*rho,nx) import itertools space = itertools.product(x,z) #cols = [5 10 15 20] coords = self.lattice.coordinates() shape = coords.shape Ncols = 50 # Select Ncols random points: idx = range(nx*nx) color_idx = random.sample(idx, Ncols) colors = [] color_map=get_cmap(len(color_idx)) for i in range(Ncols): colors.append(color_map(i)[0:3]) j=0 for i,p in enumerate(space): point = [p[0],y0,p[1]] reppoint = numpy.tile(point, (shape[0], 1)) dist = numpy.sqrt(numpy.sum((coords-reppoint)**2, axis=1)) ix = numpy.argmin(dist) cell=Cell(color="white",index=ix, time_to_division=self.cell_division_time(),time_to_migration=self.sample_migration_time()) if i in color_idx: cell.color=htmlcolor(colors[j]) j =j+1 if not self.state[ix]: heapq.heappush(self.cells,cell) self.state[ix]=cell
def pie_plot_percent_mentions(mentions_percent, save_to = None): ''' Generates and saves a pie plot with the percentage of mentions Inputs: mentions_percent: Dictionary with keys as candidates, values as percent of mentions save_to: Directory as a string Returns: A saved file if save_to is not None. ''' other = mentions_percent.pop("Other") swapped = {v:k for k, v in mentions_percent.items()} sizes = sorted(swapped) sizes.reverse() labels = [swapped[current_percent] for current_percent in sizes] sizes.append(other) labels.append("Other") N = len(labels) color_map = get_colormap(N-1) colors = [] for i in range(N-1): col = color_map(i) colors.append(col) colors.append("white") print(colors) plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90) # Set aspect ratio to be equal so that pie is drawn as a circle. plt.axis('equal') fig = plt.figure() ax = fig.gca() if save_to is None: plt.show() else: fig.savefig(save_to) #directory and filename
def plot_cluster(self): self.scale_data() print "finished scale" cmap = self.get_cmap(100) colors = [] for i in range(0, self.n_clusters): colors.append(cmap(i)) fig = plt.figure(figsize=(1,1)) #fig.subplots_adjust(left=0.02, right=0.98, bottom=0.05, top=0.9) ax = fig.add_subplot(1, 2, 1) for k, col in zip(range(self.n_clusters), colors): my_members = self.k_means_labels == k cluster_center = self.k_means_cluster_centers[k] ax.plot(self.X_scaled[my_members, 0], self.X_scaled[my_members, 1], 'w', markerfacecolor=col, marker='.') #fig.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col, # markeredgecolor='k', markersize=6) plt.show()
def colorTableList(num_colors): colors = [] # Transparent for the zero label colors.append((0,0,0,0)) rgb_color_values = list(nanshe.util.iters.splitting_xrange(num_colors)) converter = matplotlib.colors.ColorConverter() for _ in rgb_color_values: a_rgb_color = tuple() for __ in converter.to_rgba(matplotlib.cm.gist_rainbow(_)): a_rgb_color += ( int(round(255*__)), ) colors.append(a_rgb_color) colors = numpy.asarray(colors, dtype=numpy.uint8) return(colors)
def readClrColorRamp(self,path): f = open(path, 'r') colors = [] levels = None processtype = 0 for line in f: if 'colors' in line : processtype = 1 continue elif 'levels' in line : processtype = 2 continue if processtype == 1: colors.append([float(elem) for elem in line.split(';')]) #print 'col ' + str(colors) if processtype == 2: levels = ([float(elem) for elem in line.split(';')]) f.close() if colors and levels: return (self.arrayStepRGBAToCmap(colors),levels) else: return (None, None)
def version_balance(trials, ax=None, figsize=None): if ax is None: pyplot.figure(figsize=figsize) ax = pyplot.axes() counts = trials.program_name.value_counts().sort_index() # Assign colors by base colors = [] last_base = None color_i = -1 for n in counts.index: base = n.split("_")[0] if base != last_base: color_i += 1 last_base = base colors.append(kelly_colors[color_i]) counts.plot(kind="bar", ax=ax, color=colors) ax.set_title("Version Balance ({0} trials)".format(len(trials))) return ax
def fit_coefficients_version(fit, ax=None, figsize=None, intercept=True): if ax is None: pyplot.figure(figsize=figsize) ax = pyplot.axes() names = [get_fit_name(n) for n in fit.model.exog_names] means = fit.conf_int().apply(lambda x: np.mean(x), axis=1) err = fit.conf_int().apply(lambda x: (x[1] - x[0]) / 2.0, axis=1) # Assuming p-values come in the same order as confidence intervals for i, p_val in enumerate(fit.pvalues.values): if np.isclose(p_val, 1.0): err[i] = 0.0 if not intercept: means, err = means[1:], err[1:] names = names[1:] # Assign colors by base colors = [] last_base = None color_i = -1 for n in names: base = n.split("_")[0] if base != last_base: color_i += 1 last_base = base colors.append(kelly_colors[color_i]) # Plot bars ax = means.plot(kind="bar", yerr=err, error_kw={"ecolor": "black"}, color=colors) ax.set_title("Coefficients by Program/Version") ax.set_ylabel("Coefficients (95% CI)") ax.set_xlabel("Program Base/Version") ax.set_xticklabels(names) return ax
def fancy_dendrogram(*args, **kwargs): max_d = kwargs.pop('max_d', None) if max_d and 'color_threshold' not in kwargs: kwargs['color_threshold'] = max_d annotate_above = kwargs.pop('annotate_above', 0) ddata = dendrogram(*args, **kwargs) colors = [] color_elements = ["FF", "00", "33", "66", "99", "AA", "DD"] color = ["00", "00", "00"] num = 0 if not kwargs.get('no_plot', False): plt.title('Dendrogram of hierarchical clustering', fontsize=28) plt.tick_params(labelsize=22) plt.xlabel('Genes', fontsize=24, color="black") plt.ylabel('Distance', fontsize=24, color="black") for i, d, c in zip(ddata['icoord'], ddata['dcoord'], ddata['color_list']): color_index = random.randint(0, 6) if num % 3 == 0: color = color[:2] + [color_elements[color_index]] elif num % 3 == 1: color = [color_elements[color_index]] + color[1:] elif num % 3 == 2: color = [color[0]] + [color_elements[color_index]] + [color[-1]] if ("".join(color) != "FFFFFF") and \ (color not in colors): c = '#' + "".join(color) colors.append(color) x = 0.5 * sum(i[1:3]) y = d[1] if y > annotate_above: plt.plot(x, y, color=c) num += 1 if max_d: plt.axhline(y=max_d, linewidth=3, color='orange') return ddata
def get_colors(): colors=[] colors.append( 'blue' ) colors.append( 'green' ) colors.append( 'red' ) colors.append( 'cyan' ) colors.append( 'magenta' ) colors.append( 'yellow' ) return colors
def _generate_colors(self): colors = ['blue', 'green', 'red', 'magenta', 'orange', 'black', 'brown', 'grey', 'olive'] # strong colors for color in matplotlib.colors.cnames.keys(): if color not in colors and 'light' not in color: colors.append(color) return colors
def partiview(root="./", align="align/align_d_rms_t", poly="polyfit_d/fit"): s = getOrbitStars(orbitFile="orbits_movie.dat", root=root, align=align, poly=poly) # Determine the mass assuming a distance of 8.46 kpc star0orb = s.stars[0].orbit dist = 8460.0 # in parsec axis = (star0orb.a / 1000.0) * dist # in au mass = (axis) ** 3 / star0orb.p ** 2 print "Mass = %.2e Msun Dist = %4d pc" % (mass, dist) names = s.getArray("name") ## Three sets of stars ## -- constrains Ro today ## -- constrains Ro/extended mass in future (radial velocities) ## -- constrains extended mass in future (no radial velocities) # Assume the stars are in increasing order by name stars1 = ["S0-2", "S0-16", "S0-19", "S0-1", "S0-20"] stars2 = [] stars3 = [] yngstars = ["S0-1", "S0-2", "S0-3", "S0-4", "S0-5", "S0-7", "S0-8", "S0-16", "S0-19", "S0-20", "S0-26"] oldstars = ["S0-6", "S0-18"] # All stars3 come after S0-26 foundS026 = False for name in names: try: idx = stars1.index(name) continue except ValueError: if foundS026 == False: stars2.append(name) if name == "S0-26": foundS026 = True else: stars3.append(name) # Duration of the animation (30 years) t = na.arange(1995.5, 1995.5 + 300.0, 0.1, type=na.Float) xpos = na.zeros((len(s.stars), len(t)), type=na.Float) ypos = na.zeros((len(s.stars), len(t)), type=na.Float) zpos = na.zeros((len(s.stars), len(t)), type=na.Float) colors = [] for ii in range(len(s.stars)): star = s.stars[ii] orb = star.orbit print "Working on ", star.name # Determine time steps x = star.getArrayAllEpochs("x") y = star.getArrayAllEpochs("y") (r, v, a) = orb.kep2xyz(t, mass=mass, dist=dist) xpos[ii] = r[:, 0] ypos[ii] = r[:, 1] zpos[ii] = r[:, 2] # Determine color if star.name in yngstars: colors.append("b") elif star.name in oldstars: colors.append("r") else: colors.append("y") _out = open("plots/partiview/partiview.dat", "w") for ti in range(len(t)): _out.write("%9.4f %d\n" % (t[ti], ti)) for si in range(len(s.stars)): _out.write("%7.3f %7.3f %7.3f %s\n" % (xpos[si, ti], ypos[si, ti], zpos[si, ti], colors[si])) _out.close()
for name_stepsize, group in grouped_stepsize: fig, ax = plt.subplots(ncols=3, nrows=4, sharex=True, sharey=True, figsize=(8., 6.)) grouped_clearborder_method = group.groupby(['clearborder', 'method']) ax[0, 0].set_ylim([0,0.65]) for name_clearborder_method, group2 in grouped_clearborder_method: x_clearborder, y_method = name_clearborder_method x, y = axes_clearborder[x_clearborder], axes_method[y_method] table = group2.groupby(['lambda']).mean() table = table.sort_index() AJI = table['AJI'] lambda_val = [i for i in table.index] colors = [] cmap = cm.get_cmap("gist_earth", len(lambda_val)+1) # PiYG for i in range(cmap.N - 1): rgb = cmap(i)[:3] # will return rgba, we take only first 3 so we get rgb colors.append(matplotlib.colors.rgb2hex(rgb)) width = 1, ax[x, y].bar(lambda_val, list(AJI), color=colors, alpha=1., width=width) ax[x, y].axhline(y=np.max(AJI),xmin=0,xmax=3,c="black",ls="--",linewidth=0.5,zorder=0) ax[x, y].text(7.5, np.max(AJI) + 0.01, "{0:.3}".format(np.max(AJI)), rotation=0) for a, col in zip(ax[0], cols): a.annotate(col, xy=(0.5, 1), xytext=(0, pad), xycoords='axes fraction', textcoords='offset points', ha='center', va='baseline') for a, row in zip(ax[:,0], rows): a.annotate(row, xy=(0, 0.5), xytext=(-a.yaxis.labelpad - pad, 0), xycoords=a.yaxis.label, textcoords='offset points', ha='right', va='center', rotation="vertical") ax[0,-1].set_xticks(ticks=lambda_val) ax[-2,1].set_xticks(ticks=lambda_val)
def prepare_lines(lines, scalars=None, do_connections=False, other=None): """Concatenate and standardize a list of lines Args: lines (list): Must be a list of 3xN or 4xN ndarrays of xyz(s) data for N points along the line. N need not be the same for all lines. Can alse be 6xN such that lines[:][3:, :] are interpreted as rgb colors scalars (sequence): can be one of:: - single hex color (ex, `#FD7400`) - sequence of Nlines hex colors - single rgb(a) tuple - sequence of Nlines rgb(a) sequences - sequence of N values that go with each vertex and will be mapped with a colormap - sequence of Nlines values that go each line and will be mapped with a colormap - Field. If `np.prod(fld.shape) in (N, nlines)` then the field is interpreted as a simple sequence of values (ie, the topology result from calc_streamlines for coloring each line). Otherwise, the field is interpolated onto each vertex. do_connections (bool): Whether or not to make connections array other (dict): a dictionary of other arrays that should be reshaped and the like the same way scalars is Returns: (vertices, scalars, connections, other) * vertices (ndarray): 3xN array of N xyz points. N is the sum of the lengths of all the lines * scalars (ndarray): N array of scalars, 3xN array of uint8 rgb values, 4xN array of uint8 rgba values, or None * connections (ndarray): Nx2 array of ints (indices along axis 1 of vertices) describing the forward and backward connectedness of the lines, or None * other (dict): a dict of N length arrays Raises: ValueError: If rgb data is not in a valid range or the shape of scalars is not understood """ nlines = len(lines) npts = [line.shape[1] for line in lines] N = np.sum(npts) first_idx = np.cumsum([0] + npts[:-1]) vertices = [np.asarray(line) for line in lines] vertices = np.concatenate(lines, axis=1) if vertices.dtype.kind not in 'fc': vertices = np.asarray(vertices, dtype='f') if vertices.shape[0] > 3: if scalars is not None: viscid.logger.warning("Overriding line scalars with scalars kwarg") else: scalars = vertices[3:, :] vertices = vertices[:3, :] if scalars is not None: scalars_are_strings = False if isinstance(scalars, viscid.field.Field): if np.prod(scalars.shape) in (nlines, N): scalars = np.asarray(scalars).reshape(-1) else: scalars = viscid.interp_trilin(scalars, vertices) if scalars.size != N: raise ValueError("Scalars was not a scalar field") elif isinstance(scalars, (list, tuple, viscid.string_types, np.ndarray)): # string types need some extra massaging if any(isinstance(s, viscid.string_types) for s in scalars): assert all(isinstance(s, viscid.string_types) for s in scalars) scalars_are_strings = True scalars = _string_colors_as_hex(scalars) elif isinstance(scalars, np.ndarray): scalars = scalars else: for i, si in enumerate(scalars): if not isinstance(si, np.ndarray): scalars[i] = np.asarray(si) scalars[i] = np.atleast_2d(scalars[i]) try: scalars = np.concatenate(scalars, axis=0) except ValueError: scalars = np.concatenate(scalars, axis=1) scalars = np.atleast_2d(scalars) if scalars.dtype == np.dtype('object'): raise RuntimeError("Scalars must be numbers, tuples of numbers " "that indicate rgb(a), or hex strings - they " "must not be python objects") if scalars.shape == (1, 1): scalars = scalars.repeat(N, axis=1) elif scalars.shape == (1, nlines) or scalars.shape == (nlines, 1): # one scalar for each line, so broadcast it scalars = scalars.reshape(nlines, 1) scalars = [scalars[i].repeat(ni) for i, ni in enumerate(npts)] scalars = np.concatenate(scalars, axis=0).reshape(1, N) elif scalars.shape == (N, 1) or scalars.shape == (1, N): # catch these so they're not interpreted as colors if # nlines == 1 and N == 3; ie. 1 line with 3 points scalars = scalars.reshape(1, N) elif scalars.shape in [(3, nlines), (nlines, 3), (4, nlines), (nlines, 4)]: # one rgb(a) color for each line, so broadcast it if (scalars.shape in [(3, nlines), (4, nlines)] and scalars.shape not in [(3, 3), (4, 4)]): # the guard against shapes (3, 3) and (4, 4) mean that # these square shapes are assumed Nlines x {3,4} scalars = scalars.T nccomps = scalars.shape[1] # 3 for rgb, 4 for rgba colors = [] for i, ni in enumerate(npts): c = scalars[i].reshape(nccomps, 1).repeat(ni, axis=1) colors.append(c) scalars = np.concatenate(colors, axis=1) elif scalars.shape in [(3, N), (N, 3), (4, N), (N, 4)]: # one rgb(a) color for each vertex if (scalars.shape in [(3, N), (4, N)] and scalars.shape not in [(3, 3), (4, 4)]): # the guard against shapes (3, 3) and (4, 4) mean that # these square shapes are assumed N x {3,4} scalars = scalars.T elif scalars.shape in [(1, 3), (3, 1), (1, 4), (4, 1)]: # interpret a single rgb(a) color, and repeat/broadcast it scalars = scalars.reshape([-1, 1]).repeat(N, axis=1) else: scalars = scalars.reshape(-1, N) # scalars now has shape (1, N), (3, N), or (4, N) if scalars_are_strings: # translate hex colors (#ff00ff) into rgb(a) values scalars = np.char.lstrip(scalars, '#') strlens = np.char.str_len(scalars) min_strlen, max_strlen = np.min(strlens), np.max(strlens) if min_strlen == max_strlen == 8: # 32-bit rgba (two hex chars per channel) scalars = _hexchar2int(scalars.astype('S8')).reshape(-1, 4).T elif min_strlen == max_strlen == 6: # 24-bit rgb (two hex chars per channel) scalars = _hexchar2int(scalars.astype('S6')).reshape(-1, 3).T else: raise NotImplementedError("This should never happen as " "scalars as colors should already " "be preprocessed appropriately") elif scalars.shape[0] == 1: # normal scalars, cast them down to a single dimension scalars = scalars.reshape(-1) elif scalars.shape[0] in (3, 4): # The scalars encode rgb data, standardize the result to a # 3xN or 4xN ndarray of 1 byte unsigned ints [0..255] if np.all(scalars >= 0) and np.all(scalars <= 1): scalars = (255 * scalars).round().astype('u1') elif np.all(scalars >= 0) and np.all(scalars < 256): scalars = scalars.round().astype('u1') else: raise ValueError("Rgb data should be in range [0, 1] or " "[0, 255], range given is [{0}, {1}]" "".format(np.min(scalars), np.max(scalars))) else: raise ValueError("Scalars should either be a number, or set of " "rgb values, shape is {0}".format(scalars.shape)) # scalars should now have shape (N, ) or be a uint8 array with shape # (3, N) or (4, N) encoding an rgb(a) color for each point [0..255] # ... done with scalars... # broadcast / reshape additional arrays given in other if other: for key, arr in other.items(): if arr is None: pass elif arr.shape == (1, nlines) or arr.shape == (nlines, 1): arr = arr.reshape(nlines, 1) arr = [arr[i].repeat(ni) for i, ni in enumerate(npts)] other[key] = np.concatenate(arr, axis=0).reshape(1, N) else: try: other[key] = arr.reshape(-1, N) except ValueError: viscid.logger.warning("Unknown dimension, dropping array {0}" "".format(key)) if do_connections: connections = [None] * nlines for i, ni in enumerate(npts): # i0 is the index of the first point of the i'th line in lines i0 = first_idx[i] connections[i] = np.vstack([np.arange(i0, i0 + ni - 1.5), np.arange(i0 + 1, i0 + ni - 0.5)]).T connections = np.concatenate(connections, axis=0).astype('i') else: connections = None return vertices, scalars, connections, other
def partiview(root='./', align='align/align_d_rms_t', poly='polyfit_d/fit'): s = getOrbitStars(orbitFile='orbits_movie.dat', root=root, align=align, poly=poly) # Determine the mass assuming a distance of 8.46 kpc star0orb = s.stars[0].orbit dist = 8460.0 # in parsec axis = (star0orb.a / 1000.0) * dist # in au mass = (axis)**3 / star0orb.p**2 print 'Mass = %.2e Msun Dist = %4d pc' % (mass, dist) names = s.getArray('name') ## Three sets of stars ## -- constrains Ro today ## -- constrains Ro/extended mass in future (radial velocities) ## -- constrains extended mass in future (no radial velocities) # Assume the stars are in increasing order by name stars1 = ['S0-2', 'S0-16', 'S0-19', 'S0-1', 'S0-20'] stars2 = [] stars3 = [] yngstars = ['S0-1', 'S0-2', 'S0-3', 'S0-4', 'S0-5', 'S0-7', 'S0-8', 'S0-16', 'S0-19', 'S0-20', 'S0-26'] oldstars = ['S0-6', 'S0-18'] # All stars3 come after S0-26 foundS026 = False for name in names: try: idx = stars1.index(name) continue except ValueError: if foundS026 == False: stars2.append(name) if name == 'S0-26': foundS026 = True else: stars3.append(name) # Duration of the animation (30 years) t = na.arange(1995.5, 1995.5 + 300.0, 0.1, type=na.Float) xpos = na.zeros((len(s.stars), len(t)), type=na.Float) ypos = na.zeros((len(s.stars), len(t)), type=na.Float) zpos = na.zeros((len(s.stars), len(t)), type=na.Float) colors = [] for ii in range(len(s.stars)): star = s.stars[ii] orb = star.orbit print 'Working on ', star.name # Determine time steps x = star.getArrayAllEpochs('x') y = star.getArrayAllEpochs('y') (r, v, a) = orb.kep2xyz(t, mass=mass, dist=dist) xpos[ii] = r[:,0] ypos[ii] = r[:,1] zpos[ii] = r[:,2] # Determine color if (star.name in yngstars): colors.append('b') elif (star.name in oldstars): colors.append('r') else: colors.append('y') _out = open('plots/partiview/partiview.dat', 'w') for ti in range(len(t)): _out.write('%9.4f %d\n' % (t[ti], ti)) for si in range(len(s.stars)): _out.write('%7.3f %7.3f %7.3f %s\n' % (xpos[si,ti], ypos[si,ti], zpos[si,ti], colors[si])) _out.close()
txtFilterSize = 'No. ' elif filterSize > 0 and filterSize < 10: txtFilterSize = str(filterSize) + ' . ' else: txtFilterSize = str(filterSize) + '. ' txtLegend = 'Zeros = ' + (fmt1 % zerosDBZ) + ' dBZ, filter = ' + txtFilterSize \ + r'$\beta_1$ = ' + (fmt2 % beta1) + r', $\beta_2$ = ' + (fmt2 % beta2) \ + ', break at ' + str(scalingBreak_best) + ' km' # Draw spectrum ax1.plot(10*np.log10(freq),10*np.log10(psd1d), color=colorLine, linestyle = lineStyle, label=txtLegend) else: print('You can only plot the 1d spectrum with this script...') sys.exit(1) colors.append(colorLine) colorLine = np.array(colorLine) + 1/len(zerosDBZlist) # Set colorbar stochastic realizations fig_noise.subplots_adjust(right=0.8) cbar_ax = fig_noise.add_axes([0.85, 0.15, 0.05, 0.7]) fig_noise.colorbar(im_noise, cax=cbar_ax) # Generate legend for spectra legend = ax1.legend(loc='lower left', fontsize=9, labelspacing=0.1) # for text in legend.get_texts(): # text.set_color("red") for color,text in zip(colors,legend.get_texts()): text.set_color(color) # Write betas and correlations
elif clusterAlgLabel == 'AffinityPropagation': original_shape = som.codebook.shape som.codebook.shape = (som._n_columns*som._n_rows, som.n_dim) init = -np.max(distance.pdist(som.codebook, 'euclidean')) som.codebook.shape = original_shape algorithm = clusterAlgs.AffinityPropagation(preference = init,damping = 0.9) elif clusterAlgLabel == 'KMeans8': algorithm = None print('Clustering algorithm employed: %s' %clusterAlgLabel) som.cluster(algorithm=algorithm) '''----------------------------------------------------''' colors = [] for bm in som.bmus: colors.append(som.clusters[bm[1], bm[0]]) areas = [200]*len(som.bmus) xDimension, yDimension = [], [] for x in som.bmus: xDimension.append(x[0]) yDimension.append(x[1]) if not os.path.exists(figWritePath+'/'+clusterAlgLabel+'Clusters/'+SOMdimensionsString): os.makedirs(figWritePath+'/'+clusterAlgLabel+'Clusters/'+SOMdimensionsString) fig, ax = plt.subplots() colMap = 'Spectral_r' plt.imshow(som.umatrix,cmap = colMap, aspect = 'auto') ax.scatter(xDimension,yDimension,c=colors,s=areas) doneLabs = set(['']) for label, x, y in zip(labels, xDimension, yDimension):
for i in range(0,nB): name += 'B' gap = 0 for dct in con.select(comb_A=comb_A, comb_B=comb_B, sequence=name): gap = dct.gllbsc_gamma_gap vect.append(gap) gaps.append(gap) vect.append(gap) matrix.append(np.array(vect)) matrix.append(np.array(vect)) colors = [] for i in gaps: c = cm.jet(int(float(i)/float(max(gaps))*255)) for j in range(6): colors.append([c[0],c[1],c[2]]) x = np.array(range(1, 7), float) y = x.copy() xpos, ypos = np.meshgrid(x, y) z = np.array(matrix) xpos = xpos.flatten() ypos = ypos.flatten() zpos = np.zeros_like(xpos) dx = 0.5 * np.ones_like(zpos) dy = dx.copy() dz = z.flatten() fig = plt.figure() ax = Axes3D(fig) plt.xlabel('nB, B = '+comb_B) plt.ylabel('nA, A = '+comb_A)