import os
from xml.dom import minidom
import matplotlib.pyplot as plt
import numpy as np
from warnings import warn
import traceback
import time
import sys
import copy
if sys.version_info > (3, 0):
PY3 = True
else:
PY3 = False
if PY3:
unicode = str
# Load some user parameters / defaults
# By default figurefirst will load the figurefirst_user_parameters.py file from the figurefirst/figurefirst directory.
# If you would like to set custom parameters, copy that defaults file to another location.
# Then make the changes you like and set the environment variable 'figurefirst_user_parameters' to point to the new file.
# It will be loaded instead.
import os
try:
figurefirst_user_parameters = os.environ["figurefirst_user_parameters"]
print("Using FigureFirst parameters loaded from: " + figurefirst_user_parameters)
except:
figurefirst_user_parameters = "default"
if figurefirst_user_parameters == "default":
try:
from . import figurefirst_user_parameters
except:
import figurefirst_user_parameters
else:
import imp
figurefirst_user_parameters = imp.load_source(
"figurefirst_user_parameters", figurefirst_user_parameters
)
if PY3:
try:
from . import regenerate
except:
import regenerate
try:
from . import mpl_functions
except:
import mpl_functions
XMLNS = "http://flyranch.github.io/figurefirst/"
SCALE_FACTORS = {
"px": {"in": 72.0, "cm": 72 / 2.54, "mm": 72 / 25.4, "px": 1.0,},
"in": {"in": 1.0, "cm": 0.3937, "mm": 0.0393, "px": 1 / 72.0,},
"mm": {"in": 25.4, "cm": 10.0, "mm": 1, "px": 25.4 / 72,},
"cm": {"in": 2.54, "cm": 1.0, "mm": 0.1, "px": 2.54 / 72,},
}
def upar(unit_st):
"""Parse unit_st into num (float), unit (string) pair"""
unit_st = str(unit_st)
try:
# Python 3 mod
ind = list(map(str.isalpha, unit_st)).index(True)
num, unit = float(unit_st[:ind]), unit_st[ind:]
except ValueError:
num = float(unit_st)
unit = "u"
return num, unit
def repar(val, unit):
"""reparse a value and unit into a string for writing into an svg"""
if unit not in SCALE_FACTORS.keys():
raise ValueError("Unit not recognized, use px, in, mm, or cm")
return str(val) + unit
def tounit(in_unit, dst_unit):
"""returns a float with the value of string s
in the units of dst"""
# need to support em, ex, px, pt, pc, cm, mm, in
# for svg as well as percent - implemented px,in,mm and cm here
# not sure the best way to deal with the other options
# num, unit = upar(unit_st)
return in_unit[0] / SCALE_FACTORS[in_unit[1]][dst_unit]
def get_elements_by_attr(xml_node, attribute, value):
"""helper function for xml trees when using minidom"""
import itertools
def recur_get_element_by_attr(xml_node, attribute, value):
if xml_node.attributes:
test_list = xml_node.attributes.keys()
if attribute in test_list:
if xml_node.getAttribute(attribute) == value:
yield xml_node
nls = [
recur_get_element_by_attr(nd, attribute, value)
for nd in xml_node.childNodes
]
yield list(itertools.chain.from_iterable(nls))
def flatten(container):
# from hexparrot @ http://stackoverflow.com/questions/10823877/what-is-the-fastest-way-to-flatten-arbitrarily-nested-lists-in-python pylint: disable=redefined-builtin
for i in container:
if isinstance(i, (list, tuple)):
for j in flatten(i):
yield j
else:
yield i
return list(
flatten([el for el in recur_get_element_by_attr(xml_node, attribute, value)])
)
def flatten_list(container):
for i in container:
if isinstance(i, (list)):
for j in flatten_list(i):
yield j
else:
yield i
# from hexparrot @ http://stackoverflow.com/questions/10823877/
# what-is-the-fastest-way-to-flatten-arbitrarily-nested-lists-in-python
def flatten_dict(d):
"""unrap a nested dict, d, returns a new dictionary with that have tuples
as keys that specify the path through the original dictionary tree to the
leaf. e.g. {'l1key': {'l2key1':item1,'l2key2':item2}} will become
{('l1key','l2key1'):item1,('l1key','l2key2'):item2}"""
import copy
keylist = []
def traverse(kl, d):
if len(d) == 0:
yield {tuple(kl): d}
else:
for key, value in d.items():
new_keylist = copy.copy(kl)
new_keylist.append(key)
yield [l for l in traverse(new_keylist, value)]
flat_dict = {}
fd_list = [fd for fd in flatten_list(list(traverse(keylist, d)))]
[flat_dict.update(fd) for fd in flatten_list(list(traverse(keylist, d)))]
return flat_dict
def extractTreeByType(node, searchType):
"""walk a nested dictionary and pop the items of a
certain type from the dictionary"""
temp = dict()
for key, value in node.items():
if isinstance(value, searchType):
temp.update({key: value})
elif isinstance(value, dict):
rval = extractTreeByType(value, searchType)
if len(rval.keys()) > 0:
temp.update({key: rval})
return temp
def filterTreeByType(node, searchType):
for key, value in node.items():
if isinstance(value, searchType):
node.pop(key)
else:
filterTreeByType(value, searchType)
def parse_transform(transform_str):
"""convert transforms into transformation matrix"""
# print transform_str
import re
# regex for extracting numbers from transform string
scanfloat = r"[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?"
tr = None
tr_pos = None
mt = None
mt_pos = None
sc = None
sc_pos = None
##################
if "translate" in transform_str:
translate_str = re.findall(r"translate\(.*?\)", transform_str)[0]
txy = re.findall(scanfloat, translate_str)
if type(txy) is list and len(txy) == 2:
tx, ty = txy
else: # deal with rare situation of exact resizing
tx = txy[0]
ty = txy[0]
tr = np.array([[1.0, 0, float(tx)], [0, 1.0, float(ty)], [0, 0, 1.0]])
tr_pos = transform_str.find("translate")
##################
if "scale" in transform_str:
translate_str = re.findall(r"scale\(.*?\)", transform_str)[0]
sx, sy = re.findall(scanfloat, translate_str)
sc = np.array([[float(sx), 0, 0], [0, float(sy), 0], [0, 0, 1.0]])
sc_pos = transform_str.find("scale")
##################
if "matrix" in transform_str:
matrix_str = re.findall(r"matrix\(.*?\)", transform_str)[0]
a, b, c, d, e, f = re.findall(scanfloat, matrix_str)
a, b, c, d, e, f = [float(s) for s in [a, b, c, d, e, f]]
mt = np.array([[a, c, e], [b, d, f], [0, 0, 1.0]])
mt_pos = transform_str.find("matrix")
##################
tr_pos = {False: tr_pos, True: 0}[tr_pos is None]
mt_pos = {False: mt_pos, True: 0}[mt_pos is None]
sc_pos = {False: sc_pos, True: 0}[sc_pos is None]
s = [tr_pos, mt_pos, sc_pos]
def take0(x):
return x[0]
trnsfrms = [mtrx for pos, mtrx in sorted(zip(s, [tr, mt, sc]), key=take0)]
trnsfrms = [m for m in trnsfrms if not (m is None)]
from numpy import dot
from functools import reduce
if len(trnsfrms) >= 1:
mtrx = reduce(lambda x, y: dot(x, y.T), trnsfrms)
return mtrx
def get_transforms(node, tlist=[]):
"""get the list of transforms applied to a given node, walking up the svg
tree to fill tlist. Pass an empyt list to call"""
if node.hasAttribute("transform"):
# print node.toxml()
tlist.extend([parse_transform(node.getAttribute("transform"))])
if not (node.nodeName == "svg"):
return get_transforms(node.parentNode, tlist)
else:
return [t for t in tlist if not (t is None)]
class FFItem(dict, object):
""" base class for figurefirst objects that will be converted to matplotlib
objects eg. axes"""
def __init__(self, tagnode, **kwargs):
self.tagnode = tagnode
self.node = tagnode.parentNode
self.id = self.node.getAttribute("id")
self.name = tagnode.getAttribute("figurefirst:name")
self.ismplaxis = False
self.ismplfigure = False
if self.node.hasAttribute("transform"):
self.transform_str = self.node.getAttribute("transform")
else:
self.transform_str = None
class FFSVGItem(FFItem, object):
"""base class for svg objects that figurefirst will manipulate in
the native svg form eg. text and paths. These objects can be used
to change the style of tagged graphics in the document"""
def __init__(self, tagnode):
super(FFSVGItem, self).__init__(tagnode)
if self.node.tagName != "circle":
x = float(self.node.getAttribute("x"))
y = float(self.node.getAttribute("y"))
h = float(self.node.getAttribute("height"))
w = float(self.node.getAttribute("width"))
else:
x = float(self.node.getAttribute("cx"))
y = float(self.node.getAttribute("cy"))
h = float(self.node.getAttribute("r")) * 2
w = float(self.node.getAttribute("r")) * 2
self.p1 = np.array([x, y, 1])
self.p2 = np.array([x + w, h + y, 1])
self.load_style()
def __getattr__(self, attr):
if attr == "x":
return self.p1[0]
if attr == "y":
return self.p1[1]
if attr == "w":
return (self.p2 - self.p1)[0]
if attr == "h":
return (self.p2 - self.p1)[1]
if attr == "r":
return (self.p2 - self.p1)[0] / 2.0
def load_style(self):
self.loaded_attr = dict()
[self.loaded_attr.update({k: v}) for k, v in self.node.attributes.items()]
self.style = dict()
style_list = self.loaded_attr["style"].split(";")
style_list = [x for x in style_list if len(x) > 0]
[self.style.update({x.split(":")[0]: x.split(":")[1]}) for x in style_list]
def frmtstyle(self):
return ";".join(["%s:%s" % (k, v) for k, v in self.style.items()])
class FFSVGPath(FFSVGItem, object):
""" represents a svg path, currently figurefirst is unable to change the dimensions of the
path, and the x, y, w, h attributes are meaningless placeholders"""
def __init__(self, tagnode):
super(FFSVGItem, self).__init__(tagnode)
self.d_str = self.node.getAttribute("d")
self.load_style()
self.p1 = np.array([0, 0, 1])
self.p2 = np.array([0, 0, 1])
def __getattr__(self, attr):
if attr == "x":
return self.p1[0]
if attr == "y":
return self.p1[1]
if attr == "w":
return (self.p2 - self.p1)[0]
if attr == "h":
return (self.p2 - self.p1)[1]
def load_style(self):
self.loaded_attr = dict()
[self.loaded_attr.update({k: v}) for k, v in self.node.attributes.items()]
self.style = dict()
style_list = self.loaded_attr["style"].split(";")
style_list = [x for x in style_list if len(x) > 0]
[self.style.update({x.split(":")[0]: x.split(":")[1]}) for x in style_list]
def frmtstyle(self):
return ";".join(["%s:%s" % (k, v) for k, v in self.style.items()])
class FFSVGText(FFSVGItem, object):
""" represents a svg text object, you can change the text, font as well
as styling x,y contain the orign of the text box, height and with are
currently not implemented since that would require parsing the font info"""
def __init__(self, tagnode):
super(FFSVGItem, self).__init__(tagnode)
# print 'here'
x = float(self.node.getAttribute("x"))
y = float(self.node.getAttribute("y"))
self.p1 = np.array([x, y, 1])
# self.p1 = np.array([0,0,1])
self.p2 = np.array([0, 0, 1])
## need to implement h and width
# h = float(self.node.getAttribute('height'))
# w = float(self.node.getAttribute('width'))
# self.p1 = np.array([x,y,1])
# self.p2 = np.array([x+w,h+y,1])
self.load_style()
self.load_text()
self.node.getElementsByTagName("tspan")[0].childNodes[0]
def load_style(self):
self.loaded_attr = dict()
[self.loaded_attr.update({k: v}) for k, v in self.node.attributes.items()]
self.style = dict()
style_list = self.loaded_attr["style"].split(";")
style_list = [x for x in style_list if len(x) > 0]
[self.style.update({x.split(":")[0]: x.split(":")[1]}) for x in style_list]
def load_text(self):
self.text = self.node.getElementsByTagName("tspan")[0].childNodes[0].data
def __getattr__(self, attr):
if attr == "x":
return self.p1[0]
if attr == "y":
return self.p1[1]
if attr == "w":
warn("FFSVGtext object width attribute not implemented")
return (self.p2 - self.p1)[0]
if attr == "h":
warn("FFSVGtext object height attribute not implemented")
return (self.p2 - self.p1)[1]
class FFSVGGroup(FFItem, object):
""" used to collect groups of svg items"""
def __init__(self, tagnode, **kwargs):
super(FFSVGGroup, self).__init__(tagnode, **kwargs)
def __getattr__(self, attr):
try:
pnts = np.vstack(
[
np.array([np.array([i.x, i.y]), np.array([i.x + i.w, i.y + i.h])])
for i in self.values()
]
)
except ValueError:
raise NameError(
"Could not find an axis for this figure. You probably have a figurefirst:figure tag with no axes associated with it."
)
x = np.min(pnts[:, 0])
y = np.min(pnts[:, 1])
w = np.max(pnts[:, 0]) - x
h = np.max(pnts[:, 1]) - y
try:
return {"x": x, "y": y, "w": w, "h": h}[attr]
except KeyError:
return self.__getattribute__(attr)
class FFGroup(FFItem, object):
""" used to collect groups objects that will be translated into matplotlib objects
eg. axes and figures, x,y w and h is the collective x,y width and height of all the
enclosed objects"""
def __init__(self, tagnode, **kwargs):
super(FFGroup, self).__init__(tagnode, **kwargs)
def __getattr__(self, attr):
# try:
vals = [
np.array([np.array([i.x, i.y]), np.array([i.x + i.w, i.y + i.h])])
for i in self.values()
]
# print(attr)
if len(vals) > 0:
pnts = np.vstack(
[
np.array([np.array([i.x, i.y]), np.array([i.x + i.w, i.y + i.h])])
for i in self.values()
]
)
x = np.min(pnts[:, 0])
y = np.min(pnts[:, 1])
w = np.max(pnts[:, 0]) - x
h = np.max(pnts[:, 1]) - y
try:
return {"x": x, "y": y, "w": w, "h": h}[attr]
except KeyError:
# return self.__dict__[attr]
return super(FFGroup, self).__getattribute__(attr)
# return self.__getattribute__(attr)
else:
pnts = None
return self.__getattribute__(attr)
# except ValueError:
# raise NameError('Could not find an axis for this figure. You probably have a figurefirst:figure tag with no axes associated with it.')
class FFFigure(FFGroup, object):
""" Represents a matplotlib figure """
def __init__(self, tagnode, **kwargs):
if not (tagnode == None):
super(FFFigure, self).__init__(tagnode, **kwargs)
self.ismplfigure = False
def __getattr__(self, attr):
try:
if attr == "ismplfigure":
return False
val = super(FFFigure, self).__getattr__(attr)
return val
except AttributeError:
if self.ismplfigure == True:
return self.figure.__getattribute__(attr)
# return self['figure'].__getattribute__(attr)
else:
return self.__getattribute__(attr)
class FFTemplateTarget(FFFigure, object):
"""represtents the target of a template. The all the axes within the template
figure will be scaled to fit within the template target box"""
def __init__(self, tagnode, **kwargs):
self.template_source = tagnode.getAttribute("figurefirst:template")
super(FFTemplateTarget, self).__init__(tagnode, **kwargs)
x = float(self.node.getAttribute("x"))
y = float(self.node.getAttribute("y"))
h = float(self.node.getAttribute("height"))
w = float(self.node.getAttribute("width"))
self.p1 = np.array([x, y, 1])
self.p2 = np.array([x + w, h + y, 1])
def __getattr__(self, attr):
if attr == "x":
return self.p1[0]
if attr == "y":
return self.p1[1]
if attr == "w":
return (self.p2 - self.p1)[0]
if attr == "h":
return (self.p2 - self.p1)[1]
else:
try:
val = super(FFTemplateTarget, self).__getattr__(attr)
return val
except AttributeError:
if self.ismplfigure == True:
return self["figure"].__getattribute__(attr)
else:
return self.__getattribute__(attr)
class FFAxis(FFItem):
""" Stores the data requred for the creation of a matplotlib axes
as specified by the layout """
def __init__(self, tagnode, **kwargs):
super(FFAxis, self).__init__(tagnode, **kwargs)
x = float(self.node.getAttribute("x"))
y = float(self.node.getAttribute("y"))
h = float(self.node.getAttribute("height"))
w = float(self.node.getAttribute("width"))
self.p1 = np.array([x, y, 1])
self.p2 = np.array([x + w, h + y, 1])
self.record = (
False # if this is true, it will save all matplotlib calls to the datafile
)
def __getattr__(self, attr):
if attr == "x":
return self.p1[0]
if attr == "y":
return self.p1[1]
if attr == "w":
return (self.p2 - self.p1)[0]
if attr == "h":
return (self.p2 - self.p1)[1]
else:
if attr == "ismplaxis":
return self.__getattribute__(attr)
if self.ismplaxis:
data_filename = self.breadcrumb["data_filename"]
layout_filename = self.breadcrumb["layout_filename"]
layout_key = self.breadcrumb["layout_key"]
# wrap custom functions as if they are matplotlib functions
# functions must have form: func(ax, *args, *kwargs)
# Two options:
# (1) Self contained function, which will be pickled into the data file
# (2) String pointing to a package.module.function (package.module.submodule.function okay too)
# syntax: (1) _custom
# (2) first argument is a list
# - if not empty: first element is a unique title,
# additional elements should describe the arguments (in order)
# argument descriptions are not required
# - if empty: title is set to function name. duplicate titles are deleted in the data file
# thus, for non-unique function calls, it is necessary to specify a title
# (3) second argument is either a function (which will be pickled) or a string of a full package.module.function path
# example: self._plot(['Unique Title', 'Time', 'Response'],
# user_defined_function, *args, **kwargs)
if PY3 and attr == "_custom":
def custom_wrapper(*args, **kwargs):
info = args[0]
title = args[1]
args_description = []
if len(info) > 0:
title = info[0]
if len(info) > 1:
args_description = info[1:]
function = args[1]
package = "custom"
regenerate.__save_fifidata__(
data_filename,
layout_key,
package,
function,
title,
args_description,
*args[2:],
**kwargs
)
f = regenerate.__load_custom_function__(package, function)
f(self["axis"], *args[2:], **kwargs)
return custom_wrapper
# wrap matplotlib methods and figurefirst.mpl_functions and save data to a pickle file
# syntax: (1) call: prepend '_' to function call (eg. '_plot', '_set_xlim', '_adjust_spines')
# (2) first argument is a list
# - if not empty: first element is a unique title,
# additional elements should describe the arguments (in order)
# argument descriptions are not required
# - if empty: title is set to function name. duplicate titles are deleted in the data file
# thus, for non-unique function calls, it is necessary to specify a title
# example: self._plot(['Unique Title', 'Time', 'Response'], *args, **kwargs)
#
# notes: add_artist does not work, other functions like linecollections etc. might not work either?
elif PY3 and attr[0] == "_":
function = attr[1:]
if function in mpl_functions.__dict__.keys():
def figurefirst_wrapper(*args, **kwargs):
info = args[0]
title = attr[1:]
args_description = []
if len(info) > 0:
title = info[0]
if len(info) > 1:
args_description = info[1:]
package = "figurefirst"
function = attr[1:]
regenerate.__save_fifidata__(
data_filename,
layout_key,
package,
function,
title,
args_description,
*args[1:],
**kwargs
)
f = regenerate.__load_custom_function__(package, function)
f(self["axis"], *args[1:], **kwargs)
return figurefirst_wrapper
else:
def mpl_wrapper(*args, **kwargs):
info = args[0]
title = attr[1:]
args_description = []
if len(info) > 0:
title = info[0]
if len(info) > 1:
args_description = info[1:]
package = "matplotlib"
function = attr[1:]
if not regenerate.__is_mpl_call_saveable__(function):
s = (
"Function name: "
+ function
+ " cannot be saved. Try finding a replacement in figurefirst.mpl_functions, or define your own custom wrapper"
)
raise ValueError(s)
regenerate.__save_fifidata__(
data_filename,
layout_key,
package,
function,
title,
args_description,
*args[1:],
**kwargs
)
self["axis"].__getattribute__(attr[1:])(
*args[1:], **kwargs
) # This calls a matplotlib method
return mpl_wrapper
# regular matplotlib or figurefirst.mpl_functions call, will only be recorded if self.record = True
else:
if not PY3:
return self["axis"].__getattribute__(attr)
else:
if not self.record:
return self["axis"].__getattribute__(attr)
else:
if attr in mpl_functions.__dict__.keys():
def wrapper(*args, **kwargs):
title = attr
args_description = []
package = "figurefirst"
function = attr
regenerate.__save_fifidata__(
data_filename,
layout_key,
package,
function,
title,
args_description,
*args,
**kwargs
)
f = regenerate.__load_custom_function__(
package, function
)
f(self["axis"], *args, **kwargs)
else:
def wrapper(*args, **kwargs):
title = attr
package = "matplotlib"
function = attr
args_description = []
if not regenerate.__is_mpl_call_saveable__(
function
):
s = (
"Function name: "
+ function
+ " cannot be saved. Try finding a replacement in figurefirst.mpl_functions, or define your own custom wrapper, or turn off record."
)
raise ValueError(s)
regenerate.__save_fifidata__(
data_filename,
layout_key,
package,
function,
title,
args_description,
*args,
**kwargs
)
self["axis"].__getattribute__(attr)(
*args, **kwargs
) # This calls a matplotlib method
return wrapper
else:
return self.__getattribute__(attr)
class PathSpec(dict):
def __init__(self, *args, **kwargs):
for arg in args:
try:
if arg.tagName == "figurefirst:pathspec":
self.load(arg)
self.name = arg.getAttributeNS(
"http://flyranch.github.io/figurefirst/", "name"
)
if arg.tagName == "figurefirst:linespec":
self.load(arg)
self.name = arg.getAttributeNS(
"http://flyranch.github.io/figurefirst/", "name"
)
if arg.tagName == "figurefirst:patchspec":
self.load(arg)
self.name = arg.getAttributeNS(
"http://flyranch.github.io/figurefirst/", "name"
)
except AttributeError:
if type(arg) == FigureLayout:
self.layout = arg
super(PathSpec, self).__init__(**kwargs)
def load(self, ptag):
pnode = ptag.parentNode
[self.update({k: v}) for k, v in pnode.attributes.items()]
self.style = dict()
[
self.style.update({x.split(":")[0]: x.split(":")[1]})
for x in self["style"].split(";")
]
class LineSpec(PathSpec):
def mplkwargs(self):
mpl_map = {"stroke": "color", "stroke-opacity": "alpha", "stroke-width": "lw"}
mpl_kwargs = {}
keylist = list()
for k, v in self.style.items():
try:
mpl_kwargs[mpl_map[k]] = v
except KeyError:
pass
for k, v in mpl_kwargs.items():
if k == "lw":
tmp = v.split("px")[0]
tmp = (
self.layout.from_userx(tmp, "in") / 13.889e-3
) # hard coding pnt scaling
mpl_kwargs["lw"] = tmp
if k == "alpha":
mpl_kwargs["alpha"] = float(v)
return mpl_kwargs
class PatchSpec(PathSpec):
def mplkwargs(self):
mpl_map = {"stroke": "edgecolor", "stroke-width": "lw", "fill": "facecolor"}
mpl_kwargs = {}
keylist = list()
for k, v in self.style.items():
try:
mpl_kwargs[mpl_map[k]] = v
except KeyError:
pass
from matplotlib.colors import ColorConverter
converter = ColorConverter()
for k, v in mpl_kwargs.items():
if k == "lw":
tmp = v.split("px")[0]
tmp = (
self.layout.from_userx(tmp, "in") / 13.889e-3
) # hard coding pnt scaling
mpl_kwargs["lw"] = tmp
if k == "edgecolor":
mpl_kwargs["edgecolor"] = np.array(
converter.to_rgba(v, float(self.style["stroke-opacity"]))
)
if k == "facecolor":
mpl_kwargs["facecolor"] = np.array(
converter.to_rgba(v, float(self.style["fill-opacity"]))
)
return mpl_kwargs
class FigureLayout(object):
def __init__(
self,
layout_filename,
autogenlayers=True,
make_mplfigures=False,
dpi=300,
hide_layers=("Layer 1",),
):
"""An object which specifies the figure layout fom the svg file layout_filename.
:param layout_filename:
:param autogenlayers: bool
If True, figurefirst will automatically create target layers in the svg for each figure. Default True.
:param make_mplfigures: bool
If True, figurefirst will call self.make_mplfigures() during instantiation. Default False.
:param dpi: float
Dots per inch. Default 300.
:param hide_layers: iterable of str
Names of inkscape layers you want to make invisible (e.g. your template layers). Default ("Layer 1",).
"""
self.dpi = dpi # should be 300 for print figures
self.autogenlayers = autogenlayers
self.layout_filename = os.path.join(layout_filename)
# from xml.dom import minidom
# layout_filename = layout_filename
self.layout = minidom.parse(self.layout_filename).getElementsByTagName("svg")[0]
self.layout_width = upar(self.layout.getAttribute("width"))
if self.layout_width[1] == "u":
self.layout_width = (self.layout_width[0], "px")
self.layout_height = upar(self.layout.getAttribute("height"))
if self.layout_height[1] == "u":
self.layout_height = (self.layout_height[0], "px")
self.layout_viewBox = self.layout.getAttribute("viewBox").split()
self.layout_uw = float(self.layout_viewBox[2])
self.layout_uh = float(self.layout_viewBox[3])
self.layout_user_sx = (
self.layout_uw / self.layout_width[0],
self.layout_width[1],
)
self.layout_user_sy = (
self.layout_uh / self.layout_height[0],
self.layout_height[1],
)
self.output_xml = minidom.parse(self.layout_filename).cloneNode(True)
self.data_filename = self.layout_filename.split(".svg")[0] + "_data.dillpickle"
try:
figuretree, grouptree, leafs, svgitemtree = self.make_group_tree()
self.axes = leafs
self.figures = figuretree
self.axes_groups = grouptree
self.svgitems = svgitemtree
self.load_pathspecs()
except AttributeError:
pass # print('Warning: No rectangles in Document!')
except KeyError:
print(
"Warning: key error - probably loading a layout with missing links, like missing figurefirst:template targets."
)
# add the spinespecs
for ax in self.axes.values():
if not (ax.node is None):
for node in ax.node.childNodes:
if node.nodeType == 1:
if node.tagName == "figurefirst:spinespec":
ax.spinespec = node.getAttribute("figurefirst:spinelist")
# self.load_svgitems()
# dont allow sx and sy to differ
# inkscape seems to ignore inconsistent aspect ratios by
# only using the horizontal element of the viewbox, but
# it is probably best to assert that the a.r's are the same
# for now
# assert self.layout_user_sx == self.layout_user_sy
if (
np.abs(self.layout_user_sx[0] - self.layout_user_sy[0])
> figurefirst_user_parameters.rounding_tolerance
):
warn(
"""The the scaling of the user units in x and y are different and may result in unexpected
behavior. Make sure that the aspect ratio defined by the viewbox attribute of the root
SVG node is the same as that given by the document hight and width."""
)
if make_mplfigures:
self.make_mplfigures()
self._hide_layers(*hide_layers)
def __getattr__(self, attr):
if attr == "fig":
# from matplotlib import pyplot
return plt.gcf()
else:
raise AttributeError
def from_userx(self, x, dst):
"""transfrom from user coords to dst coords"""
x = float(x) # allow passing of strings
# convert into layout units
x_l = x / self.layout_user_sx[0]
# convert from layout units into destination units
return x_l / SCALE_FACTORS[self.layout_user_sx[1]][dst]
def from_usery(self, y, dst):
"""same as userx but for y coords,not used in this version"""
y = float(y) # allow passing of strings
# convert into layout units
y_l = y / self.layout_user_sx[0]
# convert from layout units into destination units
return y_l / SCALE_FACTORS[self.layout_user_sx[1]][dst]
def make_group_tree(self):
""" does the work of traversing the svg document and building the representation
of figures, groups and axes, this needs to be done before self.makemplfigures
can generate the matplotlib figurs"""
def traverse_axes(node, grouptree):
gname = None
axname = None
tree_loc = grouptree
for child in node.childNodes:
if child.nodeType == 1:
if child.tagName in ["figurefirst:group"]:
grp = FFGroup(child)
grouptree[grp.name] = grp
tree_loc = grouptree[grp.name]
if child.tagName in ["figurefirst:axis"]:
ax = FFAxis(child)
grouptree[ax.name] = ax
mpl_methods_elements = node.getElementsByTagName(
"figurefirst:mplmethods"
)
mpl_methods = dict()
grouptree[ax.name].mplmethods = mpl_methods
for mpl_methods_element in mpl_methods_elements:
[
grouptree[ax.name].mplmethods.update({key: value})
for key, value in mpl_methods_element.attributes.items()
]
projection = node.getElementsByTagName("figurefirst:projection")
if child.hasAttribute("figurefirst:projection"):
grouptree[ax.name].projection = child.getAttribute(
"figurefirst:projection"
)
else:
grouptree[ax.name].projection = "rectilinear"
if child.hasAttribute("figurefirst:spinespec"):
grouptree[ax.name].spinespec = child.getAttribute(
"figurefirst:spinespec"
)
if child.tagName in ["figurefirst:figure"]:
if child.hasAttribute("figurefirst:template"):
fig = FFTemplateTarget(child)
grouptree[fig.name] = fig
else:
fig = FFFigure(child)
grouptree[fig.name] = fig
tree_loc = grouptree[fig.name]
# if child.tagName in ['figurefirst:svgitem']:
# if node.tagName == 'path':
# item = FFSVGPath(child)
# elif node.tagName == 'text':
# item = FFSVGText(child)
# else:
# item = FFSVGItem(child)
# grouptree[item.name] = item
for child in node.childNodes:
if child.hasChildNodes():
traverse_axes(child, tree_loc)
def traverse_svgitems(node, svgtree):
gname = None
axname = None
tree_loc = svgtree
for child in node.childNodes:
if child.nodeType == 1:
if child.tagName in ["figurefirst:svggroup"]:
grp = FFSVGGroup(child)
svgtree[grp.name] = grp
tree_loc = svgtree[grp.name]
if child.tagName in ["figurefirst:svgitem"]:
if node.tagName == "path":
item = FFSVGPath(child)
elif node.tagName == "text":
item = FFSVGText(child)
else:
item = FFSVGItem(child)
svgtree[item.name] = item
for child in node.childNodes:
if child.hasChildNodes():
traverse_svgitems(child, tree_loc)
### Create the group tree
grouptree = dict()
traverse_axes(self.layout, grouptree)
svgitemtree = dict()
traverse_svgitems(self.layout, svgitemtree)
# filterTreeByType(grouptree,FFSVGPath)
leafs = flatten_dict(grouptree)
# extract the axes from the rest of the svgitems
axtree = extractTreeByType(grouptree, FFAxis)
# svgitemtree = extractTreeByType(grouptree,FFSVGItem)
### Create the figure tree
figuretree = dict()
figuretree["none"] = FFFigure(None)
for val in grouptree.values():
if isinstance(val, FFFigure):
figuretree[val.name] = val
else:
figuretree["none"][val.name] = val
### Compose the transforms
from numpy import dot
from functools import reduce
for leafname, leaf in leafs.items():
tlist = get_transforms(leaf.node, [])
tlist.reverse()
leaf.tlist = tlist
if len(tlist) > 0:
mtrx = reduce(lambda x, y: dot(x, y), tlist)
leaf.mtrx = mtrx
else:
leaf.mtrx = np.diag(np.ones(3))
leaf.p1 = np.dot(leaf.mtrx, leaf.p1)
leaf.p2 = np.dot(leaf.mtrx, leaf.p2)
# svg origin is at top left
leaf.p1[1] = self.layout_uh - leaf.p1[1]
leaf.p2[1] = self.layout_uh - leaf.p2[1]
# Deal with any vector flippage
sp = np.vstack([leaf.p1, leaf.p2])
tp1 = np.min(sp, axis=0)
tp2 = np.max(sp, axis=0)
leaf.p1 = tp1
leaf.p2 = tp2
### need to add error condition for points that are outside the figure bounds
### Populate the template targets
for key, l in leafs.items():
if type(l) == FFTemplateTarget:
import copy
# for k,v in figuretree[l.template_source].items():
# try:
figuretree[l.template_source].node = None
figuretree[l.template_source].tagnode = "None"
for value, item in figuretree[l.template_source].items():
item.node = None
item.tagnode = "None"
newv = copy.deepcopy(figuretree[l.template_source])
# except RuntimeError:
vleafs = flatten_dict(newv)
origin = np.array([newv.x, newv.y, 1])
sx = l.w / newv.w
sy = l.h / newv.h
for vleaf in vleafs.values():
t1 = (vleaf.p1 - origin) * np.array([sx, sy, 0]) + l.p1
t2 = t1 + np.array([vleaf.w * sx, vleaf.h * sy, 0])
vleaf.p1 = t1
vleaf.p2 = t2
l[vleaf.name] = vleaf
### Re-folliate
leafs = flatten_dict(figuretree)
# print leafs
new_leafs = dict()
for key, value in leafs.items():
if isinstance(value, FFAxis):
# if len(key) ==1:
if key[0] == "none":
if len(key) == 1:
pass
elif len(key) == 2:
new_leafs[key[1]] = value
else:
new_leafs[tuple(key[1:])] = value
else:
new_leafs[key] = value
axtree = figuretree
return figuretree, axtree, new_leafs, svgitemtree
def load_svgitems(self):
"""loads the svgitems from the layout document"""
self.svgitems = dict()
elementlist = self.layout.getElementsByTagNameNS(XMLNS, "svgitem")
itemlist = [SVGItem(el, self) for el in elementlist]
[self.svgitems.update({sp.name: sp}) for sp in itemlist]
def load_pathspecs(self):
"""parses pathspec objects from the layout document"""
self.pathspecs = dict()
elementlist = self.layout.getElementsByTagNameNS(XMLNS, "pathspec")
speclist = [PathSpec(el, self) for el in elementlist]
[self.pathspecs.update({sp.name: sp}) for sp in speclist]
elementlist = self.layout.getElementsByTagNameNS(XMLNS, "linespec")
speclist = [LineSpec(el, self) for el in elementlist]
[self.pathspecs.update({sp.name: sp}) for sp in speclist]
elementlist = self.layout.getElementsByTagNameNS(XMLNS, "patchspec")
speclist = [PatchSpec(el, self) for el in elementlist]
[self.pathspecs.update({sp.name: sp}) for sp in speclist]
def get_outputfile_layers(self):
"""returns dictionary of layers in teh output file"""
output_svg = self.output_xml.getElementsByTagName("svg")[0]
layers = get_elements_by_attr(output_svg, "inkscape:groupmode", "layer")
layerdict = {}
for l in layers:
label = attributes["inkscape:label"].value
layerdict[label] = l
return layerdict
def set_layer_visibility(
self, inkscape_label="Layer 1", vis=True, gid=None,
):
"""appled to the output svg usefull to hide the design layers on the
newly created figures"""
import re
value = {False: "none", True: "inline"}[vis]
output_svg = self.output_xml.getElementsByTagName("svg")[0]
layers = get_elements_by_attr(output_svg, "inkscape:groupmode", "layer")
for l in layers:
if l.attributes["inkscape:label"].value == inkscape_label:
try:
style_str = l.attributes["style"].value
except:
l.setAttribute("style", "display:none")
style_str = l.attributes["style"].value
repl_str = re.sub(
r"display:(none|inline)", "display:%s" % (value), style_str
)
l.setAttribute("style", repl_str)
def create_new_targetlayer(self, layer_name):
new_layer = self.output_xml.createElement("g")
new_targetlayer = self.output_xml.createElementNS(
XMLNS, "figurefirst:targetlayer"
)
# check to make sure there is not already a layer with that name / id
output_svg = self.output_xml.getElementsByTagName("svg")[0]
layers = get_elements_by_attr(output_svg, "inkscape:groupmode", "layer")
for layer in layers:
if layer_name == layer.getAttribute(
"id"
) or layer_name == layer.getAttribute("inkscape:label"):
raise ValueError("Layer with that name already exists!")
# set default attributes
attributes = {
u"style": u"display:inline;stroke-linecap:butt;stroke-linejoin:round",
u"inkscape:label": layer_name,
u"id": layer_name,
u"inkscape:groupmode": "layer",
}
for attribute, value in attributes.items():
new_layer.setAttribute(attribute, value)
ff_targetlayer_name = layer_name
new_targetlayer.setAttributeNS(XMLNS, "figurefirst:name", ff_targetlayer_name)
new_layer.appendChild(new_targetlayer)
output_svg.appendChild(new_layer)
def get_figure_element_by_name(self, name):
"""finds the xmlnode with a given figurefirst:name tag"""
figure_elements = self.layout.getElementsByTagNameNS(XMLNS, "figure")
figure_elements_by_name_dict = {}
for figure_element in figure_elements:
figname = figure_element.getAttribute("figurefirst:name")
figure_elements_by_name_dict[figname] = figure_element
return figure_elements_by_name_dict[name]
def make_mplfigures(self, hide=False, axes_order={}):
"""generates matplotlib figures from the tree of parsed FFFigure and FFGroup,
FFTemplatetargets
axes_order: {'figure1': [top_axis, next_axis, etc.], 'figure2': []}. Dictionary of the figures, that point to the list of axes, starting with the axis that should be on top first. Any axes not listed will end up on the bottom.
"""
for figname, figgroup in self.figures.items():
if len(figgroup.keys()):
leafs = flatten_dict(figgroup)
fw_in = tounit(self.layout_width, "in")
fh_in = tounit(self.layout_height, "in")
fig = plt.figure(figsize=(fw_in, fh_in))
if figname in axes_order.keys():
ordered_axes_for_fig = [(a,) for a in axes_order[figname]]
for leafkey in leafs.keys():
if leafkey not in ordered_axes_for_fig:
ordered_axes_for_fig.append(leafkey)
ordered_axes_for_fig = ordered_axes_for_fig[::-1]
else:
ordered_axes_for_fig = leafs.keys()
for leafkey in ordered_axes_for_fig:
leaf = leafs[leafkey]
left = leaf.x / self.layout_uw
width = leaf.w / self.layout_uw
height = leaf.h / self.layout_uh
bottom = leaf.y / self.layout_uh
if type(leaf) == FFAxis:
leaf["axis"] = fig.add_axes(
[left, bottom, width, height],
projection=leaf.projection,
label="-".join(leafkey),
)
leaf["figname"] = figname
leaf.ismplaxis = True
figgroup.figure = fig
# figgroup['figure'] = fig
figgroup.ismplfigure = True
else:
pass
# print type(leaf)
if hide:
plt.close()
self.make_breadcrumbs_for_axes()
def append_figure_to_layer(
self,
fig,
fflayername,
cleartarget=figurefirst_user_parameters.cleartarget,
save_traceback=figurefirst_user_parameters.save_traceback,
notes=None,
):
"""inserts a figure object, fig, into an inkscape SVG layer, the layer fflayername should be
taged with a figurefirst:targetlayer tag. if fflayername is not found then a targetlayer is generated so
long as self.autogenlayers is set to True, the default. If cleartarget is set to True then the contents of the
target layer will be removed, usefull for itterative figure design.
save_traceback - save the traceback stack to the figure's xml. This makes it easy to find out what function was
used to generate the figure. Also saves date modified
notes - string, which is added as an attribute to the xml of the layer. Helpful if you want to embed info into the
layers for future reference.
"""
svg_string = self.to_svg_buffer(fig)
mpldoc = minidom.parse(svg_string)
def get_target_layer(fflayername):
target_layers = self.output_xml.getElementsByTagNameNS(XMLNS, "targetlayer")
found_target = False
for tl in target_layers:
if tl.getAttribute("figurefirst:name") == fflayername:
target_layer = tl.parentNode
found_target = True
return target_layer, found_target
return None, found_target
target_layer, found_target = get_target_layer(fflayername)
if not (found_target):
if self.autogenlayers:
self.create_new_targetlayer(fflayername)
# print('Created new layer: %s'%(fflayername))
target_layer, found_target = get_target_layer(fflayername)
else:
target_layer = target_layers[0]
# print('targetlayer %s not found inserting into %s'%(fflayername,target_layer.getAttribute('figurefirst:name')))
target_layer = target_layer.parentNode
if cleartarget:
try:
self.clear_fflayer(fflayername)
except:
print(
"could not clear target, probably because desired target not found, try specifying fflayername, or use autogenlayers=True"
)
mpl_svg = mpldoc.getElementsByTagName("svg")[0]
output_svg = self.output_xml.getElementsByTagName("svg")[0]
mpl_viewbox = mpl_svg.getAttribute("viewBox").split()
output_scale = self.layout_uw / float(mpl_viewbox[2])
mpl_svg_nodes = mpl_svg.childNodes
[target_layer.appendChild(n.cloneNode(True)) for n in mpl_svg_nodes]
target_layer.setAttribute(
"transform", "scale(%s,%s)" % (output_scale, output_scale)
)
output_svg.setAttribute("xmlns:xlink", mpl_svg.getAttribute("xmlns:xlink"))
if fig.get_gid() is not None:
# pass figure gid to svg
for gr in output_svg.getElementsByTagName("g"):
if gr.attributes:
if "id" in gr.attributes.keys():
if gr.getAttribute("id") == "figure_1":
gr.setAttribute("id", fig.get_gid())
ax_ids = [ax.get_gid() for ax in fig.get_axes() if ax.get_gid() is not None]
if len(ax_ids) > 0:
print("unable to pass axes gid to svg")
if save_traceback:
tb = traceback.extract_stack()
tb_formatted = traceback.format_list(tb)
self.add_attribute_to_layer(
fflayername, "figurefirst:traceback", tb_formatted
)
time_str = (
time.strftime("%b %d %Y %H:%M:%S", time.localtime(time.time()))
+ " "
+ time.strftime("%Z", time.gmtime())
)
self.add_attribute_to_layer(
fflayername, "figurefirst:date-modified", time_str
)
if notes:
self.add_attribute_to_layer(fflayername, "figurefirst:notes", notes)
def add_attribute_to_layer(self, layer_name, attribute, value):
output_svg = self.output_xml.getElementsByTagName("svg")[0]
layers = get_elements_by_attr(output_svg, "inkscape:groupmode", "layer")
for layer in layers:
if layer_name == layer.getAttribute(
"id"
) or layer_name == layer.getAttribute("inkscape:label"):
svg_layer = layer
svg_layer.setAttribute(unicode(attribute), unicode(value))
return
s = "Failed to find layer: " + layer_name
raise ValueError(s)
def insert_figures(
self,
fflayername="mpl_layer",
cleartarget=figurefirst_user_parameters.cleartarget,
):
""" takes a reference to the matplotlib figure and saves the
svg data into the target layer specified with the xml tag <figurefirst:targetlayer>
this tag must have the attribute figurefirst:name = fflayername"""
for fig in self.figures.values():
if fig.ismplfigure:
self.append_figure_to_layer(fig, fflayername, cleartarget=cleartarget)
else:
print(fig.__dict__)
def apply_mpl_methods(self):
""" apply valid mpl methods to figure"""
for mplax in self.axes.values():
ax = mplax["axis"]
# if 'mplmethods' in mplax.keys():
for key, value in mplax.mplmethods.items():
if key.startswith("figurefirst:"):
potential_method = key.split("figurefirst:")[1]
try:
eval("ax." + potential_method + "(" + value + ")")
# print "ax."+potential_method+"("+value+")"
# getattr(ax, potential_method)(eval(value))
except AttributeError:
print(potential_method, "is unknown method for mpl axes")
def apply_svg_attrs(self, svg_items_to_update="all"):
"""applies attributes to svgitems eg. lw stroke ect... need to call
this function before saving in order to propegate changes to svgitems
svg_items_to_update - (optional) - provide a list of the svgitem tags that you wish to have updated. Default is 'all', which updates all the svgitems,
which could reset svgitems whose attributes were not set since the last call to 'None'.
"""
leafs = flatten_dict(self.svgitems)
output_svg = self.output_xml.getElementsByTagName("svg")[0]
for svgkey, svgitem in leafs.items():
if svg_items_to_update != "all":
if (
svgkey[0] not in svg_items_to_update
): # for some reason the svgkey is a tuple
continue
nd = svgitem.node
ndid = nd.getAttribute("id")
outnd = get_elements_by_attr(output_svg, "id", ndid)[0]
outnd.setAttribute("style", svgitem.frmtstyle())
if isinstance(svgitem, FFSVGText):
outnd.getElementsByTagName("tspan")[0].childNodes[0].data = svgitem.text
outnd.getElementsByTagName("tspan")[0].setAttribute(
"style", svgitem.frmtstyle()
)
def pass_xml(self, gid, key, value):
"""pass key, value pair xml pair to group with ID gid
gid should contain prefix 'figurefirst:' to ensure uniqueness
usage: layout.pass_xml(gid,'jessyink:effectIn', 'name:appear;order:1;length:800')"""
if gid[:12] != "figurefirst:":
warn(
"""Warning: ID should start with 'figurefirst:'
because non-unique ids will cause silent failure in jessyink"""
)
output_svg = self.output_xml.getElementsByTagName("svg")[0]
elist = list()
for gr in output_svg.getElementsByTagName("g"):
if gr.attributes:
test_list = gr.attributes.keys()
if "id" in test_list:
if gr.getAttribute("id") == gid:
elist.append(gr)
if len(elist) > 1:
print(len(elist), "groups with mataching ID found")
elif len(elist) == 0:
print("ID not found")
for el in elist:
el.setAttribute(key, value)
def to_svg_buffer(self, fig):
"""writes a matplotlib figure into a stringbuffer and returns the buffer"""
if PY3:
from io import StringIO
else:
from StringIO import StringIO
fid = StringIO()
# if fig.ismplfigure:
fig.figure.savefig(fid, format="svg", transparent=True, dpi=self.dpi)
fid.seek(0)
return fid
def write_svg(self, output_filename):
""" writes the current output_xml document to output_filename"""
try:
outfile = open(output_filename, "w", encoding="utf-8")
self.output_xml.writexml(outfile, encoding="utf-8")
except UnicodeEncodeError:
outfile.close()
outfile = open(output_filename, "w")
outfile.write(self.output_xml.toxml().encode("ascii", "xmlcharrefreplace"))
outfile.close()
def save(self, filename, hidelayers=(), targetlayer=None, fix_meterlimt=True):
"""convenience function, inserts layers and then calls
wirte_svg to save"""
if targetlayer:
self.insert_figures(fflayername=targetlayer)
else:
self.insert_figures()
self._hide_layers(*hidelayers)
self.write_svg(filename)
from . import mpl_functions
if fix_meterlimt:
mpl_functions.fix_mpl_svg(filename)
def _hide_layers(self, *layer_names):
for l in layer_names:
self.set_layer_visibility(l, False)
def clear_fflayer(self, fflayername):
"""
If inserting mpl figure into a mpl target layer that has stuff in it,
e.g. old mpl data, use this function to clear the layer of any children
except the figurefirst:targetlayer node.
"""
target_layers = self.output_xml.getElementsByTagNameNS(XMLNS, "targetlayer")
target_layer = None
for tl in target_layers:
if tl.getAttribute("figurefirst:name") == fflayername:
target_layer = tl.parentNode
if target_layer is None:
return # no target found
removed_children = 1
while (
removed_children != 0
): # this is not the prettiest way to do this, but it mostly works
remove = True
while (
remove
): # getting a list of children and then removing them 1 by 1 does not work!
children = target_layer.childNodes
if len(children) == 1:
if children[0].nodeName == "figurefirst:targetlayer":
remove = False
else:
raise ValueError("Something wrong with target layer!")
removed_children = 0
for child in children:
if 1:
if child.nodeName != "figurefirst:targetlayer":
# print('Removing node: '+ child.nodeName)
target_layer.removeChild(child)
removed_children += 1
else:
pass
# print 'Not removing: ', child.nodeName
def make_breadcrumbs_for_axes(self):
"""
Save layout.svg, data.svg, figure, axis information into each mpl axis
"""
breadcrumb = {
"layout_key": None,
"layout_filename": self.layout_filename,
"data_filename": self.data_filename,
}
for key, axis in self.axes.items():
breadcrumb_copy = copy.deepcopy(breadcrumb)
key_copy = (k for k in key)
breadcrumb_copy["layout_key"] = tuple(key_copy)
axis.breadcrumb = breadcrumb_copy
def write_fifidata(self, info, *args, **kwargs):
"""
Write arbitrary data to the figurefirst data file
info - list of strings, e.g. ['title', 'description 1', 'description 2']
args - data you want to store in the data file
"""
print(self.data_filename)
regenerate.__save_fifidata__(
self.data_filename,
"Supplemental Data",
"none",
"none",
info[0],
info[1:],
*args,
**kwargs
)
