From 652e3859bebf8226c4e23158972b82451e537f40 Mon Sep 17 00:00:00 2001 From: Phil Elson Date: Fri, 14 Sep 2012 10:26:19 +0100 Subject: [PATCH 1/3] Resolves #1246 exception. Agg backend works beautifully, PDF and SVG fail to produce suitable results. --- lib/matplotlib/scale.py | 2 + .../baseline_images/test_scale/log_scales.pdf | Bin 0 -> 6633 bytes .../baseline_images/test_scale/log_scales.png | Bin 0 -> 7235 bytes .../baseline_images/test_scale/log_scales.svg | 1004 +++++++++++++++++ lib/matplotlib/tests/test_scale.py | 13 + 5 files changed, 1019 insertions(+) create mode 100644 lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf create mode 100644 lib/matplotlib/tests/baseline_images/test_scale/log_scales.png create mode 100644 lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg create mode 100644 lib/matplotlib/tests/test_scale.py diff --git a/lib/matplotlib/scale.py b/lib/matplotlib/scale.py index ca50e177c6db..8a4054f94889 100644 --- a/lib/matplotlib/scale.py +++ b/lib/matplotlib/scale.py @@ -115,6 +115,7 @@ class LogTransformBase(Transform): input_dims = 1 output_dims = 1 is_separable = True + has_inverse = True def __init__(self, nonpos): Transform.__init__(self) @@ -316,6 +317,7 @@ class SymmetricalLogTransform(Transform): input_dims = 1 output_dims = 1 is_separable = True + has_inverse = True def __init__(self, base, linthresh, linscale): Transform.__init__(self) diff --git a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf new file mode 100644 index 0000000000000000000000000000000000000000..191c27b90f48b81c65fbf3531245052bab9e7a30 GIT binary patch literal 6633 zcmb_h2{@J8*RND`a7{T4Jl!`UUBh|L?8rRJbV5=x92^|e(eV1iN3y`@A*#8YVUWwYp=cbT5JFIyEYBBrL`_uk4Dfq z@(?*(NgyLA!uJay7#boZx41|yLbBjsoG^Y6LSl1*xKRiN2)H1|#sqFe02I_08{pyW z7sB<&5GF1I24EOh5P{I)BZ0&g@cmu67~%<3Sy}`2+*k}D*@XkO=A*5}XlsXfAtb9< z%*GYtU|fVIRNxxS3E)KpAq=5_JMH-N`6=f?ump?W%#fzYTFXrl`^ ziXScT2Y!Kma1kkjt^$(+1A&$(goVHRW+Z$T*=WrR15QFn)?r|!mRx^+02t}OjR?Ym z5i*Ph?(8T`z~zJ!VhbAb9Mc~%Du8klYjWwK9jyR`N!OO%ICGV`vOE zyJ)zh?`Cp2tt_Upkp+un9KDaVmYY#uk9dQ~0T z`r2sf$;Ulg7CIVv**=nW4>XpWlX`pyz1uO)IQ;dnwA(^&J66l43_DW2PM4o{YWF`I z+tqUhr)0`4%`A3V=Ag-H&Lo}596si4YwY|oA*1t=&y}_BPn^DVwBF{+uJCIk?Bdq7 zGd~s3a8_n0h!Zu6e!CA~>t`*CTgJ+&;D^>aZ#g0Sq z-lvuaZi|-kAKI=xA`^q~w;(Gd(u9 zZL?hN?6p57r#V*MJ+e+WxIMQo#G|u7GD(F!U{&n6u-IERv~bm9c_@03mUnPz{qi77 z86C?vHflyBKk7$(%u5PPm z>foI&Ct0(gUD7ful4NU;R}sz<2J>IJJKub-zViK}qN$km#ai?1#Cbz^J9!~_ACMzY zH>mI~M6aHGeU_YrG<#?Y8TMJ^)A9K!zo$0hFBBxC7Y}9FEGjkz+k+^N9yHfpsTt-J}h7O5eCyOgfaC|BprIl$N>1BbmMJ?TKECV)~dV z1#gld+>e6LDDdOp1W}AkrZGgP0U2WRuRt3^AD$s!VU0>iB@7>iK`ZIYkT#_1M%yQM_dm>v?G-F-F67c^}X-b|CN{lVPg z$KuZ*o=RqZH#yzKUSL6%dQjsUnbfkgCZPyB8S<{?=!W^)<+`TkdZcA-_KEEp56bFa zF8#e<B`K%Rw5Nv*aIXo^U)>`{H5FsSSBM&8NKb zSa%Dns2oyt@OV+a;lm#s;;r?LMf8Ik0#Bv;2h_***EytaOsQ97?@Gv-b|`n-&4<&} z_t`kcbk&{oWOUE9EE%NgWM83(abYc!~kUMvYZkAq6mtAml>R^&)+(1xNoA# za|OXMkH1v?m2G7!SKe3dw&;nwG8+lpxnm2#%RQBtX!c>Z&C!H@4>u3wMwhBxWZG7C z#=4lK`?fNy3gWo~q@iWmJEvh?f2zIPTdQc-T;S(rFeGP;=^UtGyl6U}zG%o+JJjL+ zsuDY1vs%`%Tq{14pI~&>v`6piTJLL!nd@yW-kR%&3jMY6XK^>KQq7m4T~^)HtYo-} zs+irIpq1!juUV;;Ve*^op0z%6O416Z@+U^!C_b}AV#bGioa3s#8`~Q4UnZFTp%m{s zG;(Jk?#r-*>X~(J<3mFc|4#ea2BFZt4~_0(R;GlRRMTtac=M>6-6xtd`bXXnu1;K^ zVu2Xwu4G?wmfxZM_~Vr&r=E4^&AhPc!k#Brqg9A3d1c$SnQo2;ysG9@OU9@MPU#U#EDPiJIV8*YEb+~k|D|!}v^6ERG&Vg)-_KcN{7pJ&J-@TGo@4PQfx@$$N?3KS2 zZgXdr?#j88wn5!-u8ZxSe>4wL&9+Z2IlQ=Jt7=2yn9w1xb5$XhTZ}1sFPKwvd4#4 zr&YE)o*rP5o(~wk=o}oDI8f$E{DA|-ztn%`Ko;a#B)Y5AoY|JwN3i&| z5ud~Dzg5>dO-dzNCHK-p?9q2;DaxVj1v|5IYnPxar0>7md-V&&&Y>{n=IXyB)}Q>a za($cKzn@mdPdNNJe(EE+HdQr`A6N)Wgk7%}&_k}VZ?u(4&q8+&5|2e~tPH7C@hk49^}y_$~{X?O3*J9*;9-RHiM zvo*cf5t+Unysfk8*t6t)dO7Av4I1zB)}8%wddi)DnX$xT?Hm*G zTdIyx4D1F1es3z^16<))jDgA zng8D0>#%T@oqF~AeM$;}a#LLL3NvyHjQkS*G94-AY7hL|*xK`1T3KtwA3yLPtO$R_ zfBN5NmQ~t0*;-V}a`isn$%&eQ#acNPYgLd%4g8B%_n!`eABb zi7)-EwaeDRwf5%(^Eld8q5*EdK^gL)w!r}6>7ES38FA4f}lc! z%!S3TE?J+3=u)T*pjTfXVNqC!7lC9I0g6^wmm3-qNS3_7KrSq*K}qb1(C7#$I4&}n z8-V~AC&hCGe1yc00PDwAfgTnt;DUZ2D51gsycp1r0_!G4abv&;pjvnX@pS?K5+n!C zsA&{B9ioQlYgBwkL9fH|9XA#C=uZ{^ZUZoGxI6GMtigk#5GsX0^04Ldf`T!G4)))u z70@+e;l$PcFR^sw#Nu%Pv8PesO-kgbS|%0DW(V$7c>ZP)L1A1txtY*r=v1*~i7?a? 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 literal 0 HcmV?d00001 diff --git a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg new file mode 100644 index 000000000000..d2111d248af3 --- /dev/null +++ b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg @@ -0,0 +1,1004 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/matplotlib/tests/test_scale.py b/lib/matplotlib/tests/test_scale.py new file mode 100644 index 000000000000..6a1b5fc755c4 --- /dev/null +++ b/lib/matplotlib/tests/test_scale.py @@ -0,0 +1,13 @@ +from __future__ import print_function + +from matplotlib.testing.decorators import image_comparison +import matplotlib.pyplot as plt + + +@image_comparison(baseline_images=['log_scales']) +def test_complete(): + ax = plt.subplot(122, yscale='log', xscale='symlog') + + ax.axvline(24.1) + ax.axhline(24.1) + plt.show() From b930aa76339417cdf87c662baeef21b51e3a6fe9 Mon Sep 17 00:00:00 2001 From: Phil Elson Date: Fri, 14 Sep 2012 10:50:23 +0100 Subject: [PATCH 2/3] Fixes #1246. Repeated drawing handling fixed by correcting the affine/non-affine transformation of a BlendedGenericTransform. --- lib/matplotlib/__init__.py | 1 + lib/matplotlib/scale.py | 77 ++++++++++-------- .../baseline_images/test_scale/log_scales.pdf | Bin 6633 -> 6630 bytes .../baseline_images/test_scale/log_scales.svg | 7 +- lib/matplotlib/tests/test_scale.py | 5 +- lib/matplotlib/transforms.py | 31 ++++--- 6 files changed, 66 insertions(+), 55 deletions(-) diff --git a/lib/matplotlib/__init__.py b/lib/matplotlib/__init__.py index ce52abc67663..82228189625c 100644 --- a/lib/matplotlib/__init__.py +++ b/lib/matplotlib/__init__.py @@ -1075,6 +1075,7 @@ def tk_window_focus(): 'matplotlib.tests.test_patches', 'matplotlib.tests.test_pickle', 'matplotlib.tests.test_rcparams', + 'matplotlib.tests.test_scale', 'matplotlib.tests.test_simplification', 'matplotlib.tests.test_spines', 'matplotlib.tests.test_text', diff --git a/lib/matplotlib/scale.py b/lib/matplotlib/scale.py index 8a4054f94889..0f824abeb572 100644 --- a/lib/matplotlib/scale.py +++ b/lib/matplotlib/scale.py @@ -1,16 +1,17 @@ from __future__ import print_function -import textwrap + import numpy as np from numpy import ma -MaskedArray = ma.MaskedArray -from cbook import dedent -from ticker import NullFormatter, ScalarFormatter, LogFormatterMathtext, Formatter -from ticker import NullLocator, LogLocator, AutoLocator, SymmetricalLogLocator, FixedLocator -from ticker import is_decade -from transforms import Transform, IdentityTransform +from matplotlib.cbook import dedent +from matplotlib.ticker import (NullFormatter, ScalarFormatter, + LogFormatterMathtext) +from matplotlib.ticker import (NullLocator, LogLocator, AutoLocator, + SymmetricalLogLocator) +from matplotlib.transforms import Transform, IdentityTransform from matplotlib import docstring + class ScaleBase(object): """ The base class for all scales. @@ -31,7 +32,7 @@ def get_transform(self): Return the :class:`~matplotlib.transforms.Transform` object associated with this scale. """ - raise NotImplementedError + raise NotImplementedError() def set_default_locators_and_formatters(self, axis): """ @@ -39,7 +40,7 @@ def set_default_locators_and_formatters(self, axis): :class:`~matplotlib.ticker.Formatter` objects on the given axis to match this scale. """ - raise NotImplementedError + raise NotImplementedError() def limit_range_for_scale(self, vmin, vmax, minpos): """ @@ -51,6 +52,7 @@ def limit_range_for_scale(self, vmin, vmax, minpos): """ return vmin, vmax + class LinearScale(ScaleBase): """ The default linear scale. @@ -90,10 +92,12 @@ def _mask_non_positives(a): return ma.MaskedArray(a, mask=mask) return a + def _clip_non_positives(a): a[a <= 0.0] = 1e-300 return a + class LogScale(ScaleBase): """ A standard logarithmic scale. Care is taken so non-positive @@ -116,7 +120,7 @@ class LogTransformBase(Transform): output_dims = 1 is_separable = True has_inverse = True - + def __init__(self, nonpos): Transform.__init__(self) if nonpos == 'mask': @@ -124,13 +128,12 @@ def __init__(self, nonpos): else: self._handle_nonpos = _clip_non_positives - class Log10Transform(LogTransformBase): base = 10.0 - def transform(self, a): + def transform_non_affine(self, a): a = self._handle_nonpos(a * 10.0) - if isinstance(a, MaskedArray): + if isinstance(a, ma.MaskedArray): return ma.log10(a) return np.log10(a) @@ -141,9 +144,10 @@ class InvertedLog10Transform(Transform): input_dims = 1 output_dims = 1 is_separable = True + has_inverse = True base = 10.0 - def transform(self, a): + def transform_non_affine(self, a): return ma.power(10.0, a) / 10.0 def inverted(self): @@ -152,9 +156,9 @@ def inverted(self): class Log2Transform(LogTransformBase): base = 2.0 - def transform(self, a): + def transform_non_affine(self, a): a = self._handle_nonpos(a * 2.0) - if isinstance(a, MaskedArray): + if isinstance(a, ma.MaskedArray): return ma.log(a) / np.log(2) return np.log2(a) @@ -165,9 +169,10 @@ class InvertedLog2Transform(Transform): input_dims = 1 output_dims = 1 is_separable = True + has_inverse = True base = 2.0 - def transform(self, a): + def transform_non_affine(self, a): return ma.power(2.0, a) / 2.0 def inverted(self): @@ -176,9 +181,9 @@ def inverted(self): class NaturalLogTransform(LogTransformBase): base = np.e - def transform(self, a): + def transform_non_affine(self, a): a = self._handle_nonpos(a * np.e) - if isinstance(a, MaskedArray): + if isinstance(a, ma.MaskedArray): return ma.log(a) return np.log(a) @@ -189,9 +194,10 @@ class InvertedNaturalLogTransform(Transform): input_dims = 1 output_dims = 1 is_separable = True + has_inverse = True base = np.e - def transform(self, a): + def transform_non_affine(self, a): return ma.power(np.e, a) / np.e def inverted(self): @@ -201,7 +207,8 @@ class LogTransform(Transform): input_dims = 1 output_dims = 1 is_separable = True - + has_inverse = True + def __init__(self, base, nonpos): Transform.__init__(self) self.base = base @@ -210,9 +217,9 @@ def __init__(self, base, nonpos): else: self._handle_nonpos = _clip_non_positives - def transform(self, a): + def transform_non_affine(self, a): a = self._handle_nonpos(a * self.base) - if isinstance(a, MaskedArray): + if isinstance(a, ma.MaskedArray): return ma.log(a) / np.log(self.base) return np.log(a) / np.log(self.base) @@ -223,18 +230,18 @@ class InvertedLogTransform(Transform): input_dims = 1 output_dims = 1 is_separable = True - + has_inverse = True + def __init__(self, base): Transform.__init__(self) self.base = base - def transform(self, a): + def transform_non_affine(self, a): return ma.power(self.base, a) / self.base def inverted(self): return LogScale.LogTransform(self.base) - - + def __init__(self, axis, **kwargs): """ *basex*/*basey*: @@ -318,7 +325,7 @@ class SymmetricalLogTransform(Transform): output_dims = 1 is_separable = True has_inverse = True - + def __init__(self, base, linthresh, linscale): Transform.__init__(self) self.base = base @@ -327,7 +334,7 @@ def __init__(self, base, linthresh, linscale): self._linscale_adj = (linscale / (1.0 - self.base ** -1)) self._log_base = np.log(base) - def transform(self, a): + def transform_non_affine(self, a): sign = np.sign(a) masked = ma.masked_inside(a, -self.linthresh, self.linthresh, copy=False) log = sign * self.linthresh * ( @@ -346,7 +353,8 @@ class InvertedSymmetricalLogTransform(Transform): input_dims = 1 output_dims = 1 is_separable = True - + has_inverse = True + def __init__(self, base, linthresh, linscale): Transform.__init__(self) symlog = SymmetricalLogScale.SymmetricalLogTransform(base, linthresh, linscale) @@ -356,7 +364,7 @@ def __init__(self, base, linthresh, linscale): self.linscale = linscale self._linscale_adj = (linscale / (1.0 - self.base ** -1)) - def transform(self, a): + def transform_non_affine(self, a): sign = np.sign(a) masked = ma.masked_inside(a, -self.invlinthresh, self.invlinthresh, copy=False) exp = sign * self.linthresh * ( @@ -436,17 +444,19 @@ def get_transform(self): return self._transform - _scale_mapping = { 'linear' : LinearScale, 'log' : LogScale, 'symlog' : SymmetricalLogScale } + + def get_scale_names(): names = _scale_mapping.keys() names.sort() return names + def scale_factory(scale, axis, **kwargs): """ Return a scale class by name. @@ -464,6 +474,7 @@ def scale_factory(scale, axis, **kwargs): scale_factory.__doc__ = dedent(scale_factory.__doc__) % \ {'names': " | ".join(get_scale_names())} + def register_scale(scale_class): """ Register a new kind of scale. @@ -472,6 +483,7 @@ def register_scale(scale_class): """ _scale_mapping[scale_class.name] = scale_class + def get_scale_docs(): """ Helper function for generating docstrings related to scales. @@ -488,6 +500,7 @@ def get_scale_docs(): docs.append("") return "\n".join(docs) + docstring.interpd.update( scale = ' | '.join([repr(x) for x in get_scale_names()]), scale_docs = get_scale_docs().strip(), diff --git a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf index 191c27b90f48b81c65fbf3531245052bab9e7a30..a21f989406bc07267707548583afd419e3cfd6be 100644 GIT binary patch delta 1570 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 Ap#T5? diff --git a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg index d2111d248af3..d3dd610d01d9 100644 --- a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg +++ b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg @@ -30,12 +30,13 @@ z +M393.006 388.8 +L393.006 43.2" style="fill:none;stroke:#0000ff;"/> +M315.491 66.9305 +L518.4 66.9305" style="fill:none;stroke:#0000ff;"/> diff --git a/lib/matplotlib/tests/test_scale.py b/lib/matplotlib/tests/test_scale.py index 6a1b5fc755c4..9b222f2daa1a 100644 --- a/lib/matplotlib/tests/test_scale.py +++ b/lib/matplotlib/tests/test_scale.py @@ -5,9 +5,8 @@ @image_comparison(baseline_images=['log_scales']) -def test_complete(): +def test_log_scales(): ax = plt.subplot(122, yscale='log', xscale='symlog') ax.axvline(24.1) - ax.axhline(24.1) - plt.show() + ax.axhline(24.1) \ No newline at end of file diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py index eb8435a954bf..515a51d3c864 100644 --- a/lib/matplotlib/transforms.py +++ b/lib/matplotlib/transforms.py @@ -1943,18 +1943,18 @@ def transform_non_affine(self, points): y = self._y if x == y and x.input_dims == 2: - return x.transform(points) + return x.transform_non_affine(points) if x.input_dims == 2: - x_points = x.transform(points)[:, 0:1] + x_points = x.transform_non_affine(points)[:, 0:1] else: - x_points = x.transform(points[:, 0]) + x_points = x.transform_non_affine(points[:, 0]) x_points = x_points.reshape((len(x_points), 1)) if y.input_dims == 2: - y_points = y.transform(points)[:, 1:] + y_points = y.transform_non_affine(points)[:, 1:] else: - y_points = y.transform(points[:, 1]) + y_points = y.transform_non_affine(points[:, 1]) y_points = y_points.reshape((len(y_points), 1)) if isinstance(x_points, MaskedArray) or isinstance(y_points, MaskedArray): @@ -1969,19 +1969,16 @@ def inverted(self): def get_affine(self): if self._invalid or self._affine is None: - if self._x.is_affine and self._y.is_affine: - if self._x == self._y: - self._affine = self._x.get_affine() - else: - x_mtx = self._x.get_affine().get_matrix() - y_mtx = self._y.get_affine().get_matrix() - # This works because we already know the transforms are - # separable, though normally one would want to set b and - # c to zero. - mtx = np.vstack((x_mtx[0], y_mtx[1], [0.0, 0.0, 1.0])) - self._affine = Affine2D(mtx) + if self._x == self._y: + self._affine = self._x.get_affine() else: - self._affine = IdentityTransform() + x_mtx = self._x.get_affine().get_matrix() + y_mtx = self._y.get_affine().get_matrix() + # This works because we already know the transforms are + # separable, though normally one would want to set b and + # c to zero. + mtx = np.vstack((x_mtx[0], y_mtx[1], [0.0, 0.0, 1.0])) + self._affine = Affine2D(mtx) self._invalid = 0 return self._affine get_affine.__doc__ = Transform.get_affine.__doc__ From 237e6d09492614156f60ddd5bddb0ebb101c35a2 Mon Sep 17 00:00:00 2001 From: Phil Elson Date: Mon, 17 Sep 2012 12:13:23 +0100 Subject: [PATCH 3/3] Removed text from new result image. --- .../baseline_images/test_scale/log_scales.pdf | Bin 6630 -> 2037 bytes .../baseline_images/test_scale/log_scales.png | Bin 7235 -> 5039 bytes .../baseline_images/test_scale/log_scales.svg | 293 ------------------ lib/matplotlib/tests/test_scale.py | 2 +- 4 files changed, 1 insertion(+), 294 deletions(-) diff --git a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.pdf index a21f989406bc07267707548583afd419e3cfd6be..2ad9a721436c124172aa872217f96ae3ef0b93a2 100644 GIT binary patch delta 1210 zcmaE6{FQ&h2FCiOGraTe7znt0w`%osnDEH`$u()_o2qe7Sbi!LFsaPmxlePWs_E*L zWlaaVKWkyj1E=k%AanG&13eZ`jg^>I^AT+x~<6;jkawRPLk)qb0|7_~QrK1!QX z`YkoAGbiMA$i^toD-)HbN1AR5+*(w8MO@y!eXnl(RlexeWh*0czb55nZ(jv$@Y=F?F;Gf%Q{dX*y?Fqi*&XK+~e!8IF?%=&2eF0}r7 z_0Ls(8(&O{ki8IORC@c|uPI@iudj5oE^HHuQ@Gl9>&=?8*IF4@P1hGYCgrnh;95N_r~=}xuMkjK^hMcFG@jUymbt$C5;;d2f%eUceOGxyq_iPj!ItkLe4?#5*H)|n_Z^Vsa)F_ zA(>P)^P_^B#Y4ASWzUy?-EbYE%Tec*0kf6*w2KzTACwKWI=I~+*uQ5dm-`lK#s8zTc^ffk2TvH zPWfCu4Ru~qaJm%Kb&fu-e1P^WyXa&5p}XDR4`iAPk5J&Ri4pJDOqscCx+H&6i*R1y z^PHMf0~Vkto6kk4@DYc1`!8?Wnw$>w~&B*A8_#$|_SagX8 z%0$@+MaaM-gc-=;1|u{fdwU)iMabCvyE;SyK!^-j!skUrAkY*W4+L+^j^?n~?n{6$ z@Z`y7as?4gKAX#m6PYTcx3q+|f)}XJSRCGk9mru?^J0POkUf=7Lnvet)X|+S;6?FS zz%S4b?jlCeRX`|E5O5J74D8)^CE>G3M|(~fa1w&I4+ECkvRS-9u+o{$4Msx{B8&#+ zYyrw=GsAJQ2kUcO(jL(iw+xv}?Z0&yXYkG8(e%!l*Kb8iG8QQ>B)ppR;p#nC#|4h{ zUSVmQ3dq@Zt`%!~TUm~tWqTaR!Hx?R!~3L{@-=)+i1jlA82S<^^z!^a zqZ`8%I2K(saaWo-Ic|dmcS;TP6a+psmN{GOdbk%gTr2PG*x0$LEiHBW*N5tZsBYQp zmdscEF@xQ%9iN*!EVI47NhkahSTtv=>0g=GY^8PT4U4Z1Dt>sxo_y;Woj!O=>&&im z4rzu#^!cZ9So#Ukdm86Ts7Ee5GJNOyeG>mfbnonTlZrpvDTS{o{W(LoN=urj&eNtx zBwSu{+&=2P)!(1vYPP?ypWacJ-NU(k*rbj10hKg-()XhGfZc%s-47QA4EDUs@OtFi z_i0mn@u&-v6RhlHTQho-TkF=UX$;zm$pUs zj8$tN(~Q1U?EE^rS@xUYWP9~+Ul)(2`0@I?T`l0Y#r@gU@xJFBJ+z8Em2;-e zIT2m_&(l^~kzU^2ko>-U&3(^XtJ4Pyn9JVLc>&rI{mn-Fq z?m8SuiOUuIk{TT&ze-h&;=syvm)u3mxad(~wyuQ`p3k9LUj5JV_esq!Psjdd^T56} zv>>iZ#cWIRxlX2zgIA`w|XkXD&QjR&=qD#E9z1;x0BBi8~Q}W)S;C)+6sP`5r zg_fDcZQJb=SDs3V^7$KylwMHtvVzmoTFU&-{zLS+q-A{>*^O@T)Ze-{ZA*1-i=W#v zs1qf&u!jA8;RBO93m(FSnlcW7N84G+FQ3mrLuDeH%LBUX!(L=K+_XLKS7&Avn|{@_ z(EfqL*T~`&MRjxMz+c--jTKIuIiz9j!`*~rq^{b1CA(T)ZdBL)xZ>1fb(^F)J3T@R zj4$2)5bAwRN9^^R_&+~dPjyGG1QY3t*>Jl(liqdQZB(;Sna zu}xN6pXAo3N`!N#0PcH=d`&#(S+#}ysCtK%7Z;1v`@Jv*a^vqESY_d2b86c$Opr%u zG3UkEn8KL#7fU)~a)(Z+n+Cu6G*ld8*H1q-m%d)|50BUHV67jiKqFNjt4y$j5s4JC zXe%JX!u&IJjb;irkkOh(Ceu6!Zl?*8m5Yi}aL?`c;S5rI7Flk~YLrrGl&EMjYT9U| zE1SMg%fv>OMFReeAtF^RllUK%Gk%~T+=G5b7bOd zC69=Wx3VuK9!ASUUtc=0d7j~E<3-jc_?0bANo{%$3+tYF%^uP#v$ovbpWEbKKcrSM zC{muHX}5@K}HqvK7U`jz|cT@u8Kvf zLpi^OzG7QPy4Rj-!Fu|$6d&uCxm4D6Kgz1yoRe)W_1t^IU9_U=vzD`W_vy`V7ckZC zCc7M_9@`vLnZ^pNiygY`oVq2YPTB21V%D_d`**iKnx$ER(ny>qalka_jq;d_JM zr0rHGdrX%c#&LRBF-1t5PkDtkJPcG*H2P1{ctvwE4JsRsbz6K zvF9u|-fMEH-!VK@^Y5VsT&l_*FTDqaav5%)%(r-63U0h`vHhSD;*^EkyLZnuJ=t$^ z`#VgudRS|%cI(Di#QQJbxmj7FafV9%+LdP2b-BB~m={S{bt&;rdY{!|sXEA4MLtj+ zuo;ZIu7Lz)@7s>^U6HDmwD|3>OHL#Xd3$;z&HY-A5j%IeWo(Gv_`pGqQK42{g8#fS zGkY4^zeDHs(OPB4rh@^#W}g)-QKOPewC=`JX}^4SFkI{WASU0D)1;ON>^o9OatU)+QD6tz_lQcZu_p{G9Zw=4V(< zmp`)JPdk6-!Kpk6L37@j?UL$m|74!h^54=@pZhFv(E^ot|IfqsKE{3fBB^y|gXhH1 zki-vZ|Mr29C}Troyo|9&aZ-WUu;cIR z%PXG_l=xoIu91$`3Yt7vKs8F9)hB7i!qMX+W1X-5 z*&j8FIwj%WTGt>qlA(HJ!xbrysQcG*>RgL<%J%!*mcM>pshvHu;6T>Zott%C=D0f? zd8vPlyf}SIe(AFOU0U@?y^Xqun9FrT<^J(;dU#Kua!Z4d?!Hf7 zBuffctNp-%;>YxVb0C8-rog!DTC7})$Vd)c&~bIMy)%r)w+#E0woR|8T{<~c&2G~> zYN!+8^*NI2S~r92%>A{?2|lt9ULU>jjpXQjD5W*wtYmWe+sNb=$A3OV#!o8!8b9^1 zLW`D;_YX9LeZtSwUlKU6i*E*0w?=tT1FM5^Y9%u!Zwx%Vq9$s1ZTOvqOr>FK@9UW| zamN~N8T2|?nmH?+F}YNxBYPrB@70Z5HG zicGSsH`eRD$ypbb@ZzHDtk}?5{OBo4HVyvMLaWqVyerM~(w9nf4JXyTHhy+w&)|*2 znx8Ze_P<$J!F@U}G+L*buS#mGpj?|NqhhCR9%ok+(N)nNbC;sr79_iLpTxJ{WwhX71w8A{zg=<3!izazg{=hY`XZb1DP{wW#F3YOJZHaPyPiFXZPU>45 zcUacl_XE$SK_>k&as+Qstf%(js*~JP>D3AspJgn!S+8wHd_^|0Xn59U_56H;=ZuT0 z#}8z?sRum$8ZzaA8j9C3ydnK$H(O3{Yp63{algMl#s4>+qrUpx3*^AdsYlZ479a4O z8RIg;=%ngR^7Z}|^m4NbBrH}>rR(Y>+bMslr{DC?-&vNGUeDJq!R?V+<$teNbJ>nf zhMDct(4*~Fs+u}Wdp<)B23oEOG8>ejp|Qc((0 zkaEvCl#yj-5s-Lx(QqEy@Z&!Xw+Fw~>bm*AirG6N>z& zBuZjHfD8jWW;hdQ=$)kgrvUSQ~IinPhw^MWS{i)~d-FF>&m4BM+7q#(u zyhrK#A?XFK(b16>HydaD=u9+5FVOqhvIQ(YCj#a15u&h9#V=)sgZ9pvg9;BnE7*Ld z2k1kM-Fe|mE)EY{S{EkD=U}a-34s8=bMQMl11+aDQ^3Yr-~XA77bg%65gRN?d?Kyk_3P})xP$6q!=W9$fr69&6G7a!GHANUC z2I7mu+i^k13Y&6sa~$556BNXT9X05OS0fZEf)9y{2w`&(P{#4`Y(5Xc^SHo%GzQGj z5I!5sgFycb{&J$hTmbCG3)sJtt1qhjh!+SfhIl&<)LIvO7h!)T_V&TNt{x7j~Va8%{0I{c# z;5ACb2wOTCNOJ_2Dje2gZg3bI3STVL89G(WEKv1HMyBByR02W=-x!HbMaW>Ifj|X%!uOD#Od|?MG9A+Y8{kCm$$%CDd{Ss0t7IJBYaN= z06G{tSPywJOc`Jl;^2rGL#E^42$g_FL7;)J7_OxP!-YHmEs%@N$rRuSQw*qd1~xM2 zKwp5T5lO&6p1P1Az{}v6!={U=8LJ zk#cavG7ULr z8bQc#B1JF`6gnUR^#`gC^I()eq=HB+nE)sFJjw+sMIhj?cOwiKGzKC9mZf%Th&-N%X*D)I7b4}v}Z zz1YV1y}F6%{~alIgYX?G*2;fJifSWvyUU9L1)qrEoj8GT=fN(4-QoSLa1RmQT#Kz0 zla03lH>)Uz$F+qw>)|NCYB@z#vkHB$6qWU`Qa&BM{~pVAt1yQ7mv(J3pL>MuhRu zFirpx5g3F7Fj;HCMg&MOR$#Xmry!b;ObC1y(Fh4a(Fij<{`+bZL68ZTjT(q~GM3K{ z!hw=X!-0Y~@&oD_6+}M>8O6as!ykkz!ck3Ow8!D-@c1wuM+U(fkE4PBjmLqSIswO+ zAeTU(O`s!?=@VoSNCc39V`UJjj0yTts1xZZB*p}OWClFCjO9nAfaTLl#JLq7K8b?Pp6_!FsVZ*A{IKGv`DpdMcBDz4mSZ|;SU$NNpo}Bd)w3R_x&E< zJ+W)2ld6i23IIUW#o5sl0E__uXdj#+e5W8b0IsgXS8Sn}-v;qLfR~P_5KKa34`g4~61&Y$c`x|mP&e`S> z^tWZl33-`BrF@P=*w5xxQrN9o`fQm*=#({91&g|8d_o#UqtVvbD2gmZzjc*8A3m3S zia5AmSsj#$WWvTg&&e11iX9ytsbvHGv_w-r|9rN`IoHvs(T#x=3L73%Q>=kT2u=RY z@Wxl(uABH$Df9Bvt?@dOKMW6hPVBQTkO@_%^wK$~*Wlex!8UolOeC?Zv;C+SYfi!K zk*VcZyW3&{N}Nuo09251YlI~R9UVgoIWz2A8@ATw?yVoO_&IT|3qozyq{C}C)C`;Doy{|<1`9E&ZpbN2$H`V20QcJtY2NK z=f8*%D@hvpB8|%;aC-1>k0!(VwlxTYeRDmjrZwH2gFqvsJg3`_SwR(V z+@lWn%(pyM-P47Mj$UBR7E2@ROd0o@b6BXolUxSa<9VPr2}dzh9R_CRrmIl;ebHtMPsV>ai=v`j20C|0k<0Vehm0Vz&z z3RWCT3b_WCbKj>4L1)1`$Qts3eO-~7Ib~toi)y_6sQl{{oh9ye2;PI1ZPzPGT7gmI{{p&} zHBcHN_3h(Cx&r>TZ${MV`e+5lMawib1T@PuUb?BzY+?)rAV0&uioxqmxhJpp;bt^F z3h%v`dbc>FL3X+c$l-zZLN{1EO;Rz2MN?*xW^a`L|;6YE1n9>7)p{$Uwu7h&8`hgH7a-ug29iV#4!oQR`F`$NPXux z981nLUD)zBw9R$xg}3IBI>@dWNkvQ}LY2fRq{hpt=h5UDeQB|JLsI3S5mumCwBuFF zpv@23blyRD)0T+OEv#e&j;y@`*&{a;ggp>CWVy_@CCGyB2j3iEezUO{6tQb z*DkjReH%2i2c?hJM;BR;iY4ozSpDsCvp32NQ(^pAsPhel!g$W;;=^xtUID*ZT=eLqpTKv+?Ak)7;07w4w*`9D*SMs@_~AYEk#1=AKWun` SXhwon1TLTLbgZxsO8FC|G^phO literal 7235 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 diff --git a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg index d3dd610d01d9..9c6f9cfecafb 100644 --- a/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg +++ b/lib/matplotlib/tests/baseline_images/test_scale/log_scales.svg @@ -60,49 +60,6 @@ L0 4" id="mdad270ee8e" style="stroke:#000000;stroke-linecap:butt;stroke-width:0. - - - - - - - - - - - - @@ -115,39 +72,6 @@ z - - - - - - - - - - - @@ -206,34 +130,6 @@ L-4 0" id="m0d5b0a6425" style="stroke:#000000;stroke-linecap:butt;stroke-width:0 - - - - - - - - - - - - - @@ -246,45 +142,6 @@ z - - - - - - - - - - - - @@ -297,42 +154,6 @@ Q48.4844 72.75 52.5938 71.2969" id="BitstreamVeraSans-Roman-36"/> - - - - - - - - - - - - @@ -345,36 +166,6 @@ z - - - - - - - - - - - - @@ -387,48 +178,6 @@ z - - - - - - - - - - - - @@ -441,15 +190,6 @@ Q46.9688 40.9219 40.5781 39.3125" id="BitstreamVeraSans-Roman-33"/> - - - - - - - - - @@ -462,15 +202,6 @@ Q46.9688 40.9219 40.5781 39.3125" id="BitstreamVeraSans-Roman-33"/> - - - - - - - - - @@ -483,14 +214,6 @@ Q46.9688 40.9219 40.5781 39.3125" id="BitstreamVeraSans-Roman-33"/> - - - - - - - - @@ -503,14 +226,6 @@ Q46.9688 40.9219 40.5781 39.3125" id="BitstreamVeraSans-Roman-33"/> - - - - - - - - @@ -523,14 +238,6 @@ Q46.9688 40.9219 40.5781 39.3125" id="BitstreamVeraSans-Roman-33"/> - - - - - - - - diff --git a/lib/matplotlib/tests/test_scale.py b/lib/matplotlib/tests/test_scale.py index 9b222f2daa1a..fd705834fa26 100644 --- a/lib/matplotlib/tests/test_scale.py +++ b/lib/matplotlib/tests/test_scale.py @@ -4,7 +4,7 @@ import matplotlib.pyplot as plt -@image_comparison(baseline_images=['log_scales']) +@image_comparison(baseline_images=['log_scales'], remove_text=True) def test_log_scales(): ax = plt.subplot(122, yscale='log', xscale='symlog')