Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.9/dist-packages/matplotlib/lines.py: 18%

1""" 

22D lines with support for a variety of line styles, markers, colors, etc. 

3""" 

4 

5import copy 

6 

7from numbers import Integral, Number, Real 

8import logging 

9 

10import numpy as np 

11 

12import matplotlib as mpl 

13from . import _api, cbook, colors as mcolors, _docstring 

14from .artist import Artist, allow_rasterization 

15from .cbook import ( 

16 _to_unmasked_float_array, ls_mapper, ls_mapper_r, STEP_LOOKUP_MAP) 

17from .markers import MarkerStyle 

18from .path import Path 

19from .transforms import Bbox, BboxTransformTo, TransformedPath 

20from ._enums import JoinStyle, CapStyle 

21 

22# Imported here for backward compatibility, even though they don't 

23# really belong. 

24from . import _path 

25from .markers import ( # noqa 

26 CARETLEFT, CARETRIGHT, CARETUP, CARETDOWN, 

27 CARETLEFTBASE, CARETRIGHTBASE, CARETUPBASE, CARETDOWNBASE, 

28 TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN) 

29 

30_log = logging.getLogger(__name__) 

31 

32 

33def _get_dash_pattern(style): 

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

35 # go from short hand -> full strings 

36 if isinstance(style, str): 

37 style = ls_mapper.get(style, style) 

38 # un-dashed styles 

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

40 offset = 0 

41 dashes = None 

42 # dashed styles 

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

44 offset = 0 

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

46 # 

47 elif isinstance(style, tuple): 

48 offset, dashes = style 

49 if offset is None: 

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

51 else: 

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

53 

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

55 if dashes is not None: 

56 dsum = sum(dashes) 

57 if dsum: 

58 offset %= dsum 

59 

60 return offset, dashes 

61 

62 

63def _get_inverse_dash_pattern(offset, dashes): 

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

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

66 # sequence. 

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

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

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

70 offset_gaps = offset + dashes[-1] 

71 

72 return offset_gaps, gaps 

73 

74 

75def _scale_dashes(offset, dashes, lw): 

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

77 return offset, dashes 

78 scaled_offset = offset * lw 

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

80 if dashes is not None else None) 

81 return scaled_offset, scaled_dashes 

82 

83 

84def segment_hits(cx, cy, x, y, radius): 

85 """ 

86 Return the indices of the segments in the polyline with coordinates (*cx*, 

87 *cy*) that are within a distance *radius* of the point (*x*, *y*). 

88 """ 

89 # Process single points specially 

90 if len(x) <= 1: 

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

92 return res 

93 

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

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

96 

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

98 # lies within the segment. 

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

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

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

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

103 

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

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

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

107 # following radius test eliminates these ambiguities. 

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

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

110 

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

112 # from the line. 

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

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

115 line_hits = line_hits & candidates 

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

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

118 return np.concatenate((points, lines)) 

119 

120 

121def _mark_every_path(markevery, tpath, affine, ax): 

122 """ 

123 Helper function that sorts out how to deal the input 

124 `markevery` and returns the points where markers should be drawn. 

125 

126 Takes in the `markevery` value and the line path and returns the 

127 sub-sampled path. 

128 """ 

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

130 codes, verts = tpath.codes, tpath.vertices 

131 

132 def _slice_or_none(in_v, slc): 

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

134 if in_v is None: 

135 return None 

136 return in_v[slc] 

137 

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

139 if isinstance(markevery, Integral): 

140 markevery = (0, markevery) 

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

142 elif isinstance(markevery, Real): 

143 markevery = (0.0, markevery) 

144 

145 if isinstance(markevery, tuple): 

146 if len(markevery) != 2: 

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

148 f'markevery={markevery}') 

149 start, step = markevery 

150 # if step is an int, old behavior 

151 if isinstance(step, Integral): 

152 # tuple of 2 int is for backwards compatibility, 

153 if not isinstance(start, Integral): 

154 raise ValueError( 

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

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

157 f'markevery={markevery}') 

