def get_points(gaussian,
z_list,
colorscheme,
num=100,
method="equal_density",
num_of_levels=8,
min_value=0.,
max_value=1.,
split=True,
min_border=None,
*args,
**kwargs):
# generate colors to chose from
z_list = np.asarray(z_list)
norm = iso_lines.get_iso_levels(z_list,
method=method,
num_of_levels=num_of_levels + 2)
norm = picture_contours.get_color_middlepoint(norm, min_value, max_value)
colormap = colorscheme["colorscheme"](
levels=norm,
colorscheme_name=colorscheme["colorscheme_name"],
*args,
**kwargs)
# replace points in image with matching colors
levels = iso_lines.get_iso_levels(z_list,
method=method,
num_of_levels=num_of_levels)
rand_coordinates = gaussian.gau.rvs(num * num, random_state=12345)
rand_z_values = gaussian.gau.pdf(rand_coordinates).reshape((num, num))
# z_value, alpha_value = color_operations.map_colors(rand_z_values, colormap, levels, split)
z_value = get_main_color(colorscheme)[-4]
return rand_coordinates, np.tile(z_value, (num * num, 1))
def generate_contour_lines(ax,
X,
distribution_limits,
contour_lines_colorscheme,
contour_lines_method="equal_density",
contour_lines_weighted=True,
num_of_levels=8,
borders=None,
linewidth=2,
levels=None):
if borders is None:
borders = [0.5, 1.]
if levels is None:
levels = get_iso_levels(X, contour_lines_method, num_of_levels + 1)
else:
num_of_levels = len(levels)
levels = get_iso_levels(X, "equal_value", level_targets=levels)
logger.debug("Level: {}".format(levels))
if contour_lines_weighted:
contour_lines_colors = get_contour_line_colors(
contour_lines_colorscheme, levels, borders)
else:
contour_lines_colors = np.repeat(
contour_lines_colorscheme["colorscheme"](
contour_lines_colorscheme["colorscheme_name"], [1.],
lvl_white=0),
num_of_levels + 1,
axis=0)
plot_contour_lines(ax,
X,
distribution_limits,
levels,
contour_lines_colors,
linewidth=linewidth)
def get_line(gaussian,
eigenvalue,
eigenvector,
colorscheme,
min_value=0.,
max_value=1.,
method="equal_density",
num_of_levels=5):
"""
generates a line with matching colors and iso-lines from a given gaussian and a fitting grid of densities
:param gaussian: Gaussian class with means and cov-matrix
:param eigenvalue:
:param eigenvector:
:param colorscheme:
:param min_value:
:param max_value:
:param method:
:param num_of_levels:
:return:
"""
def get_limits(line, index):
return min(line, key=lambda k: k[index])[index], max(
line, key=lambda k: k[index])[index]
first_line, second_line = get_half_lines(gaussian.means, eigenvector,
eigenvalue)
limits = helper.Limits(*get_limits([*first_line, *second_line], 0),
*get_limits([*first_line, *second_line], 1))
logger.debug("Cross-limits: {}".format(limits))
_, _, z_list = gaussian.get_density_grid(x_min=limits.x_min,
x_max=limits.x_max,
y_min=limits.y_min,
y_max=limits.y_max)
iso_level = iso_lines.get_iso_levels(z_list,
method=method,
num_of_levels=num_of_levels)
logger.debug(
"------------------------------------------------------------")
logger.debug("First Part of Line {}".format(first_line))
logger.debug("Second Part of Line {}".format(second_line))
logger.debug("Iso-Level for splitting {}".format(iso_level))
logger.debug(
"------------------------------------------------------------")
first_line = split_half_line(gaussian, *first_line, iso_level)
second_line = split_half_line(gaussian, *second_line, iso_level[::-1])
iso_lvl = iso_lines.get_iso_levels(gaussian.get_density_grid()[2],
method=method,
num_of_levels=num_of_levels + 2)
logger.debug("Min/max-value: {}/{}".format(min_value, max_value))
logger.debug("Iso-Level for colors: {}".format(iso_lvl))
iso_lvl = picture_contours.get_color_middlepoint(iso_lvl, min_value,
max_value)
colors = get_color(iso_lvl, colorscheme)
logger.debug("Colors: {}".format(colors))
return [*first_line, *second_line[1:]], [
*colors[-len(first_line) + 1:], *colors[len(second_line[1:])::-1]
], [*iso_lvl, *iso_lvl[::-1]]
def get_colorgrid(X,
colorscheme,
method="equal_density",
num_of_levels=8,
min_value=0.,
max_value=1.,
split=True,
min_border=None,
*args,
**kwargs):
"""
Takes a 2D-Grid and maps it to a color-scheme. Therefor it generates a colormap with the given number of levels
:param X: 2D-Grid with single values
:param colorscheme: color-scheme from color_schemes
:param num_of_levels:
:param min_value:
:param max_value:
:param split:
:param min_border:
:return: 2D-Grid with color values from the color-scheme
"""
check_constrains(min_value, max_value)
logger.debug("Min: {} | Max: {}".format(min_value, max_value))
# generate colors to chose from
norm = iso_lines.get_iso_levels(X,
method=method,
num_of_levels=num_of_levels + 2)
norm = get_color_middlepoint(norm, min_value, max_value)
colormap = colorscheme(levels=norm, *args, **kwargs)
# replace points in image with matching colors
levels = iso_lines.get_iso_levels(X,
method=method,
num_of_levels=num_of_levels)
return color_operations.map_colors(X,
colormap,
levels,
split,
lower_border=min_border)
def input_image(ax,
distribution,
z_sum=None,
num_of_pies_x=10,
num_of_pies_y=0,
angle=0,
set_limit=False,
iso_level=8,
level_to_cut=1,
contour_method="equal_density",
colorschemes=color_schemes.get_colorbrewer_schemes(),
modus="light",
borders=None,
scale=1.,
xlim=None,
ylim=None):
limits = helper.get_limits(distribution, xlim, ylim)
if borders is None:
if modus == "size":
borders = [0.1, 1]
else:
borders = [.2, .9]
if set_limit:
ax.set_xlim([limits.x_min, limits.x_max])
ax.set_ylim([limits.y_min, limits.y_max])
if num_of_pies_y == 0:
num_of_pies_y = get_distance_ratio(num_of_pies_x, limits)
container, distances = container_size(num_of_pies_x, num_of_pies_y, limits)
if z_sum is None:
z_list = helper.generate_distribution_grids(distribution, limits)
z_min, z_max, z_sum = helper.generate_weights(z_list)
else:
z_min = np.min(z_sum)
z_max = np.max(z_sum)
if iso_level:
if 0 < level_to_cut <= iso_level:
barrier = iso_lines.get_iso_levels(z_sum, contour_method,
iso_level)[level_to_cut - 1]
else:
if level_to_cut > 0:
logger.warning(
"Point to cut[{}] is not in iso-level[{}]. Using pie-charts without point to cut"
.format(level_to_cut, iso_level))
barrier = None
else:
barrier = None
lw_borders = [
iso_lines.get_iso_levels(
i.get_density_grid(i.size, limits.x_min, limits.x_max,
limits.y_min, limits.y_max)[2])[0]
for i in distribution
]
for k in container[0][0]:
for l in container[1]:
middle_point = k, l[0]
input_values = []
for j in range(len(distribution)):
input_values.append(distribution[j].get_density(middle_point))
if not barrier:
generate_pie(ax, middle_point, input_values, angle, distances,
z_min, z_max, borders, modus, colorschemes, scale,
lw_borders)
elif sum(input_values) > barrier:
generate_pie(ax, middle_point, input_values, angle, distances,
z_min, z_max, borders, modus, colorschemes, scale,
lw_borders)
def calculate_image(
z_list,
z_min,
z_max,
z_sum,
colorschemes,
method="equal_density",
num_of_levels=8,
color_space="lab",
use_c_implementation=False,
mode="hierarchic",
blending_operator=hierarchic_blending_operator.porter_duff_source_over,
borders=None,
min_gauss=False,
lower_border=None,
lower_border_to_cut=0):
"""
generates a merged image from multiple density-grids with same shape
:param z_list: list of densities each one with the same shape [density_1, ... , density_n]
:param z_min: minimal density occurring in the z_list min([density_1, ... , density_n])
:param z_max: maximal density occurring in the z_list max([density_1, ... , density_n])
:param z_sum:
:param colorschemes: colorschemes to use for each density-grid
:param method: method with which the distance between contour-lines is chosen
:param num_of_levels: number of contour-lines to use
:param color_space: colorspace to merge the images in "rgb" or "lab"
:param use_c_implementation: run the merging process with the c-implementation
:param mode: sets the mode to use. Defaults is hierarchic and defaults to hierarchic
:param blending_operator: operator with which the pictures are merged
:param borders: min and max color from colorspace which is used from 0. to 1.
:param min_gauss: uses minimal gaussian for the threshold for colors
:param lower_border: min alpha value which is shown in each vis
:param lower_border_to_cut:
:return: colorgrid with merged image
"""
if borders is None:
borders = [0, 1]
if lower_border:
if lower_border_to_cut < 0:
barrier = 0
else:
if min_gauss:
barrier = z_max
for i in z_list:
new_barrier = iso_lines.get_iso_levels(
i, method, lower_border)[lower_border_to_cut]
if new_barrier < barrier:
barrier = new_barrier
else:
barrier = iso_lines.get_iso_levels(
z_sum, method, lower_border)[lower_border_to_cut]
else:
barrier = None
logger.debug("Lower Barrier is: {}".format(barrier))
if len(z_list) == 1:
img, _ = get_colorgrid(z_list[0],
**colorschemes[0],
method=method,
num_of_levels=num_of_levels,
min_value=borders[0],
max_value=borders[1],
split=True,
min_border=barrier,
lvl_white=0 if not (barrier is None) else 1)
return img, z_list[0]
img_list = generate_img_list(z_list,
z_min,
z_max,
colorschemes,
*borders,
method=method,
num_of_levels=num_of_levels,
min_border=barrier,
lvl_white=0 if not (barrier is None) else 1)
return combine_multiple_images_hierarchic(
img_list,
z_list,
blending_operator,
color_space=color_space,
use_c_implementation=use_c_implementation,
mode=mode)