void
PrintLatex::print_2geomcurve(SVGOStringStream &os, Geom::Curve const &c)
{
using Geom::X;
using Geom::Y;
if( is_straight_curve(c) )
{
os << "\\lineto(" << c.finalPoint()[X] << "," << c.finalPoint()[Y] << ")\n";
}
else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const*>(&c)) {
std::vector<Geom::Point> points = cubic_bezier->points();
os << "\\curveto(" << points[1][X] << "," << points[1][Y] << ")("
<< points[2][X] << "," << points[2][Y] << ")("
<< points[3][X] << "," << points[3][Y] << ")\n";
}
else {
//this case handles sbasis as well as all other curve types
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
print_2geomcurve(os, *iter);
}
}
}
static void
geom_curve_bbox_wind_distance(Geom::Curve const & c, Geom::Affine const &m,
Geom::Point const &pt,
Geom::Rect *bbox, int *wind, Geom::Coord *dist,
Geom::Coord tolerance, Geom::Rect const *viewbox,
Geom::Point &p0) // pass p0 through as it represents the last endpoint added (the finalPoint of last curve)
{
if( is_straight_curve(c) )
{
Geom::Point pe = c.finalPoint() * m;
if (bbox) {
bbox->expandTo(pe);
}
if (dist || wind) {
if (wind) { // we need to pick fill, so do what we're told
geom_line_wind_distance (p0[X], p0[Y], pe[X], pe[Y], pt, wind, dist);
} else { // only stroke is being picked; skip this segment if it's totally outside the viewbox
Geom::Rect swept(p0, pe);
if (!viewbox || swept.intersects(*viewbox))
geom_line_wind_distance (p0[X], p0[Y], pe[X], pe[Y], pt, wind, dist);
}
}
p0 = pe;
}
else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const *>(&c)) {
Geom::Point p1 = (*cubic_bezier)[1] * m;
Geom::Point p2 = (*cubic_bezier)[2] * m;
Geom::Point p3 = (*cubic_bezier)[3] * m;
// get approximate bbox from handles (convex hull property of beziers):
Geom::Rect swept(p0, p3);
swept.expandTo(p1);
swept.expandTo(p2);
if (!viewbox || swept.intersects(*viewbox)) { // we see this segment, so do full processing
geom_cubic_bbox_wind_distance ( p0[X], p0[Y],
p1[X], p1[Y],
p2[X], p2[Y],
p3[X], p3[Y],
pt,
bbox, wind, dist, tolerance);
} else {
if (wind) { // if we need fill, we can just pretend it's a straight line
geom_line_wind_distance (p0[X], p0[Y], p3[X], p3[Y], pt, wind, dist);
} else { // otherwise, skip it completely
}
}
p0 = p3;
} else {
//this case handles sbasis as well as all other curve types
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
//recurse to convert the new path resulting from the sbasis to svgd
for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
geom_curve_bbox_wind_distance(*iter, m, pt, bbox, wind, dist, tolerance, viewbox, p0);
}
}
}
/*
* Can be called recursively.
* If optimize_stroke == false, the view Rect is not used.
*/
static void
feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Affine const & trans, Geom::Rect view, bool optimize_stroke)
{
if( is_straight_curve(c) )
{
Geom::Point end_tr = c.finalPoint() * trans;
if (!optimize_stroke) {
cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
Geom::Rect swept(c.initialPoint()*trans, end_tr);
if (swept.intersects(view)) {
cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
cairo_move_to(cr, end_tr[0], end_tr[1]);
}
}
}
else if(Geom::QuadraticBezier const *quadratic_bezier = dynamic_cast<Geom::QuadraticBezier const*>(&c)) {
std::vector<Geom::Point> points = quadratic_bezier->points();
points[0] *= trans;
points[1] *= trans;
points[2] *= trans;
Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]);
Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]);
if (!optimize_stroke) {
cairo_curve_to(cr, b1[0], b1[1], b2[0], b2[1], points[2][0], points[2][1]);
} else {
Geom::Rect swept(points[0], points[2]);
swept.expandTo(points[1]);
if (swept.intersects(view)) {
cairo_curve_to(cr, b1[0], b1[1], b2[0], b2[1], points[2][0], points[2][1]);
} else {
cairo_move_to(cr, points[2][0], points[2][1]);
}
}
}
else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const*>(&c)) {
std::vector<Geom::Point> points = cubic_bezier->points();
//points[0] *= trans; // don't do this one here for fun: it is only needed for optimized strokes
points[1] *= trans;
points[2] *= trans;
points[3] *= trans;
if (!optimize_stroke) {
cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
} else {
points[0] *= trans; // didn't transform this point yet
Geom::Rect swept(points[0], points[3]);
swept.expandTo(points[1]);
swept.expandTo(points[2]);
if (swept.intersects(view)) {
cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
} else {
cairo_move_to(cr, points[3][0], points[3][1]);
}
}
}
// else if(Geom::SVGEllipticalArc const *svg_elliptical_arc = dynamic_cast<Geom::SVGEllipticalArc *>(c)) {
// //TODO: get at the innards and spit them out to cairo
// }
else {
//this case handles sbasis as well as all other curve types
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
//recurse to convert the new path resulting from the sbasis to svgd
for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
feed_curve_to_cairo(cr, *iter, trans, view, optimize_stroke);
}
}
}
/*
* Can be called recursively.
* If optimize_stroke == false, the view Rect is not used.
*/
static void
feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Affine const & trans, Geom::Rect view, bool optimize_stroke)
{
using Geom::X;
using Geom::Y;
unsigned order = 0;
if (Geom::BezierCurve const* b = dynamic_cast<Geom::BezierCurve const*>(&c)) {
order = b->order();
}
// handle the three typical curve cases
switch (order) {
case 1:
{
Geom::Point end_tr = c.finalPoint() * trans;
if (!optimize_stroke) {
cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
Geom::Rect swept(c.initialPoint()*trans, end_tr);
if (swept.intersects(view)) {
cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
cairo_move_to(cr, end_tr[0], end_tr[1]);
}
}
}
break;
case 2:
{
Geom::QuadraticBezier const *quadratic_bezier = static_cast<Geom::QuadraticBezier const*>(&c);
std::vector<Geom::Point> points = quadratic_bezier->controlPoints();
points[0] *= trans;
points[1] *= trans;
points[2] *= trans;
// degree-elevate to cubic Bezier, since Cairo doesn't do quadratic Beziers
Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]);
Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]);
if (!optimize_stroke) {
cairo_curve_to(cr, b1[X], b1[Y], b2[X], b2[Y], points[2][X], points[2][Y]);
} else {
Geom::Rect swept(points[0], points[2]);
swept.expandTo(points[1]);
if (swept.intersects(view)) {
cairo_curve_to(cr, b1[X], b1[Y], b2[X], b2[Y], points[2][X], points[2][Y]);
} else {
cairo_move_to(cr, points[2][X], points[2][Y]);
}
}
}
break;
case 3:
{
Geom::CubicBezier const *cubic_bezier = static_cast<Geom::CubicBezier const*>(&c);
std::vector<Geom::Point> points = cubic_bezier->controlPoints();
//points[0] *= trans; // don't do this one here for fun: it is only needed for optimized strokes
points[1] *= trans;
points[2] *= trans;
points[3] *= trans;
if (!optimize_stroke) {
cairo_curve_to(cr, points[1][X], points[1][Y], points[2][X], points[2][Y], points[3][X], points[3][Y]);
} else {
points[0] *= trans; // didn't transform this point yet
Geom::Rect swept(points[0], points[3]);
swept.expandTo(points[1]);
swept.expandTo(points[2]);
if (swept.intersects(view)) {
cairo_curve_to(cr, points[1][X], points[1][Y], points[2][X], points[2][Y], points[3][X], points[3][Y]);
} else {
cairo_move_to(cr, points[3][X], points[3][Y]);
}
}
}
break;
default:
{
if (Geom::EllipticalArc const *a = dynamic_cast<Geom::EllipticalArc const*>(&c)) {
//if (!optimize_stroke || a->boundsFast().intersects(view)) {
Geom::Affine xform = a->unitCircleTransform() * trans;
Geom::Point ang(a->initialAngle().radians(), a->finalAngle().radians());
// Apply the transformation to the current context
cairo_matrix_t cm;
cm.xx = xform[0];
cm.xy = xform[2];
cm.x0 = xform[4];
cm.yx = xform[1];
cm.yy = xform[3];
cm.y0 = xform[5];
cairo_save(cr);
cairo_transform(cr, &cm);
// Draw the circle
if (a->sweep()) {
cairo_arc(cr, 0, 0, 1, ang[0], ang[1]);
} else {
cairo_arc_negative(cr, 0, 0, 1, ang[0], ang[1]);
}
// Revert the current context
cairo_restore(cr);
//} else {
// Geom::Point f = a->finalPoint() * trans;
// cairo_move_to(cr, f[X], f[Y]);
//}
} else {
// handles sbasis as well as all other curve types
// this is very slow
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
// recurse to convert the new path resulting from the sbasis to svgd
for (Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
feed_curve_to_cairo(cr, *iter, trans, view, optimize_stroke);
}
}
}
break;
}
}