158 # just return, we are done here 

159 

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

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

162 

163 elif isinstance(step, Real): 

164 if not isinstance(start, Real): 

165 raise ValueError( 

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

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

168 f'markevery={markevery}') 

169 if ax is None: 

170 raise ValueError( 

171 "markevery is specified relative to the Axes size, but " 

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

173 

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

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

176 fverts = verts[fin] 

177 disp_coords = affine.transform(fverts) 

178 

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

180 delta[0, :] = 0 

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

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

183 # calc distance between markers along path based on the Axes 

184 # bounding box diagonal being a distance of unity: 

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

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

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

188 # find closest actual data point that is closest to 

189 # the theoretical distance along the path: 

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

191 inds = inds.argmin(axis=1) 

192 inds = np.unique(inds) 

193 # return, we are done here 

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

195 else: 

196 raise ValueError( 

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

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

199 

200 elif isinstance(markevery, slice): 

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

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

203 

204 elif np.iterable(markevery): 

205 # fancy indexing 

206 try: 

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

208 except (ValueError, IndexError) as err: 

209 raise ValueError( 

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

211 f"fancy index") from err 

212 else: 

213 raise ValueError(f"markevery={markevery!r} is not a recognized value") 

214 

215 

216@_docstring.interpd 

217@_api.define_aliases({ 

218 "antialiased": ["aa"], 

219 "color": ["c"], 

220 "drawstyle": ["ds"], 

221 "linestyle": ["ls"], 

222 "linewidth": ["lw"], 

223 "markeredgecolor": ["mec"], 

224 "markeredgewidth": ["mew"], 

225 "markerfacecolor": ["mfc"], 

226 "markerfacecoloralt": ["mfcalt"], 

227 "markersize": ["ms"], 

228}) 

229class Line2D(Artist): 

230 """ 

231 A line - the line can have both a solid linestyle connecting all 

232 the vertices, and a marker at each vertex. Additionally, the 

233 drawing of the solid line is influenced by the drawstyle, e.g., one 

234 can create "stepped" lines in various styles. 

235 """ 

236 

237 lineStyles = _lineStyles = { # hidden names deprecated 

238 '-': '_draw_solid', 

239 '--': '_draw_dashed', 

240 '-.': '_draw_dash_dot', 

241 ':': '_draw_dotted', 

242 'None': '_draw_nothing', 

243 ' ': '_draw_nothing', 

244 '': '_draw_nothing', 

245 } 

246 

247 _drawStyles_l = { 

248 'default': '_draw_lines', 

249 'steps-mid': '_draw_steps_mid', 

250 'steps-pre': '_draw_steps_pre', 

251 'steps-post': '_draw_steps_post', 

252 } 

253 

254 _drawStyles_s = { 

255 'steps': '_draw_steps_pre', 

256 } 

257 

258 # drawStyles should now be deprecated. 

259 drawStyles = {**_drawStyles_l, **_drawStyles_s} 

260 # Need a list ordered with long names first: 

261 drawStyleKeys = [*_drawStyles_l, *_drawStyles_s] 

262 

263 # Referenced here to maintain API. These are defined in 

264 # MarkerStyle 

265 markers = MarkerStyle.markers 

266 filled_markers = MarkerStyle.filled_markers 

267 fillStyles = MarkerStyle.fillstyles 

268 

269 zorder = 2 

270 

271 _subslice_optim_min_size = 1000 

272 

273 def __str__(self): 

274 if self._label != "": 

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

276 elif self._x is None: 

277 return "Line2D()" 

278 elif len(self._x) > 3: 

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

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

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

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

283 else: 

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

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

286 

287 def __init__(self, xdata, ydata, *, 

288 linewidth=None, # all Nones default to rc 

289 linestyle=None, 

290 color=None, 

291 gapcolor=None, 

292 marker=None, 

293 markersize=None, 

294 markeredgewidth=None, 

295 markeredgecolor=None, 

296 markerfacecolor=None, 

297 markerfacecoloralt='none', 

298 fillstyle=None, 

299 antialiased=None, 

300 dash_capstyle=None, 

301 solid_capstyle=None, 

302 dash_joinstyle=None, 

303 solid_joinstyle=None, 

304 pickradius=5, 

305 drawstyle=None, 

306 markevery=None, 

307 **kwargs 

308 ): 

309 """ 

310 Create a `.Line2D` instance with *x* and *y* data in sequences of 

311 *xdata*, *ydata*. 

312 

313 Additional keyword arguments are `.Line2D` properties: 

314 

315 %(Line2D:kwdoc)s 

316 

317 See :meth:`set_linestyle` for a description of the line styles, 

318 :meth:`set_marker` for a description of the markers, and 

319 :meth:`set_drawstyle` for a description of the draw styles. 

320 

321 """ 

322 super().__init__() 

323 

324 # Convert sequences to NumPy arrays. 

325 if not np.iterable(xdata): 

326 raise RuntimeError('xdata must be a sequence') 

327 if not np.iterable(ydata): 

328 raise RuntimeError('ydata must be a sequence') 

329 

330 if linewidth is None: 

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

332 

333 if linestyle is None: 

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

335 if marker is None: 

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

337 if color is None: 

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

339 

340 if markersize is None: 

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

342 if antialiased is None: 

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

344 if dash_capstyle is None: 

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

346 if dash_joinstyle is None: 

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

348 if solid_capstyle is None: 

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

350 if solid_joinstyle is None: 

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

352 

353 if drawstyle is None: 

354 drawstyle = 'default' 

355 

356 self._dashcapstyle = None 

357 self._dashjoinstyle = None 

358 self._solidjoinstyle = None 

359 self._solidcapstyle = None 

360 self.set_dash_capstyle(dash_capstyle) 

361 self.set_dash_joinstyle(dash_joinstyle) 

362 self.set_solid_capstyle(solid_capstyle) 

363 self.set_solid_joinstyle(solid_joinstyle) 

364 

365 self._linestyles = None 

366 self._drawstyle = None 

367 self._linewidth = linewidth 

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

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

370 

371 self.set_linewidth(linewidth) 

372 self.set_linestyle(linestyle) 

373 self.set_drawstyle(drawstyle) 

374 

375 self._color = None 

376 self.set_color(color) 

377 if marker is None: 

378 marker = 'none' # Default. 

379 if not isinstance(marker, MarkerStyle): 

380 self._marker = MarkerStyle(marker, fillstyle) 

381 else: 

382 self._marker = marker 

383 

384 self._gapcolor = None 

385 self.set_gapcolor(gapcolor) 

386 

387 self._markevery = None 

388 self._markersize = None 

389 self._antialiased = None 

390 

391 self.set_markevery(markevery) 

392 self.set_antialiased(antialiased) 

393 self.set_markersize(markersize) 

394 

395 self._markeredgecolor = None 

396 self._markeredgewidth = None 

397 self._markerfacecolor = None 

398 self._markerfacecoloralt = None 

399 

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

401 self.set_markerfacecoloralt(markerfacecoloralt) 

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

403 self.set_markeredgewidth(markeredgewidth) 

404 

405 # update kwargs before updating data to give the caller a 

406 # chance to init axes (and hence unit support) 

407 self._internal_update(kwargs) 

408 self.pickradius = pickradius 

409 self.ind_offset = 0 

410 if (isinstance(self._picker, Number) and 

411 not isinstance(self._picker, bool)): 

412 self._pickradius = self._picker 

413 

414 self._xorig = np.asarray([]) 

415 self._yorig = np.asarray([]) 

416 self._invalidx = True 

417 self._invalidy = True 

418 self._x = None 

419 self._y = None 

420 self._xy = None 

421 self._path = None 

422 self._transformed_path = None 

423 self._subslice = False 

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

425 

426 self.set_data(xdata, ydata) 

427 

428 def contains(self, mouseevent): 

429 """ 

430 Test whether *mouseevent* occurred on the line. 

431 

432 An event is deemed to have occurred "on" the line if it is less 

433 than ``self.pickradius`` (default: 5 points) away from it. Use 

434 `~.Line2D.get_pickradius` or `~.Line2D.set_pickradius` to get or set 

435 the pick radius. 

436 

437 Parameters 

438 ---------- 

439 mouseevent : `~matplotlib.backend_bases.MouseEvent` 

440 

441 Returns 

442 ------- 

443 contains : bool 

444 Whether any values are within the radius. 

445 details : dict 

446 A dictionary ``{'ind': pointlist}``, where *pointlist* is a 

447 list of points of the line that are within the pickradius around 

448 the event position. 

449 

450 TODO: sort returned indices by distance 

451 """ 

452 if self._different_canvas(mouseevent): 

453 return False, {} 

454 

455 # Make sure we have data to plot 

456 if self._invalidy or self._invalidx: 

457 self.recache() 

458 if len(self._xy) == 0: 

459 return False, {} 

460 

461 # Convert points to pixels 

462 transformed_path = self._get_transformed_path() 

463 path, affine = transformed_path.get_transformed_path_and_affine() 

464 path = affine.transform_path(path) 

465 xy = path.vertices 

466 xt = xy[:, 0] 

467 yt = xy[:, 1] 

468 

469 # Convert pick radius from points to pixels 

470 if self.figure is None: 

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

472 pixels = self._pickradius 

473 else: 

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

475 

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

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

478 # the error flags accordingly. 

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

480 # Check for collision 

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

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

483 ind, = np.nonzero( 

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

485 <= pixels ** 2) 

486 else: 

487 # If line, return the nearby segment(s) 

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

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

490 ind //= 2 

491 

492 ind += self.ind_offset 

493 

494 # Return the point(s) within radius 

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

496 

497 def get_pickradius(self): 

498 """ 

499 Return the pick radius used for containment tests. 

500 

501 See `.contains` for more details. 

502 """ 

503 return self._pickradius 

504 

505 def set_pickradius(self, pickradius): 

506 """ 

507 Set the pick radius used for containment tests. 

508 

509 See `.contains` for more details. 

510 

511 Parameters 

512 ---------- 

513 pickradius : float 

514 Pick radius, in points. 

515 """ 

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

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

518 self._pickradius = pickradius 

519 

520 pickradius = property(get_pickradius, set_pickradius) 

521 

522 def get_fillstyle(self): 

523 """ 

524 Return the marker fill style. 

525 

526 See also `~.Line2D.set_fillstyle`. 

527 """ 

528 return self._marker.get_fillstyle() 

529 

530 def set_fillstyle(self, fs): 

531 """ 

532 Set the marker fill style. 

533 

534 Parameters 

535 ---------- 

536 fs : {'full', 'left', 'right', 'bottom', 'top', 'none'} 

537 Possible values: 

538 

539 - 'full': Fill the whole marker with the *markerfacecolor*. 

540 - 'left', 'right', 'bottom', 'top': Fill the marker half at 

541 the given side with the *markerfacecolor*. The other 

542 half of the marker is filled with *markerfacecoloralt*. 

543 - 'none': No filling. 

544 

545 For examples see :ref:`marker_fill_styles`. 

546 """ 

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

548 self.stale = True 

549 

550 def set_markevery(self, every): 

551 """ 

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

553 

554 e.g., if ``every=5``, every 5-th marker will be plotted. 

555 

556 Parameters 

557 ---------- 

558 every : None or int or (int, int) or slice or list[int] or float or \ 

559(float, float) or list[bool] 

560 Which markers to plot. 

561 

562 - ``every=None``: every point will be plotted. 

563 - ``every=N``: every N-th marker will be plotted starting with 

564 marker 0. 

565 - ``every=(start, N)``: every N-th marker, starting at index 

566 *start*, will be plotted. 

567 - ``every=slice(start, end, N)``: every N-th marker, starting at 

568 index *start*, up to but not including index *end*, will be 

569 plotted. 

570 - ``every=[i, j, m, ...]``: only markers at the given indices 

571 will be plotted. 

572 - ``every=[True, False, True, ...]``: only positions that are True 

573 will be plotted. The list must have the same length as the data 

574 points. 

575 - ``every=0.1``, (i.e. a float): markers will be spaced at 

576 approximately equal visual distances along the line; the distance 

577 along the line between markers is determined by multiplying the 

578 display-coordinate distance of the Axes bounding-box diagonal 

579 by the value of *every*. 

580 - ``every=(0.5, 0.1)`` (i.e. a length-2 tuple of float): similar 

581 to ``every=0.1`` but the first marker will be offset along the 

582 line by 0.5 multiplied by the 

583 display-coordinate-diagonal-distance along the line. 

584 

585 For examples see 

586 :doc:`/gallery/lines_bars_and_markers/markevery_demo`. 

587 

588 Notes 

589 ----- 

590 Setting *markevery* will still only draw markers at actual data points. 

591 While the float argument form aims for uniform visual spacing, it has 

592 to coerce from the ideal spacing to the nearest available data point. 

593 Depending on the number and distribution of data points, the result 

594 may still not look evenly spaced. 

595 

596 When using a start offset to specify the first marker, the offset will 

597 be from the first data point which may be different from the first 

598 the visible data point if the plot is zoomed in. 

599 

600 If zooming in on a plot when using float arguments then the actual 

601 data points that have markers will change because the distance between 

602 markers is always determined from the display-coordinates 

603 axes-bounding-box-diagonal regardless of the actual axes data limits. 

604 

605 """ 

606 self._markevery = every 

607 self.stale = True 

608 

609 def get_markevery(self): 

610 """ 

611 Return the markevery setting for marker subsampling. 

612 

613 See also `~.Line2D.set_markevery`. 

614 """ 

615 return self._markevery 

616 

617 def set_picker(self, p): 

618 """ 

619 Set the event picker details for the line. 

620 

621 Parameters 

622 ---------- 

623 p : float or callable[[Artist, Event], tuple[bool, dict]] 

624 If a float, it is used as the pick radius in points. 

625 """ 

626 if not callable(p): 

627 self.set_pickradius(p) 

628 self._picker = p 

629 

630 def get_bbox(self): 

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

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

633 bbox.update_from_data_xy(self.get_xydata()) 

634 return bbox 

635 

636 def get_window_extent(self, renderer=None): 

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

638 trans_data_to_xy = self.get_transform().transform 

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

640 ignore=True) 

641 # correct for marker size, if any 

642 if self._marker: 

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

644 bbox = bbox.padded(ms) 

645 return bbox 

646 

647 def set_data(self, *args): 

648 """ 

649 Set the x and y data. 

650 

651 Parameters 

652 ---------- 

653 *args : (2, N) array or two 1D arrays 

654 

655 See Also 

656 -------- 

657 set_xdata 

658 set_ydata 

659 """ 

660 if len(args) == 1: 

661 (x, y), = args 

662 else: 

663 x, y = args 

664 

665 self.set_xdata(x) 

666 self.set_ydata(y) 

667 

668 def recache_always(self): 

669 self.recache(always=True) 

670 

671 def recache(self, always=False): 

672 if always or self._invalidx: 

673 xconv = self.convert_xunits(self._xorig) 

674 x = _to_unmasked_float_array(xconv).ravel() 

675 else: 

676 x = self._x 

677 if always or self._invalidy: 

678 yconv = self.convert_yunits(self._yorig) 

679 y = _to_unmasked_float_array(yconv).ravel() 

680 else: 

681 y = self._y 

682 

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

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

685 

686 self._subslice = False 

687 if (self.axes 

688 and len(x) > self._subslice_optim_min_size 

689 and _path.is_sorted_and_has_non_nan(x) 

690 and self.axes.name == 'rectilinear' 

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

692 and self._markevery is None 

693 and self.get_clip_on() 

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

695 self._subslice = True 

696 nanmask = np.isnan(x) 

697 if nanmask.any(): 

698 self._x_filled = self._x.copy() 

699 indices = np.arange(len(x)) 

700 self._x_filled[nanmask] = np.interp( 

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

702 else: 

703 self._x_filled = self._x 

704 

705 if self._path is not None: 

706 interpolation_steps = self._path._interpolation_steps 

707 else: 

708 interpolation_steps = 1 

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

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

711 _interpolation_steps=interpolation_steps) 

712 self._transformed_path = None 

713 self._invalidx = False 

714 self._invalidy = False 

715 

716 def _transform_path(self, subslice=None): 

717 """ 

718 Put a TransformedPath instance at self._transformed_path; 

719 all invalidation of the transform is then handled by the 

720 TransformedPath instance. 

721 """ 

722 # Masked arrays are now handled by the Path class itself 

723 if subslice is not None: 

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

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

726 _interpolation_steps=self._path._interpolation_steps) 

727 else: 

728 _path = self._path 

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

730 

731 def _get_transformed_path(self): 

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

733 if self._transformed_path is None: 

734 self._transform_path() 

735 return self._transformed_path 

736 

737 def set_transform(self, t): 

738 # docstring inherited 

739 self._invalidx = True 

740 self._invalidy = True 

741 super().set_transform(t) 

742 

743 @allow_rasterization 

744 def draw(self, renderer): 

745 # docstring inherited 

746 

747 if not self.get_visible(): 

748 return 

749 

750 if self._invalidy or self._invalidx: 

751 self.recache() 

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

753 if self._subslice and self.axes: 

754 x0, x1 = self.axes.get_xbound() 

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

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

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

758 self.ind_offset = subslice.start 

759 self._transform_path(subslice) 

760 else: 

761 subslice = None 

762 

763 if self.get_path_effects(): 

764 from matplotlib.patheffects import PathEffectRenderer 

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

766 

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

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

769 tpath, affine = (self._get_transformed_path() 

770 .get_transformed_path_and_affine()) 

771 if len(tpath.vertices): 

772 gc = renderer.new_gc() 

773 self._set_gc_clip(gc) 

774 gc.set_url(self.get_url()) 

775 

776 gc.set_antialiased(self._antialiased) 

777 gc.set_linewidth(self._linewidth) 

778 

779 if self.is_dashed(): 

780 cap = self._dashcapstyle 

781 join = self._dashjoinstyle 

782 else: 

783 cap = self._solidcapstyle 

784 join = self._solidjoinstyle 

785 gc.set_joinstyle(join) 

786 gc.set_capstyle(cap) 

787 gc.set_snap(self.get_snap()) 

788 if self.get_sketch_params() is not None: 

789 gc.set_sketch_params(*self.get_sketch_params()) 

790 

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

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

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

794 gc.set_foreground(lc_rgba, isRGBA=True) 

795 

796 offset_gaps, gaps = _get_inverse_dash_pattern( 

797 *self._dash_pattern) 

798 

799 gc.set_dashes(offset_gaps, gaps) 

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

801 

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

803 gc.set_foreground(lc_rgba, isRGBA=True) 

804 

805 gc.set_dashes(*self._dash_pattern) 

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

807 gc.restore() 

808 

809 if self._marker and self._markersize > 0: 

810 gc = renderer.new_gc() 

811 self._set_gc_clip(gc) 

812 gc.set_url(self.get_url()) 

813 gc.set_linewidth(self._markeredgewidth) 

814 gc.set_antialiased(self._antialiased) 

815 

816 ec_rgba = mcolors.to_rgba( 

817 self.get_markeredgecolor(), self._alpha) 

818 fc_rgba = mcolors.to_rgba( 

819 self._get_markerfacecolor(), self._alpha) 

820 fcalt_rgba = mcolors.to_rgba( 

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

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

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

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

825 and not cbook._str_lower_equal( 

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

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

828 gc.set_foreground(ec_rgba, isRGBA=True) 

829 if self.get_sketch_params() is not None: 

830 scale, length, randomness = self.get_sketch_params() 

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

832 

833 marker = self._marker 

834 

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

836 # recaching if drawstyle is already "default").