def __init__(self, legend, use_blit=False, update="loc"):

"""

self.legend = legend

if update in ["loc", "bbox"]:

self._update = update

else:

raise ValueError("update parameter '%s' is not supported." %

update)

DraggableOffsetBox.__init__(self, legend, legend._legend_box,

use_blit=use_blit)

def artist_picker(self, legend, evt):

return self.legend.contains(evt)

def finalize_offset(self):

loc_in_canvas = self.get_loc_in_canvas()

if self._update == "loc":

self._update_loc(loc_in_canvas)

elif self._update == "bbox":

self._update_bbox_to_anchor(loc_in_canvas)

else:

raise RuntimeError("update parameter '%s' is not supported." %

self.update)

def _update_loc(self, loc_in_canvas):

bbox = self.legend.get_bbox_to_anchor()

# if bbox has zero width or height, the transformation is

# ill-defined. Fall back to the defaul bbox_to_anchor.

if bbox.width == 0 or bbox.height == 0:

self.legend.set_bbox_to_anchor(None)

bbox = self.legend.get_bbox_to_anchor()

_bbox_transform = BboxTransformFrom(bbox)

self.legend._loc = tuple(

_bbox_transform.transform_point(loc_in_canvas)

)

def _update_bbox_to_anchor(self, loc_in_canvas):

tr = self.legend.axes.transAxes

loc_in_bbox = tr.transform_point(loc_in_canvas)

"""

codes = {'best': 0, # only implemented for axes legends

'upper right': 1,

'upper left': 2,

'lower left': 3,

'lower right': 4,

'right': 5,

'center left': 6,

'center right': 7,

'lower center': 8,

'upper center': 9,

'center': 10,

}

zorder = 5

def __str__(self):

return "Legend"

def __init__(self, parent, handles, labels,

loc=None,

numpoints=None, # the number of points in the legend line

markerscale=None, # the relative size of legend markers

# vs. original

markerfirst=True, # controls ordering (left-to-right) of

# legend marker and label

scatterpoints=None, # number of scatter points

scatteryoffsets=None,

prop=None, # properties for the legend texts

fontsize=None, # keyword to set font size directly

# spacing & pad defined as a fraction of the font-size

borderpad=None, # the whitespace inside the legend border

labelspacing=None, # the vertical space between the legend

# entries

handlelength=None, # the length of the legend handles

handleheight=None, # the height of the legend handles

handletextpad=None, # the pad between the legend handle

# and text

borderaxespad=None, # the pad between the axes and legend

# border

columnspacing=None, # spacing between columns

ncol=1, # number of columns

mode=None, # mode for horizontal distribution of columns.

# None, "expand"

fancybox=None, # True use a fancy box, false use a rounded

# box, none use rc

shadow=None,

title=None, # set a title for the legend

framealpha=None, # set frame alpha

bbox_to_anchor=None, # bbox that the legend will be anchored.

bbox_transform=None, # transform for the bbox

frameon=None, # draw frame

handler_map=None,

):

