utils.py

"""
Utility Routines for Working with Matplotlib Objects
====================================================
"""
importitertools
importio
importbase64

importnumpyasnp

importwarnings

importmatplotlib
frommatplotlib.colorsimportcolorConverter
frommatplotlib.pathimportPath
frommatplotlib.markersimportMarkerStyle
frommatplotlib.transformsimportAffine2D
frommatplotlibimportticker


defexport_color(color):
"""Convert matplotlib color code to hex color or RGBA color"""
ifcolorisNoneorcolorConverter.to_rgba(color)[3] ==0:
return"none"
elifcolorConverter.to_rgba(color)[3] ==1:
rgb=colorConverter.to_rgb(color)
return"#{0:02X}{1:02X}{2:02X}".format(*(int(255*c) forcinrgb))
else:
c=colorConverter.to_rgba(color)
return (
"rgba("
+", ".join(str(int(np.round(val*255))) forvalinc[:3])
+", "
+str(c[3])
+")"
 )


def_many_to_one(input_dict):
"""Convert a many-to-one mapping to a one-to-one mapping"""
returndict((key, val) forkeys, valininput_dict.items() forkeyinkeys)


LINESTYLES=_many_to_one(
 {
 ("solid", "-", (None, None)): "none",
 ("dashed", "--"): "6,6",
 ("dotted", ":"): "2,2",
 ("dashdot", "-."): "4,4,2,4",
 ("", " ", "None", "none"): None,
 }
)


defget_dasharray(obj):
"""Get an SVG dash array for the given matplotlib linestyle

 Parameters
 ----------
 obj : matplotlib object
 The matplotlib line or path object, which must have a get_linestyle()
 method which returns a valid matplotlib line code

 Returns
 -------
 dasharray : string
 The HTML/SVG dasharray code associated with the object.
 """
ifobj.__dict__.get("_dashSeq", None) isnotNone:
return",".join(map(str, obj._dashSeq))
else:
ls=obj.get_linestyle()
dasharray=LINESTYLES.get(ls, "not found")
ifdasharray=="not found":
warnings.warn(
"line style '{0}' not understood: "
"defaulting to solid line.".format(ls)
 )
dasharray=LINESTYLES["solid"]
returndasharray


PATH_DICT= {
Path.LINETO: "L",
Path.MOVETO: "M",
Path.CURVE3: "S",
Path.CURVE4: "C",
Path.CLOSEPOLY: "Z",
}


defSVG_path(path, transform=None, simplify=False):
"""Construct the vertices and SVG codes for the path

 Parameters
 ----------
 path : matplotlib.Path object

 transform : matplotlib transform (optional)
 if specified, the path will be transformed before computing the output.

 Returns
 -------
 vertices : array
 The shape (M, 2) array of vertices of the Path. Note that some Path
 codes require multiple vertices, so the length of these vertices may
 be longer than the list of path codes.
 path_codes : list
 A length N list of single-character path codes, N <= M. Each code is
 a single character, in ['L','M','S','C','Z']. See the standard SVG
 path specification for a description of these.
 """
iftransformisnotNone:
path=path.transformed(transform)

vc_tuples= [
 (verticesifpath_code!=Path.CLOSEPOLYelse [], PATH_DICT[path_code])
for (vertices, path_code) inpath.iter_segments(simplify=simplify)
 ]

ifnotvc_tuples:
# empty path is a special case
returnnp.zeros((0, 2)), []
else:
vertices, codes=zip(*vc_tuples)
vertices=np.array(list(itertools.chain(*vertices))).reshape(-1, 2)
returnvertices, list(codes)


defget_path_style(path, fill=True):
"""Get the style dictionary for matplotlib path objects"""
style= {}
style["alpha"] =path.get_alpha()
ifstyle["alpha"] isNone:
style["alpha"] =1
style["edgecolor"] =export_color(path.get_edgecolor())
iffill:
style["facecolor"] =export_color(path.get_facecolor())
else:
style["facecolor"] ="none"
style["edgewidth"] =path.get_linewidth()
style["dasharray"] =get_dasharray(path)
style["zorder"] =path.get_zorder()
returnstyle


defget_line_style(line):
"""Get the style dictionary for matplotlib line objects"""
style= {}
style["alpha"] =line.get_alpha()
ifstyle["alpha"] isNone:
style["alpha"] =1
style["color"] =export_color(line.get_color())
style["linewidth"] =line.get_linewidth()
style["dasharray"] =get_dasharray(line)
style["zorder"] =line.get_zorder()
style["drawstyle"] =line.get_drawstyle()
returnstyle


defget_marker_style(line):
"""Get the style dictionary for matplotlib marker objects"""
style= {}
style["alpha"] =line.get_alpha()
ifstyle["alpha"] isNone:
style["alpha"] =1

style["facecolor"] =export_color(line.get_markerfacecolor())
style["edgecolor"] =export_color(line.get_markeredgecolor())
style["edgewidth"] =line.get_markeredgewidth()

style["marker"] =line.get_marker()
markerstyle=MarkerStyle(line.get_marker())
markersize=line.get_markersize()
markertransform=markerstyle.get_transform() +Affine2D().scale(
markersize, -markersize
 )
style["markerpath"] =SVG_path(markerstyle.get_path(), markertransform)
style["markersize"] =markersize
style["zorder"] =line.get_zorder()
returnstyle


