#include "mplutils.h"

#include "py_converters.h"

#include "_backend_agg.h"

typedef struct

{

PyObject_HEAD

RendererAgg *x;

Py_ssize_t shape[3];

Py_ssize_t strides[3];

Py_ssize_t suboffsets[3];

} PyRendererAgg;

typedef struct

{

PyObject_HEAD

BufferRegion *x;

Py_ssize_t shape[3];

Py_ssize_t strides[3];

Py_ssize_t suboffsets[3];

} PyBufferRegion;

static PyObject *PyBufferRegion_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyBufferRegion *self;

self = (PyBufferRegion *)type->tp_alloc(type, 0);

self->x = NULL;

return (PyObject *)self;

}

static void PyBufferRegion_dealloc(PyBufferRegion *self)

}

static PyObject *PyBufferRegion_to_string(PyBufferRegion *self, PyObject *args, PyObject *kwds)

{

return PyBytes_FromStringAndSize((const char *)self->x->get_data(),

self->x->get_height() * self->x->get_stride());

}

static PyObject *PyBufferRegion_set_x(PyBufferRegion *self, PyObject *args, PyObject *kwds)

{

int x;

if (!PyArg_ParseTuple(args, "i:set_x", &x)) {

return NULL;

}

self->x->get_rect().x1 = x;

Py_RETURN_NONE;

}

static PyObject *PyBufferRegion_set_y(PyBufferRegion *self, PyObject *args, PyObject *kwds)

{

int y;

if (!PyArg_ParseTuple(args, "i:set_y", &y)) {

return NULL;

}

self->x->get_rect().y1 = y;

Py_RETURN_NONE;

}

static PyObject *PyBufferRegion_get_extents(PyBufferRegion *self, PyObject *args, PyObject *kwds)

{

agg::rect_i rect = self->x->get_rect();

return Py_BuildValue("IIII", rect.x1, rect.y1, rect.x2, rect.y2);

}

static PyObject *PyBufferRegion_to_string_argb(PyBufferRegion *self, PyObject *args, PyObject *kwds)

{

PyObject *bufobj;

uint8_t *buf;

bufobj = PyBytes_FromStringAndSize(NULL, self->x->get_height() * self->x->get_stride());

buf = (uint8_t *)PyBytes_AS_STRING(bufobj);

CALL_CPP_CLEANUP("to_string_argb", (self->x->to_string_argb(buf)), Py_DECREF(bufobj));

return bufobj;

}

int PyBufferRegion_get_buffer(PyBufferRegion *self, Py_buffer *buf, int flags)

}

static PyTypeObject PyBufferRegionType;

static PyTypeObject *PyBufferRegion_init_type(PyObject *m, PyTypeObject *type)

