def afficher_cellules(self, color):
# test sign
def test_sign(vectors):
for i in range(len(vectors) - 1):
vec1, vec2 = vectors[i], vectors[i + 1]
# Si le produit scalaire est négatif, alors les vecteurs sont opposés
if np.dot(vec1, vec2) < 0:
return False
return True
# Begin
for cell in self.__cells:
x1, x2, x3, x4 = cell[:, 0]
y1, y2, y3, y4 = cell[:, 1]
u1, u2, u3, u4 = cell[:, 2]
v1, v2, v3, v4 = cell[:, 3]
# Les 4 vecteurs
vecs = [[u1, v1], [u2, v2], [u3, v3], [u4, v4]]
if not test_sign(vecs):
verts = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
poly = Polygon(verts)
poly.set_color(color)
ax.add_patch(poly)
def __add_xy_values_as_polygon__(self, xy: list, color: str, closed=False, fill=False, alpha=0.2, line_width=2):
xy = PlotterInterface.get_xy_from_timestamp_to_date_number(xy)
polygon = Polygon(np.array(xy), closed=closed, fill=fill)
polygon.set_visible(True)
polygon.set_color(color)
polygon.set_alpha(alpha)
polygon.set_linewidth(line_width)
self.axes_for_candlesticks.add_patch(polygon)
def __plot_single_fibonacci_wave__(self, fib_wave: FibonacciWave, color: str, suffix: str = ''):
if self.sys_config.config.fibonacci_detail_print:
fib_wave.print(suffix)
xy = fib_wave.get_xy_parameter()
xy = PlotterInterface.get_xy_from_timestamp_to_date_number(xy)
fib_polygon = Polygon(np.array(xy), closed=False, fill=False)
fib_polygon.set_visible(True)
fib_polygon.set_color(color)
fib_polygon.set_linewidth(1)
self.axes_for_candlesticks.add_patch(fib_polygon)
fib_wave_patch = FibonacciWavePatch(fib_wave, fib_polygon)
self.fibonacci_patch_container.add_patch(fib_wave_patch)
fib_wave_patch.add_retracement_patch_list_to_axis(self.axes_for_candlesticks)
def __add_to_ranges_polygon_dic__(self, polygon: Polygon, for_main: bool, range: PatternRange):
polygon.set_visible(False)
polygon.set_color('r' if for_main else 'k')
polygon.set_linewidth(1)
self.axes_for_candlesticks.add_patch(polygon)
for ticks in range.tick_list:
if for_main:
if ticks.f_var not in self.ranges_polygon_dic_list:
self.ranges_polygon_dic_list[ticks.f_var] = [polygon]
else:
self.ranges_polygon_dic_list[ticks.f_var].append(polygon)
else:
if ticks.f_var not in self.ranges_opposite_polygon_dic_list:
self.ranges_opposite_polygon_dic_list[ticks.f_var] = [polygon]
else:
self.ranges_opposite_polygon_dic_list[ticks.f_var].append(polygon)
def show_cells(self):
def checker(vecs):
for i in range(len(vecs) - 1):
vec1, vec2 = vecs[i], vecs[i + 1]
if np.dot(vec1, vec2) < 0:
return False
return True
for cell in self.cells:
x1, x2, x3, x4 = cell[:, 0]
y1, y2, y3, y4 = cell[:, 1]
u1, u2, u3, u4 = cell[:, 2]
v1, v2, v3, v4 = cell[:, 3]
vecs = [[u1, v1], [u2, v2], [u3, v3], [u4, v4]]
if not checker(vecs):
pts = [(x1, y1), (x2, y2), (x3, y3), (x4, y4)]
poly = Polygon(pts)
poly.set_color("yellow")
self.ax.add_patch(poly)
def afficher_profil(self, color):
verts = self.__coords[0:len(self.__coords):35]
poly = Polygon(verts)
poly.set_color(color)
ax.add_patch(poly)
def main():
tic = time.perf_counter()
gn = Granatum()
sample_coords = gn.get_import("viz_data")
value = gn.get_import("value")
coloring_type = gn.get_arg("coloring_type")
bounding_stdev = gn.get_arg("bounding_stdev")
label_location = gn.get_arg("label_location")
label_transform = gn.get_arg("label_transform")
labelXaxis = gn.get_arg("labelXaxis")
labelYaxis = gn.get_arg("labelYaxis")
sigfigs = gn.get_arg("sigfigs")
numticks = gn.get_arg("numticks")
font = gn.get_arg('font')
coords = sample_coords.get("coords")
dim_names = sample_coords.get("dimNames")
seed = gn.get_arg('random_seed')
random.seed(seed)
np.random.seed(seed)
df = pd.DataFrame(
{
"x": [a[0] for a in coords.values()],
"y": [a[1] for a in coords.values()],
"value": pd.Series(value)
},
index=coords.keys())
target_dpi = 300
target_width = 7.5 # inches
target_height = 6.5 # inches
font_size_in_in = font / 72.0 # inches
font_size_in_px = font_size_in_in * target_dpi
try:
if coloring_type == "categorical":
uniq = df["value"].unique()
uniq.sort(kind="stable")
num = uniq.shape[0]
COLORS2 = plt.get_cmap('gist_rainbow')
carr = [0] * df.shape[0]
listcats = list(df["value"])
miny = min(list(df["y"]))
maxy = max(list(df["y"]))
scaley = (maxy - miny) / (target_height * target_dpi)
print("Scaley = {}".format(scaley))
colorhash = {}
colorstep = np.ceil(256.0 / num)
coffset = randrange(colorstep)
grouptocolor = np.random.choice(np.arange(num), num, replace=False)
for i, cat in enumerate(uniq):
dff = df[df["value"] == cat]
xs = list(dff["x"])
ys = list(dff["y"])
#avgx = sum(dff["x"]) / len(dff["x"])
#avgy = sum(dff["y"]) / len(dff["y"])
#plt.scatter(x=dff["x"], y=dff["y"], s=5000 / df.shape[0], c=COLORS[i].hex_l, label=cat)
#plt.scatter(x=dff["x"], y=dff["y"], s=5000 / df.shape[0], c=[abs(hash(cat)) % 256]*len(dff["x"]), cmap=COLORS2, label=cat)
#plt.scatter(x=dff["x"], y=dff["y"], s=5000 / df.shape[0], c=abs(hash(cat)) % 256, cmap=COLORS2, label=cat)
#abs(hash(cat))
colorindex = (coffset + grouptocolor[i] * colorstep) % 256
colorhash[cat] = colorindex
craw = COLORS2((colorindex + 0.0) / 256.0)
clr = [craw[0], craw[1], craw[2], 0.2]
whitetransparent = [1.0, 1.0, 1.0, 0.5]
coloropaque = [craw[0], craw[1], craw[2], 1.0]
if len(xs) > 3:
pts = list(zip(xs, ys))
cent = np.mean(pts, axis=0)
lengs = list(
map(
lambda p: math.sqrt(
(p[0] - cent[0]) * (p[0] - cent[0]) +
(p[1] - cent[1]) * (p[1] - cent[1])), pts))
avgleng = st.mean(lengs)
stdleng = st.stdev(lengs) * bounding_stdev
rpts = []
if (stdleng > 0.0):
for j, ln in enumerate(lengs):
if (ln - avgleng < stdleng):
rpts.append(pts[j])
pts = rpts
cent = np.mean(pts, axis=0)
hull = ConvexHull(pts)
ptslist = []
for pt in hull.simplices:
ptslist.append(pts[pt[0]])
ptslist.append(pts[pt[1]])
ptslist.sort(key=lambda p: np.arctan2(
p[1] - cent[1], p[0] - cent[0]))
ptslist = ptslist[0::2]
ptslist.insert(len(ptslist), ptslist[0])
lowestpt = ptslist[0]
if label_location == 'bottom':
for pt in ptslist:
if (pt[1] < lowestpt[1]):
lowestpt = pt
else:
lowestpt = ptslist[randrange(len(ptslist))]
if (bounding_stdev >= 0.0):
poly = Polygon(1.1 * (np.array(ptslist) - cent) + cent,
facecolor=clr)
poly.set_capstyle('round')
plt.gca().add_patch(poly)
poly.set_color(clr)
label_text = cat
if label_transform == "numbers":
label_text = re.sub("[^0-9]", "", cat)
txt = plt.text(lowestpt[0],
lowestpt[1] -
scaley * font_size_in_px * 1.2,
label_text,
fontsize=font,
fontname="Arial",
ha="center",
va="center",
color="black",
bbox=dict(boxstyle="round",
fc=whitetransparent,
ec=coloropaque))
# plt.gca().add_artist(txt)
for j, x in enumerate(listcats):
if x == cat:
carr[j] = colorhash[cat]
#carr[j] = colorhash[cat] / 256.0
#int(abs(hash(cat)) % 256)
plt.scatter(x=df["x"],
y=df["y"],
s=5000 / df.shape[0],
c=carr,
cmap=COLORS2)
lgd = plt.legend(markerscale=6,
loc='upper center',
bbox_to_anchor=(0.5, -0.05),
ncol=5)
#60 / (5000 / df.shape[0])
elif coloring_type == "continuous":
plt.scatter(x=df["x"],
y=df["y"],
s=5000 / df.shape[0],
c=df["value"],
cmap="Reds")
plt.colorbar()
xmin, xmax = plt.gca().get_xlim()
ymin, ymax = plt.gca().get_ylim()
# stepsizex=(xmax-xmin)/numticks
# stepsizey=(ymax-ymin)/numticks
xtickArray = resetArray(xmin, xmax, numticks, sigfigs)
ytickArray = resetArray(ymin, ymax, numticks, sigfigs)
# plt.xticks(np.arange(xmin, xmax+stepsizex, step=stepsizex), fontsize=font, fontname="Arial")
# plt.yticks(np.arange(ymin, ymax+stepsizey, step=stepsizey), fontsize=font, fontname="Arial")
plt.xlim(xtickArray[0], xtickArray[-1])
plt.ylim(ytickArray[0], ytickArray[-1])
plt.xticks(xtickArray, fontsize=font, fontname="Arial")
plt.yticks(ytickArray, fontsize=font, fontname="Arial")
if labelXaxis == "":
plt.xlabel(dim_names[0], fontsize=font, fontname="Arial")
else:
plt.xlabel(labelXaxis, fontsize=font, fontname="Arial")
if labelYaxis == "":
plt.ylabel(dim_names[1], fontsize=font, fontname="Arial")
else:
plt.ylabel(labelYaxis, fontsize=font, fontname="Arial")
# plt.tight_layout()
gn.add_current_figure_to_results(
"Scatter-plot",
dpi=target_dpi,
width=target_width * target_dpi,
height=target_height * target_dpi,
savefig_kwargs={'bbox_inches': 'tight'})
toc = time.perf_counter()
time_passed = round(toc - tic, 2)
timing = "* Finished sample coloring step in {} seconds*".format(
time_passed)
gn.add_result(timing, "markdown")
gn.commit()
except Exception as e:
plt.figure()
plt.text(
0.05, 0.7,
'Values used as colors and type of sample metadata are incompatible with each other'
)
if coloring_type == 'categorical':
new_coloring_type = 'continuous'
else:
new_coloring_type = 'categorical'
plt.text(
0.05, 0.5, 'Retry the step with ' + new_coloring_type +
' instead of ' + coloring_type)
plt.axis('off')
gn.add_current_figure_to_results('Scatter-plot')
gn.commit()
def create_stats_circle(self, color='b', bg_color=None, **kwargs):
c = 'black'
if color_distance(Color(c), bg_color) < (MAX_COLOR_DIFF / 2):
c = 'white'
inner_circle = Circle((0, 0), radius=1.1, fc='none', ec=c)
outer_circle = Circle((0, 0), radius=1.55, fc='none', ec=c)
outest_circle = Circle((0, 0), radius=1.65, fc='none', ec=c)
fig, ax = self.create_empty_stats_circle(c)
stat_spread = []
for idx, line in enumerate(self.stats.values()):
x, y = line[0].get_data()
power = POWERS[idx]
power_value = kwargs.get(power, 'E')
if power_value is None:
power_value = 'E'
power_value = power_value.upper()
power_int = LETTERS_TO_INT.get(power_value, 0)
# Small correction to the text position
correction = 0.03
r = 60 * idx / 180 * pi
sinr = np.round(np.sin(r), 5)
cosr = np.round(np.cos(r), 5)
if sinr < 0:
lx = 1.25 * sinr - correction
else:
lx = 1.25 * sinr + correction
if cosr < 0:
ly = 1.25 * cosr - correction
else:
ly = 1.25 * cosr + correction
rot = (0 + min(check_negative(cosr) * 180, 0)) - 60 * idx
if sinr == 0:
rot = 0
ax.text(lx,
ly,
power_value,
color=c,
alpha=0.9,
fontsize=14,
weight='bold',
ha='center',
va='center')
ax.text(lx * 1.50,
ly * 1.50,
power,
color=c,
fontsize=17,
ha='center',
rotation=rot,
va='center')
x = x[power_int]
y = y[power_int]
stat_spread.append([x, y])
r1 = outer_circle.radius
r2 = outest_circle.radius
w = 3.0
for r in range(0, 360, 15):
sinr = np.round(np.sin(np.deg2rad(r)), 5)
cosr = np.round(np.cos(np.deg2rad(r)), 5)
x = (r1 * sinr, r2 * sinr)
y = (r1 * cosr, r2 * cosr)
ax.plot(x, y, '-', color=c, linewidth=w)
pol = Polygon(stat_spread, fc='y', alpha=0.7)
pol.set_color(color)
fig.gca().add_patch(inner_circle)
fig.gca().add_patch(outer_circle)
fig.gca().add_patch(outest_circle)
fig.gca().add_patch(pol)
fig.gca().autoscale(True)
fig.gca().set_axis_off()
ax.axis('scaled')
fig.canvas.draw()
return fig, ax
class Plot:
def __init__(self, fig, ax):
self.fig = fig
self.ax = ax
self.plot_dict = {}
self.plot_dict2 = {}
self.dark_fg = "0.2"
self.bright_fg = "0.64"
self.white_bg = "1.0"
self.gray_bg = "0.5"
self.black_bg = "0.0"
# plot points per 90°
self.num_x = 30
self.z = 0.2
self.top_bottom_border = 2 * self.z
self.paired_function_offset = 0.5
self.row_offset = 2.0
self.rows = 12
self.cols = 10
self.height = (self.rows - 1) * self.row_offset + 2 * self.z + self.paired_function_offset + 2 * self.top_bottom_border
self.width = self.cols * 2 * np.pi
self.r = self.height / self.width
self.width = self.height
self.white_triangle = Polygon([[0, self.height],
[0.5 * self.width, self.height],
[0, 0.5 * self.height]],
color=self.white_bg)
self.gray_polygon = Polygon([[0.5 * self.width, self.height],
[self.width, self.height],
[self.width, 0.5 * self.height],
[0.5 * self.width, 0],
[0, 0],
[0, 0.5 * self.height]], color=self.gray_bg)
self.black_triangle = Polygon([[self.width, 0.5 * self.height],
[self.width, 0],
[0.5 * self.width, 0]],
color=self.black_bg)
self.ax.add_patch(self.white_triangle)
self.ax.add_patch(self.gray_polygon)
self.ax.add_patch(self.black_triangle)
for i in range(self.rows):
if i % 2 == 0:
colors = (self.dark_fg, self.dark_fg, self.bright_fg, self.bright_fg)
else:
colors = (self.bright_fg, self.dark_fg, self.dark_fg, self.bright_fg)
for j in range(self.cols):
for k in range(4):
xs = np.linspace((2*j+k/2)*np.pi*self.r, (2*j+(k+1)/2)*np.pi*self.r, self.num_x)
y1 = self.z * np.sin(xs / self.r) + i * self.row_offset + self.z + self.top_bottom_border
y2 = y1 + self.paired_function_offset
# keep plots for color changing
self.plot_dict[(i, j, k)] = self.ax.plot(xs, y1, color=colors[k])
self.plot_dict2[(i, j, k)] = self.ax.plot(xs, y2, color=colors[k])
def update_white_bg(self, val):
self.white_triangle.set_color(str(val))
self.fig.canvas.draw()
def update_gray_bg(self, val):
self.gray_polygon.set_color(str(val))
self.fig.canvas.draw()
def update_black_bg(self, val):
self.black_triangle.set_color(str(val))
self.fig.canvas.draw()
def update_bright_fg(self, val):
self.bright_fg = str(val)
self.update_colors()
self.fig.canvas.draw()
def update_dark_fg(self, val):
self.dark_fg = str(val)
self.update_colors()
self.fig.canvas.draw()
def update_colors(self):
for i in range(self.rows):
if i % 2 == 0:
colors = (self.dark_fg, self.dark_fg, self.bright_fg, self.bright_fg)
else:
colors = (self.bright_fg, self.dark_fg, self.dark_fg, self.bright_fg)
for j in range(self.cols):
for k in range(4):
for l in self.plot_dict[(i, j, k)]:
l.set_color(colors[k])
for l in self.plot_dict2[(i, j, k)]:
l.set_color(colors[k])
def profile(self, color):
pts = self.coords[0:len(self.coords):35]
poly = Polygon(pts)
poly.set_color(color)
self.ax.add_patch(poly)
