{

public:

BufferRegion(const agg::rect_i &r) : rect(r)

{

width = r.x2 - r.x1;

height = r.y2 - r.y1;

stride = width * 4;

data = new agg::int8u[stride * height];

}

virtual ~BufferRegion()

{

delete[] data;

};

// prevent copying

BufferRegion(const BufferRegion &) = delete;

BufferRegion &operator=(const BufferRegion &) = delete;

agg::int8u *get_data()

{

return data;

}

agg::rect_i &get_rect()

{

return rect;

}

int get_width()

{

return width;

}

int get_height()

{

return height;

}

int get_stride()

{

return stride;

}

private:

agg::int8u *data;

agg::rect_i rect;

int width;

int height;

int stride;

{

public:

typedef fixed_blender_rgba_plain<agg::rgba8, agg::order_rgba> fixed_blender_rgba32_plain;

typedef agg::pixfmt_alpha_blend_rgba<fixed_blender_rgba32_plain, agg::rendering_buffer> pixfmt;

typedef agg::renderer_base<pixfmt> renderer_base;

typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_aa;

typedef agg::renderer_scanline_bin_solid<renderer_base> renderer_bin;

typedef agg::rasterizer_scanline_aa<agg::rasterizer_sl_clip_dbl> rasterizer;

typedef agg::scanline32_p8 scanline_p8;

typedef agg::scanline32_bin scanline_bin;

typedef agg::amask_no_clip_gray8 alpha_mask_type;

typedef agg::scanline32_u8_am<alpha_mask_type> scanline_am;

typedef agg::renderer_base<agg::pixfmt_gray8> renderer_base_alpha_mask_type;

typedef agg::renderer_scanline_aa_solid<renderer_base_alpha_mask_type> renderer_alpha_mask_type;

RendererAgg(unsigned int width, unsigned int height, double dpi);

virtual ~RendererAgg();

unsigned int get_width()

{

return width;

}

unsigned int get_height()

{

return height;

}

template <class PathIterator>

void draw_path(GCAgg &gc, PathIterator &path, agg::trans_affine &trans, agg::rgba &color);

template <class PathIterator>

void draw_markers(GCAgg &gc,

PathIterator &marker_path,

agg::trans_affine &marker_path_trans,

PathIterator &path,

agg::trans_affine &trans,

agg::rgba face);

template <class ImageArray>

void draw_text_image(GCAgg &gc, ImageArray &image, int x, int y, double angle);

template <class ImageArray>

void draw_image(GCAgg &gc,

double x,

double y,

ImageArray &image);

template <class PathGenerator,

class TransformArray,

class OffsetArray,

class ColorArray,

class LineWidthArray,

class AntialiasedArray>

void draw_path_collection(GCAgg &gc,

agg::trans_affine &master_transform,

PathGenerator &path,

TransformArray &transforms,

OffsetArray &offsets,

agg::trans_affine &offset_trans,

ColorArray &facecolors,

ColorArray &edgecolors,

LineWidthArray &linewidths,

DashesVector &linestyles,

AntialiasedArray &antialiaseds,

ColorArray &hatchcolors);

template <class CoordinateArray, class OffsetArray, class ColorArray>

void draw_quad_mesh(GCAgg &gc,

agg::trans_affine &master_transform,

unsigned int mesh_width,

unsigned int mesh_height,

CoordinateArray &coordinates,

OffsetArray &offsets,

agg::trans_affine &offset_trans,

ColorArray &facecolors,

bool antialiased,

ColorArray &edgecolors);

template <class PointArray, class ColorArray>

void draw_gouraud_triangles(GCAgg &gc,

PointArray &points,

ColorArray &colors,

agg::trans_affine &trans);

agg::rect_i get_content_extents();

void clear();

BufferRegion *copy_from_bbox(agg::rect_d in_rect);

void restore_region(BufferRegion &reg);

void restore_region(BufferRegion &region, int xx1, int yy1, int xx2, int yy2, int x, int y);

unsigned int width, height;

double dpi;

size_t NUMBYTES; // the number of bytes in buffer

agg::int8u *pixBuffer;

agg::rendering_buffer renderingBuffer;

agg::int8u *alphaBuffer;

agg::rendering_buffer alphaMaskRenderingBuffer;

alpha_mask_type alphaMask;

agg::pixfmt_gray8 pixfmtAlphaMask;

renderer_base_alpha_mask_type rendererBaseAlphaMask;

renderer_alpha_mask_type rendererAlphaMask;

scanline_am scanlineAlphaMask;

scanline_p8 slineP8;

scanline_bin slineBin;

pixfmt pixFmt;

renderer_base rendererBase;

renderer_aa rendererAA;

renderer_bin rendererBin;

rasterizer theRasterizer;

void *lastclippath;

agg::trans_affine lastclippath_transform;

size_t hatch_size;

agg::int8u *hatchBuffer;

agg::rendering_buffer hatchRenderingBuffer;

agg::rgba _fill_color;

protected:

inline double points_to_pixels(double points)

{

return points * dpi / 72.0;

}

template <class R>

void set_clipbox(const agg::rect_d &cliprect, R &rasterizer);

bool render_clippath(mpl::PathIterator &clippath, const agg::trans_affine &clippath_trans, e_snap_mode snap_mode);

template <class PathIteratorType>

void _draw_path(PathIteratorType &path, bool has_clippath, const std::optional<agg::rgba> &face, GCAgg &gc);

template <class PathIterator,

class PathGenerator,

class TransformArray,

class OffsetArray,

class ColorArray,

class LineWidthArray,

class AntialiasedArray>

void _draw_path_collection_generic(GCAgg &gc,

agg::trans_affine master_transform,

const agg::rect_d &cliprect,

PathIterator &clippath,

const agg::trans_affine &clippath_trans,

PathGenerator &path_generator,

TransformArray &transforms,

OffsetArray &offsets,

const agg::trans_affine &offset_trans,

ColorArray &facecolors,

ColorArray &edgecolors,

LineWidthArray &linewidths,

DashesVector &linestyles,

AntialiasedArray &antialiaseds,

bool check_snap,

bool has_codes,

ColorArray &hatchcolors);

template <class PointArray, class ColorArray>

void _draw_gouraud_triangle(PointArray &points,

ColorArray &colors,

agg::trans_affine trans,

bool has_clippath);

private:

void create_alpha_buffers();

// prevent copying

RendererAgg(const RendererAgg &);

RendererAgg &operator=(const RendererAgg &);

{

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) {

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);

agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);

} else {

rendererAA.color(*face);

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);

agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);

} else {

rendererBin.color(*face);

agg::render_scanlines(theRasterizer, slineP8, rendererBin);

}

}

}

// Render hatch

if (gc.has_hatchpath()) {

// 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<mpl::PathIterator> hatch_path_trans_t;

typedef agg::conv_curve<hatch_path_trans_t> hatch_path_curve_t;

typedef agg::conv_stroke<hatch_path_curve_t> hatch_path_stroke_t;

mpl::PathIterator hatch_path(gc.hatchpath);

agg::trans_affine hatch_trans;

hatch_trans *= agg::trans_affine_scaling(1.0, -1.0);

hatch_trans *= agg::trans_affine_translation(0.0, 1.0);

hatch_trans *= agg::trans_affine_scaling(static_cast<double>(hatch_size),

static_cast<double>(hatch_size));

hatch_path_trans_t hatch_path_trans(hatch_path, hatch_trans);

hatch_path_curve_t hatch_path_curve(hatch_path_trans);

hatch_path_stroke_t hatch_path_stroke(hatch_path_curve);

hatch_path_stroke.width(points_to_pixels(gc.hatch_linewidth));

hatch_path_stroke.line_cap(agg::square_cap);

// Render the path into the hatch buffer

pixfmt hatch_img_pixf(hatchRenderingBuffer);

renderer_base rb(hatch_img_pixf);

renderer_aa rs(rb);

rb.clear(_fill_color);

rs.color(gc.hatch_color);

theRasterizer.add_path(hatch_path_curve);

agg::render_scanlines(theRasterizer, slineP8, rs);

theRasterizer.add_path(hatch_path_stroke);

agg::render_scanlines(theRasterizer, slineP8, rs);

// Put clipping back on, if originally set on entry to this

// function

set_clipbox(gc.cliprect, theRasterizer);

if (has_clippath) {

render_clippath(gc.clippath.path, gc.clippath.trans, gc.snap_mode);

}

// Transfer the hatch to the main image buffer

typedef agg::image_accessor_wrap<pixfmt,

agg::wrap_mode_repeat_auto_pow2,

agg::wrap_mode_repeat_auto_pow2> img_source_type;

typedef agg::span_pattern_rgba<img_source_type> span_gen_type;

agg::span_allocator<agg::rgba8> sa;

img_source_type img_src(hatch_img_pixf);

span_gen_type sg(img_src, 0, 0);

theRasterizer.add_path(path);

if (has_clippath) {

pixfmt_amask_type pfa(pixFmt, alphaMask);

amask_ren_type ren(pfa);

agg::render_scanlines_aa(theRasterizer, slineP8, ren, sa, sg);

} else {

agg::render_scanlines_aa(theRasterizer, slineP8, rendererBase, sa, sg);

}

}

