{

mpl::PathIterator path;

agg::trans_affine trans;

{

double scale;

double length;

double randomness;

{

typedef std::vector<std::pair<double, double> > dash_t;

double dash_offset;

dash_t dashes;

public:

double get_dash_offset() const

{

return dash_offset;

}

void set_dash_offset(double x)

{

dash_offset = x;

}

void add_dash_pair(double length, double skip)

{

dashes.emplace_back(length, skip);

}

size_t size() const

{

return dashes.size();

}

template <class T>

void dash_to_stroke(T &stroke, double dpi, bool isaa)

{

double scaleddpi = dpi / 72.0;

for (auto [val0, val1] : dashes) {

val0 = val0 * scaleddpi;

val1 = val1 * scaleddpi;

if (!isaa) {

val0 = (int)val0 + 0.5;

val1 = (int)val1 + 0.5;

}

stroke.add_dash(val0, val1);

}

stroke.dash_start(get_dash_offset() * scaleddpi);

}

{

public:

GCAgg()

: linewidth(1.0),

alpha(1.0),

comp_op(agg::comp_op_src_over),

cap(agg::butt_cap),

join(agg::round_join),

snap_mode(SNAP_FALSE)

{

}

~GCAgg()

{

}

double linewidth;

double alpha;

bool forced_alpha;

agg::comp_op_e comp_op;

agg::filling_rule_e filling_rule;

agg::rgba color;

bool isaa;

agg::line_cap_e cap;

agg::line_join_e join;

agg::rect_d cliprect;

ClipPath clippath;

Dashes dashes;

e_snap_mode snap_mode;

mpl::PathIterator hatchpath;

agg::rgba hatch_color;

double hatch_linewidth;

SketchParams sketch;

bool has_hatchpath()

{

return hatchpath.total_vertices() != 0;

}

private:

// prevent copying

GCAgg(const GCAgg &);

GCAgg &operator=(const GCAgg &);

const std::unordered_map<std::string, agg::comp_op_e> enum_values = {

{"clear", agg::comp_op_clear},

{"knockout", agg::comp_op_src},

//{"dest", agg::comp_op_dst},

{"normal", agg::comp_op_src_over},

//{"dst_over", agg::comp_op_dst_over},

//{"in", agg::comp_op_src_in},

//{"dst_in", agg::comp_op_dst_in},

//{"out", agg::comp_op_src_out},

{"erase", agg::comp_op_dst_out},

{"atop", agg::comp_op_src_atop},

//{"dst_atop", agg::comp_op_dst_atop},

{"xor", agg::comp_op_xor},

{"plus", agg::comp_op_plus},

{"multiply", agg::comp_op_multiply},

{"screen", agg::comp_op_screen},

{"overlay", agg::comp_op_overlay},

{"darken", agg::comp_op_darken},

{"lighten", agg::comp_op_lighten},

{"color dodge", agg::comp_op_color_dodge},

{"color burn", agg::comp_op_color_burn},

{"hard light", agg::comp_op_hard_light},

{"soft light", agg::comp_op_soft_light},

{"difference", agg::comp_op_difference},

{"exclusion", agg::comp_op_exclusion},

{"hue", agg::comp_op_hsl_hue},

{"saturation", agg::comp_op_hsl_saturation},

{"color", agg::comp_op_hsl_color},

{"luminosity", agg::comp_op_hsl_luminosity},

};

value = enum_values.at(src.cast<std::string>());

return true;

const std::unordered_map<std::string, agg::filling_rule_e> enum_values = {

{"nonzero", agg::fill_non_zero},

{"evenodd", agg::fill_even_odd},

};

value = enum_values.at(src.cast<std::string>());

return true;

const std::unordered_map<std::string, agg::line_cap_e> enum_values = {

{"butt", agg::butt_cap},

{"round", agg::round_cap},

{"projecting", agg::square_cap},

};

value = enum_values.at(src.cast<std::string>());

return true;

const std::unordered_map<std::string, agg::line_join_e> enum_values = {

{"miter", agg::miter_join_revert},

{"round", agg::round_join},

{"bevel", agg::bevel_join},

};

value = enum_values.at(src.cast<std::string>());

return true;

if (src.is_none()) {

return true;

}

auto [path, trans] =

src.cast<std::pair<std::optional<mpl::PathIterator>, agg::trans_affine>>();

if (path) {

value.path = *path;

}

value.trans = trans;

return true;

auto [dash_offset, dashes_seq_or_none] =

src.cast<std::pair<double, std::optional<py::sequence>>>();

if (!dashes_seq_or_none) {

return true;

}

auto dashes_seq = *dashes_seq_or_none;

auto nentries = dashes_seq.size();

// If the dashpattern has odd length, iterate through it twice (in

// accordance with the pdf/ps/svg specs).

auto dash_pattern_length = (nentries % 2) ? 2 * nentries : nentries;

for (py::size_t i = 0; i < dash_pattern_length; i += 2) {

auto length = dashes_seq[i % nentries].cast<double>();

auto skip = dashes_seq[(i + 1) % nentries].cast<double>();

value.add_dash_pair(length, skip);

}

value.set_dash_offset(dash_offset);

return true;

if (src.is_none()) {

value.scale = 0.0;

value.length = 0.0;

value.randomness = 0.0;

return true;

}

auto params = src.cast<std::tuple<double, double, double>>();

std::tie(value.scale, value.length, value.randomness) = params;

return true;

value.linewidth = src.attr("_linewidth").cast<double>();

value.alpha = src.attr("_alpha").cast<double>();

value.forced_alpha = src.attr("_forced_alpha").cast<bool>();

value.comp_op = src.attr("_blend_mode").cast<agg::comp_op_e>();

value.filling_rule = src.attr("_fill_rule").cast<agg::filling_rule_e>();

value.color = src.attr("_rgb").cast<agg::rgba>();

value.isaa = src.attr("_antialiased").cast<bool>();

value.cap = src.attr("_capstyle").cast<agg::line_cap_e>();

value.join = src.attr("_joinstyle").cast<agg::line_join_e>();

value.dashes = src.attr("get_dashes")().cast<Dashes>();

value.cliprect = src.attr("_cliprect").cast<agg::rect_d>();

value.clippath = src.attr("get_clip_path")().cast<ClipPath>();

value.snap_mode = src.attr("get_snap")().cast<e_snap_mode>();

value.hatchpath = src.attr("get_hatch_path")().cast<mpl::PathIterator>();

value.hatch_color = src.attr("get_hatch_color")().cast<agg::rgba>();

value.hatch_linewidth = src.attr("get_hatch_linewidth")().cast<double>();

value.sketch = src.attr("get_sketch_params")().cast<SketchParams>();

return true;