"""

# local import only to avoid circularity

from matplotlib.axes import Axes

from matplotlib.figure import Figure

Artist.__init__(self)

if prop is None:

if fontsize is not None:

self.prop = FontProperties(size=fontsize)

else:

self.prop = FontProperties(size=rcParams["legend.fontsize"])

elif isinstance(prop, dict):

self.prop = FontProperties(**prop)

if "size" not in prop:

self.prop.set_size(rcParams["legend.fontsize"])

else:

self.prop = prop

self._fontsize = self.prop.get_size_in_points()

self.texts = []

self.legendHandles = []

self._legend_title_box = None

#: A dictionary with the extra handler mappings for this Legend

#: instance.

self._custom_handler_map = handler_map

locals_view = locals()

for name in ["numpoints", "markerscale", "shadow", "columnspacing",

"scatterpoints", "handleheight", 'borderpad',

'labelspacing', 'handlelength', 'handletextpad',

'borderaxespad']:

if locals_view[name] is None:

value = rcParams["legend." + name]

else:

value = locals_view[name]

setattr(self, name, value)

del locals_view

handles = list(handles)

if len(handles) < 2:

ncol = 1

self._ncol = ncol

if self.numpoints <= 0:

raise ValueError("numpoints must be > 0; it was %d" % numpoints)

# introduce y-offset for handles of the scatter plot

if scatteryoffsets is None:

self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])

else:

self._scatteryoffsets = np.asarray(scatteryoffsets)

reps = int(self.scatterpoints / len(self._scatteryoffsets)) + 1

self._scatteryoffsets = np.tile(self._scatteryoffsets,

reps)[:self.scatterpoints]

# _legend_box is an OffsetBox instance that contains all

# legend items and will be initialized from _init_legend_box()

# method.

self._legend_box = None

if isinstance(parent, Axes):

self.isaxes = True

self.axes = parent

self.set_figure(parent.figure)

elif isinstance(parent, Figure):

self.isaxes = False

self.set_figure(parent)

else:

raise TypeError("Legend needs either Axes or Figure as parent")

self.parent = parent

if loc is None:

loc = rcParams["legend.loc"]

if not self.isaxes and loc in [0, 'best']:

loc = 'upper right'

if is_string_like(loc):

if loc not in self.codes:

if self.isaxes:

warnings.warn('Unrecognized location "%s". Falling back '

'on "best"; valid locations are\n\t%s\n'

% (loc, '\n\t'.join(

six.iterkeys(self.codes))))

loc = 0

else:

warnings.warn('Unrecognized location "%s". Falling back '

'on "upper right"; '

'valid locations are\n\t%s\n'

% (loc, '\n\t'.join(

six.iterkeys(self.codes))))

loc = 1

else:

loc = self.codes[loc]

if not self.isaxes and loc == 0:

warnings.warn('Automatic legend placement (loc="best") not '

'implemented for figure legend. '

'Falling back on "upper right".')

loc = 1

self._mode = mode

self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)

# We use FancyBboxPatch to draw a legend frame. The location

# and size of the box will be updated during the drawing time.

if rcParams["legend.facecolor"] == 'inherit':

facecolor = rcParams["axes.facecolor"]

else:

facecolor = rcParams["legend.facecolor"]

if rcParams["legend.edgecolor"] == 'inherit':

edgecolor = rcParams["axes.edgecolor"]

else:

edgecolor = rcParams["legend.edgecolor"]

self.legendPatch = FancyBboxPatch(

xy=(0.0, 0.0), width=1., height=1.,

facecolor=facecolor,

edgecolor=edgecolor,

mutation_scale=self._fontsize,

snap=True

)

# The width and height of the legendPatch will be set (in the

# draw()) to the length that includes the padding. Thus we set

# pad=0 here.

if fancybox is None:

fancybox = rcParams["legend.fancybox"]

if fancybox:

self.legendPatch.set_boxstyle("round", pad=0,

rounding_size=0.2)

else:

self.legendPatch.set_boxstyle("square", pad=0)

self._set_artist_props(self.legendPatch)

self._drawFrame = frameon

if frameon is None:

self._drawFrame = rcParams["legend.frameon"]

# init with null renderer

self._init_legend_box(handles, labels, markerfirst)

if framealpha is None:

self.get_frame().set_alpha(rcParams["legend.framealpha"])

else:

self.get_frame().set_alpha(framealpha)

self._loc = loc

self.set_title(title)

self._last_fontsize_points = self._fontsize

self._draggable = None

def _set_artist_props(self, a):

"""

a.set_figure(self.figure)

if self.isaxes:

# a.set_axes(self.axes)

a.axes = self.axes

a.set_transform(self.get_transform())

def _set_loc(self, loc):

# find_offset function will be provided to _legend_box and

# _legend_box will draw itself at the location of the return

# value of the find_offset.

self._loc_real = loc

if loc == 0:

_findoffset = self._findoffset_best

else:

_findoffset = self._findoffset_loc

self._legend_box.set_offset(_findoffset)

self._loc_real = loc

self.stale = True

def _get_loc(self):

return self._loc_real

_loc = property(_get_loc, _set_loc)

def _findoffset_best(self, width, height, xdescent, ydescent, renderer):

"Helper function to locate the legend at its best position"

ox, oy = self._find_best_position(width, height, renderer)

return ox + xdescent, oy + ydescent

def _findoffset_loc(self, width, height, xdescent, ydescent, renderer):

"Helper function to locate the legend using the location code"

if iterable(self._loc) and len(self._loc) == 2:

# when loc is a tuple of axes(or figure) coordinates.

fx, fy = self._loc

bbox = self.get_bbox_to_anchor()

x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy

else:

