from collections import OrderedDict

import math

import types

import numpy as np

from matplotlib import _api, cbook, rcParams

from matplotlib.axes import Axes

import matplotlib.axis as maxis

import matplotlib.markers as mmarkers

import matplotlib.patches as mpatches

from matplotlib.path import Path

import matplotlib.ticker as mticker

import matplotlib.transforms as mtransforms

import matplotlib.spines as mspines

class PolarTransform(mtransforms.Transform):

"""

The base polar transform. This handles projection *theta* and

*r* into Cartesian coordinate space *x* and *y*, but does not

perform the ultimate affine transformation into the correct

position.

"""

input_dims = output_dims = 2

def __init__(self, axis=None, use_rmin=True,

_apply_theta_transforms=True):

super().__init__()

self._axis = axis

self._use_rmin = use_rmin

self._apply_theta_transforms = _apply_theta_transforms

__str__ = mtransforms._make_str_method(

"_axis",

use_rmin="_use_rmin",

_apply_theta_transforms="_apply_theta_transforms")

def transform_non_affine(self, tr):

# docstring inherited

t, r = np.transpose(tr)

# PolarAxes does not use the theta transforms here, but apply them for

# backwards-compatibility if not being used by it.

if self._apply_theta_transforms and self._axis is not None:

t *= self._axis.get_theta_direction()

t += self._axis.get_theta_offset()

if self._use_rmin and self._axis is not None:

r = (r - self._axis.get_rorigin()) * self._axis.get_rsign()

r = np.where(r >= 0, r, np.nan)

return np.column_stack([r * np.cos(t), r * np.sin(t)])

def transform_path_non_affine(self, path):

# docstring inherited

if not len(path) or path._interpolation_steps == 1:

return Path(self.transform_non_affine(path.vertices), path.codes)

xys = []

codes = []

last_t = last_r = None

for trs, c in path.iter_segments():

trs = trs.reshape((-1, 2))

if c == Path.LINETO:

(t, r), = trs

if t == last_t: # Same angle: draw a straight line.

xys.extend(self.transform_non_affine(trs))

codes.append(Path.LINETO)

elif r == last_r: # Same radius: draw an arc.

# The following is complicated by Path.arc() being

# "helpful" and unwrapping the angles, but we don't want

# that behavior here.

last_td, td = np.rad2deg([last_t, t])

if self._use_rmin and self._axis is not None:

r = ((r - self._axis.get_rorigin())

* self._axis.get_rsign())

if last_td <= td:

while td - last_td > 360:

arc = Path.arc(last_td, last_td + 360)

xys.extend(arc.vertices[1:] * r)

codes.extend(arc.codes[1:])

last_td += 360

arc = Path.arc(last_td, td)

xys.extend(arc.vertices[1:] * r)

codes.extend(arc.codes[1:])

else:

# The reverse version also relies on the fact that all

# codes but the first one are the same.

while last_td - td > 360:

arc = Path.arc(last_td - 360, last_td)

xys.extend(arc.vertices[::-1][1:] * r)

codes.extend(arc.codes[1:])

last_td -= 360

arc = Path.arc(td, last_td)

xys.extend(arc.vertices[::-1][1:] * r)

codes.extend(arc.codes[1:])

else: # Interpolate.

trs = cbook.simple_linear_interpolation(

np.row_stack([(last_t, last_r), trs]),

path._interpolation_steps)[1:]

xys.extend(self.transform_non_affine(trs))

codes.extend([Path.LINETO] * len(trs))

else: # Not a straight line.

xys.extend(self.transform_non_affine(trs))

codes.extend([c] * len(trs))

last_t, last_r = trs[-1]

return Path(xys, codes)

def inverted(self):

# docstring inherited

return PolarAxes.InvertedPolarTransform(self._axis, self._use_rmin,

self._apply_theta_transforms)

class PolarAffine(mtransforms.Affine2DBase):

"""

The affine part of the polar projection. Scales the output so

that maximum radius rests on the edge of the axes circle.

"""

def __init__(self, scale_transform, limits):

"""

*limits* is the view limit of the data. The only part of

its bounds that is used is the y limits (for the radius limits).

The theta range is handled by the non-affine transform.

"""