defget_text_style(text):
"""Return the text style dict for a text instance"""
style= {}
style["alpha"] =text.get_alpha()
ifstyle["alpha"] isNone:
style["alpha"] =1
style["fontsize"] =text.get_size()
style["color"] =export_color(text.get_color())
style["halign"] =text.get_horizontalalignment() # left, center, right
style["valign"] =text.get_verticalalignment() # baseline, center, top
style["malign"] =text._multialignment# text alignment when '\n' in text
style["rotation"] =text.get_rotation()
style["zorder"] =text.get_zorder()
returnstyle


defget_axis_properties(axis):
"""Return the property dictionary for a matplotlib.Axis instance"""
props= {}
label1On=axis._major_tick_kw.get("label1On", True)

ifisinstance(axis, matplotlib.axis.XAxis):
iflabel1On:
props["position"] ="bottom"
else:
props["position"] ="top"
elifisinstance(axis, matplotlib.axis.YAxis):
iflabel1On:
props["position"] ="left"
else:
props["position"] ="right"
else:
raiseValueError("{0} should be an Axis instance".format(axis))

# Use tick values if appropriate
locator=axis.get_major_locator()
props["nticks"] =len(locator())
ifisinstance(locator, ticker.FixedLocator):
props["tickvalues"] =list(locator())
else:
props["tickvalues"] =None

# Find tick formats
formatter=axis.get_major_formatter()
ifisinstance(formatter, ticker.NullFormatter):
props["tickformat"] =""
elifisinstance(formatter, ticker.FixedFormatter):
props["tickformat"] =list(formatter.seq)
elifisinstance(formatter, ticker.FuncFormatter):
props["tickformat"] =list(formatter.func.args[0].values())
elifnotany(label.get_visible() forlabelinaxis.get_ticklabels()):
props["tickformat"] =""
else:
props["tickformat"] =None

# Get axis scale
props["scale"] =axis.get_scale()

# Get major tick label size (assumes that's all we really care about!)
labels=axis.get_ticklabels()
iflabels:
props["fontsize"] =labels[0].get_fontsize()
else:
props["fontsize"] =None

# Get associated grid
props["grid"] =get_grid_style(axis)

# get axis visibility
props["visible"] =axis.get_visible()

returnprops


defget_grid_style(axis):
gridlines=axis.get_gridlines()
ifaxis._major_tick_kw["gridOn"] andlen(gridlines) >0:
color=export_color(gridlines[0].get_color())
alpha=gridlines[0].get_alpha()
dasharray=get_dasharray(gridlines[0])
returndict(gridOn=True, color=color, dasharray=dasharray, alpha=alpha)
else:
return {"gridOn": False}


defget_figure_properties(fig):
return {
"figwidth": fig.get_figwidth(),
"figheight": fig.get_figheight(),
"dpi": fig.dpi,
 }


defget_axes_properties(ax):
props= {
"axesbg": export_color(ax.patch.get_facecolor()),
"axesbgalpha": ax.patch.get_alpha(),
"bounds": ax.get_position().bounds,
"dynamic": ax.get_navigate(),
"axison": ax.axison,
"frame_on": ax.get_frame_on(),
"patch_visible": ax.patch.get_visible(),
"axes": [get_axis_properties(ax.xaxis), get_axis_properties(ax.yaxis)],
 }

foraxnamein ["x", "y"]:
axis=getattr(ax, axname+"axis")
domain=getattr(ax, "get_{0}lim".format(axname))()
lim=domain
ifisinstance(axis.converter, matplotlib.dates.DateConverter):
scale="date"
try:
importpandasaspd
frompandas.tseries.converterimportPeriodConverter
exceptImportError:
pd=None

ifpdisnotNoneandisinstance(axis.converter, PeriodConverter):
_dates= [pd.Period(ordinal=int(d), freq=axis.freq) fordindomain]
domain= [
 (d.year, d.month-1, d.day, d.hour, d.minute, d.second, 0)
fordin_dates
 ]
else:
domain= [
 (
d.year,
d.month-1,
d.day,
d.hour,
d.minute,
d.second,
d.microsecond*1e-3,
 )
fordinmatplotlib.dates.num2date(domain)
 ]
else:
scale=axis.get_scale()

ifscalenotin ["date", "linear", "log"]:
raiseValueError("Unknown axis scale: ""{0}".format(axis.get_scale()))

props[axname+"scale"] =scale
props[axname+"lim"] =lim
props[axname+"domain"] =domain

returnprops


defiter_all_children(obj, skipContainers=False):
"""
 Returns an iterator over all childen and nested children using
 obj's get_children() method

 if skipContainers is true, only childless objects are returned.
 """
ifhasattr(obj, "get_children") andlen(obj.get_children()) >0:
forchildinobj.get_children():
ifnotskipContainers:
yieldchild
# could use `yield from` in python 3...
forgrandchildiniter_all_children(child, skipContainers):
yieldgrandchild
else:
yieldobj


defget_legend_properties(ax, legend):
handles, labels=ax.get_legend_handles_labels()
visible=legend.get_visible()
return {"handles": handles, "labels": labels, "visible": visible}


defimage_to_base64(image):
"""
 Convert a matplotlib image to a base64 png representation

 Parameters
 ----------
 image : matplotlib image object
 The image to be converted.

 Returns
 -------
 image_base64 : string
 The UTF8-encoded base64 string representation of the png image.
 """
ax=image.axes
binary_buffer=io.BytesIO()

# image is saved in axes coordinates: we need to temporarily
# set the correct limits to get the correct image
lim=ax.axis()
ax.axis(image.get_extent())
image.write_png(binary_buffer)
ax.axis(lim)

binary_buffer.seek(0)
returnbase64.b64encode(binary_buffer.read()).decode("utf-8")