"""Convert linestyle to dash pattern."""

# go from short hand -> full strings

if isinstance(style, str):

style = ls_mapper.get(style, style)

# un-dashed styles

if style in ['solid', 'None']:

offset = 0

dashes = None

# dashed styles

elif style in ['dashed', 'dashdot', 'dotted']:

offset = 0

dashes = tuple(mpl.rcParams[f'lines.{style}_pattern'])

#

elif isinstance(style, tuple):

offset, dashes = style

if offset is None:

raise ValueError(f'Unrecognized linestyle: {style!r}')

else:

raise ValueError(f'Unrecognized linestyle: {style!r}')

# normalize offset to be positive and shorter than the dash cycle

if dashes is not None:

dsum = sum(dashes)

if dsum:

offset %= dsum

"""Return the inverse of the given dash pattern, for filling the gaps."""

# Define the inverse pattern by moving the last gap to the start of the

# sequence.

gaps = dashes[-1:] + dashes[:-1]

# Set the offset so that this new first segment is skipped

# (see backend_bases.GraphicsContextBase.set_dashes for offset definition).

offset_gaps = offset + dashes[-1]

if not mpl.rcParams['lines.scale_dashes']:

return offset, dashes

scaled_offset = offset * lw

scaled_dashes = ([x * lw if x is not None else None for x in dashes]

if dashes is not None else None)

"""

# Process single points specially

if len(x) <= 1:

res, = np.nonzero((cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2)

return res

# We need to lop the last element off a lot.

xr, yr = x[:-1], y[:-1]

# Only look at line segments whose nearest point to C on the line

# lies within the segment.

dx, dy = x[1:] - xr, y[1:] - yr

Lnorm_sq = dx ** 2 + dy ** 2 # Possibly want to eliminate Lnorm==0

u = ((cx - xr) * dx + (cy - yr) * dy) / Lnorm_sq

candidates = (u >= 0) & (u <= 1)

# Note that there is a little area near one side of each point

# which will be near neither segment, and another which will

# be near both, depending on the angle of the lines. The

# following radius test eliminates these ambiguities.

point_hits = (cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2

candidates = candidates & ~(point_hits[:-1] | point_hits[1:])

# For those candidates which remain, determine how far they lie away

# from the line.

px, py = xr + u * dx, yr + u * dy

line_hits = (cx - px) ** 2 + (cy - py) ** 2 <= radius ** 2

line_hits = line_hits & candidates

points, = point_hits.ravel().nonzero()

lines, = line_hits.ravel().nonzero()

"""

# pull out the two bits of data we want from the path

codes, verts = tpath.codes, tpath.vertices

def _slice_or_none(in_v, slc):

"""Helper function to cope with `codes` being an ndarray or `None`."""

if in_v is None:

return None

return in_v[slc]

# if just an int, assume starting at 0 and make a tuple

if isinstance(markevery, Integral):

markevery = (0, markevery)

# if just a float, assume starting at 0.0 and make a tuple

elif isinstance(markevery, Real):

markevery = (0.0, markevery)

if isinstance(markevery, tuple):

if len(markevery) != 2:

raise ValueError('`markevery` is a tuple but its len is not 2; '

f'markevery={markevery}')

start, step = markevery

# if step is an int, old behavior

if isinstance(step, Integral):

# tuple of 2 int is for backwards compatibility,

if not isinstance(start, Integral):

raise ValueError(

'`markevery` is a tuple with len 2 and second element is '

'an int, but the first element is not an int; '

f'markevery={markevery}')

# just return, we are done here

return Path(verts[slice(start, None, step)],

_slice_or_none(codes, slice(start, None, step)))

elif isinstance(step, Real):

if not isinstance(start, Real):

raise ValueError(

'`markevery` is a tuple with len 2 and second element is '

'a float, but the first element is not a float or an int; '

f'markevery={markevery}')

if ax is None:

raise ValueError(

"markevery is specified relative to the axes size, but "

"the line does not have a Axes as parent")

# calc cumulative distance along path (in display coords):

fin = np.isfinite(verts).all(axis=1)

fverts = verts[fin]

disp_coords = affine.transform(fverts)

delta = np.empty((len(disp_coords), 2))

delta[0, :] = 0

delta[1:, :] = disp_coords[1:, :] - disp_coords[:-1, :]

delta = np.hypot(*delta.T).cumsum()

# calc distance between markers along path based on the axes

# bounding box diagonal being a distance of unity:

(x0, y0), (x1, y1) = ax.transAxes.transform([[0, 0], [1, 1]])