super().__init__()

self._scale_transform = scale_transform

self._limits = limits

self.set_children(scale_transform, limits)

self._mtx = None

__str__ = mtransforms._make_str_method("_scale_transform", "_limits")

def get_matrix(self):

# docstring inherited

if self._invalid:

limits_scaled = self._limits.transformed(self._scale_transform)

yscale = limits_scaled.ymax - limits_scaled.ymin

affine = mtransforms.Affine2D() \

.scale(0.5 / yscale) \

.translate(0.5, 0.5)

self._mtx = affine.get_matrix()

self._inverted = None

self._invalid = 0

return self._mtx

class InvertedPolarTransform(mtransforms.Transform):

"""

The inverse of the polar transform, mapping Cartesian

coordinate space *x* and *y* back to *theta* and *r*.

"""

input_dims = output_dims = 2

def __init__(self, axis=None, use_rmin=True,

_apply_theta_transforms=True):

super().__init__()

self._axis = axis

self._use_rmin = use_rmin

self._apply_theta_transforms = _apply_theta_transforms

__str__ = mtransforms._make_str_method(

"_axis",

use_rmin="_use_rmin",

_apply_theta_transforms="_apply_theta_transforms")

def transform_non_affine(self, xy):

# docstring inherited

x, y = xy.T

r = np.hypot(x, y)

theta = (np.arctan2(y, x) + 2 * np.pi) % (2 * np.pi)

# PolarAxes does not use the theta transforms here, but apply them for

# backwards-compatibility if not being used by it.

if self._apply_theta_transforms and self._axis is not None:

theta -= self._axis.get_theta_offset()

theta *= self._axis.get_theta_direction()

theta %= 2 * np.pi

if self._use_rmin and self._axis is not None:

r += self._axis.get_rorigin()

r *= self._axis.get_rsign()

return np.column_stack([theta, r])

def inverted(self):

# docstring inherited

return PolarAxes.PolarTransform(self._axis, self._use_rmin,

self._apply_theta_transforms)

class ThetaFormatter(mticker.Formatter):

"""

Used to format the *theta* tick labels. Converts the native

unit of radians into degrees and adds a degree symbol.

"""

def __call__(self, x, pos=None):

vmin, vmax = self.axis.get_view_interval()

d = np.rad2deg(abs(vmax - vmin))

digits = max(-int(np.log10(d) - 1.5), 0)

# Use unicode rather than mathtext with \circ, so that it will work

# correctly with any arbitrary font (assuming it has a degree sign),

# whereas $5\circ$ will only work correctly with one of the supported

# math fonts (Computer Modern and STIX).

return ("{value:0.{digits:d}f}\N{DEGREE SIGN}"

.format(value=np.rad2deg(x), digits=digits))

class _AxisWrapper:

def __init__(self, axis):

self._axis = axis

def get_view_interval(self):

return np.rad2deg(self._axis.get_view_interval())

def set_view_interval(self, vmin, vmax):

self._axis.set_view_interval(*np.deg2rad((vmin, vmax)))

def get_minpos(self):

return np.rad2deg(self._axis.get_minpos())

def get_data_interval(self):

return np.rad2deg(self._axis.get_data_interval())

def set_data_interval(self, vmin, vmax):

self._axis.set_data_interval(*np.deg2rad((vmin, vmax)))

def get_tick_space(self):

return self._axis.get_tick_space()

class ThetaLocator(mticker.Locator):

"""

Used to locate theta ticks.

This will work the same as the base locator except in the case that the

view spans the entire circle. In such cases, the previously used default

locations of every 45 degrees are returned.

"""

def __init__(self, base):

self.base = base

self.axis = self.base.axis = _AxisWrapper(self.base.axis)

def set_axis(self, axis):

self.axis = _AxisWrapper(axis)

self.base.set_axis(self.axis)

def __call__(self):

lim = self.axis.get_view_interval()

if _is_full_circle_deg(lim[0], lim[1]):

return np.arange(8) * 2 * np.pi / 8

else:

return np.deg2rad(self.base())

def refresh(self):

# docstring inherited

return self.base.refresh()

