bufferIn(NULL), rbufIn(NULL), colsIn(0), rowsIn(0),

bufferOut(NULL), rbufOut(NULL), colsOut(0), rowsOut(0), BPP(4),

interpolation(BILINEAR), aspect(ASPECT_FREE), bg(1, 1, 1, 0), resample(true)

{

_VERBOSE("Image::Image");

{

_VERBOSE("Image::setattr");

__dict__[name] = value;

return 0;

{

_VERBOSE("Image::getattro");

if (__dict__.hasKey(name)) return __dict__[name];

else return getattr_default(name);

{

_VERBOSE("Image::apply_rotation");

args.verify_length(1);

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

agg::trans_affine M = agg::trans_affine_rotation(r * agg::pi / 180.0);

srcMatrix *= M;

imageMatrix *= M;

return Py::Object();

{

_VERBOSE("Image::flipud_in");

args.verify_length(0);

int stride = rbufIn->stride();

rbufIn->attach(bufferIn, colsIn, rowsIn, -stride);

return Py::Object();

{

_VERBOSE("Image::set_bg");

args.verify_length(4);

bg.r = Py::Float(args[0]);

bg.g = Py::Float(args[1]);

bg.b = Py::Float(args[2]);

bg.a = Py::Float(args[3]);

return Py::Object();

{

_VERBOSE("Image::apply_scaling");

args.verify_length(2);

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

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

//printf("applying scaling %1.2f, %1.2f\n", sx, sy);

agg::trans_affine M = agg::trans_affine_scaling(sx, sy);

srcMatrix *= M;

imageMatrix *= M;

return Py::Object();

{

_VERBOSE("Image::apply_translation");

args.verify_length(2);

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

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

//printf("applying translation %1.2f, %1.2f\n", tx, ty);

agg::trans_affine M = agg::trans_affine_translation(tx, ty);

srcMatrix *= M;

imageMatrix *= M;

return Py::Object();

{

_VERBOSE("Image::as_rgba_str");

args.verify_length(0);

std::pair<agg::int8u*, bool> bufpair = _get_output_buffer();

#if PY3K

Py::Object ret = Py::asObject(Py_BuildValue("lly#", rowsOut, colsOut,

bufpair.first, colsOut * rowsOut * 4));

#else

Py::Object ret = Py::asObject(Py_BuildValue("lls#", rowsOut, colsOut,

bufpair.first, colsOut * rowsOut * 4));

#endif

if (bufpair.second) delete [] bufpair.first;

return ret;

{

_VERBOSE("Image::color_conv");

args.verify_length(1);

int format = Py::Int(args[0]);

PyObject* py_buffer = NULL;

int row_len = colsOut * 4;

#if PY3K

unsigned char* buf = (unsigned char *)malloc(row_len * rowsOut);

if (buf == NULL)

throw Py::MemoryError("Image::color_conv could not allocate memory");

#else

py_buffer = PyBuffer_New(row_len * rowsOut);

if (py_buffer == NULL)

throw Py::MemoryError("Image::color_conv could not allocate memory");

void* buf;

Py_ssize_t buffer_len;

int ret = PyObject_AsWriteBuffer(py_buffer, &buf, &buffer_len);

if (ret != 0)

{

Py_XDECREF(py_buffer);

throw Py::MemoryError("Image::color_conv could not allocate memory");

}

#endif

agg::rendering_buffer rtmp;

rtmp.attach(reinterpret_cast<unsigned char*>(buf), colsOut, rowsOut,

row_len);

switch (format)

{

case 0:

agg::color_conv(&rtmp, rbufOut, agg::color_conv_rgba32_to_bgra32());

break;

case 1:

agg::color_conv(&rtmp, rbufOut, agg::color_conv_rgba32_to_argb32());

break;

default:

Py_XDECREF(py_buffer);

throw Py::ValueError("Image::color_conv unknown format");

}

#if PY3K

py_buffer = PyByteArray_FromStringAndSize((char *)buf, row_len * rowsOut);

if (py_buffer == NULL) {

free(buf);

}

#endif

PyObject* o = Py_BuildValue("llN", rowsOut, colsOut, py_buffer);

return Py::asObject(o);

{

//"Return the image object as rgba";

_VERBOSE("RendererAgg::buffer_rgba");

args.verify_length(0);

int row_len = colsOut * 4;

PyObject* o = Py_BuildValue("lls#", rowsOut, colsOut,

rbufOut, row_len * rowsOut);

return Py::asObject(o);

{

_VERBOSE("Image::reset_matrix");

args.verify_length(0);

srcMatrix.reset();

imageMatrix.reset();

return Py::Object();

{

_VERBOSE("Image::get_matrix");

args.verify_length(0);

double m[6];

srcMatrix.store_to(m);

Py::Tuple ret(6);

for (int i = 0;i < 6;i++)

{

ret[i] = Py::Float(m[i]);

}

return ret;

{

_VERBOSE("Image::resize");

args.verify_length(2);

int norm = 1;

if (kwargs.hasKey("norm"))

{

norm = Py::Int(kwargs["norm"]);

}

double radius = 4.0;

if (kwargs.hasKey("radius"))

{

radius = Py::Float(kwargs["radius"]);

}

if (bufferIn == NULL)

{

throw Py::RuntimeError("You must first load the image");

}

int numcols = Py::Int(args[0]);

int numrows = Py::Int(args[1]);

colsOut = numcols;

rowsOut = numrows;

size_t NUMBYTES(numrows * numcols * BPP);

delete [] bufferOut;

bufferOut = new agg::int8u[NUMBYTES];

if (bufferOut == NULL) //todo: also handle allocation throw

{

throw Py::MemoryError("Image::resize could not allocate memory");

}

delete rbufOut;

rbufOut = new agg::rendering_buffer;

rbufOut->attach(bufferOut, numcols, numrows, numcols * BPP);

// init the output rendering/rasterizing stuff

pixfmt pixf(*rbufOut);

renderer_base rb(pixf);

rb.clear(bg);

rasterizer ras;

agg::scanline_u8 sl;

ras.clip_box(0, 0, numcols, numrows);

//srcMatrix *= resizingMatrix;

//imageMatrix *= resizingMatrix;

imageMatrix.invert();

interpolator_type interpolator(imageMatrix);

typedef agg::span_allocator<agg::rgba8> span_alloc_type;

span_alloc_type sa;

agg::rgba8 background(agg::rgba8(int(255*bg.r),

int(255*bg.g),

int(255*bg.b),

int(255*bg.a)));

// the image path

agg::path_storage path;

agg::rendering_buffer rbufPad;

double x0, y0, x1, y1;

x0 = 0.0;

x1 = colsIn;

y0 = 0.0;

y1 = rowsIn;

path.move_to(x0, y0);

path.line_to(x1, y0);

path.line_to(x1, y1);

path.line_to(x0, y1);

path.close_polygon();

agg::conv_transform<agg::path_storage> imageBox(path, srcMatrix);

ras.add_path(imageBox);

typedef agg::wrap_mode_reflect reflect_type;

typedef agg::image_accessor_wrap<pixfmt, reflect_type, reflect_type> img_accessor_type;

pixfmt pixfmtin(*rbufIn);

img_accessor_type ia(pixfmtin);

switch (interpolation)

{

case NEAREST:

{

typedef agg::span_image_filter_rgba_nn<img_accessor_type, interpolator_type> span_gen_type;

typedef agg::renderer_scanline_aa<renderer_base, span_alloc_type, span_gen_type> renderer_type;

span_gen_type sg(ia, interpolator);

renderer_type ri(rb, sa, sg);

agg::render_scanlines(ras, sl, ri);

}

break;

case HANNING:

case HAMMING:

case HERMITE:

{

agg::image_filter_lut filter;

switch (interpolation)

{

case HANNING:

filter.calculate(agg::image_filter_hanning(), norm);

break;

case HAMMING:

filter.calculate(agg::image_filter_hamming(), norm);

break;

case HERMITE:

filter.calculate(agg::image_filter_hermite(), norm);

break;

}

if (resample)

{

typedef agg::span_image_resample_rgba_affine<img_accessor_type> span_gen_type;

typedef agg::renderer_scanline_aa<renderer_base, span_alloc_type, span_gen_type> renderer_type;

span_gen_type sg(ia, interpolator, filter);

renderer_type ri(rb, sa, sg);

agg::render_scanlines(ras, sl, ri);

}

else

{

typedef agg::span_image_filter_rgba_2x2<img_accessor_type, interpolator_type> span_gen_type;

typedef agg::renderer_scanline_aa<renderer_base, span_alloc_type, span_gen_type> renderer_type;

span_gen_type sg(ia, interpolator, filter);

renderer_type ri(rb, sa, sg);

agg::render_scanlines(ras, sl, ri);

}

}

break;

case BILINEAR:

case BICUBIC:

case SPLINE16:

case SPLINE36:

case KAISER:

case QUADRIC:

case CATROM:

case GAUSSIAN:

case BESSEL:

case MITCHELL:

case SINC:

case LANCZOS:

case BLACKMAN:

{

agg::image_filter_lut filter;

switch (interpolation)

{

case BILINEAR:

filter.calculate(agg::image_filter_bilinear(), norm);

break;

case BICUBIC:

filter.calculate(agg::image_filter_bicubic(), norm);

break;

case SPLINE16:

filter.calculate(agg::image_filter_spline16(), norm);

break;

case SPLINE36:

filter.calculate(agg::image_filter_spline36(), norm);

break;

case KAISER:

filter.calculate(agg::image_filter_kaiser(), norm);

break;

case QUADRIC:

filter.calculate(agg::image_filter_quadric(), norm);

break;

case CATROM:

filter.calculate(agg::image_filter_catrom(), norm);

break;

case GAUSSIAN:

filter.calculate(agg::image_filter_gaussian(), norm);

break;

case BESSEL:

filter.calculate(agg::image_filter_bessel(), norm);

break;

case MITCHELL:

filter.calculate(agg::image_filter_mitchell(), norm);

break;

case SINC:

filter.calculate(agg::image_filter_sinc(radius), norm);

break;

case LANCZOS:

filter.calculate(agg::image_filter_lanczos(radius), norm);

break;

case BLACKMAN:

filter.calculate(agg::image_filter_blackman(radius), norm);

break;

}

if (resample)

{

typedef agg::span_image_resample_rgba_affine<img_accessor_type> span_gen_type;

typedef agg::renderer_scanline_aa<renderer_base, span_alloc_type, span_gen_type> renderer_type;

span_gen_type sg(ia, interpolator, filter);

renderer_type ri(rb, sa, sg);

agg::render_scanlines(ras, sl, ri);

}

else

{

typedef agg::span_image_filter_rgba<img_accessor_type, interpolator_type> span_gen_type;

typedef agg::renderer_scanline_aa<renderer_base, span_alloc_type, span_gen_type> renderer_type;

span_gen_type sg(ia, interpolator, filter);

renderer_type ri(rb, sa, sg);

agg::render_scanlines(ras, sl, ri);

}

}

break;

}

return Py::Object();

{

_VERBOSE("Image::get_interpolation");

args.verify_length(0);

return Py::Int((int)interpolation);

{

_VERBOSE("Image::get_aspect");

args.verify_length(0);

return Py::Int((int)aspect);

{

_VERBOSE("Image::get_size");

args.verify_length(0);

Py::Tuple ret(2);

ret[0] = Py::Int((long)rowsIn);

ret[1] = Py::Int((long)colsIn);

return ret;

{

_VERBOSE("Image::get_resample");

args.verify_length(0);

return Py::Int((int)resample);

{

_VERBOSE("Image::get_size_out");

args.verify_length(0);

Py::Tuple ret(2);

ret[0] = Py::Int((long)rowsOut);

ret[1] = Py::Int((long)colsOut);

return ret;

{

_VERBOSE("Image::_get_output_buffer");

std::pair<agg::int8u*, bool> ret;

bool flipy = rbufOut->stride() < 0;

if (flipy)

{

agg::int8u* buffer = new agg::int8u[rowsOut*colsOut*4];

agg::rendering_buffer rb;

rb.attach(buffer, colsOut, rowsOut, colsOut*4);

rb.copy_from(*rbufOut);

ret.first = buffer;

ret.second = true;

}

else

{

ret.first = bufferOut;

ret.second = false;

}

return ret;

{

_VERBOSE("Image::set_interpolation");

args.verify_length(1);

size_t method = (long)Py::Int(args[0]);

interpolation = (unsigned)method;

return Py::Object();

{

_VERBOSE("Image::set_resample");

args.verify_length(1);

int flag = Py::Int(args[0]);

resample = (bool)flag;

return Py::Object();

{

_VERBOSE("Image::set_aspect");

args.verify_length(1);

size_t method = (long)Py::Int(args[0]);

aspect = (unsigned)method;

return Py::Object();

{

_VERBOSE("Image::init_type");

behaviors().name("Image");

behaviors().doc("Image");

behaviors().supportGetattr();

behaviors().supportSetattr();

add_varargs_method("apply_rotation", &Image::apply_rotation, Image::apply_rotation__doc__);

add_varargs_method("apply_scaling", &Image::apply_scaling, Image::apply_scaling__doc__);

add_varargs_method("apply_translation", &Image::apply_translation, Image::apply_translation__doc__);

add_keyword_method("as_rgba_str", &Image::as_rgba_str, Image::as_rgba_str__doc__);

add_varargs_method("color_conv", &Image::color_conv, Image::color_conv__doc__);

add_varargs_method("buffer_rgba", &Image::buffer_rgba, Image::buffer_rgba__doc__);

add_varargs_method("get_aspect", &Image::get_aspect, Image::get_aspect__doc__);

add_varargs_method("get_interpolation", &Image::get_interpolation, Image::get_interpolation__doc__);

add_varargs_method("get_resample", &Image::get_resample, Image::get_resample__doc__);

add_varargs_method("get_size", &Image::get_size, Image::get_size__doc__);

add_varargs_method("get_size_out", &Image::get_size_out, Image::get_size_out__doc__);

add_varargs_method("reset_matrix", &Image::reset_matrix, Image::reset_matrix__doc__);

add_varargs_method("get_matrix", &Image::get_matrix, Image::get_matrix__doc__);

add_keyword_method("resize", &Image::resize, Image::resize__doc__);

add_varargs_method("set_interpolation", &Image::set_interpolation, Image::set_interpolation__doc__);

add_varargs_method("set_resample", &Image::set_resample, Image::set_resample__doc__);

add_varargs_method("set_aspect", &Image::set_aspect, Image::set_aspect__doc__);

add_varargs_method("set_bg", &Image::set_bg, Image::set_bg__doc__);

add_varargs_method("flipud_out", &Image::flipud_out, Image::flipud_out__doc__);

add_varargs_method("flipud_in", &Image::flipud_in, Image::flipud_in__doc__);

{

_VERBOSE("_image_module::from_images");

args.verify_length(3);

size_t numrows = (long)Py::Int(args[0]);

size_t numcols = (long)Py::Int(args[1]);

if (numrows >= 32768 || numcols >= 32768)

{

throw Py::RuntimeError("numrows and numcols must both be less than 32768");

}

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

size_t N = tups.length();

if (N == 0)

{

throw Py::RuntimeError("Empty list of images");

}

Py::Tuple tup;

size_t ox(0), oy(0), thisx(0), thisy(0);

//copy image 0 output buffer into return images output buffer

Image* imo = new Image;

imo->rowsOut = numrows;

imo->colsOut = numcols;

size_t NUMBYTES(numrows * numcols * imo->BPP);

imo->bufferOut = new agg::int8u[NUMBYTES];

if (imo->bufferOut == NULL) //todo: also handle allocation throw

{

throw Py::MemoryError("_image_module::from_images could not allocate memory");

}

delete imo->rbufOut;

imo->rbufOut = new agg::rendering_buffer;

imo->rbufOut->attach(imo->bufferOut, imo->colsOut, imo->rowsOut, imo->colsOut * imo->BPP);

pixfmt pixf(*imo->rbufOut);

renderer_base rb(pixf);

rb.clear(agg::rgba(1, 1, 1, 1));

for (size_t imnum = 0; imnum < N; imnum++)

{

tup = Py::Tuple(tups[imnum]);

Image* thisim = static_cast<Image*>(tup[0].ptr());

ox = (long)Py::Int(tup[1]);

oy = (long)Py::Int(tup[2]);

bool isflip = (thisim->rbufOut->stride()) < 0;

//std::cout << "from images " << isflip << "; stride=" << thisim->rbufOut->stride() << std::endl;

size_t ind = 0;

for (size_t j = 0; j < thisim->rowsOut; j++)

{

for (size_t i = 0; i < thisim->colsOut; i++)

{

thisx = i + ox;

if (isflip)

{

thisy = thisim->rowsOut - j + oy;

}

else

{

thisy = j + oy;

}

if (thisx >= numcols || thisy >= numrows)

{

ind += 4;

continue;

}

pixfmt::color_type p;

p.r = *(thisim->bufferOut + ind++);

p.g = *(thisim->bufferOut + ind++);

p.b = *(thisim->bufferOut + ind++);

p.a = *(thisim->bufferOut + ind++);

pixf.blend_pixel(thisx, thisy, p, 255);

}

}

}

return Py::asObject(imo);

{

_VERBOSE("_image_module::fromarray");

args.verify_length(2);

Py::Object x = args[0];

int isoutput = Py::Int(args[1]);

PyArrayObject *A = (PyArrayObject *) PyArray_FromObject(x.ptr(), PyArray_DOUBLE, 2, 3);

if (A == NULL)

{

throw Py::ValueError("Array must be rank 2 or 3 of doubles");

}

Py::Object A_obj((PyObject *)A, true);

Image* imo = new Image;

imo->rowsIn = A->dimensions[0];

imo->colsIn = A->dimensions[1];

size_t NUMBYTES(imo->colsIn * imo->rowsIn * imo->BPP);

agg::int8u *buffer = new agg::int8u[NUMBYTES];

if (buffer == NULL) //todo: also handle allocation throw

{

throw Py::MemoryError("_image_module::fromarray could not allocate memory");

}

if (isoutput)

{

// make the output buffer point to the input buffer

imo->rowsOut = imo->rowsIn;

imo->colsOut = imo->colsIn;

imo->rbufOut = new agg::rendering_buffer;

imo->bufferOut = buffer;

imo->rbufOut->attach(imo->bufferOut, imo->colsOut, imo->rowsOut, imo->colsOut * imo->BPP);

}

else

{

imo->bufferIn = buffer;

imo->rbufIn = new agg::rendering_buffer;

imo->rbufIn->attach(buffer, imo->colsIn, imo->rowsIn, imo->colsIn*imo->BPP);

}

if (A->nd == 2) //assume luminance for now;

{

agg::int8u gray;

for (size_t rownum = 0; rownum < imo->rowsIn; rownum++)

{

for (size_t colnum = 0; colnum < imo->colsIn; colnum++)

{

double val = *(double *)(A->data + rownum * A->strides[0] + colnum * A->strides[1]);

gray = int(255 * val);

*buffer++ = gray; // red

*buffer++ = gray; // green

*buffer++ = gray; // blue

*buffer++ = 255; // alpha

}

}

}

else if (A->nd == 3) // assume RGB

{

if (A->dimensions[2] != 3 && A->dimensions[2] != 4)

{

throw Py::ValueError(Printf("3rd dimension must be length 3 (RGB) or 4 (RGBA); found %d", A->dimensions[2]).str());

}

int rgba = A->dimensions[2] == 4;

double r, g, b, alpha;

size_t offset = 0;

for (size_t rownum = 0; rownum < imo->rowsIn; rownum++)

{

for (size_t colnum = 0; colnum < imo->colsIn; colnum++)

{

offset = rownum * A->strides[0] + colnum * A->strides[1];

r = *(double *)(A->data + offset);

g = *(double *)(A->data + offset + A->strides[2]);

b = *(double *)(A->data + offset + 2 * A->strides[2]);

if (rgba)

{

alpha = *(double *)(A->data + offset + 3 * A->strides[2]);

}

else

{

alpha = 1.0;

}

*buffer++ = int(255 * r); // red

*buffer++ = int(255 * g); // green

*buffer++ = int(255 * b); // blue

*buffer++ = int(255 * alpha); // alpha

}

}

}

else // error

{

throw Py::ValueError("Illegal array rank; must be rank; must 2 or 3");

}

buffer -= NUMBYTES;

return Py::asObject(imo);

{

_VERBOSE("_image_module::fromarray2");

args.verify_length(2);

Py::Object x = args[0];

int isoutput = Py::Int(args[1]);

PyArrayObject *A = (PyArrayObject *) PyArray_ContiguousFromObject(x.ptr(), PyArray_DOUBLE, 2, 3);