{

static PyMethodDef methods[] = {

{ "to_string", (PyCFunction)PyBufferRegion_to_string, METH_NOARGS, NULL },

{ "to_string_argb", (PyCFunction)PyBufferRegion_to_string_argb, METH_NOARGS, NULL },

{ "set_x", (PyCFunction)PyBufferRegion_set_x, METH_VARARGS, NULL },

{ "set_y", (PyCFunction)PyBufferRegion_set_y, METH_VARARGS, NULL },

{ "get_extents", (PyCFunction)PyBufferRegion_get_extents, METH_NOARGS, NULL },

{ NULL }

};

static PyBufferProcs buffer_procs;

memset(&buffer_procs, 0, sizeof(PyBufferProcs));

buffer_procs.bf_getbuffer = (getbufferproc)PyBufferRegion_get_buffer;

memset(type, 0, sizeof(PyTypeObject));

type->tp_name = "matplotlib.backends._backend_agg.BufferRegion";

type->tp_basicsize = sizeof(PyBufferRegion);

type->tp_dealloc = (destructor)PyBufferRegion_dealloc;

type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;

type->tp_methods = methods;

type->tp_new = PyBufferRegion_new;

type->tp_as_buffer = &buffer_procs;

if (PyType_Ready(type) < 0) {

return NULL;

}

/* Don't need to add to module, since you can't create buffer

return type;

}

static PyObject *PyRendererAgg_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyRendererAgg *self;

self = (PyRendererAgg *)type->tp_alloc(type, 0);

self->x = NULL;

return (PyObject *)self;

}

static int PyRendererAgg_init(PyRendererAgg *self, PyObject *args, PyObject *kwds)

}

static void PyRendererAgg_dealloc(PyRendererAgg *self)

}

static PyObject *PyRendererAgg_draw_path(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

py::PathIterator path;

agg::trans_affine trans;

PyObject *faceobj = NULL;

agg::rgba face;

if (!PyArg_ParseTuple(args,

"O&O&O&|O:draw_path",

&convert_gcagg,

&gc,

&convert_path,

&path,

&convert_trans_affine,

&trans,

&faceobj)) {

return NULL;

}

if (!convert_face(faceobj, gc, &face)) {

return NULL;

}

CALL_CPP("draw_path", (self->x->draw_path(gc, path, trans, face)));

Py_RETURN_NONE;

}

static PyObject *PyRendererAgg_draw_text_image(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

numpy::array_view<agg::int8u, 2> image;

double x;

double y;

double angle;

GCAgg gc;

if (!PyArg_ParseTuple(args,

"O&dddO&:draw_text_image",

&image.converter_contiguous,

&image,

&x,

&y,

&angle,

&convert_gcagg,

&gc)) {

return NULL;

}

CALL_CPP("draw_text_image", (self->x->draw_text_image(gc, image, x, y, angle)));

Py_RETURN_NONE;

}

PyObject *PyRendererAgg_draw_markers(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

py::PathIterator marker_path;

agg::trans_affine marker_path_trans;

py::PathIterator path;

agg::trans_affine trans;

PyObject *faceobj = NULL;

agg::rgba face;

if (!PyArg_ParseTuple(args,

"O&O&O&O&O&|O:draw_markers",

&convert_gcagg,

&gc,

&convert_path,

&marker_path,

&convert_trans_affine,

&marker_path_trans,

&convert_path,

&path,

&convert_trans_affine,

&trans,

&faceobj)) {

return NULL;

}

if (!convert_face(faceobj, gc, &face)) {

return NULL;

}

CALL_CPP("draw_markers",

(self->x->draw_markers(gc, marker_path, marker_path_trans, path, trans, face)));

Py_RETURN_NONE;

}

static PyObject *PyRendererAgg_draw_image(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

double x;

double y;

numpy::array_view<agg::int8u, 3> image;

if (!PyArg_ParseTuple(args,

"O&ddO&:draw_image",

&convert_gcagg,

&gc,

&x,

&y,

&image.converter_contiguous,

&image)) {

return NULL;

}

x = mpl_round(x);

y = mpl_round(y);

gc.alpha = 1.0;

CALL_CPP("draw_image", (self->x->draw_image(gc, x, y, image)));

Py_RETURN_NONE;

}

static PyObject *

PyRendererAgg_draw_path_collection(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

agg::trans_affine master_transform;

PyObject *pathobj;

numpy::array_view<const double, 3> transforms;

numpy::array_view<const double, 2> offsets;

agg::trans_affine offset_trans;

numpy::array_view<const double, 2> facecolors;

numpy::array_view<const double, 2> edgecolors;

numpy::array_view<const double, 1> linewidths;

DashesVector dashes;

numpy::array_view<const uint8_t, 1> antialiaseds;

PyObject *ignored;

e_offset_position offset_position;

if (!PyArg_ParseTuple(args,

"O&O&OO&O&O&O&O&O&O&O&OO&:draw_path_collection",

&convert_gcagg,

&gc,

&convert_trans_affine,

&master_transform,

&pathobj,

&convert_transforms,

&transforms,

&convert_points,

&offsets,

&convert_trans_affine,

&offset_trans,

&convert_colors,

&facecolors,

&convert_colors,

&edgecolors,

&linewidths.converter,

&linewidths,

&convert_dashes_vector,

&dashes,

&antialiaseds.converter,

&antialiaseds,

&ignored,

&convert_offset_position,

&offset_position)) {

return NULL;

}

try

{

py::PathGenerator path(pathobj);

CALL_CPP("draw_path_collection",

(self->x->draw_path_collection(gc,

master_transform,

path,

transforms,

offsets,

offset_trans,

facecolors,

edgecolors,

linewidths,

dashes,

antialiaseds,

offset_position)));

}

catch (const py::exception &)

{

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *PyRendererAgg_draw_quad_mesh(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

agg::trans_affine master_transform;

unsigned int mesh_width;

unsigned int mesh_height;

numpy::array_view<const double, 3> coordinates;

numpy::array_view<const double, 2> offsets;

agg::trans_affine offset_trans;

numpy::array_view<const double, 2> facecolors;

bool antialiased;

numpy::array_view<const double, 2> edgecolors;

if (!PyArg_ParseTuple(args,

"O&O&IIO&O&O&O&O&O&:draw_quad_mesh",

&convert_gcagg,

&gc,

&convert_trans_affine,

&master_transform,

&mesh_width,

&mesh_height,

&coordinates.converter,

&coordinates,

&convert_points,

&offsets,

&convert_trans_affine,

&offset_trans,

&convert_colors,

&facecolors,

&convert_bool,

&antialiased,

&convert_colors,

&edgecolors)) {

return NULL;

}

CALL_CPP("draw_quad_mesh",

(self->x->draw_quad_mesh(gc,

master_transform,

mesh_width,

mesh_height,

coordinates,

offsets,

offset_trans,

facecolors,

antialiased,

edgecolors)));

Py_RETURN_NONE;

}

static PyObject *

PyRendererAgg_draw_gouraud_triangle(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

numpy::array_view<const double, 2> points;

numpy::array_view<const double, 2> colors;

agg::trans_affine trans;

if (!PyArg_ParseTuple(args,

"O&O&O&O&|O:draw_gouraud_triangle",

&convert_gcagg,

&gc,

&points.converter,

&points,

&colors.converter,

&colors,

&convert_trans_affine,

&trans)) {

return NULL;

}

if (points.dim(0) != 3 || points.dim(1) != 2) {

PyErr_Format(PyExc_ValueError,

"points must be a 3x2 array, got %" NPY_INTP_FMT "x%" NPY_INTP_FMT,

points.dim(0), points.dim(1));

return NULL;

}

if (colors.dim(0) != 3 || colors.dim(1) != 4) {

PyErr_Format(PyExc_ValueError,

"colors must be a 3x4 array, got %" NPY_INTP_FMT "x%" NPY_INTP_FMT,

colors.dim(0), colors.dim(1));

return NULL;

}

CALL_CPP("draw_gouraud_triangle", (self->x->draw_gouraud_triangle(gc, points, colors, trans)));

Py_RETURN_NONE;

}

static PyObject *

PyRendererAgg_draw_gouraud_triangles(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

GCAgg gc;

numpy::array_view<const double, 3> points;

numpy::array_view<const double, 3> colors;

agg::trans_affine trans;

if (!PyArg_ParseTuple(args,

"O&O&O&O&|O:draw_gouraud_triangles",

&convert_gcagg,

&gc,

&points.converter,

&points,

&colors.converter,

&colors,

&convert_trans_affine,

&trans)) {

return NULL;

}

if (points.size() != 0 && (points.dim(1) != 3 || points.dim(2) != 2)) {

PyErr_Format(PyExc_ValueError,

"points must be a Nx3x2 array, got %" NPY_INTP_FMT "x%" NPY_INTP_FMT "x%" NPY_INTP_FMT,

points.dim(0), points.dim(1), points.dim(2));

return NULL;

}

if (colors.size() != 0 && (colors.dim(1) != 3 || colors.dim(2) != 4)) {

PyErr_Format(PyExc_ValueError,

"colors must be a Nx3x4 array, got %" NPY_INTP_FMT "x%" NPY_INTP_FMT "x%" NPY_INTP_FMT,

colors.dim(0), colors.dim(1), colors.dim(2));

return NULL;

}

if (points.size() != colors.size()) {

PyErr_Format(PyExc_ValueError,

"points and colors arrays must be the same length, got %" NPY_INTP_FMT " and %" NPY_INTP_FMT,

points.dim(0), colors.dim(0));

return NULL;

}

CALL_CPP("draw_gouraud_triangles", self->x->draw_gouraud_triangles(gc, points, colors, trans));

Py_RETURN_NONE;

}

static PyObject *

PyRendererAgg_get_content_extents(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

agg::rect_i extents;

CALL_CPP("get_content_extents", (extents = self->x->get_content_extents()));

return Py_BuildValue(

"iiii", extents.x1, extents.y1, extents.x2 - extents.x1, extents.y2 - extents.y1);

}

static PyObject *PyRendererAgg_buffer_rgba(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

return PyBytes_FromStringAndSize((const char *)self->x->pixBuffer,

self->x->get_width() * self->x->get_height() * 4);

}

int PyRendererAgg_get_buffer(PyRendererAgg *self, Py_buffer *buf, int flags)

}

static PyObject *PyRendererAgg_clear(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

CALL_CPP("clear", self->x->clear());

Py_RETURN_NONE;

}

static PyObject *PyRendererAgg_copy_from_bbox(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

agg::rect_d bbox;

BufferRegion *reg;

PyObject *regobj;

if (!PyArg_ParseTuple(args, "O&:copy_from_bbox", &convert_rect, &bbox)) {

return 0;

}

CALL_CPP("copy_from_bbox", (reg = self->x->copy_from_bbox(bbox)));

regobj = PyBufferRegion_new(&PyBufferRegionType, NULL, NULL);

((PyBufferRegion *)regobj)->x = reg;

return regobj;

}

static PyObject *PyRendererAgg_restore_region(PyRendererAgg *self, PyObject *args, PyObject *kwds)

{

PyBufferRegion *regobj;

int xx1 = 0, yy1 = 0, xx2 = 0, yy2 = 0, x = 0, y = 0;

if (!PyArg_ParseTuple(args,

"O!|iiiiii:restore_region",

&PyBufferRegionType,

&regobj,

&xx1,

&yy1,

&xx2,

&yy2,

&x,

&y)) {

return 0;

}

if (PySequence_Size(args) == 1) {

CALL_CPP("restore_region", self->x->restore_region(*(regobj->x)));

} else {

CALL_CPP("restore_region", self->x->restore_region(*(regobj->x), xx1, yy1, xx2, yy2, x, y));

}

Py_RETURN_NONE;

}

PyTypeObject PyRendererAggType;

static PyTypeObject *PyRendererAgg_init_type(PyObject *m, PyTypeObject *type)

{

static PyMethodDef methods[] = {

{"draw_path", (PyCFunction)PyRendererAgg_draw_path, METH_VARARGS, NULL},

{"draw_markers", (PyCFunction)PyRendererAgg_draw_markers, METH_VARARGS, NULL},

{"draw_text_image", (PyCFunction)PyRendererAgg_draw_text_image, METH_VARARGS, NULL},

{"draw_image", (PyCFunction)PyRendererAgg_draw_image, METH_VARARGS, NULL},

{"draw_path_collection", (PyCFunction)PyRendererAgg_draw_path_collection, METH_VARARGS, NULL},

{"draw_quad_mesh", (PyCFunction)PyRendererAgg_draw_quad_mesh, METH_VARARGS, NULL},

{"draw_gouraud_triangle", (PyCFunction)PyRendererAgg_draw_gouraud_triangle, METH_VARARGS, NULL},

{"draw_gouraud_triangles", (PyCFunction)PyRendererAgg_draw_gouraud_triangles, METH_VARARGS, NULL},

{"get_content_extents", (PyCFunction)PyRendererAgg_get_content_extents, METH_NOARGS, NULL},

{"buffer_rgba", (PyCFunction)PyRendererAgg_buffer_rgba, METH_NOARGS, NULL},

{"clear", (PyCFunction)PyRendererAgg_clear, METH_NOARGS, NULL},

{"copy_from_bbox", (PyCFunction)PyRendererAgg_copy_from_bbox, METH_VARARGS, NULL},

{"restore_region", (PyCFunction)PyRendererAgg_restore_region, METH_VARARGS, NULL},

{NULL}

};

static PyBufferProcs buffer_procs;

memset(&buffer_procs, 0, sizeof(PyBufferProcs));

buffer_procs.bf_getbuffer = (getbufferproc)PyRendererAgg_get_buffer;

memset(type, 0, sizeof(PyTypeObject));

type->tp_name = "matplotlib.backends._backend_agg.RendererAgg";

type->tp_basicsize = sizeof(PyRendererAgg);

type->tp_dealloc = (destructor)PyRendererAgg_dealloc;

type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;

type->tp_methods = methods;

type->tp_init = (initproc)PyRendererAgg_init;

type->tp_new = PyRendererAgg_new;

type->tp_as_buffer = &buffer_procs;

if (PyType_Ready(type) < 0) {

return NULL;

}

if (PyModule_AddObject(m, "RendererAgg", (PyObject *)type)) {

return NULL;

}

return type;

}

extern "C" {

static struct PyModuleDef moduledef = {

PyModuleDef_HEAD_INIT,

"_backend_agg",

NULL,

0,

NULL,

NULL,

NULL,

NULL,

NULL

};

PyMODINIT_FUNC PyInit__backend_agg(void)

}

} // extern "C"