def view_limits(self, vmin, vmax):

vmin, vmax = np.rad2deg((vmin, vmax))

return np.deg2rad(self.base.view_limits(vmin, vmax))

class ThetaTick(maxis.XTick):

"""

A theta-axis tick.

This subclass of `.XTick` provides angular ticks with some small

modification to their re-positioning such that ticks are rotated based on

tick location. This results in ticks that are correctly perpendicular to

the arc spine.

When 'auto' rotation is enabled, labels are also rotated to be parallel to

the spine. The label padding is also applied here since it's not possible

to use a generic axes transform to produce tick-specific padding.

"""

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

self._text1_translate = mtransforms.ScaledTranslation(

0, 0, axes.figure.dpi_scale_trans)

self._text2_translate = mtransforms.ScaledTranslation(

0, 0, axes.figure.dpi_scale_trans)

super().__init__(axes, *args, **kwargs)

self.label1.set(

rotation_mode='anchor',

transform=self.label1.get_transform() + self._text1_translate)

self.label2.set(

rotation_mode='anchor',

transform=self.label2.get_transform() + self._text2_translate)

def _apply_params(self, **kw):

super()._apply_params(**kw)

# Ensure transform is correct; sometimes this gets reset.

trans = self.label1.get_transform()

if not trans.contains_branch(self._text1_translate):

self.label1.set_transform(trans + self._text1_translate)

trans = self.label2.get_transform()

if not trans.contains_branch(self._text2_translate):

self.label2.set_transform(trans + self._text2_translate)

def _update_padding(self, pad, angle):

padx = pad * np.cos(angle) / 72

pady = pad * np.sin(angle) / 72

self._text1_translate._t = (padx, pady)

self._text1_translate.invalidate()

self._text2_translate._t = (-padx, -pady)

self._text2_translate.invalidate()

def update_position(self, loc):

super().update_position(loc)

axes = self.axes

angle = loc * axes.get_theta_direction() + axes.get_theta_offset()

text_angle = np.rad2deg(angle) % 360 - 90

angle -= np.pi / 2

marker = self.tick1line.get_marker()

if marker in (mmarkers.TICKUP, '|'):

trans = mtransforms.Affine2D().scale(1, 1).rotate(angle)

elif marker == mmarkers.TICKDOWN:

trans = mtransforms.Affine2D().scale(1, -1).rotate(angle)

else:

# Don't modify custom tick line markers.

trans = self.tick1line._marker._transform

self.tick1line._marker._transform = trans

marker = self.tick2line.get_marker()

if marker in (mmarkers.TICKUP, '|'):

trans = mtransforms.Affine2D().scale(1, 1).rotate(angle)

elif marker == mmarkers.TICKDOWN:

trans = mtransforms.Affine2D().scale(1, -1).rotate(angle)

else:

# Don't modify custom tick line markers.

trans = self.tick2line._marker._transform

self.tick2line._marker._transform = trans

mode, user_angle = self._labelrotation

if mode == 'default':

text_angle = user_angle

else:

if text_angle > 90:

text_angle -= 180

elif text_angle < -90:

text_angle += 180

text_angle += user_angle

self.label1.set_rotation(text_angle)

self.label2.set_rotation(text_angle)

# This extra padding helps preserve the look from previous releases but

# is also needed because labels are anchored to their center.

pad = self._pad + 7

self._update_padding(pad,

self._loc * axes.get_theta_direction() +

axes.get_theta_offset())

class ThetaAxis(maxis.XAxis):

"""

A theta Axis.

This overrides certain properties of an `.XAxis` to provide special-casing

for an angular axis.

"""

__name__ = 'thetaaxis'

axis_name = 'theta' #: Read-only name identifying the axis.

def _get_tick(self, major):

if major:

tick_kw = self._major_tick_kw

else:

tick_kw = self._minor_tick_kw

return ThetaTick(self.axes, 0, major=major, **tick_kw)

def _wrap_locator_formatter(self):

self.set_major_locator(ThetaLocator(self.get_major_locator()))

self.set_major_formatter(ThetaFormatter())

self.isDefault_majloc = True

self.isDefault_majfmt = True

def clear(self):

