Shorten/make more consistent the half-filled marker definitions.

anntzer · anntzer · commit b52d64606abe · 2021-01-24T18:39:19.000+01:00
- Use dict lookups for fillstyle.
- When possible, prefer defining `path` and `alt_path` to the same path
  and just make `alt_transform` the 180°-rotated version of `transform`.
  (This is consistent with what's already being done for "circle" and
  "octagon".)
diff --git a/lib/matplotlib/markers.py b/lib/matplotlib/markers.py
@@ -428,18 +428,9 @@ def _set_circle(self, reduction=1.0):
         if not self._half_fill():
             self._path = Path.unit_circle()
         else:
-            # build a right-half circle
-            if fs == 'bottom':
-                rotate = 270.
-            elif fs == 'top':
-                rotate = 90.
-            elif fs == 'left':
-                rotate = 180.
-            else:
-                rotate = 0.
-
             self._path = self._alt_path = Path.unit_circle_righthalf()
-            self._transform.rotate_deg(rotate)
+            self._transform.rotate_deg(
+                {'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs])
             self._alt_transform = self._transform.frozen().rotate_deg(180.)
 
     def _set_pixel(self):
@@ -518,24 +509,11 @@ def _set_square(self):
         if not self._half_fill():
             self._path = Path.unit_rectangle()
         else:
-            # build a bottom filled square out of two rectangles, one
-            # filled.  Use the rotation to support left, right, bottom
-            # or top
-            if fs == 'bottom':
-                rotate = 0.
-            elif fs == 'top':
-                rotate = 180.
-            elif fs == 'left':
-                rotate = 270.
-            else:
-                rotate = 90.
-
-            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]])
-            self._transform.rotate_deg(rotate)
-            self._alt_transform = self._transform
+            self._path = self._alt_path = Path(  # Half-square.
+                [[0.0, 0.0], [1.0, 0.0], [1.0, 0.5], [0.0, 0.5], [0.0, 0.0]])
+            self._transform.rotate_deg(
+                {'bottom': 0, 'right': 90, 'top': 180, 'left': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate_deg(180)
 
         self._joinstyle = 'miter'
 
@@ -546,18 +524,11 @@ def _set_diamond(self):
         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]])
-            if fs == 'bottom':
-                rotate = 270.
-            elif fs == 'top':
-                rotate = 90.
-            elif fs == 'left':
-                rotate = 180.
-            else:
-                rotate = 0.
-            self._transform.rotate_deg(rotate)
-            self._alt_transform = self._transform
+            self._path = self._alt_path = Path(
+                [[0, 0], [1, 0], [1, 1], [0, 0]])
+            self._transform.rotate_deg(
+                {'right': 0, 'top': 90, 'left': 180, 'bottom': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate_deg(180)
         self._joinstyle = 'miter'
 
     def _set_thin_diamond(self):
@@ -575,23 +546,15 @@ def _set_pentagon(self):
             self._path = polypath
         else:
             verts = polypath.vertices
-
             y = (1 + np.sqrt(5)) / 4.
             top = Path([verts[0], verts[1], verts[4], verts[0]])
             bottom = Path([verts[1], verts[2], verts[3], verts[4], verts[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]])
-
-            if fs == 'top':
-                mpath, mpath_alt = top, bottom
-            elif fs == 'bottom':
-                mpath, mpath_alt = bottom, top
-            elif fs == 'left':
-                mpath, mpath_alt = left, right
-            else:
-                mpath, mpath_alt = right, left
-            self._path = mpath
-            self._alt_path = mpath_alt
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[fs]
             self._alt_transform = self._transform
 
         self._joinstyle = 'miter'
@@ -607,22 +570,14 @@ def _set_star(self):
             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]]))
-
-            if fs == 'top':
-                mpath, mpath_alt = top, bottom
-            elif fs == 'bottom':
-                mpath, mpath_alt = bottom, top
-            elif fs == 'left':
-                mpath, mpath_alt = left, right
-            else:
-                mpath, mpath_alt = right, left
-            self._path = mpath
-            self._alt_path = mpath_alt
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[fs]
             self._alt_transform = self._transform
 
         self._joinstyle = 'bevel'
@@ -638,25 +593,16 @@ def _set_hexagon1(self):
             self._path = polypath
         else:
             verts = polypath.vertices
-
             # not drawing inside lines
             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]])