scale = np.hypot(x1 - x0, y1 - y0)

marker_delta = np.arange(start * scale, delta[-1], step * scale)

# find closest actual data point that is closest to

# the theoretical distance along the path:

inds = np.abs(delta[np.newaxis, :] - marker_delta[:, np.newaxis])

inds = inds.argmin(axis=1)

inds = np.unique(inds)

# return, we are done here

return Path(fverts[inds], _slice_or_none(codes, inds))

else:

raise ValueError(

f"markevery={markevery!r} is a tuple with len 2, but its "

f"second element is not an int or a float")

elif isinstance(markevery, slice):

# mazol tov, it's already a slice, just return

return Path(verts[markevery], _slice_or_none(codes, markevery))

elif np.iterable(markevery):

# fancy indexing

try:

return Path(verts[markevery], _slice_or_none(codes, markevery))

except (ValueError, IndexError) as err:

raise ValueError(

f"markevery={markevery!r} is iterable but not a valid numpy "

f"fancy index") from err

else:

"""

lineStyles = _lineStyles = { # hidden names deprecated

'-': '_draw_solid',

'--': '_draw_dashed',

'-.': '_draw_dash_dot',

':': '_draw_dotted',

'None': '_draw_nothing',

' ': '_draw_nothing',

'': '_draw_nothing',

}

_drawStyles_l = {

'default': '_draw_lines',

'steps-mid': '_draw_steps_mid',

'steps-pre': '_draw_steps_pre',

'steps-post': '_draw_steps_post',

}

_drawStyles_s = {

'steps': '_draw_steps_pre',

}

# drawStyles should now be deprecated.

drawStyles = {**_drawStyles_l, **_drawStyles_s}

# Need a list ordered with long names first:

drawStyleKeys = [*_drawStyles_l, *_drawStyles_s]

# Referenced here to maintain API. These are defined in

# MarkerStyle

markers = MarkerStyle.markers

filled_markers = MarkerStyle.filled_markers

fillStyles = MarkerStyle.fillstyles

zorder = 2

def __str__(self):

if self._label != "":

return f"Line2D({self._label})"

elif self._x is None:

return "Line2D()"

elif len(self._x) > 3:

return "Line2D(({:g},{:g}),({:g},{:g}),...,({:g},{:g}))".format(

self._x[0], self._y[0],

self._x[1], self._y[1],

self._x[-1], self._y[-1])

else:

return "Line2D(%s)" % ",".join(

map("({:g},{:g})".format, self._x, self._y))

def __init__(self, xdata, ydata, *,

linewidth=None, # all Nones default to rc

linestyle=None,

color=None,

gapcolor=None,

marker=None,

markersize=None,

markeredgewidth=None,

markeredgecolor=None,

markerfacecolor=None,

markerfacecoloralt='none',

fillstyle=None,

antialiased=None,

dash_capstyle=None,

solid_capstyle=None,

dash_joinstyle=None,

solid_joinstyle=None,

pickradius=5,

drawstyle=None,

markevery=None,

**kwargs

):

"""

super().__init__()

# Convert sequences to NumPy arrays.

if not np.iterable(xdata):

raise RuntimeError('xdata must be a sequence')

if not np.iterable(ydata):

raise RuntimeError('ydata must be a sequence')

if linewidth is None:

linewidth = mpl.rcParams['lines.linewidth']

if linestyle is None:

linestyle = mpl.rcParams['lines.linestyle']

if marker is None:

marker = mpl.rcParams['lines.marker']

if color is None:

color = mpl.rcParams['lines.color']

if markersize is None:

markersize = mpl.rcParams['lines.markersize']

if antialiased is None:

antialiased = mpl.rcParams['lines.antialiased']

if dash_capstyle is None:

dash_capstyle = mpl.rcParams['lines.dash_capstyle']

if dash_joinstyle is None:

dash_joinstyle = mpl.rcParams['lines.dash_joinstyle']

if solid_capstyle is None:

solid_capstyle = mpl.rcParams['lines.solid_capstyle']

if solid_joinstyle is None:

solid_joinstyle = mpl.rcParams['lines.solid_joinstyle']

if drawstyle is None:

drawstyle = 'default'

self._dashcapstyle = None

self._dashjoinstyle = None

self._solidjoinstyle = None

self._solidcapstyle = None

self.set_dash_capstyle(dash_capstyle)

self.set_dash_joinstyle(dash_joinstyle)

self.set_solid_capstyle(solid_capstyle)

