matplotlib
diff --git a/‎lib/matplotlib/lines.py
Lines changed: 8 additions & 1 deletion b/‎lib/matplotlib/lines.py
Lines changed: 8 additions & 1 deletion
diff --git a/‎lib/matplotlib/path.py
Lines changed: 2 additions & 2 deletions b/‎lib/matplotlib/path.py
Lines changed: 2 additions & 2 deletions
diff --git a/‎lib/matplotlib/tests/test_simplification.py
Lines changed: 19 additions & 44 deletions b/‎lib/matplotlib/tests/test_simplification.py
Lines changed: 19 additions & 44 deletions
@@ -791,14 +791,21 @@ def draw(self, renderer):
                     join = self._dashjoinstyle
                 else:
                     if tpath.should_simplify and affine.has_inverse:
-                        # the path simplification code expects the path
+                        # The path simplification code expects the path
                         # to be in pixel space, not data space, but the
                         # renderer downstream expects the path to be
                         # in data space. The transformation `affine`
                         # will put the path into pixel space, and
                         # affine.inverted() will transform it back to
                         # data space. So, transform using affine, simplify
                         # the path, and transform using the affine inverted.
+                        #
+                        # This may be inefficient, but it appears to be the
+                        # only way forward at the moment. It's possible that
+                        # the problem only lies in path clipping inside
+                        # src/path_converters.h, but that is only a
+                        # hypothesis. Despite the inefficiency, it is still
+                        # faster than *not* simplifying.
                         tpath = affine.inverted().transform_path(
                             affine.transform_path(tpath).cleaned(simplify=True)
                         )
 
@@ -208,10 +208,10 @@ def _fast_from_codes_and_verts(cls, verts, codes, internals=None):
     def _update_values(self):
         self._simplify_threshold = rcParams['path.simplify_threshold']
         self._should_simplify = (
+            self._simplify_threshold > 0 and
             rcParams['path.simplify'] and
             len(self._vertices) >= 128 and
-            (self._codes is None or np.all(self._codes <= Path.LINETO)) and
-            self._simplify_threshold > 0
+            (self._codes is None or np.all(self._codes <= Path.LINETO))
         )
         self._has_nonfinite = not np.isfinite(self._vertices).all()
 
 
@@ -15,13 +15,14 @@
 from matplotlib.path import Path
 
 
-# NOTE: All of these tests used to assume that path.simplify is set to True
-# but that is no longer the case.
-
-@image_comparison(baseline_images=['clipping'], remove_text=True)
-def test_clipping():
+@pytest.fixture
+def set_simplify_and_threshold():
     plt.rcParams['path.simplify'] = True
+    plt.rcParams['path.simplify_threshold'] = 0.1111111111111111
 
+
+@image_comparison(baseline_images=['clipping'], remove_text=True)
+def test_clipping(set_simplify_and_threshold):
     t = np.arange(0.0, 2.0, 0.01)
     s = np.sin(2*np.pi*t)
 
@@ -31,9 +32,7 @@ def test_clipping():
 
 
 @image_comparison(baseline_images=['overflow'], remove_text=True)
-def test_overflow():
-    plt.rcParams['path.simplify'] = True
-
+def test_overflow(set_simplify_and_threshold):
     x = np.array([1.0, 2.0, 3.0, 2.0e5])
     y = np.arange(len(x))
 
@@ -43,9 +42,7 @@ def test_overflow():
 
 
 @image_comparison(baseline_images=['clipping_diamond'], remove_text=True)
-def test_diamond():
-    plt.rcParams['path.simplify'] = True
-
+def test_diamond(set_simplify_and_threshold):
     x = np.array([0.0, 1.0, 0.0, -1.0, 0.0])
     y = np.array([1.0, 0.0, -1.0, 0.0, 1.0])
 
@@ -55,9 +52,7 @@ def test_diamond():
     ax.set_ylim(ymin=-0.6, ymax=0.6)
 
 
-def test_noise():
-    plt.rcParams['path.simplify'] = True
-
+def test_noise(set_simplify_and_threshold):
     np.random.seed(0)
     x = np.random.uniform(size=(50000,)) * 50
 
@@ -72,9 +67,7 @@ def test_noise():
     assert simplified.vertices.size == 25888
 
 
-def test_antiparallel_simplification():
-    plt.rcParams['path.simplify'] = True
-
+def 
9E88
test_antiparallel_simplification(set_simplify_and_threshold):
     def _get_simplified(x,y):
         fig, ax = plt.subplots()
         p1 = ax.plot(x, y)
