"""

def get_rotation(self):

angle = text.Text.get_rotation(self)

trans = self.get_transform()

x, y = self.get_position()

new_angles = trans.transform_angles(np.array([angle]),

np.array([[x, y]]))

"""Mixin to provide labelling capability to ContourSet"""

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

"""

"""

fontsize = kwargs.get('fontsize', None)

inline = kwargs.get('inline', 1)

inline_spacing = kwargs.get('inline_spacing', 5)

self.labelFmt = kwargs.get('fmt', '%1.3f')

_colors = kwargs.get('colors', None)

self._use_clabeltext = kwargs.get('use_clabeltext', False)

# Detect if manual selection is desired and remove from argument list

self.labelManual = kwargs.get('manual', False)

self.rightside_up = kwargs.get('rightside_up', True)

if len(args) == 0:

levels = self.levels

indices = list(xrange(len(self.cvalues)))

elif len(args) == 1:

levlabs = list(args[0])

indices, levels = [], []

for i, lev in enumerate(self.levels):

if lev in levlabs:

indices.append(i)

levels.append(lev)

if len(levels) < len(levlabs):

msg = "Specified levels " + str(levlabs)

msg += "\n don't match available levels "

msg += str(self.levels)

raise ValueError(msg)

else:

raise TypeError("Illegal arguments to clabel, see help(clabel)")

self.labelLevelList = levels

self.labelIndiceList = indices

self.labelFontProps = font_manager.FontProperties()

self.labelFontProps.set_size(fontsize)

font_size_pts = self.labelFontProps.get_size_in_points()

self.labelFontSizeList = [font_size_pts] * len(levels)

if _colors is None:

self.labelMappable = self

self.labelCValueList = np.take(self.cvalues, self.labelIndiceList)

else:

cmap = colors.ListedColormap(_colors, N=len(self.labelLevelList))

self.labelCValueList = list(xrange(len(self.labelLevelList)))

self.labelMappable = cm.ScalarMappable(cmap=cmap,

norm=colors.NoNorm())

self.labelXYs = []

if cbook.iterable(self.labelManual):

for x, y in self.labelManual:

self.add_label_near(x, y, inline,

inline_spacing)

elif self.labelManual:

print('Select label locations manually using first mouse button.')

print('End manual selection with second mouse button.')

if not inline:

print('Remove last label by clicking third mouse button.')

blocking_contour_labeler = BlockingContourLabeler(self)

blocking_contour_labeler(inline, inline_spacing)

else:

self.labels(inline, inline_spacing)

# Hold on to some old attribute names. These are deprecated and will

# be removed in the near future (sometime after 2008-08-01), but

# keeping for now for backwards compatibility

self.cl = self.labelTexts

self.cl_xy = self.labelXYs

self.cl_cvalues = self.labelCValues

self.labelTextsList = cbook.silent_list('text.Text', self.labelTexts)

return self.labelTextsList

def print_label(self, linecontour, labelwidth):

"Return *False* if contours are too short for a label."

return (len(linecontour) > 10 * labelwidth

or (np.ptp(linecontour, axis=0) > 1.2 * labelwidth).any())

def too_close(self, x, y, lw):

"Return *True* if a label is already near this location."

for loc in self.labelXYs:

d = np.sqrt((x - loc[0]) ** 2 + (y - loc[1]) ** 2)

if d < 1.2 * lw:

return True

return False

def get_label_coords(self, distances, XX, YY, ysize, lw):

"""

hysize = int(ysize / 2)

adist = np.argsort(distances)

for ind in adist:

x, y = XX[ind][hysize], YY[ind][hysize]

if self.too_close(x, y, lw):

continue

return x, y, ind

ind = adist[0]

x, y = XX[ind][hysize], YY[ind][hysize]

return x, y, ind

def get_label_width(self, lev, fmt, fsize):

