def cmapFromName(cmapname, ncols=256, bad=None):
"""
Do we need this?
"""
if not bad:
bad = [1.0, 1.0, 1.0, 0.0]
cmap = mpl.cm.get_cmap('jet', ncols)
if cmapname is not None:
if cmapname == 'b2r':
cmap = mpl.colors.LinearSegmentedColormap('my_colormap',
cdict, ncols)
elif cmapname == 'viridis' and StrictVersion(mpl.__version__) < StrictVersion('1.5.0'):
print("Mpl:", mpl.__version__, " using HB viridis")
cmap = LinearSegmentedColormap.from_list('viridis', viridis_data[::-1])
elif cmapname == 'viridis_r':
print("Using HB viridis_r")
cmap = LinearSegmentedColormap.from_list('viridis', viridis_data)
else:
try:
cmap = mpl.cm.get_cmap(cmapname, ncols)
except Exception as e:
print("Could not retrieve colormap ", cmapname, e)
cmap.set_bad(bad)
return cmap
def cmap_powerlaw_adjust(cmap, a):
'''
returns a new colormap based on the one given
but adjusted via power-law:
newcmap = oldcmap**a
'''
if a < 0.:
return cmap
cdict = copy(cmap._segmentdata)
def fn(x):
return (x[0]**a, x[1], x[2])
for key in ('red','green','blue'):
try:
cdict[key] = map(fn, cdict[key])
cdict[key].sort()
assert (cdict[key][0]<0 or cdict[key][-1]>1), \
"Resulting indices extend out of the [0, 1] segment."
except TypeError:
def fngen(f):
def fn(x):
return f(x)**a
return fn
cdict[key] = fngen(cdict[key])
newcmap = LinearSegmentedColormap('colormap',cdict,1024)
newcmap.set_bad(cmap(np.nan))
return newcmap
def get_colorMap_intensity_r():
""" according to the colorweel intensity II"""
color5 = [0.0,4./255,76./255]
color4 = [49./255., 130./255., 0.0]
color3 = [1.,197./255.,98./255.]
color2 = [245./255., 179./255., 223./255.]
color1 = [ 216./255., 1.0,1.0]
cdict = {'red': ((0.0, color1[0], color1[0]),
(0.25,color2[0] ,color2[0]),
(0.5,color3[0] ,color3[0]),
(0.75,color4[0] ,color4[0]),
(1.00,color5[0] ,color5[0])),
'green': ((0.0, color1[1], color1[1]),
(0.25,color2[1] , color2[1]),
(0.5,color3[1] ,color3[1]),
(0.75,color4[1] ,color4[1]),
(1.0,color5[1] ,color5[1])),
'blue': ((0.0, color1[2], color1[2]),
(0.25, color2[2], color2[2]),
(0.5, color3[2] ,color3[2]),
(0.75,color4[2] ,color4[2]),
(1.0,color5[2] ,color5[2]))
}
hag_cmap = LinearSegmentedColormap('hag_cmap',cdict)
hag_cmap.set_bad('black')
return hag_cmap
def get_colorMap_heat():
""" according to the colorweel heat"""
color1 = np.array([0.0,14.,161.])/255.
color2 = np.array([0., 125., 11.])/255.
color3 = np.array([255.,255.,255.])/255.
color4 = np.array([255., 172., 0.])/255.
# color5 = np.array([ 184., 0.,18.])/255.
color5 = np.array([ 163., 0.,119.])/255.
cdict = {'red': ((0.0, color1[0], color1[0]),
(0.25,color2[0] ,color2[0]),
(0.5,color3[0] ,color3[0]),
(0.75,color4[0] ,color4[0]),
(1.00,color5[0] ,color5[0])),
'green': ((0.0, color1[1], color1[1]),
(0.25,color2[1] , color2[1]),
(0.5,color3[1] ,color3[1]),
(0.75,color4[1] ,color4[1]),
(1.0,color5[1] ,color5[1])),
'blue': ((0.0, color1[2], color1[2]),
(0.25, color2[2], color2[2]),
(0.5, color3[2] ,color3[2]),
(0.75,color4[2] ,color4[2]),
(1.0,color5[2] ,color5[2]))
}
hag_cmap = LinearSegmentedColormap('hag_cmap',cdict)
hag_cmap.set_bad('black')
return hag_cmap
def demo_compositing(im_r, im_g, im_b, im_rgb):
fig = plt.figure(3)
grid = ImageGrid(fig, 222,
nrows_ncols = (2, 2),
axes_pad = 0.1,
)
cm_red = LinearSegmentedColormap.from_list('cm_black_red',
[cm.colors.cnames['black'], cm.colors.cnames['red']])
cm_green = LinearSegmentedColormap.from_list('cm_black_green',
[cm.colors.cnames['black'], cm.colors.cnames['green']])
cm_blue= LinearSegmentedColormap.from_list('cm_black_blue',
[cm.colors.cnames['black'], cm.colors.cnames['blue']])
im_grid = [im_r, im_g, im_b, im_rgb]
color_maps = [cm_red, cm_green, cm_blue, None]
for i in range(4):
cmap = color_maps[i]
grid[i].imshow(im_grid[i], cmap = cmap, interpolation = 'nearest')
# The AxesGrid object work as a list of axes.
plt.show()
def get_colorMap_water():
"""elevation map according to a tundra climate """
colors = []
# color.append(np.array([0.,0.,0.])/255.) #white for ice
# blue = np.array([ 0., 0., 50])/255.
blue = np.array([161., 190., 255.]) / 255.
colors.append(blue)
colors.append(blue)
# colors.append(np.array([39., 62., 44.])/255.)
# colors.append(np.array([77.,102.,70.])/255.)
# colors.append(np.array([126., 129., 110.])/255.)
# colors.append(np.array([ 95., 93.,94.])/255.)
# colors.append(np.array([1.,1.,1.])) #white for ice
steps = np.linspace(0,1,len(colors))
# print(len(colors))
# print(steps)
red = []
green = []
blue = []
for e,c in enumerate(colors):
red.append((steps[e],c[0],c[0]))
green.append((steps[e],c[1],c[1]))
blue.append((steps[e],c[2],c[2]))
cdict = {'red': red,
'green': green,
'blue': blue
}
hag_cmap = LinearSegmentedColormap('svalbard',cdict)
hag_cmap.set_bad(np.array([ 0., 0.,0.,0]))
return hag_cmap
def _make_STMView_colormap(fileName, name='my_cmap'):
if fileName.endswith('.mat'):
matFile = _loadmat(_path + fileName)
for key in matFile:
if key not in ['__version__', '__header__', '__globals__']:
return _LSC.from_list(name, matFile[key])
elif fileName.endswith('.txt'):
txtFile = _np.loadtxt(_path + fileName)
return _LSC.from_list(name, txtFile)
def __init__(self, name, segmented_data, index=None, **kwargs):
if index is None:
# If index not given, RGB colors are evenly-spaced in colormap.
index = np.linspace(0, 1, len(segmented_data['red']))
for key, value in segmented_data.items():
# Combine color index with color values.
segmented_data[key] = zip(index, value)
segmented_data = dict((key, [(x, y, y) for x, y in value])
for key, value in segmented_data.items())
LinearSegmentedColormap.__init__(self, name, segmented_data, **kwargs)
def __init__(self):
aggr1=0.2
aggr2 = 0.2
#fitnessCmap=LinearSegmentedColormap.from_list('fitness_map',[(aggr1,1,aggr1),(1,1,aggr1),(1,aggr1,aggr1)])
fitnessCmap = LinearSegmentedColormap.from_list('fitness_map',[(0, 1-aggr1, 0), (1-aggr1, 1-aggr1, 0), (1-aggr1, 0, 0)])
#complexityCmap = LinearSegmentedColormap.from_list('complexity_map', [(1,1,1),(aggr2, 1, 1), (aggr2,aggr2,1),(aggr2, aggr2, aggr2)])
complexityCmap = LinearSegmentedColormap.from_list('complexity_map',[(0.6, 0.6, 0.9),(0, 0, 0.3)])
self.complexity = complexityCmap#plt.get_cmap("cool")
self.globalm = fitnessCmap
self.localm = fitnessCmap#plt.get_cmap("RdYlGn")
def newgray():
""" Modified version of Oranges."""
oranges = cm.get_cmap("gray", 100)
array = oranges(np.arange(100))
array = array[40:]
cmap = LinearSegmentedColormap.from_list("newgray", array)
cm.register_cmap(name='newgray', cmap=cmap)
array = array[::-1]
cmap = LinearSegmentedColormap.from_list("newgray_r", array)
cm.register_cmap(name='newgray_r', cmap=cmap)
return
def __init__(self, name, color_data, index=None, **kwargs):
if not hasattr(color_data, 'keys'):
color_data = rgb_list_to_colordict(color_data)
if index is None:
# If index not given, RGB colors are evenly-spaced in colormap.
index = np.linspace(0, 1, len(color_data['red']))
# Adapt color_data to the form expected by LinearSegmentedColormap.
color_data = dict((key, [(x, y, y) for x, y in zip(index, value)])
for key, value in color_data.items())
LinearSegmentedColormap.__init__(self, name, color_data, **kwargs)
def pl_hess_diag(
gs, gs_y1, gs_y2, x_min_cmd, x_max_cmd, y_min_cmd, y_max_cmd, x_ax, y_ax,
lkl_method, hess_xedges, hess_yedges, hess_x, hess_y, HD):
"""
Hess diagram of observed minus best match synthetic cluster.
"""
ax = plt.subplot(gs[gs_y1:gs_y2, 2:4])
# Set plot limits
plt.xlim(x_min_cmd, x_max_cmd)
plt.ylim(y_min_cmd, y_max_cmd)
# Set axis labels
plt.xlabel('$' + x_ax + '$', fontsize=18)
# Set minor ticks
ax.minorticks_on()
ax.xaxis.set_major_locator(MultipleLocator(1.0))
if gs_y1 == 0:
ax.set_title("Hess diagram (observed - synthetic)", fontsize=10)
for x_ed in hess_xedges:
# vertical lines
ax.axvline(x_ed, linestyle=':', lw=.8, color='k', zorder=1)
for y_ed in hess_yedges:
# horizontal lines
ax.axhline(y_ed, linestyle=':', lw=.8, color='k', zorder=1)
if HD.any():
# Add text box.
if HD.min() < 0:
plt.scatter(-100., -100., marker='s', lw=0., s=60, c='#0B02F8',
label='{}'.format(int(HD.min())))
if HD.max() > 0:
plt.scatter(-100., -100., marker='s', lw=0., s=60, c='#FB0605',
label='{}'.format(int(HD.max())))
# Define custom colorbar.
if HD.min() == 0:
cmap = LinearSegmentedColormap.from_list(
'mycmap', [(0, 'white'), (1, 'red')])
else:
# Zero point for empty bins which should be colored in white.
zero_pt = (0. - HD.min()) / float(HD.max() - HD.min())
N = 256.
zero_pt0 = np.floor(zero_pt * (N - 1)) / (N - 1)
zero_pt1 = np.ceil(zero_pt * (N - 1)) / (N - 1)
cmap = LinearSegmentedColormap.from_list(
'mycmap', [(0, 'blue'), (zero_pt0, 'white'), (zero_pt1,
'white'), (1, 'red')], N=N)
ax.pcolormesh(hess_x, hess_y, HD, cmap=cmap, vmin=HD.min(),
vmax=HD.max(), zorder=1)
# Legend.
handles, labels = ax.get_legend_handles_labels()
leg = ax.legend(
handles, labels, loc='lower right', scatterpoints=1, ncol=2,
columnspacing=.2, handletextpad=-.3, fontsize=10)
leg.get_frame().set_alpha(0.7)
def _create_overlay_map():
#transparent colormap
global _over_red
r, g, b = plotParams['mask']['color']
cdict = {'red': ((0.0, r, r),
(1.0, r, r)),
'green': ((0.0, g, g),
(1.0, g, g)),
'blue': ((0.0, b, b),
(1.0, b, b))
}
_over_red = LinearSegmentedColormap('MaskOver', cdict)
_over_red.set_bad(alpha=0)
def temp_style_file(name):
""" A context manager for creating an empty style file in the expected path.
"""
stylelib_path = USER_LIBRARY_PATHS[0]
if not os.path.exists(stylelib_path):
os.makedirs(stylelib_path)
srcname = os.path.abspath(os.path.join(os.path.dirname(__file__),name))
dstname = os.path.join(stylelib_path, os.path.basename(name))
if not os.path.exists(srcname):
raise RuntimeError('Cannot use file at "' + srcname + '". This file does not exist.')
if os.path.exists(dstname):
#raise RuntimeError('Cannot create a temporary file at "' + dstname + '". This file exists already.')
warnings.warn('Overwriting the temporary file at "' + dstname + '".')
#with open(filename, 'w'):
# pass
shutil.copy2(srcname, dstname)
rgb = [
( 0./255. , 0./255. , 0./255.),
( 0./255. , 102./255. , 51./255.),
#(114./255. , 121./255. , 126./255.),
( 91./255. , 172./255. , 38./255.),
(217./255. , 220./255. , 222./255.),
(255./255. , 255./255. , 255./255.)
]
# create map and register it together with reversed colours
maps = []
maps.append(LinearSegmentedColormap.from_list('IPU' , rgb))
maps.append(LinearSegmentedColormap.from_list('IPU_r', rgb[::-1]))
for cmap in maps:
mplcm.register_cmap(cmap=cmap)
#self._color_maps[cmap.name] = cmap
yield
os.remove(dstname)
#print('# styles available:', len(plt.style.available))
#
#with temp_style_file('dummy.mplstyle'):
# print('# before reload:', len(plt.style.available))
#
# plt.style.reload_library()
# print('# after reload:', len(plt.style.available))
def custom_div_cmap(numcolors=11, name='custom_div_cmap',
mincol='r', midcol='white', maxcol='g'):
from matplotlib.colors import LinearSegmentedColormap
cmap = LinearSegmentedColormap.from_list(name=name,
colors =[mincol, midcol, maxcol],
N=numcolors)
return cmap
def generate_cmap(colors):
values = range(len(colors))
vmax = np.ceil(np.max(values))
color_list = []
for v, c in zip(values, colors):
color_list.append( ( v/ vmax, c) )
return LinearSegmentedColormap.from_list('custom_cmap', color_list)
def set_binary_lut(mayavi_obj, color1, color2, use_vector_lut=False):
'''
sets the lookup table to of the mayavi object provided to a 2 color
color map ranging between color1 and color2. Also sets the appropriate
attributes of the LUT so that the scalars are immediately displayed
Parameters
----------
mayavi_obj : Instance(mlab.pipeline)
A mayavi object with a module_manager instance
color1 : 3-tuple
An RGB color represented as a 3-tuple with values [0,1], and
corresponding to the scalar value 0
color2 : 3-tuple
An RGB color represented as a 3-tuple with values [0,1], and
corresponding to the scalar value 1
use_vector_lut : Bool
If true, uses the vector_lut_manager. Otherwise, uses the
scalar_lut_manager. Defaults to False.
'''
mayavi_obj.actor.mapper.scalar_visibility = True
if use_vector_lut:
lut_mgr=mayavi_obj.module_manager.vector_lut_manager
else:
lut_mgr=mayavi_obj.module_manager.scalar_lut_manager
lut_mgr.lut.table = map_to_table(
LinearSegmentedColormap.from_list('ign', [color1, color2]))
#map(mayavi2vtk_color, [color1, color2])))
#lut_mgr.use_default_range = False
lut_mgr.data_range = [0,1]
def _init_mutable_colormap():
"""Create a matplotlib colormap that will be updated by the widgets."""
greys = color_palette("Greys", 256)
cmap = LinearSegmentedColormap.from_list("interactive", greys)
cmap._init()
cmap._set_extremes()
return cmap
def get_color_map(num_states):
colours = plt.cm.viridis(np.linspace(0, 1, num_states))
colormap = {i: colours[i] for i in range(num_states)}
cmap = LinearSegmentedColormap.from_list('name',
list(colormap.values()),
num_states)
return colormap, cmap
def plotBackground(areaPoly=None, ax=None, globalOrigin=None):
"""
plots the background from the tiff-file given. In the future, maybe data is taken from
google maps or something similar?
#local coordinates in areaPoly, with origin in origin
origin is given in sweref99 coordinates, not local.
"""
if not areaPoly: raise Exception('need area polygon in order to plot background')
if not ax:
fig=plt.figure()
ax=fig.add_subplot(111, aspect='equal')
figCorner=(595000, 6725000) #for this specific area, not general
if not globalOrigin:
globalOrigin=figCorner
#now, let our global origin be in the origin..
w=5000 #for this specific image..
h=5000
figorigin=np.array(figCorner)-np.array(globalOrigin)
limits=[figorigin[0], figorigin[0]+w, figorigin[1], figorigin[1]+h]
folder=os.path.dirname(os.path.abspath(__file__))
folder=os.path.join(folder, 'GIS')
map=LinearSegmentedColormap.from_list('lightgray', ['#666666', '#C5C5C5']) #our own cmap
bg=mpimg.imread(os.path.join(folder,'672_59_11.tif'))
im = plt.imshow(bg, cmap=map,origin='lower', extent=limits)
#now, adjust to our polygon..
limits=list(fun.polygonLim(areaPoly))
w=max(10, max(limits)/10.)
limits[0]-=w #to get some space to polygon
limits[1]+=w
limits[2]-=w
limits[3]+=w
ax.axis(limits)
return ax
def heat_map(self, cmap='RdYlGn', vmin=None, vmax=None, font_cmap=None):
if cmap is None:
carr = ['#d7191c', '#fdae61', '#ffffff', '#a6d96a', '#1a9641']
cmap = LinearSegmentedColormap.from_list('default-heatmap', carr)
if isinstance(cmap, basestring):
cmap = get_cmap(cmap)
if isinstance(font_cmap, basestring):
font_cmap = get_cmap(font_cmap)
vals = self.actual_values.astype(float)
if vmin is None:
vmin = vals.min().min()
if vmax is None:
vmax = vals.max().max()
norm = (vals - vmin) / (vmax - vmin)
for ridx in range(self.nrows):
for cidx in range(self.ncols):
v = norm.iloc[ridx, cidx]
if np.isnan(v):
continue
color = cmap(v)
hex = rgb2hex(color)
styles = {'BACKGROUND': HexColor(hex)}
if font_cmap is not None:
styles['TEXTCOLOR'] = HexColor(rgb2hex(font_cmap(v)))
self.iloc[ridx, cidx].apply_styles(styles)
return self
def heat_map(self, cmap="RdYlGn", vmin=None, vmax=None, font_cmap=None):
if cmap is None:
carr = ["#d7191c", "#fdae61", "#ffffff", "#a6d96a", "#1a9641"]
cmap = LinearSegmentedColormap.from_list("default-heatmap", carr)
if isinstance(cmap, str):
cmap = get_cmap(cmap)
if isinstance(font_cmap, str):
font_cmap = get_cmap(font_cmap)
vals = self.actual_values.astype(float)
if vmin is None:
vmin = vals.min().min()
if vmax is None:
vmax = vals.max().max()
norm = (vals - vmin) / (vmax - vmin)
for ridx in range(self.nrows):
for cidx in range(self.ncols):
v = norm.iloc[ridx, cidx]
if np.isnan(v):
continue
color = cmap(v)
hex = rgb2hex(color)
styles = {"BACKGROUND": HexColor(hex)}
if font_cmap is not None:
styles["TEXTCOLOR"] = HexColor(rgb2hex(font_cmap(v)))
self.iloc[ridx, cidx].apply_styles(styles)
return self
def plot_confusion_matrix(conf_matrix, cm_labels):
startcolor = "#cccccc"
midcolor = "#08519c"
endcolor = "#08306b"
b_g2 = LinearSegmentedColormap.from_list("B_G2", [startcolor, midcolor, endcolor])
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(conf_matrix, cmap=b_g2)
fig.colorbar(cax)
plt.title("Neural Net Confusion Matrix \n", fontsize=16)
ax.set_xticklabels([""] + cm_labels, fontsize=13)
ax.set_yticklabels([""] + cm_labels, fontsize=13)
ax.xaxis.set_ticks_position("none")
ax.yaxis.set_ticks_position("none")
spines_to_remove = ["top", "right", "left", "bottom"]
plt.xlabel("Predicted", fontsize=14)
plt.ylabel("Actual", fontsize=14)
# plt.savefig(os.path.join(graph_dir, graph_fn))
plt.show()
def like2d(datx,daty,weights=None,
nbins=15, which=[.68,.95], range=None,
filled=True, color=None, cmap=None, smooth=None,
ax=None,
**kwargs):
from matplotlib.pyplot import gca, get_cmap
from matplotlib.mlab import movavg
from matplotlib.colors import LinearSegmentedColormap
from scipy.ndimage import gaussian_filter
if ax is None: ax = gca()
if weights is None: weights=ones(len(datx))
if color is None: color = kwargs.pop('c') if 'c' in kwargs else 'b'
H,xe,ye = histogram2d(datx,daty,nbins,weights=weights, range=range)
xem, yem = movavg(xe,2), movavg(ye,2)
kwargs = dict(levels=confint2d(H, sorted(which)[::-1]+[0]),**kwargs)
if smooth: H = gaussian_filter(H,smooth)
args = (xem,yem,transpose(H))
if cmap is None:
cmap = {'b':'Blues',
'g':'Greens',
'r':'Reds',
'orange':'Oranges',
'grey':'Greys'}.get(color)
if cmap is None: cmap = LinearSegmentedColormap.from_list(None,['w',color])
else: cmap = get_cmap(cmap)
if filled: ax.contourf(*args,cmap=cmap,**kwargs)
ax.contour(*args,colors=color,**kwargs)
def green_white(levels=10):
""" Generate a colormap from green to white.
"""
colors =[(0., 0.5, 0.),
(1., 1., 1.)]
return LinearSegmentedColormap.from_list(colors=colors, name='green_white', N=levels)
def green_lightblue_blue(levels=10):
""" Generate a colormap from green to light blue then dark blue.
"""
colors =[(0., 1., 0.),
(0., 1., 1.),
(0., 0., 1.)]
return LinearSegmentedColormap.from_list(colors=colors, name='green_lightblue_blue', N=levels)
def plot_confusion_matrix(model_name, conf_matrix, labels, save, cmap, graph_fn='cfm.png'):
startcolor = '#cccccc'
midcolor = '#08519c'
endcolor = '#08306b'
b_g2 = LinearSegmentedColormap.from_list('B_G2', [startcolor, midcolor, endcolor])
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(conf_matrix, cmap=b_g2)
fig.colorbar(cax)
plt.title('Jeeves Confusion Matrix \n', fontsize=16)
ax.set_xticklabels([''] + labels, fontsize=13)
ax.set_yticklabels([''] + labels, fontsize=13)
ax.xaxis.set_ticks_position('none')
ax.yaxis.set_ticks_position('none')
spines_to_remove = ['top', 'right', 'left', 'bottom']
# for spine in spines_to_remove:
# ax.spines[spine].set_visible(False)
plt.xlabel('Predicted', fontsize=14)
plt.ylabel('Actual', fontsize=14)
if save:
plt.savefig(os.path.join(graph_dir, graph_fn))
plt.show()
def heatmap(cea, synchronous=True):
data = cea.grid.get_heat_data()
fig, ax = plt.subplots()
cmap = LinearSegmentedColormap.from_list('my cmap', ['black', 'white'])
heatmap_plot = ax.imshow(data, interpolation='nearest', cmap=cmap, vmin=0, vmax=1.0)
def init():
heatmap_plot.set_data(cea.grid.get_heat_data())
return heatmap_plot
def animate(i):
if i > 2:
cea.iterate_population() if synchronous else cea.iterate_individual()
heatmap_plot.set_data(cea.grid.get_heat_data())
return heatmap
anim = animation.FuncAnimation(fig, animate, init_func=init, frames=150)
plt.axis('off')
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None)
anim.save('gifs/slash_final.gif', writer='imagemagick')
plt.show()
def get_with_white_added(cm_name_default, white_start=0.0, white_end=0.1,
ncolors_out=100):
cmap = cm.get_cmap(cm_name_default)
ncolors = cmap.N
clist = []
lower = []
if white_start > 0:
lower = cmap(np.linspace(0, white_start, int(white_start * ncolors)))
clist.append(lower)
white = np.ones((int((white_end - white_start) * ncolors), 4))
clist.append(white)
upper = []
if white_end < 1:
upper = cmap(np.linspace(white_end, 1, int((1 - white_end) * ncolors)))
clist.append(upper)
colors = np.vstack(tuple([p for p in clist if len(p) > 0]))
return LinearSegmentedColormap.from_list("mycmap", colors, N=ncolors_out)
def swap_colors(json_file_path):
'''
Switches out color ramp in meta.json files.
Uses custom color ramp if provided and valid; otherwise falls back to nextstrain default colors.
N.B.: Modifies json in place and writes to original file path.
'''
j = json.load(open(json_file_path, 'r'))
color_options = j['color_options']
for k,v in color_options.items():
if 'color_map' in v:
categories, colors = zip(*v['color_map'])
## Use custom colors if provided AND present for all categories in the dataset
if custom_colors and all([category in custom_colors for category in categories]):
colors = [ custom_colors[category] for category in categories ]
## Expand the color palette if we have too many categories
elif len(categories) > len(default_colors):
from matplotlib.colors import LinearSegmentedColormap, to_hex
from numpy import linspace
expanded_cmap = LinearSegmentedColormap.from_list('expanded_cmap', default_colors[-1], N=len(categories))
discrete_colors = [expanded_cmap(i) for i in linspace(0,1,len(categories))]
colors = [to_hex(c).upper() for c in discrete_colors]
else: ## Falls back to default nextstrain colors
colors = default_colors[len(categories)] # based on how many categories are present; keeps original ordering
j['color_options'][k]['color_map'] = map(list, zip(categories, colors))
json.dump(j, open(json_file_path, 'w'), indent=1)
[0.9418, 0.93824, 0.40155],
[0.94585, 0.94289, 0.40136],
[0.95, 0.94756, 0.40118],
[0.95426, 0.95224, 0.40103],
[0.9586, 0.95696, 0.4009],
[0.96301, 0.96169, 0.40079],
[0.9675, 0.96644, 0.40069],
[0.97205, 0.97121, 0.4006],
[0.97664, 0.97598, 0.40052],
[0.98129, 0.98078, 0.40045],
[0.98597, 0.98558, 0.40038],
[0.99068, 0.9904, 0.40032],
[0.99542, 0.99522, 0.40026],
[1, 1, 0.4002]]
buda_map = LinearSegmentedColormap.from_list('buda', cm_data)
# For use of "viscm view"
test_cm = buda_map
if __name__ == "__main__":
import matplotlib.pyplot as plt
import numpy as np
try:
from viscm import viscm
viscm(buda_map)
except ImportError:
print("viscm not found, falling back on simple display")
plt.imshow(np.linspace(0, 100, 256)[None, :], aspect='auto',
cmap=buda_map)
plt.show()
def update(self, data):
feat_map = None
if data["ml_frame_data"] is not None:
frame_data = data["ml_frame_data"]
feat_map = frame_data["current_frame"]["feature_map"]
frame_size = frame_data["frame_info"]["frame_size"]
frame_pad = frame_data["frame_info"]["frame_pad"]
frame_complete = frame_data["current_frame"]["frame_complete"]
model_dimension = data["ml_frame_data"]["model_dimension"]
else:
return
sensors = []
if self.sensor_config is not None:
sensors = self.sensor_config.sensor
mode = data["sensor_config"].mode
if self.first:
self.first = False
self.env_plot_max_y = 0
s_buff = frame_size + 2 * frame_pad
self.feat_plot.resetTransform()
if model_dimension > 1:
self.feat_plot.translate(-frame_pad, 0)
self.feat_plot_image.setXRange(-frame_pad, s_buff - frame_pad)
self.border_left.setValue(0)
self.border_right.setValue(frame_size)
self.border_left.show()
self.border_right.show()
nr_sensors = len(sensors)
self.hist_plot_max_y = np.zeros(nr_sensors)
lut = utils.pg_mpl_cmap("viridis")
if mode == Mode.SPARSE:
cmap_cols = [
"steelblue", "lightblue", "#f0f0f0", "moccasin",
"darkorange"
]
cmap = LinearSegmentedColormap.from_list("mycmap", cmap_cols)
cmap._init()
lut = (cmap._lut * 255).view(np.ndarray)
for i in range(4):
if (i + 1) in sensors:
self.hist_plot_images[i].show()
self.set_axis(data, self.hist_plot_images[i])
self.hist_plots[i].setLookupTable(lut)
if (i + 1) == sensors[0]:
self.hist_plot_images[i].setLabel(
"left", "Distance (mm)")
else:
self.hist_plot_images[i].hide()
for idx, sensor in enumerate(sensors):
if mode == Mode.SPARSE:
data_history_adj = data["hist_env"][idx, :, :].T - 2**15
sign = np.sign(data_history_adj)
data_history_adj = np.abs(data_history_adj)
data_history_adj /= data_history_adj.max()
data_history_adj = np.power(data_history_adj,
1 / 2.2) # gamma correction
data_history_adj *= sign
self.hist_plots[sensor - 1].updateImage(data_history_adj,
levels=(-1.05, 1.05))
else:
max_val = np.max(data["env_ampl"][idx])
ymax_level = min(
1.5 * np.max(np.max(data["hist_env"][idx, :, :])),
self.hist_plot_max_y[idx])
if max_val > self.hist_plot_max_y[idx]:
self.hist_plot_max_y[idx] = 1.2 * max_val
self.hist_plots[sensor - 1].updateImage(
data["hist_env"][idx, :, :].T, levels=(0, ymax_level))
if self.show_predictions and data.get("prediction") is not None:
self.predictions_plot_window.show()
prediction_text = "{} ({:.2f}%)".format(
data["prediction"]["prediction"],
data["prediction"]["confidence"] * 100,
)
self.predictions_plot_window.setTitle(prediction_text)
predictions = data["prediction"]["label_predictions"]
pred_num = data["prediction"]["number_labels"]
pred_history = data["prediction_hist"]
if len(self.prediction_plots) < pred_num:
self.generate_predciction_plots(predictions, pred_num)
if pred_history is not None:
for idx in range(pred_num):
self.prediction_plots[idx].setData(pred_history[idx, :])
detected = True
if feat_map is None:
detected = False
if detected and not len(feat_map):
detected = False
if self.print_info_text:
feature_nr = frame_data["current_frame"]["frame_nr"]
self.feature_nr_text.setText("Feature: {}".format(feature_nr))
if not detected:
motion_score = frame_data.pop("motion_score", None)
text = "Waiting..."
if motion_score is not None:
if isinstance(motion_score, float):
motion_score = "{:.1f}".format(motion_score)
text = "Waiting.. (Motion score: {})".format(motion_score)
self.detected_text.setText(text)
return
else:
self.detected_text.setText("Collecting..")
if not frame_complete:
self.border_rolling.show()
self.border_rolling.setValue(
frame_data["current_frame"]["sweep_counter"] - frame_pad)
else:
self.border_rolling.hide()
if feat_map is None:
return
self.feat_plot_image.setYRange(0, feat_map.shape[0])
map_max = 1.2 * np.max(feat_map)
ymax_level = max(map_max, self.env_plot_max_y)
g = 1 / 2.2
feat_map = 254 / (ymax_level + 1.0e-9)**g * feat_map**g
feat_map[feat_map > 254] = 254
self.feat_plot.updateImage(feat_map.T, levels=(0, 256))
if map_max > self.env_plot_max_y:
self.env_plot_max_y = map_max
plottype = "pseudo" # map of pseudo for map or pseudo section
diffyn = "y"
sline = "ns"
# ==============================================================================
# a few constants
# ==============================================================================
refe = 23
# phase tensor map
ptcmapdict = {
"red": ((0.0, 1.0, 1.0), (1.0, 1.0, 1.0)),
"green": ((0.0, 0.0, 1.0), (1.0, 0.0, 1.0)),
"blue": ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
}
ptcmap = LinearSegmentedColormap("ptcmap", ptcmapdict, 256)
# phase tensor map for difference (reverse)
ptcmapdictr = {
"red": ((0.0, 1.0, 1.0), (1.0, 1.0, 1.0)),
"green": ((0.0, 1.0, 0.0), (1.0, 1.0, 0.0)),
"blue": ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
}
ptcmapr = LinearSegmentedColormap("ptcmapr", ptcmapdictr, 256)
# resistivity tensor map for calculating delta
ptcmapdict2 = {
"red": ((0.0, 0.0, 1.0), (1.0, 0.0, 1.0)),
"green": ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
"blue": ((0.0, 1.0, 0.0), (1.0, 1.0, 0.0)),
}
'#ff6555', # red apple
'#66c56c', # moss green
'#f4b247' # mustard yellow
'#d62728', # brick red
'#9467bd', # muted purple
'#8c564b', # chestnut brown
'#e377c2', # raspberry yogurt pink
'#bcbd22', # curry yellow-green
'rgb(247,104,161)', # pink
'rgb(104,171,184)' # teal
]
color_array_solid = color_array[::2]
color_array_shade = color_array[1::2]
cm_confusion = LinearSegmentedColormap.from_list(
name='confusion', colors=[color_array[0], color_array[2]], N=100)
cm_colors = LinearSegmentedColormap.from_list(name='colors',
colors=color_array,
N=len(color_array))
cm_confusion.set_bad((1, 0, 0, 0))
color_bw_signal = tuple(np.array([210, 242, 201]) / 255)
color_bw_noise = tuple(np.array([255, 201, 201]) / 255)
#cmap_list = [(1, 1, 1), color_array[2], color_array[6], color_array[8], color_array[0], color_array[4]] # R -> G -> B
cmap_list = [(1, 1, 1), color_array[6], color_array[4]] # R -> G -> B
cmap_conf = LinearSegmentedColormap.from_list("cmap_conf", cmap_list, N=100)
def show_colors():
fig = plt.figure(figsize=(9, 4))
Chem.Compute2DCoords(mol)
# print index, len(annotateWeights)
# normalize the weights
normweights = [w / maxval for w in weights]
# make a custom red - white - green color map
# slight tint so O and Cl are still visible
cdict = {
'red': ((0.0, 1.0, 1.0), (0.5, 1.0, 1.0), (1.0, 0.2, 0.2)),
'green': ((0.0, 0.2, 0.2), (0.5, 1.0, 1.0), (1.0, 1.0, 1.0)),
'blue': ((0.0, 0.2, 0.2), (0.5, 1.0, 1.0), (1.0, 0.2, 0.2))
}
colors = LinearSegmentedColormap('RWG', cdict)
size = (args.size, args.size) # get errors if not square
# this is an awfully hacky way to standardize the color ranges across
# all the processed molecules. A major issue is that scale and sigma
# are in image coordinates
sigma = 0.05
if len(mols) and mols[0].GetNumBonds() > 0:
mol = mols[0]
rdkit.Chem.Draw.MolToMPL(mol, size=size) # initialize 2D coordinates
plt.clf()
bond = mol.GetBondWithIdx(0)
idx1 = bond.GetBeginAtomIdx()
idx2 = bond.GetEndAtomIdx()
sigma = 0.5 * math.sqrt(
sum([(mol._atomPs[idx1][i] - mol._atomPs[idx2][i])**2
def visualize_ensemble_raster(crop, osc, raster_data, raster_mask, savepath,
save, cmap, colorbar_name, data_type):
# Initialize the map figure using Basemap
m = Basemap(
projection='cyl',
resolution='c',
llcrnrlat=-60,
urcrnrlat=90,
llcrnrlon=-180,
urcrnrlon=180,
)
fig = plt.figure()
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
# Create the colorscale, using RGB information and the function LinearSegmentedColormap
if cmap == 'redblue':
cdict = {
'blue': ((0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.49, 0.8, 0.9),
(0.51, 0.9, 1.0), (0.75, 1.0, 1.0), (1.0, 0.4, 1.0)),
'green': ((0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.49, 0.9, 0.9),
(0.51, 0.9, 0.9), (0.75, 0.0, 0.0), (1.0, 0.0, 0.0)),
'red': ((0.0, 0.0, 0.4), (0.25, 1.0, 1.0), (0.49, 1.0, 0.9),
(0.51, 0.9, 0.8), (0.75, 0.0, 0.0), (1.0, 0.0, 0.0))
}
clim = (-5, 5)
cbar_label = 'Crop yield deviation (%) per unit index change'
cmap = LinearSegmentedColormap('cmap', cdict)
elif cmap == 'whiteblue':
cdict = {
'blue': ((0.0, 0.8, 0.9), (0.01, 0.9, 1.0), (0.5, 1.0, 1.0),
(1.0, 0.4, 1.0)),
'green': ((0.0, 0.9, 0.9), (0.01, 0.9, 0.9), (0.5, 0.0, 0.0),
(1.0, 0.0, 0.0)),
'red': ((0.0, 1.0, 0.9), (0.01, 0.9, 0.8), (0.5, 0.0, 0.0),
(1.0, 0.0, 0.0))
}
clim = (0, 100)
cbar_label = 'Proportion of individual models that agree with the ensemble sensitivity sign'
cmap = LinearSegmentedColormap('cmap', cdict)
# Modify settings for the raster visualization.
raster_data = np.flipud(raster_data)
raster_mask = np.flipud(raster_mask)
mask_index = raster_mask * np.isnan(raster_data)
raster_data[mask_index] = 0
cs = m.imshow(raster_data[60:, :] * 100, clim=clim, cmap=cmap)
m.drawcoastlines(linewidth=0.25)
# m.drawcountries(linewidth=0.25)
m.fillcontinents(color='white', lake_color='white', zorder=0)
m.drawmapboundary(fill_color='White')
# Save the figure.
if save == 1:
os.chdir(savepath)
plt.savefig(crop + '_' + osc + '_' + data_type + '.png',
dpi=300,
bbox_inches='tight')
plt.show(m)
# If colorbar for sensitivity doesn't exist in folder, create it.
if colorbar_name not in os.listdir(savepath):
# add colorbar
plt.figure()
cs = plt.imshow(raster_data[60:, :] * 100, clim=clim, cmap=cmap)
plt.gca().set_visible(False)
cbar = plt.colorbar(cs, extend='both', orientation='horizontal')
cbar.set_label(cbar_label, fontsize=12)
plt.savefig(colorbar_name, dpi=300, bbox_inches='tight')
def visualize(self, title_override=None, show_title=True, show_container_value_and_weight=True, show_outside_value_and_weight=True, show_outside_items=True, color_items_by_profit_ratio=True, show_item_value_and_weight=True, show_value_and_weight_for_container_items=False, show_reference_positions=False, show_bounding_boxes=False, show_value_weight_ratio_bar=True, force_show_color_bar_min_max=False, show_plot=True, save_path=None):
"""Visualize the solution, with placed items in their real position and rotation, and the other ones visible outside the container"""
can_consider_weight = self.problem.container.max_weight != np.inf
# set up the plotting figure
fig_size = (13, 6.75)
dpi = 160
fig = plt.figure(figsize=fig_size, dpi=dpi)
if show_outside_items:
ax1 = fig.add_subplot(1, 2, 1)
ax1.set(aspect="equal")
ax2 = fig.add_subplot(1, 2, 2, sharex=ax1, sharey=ax1)
ax2.set(aspect="equal")
ax2.tick_params(axis="both", which="major", labelsize=11)
else:
ax1 = plt.gca()
ax1.set(aspect="equal")
ax2 = None
ax1.tick_params(axis="both", which="major", labelsize=11)
if show_title:
fig.suptitle(title_override if title_override else "2D Irregular Shape Packing + 0/1 Knapsack Problem")
outside_item_bounds = dict()
total_outside_item_width = 0.
# represent the container
x, y = get_shape_exterior_points(self.problem.container.shape, True)
container_color = (.8, .8, .8)
boundary_color = (0., 0., 0.)
ax1.plot(x, y, color=boundary_color, linewidth=1)
ax1.fill(x, y, color=container_color)
empty_color = (1., 1., 1.)
if type(self.problem.container.shape) == MultiPolygon:
for geom in self.problem.container.shape.geoms:
for hole in geom.interiors:
x, y = get_shape_exterior_points(hole, True)
fill_color = empty_color
boundary_color = (0., 0., 0.)
ax1.plot(x, y, color=boundary_color, linewidth=1)
ax1.fill(x, y, color=fill_color)
font = {'family': 'serif', 'color': 'black', 'weight': 'normal', 'size': 12}
# show the total value and weight in the container, and the maximum acceptable weight (capacity)
if show_container_value_and_weight:
value_weight_string = "V={}".format(self.value if can_consider_weight else int(self.value))
if can_consider_weight:
value_weight_string += ", W={}, Wmax={}".format(self.weight, self.problem.container.max_weight)
ax1.set_title("Items inside the container\n({})".format(value_weight_string), fontsize=13)
# determine the range of item profitability ratio, for later coloring of items
min_profit_ratio = np.inf
max_profit_ratio = -np.inf
item_profit_ratios = dict()
for item_index, item in self.problem.items.items():
if item.weight == 0:
profit_ratio = np.inf
else:
profit_ratio = item.value / item.weight
item_profit_ratios[item_index] = profit_ratio
min_profit_ratio = min(min_profit_ratio, profit_ratio)
max_profit_ratio = max(max_profit_ratio, profit_ratio)
best_profit_color = (1, 0.35, 0)
worst_profit_color = (1, 0.8, 0.8)
color_interp = interpolate.interp1d([min_profit_ratio, max_profit_ratio], [0, 1])
# if possible, add a color-bar showing the value/weight ratio scale
if show_value_weight_ratio_bar:
fig.subplots_adjust(bottom=0.15)
fig.subplots_adjust(wspace=0.11)
bar_x, bar_y, bar_width, bar_height = 0.5, 0.1, 0.3, 0.02
bar_ax = fig.add_axes([bar_x - bar_width * 0.5, bar_y - bar_height * 0.5, bar_width, bar_height])
color_map = LinearSegmentedColormap.from_list(name="profit-colors", colors=[worst_profit_color, best_profit_color])
norm = colors.Normalize(vmin=min_profit_ratio, vmax=max_profit_ratio)
if force_show_color_bar_min_max:
ticks = np.linspace(min_profit_ratio, max_profit_ratio, 7, endpoint=True)
else:
ticks = None
bar = colorbar.ColorbarBase(bar_ax, cmap=color_map, norm=norm, ticks=ticks, orientation='horizontal', ticklocation="bottom")
bar.set_label(label="value/weight ratio", size=13)
bar.ax.tick_params(labelsize=11)
for item_index, item in self.problem.items.items():
# represent the placed items
if item_index in self.placed_items:
if color_items_by_profit_ratio:
fill_color = worst_profit_color + tuple(best_profit_color[i] - worst_profit_color[i] for i in range(len(best_profit_color))) * color_interp(item_profit_ratios[item_index])
else:
fill_color = (1, 0.5, 0.5)
self.show_item(item_index, ax1, boundary_color, fill_color, container_color, show_item_value_and_weight and show_value_and_weight_for_container_items, font, show_bounding_boxes, show_reference_positions)
# determine the boundary rectangle of the outside-of-container items
elif show_outside_items and ax2:
outside_item_bounds[item_index] = get_bounds(self.problem.items[item_index].shape)
total_outside_item_width += abs(outside_item_bounds[item_index][2] - outside_item_bounds[item_index][0])
# show the outside-of-container items
if show_outside_items and ax2:
out_value_sum = 0
out_weight_sum = 0
row_num = max(1, int(np.log10(len(self.problem.items)) * (3 if len(self.problem.items) < 15 else 4)))
row = 0
width = 0
max_width = 0
row_height = 0
height = 0
for item_index, bounds in outside_item_bounds.items():
out_value_sum += self.problem.items[item_index].value
out_weight_sum += self.problem.items[item_index].weight
if color_items_by_profit_ratio:
fill_color = worst_profit_color + tuple(best_profit_color[i] - worst_profit_color[i] for i in range(len(best_profit_color))) * color_interp(item_profit_ratios[item_index])
else:
fill_color = (1, 0.5, 0.5)
min_x, min_y, max_x, max_y = bounds
shape_width = abs(max_x - min_x)
shape_height = abs(max_y - min_y)
shape_center = get_bounding_rectangle_center(self.problem.items[item_index].shape)
position_offset = (width + shape_width * 0.5 - shape_center[0], row_height + shape_height * 0.5 - shape_center[1])
self.show_item(item_index, ax2, boundary_color, fill_color, empty_color, show_item_value_and_weight, font, show_bounding_boxes, show_reference_positions, position_offset)
height = max(height, row_height + shape_height)
width += shape_width
max_width += width
if width >= total_outside_item_width / row_num:
row += 1
width = 0
row_height = height
# show the value and weight outside the container
if show_outside_value_and_weight and ax2:
value_weight_string = "V={}".format(out_value_sum if can_consider_weight else int(out_value_sum))
if can_consider_weight:
value_weight_string += ", W={}".format(out_weight_sum)
ax2.set_title("Items outside the container\n({})".format(value_weight_string), fontsize=13)
fig = plt.gcf()
if show_plot:
plt.show()
if save_path:
fig.savefig(save_path, bbox_inches="tight", dpi=dpi)
plt.close(fig)
import math
from matplotlib import rc
from scipy import signal
from scipy.fftpack import fft
#prec = np.float32
prec = np.float64
cdict1 = {
'red': ((0.0, 0.0, 0.0), (0.5, 0.0, 0.1), (1.0, 1.0, 1.0)),
'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
'blue': ((0.0, 0.0, 1.0), (0.5, 0.1, 0.0), (1.0, 0.0, 0.0))
}
blue_red1 = LinearSegmentedColormap('BlueRed1', cdict1)
def readFromFile(name,
newshape=None,
typ=np.float32,
numberOfItems=-1,
seek_num=-1):
ff = open(name, 'rb')
if seek_num > 0:
ff.seek(seek_num)
data = np.fromfile(
ff, dtype=typ,
count=numberOfItems) # numberOfItems = -1 means all items
#print(name, data.shape, newshape)
ff.close()
def make_dismph_colormap():
"""Make a custom colormap like the one used in dismph.
The list was created from dismphN.mat in geodmod which is a 64 segmented colormap
using the following:
from scipy.io import loadmat
cmap = loadmat('dismphN.mat',struct_as_record=True)['dismphN']
from matplotlib.colors import rgb2hex
list=[]
for i in cmap: list.append(rgb2hex(i))
Source: https://imaging.unavco.org/data/geoslc/geoslc2intf.py
"""
colors = [
"#f579cd",
"#f67fc6",
"#f686bf",
"#f68cb9",
"#f692b3",
"#f698ad",
"#f69ea7",
"#f6a5a1",
"#f6ab9a",
"#f6b194",
"#f6b78e",
"#f6bd88",
"#f6c482",
"#f6ca7b",
"#f6d075",
"#f6d66f",
"#f6dc69",
"#f6e363",
"#efe765",
"#e5eb6b",
"#dbf071",
"#d0f477",
"#c8f67d",
"#c2f684",
"#bbf68a",
"#b5f690",
"#aff696",
"#a9f69c",
"#a3f6a3",
"#9cf6a9",
"#96f6af",
"#90f6b5",
"#8af6bb",
"#84f6c2",
"#7df6c8",
"#77f6ce",
"#71f6d4",
"#6bf6da",
"#65f6e0",
"#5ef6e7",
"#58f0ed",
"#52e8f3",
"#4cdbf9",
"#7bccf6",
"#82c4f6",
"#88bdf6",
"#8eb7f6",
"#94b1f6",
"#9aabf6",
"#a1a5f6",
"#a79ef6",
"#ad98f6",
"#b392f6",
"#b98cf6",
"#bf86f6",
"#c67ff6",
"#cc79f6",
"#d273f6",
"#d86df6",
"#de67f6",
"#e561f6",
"#e967ec",
"#ed6de2",
"#f173d7",
]
dismphCM = LinearSegmentedColormap.from_list("dismph", colors)
dismphCM.set_bad("w", 0.0)
return dismphCM
def show_cut_image(shap_values, img_orig, num_features=1000):
# segment the image so we don't have to explain every pixel
segments_slic = slic(img_orig, n_segments=49, compactness=100, sigma=3)
# define a function that depends on a binary mask representing if an image region is hidden
def mask_image(zs, segmentation, image, background=None):
if background is None:
background = image.mean((0, 1))
out = np.zeros(
(zs.shape[0], image.shape[0], image.shape[1], image.shape[2]))
for i in range(zs.shape[0]):
out[i, :, :, :] = image
for j in range(zs.shape[1]):
if zs[i, j] == 0:
out[i][segmentation == j, :] = background
return out
def f(z):
print(model.predict(mask_image(z, segments_slic, img_orig, 250)))
return model.predict((mask_image(z, segments_slic, img_orig, 250)))
# # use Kernel SHAP to explain the network's predictions
# explainer = shap.KernelExplainer(f, np.zeros((1,50)))
# shap_values = explainer.shap_values(np.ones((1,50)), nsamples=5000) # runs model 1000 times
shap_values = extract_top_ten(shap_values, num_features)
# get the top predictions from the model
preds = model.predict((np.expand_dims(img_orig.copy(), axis=0)))
top_preds = np.argsort(-preds)
# make a color map
from matplotlib.colors import LinearSegmentedColormap
colors = []
for l in np.linspace(1, 0, 100):
colors.append((0.2, 0.2, 0.2, l))
for l in np.linspace(0, 1, 100):
colors.append((0.5, 0.5, 0.5, l))
cm = LinearSegmentedColormap.from_list("shap", colors)
def fill_segmentation(values, segmentation):
out = np.zeros(segmentation.shape)
for i in range(len(values)):
out[segmentation == i] = 0 if values[i] > 0 else 1
return out
# plot our explanations
fig, axes = plt.subplots(nrows=1, ncols=6, figsize=(30, 20))
inds = top_preds[0]
axes[0].imshow(img_orig)
axes[0].axis('off')
max_val = np.max([
np.max(np.abs(shap_values[i][:, :-1])) for i in range(len(shap_values))
])
for i in range(5):
m = fill_segmentation(shap_values[inds[i]][0], segments_slic)
axes[i + 1].set_title(
str(list(test_image_gen.class_indices.keys())[inds[i]]))
axes[i + 1].imshow(img_orig)
im = axes[i + 1].imshow(m, cmap=cm, vmin=-max_val, vmax=max_val)
plt.savefig('foo.png')
axes[i + 1].axis('off')
cb = fig.colorbar(im,
ax=axes.ravel().tolist(),
label="SHAP value",
orientation="horizontal",
aspect=60)
cb.outline.set_visible(False)
model.predict(np.expand_dims(img_orig.copy(), axis=0))
# In[ ]:
plt.imshow(img_orig.copy())
# In[ ]:
# make a color map
from matplotlib.colors import LinearSegmentedColormap
colors = []
for l in np.linspace(1, 0, 100):
colors.append((245 / 255, 39 / 255, 87 / 255, l))
for l in np.linspace(0, 1, 100):
colors.append((24 / 255, 196 / 255, 93 / 255, l))
cm = LinearSegmentedColormap.from_list("shap", colors)
# In[ ]:
def fill_segmentation(values, segmentation):
out = np.zeros(segmentation.shape)
for i in range(len(values)):
out[segmentation == i] = values[i]
return out
# plot our explanations
fig, axes = plt.subplots(nrows=1, ncols=6, figsize=(30, 20))
inds = top_preds[0]
axes[0].imshow(img)
signif = (splusb - b) / (np.sqrt(b) + 1)
imax = np.unravel_index(np.argmax(signif), signif.shape)
cuts = [
ax.edges(overflow='all')[::d][i] for ax, i, d in zip(axes, imax, intdir)
]
print("Best significance: %.4f at BvL %.2f CvL %.2f CvB %.2f" %
((signif[imax], ) + tuple(cuts)))
cut = (xyz[0] < cuts[0]) & (xyz[1] >= cuts[1]) & (xyz[2] >= cuts[2])
figures = []
pdfs = {}
for proc in processes:
array = htagtensor.values()[(proc, )]
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
cmap_blue = LinearSegmentedColormap.from_list(name="transparentblue",
colors=["#0000ff00", "b"])
cmap_red = LinearSegmentedColormap.from_list(name="transparentred",
colors=["#ff000000", "r"])
density = array.flatten()
density /= density.max() # transparency according to full scale
pdfs[proc] = density / density.sum()
colors = cmap_blue(density)
colors[cut] = cmap_red(density[cut])
print("Efficiency for %s: %.3f" %
(proc, density[cut].sum() / density.sum()))
# rendering all 40^3 points makes it a bit slow, cut the mostly transparent ones
rendercut = (density > density.max() / 150.)
# print("Reduced to %.1f%%" % (100.*rendercut.sum()/rendercut.size))
ax.scatter(xyz[0][rendercut],
def main(argv):
""" ********* Main program ********* """
nmeltatoms = 100 #limit of natoms to consider a species being part of the melt
#other dictionnaries and parameters for the figure for article version
letter = ''
statfile2 = ''
plot_parameters = {
"size_fonts": 12,
"size_font_ticks": 10,
"size_figure": (8, 4),
"size_markers": 4,
"size_lines": 1,
"shift_labelpad": 20
}
#plot_parameters = {"size_fonts" : 12,"size_font_ticks":10,"size_figure" : (8,4),"size_markers" : 10,"size_lines" : 2,"shift_labelpad" : 20}
#other parameters
Na = 6.022 * 10**23
try:
options, arg = getopt.getopt(argv, "hf:g:v:m:d:l:", [
"file1", "gfile2", "variable", "mineralfile", "density_max",
"letter"
])
except getopt.GetoptError:
print(
"plot_speciation-r1-species.py -v <variable (rho,T)> -m <mineralfile with elements> -f <stat-concentrate_r1_abso_filename> -g <stat-concentrate_r1_abso_filename2> -d <maximum density to plot in g/cm3> -l <letter for article subplot, default = ''>"
)
sys.exit()
for opt, arg in options:
if opt == '-h':
print('')
print(
'plot_speciation-r1-species.py program to Plot abundance of chemical species for selected cation as a function of rho or T'
)
print(
"plot_speciation-r1-species.py -v <variable (rho,T)> -m <mineralfile with elements> -f <stat-concentrate_r1_abso_filename> -g <stat-concentrate_r1_abso_filename2> -d <maximum density to plot in g/cm3> -l <letter for article subplot, default = ''>"
)
print(
'requires the file containing elements and number (in order to compute the densities)'
)
print('')
sys.exit()
elif opt in ("-f", "--file1"):
statfile1 = str(arg)
elif opt in ("-g", "--gfile2"):
statfile2 = str(arg)
elif opt in ("-v", "--variable"):
variable = str(arg)
elif opt in ("-m", "--mineralfile"):
mineralfile = str(arg)
elif opt in ("-d", "--density_max"):
max_den = float(arg)
elif opt in ("-l", "--letter"):
letter = str(arg)
#***** Calculation of the molecular mass
with open(mineralfile, 'r') as mf:
entry = mf.readline()
elements = entry.split()[1:]
entry = mf.readline()
number = entry.split()[1:]
MN = 0
for i in range(len(elements)):
MN = MN + float(number[i]) * cr.Elements2rest(elements[i])[3]
#***** Creation of the plot
if statfile2 != '':
allstatfiles = [statfile1, statfile2]
with open(statfile1, 'r') as f:
line = f.readline()
file1 = line.split()[1]
with open(statfile2, 'r') as f2:
line = f2.readline()
file2 = line.split()[1]
fig, ax1, ax2 = creation_plot2(variable, file1, file2, MN,
plot_parameters, max_den, letter)
figurename = statfile1.split('/')[-1].split(
'.dat')[0] + '+' + statfile2.split('/')[-1].split(
'.dat')[0] + '_' + variable + '-species'
else:
allstatfiles = [statfile1]
fig, ax1 = creation_plot(variable, plot_parameters, max_den, letter)
figurename = statfile1.split('.dat')[0] + '_' + variable + '-species'
for ii in range(len(allstatfiles)):
statfile = allstatfiles[ii]
#selection of the plot
if ii == 1:
ax = ax2
else:
ax = ax1
#initialisation
xdata = {'T': [], 'rho': []} #dictionnary containing the x data
data = [] #list containing y data
melt = [] #list containing y data for species with 100 atoms or more
selected_files = [
] #list containing the files we use for the plot (depends on the density limit)
species1 = []
list_colored_species = []
list_colored_red = []
list_colored_blue = []
list_colored_purple = []
list_colored_green = []
list_grey_species = []
list_black_species = ["melt-like"]
colors_species = {}
#***** Count of the number of clusters for the selected atom type (needed for the automatic color change)
#first store every cluster type into the dictionary
if re.search("L208", statfile):
#print("we group all the species of more than nmeltatoms atoms under the denomination 'melt-like'")
with open(statfile, 'r') as f:
line = f.readline()
while True:
line = f.readline()
if not line: break
else:
entry = line.split('\n')[0].split('\t')
if len(entry) > 1:
natoms = count_natom(entry[0])
if natoms < nmeltatoms:
species1.append(entry[0])
colors_species[entry[0]] = []
species1.append("melt-like")
colors_species["melt-like"] = []
else:
#print("we use the standard script")
with open(statfile, 'r') as f:
line = f.readline()
while True:
line = f.readline()
if not line: break
else:
entry = line.split('\n')[0].split('\t')
if len(entry) > 1:
species1.append(entry[0])
colors_species[entry[0]] = []
#*****************************
#*******************
#*******
#Read and compute percentages
#in case of speciation r1 L208, we group all the species of more than 100 atoms under the denomination "melt-like"
with open(statfile, 'r') as f:
line = f.readline()
entry = line.split()
files = entry[1:]
#creation of the x data list
for file in files:
temperature, acell = split_name(file)
density = MN / (Na * float(acell)**3 * 10**(-24))
if density <= max_den:
xdata['rho'].append(density) #calculation density
xdata['T'].append(int(temperature))
selected_files.append(file)
if re.search("L208", statfile):
print("we group all the species of more than", nmeltatoms,
"atoms under the denomination 'melt-like'")
#creation of the y data matrix
while True:
line = f.readline()
if not line: break
else:
entry = line.split('\n')[0].split('\t')[:-1]
linedata = [] #we initialize the list of data per line
if len(entry) > 1:
for i in range(1, len(entry)):
if files[
i -
1] in selected_files: #if the column which corresponding file is in the selected files, then we use the data
if entry[i] == '':
entry[i] = 0
else:
entry[i] = float(entry[i])
linedata.append(
entry[i]
) #we create a list of the data for this line (cluster)
natoms = count_natom(entry[0])
if natoms < nmeltatoms:
data.append(
linedata[:]
) #we add this list to the big list of data in order to have nested lists
else:
melt.append(linedata[:])
print('for files', selected_files)
print('all species are', species1, len(species1))
print('and density', xdata['rho'])
#calculation of the percentages per density
totalsmelt = np.ndarray.tolist(np.sum(
melt, 0)) #we sum all the melt species together
data.append(
totalsmelt[:]) #and we add this total to the data matrix
print('initial data of len', np.size(data, 0),
np.size(data, 1))
totals = np.sum(data, 0)
#print('totals', totals)
for i in range(np.size(data, 0)):
for j in range(np.size(data, 1)):
if totals[j] == 0:
data[i][j] = 0
else:
data[i][j] = data[i][j] / totals[j]
#print('calculated percentages',data)
newtotals = np.sum(data, 0)
print('total should be 1', newtotals)
else:
print("we use the standard script")
#creation of the y data matrix
while True:
line = f.readline()
if not line: break
else:
entry = line.split('\n')[0].split('\t')[:-1]
linedata = [] #we initialize the list of data per line
if len(entry) > 1:
for i in range(1, len(entry)):
if files[
i -
1] in selected_files: #if the column which corresponding file is in the selected files, then we use the data
if entry[i] == '':
entry[i] = 0
else:
entry[i] = float(entry[i])
linedata.append(
entry[i]
) #we create a list of the data for this line (cluster)
data.append(
linedata[:]
) #we add this list to the big list of data in order to have nested lists
print('for files', selected_files)
print('all species are', species1)
#print('initial data',data)
#print('and density', xdata['rho'])
#calculation of the percentages per density
totals = np.sum(data, 0)
#print('totals', totals)
for i in range(np.size(data, 0)):
for j in range(np.size(data, 1)):
if totals[j] == 0:
data[i][j] = 0
else:
data[i][j] = data[i][j] / totals[j]
#print('calculated percentages',data)
newtotals = np.sum(data, 0)
print('total should be 1', newtotals)
#*****************************
#*******************
#*******
# #now the dictionary has every possible cluster, we attribute the colors to each cluster
# list_species = []
# color = iter(plt.cm.jet(np.linspace(0,1,len(colors_species)))) #Creation of the color list
# for key in natsort.natsorted(colors_species):
# c = next(color)
# colors_species[key] = c
# list_species.append(key)
# print(list_species, len(list_species))
#*** check the abundance to put in grey the species less abundant than 1% and put a label only for species more abundante than 5% at least one time
for i in range(np.size(data, axis=0)): #loop on each cluster
if max(data[i]) < 0.01:
colors_species[species1[i]] = '0.5'
list_grey_species.append(species1[i])
else:
#this is for basic automatic color change
list_colored_species.append(species1[i])
#this is for custom color change relative to the feldspars
if (species1[i][0] == 'N' or species1[i][0] == 'K'
or species1[i][0] == 'C') and re.search(
'Si_1O', species1[i]):
list_colored_blue.append(species1[i])
elif re.match('Si_1O', species1[i]):
list_colored_red.append(species1[i])
elif (species1[i][0] == 'N' or species1[i][0] == 'K' or
species1[i][0] == 'C') and re.search('O', species1[i]):
list_colored_purple.append(species1[i])
elif species1[i][0:5] == 'Al_1O':
list_colored_green.append(species1[i])
#We add the label
if max(data[i]) > 0.05:
x_max = xdata[variable][data[i].index(max(data[i]))]
y_max = max(data[i])
label = species1[i]
#formatage of label
label = format1label(label)
ax.text(x_max, y_max, label, color='0.35')
print('list red', list_colored_red)
print('list blue', list_colored_blue)
print('list purple', list_colored_purple)
print('list green', list_colored_green)
#**** we attribute the colors to each cluster with abundance > 0.01
#this is for basic automatic color change
#color = iter(plt.cm.jet(np.linspace(0,1,len(list_colored_species)))) #Creation of the color list
#for key in natsort.natsorted(list_colored_species):
# c = next(color)
# colors_species[key] = c
#and this is for custom color change relative to the feldspars
dict_r = {
'red': (
(
0.0, 1.0, 1.0
), # <- at 0.0 (first value), the red component is 1 (second value) (the third value may be alpha)
(1.0, 0.3, 1.0)), # <- at 1.0, the red component is 0.3
'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))
}
cmreds = LinearSegmentedColormap('reds', dict_r)
color_r = iter(cmreds(np.linspace(
0, 1,
len(list_colored_red)))) #Creation of the color list for reds
dict_b = {
'red': ((0.0, 0.0, 0.0), (1.0, 0.4, 1.0)),
'green': ((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)),
'blue': (
(
0.0, 1.0, 1.0
), # <- at 0.0 (first value), the blue component is 1 (second value) (the third value may be alpha)
(1.0, 1.0, 1.0)) # <- at 1.0, the blue component is 0.3
}
cmblues = LinearSegmentedColormap('blues', dict_b)
color_b = iter(cmblues(np.linspace(
0, 1,
len(list_colored_blue)))) #Creation of the color list for blues
dict_p = {
'red': (
(
0.0, 0.6, 1.0
), # <- at 0.0 (first value), the red component is 0.6 (second value) (the third value may be alpha)
(1.0, 0.3, 1.0)), # <- at 1.0, the red component is 0.3
'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
'blue': (
(
0.0, 0.6, 1.0
), # <- at 0.0 (first value), the blue component is 0.6 (second value) (the third value may be alpha)
(1.0, 0.3, 1.0)) # <- at 1.0, the blue component is 0.3
}
cmpurples = LinearSegmentedColormap('purples', dict_p)
color_p = iter(cmpurples(np.linspace(0, 1, len(
list_colored_purple)))) #Creation of the color list for purples
dict_g = {
'red': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
'green': (
(
0.0, 1.0, 1.0
), # <- at 0.0 (first value), the green component is 0.7 (second value) (the third value may be alpha)
(1.0, 0.3, 1.0)), # <- at 1.0, the green component is 0.3
'blue': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0))
}
cmgreens = LinearSegmentedColormap('greens', dict_g)
color_g = iter(cmgreens(np.linspace(
0, 1,
len(list_colored_green)))) #Creation of the color list for greens
for key in natsort.natsorted(list_colored_species):
if key == 'O_1':
colors_species[key] = 'gold'
elif key == 'O_2':
colors_species[key] = 'darkorange'
elif key == 'O_3':
colors_species[key] = 'tomato'
elif key == 'Na_1' or key == 'K_1' or key == 'Ca_1':
colors_species[key] = (0.5, 0, 1.0)
elif key == "melt-like":
colors_species[key] = '0'
else:
colors_species[key] = '0.5'
colors_species = color_change(color_r, list_colored_red,
colors_species)
colors_species = color_change(color_b, list_colored_blue,
colors_species)
colors_species = color_change(color_p, list_colored_purple,
colors_species)
colors_species = color_change(color_g, list_colored_green,
colors_species)
#*****************************
#*******************
#*******
#***plot for each cluster and write file with percentages
newfilename = statfile.split(
'.dat')[0] + '_' + variable + '-species' + '.txt'
nf = open(newfilename, 'w')
if variable == 'rho':
nf.write('Density(g/cm3)\t' + '\t'.join(
str(round(density, 2)) for density in xdata[variable]) + '\n')
else:
nf.write('Temperature(K)\t' +
'\t'.join(str(temp) for temp in xdata[variable]) + '\n')
#plot stacked area
# plt.stackplot(xdata[variable],data)
#plot lines
if re.search("L208", statfile):
#print("we group all the species of more than nmeltatoms atoms under the denomination 'melt-like'")
i = -1
with open(statfile, 'r') as f:
line = f.readline()
while True:
line = f.readline()
if not line: break
else:
entry = line.split('\n')[0].split('\t')[:-1]
if len(entry) > 1:
natoms = count_natom(entry[0])
if natoms < nmeltatoms:
i += 1
x, y = zip(
*sorted(zip(xdata[variable], data[i])))
if entry[
0] in list_colored_species: #we plot only the colored lines. delete this line to plot also the grey species
line, = ax.plot(
x,
y,
'.--',
color=colors_species[entry[0]],
markersize=plot_parameters[
"size_markers"],
linewidth=plot_parameters["size_lines"]
)
nf.write(
format1label(entry[0]) + '\t' + '\t'.join(
str(round(perc, 4))
for perc in data[i]) + '\n')
#we plot the last line, for the melt-like
i += 1
x, y = zip(*sorted(zip(xdata[variable], data[i])))
line, = ax.plot(x,
y,
'.--',
color=colors_species['melt-like'],
markersize=plot_parameters["size_markers"],
linewidth=plot_parameters["size_lines"])
nf.write(
format1label('melt-like') + '\t' +
'\t'.join(str(round(perc, 4)) for perc in data[i]) + '\n')
else:
i = -1
with open(statfile, 'r') as f:
line = f.readline()
while True:
line = f.readline()
if not line: break
else:
entry = line.split('\n')[0].split('\t')[:-1]
if len(entry) > 1:
i += 1
x, y = zip(*sorted(zip(xdata[variable], data[i])))
if entry[
0] in list_colored_species: #we plot only the colored lines. delete this line to plot also the grey species
line, = ax.plot(
x,
y,
'.--',
color=colors_species[entry[0]],
markersize=plot_parameters["size_markers"],
linewidth=plot_parameters["size_lines"])
nf.write(
format1label(entry[0]) + '\t' + '\t'.join(
str(round(perc, 4))
for perc in data[i]) + '\n')
# if variable == 'T':
# label_line(ax, line, entry[0], halign='right')
# elif list_species.index(entry[0]) < int(len(list_species)/2):
# label_line(ax, line, entry[0], halign='left')
# else:
# label_line(ax, line, entry[0], halign='right')
# ax.hlines(y=0.05, xmin = 1, xmax=2.1, color = 'r')
# ax.hlines(y=0.01, xmin = 1, xmax=2.1, color = 'm')
#*****************************
#*******************
#*******
#legend
#custom_lines_grey = [Line2D([0],[0],color = colors_species[key], ls = '--', marker = '.', markersize = plot_parameters["size_markers"], linewidth = plot_parameters["size_lines"]) for key in natsort.natsorted(list_grey_species)]
list_grey_species = format_label(natsort.natsorted(list_grey_species))
#legend_grey = plt.legend([line for line in custom_lines_grey],[label for label in list_grey_species],title = '$\\bf{Clusters <1\%}$', bbox_to_anchor=(1.25, 1), loc='upper left', fontsize = plot_parameters["size_fonts"], borderaxespad=0.)
#plt.gca().add_artist(legend_grey)
#plt.setp(legend_grey.get_title(),fontsize= plot_parameters["size_fonts"])
custom_lines = [
Line2D([0], [0],
color=colors_species[key],
ls='--',
marker='.',
markersize=plot_parameters["size_markers"],
linewidth=plot_parameters["size_lines"])
for key in natsort.natsorted(list_colored_species)
]
list_colored_species = format_label(
natsort.natsorted(list_colored_species))
if statfile2 != '':
legend = ax.legend([line for line in custom_lines],
[label for label in list_colored_species],
bbox_to_anchor=(0.5, 0.99),
loc='upper center',
fontsize=plot_parameters["size_font_ticks"],
borderaxespad=0.,
ncol=3)
#if len(list_colored_species) > 16:
# legend = plt.legend([line for line in custom_lines],[label for label in list_colored_species],title = '$\\bf{Species}$', bbox_to_anchor=(1.01, 1), loc='upper left', fontsize = plot_parameters["size_fonts"], borderaxespad=0., ncol = 2)
# legend = plt.legend([line for line in custom_lines],[label for label in list_colored_species],title = '$\\bf{Species}$', bbox_to_anchor=(0.5, 0.99), loc='upper center', fontsize = plot_parameters["size_fonts"], borderaxespad=0.,ncol = 8)
else:
# legend = plt.legend([line for line in custom_lines],[label for label in list_colored_species],title = '$\\bf{Species}$', bbox_to_anchor=(1.01, 1), loc='upper left', fontsize = plot_parameters["size_fonts"], borderaxespad=0.)
legend = ax.legend([line for line in custom_lines],
[label for label in list_colored_species],
title='$\\bf{Species}$',
bbox_to_anchor=(0.5, 0.99),
loc='upper center',
fontsize=plot_parameters["size_fonts"],
borderaxespad=0.,
ncol=8)
plt.setp(legend.get_title(),
fontsize=plot_parameters["size_fonts"])
nf.write('\n')
nf.write('Species<1%\t' +
'\t'.join(str(species)
for species in list_grey_species) + '\n')
print(newfilename, 'is created')
figurename = figurename + '.pdf'
plt.savefig(figurename, bbox_inches='tight', dpi=300)
print(figurename, 'is created')
cluster_img[(ent_dat >= 0) & (ent_dat <= 0.3) & (theta_dat >= -10) &
(theta_dat < 0)] = 6
cluster_img[(ent_dat >= 0) & (ent_dat <= 0.3) & (theta_dat >= 0) &
(theta_dat < 20)] = 9
cluster_img[(ent_dat >= 0) & (ent_dat <= 0.3) & (theta_dat >= 20) &
(theta_dat <= 90)] = 12
cluster_img = cluster_img.astype(np.float32)
cluster_img[np.isnan(theta_dat) == True] = np.nan
mymap = [(1, 0.69, 0.69), (0.97, 0.24, 0.24), (0.77, 0.19, 0.19),
(0.51, 1, 0.84), (0.01, 1, 0.67), (0.50, 0.99, 0.51),
(0.45, 0.89, 0.46), (0.35, 0.69, 0.58), (0.11, 0.44, 0.23),
(0.51, 0.58, 1), (0.2, 0.32, 0.97), (0, 0.15, 0.96)]
mymap = LinearSegmentedColormap.from_list("mymap", mymap, N=12)
num_list = []
low_val = 1
high_val = 12
step = (high_val - low_val) / 24 # total 12 zones
cur_val = low_val + step
num_list.append(cur_val)
for i in np.arange(low_val + 1, high_val + 1):
step1 = 2 * step
cur_val = cur_val + step1
num_list.append(cur_val)
def render_hunting_policy(title, policy):
"""render_hunting_policy
This was pure hell to make. Renders a visual representation of a hunting policy.
Parameters
----------
title : Title of figure
policy :
Returns
-------
"""
env = create_small_hunting_environment()
p_stats, v_stats = get_solver_stats_by_animal(env, policy)
fig, axs = plt.subplots(1, 5, sharey=True, figsize=(8, 10))
cmap = LinearSegmentedColormap.from_list("Custom", ("goldenrod", "purple"),
2)
buffalo = p_stats["buffalo"]
ostrich = p_stats["ostrich"]
lemur = p_stats["lemur"]
rabbit = p_stats["rabbit"]
bird = p_stats["bird"]
cmap = colors.ListedColormap(["goldenrod", "red", "purple"])
bounds = [0, 1, 2]
norm = colors.BoundaryNorm(bounds, cmap.N)
for ax, intmap, name in zip(
axs,
[buffalo, ostrich, lemur, rabbit, bird],
["buffalo", "ostrich", "lemur", "rabbit", "bird"],
):
values = None
if values == None:
ax.imshow(intmap, cmap=cmap, norm=norm)
else:
arr_values = np.array(values).reshape((size, size))
ax.imshow(arr_values, cmap="Blues")
# draw gridlines
rows = 50
cols = 5
ax.grid(which="major",
axis="both",
linestyle="-",
color="k",
linewidth=2)
ax.set_xticks(np.arange(-0.5, cols, 1))
ax.set_yticks(np.arange(-0.5, rows, 1))
ax.set_xticklabels(np.arange(0, cols + 1, 1))
ax.set_yticklabels(np.arange(0, rows + 1, 1))
ax.set_xlabel("Injury")
ax.xaxis.set_tick_params(size=0)
ax.yaxis.set_tick_params(size=0)
for label in ax.xaxis.get_majorticklabels():
label.set_horizontalalignment("left")
for label in ax.yaxis.get_majorticklabels():
label.set_verticalalignment("top")
ax.set_title(name)
axs[0].set_ylabel('Energy')
legend_elements = [
Patch(facecolor="goldenrod", edgecolor="goldenrod", label="HUNT"),
Patch(facecolor="purple", edgecolor="purple", label="WAIT"),
]
axs[2].legend(handles=legend_elements,
loc="center left",
bbox_to_anchor=(-0.06, 1.08))
plt.suptitle(title)
outpath = os.path.join(output_dir, title + ".png")
plt.savefig(outpath)
plt.close()
def create_range_aprs(time):
client = MongoClient(os.environ["MONGODB_CLIENT"])
lat = 29.780880
lon = -95.420410
start, now = helpers.get_time_range(time)
db = client.aprs
df = pd.DataFrame(
list(
db.raw.find({
"script": "entry",
"latitude": {
"$exists": True,
"$ne": None
},
"timestamp_": {
"$gt": start,
"$lte": now
},
}).sort([("timestamp_", -1)])))
df["dist"] = helpers.haversine_np(lon, lat, df["longitude"],
df["latitude"])
df["month"] = df["timestamp_"].apply(
lambda row: str(row.year) + "-" + str(row.month).zfill(2))
df["dist_"] = np.round(df["dist"] * 1) / 1
df = df[df["dist"] <= 250]
c5 = np.array([245 / 256, 200 / 256, 66 / 256, 1])
c4 = np.array([245 / 256, 218 / 256, 66 / 256, 1])
c3 = np.array([188 / 256, 245 / 256, 66 / 256, 1])
c2 = np.array([108 / 256, 201 / 256, 46 / 256, 1])
c1 = np.array([82 / 256, 138 / 256, 45 / 256, 1])
c0 = np.array([24 / 256, 110 / 256, 45 / 256, 1])
total = len(df["month"].unique())
cm = LinearSegmentedColormap.from_list("custom", [c0, c1, c2, c3, c4, c5],
N=total)
data = []
for idx, month in enumerate(df["month"].unique()):
color = rgb2hex(cm(idx / total))
df2 = df[df["month"] == month]
df2 = df2.groupby(by="dist_").count()
data.append(
go.Scatter(
x=df2.index,
y=df2["_id"],
name=month,
line=dict(color=color, width=3, shape="spline", smoothing=0.3),
mode="lines",
), )
layout = go.Layout(
autosize=True,
hoverlabel=dict(font=dict(family="Roboto Mono")),
yaxis=dict(
domain=[0.02, 0.98],
type="log",
title="Frequency",
fixedrange=False,
),
xaxis=dict(
type="log",
title="Distance (mi)",
fixedrange=False,
),
margin=dict(r=50, t=30, b=30, l=60, pad=0),
# showlegend=False,
)
graphJSON = json.dumps(dict(data=data, layout=layout),
cls=plotly.utils.PlotlyJSONEncoder)
client.close()
return graphJSON
def hist2d(x, y, bins=20, range=None, weights=None, levels=None, smooth=None,
ax=None, color=None, plot_datapoints=True, plot_density=True,
plot_contours=True, no_fill_contours=False, fill_contours=False,
contour_kwargs=None, contourf_kwargs=None, data_kwargs=None,
**kwargs):
"""
Plot a 2-D histogram of samples.
Parameters
----------
x : array_like[nsamples,]
The samples.
y : array_like[nsamples,]
The samples.
levels : array_like
The contour levels to draw.
ax : matplotlib.Axes
A axes instance on which to add the 2-D histogram.
plot_datapoints : bool
Draw the individual data points.
plot_density : bool
Draw the density colormap.
plot_contours : bool
Draw the contours.
no_fill_contours : bool
Add no filling at all to the contours (unlike setting
``fill_contours=False``, which still adds a white fill at the densest
points).
fill_contours : bool
Fill the contours.
contour_kwargs : dict
Any additional keyword arguments to pass to the `contour` method.
contourf_kwargs : dict
Any additional keyword arguments to pass to the `contourf` method.
data_kwargs : dict
Any additional keyword arguments to pass to the `plot` method when
adding the individual data points.
"""
if ax is None:
ax = pl.gca()
# Set the default range based on the data range if not provided.
if range is None:
if "extent" in kwargs:
logging.warn("Deprecated keyword argument 'extent'. "
"Use 'range' instead.")
range = kwargs["extent"]
else:
range = [[x.min(), x.max()], [y.min(), y.max()]]
# Set up the default plotting arguments.
if color is None:
color = "k"
# Choose the default "sigma" contour levels.
if levels is None:
levels = 1.0 - np.exp(-0.5 * np.arange(0.5, 2.1, 0.5) ** 2)
# This is the color map for the density plot, over-plotted to indicate the
# density of the points near the center.
density_cmap = LinearSegmentedColormap.from_list(
"density_cmap", [color, (1, 1, 1, 0)])
# This color map is used to hide the points at the high density areas.
white_cmap = LinearSegmentedColormap.from_list(
"white_cmap", [(1, 1, 1), (1, 1, 1)], N=2)
# This "color map" is the list of colors for the contour levels if the
# contours are filled.
rgba_color = colorConverter.to_rgba(color)
contour_cmap = [list(rgba_color) for l in levels] + [rgba_color]
for i, l in enumerate(levels):
contour_cmap[i][-1] *= float(i) / (len(levels)+1)
# We'll make the 2D histogram to directly estimate the density.
try:
H, X, Y = np.histogram2d(x.flatten(), y.flatten(), bins=bins,
range=list(map(np.sort, range)),
weights=weights)
except ValueError:
raise ValueError("It looks like at least one of your sample columns "
"have no dynamic range. You could try using the "
"'range' argument.")
if smooth is not None:
if gaussian_filter is None:
raise ImportError("Please install scipy for smoothing")
H = gaussian_filter(H, smooth)
# Compute the density levels.
Hflat = H.flatten()
inds = np.argsort(Hflat)[::-1]
Hflat = Hflat[inds]
sm = np.cumsum(Hflat)
sm /= sm[-1]
V = np.empty(len(levels))
for i, v0 in enumerate(levels):
try:
V[i] = Hflat[sm <= v0][-1]
except:
V[i] = Hflat[0]
V.sort()
m = np.diff(V) == 0
if np.any(m):
logging.warning("Too few points to create valid contours")
while np.any(m):
V[np.where(m)[0][0]] *= 1.0 - 1e-4
m = np.diff(V) == 0
V.sort()
# Compute the bin centers.
X1, Y1 = 0.5 * (X[1:] + X[:-1]), 0.5 * (Y[1:] + Y[:-1])
# Extend the array for the sake of the contours at the plot edges.
H2 = H.min() + np.zeros((H.shape[0] + 4, H.shape[1] + 4))
H2[2:-2, 2:-2] = H
H2[2:-2, 1] = H[:, 0]
H2[2:-2, -2] = H[:, -1]
H2[1, 2:-2] = H[0]
H2[-2, 2:-2] = H[-1]
H2[1, 1] = H[0, 0]
H2[1, -2] = H[0, -1]
H2[-2, 1] = H[-1, 0]
H2[-2, -2] = H[-1, -1]
X2 = np.concatenate([
X1[0] + np.array([-2, -1]) * np.diff(X1[:2]),
X1,
X1[-1] + np.array([1, 2]) * np.diff(X1[-2:]),
])
Y2 = np.concatenate([
Y1[0] + np.array([-2, -1]) * np.diff(Y1[:2]),
Y1,
Y1[-1] + np.array([1, 2]) * np.diff(Y1[-2:]),
])
if plot_datapoints:
if data_kwargs is None:
data_kwargs = dict()
data_kwargs["color"] = data_kwargs.get("color", color)
data_kwargs["ms"] = data_kwargs.get("ms", 2.0)
data_kwargs["mec"] = data_kwargs.get("mec", "none")
data_kwargs["alpha"] = data_kwargs.get("alpha", 0.1)
ax.plot(x, y, "o", zorder=-1, rasterized=True, **data_kwargs)
# Plot the base fill to hide the densest data points.
if (plot_contours or plot_density) and not no_fill_contours:
ax.contourf(X2, Y2, H2.T, [V.min(), H.max()],
cmap=white_cmap, antialiased=False)
if plot_contours and fill_contours:
if contourf_kwargs is None:
contourf_kwargs = dict()
contourf_kwargs["colors"] = contourf_kwargs.get("colors", contour_cmap)
contourf_kwargs["antialiased"] = contourf_kwargs.get("antialiased",
False)
ax.contourf(X2, Y2, H2.T, np.concatenate([[0], V, [H.max()*(1+1e-4)]]),
**contourf_kwargs)
# Plot the density map. This can't be plotted at the same time as the
# contour fills.
elif plot_density:
ax.pcolor(X, Y, H.max() - H.T, cmap=density_cmap)
# Plot the contour edge colors.
if plot_contours:
if contour_kwargs is None:
contour_kwargs = dict()
contour_kwargs["colors"] = contour_kwargs.get("colors", color)
ax.contour(X2, Y2, H2.T, V, **contour_kwargs)
ax.set_xlim(range[0])
ax.set_ylim(range[1])
# (178, 24, 43, 256),
# ]) / 256)
SEISMIC_WIDE2 = LinearSegmentedColormap.from_list(
"seismic_wider",
[
(0, 0, 0.3, 1),
(0, 0, 0.7, 1),
(0.1, 0.1, 0.9, 1),
(0.3, 0.3, 0.95, 1),
(0.6, 0.6, 1, 1),
(0.85, 0.85, 1, 1),
(0.92, 0.92, 1, 0.99),
(0.98, 0.98, 1, 0.98),
(1, 1, 1, 0.95),
(1, 0.98, 0.98, 0.98),
(1, 0.92, 0.92, 0.99),
(1, 0.85, 0.85, 1),
(1, 0.6, 0.6, 1),
(1, 0.3, 0.3, 1),
(0.9, 0.1, 0.1, 1),
(0.7, 0, 0, 1),
(0.3, 0, 0, 1),
],
N=250,
)
plt.register_cmap("seismic_wider", SEISMIC_WIDE2)
SEISMIC_WIDE_Y = LinearSegmentedColormap.from_list(
"seismic_wide_y",
[
def plot_onestep_1d(
res,
function,
test_box,
x_next,
eta,
rhos,
theta_S,
x0,
y0,
smoothGaussians=True,
plotGradient=False,
):
x_max = test_box[0, 0]
x_min = test_box[1, 0]
X = np.linspace(x_min, x_max, res)
y_func = function(X)
plt.plot(X, y_func, "--k", label="objective function")
y_max = y_func.max() * 1.2
y_min = y_func.min() * 1.2
y_loss = np.zeros(X.shape[0])
y_loss_grad = np.zeros(X.shape[0])
for i in range(X.shape[0]):
y_loss[i] = expectedLoss(X[i].reshape((1, -1)),
eta,
rhos,
theta_S,
x0=x0,
y0=y0).flatten()
y_loss_grad[i] = expectedLossGrad(X[i].reshape((1, -1)),
eta,
rhos,
theta_S,
x0=x0,
y0=y0)
mean, std = get_plotting_mean_std(X.reshape((-1, 1)), rhos, theta_S, x0,
y0)
plt.plot(X, y_loss, color="blue", label="expected loss")
if plotGradient:
plt.plot(X, y_loss_grad, color="green", label="expected loss grad")
plt.plot(X, mean, "r", label="mean")
if smoothGaussians:
y_space = np.linspace(
y_min, y_max, int(X.shape[0] * (y_max - y_min) / (x_max - x_min)))
M = np.flip(-np.abs(y_space[:, None] - mean[None, :]) / std[None, :] +
3,
axis=0)
cm = LinearSegmentedColormap.from_list("myMap", [(1, 1, 1),
(1, 0.5, 0.5)])
plt.imshow(
M,
extent=[x_min, x_max, y_min, y_max],
interpolation="bicubic",
vmin=0,
vmax=3,
cmap=cm,
)
else:
plt.fill_between(X,
mean - std,
mean + std,
alpha=0.1,
color="red",
label="+- 1SD")
plt.scatter(x0, y0, marker="+", color="black", s=300, label="observation")
x_next_loss = expectedLoss(x_next, eta, rhos, theta_S, x0=x0, y0=y0)
plt.scatter(x_next,
x_next_loss,
color="blue",
marker="D",
label="next evaluation")
plt.hlines(
eta,
x_min,
x_max,
linestyles="--",
linewidths=0.8,
color="green",
label=r"$\eta$",
)
plt.ylim(y_min, y_max)
plt.xlim(x_min, x_max)
plt.title("One Step Lookahead: function evaluation #" + str(x0.shape[0]))
plt.grid(True)
plt.legend(loc="best")
plt.show()
def plot_field_panel(
grid,
field,
level,
fmin,
fmax,
lat_index=None,
lon_index=None,
date="",
name_multi="",
shp_name="",
hailpad_pos=None,
zero_height=3.0,
minusforty_height=10.0,
grid_spc=0.25,
cmap=None,
reverse_cmap=False,
norm=None,
xlim=(-48, -46),
ylim=(-24, -22),
save_path="./",
):
"""
Using gridded multidoppler processed data, plot horizontal and vertical
views:
- In a specific height (defined by index)
- In a specific cross-section (defined by lat_index and lon_index)
Parameters
----------
grid: gridded multidoppler processed data
field: field to be plotted
level: level of horizontal plot
fmin, fmax: field min and max values
lat_index: tuple of latitude indexes for cross section
(end, start) in degrees
lon_index: tuple of longitude indexes for cross section
(end, start) in degrees
date: date to be shown on main title
name_multi: acronym with all radar names
shp_name: path of shapefiles
hailpad_pos: tuple of hailpad position
(lon, lat)
zero_height: 0 degrees height
grid_spc: grid spacing for horizontal plot
cmap: define colorbar. None will use Py-ART defauts
reverse_cmap: If cmap is defined and this is True, the colormap will be
reversed
norm: normalization of the colormap
xlim, ylim: plot limits in lon, lat for horizontal view
(min, max) in degrees
save_path: path to save the figures
"""
# Getting lat-lon-z points
lons, lats = grid.get_point_longitude_latitude(level)
xz, z = np.meshgrid(grid.get_point_longitude_latitude()[0], grid.z["data"])
# Opening colortables
if field != "FH":
if cmap:
cpt = loadCPT(cmap)
if reverse_cmap:
cmap = LinearSegmentedColormap("cpt_r", revcmap(cpt))
else:
cmap = LinearSegmentedColormap("cpt", cpt)
# Main figure
display = pyart.graph.GridMapDisplay(grid)
fig = plt.figure(figsize=(10, 3.25), constrained_layout=True)
if field == "FH":
gs = GridSpec(nrows=1, ncols=8, figure=fig)
else:
gs = GridSpec(nrows=1, ncols=7, figure=fig)
# - Horizontal view
print("-- Plotting horizontal view --")
ax1 = fig.add_subplot(gs[0, :3])
display.plot_basemap(
min_lon=xlim[0],
max_lon=xlim[1],
min_lat=ylim[0],
max_lat=ylim[1],
lon_lines=np.arange(xlim[0], xlim[1], grid_spc),
lat_lines=np.arange(ylim[0], ylim[1], grid_spc),
auto_range=False,
)
display.basemap.readshapefile(shp_name, "sao_paulo", color="gray")
# -- Reflectivity (shaded)
display.plot_grid(
field,
level,
vmin=fmin,
vmax=fmax,
cmap=cmap,
colorbar_flag=False,
norm=norm,
)
# -- Hailpad position
display.basemap.plot(
hailpad_pos[0],
hailpad_pos[1],
"kX",
markersize=15,
markerfacecolor="None",
latlon=True,
)
# -- Cross section position
display.basemap.plot(lon_index, lat_index, "k--", latlon=True)
# - Vertical view
print("-- Plotting vertical view --")
ax2 = fig.add_subplot(gs[0, 3:])
# -- Reflectivity (shaded)
display.plot_latlon_slice(
field,
vmin=fmin,
vmax=fmax,
coord1=(lon_index[0], lat_index[0]),
coord2=(lon_index[1], lat_index[1]),
zerodeg_height=zero_height,
minusfortydeg_height=minusforty_height,
zdh_col="k",
cmap=cmap,
dot_pos=hailpad_pos,
colorbar_flag=False,
norm=norm,
)
cb = display.plot_colorbar(
orientation="vertical", label=grid.fields[field]["units"]
)
if field == "FH":
cb = adjust_fhc_colorbar_for_pyart(cb)
# - General aspects
plt.suptitle(
name_multi + " " + date,
weight="bold",
stretch="condensed",
size="x-large",
)
ax1.set_title(
str(level + 1) + " km " + grid.fields[field]["standard_name"].title()
)
ax2.set_title(
"Cross Section " + grid.fields[field]["standard_name"].title()
)
ax2.set_xlabel("")
ax2.set_ylabel("Distance above Ground (km)")
ax2.grid(linestyle="-", linewidth=0.25)
plt.savefig(
save_path
+ name_multi
+ " "
+ grid.fields[field]["standard_name"].title()
+ " "
+ date
+ ".png",
dpi=300,
bbox_inches="tight",
transparent=True,
)
mpl.rc('axes', unicode_minus=False, linewidth=0.8)
mpl.rc('figure.subplot', right=0.97, top=0.97, bottom=0.15, left=0.13)
mpl.rc('axes', titlepad=-10)
mpl.rc('axes', prop_cycle=mpl.cycler(
'color', [
'#0083b8', '#e66400', '#93a661', '#ebc944', '#da1884', '#7e48bd']))
# girl scouts green is 0x00ae58
# #0083b8 = (0.0, 0.51, 0.72)
mpl.rc('figure', max_open_warning=False)
def gen_cdict(red, green, blue, midpoint, frac):
return {'red': [[0.0, 1.0, 1.0],
[midpoint, red, red],
[1.0, red*frac, red*frac]],
'green': [[0.0, 1.0, 1.0],
[midpoint, green, green],
[1.0, green*frac, green*frac]],
'blue': [[0.0, 1.0, 1.0],
[midpoint, blue, blue],
[1.0, blue*frac, blue*frac]]}
blue_cmap = LinearSegmentedColormap(
'pbpl_blue_cmap', segmentdata=gen_cdict(0, 0.51, 0.72, 0.75, 0.3), N=256)
# 'pbpl_blue_cmap', segmentdata=gen_cdict(0, 0.51, 0.72, 0.6, 0.3), N=256)
orange_cmap = LinearSegmentedColormap(
'pbpl_orange_cmap', segmentdata=gen_cdict(0.90, 0.39, 0, 0.75, 0.3), N=256)
BlueOrange_cmap = LinearSegmentedColormap.from_list(
'BlueOrange_colormap', ['#0083b8', '#ffffff', '#e66400'], 256)
def plotter(image,
odor_on,
water_on,
odor_names,
condition_config,
save_path,
name_str=''):
if black:
plt.style.use('dark_background')
frames_per_trial = 75
titles = odor_names
n_plots = int(image.shape[1] / frames_per_trial)
fig = plt.figure(figsize=(3.5, 3))
fig_width = .14 * n_plots
rect = [.1, .1, fig_width, .7]
rect_cb = [fig_width + .1 + .02, 0.1, 0.02, .7]
ax = fig.add_axes(rect)
if black:
from matplotlib.colors import LinearSegmentedColormap
cdict1 = {
'red': ((0.0, 0.0, 0.0), (0.5, 0.0, 0.1), (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.55), (0.5, 0.1, 0.0), (1.0, 0.0, 0.0))
}
cmap = LinearSegmentedColormap('BlueRed1', cdict1)
cmap = LinearSegmentedColormap.from_list("",
["turquoise", "black", "red"])
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.tick_params(axis=u'both', which=u'both', length=0)
else:
cmap = 'bwr'
plt.tick_params(direction='out', length=2, width=.5, grid_alpha=0.5)
plt.imshow(image,
vmin=-condition_config.vlim,
vmax=condition_config.vlim,
cmap=cmap)
plt.axis('tight')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
condition_lines = np.cumsum([frames_per_trial] * n_plots)[:-1]
odor_on_lines_raw = np.arange(odor_on, frames_per_trial * n_plots,
frames_per_trial)
water_on_lines = np.arange(water_on, frames_per_trial * n_plots,
frames_per_trial)
if 'water' in titles:
water_on_lines = water_on_lines[[0, 1, 4]]
# water_on_lines = water_on_lines[[2, 3, 4]]
odor_on_lines = odor_on_lines_raw[:-1]
else:
if condition_config.period == 'pt':
odor_on_lines = odor_on_lines_raw
else:
if condition_config.filter_ix is None:
water_on_lines = water_on_lines[:2]
# water_on_lines = water_on_lines[2:]
else:
water_on_lines = water_on_lines[[0]]
odor_on_lines = odor_on_lines_raw
if not naive:
xticks = np.concatenate(
(odor_on_lines, odor_on_lines + 8, water_on_lines))
xticklabels = ['ON'] * len(odor_on_lines) + ['OFF'] * len(
odor_on_lines) + ['US'] * len(water_on_lines)
else:
xticks = np.concatenate((odor_on_lines, odor_on_lines + 8))
xticklabels = ['ON'] * len(odor_on_lines) + ['OFF'
] * len(odor_on_lines)
plt.xticks(xticks, xticklabels, fontsize=5)
range = image.shape[0]
if range > 100:
interval = 50
else:
interval = 25
plt.yticks(np.arange(0, range, interval))
for line in xticks:
plt.plot([line, line],
plt.ylim(),
'--',
color='grey',
linewidth=.5,
alpha=0.5)
for line in condition_lines:
plt.plot([line, line],
plt.ylim(),
'--',
color='grey',
linewidth=.75,
alpha=1)
for j, x in enumerate(odor_on_lines_raw):
plt.text(x, -1, titles[j].upper())
axcb = fig.add_axes(rect_cb)
cb = plt.colorbar(cax=axcb,
ticks=[-condition_config.vlim, condition_config.vlim])
if black:
cb.outline.set_visible(False)
cb.set_ticks([])
else:
cb.outline.set_linewidth(0.5)
cb.set_label(r'$\Delta$ F/F', fontsize=7, labelpad=-10)
plt.tick_params(axis='both', which='major', labelsize=7)
name_black = '_black' if black else ''
if condition_config.plot_big:
name = 'big_mouse_' + ','.join(
[str(x) for x in condition_config.plot_big_days])
name += '_sorted_to_' + ','.join(
[str(x) for x in condition_config.sort_days])
name += name_black
else:
name = 'mouse_' + str(mouse) + name_str
if not condition_config.independent_sort:
name += '_sorted_to_' + str(condition_config.sort_days)
if condition_config.filter_ix is not None:
name += '_odor_' + str(condition_config.filter_ix)
plt.sca(ax)
# plt.title(name)
plot._easy_save(save_path, name)
mask = data > 999.
data[data > datamax] = datamax
data[data < datamin] = datamin
#Finally, nan out the missing data based on the above "mask test"
data[mask] = np.nan
fig = plt.figure(figsize=(figxsize, figysize))
ax1 = fig.add_axes([0.0, 0.0, 1.0, 1.0], frameon=False, axisbg='#F5F5F5')
# setup basemap.
m = Basemap(projection='cyl',llcrnrlat=-90,urcrnrlat=90,area_thresh=10000,\
llcrnrlon=-180,urcrnrlon=180,resolution='l')
#m.drawlsmask(land_color='#E2E2E2', ocean_color='#E2E2E2', lakes=False)
cdict1 = gmtColormap('./OceanHeatContent.cpt')
cmap_temp = LinearSegmentedColormap('cmap_temp', cdict1)
# Set up grid
x, y = np.meshgrid(lons, lats)
levs = np.arange(101) - 50
m.contourf(x, y, data, levs, cmap=cmap_temp)
#m.fillcontinents(color='#E2E2E2', lake_color='#E2E2E2')
#m.drawcoastlines(color='#787878',linewidth=0.15)
#m.drawcoastlines(color='#E2E2E2',linewidth=0.15)
#m.drawrivers(color='#E2E2E2',linewidth=1)
plt.savefig(outpng,
dpi=figdpi,
orientation='landscape',
bbox_inches='tight',
import numpy as np
import h5py
import imagesize
from PIL import Image as ImagePil
ImagePil.MAX_IMAGE_PIXELS = None
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
from irreg.normalizations import min_max_scaler
cmap_eosin = LinearSegmentedColormap.from_list("mycmap",
["white", "darkviolet"])
cmap_hema = LinearSegmentedColormap.from_list("mycmap", ["white", "navy"])
class Image:
data = None
def __init__(self, data):
self.data = data
@staticmethod
def read(filename):
img = ImagePil.open(filename)
img = np.asarray(img)
return Image(img)
@staticmethod
def main():
""" Main function """
# Initialize and configure tmap
dims = 2048
enc = tm.Minhash(dims)
lf = tm.LSHForest(dims, 128, store=True)
fps = []
# fps_umap = []
for row in DATA:
fps.append(tm.VectorUint(list(row)))
lf.batch_add(enc.batch_from_sparse_binary_array(fps))
lf.index()
x_tmap, y_tmap, s, t, _ = tm.layout_from_lsh_forest(lf, CFG_TMAP)
lf.clear()
# Prepare custom color map
tab10 = plt.get_cmap("tab10").colors
colors_gray = [(0.2, 0.2, 0.2), tab10[0], tab10[1], tab10[2], tab10[3],
tab10[4]]
custom_cm_gray = LinearSegmentedColormap.from_list("custom_cm_gray",
colors_gray,
N=len(colors_gray))
legend_labels = [
(1, "Rudyard Kipling"),
(2, "Herbert George Wells"),
(3, "Charles Darwin"),
(4, "George Bernard Shaw"),
(5, "William Wymark Jacobs"),
(0, "Other"),
]
faerun = Faerun(
clear_color="#111111",
view="front",
coords=False,
alpha_blending=True,
legend_title="",
)
faerun.add_scatter(
"gutenberg",
{
"x": x_tmap,
"y": y_tmap,
"c": LABELS,
"labels": FAERUN_LABELS
},
colormap=custom_cm_gray,
point_scale=4.2,
max_point_size=10,
has_legend=True,
categorical=True,
legend_title="Authors",
legend_labels=legend_labels,
shader="smoothCircle",
selected_labels=["Author", "Title"],
)
faerun.add_tree(
"gutenberg_tree",
{
"from": s,
"to": t
},
point_helper="gutenberg",
color="#222222",
)
faerun.plot("gutenberg", template="default")
(0.25, 72./255., 72./255.),
(0.5, 60./255., 60./255.),
(0.75, 111./255., 111./255.),
(1.0, 1.0, 1.0)),
'green': ((0.0, 0.0, 0.0),
(0.25, 0./255., 0./255.),
(0.5, 112./255., 112./255.),
(0.75, 200./255., 200./255.),
(1.0, 1.0, 1.0)),
'blue': ((0.0, 0.0, 0.0),
(0.25, 173./255., 173./255.),
(0.5, 229./255., 229./255.),
(0.75, 204./255., 204./255.),
(1.0, 1.0, 1.0))}
'''
my_cmap = LinearSegmentedColormap('my_colormap', cdict, 256)
######
## Image picture of matS
theFig = plt.figure(figsize=(14, 9))
theImage = plt.imshow(scaledMatS,
aspect='auto',
interpolation='none',
cmap=my_cmap)
theImage.set_clim(0.0, 1.0)
plt.xlabel('Time (tenths of seconds)', fontsize=10)
plt.xticks(fontsize=10)
plt.yticks(range(0, num_normalForms), forte_names, fontsize=10)
### Everything we need for the colorbar
def image_plot_v2(shap_values,
x,
labels=None,
show=True,
width=20,
aspect=0.2,
hspace=0.2,
labelpad=None):
input_image = list()
curr_gray_image = list()
multi_output = True
if type(shap_values) != list:
multi_output = False
shap_values = [shap_values]
# make sure labels
if labels is not None:
assert labels.shape[0] == shap_values[0].shape[
0], "Labels must have same row count as shap_values arrays!"
if multi_output:
assert labels.shape[1] == len(
shap_values
), "Labels must have a column for each output in shap_values!"
else:
assert len(
labels.shape
) == 1, "Labels must be a vector for single output shap_values."
label_kwargs = {} if labelpad is None else {'pad': labelpad}
# plot our explanations
fig_size = np.array([3 * (len(shap_values) + 1), 2.5 * (x.shape[0] + 1)])
if fig_size[0] > width:
fig_size *= width / fig_size[0]
fig, axes = pl.subplots(nrows=x.shape[0],
ncols=len(shap_values) + 1,
figsize=fig_size)
if len(axes.shape) == 1:
axes = axes.reshape(1, axes.size)
for row in range(x.shape[0]):
x_curr = x[row].copy()
# make sure
if len(x_curr.shape) == 3 and x_curr.shape[2] == 1:
x_curr = x_curr.reshape(x_curr.shape[:2])
if x_curr.max() > 1:
x_curr /= 255.
# get a grayscale version of the image
if len(x_curr.shape) == 3 and x_curr.shape[2] == 3:
x_curr_gray = (0.2989 * x_curr[:, :, 0] +
0.5870 * x_curr[:, :, 1] + 0.1140 * x_curr[:, :, 2]
) # rgb to gray
else:
x_curr_gray = x_curr
axes[row, 0].imshow(x_curr)
axes[row, 0].axis('off')
input_image.append(x_curr)
curr_gray_image.append(x_curr_gray)
if len(shap_values[0][row].shape) == 2:
abs_vals = np.stack(
[np.abs(shap_values[i]) for i in range(len(shap_values))],
0).flatten()
else:
abs_vals = np.stack([
np.abs(shap_values[i].sum(-1)) for i in range(len(shap_values))
], 0).flatten()
max_val = np.nanpercentile(abs_vals, 99.9)
for i in range(len(shap_values)):
if labels is not None:
axes[row, i + 1].set_title(labels[row, i], **label_kwargs)
sv = shap_values[i][row] if len(
shap_values[i][row].shape) == 2 else shap_values[i][row].sum(
-1)
axes[row, i + 1].imshow(x_curr_gray,
cmap=pl.get_cmap('gray'),
alpha=0.15,
extent=(-1, sv.shape[0], sv.shape[1], -1))
colors = []
for l in np.linspace(1, 0, 100):
colors.append((30. / 255, 136. / 255, 229. / 255, l))
for l in np.linspace(0, 1, 100):
colors.append((255. / 255, 13. / 255, 87. / 255, l))
cm = LinearSegmentedColormap.from_list("red_transparent_blue",
colors)
im = axes[row, i + 1].imshow(sv,
cmap=cm,
vmin=-max_val,
vmax=max_val)
axes[row, i + 1].axis('off')
hspace = 0.5
if hspace == 'auto':
fig.tight_layout()
else:
fig.subplots_adjust(hspace=hspace)
cb = fig.colorbar(im,
ax=np.ravel(axes).tolist(),
label="SHAP value",
orientation="horizontal",
aspect=fig_size[0] / aspect)
cb.outline.set_visible(False)
fig.savefig('output.png')
[0.6473, 0.7456, 0.4188], [0.6834190476, 0.7434761905, 0.4044333333],
[0.7184095238, 0.7411333333, 0.3904761905],
[0.7524857143, 0.7384, 0.3768142857], [0.7858428571, 0.7355666667,
0.3632714286], [0.8185047619, 0.7327333333, 0.3497904762],
[0.8506571429, 0.7299, 0.3360285714], [0.8824333333, 0.7274333333, 0.3217],
[0.9139333333, 0.7257857143, 0.3062761905], [0.9449571429, 0.7261142857,
0.2886428571], [0.9738952381, 0.7313952381, 0.266647619],
[0.9937714286, 0.7454571429, 0.240347619], [0.9990428571, 0.7653142857,
0.2164142857], [0.9955333333, 0.7860571429, 0.196652381],
[0.988, 0.8066, 0.1793666667], [0.9788571429, 0.8271428571, 0.1633142857],
[0.9697, 0.8481380952, 0.147452381], [0.9625857143, 0.8705142857, 0.1309],
[0.9588714286, 0.8949, 0.1132428571], [0.9598238095, 0.9218333333,
0.0948380952], [0.9661, 0.9514428571, 0.0755333333],
[0.9763, 0.9831, 0.0538]]
parula_map = LinearSegmentedColormap.from_list('parula', cm_data)
# For use of "viscm view"
test_cm = parula_map
if __name__ == "__main__":
import matplotlib.pyplot as plt
import numpy as np
try:
from viscm import viscm
viscm(parula_map)
except ImportError:
print("viscm not found, falling back on simple display")
plt.imshow(np.linspace(0, 100, 256)[None, :], aspect='auto',
cmap=parula_map)
plt.show()
import matplotlib.cm as cm
from pylab import setp
from osgeo import gdal
from mpl_toolkits.axes_grid1 import make_axes_locatable
import os
# read arguments
arguments = docopt.docopt(__doc__)
infile = arguments["--infile"]
if arguments["--cpt"] is None:
# cmap=cm.jet
try:
from matplotlib.colors import LinearSegmentedColormap
cm_locs = os.environ["PYGDALSAR"] + '/contrib/python/colormaps/'
cmap = LinearSegmentedColormap.from_list(
'roma', np.loadtxt(cm_locs + "roma.txt"))
cmap = cmap.reversed()
except:
cmap = cm.rainbow
else:
cmap = arguments["--cpt"]
if arguments["--format"] == None:
sformat = 'ROI_PAC'
else:
sformat = arguments["--format"]
if arguments["--lectfile"] == None:
lecfile = "lect.in"
else:
lecfile = arguments["--lectfile"]
mainString = mainString.replace(elem, newString)
return mainString
# This for-loop will get tweet from mongo to value(text)
for x in collection.find({}, {"text": 1, "_id": 0}):
tweet = x['text']
text = text + " " + tweet
text = replaceMultiple(text, ['https', 'RT', 'co'], '')
# Generate a word cloud image
# ตัดคำพวก stopword เช่น "the", "a", "an", "or", "not", "in"
stopword = set(STOPWORDS)
# เปิดภาพแล้วเก็บภาพเป็น array
shape = np.array(Image.open('google_mask.png'))
colors = ["#FF0000", "#111111", "#101010", "#121212", "#212121", "#222222"]
cmap = LinearSegmentedColormap.from_list("mycmap", colors)
# Word cloud object สำหรับการสร้างภาพและวาดภาพ โดยมีการกำหนด background_color คือสีพื้นหลังสำหรับรูป WordCloud,
# stopwords คือ คำที่เราต้องการกำจัดออกไป, mask คือลักษณะที่จะวาด WordCloud ลงไป, width กว้าง, height ยาว, เซตของสีที่จะใช้
# generate สร้าง WordCloud จาก text
wordcloud = WordCloud(background_color="white",
stopwords=stopword, mask=shape, width=1987, height=736, colormap=cmap).generate(text)
# แสดงรูปภาพ wordcloud
plt.imshow(wordcloud, interpolation='bilinear')
# ปิดไม่แสดงเส้นแกน x,y
plt.axis("off")
# แสดงหน้าต่างและรูป
plt.show()