// Render stroke

if (gc.linewidth != 0.0) {

double linewidth = points_to_pixels(gc.linewidth);

if (!gc.isaa) {

linewidth = (linewidth < 0.5) ? 0.5 : mpl_round(linewidth);

}

if (gc.dashes.size() == 0) {

stroke_t stroke(path);

stroke.width(points_to_pixels(gc.linewidth));

stroke.line_cap(gc.cap);

stroke.line_join(gc.join);

stroke.miter_limit(points_to_pixels(gc.linewidth));

theRasterizer.add_path(stroke);

} else {

dash_t dash(path);

gc.dashes.dash_to_stroke(dash, dpi, gc.isaa);

stroke_dash_t stroke(dash);

stroke.line_cap(gc.cap);

stroke.line_join(gc.join);

stroke.width(linewidth);

stroke.miter_limit(points_to_pixels(gc.linewidth));

theRasterizer.add_path(stroke);

}

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(gc.color);

agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);

} else {

rendererAA.color(gc.color);

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(gc.color);

agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);

} else {

rendererBin.color(gc.color);

agg::render_scanlines(theRasterizer, slineBin, rendererBin);

}

}

}

{

typedef agg::conv_transform<mpl::PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> nan_removed_t;

typedef PathClipper<nan_removed_t> clipped_t;

typedef PathSnapper<clipped_t> snapped_t;

typedef PathSimplifier<snapped_t> simplify_t;

typedef agg::conv_curve<simplify_t> curve_t;

typedef Sketch<curve_t> sketch_t;

std::optional<agg::rgba> face;

if (color.a != 0.0) {

face = color;

}

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

set_clipbox(gc.cliprect, theRasterizer);

bool has_clippath = render_clippath(gc.clippath.path, gc.clippath.trans, gc.snap_mode);

trans *= agg::trans_affine_scaling(1.0, -1.0);

trans *= agg::trans_affine_translation(0.0, (double)height);

bool clip = !face && !gc.has_hatchpath();

bool simplify = path.should_simplify() && clip;

double snapping_linewidth = points_to_pixels(gc.linewidth);

if (gc.color.a == 0.0) {

snapping_linewidth = 0.0;

}

transformed_path_t tpath(path, trans);

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

clipped_t clipped(nan_removed, clip, width, height);

snapped_t snapped(clipped, gc.snap_mode, path.total_vertices(), snapping_linewidth);

simplify_t simplified(snapped, simplify, path.simplify_threshold());

curve_t curve(simplified);

sketch_t sketch(curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);

_draw_path(sketch, has_clippath, face, gc);

PathIterator &marker_path,

agg::trans_affine &marker_trans,

PathIterator &path,

agg::trans_affine &trans,

agg::rgba color)

