def set_color_range(self, color1, color2):
hsl_cs = colour.color_scale(color1.get_hsl(), color2.get_hsl(), 100)
rgb_cs = [colour.hsl2rgb(a) for a in hsl_cs]
self.scaled_cs = []
for a in rgb_cs:
self.scaled_cs.append(
(round(a[0] * 255), round(a[1] * 255), round(a[2] * 255)))
def dominant_color(image):
hsl_cat = np.zeros((6, 5, 5))
image = (prepare_image(image).astype('uint8'))
red = 0
blue = 0
for i in range(image.shape[0]):
pix_hsl = rgb2hsl(image[i])
if image[i][0] > image[i][2]:
red += 1
else:
blue += 1
#print(image[i],pix_hsl)
for i in range(1, 6):
if pix_hsl[0] >= hue[i][0] and pix_hsl[0] < hue[i][1]:
pix_h = i
if pix_hsl[0] >= 330 or pix_hsl[0] < 30:
pix_h = 0
for i in range(5):
if pix_hsl[1] >= satuation[i][0] and pix_hsl[1] < satuation[i][1]:
pix_s = i
if pix_hsl[2] >= lightness[i][0] and pix_hsl[2] < lightness[i][1]:
pix_l = i
hsl_cat[pix_h, pix_s, pix_l] += 1
#print([pix_h,pix_s,pix_l])
color_cat_flat = hsl_cat.reshape(150)
frequency = {}
for i in range(150):
frequency[i] = color_cat_flat[i]
color_count = np.arange(150)
for i in range(150):
color_count[i] = frequency[i]
color_order = np.argsort(color_count)[::-1]
color_rank_rgb = []
for i in color_order:
i1, i2, i3 = oneD_to_3D_index(i)
color_hsl = np.asarray([
hue_value[i1] / 360., satuation_value[i2] / 100.,
lightness_value[i3] / 100.
])
color_rgb = np.asarray(hsl2rgb(color_hsl))
color_rank_rgb.append(color_rgb)
return color_order, color_rank_rgb, color_count
def render(hsl0, hsl1, trans01, trans10):
"""take params and return array of rendered frames to loop"""
# TODO: decide if want to actually use hsl
hsl0 = hsl0.unsqueeze(0)
hsl1 = hsl1.unsqueeze(0)
_, w_hsl0_01 = laggy_logistic_fn(trans01[0], trans01[1], trans01[2])
w_hsl0_01 = w_hsl0_01.unsqueeze(-1)
hsl_01 = (w_hsl0_01 * hsl0) + ((1. - w_hsl0_01) * hsl1)
_, w_hsl0_10 = laggy_logistic_fn(trans10[0], trans10[1], trans10[2])
w_hsl0_10 = w_hsl0_10.unsqueeze(-1)
hsl_10 = (w_hsl0_10 * hsl1) + ((1. - w_hsl0_10) * hsl0)
frames = torch.cat([hsl_01, hsl_10]).data.numpy()
rgb_frames = np.stack([hsl2rgb(frame) for frame in frames])
return rgb_frames
def create_data(self) -> str:
"""Returns a JavaScript string defining a JavaScript object containing the data.
Returns:
:obj:`str`: JavaScript code defining an object containing the data
"""
s = self.scale
mini, maxi = self.get_min_max()
diff = maxi - mini
output = "const data = {\n"
# Create the data for the scatters
# TODO: If it's not interactive, labels shouldn't be exported.
for name, data in self.scatters_data.items():
mapping = self.scatters[name]["mapping"]
colormaps = self.scatters[name]["colormap"]
cmaps = [None] * len(colormaps)
for i, colormap in enumerate(colormaps):
if isinstance(colormap, str):
cmaps[i] = plt.cm.get_cmap(colormap)
else:
cmaps[i] = colormap
output += name + ": {\n"
x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping["x"]]]
output += "x: [" + ",".join(map(str, x_norm)) + "],\n"
y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping["y"]]]
output += "y: [" + ",".join(map(str, y_norm)) + "],\n"
z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping["z"]]]
output += "z: [" + ",".join(map(str, z_norm)) + "],\n"
if mapping["labels"] in data:
fmt_labels = ["'{0}'".format(s) for s in data[mapping["labels"]]]
output += "labels: [" + ",".join(fmt_labels) + "],\n"
if mapping["s"] in data:
output += "s: ["
for series in range(len(data[mapping["s"]])):
output += (
"["
+ ",".join(map(str, np.round(data[mapping["s"]][series], 3)))
+ "],\n"
)
output += "],\n"
output += "colors: [\n"
for series in range(len(data[mapping["c"]])):
output += "{\n"
if mapping["cs"] in data:
colors = np.array(
[cmaps[series](x) for x in data[mapping["c"]][series]]
)
for i, c in enumerate(colors):
hsl = np.array(colour.rgb2hsl(c[:3]))
hsl[1] = hsl[1] - hsl[1] * data[mapping["cs"]][series][i]
colors[i] = np.append(np.array(colour.hsl2rgb(hsl)), 1.0)
colors = np.round(colors * 255.0)
output += (
"r: [" + ",".join(map(str, map(int, colors[:, 0]))) + "],\n"
)
output += (
"g: [" + ",".join(map(str, map(int, colors[:, 1]))) + "],\n"
)
output += (
"b: [" + ",".join(map(str, map(int, colors[:, 2]))) + "],\n"
)
elif mapping["c"] in data:
colors = np.array(
[cmaps[series](x) for x in data[mapping["c"]][series]]
)
colors = np.round(colors * 255.0)
output += (
"r: [" + ",".join(map(str, map(int, colors[:, 0]))) + "],\n"
)
output += (
"g: [" + ",".join(map(str, map(int, colors[:, 1]))) + "],\n"
)
output += (
"b: [" + ",".join(map(str, map(int, colors[:, 2]))) + "],\n"
)
output += "},\n"
output += "]"
output += "},\n"
for name, data in self.trees_data.items():
mapping = self.trees[name]["mapping"]
point_helper = self.trees[name]["point_helper"]
output += name + ": {\n"
if point_helper is not None and point_helper in self.scatters_data:
scatter = self.scatters_data[point_helper]
scatter_mapping = self.scatters[point_helper]["mapping"]
x_t = []
y_t = []
z_t = []
for i in range(len(data[mapping["from"]])):
x_t.append(scatter[scatter_mapping["x"]][data[mapping["from"]][i]])
x_t.append(scatter[scatter_mapping["x"]][data[mapping["to"]][i]])
y_t.append(scatter[scatter_mapping["y"]][data[mapping["from"]][i]])
y_t.append(scatter[scatter_mapping["y"]][data[mapping["to"]][i]])
z_t.append(scatter[scatter_mapping["z"]][data[mapping["from"]][i]])
z_t.append(scatter[scatter_mapping["z"]][data[mapping["to"]][i]])
x_norm = [round(s * (x - mini) / diff, 3) for x in x_t]
output += f"x: [" + ",".join(map(str, x_norm)) + "],\n"
y_norm = [round(s * (y - mini) / diff, 3) for y in y_t]
output += "y: [" + ",".join(map(str, y_norm)) + "],\n"
z_norm = [round(s * (z - mini) / diff, 3) for z in z_t]
output += "z: [" + ",".join(map(str, z_norm)) + "],\n"
else:
x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping["x"]]]
output += "x: [" + ",".join(map(str, x_norm)) + "],\n"
y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping["y"]]]
output += "y: [" + ",".join(map(str, y_norm)) + "],\n"
z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping["z"]]]
output += "z: [" + ",".join(map(str, z_norm)) + "],\n"
if mapping["c"] in data:
colormap = self.trees[name]["colormap"]
cmap = None
if isinstance(colormap, str):
cmap = plt.cm.get_cmap(colormap)
else:
cmap = colormap
colors = np.array([cmap(x) for x in data[mapping["c"]]])
colors = np.round(colors * 255.0)
output += "r: [" + ",".join(map(str, colors[:, 0])) + "],\n"
output += "g: [" + ",".join(map(str, colors[:, 1])) + "],\n"
output += "b: [" + ",".join(map(str, colors[:, 2])) + "],\n"
output += "},\n"
output += "};\n"
return output
def create_python_data(self) -> dict:
"""Returns a Python dict containing the data
Returns:
:obj:`dict`: The data defined in this Faerun instance
"""
s = self.scale
minimum, maximum = self.get_min_max()
diff = maximum - minimum
output = {}
# Create the data for the scatters
for name, data in self.scatters_data.items():
mapping = self.scatters[name]["mapping"]
colormaps = self.scatters[name]["colormap"]
cmaps = [None] * len(colormaps)
for i, colormap in enumerate(colormaps):
if isinstance(colormap, str):
cmaps[i] = plt.cm.get_cmap(colormap)
else:
cmaps[i] = colormap
output[name] = {}
output[name]["meta"] = self.scatters[name]
output[name]["type"] = "scatter"
output[name]["x"] = np.array(
[s * (x - minimum) / diff for x in data[mapping["x"]]], dtype=np.float32
)
output[name]["y"] = np.array(
[s * (y - minimum) / diff for y in data[mapping["y"]]], dtype=np.float32
)
output[name]["z"] = np.array(
[s * (z - minimum) / diff for z in data[mapping["z"]]], dtype=np.float32
)
if mapping["labels"] in data:
# Make sure that the labels are always strings
output[name]["labels"] = list(map(str, data[mapping["labels"]]))
if mapping["s"] in data:
output[name]["s"] = np.array(data[mapping["s"]], dtype=np.float32)
output[name]["colors"] = [{}] * len(data[mapping["c"]])
for s in range(len(data[mapping["c"]])):
if mapping["cs"] in data:
colors = np.array([cmaps[s](x) for x in data[mapping["c"]][s]])
for i, c in enumerate(colors):
hsl = np.array(colour.rgb2hsl(c[:3]))
hsl[1] = hsl[1] - hsl[1] * data[mapping["cs"]][s][i]
colors[i] = np.append(np.array(colour.hsl2rgb(hsl)), 1.0)
colors = np.round(colors * 255.0)
output[name]["colors"][s]["r"] = np.array(
colors[:, 0], dtype=np.float32
)
output[name]["colors"][s]["g"] = np.array(
colors[:, 1], dtype=np.float32
)
output[name]["colors"][s]["b"] = np.array(
colors[:, 2], dtype=np.float32
)
else:
colors = np.array([cmaps[s](x) for x in data[mapping["c"]][s]])
colors = np.round(colors * 255.0)
output[name]["colors"][s]["r"] = np.array(
colors[:, 0], dtype=np.float32
)
output[name]["colors"][s]["g"] = np.array(
colors[:, 1], dtype=np.float32
)
output[name]["colors"][s]["b"] = np.array(
colors[:, 2], dtype=np.float32
)
for name, data in self.trees_data.items():
mapping = self.trees[name]["mapping"]
point_helper = self.trees[name]["point_helper"]
output[name] = {}
output[name]["meta"] = self.trees[name]
output[name]["type"] = "tree"
if point_helper is not None and point_helper in self.scatters_data:
scatter = self.scatters_data[point_helper]
scatter_mapping = self.scatters[point_helper]["mapping"]
x_t = []
y_t = []
z_t = []
for i in range(len(data[mapping["from"]])):
x_t.append(scatter[scatter_mapping["x"]][data[mapping["from"]][i]])
x_t.append(scatter[scatter_mapping["x"]][data[mapping["to"]][i]])
y_t.append(scatter[scatter_mapping["y"]][data[mapping["from"]][i]])
y_t.append(scatter[scatter_mapping["y"]][data[mapping["to"]][i]])
z_t.append(scatter[scatter_mapping["z"]][data[mapping["from"]][i]])
z_t.append(scatter[scatter_mapping["z"]][data[mapping["to"]][i]])
output[name]["x"] = np.array(
[s * (x - minimum) / diff for x in x_t], dtype=np.float32
)
output[name]["y"] = np.array(
[s * (y - minimum) / diff for y in y_t], dtype=np.float32
)
output[name]["z"] = np.array(
[s * (z - minimum) / diff for z in z_t], dtype=np.float32
)
else:
output[name]["x"] = np.array(
[s * (x - minimum) / diff for x in data[mapping["x"]]],
dtype=np.float32,
)
output[name]["y"] = np.array(
[s * (y - minimum) / diff for y in data[mapping["y"]]],
dtype=np.float32,
)
output[name]["z"] = np.array(
[s * (z - minimum) / diff for z in data[mapping["z"]]],
dtype=np.float32,
)
if mapping["c"] in data:
colormap = self.trees[name]["colormap"]
cmap = None
if isinstance(colormap, str):
cmap = plt.cm.get_cmap(colormap)
else:
cmap = colormap
colors = np.array([cmap(x) for x in data[mapping["c"]]])
colors = np.round(colors * 255.0)
output[name]["r"] = np.array(colors[:, 0], dtype=np.float32)
output[name]["g"] = np.array(colors[:, 1], dtype=np.float32)
output[name]["b"] = np.array(colors[:, 2], dtype=np.float32)
return output
#r2 = r2_score(y_train, preds)
from colour import hsl2rgb
time_save = time[:divide].append(time[divide:])
data_save = np.append(y_train, y_valid)
model_save = np.append(preds_train, preds_test)
#dict={'time':time_save,'data':data_save,'model':model_save}
#df_save=pd.DataFrame(data=dict)
#df_save.to_csv("color_feature_hsl/model_fit_"+i+".csv")
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(pd.to_datetime(time[:divide]),
y_train * 100,
color=hsl2rgb([0.6, 0.5, 70 / 100.]),
lw=3,
label='data')
ax.plot(pd.to_datetime(time[:divide]),
preds_train * 100,
color=hsl2rgb([0.6, 0.5, 10 / 100.]),
lw=2,
ls=":",
label='model')
ax.plot(pd.to_datetime(time[divide:size]),
y_valid * 100,
color=hsl2rgb([0.6, 0.5, 70 / 100.]),
lw=3) #,ls=":")#,label='test data')
ax.plot(pd.to_datetime(time[divide:size]),
preds_test * 100,
color=hsl2rgb([0.6, 0.5, 10 / 100.]),
def get_plotly_SxL_pop(data, hue=4):
col = ['s0l2', 's0l1', 's1l1', 's1l2', 's0l3']
#fig = go.Figure()
fig = go.Figure()
for col_test in col:
s = int(col_test[1])
l = int(col_test[-1])
df_forecasting = rolling_rf_data_pre(data, col=col_test)
f = forescast_feature_pre(data, df_forecasting, col=col_test)
t, model, pred = forecast_rf(df_forecasting, f)
time = list(t)
time.append(pd.to_datetime("2020-06-30"))
forecast = list(100 * model)
forecast.append(pred[0] * 100)
color = np.asarray(
hsl2rgb([
hue_value[hue] / 360., satuation_value[s] / 100,
lightness_value[l] / 100
]))
color = (color * 255).astype('int')
color = rgb2hex(color)
fig.add_trace(
go.Scatter(x=t,
y=100 * df_forecasting[col_test],
mode='lines',
name='data: saturation = ' + str(satuation_value[s]) +
'%, lightness = ' + str(lightness_value[l]) + '%',
line=dict(color=color, width=3)))
fig.add_trace(
go.Scatter(x=time,
y=forecast,
mode='lines',
name='forecast',
line=dict(color=color, dash='dot', width=3)))
title = "Most Popular Saturation X Lightness Categories (Hue Independent)"
fig.update_layout(
title=title,
width=1050,
height=650,
xaxis_title="time",
yaxis_title="% popularity",
font=dict(family="Courier New, monospace", size=17, color="#7f7f7f"),
xaxis=dict(
range=[pd.to_datetime("2016-06-30"),
pd.to_datetime("2020-06-30")],
rangeselector=dict(buttons=list([
dict(count=6,
label="last 6 months",
step="month",
stepmode="backward"),
dict(count=1,
label="last year",
step="year",
stepmode="backward"),
dict(step="all")
])),
rangeslider=dict(visible=True),
type="date"),
legend=dict(
x=1.1,
y=0.99,
traceorder='normal',
font=dict(size=12, ),
),
)
return fig
def get_plotly_H_6(data):
col = ['h0', 'h1', 'h2', 'h3', 'h4', 'h5']
fig = go.Figure()
i = 0
for col_test in col:
df_forecasting = rolling_rf_data_pre(data, col=col_test)
f = forescast_feature_pre(data, df_forecasting, col=col_test)
t, model, pred = forecast_rf(df_forecasting, f)
time = list(t)
time.append(pd.to_datetime("2020-06-30"))
forecast = list(100 * model)
forecast.append(pred[0] * 100)
color = np.asarray(hsl2rgb([hue_value[i] / 360., 0.5, 0.7]))
color = (color * 255).astype('int')
color = rgb2hex(color)
fig.add_trace(
go.Scatter(x=t,
y=100 * df_forecasting[col_test],
name='data: ' + hue_name[i],
mode='lines',
line=dict(color=color, width=4)))
fig.add_trace(
go.Scatter(x=time,
y=forecast,
mode='lines',
name='forecast',
line=dict(color=color, dash='dot', width=4)))
i += 1
print(color)
h = int(col_test[1])
title = "Popularity of Each Primary Hue"
fig.update_layout(
title=title,
width=850,
height=550,
xaxis_title="time",
yaxis_title="% popularity",
font=dict(family="Courier New, monospace", size=17, color="#7f7f7f"),
xaxis_showgrid=True,
yaxis_showgrid=True,
xaxis=dict(
range=[pd.to_datetime("2016-06-30"),
pd.to_datetime("2020-06-30")],
rangeselector=dict(buttons=list([
dict(count=6,
label="last 6 months",
step="month",
stepmode="backward"),
dict(count=1,
label="last year",
step="year",
stepmode="backward"),
dict(step="all")
])),
rangeslider=dict(visible=True),
type="date"),
legend=dict(
x=1.1,
y=0.99,
traceorder='normal',
font=dict(size=12, ),
),
#paper_bgcolor='rgba(0,0,0,0)')
plot_bgcolor='rgba(0,0,0,0)',
)
fig.update_yaxes(showgrid=True, gridcolor="#DCDCDC")
fig.update_xaxes(showgrid=True, gridcolor="#DCDCDC")
return fig
def get_plotly_SxL(col_test, data):
s = int(col_test[1])
l = int(col_test[-1])
df_forecasting = rolling_rf_data_pre(data, col=col_test)
f = forescast_feature_pre(data, df_forecasting, col=col_test)
t, model, pred = forecast_rf(df_forecasting, f)
#fig = go.Figure()
fig = make_subplots(
rows=1,
cols=2,
subplot_titles=(
" ", "Colors in the Same <br> Saturation X Lightness Palette"),
specs=[[{
'type': 'xy'
}, {
'type': 'polar'
}]],
column_widths=[0.75, 0.25])
time = list(t)
time.append(pd.to_datetime("2020-06-30"))
forecast = list(100 * model)
forecast.append(pred[0] * 100)
fig.add_trace(go.Scatter(x=time,
y=forecast,
mode='lines',
name='model & forecast',
line=dict(color="#80bf40", dash='dot', width=3)),
row=1,
col=1)
fig.add_trace(go.Scatter(x=t,
y=100 * df_forecasting[col_test],
mode='lines',
name='data',
line=dict(color="#409fbf", width=3)),
row=1,
col=1)
title = 'Saturation = ' + str(satuation[s]) + ', Lightness = ' + str(
satuation[l])
fig.update_layout(
title=title,
title_x=0.,
width=1050,
height=650,
xaxis_title="time",
yaxis_title="% popularity",
font=dict(family="Courier New, monospace", size=17, color="#7f7f7f"),
xaxis=dict(
range=[pd.to_datetime("2016-06-30"),
pd.to_datetime("2020-06-30")],
rangeselector=dict(buttons=list([
dict(count=6,
label="last 6 months",
step="month",
stepmode="backward"),
dict(count=1,
label="last year",
step="year",
stepmode="backward"),
dict(step="all")
])),
rangeslider=dict(visible=True),
type="date"),
legend=dict(
x=0,
y=0.99,
traceorder='normal',
font=dict(size=12, ),
),
)
hexcode = []
for h in hue_value:
color = np.asarray((hsl2rgb([(h + 10) / 360, satuation_value[s] / 100,
lightness_value[l] / 100])))
color = color * 255
color = color.astype('int')
#print(color)
hexcode.append(rgb2hex(color))
fig.add_trace(go.Barpolar(r=[2] * 6,
theta=hue_value,
width=[60] * 6,
marker_color=hexcode,
showlegend=False,
hoverinfo='none'),
row=1,
col=2)
fig.update_layout(
template=None,
polar=dict(
radialaxis=dict(showticklabels=False,
ticks='',
showgrid=False,
showline=False),
angularaxis=dict(showticklabels=False,
ticks='',
showgrid=False,
showline=False,
rotation=90),
),
)
return fig
def axis_colours(self):
for ax_name, ax in self.axes.items():
yield (colour.hsl2rgb((ax.get_color(), 1.0, 0.35)), ax_name)
def trace_colours(self):
for ax in self.axes.values():
size = float(len(ax))
for i, trace in enumerate(ax.traces):
yield (colour.hsl2rgb((ax.get_color(i), 1.0, 0.35)), trace)
def axis_colours(self):
for ax_name, ax in self.axes.items():
yield (colour.hsl2rgb((ax.get_color(), 1.0, 0.35)), ax_name)
def trace_colours(self):
for ax in self.axes.values():
size = float(len(ax))
for i, trace in enumerate(ax.traces):
yield (colour.hsl2rgb((ax.get_color(i), 1.0, 0.35)), trace)
