853N/A

853N/A#include "snapped-curve.h"

853N/A#include <2geom/crossing.h>

853N/A#include <2geom/path-intersection.h>

853N/A

853N/AInkscape::SnappedCurve::SnappedCurve(Geom::Point const &snapped_point, int num_path, int num_segm, Geom::Coord const &snapped_distance, Geom::Coord const &snapped_tolerance, bool const &always_snap, bool const &fully_constrained, Geom::Curve const *curve, SnapSourceType source, long source_num, SnapTargetType target, Geom::OptRect target_bbox)

853N/A{

853N/A _num_path = num_path;

853N/A _num_segm = num_segm;

853N/A _distance = snapped_distance;

853N/A _tolerance = std::max(snapped_tolerance, 1.0);

853N/A _always_snap = always_snap;

853N/A _curve = curve;

853N/A _second_distance = Geom::infinity();

853N/A _second_tolerance = 1;

853N/A _second_always_snap = false;

853N/A _point = snapped_point;

853N/A _at_intersection = false;

853N/A _fully_constrained = fully_constrained;

853N/A _source = source;

853N/A _source_num = source_num;

853N/A _target = target;

853N/A _target_bbox = target_bbox;

853N/A}

853N/A

853N/AInkscape::SnappedCurve::SnappedCurve()

853N/A{

853N/A _num_path = 0;

853N/A _num_segm = 0;

853N/A _distance = Geom::infinity();

853N/A _tolerance = 1;

853N/A _always_snap = false;

853N/A _curve = NULL;

853N/A _second_distance = Geom::infinity();

853N/A _second_tolerance = 1;

853N/A _second_always_snap = false;

853N/A _point = Geom::Point(0,0);

853N/A _at_intersection = false;

853N/A _fully_constrained = false;

853N/A _source = SNAPSOURCE_UNDEFINED;

853N/A _source_num = -1;

853N/A _target = SNAPTARGET_UNDEFINED;

853N/A _target_bbox = Geom::OptRect();

853N/A}

853N/A

853N/AInkscape::SnappedCurve::~SnappedCurve()

853N/A{

853N/A}

853N/A

853N/AInkscape::SnappedPoint Inkscape::SnappedCurve::intersect(SnappedCurve const &curve, Geom::Point const &p, Geom::Affine dt2doc) const

853N/A{

853N/A // Calculate the intersections of two curves, which are both within snapping range, and

853N/A // return only the closest intersection

853N/A // The point of intersection should be considered for snapping, but might be outside the snapping range

853N/A // PS: We need p (the location of the mouse pointer) to find out which intersection is the

853N/A // closest, as there might be multiple intersections of two curves

853N/A Geom::Crossings cs = crossings(*(this->_curve), *(curve._curve));

853N/A

853N/A if (cs.size() > 0) {

853N/A // There might be multiple intersections: find the closest

853N/A Geom::Coord best_dist = Geom::infinity();

853N/A Geom::Point best_p = Geom::Point(Geom::infinity(), Geom::infinity());

853N/A for (Geom::Crossings::const_iterator i = cs.begin(); i != cs.end(); i++) {

853N/A Geom::Point p_ix = this->_curve->pointAt((*i).ta);

853N/A Geom::Coord dist = Geom::distance(p_ix, p);

853N/A

853N/A // Test if we have two segments (curves) from the same path..

853N/A if (this->_num_path == curve._num_path) {

853N/A // Never try to intersect a segment with itself

853N/A if (this->_num_segm == curve._num_segm) continue;

853N/A // Two subsequent segments (curves) in a path will have a common node; this node is not considered to be an intersection

if (this->_num_segm == curve._num_segm + 1 && (*i).ta == 0 && (*i).tb == 1) continue;

if (this->_num_segm + 1 == curve._num_segm && (*i).ta == 1 && (*i).tb == 0) continue;

}

if (dist < best_dist) {

best_dist = dist;

best_p = p_ix;

}

}

// Now we've found the closest intersection, return it as a SnappedPoint

bool const use_this_as_primary = _distance < curve.getSnapDistance();

Inkscape::SnappedCurve const *primaryC = use_this_as_primary ? this : &curve;

Inkscape::SnappedCurve const *secondaryC = use_this_as_primary ? &curve : this;

// The intersection should in fact be returned in desktop coordinates

best_p = best_p * dt2doc;

Geom::Coord primaryDist = use_this_as_primary ? Geom::L2(best_p - this->getPoint()) : Geom::L2(best_p - curve.getPoint());

Geom::Coord secondaryDist = use_this_as_primary ? Geom::L2(best_p - curve.getPoint()) : Geom::L2(best_p - this->getPoint());

// TODO: Investigate whether it is possible to use document coordinates everywhere

// in the snapper code. Only the mouse position should be in desktop coordinates, I guess.

// All paths are already in document coords and we are certainly not going to change THAT.

return SnappedPoint(best_p, Inkscape::SNAPSOURCE_UNDEFINED, primaryC->getSourceNum(), Inkscape::SNAPTARGET_PATH_INTERSECTION, primaryDist, primaryC->getTolerance(), primaryC->getAlwaysSnap(), true, false, true,

secondaryDist, secondaryC->getTolerance(), secondaryC->getAlwaysSnap());

}

// No intersection

return SnappedPoint(Geom::Point(Geom::infinity(), Geom::infinity()), SNAPSOURCE_UNDEFINED, 0, SNAPTARGET_UNDEFINED, Geom::infinity(), 0, false, false, false, false, Geom::infinity(), 0, false);

}

Inkscape::SnappedPoint Inkscape::SnappedCurve::intersect(SnappedLine const &line, Geom::Point const &p, Geom::Affine dt2doc) const

{

// Calculate the intersections of a curve with a line, which are both within snapping range, and

// return only the closest intersection

// The point of intersection should be considered for snapping, but might be outside the snapping range

// PS: We need p (the location of the mouse pointer) to find out which intersection is the

// closest, as there might be multiple intersections of a single curve with a line

// 1) get a Geom::Line object from the SnappedLine

// 2) convert to document coordinates (line and p are in desktop coordinates, but the curves are in document coordinate)

// 3) create a Geom::LineSegment (i.e. a curve), because we cannot use a Geom::Line for calculating intersections

// (for this we will create a 2e6 pixels long linesegment, with t running from -1e6 to 1e6; this should be long

// enough for any practical purpose)

Geom::LineSegment line_segm = line.getLine().transformed(dt2doc).segment(-1e6, 1e6); //

const Geom::Curve *line_as_curve = dynamic_cast<Geom::Curve const*>(&line_segm);

Geom::Crossings cs = crossings(*(this->_curve), *line_as_curve);

if (cs.size() > 0) {

// There might be multiple intersections: find the closest

Geom::Coord best_dist = Geom::infinity();

Geom::Point best_p = Geom::Point(Geom::infinity(), Geom::infinity());

for (Geom::Crossings::const_iterator i = cs.begin(); i != cs.end(); i++) {

Geom::Point p_ix = this->_curve->pointAt((*i).ta);

Geom::Coord dist = Geom::distance(p_ix, p);

if (dist < best_dist) {

best_dist = dist;

best_p = p_ix;

}

}

// The intersection should in fact be returned in desktop coordinates

best_p = best_p * dt2doc;

// Now we've found the closest intersection, return it as a SnappedPoint

if (_distance < line.getSnapDistance()) {

// curve is the closest, so this is our primary snap target

return SnappedPoint(best_p, Inkscape::SNAPSOURCE_UNDEFINED, this->getSourceNum(), Inkscape::SNAPTARGET_PATH_GUIDE_INTERSECTION,

Geom::L2(best_p - this->getPoint()), this->getTolerance(), this->getAlwaysSnap(), true, false, true,

Geom::L2(best_p - line.getPoint()), line.getTolerance(), line.getAlwaysSnap());

} else {

return SnappedPoint(best_p, Inkscape::SNAPSOURCE_UNDEFINED, line.getSourceNum(), Inkscape::SNAPTARGET_PATH_GUIDE_INTERSECTION,

Geom::L2(best_p - line.getPoint()), line.getTolerance(), line.getAlwaysSnap(), true, false, true,

Geom::L2(best_p - this->getPoint()), this->getTolerance(), this->getAlwaysSnap());

}

}

// No intersection

return SnappedPoint(Geom::Point(Geom::infinity(), Geom::infinity()), SNAPSOURCE_UNDEFINED, 0, SNAPTARGET_UNDEFINED, Geom::infinity(), 0, false, false, false, false, Geom::infinity(), 0, false);

}