{

typedef agg::conv_transform<mpl::PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> nan_removed_t;

typedef PathSnapper<nan_removed_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;

// 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.5, (double)height + 0.5);

transformed_path_t marker_path_transformed(marker_path, marker_trans);

nan_removed_t marker_path_nan_removed(marker_path_transformed, true, marker_path.has_codes());

snap_t marker_path_snapped(marker_path_nan_removed,

gc.snap_mode,

marker_path.total_vertices(),

points_to_pixels(gc.linewidth));

curve_t marker_path_curve(marker_path_snapped);

if (!marker_path_snapped.is_snapping()) {

// If the path snapper isn't in effect, at least make sure the marker

// at (0, 0) is in the center of a pixel. This, importantly, makes

// the circle markers look centered around the point they refer to.

marker_trans *= agg::trans_affine_translation(0.5, 0.5);

}

transformed_path_t path_transformed(path, trans);

nan_removed_t path_nan_removed(path_transformed, false, false);

snap_t path_snapped(path_nan_removed, SNAP_FALSE, path.total_vertices(), 0.0);

curve_t path_curve(path_snapped);

path_curve.rewind(0);

std::optional<agg::rgba> face;

if (color.a != 0.0) {

face = color;

}

// maxim's suggestions for cached scanlines

agg::scanline_storage_aa8 scanlines;

theRasterizer.reset();

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

agg::rect_i marker_size(0x7FFFFFFF, 0x7FFFFFFF, -0x7FFFFFFF, -0x7FFFFFFF);

try

{

std::vector<agg::int8u> fillBuffer;

if (face) {

theRasterizer.add_path(marker_path_curve);

agg::render_scanlines(theRasterizer, slineP8, scanlines);

fillBuffer.resize(scanlines.byte_size());

scanlines.serialize(fillBuffer.data());

marker_size = agg::rect_i(scanlines.min_x(),

scanlines.min_y(),

scanlines.max_x(),

scanlines.max_y());

}

stroke_t stroke(marker_path_curve);

stroke.width(points_to_pixels(gc.linewidth));

stroke.line_cap(gc.cap);

stroke.line_join(gc.join);

stroke.miter_limit(points_to_pixels(gc.linewidth));

theRasterizer.reset();

theRasterizer.add_path(stroke);

agg::render_scanlines(theRasterizer, slineP8, scanlines);

std::vector<agg::int8u> strokeBuffer(scanlines.byte_size());

scanlines.serialize(strokeBuffer.data());

marker_size = agg::rect_i(std::min(marker_size.x1, scanlines.min_x()),

std::min(marker_size.y1, scanlines.min_y()),

std::max(marker_size.x2, scanlines.max_x()),

std::max(marker_size.y2, scanlines.max_y()));

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

set_clipbox(gc.cliprect, rendererBase);

bool has_clippath = render_clippath(gc.clippath.path, gc.clippath.trans, gc.snap_mode);

double x, y;

agg::serialized_scanlines_adaptor_aa8 sa;

agg::serialized_scanlines_adaptor_aa8::embedded_scanline sl;

agg::rect_d clipping_rect(-1.0 - marker_size.x2,

-1.0 - marker_size.y2,

1.0 + width - marker_size.x1,

1.0 + height - marker_size.y1);

if (has_clippath) {

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

if (!(std::isfinite(x) && std::isfinite(y))) {

continue;

}

/* These values are correctly snapped above -- so we don't want

x = floor(x);

y = floor(y);

// 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);

if (face) {

ren.color(*face);

sa.init(fillBuffer.data(), fillBuffer.size(), x, y);

agg::render_scanlines(sa, sl, ren);

}

ren.color(gc.color);

sa.init(strokeBuffer.data(), strokeBuffer.size(), x, y);

agg::render_scanlines(sa, sl, ren);

}

} else {

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

if (!(std::isfinite(x) && std::isfinite(y))) {

continue;

}

/* These values are correctly snapped above -- so we don't want

x = floor(x);

y = floor(y);

// 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) {

rendererAA.color(*face);

sa.init(fillBuffer.data(), fillBuffer.size(), x, y);

agg::render_scanlines(sa, sl, rendererAA);

}

rendererAA.color(gc.color);

sa.init(strokeBuffer.data(), strokeBuffer.size(), x, y);

agg::render_scanlines(sa, sl, rendererAA);

}

}

}

catch (...)

{

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

throw;

}

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

{

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;

private:

child_type *_gen;

color_type _color;

span_alloc_type _allocator;

public:

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);

}

void prepare()

{

_gen->prepare();

}

{

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;

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

if (angle != 0.0) {

agg::rendering_buffer srcbuf(

image.mutable_data(0, 0), (unsigned)image.shape(1),

(unsigned)image.shape(0), (unsigned)image.shape(1));

agg::pixfmt_gray8 pixf_img(srcbuf);

set_clipbox(gc.cliprect, theRasterizer);

auto image_height = static_cast<double>(image.shape(0)),

image_width = static_cast<double>(image.shape(1));

agg::trans_affine mtx;

mtx *= agg::trans_affine_translation(0, -image_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(image_width, 0);

rect.line_to(image_width, image_height);

rect.line_to(0, image_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::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, agg::gray8(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);

} else {

agg::rect_i fig, text;

int deltay = y - image.shape(0);

fig.init(0, 0, width, height);

text.init(x, deltay, x + image.shape(1), y);

text.clip(fig);

if (gc.cliprect.x1 != 0.0 || gc.cliprect.y1 != 0.0 || gc.cliprect.x2 != 0.0 || gc.cliprect.y2 != 0.0) {

agg::rect_i clip;

clip.init(mpl_round_to_int(gc.cliprect.x1),

mpl_round_to_int(height - gc.cliprect.y2),

mpl_round_to_int(gc.cliprect.x2),

mpl_round_to_int(height - gc.cliprect.y1));

text.clip(clip);

}

if (text.x2 > text.x1) {

int deltax = text.x2 - text.x1;

int deltax2 = text.x1 - x;

for (int yi = text.y1; yi < text.y2; ++yi) {

pixFmt.blend_solid_hspan(text.x1, yi, deltax, gc.color,

&image(yi - deltay, deltax2));

}

}

}

{

public:

typedef agg::rgba8 color_type;

double m_alpha;

span_conv_alpha(double alpha) : m_alpha(alpha)

{

}

void prepare()

{

}

void generate(color_type *span, int x, int y, unsigned len) const

{

do {

span->a = (agg::int8u)((double)span->a * m_alpha);

++span;

} while (--len);

}

double x,

double y,

ImageArray &image)

{

double alpha = gc.alpha;

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

set_clipbox(gc.cliprect, theRasterizer);

bool has_clippath = render_clippath(gc.clippath.path, gc.clippath.trans, gc.snap_mode);

agg::rendering_buffer buffer;

buffer.attach(image.mutable_data(0, 0, 0),

(unsigned)image.shape(1), (unsigned)image.shape(0),

-(int)image.shape(1) * 4);

pixfmt pixf(buffer);

if (has_clippath) {

agg::trans_affine mtx;

agg::path_storage rect;

auto image_height = static_cast<double>(image.shape(0)),

image_width = static_cast<double>(image.shape(1));

mtx *= agg::trans_affine_translation((int)x, (int)(height - (y + image_height)));

rect.move_to(0, 0);

rect.line_to(image_width, 0);

rect.line_to(image_width, image_height);

rect.line_to(0, image_height);

rect.line_to(0, 0);

agg::conv_transform<agg::path_storage> rect2(rect, mtx);

agg::trans_affine inv_mtx(mtx);

inv_mtx.invert();

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

typedef agg::image_accessor_clip<pixfmt> 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;

typedef agg::span_converter<image_span_gen_type, span_conv_alpha> span_conv;

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);

span_conv_alpha conv_alpha(alpha);

span_conv spans(image_span_generator, conv_alpha);

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, span_conv>

renderer_type_alpha;

pixfmt_amask_type pfa(pixFmt, alphaMask);

amask_ren_type r(pfa);

renderer_type_alpha ri(r, sa, spans);

theRasterizer.add_path(rect2);

agg::render_scanlines(theRasterizer, scanlineAlphaMask, ri);

} else {

set_clipbox(gc.cliprect, rendererBase);

rendererBase.blend_from(

pixf, nullptr, (int)x, (int)(height - (y + image.shape(0))), (agg::int8u)(alpha * 255));

}

rendererBase.reset_clipping(true);

agg::trans_affine master_transform,

const agg::rect_d &cliprect,

PathIterator &clippath,

const agg::trans_affine &clippath_trans,

PathGenerator &path_generator,

TransformArray &transforms,

OffsetArray &offsets,

const agg::trans_affine &offset_trans,

ColorArray &facecolors,

ColorArray &edgecolors,

LineWidthArray &linewidths,

DashesVector &linestyles,

AntialiasedArray &antialiaseds,

bool check_snap,

bool has_codes,

ColorArray &hatchcolors)

{

typedef agg::conv_transform<typename PathGenerator::path_iterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> nan_removed_t;

typedef PathClipper<nan_removed_t> clipped_t;

typedef PathSnapper<clipped_t> snapped_t;

typedef agg::conv_curve<snapped_t> snapped_curve_t;

typedef agg::conv_curve<clipped_t> curve_t;

typedef Sketch<clipped_t> sketch_clipped_t;

typedef Sketch<curve_t> sketch_curve_t;

typedef Sketch<snapped_t> sketch_snapped_t;

typedef Sketch<snapped_curve_t> sketch_snapped_curve_t;

size_t Npaths = path_generator.num_paths();

size_t Noffsets = safe_first_shape(offsets);

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

size_t Ntransforms = safe_first_shape(transforms);

size_t Nfacecolors = safe_first_shape(facecolors);

size_t Nedgecolors = safe_first_shape(edgecolors);

size_t Nhatchcolors = safe_first_shape(hatchcolors);

size_t Nlinewidths = safe_first_shape(linewidths);

size_t Nlinestyles = std::min(linestyles.size(), N);

size_t Naa = safe_first_shape(antialiaseds);

if ((Nfacecolors == 0 && Nedgecolors == 0 && Nhatchcolors == 0) || Npaths == 0) {

return;

}

// Handle any clipping globally

theRasterizer.reset_clipping();

rendererBase.reset_clipping(true);

set_clipbox(cliprect, theRasterizer);

bool has_clippath = render_clippath(clippath, clippath_trans, gc.snap_mode);

// Set some defaults, assuming no face or edge

gc.linewidth = 0.0;

std::optional<agg::rgba> face;

agg::trans_affine trans;

bool do_clip = Nfacecolors == 0 && !gc.has_hatchpath();

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

typename PathGenerator::path_iterator path = path_generator(i);

if (Ntransforms) {

int it = i % Ntransforms;

trans = agg::trans_affine(transforms(it, 0, 0),

transforms(it, 1, 0),

transforms(it, 0, 1),

transforms(it, 1, 1),

transforms(it, 0, 2),

transforms(it, 1, 2));

trans *= master_transform;

} else {

trans = master_transform;

}

if (Noffsets) {

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

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

offset_trans.transform(&xo, &yo);

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

}

// These transformations must be done post-offsets

trans *= agg::trans_affine_scaling(1.0, -1.0);

trans *= agg::trans_affine_translation(0.0, (double)height);

if (Nfacecolors) {

int ic = i % Nfacecolors;

face.emplace(facecolors(ic, 0), facecolors(ic, 1), facecolors(ic, 2), facecolors(ic, 3));

}

if (Nedgecolors) {

int ic = i % Nedgecolors;

gc.color = agg::rgba(edgecolors(ic, 0), edgecolors(ic, 1), edgecolors(ic, 2), edgecolors(ic, 3));

if (Nlinewidths) {

gc.linewidth = linewidths(i % Nlinewidths);

} else {

gc.linewidth = 1.0;

}

if (Nlinestyles) {

gc.dashes = linestyles[i % Nlinestyles];

}

}

if(Nhatchcolors) {

int ic = i % Nhatchcolors;

gc.hatch_color = agg::rgba(hatchcolors(ic, 0), hatchcolors(ic, 1), hatchcolors(ic, 2), hatchcolors(ic, 3));

}

gc.isaa = antialiaseds(i % Naa);

transformed_path_t tpath(path, trans);

nan_removed_t nan_removed(tpath, true, has_codes);