Menu
▾
▴
SF.net SVN: matplotlib:[8460] trunk/matplotlib/src
|
From: <md...@us...> - 2010-06-24 13:06:10
|
Revision: 8460
http://matplotlib.svn.sourceforge.net/matplotlib/?rev=8460&view=rev
Author: mdboom
Date: 2010-06-24 13:06:03 +0000 (Thu, 24 Jun 2010)
Log Message:
-----------
Standardizing formatting of C/C++ code.
Modified Paths:
--------------
trunk/matplotlib/src/_backend_agg.cpp
trunk/matplotlib/src/_backend_agg.h
trunk/matplotlib/src/_gtkagg.cpp
trunk/matplotlib/src/_image.cpp
trunk/matplotlib/src/_image.h
trunk/matplotlib/src/_path.cpp
trunk/matplotlib/src/_png.cpp
trunk/matplotlib/src/_tkagg.cpp
trunk/matplotlib/src/_ttconv.cpp
trunk/matplotlib/src/_windowing.cpp
trunk/matplotlib/src/_wxagg.cpp
trunk/matplotlib/src/agg_py_path_iterator.h
trunk/matplotlib/src/ft2font.cpp
trunk/matplotlib/src/ft2font.h
trunk/matplotlib/src/mplutils.cpp
trunk/matplotlib/src/mplutils.h
trunk/matplotlib/src/path_cleanup.cpp
trunk/matplotlib/src/path_converters.h
Modified: trunk/matplotlib/src/_backend_agg.cpp
===================================================================
--- trunk/matplotlib/src/_backend_agg.cpp 2010-06-23 14:44:32 UTC (rev 8459)
+++ trunk/matplotlib/src/_backend_agg.cpp 2010-06-24 13:06:03 UTC (rev 8460)
@@ -54,57 +54,82 @@
/*
Convert dashes from the Python representation as nested sequences to
the C++ representation as a std::vector<std::pair<double, double> >
- (GCAgg::dash_t)
-*/
-void convert_dashes(const Py::Tuple& dashes, double dpi, GCAgg::dash_t& dashes_out,
- double& dashOffset_out) {
- if (dashes.length()!=2)
- throw Py::ValueError(Printf("Dash descriptor must be a length 2 tuple; found %d", dashes.length()).str());
+ (GCAgg::dash_t) */
+void
+convert_dashes(const Py::Tuple& dashes, double dpi,
+ GCAgg::dash_t& dashes_out, double& dashOffset_out)
+{
+ if (dashes.length() != 2)
+ {
+ throw Py::ValueError(
+ Printf("Dash descriptor must be a length 2 tuple; found %d",
+ dashes.length()).str()
+ );
+ }
- dashes_out.clear();
- dashOffset_out = 0.0;
- if (dashes[0].ptr() == Py_None)
- return;
+ dashes_out.clear();
+ dashOffset_out = 0.0;
+ if (dashes[0].ptr() == Py_None)
+ {
+ return;
+ }
- dashOffset_out = double(Py::Float(dashes[0])) * dpi/72.0;
+ dashOffset_out = double(Py::Float(dashes[0])) * dpi / 72.0;
- Py::SeqBase<Py::Object> dashSeq = dashes[1];
+ Py::SeqBase<Py::Object> dashSeq = dashes[1];
- size_t Ndash = dashSeq.length();
- if (Ndash % 2 != 0)
- throw Py::ValueError(Printf("Dash sequence must be an even length sequence; found %d", Ndash).str());
+ size_t Ndash = dashSeq.length();
+ if (Ndash % 2 != 0)
+ {
+ throw Py::ValueError(
+ Printf("Dash sequence must be an even length sequence; found %d", Ndash).str()
+ );
+ }
- dashes_out.clear();
- dashes_out.reserve(Ndash / 2);
+ dashes_out.clear();
+ dashes_out.reserve(Ndash / 2);
- double val0, val1;
- for (size_t i = 0; i < Ndash; i += 2) {
- val0 = double(Py::Float(dashSeq[i])) * dpi/72.0;
- val1 = double(Py::Float(dashSeq[i+1])) * dpi/72.0;
- dashes_out.push_back(std::make_pair(val0, val1));
- }
+ double val0, val1;
+ for (size_t i = 0; i < Ndash; i += 2)
+ {
+ val0 = double(Py::Float(dashSeq[i])) * dpi / 72.0;
+ val1 = double(Py::Float(dashSeq[i+1])) * dpi / 72.0;
+ dashes_out.push_back(std::make_pair(val0, val1));
+ }
}
-Py::Object BufferRegion::to_string(const Py::Tuple &args) {
- // owned=true to prevent memory leak
- return Py::String(PyString_FromStringAndSize((const char*)data, height*stride), true);
+
+Py::Object
+BufferRegion::to_string(const Py::Tuple &args)
+{
+ // owned=true to prevent memory leak
+ return Py::String(PyString_FromStringAndSize((const char*)data, height*stride), true);
}
-Py::Object BufferRegion::set_x(const Py::Tuple &args) {
+
+Py::Object
+BufferRegion::set_x(const Py::Tuple &args)
+{
args.verify_length(1);
- size_t x = Py::Int( args[0] );
+ size_t x = Py::Int(args[0]);
rect.x1 = x;
return Py::Object();
}
-Py::Object BufferRegion::set_y(const Py::Tuple &args) {
+
+Py::Object
+BufferRegion::set_y(const Py::Tuple &args)
+{
args.verify_length(1);
- size_t y = Py::Int( args[0] );
+ size_t y = Py::Int(args[0]);
rect.y1 = y;
return Py::Object();
}
-Py::Object BufferRegion::get_extents(const Py::Tuple &args) {
+
+Py::Object
+BufferRegion::get_extents(const Py::Tuple &args)
+{
args.verify_length(0);
Py::Tuple extents(4);
@@ -116,562 +141,673 @@
return extents;
}
-Py::Object BufferRegion::to_string_argb(const Py::Tuple &args) {
- // owned=true to prevent memory leak
- Py_ssize_t length;
- unsigned char* pix;
- unsigned char* begin;
- unsigned char* end;
- unsigned char tmp;
- size_t i, j;
- PyObject* str = PyString_FromStringAndSize((const char*)data, height*stride);
- if (PyString_AsStringAndSize(str, (char**)&begin, &length)) {
- throw Py::TypeError("Could not create memory for blit");
- }
+Py::Object
+BufferRegion::to_string_argb(const Py::Tuple &args)
+{
+ // owned=true to prevent memory leak
+ Py_ssize_t length;
+ unsigned char* pix;
+ unsigned char* begin;
+ unsigned char* end;
+ unsigned char tmp;
+ size_t i, j;
- pix = begin;
- end = begin + (height * stride);
- for (i = 0; i < (size_t)height; ++i) {
- pix = begin + i * stride;
- for (j = 0; j < (size_t)width; ++j) {
- // Convert rgba to argb
- tmp = pix[2];
- pix[2] = pix[0];
- pix[0] = tmp;
- pix += 4;
+ PyObject* str = PyString_FromStringAndSize(
+ (const char*)data, height * stride);
+ if (PyString_AsStringAndSize(str, (char**)&begin, &length))
+ {
+ throw Py::TypeError("Could not create memory for blit");
}
- }
- return Py::String(str, true);
+ pix = begin;
+ end = begin + (height * stride);
+ for (i = 0; i < (size_t)height; ++i)
+ {
+ pix = begin + i * stride;
+ for (j = 0; j < (size_t)width; ++j)
+ {
+ // Convert rgba to argb
+ tmp = pix[2];
+ pix[2] = pix[0];
+ pix[0] = tmp;
+ pix += 4;
+ }
+ }
+
+ return Py::String(str, true);
}
+
GCAgg::GCAgg(const Py::Object &gc, double dpi) :
- dpi(dpi), isaa(true), dashOffset(0.0)
+ dpi(dpi), isaa(true), dashOffset(0.0)
{
- _VERBOSE("GCAgg::GCAgg");
- linewidth = points_to_pixels ( gc.getAttr("_linewidth") ) ;
- alpha = Py::Float( gc.getAttr("_alpha") );
- color = get_color(gc);
- _set_antialiased(gc);
- _set_linecap(gc);
- _set_joinstyle(gc);
- _set_dashes(gc);
- _set_clip_rectangle(gc);
- _set_clip_path(gc);
- _set_snap(gc);
- _set_hatch_path(gc);
+ _VERBOSE("GCAgg::GCAgg");
+ linewidth = points_to_pixels(gc.getAttr("_linewidth")) ;
+ alpha = Py::Float(gc.getAttr("_alpha"));
+ color = get_color(gc);
+ _set_antialiased(gc);
+ _set_linecap(gc);
+ _set_joinstyle(gc);
+ _set_dashes(gc);
+ _set_clip_rectangle(gc);
+ _set_clip_path(gc);
+ _set_snap(gc);
+ _set_hatch_path(gc);
}
+
void
-GCAgg::_set_antialiased(const Py::Object& gc) {
- _VERBOSE("GCAgg::antialiased");
- isaa = Py::Int( gc.getAttr( "_antialiased") );
+GCAgg::_set_antialiased(const Py::Object& gc)
+{
+ _VERBOSE("GCAgg::antialiased");
+ isaa = Py::Int(gc.getAttr("_antialiased"));
}
+
agg::rgba
-GCAgg::get_color(const Py::Object& gc) {
- _VERBOSE("GCAgg::get_color");
- Py::Tuple rgb = Py::Tuple( gc.getAttr("_rgb") );
+GCAgg::get_color(const Py::Object& gc)
+{
+ _VERBOSE("GCAgg::get_color");
+ Py::Tuple rgb = Py::Tuple(gc.getAttr("_rgb"));
- double alpha = Py::Float( gc.getAttr("_alpha") );
+ double alpha = Py::Float(gc.getAttr("_alpha"));
- double r = Py::Float(rgb[0]);
- double g = Py::Float(rgb[1]);
- double b = Py::Float(rgb[2]);
- return agg::rgba(r, g, b, alpha);
+ double r = Py::Float(rgb[0]);
+ double g = Py::Float(rgb[1]);
+ double b = Py::Float(rgb[2]);
+ return agg::rgba(r, g, b, alpha);
}
+
double
-GCAgg::points_to_pixels( const Py::Object& points) {
- _VERBOSE("GCAgg::points_to_pixels");
- double p = Py::Float( points ) ;
- return p * dpi/72.0;
+GCAgg::points_to_pixels(const Py::Object& points)
+{
+ _VERBOSE("GCAgg::points_to_pixels");
+ double p = Py::Float(points) ;
+ return p * dpi / 72.0;
}
+
void
-GCAgg::_set_linecap(const Py::Object& gc) {
- _VERBOSE("GCAgg::_set_linecap");
+GCAgg::_set_linecap(const Py::Object& gc)
+{
+ _VERBOSE("GCAgg::_set_linecap");
- std::string capstyle = Py::String( gc.getAttr( "_capstyle" ) );
+ std::string capstyle = Py::String(gc.getAttr("_capstyle"));
- if (capstyle=="butt")
- cap = agg::butt_cap;
- else if (capstyle=="round")
- cap = agg::round_cap;
- else if(capstyle=="projecting")
- cap = agg::square_cap;
- else
- throw Py::ValueError(Printf("GC _capstyle attribute must be one of butt, round, projecting; found %s", capstyle.c_str()).str());
+ if (capstyle == "butt")
+ {
+ cap = agg::butt_cap;
+ }
+ else if (capstyle == "round")
+ {
+ cap = agg::round_cap;
+ }
+ else if (capstyle == "projecting")
+ {
+ cap = agg::square_cap;
+ }
+ else
+ {
+ throw Py::ValueError(Printf("GC _capstyle attribute must be one of butt, round, projecting; found %s", capstyle.c_str()).str());
+ }
}
+
void
-GCAgg::_set_joinstyle(const Py::Object& gc) {
- _VERBOSE("GCAgg::_set_joinstyle");
+GCAgg::_set_joinstyle(const Py::Object& gc)
+{
+ _VERBOSE("GCAgg::_set_joinstyle");
- std::string joinstyle = Py::String( gc.getAttr("_joinstyle") );
+ std::string joinstyle = Py::String(gc.getAttr("_joinstyle"));
- if (joinstyle == "miter")
- join = agg::miter_join_revert;
- else if (joinstyle == "round")
- join = agg::round_join;
- else if (joinstyle == "bevel")
- join = agg::bevel_join;
- else
- throw Py::ValueError(Printf("GC _joinstyle attribute must be one of butt, round, projecting; found %s", joinstyle.c_str()).str());
+ if (joinstyle == "miter")
+ {
+ join = agg::miter_join_revert;
+ }
+ else if (joinstyle == "round")
+ {
+ join = agg::round_join;
+ }
+ else if (joinstyle == "bevel")
+ {
+ join = agg::bevel_join;
+ }
+ else
+ {
+ throw Py::ValueError(Printf("GC _joinstyle attribute must be one of butt, round, projecting; found %s", joinstyle.c_str()).str());
+ }
}
+
void
-GCAgg::_set_dashes(const Py::Object& gc) {
- //return the dashOffset, dashes sequence tuple.
- _VERBOSE("GCAgg::_set_dashes");
+GCAgg::_set_dashes(const Py::Object& gc)
+{
+ //return the dashOffset, dashes sequence tuple.
+ _VERBOSE("GCAgg::_set_dashes");
- Py::Object dash_obj( gc.getAttr( "_dashes" ) );
- if (dash_obj.ptr() == Py_None) {
- dashes.clear();
- return;
- }
+ Py::Object dash_obj(gc.getAttr("_dashes"));
+ if (dash_obj.ptr() == Py_None)
+ {
+ dashes.clear();
+ return;
+ }
- convert_dashes(dash_obj, dpi, dashes, dashOffset);
+ convert_dashes(dash_obj, dpi, dashes, dashOffset);
}
+
void
-GCAgg::_set_clip_rectangle( const Py::Object& gc) {
- //set the clip rectangle from the gc
+GCAgg::_set_clip_rectangle(const Py::Object& gc)
+{
+ //set the clip rectangle from the gc
- _VERBOSE("GCAgg::_set_clip_rectangle");
+ _VERBOSE("GCAgg::_set_clip_rectangle");
- Py::Object o ( gc.getAttr( "_cliprect" ) );
- cliprect = o;
+ Py::Object o(gc.getAttr("_cliprect"));
+ cliprect = o;
}
+
void
-GCAgg::_set_clip_path( const Py::Object& gc) {
- //set the clip path from the gc
+GCAgg::_set_clip_path(const Py::Object& gc)
+{
+ //set the clip path from the gc
- _VERBOSE("GCAgg::_set_clip_path");
+ _VERBOSE("GCAgg::_set_clip_path");
- Py::Object method_obj = gc.getAttr("get_clip_path");
- Py::Callable method(method_obj);
- Py::Tuple path_and_transform = method.apply(Py::Tuple());
- if (path_and_transform[0].ptr() != Py_None) {
- clippath = path_and_transform[0];
- clippath_trans = py_to_agg_transformation_matrix(path_and_transform[1].ptr());
- }
+ Py::Object method_obj = gc.getAttr("get_clip_path");
+ Py::Callable method(method_obj);
+ Py::Tuple path_and_transform = method.apply(Py::Tuple());
+ if (path_and_transform[0].ptr() != Py_None)
+ {
+ clippath = path_and_transform[0];
+ clippath_trans = py_to_agg_transformation_matrix(path_and_transform[1].ptr());
+ }
}
+
void
-GCAgg::_set_snap( const Py::Object& gc) {
- //set the snap setting
+GCAgg::_set_snap(const Py::Object& gc)
+{
+ //set the snap setting
- _VERBOSE("GCAgg::_set_snap");
+ _VERBOSE("GCAgg::_set_snap");
- Py::Object method_obj = gc.getAttr("get_snap");
- Py::Callable method(method_obj);
- Py::Object py_snap = method.apply(Py::Tuple());
- if (py_snap.isNone()) {
- snap_mode = SNAP_AUTO;
- } else if (py_snap.isTrue()) {
- snap_mode = SNAP_TRUE;
- } else {
- snap_mode = SNAP_FALSE;
- }
+ Py::Object method_obj = gc.getAttr("get_snap");
+ Py::Callable method(method_obj);
+ Py::Object py_snap = method.apply(Py::Tuple());
+ if (py_snap.isNone())
+ {
+ snap_mode = SNAP_AUTO;
+ }
+ else if (py_snap.isTrue())
+ {
+ snap_mode = SNAP_TRUE;
+ }
+ else
+ {
+ snap_mode = SNAP_FALSE;
+ }
}
+
void
-GCAgg::_set_hatch_path( const Py::Object& gc) {
- _VERBOSE("GCAgg::_set_hatch_path");
+GCAgg::_set_hatch_path(const Py::Object& gc)
+{
+ _VERBOSE("GCAgg::_set_hatch_path");
- Py::Object method_obj = gc.getAttr("get_hatch_path");
- Py::Callable method(method_obj);
- hatchpath = method.apply(Py::Tuple());
+ Py::Object method_obj = gc.getAttr("get_hatch_path");
+ Py::Callable method(method_obj);
+ hatchpath = method.apply(Py::Tuple());
}
+
const size_t
RendererAgg::PIXELS_PER_INCH(96);
+
RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi,
int debug) :
- width(width),
- height(height),
- dpi(dpi),
- NUMBYTES(width*height*4),
- pixBuffer(NULL),
- renderingBuffer(),
- alphaBuffer(NULL),
- alphaMaskRenderingBuffer(),
- alphaMask(alphaMaskRenderingBuffer),
- pixfmtAlphaMask(alphaMaskRenderingBuffer),
- rendererBaseAlphaMask(),
- rendererAlphaMask(),
- scanlineAlphaMask(),
- slineP8(),
- slineBin(),
- pixFmt(),
- rendererBase(),
- rendererAA(),
- rendererBin(),
- theRasterizer(),
- debug(debug)
+ width(width),
+ height(height),
+ dpi(dpi),
+ NUMBYTES(width*height*4),
+ pixBuffer(NULL),
+ renderingBuffer(),
+ alphaBuffer(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);
+ _VERBOSE("RendererAgg::RendererAgg");
+ unsigned stride(width*4);
- pixBuffer = new agg::int8u[NUMBYTES];
- 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);
- hatchRenderingBuffer.attach(hatchBuffer, HATCH_SIZE, HATCH_SIZE, HATCH_SIZE*4);
+ pixBuffer = new agg::int8u[NUMBYTES];
+ 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);
+ hatchRenderingBuffer.attach(hatchBuffer, HATCH_SIZE, HATCH_SIZE,
+ HATCH_SIZE*4);
}
-void RendererAgg::create_alpha_buffers() {
- if (!alphaBuffer) {
- unsigned stride(width*4);
- alphaBuffer = new agg::int8u[NUMBYTES];
- alphaMaskRenderingBuffer.attach(alphaBuffer, width, height, stride);
- rendererBaseAlphaMask.attach(pixfmtAlphaMask);
- rendererAlphaMask.attach(rendererBaseAlphaMask);
- }
+
+void
+RendererAgg::create_alpha_buffers()
+{
+ if (!alphaBuffer)
+ {
+ unsigned stride(width*4);
+ alphaBuffer = new agg::int8u[NUMBYTES];
+ 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) {
- //set the clip rectangle from the gc
+RendererAgg::set_clipbox(const Py::Object& cliprect, R& rasterizer)
+{
+ //set the clip rectangle from the gc
- _VERBOSE("RendererAgg::set_clipbox");
+ _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)), height - int(mpl_round(b)),
- int(mpl_round(r)), height - int(mpl_round(t)));
- }
+ double l, b, r, t;
+ if (py_convert_bbox(cliprect.ptr(), l, b, r, t))
+ {
+ rasterizer.clip_box(int(mpl_round(l)), height - int(mpl_round(b)),
+ int(mpl_round(r)), height - int(mpl_round(t)));
+ }
- _VERBOSE("RendererAgg::set_clipbox done");
+ _VERBOSE("RendererAgg::set_clipbox done");
}
+
std::pair<bool, agg::rgba>
-RendererAgg::_get_rgba_face(const Py::Object& rgbFace, double alpha) {
- _VERBOSE("RendererAgg::_get_rgba_face");
- std::pair<bool, agg::rgba> face;
+RendererAgg::_get_rgba_face(const Py::Object& rgbFace, double alpha)
+{
+ _VERBOSE("RendererAgg::_get_rgba_face");
+ std::pair<bool, agg::rgba> face;
- if (rgbFace.ptr() == Py_None) {
- face.first = false;
- }
- else {
- face.first = true;
- Py::Tuple rgb = Py::Tuple(rgbFace);
- face.second = rgb_to_color(rgb, alpha);
- }
- return face;
+ if (rgbFace.ptr() == Py_None)
+ {
+ face.first = false;
+ }
+ else
+ {
+ face.first = true;
+ Py::Tuple rgb = Py::Tuple(rgbFace);
+ face.second = rgb_to_color(rgb, alpha);
+ }
+ return face;
}
+
Py::Object
-RendererAgg::copy_from_bbox(const Py::Tuple& args) {
- //copy region in bbox to buffer and return swig/agg buffer object
- args.verify_length(1);
+RendererAgg::copy_from_bbox(const Py::Tuple& args)
+{
+ //copy region in bbox to buffer and return swig/agg buffer object
+ args.verify_length(1);
- Py::Object box_obj = args[0];
- double l, b, r, t;
- if (!py_convert_bbox(box_obj.ptr(), l, b, r, t))
- throw Py::TypeError("Invalid bbox provided to copy_from_bbox");
+ Py::Object box_obj = args[0];
+ double l, b, r, t;
+ if (!py_convert_bbox(box_obj.ptr(), l, b, r, t))
+ {
+ throw Py::TypeError("Invalid bbox provided to copy_from_bbox");
+ }
- // std::cout << l << " " << b << " " << r << " " << t << " " << (height - (int)b) << " " << height - (int)t << std::endl;
- agg::rect_i rect((int)l, height - (int)t, (int)r, height - (int)b);
+ agg::rect_i rect((int)l, height - (int)t, (int)r, height - (int)b);
- BufferRegion* reg = NULL;
- try {
- reg = new BufferRegion(rect, true);
- } catch (...) {
- throw Py::MemoryError("RendererAgg::copy_from_bbox could not allocate memory for buffer");
- }
+ BufferRegion* reg = NULL;
+ try
+ {
+ reg = new BufferRegion(rect, true);
+ }
+ catch (...)
+ {
+ throw Py::MemoryError(
+ "RendererAgg::copy_from_bbox could not allocate memory for buffer");
+ }
- if (!reg) {
- throw Py::MemoryError("RendererAgg::copy_from_bbox could not allocate memory for buffer");
- }
+ if (!reg)
+ {
+ throw Py::MemoryError(
+ "RendererAgg::copy_from_bbox could not allocate memory for buffer");
+ }
- try {
- 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);
- } catch (...) {
- delete reg;
- throw Py::RuntimeError("An unknown error occurred in copy_from_bbox");
- }
- return Py::asObject(reg);
+ 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);
}
+
Py::Object
-RendererAgg::restore_region(const Py::Tuple& args) {
- //copy BufferRegion to buffer
- args.verify_length(1);
- BufferRegion* region = static_cast<BufferRegion*>(args[0].ptr());
+RendererAgg::restore_region(const Py::Tuple& args)
+{
+ //copy BufferRegion to buffer
+ args.verify_length(1);
+ BufferRegion* region = static_cast<BufferRegion*>(args[0].ptr());
- if (region->data==NULL)
- throw Py::ValueError("Cannot restore_region from NULL data");
- //return Py::Object();
+ if (region->data == NULL)
+ {
+ throw Py::ValueError("Cannot restore_region from NULL data");
+ }
- //std::cout << "restoring " << region->width << " " << region->height << " " << region->stride << " " << region->rect.x1 << " " << region->rect.y1 << std::endl;
+ agg::rendering_buffer rbuf;
+ rbuf.attach(region->data,
+ region->width,
+ region->height,
+ region->stride);
- agg::rendering_buffer rbuf;
- rbuf.attach(region->data,
- region->width,
- 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();
+ return Py::Object();
}
+
// Restore the part of the saved region with offsets
Py::Object
-RendererAgg::restore_region2(const Py::Tuple& args) {
- //copy BufferRegion to buffer
- args.verify_length(7);
+RendererAgg::restore_region2(const Py::Tuple& args)
+{
+ //copy BufferRegion to buffer
+ args.verify_length(7);
+ int x(0), y(0), xx1(0), yy1(0), xx2(0), yy2(0);
+ try
+ {
+ xx1 = Py::Int(args[1]);
+ yy1 = Py::Int(args[2]);
+ xx2 = Py::Int(args[3]);
+ yy2 = Py::Int(args[4]);
+ x = Py::Int(args[5]);
+ y = Py::Int(args[6]);
+ }
+ catch (Py::TypeError)
+ {
+ throw Py::TypeError("Invalid input arguments to draw_text_image");
+ }
- int x(0),y(0), xx1(0),yy1(0), xx2(0), yy2(0);
- try {
- xx1 = Py::Int( args[1] );
- yy1 = Py::Int( args[2] );
- xx2 = Py::Int( args[3] );
- yy2 = Py::Int( args[4] );
- x = Py::Int( args[5] );
- y = Py::Int( args[6] );
- }
- catch (Py::TypeError) {
- throw Py::TypeError("Invalid input arguments to draw_text_image");
- }
+ BufferRegion* region = static_cast<BufferRegion*>(args[0].ptr());
+ if (region->data == NULL)
+ {
+ throw Py::ValueError("Cannot restore_region from NULL data");
+ }
- BufferRegion* region = static_cast<BufferRegion*>(args[0].ptr());
+ agg::rect_i rect(xx1 - region->rect.x1, (yy1 - region->rect.y1),
+ xx2 - region->rect.x1, (yy2 - region->rect.y1));
- if (region->data==NULL)
- throw Py::ValueError("Cannot restore_region from NULL data");
+ agg::rendering_buffer rbuf;
+ rbuf.attach(region->data,
+ region->width,
+ region->height,
+ region->stride);
- agg::rect_i rect(xx1-region->rect.x1, (yy1-region->rect.y1),
- xx2-region->rect.x1, (yy2-region->rect.y1));
+ rendererBase.copy_from(rbuf, &rect, x, y);
-
- agg::rendering_buffer rbuf;
- rbuf.attach(region->data,
- region->width,
- region->height,
- region->stride);
-
- rendererBase.copy_from(rbuf, &rect, x, y);
-
- return Py::Object();
+ return Py::Object();
}
-bool RendererAgg::render_clippath(const Py::Object& clippath, const agg::trans_affine& clippath_trans) {
- typedef agg::conv_transform<PathIterator> transformed_path_t;
- typedef agg::conv_curve<transformed_path_t> curve_t;
+bool
+RendererAgg::render_clippath(const Py::Object& clippath,
+ const agg::trans_affine& clippath_trans)
+{
+ typedef agg::conv_transform<PathIterator> transformed_path_t;
+ typedef agg::conv_curve<transformed_path_t> curve_t;
- bool has_clippath = (clippath.ptr() != Py_None);
+ bool has_clippath = (clippath.ptr() != Py_None);
- if (has_clippath &&
- (clippath.ptr() != lastclippath.ptr() ||
- clippath_trans != lastclippath_transform)) {
- create_alpha_buffers();
- agg::trans_affine trans(clippath_trans);
- trans *= agg::trans_affine_scaling(1.0, -1.0);
- trans *= agg::trans_affine_translation(0.0, (double)height);
+ if (has_clippath &&
+ (clippath.ptr() != lastclippath.ptr() ||
+ clippath_trans != lastclippath_transform))
+ {
+ create_alpha_buffers();
+ agg::trans_affine trans(clippath_trans);
+ trans *= agg::trans_affine_scaling(1.0, -1.0);
+ trans *= agg::trans_affine_translation(0.0, (double)height);
- PathIterator clippath_iter(clippath);
- 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);
- lastclippath = clippath;
- lastclippath_transform = clippath_trans;
- }
+ PathIterator clippath_iter(clippath);
+ 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);
+ lastclippath = clippath;
+ lastclippath_transform = clippath_trans;
+ }
- return has_clippath;
+ return has_clippath;
}
#define MARKER_CACHE_SIZE 512
+
Py::Object
-RendererAgg::draw_markers(const Py::Tuple& args) {
- typedef agg::conv_transform<PathIterator> transformed_path_t;
- typedef PathSnapper<transformed_path_t> snap_t;
- typedef agg::conv_curve<snap_t> curve_t;
- typedef agg::conv_stroke<curve_t> stroke_t;
- typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
- typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
- typedef agg::renderer_scanline_aa_solid<amask_ren_type> amask_aa_renderer_type;
- typedef agg::renderer_scanline_bin_solid<amask_ren_type> amask_bin_renderer_type;
- args.verify_length(5, 6);
+RendererAgg::draw_markers(const Py::Tuple& args)
+{
+ typedef agg::conv_transform<PathIterator> transformed_path_t;
+ typedef PathSnapper<transformed_path_t> snap_t;
+ typedef agg::conv_curve<snap_t> curve_t;
+ typedef agg::conv_stroke<curve_t> stroke_t;
+ typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
+ typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
+ typedef agg::renderer_scanline_aa_solid<amask_ren_type> amask_aa_renderer_type;
+ typedef agg::renderer_scanline_bin_solid<amask_ren_type> amask_bin_renderer_type;
+ args.verify_length(5, 6);
- Py::Object gc_obj = args[0];
- Py::Object marker_path_obj = args[1];
- agg::trans_affine marker_trans = py_to_agg_transformation_matrix(args[2].ptr());
- Py::Object path_obj = args[3];
- agg::trans_affine trans = py_to_agg_transformation_matrix(args[4].ptr());
- Py::Object face_obj;
- if (args.size() == 6)
- face_obj = args[5];
+ Py::Object gc_obj = args[0];
+ Py::Object marker_path_obj = args[1];
+ agg::trans_affine marker_trans = py_to_agg_transformation_matrix(args[2].ptr());
+ Py::Object path_obj = args[3];
+ agg::trans_affine trans = py_to_agg_transformation_matrix(args[4].ptr());
+ Py::Object face_obj;
+ if (args.size() == 6)
+ {
+ face_obj = args[5];
+ }
- GCAgg gc(gc_obj, dpi);
+ GCAgg gc(gc_obj, dpi);
- // Deal with the difference in y-axis direction
- marker_trans *= agg::trans_affine_scaling(1.0, -1.0);
- trans *= agg::trans_affine_scaling(1.0, -1.0);
- trans *= agg::trans_affine_translation(0.0, (double)height);
+ // Deal with the difference in y-axis direction
+ marker_trans *= agg::trans_affine_scaling(1.0, -1.0);
+ trans *= agg::trans_affine_scaling(1.0, -1.0);
+ trans *= agg::trans_affine_translation(0.0, (double)height);
- PathIterator marker_path(marker_path_obj);
- transformed_path_t marker_path_transformed(marker_path, marker_trans);
- snap_t marker_path_snapped(marker_path_transformed,
- gc.snap_mode,
- marker_path.total_vertices(),
- gc.linewidth);
- curve_t marker_path_curve(marker_path_snapped);
+ PathIterator marker_path(marker_path_obj);
+ transformed_path_t marker_path_transformed(marker_path, marker_trans);
+ snap_t marker_path_snapped(marker_path_transformed,
+ gc.snap_mode,
+ marker_path.total_vertices(),
+ gc.linewidth);
+ curve_t marker_path_curve(marker_path_snapped);
- PathIterator path(path_obj);
- transformed_path_t path_transformed(path, trans);
- snap_t path_snapped(path_transformed,
- gc.snap_mode,
- path.total_vertices(),
- 1.0);
- curve_t path_curve(path_snapped);
- path_curve.rewind(0);
+ PathIterator path(path_obj);
+ transformed_path_t path_transformed(path, trans);
+ snap_t path_snapped(path_transformed,
+ gc.snap_mode,
+ path.total_vertices(),
+ 1.0);
+ curve_t path_curve(path_snapped);
+ path_curve.rewind(0);
- facepair_t face = _get_rgba_face(face_obj, gc.alpha);
+ facepair_t face = _get_rgba_face(face_obj, gc.alpha);
- //maxim's suggestions for cached scanlines
- agg::scanline_storage_aa8 scanlines;
- theRasterizer.reset();
- theRasterizer.reset_clipping();
- rendererBase.reset_clipping(true);
+ //maxim's suggestions for cached scanlines
+ agg::scanline_storage_aa8 scanlines;
+ theRasterizer.reset();
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
- agg::int8u staticFillCache[MARKER_CACHE_SIZE];
- agg::int8u staticStrokeCache[MARKER_CACHE_SIZE];
- agg::int8u* fillCache = staticFillCache;
- agg::int8u* strokeCache = staticStrokeCache;
+ agg::int8u staticFillCache[MARKER_CACHE_SIZE];
+ agg::int8u staticStrokeCache[MARKER_CACHE_SIZE];
+ 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);
- fillSize = scanlines.byte_size();
- if (fillSize >= MARKER_CACHE_SIZE)
- fillCache = new agg::int8u[fillSize];
- scanlines.serialize(fillCache);
- }
+ try
+ {
+ unsigned fillSize = 0;
+ if (face.first)
+ {
+ theRasterizer.add_path(marker_path_curve);
+ agg::render_scanlines(theRasterizer, slineP8, scanlines);
+ fillSize = scanlines.byte_size();
+ if (fillSize >= MARKER_CACHE_SIZE)
+ {
+ fillCache = new agg::int8u[fillSize];
+ }
+ scanlines.serialize(fillCache);
+ }
- stroke_t stroke(marker_path_curve);
- 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);
- unsigned strokeSize = scanlines.byte_size();
- if (strokeSize >= MARKER_CACHE_SIZE)
- strokeCache = new agg::int8u[strokeSize];
- scanlines.serialize(strokeCache);
+ stroke_t stroke(marker_path_curve);
+ 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);
+ unsigned strokeSize = scanlines.byte_size();
+ if (strokeSize >= MARKER_CACHE_SIZE)
+ {
+ strokeCache = new agg::int8u[strokeSize];
+ }
+ scanlines.serialize(strokeCache);
- theRasterizer.reset_clipping();
- rendererBase.reset_clipping(true);
- set_clipbox(gc.cliprect, rendererBase);
- bool has_clippath = render_clippath(gc.clippath, gc.clippath_trans);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
+ set_clipbox(gc.cliprect, rendererBase);
+ bool has_clippath = render_clippath(gc.clippath, gc.clippath_trans);
- double x, y;
+ double x, y;
- agg::serialized_scanlines_adaptor_aa8 sa;
- agg::serialized_scanlines_adaptor_aa8::embedded_scanline sl;
+ agg::serialized_scanlines_adaptor_aa8 sa;
+ agg::serialized_scanlines_adaptor_aa8::embedded_scanline sl;
- agg::rect_d clipping_rect(
- -(scanlines.min_x() + 1.0),
- -(scanlines.min_y() + 1.0),
- width + scanlines.max_x() + 1.0,
- height + scanlines.max_y() + 1.0);
+ agg::rect_d clipping_rect(
+ -(scanlines.min_x() + 1.0),
+ -(scanlines.min_y() + 1.0),
+ width + scanlines.max_x() + 1.0,
+ height + scanlines.max_y() + 1.0);
- if (has_clippath) {
- while (path_curve.vertex(&x, &y) != agg::path_cmd_stop) {
- if (MPL_notisfinite64(x) || MPL_notisfinite64(y)) {
- continue;
- }
+ if (has_clippath)
+ {
+ while (path_curve.vertex(&x, &y) != agg::path_cmd_stop)
+ {
+ if (MPL_notisfinite64(x) || MPL_notisfinite64(y))
+ {
+ continue;
+ }
- x = (double)(int)x; y = (double)(int)y;
+ x = (double)(int)x;
+ y = (double)(int)y;
- // Cull points outside the boundary of the image. Values
- // that are too large may overflow and create segfaults.
- // because they can create segfaults of they overflow; eg
- // http://sourceforge.net/tracker/?func=detail&aid=2865490&group_id=80706&atid=560720
- if (!clipping_rect.hit_test(x, y)) {
- continue;
- }
+ // Cull points outside the boundary of the image.
+ // Values that are too large may overflow and create
+ // segfaults.
+ // http://sourceforge.net/tracker/?func=detail&aid=2865490&group_id=80706&atid=560720
+ if (!clipping_rect.hit_test(x, y))
+ {
+ continue;
+ }
- pixfmt_amask_type pfa(pixFmt, alphaMask);
- amask_ren_type r(pfa);
- amask_aa_renderer_type ren(r);
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
+ amask_ren_type r(pfa);
+ amask_aa_renderer_type ren(r);
- if (face.first) {
- ren.color(face.second);
- sa.init(fillCache, fillSize, x, y);
- agg::render_scanlines(sa, sl, ren);
+ if (face.first)
+ {
+ ren.color(face.second);
+ sa.init(fillCache, fillSize, x, y);
+ agg::render_scanlines(sa, sl, ren);
+ }
+ ren.color(gc.color);
+ sa.init(strokeCache, strokeSize, x, y);
+ agg::render_scanlines(sa, sl, ren);
+ }
}
- ren.color(gc.color);
- sa.init(strokeCache, strokeSize, x, y);
- agg::render_scanlines(sa, sl, ren);
- }
- } else {
- while (path_curve.vertex(&x, &y) != agg::path_cmd_stop) {
- if (MPL_notisfinite64(x) || MPL_notisfinite64(y)) {
- continue;
- }
+ else
+ {
+ while (path_curve.vertex(&x, &y) != agg::path_cmd_stop)
+ {
+ if (MPL_notisfinite64(x) || MPL_notisfinite64(y))
+ {
+ continue;
+ }
- x = (double)(int)x; y = (double)(int)y;
+ x = (double)(int)x;
+ y = (double)(int)y;
- // Cull points outside the boundary of the image. Values
- // that are too large may overflow and create segfaults.
- // because they can create segfaults of they overflow; eg
- // http://sourceforge.net/tracker/?func=detail&aid=2865490&group_id=80706&atid=560720
- if (!clipping_rect.hit_test(x, y)) {
- continue;
- }
+ // Cull points outside the boundary of the image.
+ // Values that are too large may overflow and create
+ // segfaults.
+ // http://sourceforge.net/tracker/?func=detail&aid=2865490&group_id=80706&atid=560720
+ if (!clipping_rect.hit_test(x, y))
+ {
+ continue;
+ }
- if (face.first) {
- rendererAA.color(face.second);
- sa.init(fillCache, fillSize, x, y);
- agg::render_scanlines(sa, sl, rendererAA);
+ if (face.first)
+ {
+ rendererAA.color(face.second);
+ sa.init(fillCache, fillSize, x, y);
+ agg::render_scanlines(sa, sl, rendererAA);
+ }
+
+ rendererAA.color(gc.color);
+ sa.init(strokeCache, strokeSize, x, y);
+ agg::render_scanlines(sa, sl, rendererAA);
+ }
}
+ }
+ catch (...)
+ {
+ if (fillCache != staticFillCache)
+ delete[] fillCache;
+ if (strokeCache != staticStrokeCache)
+ delete[] strokeCache;
+ throw;
+ }
- rendererAA.color(gc.color);
- sa.init(strokeCache, strokeSize, x, y);
- agg::render_scanlines(sa, sl, rendererAA);
- }
- }
- } catch(...) {
if (fillCache != staticFillCache)
- delete[] fillCache;
+ delete[] fillCache;
if (strokeCache != staticStrokeCache)
- delete[] strokeCache;
- throw;
- }
+ delete[] strokeCache;
- if (fillCache != staticFillCache)
- delete[] fillCache;
- if (strokeCache != staticStrokeCache)
- delete[] strokeCache;
-
- return Py::Object();
+ return Py::Object();
}
+
/**
* This is a custom span generator that converts spans in the
* 8-bit inverted greyscale font buffer to rgba that agg can use.
@@ -680,1380 +816,1626 @@
class font_to_rgba
{
public:
- typedef ChildGenerator child_type;
- typedef agg::rgba8 color_type;
- typedef typename child_type::color_type child_color_type;
- typedef agg::span_allocator<child_color_type> span_alloc_type;
+ typedef ChildGenerator child_type;
+ typedef agg::rgba8 color_type;
+ typedef typename child_type::color_type child_color_type;
+ typedef agg::span_allocator<child_color_type> span_alloc_type;
private:
- child_type* _gen;
- color_type _color;
- span_alloc_type _allocator;
+ child_type* _gen;
+ color_type _color;
+ span_alloc_type _allocator;
public:
- font_to_rgba(child_type* gen, color_type color) :
- _gen(gen),
- _color(color) {
- }
+ font_to_rgba(child_type* gen, color_type color) :
+ _gen(gen),
+ _color(color)
+ {
- inline void generate(color_type* output_span, int x, int y, unsigned len)
- {
- _allocator.allocate(len);
- child_color_type* input_span = _allocator.span();
- _gen->generate(input_span, x, y, len);
+ }
- do {
- *output_span = _color;
- output_span->a = ((unsigned int)_color.a * (unsigned int)input_span->v) >> 8;
- ++output_span;
- ++input_span;
- } while (--len);
- }
+ inline void
+ generate(color_type* output_span, int x, int y, unsigned len)
+ {
+ _allocator.allocate(len);
+ child_color_type* input_span = _allocator.span();
+ _gen->generate(input_span, x, y, len);
- void prepare()
- {
- _gen->prepare();
- }
+ do
+ {
+ *output_span = _color;
+ output_span->a = ((unsigned int)_color.a *
+ (unsigned int)input_span->v) >> 8;
+ ++output_span;
+ ++input_span;
+ }
+ while (--len);
+ }
+ void
+ prepare()
+ {
+ _gen->prepare();
+ }
};
+
// MGDTODO: Support clip paths
Py::Object
-RendererAgg::draw_text_image(const Py::Tuple& args) {
- _VERBOSE("RendererAgg::draw_text");
+RendererAgg::draw_text_image(const Py::Tuple& args)
+{
+ _VERBOSE("RendererAgg::draw_text");
- typedef agg::span_allocator<agg::gray8> gray_span_alloc_type;
- typedef agg::span_allocator<agg::rgba8> color_span_alloc_type;
- typedef agg::span_interpolator_linear<> interpolator_type;
- typedef agg::image_accessor_clip<agg::pixfmt_gray8> image_accessor_type;
- //typedef agg::span_image_filter_gray_2x2<image_accessor_type, interpolator_type>
- // image_span_gen_type;
- typedef agg::span_image_filter_gray<image_accessor_type, interpolator_type>
- image_span_gen_type;
+ typedef agg::span_allocator<agg::gray8> gray_span_alloc_type;
+ typedef agg::span_allocator<agg::rgba8> color_span_alloc_type;
+ typedef agg::span_interpolator_linear<> interpolator_type;
+ typedef agg::image_accessor_clip<agg::pixfmt_gray8> image_accessor_type;
+ typedef agg::span_image_filter_gray<image_accessor_type,
+ interpolator_type> image_span_gen_type;
+ typedef font_to_rgba<image_span_gen_type> span_gen_type;
+ typedef agg::renderer_scanline_aa<renderer_base, color_span_alloc_type,
+ span_gen_type> renderer_type;
- typedef font_to_rgba<image_span_gen_type> span_gen_type;
- typedef agg::renderer_scanline_aa<renderer_base, color_span_alloc_type, span_gen_type>
- renderer_type;
+ args.verify_length(5);
- args.verify_length(5);
+ const unsigned char* buffer = NULL;
+ int width, height;
+ Py::Object image_obj = args[0];
+ PyArrayObject* image_array = NULL;
- const unsigned char* buffer = NULL;
- int width, height;
- Py::Object image_obj = args[0];
- PyArrayObject* image_array = NULL;
- if (PyArray_Check(image_obj.ptr())) {
- image_array = (PyArrayObject*)PyArray_FromObject(image_obj.ptr(), PyArray_UBYTE, 2, 2);
- if (!image_array)
- throw Py::ValueError("First argument to draw_text_image must be a FT2Font.Image object or a Nx2 uint8 numpy array.");
- buffer = (unsigned char *)PyArray_DATA(image_array);
- width = PyArray_DIM(image_array, 1);
- height = PyArray_DIM(image_array, 0);
- } else {
- FT2Image *image = static_cast<FT2Image*>(args[0].ptr());
- if (!image->get_buffer())
- throw Py::ValueError("First argument to draw_text_image must be a FT2Font.Image object or a Nx2 uint8 numpy array.");
- buffer = image->get_buffer();
- width = image->get_width();
- height = image->get_height();
- }
+ if (PyArray_Check(image_obj.ptr()))
+ {
+ image_array = (PyArrayObject*)PyArray_FromObject(image_obj.ptr(), PyArray_UBYTE, 2, 2);
+ if (!image_array)
+ {
+ throw Py::ValueError(
+ "First argument to draw_text_image must be a FT2Font.Image object or a Nx2 uint8 numpy array.");
+ }
+ buffer = (unsigned char *)PyArray_DATA(image_array);
+ width = PyArray_DIM(image_array, 1);
+ height = PyArray_DIM(image_array, 0);
+ }
+ else
+ {
+ FT2Image *image = static_cast<FT2Image*>(args[0].ptr());
+ if (!image->get_buffer())
+ {
+ throw Py::ValueError(
+ "First argument to draw_text_image must be a FT2Font.Image object or a Nx2 uint8 numpy array.");
+ }
+ buffer = image->get_buffer();
+ width = image->get_width();
+ height = image->get_height();
+ }
- int x(0),y(0);
- try {
- x = Py::Int( args[1] );
- y = Py::Int( args[2] );
- }
- catch (Py::TypeError) {
- Py_XDECREF(image_array);
- throw Py::TypeError("Invalid input arguments to draw_text_image");
- }
+ int x(0), y(0);
+ try
+ {
+ x = Py::Int(args[1]);
+ y = Py::Int(args[2]);
+ }
+ catch (Py::TypeError)
+ {
+ Py_XDECREF(image_array);
+ throw Py::TypeError("Invalid input arguments to draw_text_image");
+ }
- double angle = Py::Float( args[3] );
+ double angle = Py::Float(args[3]);
- GCAgg gc(args[4], dpi);
+ GCAgg gc(args[4], dpi);
- theRasterizer.reset_clipping();
- rendererBase.reset_clipping(true);
- set_clipbox(gc.cliprect, theRasterizer);
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
+ set_clipbox(gc.cliprect, theRasterizer);
- agg::rendering_buffer srcbuf((agg::int8u*)buffer, width, height, width);
- agg::pixfmt_gray8 pixf_img(srcbuf);
+ agg::rendering_buffer srcbuf((agg::int8u*)buffer, width, height, width);
+ agg::pixfmt_gray8 pixf_img(srcbuf);
- agg::trans_affine mtx;
- mtx *= agg::trans_affine_translation(0, -height);
- mtx *= agg::trans_affine_rotation(-angle * agg::pi / 180.0);
- mtx *= agg::trans_affine_translation(x, y);
+ agg::trans_affine mtx;
+ mtx *= agg::trans_affine_translation(0, -height);
+ mtx *= agg::trans_affine_rotation(-angle * agg::pi / 180.0);
+ mtx *= agg::trans_affine_translation(x, y);
- agg::path_storage rect;
- rect.move_to(0, 0);
- rect.line_to(width, 0);
- rect.line_to(width, height);
- rect.line_to(0, height);
- rect.line_to(0, 0);
- agg::conv_transform<agg::path_storage> rect2(rect, mtx);
+ agg::path_storage rect;
+ rect.move_to(0, 0);
+ rect.line_to(width, 0);
+ rect.line_to(width, height);
+ rect.line_to(0, height);
+ rect.line_to(0, 0);
+ agg::conv_transform<agg::path_storage> rect2(rect, mtx);
- agg::trans_affine inv_mtx(mtx);
- inv_mtx.invert();
+ agg::trans_affine inv_mtx(mtx);
+ inv_mtx.invert();
- agg::image_filter_lut filter;
- filter.calculate(agg::image_filter_spline36());
- interpolator_type interpolator(inv_mtx);
- color_span_alloc_type sa;
- 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);
+ agg::image_filter_lut filter;
+ filter.calculate(agg::image_filter_spline36());
+ interpolator_type interpolator(inv_mtx);
+ color_span_alloc_type sa;
+ 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);
- theRasterizer.add_path(rect2);
- agg::render_scanlines(theRasterizer, slineP8, ri);
+ theRasterizer.add_path(rect2);
+ agg::render_scanlines(theRasterizer, slineP8, ri);
- Py_XDECREF(image_array);
+ Py_XDECREF(image_array);
- return Py::Object();
+ return Py::Object();
}
Py::Object
-RendererAgg::draw_image(const Py::Tuple& args) {
- _VERBOSE("RendererAgg::draw_image");
+RendererAgg::draw_image(const Py::Tuple& args)
+{
+ _VERBOSE("RendererAgg::draw_image");
- args.verify_length(4, 7); // 7 if affine matrix if given
+ args.verify_length(4, 7); // 7 if affine matrix if given
- GCAgg gc(args[0], dpi);
- Image *image = static_cast<Image*>(args[3].ptr());
- bool has_clippath = false;
- agg::trans_affine affine_trans;
- bool has_affine = false;
- double x, y, w, h;
+ GCAgg gc(args[0], dpi);
+ Image *image = static_cast<Image*>(args[3].ptr());
+ bool has_clippath = false;
+ agg::trans_affine affine_trans;
+ bool has_affine = false;
+ double x, y, w, h;
-
- if (args.size() == 7) {
- has_affine = true;
- x = Py::Float(args[1]);
- y = Py::Float(args[2]);
- w = Py::Float(args[4]);
- h = Py::Float(args[5]);
- affine_trans = py_to_agg_transformation_matrix(args[6].ptr());
- } else {
- x = mpl_round(Py::Float(args[1]));
- y = mpl_round(Py::Float(args[2]));
- w = h = 0; /* w and h not used in this case, but assign to prevent
+ if (args.size() == 7)
+ {
+ has_affine = true;
+ x = Py::Float(args[1]);
+ y = Py::Float(args[2]);
+ w = Py::Float(args[4]);
+ h = Py::Float(args[5]);
+ affine_trans = py_to_agg_transformation_matrix(args[6].ptr());
+ }
+ else
+ {
+ x = mpl_round(Py::Float(args[1]));
+ y = mpl_round(Py::Float(args[2]));
+ w = h = 0; /* w and h not used in this case, but assign to prevent
warnings from the compiler */
- }
+ }
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
+ set_clipbox(gc.cliprect, theRasterizer);
+ has_clippath = render_clippath(gc.clippath, gc.clippath_trans);
- theRasterizer.reset_clipping();
- rendererBase.reset_clipping(true);
- set_clipbox(gc.cliprect, theRasterizer);
- has_clippath = render_clippath(gc.clippath, gc.clippath_trans);
+ Py::Tuple empty;
+ image->flipud_out(empty);
+ pixfmt pixf(*(image->rbufOut));
- Py::Tuple empty;
- image->flipud_out(empty);
- pixfmt pixf(*(image->rbufOut));
+ if (has_affine | has_clippath)
+ {
+ agg::trans_affine mtx;
+ agg::path_storage rect;
- if (has_affine | has_clippath) {
- agg::trans_affine mtx;
- agg::path_storage rect;
+ if (has_affine)
+ {
+ mtx *= agg::trans_affine_scaling(1, -1);
+ mtx *= agg::trans_affine_translation(0, image->rowsOut);
+ mtx *= agg::trans_affine_scaling(w / (image->colsOut),
+ h / (image->rowsOut));
+ mtx *= agg::trans_affine_translation(x, y);
+ mtx *= affine_trans;
+ mtx *= agg::trans_affine_scaling(1.0, -1.0);
+ mtx *= agg::trans_affine_translation(0.0, (double) height);
+ }
+ else
+ {
+ mtx *= agg::trans_affine_translation(
+ (int)x,
+ (int)(height - (y + image->rowsOut)));
+ }
- if (has_affine) {
- mtx *= agg::trans_affine_scaling(1, -1);
- mtx *= agg::trans_affine_translation(0, image->rowsOut);
- mtx *= agg::trans_affine_scaling(w/(image->colsOut), h/(image->rowsOut));
- mtx *= agg::trans_affine_translation(x, y);
- mtx *= affine_trans;
- mtx *= agg::trans_affine_scaling(1.0, -1.0);
- mtx *= agg::trans_affine_translation(0.0, (double) height);
- } else {
- mtx *= agg::trans_affine_translation((int)x, (int)(height-(y+image->rowsOut)));
- }
+ rect.move_to(0, 0);
+ rect.line_to(image->colsOut, 0);
+ rect.line_to(image->colsOut, image->rowsOut);
+ rect.line_to(0, image->rowsOut);
+ rect.line_to(0, 0);
- rect.move_to(0, 0);
- rect.line_to(image->colsOut, 0);
- rect.line_to(image->colsOut, image->rowsOut);
- rect.line_to(0, image->rowsOut);
- rect.line_to(0, 0);
+ agg::conv_transform<agg::path_storage> rect2(rect, mtx);
- agg::conv_transform<agg::path_storage> rect2(rect, mtx);
+ agg::trans_affine inv_mtx(mtx);
+ inv_mtx.invert();
- agg::trans_affine inv_mtx(mtx);
- inv_mtx.invert();
+ typedef agg::span_allocator<agg::rgba8> color_span_alloc_type;
+ typedef agg::image_accessor_clip<agg::pixfmt_rgba32>
+ image_accessor_type;
+ typedef agg::span_interpolator_linear<> interpolator_type;
+ typedef agg::span_image_filter_rgba_nn<image_accessor_type,
+ interpolator_type> image_span_gen_type;
+ color_span_alloc_type sa;
+ 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);
- typedef agg::span_allocator<agg::rgba8> color_span_alloc_type;
- typedef agg::image_accessor_clip<agg::pixfmt_rgba32> image_accessor_type;
- typedef agg::span_interpolator_linear<> interpolator_type;
- typedef agg::span_image_filter_rgba_nn<image_accessor_type, interpolator_type> image_span_gen_type;
+ if (has_clippath)
+ {
+ typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type>
+ pixfmt_amask_type;
+ typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
+ typedef agg::renderer_scanline_aa<amask_ren_type,
+ color_span_alloc_type,
+ image_span_gen_type>
+ renderer_type_alpha;
+ pixfmt_amask_type pfa(pixFmt, alphaMask);
+ amask_ren_type r(pfa);
+ renderer_type_alpha ri(r, sa, image_span_generator);
- color_span_alloc_type sa;
- 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);
+ theRasterizer.add_path(rect2);
+ agg::render_scanlines(theRasterizer, slineP8, ri);
+ }
+ else
+ {
+ typedef agg::renderer_base<pixfmt> ren_type;
+ typedef agg::renderer_scanline_aa<ren_type,
+ color_span_alloc_type,
+ image_span_gen_type>
+ renderer_type;
+ ren_type r(pixFmt);
+ renderer_type ri(r, sa, image_span_generator);
- if (has_clippath) {
- typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
- typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
- typedef agg::renderer_scanline_aa<amask_ren_type, color_span_alloc_type, image_span_gen_type> renderer_type_alpha;
+ theRasterizer.add_path(rect2);
+ agg::render_scanlines(theRasterizer, slineP8, ri);
+ }
- pixfmt_amask_type pfa(pixFmt, alphaMask);
- amask_ren_type r(pfa);
- renderer_type_alpha ri(r, sa, image_span_generator);
-
- theRasterizer.add_path(rect2);
- agg::render_scanlines(theRasterizer, slineP8, ri);
- } else {
- typedef agg::renderer_base<pixfmt> ren_type;
- typedef agg::renderer_scanline_aa<ren_type, color_span_alloc_type, image_span_gen_type> renderer_type;
- ren_type r(pixFmt);
- renderer_type ri(r, sa, image_span_generator);
-
- theRasterizer.add_path(rect2);
- agg::render_scanlines(theRasterizer, slineP8, ri);
}
+ else
+ {
+ set_clipbox(gc.cliprect, rendererBase);
+ rendererBase.blend_from(pixf, 0, (int)x, (int)(height - (y + image->rowsOut)));
+ }
- } else {
- set_clipbox(gc.cliprect, rendererBase);
- rendererBase.blend_from(pixf, 0, (int)x, (int)(height-(y+image->rowsOut)));
- }
+ image->flipud_out(empty);
- image->flipud_out(empty);
-
- return Py::Object();
+ return Py::Object();
}
-
-
template<class path_t>
void RendererAgg::_draw_path(path_t& path, bool has_clippath,
- const facepair_t& face, const GCAgg& gc) {
- typedef agg::conv_stroke<path_t> stroke_t;
- typedef agg::conv_dash<path_t> dash_t;
- typedef agg::conv_stroke<dash_t> stroke_dash_t;
- typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
- typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
- typedef agg::renderer_scanline_aa_solid<amask_ren_type> amask_aa_renderer_type;
- typedef agg::renderer_scanline_bin_solid<amask_ren_type> amask_bin_renderer_type;
+ const facepair_t& face, const GCAgg& gc)
+{
+ typedef agg::conv_stroke<path_t> stroke_t;
+ typedef agg::conv_dash<path_t> dash_t;
+ typedef agg::conv_stroke<dash_t> stroke_dash_t;
+ typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
+ typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
+ typedef agg::renderer_scanline_aa_solid<amask_ren_type> amask_aa_renderer_type;
+ typedef agg::renderer_scanline_bin_solid<amask_ren_type> amask_bin_renderer_type;
- // Render face
- if (face.first) {
- theRasterizer.add_path(path);
+ // Render face
+ if (face.first)
+ {
+ theRasterizer.add_path(path);
- if (gc.isaa) {
- if (has_clippath) {
- 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);
- } else {
- rendererAA.color(face.second);
- agg::render_scanlines(theRasterizer, slineP8, rendererAA);
- }
- } else {
- if (has_clippath) {
- 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);
- } else {
- rendererBin.color(face.second);
- agg::render_scanlines(theRasterizer, slineP8, rendererBin);
- }
+ if (gc.isaa)
+ {
+ if (has_clippath)
+ {
+ 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);
+ }
+ else
+ {
+ rendererAA.color(face.second);
+ agg::render_scanlines(theRasterizer, slineP8, rendererAA);
+ }
+ }
+ else
+ {
+ if (has_clippath)
+ {
+ 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);
+ }
+ else
+ {
+ rendererBin.color(face.second);
+ agg::render_scanlines(theRasterizer, slineP8, rendererBin);
+ }
+ }
}
- }
- // Render hatch
- if (!gc.hatchpath.isNone()) {
- // Reset any clipping that may be in effect, since we'll be
- // drawing the hatch in a scratch buffer at origin (0, 0)
- theRasterizer.reset_clipping();
- rendererBase.reset_clipping(true);
+ // Render hatch
+ if (!gc.hatchpath.isNone())
+ {
+ // Reset any clipping that may be in effect, since we'll be
+ // drawing the hatch in a scratch buffer at origin (0, 0)
+ theRasterizer.reset_clipping();
+ rendererBase.reset_clipping(true);
- // Create and transform the path
- typedef agg::conv_transform<PathIterator> hatch_p...
[truncated message content] |