@@ -148,9 +141,7 @@ def _get_simplified(x,y):
                                [ 1. ,  0.5]],
                               simplified.vertices[:-2, :])
 
-def test_sine_plus_noise():
-    plt.rcParams['path.simplify'] = True
-
+def test_sine_plus_noise(set_simplify_and_threshold):
     np.random.seed(0)
     x = (np.sin(np.linspace(0, np.pi * 2.0, 50000)) +
          np.random.uniform(size=(50000,)) * 0.01)
@@ -167,9 +158,7 @@ def test_sine_plus_noise():
 
 
 @image_comparison(baseline_images=['simplify_curve'], remove_text=True)
-def test_simplify_curve():
-    plt.rcParams['path.simplify'] = True
-
+def test_simplify_curve(set_simplify_and_threshold):
     pp1 = patches.PathPatch(
         Path([(0, 0), (1, 0), (1, 1), (np.nan, 1), (0, 0), (2, 0), (2, 2),
               (0, 0)],
@@ -184,19 +173,15 @@ def test_simplify_curve():
 
 
 @image_comparison(baseline_images=['hatch_simplify'], remove_text=True)
-def test_hatch():
-    plt.rcParams['path.simplify'] = True
-
+def test_hatch(set_simplify_and_threshold):
     fig, ax = plt.subplots()
     ax.add_patch(plt.Rectangle((0, 0), 1, 1, fill=False, hatch="/"))
     ax.set_xlim((0.45, 0.55))
     ax.set_ylim((0.45, 0.55))
 
 
 @image_comparison(baseline_images=['fft_peaks'], remove_text=True)
-def test_fft_peaks():
-    plt.rcParams['path.simplify'] = True
-
+def test_fft_peaks(set_simplify_and_threshold):
     fig, ax = plt.subplots()
     t = np.arange(65536)
     p1 = ax.plot(abs(np.fft.fft(np.sin(2*np.pi*.01*t)*np.blackman(len(t)))))
@@ -209,9 +194,7 @@ def test_fft_peaks():
     assert simplified.vertices.size == 38
 
 
-def test_start_with_moveto():
-    plt.rcParams['path.simplify'] = True
-
+def test_start_with_moveto(set_simplify_and_threshold):
     # Should be entirely clipped away to a single MOVETO
     data = b"""
 ZwAAAAku+v9UAQAA+Tj6/z8CAADpQ/r/KAMAANlO+v8QBAAAyVn6//UEAAC6ZPr/2gUAAKpv+v+8
@@ -266,9 +249,7 @@ def test_throw_rendering_complexity_exceeded():
 
 
 @image_comparison(baseline_images=['clipper_edge'], remove_text=True)
-def test_clipper():
-    plt.rcParams['path.simplify'] = True
-
+def test_clipper(set_simplify_and_threshold):
     dat = (0, 1, 0, 2, 0, 3, 0, 4, 0, 5)
     fig = plt.figure(figsize=(2, 1))
     fig.subplots_adjust(left=0, bottom=0, wspace=0, hspace=0)
@@ -284,9 +265,7 @@ def test_clipper():
 
 
 @image_comparison(baseline_images=['para_equal_perp'], remove_text=True)
-def test_para_equal_perp():
-    plt.rcParams['path.simplify'] = True
-
+def test_para_equal_perp(set_simplify_and_threshold):
     x = np.array([0, 1, 2, 1, 0, -1, 0, 1] + [1] * 128)
     y = np.array([1, 1, 2, 1, 0, -1, 0, 0] + [0] * 128)
 
@@ -296,9 +275,7 @@ def test_para_equal_perp():
 
 
 @image_comparison(baseline_images=['clipping_with_nans'])
-def test_clipping_with_nans():
-    plt.rcParams['path.simplify'] = True
-
+def test_clipping_with_nans(set_simplify_and_threshold):
     x = np.linspace(0, 3.14 * 2, 3000)
     y = np.sin(x)
     x[::100] = np.nan
@@ -308,9 +285,7 @@ def test_clipping_with_nans():
     ax.set_ylim(-0.25, 0.25)
 
 
-def test_clipping_full():
-    plt.rcParams['path.simplify'] = True
-
+def test_clipping_full(set_simplify_and_threshold):
     p = Path([[1e30, 1e30]] * 5)
     simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))
     assert simplified == []