"""

if not isinstance(lev, six.string_types):

lev = self.get_text(lev, fmt)

lev, ismath = text.Text.is_math_text(lev)

if ismath == 'TeX':

if not hasattr(self, '_TeX_manager'):

self._TeX_manager = texmanager.TexManager()

lw, _, _ = self._TeX_manager.get_text_width_height_descent(lev,

fsize)

elif ismath:

if not hasattr(self, '_mathtext_parser'):

self._mathtext_parser = mathtext.MathTextParser('bitmap')

img, _ = self._mathtext_parser.parse(lev, dpi=72,

prop=self.labelFontProps)

lw = img.get_width() # at dpi=72, the units are PostScript points

else:

# width is much less than "font size"

lw = (len(lev)) * fsize * 0.6

return lw

def get_real_label_width(self, lev, fmt, fsize):

"""

# Find middle of axes

xx = np.mean(np.asarray(self.ax.axis()).reshape(2, 2), axis=1)

# Temporarily create text object

t = text.Text(xx[0], xx[1])

self.set_label_props(t, self.get_text(lev, fmt), 'k')

# Some black magic to get onscreen extent

# NOTE: This will only work for already drawn figures, as the canvas

# does not have a renderer otherwise. This is the reason this function

# can't be integrated into the rest of the code.

bbox = t.get_window_extent(renderer=self.ax.figure.canvas.renderer)

# difference in pixel extent of image

lw = np.diff(bbox.corners()[0::2, 0])[0]

return lw

def set_label_props(self, label, text, color):

"set the label properties - color, fontsize, text"

label.set_text(text)

label.set_color(color)

label.set_fontproperties(self.labelFontProps)

label.set_clip_box(self.ax.bbox)

def get_text(self, lev, fmt):

"get the text of the label"

if isinstance(lev, six.string_types):

return lev

else:

if isinstance(fmt, dict):

return fmt[lev]

elif callable(fmt):

return fmt(lev)

else:

return fmt % lev

def locate_label(self, linecontour, labelwidth):

"""

# Number of contour points

nsize = len(linecontour)

if labelwidth > 1:

xsize = int(np.ceil(nsize / labelwidth))

else:

xsize = 1

if xsize == 1:

ysize = nsize

else:

ysize = int(labelwidth)

XX = np.resize(linecontour[:, 0], (xsize, ysize))

YY = np.resize(linecontour[:, 1], (xsize, ysize))

# I might have fouled up the following:

yfirst = YY[:, 0].reshape(xsize, 1)

ylast = YY[:, -1].reshape(xsize, 1)

xfirst = XX[:, 0].reshape(xsize, 1)

xlast = XX[:, -1].reshape(xsize, 1)

s = (yfirst - YY) * (xlast - xfirst) - (xfirst - XX) * (ylast - yfirst)

L = np.sqrt((xlast - xfirst) ** 2 + (ylast - yfirst) ** 2).ravel()

# Ignore warning that divide by zero throws, as this is a valid option

with np.errstate(divide='ignore', invalid='ignore'):

dist = np.add.reduce([(abs(s)[i] / L[i]) for i in range(xsize)],

-1)

x, y, ind = self.get_label_coords(dist, XX, YY, ysize, labelwidth)

# There must be a more efficient way...

lc = [tuple(l) for l in linecontour]

dind = lc.index((x, y))

return x, y, dind

def calc_label_rot_and_inline(self, slc, ind, lw, lc=None, spacing=5):

"""

if lc is None:

lc = []

# Half the label width

hlw = lw / 2.0

# Check if closed and, if so, rotate contour so label is at edge

closed = mlab.is_closed_polygon(slc)

if closed:

slc = np.r_[slc[ind:-1], slc[:ind + 1]]

if len(lc): # Rotate lc also if not empty

lc = np.r_[lc[ind:-1], lc[:ind + 1]]

ind = 0

# Path length in pixel space

pl = mlab.path_length(slc)

