Revision: 6340
http://matplotlib.svn.sourceforge.net/matplotlib/?rev=6340&view=rev
Author: mdboom
Date: 2008-10-27 21:13:24 +0000 (Mon, 27 Oct 2008)
Log Message:
-----------
Reduce heap allocation of objects. Be safer when forced to do heap allocation.
Remove some dead code.
Modified Paths:
--------------
trunk/matplotlib/src/_backend_agg.cpp
trunk/matplotlib/src/_backend_agg.h
Modified: trunk/matplotlib/src/_backend_agg.cpp
===================================================================
--- trunk/matplotlib/src/_backend_agg.cpp 2008-10-27 19:40:25 UTC (rev
6339)
+++ trunk/matplotlib/src/_backend_agg.cpp 2008-10-27 21:13:24 UTC (rev
6340)
@@ -263,63 +263,57 @@
height(height),
dpi(dpi),
NUMBYTES(width*height*4),
+ pixBuffer(NULL),
+ renderingBuffer(),
alphaBuffer(NULL),
- alphaMaskRenderingBuffer(NULL),
- alphaMask(NULL),
- pixfmtAlphaMask(NULL),
- rendererBaseAlphaMask(NULL),
- rendererAlphaMask(NULL),
- scanlineAlphaMask(NULL),
+ alphaMaskRenderingBuffer(),
+ alphaMask(alphaMaskRenderingBuffer),
+ pixfmtAlphaMask(alphaMaskRenderingBuffer),
+ rendererBaseAlphaMask(),
+ rendererAlphaMask(),
+ scanlineAlphaMask(),
+ slineP8(),
+ slineBin(),
+ pixFmt(),
+ rendererBase(),
+ rendererAA(),
+ rendererBin(),
+ theRasterizer(),
debug(debug)
{
_VERBOSE("RendererAgg::RendererAgg");
unsigned stride(width*4);
pixBuffer = new agg::int8u[NUMBYTES];
- renderingBuffer = new agg::rendering_buffer;
- renderingBuffer->attach(pixBuffer, width, height, stride);
-
- slineP8 = new scanline_p8;
- slineBin = new scanline_bin;
-
- pixFmt = new pixfmt(*renderingBuffer);
- rendererBase = new renderer_base(*pixFmt);
- rendererBase->clear(agg::rgba(1, 1, 1, 0));
-
- rendererAA = new renderer_aa(*rendererBase);
- rendererBin = new renderer_bin(*rendererBase);
- theRasterizer = new rasterizer();
- //theRasterizer->filling_rule(agg::fill_even_odd);
- //theRasterizer->filling_rule(agg::fill_non_zero);
-
+ renderingBuffer.attach(pixBuffer, width, height, stride);
+ pixFmt.attach(renderingBuffer);
+ rendererBase.attach(pixFmt);
+ rendererBase.clear(agg::rgba(1, 1, 1, 0));
+ rendererAA.attach(rendererBase);
+ rendererBin.attach(rendererBase);
}
void RendererAgg::create_alpha_buffers() {
if (!alphaBuffer) {
unsigned stride(width*4);
alphaBuffer = new agg::int8u[NUMBYTES];
- alphaMaskRenderingBuffer = new agg::rendering_buffer;
- alphaMaskRenderingBuffer->attach(alphaBuffer, width, height, stride);
- alphaMask = new alpha_mask_type(*alphaMaskRenderingBuffer);
-
- pixfmtAlphaMask = new agg::pixfmt_gray8(*alphaMaskRenderingBuffer);
- rendererBaseAlphaMask = new
renderer_base_alpha_mask_type(*pixfmtAlphaMask);
- rendererAlphaMask = new
renderer_alpha_mask_type(*rendererBaseAlphaMask);
- scanlineAlphaMask = new agg::scanline_p8();
+ alphaMaskRenderingBuffer.attach(alphaBuffer, width, height, stride);
+ rendererBaseAlphaMask.attach(pixfmtAlphaMask);
+ rendererAlphaMask.attach(rendererBaseAlphaMask);
}
}
template<class R>
void
-RendererAgg::set_clipbox(const Py::Object& cliprect, R rasterizer) {
+RendererAgg::set_clipbox(const Py::Object& cliprect, R& rasterizer) {
//set the clip rectangle from the gc
_VERBOSE("RendererAgg::set_clipbox");
double l, b, r, t;
if (py_convert_bbox(cliprect.ptr(), l, b, r, t)) {
- rasterizer->clip_box(int(mpl_round(l)) + 1, height - int(mpl_round(b)),
- int(mpl_round(r)), height - int(mpl_round(t)));
+ rasterizer.clip_box(int(mpl_round(l)) + 1, height - int(mpl_round(b)),
+ int(mpl_round(r)), height - int(mpl_round(t)));
}
_VERBOSE("RendererAgg::set_clipbox done");
@@ -341,45 +335,6 @@
return face;
}
-SnapData
-SafeSnap::snap (const float& x, const float& y) {
- xsnap = (int)(x + 0.5f);
- ysnap = (int)(y + 0.5f);
-
- if ( first || ( (xsnap!=lastxsnap) || (ysnap!=lastysnap) ) ) {
- lastxsnap = xsnap;
- lastysnap = ysnap;
- lastx = x;
- lasty = y;
- first = false;
- return SnapData(true, xsnap, ysnap);
- }
-
- // ok both are equal and we need to do an offset
- if ( (x==lastx) && (y==lasty) ) {
- // no choice but to return equal coords; set newpoint = false
- lastxsnap = xsnap;
- lastysnap = ysnap;
- lastx = x;
- lasty = y;
- return SnapData(false, xsnap, ysnap);
- }
-
- // ok the real points are not identical but the rounded ones, so do
- // a one pixel offset
- if (x>lastx) xsnap += 1.;
- else if (x<lastx) xsnap -= 1.;
-
- if (y>lasty) ysnap += 1.;
- else if (y<lasty) ysnap -= 1.;
-
- lastxsnap = xsnap;
- lastysnap = ysnap;
- lastx = x;
- lasty = y;
- return SnapData(true, xsnap, ysnap);
-}
-
template<class Path>
bool should_snap(Path& path, const agg::trans_affine& trans) {
// If this contains only straight horizontal or vertical lines, it should be
@@ -443,12 +398,17 @@
throw Py::MemoryError("RendererAgg::copy_from_bbox could not allocate
memory for buffer");
}
- agg::rendering_buffer rbuf;
- rbuf.attach(reg->data, reg->width, reg->height, reg->stride);
+ try {
+ agg::rendering_buffer rbuf;
+ rbuf.attach(reg->data, reg->width, reg->height, reg->stride);
- pixfmt pf(rbuf);
- renderer_base rb(pf);
- rb.copy_from(*renderingBuffer, &rect, -rect.x1, -rect.y1);
+ pixfmt pf(rbuf);
+ renderer_base rb(pf);
+ rb.copy_from(renderingBuffer, &rect, -rect.x1, -rect.y1);
+ } catch (...) {
+ delete reg;
+ throw Py::RuntimeError("An unknown error occurred in copy_from_bbox");
+ }
return Py::asObject(reg);
}
@@ -468,7 +428,7 @@
region->height,
region->stride);
- rendererBase->copy_from(rbuf, 0, region->rect.x1, region->rect.y1);
+ rendererBase.copy_from(rbuf, 0, region->rect.x1, region->rect.y1);
return Py::Object();
}
@@ -488,12 +448,12 @@
trans *= agg::trans_affine_translation(0.0, (double)height);
PathIterator clippath_iter(clippath);
- rendererBaseAlphaMask->clear(agg::gray8(0, 0));
+ rendererBaseAlphaMask.clear(agg::gray8(0, 0));
transformed_path_t transformed_clippath(clippath_iter, trans);
agg::conv_curve<transformed_path_t> curved_clippath(transformed_clippath);
- theRasterizer->add_path(curved_clippath);
- rendererAlphaMask->color(agg::gray8(255, 255));
- agg::render_scanlines(*theRasterizer, *scanlineAlphaMask,
*rendererAlphaMask);
+ theRasterizer.add_path(curved_clippath);
+ rendererAlphaMask.color(agg::gray8(255, 255));
+ agg::render_scanlines(theRasterizer, scanlineAlphaMask, rendererAlphaMask);
lastclippath = clippath;
lastclippath_transform = clippath_trans;
}
@@ -544,24 +504,22 @@
//maxim's suggestions for cached scanlines
agg::scanline_storage_aa8 scanlines;
- theRasterizer->reset();
- theRasterizer->reset_clipping();
- rendererBase->reset_clipping(true);
+ theRasterizer.reset();
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
agg::int8u staticFillCache[MARKER_CACHE_SIZE];
agg::int8u staticStrokeCache[MARKER_CACHE_SIZE];
- agg::int8u* fillCache = NULL;
- agg::int8u* strokeCache = NULL;
+ agg::int8u* fillCache = staticFillCache;
+ agg::int8u* strokeCache = staticStrokeCache;
try {
unsigned fillSize = 0;
if (face.first) {
- theRasterizer->add_path(marker_path_curve);
- agg::render_scanlines(*theRasterizer, *slineP8, scanlines);
+ theRasterizer.add_path(marker_path_curve);
+ agg::render_scanlines(theRasterizer, slineP8, scanlines);
fillSize = scanlines.byte_size();
- if (fillSize < MARKER_CACHE_SIZE)
- fillCache = staticFillCache;
- else
+ if (fillSize >= MARKER_CACHE_SIZE)
fillCache = new agg::int8u[fillSize];
scanlines.serialize(fillCache);
}
@@ -570,18 +528,16 @@
stroke.width(gc.linewidth);
stroke.line_cap(gc.cap);
stroke.line_join(gc.join);
- theRasterizer->reset();
- theRasterizer->add_path(stroke);
- agg::render_scanlines(*theRasterizer, *slineP8, scanlines);
+ theRasterizer.reset();
+ theRasterizer.add_path(stroke);
+ agg::render_scanlines(theRasterizer, slineP8, scanlines);
unsigned strokeSize = scanlines.byte_size();
- if (strokeSize < MARKER_CACHE_SIZE)
- strokeCache = staticStrokeCache;
- else
+ if (strokeSize >= MARKER_CACHE_SIZE)
strokeCache = new agg::int8u[strokeSize];
scanlines.serialize(strokeCache);
- theRasterizer->reset_clipping();
- rendererBase->reset_clipping(true);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
set_clipbox(gc.cliprect, rendererBase);
bool has_clippath = render_clippath(gc.clippath, gc.clippath_trans);
@@ -592,7 +548,7 @@
if (has_clippath) {
while (path_transformed.vertex(&x, &y) != agg::path_cmd_stop) {
- pixfmt_amask_type pfa(*pixFmt, *alphaMask);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
amask_ren_type r(pfa);
amask_aa_renderer_type ren(r);
@@ -608,14 +564,14 @@
} else {
while (path_transformed.vertex(&x, &y) != agg::path_cmd_stop) {
if (face.first) {
- rendererAA->color(face.second);
+ rendererAA.color(face.second);
sa.init(fillCache, fillSize, x, y);
- agg::render_scanlines(sa, sl, *rendererAA);
+ agg::render_scanlines(sa, sl, rendererAA);
}
- rendererAA->color(gc.color);
+ rendererAA.color(gc.color);
sa.init(strokeCache, strokeSize, x, y);
- agg::render_scanlines(sa, sl, *rendererAA);
+ agg::render_scanlines(sa, sl, rendererAA);
}
}
} catch(...) {
@@ -734,8 +690,8 @@
GCAgg gc = GCAgg(args[4], dpi);
- theRasterizer->reset_clipping();
- rendererBase->reset_clipping(true);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
set_clipbox(gc.cliprect, theRasterizer);
agg::rendering_buffer srcbuf((agg::int8u*)buffer, width, height, width);
@@ -764,10 +720,10 @@
image_accessor_type ia(pixf_img, 0);
image_span_gen_type image_span_generator(ia, interpolator, filter);
span_gen_type output_span_generator(&image_span_generator, gc.color);
- renderer_type ri(*rendererBase, sa, output_span_generator);
+ renderer_type ri(rendererBase, sa, output_span_generator);
- theRasterizer->add_path(rect2);
- agg::render_scanlines(*theRasterizer, *slineP8, ri);
+ theRasterizer.add_path(rect2);
+ agg::render_scanlines(theRasterizer, slineP8, ri);
Py_XDECREF(image_array);
@@ -789,8 +745,8 @@
agg::trans_affine clippath_trans;
bool has_clippath = false;
- theRasterizer->reset_clipping();
- rendererBase->reset_clipping(true);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
if (args.size() == 6) {
clippath = args[4];
clippath_trans = py_to_agg_transformation_matrix(args[5], false);
@@ -828,15 +784,15 @@
image_accessor_type ia(pixf, agg::rgba8(0, 0, 0, 0));
interpolator_type interpolator(inv_mtx);
image_span_gen_type image_span_generator(ia, interpolator);
- pixfmt_amask_type pfa(*pixFmt, *alphaMask);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
amask_ren_type r(pfa);
renderer_type ri(r, sa, image_span_generator);
- theRasterizer->add_path(rect2);
- agg::render_scanlines(*theRasterizer, *slineP8, ri);
+ theRasterizer.add_path(rect2);
+ agg::render_scanlines(theRasterizer, slineP8, ri);
} else {
set_clipbox(box_obj, rendererBase);
- rendererBase->blend_from(pixf, 0, (int)x,
(int)(height-(y+image->rowsOut)));
+ rendererBase.blend_from(pixf, 0, (int)x, (int)(height-(y+image->rowsOut)));
}
image->flipud_out(empty);
@@ -857,29 +813,29 @@
// Render face
if (face.first) {
- theRasterizer->add_path(path);
+ theRasterizer.add_path(path);
if (gc.isaa) {
if (has_clippath) {
- pixfmt_amask_type pfa(*pixFmt, *alphaMask);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
amask_ren_type r(pfa);
amask_aa_renderer_type ren(r);
ren.color(face.second);
- agg::render_scanlines(*theRasterizer, *slineP8, ren);
+ agg::render_scanlines(theRasterizer, slineP8, ren);
} else {
- rendererAA->color(face.second);
- agg::render_scanlines(*theRasterizer, *slineP8, *rendererAA);
+ rendererAA.color(face.second);
+ agg::render_scanlines(theRasterizer, slineP8, rendererAA);
}
} else {
if (has_clippath) {
- pixfmt_amask_type pfa(*pixFmt, *alphaMask);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
amask_ren_type r(pfa);
amask_bin_renderer_type ren(r);
ren.color(face.second);
- agg::render_scanlines(*theRasterizer, *slineP8, ren);
+ agg::render_scanlines(theRasterizer, slineP8, ren);
} else {
- rendererBin->color(face.second);
- agg::render_scanlines(*theRasterizer, *slineP8, *rendererBin);
+ rendererBin.color(face.second);
+ agg::render_scanlines(theRasterizer, slineP8, rendererBin);
}
}
}
@@ -895,7 +851,7 @@
stroke.width(linewidth);
stroke.line_cap(gc.cap);
stroke.line_join(gc.join);
- theRasterizer->add_path(stroke);
+ theRasterizer.add_path(stroke);
} else {
dash_t dash(path);
for (GCAgg::dash_t::const_iterator i = gc.dashes.begin();
@@ -912,30 +868,30 @@
stroke.line_cap(gc.cap);
stroke.line_join(gc.join);
stroke.width(linewidth);
- theRasterizer->add_path(stroke);
+ theRasterizer.add_path(stroke);
}
if (gc.isaa) {
if (has_clippath) {
- pixfmt_amask_type pfa(*pixFmt, *alphaMask);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
amask_ren_type r(pfa);
amask_aa_renderer_type ren(r);
ren.color(gc.color);
- agg::render_scanlines(*theRasterizer, *slineP8, ren);
+ agg::render_scanlines(theRasterizer, slineP8, ren);
} else {
- rendererAA->color(gc.color);
- agg::render_scanlines(*theRasterizer, *slineP8, *rendererAA);
+ rendererAA.color(gc.color);
+ agg::render_scanlines(theRasterizer, slineP8, rendererAA);
}
} else {
if (has_clippath) {
- pixfmt_amask_type pfa(*pixFmt, *alphaMask);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
amask_ren_type r(pfa);
amask_bin_renderer_type ren(r);
ren.color(gc.color);
- agg::render_scanlines(*theRasterizer, *slineP8, ren);
+ agg::render_scanlines(theRasterizer, slineP8, ren);
} else {
- rendererBin->color(gc.color);
- agg::render_scanlines(*theRasterizer, *slineBin, *rendererBin);
+ rendererBin.color(gc.color);
+ agg::render_scanlines(theRasterizer, slineBin, rendererBin);
}
}
}
@@ -961,8 +917,8 @@
GCAgg gc = GCAgg(gc_obj, dpi);
facepair_t face = _get_rgba_face(face_obj, gc.alpha);
- theRasterizer->reset_clipping();
- rendererBase->reset_clipping(true);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
set_clipbox(gc.cliprect, theRasterizer);
bool has_clippath = render_clippath(gc.clippath, gc.clippath_trans);
@@ -1074,8 +1030,8 @@
}
// Handle any clipping globally
- theRasterizer->reset_clipping();
- rendererBase->reset_clipping(true);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
set_clipbox(cliprect, theRasterizer);
bool has_clippath = render_clippath(clippath, clippath_trans);
@@ -1430,21 +1386,28 @@
args.verify_length(0);
int row_len = width*3;
unsigned char* buf_tmp = new unsigned char[row_len * height];
- if (buf_tmp ==NULL) {
+ if (buf_tmp == NULL) {
//todo: also handle allocation throw
throw Py::MemoryError("RendererAgg::tostring_rgb could not allocate
memory");
}
- agg::rendering_buffer renderingBufferTmp;
- renderingBufferTmp.attach(buf_tmp,
- width,
- height,
- row_len);
- agg::color_conv(&renderingBufferTmp, renderingBuffer,
agg::color_conv_rgba32_to_rgb24());
+ try {
+ agg::rendering_buffer renderingBufferTmp;
+ renderingBufferTmp.attach(buf_tmp,
+ width,
+ height,
+ row_len);
+ agg::color_conv(&renderingBufferTmp, &renderingBuffer,
agg::color_conv_rgba32_to_rgb24());
+ } catch (...) {
+ delete [] buf_tmp;
+ throw Py::RuntimeError("Unknown exception occurred in tostring_rgb");
+ }
+
//todo: how to do this with native CXX
PyObject* o = Py_BuildValue("s#", buf_tmp, row_len * height);
+
delete [] buf_tmp;
return Py::asObject(o);
}
@@ -1463,12 +1426,16 @@
//todo: also handle allocation throw
throw Py::MemoryError("RendererAgg::tostring_argb could not allocate
memory");
}
- agg::rendering_buffer renderingBufferTmp;
- renderingBufferTmp.attach(buf_tmp, width, height, row_len);
- agg::color_conv(&renderingBufferTmp, renderingBuffer,
agg::color_conv_rgba32_to_argb32());
+ try {
+ agg::rendering_buffer renderingBufferTmp;
+ renderingBufferTmp.attach(buf_tmp, width, height, row_len);
+ agg::color_conv(&renderingBufferTmp, &renderingBuffer,
agg::color_conv_rgba32_to_argb32());
+ } catch (...) {
+ delete [] buf_tmp;
+ throw Py::RuntimeError("Unknown exception occurred in tostring_argb");
+ }
-
//todo: how to do this with native CXX
PyObject* o = Py_BuildValue("s#", buf_tmp, row_len * height);
delete [] buf_tmp;
@@ -1488,14 +1455,19 @@
//todo: also handle allocation throw
throw Py::MemoryError("RendererAgg::tostring_bgra could not allocate
memory");
}
- agg::rendering_buffer renderingBufferTmp;
- renderingBufferTmp.attach(buf_tmp,
- width,
- height,
- row_len);
- agg::color_conv(&renderingBufferTmp, renderingBuffer,
agg::color_conv_rgba32_to_bgra32());
+ try {
+ agg::rendering_buffer renderingBufferTmp;
+ renderingBufferTmp.attach(buf_tmp,
+ width,
+ height,
+ row_len);
+ agg::color_conv(&renderingBufferTmp, &renderingBuffer,
agg::color_conv_rgba32_to_bgra32());
+ } catch (...) {
+ delete [] buf_tmp;
+ throw Py::RuntimeError("Unknown exception occurred in tostring_bgra");
+ }
//todo: how to do this with native CXX
PyObject* o = Py_BuildValue("s#",
@@ -1557,12 +1529,17 @@
int newsize = newwidth * newheight * 4;
unsigned char* buf = new unsigned char[newsize];
+ if (buf == NULL) {
+ throw Py::MemoryError("RendererAgg::tostring_minimized could not
allocate memory");
+ }
+
unsigned int* dst = (unsigned int*)buf;
unsigned int* src = (unsigned int*)pixBuffer;
for (int y = ymin; y < ymax; ++y)
for (int x = xmin; x < xmax; ++x, ++dst)
*dst = src[y * width + x];
+ // The Py::String will take over the buffer
data = Py::String((const char *)buf, (int)newsize);
}
@@ -1586,7 +1563,7 @@
_VERBOSE("RendererAgg::clear");
args.verify_length(0);
- rendererBase->clear(agg::rgba(1, 1, 1, 0));
+ rendererBase.clear(agg::rgba(1, 1, 1, 0));
return Py::Object();
}
@@ -1627,25 +1604,8 @@
_VERBOSE("RendererAgg::~RendererAgg");
-
- delete slineP8;
- delete slineBin;
- delete theRasterizer;
- delete rendererAA;
- delete rendererBin;
- delete rendererBase;
- delete pixFmt;
- delete renderingBuffer;
-
- delete alphaMask;
- delete alphaMaskRenderingBuffer;
delete [] alphaBuffer;
delete [] pixBuffer;
- delete pixfmtAlphaMask;
- delete rendererBaseAlphaMask;
- delete rendererAlphaMask;
- delete scanlineAlphaMask;
-
}
/* ------------ module methods ------------- */
@@ -1752,5 +1712,4 @@
static _backend_agg_module* _backend_agg = NULL;
_backend_agg = new _backend_agg_module;
-
}
Modified: trunk/matplotlib/src/_backend_agg.h
===================================================================
--- trunk/matplotlib/src/_backend_agg.h 2008-10-27 19:40:25 UTC (rev 6339)
+++ trunk/matplotlib/src/_backend_agg.h 2008-10-27 21:13:24 UTC (rev 6340)
@@ -64,25 +64,6 @@
typedef agg::renderer_base<agg::pixfmt_gray8> renderer_base_alpha_mask_type;
typedef agg::renderer_scanline_aa_solid<renderer_base_alpha_mask_type>
renderer_alpha_mask_type;
-struct SnapData {
- SnapData(const bool& newpoint, const float& xsnap, const float& ysnap) :
- newpoint(newpoint), xsnap(xsnap), ysnap(ysnap) {}
- bool newpoint;
- float xsnap, ysnap;
-};
-
-class SafeSnap {
- // snap to pixel center, avoiding 0 path length rounding errors.
-public:
- SafeSnap() : first(true), xsnap(0.0), lastx(0.0), lastxsnap(0.0),
- ysnap(0.0), lasty(0.0), lastysnap(0.0) {}
- SnapData snap (const float& x, const float& y);
-
-private:
- bool first;
- float xsnap, lastx, lastxsnap, ysnap, lasty, lastysnap;
-};
-
// a helper class to pass agg::buffer objects around. agg::buffer is
// a class in the swig wrapper
class BufferRegion : public Py::PythonExtension<BufferRegion> {
@@ -198,27 +179,27 @@
size_t NUMBYTES; //the number of bytes in buffer
agg::int8u *pixBuffer;
- agg::rendering_buffer *renderingBuffer;
+ agg::rendering_buffer renderingBuffer;
agg::int8u *alphaBuffer;
- agg::rendering_buffer *alphaMaskRenderingBuffer;
- alpha_mask_type *alphaMask;
- agg::pixfmt_gray8 *pixfmtAlphaMask;
- renderer_base_alpha_mask_type *rendererBaseAlphaMask;
- renderer_alpha_mask_type *rendererAlphaMask;
- agg::scanline_p8 *scanlineAlphaMask;
+ agg::rendering_buffer alphaMaskRenderingBuffer;
+ alpha_mask_type alphaMask;
+ agg::pixfmt_gray8 pixfmtAlphaMask;
+ renderer_base_alpha_mask_type rendererBaseAlphaMask;
+ renderer_alpha_mask_type rendererAlphaMask;
+ agg::scanline_p8 scanlineAlphaMask;
+ scanline_p8 slineP8;
+ scanline_bin slineBin;
+ pixfmt pixFmt;
+ renderer_base rendererBase;
+ renderer_aa rendererAA;
+ renderer_bin rendererBin;
+ rasterizer theRasterizer;
+ Py::Object lastclippath;
+ agg::trans_affine lastclippath_transform;
- scanline_p8* slineP8;
- scanline_bin* slineBin;
- pixfmt *pixFmt;
- renderer_base *rendererBase;
- renderer_aa *rendererAA;
- renderer_bin *rendererBin;
- rasterizer *theRasterizer;
-
-
const int debug;
protected:
@@ -227,7 +208,7 @@
agg::rgba rgb_to_color(const Py::SeqBase<Py::Object>& rgb, double alpha);
facepair_t _get_rgba_face(const Py::Object& rgbFace, double alpha);
template<class R>
- void set_clipbox(const Py::Object& cliprect, R rasterizer);
+ void set_clipbox(const Py::Object& cliprect, R& rasterizer);
bool render_clippath(const Py::Object& clippath, const agg::trans_affine&
clippath_trans);
template<class PathIteratorType>
void _draw_path(PathIteratorType& path, bool has_clippath,
@@ -251,8 +232,6 @@
private:
void create_alpha_buffers();
- Py::Object lastclippath;
- agg::trans_affine lastclippath_transform;
};
// the extension module
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
Matplotlib-checkins mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/matplotlib-checkins
