演示Agg过滤器

演示Agg过滤器示例

  1. import matplotlib.pyplot as plt
  3. import numpy as np
  4. import matplotlib.cm as cm
  5. import matplotlib.transforms as mtransforms
  6. from matplotlib.colors import LightSource
  7. from matplotlib.artist import Artist
  10. def smooth1d(x, window_len):
  11.     # copied from http://www.scipy.org/Cookbook/SignalSmooth
  13.     s = np.r_[2*x[0] - x[window_len:1:-1], x, 2*x[-1] - x[-1:-window_len:-1]]
  14.     w = np.hanning(window_len)
  15.     y = np.convolve(w/w.sum(), s, mode='same')
  16.     return y[window_len-1:-window_len+1]
  19. def smooth2d(A, sigma=3):
  21.     window_len = max(int(sigma), 3)*2 + 1
  22.     A1 = np.array([smooth1d(x, window_len) for x in np.asarray(A)])
  23.     A2 = np.transpose(A1)
  24.     A3 = np.array([smooth1d(x, window_len) for x in A2])
  25.     A4 = np.transpose(A3)
  27.     return A4
  30. class BaseFilter(object):
  31.     def prepare_image(self, src_image, dpi, pad):
  32.         ny, nx, depth = src_image.shape
  33.         # tgt_image = np.zeros([pad*2+ny, pad*2+nx, depth], dtype="d")
  34.         padded_src = np.zeros([pad*2 + ny, pad*2 + nx, depth], dtype="d")
  35.         padded_src[pad:-pad, pad:-pad, :] = src_image[:, :, :]
  37.         return padded_src  # , tgt_image
  39.     def get_pad(self, dpi):
  40.         return 0
  42.     def __call__(self, im, dpi):
  43.         pad = self.get_pad(dpi)
  44.         padded_src = self.prepare_image(im, dpi, pad)
  45.         tgt_image = self.process_image(padded_src, dpi)
  46.         return tgt_image, -pad, -pad
  49. class OffsetFilter(BaseFilter):
  50.     def __init__(self, offsets=None):
  51.         if offsets is None:
  52.             self.offsets = (0, 0)
  53.         else:
  54.             self.offsets = offsets
  56.     def get_pad(self, dpi):
  57.         return int(max(*self.offsets)/72.*dpi)
  59.     def process_image(self, padded_src, dpi):
  60.         ox, oy = self.offsets
  61.         a1 = np.roll(padded_src, int(ox/72.*dpi), axis=1)
  62.         a2 = np.roll(a1, -int(oy/72.*dpi), axis=0)
  63.         return a2
  66. class GaussianFilter(BaseFilter):
  67.     "simple gauss filter"
  69.     def __init__(self, sigma, alpha=0.5, color=None):
  70.         self.sigma = sigma
  71.         self.alpha = alpha
  72.         if color is None:
  73.             self.color = (0, 0, 0)
  74.         else:
  75.             self.color = color
  77.     def get_pad(self, dpi):
  78.         return int(self.sigma*3/72.*dpi)
  80.     def process_image(self, padded_src, dpi):
  81.         # offsetx, offsety = int(self.offsets[0]), int(self.offsets[1])
  82.         tgt_image = np.zeros_like(padded_src)
  83.         aa = smooth2d(padded_src[:, :, -1]*self.alpha,
  84.                       self.sigma/72.*dpi)
  85.         tgt_image[:, :, -1] = aa
  86.         tgt_image[:, :, :-1] = self.color
  87.         return tgt_image
  90. class DropShadowFilter(BaseFilter):
  91.     def __init__(self, sigma, alpha=0.3, color=None, offsets=None):
  92.         self.gauss_filter = GaussianFilter(sigma, alpha, color)
  93.         self.offset_filter = OffsetFilter(offsets)
  95.     def get_pad(self, dpi):
  96.         return max(self.gauss_filter.get_pad(dpi),
  97.                    self.offset_filter.get_pad(dpi))
  99.     def process_image(self, padded_src, dpi):
  100.         t1 = self.gauss_filter.process_image(padded_src, dpi)
  101.         t2 = self.offset_filter.process_image(t1, dpi)
  102.         return t2
  105. class LightFilter(BaseFilter):
  106.     "simple gauss filter"
  108.     def __init__(self, sigma, fraction=0.5):
  109.         self.gauss_filter = GaussianFilter(sigma, alpha=1)
  110.         self.light_source = LightSource()
  111.         self.fraction = fraction
  113.     def get_pad(self, dpi):
  114.         return self.gauss_filter.get_pad(dpi)
  116.     def process_image(self, padded_src, dpi):
  117.         t1 = self.gauss_filter.process_image(padded_src, dpi)
  118.         elevation = t1[:, :, 3]
  119.         rgb = padded_src[:, :, :3]
  121.         rgb2 = self.light_source.shade_rgb(rgb, elevation,
  122.                                            fraction=self.fraction)
  124.         tgt = np.empty_like(padded_src)
  125.         tgt[:, :, :3] = rgb2
  126.         tgt[:, :, 3] = padded_src[:, :, 3]
  128.         return tgt
  131. class GrowFilter(BaseFilter):
  132.     "enlarge the area"
  134.     def __init__(self, pixels, color=None):
  135.         self.pixels = pixels
  136.         if color is None:
  137.             self.color = (1, 1, 1)
  138.         else:
  139.             self.color = color
  141.     def __call__(self, im, dpi):
  142.         pad = self.pixels
  143.         ny, nx, depth = im.shape
  144.         new_im = np.empty([pad*2 + ny, pad*2 + nx, depth], dtype="d")
  145.         alpha = new_im[:, :, 3]
  146.         alpha.fill(0)
  147.         alpha[pad:-pad, pad:-pad] = im[:, :, -1]
  148.         alpha2 = np.clip(smooth2d(alpha, self.pixels/72.*dpi) * 5, 0, 1)
  149.         new_im[:, :, -1] = alpha2
  150.         new_im[:, :, :-1] = self.color
  151.         offsetx, offsety = -pad, -pad
  153.         return new_im, offsetx, offsety
  156. class FilteredArtistList(Artist):
  157.     """
  158.     A simple container to draw filtered artist.
  159.     """
  161.     def __init__(self, artist_list, filter):
  162.         self._artist_list = artist_list
  163.         self._filter = filter
  164.         Artist.__init__(self)
  166.     def draw(self, renderer):
  167.         renderer.start_rasterizing()
  168.         renderer.start_filter()
  169.         for a in self._artist_list:
  170.             a.draw(renderer)
  171.         renderer.stop_filter(self._filter)
  172.         renderer.stop_rasterizing()
  175. def filtered_text(ax):
  176.     # mostly copied from contour_demo.py
  178.     # prepare image
  179.     delta = 0.025
  180.     x = np.arange(-3.0, 3.0, delta)
  181.     y = np.arange(-2.0, 2.0, delta)
  182.     X, Y = np.meshgrid(x, y)
  183.     Z1 = np.exp(-X**2 - Y**2)
  184.     Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
  185.     Z = (Z1 - Z2) * 2
  187.     # draw
  188.     im = ax.imshow(Z, interpolation='bilinear', origin='lower',
  189.                    cmap=cm.gray, extent=(-3, 3, -2, 2))
  190.     levels = np.arange(-1.2, 1.6, 0.2)
  191.     CS = ax.contour(Z, levels,
  192.                     origin='lower',
  193.                     linewidths=2,
  194.                     extent=(-3, 3, -2, 2))
  196.     ax.set_aspect("auto")
  198.     # contour label
  199.     cl = ax.clabel(CS, levels[1::2],  # label every second level
  200.                    inline=1,
  201.                    fmt='%1.1f',
  202.                    fontsize=11)
  204.     # change clable color to black
  205.     from matplotlib.patheffects import Normal
  206.     for t in cl:
  207.         t.set_color("k")
  208.         # to force TextPath (i.e., same font in all backends)
  209.         t.set_path_effects([Normal()])
  211.     # Add white glows to improve visibility of labels.
  212.     white_glows = FilteredArtistList(cl, GrowFilter(3))
  213.     ax.add_artist(white_glows)
  214.     white_glows.set_zorder(cl[0].get_zorder() - 0.1)
  216.     ax.xaxis.set_visible(False)
  217.     ax.yaxis.set_visible(False)
  220. def drop_shadow_line(ax):
  221.     # copied from examples/misc/svg_filter_line.py
  223.     # draw lines
  224.     l1, = ax.plot([0.1, 0.5, 0.9], [0.1, 0.9, 0.5], "bo-",
  225.                   mec="b", mfc="w", lw=5, mew=3, ms=10, label="Line 1")
  226.     l2, = ax.plot([0.1, 0.5, 0.9], [0.5, 0.2, 0.7], "ro-",
  227.                   mec="r", mfc="w", lw=5, mew=3, ms=10, label="Line 1")
  229.     gauss = DropShadowFilter(4)
  231.     for l in [l1, l2]:
  233.         # draw shadows with same lines with slight offset.
  235.         xx = l.get_xdata()
  236.         yy = l.get_ydata()
  237.         shadow, = ax.plot(xx, yy)
  238.         shadow.update_from(l)
  240.         # offset transform
  241.         ot = mtransforms.offset_copy(l.get_transform(), ax.figure,
  242.                                      x=4.0, y=-6.0, units='points')
  244.         shadow.set_transform(ot)
  246.         # adjust zorder of the shadow lines so that it is drawn below the
  247.         # original lines
  248.         shadow.set_zorder(l.get_zorder() - 0.5)
  249.         shadow.set_agg_filter(gauss)
  250.         shadow.set_rasterized(True)  # to support mixed-mode renderers
  252.     ax.set_xlim(0., 1.)
  253.     ax.set_ylim(0., 1.)
  255.     ax.xaxis.set_visible(False)
  256.     ax.yaxis.set_visible(False)
  259. def drop_shadow_patches(ax):
  260.     # Copied from barchart_demo.py
  261.     N = 5
  262.     menMeans = (20, 35, 30, 35, 27)
  264.     ind = np.arange(N)  # the x locations for the groups
  265.     width = 0.35       # the width of the bars
  267.     rects1 = ax.bar(ind, menMeans, width, color='r', ec="w", lw=2)
  269.     womenMeans = (25, 32, 34, 20, 25)
  270.     rects2 = ax.bar(ind + width + 0.1, womenMeans, width,
  271.                     color='y', ec="w", lw=2)
  273.     # gauss = GaussianFilter(1.5, offsets=(1,1), )
  274.     gauss = DropShadowFilter(5, offsets=(1, 1), )
  275.     shadow = FilteredArtistList(rects1 + rects2, gauss)
  276.     ax.add_artist(shadow)
  277.     shadow.set_zorder(rects1[0].get_zorder() - 0.1)
  279.     ax.set_ylim(0, 40)
  281.     ax.xaxis.set_visible(False)
  282.     ax.yaxis.set_visible(False)
  285. def light_filter_pie(ax):
  286.     fracs = [15, 30, 45, 10]
  287.     explode = (0, 0.05, 0, 0)
  288.     pies = ax.pie(fracs, explode=explode)
  289.     ax.patch.set_visible(True)
  291.     light_filter = LightFilter(9)
  292.     for p in pies[0]:
  293.         p.set_agg_filter(light_filter)
  294.         p.set_rasterized(True)  # to support mixed-mode renderers
  295.         p.set(ec="none",
  296.               lw=2)
  298.     gauss = DropShadowFilter(9, offsets=(3, 4), alpha=0.7)
  299.     shadow = FilteredArtistList(pies[0], gauss)
  300.     ax.add_artist(shadow)
  301.     shadow.set_zorder(pies[0][0].get_zorder() - 0.1)
  304. if 1:
  306.     plt.figure(1, figsize=(6, 6))
  307.     plt.subplots_adjust(left=0.05, right=0.95)
  309.     ax = plt.subplot(221)
  310.     filtered_text(ax)
  312.     ax = plt.subplot(222)
  313.     drop_shadow_line(ax)
  315.     ax = plt.subplot(223)
  316.     drop_shadow_patches(ax)
  318.     ax = plt.subplot(224)
  319.     ax.set_aspect(1)
  320.     light_filter_pie(ax)
  321.     ax.set_frame_on(True)
  323.     plt.show()

下载这个示例