/* -*- mode: c++; c-basic-offset: 4 -*- */

#include <Python.h>

#define NO_IMPORT_ARRAY

#include "numpy/arrayobject.h"

#include "agg_py_path_iterator.h"

#include "agg_conv_transform.h"

#include "agg_py_transforms.h"

#include "path_converters.h"

class PathCleanupIterator

{

typedef agg::conv_transform<PathIterator> transformed_path_t;

typedef PathNanRemover<transformed_path_t> nan_removal_t;

typedef PathClipper<nan_removal_t> clipped_t;

typedef PathSnapper<clipped_t> snapped_t;

typedef PathSimplifier<snapped_t> simplify_t;

typedef Sketch<simplify_t> sketch_t;

Py::Object m_path_obj;

PathIterator m_path_iter;

agg::trans_affine m_transform;

transformed_path_t m_transformed;

nan_removal_t m_nan_removed;

clipped_t m_clipped;

snapped_t m_snapped;

simplify_t m_simplify;

sketch_t m_sketch;

public:

PathCleanupIterator(PyObject* path, agg::trans_affine trans,

bool remove_nans, bool do_clip,

const agg::rect_base<double>& rect,

e_snap_mode snap_mode, double stroke_width,

bool do_simplify, double sketch_scale,

double sketch_length, double sketch_randomness) :

m_path_obj(path, true),

m_path_iter(m_path_obj),

m_transform(trans),

m_transformed(m_path_iter, m_transform),

m_nan_removed(m_transformed, remove_nans, m_path_iter.has_curves()),

m_clipped(m_nan_removed, do_clip, rect),

m_snapped(m_clipped, snap_mode, m_path_iter.total_vertices(),

stroke_width),

m_simplify(m_snapped, do_simplify && m_path_iter.should_simplify(),

m_path_iter.simplify_threshold()),

m_sketch(m_simplify, sketch_scale, sketch_length, sketch_randomness)

{

Py_INCREF(path);

m_path_iter.rewind(0);

}

unsigned vertex(double* x, double* y)

{

return m_simplify.vertex(x, y);

}

};

extern "C"

{

void*

get_path_iterator(

PyObject* path, PyObject* trans, int remove_nans, int do_clip,

double rect[4], e_snap_mode snap_mode, double stroke_width,

int do_simplify, double sketch_scale, double sketch_length,

double sketch_randomness)

{

agg::trans_affine agg_trans = py_to_agg_transformation_matrix(trans, false);

agg::rect_base<double> clip_rect(rect[0], rect[1], rect[2], rect[3]);

PathCleanupIterator* pipeline = new PathCleanupIterator(

path, agg_trans, remove_nans != 0, do_clip != 0,

clip_rect, snap_mode, stroke_width, do_simplify != 0,

sketch_scale, sketch_length, sketch_randomness);

return (void*)pipeline;

}

unsigned

get_vertex(void* pipeline, double* x, double* y)

{

PathCleanupIterator* pipeline_iter = (PathCleanupIterator*)pipeline;

unsigned code = pipeline_iter->vertex(x, y);

return code;

}

void

free_path_iterator(void* pipeline)

{

PathCleanupIterator* pipeline_iter = (PathCleanupIterator*)pipeline;

delete pipeline_iter;

}

}