pl = pl - pl[ind]

# Use linear interpolation to get points around label

xi = np.array([-hlw, hlw])

if closed: # Look at end also for closed contours

dp = np.array([pl[-1], 0])

else:

dp = np.zeros_like(xi)

ll = mlab.less_simple_linear_interpolation(pl, slc, dp + xi,

extrap=True)

# get vector in pixel space coordinates from one point to other

dd = np.diff(ll, axis=0).ravel()

# Get angle of vector - must be calculated in pixel space for

# text rotation to work correctly

if np.all(dd == 0): # Must deal with case of zero length label

rotation = 0.0

else:

rotation = np.rad2deg(np.arctan2(dd[1], dd[0]))

if self.rightside_up:

# Fix angle so text is never upside-down

if rotation > 90:

rotation = rotation - 180.0

if rotation < -90:

rotation = 180.0 + rotation

# Break contour if desired

nlc = []

if len(lc):

# Expand range by spacing

xi = dp + xi + np.array([-spacing, spacing])

# Get indices near points of interest

I = mlab.less_simple_linear_interpolation(

pl, np.arange(len(pl)), xi, extrap=False)

# If those indices aren't beyond contour edge, find x,y

if (not np.isnan(I[0])) and int(I[0]) != I[0]:

xy1 = mlab.less_simple_linear_interpolation(

pl, lc, [xi[0]])

if (not np.isnan(I[1])) and int(I[1]) != I[1]:

xy2 = mlab.less_simple_linear_interpolation(

pl, lc, [xi[1]])

# Round to integer values but keep as float

# To allow check against nan below

# Ignore nans here to avoid throwing an error on Appveyor build

# (can possibly be removed when build uses numpy 1.13)

with np.errstate(invalid='ignore'):

I = [np.floor(I[0]), np.ceil(I[1])]

# Actually break contours

if closed:

# This will remove contour if shorter than label

if np.all(~np.isnan(I)):

nlc.append(np.r_[xy2, lc[int(I[1]):int(I[0]) + 1], xy1])

else:

# These will remove pieces of contour if they have length zero

if not np.isnan(I[0]):

nlc.append(np.r_[lc[:int(I[0]) + 1], xy1])

if not np.isnan(I[1]):

nlc.append(np.r_[xy2, lc[int(I[1]):]])

# The current implementation removes contours completely

# covered by labels. Uncomment line below to keep

# original contour if this is the preferred behavior.

# if not len(nlc): nlc = [ lc ]

return rotation, nlc

def _get_label_text(self, x, y, rotation):

dx, dy = self.ax.transData.inverted().transform_point((x, y))

t = text.Text(dx, dy, rotation=rotation,

horizontalalignment='center',

verticalalignment='center')

return t

def _get_label_clabeltext(self, x, y, rotation):

# x, y, rotation is given in pixel coordinate. Convert them to

# the data coordinate and create a label using ClabelText

# class. This way, the roation of the clabel is along the

# contour line always.

transDataInv = self.ax.transData.inverted()

dx, dy = transDataInv.transform_point((x, y))

drotation = transDataInv.transform_angles(np.array([rotation]),

np.array([[x, y]]))

t = ClabelText(dx, dy, rotation=drotation[0],

horizontalalignment='center',

verticalalignment='center')

return t

def _add_label(self, t, x, y, lev, cvalue):

color = self.labelMappable.to_rgba(cvalue, alpha=self.alpha)

_text = self.get_text(lev, self.labelFmt)

self.set_label_props(t, _text, color)

self.labelTexts.append(t)

self.labelCValues.append(cvalue)

self.labelXYs.append((x, y))

# Add label to plot here - useful for manual mode label selection

self.ax.add_artist(t)

def add_label(self, x, y, rotation, lev, cvalue):

"""

t = self._get_label_text(x, y, rotation)

self._add_label(t, x, y, lev, cvalue)

def add_label_clabeltext(self, x, y, rotation, lev, cvalue):

"""

# x, y, rotation is given in pixel coordinate. Convert them to

# the data coordinate and create a label using ClabelText

# class. This way, the roation of the clabel is along the

# contour line always.

t = self._get_label_clabeltext(x, y, rotation)

self._add_label(t, x, y, lev, cvalue)

def add_label_near(self, x, y, inline=True, inline_spacing=5,

transform=None):

"""

if transform is None:

transform = self.ax.transData

if transform:

x, y = transform.transform_point((x, y))

# find the nearest contour _in screen units_

conmin, segmin, imin, xmin, ymin = self.find_nearest_contour(

x, y, self.labelIndiceList)[:5]

# The calc_label_rot_and_inline routine requires that (xmin,ymin)

# be a vertex in the path. So, if it isn't, add a vertex here

# grab the paths from the collections

paths = self.collections[conmin].get_paths()

# grab the correct segment

active_path = paths[segmin]

# grab it's verticies

lc = active_path.vertices

# sort out where the new vertex should be added data-units

xcmin = self.ax.transData.inverted().transform_point([xmin, ymin])

# if there isn't a vertex close enough

if not np.allclose(xcmin, lc[imin]):

# insert new data into the vertex list

lc = np.r_[lc[:imin], np.array(xcmin)[None, :], lc[imin:]]

# replace the path with the new one

paths[segmin] = mpath.Path(lc)

# Get index of nearest level in subset of levels used for labeling

lmin = self.labelIndiceList.index(conmin)

# Coordinates of contour

paths = self.collections[conmin].get_paths()

lc = paths[segmin].vertices

# In pixel/screen space

slc = self.ax.transData.transform(lc)

# Get label width for rotating labels and breaking contours

lw = self.get_label_width(self.labelLevelList[lmin],

self.labelFmt, self.labelFontSizeList[lmin])

# Figure out label rotation.

if inline:

lcarg = lc

else:

lcarg = None

rotation, nlc = self.calc_label_rot_and_inline(

slc, imin, lw, lcarg,

inline_spacing)

self.add_label(xmin, ymin, rotation, self.labelLevelList[lmin],

self.labelCValueList[lmin])

if inline:

# Remove old, not looping over paths so we can do this up front

paths.pop(segmin)

# Add paths if not empty or single point

for n in nlc:

if len(n) > 1:

paths.append(mpath.Path(n))

def pop_label(self, index=-1):

"""Defaults to removing last label, but any index can be supplied"""

self.labelCValues.pop(index)

t = self.labelTexts.pop(index)

t.remove()

def labels(self, inline, inline_spacing):

if self._use_clabeltext:

add_label = self.add_label_clabeltext

else:

add_label = self.add_label

for icon, lev, fsize, cvalue in zip(

self.labelIndiceList, self.labelLevelList,

self.labelFontSizeList, self.labelCValueList):

con = self.collections[icon]

trans = con.get_transform()

lw = self.get_label_width(lev, self.labelFmt, fsize)

lw *= self.ax.figure.dpi / 72.0 # scale to screen coordinates

additions = []

paths = con.get_paths()

for segNum, linepath in enumerate(paths):

lc = linepath.vertices # Line contour

slc0 = trans.transform(lc) # Line contour in screen coords

# For closed polygons, add extra point to avoid division by

# zero in print_label and locate_label. Other than these

# functions, this is not necessary and should probably be

# eventually removed.

if mlab.is_closed_polygon(lc):

slc = np.r_[slc0, slc0[1:2, :]]

else:

slc = slc0

# Check if long enough for a label

if self.print_label(slc, lw):

x, y, ind = self.locate_label(slc, lw)

if inline:

lcarg = lc

else:

lcarg = None

rotation, new = self.calc_label_rot_and_inline(

slc0, ind, lw, lcarg,

inline_spacing)

# Actually add the label

add_label(x, y, rotation, lev, cvalue)

# If inline, add new contours

if inline:

for n in new:

# Add path if not empty or single point

if len(n) > 1:

additions.append(mpath.Path(n))

else: # If not adding label, keep old path

additions.append(linepath)

# After looping over all segments on a contour, remove old

# paths and add new ones if inlining

if inline:

del paths[:]

"""find closest point to p0 on line segment connecting p1 and p2"""

# handle degenerate case

if np.all(p2 == p1):

d = np.sum((p0 - p1)**2)

return d, p1

d21 = p2 - p1

d01 = p0 - p1

# project on to line segment to find closest point

proj = np.dot(d01, d21) / np.dot(d21, d21)

if proj < 0:

proj = 0

if proj > 1:

proj = 1

pc = p1 + proj * d21

# find squared distance

d = np.sum((pc-p0)**2)

"""