super().clear()

self.set_ticks_position('none')

self._wrap_locator_formatter()

@_api.deprecated("3.4", alternative="ThetaAxis.clear()")

def cla(self):

self.clear()

def _set_scale(self, value, **kwargs):

if value != 'linear':

raise NotImplementedError(

"The xscale cannot be set on a polar plot")

super()._set_scale(value, **kwargs)

# LinearScale.set_default_locators_and_formatters just set the major

# locator to be an AutoLocator, so we customize it here to have ticks

# at sensible degree multiples.

self.get_major_locator().set_params(steps=[1, 1.5, 3, 4.5, 9, 10])

self._wrap_locator_formatter()

def _copy_tick_props(self, src, dest):

"""Copy the props from src tick to dest tick."""

if src is None or dest is None:

return

super()._copy_tick_props(src, dest)

# Ensure that tick transforms are independent so that padding works.

trans = dest._get_text1_transform()[0]

dest.label1.set_transform(trans + dest._text1_translate)

trans = dest._get_text2_transform()[0]

dest.label2.set_transform(trans + dest._text2_translate)

class RadialLocator(mticker.Locator):

"""

Used to locate radius ticks.

Ensures that all ticks are strictly positive. For all other tasks, it

delegates to the base `.Locator` (which may be different depending on the

scale of the *r*-axis).

"""

def __init__(self, base, axes=None):

self.base = base

self._axes = axes

def set_axis(self, axis):

self.base.set_axis(axis)

def __call__(self):

# Ensure previous behaviour with full circle non-annular views.

if self._axes:

if _is_full_circle_rad(*self._axes.viewLim.intervalx):

rorigin = self._axes.get_rorigin() * self._axes.get_rsign()

if self._axes.get_rmin() <= rorigin:

return [tick for tick in self.base() if tick > rorigin]

return self.base()

def nonsingular(self, vmin, vmax):

# docstring inherited

return ((0, 1) if (vmin, vmax) == (-np.inf, np.inf) # Init. limits.

else self.base.nonsingular(vmin, vmax))

def view_limits(self, vmin, vmax):

vmin, vmax = self.base.view_limits(vmin, vmax)

if vmax > vmin:

# this allows inverted r/y-lims

vmin = min(0, vmin)

return mtransforms.nonsingular(vmin, vmax)

class _ThetaShift(mtransforms.ScaledTranslation):

"""

Apply a padding shift based on axes theta limits.

This is used to create padding for radial ticks.

Parameters

----------

axes : `~matplotlib.axes.Axes`

The owning axes; used to determine limits.

pad : float

The padding to apply, in points.

mode : {'min', 'max', 'rlabel'}

Whether to shift away from the start (``'min'``) or the end (``'max'``)

of the axes, or using the rlabel position (``'rlabel'``).

"""

def __init__(self, axes, pad, mode):

super().__init__(pad, pad, axes.figure.dpi_scale_trans)

self.set_children(axes._realViewLim)

self.axes = axes

self.mode = mode

self.pad = pad

__str__ = mtransforms._make_str_method("axes", "pad", "mode")

def get_matrix(self):

if self._invalid:

if self.mode == 'rlabel':

angle = (

np.deg2rad(self.axes.get_rlabel_position()) *

self.axes.get_theta_direction() +

self.axes.get_theta_offset()

)

else:

if self.mode == 'min':

angle = self.axes._realViewLim.xmin

elif self.mode == 'max':

angle = self.axes._realViewLim.xmax

if self.mode in ('rlabel', 'min'):

padx = np.cos(angle - np.pi / 2)

pady = np.sin(angle - np.pi / 2)

else:

padx = np.cos(angle + np.pi / 2)

pady = np.sin(angle + np.pi / 2)

self._t = (self.pad * padx / 72, self.pad * pady / 72)

return super().get_matrix()

class RadialTick(maxis.YTick):

"""

A radial-axis tick.

This subclass of `.YTick` provides radial ticks with some small

modification to their re-positioning such that ticks are rotated based on

axes limits. This results in ticks that are correctly perpendicular to

the spine. Labels are also rotated to be perpendicular to the spine, when

'auto' rotation is enabled.

"""

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

