"""

def get_rotation(self):

new_angle, = self.get_transform().transform_angles(

[text.Text.get_rotation(self)], [self.get_position()])

"""Mixin to provide labelling capability to `.ContourSet`."""

def clabel(self, levels=None, *,

fontsize=None, inline=True, inline_spacing=5, fmt='%1.3f',

colors=None, use_clabeltext=False, manual=False,

rightside_up=True, zorder=None):

"""

# clabel basically takes the input arguments and uses them to

# add a list of "label specific" attributes to the ContourSet

# object. These attributes are all of the form label* and names

# should be fairly self explanatory.

#

# Once these attributes are set, clabel passes control to the

# labels method (case of automatic label placement) or

# `BlockingContourLabeler` (case of manual label placement).

self.labelFmt = fmt

self._use_clabeltext = use_clabeltext

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

self.labelManual = manual

self.rightside_up = rightside_up

if zorder is None:

self._clabel_zorder = 2+self._contour_zorder

else:

self._clabel_zorder = zorder

if levels is None:

levels = self.levels

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

else:

levlabs = list(levels)

indices, levels = [], []

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

if lev in levlabs:

indices.append(i)

levels.append(lev)

if len(levels) < len(levlabs):

raise ValueError(f"Specified levels {levlabs} don't match "

f"available levels {self.levels}")

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 = mcolors.ListedColormap(colors, N=len(self.labelLevelList))

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

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

norm=mcolors.NoNorm())

self.labelXYs = []

if np.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)

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

return self.labelTextsList

def print_label(self, linecontour, labelwidth):

"""Return whether a contour is long enough to hold 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."""

thresh = (1.2 * lw) ** 2

return any((x - loc[0]) ** 2 + (y - loc[1]) ** 2 < thresh

for loc in self.labelXYs)

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, str):

lev = self.get_text(lev, fmt)

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

if ismath == 'TeX':

