{

double x;

double y;

XY(double x_, double y_) : x(x_), y(y_) {}

{

_path_module()

: Py::ExtensionModule<_path_module>("_path")

{

add_varargs_method("point_in_path", &_path_module::point_in_path,

"point_in_path(x, y, path, trans)");

add_varargs_method("point_on_path", &_path_module::point_on_path,

"point_on_path(x, y, r, path, trans)");

add_varargs_method("get_path_extents", &_path_module::get_path_extents,

"get_path_extents(path, trans)");

add_varargs_method("update_path_extents", &_path_module::update_path_extents,

"update_path_extents(path, trans, bbox, minpos)");

add_varargs_method("get_path_collection_extents", &_path_module::get_path_collection_extents,

"get_path_collection_extents(trans, paths, transforms, offsets, offsetTrans)");

add_varargs_method("point_in_path_collection", &_path_module::point_in_path_collection,

"point_in_path_collection(x, y, r, trans, paths, transforms, offsets, offsetTrans, filled)");

add_varargs_method("path_in_path", &_path_module::path_in_path,

"path_in_path(a, atrans, b, btrans)");

add_varargs_method("clip_path_to_rect", &_path_module::clip_path_to_rect,

"clip_path_to_rect(path, bbox, inside)");

add_varargs_method("affine_transform", &_path_module::affine_transform,

"affine_transform(vertices, transform)");

add_varargs_method("count_bboxes_overlapping_bbox", &_path_module::count_bboxes_overlapping_bbox,

"count_bboxes_overlapping_bbox(bbox, bboxes)");

add_varargs_method("path_intersects_path", &_path_module::path_intersects_path,

"path_intersects_path(p1, p2)");

add_varargs_method("convert_path_to_polygons", &_path_module::convert_path_to_polygons,

"convert_path_to_polygons(path, trans, width, height)");

add_varargs_method("cleanup_path", &_path_module::cleanup_path,

"cleanup_path(path, trans, remove_nans, clip, snap, simplify, curves)");

add_varargs_method("convert_to_svg", &_path_module::convert_to_svg,

"convert_to_svg(path, trans, clip, simplify, precision)");

initialize("Helper functions for paths");

}

virtual ~_path_module() {}

Py::Object point_in_path(const Py::Tuple& args);

Py::Object point_on_path(const Py::Tuple& args);

Py::Object get_path_extents(const Py::Tuple& args);

Py::Object update_path_extents(const Py::Tuple& args);

Py::Object get_path_collection_extents(const Py::Tuple& args);

Py::Object point_in_path_collection(const Py::Tuple& args);

Py::Object path_in_path(const Py::Tuple& args);

Py::Object clip_path_to_rect(const Py::Tuple& args);

Py::Object affine_transform(const Py::Tuple& args);

Py::Object count_bboxes_overlapping_bbox(const Py::Tuple& args);

Py::Object path_intersects_path(const Py::Tuple& args);

Py::Object convert_path_to_polygons(const Py::Tuple& args);

Py::Object cleanup_path(const Py::Tuple& args);

Py::Object convert_to_svg(const Py::Tuple& args);

{

int yflag0, yflag1, inside_flag;

double vtx0, vty0, vtx1, vty1, sx, sy;

double x, y;

path.rewind(0);

inside_flag = 0;

unsigned code = 0;

do

{

if (code != agg::path_cmd_move_to)

{

code = path.vertex(&x, &y);

}

sx = vtx0 = x;

sy = vty0 = y;

// get test bit for above/below X axis

yflag0 = (vty0 >= ty);

vtx1 = x;

vty1 = y;

inside_flag = 0;

do

{

code = path.vertex(&x, &y);

// The following cases denote the beginning on a new subpath

if (code == agg::path_cmd_stop ||

(code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly)

{

x = sx;

y = sy;

}

else if (code == agg::path_cmd_move_to)

{

break;

}

yflag1 = (vty1 >= ty);

// Check if endpoints straddle (are on opposite sides) of

// X axis (i.e. the Y's differ); if so, +X ray could

// intersect this edge. The old test also checked whether

// the endpoints are both to the right or to the left of

// the test point. However, given the faster intersection

// point computation used below, this test was found to be

// a break-even proposition for most polygons and a loser

// for triangles (where 50% or more of the edges which

// survive this test will cross quadrants and so have to

// have the X intersection computed anyway). I credit

// Joseph Samosky with inspiring me to try dropping the

// "both left or both right" part of my code.

if (yflag0 != yflag1)

{

// Check intersection of pgon segment with +X ray.

// Note if >= point's X; if so, the ray hits it. The

// division operation is avoided for the ">=" test by

// checking the sign of the first vertex wrto the test

// point; idea inspired by Joseph Samosky's and Mark

// Haigh-Hutchinson's different polygon inclusion

// tests.

if (((vty1 - ty) * (vtx0 - vtx1) >=

(vtx1 - tx) * (vty0 - vty1)) == yflag1)

{

inside_flag ^= 1;

}

}

// Move to the next pair of vertices, retaining info as

// possible.

yflag0 = yflag1;

vtx0 = vtx1;

vty0 = vty1;

vtx1 = x;

vty1 = y;

}

while (code != agg::path_cmd_stop &&

(code & agg::path_cmd_end_poly) != agg::path_cmd_end_poly);

yflag1 = (vty1 >= ty);

if (yflag0 != yflag1)

{

if (((vty1 - ty) * (vtx0 - vtx1) >=

(vtx1 - tx) * (vty0 - vty1)) == yflag1)

{

inside_flag ^= 1;

}

}

if (inside_flag != 0)

{

return true;

}

}

while (code != agg::path_cmd_stop);

return (inside_flag != 0);

const agg::trans_affine& trans)

{

typedef agg::conv_transform<PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> no_nans_t;

typedef agg::conv_curve<no_nans_t> curve_t;

typedef agg::conv_contour<curve_t> contour_t;

if (path.total_vertices() < 3)

{

return false;

}

transformed_path_t trans_path(path, trans);

no_nans_t no_nans_path(trans_path, true, path.has_curves());

curve_t curved_path(no_nans_path);

contour_t contoured_path(curved_path);

contoured_path.width(fabs(r));

return point_in_path_impl(x, y, contoured_path);

const agg::trans_affine& trans)

{

typedef agg::conv_transform<PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> no_nans_t;

typedef agg::conv_curve<no_nans_t> curve_t;

typedef agg::conv_stroke<curve_t> stroke_t;

transformed_path_t trans_path(path, trans);

no_nans_t nan_removed_path(trans_path, true, path.has_curves());

curve_t curved_path(nan_removed_path);

stroke_t stroked_path(curved_path);

stroked_path.width(r * 2.0);

return point_in_path_impl(x, y, stroked_path);

{

args.verify_length(5);

double x = Py::Float(args[0]);

double y = Py::Float(args[1]);

double r = Py::Float(args[2]);

PathIterator path(args[3]);

agg::trans_affine trans = py_to_agg_transformation_matrix(args[4].ptr(), false);

if (::point_in_path(x, y, r, path, trans))

{

return Py::Int(1);

}

return Py::Int(0);

{

args.verify_length(5);

double x = Py::Float(args[0]);

double y = Py::Float(args[1]);

double r = Py::Float(args[2]);

PathIterator path(args[3]);

agg::trans_affine trans = py_to_agg_transformation_matrix(args[4].ptr());

if (::point_on_path(x, y, r, path, trans))

{

return Py::Int(1);

}

return Py::Int(0);

double* x0, double* y0, double* x1, double* y1,

double* xm, double* ym)

{

typedef agg::conv_transform<PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> nan_removed_t;

typedef agg::conv_curve<nan_removed_t> curve_t;

double x, y;

unsigned code;

transformed_path_t tpath(path, trans);

nan_removed_t nan_removed(tpath, true, path.has_curves());

curve_t curved_path(nan_removed);

curved_path.rewind(0);

while ((code = curved_path.vertex(&x, &y)) != agg::path_cmd_stop)

{

if ((code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly)

{

continue;

}

if (x < *x0) *x0 = x;

if (y < *y0) *y0 = y;

if (x > *x1) *x1 = x;

if (y > *y1) *y1 = y;

/* xm and ym are the minimum positive values in the data, used

if (x > 0.0 && x < *xm) *xm = x;

if (y > 0.0 && y < *ym) *ym = y;

}

{

args.verify_length(2);

PathIterator path(args[0]);

agg::trans_affine trans = py_to_agg_transformation_matrix(args[1].ptr(), false);

npy_intp extent_dims[] = { 2, 2, 0 };

double* extents_data = NULL;

double xm, ym;

PyArrayObject* extents = NULL;

try

{

extents = (PyArrayObject*)PyArray_SimpleNew

(2, extent_dims, PyArray_DOUBLE);

if (extents == NULL)

{

throw Py::MemoryError("Could not allocate result array");

}

extents_data = (double*)PyArray_DATA(extents);

extents_data[0] = std::numeric_limits<double>::infinity();

extents_data[1] = std::numeric_limits<double>::infinity();

extents_data[2] = -std::numeric_limits<double>::infinity();

extents_data[3] = -std::numeric_limits<double>::infinity();

/* xm and ym are the minimum positive values in the data, used

xm = std::numeric_limits<double>::infinity();

ym = std::numeric_limits<double>::infinity();

::get_path_extents(path, trans, &extents_data[0], &extents_data[1],

&extents_data[2], &extents_data[3], &xm, &ym);

}

catch (...)

{

Py_XDECREF(extents);

throw;

}

return Py::Object((PyObject*)extents, true);

{

args.verify_length(5);

double x0, y0, x1, y1;

PathIterator path(args[0]);

agg::trans_affine trans = py_to_agg_transformation_matrix(

args[1].ptr(), false);

if (!py_convert_bbox(args[2].ptr(), x0, y0, x1, y1))

{

throw Py::ValueError(

"Must pass Bbox object as arg 3 of update_path_extents");

}

Py::Object minpos_obj = args[3];

bool ignore = Py::Boolean(args[4]);

double xm, ym;

PyArrayObject* input_minpos = NULL;

try

{

input_minpos = (PyArrayObject*)PyArray_FromObject(

minpos_obj.ptr(), PyArray_DOUBLE, 1, 1);

if (!input_minpos || PyArray_DIM(input_minpos, 0) != 2)

{

throw Py::TypeError(

"Argument 4 to update_path_extents must be a length-2 numpy array.");

}

xm = *(double*)PyArray_GETPTR1(input_minpos, 0);

ym = *(double*)PyArray_GETPTR1(input_minpos, 1);

}

catch (...)

{

Py_XDECREF(input_minpos);

throw;

}

Py_XDECREF(input_minpos);

npy_intp extent_dims[] = { 2, 2, 0 };

double* extents_data = NULL;

npy_intp minpos_dims[] = { 2, 0 };

double* minpos_data = NULL;

PyArrayObject* extents = NULL;

PyArrayObject* minpos = NULL;

bool changed = false;

try

{

extents = (PyArrayObject*)PyArray_SimpleNew

(2, extent_dims, PyArray_DOUBLE);

if (extents == NULL)

{

throw Py::MemoryError("Could not allocate result array");

}

minpos = (PyArrayObject*)PyArray_SimpleNew

(1, minpos_dims, PyArray_DOUBLE);

if (minpos == NULL)

{

throw Py::MemoryError("Could not allocate result array");

}

extents_data = (double*)PyArray_DATA(extents);

minpos_data = (double*)PyArray_DATA(minpos);

if (ignore)

{

extents_data[0] = std::numeric_limits<double>::infinity();

extents_data[1] = std::numeric_limits<double>::infinity();

extents_data[2] = -std::numeric_limits<double>::infinity();

extents_data[3] = -std::numeric_limits<double>::infinity();

minpos_data[0] = std::numeric_limits<double>::infinity();

minpos_data[1] = std::numeric_limits<double>::infinity();

}

else

{

if (x0 > x1)

{

extents_data[0] = std::numeric_limits<double>::infinity();

extents_data[2] = -std::numeric_limits<double>::infinity();

}

else

{

extents_data[0] = x0;

extents_data[2] = x1;

}

if (y0 > y1)

{

extents_data[1] = std::numeric_limits<double>::infinity();

extents_data[3] = -std::numeric_limits<double>::infinity();

}

else

{

extents_data[1] = y0;

extents_data[3] = y1;

}

minpos_data[0] = xm;

minpos_data[1] = ym;

}

::get_path_extents(path, trans, &extents_data[0], &extents_data[1],

&extents_data[2], &extents_data[3], &minpos_data[0],

&minpos_data[1]);

changed = (extents_data[0] != x0 ||

extents_data[1] != y0 ||

extents_data[2] != x1 ||

extents_data[3] != y1 ||

minpos_data[0] != xm ||

minpos_data[1] != ym);

}

catch (...)

{

Py_XDECREF(extents);

Py_XDECREF(minpos);

throw;

}

Py::Tuple result(3);

result[0] = Py::Object((PyObject*) extents);

result[1] = Py::Object((PyObject*) minpos);

result[2] = Py::Int(changed ? 1 : 0);

Py_XDECREF(extents);

Py_XDECREF(minpos);

return result;

{

args.verify_length(5);

//segments, trans, clipbox, colors, linewidths, antialiaseds

agg::trans_affine master_transform = py_to_agg_transformation_matrix(args[0].ptr());

Py::SeqBase<Py::Object> paths = args[1];

Py::SeqBase<Py::Object> transforms_obj = args[2];

Py::Object offsets_obj = args[3];

agg::trans_affine offset_trans = py_to_agg_transformation_matrix(args[4].ptr(), false);

PyArrayObject* offsets = NULL;

double x0, y0, x1, y1, xm, ym;

try

{

offsets = (PyArrayObject*)PyArray_FromObject(

offsets_obj.ptr(), PyArray_DOUBLE, 0, 2);

if (!offsets ||

(PyArray_NDIM(offsets) == 2 && PyArray_DIM(offsets, 1) != 2) ||

(PyArray_NDIM(offsets) == 1 && PyArray_DIM(offsets, 0) != 0))

{

throw Py::ValueError("Offsets array must be Nx2");

}

size_t Npaths = paths.length();

size_t Noffsets = offsets->dimensions[0];

size_t N = std::max(Npaths, Noffsets);

size_t Ntransforms = std::min(transforms_obj.length(), N);

size_t i;

// Convert all of the transforms up front

typedef std::vector<agg::trans_affine> transforms_t;

transforms_t transforms;

transforms.reserve(Ntransforms);

for (i = 0; i < Ntransforms; ++i)

{

agg::trans_affine trans = py_to_agg_transformation_matrix

(transforms_obj[i].ptr(), false);

trans *= master_transform;

transforms.push_back(trans);

}

// The offset each of those and collect the mins/maxs

x0 = std::numeric_limits<double>::infinity();

y0 = std::numeric_limits<double>::infinity();

x1 = -std::numeric_limits<double>::infinity();

y1 = -std::numeric_limits<double>::infinity();

xm = std::numeric_limits<double>::infinity();

ym = std::numeric_limits<double>::infinity();

agg::trans_affine trans;

for (i = 0; i < N; ++i)

{

PathIterator path(paths[i % Npaths]);

if (Ntransforms)

{

trans = transforms[i % Ntransforms];

}

else

{

trans = master_transform;

}

if (Noffsets)

{

double xo = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 0);

double yo = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 1);

offset_trans.transform(&xo, &yo);

trans *= agg::trans_affine_translation(xo, yo);

}

::get_path_extents(path, trans, &x0, &y0, &x1, &y1, &xm, &ym);

}

}

catch (...)

{

Py_XDECREF(offsets);

throw;

}

Py_XDECREF(offsets);

Py::Tuple result(4);

result[0] = Py::Float(x0);

result[1] = Py::Float(y0);

result[2] = Py::Float(x1);

result[3] = Py::Float(y1);

return result;

{

args.verify_length(9);

//segments, trans, clipbox, colors, linewidths, antialiaseds

double x = Py::Float(args[0]);

double y = Py::Float(args[1]);

double radius = Py::Float(args[2]);

agg::trans_affine master_transform = py_to_agg_transformation_matrix(args[3].ptr());

Py::SeqBase<Py::Object> paths = args[4];

Py::SeqBase<Py::Object> transforms_obj = args[5];

Py::SeqBase<Py::Object> offsets_obj = args[6];

agg::trans_affine offset_trans = py_to_agg_transformation_matrix(args[7].ptr());

bool filled = Py::Boolean(args[8]);

PyArrayObject* offsets = (PyArrayObject*)PyArray_FromObject(

offsets_obj.ptr(), PyArray_DOUBLE, 0, 2);

if (!offsets ||

(PyArray_NDIM(offsets) == 2 && PyArray_DIM(offsets, 1) != 2) ||

(PyArray_NDIM(offsets) == 1 && PyArray_DIM(offsets, 0) != 0))

{

Py_XDECREF(offsets);

throw Py::ValueError("Offsets array must be Nx2");

}

size_t Npaths = paths.length();

size_t Noffsets = offsets->dimensions[0];

size_t N = std::max(Npaths, Noffsets);

size_t Ntransforms = std::min(transforms_obj.length(), N);

size_t i;

// Convert all of the transforms up front

typedef std::vector<agg::trans_affine> transforms_t;

transforms_t transforms;

transforms.reserve(Ntransforms);

for (i = 0; i < Ntransforms; ++i)

{

agg::trans_affine trans = py_to_agg_transformation_matrix

(transforms_obj[i].ptr(), false);

trans *= master_transform;

transforms.push_back(trans);

}

Py::List result;

agg::trans_affine trans;

for (i = 0; i < N; ++i)

{

PathIterator path(paths[i % Npaths]);

if (Ntransforms)

{

trans = transforms[i % Ntransforms];

}

else

{

trans = master_transform;

}

if (Noffsets)

{

double xo = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 0);

double yo = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 1);

offset_trans.transform(&xo, &yo);

trans *= agg::trans_affine_translation(xo, yo);

}

if (filled)

{

if (::point_in_path(x, y, radius, path, trans))

result.append(Py::Int((int)i));

}

else

{

if (::point_on_path(x, y, radius, path, trans))

result.append(Py::Int((int)i));

}

}

return result;

PathIterator& b, const agg::trans_affine& btrans)

{

typedef agg::conv_transform<PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> no_nans_t;

typedef agg::conv_curve<no_nans_t> curve_t;

if (a.total_vertices() < 3)

return false;

transformed_path_t b_path_trans(b, btrans);

no_nans_t b_no_nans(b_path_trans, true, b.has_curves());

curve_t b_curved(b_no_nans);

double x, y;

b_curved.rewind(0);

while (b_curved.vertex(&x, &y) != agg::path_cmd_stop)

{

if (!::point_in_path(x, y, 0.0, a, atrans))

return false;

}

return true;

{

args.verify_length(4);

PathIterator a(args[0]);

agg::trans_affine atrans = py_to_agg_transformation_matrix(

args[1].ptr(), false);

PathIterator b(args[2]);

agg::trans_affine btrans = py_to_agg_transformation_matrix(

args[3].ptr(), false);

return Py::Int(::path_in_path(a, atrans, b, btrans));

{

double m_x;

bisectx(double x) : m_x(x) {}

inline void

bisect(double sx, double sy, double px, double py, double* bx,

double* by) const

{

*bx = m_x;

double dx = px - sx;

double dy = py - sy;

*by = sy + dy * ((m_x - sx) / dx);

}

{

xlt(double x) : bisectx(x) {}

inline bool

is_inside(double x, double y) const

{

return x <= m_x;

}

{

xgt(double x) : bisectx(x) {}

inline bool

is_inside(double x, double y) const

{

return x >= m_x;

}

{

double m_y;

bisecty(double y) : m_y(y) {}

inline void

bisect(double sx, double sy, double px, double py, double* bx,

double* by) const

{

*by = m_y;

double dx = px - sx;

double dy = py - sy;

*bx = sx + dx * ((m_y - sy) / dy);

}

{

ylt(double y) : bisecty(y) {}

inline bool

is_inside(double x, double y) const

{

return y <= m_y;

}

{

ygt(double y) : bisecty(y) {}

inline bool

is_inside(double x, double y) const

{

return y >= m_y;

}

{

double sx, sy, px, py, bx, by;

bool sinside, pinside;

result.clear();

if (polygon.size() == 0)

{

return;

}

sx = polygon.back().x;

sy = polygon.back().y;

for (Polygon::const_iterator i = polygon.begin(); i != polygon.end(); ++i)

{

px = i->x;

py = i->y;

sinside = filter.is_inside(sx, sy);

pinside = filter.is_inside(px, py);

if (sinside ^ pinside)

{

filter.bisect(sx, sy, px, py, &bx, &by);

result.push_back(XY(bx, by));

}

if (pinside)

{

result.push_back(XY(px, py));

}

sx = px;

sy = py;

}

double x0, double y0, double x1, double y1,

bool inside, std::vector<Polygon>& results)

{

double xmin, ymin, xmax, ymax;

if (x0 < x1)

{

xmin = x0;

xmax = x1;

}

else

{

xmin = x1;

xmax = x0;

}

if (y0 < y1)

{

ymin = y0;

ymax = y1;

}

else

{

ymin = y1;

ymax = y0;

}

if (!inside)

{

std::swap(xmin, xmax);

std::swap(ymin, ymax);

}

Polygon polygon1, polygon2;

double x = 0, y = 0;

unsigned code = 0;

path.rewind(0);

do

{

// Grab the next subpath and store it in polygon1

polygon1.clear();

do

{

if (code == agg::path_cmd_move_to)

{

polygon1.push_back(XY(x, y));

}

code = path.vertex(&x, &y);

if (code == agg::path_cmd_stop)

{

break;

}

if (code != agg::path_cmd_move_to)

{

polygon1.push_back(XY(x, y));

}

}

while ((code & agg::path_cmd_end_poly) != agg::path_cmd_end_poly);

// The result of each step is fed into the next (note the

// swapping of polygon1 and polygon2 at each step).

clip_to_rect_one_step(polygon1, polygon2, clip_to_rect_filters::xlt(xmax));

clip_to_rect_one_step(polygon2, polygon1, clip_to_rect_filters::xgt(xmin));

clip_to_rect_one_step(polygon1, polygon2, clip_to_rect_filters::ylt(ymax));

clip_to_rect_one_step(polygon2, polygon1, clip_to_rect_filters::ygt(ymin));

// Empty polygons aren't very useful, so skip them

if (polygon1.size())

{

results.push_back(polygon1);

}

}

while (code != agg::path_cmd_stop);

{

args.verify_length(3);

PathIterator path(args[0]);

Py::Object bbox_obj = args[1];

bool inside = Py::Boolean(args[2]);

double x0, y0, x1, y1;

if (!py_convert_bbox(bbox_obj.ptr(), x0, y0, x1, y1))

{

throw Py::TypeError("Argument 2 to clip_to_rect must be a Bbox object.");

}

std::vector<Polygon> results;

::clip_to_rect(path, x0, y0, x1, y1, inside, results);

npy_intp dims[2];

dims[1] = 2;

PyObject* py_results = PyList_New(results.size());

if (!py_results)

{

throw Py::RuntimeError("Error creating results list");

}

try

{

for (std::vector<Polygon>::const_iterator p = results.begin(); p != results.end(); ++p)

{

size_t size = p->size();

dims[0] = p->size();

PyArrayObject* pyarray = (PyArrayObject*)PyArray_SimpleNew(2, dims, PyArray_DOUBLE);

if (pyarray == NULL)

{

throw Py::MemoryError("Could not allocate result array");

}

for (size_t i = 0; i < size; ++i)

{

((double *)pyarray->data)[2*i] = (*p)[i].x;

((double *)pyarray->data)[2*i+1] = (*p)[i].y;

}

if (PyList_SetItem(py_results, p - results.begin(), (PyObject *)pyarray) != -1)

{

throw Py::RuntimeError("Error creating results list");

}

}

}

catch (...)

{

Py_XDECREF(py_results);

throw;

}

return Py::Object(py_results, true);

{

args.verify_length(2);