super().__init__(*args, **kwargs)

self.label1.set_rotation_mode('anchor')

self.label2.set_rotation_mode('anchor')

def _determine_anchor(self, mode, angle, start):

# Note: angle is the (spine angle - 90) because it's used for the tick

# & text setup, so all numbers below are -90 from (normed) spine angle.

if mode == 'auto':

if start:

if -90 <= angle <= 90:

return 'left', 'center'

else:

return 'right', 'center'

else:

if -90 <= angle <= 90:

return 'right', 'center'

else:

return 'left', 'center'

else:

if start:

if angle < -68.5:

return 'center', 'top'

elif angle < -23.5:

return 'left', 'top'

elif angle < 22.5:

return 'left', 'center'

elif angle < 67.5:

return 'left', 'bottom'

elif angle < 112.5:

return 'center', 'bottom'

elif angle < 157.5:

return 'right', 'bottom'

elif angle < 202.5:

return 'right', 'center'

elif angle < 247.5:

return 'right', 'top'

else:

return 'center', 'top'

else:

if angle < -68.5:

return 'center', 'bottom'

elif angle < -23.5:

return 'right', 'bottom'

elif angle < 22.5:

return 'right', 'center'

elif angle < 67.5:

return 'right', 'top'

elif angle < 112.5:

return 'center', 'top'

elif angle < 157.5:

return 'left', 'top'

elif angle < 202.5:

return 'left', 'center'

elif angle < 247.5:

return 'left', 'bottom'

else:

return 'center', 'bottom'

def update_position(self, loc):

super().update_position(loc)

axes = self.axes

thetamin = axes.get_thetamin()

thetamax = axes.get_thetamax()

direction = axes.get_theta_direction()

offset_rad = axes.get_theta_offset()

offset = np.rad2deg(offset_rad)

full = _is_full_circle_deg(thetamin, thetamax)

if full:

angle = (axes.get_rlabel_position() * direction +

offset) % 360 - 90

tick_angle = 0

else:

angle = (thetamin * direction + offset) % 360 - 90

if direction > 0:

tick_angle = np.deg2rad(angle)

else:

tick_angle = np.deg2rad(angle + 180)

text_angle = (angle + 90) % 180 - 90 # between -90 and +90.

mode, user_angle = self._labelrotation

if mode == 'auto':

text_angle += user_angle

else:

text_angle = user_angle

if full:

ha = self.label1.get_horizontalalignment()

va = self.label1.get_verticalalignment()

else:

ha, va = self._determine_anchor(mode, angle, direction > 0)

self.label1.set_horizontalalignment(ha)

self.label1.set_verticalalignment(va)

self.label1.set_rotation(text_angle)

marker = self.tick1line.get_marker()

if marker == mmarkers.TICKLEFT:

trans = mtransforms.Affine2D().rotate(tick_angle)

elif marker == '_':

trans = mtransforms.Affine2D().rotate(tick_angle + np.pi / 2)

elif marker == mmarkers.TICKRIGHT:

trans = mtransforms.Affine2D().scale(-1, 1).rotate(tick_angle)

else:

# Don't modify custom tick line markers.

trans = self.tick1line._marker._transform

self.tick1line._marker._transform = trans

if full:

self.label2.set_visible(False)

self.tick2line.set_visible(False)

angle = (thetamax * direction + offset) % 360 - 90

if direction > 0:

tick_angle = np.deg2rad(angle)

else:

tick_angle = np.deg2rad(angle + 180)

text_angle = (angle + 90) % 180 - 90 # between -90 and +90.

mode, user_angle = self._labelrotation

if mode == 'auto':

text_angle += user_angle

else:

text_angle = user_angle

ha, va = self._determine_anchor(mode, angle, direction < 0)

self.label2.set_ha(ha)

self.label2.set_va(va)

self.label2.set_rotation(text_angle)

marker = self.tick2line.get_marker()

if marker == mmarkers.TICKLEFT:

trans = mtransforms.Affine2D().rotate(tick_angle)

elif marker == '_':

trans = mtransforms.Affine2D().rotate(tick_angle + np.pi / 2)

