From ef22647ff7f24ab39aac0020f01187587364dae0 Mon Sep 17 00:00:00 2001 From: Diederik van Lierop Date: Fri, 8 Aug 2008 22:28:49 +0000 Subject: Snap to intersections of any kind of path (were we previously only could snap to intersections of line-segments) (bzr r6597) --- src/snapped-curve.cpp | 146 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 src/snapped-curve.cpp (limited to 'src/snapped-curve.cpp') diff --git a/src/snapped-curve.cpp b/src/snapped-curve.cpp new file mode 100644 index 000000000..c6b7edc8a --- /dev/null +++ b/src/snapped-curve.cpp @@ -0,0 +1,146 @@ +/** + * \file src/snapped-curve.cpp + * \brief SnappedCurve class. + * + * Authors: + * Diederik van Lierop + * + * Released under GNU GPL, read the file 'COPYING' for more information. + */ + +#include "snapped-curve.h" +#include "libnr/nr-values.h" +#include <2geom/crossing.h> +#include <2geom/path-intersection.h> +#include + +// These two are needed for SP_ACTIVE_DESKTOP; this is a dirty hack +#include "desktop.h" +#include "inkscape.h" + +Inkscape::SnappedCurve::SnappedCurve(NR::Point const &snapped_point, NR::Coord const &snapped_distance, NR::Coord const &snapped_tolerance, bool const &always_snap, Geom::Curve const *curve) +{ + _distance = snapped_distance; + _tolerance = snapped_tolerance; + _always_snap = always_snap; + _curve = curve; + _second_distance = NR_HUGE; + _second_tolerance = 0; + _second_always_snap = false; + _point = snapped_point; + _at_intersection = false; +} + +Inkscape::SnappedCurve::SnappedCurve() +{ + _distance = NR_HUGE; + _tolerance = 0; + _always_snap = false; + _curve = NULL; + _second_distance = NR_HUGE; + _second_tolerance = 0; + _second_always_snap = false; + _point = NR::Point(0,0); + _at_intersection = false; +} + +Inkscape::SnappedCurve::~SnappedCurve() +{ +} + +Inkscape::SnappedPoint Inkscape::SnappedCurve::intersect(SnappedCurve const &curve, NR::Point const &p) const +{ + // Calculate the intersections of two curves, 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) for find out which intersection is the + // closest, as there might be multiple intersections of two curves + Geom::SimpleCrosser xr; + Geom::Crossings cs = xr.crossings(*(this->_curve), *(curve._curve)); + + if (cs.size() > 0) { + // There might be multiple intersections: find the closest + Geom::Coord best_dist = NR_HUGE; + Geom::Point best_p = Geom::Point(NR_HUGE, NR_HUGE); + for (std::vector::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; + } + } + + // Now we've found the closests intersection, return it as a SnappedPoint + bool const use_this_as_primary = _distance < curve.getDistance(); + 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, but for this + // we need a desktop: this is a dirty hack + SPDesktop const *desktop = SP_ACTIVE_DESKTOP; + best_p = desktop->dt2doc(best_p); + // 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(from_2geom(best_p), Inkscape::SNAPTARGET_PATH_INTERSECTION, primaryC->getDistance(), primaryC->getTolerance(), primaryC->getAlwaysSnap(), true, + secondaryC->getDistance(), secondaryC->getTolerance(), secondaryC->getAlwaysSnap()); + } + + // No intersection + return SnappedPoint(NR::Point(NR_HUGE, NR_HUGE), SNAPTARGET_UNDEFINED, NR_HUGE, 0, false, false, NR_HUGE, 0, false); +} + +// search for the closest snapped line +bool getClosestCurve(std::list const &list, Inkscape::SnappedCurve &result) +{ + bool success = false; + + for (std::list::const_iterator i = list.begin(); i != list.end(); i++) { + if ((i == list.begin()) || (*i).getDistance() < result.getDistance()) { + result = *i; + success = true; + } + } + + return success; +} + +// search for the closest intersection of two snapped curves, which are both member of the same collection +bool getClosestIntersectionCS(std::list const &list, NR::Point const &p, Inkscape::SnappedPoint &result) +{ + bool success = false; + + for (std::list::const_iterator i = list.begin(); i != list.end(); i++) { + std::list::const_iterator j = i; + j++; + for (; j != list.end(); j++) { + Inkscape::SnappedPoint sp = (*i).intersect(*j, p); + if (sp.getAtIntersection()) { + // if it's the first point + bool const c1 = !success; + // or, if it's closer + bool const c2 = sp.getDistance() < result.getDistance(); + // or, if it's just then look at the other distance + // (only relevant for snapped points which are at an intersection + bool const c3 = (sp.getDistance() == result.getDistance()) && (sp.getSecondDistance() < result.getSecondDistance()); + // then prefer this point over the previous one + if (c1 || c2 || c3) { + result = sp; + success = true; + } + } + } + } + + return success; +} +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : -- cgit v1.2.3