Geom::PathVector
LPEGears::doEffect_path (Geom::PathVector const &path_in)
{
Geom::PathVector path_out;
Geom::Path gearpath = path_in[0];
Geom::Path::iterator it(gearpath.begin());
if ( it == gearpath.end() ) return path_out;
Gear * gear = new Gear(teeth, 200.0, phi * M_PI / 180);
Geom::Point gear_centre = (*it).finalPoint();
gear->centre(gear_centre);
gear->angle(atan2((*it).initialPoint() - gear_centre));
++it;
if ( it == gearpath.end() ) return path_out;
gear->pitch_radius(Geom::distance(gear_centre, (*it).finalPoint()));
path_out.push_back( gear->path());
for (++it; it != gearpath.end() ; ++it) {
// iterate through Geom::Curve in path_in
Gear* gearnew = new Gear(gear->spawn( (*it).finalPoint() ));
path_out.push_back( gearnew->path() );
delete gear;
gear = gearnew;
}
delete gear;
return path_out;
}
Geom::Path half_outline_old(Geom::Path const& input, double width, double miter, Inkscape::LineJoinType join = Inkscape::JOIN_BEVEL)
{
Geom::Path res;
if (input.size() == 0) return res;
Geom::Point tang1 = input[0].unitTangentAt(0);
Geom::Point start = input.initialPoint() + tang1 * width;
Geom::Path temp;
Geom::Point tang[2];
res.setStitching(true);
temp.setStitching(true);
res.start(start);
// Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well
const size_t k = (input.back_closed().isDegenerate() && input.closed())
?input.size_default()-1:input.size_default();
for (size_t u = 0; u < k; u += 2) {
temp.clear();
offset_curve_old(temp, &input[u], width);
// on the first run through, there isn't a join
if (u == 0) {
res.append(temp);
} else {
tangents_old(tang, input[u-1], input[u]);
outline_join(res, temp, tang[0], tang[1], width, miter, join);
}
// odd number of paths
if (u < k - 1) {
temp.clear();
offset_curve_old(temp, &input[u+1], width);
tangents_old(tang, input[u], input[u+1]);
outline_join(res, temp, tang[0], tang[1], width, miter, join);
}
}
if (input.closed()) {
Geom::Curve const &c1 = res.back();
Geom::Curve const &c2 = res.front();
temp.clear();
temp.append(c1);
Geom::Path temp2;
temp2.append(c2);
tangents_old(tang, input.back(), input.front());
outline_join(temp, temp2, tang[0], tang[1], width, miter, join);
res.erase(res.begin());
res.erase_last();
//
res.append(temp);
res.close();
}
return res;
}
static void sp_svg_write_path(Inkscape::SVG::PathString & str, Geom::Path const & p) {
str.moveTo( p.initialPoint()[0], p.initialPoint()[1] );
for(Geom::Path::const_iterator cit = p.begin(); cit != p.end_open(); ++cit) {
sp_svg_write_curve(str, &(*cit));
}
if (p.closed()) {
str.closePath();
}
}
/** Feeds path-creating calls to the cairo context translating them from the Path */
static void
feed_path_to_cairo (cairo_t *ct, Geom::Path const &path)
{
if (path.empty())
return;
cairo_move_to(ct, path.initialPoint()[0], path.initialPoint()[1] );
for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
feed_curve_to_cairo(ct, *cit, Geom::identity(), Geom::Rect(), false); // optimize_stroke is false, so the view rect is not used
}
if (path.closed()) {
cairo_close_path(ct);
}
}
/** Feeds path-creating calls to the cairo context translating them from the Path, with the given transform and shift */
static void
feed_path_to_cairo (cairo_t *ct, Geom::Path const &path, Geom::Affine trans, Geom::OptRect area, bool optimize_stroke, double stroke_width)
{
if (!area)
return;
if (path.empty())
return;
// Transform all coordinates to coords within "area"
Geom::Point shift = area->min();
Geom::Rect view = *area;
view.expandBy (stroke_width);
view = view * (Geom::Affine)Geom::Translate(-shift);
// Pass transformation to feed_curve, so that we don't need to create a whole new path.
Geom::Affine transshift(trans * Geom::Translate(-shift));
Geom::Point initial = path.initialPoint() * transshift;
cairo_move_to(ct, initial[0], initial[1] );
for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
feed_curve_to_cairo(ct, *cit, transshift, view, optimize_stroke);
}
if (path.closed()) {
if (!optimize_stroke) {
cairo_close_path(ct);
} else {
cairo_line_to(ct, initial[0], initial[1]);
/* We cannot use cairo_close_path(ct) here because some parts of the path may have been
clipped and not drawn (maybe the before last segment was outside view area), which
would result in closing the "subpath" after the last interruption, not the entire path.
However, according to cairo documentation:
The behavior of cairo_close_path() is distinct from simply calling cairo_line_to() with the equivalent coordinate
in the case of stroking. When a closed sub-path is stroked, there are no caps on the ends of the sub-path. Instead,
there is a line join connecting the final and initial segments of the sub-path.
The correct fix will be possible when cairo introduces methods for moving without
ending/starting subpaths, which we will use for skipping invisible segments; then we
will be able to use cairo_close_path here. This issue also affects ps/eps/pdf export,
see bug 168129
*/
}
}
}
static gboolean
expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
int width = 256;
int height = 256;
std::ostringstream notify;
gdk_drawable_get_size(widget->window, &width, &height);
for(int i = 0; i < display_path.handles.size(); i++) {
draw_handle(widget->window, display_path.handles[i]);
}
draw_path(widget->window, display_path);
//draw_elip(widget->window, handles);
Geom::Point dir(1,1);
/*
vector<Geom::Path::Location> pts = find_vector_extreme_points(display_path, dir);
for(int i = 0; i < pts.size(); i++) {
draw_circ(widget->window, display_path.point_at(pts[i]));
}*/
double dist = INFINITY;
Geom::Path::Location pl =
display_path.nearest_location(old_mouse_point, dist);
{
Geom::Point pos, tgt, acc;
display_path.point_tangent_acc_at (pl, pos, tgt, acc);
draw_circ(widget->window, pos);
double kurvature = dot(acc, rot90(tgt))/pow(Geom::L2(tgt),3);
if(fabs(kurvature) > 0.001)
draw_ray(widget->window, pos,
(1./kurvature)*Geom::unit_vector(rot90(tgt)));
else // just normal
draw_ray(widget->window, pos, rot90(tgt));
}
Geom::Path pth = display_path.subpath(display_path.begin(), display_path.end());
pth = pth*Geom::translate(Geom::Point(30, 30));
draw_path(widget->window, pth);
Bezier a, b;
const int curve_seg = 3;
Geom::Path::Elem ai(*display_path.indexed_elem(curve_seg)), bi(*pth.indexed_elem(curve_seg));
for(int i = 0; i < 4; i++) {
a.p[i] = ai[i];
b.p[i] = bi[i];
}
std::vector<std::pair <double, double> > ts = Geom::FindIntersections(a, b);
for(int i = 0; i < ts.size(); i++) {
Geom::Path::Location pl(display_path.indexed_elem(curve_seg), ts[i].first);
draw_handle(widget->window, display_path.point_at(pl));
Geom::Path::Location p2(pth.indexed_elem(curve_seg), ts[i].second);
draw_circ(widget->window, display_path.point_at(p2));
}
/*
vector<Geom::Path::Location> pts =
find_inflection_points(display_path);
for(int i = 0; i < pts.size(); i++) {
Geom::Point pos, tgt, acc;
display_path.point_tangent_acc_at (pts[i], pos, tgt, acc);
//tgt *= 0.1;
//acc *= 0.1;
draw_handle(widget->window, display_path.point_at(pts[i]));
draw_circ(widget->window, pos);
//draw_ray(widget->window, pos+tgt, acc);
}
*/
notify << "path length: " << arc_length_integrating(display_path, 1e3) << "\n";
{
notify << std::ends;
PangoLayout *layout = gtk_widget_create_pango_layout(widget, notify.str().c_str());
PangoRectangle logical_extent;
pango_layout_get_pixel_extents(layout,
NULL,
&logical_extent);
gdk_draw_layout(widget->window,
widget->style->fg_gc[GTK_STATE_NORMAL],
0, height-logical_extent.height, layout);
}
return TRUE;
}