elif marker == mmarkers.TICKRIGHT:

trans = mtransforms.Affine2D().scale(-1, 1).rotate(tick_angle)

else:

# Don't modify custom tick line markers.

trans = self.tick2line._marker._transform

self.tick2line._marker._transform = trans

class RadialAxis(maxis.YAxis):

"""

A radial Axis.

This overrides certain properties of a `.YAxis` to provide special-casing

for a radial axis.

"""

__name__ = 'radialaxis'

axis_name = 'radius' #: Read-only name identifying the axis.

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

super().__init__(*args, **kwargs)

self.sticky_edges.y.append(0)

def _get_tick(self, major):

if major:

tick_kw = self._major_tick_kw

else:

tick_kw = self._minor_tick_kw

return RadialTick(self.axes, 0, major=major, **tick_kw)

def _wrap_locator_formatter(self):

self.set_major_locator(RadialLocator(self.get_major_locator(),

self.axes))

self.isDefault_majloc = True

def clear(self):

super().clear()

self.set_ticks_position('none')

self._wrap_locator_formatter()

@_api.deprecated("3.4", alternative="RadialAxis.clear()")

def cla(self):

self.clear()

def _set_scale(self, value, **kwargs):

super()._set_scale(value, **kwargs)

self._wrap_locator_formatter()

def _is_full_circle_deg(thetamin, thetamax):

"""

Determine if a wedge (in degrees) spans the full circle.

The condition is derived from :class:`~matplotlib.patches.Wedge`.

"""

return abs(abs(thetamax - thetamin) - 360.0) < 1e-12

def _is_full_circle_rad(thetamin, thetamax):

"""

Determine if a wedge (in radians) spans the full circle.

The condition is derived from :class:`~matplotlib.patches.Wedge`.

"""

return abs(abs(thetamax - thetamin) - 2 * np.pi) < 1.74e-14

class _WedgeBbox(mtransforms.Bbox):

"""

Transform (theta, r) wedge Bbox into axes bounding box.

Parameters

----------

center : (float, float)

Center of the wedge

viewLim : `~matplotlib.transforms.Bbox`

Bbox determining the boundaries of the wedge

originLim : `~matplotlib.transforms.Bbox`

Bbox determining the origin for the wedge, if different from *viewLim*

"""

def __init__(self, center, viewLim, originLim, **kwargs):

super().__init__([[0, 0], [1, 1]], **kwargs)

self._center = center

self._viewLim = viewLim

self._originLim = originLim

self.set_children(viewLim, originLim)

__str__ = mtransforms._make_str_method("_center", "_viewLim", "_originLim")

def get_points(self):

# docstring inherited

if self._invalid:

points = self._viewLim.get_points().copy()

# Scale angular limits to work with Wedge.

points[:, 0] *= 180 / np.pi

if points[0, 0] > points[1, 0]:

points[:, 0] = points[::-1, 0]

# Scale radial limits based on origin radius.

points[:, 1] -= self._originLim.y0

# Scale radial limits to match axes limits.

rscale = 0.5 / points[1, 1]

points[:, 1] *= rscale

width = min(points[1, 1] - points[0, 1], 0.5)

# Generate bounding box for wedge.

wedge = mpatches.Wedge(self._center, points[1, 1],

points[0, 0], points[1, 0],

width=width)

self.update_from_path(wedge.get_path())

# Ensure equal aspect ratio.

w, h = self._points[1] - self._points[0]

deltah = max(w - h, 0) / 2

deltaw = max(h - w, 0) / 2

self._points += np.array([[-deltaw, -deltah], [deltaw, deltah]])

self._invalid = 0

return self._points

class PolarAxes(Axes):

"""

A polar graph projection, where the input dimensions are *theta*, *r*.

Theta starts pointing east and goes anti-clockwise.

"""

name = 'polar'

def __init__(self, *args,

theta_offset=0, theta_direction=1, rlabel_position=22.5,

**kwargs):

# docstring inherited

self._default_theta_offset = theta_offset

self._default_theta_direction = theta_direction

self._default_rlabel_position = np.deg2rad(rlabel_position)

super().__init__(*args, **kwargs)

self.use_sticky_edges = True

