1 /**
2 * \file src/snapped-point.cpp
3 * \brief SnappedPoint class.
4 *
5 * Authors:
6 * Mathieu Dimanche <mdimanche@free.fr>
7 * Diederik van Lierop <mail@diedenrezi.nl>
8 *
9 * Released under GNU GPL, read the file 'COPYING' for more information.
10 */
12 #include <gtk/gtk.h>
13 #include "snapped-point.h"
14 #include "preferences.h"
16 // overloaded constructor
17 Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &fully_constrained, Geom::OptRect target_bbox)
18 : _point(p), _source(source), _source_num(source_num), _target(target), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a), _target_bbox(target_bbox)
19 {
20 // tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
21 _at_intersection = false;
22 _fully_constrained = fully_constrained;
23 _second_distance = NR_HUGE;
24 _second_tolerance = 1;
25 _second_always_snap = false;
26 _transformation = Geom::Point(1,1);
27 _pointer_distance = NR_HUGE;
28 }
30 Inkscape::SnappedPoint::SnappedPoint(Inkscape::SnapCandidatePoint const &p, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &fully_constrained)
31 : _target(target), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a)
32 {
33 _point = p.getPoint();
34 _source = p.getSourceType();
35 _source_num = p.getSourceNum();
36 _at_intersection = false;
37 _fully_constrained = fully_constrained;
38 _second_distance = NR_HUGE;
39 _second_tolerance = 1;
40 _second_always_snap = false;
41 _transformation = Geom::Point(1,1);
42 _pointer_distance = NR_HUGE;
43 _target_bbox = p.getTargetBBox();
45 }
47 Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &at_intersection, bool const &fully_constrained, Geom::Coord const &d2, Geom::Coord const &t2, bool const &a2)
48 : _point(p), _source(source), _source_num(source_num), _target(target), _at_intersection(at_intersection), _fully_constrained(fully_constrained), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a),
49 _second_distance(d2), _second_tolerance(std::max(t2,1.0)), _second_always_snap(a2)
50 {
51 // tolerance should never be smaller than 1 px, as it is used for normalization in
52 // isOtherSnapBetter. We don't want a division by zero.
53 _transformation = Geom::Point(1,1);
54 _pointer_distance = NR_HUGE;
55 _target_bbox = Geom::OptRect();
56 }
58 Inkscape::SnappedPoint::SnappedPoint()
59 {
60 _point = Geom::Point(0,0);
61 _source = SNAPSOURCE_UNDEFINED,
62 _source_num = 0,
63 _target = SNAPTARGET_UNDEFINED,
64 _at_intersection = false;
65 _fully_constrained = false;
66 _distance = NR_HUGE;
67 _tolerance = 1;
68 _always_snap = false;
69 _second_distance = NR_HUGE;
70 _second_tolerance = 1;
71 _second_always_snap = false;
72 _transformation = Geom::Point(1,1);
73 _pointer_distance = NR_HUGE;
74 _target_bbox = Geom::OptRect();
75 }
77 Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p)
78 {
79 _point = p;
80 _source = SNAPSOURCE_UNDEFINED,
81 _source_num = 0,
82 _target = SNAPTARGET_UNDEFINED,
83 _at_intersection = false;
84 _fully_constrained = false;
85 _distance = NR_HUGE;
86 _tolerance = 1;
87 _always_snap = false;
88 _second_distance = NR_HUGE;
89 _second_tolerance = 1;
90 _second_always_snap = false;
91 _transformation = Geom::Point(1,1);
92 _pointer_distance = NR_HUGE;
93 _target_bbox = Geom::OptRect();
94 }
96 Inkscape::SnappedPoint::~SnappedPoint()
97 {
98 }
100 void Inkscape::SnappedPoint::getPoint(Geom::Point &p) const
101 {
102 // When we have snapped
103 if (getSnapped()) {
104 // then return the snapped point by overwriting p
105 p = _point;
106 } //otherwise p will be left untouched; this way the caller doesn't have to check whether we've snapped
107 }
109 // search for the closest snapped point
110 bool getClosestSP(std::list<Inkscape::SnappedPoint> const &list, Inkscape::SnappedPoint &result)
111 {
112 bool success = false;
114 for (std::list<Inkscape::SnappedPoint>::const_iterator i = list.begin(); i != list.end(); i++) {
115 if ((i == list.begin()) || (*i).getSnapDistance() < result.getSnapDistance()) {
116 result = *i;
117 success = true;
118 }
119 }
121 return success;
122 }
124 bool Inkscape::SnappedPoint::isOtherSnapBetter(Inkscape::SnappedPoint const &other_one, bool weighted) const
125 {
127 if (!other_one.getSnapped()) {
128 return false;
129 }
131 double dist_other = other_one.getSnapDistance();
132 double dist_this = getSnapDistance();
134 // The distance to the pointer should only be taken into account when finding the best snapped source node (when
135 // there's more than one). It is not useful when trying to find the best snapped target point.
136 // (both the snap distance and the pointer distance are measured in document pixels, not in screen pixels)
137 if (weighted) {
139 Geom::Coord const dist_pointer_other = other_one.getPointerDistance();
140 Geom::Coord const dist_pointer_this = getPointerDistance();
141 // Weight factor: controls which node should be preferred for snapping, which is either
142 // the node with the closest snap (w = 0), or the node closest to the mousepointer (w = 1)
143 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
144 double w = prefs->getDoubleLimited("/options/snapweight/value", 0.5, 0, 1);
145 if (prefs->getBool("/options/snapclosestonly/value", false)) {
146 w = 1;
147 }
148 if (w > 0) {
149 if (!(w == 1 && dist_pointer_this == dist_pointer_other)) {
150 // When accounting for the distance to the mouse pointer, then at least one of the snapped points should
151 // have that distance set. If not, then this is a bug. Either "weighted" must be set to false, or the
152 // mouse pointer distance must be set.
153 g_assert(dist_pointer_this != NR_HUGE || dist_pointer_other != NR_HUGE);
154 // The snap distance will always be smaller than the tolerance set for the snapper. The pointer distance can
155 // however be very large. To compare these in a fair way, we will have to normalize these metrics first
156 // The closest pointer distance will be normalized to 1.0; the other one will be > 1.0
157 // The snap distance will be normalized to 1.0 if it's equal to the snapper tolerance
158 double const norm_p = std::min(dist_pointer_this, dist_pointer_other);
159 double const norm_t_other = std::min(50.0, other_one.getTolerance());
160 double const norm_t_this = std::min(50.0, getTolerance());
161 dist_other = w * dist_pointer_other / norm_p + (1-w) * dist_other / norm_t_other;
162 dist_this = w * dist_pointer_this / norm_p + (1-w) * dist_this / norm_t_this;
163 }
164 }
165 }
167 // If it's closer
168 bool c1 = dist_other < dist_this;
169 // or, if it's for a snapper with "always snap" turned on, and the previous wasn't
170 bool c2 = other_one.getAlwaysSnap() && !getAlwaysSnap();
171 // But in no case fall back from a snapper with "always snap" on to one with "always snap" off
172 bool c2n = !other_one.getAlwaysSnap() && getAlwaysSnap();
173 // or, if we have a fully constrained snappoint (e.g. to a node or an intersection), while the previous one was only partly constrained (e.g. to a line)
174 bool c3 = other_one.getFullyConstrained() && !getFullyConstrained();
175 // But in no case fall back; (has less priority than c3n, so it is allowed to fall back when c3 is true, see below)
176 bool c3n = !other_one.getFullyConstrained() && getFullyConstrained();
178 // When both are fully constrained AND coincident, then prefer nodes over intersections
179 bool d = other_one.getFullyConstrained() && getFullyConstrained() && (Geom::L2(other_one.getPoint() - getPoint()) < 1e-9);
180 bool c4 = d && !other_one.getAtIntersection() && getAtIntersection();
181 // But don't fall back...
182 bool c4n = d && other_one.getAtIntersection() && !getAtIntersection();
184 // or, if it's just as close then consider the second distance
185 bool c5a = (dist_other == dist_this);
186 bool c5b = other_one.getSecondSnapDistance() < getSecondSnapDistance();
188 // std::cout << other_one.getPoint() << " (Other one, dist = " << dist_other << ") vs. " << getPoint() << " (this one, dist = " << dist_this << ") ---> ";
189 // std::cout << "c1 = " << c1 << " | c2 = " << c2 << " | c2n = " << c2n << " | c3 = " << c3 << " | c3n = " << c3n << " | c4 = " << c4 << " | c4n = " << c4n << " | c5a = " << c5a << " | c5b = " << c5b << std::endl;
190 return (c1 || c2 || c3 || c4 || (c5a && c5b)) && !c2n && (!c3n || c2) && !c4n;
191 }
193 /*
194 Local Variables:
195 mode:c++
196 c-file-style:"stroustrup"
197 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
198 indent-tabs-mode:nil
199 fill-column:99
200 End:
201 */
202 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :