|
|
r""" |
|
|
Functions to handle markers; used by the marker functionality of |
|
|
`~matplotlib.axes.Axes.plot`, `~matplotlib.axes.Axes.scatter`, and |
|
|
`~matplotlib.axes.Axes.errorbar`. |
|
|
|
|
|
All possible markers are defined here: |
|
|
|
|
|
============================== ====== ========================================= |
|
|
marker symbol description |
|
|
============================== ====== ========================================= |
|
|
``"."`` |m00| point |
|
|
``","`` |m01| pixel |
|
|
``"o"`` |m02| circle |
|
|
``"v"`` |m03| triangle_down |
|
|
``"^"`` |m04| triangle_up |
|
|
``"<"`` |m05| triangle_left |
|
|
``">"`` |m06| triangle_right |
|
|
``"1"`` |m07| tri_down |
|
|
``"2"`` |m08| tri_up |
|
|
``"3"`` |m09| tri_left |
|
|
``"4"`` |m10| tri_right |
|
|
``"8"`` |m11| octagon |
|
|
``"s"`` |m12| square |
|
|
``"p"`` |m13| pentagon |
|
|
``"P"`` |m23| plus (filled) |
|
|
``"*"`` |m14| star |
|
|
``"h"`` |m15| hexagon1 |
|
|
``"H"`` |m16| hexagon2 |
|
|
``"+"`` |m17| plus |
|
|
``"x"`` |m18| x |
|
|
``"X"`` |m24| x (filled) |
|
|
``"D"`` |m19| diamond |
|
|
``"d"`` |m20| thin_diamond |
|
|
``"|"`` |m21| vline |
|
|
``"_"`` |m22| hline |
|
|
``0`` (``TICKLEFT``) |m25| tickleft |
|
|
``1`` (``TICKRIGHT``) |m26| tickright |
|
|
``2`` (``TICKUP``) |m27| tickup |
|
|
``3`` (``TICKDOWN``) |m28| tickdown |
|
|
``4`` (``CARETLEFT``) |m29| caretleft |
|
|
``5`` (``CARETRIGHT``) |m30| caretright |
|
|
``6`` (``CARETUP``) |m31| caretup |
|
|
``7`` (``CARETDOWN``) |m32| caretdown |
|
|
``8`` (``CARETLEFTBASE``) |m33| caretleft (centered at base) |
|
|
``9`` (``CARETRIGHTBASE``) |m34| caretright (centered at base) |
|
|
``10`` (``CARETUPBASE``) |m35| caretup (centered at base) |
|
|
``11`` (``CARETDOWNBASE``) |m36| caretdown (centered at base) |
|
|
``"none"`` or ``"None"`` nothing |
|
|
``" "`` or ``""`` nothing |
|
|
``"$...$"`` |m37| Render the string using mathtext. |
|
|
E.g ``"$f$"`` for marker showing the |
|
|
letter ``f``. |
|
|
``verts`` A list of (x, y) pairs used for Path |
|
|
vertices. The center of the marker is |
|
|
located at (0, 0) and the size is |
|
|
normalized, such that the created path |
|
|
is encapsulated inside the unit cell. |
|
|
``path`` A `~matplotlib.path.Path` instance. |
|
|
``(numsides, 0, angle)`` A regular polygon with ``numsides`` |
|
|
sides, rotated by ``angle``. |
|
|
``(numsides, 1, angle)`` A star-like symbol with ``numsides`` |
|
|
sides, rotated by ``angle``. |
|
|
``(numsides, 2, angle)`` An asterisk with ``numsides`` sides, |
|
|
rotated by ``angle``. |
|
|
============================== ====== ========================================= |
|
|
|
|
|
Note that special symbols can be defined via the |
|
|
:ref:`STIX math font <mathtext>`, |
|
|
e.g. ``"$\u266B$"``. For an overview over the STIX font symbols refer to the |
|
|
`STIX font table <http://www.stixfonts.org/allGlyphs.html>`_. |
|
|
Also see the :doc:`/gallery/text_labels_and_annotations/stix_fonts_demo`. |
|
|
|
|
|
Integer numbers from ``0`` to ``11`` create lines and triangles. Those are |
|
|
equally accessible via capitalized variables, like ``CARETDOWNBASE``. |
|
|
Hence the following are equivalent:: |
|
|
|
|
|
plt.plot([1, 2, 3], marker=11) |
|
|
plt.plot([1, 2, 3], marker=matplotlib.markers.CARETDOWNBASE) |
|
|
|
|
|
Markers join and cap styles can be customized by creating a new instance of |
|
|
MarkerStyle. |
|
|
A MarkerStyle can also have a custom `~matplotlib.transforms.Transform` |
|
|
allowing it to be arbitrarily rotated or offset. |
|
|
|
|
|
Examples showing the use of markers: |
|
|
|
|
|
* :doc:`/gallery/lines_bars_and_markers/marker_reference` |
|
|
* :doc:`/gallery/lines_bars_and_markers/scatter_star_poly` |
|
|
* :doc:`/gallery/lines_bars_and_markers/multivariate_marker_plot` |
|
|
|
|
|
.. |m00| image:: /_static/markers/m00.png |
|
|
.. |m01| image:: /_static/markers/m01.png |
|
|
.. |m02| image:: /_static/markers/m02.png |
|
|
.. |m03| image:: /_static/markers/m03.png |
|
|
.. |m04| image:: /_static/markers/m04.png |
|
|
.. |m05| image:: /_static/markers/m05.png |
|
|
.. |m06| image:: /_static/markers/m06.png |
|
|
.. |m07| image:: /_static/markers/m07.png |
|
|
.. |m08| image:: /_static/markers/m08.png |
|
|
.. |m09| image:: /_static/markers/m09.png |
|
|
.. |m10| image:: /_static/markers/m10.png |
|
|
.. |m11| image:: /_static/markers/m11.png |
|
|
.. |m12| image:: /_static/markers/m12.png |
|
|
.. |m13| image:: /_static/markers/m13.png |
|
|
.. |m14| image:: /_static/markers/m14.png |
|
|
.. |m15| image:: /_static/markers/m15.png |
|
|
.. |m16| image:: /_static/markers/m16.png |
|
|
.. |m17| image:: /_static/markers/m17.png |
|
|
.. |m18| image:: /_static/markers/m18.png |
|
|
.. |m19| image:: /_static/markers/m19.png |
|
|
.. |m20| image:: /_static/markers/m20.png |
|
|
.. |m21| image:: /_static/markers/m21.png |
|
|
.. |m22| image:: /_static/markers/m22.png |
|
|
.. |m23| image:: /_static/markers/m23.png |
|
|
.. |m24| image:: /_static/markers/m24.png |
|
|
.. |m25| image:: /_static/markers/m25.png |
|
|
.. |m26| image:: /_static/markers/m26.png |
|
|
.. |m27| image:: /_static/markers/m27.png |
|
|
.. |m28| image:: /_static/markers/m28.png |
|
|
.. |m29| image:: /_static/markers/m29.png |
|
|
.. |m30| image:: /_static/markers/m30.png |
|
|
.. |m31| image:: /_static/markers/m31.png |
|
|
.. |m32| image:: /_static/markers/m32.png |
|
|
.. |m33| image:: /_static/markers/m33.png |
|
|
.. |m34| image:: /_static/markers/m34.png |
|
|
.. |m35| image:: /_static/markers/m35.png |
|
|
.. |m36| image:: /_static/markers/m36.png |
|
|
.. |m37| image:: /_static/markers/m37.png |
|
|
""" |
|
|
import copy |
|
|
|
|
|
from collections.abc import Sized |
|
|
|
|
|
import numpy as np |
|
|
|
|
|
import matplotlib as mpl |
|
|
from . import _api, cbook |
|
|
from .path import Path |
|
|
from .transforms import IdentityTransform, Affine2D |
|
|
from ._enums import JoinStyle, CapStyle |
|
|
|
|
|
|
|
|
(TICKLEFT, TICKRIGHT, TICKUP, TICKDOWN, |
|
|
CARETLEFT, CARETRIGHT, CARETUP, CARETDOWN, |
|
|
CARETLEFTBASE, CARETRIGHTBASE, CARETUPBASE, CARETDOWNBASE) = range(12) |
|
|
|
|
|
_empty_path = Path(np.empty((0, 2))) |
|
|
|
|
|
|
|
|
class MarkerStyle: |
|
|
""" |
|
|
A class representing marker types. |
|
|
|
|
|
Instances are immutable. If you need to change anything, create a new |
|
|
instance. |
|
|
|
|
|
Attributes |
|
|
---------- |
|
|
markers : dict |
|
|
All known markers. |
|
|
filled_markers : tuple |
|
|
All known filled markers. This is a subset of *markers*. |
|
|
fillstyles : tuple |
|
|
The supported fillstyles. |
|
|
""" |
|
|
|
|
|
markers = { |
|
|
'.': 'point', |
|
|
',': 'pixel', |
|
|
'o': 'circle', |
|
|
'v': 'triangle_down', |
|
|
'^': 'triangle_up', |
|
|
'<': 'triangle_left', |
|
|
'>': 'triangle_right', |
|
|
'1': 'tri_down', |
|
|
'2': 'tri_up', |
|
|
'3': 'tri_left', |
|
|
'4': 'tri_right', |
|
|
'8': 'octagon', |
|
|
's': 'square', |
|
|
'p': 'pentagon', |
|
|
'*': 'star', |
|
|
'h': 'hexagon1', |
|
|
'H': 'hexagon2', |
|
|
'+': 'plus', |
|
|
'x': 'x', |
|
|
'D': 'diamond', |
|
|
'd': 'thin_diamond', |
|
|
'|': 'vline', |
|
|
'_': 'hline', |
|
|
'P': 'plus_filled', |
|
|
'X': 'x_filled', |
|
|
TICKLEFT: 'tickleft', |
|
|
TICKRIGHT: 'tickright', |
|
|
TICKUP: 'tickup', |
|
|
TICKDOWN: 'tickdown', |
|
|
CARETLEFT: 'caretleft', |
|
|
CARETRIGHT: 'caretright', |
|
|
CARETUP: 'caretup', |
|
|
CARETDOWN: 'caretdown', |
|
|
CARETLEFTBASE: 'caretleftbase', |
|
|
CARETRIGHTBASE: 'caretrightbase', |
|
|
CARETUPBASE: 'caretupbase', |
|
|
CARETDOWNBASE: 'caretdownbase', |
|
|
"None": 'nothing', |
|
|
"none": 'nothing', |
|
|
' ': 'nothing', |
|
|
'': 'nothing' |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
filled_markers = ( |
|
|
'.', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd', |
|
|
'P', 'X') |
|
|
|
|
|
fillstyles = ('full', 'left', 'right', 'bottom', 'top', 'none') |
|
|
_half_fillstyles = ('left', 'right', 'bottom', 'top') |
|
|
|
|
|
def __init__(self, marker, |
|
|
fillstyle=None, transform=None, capstyle=None, joinstyle=None): |
|
|
""" |
|
|
Parameters |
|
|
---------- |
|
|
marker : str, array-like, Path, MarkerStyle |
|
|
- Another instance of `MarkerStyle` copies the details of that *marker*. |
|
|
- For other possible marker values, see the module docstring |
|
|
`matplotlib.markers`. |
|
|
|
|
|
fillstyle : str, default: :rc:`markers.fillstyle` |
|
|
One of 'full', 'left', 'right', 'bottom', 'top', 'none'. |
|
|
|
|
|
transform : `~matplotlib.transforms.Transform`, optional |
|
|
Transform that will be combined with the native transform of the |
|
|
marker. |
|
|
|
|
|
capstyle : `.CapStyle` or %(CapStyle)s, optional |
|
|
Cap style that will override the default cap style of the marker. |
|
|
|
|
|
joinstyle : `.JoinStyle` or %(JoinStyle)s, optional |
|
|
Join style that will override the default join style of the marker. |
|
|
""" |
|
|
self._marker_function = None |
|
|
self._user_transform = transform |
|
|
self._user_capstyle = CapStyle(capstyle) if capstyle is not None else None |
|
|
self._user_joinstyle = JoinStyle(joinstyle) if joinstyle is not None else None |
|
|
self._set_fillstyle(fillstyle) |
|
|
self._set_marker(marker) |
|
|
|
|
|
def _recache(self): |
|
|
if self._marker_function is None: |
|
|
return |
|
|
self._path = _empty_path |
|
|
self._transform = IdentityTransform() |
|
|
self._alt_path = None |
|
|
self._alt_transform = None |
|
|
self._snap_threshold = None |
|
|
self._joinstyle = JoinStyle.round |
|
|
self._capstyle = self._user_capstyle or CapStyle.butt |
|
|
|
|
|
|
|
|
|
|
|
self._filled = self._fillstyle != 'none' |
|
|
self._marker_function() |
|
|
|
|
|
def __bool__(self): |
|
|
return bool(len(self._path.vertices)) |
|
|
|
|
|
def is_filled(self): |
|
|
return self._filled |
|
|
|
|
|
def get_fillstyle(self): |
|
|
return self._fillstyle |
|
|
|
|
|
def _set_fillstyle(self, fillstyle): |
|
|
""" |
|
|
Set the fillstyle. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
fillstyle : {'full', 'left', 'right', 'bottom', 'top', 'none'} |
|
|
The part of the marker surface that is colored with |
|
|
markerfacecolor. |
|
|
""" |
|
|
if fillstyle is None: |
|
|
fillstyle = mpl.rcParams['markers.fillstyle'] |
|
|
_api.check_in_list(self.fillstyles, fillstyle=fillstyle) |
|
|
self._fillstyle = fillstyle |
|
|
|
|
|
def get_joinstyle(self): |
|
|
return self._joinstyle.name |
|
|
|
|
|
def get_capstyle(self): |
|
|
return self._capstyle.name |
|
|
|
|
|
def get_marker(self): |
|
|
return self._marker |
|
|
|
|
|
def _set_marker(self, marker): |
|
|
""" |
|
|
Set the marker. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
marker : str, array-like, Path, MarkerStyle |
|
|
- Another instance of `MarkerStyle` copies the details of that *marker*. |
|
|
- For other possible marker values see the module docstring |
|
|
`matplotlib.markers`. |
|
|
""" |
|
|
if isinstance(marker, str) and cbook.is_math_text(marker): |
|
|
self._marker_function = self._set_mathtext_path |
|
|
elif isinstance(marker, (int, str)) and marker in self.markers: |
|
|
self._marker_function = getattr(self, '_set_' + self.markers[marker]) |
|
|
elif (isinstance(marker, np.ndarray) and marker.ndim == 2 and |
|
|
marker.shape[1] == 2): |
|
|
self._marker_function = self._set_vertices |
|
|
elif isinstance(marker, Path): |
|
|
self._marker_function = self._set_path_marker |
|
|
elif (isinstance(marker, Sized) and len(marker) in (2, 3) and |
|
|
marker[1] in (0, 1, 2)): |
|
|
self._marker_function = self._set_tuple_marker |
|
|
elif isinstance(marker, MarkerStyle): |
|
|
self.__dict__ = copy.deepcopy(marker.__dict__) |
|
|
else: |
|
|
try: |
|
|
Path(marker) |
|
|
self._marker_function = self._set_vertices |
|
|
except ValueError as err: |
|
|
raise ValueError( |
|
|
f'Unrecognized marker style {marker!r}') from err |
|
|
|
|
|
if not isinstance(marker, MarkerStyle): |
|
|
self._marker = marker |
|
|
self._recache() |
|
|
|
|
|
def get_path(self): |
|
|
""" |
|
|
Return a `.Path` for the primary part of the marker. |
|
|
|
|
|
For unfilled markers this is the whole marker, for filled markers, |
|
|
this is the area to be drawn with *markerfacecolor*. |
|
|
""" |
|
|
return self._path |
|
|
|
|
|
def get_transform(self): |
|
|
""" |
|
|
Return the transform to be applied to the `.Path` from |
|
|
`MarkerStyle.get_path()`. |
|
|
""" |
|
|
if self._user_transform is None: |
|
|
return self._transform.frozen() |
|
|
else: |
|
|
return (self._transform + self._user_transform).frozen() |
|
|
|
|
|
def get_alt_path(self): |
|
|
""" |
|
|
Return a `.Path` for the alternate part of the marker. |
|
|
|
|
|
For unfilled markers, this is *None*; for filled markers, this is the |
|
|
area to be drawn with *markerfacecoloralt*. |
|
|
""" |
|
|
return self._alt_path |
|
|
|
|
|
def get_alt_transform(self): |
|
|
""" |
|
|
Return the transform to be applied to the `.Path` from |
|
|
`MarkerStyle.get_alt_path()`. |
|
|
""" |
|
|
if self._user_transform is None: |
|
|
return self._alt_transform.frozen() |
|
|
else: |
|
|
return (self._alt_transform + self._user_transform).frozen() |
|
|
|
|
|
def get_snap_threshold(self): |
|
|
return self._snap_threshold |
|
|
|
|
|
def get_user_transform(self): |
|
|
"""Return user supplied part of marker transform.""" |
|
|
if self._user_transform is not None: |
|
|
return self._user_transform.frozen() |
|
|
|
|
|
def transformed(self, transform): |
|
|
""" |
|
|
Return a new version of this marker with the transform applied. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
transform : `~matplotlib.transforms.Affine2D` |
|
|
Transform will be combined with current user supplied transform. |
|
|
""" |
|
|
new_marker = MarkerStyle(self) |
|
|
if new_marker._user_transform is not None: |
|
|
new_marker._user_transform += transform |
|
|
else: |
|
|
new_marker._user_transform = transform |
|
|
return new_marker |
|
|
|
|
|
def rotated(self, *, deg=None, rad=None): |
|
|
""" |
|
|
Return a new version of this marker rotated by specified angle. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
deg : float, optional |
|
|
Rotation angle in degrees. |
|
|
|
|
|
rad : float, optional |
|
|
Rotation angle in radians. |
|
|
|
|
|
.. note:: You must specify exactly one of deg or rad. |
|
|
""" |
|
|
if deg is None and rad is None: |
|
|
raise ValueError('One of deg or rad is required') |
|
|
if deg is not None and rad is not None: |
|
|
raise ValueError('Only one of deg and rad can be supplied') |
|
|
new_marker = MarkerStyle(self) |
|
|
if new_marker._user_transform is None: |
|
|
new_marker._user_transform = Affine2D() |
|
|
|
|
|
if deg is not None: |
|
|
new_marker._user_transform.rotate_deg(deg) |
|
|
if rad is not None: |
|
|
new_marker._user_transform.rotate(rad) |
|
|
|
|
|
return new_marker |
|
|
|
|
|
def scaled(self, sx, sy=None): |
|
|
""" |
|
|
Return new marker scaled by specified scale factors. |
|
|
|
|
|
If *sy* is not given, the same scale is applied in both the *x*- and |
|
|
*y*-directions. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
sx : float |
|
|
*X*-direction scaling factor. |
|
|
sy : float, optional |
|
|
*Y*-direction scaling factor. |
|
|
""" |
|
|
if sy is None: |
|
|
sy = sx |
|
|
|
|
|
new_marker = MarkerStyle(self) |
|
|
_transform = new_marker._user_transform or Affine2D() |
|
|
new_marker._user_transform = _transform.scale(sx, sy) |
|
|
return new_marker |
|
|
|
|
|
def _set_nothing(self): |
|
|
self._filled = False |
|
|
|
|
|
def _set_custom_marker(self, path): |
|
|
rescale = np.max(np.abs(path.vertices)) |
|
|
self._transform = Affine2D().scale(0.5 / rescale) |
|
|
self._path = path |
|
|
|
|
|
def _set_path_marker(self): |
|
|
self._set_custom_marker(self._marker) |
|
|
|
|
|
def _set_vertices(self): |
|
|
self._set_custom_marker(Path(self._marker)) |
|
|
|
|
|
def _set_tuple_marker(self): |
|
|
marker = self._marker |
|
|
if len(marker) == 2: |
|
|
numsides, rotation = marker[0], 0.0 |
|
|
elif len(marker) == 3: |
|
|
numsides, rotation = marker[0], marker[2] |
|
|
symstyle = marker[1] |
|
|
if symstyle == 0: |
|
|
self._path = Path.unit_regular_polygon(numsides) |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
elif symstyle == 1: |
|
|
self._path = Path.unit_regular_star(numsides) |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.bevel |
|
|
elif symstyle == 2: |
|
|
self._path = Path.unit_regular_asterisk(numsides) |
|
|
self._filled = False |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.bevel |
|
|
else: |
|
|
raise ValueError(f"Unexpected tuple marker: {marker}") |
|
|
self._transform = Affine2D().scale(0.5).rotate_deg(rotation) |
|
|
|
|
|
def _set_mathtext_path(self): |
|
|
""" |
|
|
Draw mathtext markers '$...$' using `.TextPath` object. |
|
|
|
|
|
Submitted by tcb |
|
|
""" |
|
|
from matplotlib.text import TextPath |
|
|
|
|
|
|
|
|
|
|
|
text = TextPath(xy=(0, 0), s=self.get_marker(), |
|
|
usetex=mpl.rcParams['text.usetex']) |
|
|
if len(text.vertices) == 0: |
|
|
return |
|
|
|
|
|
bbox = text.get_extents() |
|
|
max_dim = max(bbox.width, bbox.height) |
|
|
self._transform = ( |
|
|
Affine2D() |
|
|
.translate(-bbox.xmin + 0.5 * -bbox.width, -bbox.ymin + 0.5 * -bbox.height) |
|
|
.scale(1.0 / max_dim)) |
|
|
self._path = text |
|
|
self._snap = False |
|
|
|
|
|
def _half_fill(self): |
|
|
return self.get_fillstyle() in self._half_fillstyles |
|
|
|
|
|
def _set_circle(self, size=1.0): |
|
|
self._transform = Affine2D().scale(0.5 * size) |
|
|
self._snap_threshold = np.inf |
|
|
if not self._half_fill(): |
|
|
self._path = Path.unit_circle() |
|
|
else: |
|
|
self._path = self._alt_path = Path.unit_circle_righthalf() |
|
|
fs = self.get_fillstyle() |
|
|
self._transform.rotate_deg( |
|
|
{'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs]) |
|
|
self._alt_transform = self._transform.frozen().rotate_deg(180.) |
|
|
|
|
|
def _set_point(self): |
|
|
self._set_circle(size=0.5) |
|
|
|
|
|
def _set_pixel(self): |
|
|
self._path = Path.unit_rectangle() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
self._transform = Affine2D().translate(-0.49999, -0.49999) |
|
|
self._snap_threshold = None |
|
|
|
|
|
_triangle_path = Path._create_closed([[0, 1], [-1, -1], [1, -1]]) |
|
|
|
|
|
_triangle_path_u = Path._create_closed([[0, 1], [-3/5, -1/5], [3/5, -1/5]]) |
|
|
_triangle_path_d = Path._create_closed( |
|
|
[[-3/5, -1/5], [3/5, -1/5], [1, -1], [-1, -1]]) |
|
|
_triangle_path_l = Path._create_closed([[0, 1], [0, -1], [-1, -1]]) |
|
|
_triangle_path_r = Path._create_closed([[0, 1], [0, -1], [1, -1]]) |
|
|
|
|
|
def _set_triangle(self, rot, skip): |
|
|
self._transform = Affine2D().scale(0.5).rotate_deg(rot) |
|
|
self._snap_threshold = 5.0 |
|
|
|
|
|
if not self._half_fill(): |
|
|
self._path = self._triangle_path |
|
|
else: |
|
|
mpaths = [self._triangle_path_u, |
|
|
self._triangle_path_l, |
|
|
self._triangle_path_d, |
|
|
self._triangle_path_r] |
|
|
|
|
|
fs = self.get_fillstyle() |
|
|
if fs == 'top': |
|
|
self._path = mpaths[(0 + skip) % 4] |
|
|
self._alt_path = mpaths[(2 + skip) % 4] |
|
|
elif fs == 'bottom': |
|
|
self._path = mpaths[(2 + skip) % 4] |
|
|
self._alt_path = mpaths[(0 + skip) % 4] |
|
|
elif fs == 'left': |
|
|
self._path = mpaths[(1 + skip) % 4] |
|
|
self._alt_path = mpaths[(3 + skip) % 4] |
|
|
else: |
|
|
self._path = mpaths[(3 + skip) % 4] |
|
|
self._alt_path = mpaths[(1 + skip) % 4] |
|
|
|
|
|
self._alt_transform = self._transform |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_triangle_up(self): |
|
|
return self._set_triangle(0.0, 0) |
|
|
|
|
|
def _set_triangle_down(self): |
|
|
return self._set_triangle(180.0, 2) |
|
|
|
|
|
def _set_triangle_left(self): |
|
|
return self._set_triangle(90.0, 3) |
|
|
|
|
|
def _set_triangle_right(self): |
|
|
return self._set_triangle(270.0, 1) |
|
|
|
|
|
def _set_square(self): |
|
|
self._transform = Affine2D().translate(-0.5, -0.5) |
|
|
self._snap_threshold = 2.0 |
|
|
if not self._half_fill(): |
|
|
self._path = Path.unit_rectangle() |
|
|
else: |
|
|
|
|
|
self._path = Path([[0.0, 0.0], [1.0, 0.0], [1.0, 0.5], |
|
|
[0.0, 0.5], [0.0, 0.0]]) |
|
|
self._alt_path = Path([[0.0, 0.5], [1.0, 0.5], [1.0, 1.0], |
|
|
[0.0, 1.0], [0.0, 0.5]]) |
|
|
fs = self.get_fillstyle() |
|
|
rotate = {'bottom': 0, 'right': 90, 'top': 180, 'left': 270}[fs] |
|
|
self._transform.rotate_deg(rotate) |
|
|
self._alt_transform = self._transform |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_diamond(self): |
|
|
self._transform = Affine2D().translate(-0.5, -0.5).rotate_deg(45) |
|
|
self._snap_threshold = 5.0 |
|
|
if not self._half_fill(): |
|
|
self._path = Path.unit_rectangle() |
|
|
else: |
|
|
self._path = Path([[0, 0], [1, 0], [1, 1], [0, 0]]) |
|
|
self._alt_path = Path([[0, 0], [0, 1], [1, 1], [0, 0]]) |
|
|
fs = self.get_fillstyle() |
|
|
rotate = {'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs] |
|
|
self._transform.rotate_deg(rotate) |
|
|
self._alt_transform = self._transform |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_thin_diamond(self): |
|
|
self._set_diamond() |
|
|
self._transform.scale(0.6, 1.0) |
|
|
|
|
|
def _set_pentagon(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 5.0 |
|
|
|
|
|
polypath = Path.unit_regular_polygon(5) |
|
|
|
|
|
if not self._half_fill(): |
|
|
self._path = polypath |
|
|
else: |
|
|
verts = polypath.vertices |
|
|
y = (1 + np.sqrt(5)) / 4. |
|
|
top = Path(verts[[0, 1, 4, 0]]) |
|
|
bottom = Path(verts[[1, 2, 3, 4, 1]]) |
|
|
left = Path([verts[0], verts[1], verts[2], [0, -y], verts[0]]) |
|
|
right = Path([verts[0], verts[4], verts[3], [0, -y], verts[0]]) |
|
|
self._path, self._alt_path = { |
|
|
'top': (top, bottom), 'bottom': (bottom, top), |
|
|
'left': (left, right), 'right': (right, left), |
|
|
}[self.get_fillstyle()] |
|
|
self._alt_transform = self._transform |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_star(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 5.0 |
|
|
|
|
|
polypath = Path.unit_regular_star(5, innerCircle=0.381966) |
|
|
|
|
|
if not self._half_fill(): |
|
|
self._path = polypath |
|
|
else: |
|
|
verts = polypath.vertices |
|
|
top = Path(np.concatenate([verts[0:4], verts[7:10], verts[0:1]])) |
|
|
bottom = Path(np.concatenate([verts[3:8], verts[3:4]])) |
|
|
left = Path(np.concatenate([verts[0:6], verts[0:1]])) |
|
|
right = Path(np.concatenate([verts[0:1], verts[5:10], verts[0:1]])) |
|
|
self._path, self._alt_path = { |
|
|
'top': (top, bottom), 'bottom': (bottom, top), |
|
|
'left': (left, right), 'right': (right, left), |
|
|
}[self.get_fillstyle()] |
|
|
self._alt_transform = self._transform |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.bevel |
|
|
|
|
|
def _set_hexagon1(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = None |
|
|
|
|
|
polypath = Path.unit_regular_polygon(6) |
|
|
|
|
|
if not self._half_fill(): |
|
|
self._path = polypath |
|
|
else: |
|
|
verts = polypath.vertices |
|
|
|
|
|
x = np.abs(np.cos(5 * np.pi / 6.)) |
|
|
top = Path(np.concatenate([[(-x, 0)], verts[[1, 0, 5]], [(x, 0)]])) |
|
|
bottom = Path(np.concatenate([[(-x, 0)], verts[2:5], [(x, 0)]])) |
|
|
left = Path(verts[0:4]) |
|
|
right = Path(verts[[0, 5, 4, 3]]) |
|
|
self._path, self._alt_path = { |
|
|
'top': (top, bottom), 'bottom': (bottom, top), |
|
|
'left': (left, right), 'right': (right, left), |
|
|
}[self.get_fillstyle()] |
|
|
self._alt_transform = self._transform |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_hexagon2(self): |
|
|
self._transform = Affine2D().scale(0.5).rotate_deg(30) |
|
|
self._snap_threshold = None |
|
|
|
|
|
polypath = Path.unit_regular_polygon(6) |
|
|
|
|
|
if not self._half_fill(): |
|
|
self._path = polypath |
|
|
else: |
|
|
verts = polypath.vertices |
|
|
|
|
|
x, y = np.sqrt(3) / 4, 3 / 4. |
|
|
top = Path(verts[[1, 0, 5, 4, 1]]) |
|
|
bottom = Path(verts[1:5]) |
|
|
left = Path(np.concatenate([ |
|
|
[(x, y)], verts[:3], [(-x, -y), (x, y)]])) |
|
|
right = Path(np.concatenate([ |
|
|
[(x, y)], verts[5:2:-1], [(-x, -y)]])) |
|
|
self._path, self._alt_path = { |
|
|
'top': (top, bottom), 'bottom': (bottom, top), |
|
|
'left': (left, right), 'right': (right, left), |
|
|
}[self.get_fillstyle()] |
|
|
self._alt_transform = self._transform |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_octagon(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 5.0 |
|
|
|
|
|
polypath = Path.unit_regular_polygon(8) |
|
|
|
|
|
if not self._half_fill(): |
|
|
self._transform.rotate_deg(22.5) |
|
|
self._path = polypath |
|
|
else: |
|
|
x = np.sqrt(2.) / 4. |
|
|
self._path = self._alt_path = Path( |
|
|
[[0, -1], [0, 1], [-x, 1], [-1, x], |
|
|
[-1, -x], [-x, -1], [0, -1]]) |
|
|
fs = self.get_fillstyle() |
|
|
self._transform.rotate_deg( |
|
|
{'left': 0, 'bottom': 90, 'right': 180, 'top': 270}[fs]) |
|
|
self._alt_transform = self._transform.frozen().rotate_deg(180.0) |
|
|
|
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
_line_marker_path = Path([[0.0, -1.0], [0.0, 1.0]]) |
|
|
|
|
|
def _set_vline(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 1.0 |
|
|
self._filled = False |
|
|
self._path = self._line_marker_path |
|
|
|
|
|
def _set_hline(self): |
|
|
self._set_vline() |
|
|
self._transform = self._transform.rotate_deg(90) |
|
|
|
|
|
_tickhoriz_path = Path([[0.0, 0.0], [1.0, 0.0]]) |
|
|
|
|
|
def _set_tickleft(self): |
|
|
self._transform = Affine2D().scale(-1.0, 1.0) |
|
|
self._snap_threshold = 1.0 |
|
|
self._filled = False |
|
|
self._path = self._tickhoriz_path |
|
|
|
|
|
def _set_tickright(self): |
|
|
self._transform = Affine2D().scale(1.0, 1.0) |
|
|
self._snap_threshold = 1.0 |
|
|
self._filled = False |
|
|
self._path = self._tickhoriz_path |
|
|
|
|
|
_tickvert_path = Path([[-0.0, 0.0], [-0.0, 1.0]]) |
|
|
|
|
|
def _set_tickup(self): |
|
|
self._transform = Affine2D().scale(1.0, 1.0) |
|
|
self._snap_threshold = 1.0 |
|
|
self._filled = False |
|
|
self._path = self._tickvert_path |
|
|
|
|
|
def _set_tickdown(self): |
|
|
self._transform = Affine2D().scale(1.0, -1.0) |
|
|
self._snap_threshold = 1.0 |
|
|
self._filled = False |
|
|
self._path = self._tickvert_path |
|
|
|
|
|
_tri_path = Path([[0.0, 0.0], [0.0, -1.0], |
|
|
[0.0, 0.0], [0.8, 0.5], |
|
|
[0.0, 0.0], [-0.8, 0.5]], |
|
|
[Path.MOVETO, Path.LINETO, |
|
|
Path.MOVETO, Path.LINETO, |
|
|
Path.MOVETO, Path.LINETO]) |
|
|
|
|
|
def _set_tri_down(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 5.0 |
|
|
self._filled = False |
|
|
self._path = self._tri_path |
|
|
|
|
|
def _set_tri_up(self): |
|
|
self._set_tri_down() |
|
|
self._transform = self._transform.rotate_deg(180) |
|
|
|
|
|
def _set_tri_left(self): |
|
|
self._set_tri_down() |
|
|
self._transform = self._transform.rotate_deg(270) |
|
|
|
|
|
def _set_tri_right(self): |
|
|
self._set_tri_down() |
|
|
self._transform = self._transform.rotate_deg(90) |
|
|
|
|
|
_caret_path = Path([[-1.0, 1.5], [0.0, 0.0], [1.0, 1.5]]) |
|
|
|
|
|
def _set_caretdown(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 3.0 |
|
|
self._filled = False |
|
|
self._path = self._caret_path |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
|
|
|
def _set_caretup(self): |
|
|
self._set_caretdown() |
|
|
self._transform = self._transform.rotate_deg(180) |
|
|
|
|
|
def _set_caretleft(self): |
|
|
self._set_caretdown() |
|
|
self._transform = self._transform.rotate_deg(270) |
|
|
|
|
|
def _set_caretright(self): |
|
|
self._set_caretdown() |
|
|
self._transform = self._transform.rotate_deg(90) |
|
|
|
|
|
_caret_path_base = Path([[-1.0, 0.0], [0.0, -1.5], [1.0, 0]]) |
|
|
|
|
|
def _set_caretdownbase(self): |
|
|
self._set_caretdown() |
|
|
self._path = self._caret_path_base |
|
|
|
|
|
def _set_caretupbase(self): |
|
|
self._set_caretdownbase() |
|
|
self._transform = self._transform.rotate_deg(180) |
|
|
|
|
|
def _set_caretleftbase(self): |
|
|
self._set_caretdownbase() |
|
|
self._transform = self._transform.rotate_deg(270) |
|
|
|
|
|
def _set_caretrightbase(self): |
|
|
self._set_caretdownbase() |
|
|
self._transform = self._transform.rotate_deg(90) |
|
|
|
|
|
_plus_path = Path([[-1.0, 0.0], [1.0, 0.0], |
|
|
[0.0, -1.0], [0.0, 1.0]], |
|
|
[Path.MOVETO, Path.LINETO, |
|
|
Path.MOVETO, Path.LINETO]) |
|
|
|
|
|
def _set_plus(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 1.0 |
|
|
self._filled = False |
|
|
self._path = self._plus_path |
|
|
|
|
|
_x_path = Path([[-1.0, -1.0], [1.0, 1.0], |
|
|
[-1.0, 1.0], [1.0, -1.0]], |
|
|
[Path.MOVETO, Path.LINETO, |
|
|
Path.MOVETO, Path.LINETO]) |
|
|
|
|
|
def _set_x(self): |
|
|
self._transform = Affine2D().scale(0.5) |
|
|
self._snap_threshold = 3.0 |
|
|
self._filled = False |
|
|
self._path = self._x_path |
|
|
|
|
|
_plus_filled_path = Path._create_closed(np.array([ |
|
|
(-1, -3), (+1, -3), (+1, -1), (+3, -1), (+3, +1), (+1, +1), |
|
|
(+1, +3), (-1, +3), (-1, +1), (-3, +1), (-3, -1), (-1, -1)]) / 6) |
|
|
_plus_filled_path_t = Path._create_closed(np.array([ |
|
|
(+3, 0), (+3, +1), (+1, +1), (+1, +3), |
|
|
(-1, +3), (-1, +1), (-3, +1), (-3, 0)]) / 6) |
|
|
|
|
|
def _set_plus_filled(self): |
|
|
self._transform = Affine2D() |
|
|
self._snap_threshold = 5.0 |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
if not self._half_fill(): |
|
|
self._path = self._plus_filled_path |
|
|
else: |
|
|
|
|
|
self._path = self._alt_path = self._plus_filled_path_t |
|
|
fs = self.get_fillstyle() |
|
|
self._transform.rotate_deg( |
|
|
{'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs]) |
|
|
self._alt_transform = self._transform.frozen().rotate_deg(180) |
|
|
|
|
|
_x_filled_path = Path._create_closed(np.array([ |
|
|
(-1, -2), (0, -1), (+1, -2), (+2, -1), (+1, 0), (+2, +1), |
|
|
(+1, +2), (0, +1), (-1, +2), (-2, +1), (-1, 0), (-2, -1)]) / 4) |
|
|
_x_filled_path_t = Path._create_closed(np.array([ |
|
|
(+1, 0), (+2, +1), (+1, +2), (0, +1), |
|
|
(-1, +2), (-2, +1), (-1, 0)]) / 4) |
|
|
|
|
|
def _set_x_filled(self): |
|
|
self._transform = Affine2D() |
|
|
self._snap_threshold = 5.0 |
|
|
self._joinstyle = self._user_joinstyle or JoinStyle.miter |
|
|
if not self._half_fill(): |
|
|
self._path = self._x_filled_path |
|
|
else: |
|
|
|
|
|
self._path = self._alt_path = self._x_filled_path_t |
|
|
fs = self.get_fillstyle() |
|
|
self._transform.rotate_deg( |
|
|
{'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs]) |
|
|
self._alt_transform = self._transform.frozen().rotate_deg(180) |
|
|
|