# find index of closest vertex for this segment

ds = np.sum((lc - point[None, :])**2, 1)

imin = np.argmin(ds)

dmin = np.inf

xcmin = None

legmin = (None, None)

closed = mlab.is_closed_polygon(lc)

# build list of legs before and after this vertex

legs = []

if imin > 0 or closed:

legs.append(((imin-1) % len(lc), imin))

if imin < len(lc) - 1 or closed:

legs.append((imin, (imin+1) % len(lc)))

for leg in legs:

d, xc = _find_closest_point_on_leg(lc[leg[0]], lc[leg[1]], point)

if d < dmin:

dmin = d

xcmin = xc

legmin = leg

"""

def __init__(self, ax, *args, **kwargs):

"""

self.ax = ax

self.levels = kwargs.get('levels', None)

self.filled = kwargs.get('filled', False)

self.linewidths = kwargs.get('linewidths', None)

self.linestyles = kwargs.get('linestyles', None)

self.hatches = kwargs.get('hatches', [None])

self.alpha = kwargs.get('alpha', None)

self.origin = kwargs.get('origin', None)

self.extent = kwargs.get('extent', None)

cmap = kwargs.get('cmap', None)

self.colors = kwargs.get('colors', None)

norm = kwargs.get('norm', None)

vmin = kwargs.get('vmin', None)

vmax = kwargs.get('vmax', None)

self.extend = kwargs.get('extend', 'neither')

self.antialiased = kwargs.get('antialiased', None)

if self.antialiased is None and self.filled:

self.antialiased = False # eliminate artifacts; we are not

# stroking the boundaries.

# The default for line contours will be taken from

# the LineCollection default, which uses the

# rcParams['lines.antialiased']

self.nchunk = kwargs.get('nchunk', 0)

self.locator = kwargs.get('locator', None)

if (isinstance(norm, colors.LogNorm)

or isinstance(self.locator, ticker.LogLocator)):

self.logscale = True

if norm is None:

norm = colors.LogNorm()

if self.extend is not 'neither':

raise ValueError('extend kwarg does not work yet with log '

' scale')

else:

self.logscale = False

if self.origin not in [None, 'lower', 'upper', 'image']:

raise ValueError("If given, *origin* must be one of [ 'lower' |"

" 'upper' | 'image']")

if self.extent is not None and len(self.extent) != 4:

raise ValueError("If given, *extent* must be '[ *None* |"

" (x0,x1,y0,y1) ]'")

if self.colors is not None and cmap is not None:

raise ValueError('Either colors or cmap must be None')

if self.origin == 'image':

self.origin = mpl.rcParams['image.origin']

self._transform = kwargs.get('transform', None)

self._process_args(*args, **kwargs)

self._process_levels()

if self.colors is not None:

ncolors = len(self.levels)

if self.filled:

ncolors -= 1

i0 = 0

# Handle the case where colors are given for the extended

# parts of the contour.

extend_min = self.extend in ['min', 'both']

