def custom_color(sample_to_label, samples_dendro_leaves, color_scale='Spectral'):
# Sample label fragmentation
sample_to_label = sample_to_label.astype(str).fillna('unkown')
label_leaves = [str(sample_to_label[x]) for x in samples_dendro_leaves]
uni_labels = list(np.unique(sample_to_label))
uni_len = len(uni_labels)
uni_range = range(uni_len)
uni_normal = [x/uni_range[-1] for x in uni_range]
val_label = pd.Series(uni_range, index=uni_labels)
val_set = [val_label[x] for x in label_leaves]
colors = cl.scales[str(min(max(uni_len, 3), 11))]['div']['Spectral']
if uni_len > len(colors):
if uni_len > 20:
colors = cl.to_rgb(cl.interp(colors, 20))
for i in range(uni_len - 20):
i = i % 20
colors.append(colors[i])
else:
colors = cl.to_rgb(cl.interp(colors, uni_len))
colors_legend = [tuple(map(lambda x:x/255, x)) for x in cl.to_numeric(colors)]
c_map_legend = list(zip(uni_range, colors_legend))
c_map = list(zip(uni_normal, colors))
return c_map, c_map_legend, val_set, val_label
def pie_chart_product(data):
'''
pie chart for products
'''
pie_chart = result_df.groupby(['Product_name',
'Brand_name']).agg({'fileIndex': 'count'})
pie_chart.reset_index(inplace=True)
pie_chart.sort_values(by='fileIndex', inplace=True, ascending=False)
pie_chart = pie_chart.iloc[:20]
bupu = cl.scales['9']['seq']['BuPu']
data_g = []
tr_p = go.Pie(labels=pie_chart['Product_name'],
values=pie_chart['fileIndex'],
text=pie_chart['Brand_name'],
hoverinfo='text+label+value+percent',
textinfo='label+percent',
textfont=dict(size=13),
marker=dict(colors=cl.interp(bupu, 20),
line=dict(color='#000000', width=1)))
data_g.append(tr_p)
layout = go.Layout(title="Top20 most popular products",
titlefont=dict(size=35))
fig = go.Figure(data=data_g, layout=layout)
plotly.offline.plot(fig, filename='products.html')
def generate_colors_palette(data, isDict=True, forceString=False):
'''
This function builds a dict containing color for each element in data.
Parameters
- data: Container of objects containing name of objects which need specific color
- isDict: Boolean which indicates if data is a Dict (if True, keys will be used / by default, True)
- forceString: Boolean which indicates if key of colors dictionary must be converted to string (by default, False)
Return
- colors: Dict containing color for each object (key: name of object, value: color (string))
'''
palette = None
if len(data) <=8:
palette = cl.scales['8']['qual']['Paired']
else:
size = len(data)
# Bug in colorlover (see issues on GitHub page of project)
# We artificially increase size until no exception is thrown (i.e. mapping has been successfully created)
while not palette:
try:
palette = cl.interp(cl.scales['11']['div']['Spectral'], size)
except:
size += 1
colors = {(name if not forceString else str(name)): palette[index] for index, name in enumerate(data.keys() if isDict else data)}
return colors
def __init__(self, time_by_forces: ndarray, step_size: float):
forces_by_time = np.array(time_by_forces).T
motor_unit_count, steps = forces_by_time.shape
sim_duration = steps * step_size
times = np.arange(0.0, sim_duration, step_size)
# Setting colors for plot.
potvin_scheme = [
'rgb(115, 0, 0)', 'rgb(252, 33, 23)', 'rgb(230, 185, 43)',
'rgb(107, 211, 100)', 'rgb(52, 211, 240)', 'rgb(36, 81, 252)',
'rgb(0, 6, 130)'
]
# It's hacky but also sorta cool.
c = cl.to_rgb(cl.interp(potvin_scheme, motor_unit_count))
c = [val.replace('rgb', 'rgba') for val in c]
c = [val.replace(')', ',{})') for val in c]
# Assing non-public attributes
self._step_size = step_size
self._forces_by_time = forces_by_time
self._c = c
self._times = times
# Assign public attributes
self.motor_unit_count = motor_unit_count
def get_singlecell_colors(cell_list, palette="paired", return_str=False):
u_cells = list(set(cell_list))
color_list = cl.to_rgb(cl.interp(my_palette_dict[palette], len(u_cells)))
if not return_str:
color_list = [rgb_to_list(i) for i in color_list]
group_colors = dict(zip(u_cells, color_list))
return group_colors
def create_topic_description_table(topic_df):
"""Create the topic descriptions table."""
bupu = cl.scales['9']['div']['RdYlGn']
colors = cl.interp(bupu, 16) # Map color scale to 16 bins
# cl.to_html(colors) # html for the colorscale
trace0 = go.Table(
columnorder=[1, 2],
columnwidth=[80, 300],
header=dict(values=["<b>TOPIC NUMBER</b>", "<b>TOPIC DESCRIPTION</b>"],
line=dict(color='white'),
fill=dict(color='white'),
align=['center'],
font=dict(color='black', size=14),
height=80),
cells=dict(
values=[topic_df.dominant_topic_num, topic_df.topic_description],
line=dict(color=[
np.array(colors)[topic_df.topic_size],
np.array(colors)[topic_df.topic_size]
]),
fill=dict(color=[
np.array(colors)[topic_df.topic_size],
np.array(colors)[topic_df.topic_size]
]),
align=['center', 'left'],
font=dict(color='black', size=12)))
data = [trace0]
plotly.offline.plot(data,
filename='templates/topic_descriptions.html',
auto_open=False)
def generate_cluster_colors(num):
"""Generate a list of colors given number needed.
Arguments:
num (int): Number of colors needed. n <= 35.
Returns:
list: strings containing RGB-style strings e.g. rgb(255,255,255).
"""
# Selects a random colorscale (RGB) depending on number of colors needed
if num < 12:
c = cl.scales[str(num)]['qual']
c = c[random.choice(list(c))]
else:
num_rounded = int(math.ceil(num / 10)) * 10
c = cl.to_rgb(cl.interp(cl.scales['12']['qual']['Paired'],
num_rounded))
c = cl.to_numeric(sample(c, int(num)))
# Converts selected colorscale to HSL, darkens the color if it is too light,
# convert it to rgb string and return
c_rgb = []
for color in c:
hls = colorsys.rgb_to_hls(color[0] / 255, color[1] / 255,
color[2] / 255)
if hls[1] < 0.6: # Darkens the color if it is too light (HLS = [0]Hue [1]Lightness [2]Saturation)
rgb = colorsys.hls_to_rgb(hls[0], 0.6, hls[2])
else:
rgb = colorsys.hls_to_rgb(hls[0], hls[1], hls[2])
rgb_str = "rgb(" + str(rgb[0] * 255) + "," + str(
rgb[1] * 255) + "," + str(rgb[2] * 255) + ")"
c_rgb.append(rgb_str)
return c_rgb
def get_palette(aeb_count):
'''Get the suitable palette to plot for some number of aeb graphs, where each aeb is a color.'''
if aeb_count <= 8:
palette = cl.scales[str(max(3, aeb_count))]['qual']['Set2']
else:
palette = cl.interp(cl.scales['8']['qual']['Set2'], aeb_count)
return palette
def create_k_clusters(k, X, text=''):
"""
Creates a list of scatter objects for clustering visualization
Parameters:
----------------
k: int
Number of clusters to fit data to
X: numpy array
n x 2 array with coordinates of each point
text: string or array of strings
Text which will pop up when hovering over data points
Returns:
----------------
data: list of plotly.graph_objs.Scatter objects
Contains Scatter objects for two dimensional plotting
"""
data = []
colors_k_bins = cl.to_rgb(cl.interp(cl.scales['11']['qual']['Paired'], k))
class_labels_k = KMeans(k).fit_predict(X)
for i,j in enumerate(colors_k_bins):
data.append(go.Scatter(x = X[class_labels_k==i,0],
y = X[class_labels_k==i,1],
text = text,
mode = 'markers',
marker=go.scatter.Marker(color=j)
)
)
return data
def get_palette(size):
'''Get the suitable palette of a certain size'''
if size <= 8:
palette = cl.scales[str(max(3, size))]['qual']['Set2']
else:
palette = cl.interp(cl.scales['8']['qual']['Set2'], size)
return palette
def get_plot_colors(max_colors, color_format="pyplot"):
"""Generate colors for plotting."""
colors = cl.scales["11"]["qual"]["Paired"]
if max_colors > len(colors):
colors = cl.to_rgb(cl.interp(colors, max_colors))
if color_format == "pyplot":
return [[j / 255.0 for j in c] for c in cl.to_numeric(colors)]
return colors
def get_plot_colors(max_colors, color_format='pyplot'):
"""Generate colors for plotting."""
colors = cl.scales['11']['qual']['Paired']
if max_colors > len(colors):
colors = cl.to_rgb(cl.interp(colors, max_colors))
if color_format == 'pyplot':
return [[j / 255.0 for j in c] for c in cl.to_numeric(colors)]
return colors
def make_color_list(self, position_data):
### make color list for each clade
clade_list = position_data["clade"].unique()
color_list = cl.scales['11']['div']['Spectral']
color_list = cl.interp(color_list, len(clade_list))
color_list = dict(zip(clade_list, color_list))
return color_list
def init_data_store():
print("INITIALIZING GRAPHS...")
store = {'graphData': {}, 'colorMaps': {}}
store['graphData']['activeRanges'] = {}
store['graphData']['pseudoMsgCount'] = {}
store['graphData']['actualMsgCount'] = {}
store['colorMaps']['colorGrad'] = cl.interp(COLOR_RANGE, COLOR_SCALE)
store['colorMaps']['consumer2color'] = {}
return store
def colorscale(colorPalette, color_step):
color_scale = cl.scales['3']['div'][colorPalette]
color_scale = cl.interp(color_scale, color_step)
# create a list of pairs of (value, color) to map to a colorbar -- value in [0,0.2,0.4,0.6,0.8,1]
colorbar_scale = [[i / 100, color] for i, color in zip(
range(0, 101, 20), color_scale[0::int(len(color_scale) / 5)] +
[color_scale[-1]])]
return color_scale, colorbar_scale
def get_colors(number_of_colors, colors=None, cl_scales=['9', 'qual', 'Set1']):
if colors is None:
color_scale = cl.scales[cl_scales[0]][cl_scales[1]][cl_scales[2]]
if number_of_colors > int(cl_scales[0]):
print('interpolated')
colors = cl.interp(color_scale, 500)
colors = [colors[int(x)] for x in np.arange(0, 500,
int(np.floor(500 / number_of_colors)))]
else:
colors = color_scale
return colors
def __init__(self):
self._min = 0
vals = list(self.all_values())
if len(vals) > 0:
self._max = max(vals) * 2
else:
self._max = 0
self._n = 500
sch = colorlover.scales['9']['seq']['BuPu']
self._scheme = colorlover.interp(sch, 500)
def color_palette(elements, ptype='qual', palette='Paired'):
n_element = len(elements)
if n_element < 3:
colors = cl.scales['3'][ptype][palette][:n_element]
elif n_element <= 11:
cnt = str(n_element)
colors = cl.scales[cnt][ptype][palette]
else:
cnt = '11'
palettes = cl.scales[cnt][ptype][palette]
colors = cl.interp(palettes, n_element)
colors = cl.to_rgb(colors)
return dict(zip(elements, colors))
def drawActionSeqGantt(self):
import plotly.figure_factory as ff
import colorlover as cl
import plotly.graph_objects as go
from plotly.subplots import make_subplots
'''
'''
self.checkActionSeq()
multiPerm = self._seq.convert2MultiPerm(self._robNum)
print(multiPerm)
actionRobLst = [[] for x in range(self._robNum)]
for act in self._seq:
actionRobLst[act.robID].append(act)
df = []
for robID in range(self._robNum):
for ind in range(0, len(actionRobLst[robID]), 2):
dic = dict(Task='rob' + str(robID),
Start=actionRobLst[robID][ind].eventTime,
Finish=actionRobLst[robID][ind + 1].eventTime,
Resource='Task' +
str(actionRobLst[robID][ind].taskID))
df.append(dic)
# if robID > 1:
# break
if self._taskNum <= 10:
colorLst = cl.scales[str(self._taskNum)]['qual']['Paired']
else:
colorLst = cl.scales['10']['qual']['Paired']
colorLst = cl.interp(colorLst, 500)
colorDic = dict()
for taskID in range(self._taskNum):
colorDic['Task' + str(taskID)] = colorLst[taskID]
print(colorDic)
print(df)
# print(actionRobLst)
# exit()
# for act in self._seq:
# pass
# # df.append(dict(Task = ''))
# for robID in range(self._robNum):
# df.append(dict(Task = 'rob'+ str(robID), Start = 1, Finish = 5))
# fig = ff.create_gantt(df, colors=colorDic, index_col= 'Resource', show_colorbar=True, group_tasks=True)
fig = ff.create_gantt(df,
colors=colorLst,
index_col='Resource',
show_colorbar=True,
group_tasks=True)
fig['layout']['xaxis']['type'] = 'linear'
fig['layout']['xaxis']['zeroline'] = True
fig.show()
def id_survey(frequency, intensity, catdict):
"""
Function for plotting predicted lines as stick spectra
on top of a broadband survey spectrum.
Frequency and intensity are 1D arrays of the spectrum
frequency and intensity.
catdict is a dictionary with keys corresponding to
the name of the molecule, and values corresponding
to dataframes of the parsed .cat file.
"""
plots = list()
# Plot out the experiment first
plots.append(
go.Scatter(x=frequency, y=intensity, marker={"color": (0., 0., 0.)}))
# Set the colour palette, and interpolate colours to
# accommodate for the number of cat files
spectral_palette = cl.scales["8"]["div"]["Spectral"]
colors = cl.interp(spectral_palette, len(catdict))
for name, color in zip(catdict, colors):
plots.append(
go.Bar(x=catdict[name]["Frequency"],
y=np.abs(catdict[name]["Intensity"]),
name=name,
width=2.,
marker={"color": color}))
layout = go.Layout(
xaxis={
"title": "Frequency (MHz)",
"range": [np.min(frequency), np.max(frequency)],
"tickformat": "0.2f"
},
yaxis={"title": ""},
autosize=False,
height=800,
width=1000,
paper_bgcolor="#f0f0f0",
plot_bgcolor="#f0f0f0",
)
fig = go.Figure(data=plots, layout=layout)
iplot(fig)
return fig
def color_scale_interp(
input_num,
max_num,
min_num,
color_mesh_size=80,
hex_mode=True,
):
"""
"""
# | - color_scale_interp
# cl.scales["8"]["seq"]["Purples"]
black_white_cs = [
'rgb(0,0,0)',
'rgb(255,255,255)',
]
black_red_cs = [
'rgb(0,0,0)',
'rgb(255,0,0)',
]
color_scale_i = black_red_cs
color_scale_i = cl.scales["8"]["seq"]["Greys"][::-1]
# color_scale_i = cl.scales["8"]["seq"]["Purples"]
# color_scale_i = cl.scales['3']['div']['RdYlBu']
color_scale = cl.interp(
color_scale_i,
color_mesh_size,
)
color_scale = cl.to_rgb(color_scale)
# Converting RGB string representatino to tuple
color_scale = cl.to_numeric(color_scale)
input_norm = ((input_num - min_num) / (max_num - min_num))
cs_index = round(input_norm * len(color_scale)) - 1
if cs_index == -1:
cs_index = 0
color_out = color_scale[cs_index]
if hex_mode:
color_out = rgb_to_hex(color_out)
return (color_out)
def setColorSet(self, dimensions='12', type='qual', dataset='Paired'):
if dimensions in cl.scales:
if type in cl.scales[dimensions]:
if dataset in cl.scales[dimensions][type]:
color_set = cl.scales[dimensions][type][dataset]
self.colorset = (dimensions, type, dataset)
if (len(self.data.components) > len(color_set)):
color_set = cl.interp(color_set,
len(self.data.components))
color_set = cl.to_rgb(color_set)
for i, component in enumerate(self.data.components):
self.data.get_component(component).color = color_set[i]
return True
return False
def cache_raw_data(net_type, N=25, p=0.5, m=3, k=3):
global model, data2, end, colors_c, stocks, initiated, agents
if m >= N:
N = m + 1
agents = fresh_agents if N >= len(fresh_agents) else fresh_agents[0:N]
agents = [deepcopy(x) for x in agents]
model = FinNetwork("Net 1", agents, net_type=net_type, p=p, m=m, k=k)
stocks = [x.name for x in agents]
colors_ = (cl.to_rgb(
cl.interp(cl.scales['6']['qual']['Set1'],
len(stocks) * 20)))
colors_c = np.asarray(colors_)[np.arange(0, len(stocks) * 20, 20)]
end = datetime.date.today()
print('Loaded raw data')
return 'loaded'
def palette_de_couleurs(nb_of_colors):
""" Input: the length of the list with different colors
Output: a list with rgb colors in an ascending order
"""
bupu = cl.scales['9']['seq']['Reds']
bupu500 = cl.interp( bupu, nb_of_colors ) # Map color scale to 500 bins
colors=cl.to_rgb(bupu500)
for i in range(nb_of_colors):
color= colors[i][3:]
c=array((0,0,0))
for j in range(3):
c[j]=color.strip("()").split(",")[j]
colors[i]=c
return colors
def preload_data_store():
store = {'graphData': {}, 'colorMaps': {}}
store['graphData']['activeRanges'] = {'t1': 50, 't2': 25, 't3': 25}
store['graphData']['pseudoMsgCount'] = {'t1': 50, 't2': 20, 't3': 100}
store['graphData']['actualMsgCount'] = {'t1': 50, 't2': 30, 't3': 100}
store['colorMaps']['colorGrad'] = cl.interp(COLOR_RANGE, COLOR_SCALE)
store['colorMaps']['consumer2color'] = {}
# Assign colors
for c in store['graphData']['activeRanges'].keys():
assign_color(consumer=c,
consumer2color=store['colorMaps']['consumer2color'],
color_grad=store['colorMaps']['colorGrad'])
return store
def draw_stack_bar(self, key):
count_matrix = []
data_of_key, labels = self.get_value_by_key(key)
all_uniques_cells = sorted(list(BACKGROUND_COLOR_DICT.keys()))
for i in range(len(data_of_key)):
uniques, counts = np.unique(data_of_key[i], return_counts= True)
temp = []
# sum_counts = np.sum(counts)
# counts = counts/sum_counts
i = 0
print(uniques, all_uniques_cells)
for j in all_uniques_cells:
if i >= len(uniques):
temp.append(0)
elif j == uniques[i]:
temp.append(counts[i])
i += 1
else:
temp.append(0)
count_matrix.append(temp)
np_matrix = np.array(count_matrix)
np_matrix = np_matrix.T
bupu = cl.scales['9']['seq']['YlOrBr']
bupux = cl.interp(bupu, 100)
gap = math.floor(100/len(np_matrix))
stacked_data = []
for i in range(len(np_matrix)):
trace0 = go.Bar(
x = labels,
y = np_matrix[i],
name = all_uniques_cells[i],
marker = dict(
# cmax=len(np_matrix),
# cmin=0,
# colorscale='Viridis',
color = bupux[gap * i]
)
)
stacked_data.append(trace0)
layout = go.Layout(
barmode = 'stack'
)
fig = go.Figure(data=stacked_data, layout=layout)
return py.iplot(fig, filename='stacked-bar')
def make_table_plot(name,set,site_list,loci_dict,filename):
ryg = cl.scales['11']['div']['RdYlGn']
ryg100 = cl.interp(ryg, 100)
table_values = [set]
colors = [['grey' for i in set]]
for sample1 in set:
table_line = []
table_color = []
for sample2 in set:
correct_calls = []
if sample1 == sample2:
cell_percent = 'X'
table_line.append(cell_percent)
cell_color = 'grey'
else:
for locus in site_list:
if loci_dict[sample1][locus]['genotype'] == loci_dict[sample2][locus]['genotype']:
correct_calls.append(1)
else:
correct_calls.append(0)
cell_percent = int((sum(correct_calls)/len(correct_calls))*100)
cell_color = ryg100[cell_percent-1]
table_line.append(str(cell_percent)+'%')
table_color.append(cell_color)
table_values.append(table_line)
colors.append(table_color)
trace = go.Table(
header = dict(
values=['']+set,
line = dict(color = '#506784'),
fill=dict(color='grey'),
font = dict(color = 'white', size = 12)
),
cells = dict(
values=table_values,
line = dict(color = '#506784'),
fill = dict(color = colors),
font=dict(color=['white','lightgrey'], size=12)
)
)
layout = go.Layout(
title='percentage of same calls {}'.format(name),
width=1500,
height=640
)
fig = dict(data=[trace], layout=layout)
py.image.save_as(fig, filename=filename)
def plot_1(n_clicks, n_cols, options):
if (n_clicks is None) or (mint.rt_projections is None):
raise PreventUpdate
files = mint.crosstab.columns
labels = mint.crosstab.index
fig = make_subplots(rows=len(labels) // n_cols + 1,
cols=n_cols,
subplot_titles=labels)
if len(files) < 13:
# largest color set in colorlover is 12
colors = cl.scales['12']['qual']['Paired']
else:
colors = cl.interp(cl.scales['12']['qual']['Paired'], len(files))
for label_i, label in enumerate(labels):
for file_i, file in enumerate(files):
data = mint.rt_projections[label][file]
ndx_r = (label_i // n_cols) + 1
ndx_c = label_i % n_cols + 1
fig.add_trace(
go.Scatter(x=data.index,
y=data.values,
name=basename(file),
mode='lines',
legendgroup=file_i,
showlegend=(label_i == 0),
marker_color=colors[file_i],
text=file),
row=ndx_r,
col=ndx_c,
)
fig.update_xaxes(title_text="Retention Time", row=ndx_r, col=ndx_c)
fig.update_yaxes(title_text="Intensity", row=ndx_r, col=ndx_c)
fig.update_layout(height=200 * len(labels), title_text="Peak Shapes")
fig.update_layout(xaxis={'title': 'test'})
if 'legend_horizontal' in options:
fig.update_layout(legend_orientation="h")
if 'legend' in options:
fig.update_layout(showlegend=True)
return fig
def plot_gaussian():
x = arange(0, 30, .05)
colorscale = cl.scales['9']['seq']['PuBuGn']
scales = cl.interp(colorscale, 30)
traces = []
for i, K in enumerate(arange(1, 11)):
y = norm.pdf(x, scale=K) / norm.pdf(0, scale=K)
traces.append(
dict(
x=x,
y=y,
name=f'{K:d}mm',
marker=dict(color=scales[i * 2 + 5], ),
))
fig = go.Figure(data=traces,
layout=go.Layout(
xaxis=dict(
linecolor='black',
gridcolor='black',
dtick=4,
tickfont=dict(size=8, ),
),
yaxis=dict(
linecolor='black',
gridcolor='black',
tickmode='array',
tickvals=[0, 1],
ticktext=[0, 'MAX'],
tickfont=dict(size=8, ),
),
legend=dict(
title=dict(
text='kernel σ',
font=dict(size=10, ),
),
itemwidth=30,
font=dict(size=8, ),
),
))
return fig
def get_colours(n_classes, rettype='numeric255'):
n_categorical_colours = 11
if n_classes <= n_categorical_colours:
# colours = cl.to_numeric(cl.scales[str(nClasses)]['div']['Spectral'])
colours = to_numeric(cl.scales[str(n_classes)]['div']['Spectral'])
else:
colours = to_numeric(
cl.interp(cl.scales[str(n_categorical_colours)]['div']['Spectral'],
n_classes))
if rettype == 'numeric255':
return colours
if rettype == 'numeric1':
return (np.array(colours) / 255.).tolist()
if rettype == 'hex':
return to_hex(colours)
raise Exception('Unknown type {}'.format(rettype))
def plotPrettyColours(data, grouping):
#make directories for saving plot htmls
os.makedirs(clustering_evaluation_dir, exist_ok=True)
os.makedirs(cluster_analysis_dir, exist_ok=True)
if grouping == 'experiments':
colour_seq = ['Reds','Oranges','YlOrBr','YlGn','Greens','BuGn','Blues','RdPu',
'PuBu','Purples','PuRd','YlGnBu','YlOrRd']
df = pd.DataFrame(data.experiment_name.unique(), columns=['name'])
df['root'] = df.applymap(lambda x: '_'.join(x.split('_',2)[0:2]))
elif grouping == 'elec_bin':
colour_seq = ['YlGn','PuRd','Blues','YlOrBr','Greens','RdPu','Oranges',
'Purples','PuBu','BuGn','Reds']
df = data['elec_bin'].reset_index().rename({'elec_bin':'root', 'k':'name'}, axis=1)
df['root'] = df.root.astype('category')
df.root.cat.rename_categories(colour_seq[:len(df.root.cat.categories)], inplace=True)
col_temp = df.groupby('root').apply(lambda x: len(x))
my_cols = list()
for c, v in col_temp.items():
try:
i = 0
gcol=list()
while i < v:
gcol.append(cl.scales['9']['seq'][c][2+i])
i+=1
except:
i = 0
gcol=list()
jump = int(80/v)
while i < v:
gcol.append(cl.to_rgb(cl.interp(cl.scales['9']['seq'][c], 100))[-1-jump*i])
i+=1
my_cols+=gcol
colours = dict(zip(df.name, my_cols))
return colours
def viewSections(width = 800, height = 400, cs = None, layNb = 2,
linesize = 3, title = 'Cross section'):
"""
Plot multiple cross-sections data on a graph.
Parameters
----------
variable: width
Figure width.
variable: height
Figure height.
variable: cs
Cross-sections dataset.
variable: layNb
Number of layer to plot.
variable: linesize
Requested size for the line.
variable: title
Title of the graph.
"""
colors = cl.scales['9']['div']['RdYlBu']
hist = cl.interp( colors, layNb )
colorrgb = cl.to_rgb( hist )
nlay = layNb - 1
lay = {}
toplay = cs[nlay].top
cs[nlay].ndepo = cs[nlay].depo
cs[nlay].ntop = toplay
botlay = cs[nlay].top - cs[nlay].depo
for i in range(nlay-1,-1,-1):
tmp1 = cs[i+1].ndepo - cs[i].depo
tmp2 = cs[i+1].ndepo - tmp1.clip(min=0)
cs[i].ndepo = tmp2
cs[i].ntop = botlay + tmp2
trace = {}
data = []
for i in range(1,nlay):
trace[i-1] = Scatter(
x=cs[i].dist,
y=cs[i].ntop,
mode='lines',
name="layer "+str(i),
line=dict(
shape='line',
width = linesize-1,
color = colorrgb[i-1] #,
#dash = 'dash'
)
)
data.append(trace[i-1])
# Top line
trace[nlay] = Scatter(
x=cs[nlay].dist,
y=cs[nlay].top,
mode='lines',
name="top",
line=dict(
shape='line',
width = linesize,
color = 'rgb(102, 102, 102)'
)
)
data.append(trace[nlay])
# Bottom line
trace[nlay+1] = Scatter(
x=cs[nlay].dist,
y=cs[nlay].top - cs[nlay].depo,
mode='lines',
name="base",
line=dict(
shape='line',
width = linesize,
color = 'rgb(102, 102, 102)'
)
)
data.append(trace[nlay+1])
layout = dict(
title=title,
width=width,
height=height
)
fig = Figure(data=data, layout=layout)
plotly.offline.iplot(fig)
return
def plot_scatter_comparison(title, x_axis_title, y_axis_title, mat_1, mat_2, plot_out, color_vector=None, qqplot=False):
L = mat_1.shape[0]
upper_triangular_indices = np.triu_indices(L, k=1)
score_1 = mat_1[upper_triangular_indices]
score_2 = mat_2[upper_triangular_indices]
lin_reg_x = list(np.arange(
np.min([np.min(score_1),np.min(score_2)]),
np.max([np.max(score_1),np.max(score_2)]),
0.05))
slope, intercept, rvalue, pvalue, stderr = linregress(score_1, score_2)
lin_reg_y = [intercept + slope * x for x in lin_reg_x]
text = ["i: " + str(i+1) + ", j: " + str(j+1) for i,j in zip(upper_triangular_indices[0], upper_triangular_indices[1])]
if color_vector is not None:
text = [text[ij] + ", sum_nia * sum_njb: " + str(color_vector[ij]) for ij in range(len(text))]
color_scale = cl.interp(cl.scales['3']['seq']['Reds'], 400)
color_vector = [color_scale[i - 1] for i in color_vector]
opacity = 1
else:
color_vector = 'rgb(31,120,180)'
opacity = 1
data=[]
data.append(
go.Scattergl(
x=[np.min([np.min(score_1), np.min(score_2)]), np.min([np.max(score_1), np.max(score_2)])],
y=[np.min([np.min(score_1), np.min(score_2)]), np.min([np.max(score_1), np.max(score_2)])],
mode='lines',
line=dict(color='lightgrey',
width=3,
dash='dash'
),
showlegend=False
)
)
data.append(
go.Scattergl(
x= score_1,
y= score_2,
text = text,
mode = 'markers',
marker=dict(
opacity=opacity,
color=color_vector),
hoverinfo="x+y+text",
showlegend=False
)
)
if qqplot:
index_sorted_i = np.argsort(score_1)
index_sorted_j = np.argsort(score_2)
text_sorted = ["i: " + str(i+1) + ", j: " + str(j+1) for i,j in zip(
upper_triangular_indices[0][index_sorted_i],
upper_triangular_indices[1][index_sorted_j]
)]
data.append(
go.Scattergl(
x=sorted(score_1),
y=sorted(score_2),
text=text_sorted,
mode='markers',
marker=dict(
color="rgb(255,127,0)"),
hoverinfo="x+y+text",
showlegend=False
)
)
data.append(
go.Scattergl(
x=lin_reg_x,
y=lin_reg_y,
mode='lines',
line=dict(color="black",
width=4),#"rgb(166,206,227)"),#"rgb(51,160,44)"),
showlegend=False
)
)
plot = {
"data": data,
"layout" : go.Layout(
annotations=go.Annotations([
go.Annotation(
x=np.percentile(lin_reg_x, 95),
y=np.percentile(lin_reg_y, 95),
showarrow=True,
ax=30,
ay=50,
arrowcolor='black',
arrowside="start",
text='y = {0} + {1}x'.format(np.round(intercept, decimals=3),np.round(slope, decimals=3)),
font=dict(color="black", size=18),
xref='x1',
yref='y1'
)
]),
title = title,
font=dict(size=18),
yaxis1 = dict(
title=y_axis_title,
exponentformat="e",
showexponent='All',
scaleratio=1.0,
scaleanchor='x',
),
xaxis1 = dict(
title=x_axis_title,
exponentformat="e",
showexponent='All',
scaleratio=1.0,
scaleanchor='y'
)
)
}
plotly_plot(plot, filename=plot_out, auto_open=False)
def _interp(colors,N): try: return cl.interp(colors,N) except: return _interp(colors,N+1)
def viewSection(width = 800, height = 400, cs = None, dnlay = None,
rangeX = None, rangeY = None, linesize = 3, title = 'Cross section'):
"""
Plot multiple cross-sections data on a graph.
Parameters
----------
variable: width
Figure width.
variable: height
Figure height.
variable: cs
Cross-sections dataset.
variable: dnlay
Layer step to plot the cross-section.
variable: rangeX, rangeY
Extent of the cross section plot.
variable: linesize
Requested size for the line.
variable: title
Title of the graph.
"""
nlay = len(cs.secDep)
colors = cl.scales['9']['div']['BrBG']
hist = cl.interp( colors, nlay )
colorrgb = cl.to_rgb( hist )
trace = {}
data = []
trace[0] = Scatter(
x=cs.dist,
y=cs.secDep[0],
mode='lines',
line=dict(
shape='line',
width = linesize+2,
color = 'rgb(0, 0, 0)'
)
)
data.append(trace[0])
for i in range(1,nlay-1,dnlay):
trace[i] = Scatter(
x=cs.dist,
y=cs.secDep[i],
mode='lines',
line=dict(
shape='line',
width = linesize,
color = 'rgb(0,0,0)'
),
opacity=0.5,
fill='tonexty',
fillcolor=colorrgb[i]
)
data.append(trace[i])
trace[nlay-1] = Scatter(
x=cs.dist,
y=cs.secDep[nlay-1],
mode='lines',
line=dict(
shape='line',
width = linesize+2,
color = 'rgb(0, 0, 0)'
),
fill='tonexty',
fillcolor=colorrgb[nlay-1]
)
data.append(trace[nlay-1])
trace[nlay] = Scatter(
x=cs.dist,
y=cs.secDep[0],
mode='lines',
line=dict(
shape='line',
width = linesize+2,
color = 'rgb(0, 0, 0)'
)
)
data.append(trace[nlay])
if rangeX is not None and rangeY is not None:
layout = dict(
title=title,
font=dict(size=10),
width=width,
height=height,
showlegend = False,
xaxis=dict(title='distance [m]',
range=rangeX,
ticks='outside',
zeroline=False,
showline=True,
mirror='ticks'),
yaxis=dict(title='elevation [m]',
range=rangeY,
ticks='outside',
zeroline=False,
showline=True,
mirror='ticks')
)
else:
layout = dict(
title=title,
font=dict(size=10),
width=width,
height=height
)
fig = Figure(data=data, layout=layout)
plotly.offline.iplot(fig)
return