self.set_aspect('equal', adjustable='box', anchor='C')

self.cla()

def cla(self):

super().cla()

self.title.set_y(1.05)

start = self.spines.get('start', None)

if start:

start.set_visible(False)

end = self.spines.get('end', None)

if end:

end.set_visible(False)

self.set_xlim(0.0, 2 * np.pi)

self.grid(rcParams['polaraxes.grid'])

inner = self.spines.get('inner', None)

if inner:

inner.set_visible(False)

self.set_rorigin(None)

self.set_theta_offset(self._default_theta_offset)

self.set_theta_direction(self._default_theta_direction)

def _init_axis(self):

# This is moved out of __init__ because non-separable axes don't use it

self.xaxis = ThetaAxis(self)

self.yaxis = RadialAxis(self)

# Calling polar_axes.xaxis.clear() or polar_axes.xaxis.clear()

# results in weird artifacts. Therefore we disable this for

# now.

# self.spines['polar'].register_axis(self.yaxis)

self._update_transScale()

def _set_lim_and_transforms(self):

# A view limit where the minimum radius can be locked if the user

# specifies an alternate origin.

self._originViewLim = mtransforms.LockableBbox(self.viewLim)

# Handle angular offset and direction.

self._direction = mtransforms.Affine2D() \

.scale(self._default_theta_direction, 1.0)

self._theta_offset = mtransforms.Affine2D() \

.translate(self._default_theta_offset, 0.0)

self.transShift = self._direction + self._theta_offset

# A view limit shifted to the correct location after accounting for

# orientation and offset.

self._realViewLim = mtransforms.TransformedBbox(self.viewLim,

self.transShift)

# Transforms the x and y axis separately by a scale factor

# It is assumed that this part will have non-linear components

self.transScale = mtransforms.TransformWrapper(

mtransforms.IdentityTransform())

# Scale view limit into a bbox around the selected wedge. This may be

# smaller than the usual unit axes rectangle if not plotting the full

# circle.

self.axesLim = _WedgeBbox((0.5, 0.5),

self._realViewLim, self._originViewLim)

# Scale the wedge to fill the axes.

self.transWedge = mtransforms.BboxTransformFrom(self.axesLim)

# Scale the axes to fill the figure.

self.transAxes = mtransforms.BboxTransformTo(self.bbox)

# A (possibly non-linear) projection on the (already scaled)

# data. This one is aware of rmin

self.transProjection = self.PolarTransform(

self,

_apply_theta_transforms=False)

# Add dependency on rorigin.

self.transProjection.set_children(self._originViewLim)

# An affine transformation on the data, generally to limit the

# range of the axes

self.transProjectionAffine = self.PolarAffine(self.transScale,

self._originViewLim)

# The complete data transformation stack -- from data all the

# way to display coordinates

self.transData = (

self.transScale + self.transShift + self.transProjection +

(self.transProjectionAffine + self.transWedge + self.transAxes))

# This is the transform for theta-axis ticks. It is

# equivalent to transData, except it always puts r == 0.0 and r == 1.0

# at the edge of the axis circles.

self._xaxis_transform = (

mtransforms.blended_transform_factory(

mtransforms.IdentityTransform(),

mtransforms.BboxTransformTo(self.viewLim)) +

self.transData)

# The theta labels are flipped along the radius, so that text 1 is on

# the outside by default. This should work the same as before.

flipr_transform = mtransforms.Affine2D() \

.translate(0.0, -0.5) \

.scale(1.0, -1.0) \

.translate(0.0, 0.5)

self._xaxis_text_transform = flipr_transform + self._xaxis_transform

# This is the transform for r-axis ticks. It scales the theta

# axis so the gridlines from 0.0 to 1.0, now go from thetamin to

# thetamax.

self._yaxis_transform = (

mtransforms.blended_transform_factory(

mtransforms.BboxTransformTo(self.viewLim),

mtransforms.IdentityTransform()) +

self.transData)

# The r-axis labels are put at an angle and padded in the r-direction

self._r_label_position = mtransforms.Affine2D() \

.translate(self._default_rlabel_position, 0.0)

