{

auto result = py::list(polygons.size());

for (size_t i = 0; i < polygons.size(); ++i) {

const auto& poly = polygons[i];

py::ssize_t dims[] = { static_cast<py::ssize_t>(poly.size()), 2 };

result[i] = py::array(dims, reinterpret_cast<const double *>(poly.data()));

}

return result;

agg::trans_affine trans)

{

return point_in_path(x, y, r, path, trans);

agg::trans_affine trans)

{

auto points = convert_points(points_obj);

py::ssize_t dims[] = { points.shape(0) };

py::array_t<uint8_t> results(dims);

auto results_mutable = results.mutable_unchecked<1>();

points_in_path(points, r, path, trans, results_mutable);

return results;

mpl::PathGenerator paths,

py::array_t<double> transforms_obj,

py::array_t<double> offsets_obj,

agg::trans_affine offset_trans)

{

auto transforms = convert_transforms(transforms_obj);

auto offsets = convert_points(offsets_obj);

extent_limits e;

get_path_collection_extents(

master_transform, paths, transforms, offsets, offset_trans, e);

py::ssize_t dims[] = { 2, 2 };

py::array_t<double> extents(dims);

*extents.mutable_data(0, 0) = e.start.x;

*extents.mutable_data(0, 1) = e.start.y;

*extents.mutable_data(1, 0) = e.end.x;

*extents.mutable_data(1, 1) = e.end.y;

py::ssize_t minposdims[] = { 2 };

py::array_t<double> minpos(minposdims);

*minpos.mutable_data(0) = e.minpos.x;

*minpos.mutable_data(1) = e.minpos.y;

return py::make_tuple(extents, minpos);

agg::trans_affine master_transform, mpl::PathGenerator paths,

py::array_t<double> transforms_obj,

py::array_t<double> offsets_obj,

agg::trans_affine offset_trans, bool filled)

{

auto transforms = convert_transforms(transforms_obj);

auto offsets = convert_points(offsets_obj);

std::vector<int> result;

point_in_path_collection(x, y, radius, master_transform, paths, transforms, offsets,

offset_trans, filled, result);

py::ssize_t dims[] = { static_cast<py::ssize_t>(result.size()) };

return py::array(dims, result.data());

mpl::PathIterator b, agg::trans_affine btrans)

{

return path_in_path(a, atrans, b, btrans);

{

auto result = clip_path_to_rect(path, rect, inside);

return convert_polygon_vector(result);

agg::trans_affine trans)

{

if (vertices_arr.ndim() == 2) {

auto vertices = vertices_arr.unchecked<2>();

check_trailing_shape(vertices, "vertices", 2);

py::ssize_t dims[] = { vertices.shape(0), 2 };

py::array_t<double> result(dims);

auto result_mutable = result.mutable_unchecked<2>();

affine_transform_2d(vertices, trans, result_mutable);

return result;

} else if (vertices_arr.ndim() == 1) {

auto vertices = vertices_arr.unchecked<1>();

py::ssize_t dims[] = { vertices.shape(0) };

py::array_t<double> result(dims);

auto result_mutable = result.mutable_unchecked<1>();

affine_transform_1d(vertices, trans, result_mutable);

return result;

} else {

throw py::value_error(

"vertices must be 1D or 2D, not" + std::to_string(vertices_arr.ndim()) + "D");

}

{

auto bboxes = convert_bboxes(bboxes_obj);

return count_bboxes_overlapping_bbox(bbox, bboxes);

{

agg::trans_affine t1;

agg::trans_affine t2;

bool result;

result = path_intersects_path(p1, p2);

if (filled) {

if (!result) {

result = path_in_path(p1, t1, p2, t2);

}

if (!result) {

result = path_in_path(p2, t1, p1, t2);

}

}

return result;

double rect_x2, double rect_y2, bool filled)

{

return path_intersects_rectangle(path, rect_x1, rect_y1, rect_x2, rect_y2, filled);

double width, double height, bool closed_only)

{

std::vector<Polygon> result;

convert_path_to_polygons(path, trans, width, height, closed_only, result);

return convert_polygon_vector(result);

agg::rect_d clip_rect, e_snap_mode snap_mode, double stroke_width,

std::optional<bool> simplify, bool return_curves, SketchParams sketch)

{

if (!simplify.has_value()) {

simplify = path.should_simplify();

}

bool do_clip = (clip_rect.x1 < clip_rect.x2 && clip_rect.y1 < clip_rect.y2);

std::vector<double> vertices;

std::vector<uint8_t> codes;

cleanup_path(path, trans, remove_nans, do_clip, clip_rect, snap_mode, stroke_width,

*simplify, return_curves, sketch, vertices, codes);

auto length = static_cast<py::ssize_t>(codes.size());

py::ssize_t vertices_dims[] = { length, 2 };

py::array pyvertices(vertices_dims, vertices.data());

py::ssize_t codes_dims[] = { length };

py::array pycodes(codes_dims, codes.data());

return py::make_tuple(pyvertices, pycodes);

agg::rect_d cliprect, std::optional<bool> simplify,

SketchParams sketch, int precision,

const std::array<std::string, 5> &codes, bool postfix)

{

std::string buffer;

bool status;

if (!simplify.has_value()) {

simplify = path.should_simplify();

}

status = convert_to_string(path, trans, cliprect, *simplify, sketch, precision,

codes, postfix, buffer);

if (!status) {

throw py::value_error("Malformed path codes");

}

return py::bytes(buffer);

{

bool result;

py::array array = py::array::ensure(obj);

if (array.ndim() != 1) {

throw std::invalid_argument("array must be 1D");

}

auto dtype = array.dtype();

/* Handle just the most common types here, otherwise coerce to double */

if (dtype.equal(py::dtype::of<std::int32_t>())) {

result = is_sorted_and_has_non_nan<int32_t>(array);

} else if (dtype.equal(py::dtype::of<std::int64_t>())) {

result = is_sorted_and_has_non_nan<int64_t>(array);

} else if (dtype.equal(py::dtype::of<float>())) {

result = is_sorted_and_has_non_nan<float>(array);

} else if (dtype.equal(py::dtype::of<double>())) {

result = is_sorted_and_has_non_nan<double>(array);

} else {

array = py::array_t<double>::ensure(obj);

result = is_sorted_and_has_non_nan<double>(array);

}

return result;