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 _circle(Geom::Point center, double radius, std::vector<Geom::Path> &path_out) {
using namespace Geom;
Geom::Path pb;
D2<SBasis> B;
Linear bo = Linear(0, 2 * M_PI);
B[0] = cos(bo,4);
B[1] = sin(bo,4);
B = B * radius + center;
pb.append(SBasisCurve(B));
path_out.push_back(pb);
}
void offset_curve_old(Geom::Path& res, Geom::Curve const* current, double width)
{
double const tolerance = 0.0025;
size_t levels = 8;
if (current->isDegenerate()) return; // don't do anything
// TODO: we can handle SVGEllipticalArc here as well, do that!
if (Geom::BezierCurve const *b = dynamic_cast<Geom::BezierCurve const*>(current)) {
size_t order = b->order();
switch (order) {
case 1:
res.append(offset_line_old(static_cast<Geom::LineSegment const&>(*current), width));
break;
case 2: {
Geom::QuadraticBezier const& q = static_cast<Geom::QuadraticBezier const&>(*current);
offset_quadratic_old(res, q, width, tolerance, levels);
break;
}
case 3: {
Geom::CubicBezier const& cb = static_cast<Geom::CubicBezier const&>(*current);
offset_cubic_old(res, cb, width, tolerance, levels);
break;
}
default: {
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), tolerance);
for (size_t i = 0; i < sbasis_path.size(); ++i)
offset_curve_old(res, &sbasis_path[i], width);
break;
}
}
} else {
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), 0.1);
for (size_t i = 0; i < sbasis_path.size(); ++i)
offset_curve_old(res, &sbasis_path[i], width);
}
}
void offset_cubic_old(Geom::Path& p, Geom::CubicBezier const& bez, double width, double tol, size_t levels)
{
using Geom::X;
using Geom::Y;
Geom::Point start_pos = bez.initialPoint();
Geom::Point end_pos = bez.finalPoint();
Geom::Point start_normal = Geom::rot90(bez.unitTangentAt(0));
Geom::Point end_normal = -Geom::rot90(Geom::unitTangentAt(Geom::reverse(bez.toSBasis()), 0.));
// offset the start and end control points out by the width
Geom::Point start_new = start_pos + start_normal*width;
Geom::Point end_new = end_pos + end_normal*width;
// --------
double start_rad, end_rad;
double start_len, end_len; // tangent lengths
get_cubic_data_old(bez, 0, start_len, start_rad);
get_cubic_data_old(bez, 1, end_len, end_rad);
double start_off = 1, end_off = 1;
// correction of the lengths of the tangent to the offset
if (!Geom::are_near(start_rad, 0))
start_off += width / start_rad;
if (!Geom::are_near(end_rad, 0))
end_off += width / end_rad;
start_off *= start_len;
end_off *= end_len;
// --------
Geom::Point mid1_new = start_normal.ccw()*start_off;
mid1_new = Geom::Point(start_new[X] + mid1_new[X]/3., start_new[Y] + mid1_new[Y]/3.);
Geom::Point mid2_new = end_normal.ccw()*end_off;
mid2_new = Geom::Point(end_new[X] - mid2_new[X]/3., end_new[Y] - mid2_new[Y]/3.);
// create the estimate curve
Geom::CubicBezier c = Geom::CubicBezier(start_new, mid1_new, mid2_new, end_new);
// reached maximum recursive depth
// don't bother with any more correction
if (levels == 0) {
p.append(c);
return;
}
// check the tolerance for our estimate to be a parallel curve
Geom::Point chk = c.pointAt(.5);
Geom::Point req = bez.pointAt(.5) + Geom::rot90(bez.unitTangentAt(.5))*width; // required accuracy
Geom::Point const diff = req - chk;
double const err = Geom::dot(diff, diff);
if (err < tol) {
if (Geom::are_near(start_new, p.finalPoint())) {
p.setFinal(start_new); // if it isn't near, we throw
}
// we're good, curve is accurate enough
try {
p.append(c);}
catch (...) {
}
return;
} else {
// split the curve in two
std::pair<Geom::CubicBezier, Geom::CubicBezier> s = bez.subdivide(.5);
offset_cubic_old(p, s.first, width, tol, levels - 1);
offset_cubic_old(p, s.second, width, tol, levels - 1);
}
}
Geom::Path Gear::path() {
Geom::Path pb;
// angle covered by a full tooth and fillet
double tooth_rotation = 2.0 * tooth_thickness_angle();
// angle covered by an involute
double involute_advance = involute_intersect_angle(outer_radius()) - involute_intersect_angle(root_radius());
// angle covered by the tooth tip
double tip_advance = tooth_thickness_angle() - (2 * (involute_intersect_angle(outer_radius()) - involute_intersect_angle(pitch_radius())));
// angle covered by the toothe root
double root_advance = (tooth_rotation - tip_advance) - (2.0 * involute_advance);
// begin drawing the involute at t if the root circle is larger than the base circle
double involute_t = involute_swath_angle(root_radius())/involute_swath_angle(outer_radius());
//rewind angle to start drawing from the leading edge of the tooth
double first_tooth_angle = _angle - ((0.5 * tip_advance) + involute_advance);
Geom::Point prev;
for (int i=0; i < _number_of_teeth; i++)
{
double cursor = first_tooth_angle + (i * tooth_rotation);
D2<SBasis> leading_I = compose(_involute(cursor, cursor + involute_swath_angle(outer_radius())), Linear(involute_t,1));
if(i != 0) makeContinuous(leading_I, prev);
pb.append(SBasisCurve(leading_I));
cursor += involute_advance;
prev = leading_I.at1();
D2<SBasis> tip = _arc(cursor, cursor+tip_advance, outer_radius());
makeContinuous(tip, prev);
pb.append(SBasisCurve(tip));
cursor += tip_advance;
prev = tip.at1();
cursor += involute_advance;
D2<SBasis> trailing_I = compose(_involute(cursor, cursor - involute_swath_angle(outer_radius())), Linear(1,involute_t));
makeContinuous(trailing_I, prev);
pb.append(SBasisCurve(trailing_I));
prev = trailing_I.at1();
if (base_radius() > root_radius()) {
Geom::Point leading_start = trailing_I.at1();
Geom::Point leading_end = (root_radius() * unit_vector(leading_start - _centre)) + _centre;
prev = leading_end;
pb.appendNew<LineSegment>(leading_end);
}
D2<SBasis> root = _arc(cursor, cursor+root_advance, root_radius());
makeContinuous(root, prev);
pb.append(SBasisCurve(root));
//cursor += root_advance;
prev = root.at1();
if (base_radius() > root_radius()) {
Geom::Point trailing_start = root.at1();
Geom::Point trailing_end = (base_radius() * unit_vector(trailing_start - _centre)) + _centre;
pb.appendNew<LineSegment>(trailing_end);
prev = trailing_end;
}
}
return pb;
}
virtual void draw(cairo_t *cr, std::ostringstream *notify, int width, int height, bool save, std::ostringstream *timer_stream) {
D2<SBasis2d> sb2;
for(unsigned dim = 0; dim < 2; dim++) {
sb2[dim].us = 2;
sb2[dim].vs = 2;
const int depth = sb2[dim].us*sb2[dim].vs;
sb2[dim].resize(depth, Linear2d(0));
}
Geom::Point dir(1,-2);
if(hand.pts.empty()) {
for(unsigned vi = 0; vi < sb2[0].vs; vi++)
for(unsigned ui = 0; ui < sb2[0].us; ui++)
for(unsigned iv = 0; iv < 2; iv++)
for(unsigned iu = 0; iu < 2; iu++)
hand.pts.push_back(Geom::Point((2*(iu+ui)/(2.*ui+1)+1)*width/4.,
(2*(iv+vi)/(2.*vi+1)+1)*width/4.));
}
for(int dim = 0; dim < 2; dim++) {
Geom::Point dir(0,0);
dir[dim] = 1;
for(unsigned vi = 0; vi < sb2[dim].vs; vi++)
for(unsigned ui = 0; ui < sb2[dim].us; ui++)
for(unsigned iv = 0; iv < 2; iv++)
for(unsigned iu = 0; iu < 2; iu++) {
unsigned corner = iu + 2*iv;
unsigned i = ui + vi*sb2[dim].us;
Geom::Point base((2*(iu+ui)/(2.*ui+1)+1)*width/4.,
(2*(iv+vi)/(2.*vi+1)+1)*width/4.);
if(vi == 0 && ui == 0) {
base = Geom::Point(width/4., width/4.);
}
double dl = dot((hand.pts[corner+4*i] - base), dir)/dot(dir,dir);
sb2[dim][i][corner] = dl/(width/2)*pow(4.0,(double)ui+vi);
}
}
cairo_d2_sb2d(cr, sb2, dir*0.1, width);
cairo_set_source_rgba (cr, 0., 0., 0, 0.5);
cairo_stroke(cr);
for(unsigned vi = 0; vi < v_subs; vi++) {
double tv = vi * inv_v_subs;
for(unsigned ui = 0; ui < u_subs; ui++) {
double tu = ui * inv_u_subs;
Geom::Path pb;
D2<SBasis> B;
D2<SBasis> tB;
B[0] = Linear(tu-fudge, tu+fudge + inv_u_subs );
B[1] = Linear(tv-fudge, tv-fudge);
tB = compose_each(sb2, B);
tB = tB*(width/2) + Geom::Point(width/4, width/4);
pb.append(tB);
B[0] = Linear(tu+fudge + inv_u_subs , tu+fudge + inv_u_subs);
B[1] = Linear(tv-fudge, tv+fudge + inv_v_subs);
tB = compose_each(sb2, B);
tB = tB*(width/2) + Geom::Point(width/4, width/4);
pb.append(tB);
B[0] = Linear(tu+fudge + inv_u_subs, tu-fudge);
B[1] = Linear(tv+fudge + inv_v_subs, tv+fudge + inv_v_subs);
tB = compose_each(sb2, B);
tB = tB*(width/2) + Geom::Point(width/4, width/4);
pb.append(tB);
B[0] = Linear(tu-fudge, tu-fudge);
B[1] = Linear(tv+fudge + inv_v_subs, tv-fudge);
tB = compose_each(sb2, B);
tB = tB*(width/2) + Geom::Point(width/4, width/4);
pb.append(tB);
cairo_path(cr, pb);
//std::cout << pb.peek().end() - pb.peek().begin() << std::endl;
cairo_set_source_rgba (cr, tu, tv, 0, 1);
cairo_fill(cr);
}
}
//*notify << "bo = " << sb2.index(0,0);
Toy::draw(cr, notify, width, height, save,timer_stream);
}
void Inkscape::ObjectSnapper::_snapPathsConstrained(IntermSnapResults &isr,
SnapCandidatePoint const &p,
SnapConstraint const &c,
Geom::Point const &p_proj_on_constraint) const
{
_collectPaths(p_proj_on_constraint, p.getSourceType(), p.getSourceNum() <= 0);
// Now we can finally do the real snapping, using the paths collected above
SPDesktop const *dt = _snapmanager->getDesktop();
g_assert(dt != NULL);
Geom::Point direction_vector = c.getDirection();
if (!is_zero(direction_vector)) {
direction_vector = Geom::unit_vector(direction_vector);
}
// The intersection point of the constraint line with any path, must lie within two points on the
// SnapConstraint: p_min_on_cl and p_max_on_cl. The distance between those points is twice the snapping tolerance
Geom::Point const p_min_on_cl = dt->dt2doc(p_proj_on_constraint - getSnapperTolerance() * direction_vector);
Geom::Point const p_max_on_cl = dt->dt2doc(p_proj_on_constraint + getSnapperTolerance() * direction_vector);
Geom::Coord tolerance = getSnapperTolerance();
// PS: Because the paths we're about to snap to are all expressed relative to document coordinate system, we will have
// to convert the snapper coordinates from the desktop coordinates to document coordinates
std::vector<Geom::Path> constraint_path;
if (c.isCircular()) {
Geom::Circle constraint_circle(dt->dt2doc(c.getPoint()), c.getRadius());
constraint_circle.getPath(constraint_path);
} else {
Geom::Path constraint_line;
constraint_line.start(p_min_on_cl);
constraint_line.appendNew<Geom::LineSegment>(p_max_on_cl);
constraint_path.push_back(constraint_line);
}
// Length of constraint_path will always be one
bool strict_snapping = _snapmanager->snapprefs.getStrictSnapping();
// Find all intersections of the constrained path with the snap target candidates
std::vector<Geom::Point> intersections;
for (std::vector<SnapCandidatePath >::const_iterator k = _paths_to_snap_to->begin(); k != _paths_to_snap_to->end(); ++k) {
if (k->path_vector && _allowSourceToSnapToTarget(p.getSourceType(), (*k).target_type, strict_snapping)) {
// Do the intersection math
Geom::CrossingSet cs = Geom::crossings(constraint_path, *(k->path_vector));
// Store the results as intersection points
unsigned int index = 0;
for (Geom::CrossingSet::const_iterator i = cs.begin(); i != cs.end(); ++i) {
if (index >= constraint_path.size()) {
break;
}
// Reconstruct and store the points of intersection
for (Geom::Crossings::const_iterator m = (*i).begin(); m != (*i).end(); ++m) {
intersections.push_back(constraint_path[index].pointAt((*m).ta));
}
index++;
}
//Geom::crossings will not consider the closing segment apparently, so we'll handle that separately here
//TODO: This should have been fixed in rev. #9859, which makes this workaround obsolete
for(Geom::PathVector::iterator it_pv = k->path_vector->begin(); it_pv != k->path_vector->end(); ++it_pv) {
if (it_pv->closed()) {
// Get the closing linesegment and convert it to a path
Geom::Path cls;
cls.close(false);
cls.append(it_pv->back_closed());
// Intersect that closing path with the constrained path
Geom::Crossings cs = Geom::crossings(constraint_path.front(), cls);
// Reconstruct and store the points of intersection
index = 0; // assuming the constraint path vector has only one path
for (Geom::Crossings::const_iterator m = cs.begin(); m != cs.end(); ++m) {
intersections.push_back(constraint_path[index].pointAt((*m).ta));
}
}
}
// Convert the collected points of intersection to snapped points
for (std::vector<Geom::Point>::iterator p_inters = intersections.begin(); p_inters != intersections.end(); ++p_inters) {
// Convert to desktop coordinates
(*p_inters) = dt->doc2dt(*p_inters);
// Construct a snapped point
Geom::Coord dist = Geom::L2(p.getPoint() - *p_inters);
SnappedPoint s = SnappedPoint(*p_inters, p.getSourceType(), p.getSourceNum(), k->target_type, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), true, k->target_bbox);;
// Store the snapped point
if (dist <= tolerance) { // If the intersection is within snapping range, then we might snap to it
isr.points.push_back(s);
}
}
}
}
}