001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.actions.mapmode;
003
004import static org.openstreetmap.josm.tools.I18n.tr;
005
006import java.awt.Graphics2D;
007import java.awt.event.ActionEvent;
008import java.awt.event.MouseEvent;
009import java.awt.event.MouseListener;
010import java.util.ArrayList;
011import java.util.Arrays;
012import java.util.Collection;
013import java.util.Comparator;
014import java.util.stream.DoubleStream;
015
016import javax.swing.AbstractAction;
017import javax.swing.JCheckBoxMenuItem;
018import javax.swing.JPopupMenu;
019
020import org.openstreetmap.josm.data.Preferences;
021import org.openstreetmap.josm.data.coor.EastNorth;
022import org.openstreetmap.josm.data.coor.LatLon;
023import org.openstreetmap.josm.data.osm.DataSet;
024import org.openstreetmap.josm.data.osm.Node;
025import org.openstreetmap.josm.data.osm.Way;
026import org.openstreetmap.josm.data.osm.WaySegment;
027import org.openstreetmap.josm.data.projection.ProjectionRegistry;
028import org.openstreetmap.josm.gui.MainApplication;
029import org.openstreetmap.josm.gui.MapView;
030import org.openstreetmap.josm.gui.MapViewState;
031import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
032import org.openstreetmap.josm.gui.draw.MapViewPath;
033import org.openstreetmap.josm.gui.draw.SymbolShape;
034import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
035import org.openstreetmap.josm.spi.preferences.Config;
036import org.openstreetmap.josm.tools.Logging;
037import org.openstreetmap.josm.tools.Utils;
038
039/**
040 * Class that enables the user to draw way segments in angles of exactly 30, 45,
041 * 60, 90 degrees.
042 *
043 * With enabled snapping, the new way node will be projected onto the helper line
044 * that indicates a certain fixed angle relative to the previous segment.
045 */
046class DrawSnapHelper {
047
048    private final DrawAction drawAction;
049
050    /**
051     * Constructs a new {@code SnapHelper}.
052     * @param drawAction enclosing DrawAction
053     */
054    DrawSnapHelper(DrawAction drawAction) {
055        this.drawAction = drawAction;
056        this.anglePopupListener = new PopupMenuLauncher(new AnglePopupMenu(this)) {
057            @Override
058            public void mouseClicked(MouseEvent e) {
059                super.mouseClicked(e);
060                if (e.getButton() == MouseEvent.BUTTON1) {
061                    toggleSnapping();
062                    drawAction.updateStatusLine();
063                }
064            }
065        };
066    }
067
068    private static final String DRAW_ANGLESNAP_ANGLES = "draw.anglesnap.angles";
069
070    private static final class RepeatedAction extends AbstractAction {
071        RepeatedAction(DrawSnapHelper snapHelper) {
072            super(tr("Toggle snapping by {0}", snapHelper.drawAction.getShortcut().getKeyText()));
073        }
074
075        @Override
076        public void actionPerformed(ActionEvent e) {
077            boolean sel = ((JCheckBoxMenuItem) e.getSource()).getState();
078            DrawAction.USE_REPEATED_SHORTCUT.put(sel);
079        }
080    }
081
082    private static final class HelperAction extends AbstractAction {
083        private final transient DrawSnapHelper snapHelper;
084
085        HelperAction(DrawSnapHelper snapHelper) {
086            super(tr("Show helper geometry"));
087            this.snapHelper = snapHelper;
088        }
089
090        @Override
091        public void actionPerformed(ActionEvent e) {
092            boolean sel = ((JCheckBoxMenuItem) e.getSource()).getState();
093            DrawAction.DRAW_CONSTRUCTION_GEOMETRY.put(sel);
094            DrawAction.SHOW_PROJECTED_POINT.put(sel);
095            DrawAction.SHOW_ANGLE.put(sel);
096            snapHelper.enableSnapping();
097        }
098    }
099
100    private static final class ProjectionAction extends AbstractAction {
101        private final transient DrawSnapHelper snapHelper;
102
103        ProjectionAction(DrawSnapHelper snapHelper) {
104            super(tr("Snap to node projections"));
105            this.snapHelper = snapHelper;
106        }
107
108        @Override
109        public void actionPerformed(ActionEvent e) {
110            boolean sel = ((JCheckBoxMenuItem) e.getSource()).getState();
111            DrawAction.SNAP_TO_PROJECTIONS.put(sel);
112            snapHelper.enableSnapping();
113        }
114    }
115
116    private static final class DisableAction extends AbstractAction {
117        private final transient DrawSnapHelper snapHelper;
118
119        DisableAction(DrawSnapHelper snapHelper) {
120            super(tr("Disable"));
121            this.snapHelper = snapHelper;
122        }
123
124        @Override
125        public void actionPerformed(ActionEvent e) {
126            snapHelper.saveAngles("180");
127            snapHelper.init();
128            snapHelper.enableSnapping();
129        }
130    }
131
132    private static final class Snap90DegreesAction extends AbstractAction {
133        private final transient DrawSnapHelper snapHelper;
134
135        Snap90DegreesAction(DrawSnapHelper snapHelper) {
136            super(tr("0,90,..."));
137            this.snapHelper = snapHelper;
138        }
139
140        @Override
141        public void actionPerformed(ActionEvent e) {
142            snapHelper.saveAngles("0", "90", "180");
143            snapHelper.init();
144            snapHelper.enableSnapping();
145        }
146    }
147
148    private static final class Snap45DegreesAction extends AbstractAction {
149        private final transient DrawSnapHelper snapHelper;
150
151        Snap45DegreesAction(DrawSnapHelper snapHelper) {
152            super(tr("0,45,90,..."));
153            this.snapHelper = snapHelper;
154        }
155
156        @Override
157        public void actionPerformed(ActionEvent e) {
158            snapHelper.saveAngles("0", "45", "90", "135", "180");
159            snapHelper.init();
160            snapHelper.enableSnapping();
161        }
162    }
163
164    private static final class Snap30DegreesAction extends AbstractAction {
165        private final transient DrawSnapHelper snapHelper;
166
167        Snap30DegreesAction(DrawSnapHelper snapHelper) {
168            super(tr("0,30,45,60,90,..."));
169            this.snapHelper = snapHelper;
170        }
171
172        @Override
173        public void actionPerformed(ActionEvent e) {
174            snapHelper.saveAngles("0", "30", "45", "60", "90", "120", "135", "150", "180");
175            snapHelper.init();
176            snapHelper.enableSnapping();
177        }
178    }
179
180    private static final class AnglePopupMenu extends JPopupMenu {
181
182        private AnglePopupMenu(final DrawSnapHelper snapHelper) {
183            JCheckBoxMenuItem repeatedCb = new JCheckBoxMenuItem(new RepeatedAction(snapHelper));
184            JCheckBoxMenuItem helperCb = new JCheckBoxMenuItem(new HelperAction(snapHelper));
185            JCheckBoxMenuItem projectionCb = new JCheckBoxMenuItem(new ProjectionAction(snapHelper));
186
187            helperCb.setState(DrawAction.DRAW_CONSTRUCTION_GEOMETRY.get());
188            projectionCb.setState(DrawAction.SNAP_TO_PROJECTIONS.get());
189            repeatedCb.setState(DrawAction.USE_REPEATED_SHORTCUT.get());
190            add(repeatedCb);
191            add(helperCb);
192            add(projectionCb);
193            add(new DisableAction(snapHelper));
194            add(new Snap90DegreesAction(snapHelper));
195            add(new Snap45DegreesAction(snapHelper));
196            add(new Snap30DegreesAction(snapHelper));
197        }
198    }
199
200    private boolean snapOn; // snapping is turned on
201
202    private boolean active; // snapping is active for current mouse position
203    private boolean fixed; // snap angle is fixed
204    private boolean absoluteFix; // snap angle is absolute
205
206    EastNorth dir2;
207    private EastNorth projected;
208    private String labelText;
209    private double lastAngle;
210
211    private double customBaseHeading = -1; // angle of base line, if not last segment)
212    private EastNorth segmentPoint1; // remembered first point of base segment
213    private EastNorth segmentPoint2; // remembered second point of base segment
214    private EastNorth projectionSource; // point that we are projecting to the line
215
216    private double[] snapAngles;
217
218    private double pe, pn; // (pe, pn) - direction of snapping line
219    private double e0, n0; // (e0, n0) - origin of snapping line
220
221    private final String fixFmt = "%d "+tr("FIX");
222
223    private JCheckBoxMenuItem checkBox;
224
225    final MouseListener anglePopupListener;
226
227    /**
228     * Set the initial state
229     */
230    public void init() {
231        snapOn = false;
232        checkBox.setState(snapOn);
233        fixed = false;
234        absoluteFix = false;
235
236        computeSnapAngles();
237        Preferences.main().addWeakKeyPreferenceChangeListener(DRAW_ANGLESNAP_ANGLES, e -> this.computeSnapAngles());
238    }
239
240    private void computeSnapAngles() {
241        snapAngles = Config.getPref().getList(DRAW_ANGLESNAP_ANGLES,
242                Arrays.asList("0", "30", "45", "60", "90", "120", "135", "150", "180"))
243                .stream()
244                .mapToDouble(DrawSnapHelper::parseSnapAngle)
245                .flatMap(s -> DoubleStream.of(s, 360-s))
246                .toArray();
247    }
248
249    private static double parseSnapAngle(String string) {
250        try {
251            return Double.parseDouble(string);
252        } catch (NumberFormatException e) {
253            Logging.warn("Incorrect number in draw.anglesnap.angles preferences: {0}", string);
254            return 0;
255        }
256    }
257
258    /**
259     * Save the snap angles
260     * @param angles The angles
261     */
262    public void saveAngles(String... angles) {
263        Config.getPref().putList(DRAW_ANGLESNAP_ANGLES, Arrays.asList(angles));
264    }
265
266    /**
267     * Sets the menu checkbox.
268     * @param checkBox menu checkbox
269     */
270    public void setMenuCheckBox(JCheckBoxMenuItem checkBox) {
271        this.checkBox = checkBox;
272    }
273
274    /**
275     * Draw the snap hint line.
276     * @param g2 graphics
277     * @param mv MapView state
278     * @since 10874
279     */
280    public void drawIfNeeded(Graphics2D g2, MapViewState mv) {
281        if (!snapOn || !active)
282            return;
283        MapViewPoint p1 = mv.getPointFor(drawAction.getCurrentBaseNode());
284        MapViewPoint p2 = mv.getPointFor(dir2);
285        MapViewPoint p3 = mv.getPointFor(projected);
286        if (DrawAction.DRAW_CONSTRUCTION_GEOMETRY.get()) {
287            g2.setColor(DrawAction.SNAP_HELPER_COLOR.get());
288            g2.setStroke(DrawAction.HELPER_STROKE.get());
289
290            MapViewPath b = new MapViewPath(mv);
291            b.moveTo(p2);
292            if (absoluteFix) {
293                b.lineTo(p2.interpolate(p1, 2)); // bi-directional line
294            } else {
295                b.lineTo(p3);
296            }
297            g2.draw(b);
298        }
299        if (projectionSource != null) {
300            g2.setColor(DrawAction.SNAP_HELPER_COLOR.get());
301            g2.setStroke(DrawAction.HELPER_STROKE.get());
302            MapViewPath b = new MapViewPath(mv);
303            b.moveTo(p3);
304            b.lineTo(projectionSource);
305            g2.draw(b);
306        }
307
308        if (customBaseHeading >= 0) {
309            g2.setColor(DrawAction.HIGHLIGHT_COLOR.get());
310            g2.setStroke(DrawAction.HIGHLIGHT_STROKE.get());
311            MapViewPath b = new MapViewPath(mv);
312            b.moveTo(segmentPoint1);
313            b.lineTo(segmentPoint2);
314            g2.draw(b);
315        }
316
317        g2.setColor(DrawAction.RUBBER_LINE_COLOR.get());
318        g2.setStroke(DrawAction.RUBBER_LINE_STROKE.get());
319        MapViewPath b = new MapViewPath(mv);
320        b.moveTo(p1);
321        b.lineTo(p3);
322        g2.draw(b);
323
324        g2.drawString(labelText, (int) p3.getInViewX()-5, (int) p3.getInViewY()+20);
325        if (DrawAction.SHOW_PROJECTED_POINT.get()) {
326            g2.setStroke(DrawAction.RUBBER_LINE_STROKE.get());
327            g2.draw(new MapViewPath(mv).shapeAround(p3, SymbolShape.CIRCLE, 10)); // projected point
328        }
329
330        g2.setColor(DrawAction.SNAP_HELPER_COLOR.get());
331        g2.setStroke(DrawAction.HELPER_STROKE.get());
332    }
333
334    /**
335     * If mouse position is close to line at 15-30-45-... angle, remembers this direction
336     * @param currentEN Current position
337     * @param baseHeading The heading
338     * @param curHeading The current mouse heading
339     */
340    public void checkAngleSnapping(EastNorth currentEN, double baseHeading, double curHeading) {
341        MapView mapView = MainApplication.getMap().mapView;
342        EastNorth p0 = drawAction.getCurrentBaseNode().getEastNorth();
343        EastNorth snapPoint = currentEN;
344        double angle = Double.NaN;
345
346        double activeBaseHeading = (customBaseHeading >= 0) ? customBaseHeading : baseHeading;
347
348        if (snapOn && (activeBaseHeading >= 0)) {
349            angle = curHeading - activeBaseHeading;
350            if (angle < 0) {
351                angle += 360;
352            }
353            if (angle > 360) {
354                angle = 0;
355            }
356
357            double nearestAngle;
358            if (fixed) {
359                nearestAngle = lastAngle; // if direction is fixed use previous angle
360                active = true;
361            } else {
362                nearestAngle = getNearestAngle(angle);
363                if (getAngleDelta(nearestAngle, angle) < DrawAction.SNAP_ANGLE_TOLERANCE.get()) {
364                    active = customBaseHeading >= 0 || Math.abs(nearestAngle - 180) > 1e-3;
365                    // if angle is to previous segment, exclude 180 degrees
366                    lastAngle = nearestAngle;
367                } else {
368                    active = false;
369                }
370            }
371
372            if (active) {
373                double phi;
374                e0 = p0.east();
375                n0 = p0.north();
376                buildLabelText((nearestAngle <= 180) ? nearestAngle : (nearestAngle-360));
377
378                phi = (nearestAngle + activeBaseHeading) * Math.PI / 180;
379                // (pe,pn) - direction of snapping line
380                pe = Math.sin(phi);
381                pn = Math.cos(phi);
382                double scale = 20 * mapView.getDist100Pixel();
383                dir2 = new EastNorth(e0 + scale * pe, n0 + scale * pn);
384                snapPoint = getSnapPoint(currentEN);
385            } else {
386                noSnapNow();
387            }
388        }
389
390        // find out the distance, in metres, between the base point and projected point
391        LatLon mouseLatLon = mapView.getProjection().eastNorth2latlon(snapPoint);
392        double distance = this.drawAction.getCurrentBaseNode().greatCircleDistance(mouseLatLon);
393        double hdg = Utils.toDegrees(p0.heading(snapPoint));
394        // heading of segment from current to calculated point, not to mouse position
395
396        if (baseHeading >= 0) { // there is previous line segment with some heading
397            angle = hdg - baseHeading;
398            if (angle < 0) {
399                angle += 360;
400            }
401            if (angle > 360) {
402                angle = 0;
403            }
404        }
405        DrawAction.showStatusInfo(angle, hdg, distance, isSnapOn());
406    }
407
408    private void buildLabelText(double nearestAngle) {
409        if (DrawAction.SHOW_ANGLE.get()) {
410            if (fixed) {
411                if (absoluteFix) {
412                    labelText = "=";
413                } else {
414                    labelText = String.format(fixFmt, (int) nearestAngle);
415                }
416            } else {
417                labelText = String.format("%d", (int) nearestAngle);
418            }
419        } else {
420            if (fixed) {
421                if (absoluteFix) {
422                    labelText = "=";
423                } else {
424                    labelText = String.format(tr("FIX"), 0);
425                }
426            } else {
427                labelText = "";
428            }
429        }
430    }
431
432    /**
433     * Gets a snap point close to p. Stores the result for display.
434     * @param p The point
435     * @return The snap point close to p.
436     */
437    public EastNorth getSnapPoint(EastNorth p) {
438        if (!active)
439            return p;
440        double de = p.east()-e0;
441        double dn = p.north()-n0;
442        double l = de*pe+dn*pn;
443        double delta = MainApplication.getMap().mapView.getDist100Pixel() / (20 * ProjectionRegistry.getProjection().getMetersPerUnit());
444        if (!absoluteFix && l < delta) {
445            active = false;
446            return p;
447        } //  do not go backward!
448
449        projectionSource = null;
450        if (DrawAction.SNAP_TO_PROJECTIONS.get()) {
451            DataSet ds = drawAction.getLayerManager().getActiveDataSet();
452            Collection<Way> selectedWays = ds.getSelectedWays();
453            if (selectedWays.size() == 1) {
454                Way w = selectedWays.iterator().next();
455                Collection<EastNorth> pointsToProject = new ArrayList<>();
456                if (w.getNodesCount() < 1000) {
457                    for (Node n: w.getNodes()) {
458                        pointsToProject.add(n.getEastNorth());
459                    }
460                }
461                if (customBaseHeading >= 0) {
462                    pointsToProject.add(segmentPoint1);
463                    pointsToProject.add(segmentPoint2);
464                }
465                EastNorth enOpt = null;
466                double dOpt = 1e5;
467                for (EastNorth en: pointsToProject) { // searching for best projection
468                    double l1 = (en.east()-e0)*pe+(en.north()-n0)*pn;
469                    double d1 = Math.abs(l1-l);
470                    if (d1 < delta && d1 < dOpt) {
471                        l = l1;
472                        enOpt = en;
473                        dOpt = d1;
474                    }
475                }
476                if (enOpt != null) {
477                    projectionSource = enOpt;
478                }
479            }
480        }
481        projected = new EastNorth(e0+l*pe, n0+l*pn);
482        return projected;
483    }
484
485    /**
486     * Disables snapping
487     */
488    void noSnapNow() {
489        active = false;
490        dir2 = null;
491        projected = null;
492        labelText = null;
493    }
494
495    void setBaseSegment(WaySegment seg) {
496        if (seg == null) return;
497        segmentPoint1 = seg.getFirstNode().getEastNorth();
498        segmentPoint2 = seg.getSecondNode().getEastNorth();
499
500        double hdg = segmentPoint1.heading(segmentPoint2);
501        hdg = Utils.toDegrees(hdg);
502        if (hdg < 0) {
503            hdg += 360;
504        }
505        if (hdg > 360) {
506            hdg -= 360;
507        }
508        customBaseHeading = hdg;
509    }
510
511    /**
512     * Enable snapping.
513     */
514    void enableSnapping() {
515        snapOn = true;
516        checkBox.setState(snapOn);
517        customBaseHeading = -1;
518        unsetFixedMode();
519    }
520
521    void toggleSnapping() {
522        snapOn = !snapOn;
523        checkBox.setState(snapOn);
524        customBaseHeading = -1;
525        unsetFixedMode();
526    }
527
528    void setFixedMode() {
529        if (active) {
530            fixed = true;
531        }
532    }
533
534    void unsetFixedMode() {
535        fixed = false;
536        absoluteFix = false;
537        lastAngle = 0;
538        active = false;
539    }
540
541    boolean isActive() {
542        return active;
543    }
544
545    boolean isSnapOn() {
546        return snapOn;
547    }
548
549    private double getNearestAngle(double angle) {
550        double bestAngle = DoubleStream.of(snapAngles).boxed()
551                .min(Comparator.comparing(snapAngle -> getAngleDelta(angle, snapAngle))).orElse(0.0);
552        if (Math.abs(bestAngle-360) < 1e-3) {
553            bestAngle = 0;
554        }
555        return bestAngle;
556    }
557
558    private static double getAngleDelta(double a, double b) {
559        double delta = Math.abs(a-b);
560        if (delta > 180)
561            return 360-delta;
562        else
563            return delta;
564    }
565
566    void unFixOrTurnOff() {
567        if (absoluteFix) {
568            unsetFixedMode();
569        } else {
570            toggleSnapping();
571        }
572    }
573}