self.set_solid_joinstyle(solid_joinstyle)

self._linestyles = None

self._drawstyle = None

self._linewidth = linewidth

self._unscaled_dash_pattern = (0, None) # offset, dash

self._dash_pattern = (0, None) # offset, dash (scaled by linewidth)

self.set_linewidth(linewidth)

self.set_linestyle(linestyle)

self.set_drawstyle(drawstyle)

self._color = None

self.set_color(color)

if marker is None:

marker = 'none' # Default.

if not isinstance(marker, MarkerStyle):

self._marker = MarkerStyle(marker, fillstyle)

else:

self._marker = marker

self._gapcolor = None

self.set_gapcolor(gapcolor)

self._markevery = None

self._markersize = None

self._antialiased = None

self.set_markevery(markevery)

self.set_antialiased(antialiased)

self.set_markersize(markersize)

self._markeredgecolor = None

self._markeredgewidth = None

self._markerfacecolor = None

self._markerfacecoloralt = None

self.set_markerfacecolor(markerfacecolor) # Normalizes None to rc.

self.set_markerfacecoloralt(markerfacecoloralt)

self.set_markeredgecolor(markeredgecolor) # Normalizes None to rc.

self.set_markeredgewidth(markeredgewidth)

# update kwargs before updating data to give the caller a

# chance to init axes (and hence unit support)

self._internal_update(kwargs)

self.pickradius = pickradius

self.ind_offset = 0

if (isinstance(self._picker, Number) and

not isinstance(self._picker, bool)):

self._pickradius = self._picker

self._xorig = np.asarray([])

self._yorig = np.asarray([])

self._invalidx = True

self._invalidy = True

self._x = None

self._y = None

self._xy = None

self._path = None

self._transformed_path = None

self._subslice = False

self._x_filled = None # used in subslicing; only x is needed

self.set_data(xdata, ydata)

def contains(self, mouseevent):

"""

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

# Make sure we have data to plot

if self._invalidy or self._invalidx:

self.recache()

if len(self._xy) == 0:

return False, {}

# Convert points to pixels

transformed_path = self._get_transformed_path()

path, affine = transformed_path.get_transformed_path_and_affine()

path = affine.transform_path(path)

xy = path.vertices

xt = xy[:, 0]

yt = xy[:, 1]

# Convert pick radius from points to pixels

if self.figure is None:

_log.warning('no figure set when check if mouse is on line')

pixels = self._pickradius

else:

pixels = self.figure.dpi / 72. * self._pickradius

# The math involved in checking for containment (here and inside of

# segment_hits) assumes that it is OK to overflow, so temporarily set

# the error flags accordingly.

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

# Check for collision

if self._linestyle in ['None', None]:

# If no line, return the nearby point(s)

ind, = np.nonzero(

(xt - mouseevent.x) ** 2 + (yt - mouseevent.y) ** 2

<= pixels ** 2)

else:

# If line, return the nearby segment(s)

ind = segment_hits(mouseevent.x, mouseevent.y, xt, yt, pixels)

if self._drawstyle.startswith("steps"):

ind //= 2

ind += self.ind_offset

# Return the point(s) within radius

return len(ind) > 0, dict(ind=ind)

def get_pickradius(self):

"""

return self._pickradius

def set_pickradius(self, pickradius):

"""

if not isinstance(pickradius, Real) or pickradius < 0:

raise ValueError("pick radius should be a distance")

self._pickradius = pickradius

pickradius = property(get_pickradius, set_pickradius)

def get_fillstyle(self):

"""

return self._marker.get_fillstyle()

def set_fillstyle(self, fs):

"""

self.set_marker(MarkerStyle(self._marker.get_marker(), fs))

self.stale = True

def set_markevery(self, every):

"""

self._markevery = every

self.stale = True

def get_markevery(self):

"""

return self._markevery

def set_picker(self, p):

"""

if not callable(p):

self.set_pickradius(p)

self._picker = p

def get_bbox(self):

"""Get the bounding box of this line."""

bbox = Bbox([[0, 0], [0, 0]])

bbox.update_from_data_xy(self.get_xydata())

return bbox

def get_window_extent(self, renderer=None):

bbox = Bbox([[0, 0], [0, 0]])

trans_data_to_xy = self.get_transform().transform

bbox.update_from_data_xy(trans_data_to_xy(self.get_xydata()),

ignore=True)

# correct for marker size, if any

if self._marker:

ms = (self._markersize / 72.0 * self.figure.dpi) * 0.5

bbox = bbox.padded(ms)

return bbox