bbox = Bbox.from_bounds(0, 0, width, height)

x, y = self._get_anchored_bbox(self._loc, bbox,

self.get_bbox_to_anchor(),

renderer)

return x + xdescent, y + ydescent

@allow_rasterization

def draw(self, renderer):

"Draw everything that belongs to the legend"

if not self.get_visible():

return

renderer.open_group('legend')

fontsize = renderer.points_to_pixels(self._fontsize)

# if mode == fill, set the width of the legend_box to the

# width of the paret (minus pads)

if self._mode in ["expand"]:

pad = 2 * (self.borderaxespad + self.borderpad) * fontsize

self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)

# update the location and size of the legend. This needs to

# be done in any case to clip the figure right.

bbox = self._legend_box.get_window_extent(renderer)

self.legendPatch.set_bounds(bbox.x0, bbox.y0,

bbox.width, bbox.height)

self.legendPatch.set_mutation_scale(fontsize)

if self._drawFrame:

if self.shadow:

shadow = Shadow(self.legendPatch, 2, -2)

shadow.draw(renderer)

self.legendPatch.draw(renderer)

self._legend_box.draw(renderer)

renderer.close_group('legend')

self.stale = False

def _approx_text_height(self, renderer=None):

"""

if renderer is None:

return self._fontsize

else:

return renderer.points_to_pixels(self._fontsize)

# _default_handler_map defines the default mapping between plot

# elements and the legend handlers.

_default_handler_map = {

StemContainer: legend_handler.HandlerStem(),

ErrorbarContainer: legend_handler.HandlerErrorbar(),

Line2D: legend_handler.HandlerLine2D(),

Patch: legend_handler.HandlerPatch(),

LineCollection: legend_handler.HandlerLineCollection(),

RegularPolyCollection: legend_handler.HandlerRegularPolyCollection(),

CircleCollection: legend_handler.HandlerCircleCollection(),

BarContainer: legend_handler.HandlerPatch(

update_func=legend_handler.update_from_first_child),

tuple: legend_handler.HandlerTuple(),

PathCollection: legend_handler.HandlerPathCollection(),

PolyCollection: legend_handler.HandlerPolyCollection()

}

# (get|set|update)_default_handler_maps are public interfaces to

# modify the default handler map.

@classmethod

def get_default_handler_map(cls):

"""

return cls._default_handler_map

@classmethod

def set_default_handler_map(cls, handler_map):

"""

cls._default_handler_map = handler_map

@classmethod

def update_default_handler_map(cls, handler_map):

"""

cls._default_handler_map.update(handler_map)

def get_legend_handler_map(self):

"""

default_handler_map = self.get_default_handler_map()

if self._custom_handler_map:

hm = default_handler_map.copy()

hm.update(self._custom_handler_map)

return hm

else:

return default_handler_map

@staticmethod

def get_legend_handler(legend_handler_map, orig_handle):

"""

legend_handler_keys = list(six.iterkeys(legend_handler_map))

if orig_handle in legend_handler_keys:

handler = legend_handler_map[orig_handle]

else:

for handle_type in type(orig_handle).mro():

if handle_type in legend_handler_map:

handler = legend_handler_map[handle_type]

break

else:

handler = None

return handler

def _init_legend_box(self, handles, labels, markerfirst=True):

