def plotClustering(clustering,
dimension=2,
colors=['cyan', 'magenta'],
centercol='blue',
title=None):
coords = [] # contains one list of coordinate lists for each cluster
for i in range(len(clustering.keys())):
coords.append([]) # for each cluster one list
for j in range(dimension): # for each dimension one list of coords
coords[i].append([])
for point in clustering[list(clustering.keys())[i]]:
coords[i][j].append(
point[j]) # for each point store the respective coordinate
for sets in coords:
if len(
colors
) == 0: # if colors end up empty, generate random new color for next cluster
cyan = col.to_rgb(col.get_named_colors_mapping()['cyan'])
magenta = col.to_rgb(col.get_named_colors_mapping()['magenta'])
c = np.random.rand(3, )
while (c == cyan).all() or (c == magenta).all():
c = np.random.rand(3, )
plt.scatter(sets[0], sets[1], color=c)
else:
plt.scatter(sets[0], sets[1], color=colors[0])
colors = colors[1:]
# draw the centers:
for center in clustering.keys():
plt.scatter(center[0], center[1], color=centercol, marker='x', s=200)
plt.xlabel('Eruption Time')
plt.ylabel('Waiting Time')
plt.title(title)
plt.show()
def get_color(*args):
"""Convert color name of XKCD color name survey to RGBA tuple.
Args:
List of color names. If the list is empty, a full list of
available color names is returned. Otherwise the first valid
color in the list is returned as RGBA tuple. If no color is
valid None is returned.
"""
try:
from matplotlib import colors
except ImportError as err:
raise ImportError(
"requires package matplotlib: "
"https://matplotlib.org") from err
if not args:
clist = list(colors.get_named_colors_mapping().keys())
return sorted([cname[5:].title() \
for cname in clist if cname[:5] == 'xkcd:'])
rgb = None
for cname in args:
try:
rgb = colors.to_rgb('xkcd:%s' % cname)
break
except ValueError:
continue
return rgb
def recolour_image(weight_maps, colours):
# weight maps are grayscale
colour_mapping = mc.get_named_colors_mapping()
colour_vals = np.array(
[mc.to_rgb(colour_mapping[cname]) for cname in colours])
bwms = (binarize_weights(wm) for wm in weight_maps)
# ensuring that the 0 values are translated to white we want to
# add 1 to each (0,0,0) of the binarized wm so instead of figuring
# out whatever weird broadcasting method might exist or looping
# over slowly, just -1 from the colours we are weighting by,
# multiply in the shifted colours, and then add 1 to the whole image
coloured_wms = np.array([(c[np.newaxis, np.newaxis, ...] - 1) * wm + 1
for c, wm in zip(colour_vals, map(gray2rgb, bwms))
])
fused = np.ones_like(coloured_wms[0]) # shape: (NxMx3)
# want the colour of the fused image to be that of largest
# magnitude of the original weight maps
brightest = np.max(weight_maps, axis=0)
for wm, c in zip(weight_maps, colour_vals):
fused[wm >= brightest] = c
return coloured_wms, fused
def get_color(*args):
"""Convert color name of XKCD color name survey to RGBA tuple.
Args:
List of color names. If the list is empty, a full list of
available color names is returned. Otherwise the first valid
color in the list is returned as RGBA tuple. If no color is
valid None is returned.
"""
try:
import matplotlib.colors as colors
except ImportError:
raise ImportError("nemoa.common.plot.get_color() requires matplotlib: "
"https://matplotlib.org")
if len(args) == 0:
clist = list(colors.get_named_colors_mapping().keys())
return sorted([cname[5:].title() \
for cname in clist if cname[:5] == 'xkcd:'])
rgb = None
for cname in args:
try:
rgb = colors.to_rgb('xkcd:%s' % cname)
break
except ValueError:
continue
return rgb
def setcolor(self,colorname='white', opacity=0.0):
colorlist = colors.get_named_colors_mapping().keys()
if colorname not in colorlist:
colorname = "xkcd:"+colorname
if colorname not in colorlist:
colorname = 'white'
self.color = np.array(colors.to_rgb(colorname))
self.opacity = opacity
True
def sms_ahoy_reply():
number = request.form['From']
message_body = request.form['Body']
print(number)
print(message_body)
hex_match = re.search(r'^#(?:[0-9a-fA-F]{3}){1,2}$', message_body.lower())
if message_body.lower() not in colors.get_named_colors_mapping(
) and not hex_match:
if predict([message_body])[0] < 0.7:
App.set_message(self=tkapp, message=message_body)
if message_body.lower == '/r':
App.reset_message()
message_body = random.choice(
list(colors.get_named_colors_mapping().values()))
elif not hex_match:
message_body = colors.get_named_colors_mapping()[message_body.lower()]
App.set_colour(self=tkapp, color=message_body)
App.set_lastnumber(self=tkapp, phone_number=number)
return None
def list_named_colors(show=None, color_format='rgb255'):
''' List all named colors in matplotlib.
Args:
show (None | str): the way to list the colors. if show is None,
this function only return color_dict. Else show is 'print',
this function print names and colors on screen. Or, this
function treats show as a file and put names and colors in
this file.
color_format (str): the format of color, only can be 'rgb',
'rgb255', 'hex'.
Returns:
if out is None, reture
'''
# Build format functions for different color_format.
assert color_format in ['rgb', 'rgb255', 'hex']
if color_format == 'rgb':
def _format_func(color):
color = mpl_colors.to_rgb(color)
color_str = f'({color[0]:.3f}, {color[1]:.3f}, {color[2]:.3f})'
return color, color_str
elif color_format == 'rgb255':
def _format_func(color):
color = mpl_colors.to_rgb(color)
color = tuple([int(round(255 * c)) for c in color])
return color, str(color)
else:
def _format_func(color):
color = mpl_colors.to_hex(color)
return color, color
# Use _format_func to format colors.
ori_color_dict = mpl_colors.get_named_colors_mapping()
color_dict, color_doc = {}, ''
for name, color in ori_color_dict.items():
color, color_str = _format_func(color)
color_dict[name] = color
color_doc += name + '$' + ' ' * max(25 - len(name),
1) + color_str + '\n'
# Different ways to show names and colors.
if show is not None:
assert isinstance(show, str)
if show == 'print':
print(color_doc)
else:
assert not osp.exists(show)
with open(show, 'w') as f:
f.writelines(color_doc)
return color_dict
def getColorFromName(name):
if name.find("#") == 0:
return (name)
colors = mcolors.get_named_colors_mapping()
color = None
if name in colors:
color = colors[name]
return (color)
def set_color(self, color):
if type(color) is list:
color = tuple(color)
elif isinstance(color, str):
print("Converting color string to color")
aux = colors.get_named_colors_mapping()[color]
aux = aux.replace('#', '')
aux = list(map(''.join, zip(*[iter(aux)] * 2)))
aux = [int(aux[i], 16) for i in range(len(aux))]
color = tuple(aux)
color = (int(color[0]), int(color[1]), int(color[2]))
self.color = color
def make_colours(n, color=None, **kwds):
if color is None:
color = get_named_colors_mapping().keys()
if isinstance(color, collections.Iterable):
color = list(color)
if isinstance(color, str) or (isinstance(color, (list, tuple))
and len(color) == 3):
color = [color]
if not isinstance(color, np.ndarray):
color = np.array(color)
if color.shape[0] < n:
color = np.tile(color, 1 + n // color.shape[0])
return color[0:n]
def test_named(self):
"""Named color parsing..."""
_config_reset()
# Try all known Matplotlib colors.
for color in get_named_colors_mapping().keys():
_config.read_kwargs(axes_background=color)
assert _config['pgfutils'].getcolor('axes_background') == color
# And check it rejects non-existent named colors.
with pytest.raises(ColorError):
_config.read_kwargs(axes_background='nonexistentuglycolor')
_config['pgfutils'].getcolor('axes_background')
def create_plots(data, read_data, attrs, name, output_dir, project, color=None, legend=None):
print("Creating " + name + " plots")
if not isinstance(data, list):
data = [data]
if not isinstance(attrs, list):
attrs = [attrs]
if color is None:
color = []
for index in range(len(data)):
color.append(random.choice(list(colors.get_named_colors_mapping().keys())))
elif not isinstance(color, list):
color = [color]
while len(color) < len(data):
color.append(random.choice(list(colors.get_named_colors_mapping().keys())))
if legend is None:
legend = []
if legend is not None and not isinstance(legend, list):
legend = [legend]
while len(legend) < len(data):
legend.append("Set " + str(len(legend) + 1))
snpMAF = []
for (index, data_item) in enumerate(data):
mm = SNPModule(data=data_item, attributes=attrs[index])
snpMAF.append({k: v["maf"] for (k, v) in data_item.items()})
DartGraphs.call_rates_across_snp(data=data, outfile=os.path.join(output_dir, project + "_" + name +"_CallRatesAcrossSNP" + GRAPH_IMG_TYPE), color=color, legend=legend)
DartGraphs.call_rate_across_individ(data=data, outfile=os.path.join(output_dir, project + "_" + name + "_CallRatesAcrossIndivid" + GRAPH_IMG_TYPE), color=color, legend=legend)
DartGraphs.maf_across_snp(snp_maf=snpMAF, outfile=os.path.join(output_dir, project + "_" + name + "_MAFAcrossSNP" + GRAPH_IMG_TYPE), color=color, legend=legend)
DartGraphs.maf_to_read_count(snp_maf=snpMAF, read_data=read_data, outfile=os.path.join(output_dir, project + "_" + name + "_MAFToReadCount" + GRAPH_IMG_TYPE), color=color, legend=legend)
DartGraphs.call_rate_to_maf(data=data, snp_maf=snpMAF, outfile=os.path.join(output_dir, project + "_" + name + "_CallRateToMAF" + GRAPH_IMG_TYPE), color=color, legend=legend)
def plot2D(X, labels=None):
assert X.shape[1] == 2
x = X[:,0]
y = X[:,1]
colors = list(mcolors.get_named_colors_mapping().keys())[-19:-9]
if labels is not None:
for i in range(len(labels)):
plt.scatter(x[i],y[i],color=colors[int(labels[i])])
plt.annotate(labels[i], (x[i],y[i]))
else:
plt.scatter(x,y)
plt.show()
def make_module_code():
elements = [
header_template.format(timestamp=datetime.utcnow().isoformat(),
version=matplotlib.__version__),
make_enum_code("BaseColor", mcolors.BASE_COLORS),
make_enum_code("TableauColor", grey_duplicates(mcolors.TABLEAU_COLORS),
lambda s: s[4:]),
make_enum_code("XkcdColor", grey_duplicates(mcolors.XKCD_COLORS),
lambda s: s[5:]),
make_enum_code("Css4Color", mcolors.CSS4_COLORS),
make_enum_code("Color", mcolors.get_named_colors_mapping()),
]
s = "\n\n\n".join(elements) + "\n"
return black.format_str(s, mode=black.FileMode({black.TargetVersion.PY36}))
def aggregate_maps(self, G=[], node_tags={}):
"""
Takes a list of DiGraphs and aggregates common edges between nodes to create an aggregate graph.
Attach aggregate graph as an attribute to CoMap object.
Parameters
----------
G : list
List of DiGraps
node_tags : dict
Dictionary mapping node numbers to labels, e.g {0:'A',1:'cat',2:'family',...}
Returns
-------
None
"""
self.map = nx.DiGraph()
# loop over graphs in list of graphs
for g in G:
# add nodes to graph
self.map.add_nodes_from(g.nodes())
# loop over edges
for edge in g.edges(data=True):
# if edge is already present, add weight to edge
if self.map.has_edge(edge[0], edge[1]):
self.map[edge[0]][edge[1]]['weight'] += edge[2]['weight']
# if edge is not already present, add it with weight=1
else:
self.map.add_edge(edge[0], edge[1], weight=1)
# relabel nodes according to mapping provided by 'node_tags'
nx.set_node_attributes(self.map, name='node_label', values=node_tags)
nx.relabel_nodes(self.map, mapping=node_tags, copy=False)
# assign a random color to each node
colour_list = np.random.choice(
list(colors.get_named_colors_mapping().values()), len(self.map))
colour_dict = dict(zip(self.map.nodes, colour_list))
nx.set_node_attributes(self.map, name='node_color', values=colour_dict)
# save node attributes to CoMap object
self.node_labels = nx.get_node_attributes(self.map, name='node_label')
self.node_colors = nx.get_node_attributes(self.map, name='node_color')
return
def getColor(self, name):
if name.find("#") == 0:
return (name)
colors = mcolors.get_named_colors_mapping()
color = None
if name in colors:
color = colors[name]
elif name == "lightest":
color = self.lightest
elif name == "darkest":
color = self.darkest
return (color)
def ValueToString(self, value, flag):
ret_str = ''
mpl_colors_values_list = list(mpl_utils.MPL_COLORS.values())
if wx.Colour(value) in mpl_colors_values_list:
idx = mpl_colors_values_list.index(wx.Colour(value))
ret_str = list(mpl_utils.MPL_COLORS.keys())[idx]
#
mpl_colors_od = OrderedDict(mcolors.get_named_colors_mapping())
mpl_colors_values_list = list(mpl_colors_od.values())
#
if not ret_str:
value = tuple(c / 255 for c in value)
if value in mpl_colors_values_list:
idx = mpl_colors_values_list.index(value)
ret_str = list(mpl_colors_od.keys())[idx]
#
if not ret_str:
value = mcolors.to_hex(value)
if value in mpl_colors_values_list:
idx = mpl_colors_values_list.index(value)
ret_str = list(mpl_colors_od.keys())[idx]
else:
ret_str = value
#
if ret_str == 'k':
ret_str = 'Black'
elif ret_str == 'w':
ret_str = 'White'
elif ret_str == 'b':
ret_str = 'Blue'
elif ret_str == 'g':
ret_str = 'Green'
elif ret_str == 'r':
ret_str = 'Red'
elif ret_str == 'c':
ret_str = 'Cyan'
elif ret_str == 'm':
ret_str = 'Magenta'
elif ret_str == 'w':
ret_str = 'Yellow'
elif ':' in ret_str:
ret_str = ret_str.split(':')[-1]
#
ret_str = ret_str.capitalize()
#
return ret_str
def visualize(self, X, labels=None):
""" Visualize input 2D embeddings.
Arguments:
X: a (N' x d) data matrix (NumPy array)
labels: a (N' x 1) matrix of numeric labels (NumPy array) - optional
"""
X = self.reshape_data(X)
projections = self.project_all(X)
x = projections[:, 0]
y = projections[:, 1]
colors = list(mcolors.get_named_colors_mapping().keys())[-19:-9]
if labels is not None:
for i in range(len(labels)):
plt.scatter(x[i], y[i], color=colors[int(labels[i])])
plt.annotate(labels[i], (x[i], y[i]))
else:
plt.scatter(x, y)
plt.show()
def colour_by_log_val(graph, branches, logs, get_log_val, \
cmap='seismic', \
norm=colors.Normalize(vmin=1, vmax=7)):
grey = colors.get_named_colors_mapping()['tab:gray']
grey = colors.to_rgba(grey)
cmap = plt.get_cmap(cmap)
colours = []
for commit in graph.nodes:
try:
log = logs[commit]
#should be normalised between 0 and 1
log_val = get_log_val(log)
colour = cmap(norm(log_val))
colours.append(colour)
#print(log_val, colour)
except Exception as e:
#print('log_val not found')
#print(e)
colours.append(grey)
return colours, cmap, norm
def colorname_to_hex(name):
return colors.get_named_colors_mapping()[name]
def create_bar_graph(y, title, x_tick_labels, x_label, y_label, outfile, color=None, legend=None):
# ax = pyplot.axes([0.1, 0.1, 0.8, 0.8])
fig, ax = pyplot.subplots()
fig.set_size_inches(15, 9)
if not isinstance(y, list):
y = [y]
if color is None:
color = []
for index in range(len(y)):
color.append(random.choice(list(colors.get_named_colors_mapping().keys())))
elif not isinstance(color, list):
color = [color]
while len(color) < len(y):
color.append(random.choice(list(colors.get_named_colors_mapping().keys())))
if legend is None:
legend = []
if legend is not None and not isinstance(legend, list):
legend = [legend]
while len(legend) < len(y):
legend.append("Set " + str(len(legend) + 1))
if len(y) == 0:
return
# x = range(len(y[0]))
x = numpy.arange(len(y[0]))
width = .8 / len(y)
legend_handles = []
# print(color)
# Add the graph data
for (index, val) in enumerate(y):
ax.bar(x + ((index * width) + (width / 2) - 0.4), val, width, color=color[index])
if legend is not None:
patch = patches.Patch(color=color[index], label=legend[index])
legend_handles.append(patch)
if len(legend_handles) > 0:
pyplot.legend(handles=legend_handles)
# Make the labels look nicer.
ax.set_title(title, fontdict={'weight': 'bold', 'size': 'large'})
ax.set_xticklabels(x_tick_labels, fontdict={'style': 'italic'}, rotation=45)
ax.set_xlabel(x_label, fontdict={'weight': 'bold'})
ax.set_ylabel(y_label, fontdict={'weight': 'bold'})
ax.set_xticks(x)
# Make the x-axis labels light up correctly
for tick in ax.xaxis.get_majorticklabels():
tick.set_horizontalalignment("right")
# Save the graph to file
pyplot.savefig(outfile, bbox_inches='tight')
pyplot.close(fig)
# Test Screen Clear
SimpleClear()
# Create 1, 2 and 3 dimensional lists
a = SimpleDim(5)
print(a)
a = SimpleDim(5, 4)
print(a)
a = SimpleDim(5, 4, 3)
print(a)
print(is_color_like('Saddlebrown'))
print(is_color_like('#F0123A'))
print(is_color_like('red'))
print(is_color_like('marzian'))
print(get_named_colors_mapping())
print(is_color_like(None))
SimpleGrColor('Saddlebrown')
SimpleBeep()
# Test Graphics mode
SimpleGr()
#help(Canvas)
#print( canvas.config())
#exit(0)
SimpleGrPlot(0, 0)
SimpleGrPlot(0, 1)
def create_scatter_plot(x, y, title, x_tick_labels, x_label, y_label, outfile, color="blue", legend=None, x_ticks=None):
# ax = pyplot.axes([0.1, 0.1, 0.8, 0.8])
fig, ax = pyplot.subplots()
fig.set_size_inches(15, 9)
width = .5
if not isinstance(y, list):
y = [y]
if not isinstance(x, list):
x = [x]
if color is None:
color = []
for index in range(len(y)):
color.append(random.choice(list(colors.get_named_colors_mapping().keys())))
elif not isinstance(color, list):
color = [color]
while len(color) < len(y):
color.append(random.choice(list(colors.get_named_colors_mapping().keys())))
if legend is None:
legend = []
if legend is not None and not isinstance(legend, list):
legend = [legend]
while len(legend) < len(y):
legend.append("Set " + str(len(legend)))
if len(y) == 0:
return
legend_handles = []
# Add the graph data
for (index, val) in enumerate(y):
ax.scatter(x[index], val, width, color=color[index])
if legend is not None:
patch = patches.Patch(color=color[index], label=legend[index])
legend_handles.append(patch)
if len(legend_handles) > 0:
pyplot.legend(handles=legend_handles)
# Make the labels look nicer.
ax.set_title(title, fontdict={'weight': 'bold', 'size': 'large'})
ax.set_xlabel(x_label, fontdict={'weight': 'bold'})
ax.set_ylabel(y_label, fontdict={'weight': 'bold'})
if x_ticks is not None:
ax.set_xticks(x_ticks)
# Set the x axis labels
if x_tick_labels is not None:
ax.set_xticklabels(x_tick_labels, fontdict={'style': 'italic'})
# for tick in ax.xaxis.get_majorticklabels():
# tick.set_horizontalalignment("right")
# Save the graph to file
pyplot.savefig(outfile, bbox_inches='tight')
pyplot.close(fig)
from __future__ import division
import rospy
import numpy as np
from matplotlib.colors import get_named_colors_mapping, to_rgb
from geometry_msgs.msg import Point
from visualization_msgs.msg import Marker
from math_utils import rot_unit_vectors
COLOR_MAP = get_named_colors_mapping()
def color_to_rgb_float(color):
if isinstance(color, str):
color = to_rgb(COLOR_MAP[color])
if isinstance(color, tuple) and isinstance(color[0], int):
color = (color[0]/255, color[1]/255, color[2]/255)
return color
def colored_marker(color, alpha=1.0):
color = color_to_rgb_float(color)
m = Marker()
m.color.r = color[0]
m.color.g = color[1]
m.color.b = color[2]
m.color.a = alpha
m.pose.orientation.w = 1.0
return m
def car_marker(body_frame_id, color = "red", alpha=1.0, CAR_X = 4.22100019455, CAR_Y = 1.76199996471, CAR_dX = 1.3654999733):
m = colored_marker(color, alpha)
m.header.frame_id = body_frame_id
def from_hex_color(color_name):
raw_col = colors.get_named_colors_mapping()["xkcd:" +
color_name].lstrip('#')
color = tuple(int(raw_col[i:i + 2], 16) for i in (0, 2, 4))
return color[0] / 256.0, color[1] / 256.0, color[2] / 256.0
plt.subplot(num_rows+1, n, plot_element+1)
image = image_data_flat[row[r], :]
image = image.reshape(28, 28)
plt.imshow(image)
plt.axis('off')
plot_element += 1
plt.show()
if __name__ == "__main__":
color_list = mcolors.get_named_colors_mapping()
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
data_train = x_train.reshape(len(x_train), -1)
data_test = x_test.reshape(len(x_test), -1)
labels_train = y_train
labels_test = y_test
clusters = cluster_digit_images(data_test, 10)
plot_clusters(clusters, data_test, 10)
from rpi_ws281x import *
except:
from neopixel_stub import *
try:
# Python 3
import http.client as http
except:
# Python 2
import httplib as http
import numpy as np
import font454
from matplotlib import colors as mcolors
COLORS = mcolors.get_named_colors_mapping()
from flask import Flask, request, render_template
app = Flask(__name__)
# LED strip configuration:
LED_PIN = 18 # GPIO pin connected to the pixels (18 uses PWM!).
# LED_PIN = 10 # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0).
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10 # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 127 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
args = parser.parse_args()
num_games = args.num_games
num_moves = args.num_moves
print("Simulating %d games with %d moves each." % (num_games, num_moves))
num_fields = 40
board = np.zeros(num_fields)
profit_0 = np.zeros(num_fields)
chance_fields = [FieldPos.CHANCE_1, FieldPos.CHANCE_2, FieldPos.CHANCE_3]
community_fields = [
FieldPos.COMMUNITY_1, FieldPos.COMMUNITY_2, FieldPos.COMMUNITY_3
]
color = colors.get_named_colors_mapping()
# Rents from
# http://www.math.yorku.ca/~zabrocki/math2042/Monopoly/prices.html
board_fields = [
Field("Start", color['springgreen']),
Field("Mediterranean Avenue", color['sienna'], 2),
Field("Community Chest", color['gray']),
Field("Baltic Avenue", color['sienna'], 4),
Field("Income Tax", color['gray']),
Station("Reading Railroad", color['black']),
Field("Oriental Avenue", color['skyblue'], 6),
Field("Chance", color['gray']),
Field("Vermont Avenue", color['skyblue'], 6),
Field("Conneticut Avenue", color['skyblue'], 8),
Field("Jail", color['springgreen']),
Field("St. Charles Place", color['violet'], 10),
def get_colors():
return list(
filter(not_white,
mpl_colors.get_named_colors_mapping().values()))
import matplotlib.pyplot as plt
from matplotlib.colors import ColorConverter, ListedColormap, get_named_colors_mapping
import matplotlib.patches as mpatches
DEFAULT_VMIN = 0
DEFAULT_VMAX = 1
DEFAULT_COLORMAP = 'gray'
THRESHOLD = 0.0
def make_colormap(color):
colors = [np.array(color) / 255 * i for i in range(256)]
return ListedColormap(colors)
NAMED_COLORS = get_named_colors_mapping()
COLORS = [
ColorConverter.to_rgb(NAMED_COLORS[color])
for color in ('tab:blue', 'tab:orange', 'tab:green', 'tab:red',
'tab:purple', 'tab:brown', 'tab:pink', 'tab:gray',
'tab:olive', 'tab:cyan', 'lime', 'gold', 'indigo', 'w')
]
COLORMAPS = [make_colormap(COLOR) for COLOR in COLORS]
def fuse_canals(im,
colors=COLORS,
threshold=THRESHOLD,
labels=None,
initial=0,
legend_anchor=(1, 0.5)):
"appelgroenvergrijsd": (137, 157, 12),
"violet": (172, 33, 142),
"lichtgrijs": (224, 224, 224), # 12% zwart
"grijs": (102, 102, 102), # 60% zwart
"logogrijs": (115, 115, 115), # 55% zwart
"codekleur": (88, 88, 88),
}
# prepend 'cbs:' to all color names to prevent collision
CBS_COLORS = {
"cbs:" + name: (value[0] / 255, value[1] / 255, value[2] / 255)
for name, value in CBS_COLORS_RBG.items()
}
# update the matplotlib colors
mcolors.get_named_colors_mapping().update(CBS_COLORS)
# deze dictionairy bevat meerdere palettes
CBS_PALETS = dict(koel=[
"cbs:corporatelichtblauw",
"cbs:donkerblauw",
"cbs:appelgroen",
"cbs:grasgroen",
"cbs:oranje",
"cbs:roze",
],
warm=[
"cbs:rood",
"cbs:geel",
"cbs:roze",
"cbs:oranje",
def test_named_color_hex(self):
"""Test if the 'ty:uhh-red' hex-value is correct."""
assert mcolors.get_named_colors_mapping()['ty:uhh-red'] == '#ee1d23'
def test_named_color_mapping(self):
"""Test if the typhon colors are available in the name mapping."""
assert all([
c in mcolors.get_named_colors_mapping()
for c in colors.TYPHON_COLORS.keys()
])
def __init__(self,
ax,
colormap=None,
bin_size=5,
transpose=False,
events=["press", "hover"]):
self.ax = ax
if colormap is None:
colormap = mcolors.get_named_colors_mapping()
rgb = dict([(n, mcolors.to_rgb(c)) for n, c in colormap.iteritems()])
hsv = dict([(n, mcolors.rgb_to_hsv(c)) for n, c in rgb.iteritems()])
colors = [
n for n, c in rgb.iteritems() if all([v != c[0] for v in c[1:]])
]
groups = {}
bins = np.arange(0, 360, bin_size) * (1.0 / 360)
names, hues = zip(*[(n, h) for n, (h, s, v) in hsv.iteritems()])
for gr, name in zip(np.digitize(hues, bins), names):
if gr not in groups:
groups[gr] = []
groups[gr].append(name)
self.state = {"selected": None, "background": None}
self.swatches = []
self.rgb_to_swatch, self.label_to_swatch = {}, {}
ordered = lambda c: (c[2], c[1] * -1.0, c[0])
max_y = 0
for x, grp in enumerate(
sorted(groups.itervalues(), key=lambda v: hsv[v[0]][0])):
for y, name in enumerate(sorted(grp,
key=lambda n: ordered(hsv[n]))):
if transpose:
r = plt.Rectangle((y + 0.1, x + 0.1),
0.8,
0.8,
color=rgb[name])
else:
r = plt.Rectangle((x + 0.1, y + 0.1),
0.8,
0.8,
color=rgb[name])
ax.add_artist(r)
sw = Swatch(r, name, self.state)
sw.connect(events)
self.swatches.append(sw)
self.rgb_to_swatch[rgb[name]] = sw
self.label_to_swatch[name] = sw
if y > max_y:
max_y = y
if transpose:
ax.set_xlim(0, max_y + 1), ax.set_ylim(0, len(groups))
else:
ax.set_xlim(0, len(groups)), ax.set_ylim(0, max_y + 1)
ax.set_axis_off()
ax.figure.subplots_adjust(left=0.02,
right=0.98,
top=0.98,
bottom=0.02,
hspace=0,
wspace=0)
self.state["background"] = ax.get_figure().canvas.copy_from_bbox(
ax.bbox)