extend_max = self.extend in ['max', 'both']

use_set_under_over = False

# if we are extending the lower end, and we've been given enough

# colors then skip the first color in the resulting cmap. For the

# extend_max case we don't need to worry about passing more colors

# than ncolors as ListedColormap will clip.

total_levels = ncolors + int(extend_min) + int(extend_max)

if (len(self.colors) == total_levels and

any([extend_min, extend_max])):

use_set_under_over = True

if extend_min:

i0 = 1

cmap = colors.ListedColormap(self.colors[i0:None], N=ncolors)

if use_set_under_over:

if extend_min:

cmap.set_under(self.colors[0])

if extend_max:

cmap.set_over(self.colors[-1])

if self.filled:

self.collections = cbook.silent_list('mcoll.PathCollection')

else:

self.collections = cbook.silent_list('mcoll.LineCollection')

# label lists must be initialized here

self.labelTexts = []

self.labelCValues = []

kw = {'cmap': cmap}

if norm is not None:

kw['norm'] = norm

# sets self.cmap, norm if needed;

cm.ScalarMappable.__init__(self, **kw)

if vmin is not None:

self.norm.vmin = vmin

if vmax is not None:

self.norm.vmax = vmax

self._process_colors()

self.allsegs, self.allkinds = self._get_allsegs_and_allkinds()

if self.filled:

if self.linewidths is not None:

warnings.warn('linewidths is ignored by contourf')

# Lower and upper contour levels.

lowers, uppers = self._get_lowers_and_uppers()

# Ensure allkinds can be zipped below.

if self.allkinds is None:

self.allkinds = [None] * len(self.allsegs)

for level, level_upper, segs, kinds in \

zip(lowers, uppers, self.allsegs, self.allkinds):

paths = self._make_paths(segs, kinds)

# Default zorder taken from Collection

zorder = kwargs.get('zorder', 1)

col = mcoll.PathCollection(

paths,

antialiaseds=(self.antialiased,),

edgecolors='none',

alpha=self.alpha,

transform=self.get_transform(),

zorder=zorder)

self.ax.add_collection(col, autolim=False)

self.collections.append(col)

else:

tlinewidths = self._process_linewidths()

self.tlinewidths = tlinewidths

tlinestyles = self._process_linestyles()

aa = self.antialiased

if aa is not None:

aa = (self.antialiased,)

for level, width, lstyle, segs in \

zip(self.levels, tlinewidths, tlinestyles, self.allsegs):

# Default zorder taken from LineCollection

zorder = kwargs.get('zorder', 2)

col = mcoll.LineCollection(

segs,

antialiaseds=aa,

linewidths=width,

linestyles=[lstyle],

alpha=self.alpha,

transform=self.get_transform(),

zorder=zorder)

col.set_label('_nolegend_')

self.ax.add_collection(col, autolim=False)

self.collections.append(col)

for col in self.collections:

col.sticky_edges.x[:] = [self._mins[0], self._maxs[0]]

col.sticky_edges.y[:] = [self._mins[1], self._maxs[1]]

self.ax.update_datalim([self._mins, self._maxs])

self.ax.autoscale_view(tight=True)

self.changed() # set the colors

def get_transform(self):

"""

if self._transform is None:

self._transform = self.ax.transData

elif (not isinstance(self._transform, mtransforms.Transform)

and hasattr(self._transform, '_as_mpl_transform')):

self._transform = self._transform._as_mpl_transform(self.ax)

return self._transform

def __getstate__(self):

state = self.__dict__.copy()

# the C object _contour_generator cannot currently be pickled. This

# isn't a big issue as it is not actually used once the contour has

# been calculated.

state['_contour_generator'] = None

return state

def legend_elements(self, variable_name='x', str_format=str):

"""

artists = []

labels = []

if self.filled:

lowers, uppers = self._get_lowers_and_uppers()

n_levels = len(self.collections)