"""

# Process single points specially

if len(x) < 2:

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)

#if any(candidates): print "candidates",xr[candidates]

# 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

#if any(point_hits): print "points",xr[candidates]

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

#if any(line_hits): print "lines",xr[candidates]

line_hits = line_hits & candidates

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

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

#print points,lines

"""

# 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):

'''

if in_v is None:

return None

return in_v[slc]

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

if isinstance(markevery, float):

markevery = (0.0, markevery)

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

elif isinstance(markevery, int):

markevery = (0, markevery)

if isinstance(markevery, tuple):

if len(markevery) != 2:

raise ValueError('`markevery` is a tuple but its '

'len is not 2; '

'markevery=%s' % (markevery,))

start, step = markevery

# if step is an int, old behavior

if isinstance(step, int):

#tuple of 2 int is for backwards compatibility,

if not(isinstance(start, int)):

raise ValueError('`markevery` is a tuple with '

'len 2 and second element is an int, but '

'the first element is not an int; '

'markevery=%s' % (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, float):

if not (isinstance(start, int) or

isinstance(start, float)):

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; '

'markevery=%s' % (markevery,))

#calc cumulative distance along path (in display

# coords):

disp_coords = affine.transform(tpath.vertices)

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

dtype=float)

delta[0, :] = 0.0

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

disp_coords[:-1, :])

delta = np.sum(delta**2, axis=1)

delta = np.sqrt(delta)

delta = np.cumsum(delta)

#calc distance between markers along path based on

# the axes bounding box diagonal being a distance

# of unity:

scale = ax_transform.transform(

np.array([[0, 0], [1, 1]]))

scale = np.diff(scale, axis=0)

scale = np.sum(scale**2)

scale = np.sqrt(scale)

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(verts[inds],

_slice_or_none(codes, inds))

else:

raise ValueError('`markevery` is a tuple with '

'len 2, but its second element is not an int '

'or a float; '

'markevery=%s' % (markevery,))

elif isinstance(markevery, slice):

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

return Path(verts[markevery],

_slice_or_none(codes, markevery))

elif iterable(markevery):

#fancy indexing

try:

return Path(verts[markevery],

_slice_or_none(codes, markevery))

except (ValueError, IndexError):

raise ValueError('`markevery` is iterable but '

'not a valid form of numpy fancy indexing; '

'markevery=%s' % (markevery,))

else:

raise ValueError('Value of `markevery` is not '

'recognized; '

"""

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 = {}

drawStyles.update(_drawStyles_l)

drawStyles.update(_drawStyles_s)

# Need a list ordered with long names first:

drawStyleKeys = (list(six.iterkeys(_drawStyles_l)) +

list(six.iterkeys(_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

validCap = ('butt', 'round', 'projecting')

validJoin = ('miter', 'round', 'bevel')

def __str__(self):

if self._label != "":

return "Line2D(%s)" % (self._label)

elif self._x is None:

return "Line2D()"

elif len(self._x) > 3:

return "Line2D((%g,%g),(%g,%g),...,(%g,%g))"\

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

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

else:

return "Line2D(%s)"\

% (",".join(["(%g,%g)" % (x, y) for x, y

in zip(self._x, self._y)]))

def __init__(self, xdata, ydata,

linewidth=None, # all Nones default to rc

linestyle=None,

color=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

):

"""

Artist.__init__(self)

#convert sequences to numpy arrays

if not iterable(xdata):

raise RuntimeError('xdata must be a sequence')

if not iterable(ydata):

raise RuntimeError('ydata must be a sequence')

if linewidth is None:

linewidth = rcParams['lines.linewidth']

if linestyle is None:

linestyle = rcParams['lines.linestyle']

if marker is None:

marker = rcParams['lines.marker']

if color is None:

color = rcParams['lines.color']

if markersize is None:

markersize = rcParams['lines.markersize']

if antialiased is None:

antialiased = rcParams['lines.antialiased']

if dash_capstyle is None:

dash_capstyle = rcParams['lines.dash_capstyle']

if dash_joinstyle is None:

dash_joinstyle = rcParams['lines.dash_joinstyle']

if solid_capstyle is None:

solid_capstyle = rcParams['lines.solid_capstyle']

if solid_joinstyle is None:

solid_joinstyle = 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 = None

self.set_linestyle(linestyle)

self.set_drawstyle(drawstyle)

self.set_linewidth(linewidth)

self._color = None

self.set_color(color)

self._marker = MarkerStyle()

self.set_marker(marker)

self._markevery = None

self._markersize = None

self._antialiased = None

self.set_markevery(markevery)

self.set_antialiased(antialiased)

self.set_markersize(markersize)

self._dashSeq = None

self._markeredgecolor = None

self._markeredgewidth = None

self._markerfacecolor = None

self._markerfacecoloralt = None

self.set_markerfacecolor(markerfacecolor)

self.set_markerfacecoloralt(markerfacecoloralt)

self.set_markeredgecolor(markeredgecolor)

self.set_markeredgewidth(markeredgewidth)

self.set_fillstyle(fillstyle)

self.verticalOffset = None

# update kwargs before updating data to give the caller a

# chance to init axes (and hence unit support)

self.update(kwargs)

self.pickradius = pickradius

self.ind_offset = 0

if is_numlike(self._picker):

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 __getstate__(self):

state = super(Line2D, self).__getstate__()

# _linefunc will be restored on draw time.

state.pop('_lineFunc', None)

return state

def contains(self, mouseevent):

"""

if six.callable(self._contains):

return self._contains(self, mouseevent)

if not is_numlike(self.pickradius):

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

# 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:

warnings.warn('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. In case the

# application has set the error flags such that an exception is raised

# on overflow, we temporarily set the appropriate error flags here and

# set them back when we are finished.

olderrflags = np.seterr(all='ignore')

try:

# Check for collision

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

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

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

ind, = np.nonzero(np.less_equal(d, pixels ** 2))

else:

# If line, return the nearby segment(s)

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

finally:

np.seterr(**olderrflags)

ind += self.ind_offset

# Debugging message

if False and self._label != '':

print("Checking line", self._label,

"at", mouseevent.x, mouseevent.y)

print('xt', xt)

print('yt', yt)

#print 'dx,dy', (xt-mouseevent.x)**2., (yt-mouseevent.y)**2.

print('ind', ind)

# Return the point(s) within radius

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

def get_pickradius(self):

"""return the pick radius used for containment tests"""

return self.pickradius

def set_pickradius(self, d):

"""Sets the pick radius used for containment tests

self.pickradius = d

def get_fillstyle(self):

"""

return self._marker.get_fillstyle()

def set_fillstyle(self, fs):

"""

self._marker.set_fillstyle(fs)

self.stale = True

def set_markevery(self, every):

"""Set the markevery property to subsample the plot when using markers.

if self._markevery != every:

self.stale = True

self._markevery = every

def get_markevery(self):

"""return the markevery setting"""

return self._markevery

def set_picker(self, p):

"""Sets the event picker details for the line.

if six.callable(p):

self._contains = p

else:

self.pickradius = p

self._picker = p

def get_window_extent(self, renderer):

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

@Artist.axes.setter

def axes(self, ax):

# call the set method from the base-class property

Artist.axes.fset(self, ax)

if ax is not None:

# connect unit-related callbacks

if ax.xaxis is not None:

self._xcid = ax.xaxis.callbacks.connect('units',

self.recache_always)

if ax.yaxis is not None:

self._ycid = ax.yaxis.callbacks.connect('units',

self.recache_always)

def set_data(self, *args):

"""

if len(args) == 1:

x, y = args[0]

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)

if ma.isMaskedArray(self._xorig):

x = ma.asarray(xconv, np.float_).filled(np.nan)

else:

x = np.asarray(xconv, np.float_)

x = x.ravel()

else:

x = self._x

if always or self._invalidy:

yconv = self.convert_yunits(self._yorig)

if ma.isMaskedArray(self._yorig):

y = ma.asarray(yconv, np.float_).filled(np.nan)

else:

y = np.asarray(yconv, np.float_)

y = y.ravel()

else:

y = self._y

if len(x) == 1 and len(y) > 1:

x = x * np.ones(y.shape, np.float_)

if len(y) == 1 and len(x) > 1:

y = y * np.ones(x.shape, np.float_)

if len(x) != len(y):

raise RuntimeError('xdata and ydata must be the same length')

self._xy = np.empty((len(x), 2), dtype=np.float_)

self._xy[:, 0] = x

self._xy[:, 1] = y

self._x = self._xy[:, 0] # just a view

self._y = self._xy[:, 1] # just a view

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() is True):

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

self._path = Path(self._xy, None, 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:

_steps = self._path._interpolation_steps

_path = Path(self._xy[subslice, :], _interpolation_steps=_steps)

else:

_path = self._path

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

def _get_transformed_path(self):

"""

if self._transformed_path is None:

self._transform_path()

return self._transformed_path

def set_transform(self, t):

"""

Artist.set_transform(self, t)

self._invalidx = True

self._invalidy = True

self.stale = True

def _is_sorted(self, x):

"""return True if x is sorted in ascending order"""

# We don't handle the monotonically decreasing case.

if len(x) < 2:

return True

return np.nanmin(x[1:] - x[:-1]) >= 0

@allow_rasterization

def draw(self, renderer):

"""draw the Line with `renderer` unless visibility is False"""

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)

transf_path = self._get_transformed_path()

if self.get_path_effects():

from matplotlib.patheffects import PathEffectRenderer

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

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

funcname = self._lineStyles.get(self._linestyle, '_draw_nothing')

if funcname != '_draw_nothing':

tpath, affine = transf_path.get_transformed_path_and_affine()

if len(tpath.vertices):

self._lineFunc = getattr(self, funcname)

funcname = self.drawStyles.get(self._drawstyle, '_draw_lines')

drawFunc = getattr(self, funcname)

gc = renderer.new_gc()

self._set_gc_clip(gc)

ln_color_rgba = self._get_rgba_ln_color()

gc.set_foreground(ln_color_rgba, isRGBA=True)

gc.set_alpha(ln_color_rgba[3])

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())

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

gc.restore()

if self._marker:

gc = renderer.new_gc()

self._set_gc_clip(gc)

rgbaFace = self._get_rgba_face()

rgbaFaceAlt = self._get_rgba_face(alt=True)

edgecolor = self.get_markeredgecolor()

if is_string_like(edgecolor) and edgecolor.lower() == 'none':

gc.set_linewidth(0)

gc.set_foreground(rgbaFace, isRGBA=True)

else:

gc.set_foreground(edgecolor)

gc.set_linewidth(self._markeredgewidth)

mec = self._markeredgecolor

if (is_string_like(mec) and mec == 'auto' and

rgbaFace is not None):

gc.set_alpha(rgbaFace[3])

else:

gc.set_alpha(self.get_alpha())

marker = self._marker

tpath, affine = transf_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.transAxes)

else:

subsampled = tpath

snap = marker.get_snap_threshold()

if type(snap) == float:

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 marker.get_marker() != ',':

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

marker_trans = marker_trans.scale(w)

else:

gc.set_linewidth(0)

renderer.draw_markers(gc, marker_path, marker_trans,

subsampled, affine.frozen(),

rgbaFace)

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)

if (is_string_like(mec) and mec == 'auto' and

rgbaFaceAlt is not None):

gc.set_alpha(rgbaFaceAlt[3])

else:

gc.set_alpha(self.get_alpha())

renderer.draw_markers(

gc, alt_marker_path, alt_marker_trans, subsampled,

affine.frozen(), rgbaFaceAlt)

gc.restore()

renderer.close_group('line2d')

self.stale = False

def get_antialiased(self):

return self._antialiased

def get_color(self):

return self._color

def get_drawstyle(self):

return self._drawstyle

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 (is_string_like(mec) and mec == 'auto'):

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

return self._color

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

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

else:

return self._color

else:

return mec

def get_markeredgewidth(self):

return self._markeredgewidth

def _get_markerfacecolor(self, alt=False):

if alt:

fc = self._markerfacecoloralt

else:

fc = self._markerfacecolor

if (is_string_like(fc) and fc.lower() == 'auto'):

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

return 'none'

else:

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

"""

return self.get_xdata(orig=orig), self.get_ydata(orig=orig)

def get_xdata(self, orig=True):

"""

if orig:

return self._xorig

if self._invalidx:

self.recache()

return self._x

def get_ydata(self, orig=True):

"""

if orig:

return self._yorig

if self._invalidy:

self.recache()

return self._y

def get_path(self):

"""

if self._invalidy or self._invalidx:

self.recache()

return self._path

def get_xydata(self):

"""

if self._invalidy or self._invalidx:

self.recache()

return self._xy

def set_antialiased(self, b):

"""

if self._antialiased != b:

self.stale = True

self._antialiased = b

def set_color(self, color):

"""

self._color = color

self.stale = True

def set_drawstyle(self, drawstyle):

"""

if self._drawstyle != drawstyle:

self.stale = True

self._drawstyle = drawstyle

def set_linewidth(self, w):

"""

w = float(w)

if self._linewidth != w:

self.stale = True

self._linewidth = w

def set_linestyle(self, ls):

"""