def register_colour_maps(): cdict = {'red': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (1.0, 1.0, 1.0))} plt.register_cmap(name='GreyIntensity', data=cdict) cdict2 = {'red': ((0.0, 0.0, 0.0), (0.5, 1.0, 0.7), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (0.5, 1.0, 0.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 0.0, 0.0), (0.5, 1.0, 0.0), (1.0, 0.5, 1.0))} plt.register_cmap(name='RedSplit', data=cdict2)
def shifted_cmap(cmap,vmin,vmax,start=0.0,stop=1.0,name='new_cmap'): """ This code comes primarily from an answer to a question on stackoverflow url as of 2016-06-30 was http://stackoverflow.com/questions/7404116/defining-the-midpoint-of-a-colormap-in-matplotlib and the answer / code was from Paul H. http://stackoverflow.com/users/1552748/paul-h """ mid = 1.0-vmax/(vmax + np.absolute(vmin)) colors = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } reg_index = np.linspace(start,stop,257) shift_index = np.hstack([ np.linspace(0.0, mid, 128, endpoint=False), np.linspace(mid, 1.0, 129, endpoint=True) ]) for ri, si in zip(reg_index, shift_index): r, g, b, a = cmap(ri) colors['red'].append((si, r, r)) colors['green'].append((si, g, g)) colors['blue'].append((si, b, b)) colors['alpha'].append((si, a, a)) newcmap = matplotlib.colors.LinearSegmentedColormap(name, colors) plt.register_cmap(cmap=newcmap) return newcmap
def _set_colors(): HighRGB = np.array([26, 152, 80]) / 255. MediumRGB = np.array([255, 255, 191]) / 255. LowRGB = np.array([0, 0, 0]) / 255. cdict = _set_cdict(HighRGB, MediumRGB, LowRGB) plt.register_cmap(name='PyMKS', data=cdict) plt.set_cmap('PyMKS')
def make_rainbow(a=0.75, b=0.2, name='custom_rainbow', register=False): """ Use a=0.7, b=0.2 for a darker end. when 0.5<=a<=1.5, should have b >= (a-0.5)/2 or 0 <= b <= (a-1)/3 when 0<=a<=0.5, should have b >= (0.5-a)/2 or 0<= b<= -a/3 to assert the monoique To show the parameter dependencies interactively in notebook ``` %matplotlib inline from ipywidgets import interact def func(a=0.75, b=0.2): cmap = gene_rainbow(a=a, b=b) show_cmap(cmap) interact(func, a=(0, 1, 0.05), b=(0.1, 0.5, 0.05)) ``` """ def gfunc(a, b, c=1): def func(x): return c * np.exp(-0.5 * (x - a)**2 / b**2) return func cdict = {"red": gfunc(a, b), "green": gfunc(0.5, b), "blue": gfunc(1 - a, b) } cmap = mpl.colors.LinearSegmentedColormap(name, cdict) if register: plt.register_cmap(cmap=cmap) plt.rc('image', cmap=cmap.name) return cmap
def custom_cmap(_sample, _reverse=False): midpoint = .5 from scipy.ndimage import imread im = imread(_sample, mode='RGBA') im = im[10:-10,20:-20,:] im = im/im.max() if _reverse: im = np.rot90(im,2) nx,ny,nz = im.shape my_index = np.linspace(0,ny,257, endpoint=False) cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } shift_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129, endpoint=True) ]) for i, si in zip(my_index, shift_index): i = int(i) r,g,b,a = (im[0,i,0], im[0,i,1], im[0,i,2], im[0,i,3]) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) mycmap = matplotlib.colors.LinearSegmentedColormap('custom', cdict) plt.register_cmap(cmap=mycmap) return mycmap
def spec_colormap(): # Makes the colormap that we like for spectrograms cmap = np.zeros((64,3)) cmap[0,2] = 1.0 for ib in range(21): cmap[ib+1,0] = (31.0+ib*(12.0/20.0))/60.0 cmap[ib+1,1] = (ib+1.0)/21.0 cmap[ib+1,2] = 1.0 for ig in range(21): cmap[ig+ib+1,0] = (21.0-(ig)*(12.0/20.0))/60.0 cmap[ig+ib+1,1] = 1.0 cmap[ig+ib+1,2] = 0.5+(ig)*(0.3/20.0) for ir in range(21): cmap[ir+ig+ib+1,0] = (8.0-(ir)*(7.0/20.0))/60.0 cmap[ir+ig+ib+1,1] = 0.5 + (ir)*(0.5/20.0) cmap[ir+ig+ib+1,2] = 1 for ic in range(64): (cmap[ic,0], cmap[ic,1], cmap[ic,2]) = colorsys.hsv_to_rgb(cmap[ic,0], cmap[ic,1], cmap[ic,2]) spec_cmap = pltcolors.ListedColormap(cmap, name=u'SpectroColorMap', N=64) plt.register_cmap(cmap=spec_cmap)
def compare_spectra(): import mywfc3.stgrism as st import unicorn ### Fancy colors import seaborn as sns import matplotlib.pyplot as plt cmap = sns.cubehelix_palette(as_cmap=True, light=0.95, start=0.5, hue=0.4, rot=-0.7, reverse=True) cmap.name = 'sns_rot' plt.register_cmap(cmap=cmap) sns.set_style("ticks", {"ytick.major.size":3, "xtick.major.size":3}) plt.set_cmap('sns_rot') #plt.gray() fig = st.compare_methods(x0=787, y0=712, v=np.array([-1.5,4])*0.6, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.02) #fig.tight_layout() unicorn.plotting.savefig(fig, '/tmp/compare_model_star.pdf', dpi=300) fig = st.compare_methods(x0=485, y0=332, v=np.array([-1.5,4])*0.2, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.1) unicorn.plotting.savefig(fig, '/tmp/compare_model_galaxy.pdf', dpi=300) fig = st.compare_methods(x0=286, y0=408, v=np.array([-1.5,4])*0.08, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.1) unicorn.plotting.savefig(fig, '/tmp/compare_model_galaxy2.pdf', dpi=300) fig = st.compare_methods(x0=922, y0=564, v=np.array([-1.5,4])*0.2, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.15) unicorn.plotting.savefig(fig, '/tmp/compare_model_galaxy3.pdf', dpi=300)
def main(): plt.register_cmap(name='viridis', cmap=cmaps.viridis) fig = plt.figure() ax = fig.gca(projection='3d') X = np.linspace(0.1, 20, num=50) Y = np.linspace(0.1, 20, num=50) Z = np.array([0.]*X.shape[0]*Y.shape[0]) Z.shape = (X.shape[0], Y.shape[0]) for i in range(X.shape[0]): for j in range(Y.shape[0]): he = hyperexp(0.5, X[i], Y[j]) Z[i][j] = he.CoV() X, Y = np.meshgrid(X, Y) plt.xlabel('lambda1') plt.ylabel('lambda2') ax.set_zlabel('CoV') surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cmaps.viridis, linewidth=0, antialiased=False, vmin=0., vmax=6) ax.set_zlim(0, 6) ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) fig.colorbar(surf, shrink=0.5, aspect=5) plt.show() return
def myblues(self): cdict={'red': ((0.0,1.0,1.0),(1.0,0.0,0.0)), 'green': ((0.0,1.0,1.0),(1.0,0.0,0.0)), 'blue': ((0.0,1.0,1.0),(1.0,1.0,1.0))} myblues=LinearSegmentedColormap('MyBlues',cdict) plot.register_cmap(cmap=myblues) self.cmap='MyBlues'
def remappedColorMap(cmap, data=False, start=0, midpoint=0.5, stop=1.0, name='shiftedcmap'): ''' Function to offset the median value of a colormap, and scale the remaining color range. Useful for data with a negative minimum and positive maximum where you want the middle of the colormap's dynamic range to be at zero. Input ----- cmap : The matplotlib colormap to be altered data: You can provide your data as a numpy array, and the following operations will be computed automatically for you. start : Offset from lowest point in the colormap's range. Defaults to 0.0 (no lower ofset). Should be between 0.0 and 0.5; if your dataset vmax <= abs(vmin) you should leave this at 0.0, otherwise to (vmax-abs(vmin))/(2*vmax) midpoint : The new center of the colormap. Defaults to 0.5 (no shift). Should be between 0.0 and 1.0; usually the optimal value is abs(vmin)/(vmax+abs(vmin)) stop : Offset from highets point in the colormap's range. Defaults to 1.0 (no upper ofset). Should be between 0.5 and 1.0; if your dataset vmax >= abs(vmin) you should leave this at 1.0, otherwise to (abs(vmin)-vmax)/(2*abs(vmin)) ''' if isinstance(data, np.ndarray): start, midpoint, stop = auto_remap(data) cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } # regular index to compute the colors reg_index = np.hstack([ np.linspace(start, 0.5, 128, endpoint=False), np.linspace(0.5, stop, 129) ]) # shifted index to match the data shift_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129) ]) for ri, si in zip(reg_index, shift_index): r, g, b, a = cmap(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) newcmap = matplotlib.colors.LinearSegmentedColormap(name, cdict) plt.register_cmap(cmap=newcmap) return newcmap
def make_subplot(options, ax, dplot, slicearg, data, pars, xvar, yvar, xidx, yidx, a, b): sc = a / (a+b) / 0.5 sc2 = b / (a+b) / 0.5 anm = { 'red': [ (0., 0.0, 0.0), (sc*0.5, 1.0, 1.0), (sc*0.5 + (0.817460-0.5)*sc2, 1.0, 1.0), (1.0, 0.8, 0.8)], 'green': [ (0., 0.0, 0.0), (sc*0.4, 1.0, 1.0), (sc*0.5, 1.0, 1.0), (sc*0.5 + (0.626984-0.5)*sc2, 1.0, 1.0), (sc*0.5 + (0.817460-0.5)*sc2, 0.6, 0.6), (1.0, 0.0, 0.0)], 'blue': [ (0.0, 0.4, 0.4), (sc*0.25, 1.0, 1.0), (sc*0.5, 1.0, 1.0), (sc*0.5 + (0.626984-0.5)*sc2, 0., 0.), (1.0, 0.0, 0.0)] } if sc == 0.0: for k in anm.iterkeys(): anm[k] = anm[k][1:] # Fix color scale if only positive values are present. elif a < 0.001: for k in anm.iterkeys(): anm[k][0] = (0., 1.0, 1.0) if b < 0.001: anm['red'] = anm['red'][0:1] + [(1, 1, 1)] anm['green'] = anm['green'][0:2] + [(1, 1, 1)] anm['blue'] = anm['blue'][0:2] + [(1, 1 ,1)] anm_cmap = LinearSegmentedColormap('ANM', anm) plt.register_cmap(cmap=anm_cmap) aspect = ((data[pars[xidx]][-1] - data[pars[xidx]][0]) / (data[pars[yidx]][-1] - data[pars[yidx]][0])) / options.panel_aspect im = ax.imshow(dplot[slicearg], extent=(data[pars[xidx]][0], data[pars[xidx]][-1], data[pars[yidx]][0], data[pars[yidx]][-1]), aspect=aspect, interpolation='bilinear', # interpolation='nearest', vmin = -a, vmax = b, cmap = anm_cmap, origin='lower') return im
def lin_cmap_gen(incolgs, regname, fractions = None): ''' Generates a color map with the given color list (incolgs). Accepts a list of color words (defined by the color.gs script: http://kodama.fubuki.info/wiki/wiki.cgi/GrADS/script/color.gs?lang=en) or a list of (r,g,b) values. The r,g,b values can be either 0<=x<=1 or 0<=x<=255 input: incolgs: Input color map request regname: Name for matplotlib to register color map. fractions: Fraction for each color to take up- these values must add to 1. If not, a ValueException is raised. (NOT YET IMPLEMENTED) returns: a LinearSegmentedColormap containing your colors. ''' collists = incolgs reds = list() greens = list() blues = list() reds_prep = list() greens_prep = list() blues_prep = list() if fractions != None: raise NotImplementedError("Fractional colors are not yet implemented.") for i, color in enumerate(collists): try: if (color[0] >= 0 and color[0] <= 255 and color[1] >= 0 and color[1] <= 255 and color[2] >= 0 and color[2] <= 255): rgb = convert_color(color) else: raise ValueError("Colors need to be between 0 and 255") except TypeError: rgb = get_rgb(color) reds.append(rgb[0]) greens.append(rgb[1]) blues.append(rgb[2]) for i in range(len(reds)): rp = ((float(i)/(len(reds)-1))) drp = ((1.0/(len(reds)-1))) if rp+drp >=1: drp = 0 reds_prep.append((rp, reds[i],reds[i])) blues_prep.append((rp, blues[i], blues[i])) greens_prep.append((rp, greens[i], greens[i])) cdict = {'red': tuple(reds_prep), 'blue': tuple(blues_prep), 'green': tuple(greens_prep)} #print(cdict) ucmap = LinearSegmentedColormap(regname, cdict) plt.register_cmap(cmap=ucmap) return ucmap
def shift_colormap(cmap, start=0, midpoint=0.5, stop=1.0, name='shiftedcmap'): ''' Function to offset the "center" of a colormap. Useful for data with a negative min and positive max and you want the middle of the colormap's dynamic range to be at zero Parameters ---------- cmap : The matplotlib colormap to be altered start : Offset from lowest point in the colormap's range. Defaults to 0.0 (no lower ofset). Should be between 0.0 and `midpoint`. midpoint : The new center of the colormap. Defaults to 0.5 (no shift). Should be between 0.0 and 1.0. In general, this should be 1 - vmax/(vmax + abs(vmin)) For example if your data range from -15.0 to +5.0 and you want the center of the colormap at 0.0, `midpoint` should be set to 1 - 5/(5 + 15)) or 0.75 stop : Offset from highets point in the colormap's range. Defaults to 1.0 (no upper ofset). Should be between `midpoint` and 1.0. Returns ------- new_cmap : A new colormap that has been shifted. ''' import matplotlib as mpl import matplotlib.pyplot as plt cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } # regular index to compute the colors reg_index = np.linspace(start, stop, 257) # shifted index to match the data shift_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129, endpoint=True) ]) for ri, si in zip(reg_index, shift_index): r, g, b, a = cmap(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) new_cmap = mpl.colors.LinearSegmentedColormap(name, cdict) plt.register_cmap(cmap=new_cmap) return new_cmap
def shift_cmap(cmap, start=0, midpoint=0.5, stop=1, name='shiftedcmap'): '''Offset the median value of a colormap. And scale the remaining color range. Useful for data with a negative minimum and positive maximum where you want the middle of the colormap's dynamic range to be at zero. Input ----- cmap : The matplotlib colormap to be altered start : Offset from lowest point in the colormap's range. Defaults to 0.0 (no lower ofset). Should be between 0.0 and 0.5; if your dataset mean is negative you should leave this at 0.0, otherwise to (vmax-abs(vmin))/(2*vmax) midpoint : The new center of the colormap. Defaults to 0.5 (no shift). Should be between 0.0 and 1.0; usually the optimal value is abs(vmin)/(vmax+abs(vmin)) stop : Offset from highets point in the colormap's range. Defaults to 1.0 (no upper ofset). Should be between 0.5 and 1.0; if your dataset mean is positive you should leave this at 1.0, otherwise to (abs(vmin)-vmax)/(2*abs(vmin)) Credits ------- Paul H (initial version) Horea Christian (additions/modifications) Fernando Paolo (additions/modifications) TODO ---- Set 'start' and 'stop' dynamically when negative/positive bounds. ''' # if array given, find optimal value to center new cmap if np.ndim(midpoint) != 0: midpoint = np.asarray(midpoint)[~np.isnan(midpoint)] midpoint = abs(midpoint.min()) / float(abs(midpoint.max()) + \ abs(midpoint.min())) # regular index to compute the colors reg_index = np.hstack([ np.linspace(start, 0.5, 128, endpoint=False), np.linspace(0.5, stop, 129, endpoint=True) ]) # shifted index to match the midpoint of the data new_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129, endpoint=True) ]) cdict = {'red': [], 'green': [], 'blue': [], 'alpha': []} for ri, si in zip(reg_index, new_index): r, g, b, a = cmap(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) newcmap = mpl.colors.LinearSegmentedColormap(name, cdict, 256) plt.register_cmap(cmap=newcmap) return newcmap
def _set_colors(): """ Helper function used to set the color map. """ HighRGB = np.array([26, 152, 80]) / 255. MediumRGB = np.array([255, 255, 191]) / 255. LowRGB = np.array([0, 0, 0]) / 255. cdict = _set_cdict(HighRGB, MediumRGB, LowRGB) plt.register_cmap(name='PyMKS', data=cdict) plt.set_cmap('PyMKS')
def wrappedColorMap(cmap, start=0, midpoint=0.5, stop=1.0, name='shiftedcmap'): ''' The idea here is that after your midpoint, you start going back down to zero. Useful for angles. Input ----- cmap : The matplotlib colormap to be altered start : Offset from lowest point in the colormap's range. Defaults to 0.0 (no lower ofset). Should be between 0.0 and `midpoint`. midpoint : The new center of the colormap. Defaults to 0.5 (no shift). Should be between 0.0 and 1.0. In general, this should be 1 - vmax/(vmax + abs(vmin)) For example if your data range from -15.0 to +5.0 and you want the center of the colormap at 0.0, `midpoint` should be set to 1 - 5/(5 + 15)) or 0.75 stop : Offset from highets point in the colormap's range. Defaults to 1.0 (no upper ofset). Should be between `midpoint` and 1.0. ''' cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } # regular index to compute the colors reg_index = np.linspace(start, stop, 257) reg_index = np.hstack([ np.linspace(start, stop, 128, endpoint=False), np.linspace(stop, start, 129, endpoint=True) ]) # shifted index to match the data shift_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129, endpoint=True) ]) for ri, si in zip(reg_index, shift_index): r, g, b, a = cmap(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) newcmap = LinearSegmentedColormap(name, cdict) plt.register_cmap(cmap=newcmap) return newcmap
def showbluered(data): plt.register_cmap(name='BlueRed3', data=cdict3) plt.clf() fig = plt.figure() ax = plt.subplot(111) mx = np.abs(np.max(data)) mn = np.abs(np.min(data)) vmax = np.max((mx, mn)) ax.imshow(data, interpolation='nearest', vmax=vmax, vmin=-vmax) ax.set_cmap('BlueRed3') plt.show()
def do_polar_bar_plot(self, plot_type, dpi=150, cmap='jet', file_format='png'): ''' A doodle to look at different ways of presenting data. ''' try: muf_data, im_data, global_params = self.r533.get_p2p_plot_data(plot_type) except LookupError: return #points, plot_type, lons, lats, num_pts_lon, num_pts_lat, global_params, params = dataset #plot_dt, ssn, freq = params # EDIT THE LINE BELOW TO MODIFY COLOURS IN THE COLORMAP plt.clf() #Clear any existing plot data, specifically nightshade plt.register_cmap(name='PlotlyAlt', cmap=PlotlyAlt) fig = plt.figure() ax = fig.add_subplot(111, projection='polar') palette=plt.get_cmap(cmap) rad_hour = (2 * np.pi) / 24.0 start_theta = (np.pi / 2.0) + rad_hour/2.0 theta = np.arange(start_theta, (-2.0*np.pi) + (np.pi/2.0) + (rad_hour/2.0), -rad_hour) radii = [0.5, 0.8, .6, .3, .2, .4, .8, 1.0 ,0.5, 0.8, .6, .3, .2, .4, .8, 1.0 ,0.5, 0.8, .6, .3, .2, .4, .8, 1.0] radii = [] indexes = [] for hour in range(0,24): idx = np.argmax(im_data[hour,:]) radii.append(im_data[hour,idx]) indexes.append(idx) bars = ax.bar(theta, radii, width=-rad_hour, bottom=0.0) for r, bar, idx in zip(radii, bars, indexes): c = palette(int((256/28)*idx)) bar.set_facecolor(c) bar.set_edgecolor(c) bar.set_alpha(0.75) main_title = "{:s}".format(global_params.title) tx_ant_str = "{:s} ({:.1f}dB)".format(global_params.tx_ant_type, global_params.tx_ant_gain) #pythonProp subtitle #sub_title = "{:s} - {:s} - SSN:{:.1f} - {:.3f}MHz - {:s} - {:.0f}W".format(plot_params['title'], plot_dt.strftime(ds_fmt_str), ssn, float(freq), tx_ant_str, global_params.tx_pwr) #RSGB subtitle sub_title = "{:s} {:s} {:.0f}W".format(self.plot_params['title'], tx_ant_str, global_params.tx_pwr) #plt.figtext(0.5, 0.8, main_title, fontsize=18, ha='center') #plt.figtext(0.5, 0.76,sub_title,fontsize=10, fontstyle='normal', ha='center') #todo if we're using voacap files we can include the year in the filename #plot_fn = "p2p_{:s}_{:s}_{:s}.{:s}".format(plot_type, "d".join(str(freq).split('.')), file_format) plot_fn = 'test.svg' print ("Saving file ", plot_fn) plt.savefig(plot_fn, dpi=float(dpi), bbox_inches='tight')
def remappedColorMap(self, cmap, start=0, midpoint=0.5, stop=1.0, name='shiftedcmap'): ''' Function to offset the median value of a colormap, and scale the remaining color range. Useful for data with a negative minimum and positive maximum where you want the middle of the colormap's dynamic range to be at zero. Input ----- cmap : The matplotlib colormap to be altered start : Offset from lowest point in the colormap's range. Defaults to 0.0 (no lower ofset). Should be between 0.0 and 0.5; if your dataset mean is negative you should leave this at 0.0, otherwise to (vmax-abs(vmin))/(2*vmax) midpoint : The new center of the colormap. Defaults to 0.5 (no shift). Should be between 0.0 and 1.0; usually the optimal value is abs(vmin)/(vmax+abs(vmin)) stop : Offset from highets point in the colormap's range. Defaults to 1.0 (no upper ofset). Should be between 0.5 and 1.0; if your dataset mean is positive you should leave this at 1.0, otherwise to (abs(vmin)-vmax)/(2*abs(vmin)) http://stackoverflow.com/questions/7404116/defining-the-midpoint-of-a-colormap-in-matplotlib ''' cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } # regular index to compute the colors reg_index = np.hstack([ np.linspace(start, 0.5, 128, endpoint=False), np.linspace(0.5, stop, 129) ]) # shifted index to match the data shift_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129) ]) for ri, si in zip(reg_index, shift_index): r, g, b, a = cmap(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) newcmap = mpl.colors.LinearSegmentedColormap(name, cdict) plt.register_cmap(cmap=newcmap) return newcmap
def load_cmap(name='geosoft'): """ Create and register a color map. The name must be selected from the colormaps available in the local colors module. """ try: cmList = colors.datad[name] new_cm = mcolors.LinearSegmentedColormap.from_list(name, cmList) plt.register_cmap(cmap=new_cm) return new_cm except: raise ValueError('Colormap {} has not been recognised'.format(name))
def apply_cmap(self, cmap=None): """ Make matplotlib use specified colourmap. By default will use **self.cmap** """ if cmap is None: cmap = self.cmap else: plt.set_cmap(cmap) return plt.register_cmap(name=cmap.name, cmap=cmap) plt.set_cmap(cmap)
def draw_countour(xgrid, ygrid, target_function): output = np.zeros((xgrid.shape[0], ygrid.shape[0])) for i, x in enumerate(xgrid): for j, y in enumerate(ygrid): output[j, i] = target_function(x, y) X, Y = np.meshgrid(xgrid, ygrid) plt.register_cmap(name='BlueRed', data=blue_red_cmap) plt.contourf(X, Y, output, 50, alpha=.75, cmap='BlueRed') plt.colorbar()
def drawgraph(graphobj, filename): mycolormap = makecolormap() plt.register_cmap(name='BlueRed', data=mycolormap) plt.rcParams['image.cmap'] = 'BlueRed' # I've kept these in for the syntax: they're different ways to auto-arrange the nodes. # position = nx.graphviz_layout(graphobj.graph,prog='neato') # position = nx.spectral_layout(graphobj.graph) position = nx.spring_layout(graphobj.graph, weight='weight') #I like this best. It positions nodes closer based on the strength of their connections. nx.draw_networkx(graphobj.graph, pos=position, nodelist=graphobj.nodes_ordered, node_color=graphobj.nodeweights, cmap='BlueRed') #forget about edge colorings for now, they don't look very good. may worry about those later. plt.savefig(filename) plt.close()
def smooth_colormap(colors, name='cmap1'): to_rgb = clr.ColorConverter().to_rgb colors = [(p, to_rgb(c)) for p, c in colors] result = {'red': [], 'green': [], 'blue': []} for index, item in enumerate(colors): pos, color = item if pos is not None: r, g, b = color result['red'].append([pos, r, r]) result['green'].append([pos, g, g]) result['blue'].append([pos, b, b]) cmap = clr.LinearSegmentedColormap(name, result) plt.register_cmap(name=name, cmap=cmap) return cmap
def default_cmap(): invert_if_black_bg = lambda v: (1 - v) if black_bg else v base_brightness_local = invert_if_black_bg(base_brightness) end_brightness = invert_if_black_bg(0) avg = np.average([base_brightness_local, end_brightness]) c_range = ((0, base_brightness_local, base_brightness_local), (.33, base_brightness_local, avg), (.67, avg, end_brightness), (1, end_brightness, end_brightness)) c_dict = {r: c_range for r in ['red', 'green', 'blue']} cmap_name = 'bright_bw' cmap = LinearSegmentedColormap(cmap_name, c_dict) plt.register_cmap(cmap=cmap) return cmap
def make_cubehelix(*args, **kwargs): """make_cubehelix(start=0.5, rotation=-1.5, gamma=1.0, start_hue=None, end_hue=None, sat=None, min_sat=1.2, max_sat=1.2, min_light=0., max_light=1., n=256., reverse=False, name='custom_cubehelix') """ from palettable.cubehelix import Cubehelix cmap = Cubehelix.make(*args, **kwargs).mpl_colormap register = kwargs.setdefault("register", False) if register: plt.register_cmap(cmap=cmap) plt.rc('image', cmap=cmap.name) return cmap
def angleColorMap(cmap=plt.cm.RdBu_r, cmap2=plt.cm.RdGy, name='angled', start_1=0, midpoint_1=0.5, stop_1=1, start_2=0, midpoint_2=0.5, stop_2=1): ''' The idea here is that after your midpoint, you start going back down to zero. Now we try to make this work so that you have four colors total (so that +- 90 have different colors) Input ----- cmap : The matplotlib colormap to be altered ''' cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } # regular index to compute the colors reg_index_1 = np.hstack([ np.linspace(start_1, midpoint_1, 64, endpoint=False), np.linspace(midpoint_1, stop_1, 64, endpoint=True) ]) reg_index_2 = np.hstack([ np.linspace(start_2, midpoint_2, 64, endpoint=False), np.linspace(midpoint_2, stop_2, 65, endpoint=True) ]) reg_index = np.hstack([reg_index_1, reg_index_2]) # shifted index to match the data shift_index = np.linspace(0, 1, 257) for ri, si in zip(reg_index, shift_index): if si < 0.5: r, g, b, a = cmap(ri) else: r, g, b, a = cmap2(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) newcmap = LinearSegmentedColormap(name, cdict) plt.register_cmap(cmap=newcmap) return newcmap
def drawPMF(pmf, config): fig = plt.figure(1, figsize=(2, 2)) cdict3 = {'red': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'blue': ((0.0, 0.0, 0.0), (1.0, 0.0, 1.0)), 'alpha': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)) } plt.register_cmap(name='test', data=cdict3) min1, bin1, max1, min2, bin2, max2 = getInfoPMF(pmf) PMF = getPMF(pmf, min1, bin1, max1, min2, bin2, max2) for i in config['selections']: cx, cy, r = [float(i) for i in config['selections'][i].split(",")] cx, cy, r = int((cx - min1 - bin1/2.)/bin1), int((cy - min2 - bin2/2.)/bin2), (r - min1 - bin1/2.)/bin1 ny,nx = PMF.shape x, y = np.ogrid[-cy:ny-cy, -cx:nx-cx] mask = x*x + y*y < r*r PMF_mask = PMF*mask plt.imshow(PMF_mask, cmap="test", origin='lower', interpolation="none", extent=[min2, max2, min1, max1], vmin=0.0, vmax=0.1) plt.text(cx*bin1, cy*bin2, i.upper()) # correction X, Y = np.meshgrid(PMF.columns, PMF.index) P = np.exp(-PMF/(T*kB)) corr = 1/(np.sin(X*np.pi/180)*np.sin(Y*np.pi/180)) P_corr = P*corr PMF_corr = -1*kB*T*np.log(P_corr) plt.imshow(PMF_corr, cmap="jet", origin='lower', interpolation="none", extent=[min2, max2, min1, max1], vmin=0.0, vmax=20, alpha=0.7) plt.axes().xaxis.set_major_locator(MultipleLocator(60)) plt.axes().xaxis.set_minor_locator(MultipleLocator(20)) plt.axes().yaxis.set_major_locator(MultipleLocator(60)) plt.axes().yaxis.set_minor_locator(MultipleLocator(20)) plt.tight_layout() plt.savefig("basins.svg") plt.show()
def plot_transparent_hexbin(ax, func, xlims, ylims, gridsize, color): cdict = {'red': ((0., color[0], color[0]), (1., color[0], color[0])), 'green': ((0., color[1], color[1]), (1., color[1], color[1])), 'blue': ((0., color[2], color[2]), (1., color[2], color[2])), 'alpha': ((0., 0., 0.), (1., 1., 1.))} new_cmap = LinearSegmentedColormap('Custom', cdict) plt.register_cmap(cmap=new_cmap) coords = get_hexbin_coords(ax, xlims, ylims, gridsize) c = func(coords) x, y = coords.T ax.hexbin(x.ravel(), y.ravel(), c.ravel(), cmap=new_cmap, linewidths=0., edgecolors='none', gridsize=gridsize, vmin=0., vmax=1., zorder=1)
def TS_cmap(direc): plt.register_cmap(name='inferno', cmap=colormaps.inferno) plt.register_cmap(name='inferno_r', cmap=colormaps.inferno) plt.register_cmap(name='viridis', cmap=colormaps.viridis_r) plt.register_cmap(name='viridis_r', cmap=colormaps.viridis_r) cmap = 'inferno' if direc == -1: cmap = 'inferno_r' return cmap
pan = fig.add_subplot(111) pan.errorbar(mF, frac, yerr=yerr, fmt='bo') pan.plot(mFforplot, gaussian(mFforplot, sigma, x0)) return x0, dx0 cdictAll = { 'red': ((0.0, 1.0, 1.0), (0.25, 1.0, 1.0), (0.5, 0.0, 0.0), (0.75, 0.0, 0.0), (1.0, 0.0, 0.0)), 'green': ((0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.5, 1.0, 1.0), (0.75, 0.0, 0.0), (1.0, 1.0, 1.0)), 'blue': ((0.0, 1.0, 1.0), (0.25, 0.0, 0.0), (0.5, 0.0, 0.0), (0.75, 1.0, 1.0), (1.0, 1.0, 1.0)) } allColors = mpl.colors.LinearSegmentedColormap('allColors', cdictAll) plt.register_cmap(cmap=allColors) S = 2 s = 2 * S + 1 theoryFile = np.load('SynDimBandStructure_F2_n7_Chern1.npz') kList = theoryFile['kList'] E = theoryFile['E'] m = theoryFile['m'] pops = theoryFile['pops'] #[:,0,:] modeTheory = np.zeros((kList.size, s)) sigmaModeTheory = np.zeros((kList.size, s)) fitGoodTheoryList = np.ones((kList.size, s), dtype=bool) sigmaArrayTheory = np.ones(pops.shape) * 0.0001 for bandInd in np.arange(s): for Kind in range(kList.size):
import numpy as np import matplotlib #matplotlib.use('Agg') from matplotlib import rcParams as rc from matplotlib import pyplot as plot from pylab import rcParams from pylab import fromfile import util import azimuthal as az from colormaps import cmaps for key in cmaps: plot.register_cmap(name=key, cmap=cmaps[key]) ### Sizes ### sizes = np.array([1.0, 0.3, 0.1, 0.03]) size_labels = ["cm", "hcm", "mm", "hmm"] ############################################################################### ### Input Parameters ### def new_argument_parser(description="Plot azimuthal density profiles."): parser = argparse.ArgumentParser() # Frame Selection parser.add_argument(
def main(inference_type: str = "K", batch_size: int = 1, test_path: str = None, weights: str = None, merge: bool = False, stage: str = "test", limit: int = 20, confidence: float = 0.1, visualize: bool = True): keras_model = MobileDetectNetModel.complete_model() if weights is not None: keras_model.load_weights(weights, by_name=True) images_done = 0 if test_path is not None: import cv2 if stage != 'test': from generator import MobileDetectNetSequence seq = MobileDetectNetSequence.create_augmenter(stage) else: seq = None images_full = [] images_input = [] images_scale = [] for r, d, f in os.walk(test_path): for file in f: image_full = cv2.imread(os.path.join(r, file)) image_input = cv2.resize(image_full, (224, 224)) scale_width = image_full.shape[1] / 224 scale_height = image_full.shape[0] / 224 images_scale.append((scale_width, scale_height)) if stage != 'test': seq_det = seq.to_deterministic() image_aug = (seq_det.augment_image(image_input).astype(np.float32) / 127.5) - 1. else: image_aug = image_input.astype(np.float32) / 127.5 - 1. images_full.append(image_full) images_input.append(image_aug) images_done += 1 if images_done == limit: break if images_done == limit: break x_test = np.array(images_input) else: x_test = np.random.random((limit, 224, 224, 3)) x_cold = np.random.random((batch_size, 224, 224, 3)) if inference_type == 'K': keras_model.predict(x_cold) t0 = time.time() model_outputs = keras_model.predict(x_test) t1 = time.time() elif inference_type == 'TF': tf_engine = keras_model.tf_engine() tf_engine.infer(x_cold) t0 = time.time() model_outputs = tf_engine.infer(x_test) t1 = time.time() elif inference_type == 'FP32': tftrt_engine = keras_model.tftrt_engine(precision='FP32', batch_size=batch_size) tftrt_engine.infer(x_cold) t0 = time.time() model_outputs = tftrt_engine.infer(x_test) t1 = time.time() elif inference_type == 'FP16': tftrt_engine = keras_model.tftrt_engine(precision='FP16', batch_size=batch_size) tftrt_engine.infer(x_cold) t0 = time.time() model_outputs = tftrt_engine.infer(x_test) t1 = time.time() elif inference_type == 'INT8': tftrt_engine = keras_model.tftrt_engine(precision='INT8', batch_size=batch_size) tftrt_engine.infer(x_cold) t0 = time.time() model_outputs = tftrt_engine.infer(x_test) t1 = time.time() else: raise ValueError("Invalid inference type") print('Time: ', t1 - t0) print('FPS: ', x_test.shape[0]/(t1 - t0)) if not visualize: return if len(model_outputs) == 2: classes, bboxes = model_outputs # TF / TensorRT models won't output regions (not useful for production) elif len(model_outputs) == 3: regions, bboxes, classes = model_outputs else: raise ValueError("Invalid model length output") if test_path is not None: import matplotlib.pyplot as plt from matplotlib.colors import LinearSegmentedColormap # get colormap ncolors = 256 color_array = plt.get_cmap('viridis')(range(ncolors)) # change alpha values color_array[:, -1] = np.linspace(0.0, 1.0, ncolors) # create a colormap object map_object = LinearSegmentedColormap.from_list(name='viridis_alpha', colors=color_array) # register this new colormap with matplotlib plt.register_cmap(cmap=map_object) for idx in range(0, len(images_full)): rectangles = [] for y in range(0, 7): for x in range(0, 7): if classes[idx, y, x, 0] >= confidence: rect = [ int(bboxes[idx, int(y), int(x), 0] * 224), int(bboxes[idx, int(y), int(x), 1] * 224), int(bboxes[idx, int(y), int(x), 2] * 224), int(bboxes[idx, int(y), int(x), 3] * 224)] rectangles.append(rect) if merge: rectangles, merges = cv2.groupRectangles(rectangles, 1, eps=0.75) scale_width, scale_height = images_scale[idx] for rect in rectangles: cv2.rectangle(images_full[idx], (int(rect[0]*scale_width), int(rect[1]*scale_height)), (int(rect[2]*scale_width), int(rect[3]*scale_height)), (0, 255, 0), 5) plt.imshow(cv2.cvtColor(images_full[idx], cv2.COLOR_BGR2RGB), alpha=1.0, aspect='auto') plt.imshow( cv2.resize(classes[idx].reshape((7, 7)), (images_full[idx].shape[1], images_full[idx].shape[0])), interpolation='nearest', alpha=0.5, cmap='viridis_alpha', aspect='auto') plt.show()
#!/opt/local/bin/python # --------------------------------------------------------------------------- # # My handrolled modules. import nemo # Import required modules. import cmocean import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.basemap import Basemap # Register the balance colormap. plt.register_cmap(name='speed', cmap=cmocean.cm.speed) # --------------------------------------------------------------------------- # # Specify where the input data lives. homedir = '/Users/munday/Documents/Projects/ORCHESTRA/NEMO/' nemodir = 'trunk/NEMOGCM/CONFIG/DRM-ORCH0083-LIM3/EXP00/' # Specify the names of the different files that I want to load from. filename = 'TIDY/ARCHIVE/1948/U/ORCH0083-LIM3_19481227_U_d05.nc' gridfile = 'TIDY/ARCHIVE/MESH/mesh_mask.nc' # --------------------------------------------------------------------------- # # Load the coordinates. glamu = np.squeeze(nemo.load_field('glamu', homedir, nemodir, gridfile, 'U')) gphiu = np.squeeze(nemo.load_field('gphiu', homedir, nemodir, gridfile, 'U'))
# pickle.dump(dvals, f) # pickle.dump(pwr, f) # f.close() # # # # # # # # # # # # # # # # # # # plot decision boundaries fig = plt.figure(figsize=(9, 5.5)) ax = plt.subplot(1, 1, 1) x1_mesh, x2_mesh, class_mesh = predict_bound_class(model_clf.model, train_df, model_clf.n_outputs, opt_thr=opt_thr) # custom colormap for contour vmin, vmax = 0, 2 rel_cmap = relegator_cmap() plt.register_cmap(cmap=rel_cmap) cont = ax.contourf(x1_mesh, x2_mesh, class_mesh, alpha=0.45, cmap='RelegatorCMap', vmin=vmin, vmax=vmax, levels=[-0.5, 0.5, 1.5, 2.5]) # cbar = fig.colorbar(cont) if 'regress' in model_type: plot_xs(X_train, y_train, ax) else: plot_xs(X_train, y_train[:, 1], ax) # plt.title('noise = ' + str(noise) + ', angle = ' + str(angle) + ', epochs = ' + str(n_epochs))
import itertools import numpy as np import tkinter as tk import matplotlib.pyplot as plt import matplotlib.cm as cm import matplotlib.colors as cs cdict = {'red': ((0.0, 0.173, 0.173), (1.0, 0.925, 0.925)), 'green': ((0.0, 0.067, 0.067), (1.0, 0.384, 0.384)), 'blue': ((0.0, 0.027, 0.027), (1.0, 0.196, 0.196))} plt.register_cmap(name='RustPlanet', data=cdict) REWARD_COLORS = cm.get_cmap('RustPlanet') MAP_COLORS = {b'B':"#3a0e00", b'F':"#933111", b'S':"#933111", b'U':"#d65b33",} class NegotiableMarsExplorer(NegotiableGame): def __init__(self, mdps, true_mdp=None, ws=None, gamma=0.95, matrix_form=True, render_scale=1): self.scale = render_scale self.tt_rewards = np.zeros(self.I) super(NegotiableMarsExplorer, self).__init__(mdps,true_mdp, ws, gamma, matrix_form)
def plot_image(img_obj, roi_list=None, slice_id="all", roi_mask=None, file_path=None, file_name="plot", g_range=None): """ :param img_obj: :param roi_list: :param slice_id: :param roi_mask: :param file_path: :param file_name :param g_range :return: """ # Skip if the input image is not available if img_obj.is_missing: return # Determine grey level range if g_range is None: g_range = [np.nan, np.nan] else: g_range = deepcopy(g_range) # Adapt unset intensity ranges if img_obj.modality == "PT": # PET specific settings if np.isnan(g_range[0]): g_range[0] = 0.0 if np.isnan(g_range[1]): g_range[1] = np.max(img_obj.get_voxel_grid()) elif img_obj.modality == "CT": # CT specific settings if np.isnan(g_range[0]): g_range[0] = -1024.0 if np.isnan(g_range[1]): g_range[1] = np.max(img_obj.get_voxel_grid()) elif img_obj.modality == "MR": # MR specific settings if np.isnan(g_range[0]): g_range[0] = np.min(img_obj.get_voxel_grid()) if np.isnan(g_range[1]): g_range[1] = np.max(img_obj.get_voxel_grid()) # Create custom colour map for rois ################################### # Import custom color map function from matplotlib.colors import LinearSegmentedColormap # Define color map. The custom color map goes from transparent black to semi-transparent green and is used as an overlay. cdict = { 'red': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 0.6, 0.6)), 'blue': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'alpha': ((0.0, 0.0, 0.0), (1.0, 0.4, 0.4)) } # Create map and register custom_roi_cmap = LinearSegmentedColormap("colour_roi", cdict) plt.register_cmap(cmap=custom_roi_cmap) # Define colour map for base images ################################ # Determine modality and set colour map used. if img_obj.modality == "PT": img_colour_map = "gist_yarg" elif img_obj.modality == "CT": img_colour_map = "gist_gray" else: img_colour_map = "gist_gray" # Check type of slice_id variable if isinstance(slice_id, str): if slice_id == "all": roi_flag = None slice_id = np.arange(start=0, stop=img_obj.size[0]) elif slice_id == "all_roi": roi_flag = "all" slice_id = None elif slice_id == "roi_center": roi_flag = "center" slice_id = None elif slice_id == "img_center": roi_flag = None slice_id = int(np.floor(img_obj.size[0] / 2)) else: raise ValueError( "%s is not a valid entry for identifying one or more slices for plotting.", slice_id) else: roi_flag = None # Plot without roi ################################################ # If no rois are present, iterate over slices only if roi_list is None: # Cast slice_id to list, if it isn't a list. This allows iteration. if not type(slice_id) is list: slice_id = [slice_id] # Iterate over slices for curr_slice in slice_id: # Set file name if file_path is not None: plot_file_name = os.path.join( file_path, check_string(file_name + "_" + img_obj.get_export_descriptor() + "_" + str(curr_slice) + ".png")) else: plot_file_name = None # Get image and roi slices img_slice = img_obj.get_voxel_grid()[curr_slice, :, :] # Determine minimum and maximum luminance: img_g_range = crop_image_intensity(img_slice=img_slice, g_range=g_range, modality=img_obj.modality) # Plot plotter(slice_list=[img_slice], colour_map_list=[img_colour_map], file_name=plot_file_name, intensity_range=img_g_range, enhance=img_obj.spacing[2]) # Plot with roi ################################################## else: # Iterate over rois in roi_list for curr_roi in roi_list: # Find roi center slice if slice_id is None: if roi_flag == "center": slice_id = curr_roi.get_center_slice() elif roi_flag == "all": slice_id = curr_roi.get_all_slices() # Cast slice_id to list, if it isn't a list. This allows iteration. if not (isinstance(slice_id, list) or isinstance(slice_id, np.ndarray)): slice_id = [slice_id] # Iterate over slices for curr_slice in slice_id: # Set file name if file_path is not None: plot_file_name = os.path.join( file_path, check_string(file_name + "_" + img_obj.get_export_descriptor() + curr_roi.get_export_descriptor() + "_" + str(curr_slice) + ".png")) else: plot_file_name = None # Get image and roi slices img_slice = img_obj.get_voxel_grid()[curr_slice, :, :] if roi_mask == "intensity" and curr_roi.roi_intensity is not None: roi_slice = curr_roi.roi_intensity.get_voxel_grid()[ curr_slice, :, :] elif roi_mask == "morphology" and curr_roi.roi_morphology is not None: roi_slice = curr_roi.roi_morphology.get_voxel_grid()[ curr_slice, :, :] else: roi_slice = curr_roi.roi.get_voxel_grid()[curr_slice, :, :] # Determine minimum and maximum luminance: img_g_range = crop_image_intensity(img_slice=img_slice, g_range=g_range, modality=img_obj.modality) # Create figure plotter(slice_list=[img_slice, roi_slice], colour_map_list=[img_colour_map, "colour_roi"], file_name=plot_file_name, intensity_range=img_g_range, enhance=img_obj.spacing[2])
for istep in range(nsteps): r = rgbdata[istep, 0] g = rgbdata[istep, 1] b = rgbdata[istep, 2] rdata.append((stepaxis[istep], r, r)) gdata.append((stepaxis[istep], g, g)) bdata.append((stepaxis[istep], b, b)) mpl_data = {"red": rdata, "green": gdata, "blue": bdata} return mpl_data mpl_data = RGBToPyCmap(turbo_colormap_data) plt.register_cmap(name="turbo", data=mpl_data, lut=turbo_colormap_data.shape[0]) mpl_data_r = RGBToPyCmap(turbo_colormap_data[::-1, :]) plt.register_cmap(name="turbo_r", data=mpl_data_r, lut=turbo_colormap_data.shape[0]) Turbo = plt.get_cmap('turbo') if __name__ == "__main__": XX, YY = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100)) ZZ = np.sqrt(XX**2 + YY**2) plt.figure()
def map_num_users(): mpl.rcParams['font.size'] = 4.4 ########################################################################################### fig = plt.figure(3) #Custom adjust of the subplots plt.subplots_adjust(left=0.05, right=0.95, top=0.90, bottom=0.05, wspace=0.15, hspace=0.05) ax = plt.subplot(111) m = Basemap(llcrnrlon=-9, \ llcrnrlat=3.8, \ urcrnrlon=-1.5, \ urcrnrlat = 11, \ resolution = 'h', \ projection = 'tmerc', \ lat_0 = 7.38, \ lon_0 = -5.30) subpref_users = read_in_subpref_num_users() # read the shapefile archive s = m.readshapefile( '/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE', 'subpref') max7s = 1 min7s = 10000000 for subpref in subpref_users.keys(): if subpref_users[subpref] > max7s: max7s = subpref_users[subpref] if subpref_users[subpref] < min7s: min7s = subpref_users[subpref] max7s = float(max7s) print "max", (max7s) print "min", (min7s) scaled_weight = defaultdict(int) for i in range(256): scaled_weight[i] = defaultdict(int) for subpref in subpref_users.keys(): scaled_weight[subpref] = (subpref_users[subpref] - min7s) / (max7s - min7s) # values = range(256) # jet = cm = plt.get_cmap('jet') # cNorm = colors.Normalize(vmin=0, vmax=values[-1]) # scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet) # define custom colormap, white -> nicered, #E6072A = RGB(0.9,0.03,0.16) cdict = { 'red': ((0.0, 1.0, 1.0), (1.0, 0.9, 1.0)), 'green': ((0.0, 1.0, 1.0), (1.0, 0.03, 0.0)), 'blue': ((0.0, 1.0, 1.0), (1.0, 0.16, 0.0)) } custom_map = LinearSegmentedColormap('custom_map', cdict, N=10000) plt.register_cmap(cmap=custom_map) subpref_coord = read_in_subpref_lonlat() shp = ShapeFile( r'/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE') dbf = dbflib.open( r'/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE') for npoly in range(shp.info()[0]): shpsegs = [] shpinfo = [] shp_object = shp.read_object(npoly) verts = shp_object.vertices() rings = len(verts) #print shp_object for ring in range(rings): print ring lons, lats = zip(*verts[ring]) # if max(lons) > 721. or min(lons) < -721. or max(lats) > 91. or min(lats) < -91: # raise ValueError,msg x, y = m(lons, lats) shpsegs.append(zip(x, y)) if ring == 0: shapedict = dbf.read_record(npoly) print shapedict name = shapedict["ID_DEPART"] subpref_id = shapedict["ID_SP"] # print name, subpref_id # add information about ring number to dictionary. shapedict['RINGNUM'] = ring + 1 shapedict['SHAPENUM'] = npoly + 1 shpinfo.append(shapedict) #print subpref_id #print name lines = LineCollection(shpsegs, antialiaseds=(1, )) colorVal = custom_map(subpref_users[subpref_id]) # colorVal = scaled_weight[subpef] lines.set_facecolors(colorVal) lines.set_edgecolors('gray') lines.set_linewidth(0.1) ax.add_collection(lines)
def plotmaps(data, verbose = False, filter ="WORLD", var="od550aer", plotdir="./"): """plot aerocom standard maps Will plot every supplied time step""" if not isinstance(data, GriddedData): raise TypeError("Need pyaerocom.GriddedData as input") #define color bar; #will be moved somewhere else and variable specific at some point colorbar_levels = [0., 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] colorbar_ticks = [0., 0.02, 0.04, 0.06, 0.08, 0.1, 0.3, 0.5, 0.7, 0.9] aod_data = { 'red': ((0., 0, 0), (0.07, 0, 0), (0.1, 0.678, 0.678,), (0.26, 1, 1), (0.85, 1, 1), (1, 0.545, 0.545)), 'green': ((0., 0, 0), (0.07, 1, 1), (0.24, 1, 1), (0.91, 0, 0), (1, 0, 0)), 'blue': ((0., 1, 1), (0.07, 1, 1), (0.1, 0.133, 0.133), (0.25, 0, 0), (1, 0, 0))} colormap = LinearSegmentedColormap('aod_jet', aod_data) plt.register_cmap(cmap = colormap) TIME_VAR_NAME = 'time' PlotDailyFlag = False PlotMonthlyFlag = True for model in data: #assume that we have single cube for the moment #iterate over the time dimension cube = data[model].data #model = 'AATSR_ORAC_v4.01' cube.coord('latitude').guess_bounds() cube.coord('longitude').guess_bounds() #plot daily data if PlotDailyFlag: for time_sub_cube in cube.slices_over(TIME_VAR_NAME): pre_grid_areas = iris.analysis.cartography.area_weights(time_sub_cube) #pdb.set_trace() #print(time_sub_cube) # Perform the area-weighted mean for each of the datasets using the # computed grid-box areas. weighted_mean = time_sub_cube.collapsed(['latitude', 'longitude'], iris.analysis.MEAN, weights = pre_grid_areas) time = (unit.num2date(time_sub_cube.coord(TIME_VAR_NAME).points, time_sub_cube.coord(TIME_VAR_NAME).units.name, time_sub_cube.coord(TIME_VAR_NAME).units.calendar)) date = str(time[0]).split(' ')[0].replace('-','') Year = date[0:4] TsStr = 'm'+date PlotType = 'MAP' title = " ".join([var, date, 'mean: {:6.3f}'.format(float(weighted_mean.data))]) #ABS550_AER_an2012_mALLYEAR_WORLD_ZONALOBS_AERONETSky.ps.png #OD550_AER_an2017_d20171125_WORLD_MAP.ps.png plotfilename = os.path.join(plotdir, '_'.join([var, "an" + Year, TsStr, filter, PlotType]) + ".png") if verbose: print(plotfilename) plot = iplt.pcolormesh(time_sub_cube[:, :], cmap = colormap, vmin=0., vmax=max(colorbar_levels)) # pdb.set_trace() plot.axes.set_aspect(1.8) LatsToPlot = time_sub_cube.coord(axis='X').points LonsToPlot = time_sub_cube.coord(axis='Y').points axis = plt.axis([LatsToPlot.min(), LatsToPlot.max(), LonsToPlot.min(), LonsToPlot.max()]) ax = plot.axes ax.annotate('source: AEROCOM', xy=(0.88, 0.04), xycoords='figure fraction', horizontalalignment='right', fontsize=10, bbox=dict(boxstyle='square', facecolor='none', edgecolor='black')) ax.annotate(model, xy=(-174., -83.), xycoords='data', horizontalalignment='left', fontsize=13, color='black', bbox=dict(boxstyle='square', facecolor='white', edgecolor='none', alpha=0.7)) # plt.ylabel(_title(plot_defn.coords[0], with_units=True)) # plot_defn = iplt._get_plot_defn(cube, mode, ndims) plt.colorbar(spacing='uniform', ticks=colorbar_ticks, boundaries=colorbar_levels, extend='max') ax.coastlines() ax.set_xticks([-180., -120., -60., 0., 60, 120, 180], crs=ccrs.PlateCarree()) ax.set_yticks([-90., -60, -30, 0., 30, 60, 90], crs=ccrs.PlateCarree()) lon_formatter = LongitudeFormatter(number_format='.1f', degree_symbol='') lat_formatter = LatitudeFormatter(number_format='.1f', degree_symbol='') ax.xaxis.set_major_formatter(lon_formatter) ax.yaxis.set_major_formatter(lat_formatter) plt.xlabel = 'longitude' plt.ylabel = 'latitude' plt.title(title) plt.savefig(plotfilename, dpi=300) plt.close() #pdb.set_trace() elif PlotMonthlyFlag: #calculate monthly data iris.coord_categorisation.add_month(cube, TIME_VAR_NAME, name='month_number') iris.coord_categorisation.add_year(cube, TIME_VAR_NAME, name='month_year') cube_monthly = cube.aggregated_by(['month_number', 'month_year'], iris.analysis.MEAN) for time_sub_cube in cube_monthly.slices_over(TIME_VAR_NAME): pre_grid_areas = iris.analysis.cartography.area_weights(time_sub_cube) # pdb.set_trace() # print(time_sub_cube) # Perform the area-weighted mean for each of the datasets using the # computed grid-box areas. weighted_mean = time_sub_cube.collapsed(['latitude', 'longitude'], iris.analysis.MEAN, weights=pre_grid_areas) time = (unit.num2date(time_sub_cube.coord(TIME_VAR_NAME).points, time_sub_cube.coord(TIME_VAR_NAME).units.name, time_sub_cube.coord(TIME_VAR_NAME).units.calendar)) date = str(time[0]).split(' ')[0].replace('-', ' ')[0:7] Year = date[0:4] TsStr = 'm' + date[-2:] PlotType = 'MAP' title = " ".join([var, date, 'mean: {:6.3f}'.format(float(weighted_mean.data))]) # ABS550_AER_an2012_mALLYEAR_WORLD_ZONALOBS_AERONETSky.ps.png # OD550_AER_an2017_d20171125_WORLD_MAP.ps.png plotfilename = os.path.join(plotdir, '_'.join([var, "an" + Year, TsStr, filter, PlotType]) + ".png") if verbose: print(plotfilename) LatsToPlot = time_sub_cube.coord(axis='X').points LonsToPlot = time_sub_cube.coord(axis='Y').points xticks = [-180., -120., -60., 0., 60, 120, 180] yticks = [-90., -60, -30, 0., 30, 60, 90] plot_ts_map(time_sub_cube, title, plotfilename, LatsToPlot, LonsToPlot, colorbar_ticks, colorbar_levels, colormap, model, xticks, yticks)
def draw_redflag(m, lons, lats, model, dsize, background, location, lat, lon, RUNDATE, VALIDDATE, fxx, alpha, half_box, barb_thin, RH=25, SPEED=6.7, Fill=False, Contour=False, Fill_Potential=False): # Generalized criteria for red flag warning # Winds (gusts) greater than 6.7 m/s and RH < 25% rf_RH = RH rf_WIND = SPEED # Get Data H_gust = get_hrrr_variable(RUNDATE, 'GUST:surface', model=model, fxx=fxx, outDIR='/uufs/chpc.utah.edu/common/home/u0553130/temp/', verbose=False, value_only=True) H_rh = get_hrrr_variable(RUNDATE, 'RH:2 m', model=model, fxx=fxx, outDIR='/uufs/chpc.utah.edu/common/home/u0553130/temp/', verbose=False, value_only=True) RedFlag = np.logical_and(H_gust['value'] >rf_WIND, H_rh['value'] < rf_RH) if Fill: masked = np.ma.array(RedFlag) masked[masked == 0] = np.ma.masked m.pcolormesh(lons, lats, masked, cmap="YlOrRd_r", alpha=alpha, zorder=5, latlon=True) if Contour: try: CS = m.contour(lons, lats, RedFlag, latlon=True, colors='darkred', linewidths=.75, levels=[0], zorder=10) except: # maybe there isn't any contours in this domain pass if Fill_Potential: cdict3 = {'red': ((0.0, 1.0, 1.0), (0.5, 0.5, 0.5), (0.5, 1.0, 1.0), (1.0, 0.4, 0.4)), 'green': ((0.0, 1.0, 1.0), (0.5, 0.5, 0.5), (0.5, 0.4, 0.4), (1.0, 0.0, 0.0)), 'blue': ((0.0, 1.0, 1.0), (0.5, 0.5, 0.5), (0.5, 0.0, 0.0), (1.0, 0.0, 0.0)) } plt.register_cmap(name='FirePot', data=cdict3) # Definate Red Flag Area: RED_FLAG = np.logical_and(H_rh['value'] < rf_RH, H_gust['value'] > rf_WIND) # Linear Equation b = (rf_RH-rf_WIND)*(rf_RH/rf_WIND) z = -(rf_RH/rf_WIND)*(H_rh['value']-H_gust['value'])+b m.pcolormesh(lons, lats, z, cmap="FirePot", alpha=alpha, vmax=200, vmin=-200, zorder=3, latlon=True) cb = plt.colorbar(orientation='horizontal', pad=pad, shrink=shrink) cb.set_label(r'Red Flag Potential') plt.xlabel(r'Red Flag Criteria: Winds > %s m s$\mathregular{^{-1}}$ and RH < %s%%' % (SPEED,RH))
# Check to see if DISPLAY variable set, if not # then use the Agg background try: if not (os.environ["DISPLAY"]): matplotlib.use('Agg') except: if not ('matplotlib' in sys.modules.keys()): matplotlib.use('Agg') import matplotlib.cm as colmap import matplotlib.colors as mplc import matplotlib.pyplot as plt import numpy as np ## Through a jet, darkly. ## Create DarkJet ## ------ col_list = colmap.jet(range(256)) darken = np.tile((1 - 0.5 / np.cosh(np.linspace(-10, 10, 256))).reshape( (256, 1)), [1, col_list.shape[1]]) col_list = col_list * darken # Apply the darkening # Matplotlib defaults to rgba, not rgb. # Reset the transparency values now. col_list[:, 3] = 1. darkjet = mplc.ListedColormap(col_list, 'darkjet', 256) plt.register_cmap(cmap=darkjet) ## ------
import numpy as np import astropy.units as u import astropy.constants as c from astropy.time import Time import glob import matplotlib matplotlib.use('Agg') from matplotlib.backends.backend_pdf import PdfPages import matplotlib.pyplot as plt import colormaps as cmaps plt.register_cmap(name='viridis', cmap=cmaps.viridis) plt.set_cmap(cmaps.viridis) def gpfinder(wfall_file, thresh): data = np.load(wfall_file) deltat = float(data['tbin_microsecond'])*u.microsecond tstart = Time(float(data['t0']),format='mjd') wfall = data['I'] #wfall = wfall[2000:-5000,:,0]+wfall[2000:-5000,:,-1] wfall = wfall[:,0,0,:] + wfall[:,0,-1,:] wfall = wfall.T wfall = wfall/wfall.mean(axis=1,keepdims=True) -1 med_std = np.nanmedian(np.std(wfall,axis=1)) wfall[np.abs(np.std(wfall,axis=1)-med_std)>0.01,:]=np.nan
plt.subplots_adjust(top=1.0, bottom=0.0, left=0.0, right=1.0, wspace=0.0, hspace=0.0) plt.savefig(output, bbox_inches='tight', dpi=dpi) plt.close('all') # register custom maps plt.register_cmap(cmap=colors.LinearSegmentedColormap( 'red', { 'red': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'blue': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'alpha': ((0.0, 0.0, 1.0), (1.0, 1.0, 1.0)) })) plt.register_cmap(cmap=colors.LinearSegmentedColormap( 'green', { 'green': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), 'red': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'blue': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)), 'alpha': ((0.0, 0.0, 1.0), (1.0, 1.0, 1.0)) })) plt.register_cmap(cmap=colors.LinearSegmentedColormap( 'blue', { 'blue': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)),
""" Package containing plotting customizations and routines. """ import pkg_resources # NOQA: E402 from matplotlib import pyplot # NOQA: E402 from figstyle.style import colourWheel, dashesStyles, width, golden_ratio # NOQA: F401 from figstyle.turbo_colormap import mpl_turbo_data # NOQA: F401 # Load style file style_path = pkg_resources.resource_filename( "figstyle", "data/paper_double_fig.mplstyle" ) pyplot.style.use(style_path) # register the "turbo" colormap pyplot.register_cmap(name="turbo", data=mpl_turbo_data, lut=256)
# # (0.75,1.0, 1.0), # (1.0, 1.0, 1.0)) # # blue_red = LinearSegmentedColormap('BlueRed', cdict4) ncolors = 256 color_array = plt.get_cmap('coolwarm')(range(ncolors)) # change alpha values color_array[:, -1] = np.linspace(1.0, 0.0, ncolors) # create a colormap object map_object = LinearSegmentedColormap.from_list(name='rainbow_alpha', colors=color_array) # register this new colormap with matplotlib plt.register_cmap(cmap=map_object) fig = plt.figure(figsize=plt.figaspect(0.5)) ax = fig.add_subplot(1, 2, 1, projection="3d") plot = ax.scatter(xx.flatten(), yy.flatten(), zz.flatten(), s=20, c=pc, cmap='rainbow_alpha', vmin=-20, vmax=+20) ax.set_xlabel('X Axes') ax.set_ylabel('Y Axes') ax.set_zlabel('Z Axes') ax.set_title(
from scipy.ndimage import map_coordinates import matplotlib #matplotlib.use('Agg') from matplotlib import rcParams as rc from matplotlib import pyplot as plot from pylab import rcParams from pylab import fromfile import util from readTitle import readTitle import colormaps as cmaps plot.register_cmap(name='viridis', cmap=cmaps.viridis) plot.register_cmap(name='inferno', cmap=cmaps.inferno) plot.register_cmap(name='plasma', cmap=cmaps.plasma) plot.register_cmap(name='magma', cmap=cmaps.magma) save_directory = "squarePolarGasDensityMaps" ### Get FARGO Parameters ### # Create param file if it doesn't already exist param_fn = "params.p" if not os.path.exists(param_fn): command = "python pickleParameters.py" split_command = command.split() subprocess.Popen(split_command) fargo_par = pickle.load(open(param_fn, "rb"))
cmaps['dkc_v'] = { 'colors': colors, 'position': position, 'min': -100, 'max': 100 } z = cmaps['wdtd_z'] v = cmaps['wdtd_v'] vel_max = 100 vels_array = np.linspace(-vel_max, vel_max, 11) vticks = np.ndarray.tolist(vels_array) ref_cmap = make_cmap(z['colors'], position=z['position'], bit=True) plt.register_cmap(cmap=ref_cmap) plts['ReflectivityQC'] = { 'cmap': ref_cmap, 'vmn': z['min'], 'vmx': z['max'], 'title': 'Reflectivity', 'cbticks': [0, 15, 30, 50, 60], 'cblabel': 'dBZ' } plts['Ref'] = plts['ReflectivityQC'] vel_cmap = make_cmap(v['colors'], position=v['position'], bit=True) plt.register_cmap(cmap=vel_cmap) plts['Velocity'] = { 'cmap': vel_cmap, 'vmn': v['min'],
import numpy as np import healpy as hp from matplotlib.colors import LogNorm import pyathena as pa import pyathena.synthetic_observations as syn import glob, os base = '/tigress/changgoo/' sourcedir = '../' cmap = syn.load_planck_cmap( '{}/misc/Planck_Parchment_RGB.txt'.format(sourcedir)) cmap.set_bad('white', 0.) cmap.set_under(cmap.colors[0]) plt.register_cmap(cmap=cmap) plt.rcParams['image.cmap'] = 'planck' plt.rcParams['font.size'] = 20 plt.rcParams['figure.figsize'] = (12, 6) plt.rcParams['figure.dpi'] = 150 # magnetar import sys sys.path.append('{}/Sources/magnetar/'.format(base)) from bvisual import lic from astropy.io import fits from astropy.wcs import WCS from reproject import reproject_from_healpix, reproject_to_healpix, reproject_interp
# -*- coding: utf-8 -*- """ This code is written to generate the Chlorophyll colormap. Therefore, instead of importing it, it should just be run. I'm looking into a more proper way to do this. Created on Mon Aug 13 2018 @author: joe """ import igor.binarywave as igoribw import numpy as np from matplotlib.colors import LinearSegmentedColormap import matplotlib.pyplot as plt chl = igoribw.load('Chlorophyll.ibw') colordata = np.transpose(chl['wave']['wData']) chlor = {} L = len(np.transpose(colordata)) chlor['red'] = [(i / (L - 1), colordata[0][i] / 65533, colordata[0][i] / 65533) for i, x in enumerate(colordata[0])] chlor['green'] = [(i / (L - 1), colordata[1][i] / 65533, colordata[1][i] / 65533) for i, x in enumerate(colordata[0])] chlor['blue'] = [(i / (L - 1), colordata[2][i] / 65533, colordata[2][i] / 65533) for i, x in enumerate(colordata[0])] chlorophyll = LinearSegmentedColormap('Chlorophyll', chlor) plt.register_cmap(cmap=chlorophyll)
#!/opt/local/bin/python # --------------------------------------------------------------------------- # # My handrolled modules. import nemo # Import required modules. import cmocean import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.basemap import Basemap # Register the thermal colormap. plt.register_cmap(name='ice', cmap=cmocean.cm.ice) plt.ioff() # --------------------------------------------------------------------------- # # Specify where the input data lives. homedir = '~/ORCHESTRA/NEMO/' nemodir = 'trunk/NEMOGCM/CONFIG/CORE2NYF-ORCH0083-LIM3/EXP00/' # Specify the names of the different files that I want to load from. filename = 'TIDY/ARCHIVE/1948/I/ORCH0083-LIM3_19481227_I_d05.nc' gridfile = 'TIDY/ARCHIVE/MESH/mesh_mask.nc' # --------------------------------------------------------------------------- # # Load the coordinates.
from matplotlib.patches import Wedge from matplotlib import __version__ as mplv import matplotlib.pyplot as plt from spacepy import __path__ as basepath from spacepy.datamodel import dmcopy import spacepy.datamanager as dman from .. import config from .spectrogram import * from .utils import * from .carrington import * from .colourmaps import plasma as _plasma from .colourmaps import plasma_r as _plasma_r from .colourmaps import viridis as _viridis from .colourmaps import viridis_r as _viridis_r plt.register_cmap(name='plasma', cmap=_plasma) plt.register_cmap(name='plasma_r', cmap=_plasma_r) plt.register_cmap(name='viridis', cmap=_viridis) plt.register_cmap(name='viridis_r', cmap=_viridis_r) def plot(*args, **kwargs): '''Convenience wrapper for matplotlib's plot function As with matplotlib's plot function, *args* is a variable length argument, allowing for multiple *x*, *y* pairs, each with optional format string. For full details, see matplotlib.pyplot.plot Other Parameters ---------------- smartTimeTicks : boolean If True then use applySmartTimeTicks to set x-axis labeling
# + # plotting imageDims = (14, 14) figureImageDims = (2, 3) figureTableDims = (5, 4) fontScale = 1 # set transparent mask for low attention areas # cdict = plt.get_cmap("gnuplot2")._segmentdata cdict = { "red": ((0.0, 0.0, 0.0), (0.6, 0.8, 0.8), (1.0, 1, 1)), "green": ((0.0, 0.0, 0.0), (0.6, 0.8, 0.8), (1.0, 1, 1)), "blue": ((0.0, 0.0, 0.0), (0.6, 0.8, 0.8), (1.0, 1, 1)) } cdict["alpha"] = ((0.0, 0.35, 0.35), (1.0, 0.65, 0.65)) plt.register_cmap(name="custom", data=cdict) def showTableAtt(table, words, tax=None): ''' Question attention as sns heatmap ''' if tax is None: fig2, bx = plt.subplots(1, 1) bx.cla() else: bx = tax sns.set(font_scale=fontScale) steps = len(table)
# Turn the lon/lat of the bins into 2 dimensional arrays ready # for conversion into projected coordinates lon_bins_2d, lat_bins_2d = np.meshgrid(lon_bins, lat_bins) # convert the bin mesh to map coordinates: xs, ys = m(lon_bins_2d, lat_bins_2d) # will be plotted using pcolormesh # define custom colormap, white -> nicered, #E6072A = RGB(0.9,0.03,0.16) cdict = { 'red': ((0.0, 1.0, 1.0), (1.0, 0.9, 1.0)), 'green': ((0.0, 1.0, 1.0), (1.0, 0.03, 0.0)), 'blue': ((0.0, 1.0, 1.0), (1.0, 0.16, 0.0)) } custom_map = LinearSegmentedColormap('custom_map', cdict) plt.register_cmap(cmap=custom_map) # add histogram squares and a corresponding colorbar to the map: plt.pcolormesh(xs, ys, density, cmap="custom_map") cbar = plt.colorbar(orientation='horizontal', shrink=0.625, aspect=20, fraction=0.5, pad=0.02) cbar.set_label('Number of Jobs', size=26) #plt.clim([0,100]) # translucent blue scatter plot of jobs above histogram: x, y = m(list(lons), list(lats)) m.plot(x,
(1.0, 1.0, 1.0)) # Now we will use this example to illustrate 3 ways of # handling custom colormaps. # First, the most direct and explicit: blue_red1 = LinearSegmentedColormap('BlueRed1', cdict1) # Second, create the map explicitly and register it. # Like the first method, this method works with any kind # of Colormap, not just # a LinearSegmentedColormap: blue_red2 = LinearSegmentedColormap('BlueRed2', cdict2) plt.register_cmap(cmap=blue_red2) # Third, for LinearSegmentedColormap only, # leave everything to register_cmap: plt.register_cmap(name='BlueRed3', data=cdict3) # optional lut kwarg plt.register_cmap(name='BlueRedAlpha', data=cdict4) # Make some illustrative fake data: x = np.arange(0, np.pi, 0.1) y = np.arange(0, 2*np.pi, 0.1) X, Y = np.meshgrid(x,y) Z = np.cos(X) * np.sin(Y) * 10 # Make the figure:
except Usage as err: print("\nERROR:", file=sys.stderr, end='') print(" " + str(err.msg), file=sys.stderr) print("\nFor help, use -h or --help.\n", file=sys.stderr) sys.exit(2) #%% Set cmap if SCM if cmap_name.startswith('SCM'): if cmap_name.endswith('_r'): exec("cmap = {}.reversed()".format(cmap_name[:-2])) else: exec("cmap = {}".format(cmap_name)) elif cmap_name == 'insar': cdict = tools_lib.cmap_insar() plt.register_cmap( cmap=mpl.colors.LinearSegmentedColormap('insar', cdict)) cmap = 'insar' else: cmap = cmap_name #%% Get info and Read data if gdal.IdentifyDriver(infile): ## If Geotiff or grd geotiff = gdal.Open(infile) data = geotiff.ReadAsArray() if data.ndim > 2: print('\nERROR: {} has multiple bands and cannot be displayed.\n'. format(infile), file=sys.stderr) sys.exit(2) length, width = data.shape
def shiftedColorMap(cmap, data=False, start=0, midpoint=0.5, stop=1.0, set=True, register=False, name='shiftedcmap'): ''' Function to offset the "center" of a colormap. Useful for data with a negative min and positive max and you want the middle of the colormap's dynamic range to be at zero Input ----- cmap : The matplotlib colormap to be altered start : Offset from lowest point in the colormap's range. Defaults to 0.0 (no lower ofset). Should be between 0.0 and `midpoint`. midpoint : The new center of the colormap. Defaults to 0.5 (no shift). Should be between 0.0 and 1.0. In general, this should be 1 - vmax/(vmax + abs(vmin)) For example if your data range from -15.0 to +5.0 and you want the center of the colormap at 0.0, `midpoint` should be set to 1 - 5/(5 + 15)) or 0.75 stop : Offset from highets point in the colormap's range. Defaults to 1.0 (no upper ofset). Should be between `midpoint` and 1.0. ''' if type(data) == np.ndarray: vmax = data.max() vmin = data.min() midpoint = 1 - vmax/(vmax + abs(vmin)) cdict = { 'red': [], 'green': [], 'blue': [], 'alpha': [] } # regular index to compute the colors reg_index = np.linspace(start, stop, 257) # shifted index to match the data shift_index = np.hstack([ np.linspace(0.0, midpoint, 128, endpoint=False), np.linspace(midpoint, 1.0, 129, endpoint=True) ]) for ri, si in zip(reg_index, shift_index): r, g, b, a = cmap(ri) cdict['red'].append((si, r, r)) cdict['green'].append((si, g, g)) cdict['blue'].append((si, b, b)) cdict['alpha'].append((si, a, a)) newcmap = matplotlib.colors.LinearSegmentedColormap(name, cdict) if set: plt.set_cmap(newcmap) if register: plt.register_cmap(cmap=newcmap) return newcmap
"darkpurple", colorcet.linear_bmw_5_95_c89) # add gkr theme for velocity div_blue_black_red_cmap = matplotlib.colors.LinearSegmentedColormap.from_list( "div_blue_black_red", colorcet.diverging_gkr_60_10_c40) # add RdBu_r theme for velocity div_blue_red_cmap = matplotlib.colors.LinearSegmentedColormap.from_list( "div_blue_red", colorcet.diverging_bwr_55_98_c37) # add glasbey_bw for cell annotation in white background glasbey_white_cmap = matplotlib.colors.LinearSegmentedColormap.from_list( "glasbey_white", colorcet.glasbey_bw_minc_20) # add glasbey_bw_minc_20_maxl_70 theme for cell annotation in dark background glasbey_dark_cmap = matplotlib.colors.LinearSegmentedColormap.from_list( "glasbey_dark", colorcet.glasbey_bw_minc_20_maxl_70) # register cmap plt.register_cmap("zebrafish", zebrafish_cmap) plt.register_cmap("fire", fire_cmap) plt.register_cmap("darkblue", darkblue_cmap) plt.register_cmap("darkgreen", darkgreen_cmap) plt.register_cmap("darkred", darkred_cmap) plt.register_cmap("darkpurple", darkpurple_cmap) plt.register_cmap("div_blue_black_red", div_blue_black_red_cmap) plt.register_cmap("div_blue_red", div_blue_red_cmap) plt.register_cmap("glasbey_white", glasbey_white_cmap) plt.register_cmap("glasbey_dark", glasbey_dark_cmap) _themes = { "fire": { "cmap": "fire", "color_key_cmap": "rainbow", "background": "black",
import string import glob import random import sys import numpy as np import scipy as sp import scipy.stats import matplotlib import matplotlib.pyplot as plt import itertools as it import types import pdb wrb_cmap=matplotlib.colors.LinearSegmentedColormap.from_list('wrb',colors=['white','red','black']) wrb_cmap.set_bad([0.82,0.82,0.82]) plt.register_cmap(cmap=wrb_cmap) worb_cmap=matplotlib.colors.LinearSegmentedColormap.from_list('worb',colors=['white','orange','red',[0.5,0,0],'black']) worb_cmap.set_bad([0.82,0.82,0.82]) plt.register_cmap(cmap=worb_cmap) worb2_cmap=matplotlib.colors.LinearSegmentedColormap.from_list('worb2',colors=['white','orange','red',[0.5,0,0],'black']) worb2_cmap.set_bad([1,1,1]) plt.register_cmap(cmap=worb2_cmap) dekker_cmap=matplotlib.colors.LinearSegmentedColormap.from_list('dekker',colors=[[1,1,1],[1,0.65,0],[1,0,0],[0.35,0,0]]) dekker_cmap.set_bad([0.82,0.82,0.82]) plt.register_cmap(cmap=dekker_cmap) bwr_cmap=matplotlib.colors.LinearSegmentedColormap.from_list('bwr',colors=['blue','white','red']) bwr_cmap.set_bad([0.82,0.82,0.82])
def _mpl_cm(name, colorlist): cmap = LinearSegmentedColormap.from_list(name, colorlist, N=256) register_cmap("cet_" + name, cmap=cmap)