"""

fontsize = self._fontsize

# legend_box is a HPacker, horizontally packed with

# columns. Each column is a VPacker, vertically packed with

# legend items. Each legend item is HPacker packed with

# legend handleBox and labelBox. handleBox is an instance of

# offsetbox.DrawingArea which contains legend handle. labelBox

# is an instance of offsetbox.TextArea which contains legend

# text.

text_list = [] # the list of text instances

handle_list = [] # the list of text instances

label_prop = dict(verticalalignment='baseline',

horizontalalignment='left',

fontproperties=self.prop,

)

labelboxes = []

handleboxes = []

# The approximate height and descent of text. These values are

# only used for plotting the legend handle.

descent = 0.35 * self._approx_text_height() * (self.handleheight - 0.7)

# 0.35 and 0.7 are just heuristic numbers and may need to be improved.

height = self._approx_text_height() * self.handleheight - descent

# each handle needs to be drawn inside a box of (x, y, w, h) =

# (0, -descent, width, height). And their coordinates should

# be given in the display coordinates.

# The transformation of each handle will be automatically set

# to self.get_trasnform(). If the artist does not use its

# default transform (e.g., Collections), you need to

# manually set their transform to the self.get_transform().

legend_handler_map = self.get_legend_handler_map()

for orig_handle, lab in zip(handles, labels):

handler = self.get_legend_handler(legend_handler_map, orig_handle)

if handler is None:

warnings.warn(

"Legend does not support {!r} instances.\nA proxy artist "

"may be used instead.\nSee: "

"http://matplotlib.org/users/legend_guide.html"

"#using-proxy-artist".format(orig_handle)

)

# We don't have a handle for this artist, so we just defer

# to None.

handle_list.append(None)

else:

textbox = TextArea(lab, textprops=label_prop,

multilinebaseline=True,

minimumdescent=True)

text_list.append(textbox._text)

labelboxes.append(textbox)

handlebox = DrawingArea(width=self.handlelength * fontsize,

height=height,

xdescent=0., ydescent=descent)

handleboxes.append(handlebox)

# Create the artist for the legend which represents the

# original artist/handle.

handle_list.append(handler.legend_artist(self, orig_handle,

fontsize, handlebox))

if len(handleboxes) > 0:

# We calculate number of rows in each column. The first

# (num_largecol) columns will have (nrows+1) rows, and remaining

# (num_smallcol) columns will have (nrows) rows.

ncol = min(self._ncol, len(handleboxes))

nrows, num_largecol = divmod(len(handleboxes), ncol)

num_smallcol = ncol - num_largecol

# starting index of each column and number of rows in it.

largecol = safezip(list(xrange(0,

num_largecol * (nrows + 1),

(nrows + 1))),

[nrows + 1] * num_largecol)

smallcol = safezip(list(xrange(num_largecol * (nrows + 1),

len(handleboxes), nrows)),

[nrows] * num_smallcol)

else:

largecol, smallcol = [], []

handle_label = safezip(handleboxes, labelboxes)

columnbox = []

for i0, di in largecol + smallcol:

# pack handleBox and labelBox into itemBox

itemBoxes = [HPacker(pad=0,

sep=self.handletextpad * fontsize,

children=[h, t] if markerfirst else [t, h],

align="baseline")

for h, t in handle_label[i0:i0 + di]]

# minimumdescent=False for the text of the last row of the column

if markerfirst:

itemBoxes[-1].get_children()[1].set_minimumdescent(False)

else:

itemBoxes[-1].get_children()[0].set_minimumdescent(False)

# pack columnBox

if markerfirst:

alignment = "baseline"

else:

alignment = "right"

columnbox.append(VPacker(pad=0,

sep=self.labelspacing * fontsize,

align=alignment,

children=itemBoxes))

if self._mode == "expand":

mode = "expand"

else:

mode = "fixed"

sep = self.columnspacing * fontsize

self._legend_handle_box = HPacker(pad=0,

sep=sep, align="baseline",

mode=mode,

children=columnbox)

self._legend_title_box = TextArea("")

self._legend_box = VPacker(pad=self.borderpad * fontsize,

sep=self.labelspacing * fontsize,

align="center",

children=[self._legend_title_box,

self._legend_handle_box])

self._legend_box.set_figure(self.figure)

self.texts = text_list

self.legendHandles = handle_list

def _auto_legend_data(self):

"""

# should always hold because function is only called internally

assert self.isaxes

ax = self.parent

bboxes = []

lines = []

for handle in ax.lines:

assert isinstance(handle, Line2D)

path = handle.get_path()

trans = handle.get_transform()

tpath = trans.transform_path(path)

lines.append(tpath)

for handle in ax.patches:

assert isinstance(handle, Patch)

if isinstance(handle, Rectangle):

transform = handle.get_data_transform()

bboxes.append(handle.get_bbox().transformed(transform))

else:

transform = handle.get_transform()

bboxes.append(handle.get_path().get_extents(transform))

try:

vertices = np.concatenate([l.vertices for l in lines])

except ValueError:

vertices = np.array([])

return [vertices, bboxes, lines]

def draw_frame(self, b):

'b is a boolean. Set draw frame to b'

self.set_frame_on(b)

def get_children(self):

'return a list of child artists'

children = []

if self._legend_box:

children.append(self._legend_box)

children.append(self.get_frame())

return children

def get_frame(self):

'return the Rectangle instance used to frame the legend'

return self.legendPatch