lw, _, _ = (texmanager.TexManager()

.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 = np.shape(img) # 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 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.axes.bbox)

def get_text(self, lev, fmt):

"""Get the text of the label."""

if isinstance(lev, str):

return lev

else:

if isinstance(fmt, dict):

return fmt.get(lev, '%1.3f')

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[:, :1]

ylast = YY[:, -1:]

xfirst = XX[:, :1]

xlast = XX[:, -1:]

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

L = np.hypot(xlast - xfirst, ylast - yfirst)

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

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

dist = np.sum(np.abs(s) / L, axis=-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 = _is_closed_polygon(slc)

if closed:

slc = np.concatenate([slc[ind:-1], slc[:ind + 1]])

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

lc = np.concatenate([lc[ind:-1], lc[:ind + 1]])

ind = 0

# Calculate path lengths

pl = np.zeros(slc.shape[0], dtype=float)

dx = np.diff(slc, axis=0)

pl[1:] = np.cumsum(np.hypot(dx[:, 0], dx[:, 1]))

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)

# Get angle of vector between the two ends of the label - must be

# calculated in pixel space for text rotation to work correctly.

(dx,), (dy,) = (np.diff(np.interp(dp + xi, pl, slc_col))

for slc_col in slc.T)

rotation = np.rad2deg(np.arctan2(dy, dx))

if self.rightside_up:

# Fix angle so text is never upside-down

rotation = (rotation + 90) % 180 - 90

# Break contour if desired

nlc = []

if len(lc):

# Expand range by spacing

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

# Get (integer) indices near points of interest; use -1 as marker

# for out of bounds.

I = np.interp(xi, pl, np.arange(len(pl)), left=-1, right=-1)

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

if I[0] != -1:

xy1 = [np.interp(xi[0], pl, lc_col) for lc_col in lc.T]

if I[1] != -1:

xy2 = [np.interp(xi[1], pl, lc_col) for lc_col in lc.T]

# Actually break contours

if closed:

# This will remove contour if shorter than label

if all(i != -1 for i in I):

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

else:

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

if I[0] != -1:

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

if I[1] != -1:

nlc.append(np.row_stack([xy2, lc[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.axes.transData.inverted().transform((x, y))

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

horizontalalignment='center',

verticalalignment='center', zorder=self._clabel_zorder)

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 rotation of the clabel is along the

# contour line always.

transDataInv = self.axes.transData.inverted()

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

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

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

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

horizontalalignment='center',

verticalalignment='center', zorder=self._clabel_zorder)

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.axes.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 rotation 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.axes.transData

if transform:

x, y = transform.transform((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 its vertices

lc = active_path.vertices

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

xcmin = self.axes.transData.inverted().transform([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.row_stack([lc[:imin], xcmin, 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.axes.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])

# lw is in points.

lw *= self.axes.figure.dpi / 72 # scale to screen coordinates

# now lw in pixels

# Figure out label rotation.

rotation, nlc = self.calc_label_rot_and_inline(

slc, imin, lw, lc if inline else None, 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.axes.figure.dpi / 72 # 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 _is_closed_polygon(lc):

slc = np.row_stack([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)

rotation, new = self.calc_label_rot_and_inline(

slc0, ind, lw, lc if inline else None, 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, replace old paths

# by new ones if inlining.

if inline:

"""Find the 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 = _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,

levels=None, filled=False, linewidths=None, linestyles=None,

hatches=(None,), alpha=None, origin=None, extent=None,

cmap=None, colors=None, norm=None, vmin=None, vmax=None,

extend='neither', antialiased=None, nchunk=0, locator=None,

transform=None,

**kwargs):

"""

self.axes = ax

self.levels = levels

self.filled = filled

self.linewidths = linewidths

self.linestyles = linestyles

self.hatches = hatches

self.alpha = alpha

self.origin = origin

self.extent = extent

self.colors = colors

self.extend = extend

self.antialiased = antialiased

if self.antialiased is None and self.filled:

# Eliminate artifacts; we are not stroking the boundaries.

self.antialiased = False

# The default for line contours will be taken from the

# LineCollection default, which uses :rc:`lines.antialiased`.

self.nchunk = nchunk

self.locator = locator

if (isinstance(norm, mcolors.LogNorm)

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

self.logscale = True

if norm is None:

norm = mcolors.LogNorm()

else:

self.logscale = False

cbook._check_in_list([None, 'lower', 'upper', 'image'], origin=origin)

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

raise ValueError(

"If given, 'extent' must be None or (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 = transform

kwargs = 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 (extend_min or extend_max):

use_set_under_over = True

if extend_min:

i0 = 1

cmap = mcolors.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:

cbook._warn_external('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)

# Default zorder taken from Collection

self._contour_zorder = kwargs.pop('zorder', 1)

for level, level_upper, segs, kinds in \

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

paths = self._make_paths(segs, kinds)

col = mcoll.PathCollection(

paths,

antialiaseds=(self.antialiased,),

edgecolors='none',

alpha=self.alpha,

transform=self.get_transform(),

zorder=self._contour_zorder)

self.axes.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,)

# Default zorder taken from LineCollection

self._contour_zorder = kwargs.pop('zorder', 2)

for level, width, lstyle, segs in \

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

col = mcoll.LineCollection(

segs,

antialiaseds=aa,

linewidths=width,

linestyles=[lstyle],

alpha=self.alpha,

transform=self.get_transform(),

zorder=self._contour_zorder)

col.set_label('_nolegend_')

self.axes.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.axes.update_datalim([self._mins, self._maxs])

self.axes.autoscale_view(tight=True)

self.changed() # set the colors

if kwargs:

s = ", ".join(map(repr, kwargs))

cbook._warn_external('The following kwargs were not used by '

'contour: ' + s)

@cbook.deprecated("3.3")

@property

def ax(self):

return self.axes

def get_transform(self):

"""

if self._transform is None:

self._transform = self.axes.transData

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

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

self._transform = self._transform._as_mpl_transform(self.axes)

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)

for i, (collection, lower, upper) in enumerate(

zip(self.collections, lowers, uppers)):

patch = mpatches.Rectangle(

(0, 0), 1, 1,

facecolor=collection.get_facecolor()[0],

hatch=collection.get_hatch(),

alpha=collection.get_alpha())

artists.append(patch)

lower = str_format(lower)

upper = str_format(upper)

if i == 0 and self.extend in ('min', 'both'):