bool getClosestCurve(std::list<Inkscape::SnappedCurve> const &list, Inkscape::SnappedCurve &result, bool exclude_paths)

{

bool success = false;

for (std::list<Inkscape::SnappedCurve>::const_iterator i = list.begin(); i != list.end(); i++) {

if (exclude_paths && ((*i).getTarget() == Inkscape::SNAPTARGET_PATH)) {

continue;

}

if ((i == list.begin()) || (*i).getSnapDistance() < result.getSnapDistance()) {

result = *i;

success = true;

}

}

return success;

}

bool getClosestIntersectionCS(std::list<Inkscape::SnappedCurve> const &list, Geom::Point const &p, Inkscape::SnappedPoint &result, Geom::Affine dt2doc)

{

bool success = false;

for (std::list<Inkscape::SnappedCurve>::const_iterator i = list.begin(); i != list.end(); i++) {

if ((*i).getTarget() != Inkscape::SNAPTARGET_BBOX_EDGE) { // We don't support snapping to intersections of bboxes,

// as this would require two bboxes two be flashed in the snap indicator

std::list<Inkscape::SnappedCurve>::const_iterator j = i;

j++;

for (; j != list.end(); j++) {

if ((*j).getTarget() != Inkscape::SNAPTARGET_BBOX_EDGE) { // We don't support snapping to intersections of bboxes

Inkscape::SnappedPoint sp = (*i).intersect(*j, p, dt2doc);

if (sp.getAtIntersection()) {

// if it's the first point

bool const c1 = !success;

// or, if it's closer

bool const c2 = sp.getSnapDistance() < result.getSnapDistance();

// or, if it's just as close then look at the other distance

// (only relevant for snapped points which are at an intersection)

bool const c3 = (sp.getSnapDistance() == result.getSnapDistance()) && (sp.getSecondSnapDistance() < result.getSecondSnapDistance());

// then prefer this point over the previous one

if (c1 || c2 || c3) {

result = sp;

success = true;

}

}

}

}

}

}

return success;

}

bool getClosestIntersectionCL(std::list<Inkscape::SnappedCurve> const &curve_list, std::list<Inkscape::SnappedLine> const &line_list, Geom::Point const &p, Inkscape::SnappedPoint &result, Geom::Affine dt2doc)

{

bool success = false;

for (std::list<Inkscape::SnappedCurve>::const_iterator i = curve_list.begin(); i != curve_list.end(); i++) {

if ((*i).getTarget() != Inkscape::SNAPTARGET_BBOX_EDGE) { // We don't support snapping to intersections of bboxes,

// as this would require two bboxes two be flashed in the snap indicator

for (std::list<Inkscape::SnappedLine>::const_iterator j = line_list.begin(); j != line_list.end(); j++) {

if ((*j).getTarget() != Inkscape::SNAPTARGET_BBOX_EDGE) { // We don't support snapping to intersections of bboxes

Inkscape::SnappedPoint sp = (*i).intersect(*j, p, dt2doc);

if (sp.getAtIntersection()) {

// if it's the first point

bool const c1 = !success;

// or, if it's closer

bool const c2 = sp.getSnapDistance() < result.getSnapDistance();

// or, if it's just as close then look at the other distance

// (only relevant for snapped points which are at an intersection)

bool const c3 = (sp.getSnapDistance() == result.getSnapDistance()) && (sp.getSecondSnapDistance() < result.getSecondSnapDistance());

// then prefer this point over the previous one

if (c1 || c2 || c3) {

result = sp;

success = true;

}

}

}

}

}

}

return success;

}