def set_data(self, *args):

"""

if len(args) == 1:

(x, y), = args

else:

x, y = args

self.set_xdata(x)

self.set_ydata(y)

def recache_always(self):

self.recache(always=True)

def recache(self, always=False):

if always or self._invalidx:

xconv = self.convert_xunits(self._xorig)

x = _to_unmasked_float_array(xconv).ravel()

else:

x = self._x

if always or self._invalidy:

yconv = self.convert_yunits(self._yorig)

y = _to_unmasked_float_array(yconv).ravel()

else:

y = self._y

self._xy = np.column_stack(np.broadcast_arrays(x, y)).astype(float)

self._x, self._y = self._xy.T # views

self._subslice = False

if (self.axes and len(x) > 1000 and self._is_sorted(x) and

self.axes.name == 'rectilinear' and

self.axes.get_xscale() == 'linear' and

self._markevery is None and

self.get_clip_on() and

self.get_transform() == self.axes.transData):

self._subslice = True

nanmask = np.isnan(x)

if nanmask.any():

self._x_filled = self._x.copy()

indices = np.arange(len(x))

self._x_filled[nanmask] = np.interp(

indices[nanmask], indices[~nanmask], self._x[~nanmask])

else:

self._x_filled = self._x

if self._path is not None:

interpolation_steps = self._path._interpolation_steps

else:

interpolation_steps = 1

xy = STEP_LOOKUP_MAP[self._drawstyle](*self._xy.T)

self._path = Path(np.asarray(xy).T,

_interpolation_steps=interpolation_steps)

self._transformed_path = None

self._invalidx = False

self._invalidy = False

def _transform_path(self, subslice=None):

"""

# Masked arrays are now handled by the Path class itself

if subslice is not None:

xy = STEP_LOOKUP_MAP[self._drawstyle](*self._xy[subslice, :].T)

_path = Path(np.asarray(xy).T,

_interpolation_steps=self._path._interpolation_steps)

else:

_path = self._path

self._transformed_path = TransformedPath(_path, self.get_transform())

def _get_transformed_path(self):

"""Return this line's `~matplotlib.transforms.TransformedPath`."""

if self._transformed_path is None:

self._transform_path()

return self._transformed_path

def set_transform(self, t):

# docstring inherited

self._invalidx = True

self._invalidy = True

super().set_transform(t)

def _is_sorted(self, x):

"""Return whether x is sorted in ascending order."""

# We don't handle the monotonically decreasing case.

return _path.is_sorted(x)

@allow_rasterization

def draw(self, renderer):

# docstring inherited

if not self.get_visible():

return

if self._invalidy or self._invalidx:

self.recache()

self.ind_offset = 0 # Needed for contains() method.

if self._subslice and self.axes:

x0, x1 = self.axes.get_xbound()

i0 = self._x_filled.searchsorted(x0, 'left')

i1 = self._x_filled.searchsorted(x1, 'right')

subslice = slice(max(i0 - 1, 0), i1 + 1)

self.ind_offset = subslice.start

self._transform_path(subslice)

else:

subslice = None

if self.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

renderer = PathEffectRenderer(self.get_path_effects(), renderer)

renderer.open_group('line2d', self.get_gid())

if self._lineStyles[self._linestyle] != '_draw_nothing':

tpath, affine = (self._get_transformed_path()

.get_transformed_path_and_affine())

if len(tpath.vertices):

gc = renderer.new_gc()

self._set_gc_clip(gc)

gc.set_url(self.get_url())

gc.set_antialiased(self._antialiased)

gc.set_linewidth(self._linewidth)

if self.is_dashed():

cap = self._dashcapstyle

join = self._dashjoinstyle

else:

cap = self._solidcapstyle

join = self._solidjoinstyle

gc.set_joinstyle(join)

gc.set_capstyle(cap)

gc.set_snap(self.get_snap())

if self.get_sketch_params() is not None:

gc.set_sketch_params(*self.get_sketch_params())

# We first draw a path within the gaps if needed.

if self.is_dashed() and self._gapcolor is not None:

lc_rgba = mcolors.to_rgba(self._gapcolor, self._alpha)

gc.set_foreground(lc_rgba, isRGBA=True)

offset_gaps, gaps = _get_inverse_dash_pattern(

*self._dash_pattern)

gc.set_dashes(offset_gaps, gaps)

renderer.draw_path(gc, tpath, affine.frozen())

lc_rgba = mcolors.to_rgba(self._color, self._alpha)

gc.set_foreground(lc_rgba, isRGBA=True)