-
-            if fs == 'top':
-                mpath, mpath_alt = top, bottom
-            elif fs == 'bottom':
-                mpath, mpath_alt = bottom, top
-            elif fs == 'left':
-                mpath, mpath_alt = left, right
-            else:
-                mpath, mpath_alt = right, left
-
-            self._path = mpath
-            self._alt_path = mpath_alt
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[fs]
             self._alt_transform = self._transform
 
         self._joinstyle = 'miter'
@@ -672,7 +618,6 @@ def _set_hexagon2(self):
             self._path = polypath
         else:
             verts = polypath.vertices
-
             # not drawing inside lines
             x, y = np.sqrt(3) / 4, 3 / 4.
             top = Path(verts[[1, 0, 5, 4, 1]])
@@ -681,18 +626,10 @@ def _set_hexagon2(self):
                 [(x, y)], verts[:3], [(-x, -y), (x, y)]]))
             right = Path(np.concatenate([
                 [(x, y)], verts[5:2:-1], [(-x, -y)]]))
-
-            if fs == 'top':
-                mpath, mpath_alt = top, bottom
-            elif fs == 'bottom':
-                mpath, mpath_alt = bottom, top
-            elif fs == 'left':
-                mpath, mpath_alt = left, right
-            else:
-                mpath, mpath_alt = right, left
-
-            self._path = mpath
-            self._alt_path = mpath_alt
+            self._path, self._alt_path = {
+                'top': (top, bottom), 'bottom': (bottom, top),
+                'left': (left, right), 'right': (right, left),
+            }[fs]
             self._alt_transform = self._transform
 
         self._joinstyle = 'miter'
@@ -711,17 +648,8 @@ def _set_octagon(self):
             x = np.sqrt(2.) / 4.
             half = Path([[0, -1], [0, 1], [-x, 1], [-1, x],
                          [-1, -x], [-x, -1], [0, -1]])
-
-            if fs == 'bottom':
-                rotate = 90.
-            elif fs == 'top':
-                rotate = 270.
-            elif fs == 'right':
-                rotate = 180.
-            else:
-                rotate = 0.
-
-            self._transform.rotate_deg(rotate)
+            self._transform.rotate_deg(
+                {'left': 0, 'bottom': 90, 'right': 180, 'left': 270}[fs])
             self._path = self._alt_path = half
             self._alt_transform = self._transform.frozen().rotate_deg(180.0)
 
@@ -870,20 +798,10 @@ def _set_plus_filled(self):
             self._path = self._plus_filled_path
         else:
             # Rotate top half path to support all partitions
-            if fs == 'top':
-                rotate, rotate_alt = 0, 180
-            elif fs == 'bottom':
-                rotate, rotate_alt = 180, 0
-            elif fs == 'left':
-                rotate, rotate_alt = 90, 270
-            else:
-                rotate, rotate_alt = 270, 90
-
-            self._path = self._plus_filled_path_t
-            self._alt_path = self._plus_filled_path_t
-            self._alt_transform = Affine2D().translate(-0.5, -0.5)
-            self._transform.rotate_deg(rotate)
-            self._alt_transform.rotate_deg(rotate_alt)
+            self._path = self._alt_path = self._plus_filled_path_t
+            self._transform.rotate_deg({
+                'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate(180)
 
     _x_filled_path = Path(
         [(0.25, 0), (0.5, 0.25), (0.75, 0), (1, 0.25), (0.75, 0.5), (1, 0.75),
@@ -902,17 +820,7 @@ def _set_x_filled(self):
             self._path = self._x_filled_path
         else:
             # Rotate top half path to support all partitions
-            if fs == 'top':
-                rotate, rotate_alt = 0, 180
-            elif fs == 'bottom':
-                rotate, rotate_alt = 180, 0
-            elif fs == 'left':
-                rotate, rotate_alt = 90, 270
-            else:
-                rotate, rotate_alt = 270, 90
-
-            self._path = self._x_filled_path_t
-            self._alt_path = self._x_filled_path_t
-            self._alt_transform = Affine2D().translate(-0.5, -0.5)
-            self._transform.rotate_deg(rotate)
-            self._alt_transform.rotate_deg(rotate_alt)
+            self._path = self._alt_path = self._x_filled_path_t
+            self._transform.rotate_deg({
+                'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
+            self._alt_transform = self._transform.frozen().rotate(180)