self._yaxis_text_transform = mtransforms.TransformWrapper(

self._r_label_position + self.transData)

def get_xaxis_transform(self, which='grid'):

_api.check_in_list(['tick1', 'tick2', 'grid'], which=which)

return self._xaxis_transform

def get_xaxis_text1_transform(self, pad):

return self._xaxis_text_transform, 'center', 'center'

def get_xaxis_text2_transform(self, pad):

return self._xaxis_text_transform, 'center', 'center'

def get_yaxis_transform(self, which='grid'):

if which in ('tick1', 'tick2'):

return self._yaxis_text_transform

elif which == 'grid':

return self._yaxis_transform

else:

_api.check_in_list(['tick1', 'tick2', 'grid'], which=which)

def get_yaxis_text1_transform(self, pad):

thetamin, thetamax = self._realViewLim.intervalx

if _is_full_circle_rad(thetamin, thetamax):

return self._yaxis_text_transform, 'bottom', 'left'

elif self.get_theta_direction() > 0:

halign = 'left'

pad_shift = _ThetaShift(self, pad, 'min')

else:

halign = 'right'

pad_shift = _ThetaShift(self, pad, 'max')

return self._yaxis_text_transform + pad_shift, 'center', halign

def get_yaxis_text2_transform(self, pad):

if self.get_theta_direction() > 0:

halign = 'right'

pad_shift = _ThetaShift(self, pad, 'max')

else:

halign = 'left'

pad_shift = _ThetaShift(self, pad, 'min')

return self._yaxis_text_transform + pad_shift, 'center', halign

def draw(self, renderer):

self._unstale_viewLim()

thetamin, thetamax = np.rad2deg(self._realViewLim.intervalx)

if thetamin > thetamax:

thetamin, thetamax = thetamax, thetamin

rmin, rmax = ((self._realViewLim.intervaly - self.get_rorigin()) *

self.get_rsign())

if isinstance(self.patch, mpatches.Wedge):

# Backwards-compatibility: Any subclassed Axes might override the

# patch to not be the Wedge that PolarAxes uses.

center = self.transWedge.transform((0.5, 0.5))

self.patch.set_center(center)

self.patch.set_theta1(thetamin)

self.patch.set_theta2(thetamax)

edge, _ = self.transWedge.transform((1, 0))

radius = edge - center[0]

width = min(radius * (rmax - rmin) / rmax, radius)

self.patch.set_radius(radius)

self.patch.set_width(width)

inner_width = radius - width

inner = self.spines.get('inner', None)

if inner:

inner.set_visible(inner_width != 0.0)

visible = not _is_full_circle_deg(thetamin, thetamax)

# For backwards compatibility, any subclassed Axes might override the

# spines to not include start/end that PolarAxes uses.

start = self.spines.get('start', None)

end = self.spines.get('end', None)

if start:

start.set_visible(visible)

if end:

end.set_visible(visible)

if visible:

yaxis_text_transform = self._yaxis_transform

else:

yaxis_text_transform = self._r_label_position + self.transData

if self._yaxis_text_transform != yaxis_text_transform:

self._yaxis_text_transform.set(yaxis_text_transform)

self.yaxis.reset_ticks()

self.yaxis.set_clip_path(self.patch)

super().draw(renderer)

def _gen_axes_patch(self):

return mpatches.Wedge((0.5, 0.5), 0.5, 0.0, 360.0)

def _gen_axes_spines(self):

spines = OrderedDict([

('polar', mspines.Spine.arc_spine(self, 'top',

(0.5, 0.5), 0.5, 0.0, 360.0)),

('start', mspines.Spine.linear_spine(self, 'left')),

('end', mspines.Spine.linear_spine(self, 'right')),

('inner', mspines.Spine.arc_spine(self, 'bottom',

(0.5, 0.5), 0.0, 0.0, 360.0))

])

spines['polar'].set_transform(self.transWedge + self.transAxes)

spines['inner'].set_transform(self.transWedge + self.transAxes)

spines['start'].set_transform(self._yaxis_transform)

spines['end'].set_transform(self._yaxis_transform)

return spines

def set_thetamax(self, thetamax):

"""Set the maximum theta limit in degrees."""