gc.set_dashes(*self._dash_pattern)

renderer.draw_path(gc, tpath, affine.frozen())

gc.restore()

if self._marker and self._markersize > 0:

gc = renderer.new_gc()

self._set_gc_clip(gc)

gc.set_url(self.get_url())

gc.set_linewidth(self._markeredgewidth)

gc.set_antialiased(self._antialiased)

ec_rgba = mcolors.to_rgba(

self.get_markeredgecolor(), self._alpha)

fc_rgba = mcolors.to_rgba(

self._get_markerfacecolor(), self._alpha)

fcalt_rgba = mcolors.to_rgba(

self._get_markerfacecolor(alt=True), self._alpha)

# If the edgecolor is "auto", it is set according to the *line*

# color but inherits the alpha value of the *face* color, if any.

if (cbook._str_equal(self._markeredgecolor, "auto")

and not cbook._str_lower_equal(

self.get_markerfacecolor(), "none")):

ec_rgba = ec_rgba[:3] + (fc_rgba[3],)

gc.set_foreground(ec_rgba, isRGBA=True)

if self.get_sketch_params() is not None:

scale, length, randomness = self.get_sketch_params()

gc.set_sketch_params(scale/2, length/2, 2*randomness)

marker = self._marker

# Markers *must* be drawn ignoring the drawstyle (but don't pay the

# recaching if drawstyle is already "default").

if self.get_drawstyle() != "default":

with cbook._setattr_cm(

self, _drawstyle="default", _transformed_path=None):

self.recache()

self._transform_path(subslice)

tpath, affine = (self._get_transformed_path()

.get_transformed_points_and_affine())

else:

tpath, affine = (self._get_transformed_path()

.get_transformed_points_and_affine())

if len(tpath.vertices):

# subsample the markers if markevery is not None

markevery = self.get_markevery()

if markevery is not None:

subsampled = _mark_every_path(

markevery, tpath, affine, self.axes)

else:

subsampled = tpath

snap = marker.get_snap_threshold()

if isinstance(snap, Real):

snap = renderer.points_to_pixels(self._markersize) >= snap

gc.set_snap(snap)

gc.set_joinstyle(marker.get_joinstyle())

gc.set_capstyle(marker.get_capstyle())

marker_path = marker.get_path()

marker_trans = marker.get_transform()

w = renderer.points_to_pixels(self._markersize)

if cbook._str_equal(marker.get_marker(), ","):

gc.set_linewidth(0)

else:

# Don't scale for pixels, and don't stroke them

marker_trans = marker_trans.scale(w)

renderer.draw_markers(gc, marker_path, marker_trans,

subsampled, affine.frozen(),

fc_rgba)

alt_marker_path = marker.get_alt_path()

if alt_marker_path:

alt_marker_trans = marker.get_alt_transform()

alt_marker_trans = alt_marker_trans.scale(w)

renderer.draw_markers(

gc, alt_marker_path, alt_marker_trans, subsampled,

affine.frozen(), fcalt_rgba)

gc.restore()

renderer.close_group('line2d')

self.stale = False

def get_antialiased(self):

"""Return whether antialiased rendering is used."""

return self._antialiased

def get_color(self):

"""

return self._color

def get_drawstyle(self):

"""

return self._drawstyle

def get_gapcolor(self):

"""

return self._gapcolor

def get_linestyle(self):

"""

return self._linestyle

def get_linewidth(self):

"""

return self._linewidth

def get_marker(self):

"""

return self._marker.get_marker()

def get_markeredgecolor(self):

"""

mec = self._markeredgecolor

if cbook._str_equal(mec, 'auto'):

if mpl.rcParams['_internal.classic_mode']:

if self._marker.get_marker() in ('.', ','):

return self._color

if (self._marker.is_filled()

and self._marker.get_fillstyle() != 'none'):

return 'k' # Bad hard-wired default...

return self._color

else:

return mec

def get_markeredgewidth(self):

"""

return self._markeredgewidth

def _get_markerfacecolor(self, alt=False):

if self._marker.get_fillstyle() == 'none':

return 'none'

fc = self._markerfacecoloralt if alt else self._markerfacecolor

if cbook._str_lower_equal(fc, 'auto'):

return self._color

else:

return fc

def get_markerfacecolor(self):

"""

return self._get_markerfacecolor(alt=False)

def get_markerfacecoloralt(self):

"""

return self._get_markerfacecolor(alt=True)

def get_markersize(self):

"""

return self._markersize

def get_data(self, orig=True):

"""