def IsValidColour(self, color):
"""Checks if color is a valid matplotlib color"""
try:
cc = ColorConverter()
cc.to_rgb(color)
return True
except ValueError: #invalid color
return False
def IsValidColour(self, color):
"""Checks if color is a valid matplotlib color"""
try:
cc = ColorConverter()
cc.to_rgb(color)
return True
except ValueError: #invalid color
return False
def drawOn(self, canv, x, y, _sW=0):
if _sW and hasattr(self, 'hAlign'):
from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT
a = self.hAlign
if a in ('CENTER', 'CENTRE', TA_CENTER):
x = x + 0.5 * _sW
elif a in ('RIGHT', TA_RIGHT):
x = x + _sW
elif a not in ('LEFT', TA_LEFT):
raise ValueError("Bad hAlign value " + str(a))
height = 0
if HAS_MATPLOTLIB:
global fonts
canv.saveState()
canv.translate(x, y)
try:
(
width,
height,
descent,
glyphs,
rects,
used_characters,
) = self.parser.parse(enclose(self.s),
72,
prop=FontProperties(size=self.fontsize))
for ox, oy, fontname, fontsize, num, symbol_name in glyphs:
if fontname not in fonts:
fonts[fontname] = fontname
pdfmetrics.registerFont(TTFont(fontname, fontname))
canv.setFont(fontname, fontsize)
col_conv = ColorConverter()
rgb_color = col_conv.to_rgb(self.color)
canv.setFillColorRGB(rgb_color[0], rgb_color[1],
rgb_color[2])
canv.drawString(ox, oy, chr(num))
canv.setLineWidth(0)
canv.setDash([])
for ox, oy, width, height in rects:
canv.rect(ox, oy + 2 * height, width, height, fill=1)
except Exception:
# FIXME: report error
col_conv = ColorConverter()
rgb_color = col_conv.to_rgb(self.color)
canv.setFillColorRGB(rgb_color[0], rgb_color[1], rgb_color[2])
canv.drawString(0, 0, self.s)
canv.restoreState()
else:
canv.saveState()
canv.drawString(x, y, self.s)
canv.restoreState()
if self.label:
log.info('Drawing equation-%s' % self.label)
canv.bookmarkHorizontal('equation-%s' % self.label, 0, height)
def linear_gradient(cstart, cend, n=10):
'''
Return a gradient list of `n` colors going from `cstart` to `cend`.
'''
s = np.array(ColorConverter.to_rgb(cstart))
f = np.array(ColorConverter.to_rgb(cend))
rgb_list = [s + (t / (n - 1)) * (f - s) for t in range(n)]
return rgb_list
def validate_color(self, color):
""" Function for validating Matplotlib user input color choice
"""
print color
c = ColorConverter()
try:
print c.to_rgb(color)
except:
return False
return True
def colorMask(v1, v2):
cc = ColorConverter()
mask = []
for i in range(len(v1)):
if v1[i] == v2[i]:
mask.append(cc.to_rgb("black"))
elif v1[i] < v2[i]:
mask.append(cc.to_rgb("red"))
else:
mask.append(cc.to_rgb("blue"))
return mask
def set_legend_to_bw(leg, style, colormap, line_style='continuous'):
"""
Takes the figure legend and converts it to black and white. Note that
it currently only converts lines to black and white, other artist
intances are currently not being supported, and might cause errors or
other unexpected behavior.
Parameters
----------
leg : legend
style : {GREYSCALE, HATCHING}
colormap : dict
mapping of color to B&W rendering
line_style: str
linestyle to use for converting, can be continuous, black
or None
# TODO:: None is strange as a value, and should be field based, see
# set_ax_lines_bw
"""
color_converter = ColorConverter()
if leg:
if isinstance(leg, list):
leg = leg[0]
for element in leg.legendHandles:
if isinstance(element, mpl.collections.PathCollection):
rgb_orig = color_converter.to_rgb(element._facecolors[0])
new_color = color_converter.to_rgba(colormap[rgb_orig]['fill'])
element._facecolors = np.array((new_color, ))
elif isinstance(element, mpl.patches.Rectangle):
rgb_orig = color_converter.to_rgb(element._facecolor)
if style == HATCHING:
element.update({'alpha': 1})
element.update({'facecolor': 'none'})
element.update({'edgecolor': 'black'})
element.update({'hatch': colormap[rgb_orig]['hatch']})
elif style == GREYSCALE:
ema_logging.info(colormap.keys())
element.update({'facecolor': colormap[rgb_orig]['fill']})
element.update({'edgecolor': colormap[rgb_orig]['fill']})
else:
line = element
orig_color = line.get_color()
line.set_color('black')
if not line_style == 'continuous':
line.set_dashes(colormap[orig_color]['dash'])
line.set_marker(colormap[orig_color]['marker'])
line.set_markersize(MARKERSIZE)
def set_legend_to_bw(leg, style, colormap, line_style='continuous'):
"""
Takes the figure legend and converts it to black and white. Note that
it currently only converts lines to black and white, other artist
intances are currently not being supported, and might cause errors or
other unexpected behavior.
Parameters
----------
leg : legend
style : {GREYSCALE, HATCHING}
colormap : dict
mapping of color to B&W rendering
line_style: str
linestyle to use for converting, can be continuous, black
or None
# TODO:: None is strange as a value, and should be field based, see
# set_ax_lines_bw
"""
color_converter = ColorConverter()
if leg:
if isinstance(leg, list):
leg = leg[0]
for element in leg.legendHandles:
if isinstance(element, mpl.collections.PathCollection):
rgb_orig = color_converter.to_rgb(element._facecolors[0])
new_color = color_converter.to_rgba(colormap[rgb_orig]['fill'])
element._facecolors = np.array((new_color,))
elif isinstance(element, mpl.patches.Rectangle):
rgb_orig = color_converter.to_rgb(element._facecolor)
if style==HATCHING:
element.update({'alpha':1})
element.update({'facecolor':'none'})
element.update({'edgecolor':'black'})
element.update({'hatch':colormap[rgb_orig]['hatch']})
elif style==GREYSCALE:
ema_logging.info(colormap.keys())
element.update({'facecolor':colormap[rgb_orig]['fill']})
element.update({'edgecolor':colormap[rgb_orig]['fill']})
else:
line = element
orig_color = line.get_color()
line.set_color('black')
if not line_style=='continuous':
line.set_dashes(colormap[orig_color]['dash'])
line.set_marker(colormap[orig_color]['marker'])
line.set_markersize(MARKERSIZE)
def set_legend_to_bw(leg, style):
"""
Takes the figure legend and converts it to black and white. Note that
it currently only converts lines to black and white, other artist
intances are currently not being supported, and might cause errors or
other unexpected behavior.
Parameters
----------
leg : legend
style : {GREYSCALE, HATCHING}
"""
color_converter = ColorConverter()
colors = {}
for key, value in color_converter.colors.items():
colors[value] = key
if leg:
if isinstance(leg, list):
leg = leg[0]
for element in leg.legendHandles:
if isinstance(element, mpl.collections.PathCollection):
rgb_orig = color_converter.to_rgb(element._facecolors[0])
origColor = colors[rgb_orig]
new_color = color_converter.to_rgba(COLORMAP[origColor]['fill'])
element._facecolors = np.array((new_color,))
elif isinstance(element, mpl.patches.Rectangle):
rgb_orig = color_converter.to_rgb(element._facecolor)
c = colors[rgb_orig]
if style==HATCHING:
element.update({'alpha':1})
element.update({'facecolor':'none'})
element.update({'edgecolor':'black'})
element.update({'hatch':COLORMAP[c]['hatch']})
elif style==GREYSCALE:
element.update({'facecolor':COLORMAP[c]['fill']})
element.update({'edgecolor':COLORMAP[c]['fill']})
else:
line = element
origColor = line.get_color()
line.set_color('black')
line.set_dashes(COLORMAP[origColor]['dash'])
line.set_marker(COLORMAP[origColor]['marker'])
line.set_markersize(MARKERSIZE)
def make_colormap(colors,whiten=0):
import numpy as np
from matplotlib.colors import LinearSegmentedColormap, ColorConverter
z = np.array(sorted(colors.keys()))
n = len(z)
z1 = min(z)
zn = max(z)
x0 = (z - z1) / (zn - z1)
CC = ColorConverter()
R = []
G = []
B = []
for i in range(n):
Ci = colors[z[i]]
if type(Ci) == str:
RGB = CC.to_rgb(Ci)
else:
RGB = Ci
R.append(RGB[0] + (1-RGB[0])*whiten)
G.append(RGB[1] + (1-RGB[1])*whiten)
B.append(RGB[2] + (1-RGB[2])*whiten)
cmap_dict = {}
cmap_dict['red'] = [(x0[i],R[i],R[i]) for i in range(len(R))]
cmap_dict['green'] = [(x0[i],G[i],G[i]) for i in range(len(G))]
cmap_dict['blue'] = [(x0[i],B[i],B[i]) for i in range(len(B))]
mymap = LinearSegmentedColormap('mymap',cmap_dict)
return mymap
def _return_rgb_colors():
"""."""
colors = ['#9E0142', '#B31C42', '#C93742', '#DE5242', '#F46D43', '#F68955', '#F9A667',
'#FBC379', '#FEE08B', '#F8E58E', '#F2EA91', '#ECEF94', '#E6F598', '#C6E89B',
'#A6DB9E', '#86CEA1', '#66C2A5', '#64A5A4', '#6288A3', '#606BA2', '#5E4FA2']
cc = ColorConverter()
return [cc.to_rgb(i) for i in colors]
def _set_ax_pathcollection_to_bw(collection, ax, style, colormap):
'''helper function for converting a pathcollection to black and white
Parameters
----------
collection : pathcollection
ax : axes
style : {GREYSCALE, HATCHING}
colormap : dict
mapping of color to B&W rendering
'''
color_converter = ColorConverter()
colors = {}
for key, value in color_converter.colors.items():
colors[value] = key
rgb_orig = collection._facecolors_original
rgb_orig = [color_converter.to_rgb(row) for row in rgb_orig]
new_color = [color_converter.to_rgba(colormap[entry]['fill']) for entry
in rgb_orig]
new_color = np.asarray(new_color)
collection.update({'facecolors' : new_color})
collection.update({'edgecolors' : new_color})
def parse_list_of_colors(self, number, colors):
from matplotlib.colors import ColorConverter
cconvert = ColorConverter()
if number != len(colors):
raise ValueError("the length of colors must be the number of groups")
rgbcolors = [cconvert.to_rgb(c) for c in colors]
return rgbcolors
def set_legend_to_bw(leg):
"""
Takes the figure legend and converts it to black and white. Note that
it currently only converts lines to black and white, other artist
intances are currently not being supported, and might cause errors or
other unexpected behavior.
:param fig: The figure which needs to be transformed to B&W.
"""
color_converter = ColorConverter()
colors = {}
for key, value in color_converter.colors.items():
colors[value] = key
if leg:
if type(leg) == ListType:
leg = leg[0]
for element in leg.legendHandles:
if isinstance(element, mpl.collections.PathCollection):
rgb_orig = color_converter.to_rgb(element._facecolors[0])
origColor = colors[rgb_orig]
new_color = color_converter.to_rgba(COLORMAP[origColor]['fill'])
element._facecolors = np.array((new_color,))
else:
line = element
origColor = line.get_color()
line.set_color('black')
line.set_dashes(COLORMAP[origColor]['dash'])
line.set_marker(COLORMAP[origColor]['marker'])
line.set_markersize(MARKERSIZE)
def _set_ax_pathcollection_to_bw(collection, ax, style, colormap):
'''helper function for converting a pathcollection to black and white
Parameters
----------
collection : pathcollection
ax : axes
style : {GREYSCALE, HATCHING}
colormap : dict
mapping of color to B&W rendering
'''
color_converter = ColorConverter()
colors = {}
for key, value in color_converter.colors.items():
colors[value] = key
rgb_orig = collection._original_facecolor
if isinstance(rgb_orig, six.string_types):
rgb_orig = [rgb_orig]
rgb_orig = [color_converter.to_rgb(row) for row in rgb_orig]
new_color = [color_converter.to_rgba(colormap[entry]['fill']) for entry
in rgb_orig]
new_color = np.asarray(new_color)
collection.update({'facecolors': new_color})
collection.update({'edgecolors': new_color})
def make_colormap(colors):
z = np.sort(colors.keys())
n = len(z)
z1 = min(z)
zn = max(z)
x0 = (z - z1) / (zn - z1)
CC = ColorConverter()
R = []
G = []
B = []
for i in range(n):
Ci = colors[z[i]]
if type(Ci) == str:
RGB = CC.to_rgb(Ci)
else:
RGB = Ci
R.append(RGB[0])
G.append(RGB[1])
B.append(RGB[2])
cmap_dict = {}
cmap_dict['red'] = [(x0[i],R[i],R[i]) for i in range(len(R))]
cmap_dict['green'] = [(x0[i],G[i],G[i]) for i in range(len(G))]
cmap_dict['blue'] = [(x0[i],B[i],B[i]) for i in range(len(B))]
mymap = LinearSegmentedColormap('mymap',cmap_dict)
return mymap
def get_rgb_hexad_color_palete():
"""Returns a list of RGB values with the color palette used to plot the
transit vehicles returned by NextBus. Each entry returned in the color
palette has the RGB hexadecimal format, and without the prefix '0x' as
for colors in Google Maps, nor the prefix '#' for the matplotlib color.
Ie., the entry for blue is returned as '0000FF' and for red 'FF0000'."""
# We don't use these color names directly because their intensity might
# be (are) reflected diferently between between the remote server and
# matplotlib, and this difference in rendering a same color affects the
# color-legend in matplotlib. For this reason too, we don't need to use
# only the named colors in Google Maps but more in matplotlib, for in
# both cases hexadecimal RGB values are really used.
high_contrast_colors = ["green", "red", "blue", "yellow", "aqua",
"brown", "gray", "honeydew", "purple",
"turquoise", "magenta", "orange"]
from matplotlib.colors import ColorConverter, rgb2hex
color_converter = ColorConverter()
hex_color_palette = [rgb2hex(color_converter.to_rgb(cname))[1:] for \
cname in high_contrast_colors]
# matplotlib.colors.cnames[cname] could have been used instead of rgb2hex
return hex_color_palette
def get_rgb_hexad_color_palete():
"""Returns a list of RGB values with the color palette used to plot the
transit vehicles returned by NextBus. Each entry returned in the color
palette has the RGB hexadecimal format, and without the prefix '0x' as
for colors in Google Maps, nor the prefix '#' for the matplotlib color.
Ie., the entry for blue is returned as '0000FF' and for red 'FF0000'."""
# We don't use these color names directly because their intensity might
# be (are) reflected diferently between between the remote server and
# matplotlib, and this difference in rendering a same color affects the
# color-legend in matplotlib. For this reason too, we don't need to use
# only the named colors in Google Maps but more in matplotlib, for in
# both cases hexadecimal RGB values are really used.
high_contrast_colors = [
"green", "red", "blue", "yellow", "aqua", "brown", "gray", "honeydew",
"purple", "turquoise", "magenta", "orange"
]
from matplotlib.colors import ColorConverter, rgb2hex
color_converter = ColorConverter()
hex_color_palette = [rgb2hex(color_converter.to_rgb(cname))[1:] for \
cname in high_contrast_colors]
# matplotlib.colors.cnames[cname] could have been used instead of rgb2hex
return hex_color_palette
def make_colormap(self, key):
""" define a new color map based on values specified in the color_scale file for the key"""
#colors = {0.1:'#005a00', 0.2:'#6e0dc6',0.3:'#087fdb',0.4:'#1c47e8',0.5:'#007000'} # parsed result format from color_scale file
colors = self.colorTable[key]
z = sort(colors.keys()) ## keys
n = len(z)
z1 = min(z)
zn = max(z)
x0 = (z - z1) / (zn - z1) ## normalized keys
CC = ColorConverter()
R = []
G = []
B = []
for i in range(n):
## i'th color at level z[i]:
Ci = colors[z[i]]
if type(Ci) == str:
## a hex string of form '#ff0000' for example (for red)
RGB = CC.to_rgb(Ci)
else:
## assume it's an RGB triple already:
RGB = Ci
R.append(RGB[0])
G.append(RGB[1])
B.append(RGB[2])
cmap_dict = {}
cmap_dict['red'] = [(x0[i],R[i],R[i]) for i in range(len(R))] ## normalized value in X0
cmap_dict['green'] = [(x0[i],G[i],G[i]) for i in range(len(G))]
cmap_dict['blue'] = [(x0[i],B[i],B[i]) for i in range(len(B))]
mymap = LinearSegmentedColormap(key,cmap_dict)
return mymap, z
def plot_em(step, X, K, amps, means, covs, z,
newamps, newmeans, newcovs, show=True):
import pylab as plt
from matplotlib.colors import ColorConverter
(N,D) = X.shape
if z is None:
z = np.zeros((N,K))
for k,(amp,mean,cov) in enumerate(zip(amps, means, covs)):
z[:,k] = amp * gaussian_probability(X, mean, cov)
z /= np.sum(z, axis=1)[:,np.newaxis]
plt.clf()
# snazzy color coding
cc = np.zeros((N,3))
CC = ColorConverter()
for k in range(K):
rgb = np.array(CC.to_rgb(colors[k]))
cc += z[:,k][:,np.newaxis] * rgb[np.newaxis,:]
plt.scatter(X[:,0], X[:,1], color=cc, s=9, alpha=0.5)
ax = plt.axis()
for k,(amp,mean,cov) in enumerate(zip(amps, means, covs)):
plot_ellipse(mean, cov, 'k-', lw=4)
plot_ellipse(mean, cov, 'k-', color=colors[k], lw=2)
plt.axis(ax)
if show:
plt.show()
def drawOn(self, canv, x, y, _sW=0):
if _sW and hasattr(self, 'hAlign'):
from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY
a = self.hAlign
if a in ('CENTER', 'CENTRE', TA_CENTER):
x = x + 0.5 * _sW
elif a in ('RIGHT', TA_RIGHT):
x = x + _sW
elif a not in ('LEFT', TA_LEFT):
raise ValueError("Bad hAlign value " + str(a))
height = 0
if HAS_MATPLOTLIB:
global fonts
canv.saveState()
canv.translate(x, y)
try:
width, height, descent, glyphs, rects, used_characters = \
self.parser.parse(enclose(self.s), 72,
prop=FontProperties(size=self.fontsize))
for ox, oy, fontname, fontsize, num, symbol_name in glyphs:
if fontname not in fonts:
fonts[fontname] = fontname
pdfmetrics.registerFont(TTFont(fontname, fontname))
canv.setFont(fontname, fontsize)
col_conv = ColorConverter()
rgb_color = col_conv.to_rgb(self.color)
canv.setFillColorRGB(rgb_color[0], rgb_color[1], rgb_color[2])
canv.drawString(ox, oy, chr(num))
canv.setLineWidth(0)
canv.setDash([])
for ox, oy, width, height in rects:
canv.rect(ox, oy + 2 * height, width, height, fill=1)
except:
# FIXME: report error
col_conv = ColorConverter()
rgb_color = col_conv.to_rgb(self.color)
canv.setFillColorRGB(rgb_color[0], rgb_color[1], rgb_color[2])
canv.drawString(0, 0, self.s)
canv.restoreState()
else:
canv.saveState()
canv.drawString(x, y, self.s)
canv.restoreState()
if self.label:
log.info('Drawing equation-%s' % self.label)
canv.bookmarkHorizontal('equation-%s' % self.label, 0, height)
def genImage(self):
"""Create a PNG from the contents of this flowable.
Required so we can put inline math in paragraphs.
Returns the file name.
The file is caller's responsability.
"""
dpi = 72
scale = 10
try:
import Image
import ImageFont
import ImageDraw
import ImageColor
except ImportError:
from PIL import (
Image,
ImageFont,
ImageDraw,
ImageColor,
)
if not HAS_MATPLOTLIB:
img = Image.new('RGBA', (120, 120), (255, 255, 255, 0))
else:
width, height, descent, glyphs,\
rects, used_characters = self.parser.parse(
enclose(self.s), dpi, prop=FontProperties(size=self.fontsize))
img = Image.new('RGBA', (int(width * scale), int(height * scale)),
(255, 255, 255, 0))
draw = ImageDraw.Draw(img)
for ox, oy, fontname, fontsize, num, symbol_name in glyphs:
font = ImageFont.truetype(fontname, int(fontsize * scale))
tw, th = draw.textsize(unichr(num), font=font)
# No, I don't understand why that 4 is there.
# As we used to say in the pure math
# department, that was a numerical solution.
col_conv = ColorConverter()
fc = col_conv.to_rgb(self.color)
rgb_color = (int(fc[0] * 255), int(fc[1] * 255),
int(fc[2] * 255))
draw.text((ox * scale, (height - oy - fontsize + 4) * scale),
unichr(num),
font=font,
fill=rgb_color)
for ox, oy, w, h in rects:
x1 = ox * scale
x2 = x1 + w * scale
y1 = (height - oy) * scale
y2 = y1 + h * scale
draw.rectangle([x1, y1, x2, y2], (0, 0, 0))
fh, fn = tempfile.mkstemp(suffix=".png")
os.close(fh)
img.save(fn)
return fn
def idx2color(idx, colorpalette, isscatter):
if idx is None:
c = (0, 0, 0)
else:
c = ColorConverter.to_rgb(
sns.color_palette(colorpalette).as_hex()[idx])
if isscatter: c = np.atleast_2d(np.asarray(c))
return c
def MplToWxColour(self, color):
"""Converts matplotlib color (0-1) to wx.Colour (0-255)"""
try:
cc = ColorConverter()
rgb = tuple([d * 255 for d in cc.to_rgb(color)])
return wx.Colour(*rgb)
except ValueError: #invalid color
return wx.Colour()
def MplToWxColour(self, color):
"""Converts matplotlib color (0-1) to wx.Colour (0-255)"""
try:
cc = ColorConverter()
rgb = tuple([d*255 for d in cc.to_rgb(color)])
return wx.Colour(*rgb)
except ValueError: #invalid color
return wx.Colour()
def parse_list_of_colors(self, number, colors):
from matplotlib.colors import ColorConverter
cconvert = ColorConverter()
if number != len(colors):
raise ValueError(
"the length of colors must be the number of groups")
rgbcolors = [cconvert.to_rgb(c) for c in colors]
return rgbcolors
def compute_venn2_colors(set_colors):
"""
Given two base colors, computes combinations of colors corresponding to all regions of the venn diagram.
returns a list of 6 elements, providing colors for regions (Ab_in, Ab_out, aB_in, aB_out, AB_in, AB_out).
"""
ccv = ColorConverter()
base_colors = [np.array(ccv.to_rgb(c)) for c in set_colors]
return base_colors[0], base_colors[1], mix_colors(base_colors[0],
base_colors[1])
def genImage(self):
"""Create a PNG from the contents of this flowable.
Required so we can put inline math in paragraphs.
Returns the file name.
The file is caller's responsability.
"""
dpi = 72
scale = 10
try:
import Image
import ImageFont
import ImageDraw
except ImportError:
from PIL import (
Image,
ImageFont,
ImageDraw,
)
if not HAS_MATPLOTLIB:
img = Image.new('RGBA', (120, 120), (255, 255, 255, 0))
else:
width, height, descent, glyphs, rects, used_characters = \
self.parser.parse(enclose(self.s), dpi,
prop=FontProperties(size=self.fontsize))
img = Image.new('RGBA', (int(width * scale), int(height * scale)),
(255, 255, 255, 0))
draw = ImageDraw.Draw(img)
for ox, oy, fontname, fontsize, num, symbol_name in glyphs:
font = ImageFont.truetype(fontname, int(fontsize * scale))
tw, th = draw.textsize(chr(num), font=font)
# No, I don't understand why that 4 is there.
# As we used to say in the pure math
# department, that was a numerical solution.
col_conv = ColorConverter()
fc = col_conv.to_rgb(self.color)
rgb_color = (
int(fc[0] * 255),
int(fc[1] * 255),
int(fc[2] * 255)
)
draw.text((ox * scale, (height - oy - fontsize + 4) * scale),
chr(num), font=font, fill=rgb_color)
for ox, oy, w, h in rects:
x1 = ox * scale
x2 = x1 + w * scale
y1 = (height - oy) * scale
y2 = y1 + h * scale
draw.rectangle([x1, y1, x2, y2], (0, 0, 0))
fh, fn = tempfile.mkstemp(suffix=".png")
os.close(fh)
img.save(fn)
return fn
def mplot_surface(self, ures=8, vres=8, figax=False, **kwargs):
"""Plot the enclosing surfaces of the volume using Mayavi's `mesh()` function
Parameters
----------
ures, vres : int
Specifies the oversampling of the original
volume in u and v directions. For example:
if `ures` = 2, and `self.u` = [0, 1, 2, 3],
then the surface will be resampled at
[0, 0.5, 1, 1.5, 2, 2.5, 3] prior to
plotting.
kwargs : dict
See Mayavi docs for `mesh()`
Returns
-------
None
"""
from mayavi import mlab
from matplotlib.colors import ColorConverter
if not 'color' in kwargs:
# Generate random color
cvec = np.random.rand(3)
cvec /= math.sqrt(cvec.dot(cvec))
kwargs['color'] = tuple(cvec)
else:
# The following will convert text strings representing
# colors into their (r, g, b) equivalents (which is
# the only way Mayavi will accept them)
from matplotlib.colors import ColorConverter
cconv = ColorConverter()
if kwargs['color'] is not None:
kwargs['color'] = cconv.to_rgb(kwargs['color'])
# Make new u and v values of (possibly) higher resolution
# the original ones.
hru, hrv = self._resample_uv(ures, vres)
# Sample the surface at the new u, v values and plot
meshpts1 = self.ev(hru, hrv, np.max(self.l))
meshpts2 = self.ev(hru, hrv, np.min(self.l))
if figax is None:
m1 = mlab.mesh(*meshpts1, **kwargs)
m2 = mlab.mesh(*meshpts2, **kwargs)
# Turn off perspective
fig = mlab.gcf()
fig.scene.camera.trait_set(parallel_projection=1)
return fig
else:
fig, ax = figax
m1 = ax.plot_surface(*meshpts1, **kwargs)
m2 = ax.plot_surface(*meshpts2, **kwargs)
def compute_venn2_colors(set_colors):
'''
Given two base colors, computes combinations of colors corresponding to all regions of the venn diagram.
returns a list of 3 elements, providing colors for regions (10, 01, 11).
>>> compute_venn2_colors(('r', 'g'))
(array([ 1., 0., 0.]), array([ 0. , 0.5, 0. ]), array([ 0.7 , 0.35, 0. ]))
'''
ccv = ColorConverter()
base_colors = [np.array(ccv.to_rgb(c)) for c in set_colors]
return (base_colors[0], base_colors[1], mix_colors(base_colors[0], base_colors[1]))
def modify_color(color, d_saturation=0., d_lightness=0.):
conv = ColorConverter()
if not isinstance(color, tuple):
rgb_color = conv.to_rgb(color)
else:
rgb_color = color
hls_color = rgb_to_hls(*rgb_color)
new_l = max(0, min(0.9, hls_color[1] + d_lightness))
new_s = max(0, min(1, hls_color[2] + d_saturation))
return hls_to_rgb(hls_color[0], new_l, new_s)
def mplot_volume(self, ures=8, vres=8, **kwargs):
"""Plot the volume using Mayavi's `scalar_scatter()` function
Parameters
----------
ures, vres : int
Specifies the oversampling of the original
volume in u and v directions. For example:
if `ures` = 2, and `self.u` = [0, 1, 2, 3],
then the surface will be resampled at
[0, 0.5, 1, 1.5, 2, 2.5, 3] prior to
plotting.
kwargs : dict
See Mayavi docs for `mesh()`
Returns
-------
None
"""
from mayavi import mlab
from matplotlib.colors import ColorConverter
if not 'color' in kwargs:
# Generate random color
cvec = np.random.rand(3)
cvec /= math.sqrt(cvec.dot(cvec))
kwargs['color'] = tuple(cvec)
else:
# The following will convert text strings representing
# colors into their (r, g, b) equivalents (which is
# the only way Mayavi will accept them)
from matplotlib.colors import ColorConverter
cconv = ColorConverter()
if kwargs['color'] is not None:
kwargs['color'] = cconv.to_rgb(kwargs['color'])
# Make new u and v values of (possibly) higher resolution
# the original ones.
hru, hrv = self._resample_uv(ures, vres)
volpts = self.ev(hru, hrv, self.l).reshape(3, -1)
s = np.ones_like(volpts[0, :])
sct = mlab.pipeline.scalar_scatter(volpts[0, :], volpts[1, :],
volpts[2, :], s, **kwargs)
ug = mlab.pipeline.delaunay3d(sct)
mq = mlab.pipeline.user_defined(ug, filter='MeshQuality')
c2d = mlab.pipeline.cell_to_point_data(mq)
aa = mlab.pipeline.set_active_attribute(c2d)
vol = mlab.pipeline.surface(aa, **kwargs)
# Turn off perspective
fig = mlab.gcf()
fig.scene.camera.trait_set(parallel_projection=1)
return fig
def _parse_colour(x):
if isinstance(x, basestring):
from matplotlib.colors import ColorConverter
c = ColorConverter()
x = c.to_rgb(x)
if isinstance(x, (tuple, list)):
# Assume we have a floating point rgb
if any(a <= 1.0 for a in x):
x = [int(a * 255) for a in x]
return tuple(x)
def _parse_colour(x):
if isinstance(x, basestring):
from matplotlib.colors import ColorConverter
c = ColorConverter()
x = c.to_rgb(x)
if isinstance(x, (tuple, list)):
# Assume we have a floating point rgb
if any(a <= 1.0 for a in x):
x = [int(a * 255) for a in x]
return tuple(x)
def compute_venn3_colors(set_colors):
'''
Given three base colors, computes combinations of colors corresponding to all regions of the venn diagram.
returns a list of 7 elements, providing colors for regions (100, 010, 110, 001, 101, 011, 111).
>>> compute_venn3_colors(['r', 'g', 'b'])
(array([ 1., 0., 0.]),..., array([ 0.4, 0.2, 0.4]))
'''
ccv = ColorConverter()
base_colors = [np.array(ccv.to_rgb(c)) for c in set_colors]
return (base_colors[0], base_colors[1], mix_colors(base_colors[0], base_colors[1]), base_colors[2],
mix_colors(base_colors[0], base_colors[2]), mix_colors(base_colors[1], base_colors[2]), mix_colors(base_colors[0], base_colors[1], base_colors[2]))
def compute_venn2_colors(set_colors):
'''
Given two base colors, computes combinations of colors corresponding to all regions of the venn diagram.
returns a list of 3 elements, providing colors for regions (10, 01, 11).
>>> compute_venn2_colors(('r', 'g'))
(array([ 1., 0., 0.]), array([ 0. , 0.5, 0. ]), array([ 0.7 , 0.35, 0. ]))
'''
ccv = ColorConverter()
base_colors = [np.array(ccv.to_rgb(c)) for c in set_colors]
return (base_colors[0], base_colors[1], mix_colors(base_colors[0], base_colors[1]))
def compute_venn3_colors(set_colors):
'''
Given three base colors, computes combinations of colors corresponding to all regions of the venn diagram.
returns a list of 7 elements, providing colors for regions (100, 010, 110, 001, 101, 011, 111).
>>> compute_venn3_colors(['r', 'g', 'b'])
(array([ 1., 0., 0.]),..., array([ 0.4, 0.2, 0.4]))
'''
ccv = ColorConverter()
base_colors = [np.array(ccv.to_rgb(c)) for c in set_colors]
return (base_colors[0], base_colors[1], mix_colors(base_colors[0], base_colors[1]), base_colors[2],
mix_colors(base_colors[0], base_colors[2]), mix_colors(base_colors[1], base_colors[2]), mix_colors(base_colors[0], base_colors[1], base_colors[2]))
def _set_ax_pathcollection_to_bw(collection, ax, style):
color_converter = ColorConverter()
colors = {}
for key, value in color_converter.colors.items():
colors[value] = key
rgb_orig = collection._facecolors_original
rgb_orig = [color_converter.to_rgb(row) for row in rgb_orig]
color = [colors.get(entry) for entry in rgb_orig]
new_color = [color_converter.to_rgba(COLORMAP[entry]['fill']) for entry in color]
new_color = np.asarray(new_color)
collection.update({'facecolors' : new_color})
collection.update({'edgecolors' : 'black'})
def create_gradient(values, low, high, mid=None, val_range=None, intervals=100):
# get anchor values
vmin = val_range[0] if val_range is not None else values.min()
vmax = val_range[1] if val_range is not None else values.max()
vmid = (vmax+vmin)/2
# get anchor colors
cc = ColorConverter()
low_color = np.array(cc.to_rgb(low))
high_color = np.array(cc.to_rgb(high))
mid_color = np.array(cc.to_rgb(mid)) if mid is not None else \
(np.array(low_color)+np.array(high_color))/2
# create array of values in order
vals_low = np.linspace(vmin, vmid, intervals+1)
vals_high = np.linspace(vmid, vmax, intervals+1)
all_vals = np.unique(np.append(vals_low, vals_high))
# calculate hex color representaitons for all values
color_list = [low_color, mid_color, high_color]
step_list = [(mid_color-low_color), (high_color-mid_color)]
step_list = [l/intervals for l in step_list]
color_range = []
for v in all_vals:
i = all_vals.tolist().index(v)
j = 0 if i <= intervals else 1
i = i - (intervals * j) - j
nexti = color_list[0+j]+(step_list[j]*i)
hsv = colorsys.rgb_to_hsv(*nexti)
r, g, b = colorsys.hsv_to_rgb(*hsv)
hex_value = '#%02X%02X%02X' % (r * 255, g * 255, b * 255)
color_range.append(hex_value)
# bring everything together
output_values = [color_range[np.abs(v-all_vals).argmin()] for v in values]
output_values = np.array(output_values)
return output_values
def _identify_colors(fig):
'''Identify the various colors that are used in the figure and
return as a set
'''
color_converter = ColorConverter()
all_colors = set()
for ax in fig.axes:
for line in ax.get_lines():
orig_color = line.get_color()
all_colors.add(orig_color)
for patch in ax.patches:
rgb_orig = color_converter.to_rgb(patch._facecolor)
all_colors.add(rgb_orig)
for collection in ax.collections:
for color in collection.get_facecolor():
rgb_orig = color_converter.to_rgb(color)
all_colors.add(rgb_orig)
return all_colors
def _identify_colors(fig):
'''Identify the various colors that are used in the figure and
return as a set
'''
color_converter = ColorConverter()
all_colors = set()
for ax in fig.axes:
for line in ax.get_lines():
orig_color = line.get_color()
all_colors.add(orig_color)
for patch in ax.patches:
rgb_orig = color_converter.to_rgb(patch._facecolor)
all_colors.add(rgb_orig)
for collection in ax.collections:
for color in collection.get_facecolor():
rgb_orig = color_converter.to_rgb(color)
all_colors.add(rgb_orig)
return all_colors
def mpl_to_qt4_color(color):
""" Convert a matplotlib color stirng into a PyQT4 QColor object
Parameters
----------
color: String
A color specification that matplotlib understands
Returns
-------
A QColor object representing color
"""
cc = ColorConverter()
r, g, b = cc.to_rgb(color)
return QColor(r * 255, g * 255, b * 255)
def gen_image(bool_matrix, colors=("#BF5264","beige"), figsize=None):
"""Generates an image from a matrix of booleans
:param bool_matrix: array of booleans
:type bool_matrix: :py:code:`numpy.ndArray`
"""
from matplotlib.colors import ColorConverter
from scipy.misc import toimage
cc = ColorConverter()
rgb_colors = [cc.to_rgb(x) for x in colors]
new_matrix = np.zeros(bool_matrix.shape + (3,))
for i in range(3):
new_matrix[:,:,i] = np.where(bool_matrix, rgb_colors[0][i], rgb_colors[1][i])
img = toimage(new_matrix)
img.save("ca_smallest.png")
def compute_venn_colors(set_colors):
"""
Given any amount of base colors, computes combinations of colors corresponding to all regions of the venn diagram.
It returns a list of X elements, where X is the number of available combinations.
>>> compute_venn_colors(['r', 'g', 'b', 'y'])
(array([ 1., 0., 0.]),..., array([ 0.4, 0.2, 0.4]))
"""
ccv = ColorConverter()
base_colors = [np.array(ccv.to_rgb(c)) for c in set_colors]
final = []
for num in range(len(set_colors)):
for combination in combinations(range(len(set_colors)), num):
final.append(mix_colors(*[base_colors[_] for _ in combination]))
return tuple(final)
def updatePage(self,modelSel):
if modelSel is None:
self.txt.SetLabel("")
return
txtLabel = modelSel.get_name()
self.txt.SetLabel(txtLabel)
log.info(txtLabel)
self.__modelSel = modelSel
if self.pg.GetPageCount()>0:
self.pg.RemovePage(0)
self.pg.AddPage(txtLabel)
#modelSel
for name, propertyKey in modelSel.getProperties().items():
propertyClass = propertyMap[propertyKey]
value=modelSel.getAttr(name)
## To be handled by custom property
if "alpha" == name and value is None:
value = 1.0
if "color" == propertyKey:
c = ColorConverter()
if isinstance(value,(unicode,str)):
if "none" == value.lower():
value = None
else:
value = c.to_rgb(value)
if not value is None:
try:
r,g,b = value
except:
r,g,b,_ = value
value = wx.Colour(r*255,g*255,b*255)
##
log.info("%s:%s"%(name,value))
if not value is None:
self.pg.Append(propertyClass(name,value=value))
else:
self.pg.Append(propertyClass(name))
def updatePage(self,modelSel):
if modelSel is None:
self.txt.SetLabel("")
return
txtLabel = modelSel.get_name()
self.txt.SetLabel(txtLabel)
log.info(txtLabel)
self.__modelSel = modelSel
if self.pg.GetPageCount()>0:
self.pg.RemovePage(0)
self.pg.AddPage(txtLabel)
#modelSel
for name, propertyKey in modelSel.getProperties().items():
propertyClass = propertyMap[propertyKey]
value=modelSel.getAttr(name)
## To be handled by custom property
if "alpha" == name and value is None:
value = 1.0
if "color" == propertyKey:
c = ColorConverter()
if isinstance(value,(unicode,str)):
if "none" == value.lower():
value = None
else:
value = c.to_rgb(value)
if not value is None:
try:
r,g,b = value
except:
r,g,b,_ = value
value = wx.Colour(r*255,g*255,b*255)
##
log.info("%s:%s"%(name,value))
if not value is None:
self.pg.Append(propertyClass(name,value=value))
else:
self.pg.Append(propertyClass(name))
def make_colormap(colors):
#-------------------------
"""
Define a new color map based on values specified in the dictionary
colors, where colors[z] is the color that value z should be mapped to,
with linear interpolation between the given values of z.
The z values (dictionary keys) are real numbers and the values
colors[z] can be either an RGB list, e.g. [1,0,0] for red, or an
html hex string, e.g. "#ff0000" for red.
"""
from matplotlib.colors import LinearSegmentedColormap, ColorConverter
from numpy import sort
z = [i for i in colors.keys()]
z = sort(z)
n = len(z)
z1 = min(z)
zn = max(z)
x0 = (z - z1) / (zn - z1)
CC = ColorConverter()
R = []
G = []
B = []
for i in range(n):
#i'th color at level z[i]:
Ci = colors[z[i]]
if type(Ci) == str:
# a hex string of form '#ff0000' for example (for red)
RGB = CC.to_rgb(Ci)
else:
# assume it's an RGB triple already:
RGB = Ci
R.append(RGB[0])
G.append(RGB[1])
B.append(RGB[2])
cmap_dict = {}
cmap_dict['red'] = [(x0[i],R[i],R[i]) for i in range(len(R))]
cmap_dict['green'] = [(x0[i],G[i],G[i]) for i in range(len(G))]
cmap_dict['blue'] = [(x0[i],B[i],B[i]) for i in range(len(B))]
mymap = LinearSegmentedColormap('mymap',cmap_dict)
return mymap
def make_colormap(colors):
#-------------------------
"""
Define a new color map based on values specified in the dictionary
colors, where colors[z] is the color that value z should be mapped to,
with linear interpolation between the given values of z.
The z values (dictionary keys) are real numbers and the values
colors[z] can be either an RGB list, e.g. [1,0,0] for red, or an
html hex string, e.g. "#ff0000" for red.
"""
from matplotlib.colors import LinearSegmentedColormap, ColorConverter
from numpy import sort
z = [i for i in colors.keys()]
z = sort(z)
n = len(z)
z1 = min(z)
zn = max(z)
x0 = (z - z1) / (zn - z1)
CC = ColorConverter()
R = []
G = []
B = []
for i in range(n):
#i'th color at level z[i]:
Ci = colors[z[i]]
if type(Ci) == str:
# a hex string of form '#ff0000' for example (for red)
RGB = CC.to_rgb(Ci)
else:
# assume it's an RGB triple already:
RGB = Ci
R.append(RGB[0])
G.append(RGB[1])
B.append(RGB[2])
cmap_dict = {}
cmap_dict['red'] = [(x0[i], R[i], R[i]) for i in range(len(R))]
cmap_dict['green'] = [(x0[i], G[i], G[i]) for i in range(len(G))]
cmap_dict['blue'] = [(x0[i], B[i], B[i]) for i in range(len(B))]
mymap = LinearSegmentedColormap('mymap', cmap_dict)
return mymap
def make_colormap(colors):
from matplotlib.colors import LinearSegmentedColormap, ColorConverter
z = np.sort(list(colors.keys()))
anchors = (z - min(z)) / (max(z) - min(z))
CC = ColorConverter()
R, G, B = [], [], []
for i in range(len(z)):
Ci = colors[z[i]]
RGB = CC.to_rgb(Ci)
R.append(RGB[0])
G.append(RGB[1])
B.append(RGB[2])
cmap_dict = {}
cmap_dict['red'] = [(anchors[i], R[i], R[i]) for i in range(len(R))]
cmap_dict['green'] = [(anchors[i], G[i], G[i]) for i in range(len(G))]
cmap_dict['blue'] = [(anchors[i], B[i], B[i]) for i in range(len(B))]
mymap = LinearSegmentedColormap('mymap', cmap_dict)
return mymap
def color_chooser(self, property):
""" Creates a box with widgets related to choosing a color.
:param property: A color related key in matplotlib.rcParams.
:returns: A box with widgets.
"""
cc = ColorConverter()
rgb = cc.to_rgb(mpl.rcParams[property])
logger = log_api.env_logger()
logger.debug('{0} {1}'.format(property, rgb))
r = widgets.FloatSlider(min=0, max=1, value=rgb[0], description='Red')
r.border_color = 'red'
g = widgets.FloatSlider(min=0,
max=1,
value=rgb[1],
description='Green')
g.border_color = 'green'
b = widgets.FloatSlider(min=0, max=1, value=rgb[2], description='Blue')
b.border_color = 'blue'
h = widgets.widget_string.HTML(property)
# TODO put this in a func
hex = rgb2hex((rgb[0], rgb[1], rgb[2]))
h.value = '<p style="background-color: {0};">{0}</p>'.format(hex)
def update(name, value):
hex = rgb2hex((r.value, g.value, b.value))
h.value = '<p style="background-color: {0};">{0}</p>'.format(hex)
self.rc_widget.process(property, hex)
r.on_trait_change(update, 'value')
g.on_trait_change(update, 'value')
b.on_trait_change(update, 'value')
box = widgets.VBox(children=(r, g, b, h))
box.border_style = 'dotted'
box.description = property
return box
def gen_big_image(bool_matrix, colors=("#BF5264","beige")):
"""Generates an image using PIL instead"""
from matplotlib.colors import ColorConverter
from scipy.misc import toimage
cc = ColorConverter()
rgb_colors = [cc.to_rgb(x) for x in colors]
new_matrix = np.zeros(bool_matrix.shape + (3,))
for i in range(3):
new_matrix[:,:,i] = np.where(bool_matrix, rgb_colors[0][i], rgb_colors[1][i])
n_imgs = bool_matrix.shape[0] / 2000
for i in range(n_imgs):
img = toimage(new_matrix[i*2000:(i+1)*2000,:,:])
img.save("ca{0}.png".format(i))
remainder = bool_matrix.shape[0] % 2000
if remainder > 0:
img = toimage(new_matrix[n_imgs*2000:n_imgs*2000+remainder,:,:])
img.save("ca{0}.png".format(n_imgs))
def set_ax_patches_bw(ax):
"""
Take each patch in the axes, ax, and convert the face color to be
suitable for black and white viewing.
Parameters
----------
ax : axes
The ax of which the patches needs to be transformed to B&W.
"""
color_converter = ColorConverter()
for patch in ax.patches:
rgb_orig = color_converter.to_rgb(patch._facecolor)
new_color = color_converter.to_rgba(COLORMAP[rgb_orig]['fill'])
patch._facecolor = new_color
def set_ax_patches_bw(ax):
"""
Take each patch in the axes, ax, and convert the face color to be
suitable for black and white viewing.
:param ax: The ax of which the patches needs to be transformed to B&W.
"""
color_converter = ColorConverter()
colors = {}
for key, value in color_converter.colors.items():
colors[value] = key
for patch in ax.patches:
rgb_orig = color_converter.to_rgb(patch._facecolor)
origColor = colors[rgb_orig]
new_color = color_converter.to_rgba(COLORMAP[origColor]['fill'])
patch._facecolor = new_color
def mpl_to_qt4_color(color, alpha=1.0):
""" Convert a matplotlib color stirng into a PyQT4 QColor object
:param color:
A color specification that matplotlib understands
:type color: str
:param alpha:
Optional opacity. Float in range [0,1]
:type alpha: float
* Returns *
A QColor object representing color
:rtype: QColor
"""
cc = ColorConverter()
r, g, b = cc.to_rgb(color)
alpha = max(0, min(255, int(256 * alpha)))
return QColor(r * 255, g * 255, b * 255, alpha)
def imsave(fname, arr, **kwargs):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.colors import ColorConverter as CC
C = CC()
import pylab
if pylab.isinteractive():
i_was_on = True
pylab.ioff()
else:
i_was_on = False
fig = Figure(figsize=arr.shape[::-1], dpi=1, frameon=False)
canvas = FigureCanvas(fig)
if 'background' in kwargs.keys():
if kwargs['background'] != 'transparent':
[r,g,b] = C.to_rgb(kwargs['background'])
BG = numpy.ones(shape=(arr.shape[0],arr.shape[1],3))
BG[:,:,0] = r
BG[:,:,1] = g
BG[:,:,2] = b
fig.figimage(BG)
fig.figimage(arr,
xo = kwargs.get('xo',0),
yo = kwargs.get('yo',0),
alpha = kwargs.get('alpha',None),
norm = kwargs.get('norm',None),
cmap = kwargs.get('cmap',None),
vmin = kwargs.get('vmin',None),
vmax = kwargs.get('vmax',None),
origin = kwargs.get('origin',None))
fig.savefig(fname,
dpi=1,
format = kwargs.get('format',None))
if i_was_on:
pylab.ion()
def mpl_to_qt4_color(color, alpha=1.0):
"""
Convert a matplotlib color stirng into a Qt QColor object
Parameters
----------
color : str
A color specification that matplotlib understands
alpha : float
Optional opacity. Float in range [0,1]
Returns
-------
qcolor : ``QColor``
A QColor object representing the converted color
"""
if color in [None, 'none', 'None']:
return QtGui.QColor(0, 0, 0, 0)
cc = ColorConverter()
r, g, b = cc.to_rgb(color)
alpha = max(0, min(255, int(256 * alpha)))
return QtGui.QColor(r * 255, g * 255, b * 255, alpha)
def _plot_dominant_classes_2D(self, ax, **kwargs):
if self.plot_subclasses:
probs = self.subclass_probs
else:
probs = self.probs
# <>TODO: come up with more elegant solution than scatter plot
# Identify colors of critical classes for each state
np.set_printoptions(threshold=np.nan)
max_pdf_indices = np.argmax(probs, axis=1)
max_colors = np.take(self.class_colors, max_pdf_indices)
cc = ColorConverter()
max_colors_rgb = np.array([cc.to_rgb(_) for _ in max_colors])
ax.scatter(self.X, self.Y, c=max_colors_rgb, marker='s', s=100,
linewidths=0, alpha=1)
ax.set_xlim(self.bounds[0], self.bounds[2])
ax.set_ylim(self.bounds[1], self.bounds[3])
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_title('Critical Classes')
