GitHub Viewer
/* -*- mode: c++; c-basic-offset: 4 -*- */
#define NO_IMPORT_ARRAY
#include
#include "agg_color_rgba.h"
#include "agg_conv_transform.h"
#include "agg_image_accessors.h"
#include "agg_path_storage.h"
#include "agg_pixfmt_rgb.h"
#include "agg_pixfmt_rgba.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_rasterizer_sl_clip.h"
#include "agg_renderer_scanline.h"
#include "agg_rendering_buffer.h"
#include "agg_scanline_bin.h"
#include "agg_scanline_bin.h"
#include "agg_scanline_u.h"
#include "agg_span_allocator.h"
#include "agg_span_image_filter_rgb.h"
#include "agg_span_image_filter_rgba.h"
#include "agg_span_interpolator_linear.h"
#include "util/agg_color_conv_rgb8.h"
#include "_image.h"
#include "mplutils.h"
#include "agg_workaround.h"
typedef fixed_blender_rgba_plain fixed_blender_rgba32_plain;
typedef agg::pixfmt_alpha_blend_rgba pixfmt;
typedef fixed_blender_rgba_pre fixed_blender_rgba32_pre;
typedef agg::pixfmt_alpha_blend_rgba pixfmt_pre;
typedef agg::renderer_base renderer_base;
typedef agg::span_interpolator_linear interpolator_type;
typedef agg::rasterizer_scanline_aa rasterizer;
Image::Image()
: 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)
{
}
Image::Image(unsigned numrows, unsigned numcols, bool isoutput)
: 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)
{
if (isoutput) {
rowsOut = numrows;
colsOut = numcols;
unsigned NUMBYTES(numrows * numcols * BPP);
bufferOut = new agg::int8u[NUMBYTES];
rbufOut = new agg::rendering_buffer;
rbufOut->attach(bufferOut, colsOut, rowsOut, colsOut * BPP);
} else {
rowsIn = numrows;
colsIn = numcols;
unsigned NUMBYTES(numrows * numcols * BPP);
bufferIn = new agg::int8u[NUMBYTES];
rbufIn = new agg::rendering_buffer;
rbufIn->attach(bufferIn, colsIn, rowsIn, colsIn * BPP);
}
}
Image::~Image()
{
delete[] bufferIn;
bufferIn = NULL;
delete rbufIn;
rbufIn = NULL;
delete rbufOut;
rbufOut = NULL;
delete[] bufferOut;
bufferOut = NULL;
}
void Image::apply_rotation(double r)
{
agg::trans_affine M = agg::trans_affine_rotation(r * agg::pi / 180.0);
srcMatrix *= M;
imageMatrix *= M;
}
void Image::set_bg(double r, double g, double b, double a)
{
bg.r = r;
bg.g = g;
bg.b = b;
bg.a = a;
}
void Image::apply_scaling(double sx, double sy)
{
agg::trans_affine M = agg::trans_affine_scaling(sx, sy);
srcMatrix *= M;
imageMatrix *= M;
}
void Image::apply_translation(double tx, double ty)
{
agg::trans_affine M = agg::trans_affine_translation(tx, ty);
srcMatrix *= M;
imageMatrix *= M;
}
void Image::as_rgba_str(agg::int8u *outbuf)
{
agg::rendering_buffer rb;
rb.attach(outbuf, colsOut, rowsOut, colsOut * 4);
rb.copy_from(*rbufOut);
}
void Image::color_conv(int format, agg::int8u *outbuf)
{
int row_len = colsOut * 4;
agg::rendering_buffer rtmp;
rtmp.attach(outbuf, 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:
throw "Image::color_conv unknown format";
}
}
void Image::reset_matrix(void)
{
srcMatrix.reset();
imageMatrix.reset();
}
void Image::resize(int numcols, int numrows, int norm, double radius)
{
if (bufferIn == NULL) {
throw "You must first load the image";
}
if (numcols stride()) < 0;
size_t ind = 0;
for (unsigned j = 0; j < im.rowsOut; j++) {
if (isflip) {
thisy = im.rowsOut - j + oy;
} else {
thisy = j + oy;
}
for (unsigned i = 0; i < im.colsOut; i++) {
thisx = i + ox;
if (thisx >= colsOut || thisy >= rowsOut) {
ind += 4;
continue;
}
pixfmt::color_type p;
p.r = *(im.bufferOut + ind++);
p.g = *(im.bufferOut + ind++);
p.b = *(im.bufferOut + ind++);
if (apply_alpha) {
p.a = (pixfmt::value_type) * (im.bufferOut + ind++) * alpha;
} else {
p.a = *(im.bufferOut + ind++);
}
pixf.blend_pixel(thisx, thisy, p, 255);
}
}
}
// utilities for irregular grids
void _bin_indices_middle(
unsigned int *irows, int nrows, const float *ys1, unsigned long ny, float dy, float y_min)
{
int i, j, j_last;
unsigned int *rowstart = irows;
const float *ys2 = ys1 + 1;
const float *yl = ys1 + ny;
float yo = y_min + dy / 2.0;
float ym = 0.5f * (*ys1 + *ys2);
// y/rows
j = 0;
j_last = j;
for (i = 0; i < nrows; i++, yo += dy, rowstart++) {
while (ys2 != yl && yo > ym) {
ys1 = ys2;
ys2 = ys1 + 1;
ym = 0.5f * (*ys1 + *ys2);
j++;
}
*rowstart = j - j_last;
j_last = j;
}
}
void _bin_indices_middle_linear(float *arows,
unsigned int *irows,
int nrows,
const float *y,
unsigned long ny,
float dy,
float y_min)
{
int i;
int ii = 0;
int iilast = (int)ny - 1;
float sc = 1 / dy;
int iy0 = (int)floor(sc * (y[ii] - y_min));
int iy1 = (int)floor(sc * (y[ii + 1] - y_min));
float invgap = 1.0f / (iy1 - iy0);
for (i = 0; i < nrows && i iy1 && ii < iilast) {
ii++;
iy0 = iy1;
iy1 = (int)floor(sc * (y[ii + 1] - y_min));
invgap = 1.0f / (iy1 - iy0);
}
if (i >= iy0 && i 0) {
int ii = 0;
int iilast = (int)ny - 1;
int iy0 = (int)floor(sc * (y[ii] - offs));
int iy1 = (int)floor(sc * (y[ii + 1] - offs));
for (i = 0; i < nrows && i < iy0; i++) {
irows[i] = -1;
}
for (; i < nrows; i++) {
while (i > iy1 && ii < iilast) {
ii++;
iy0 = iy1;
iy1 = (int)floor(sc * (y[ii + 1] - offs));
}
if (i >= iy0 && i iy1 && ii > 1) {
ii--;
iy0 = iy1;
iy1 = (int)floor(sc * (y[ii - 1] - offs));
}
if (i >= iy0 && i 0) {
int ii = 0;
int iilast = (int)ny - 1;
int iy0 = (int)floor(sc * (y[ii] - offs));
int iy1 = (int)floor(sc * (y[ii + 1] - offs));
float invgap = 1.0 / (iy1 - iy0);
for (i = 0; i < nrows && i < iy0; i++) {
irows[i] = -1;
}
for (; i < nrows; i++) {
while (i > iy1 && ii < iilast) {
ii++;
iy0 = iy1;
iy1 = (int)floor(sc * (y[ii + 1] - offs));
invgap = 1.0 / (iy1 - iy0);
}
if (i >= iy0 && i iy1 && ii > 1) {
ii--;
iy0 = iy1;
iy1 = (int)floor(sc * (y[ii - 1] - offs));
invgap = 1.0 / (iy1 - iy0);
}
if (i >= iy0 && i