def draw_lines(self, gc, x, y, trans):
"""
x and y are equal length arrays, draw lines connecting each
point in x, y
"""
x, y = trans.numerix_x_y(x,y)
if len(x)<2: return
path = agg.path_storage()
path.move_to(x[0],self.height-y[0])
for i in xrange(1, len(x)):
path.line_to(x[i],self.height-y[i])
stroke = agg.conv_stroke(path)
stroke.width(1.0)
r,g,b = [int(255*val) for val in gc.get_rgb()]
a = int(255*gc.get_alpha())
color = agg.rgba8(r,g,b,a)
self.renderer.color( color )
self.rasterizer.add_path(stroke)
agg.render_scanlines(self.rasterizer, self.scanline, self.renderer);
def draw_lines(self, gc, x, y, trans):
"""
x and y are equal length arrays, draw lines connecting each
point in x, y
"""
x, y = trans.numerix_x_y(x, y)
if len(x) < 2: return
path = agg.path_storage()
path.move_to(x[0], self.height - y[0])
for i in xrange(1, len(x)):
path.line_to(x[i], self.height - y[i])
stroke = agg.conv_stroke(path)
stroke.width(1.0)
r, g, b = [int(255 * val) for val in gc.get_rgb()]
a = int(255 * gc.get_alpha())
color = agg.rgba8(r, g, b, a)
self.renderer.color(color)
self.rasterizer.add_path(stroke)
agg.render_scanlines(self.rasterizer, self.scanline, self.renderer)
scaling = agg.trans_affine_scaling(20,20) translation = agg.trans_affine_translation(4,4) rotation = agg.trans_affine_rotation(3.1415926) mtrans = translation*scaling # cannot use this as a temporary tpath = agg.conv_transform_path(path, mtrans) curve = agg.conv_curve_trans(tpath) stride = width*4 buffer = agg.buffer(width, height, stride) rbuf = agg.rendering_buffer() rbuf.attachb(buffer) red = agg.rgba8(255,0,0,255) blue = agg.rgba8(0,0,255,255) white = agg.rgba8(255,255,255,255) pf = agg.pixel_format_rgba(rbuf) rbase = agg.renderer_base_rgba(pf) rbase.clear_rgba8(white) renderer = agg.renderer_scanline_aa_solid_rgba(rbase); rasterizer = agg.rasterizer_scanline_aa() scanline = agg.scanline_p8() # first fill rasterizer.add_path(curve)
# this example uses the agg python module directly there is no # documentation -- you have to know how to use the agg c++ API to use # it import matplotlib.agg as agg from math import pi ## Define some colors red = agg.rgba8(255,0,0,255) blue = agg.rgba8(0,0,255,255) green = agg.rgba8(0,255,0,255) black = agg.rgba8(0,0,0,255) white = agg.rgba8(255,255,255,255) yellow = agg.rgba8(192,192,255,255) ## Create the rendering buffer, rasterizer, etc width, height = 600,400 stride = width*4 buffer = agg.buffer(width, height, stride) rbuf = agg.rendering_buffer() rbuf.attachb(buffer) pf = agg.pixel_format_rgba(rbuf) rbase = agg.renderer_base_rgba(pf) rbase.clear_rgba8(blue) renderer = agg.renderer_scanline_aa_solid_rgba(rbase); renderer.color_rgba8( red ) rasterizer = agg.rasterizer_scanline_aa() scanline = agg.scanline_p8()
class RendererAgg(Renderer):
gray = agg.rgba8(128, 128, 128, 255)
white = agg.rgba8(255, 255, 255, 255)
blue = agg.rgba8(0, 0, 255, 255)
black = agg.rgba8(0, 0, 0, 0)
pathd = traits.Dict(Int, PathPrimitiveAgg)
markerd = traits.Dict(Int, MarkerPrimitiveAgg)
def _size_changed(self, old, new):
Renderer._size_changed(self, old, new)
width, height = self.size
stride = width * 4
self.buf = buf = agg.buffer(width, height, stride)
self.rbuf = rbuf = agg.rendering_buffer()
rbuf.attachb(buf)
self.pf = pf = agg.pixel_format_rgba(rbuf)
self.rbase = rbase = agg.renderer_base_rgba(pf)
rbase.clear_rgba8(self.white)
# the antialiased renderers
self.renderer = agg.renderer_scanline_aa_solid_rgba(rbase)
self.rasterizer = agg.rasterizer_scanline_aa()
self.scanline = agg.scanline_p8()
self.trans = None
# the aliased renderers
self.rendererbin = agg.renderer_scanline_bin_solid_rgba(rbase)
self.scanlinebin = agg.scanline_bin()
def new_path_primitive(self):
'return a PathPrimitive (or derived)'
return PathPrimitiveAgg()
def new_marker_primitive(self):
'return a MarkerPrimitive (or derived)'
return MarkerPrimitiveAgg()
def render_path(self, pathid):
path = self.pathd[pathid]
if path.antialiased:
renderer = self.renderer
scanline = self.scanline
render_scanlines = agg.render_scanlines_rgba
else:
renderer = self.rendererbin
scanline = self.scanlinebin
render_scanlines = agg.render_scanlines_bin_rgba
affine = self.adisplay * path.affine
#print 'display affine:\n', self.adisplay
#print 'path affine:\n', path.affine
#print 'product affine:\n', affine
aggaffine = agg.trans_affine(*affine.vec6)
transpath = agg.conv_transform_path(path.agg_path, aggaffine)
if path.facecolor is not None:
#print 'render path', path.facecolor, path.agg_facecolor
self.rasterizer.add_path(transpath)
renderer.color_rgba8(path.agg_facecolor)
render_scanlines(self.rasterizer, scanline, renderer)
if path.color is not None:
stroke = agg.conv_stroke_transpath(transpath)
stroke.width(path.linewidth)
self.rasterizer.add_path(stroke)
renderer.color_rgba8(path.agg_color)
render_scanlines(self.rasterizer, scanline, renderer)
def render_marker(self, markerid):
marker = self.markerd[markerid]
path = marker.path
if path.antialiased:
renderer = self.renderer
scanline = self.scanline
render_scanlines = agg.render_scanlines_rgba
else:
renderer = self.rendererbin
scanline = self.scanlinebin
render_scanlines = agg.render_scanlines_bin_rgba
affinelocs = self.adisplay * marker.affine
Nmarkers = marker.locs.shape[0]
Locs = npy.ones((3, Nmarkers))
Locs[0] = marker.locs[:, 0]
Locs[1] = marker.locs[:, 1]
Locs = affinelocs * Locs
dpiscale = self.dpi / 72. # for some reason this is broken
# this will need to be highly optimized and hooked into some
# extension code using cached marker rasters as we now do in
# _backend_agg
pathcodes, pathxy = marker.path.pathdata
pathx = dpiscale * pathxy[:, 0]
pathy = dpiscale * pathxy[:, 1]
Npath = len(pathcodes)
XY = npy.ones((Npath, 2))
for xv, yv, tmp in Locs.T:
XY[:, 0] = (pathx + xv).astype(int) + 0.5
XY[:, 1] = (pathy + yv).astype(int) + 0.5
pathdata = pathcodes, XY
aggpath = PathPrimitiveAgg.make_agg_path(pathdata)
if path.facecolor is not None:
self.rasterizer.add_path(aggpath)
renderer.color_rgba8(path.agg_facecolor)
render_scanlines(self.rasterizer, scanline, renderer)
if path.color is not None:
stroke = agg.conv_stroke_path(aggpath)
stroke.width(path.linewidth)
self.rasterizer.add_path(stroke)
renderer.color_rgba8(path.agg_color)
render_scanlines(self.rasterizer, scanline, renderer)
def show(self):
# we'll cheat a little and use pylab for display
X = npy.fromstring(self.buf.to_string(), npy.uint8)
width, height = self.size
X.shape = height, width, 4
if 1:
import pylab
fig = pylab.figure()
ax = fig.add_axes([0, 0, 1, 1],
xticks=[],
yticks=[],
frameon=False,
aspect='auto')
ax.imshow(X, aspect='auto')
pylab.show()
def color_to_rgba8(self, color):
if color is None: return None
rgba = [int(255 * c) for c in color]
return agg.rgba8(*rgba)
def color_to_rgba8(self, color):
if color is None:
return None
rgba = [int(255 * c) for c in color]
return agg.rgba8(*rgba)