def get_lines(self):

'return a list of lines.Line2D instances in the legend'

return [h for h in self.legendHandles if isinstance(h, Line2D)]

def get_patches(self):

'return a list of patch instances in the legend'

return silent_list('Patch',

[h for h in self.legendHandles

if isinstance(h, Patch)])

def get_texts(self):

'return a list of text.Text instance in the legend'

return silent_list('Text', self.texts)

def set_title(self, title, prop=None):

"""

self._legend_title_box._text.set_text(title)

if prop is not None:

if isinstance(prop, dict):

prop = FontProperties(**prop)

self._legend_title_box._text.set_fontproperties(prop)

if title:

self._legend_title_box.set_visible(True)

else:

self._legend_title_box.set_visible(False)

self.stale = True

def get_title(self):

'return Text instance for the legend title'

return self._legend_title_box._text

def get_window_extent(self, *args, **kwargs):

'return a extent of the legend'

return self.legendPatch.get_window_extent(*args, **kwargs)

def get_frame_on(self):

"""

return self._drawFrame

def set_frame_on(self, b):

"""

self._drawFrame = b

self.stale = True

def get_bbox_to_anchor(self):

"""

if self._bbox_to_anchor is None:

return self.parent.bbox

else:

return self._bbox_to_anchor

def set_bbox_to_anchor(self, bbox, transform=None):

"""

if bbox is None:

self._bbox_to_anchor = None

return

elif isinstance(bbox, BboxBase):

self._bbox_to_anchor = bbox

else:

try:

l = len(bbox)

except TypeError:

raise ValueError("Invalid argument for bbox : %s" % str(bbox))

if l == 2:

bbox = [bbox[0], bbox[1], 0, 0]

self._bbox_to_anchor = Bbox.from_bounds(*bbox)

if transform is None:

transform = BboxTransformTo(self.parent.bbox)

self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor,

transform)

self.stale = True

def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):

"""

assert loc in range(1, 11) # called only internally

BEST, UR, UL, LL, LR, R, CL, CR, LC, UC, C = list(xrange(11))

anchor_coefs = {UR: "NE",

UL: "NW",

LL: "SW",

LR: "SE",

R: "E",

CL: "W",

CR: "E",

LC: "S",

UC: "N",

C: "C"}

c = anchor_coefs[loc]

fontsize = renderer.points_to_pixels(self._fontsize)

container = parentbbox.padded(-(self.borderaxespad) * fontsize)

anchored_box = bbox.anchored(c, container=container)

return anchored_box.x0, anchored_box.y0

def _find_best_position(self, width, height, renderer, consider=None):

"""

# should always hold because function is only called internally

assert self.isaxes

verts, bboxes, lines = self._auto_legend_data()

bbox = Bbox.from_bounds(0, 0, width, height)

if consider is None:

consider = [self._get_anchored_bbox(x, bbox,

self.get_bbox_to_anchor(),

renderer)

for x in range(1, len(self.codes))]

candidates = []

for l, b in consider:

legendBox = Bbox.from_bounds(l, b, width, height)

badness = 0

# XXX TODO: If markers are present, it would be good to

# take their into account when checking vertex overlaps in

# the next line.

badness = legendBox.count_contains(verts)

badness += legendBox.count_overlaps(bboxes)

for line in lines:

# FIXME: the following line is ill-suited for lines

# that 'spiral' around the center, because the bbox

# may intersect with the legend even if the line

# itself doesn't. One solution would be to break up

# the line into its straight-segment components, but

# this may (or may not) result in a significant

# slowdown if lines with many vertices are present.

if line.intersects_bbox(legendBox):

badness += 1

ox, oy = l, b

if badness == 0:

return ox, oy

candidates.append((badness, (l, b)))

# rather than use min() or list.sort(), do this so that we are assured

# that in the case of two equal badnesses, the one first considered is

# returned.

# NOTE: list.sort() is stable.But leave as it is for now. -JJL

minCandidate = candidates[0]

for candidate in candidates:

if candidate[0] < minCandidate[0]:

minCandidate = candidate

ox, oy = minCandidate[1]

return ox, oy

def contains(self, event):

return self.legendPatch.contains(event)

def draggable(self, state=None, use_blit=False, update="loc"):

"""

is_draggable = self._draggable is not None

# if state is None we'll toggle

if state is None:

state = not is_draggable

if state: