001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.actions.mapmode;
003
004import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
005import static org.openstreetmap.josm.tools.I18n.marktr;
006import static org.openstreetmap.josm.tools.I18n.tr;
007
008import java.awt.BasicStroke;
009import java.awt.Color;
010import java.awt.Cursor;
011import java.awt.Graphics2D;
012import java.awt.Point;
013import java.awt.Rectangle;
014import java.awt.Stroke;
015import java.awt.event.ActionEvent;
016import java.awt.event.KeyEvent;
017import java.awt.event.MouseEvent;
018import java.awt.geom.AffineTransform;
019import java.awt.geom.GeneralPath;
020import java.awt.geom.Line2D;
021import java.awt.geom.NoninvertibleTransformException;
022import java.awt.geom.Point2D;
023import java.util.ArrayList;
024import java.util.Collection;
025import java.util.LinkedList;
026import java.util.List;
027
028import javax.swing.JCheckBoxMenuItem;
029
030import org.openstreetmap.josm.actions.JosmAction;
031import org.openstreetmap.josm.actions.MergeNodesAction;
032import org.openstreetmap.josm.command.AddCommand;
033import org.openstreetmap.josm.command.ChangeNodesCommand;
034import org.openstreetmap.josm.command.Command;
035import org.openstreetmap.josm.command.MoveCommand;
036import org.openstreetmap.josm.command.SequenceCommand;
037import org.openstreetmap.josm.data.Bounds;
038import org.openstreetmap.josm.data.UndoRedoHandler;
039import org.openstreetmap.josm.data.coor.EastNorth;
040import org.openstreetmap.josm.data.coor.ILatLon;
041import org.openstreetmap.josm.data.osm.DataSet;
042import org.openstreetmap.josm.data.osm.Node;
043import org.openstreetmap.josm.data.osm.OsmPrimitive;
044import org.openstreetmap.josm.data.osm.Way;
045import org.openstreetmap.josm.data.osm.WaySegment;
046import org.openstreetmap.josm.data.preferences.NamedColorProperty;
047import org.openstreetmap.josm.data.projection.ProjectionRegistry;
048import org.openstreetmap.josm.gui.MainApplication;
049import org.openstreetmap.josm.gui.MainMenu;
050import org.openstreetmap.josm.gui.MapFrame;
051import org.openstreetmap.josm.gui.MapView;
052import org.openstreetmap.josm.gui.draw.MapViewPath;
053import org.openstreetmap.josm.gui.draw.SymbolShape;
054import org.openstreetmap.josm.gui.layer.Layer;
055import org.openstreetmap.josm.gui.layer.MapViewPaintable;
056import org.openstreetmap.josm.gui.util.GuiHelper;
057import org.openstreetmap.josm.gui.util.KeyPressReleaseListener;
058import org.openstreetmap.josm.gui.util.ModifierExListener;
059import org.openstreetmap.josm.spi.preferences.Config;
060import org.openstreetmap.josm.tools.Geometry;
061import org.openstreetmap.josm.tools.ImageProvider;
062import org.openstreetmap.josm.tools.Logging;
063import org.openstreetmap.josm.tools.Shortcut;
064
065/**
066 * Makes a rectangle from a line, or modifies a rectangle.
067 */
068public class ExtrudeAction extends MapMode implements MapViewPaintable, KeyPressReleaseListener, ModifierExListener {
069
070    enum Mode { extrude, translate, select, create_new, translate_node }
071
072    private Mode mode = Mode.select;
073
074    /**
075     * If {@code true}, when extruding create new node(s) even if segments are parallel.
076     */
077    private boolean alwaysCreateNodes;
078    private boolean nodeDragWithoutCtrl;
079
080    private long mouseDownTime;
081    private transient WaySegment selectedSegment;
082    private transient Node selectedNode;
083    private transient Command lastCommandOnUndoStack;
084    private Color mainColor;
085    private transient Stroke mainStroke;
086
087    /** settings value whether shared nodes should be ignored or not */
088    private boolean ignoreSharedNodes;
089
090    private boolean keepSegmentDirection;
091
092    /**
093     * drawing settings for helper lines
094     */
095    private Color helperColor;
096    private transient Stroke helperStrokeDash;
097    private transient Stroke helperStrokeRA;
098
099    private transient Stroke oldLineStroke;
100    private double symbolSize;
101    /**
102     * Possible directions to move to.
103     */
104    private transient List<ReferenceSegment> possibleMoveDirections;
105
106
107    /**
108     * Collection of nodes that is moved
109     */
110    private transient List<Node> movingNodeList;
111
112    /**
113     * The direction that is currently active.
114     */
115    private transient ReferenceSegment activeMoveDirection;
116
117    /**
118     * The position of the mouse cursor when the drag action was initiated.
119     */
120    private Point initialMousePos;
121    /**
122     * The time which needs to pass between click and release before something
123     * counts as a move, in milliseconds
124     */
125    private int initialMoveDelay = 200;
126    /**
127     * The minimal shift of mouse (in pixels) before something counts as move
128     */
129    private int initialMoveThreshold = 1;
130
131    /**
132     * The initial EastNorths of node1 and node2
133     */
134    private EastNorth initialN1en;
135    private EastNorth initialN2en;
136    /**
137     * The new EastNorths of node1 and node2
138     */
139    private EastNorth newN1en;
140    private EastNorth newN2en;
141
142    /**
143     * the command that performed last move.
144     */
145    private transient MoveCommand moveCommand;
146    /**
147     *  The command used for dual alignment movement.
148     *  Needs to be separate, due to two nodes moving in different directions.
149     */
150    private transient MoveCommand moveCommand2;
151
152    /** The cursor for the 'create_new' mode. */
153    private final Cursor cursorCreateNew;
154
155    /** The cursor for the 'translate' mode. */
156    private final Cursor cursorTranslate;
157
158    /** The cursor for the 'alwaysCreateNodes' submode. */
159    private final Cursor cursorCreateNodes;
160
161    private static class ReferenceSegment {
162        public final EastNorth en;
163        public final EastNorth p1;
164        public final EastNorth p2;
165        public final boolean perpendicular;
166
167        ReferenceSegment(EastNorth en, EastNorth p1, EastNorth p2, boolean perpendicular) {
168            this.en = en;
169            this.p1 = p1;
170            this.p2 = p2;
171            this.perpendicular = perpendicular;
172        }
173
174        @Override
175        public String toString() {
176            return "ReferenceSegment[en=" + en + ", p1=" + p1 + ", p2=" + p2 + ", perp=" + perpendicular + ']';
177        }
178    }
179
180    // Dual alignment mode stuff
181    /** {@code true}, if dual alignment mode is enabled. User wants following extrude to be dual aligned. */
182    private boolean dualAlignEnabled;
183    /** {@code true}, if dual alignment is active. User is dragging the mouse, required conditions are met.
184     * Treat {@link #mode} (extrude/translate/create_new) as dual aligned. */
185    private boolean dualAlignActive;
186    /** Dual alignment reference segments */
187    private transient ReferenceSegment dualAlignSegment1, dualAlignSegment2;
188    /** {@code true}, if new segment was collapsed */
189    private boolean dualAlignSegmentCollapsed;
190    // Dual alignment UI stuff
191    private final DualAlignChangeAction dualAlignChangeAction;
192    private final JCheckBoxMenuItem dualAlignCheckboxMenuItem;
193    private final transient Shortcut dualAlignShortcut;
194    private boolean useRepeatedShortcut;
195    private boolean ignoreNextKeyRelease;
196
197    private class DualAlignChangeAction extends JosmAction {
198        DualAlignChangeAction() {
199            super(tr("Dual alignment"), /* ICON() */ "mapmode/extrude/dualalign",
200                    tr("Switch dual alignment mode while extruding"), null, false);
201            setHelpId(ht("/Action/Extrude#DualAlign"));
202        }
203
204        @Override
205        public void actionPerformed(ActionEvent e) {
206            toggleDualAlign();
207        }
208
209        @Override
210        protected void updateEnabledState() {
211            MapFrame map = MainApplication.getMap();
212            setEnabled(map != null && map.mapMode instanceof ExtrudeAction);
213        }
214    }
215
216    /**
217     * Creates a new ExtrudeAction
218     * @since 11713
219     */
220    public ExtrudeAction() {
221        super(tr("Extrude"), /* ICON(mapmode/) */ "extrude/extrude", tr("Create areas"),
222                Shortcut.registerShortcut("mapmode:extrude", tr("Mode: {0}", tr("Extrude")), KeyEvent.VK_X, Shortcut.DIRECT),
223                ImageProvider.getCursor("normal", "rectangle"));
224        setHelpId(ht("/Action/Extrude"));
225        cursorCreateNew = ImageProvider.getCursor("normal", "rectangle_plus");
226        cursorTranslate = ImageProvider.getCursor("normal", "rectangle_move");
227        cursorCreateNodes = ImageProvider.getCursor("normal", "rectangle_plussmall");
228
229        dualAlignEnabled = false;
230        dualAlignChangeAction = new DualAlignChangeAction();
231        dualAlignCheckboxMenuItem = addDualAlignMenuItem();
232        dualAlignCheckboxMenuItem.getAction().setEnabled(false);
233        dualAlignCheckboxMenuItem.setState(dualAlignEnabled);
234        dualAlignShortcut = Shortcut.registerShortcut("mapmode:extrudedualalign",
235                tr("Edit: {0}", tr("Extrude Dual alignment")), KeyEvent.CHAR_UNDEFINED, Shortcut.NONE);
236        readPreferences(); // to show prefernces in table before entering the mode
237    }
238
239    @Override
240    public void destroy() {
241        super.destroy();
242        MainApplication.getMenu().editMenu.remove(dualAlignCheckboxMenuItem);
243        dualAlignChangeAction.destroy();
244    }
245
246    private JCheckBoxMenuItem addDualAlignMenuItem() {
247        int n = MainApplication.getMenu().editMenu.getItemCount();
248        return MainMenu.addWithCheckbox(MainApplication.getMenu().editMenu, dualAlignChangeAction, n >= 5 ? n-5 : -1, false);
249    }
250
251    // -------------------------------------------------------------------------
252    // Mode methods
253    // -------------------------------------------------------------------------
254
255    @Override
256    public String getModeHelpText() {
257        StringBuilder rv;
258        if (mode == Mode.select) {
259            rv = new StringBuilder(tr("Drag a way segment to make a rectangle. Ctrl-drag to move a segment along its normal, " +
260                "Alt-drag to create a new rectangle, double click to add a new node."));
261            if (dualAlignEnabled) {
262                rv.append(' ').append(tr("Dual alignment active."));
263                if (dualAlignSegmentCollapsed)
264                    rv.append(' ').append(tr("Segment collapsed due to its direction reversing."));
265            }
266        } else {
267            if (mode == Mode.translate) {
268                rv = new StringBuilder(tr("Move a segment along its normal, then release the mouse button."));
269            } else if (mode == Mode.translate_node) {
270                rv = new StringBuilder(tr("Move the node along one of the segments, then release the mouse button."));
271            } else if (mode == Mode.extrude || mode == Mode.create_new) {
272                rv = new StringBuilder(tr("Draw a rectangle of the desired size, then release the mouse button."));
273            } else {
274                Logging.warn("Extrude: unknown mode " + mode);
275                rv = new StringBuilder();
276            }
277            if (dualAlignActive) {
278                rv.append(' ').append(tr("Dual alignment active."));
279                if (dualAlignSegmentCollapsed) {
280                    rv.append(' ').append(tr("Segment collapsed due to its direction reversing."));
281                }
282            }
283        }
284        return rv.toString();
285    }
286
287    @Override
288    public boolean layerIsSupported(Layer l) {
289        return isEditableDataLayer(l);
290    }
291
292    @Override
293    public void enterMode() {
294        super.enterMode();
295        MapFrame map = MainApplication.getMap();
296        map.mapView.addMouseListener(this);
297        map.mapView.addMouseMotionListener(this);
298        map.statusLine.setAutoLength(false);
299        ignoreNextKeyRelease = true;
300        map.keyDetector.addKeyListener(this);
301        map.keyDetector.addModifierExListener(this);
302    }
303
304    @Override
305    protected void readPreferences() {
306        initialMoveDelay = Config.getPref().getInt("edit.initial-move-delay", 200);
307        initialMoveThreshold = Config.getPref().getInt("extrude.initial-move-threshold", 1);
308        mainColor = new NamedColorProperty(marktr("Extrude: main line"), Color.RED).get();
309        helperColor = new NamedColorProperty(marktr("Extrude: helper line"), Color.ORANGE).get();
310        helperStrokeDash = GuiHelper.getCustomizedStroke(Config.getPref().get("extrude.stroke.helper-line", "1 4"));
311        helperStrokeRA = new BasicStroke(1);
312        symbolSize = Config.getPref().getDouble("extrude.angle-symbol-radius", 8);
313        nodeDragWithoutCtrl = Config.getPref().getBoolean("extrude.drag-nodes-without-ctrl", false);
314        oldLineStroke = GuiHelper.getCustomizedStroke(Config.getPref().get("extrude.ctrl.stroke.old-line", "1"));
315        mainStroke = GuiHelper.getCustomizedStroke(Config.getPref().get("extrude.stroke.main", "3"));
316
317        ignoreSharedNodes = Config.getPref().getBoolean("extrude.ignore-shared-nodes", true);
318        dualAlignCheckboxMenuItem.getAction().setEnabled(true);
319        useRepeatedShortcut = Config.getPref().getBoolean("extrude.dualalign.toggleOnRepeatedX", true);
320        keepSegmentDirection = Config.getPref().getBoolean("extrude.dualalign.keep-segment-direction", true);
321    }
322
323    @Override
324    public void exitMode() {
325        MapFrame map = MainApplication.getMap();
326        map.mapView.removeMouseListener(this);
327        map.mapView.removeMouseMotionListener(this);
328        map.mapView.removeTemporaryLayer(this);
329        dualAlignCheckboxMenuItem.getAction().setEnabled(false);
330        map.keyDetector.removeKeyListener(this);
331        map.keyDetector.removeModifierExListener(this);
332        this.selectedNode = null;
333        this.selectedSegment = null;
334        this.lastCommandOnUndoStack = null;
335        super.exitMode();
336    }
337
338    // -------------------------------------------------------------------------
339    // Event handlers
340    // -------------------------------------------------------------------------
341
342    /**
343     * This method is called to indicate different modes via cursor when the Alt/Ctrl/Shift modifier is pressed,
344     */
345    @Override
346    public void modifiersExChanged(int modifiers) {
347        MapFrame map = MainApplication.getMap();
348        if (!MainApplication.isDisplayingMapView() || !map.mapView.isActiveLayerDrawable())
349            return;
350        updateKeyModifiersEx(modifiers);
351        if (mode == Mode.select) {
352            map.mapView.setNewCursor(ctrl ? cursorTranslate : alt ? cursorCreateNew : shift ? cursorCreateNodes : cursor, this);
353        }
354    }
355
356    @Override
357    public void doKeyPressed(KeyEvent e) {
358        // Do nothing
359    }
360
361    @Override
362    public void doKeyReleased(KeyEvent e) {
363        if (!dualAlignShortcut.isEvent(e) && !(useRepeatedShortcut && getShortcut().isEvent(e)))
364             return;
365        if (ignoreNextKeyRelease) {
366            ignoreNextKeyRelease = false;
367        } else {
368            toggleDualAlign();
369        }
370    }
371
372    /**
373     * Toggles dual alignment mode.
374     */
375    private void toggleDualAlign() {
376        dualAlignEnabled = !dualAlignEnabled;
377        dualAlignCheckboxMenuItem.setState(dualAlignEnabled);
378        updateStatusLine();
379    }
380
381    /**
382     * If the left mouse button is pressed over a segment or a node, switches
383     * to appropriate {@link #mode}, depending on Ctrl/Alt/Shift modifiers and
384     * {@link #dualAlignEnabled}.
385     * @param e current mouse event
386     */
387    @Override
388    public void mousePressed(MouseEvent e) {
389        MapFrame map = MainApplication.getMap();
390        if (!map.mapView.isActiveLayerVisible())
391            return;
392        if (Boolean.FALSE.equals(this.getValue("active")))
393            return;
394        if (e.getButton() != MouseEvent.BUTTON1)
395            return;
396
397        requestFocusInMapView();
398        updateKeyModifiers(e);
399
400        selectedNode = map.mapView.getNearestNode(e.getPoint(), OsmPrimitive::isSelectable);
401        selectedSegment = map.mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
402
403        // If nothing gets caught, stay in select mode
404        if (selectedSegment == null && selectedNode == null) return;
405        lastCommandOnUndoStack = UndoRedoHandler.getInstance().getLastCommand();
406
407        if (selectedNode != null) {
408            if (ctrl || nodeDragWithoutCtrl) {
409                movingNodeList = new ArrayList<>();
410                movingNodeList.add(selectedNode);
411                calculatePossibleDirectionsByNode();
412                if (possibleMoveDirections.isEmpty()) {
413                    // if no directions fould, do not enter dragging mode
414                    return;
415                }
416                mode = Mode.translate_node;
417                dualAlignActive = false;
418            }
419        } else {
420            // Otherwise switch to another mode
421            if (dualAlignEnabled && checkDualAlignConditions()) {
422                dualAlignActive = true;
423                calculatePossibleDirectionsForDualAlign();
424                dualAlignSegmentCollapsed = false;
425            } else {
426                dualAlignActive = false;
427                calculatePossibleDirectionsBySegment();
428            }
429            if (ctrl) {
430                mode = Mode.translate;
431                movingNodeList = new ArrayList<>();
432                movingNodeList.add(selectedSegment.getFirstNode());
433                movingNodeList.add(selectedSegment.getSecondNode());
434            } else if (alt) {
435                mode = Mode.create_new;
436                // create a new segment and then select and extrude the new segment
437                getLayerManager().getEditDataSet().setSelected(selectedSegment.getWay());
438                alwaysCreateNodes = true;
439            } else {
440                mode = Mode.extrude;
441                getLayerManager().getEditDataSet().setSelected(selectedSegment.getWay());
442                alwaysCreateNodes = shift;
443            }
444        }
445
446        // Signifies that nothing has happened yet
447        newN1en = null;
448        newN2en = null;
449        moveCommand = null;
450        moveCommand2 = null;
451
452        map.mapView.addTemporaryLayer(this);
453
454        updateStatusLine();
455        map.mapView.repaint();
456
457        // Make note of time pressed
458        mouseDownTime = System.currentTimeMillis();
459
460        // Make note of mouse position
461        initialMousePos = e.getPoint();
462   }
463
464    /**
465     * Performs action depending on what {@link #mode} we're in.
466     * @param e current mouse event
467     */
468    @Override
469    public void mouseDragged(MouseEvent e) {
470        MapView mapView = MainApplication.getMap().mapView;
471        if (!mapView.isActiveLayerVisible())
472            return;
473
474        // do not count anything as a drag if it lasts less than 100 milliseconds.
475        if (System.currentTimeMillis() - mouseDownTime < initialMoveDelay)
476            return;
477
478        if (mode == Mode.select) {
479            // Just sit tight and wait for mouse to be released.
480        } else {
481            //move, create new and extrude mode - move the selected segment
482
483            EastNorth mouseEn = mapView.getEastNorth(e.getPoint().x, e.getPoint().y);
484            EastNorth bestMovement = calculateBestMovementAndNewNodes(mouseEn);
485
486            mapView.setNewCursor(Cursor.MOVE_CURSOR, this);
487
488            if (dualAlignActive) {
489                if (mode == Mode.extrude || mode == Mode.create_new) {
490                    // nothing here
491                } else if (mode == Mode.translate) {
492                    EastNorth movement1 = newN1en.subtract(initialN1en);
493                    EastNorth movement2 = newN2en.subtract(initialN2en);
494                    // move nodes to new position
495                    if (moveCommand == null || moveCommand2 == null) {
496                        // make a new move commands
497                        moveCommand = new MoveCommand(movingNodeList.get(0), movement1.getX(), movement1.getY());
498                        moveCommand2 = new MoveCommand(movingNodeList.get(1), movement2.getX(), movement2.getY());
499                        Command c = new SequenceCommand(tr("Extrude Way"), moveCommand, moveCommand2);
500                        UndoRedoHandler.getInstance().add(c);
501                    } else {
502                        // reuse existing move commands
503                        moveCommand.moveAgainTo(movement1.getX(), movement1.getY());
504                        moveCommand2.moveAgainTo(movement2.getX(), movement2.getY());
505                    }
506                }
507            } else if (bestMovement != null) {
508                if (mode == Mode.extrude || mode == Mode.create_new) {
509                    //nothing here
510                } else if (mode == Mode.translate_node || mode == Mode.translate) {
511                    //move nodes to new position
512                    if (moveCommand == null) {
513                        //make a new move command
514                        moveCommand = new MoveCommand(new ArrayList<>(movingNodeList), bestMovement);
515                        UndoRedoHandler.getInstance().add(moveCommand);
516                    } else {
517                        //reuse existing move command
518                        moveCommand.moveAgainTo(bestMovement.getX(), bestMovement.getY());
519                    }
520                }
521            }
522
523            mapView.repaint();
524        }
525    }
526
527    /**
528     * Does anything that needs to be done, then switches back to select mode.
529     * @param e current mouse event
530     */
531    @Override
532    public void mouseReleased(MouseEvent e) {
533
534        MapView mapView = MainApplication.getMap().mapView;
535        if (!mapView.isActiveLayerVisible())
536            return;
537
538        if (mode == Mode.select) {
539            // Nothing to be done
540        } else {
541            if (mode == Mode.create_new) {
542                if (e.getPoint().distance(initialMousePos) > initialMoveThreshold && newN1en != null) {
543                    createNewRectangle();
544                }
545            } else if (mode == Mode.extrude) {
546                if (e.getClickCount() == 2 && e.getPoint().equals(initialMousePos)) {
547                    // double click adds a new node
548                    addNewNode(e);
549                } else if (e.getPoint().distance(initialMousePos) > initialMoveThreshold && newN1en != null && selectedSegment != null) {
550                    // main extrusion commands
551                    performExtrusion();
552                }
553            } else if (mode == Mode.translate || mode == Mode.translate_node) {
554                //Commit translate
555                //the move command is already committed in mouseDragged
556                joinNodesIfCollapsed(movingNodeList);
557            }
558            MainApplication.getMap().statusLine.setDist(getLayerManager().getEditDataSet().getSelectedWays());
559            MainApplication.getMap().statusLine.repaint();
560
561            updateKeyModifiers(e);
562            // Switch back into select mode
563            mapView.setNewCursor(ctrl ? cursorTranslate : alt ? cursorCreateNew : shift ? cursorCreateNodes : cursor, this);
564            mapView.removeTemporaryLayer(this);
565            selectedSegment = null;
566            lastCommandOnUndoStack = null;
567            moveCommand = null;
568            mode = Mode.select;
569            dualAlignSegmentCollapsed = false;
570            updateStatusLine();
571            mapView.repaint();
572        }
573    }
574
575    // -------------------------------------------------------------------------
576    // Custom methods
577    // -------------------------------------------------------------------------
578
579    /**
580     * Inserts node into nearby segment.
581     * @param e current mouse point
582     */
583    private static void addNewNode(MouseEvent e) {
584        // Should maybe do the same as in DrawAction and fetch all nearby segments?
585        MapView mapView = MainApplication.getMap().mapView;
586        WaySegment ws = mapView.getNearestWaySegment(e.getPoint(), OsmPrimitive::isSelectable);
587        if (ws != null) {
588            Node n = new Node(mapView.getLatLon(e.getX(), e.getY()));
589            EastNorth a = ws.getFirstNode().getEastNorth();
590            EastNorth b = ws.getSecondNode().getEastNorth();
591            n.setEastNorth(Geometry.closestPointToSegment(a, b, n.getEastNorth()));
592            Way wnew = new Way(ws.getWay());
593            wnew.addNode(ws.getLowerIndex() +1, n);
594            DataSet ds = ws.getWay().getDataSet();
595            UndoRedoHandler.getInstance().add(new SequenceCommand(tr("Add a new node to an existing way"),
596                    new AddCommand(ds, n), new ChangeNodesCommand(ds, ws.getWay(), wnew.getNodes())));
597            wnew.setNodes(null); // see #19885
598
599        }
600    }
601
602    /**
603     * Creates a new way that shares segment with selected way.
604     */
605    private void createNewRectangle() {
606        if (selectedSegment == null) return;
607        DataSet ds = getLayerManager().getEditDataSet();
608        // create a new rectangle
609        Collection<Command> cmds = new LinkedList<>();
610        Node third = new Node(newN2en);
611        Node fourth = new Node(newN1en);
612        Way wnew = new Way();
613        wnew.addNode(selectedSegment.getFirstNode());
614        wnew.addNode(selectedSegment.getSecondNode());
615        wnew.addNode(third);
616        if (!dualAlignSegmentCollapsed) {
617            // rectangle can degrade to triangle for dual alignment after collapsing
618            wnew.addNode(fourth);
619        }
620        // ... and close the way
621        wnew.addNode(selectedSegment.getFirstNode());
622        // undo support
623        cmds.add(new AddCommand(ds, third));
624        if (!dualAlignSegmentCollapsed) {
625            cmds.add(new AddCommand(ds, fourth));
626        }
627        cmds.add(new AddCommand(ds, wnew));
628        Command c = new SequenceCommand(tr("Extrude Way"), cmds);
629        UndoRedoHandler.getInstance().add(c);
630        ds.setSelected(wnew);
631    }
632
633    /**
634     * Does actual extrusion of {@link #selectedSegment}.
635     * Uses {@link #initialN1en}, {@link #initialN2en} saved in calculatePossibleDirections* call
636     * Uses {@link #newN1en}, {@link #newN2en} calculated by {@link #calculateBestMovementAndNewNodes}
637     */
638    private void performExtrusion() {
639        // sanity checks, see #23447 and #12870: don't try to extrude when user pressed undo
640        if (lastCommandOnUndoStack != UndoRedoHandler.getInstance().getLastCommand())
641            return;
642        DataSet ds = getLayerManager().getEditDataSet();
643        if (ds.getPrimitiveById(selectedSegment.getWay()) == null || !selectedSegment.isUsable())
644            return;
645
646        // create extrusion
647        Collection<Command> cmds = new LinkedList<>();
648        Way wnew = new Way(selectedSegment.getWay());
649        boolean wayWasModified = false;
650        boolean wayWasSingleSegment = wnew.getNodesCount() == 2;
651        int insertionPoint = selectedSegment.getUpperIndex();
652
653        //find if the new points overlap existing segments (in case of 90 degree angles)
654        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
655        boolean nodeOverlapsSegment = prevNode != null && Geometry.segmentsParallel(initialN1en, prevNode.getEastNorth(), initialN1en, newN1en);
656        // segmentAngleZero marks subset of nodeOverlapsSegment.
657        // nodeOverlapsSegment is true if angle between segments is 0 or PI, segmentAngleZero only if angle is 0
658        boolean segmentAngleZero = prevNode != null && Math.abs(Geometry.getCornerAngle(prevNode.getEastNorth(), initialN1en, newN1en)) < 1e-5;
659        boolean hasOtherWays = hasNodeOtherWays(selectedSegment.getFirstNode(), selectedSegment.getWay());
660        List<Node> changedNodes = new ArrayList<>();
661        if (nodeOverlapsSegment && !alwaysCreateNodes && !hasOtherWays) {
662            //move existing node
663            Node n1Old = selectedSegment.getFirstNode();
664            cmds.add(new MoveCommand(n1Old, ProjectionRegistry.getProjection().eastNorth2latlon(newN1en)));
665            changedNodes.add(n1Old);
666        } else if (ignoreSharedNodes && segmentAngleZero && !alwaysCreateNodes && hasOtherWays) {
667            // replace shared node with new one
668            Node n1Old = selectedSegment.getFirstNode();
669            Node n1New = new Node(ProjectionRegistry.getProjection().eastNorth2latlon(newN1en));
670            wnew.addNode(insertionPoint, n1New);
671            wnew.removeNode(n1Old);
672            wayWasModified = true;
673            cmds.add(new AddCommand(ds, n1New));
674            changedNodes.add(n1New);
675        } else {
676            //introduce new node
677            Node n1New = new Node(ProjectionRegistry.getProjection().eastNorth2latlon(newN1en));
678            wnew.addNode(insertionPoint, n1New);
679            wayWasModified = true;
680            insertionPoint++;
681            cmds.add(new AddCommand(ds, n1New));
682            changedNodes.add(n1New);
683        }
684
685        //find if the new points overlap existing segments (in case of 90 degree angles)
686        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
687        nodeOverlapsSegment = nextNode != null && Geometry.segmentsParallel(initialN2en, nextNode.getEastNorth(), initialN2en, newN2en);
688        segmentAngleZero = nextNode != null && Math.abs(Geometry.getCornerAngle(nextNode.getEastNorth(), initialN2en, newN2en)) < 1e-5;
689        hasOtherWays = hasNodeOtherWays(selectedSegment.getSecondNode(), selectedSegment.getWay());
690
691        if (nodeOverlapsSegment && !alwaysCreateNodes && !hasOtherWays) {
692            //move existing node
693            Node n2Old = selectedSegment.getSecondNode();
694            cmds.add(new MoveCommand(n2Old, ProjectionRegistry.getProjection().eastNorth2latlon(newN2en)));
695            changedNodes.add(n2Old);
696        } else if (ignoreSharedNodes && segmentAngleZero && !alwaysCreateNodes && hasOtherWays) {
697            // replace shared node with new one
698            Node n2Old = selectedSegment.getSecondNode();
699            Node n2New = new Node(ProjectionRegistry.getProjection().eastNorth2latlon(newN2en));
700            wnew.addNode(insertionPoint, n2New);
701            wnew.removeNode(n2Old);
702            wayWasModified = true;
703            cmds.add(new AddCommand(ds, n2New));
704            changedNodes.add(n2New);
705        } else {
706            //introduce new node
707            Node n2New = new Node(ProjectionRegistry.getProjection().eastNorth2latlon(newN2en));
708            wnew.addNode(insertionPoint, n2New);
709            wayWasModified = true;
710            cmds.add(new AddCommand(ds, n2New));
711            changedNodes.add(n2New);
712        }
713
714        //the way was a single segment, close the way
715        if (wayWasSingleSegment) {
716            wnew.addNode(selectedSegment.getFirstNode());
717            wayWasModified = true;
718        }
719        if (wayWasModified) {
720            // we only need to change the way if its node list was really modified
721            cmds.add(new ChangeNodesCommand(selectedSegment.getWay(), wnew.getNodes()));
722        }
723        wnew.setNodes(null); // see #19885
724        Command c = new SequenceCommand(tr("Extrude Way"), cmds);
725        UndoRedoHandler.getInstance().add(c);
726        joinNodesIfCollapsed(changedNodes);
727    }
728
729    private void joinNodesIfCollapsed(List<Node> changedNodes) {
730        if (!dualAlignActive || newN1en == null || newN2en == null) return;
731        if (newN1en.distance(newN2en) > 1e-6) return;
732        // If the dual alignment moved two nodes to the same point, merge them
733        Node targetNode = MergeNodesAction.selectTargetNode(changedNodes);
734        Node locNode = MergeNodesAction.selectTargetLocationNode(changedNodes);
735        Command mergeCmd = MergeNodesAction.mergeNodes(changedNodes, targetNode, locNode);
736        if (mergeCmd != null) {
737            UndoRedoHandler.getInstance().add(mergeCmd);
738        } else {
739            // undo extruding command itself
740            UndoRedoHandler.getInstance().undo();
741        }
742    }
743
744    /**
745     * This method tests if {@code node} has other ways apart from the given one.
746     * @param node node to test
747     * @param myWay way known to contain this node
748     * @return {@code true} if {@code node} belongs only to {@code myWay}, false if there are more ways.
749     */
750    private static boolean hasNodeOtherWays(Node node, Way myWay) {
751        return node.getReferrers().stream()
752                .anyMatch(p -> p instanceof Way && p.isUsable() && p != myWay);
753    }
754
755    /**
756     * Determines best movement from {@link #initialMousePos} to current mouse position,
757     * choosing one of the directions from {@link #possibleMoveDirections}.
758     * @param mouseEn current mouse position
759     * @return movement vector
760     */
761    private EastNorth calculateBestMovement(EastNorth mouseEn) {
762
763        EastNorth initialMouseEn = MainApplication.getMap().mapView.getEastNorth(initialMousePos.x, initialMousePos.y);
764        EastNorth mouseMovement = mouseEn.subtract(initialMouseEn);
765
766        double bestDistance = Double.POSITIVE_INFINITY;
767        EastNorth bestMovement = null;
768        activeMoveDirection = null;
769
770        //find the best movement direction and vector
771        for (ReferenceSegment direction : possibleMoveDirections) {
772            EastNorth movement = calculateSegmentOffset(initialN1en, initialN2en, direction.en, mouseEn);
773            if (movement == null) {
774                //if direction parallel to segment.
775                continue;
776            }
777
778            double distanceFromMouseMovement = movement.distance(mouseMovement);
779            if (bestDistance > distanceFromMouseMovement) {
780                bestDistance = distanceFromMouseMovement;
781                activeMoveDirection = direction;
782                bestMovement = movement;
783            }
784        }
785        return bestMovement;
786    }
787
788    /***
789     * This method calculates offset amount by which to move the given segment
790     * perpendicularly for it to be in line with mouse position.
791     * @param segmentP1 segment's first point
792     * @param segmentP2 segment's second point
793     * @param moveDirection direction of movement
794     * @param targetPos mouse position
795     * @return offset amount of P1 and P2.
796     */
797    private static EastNorth calculateSegmentOffset(EastNorth segmentP1, EastNorth segmentP2, EastNorth moveDirection,
798            EastNorth targetPos) {
799        EastNorth intersectionPoint;
800        if (segmentP1.distanceSq(segmentP2) > 1e-7) {
801            intersectionPoint = Geometry.getLineLineIntersection(segmentP1, segmentP2, targetPos, targetPos.add(moveDirection));
802        } else {
803            intersectionPoint = Geometry.closestPointToLine(targetPos, targetPos.add(moveDirection), segmentP1);
804        }
805
806        if (intersectionPoint == null)
807            return null;
808        else
809            //return distance form base to target position
810            return targetPos.subtract(intersectionPoint);
811    }
812
813    /**
814     * Gathers possible move directions - perpendicular to the selected segment
815     * and parallel to neighboring segments.
816     */
817    private void calculatePossibleDirectionsBySegment() {
818        // remember initial positions for segment nodes.
819        initialN1en = selectedSegment.getFirstNode().getEastNorth();
820        initialN2en = selectedSegment.getSecondNode().getEastNorth();
821
822        //add direction perpendicular to the selected segment
823        possibleMoveDirections = new ArrayList<>();
824        possibleMoveDirections.add(new ReferenceSegment(new EastNorth(
825                initialN1en.getY() - initialN2en.getY(),
826                initialN2en.getX() - initialN1en.getX()
827                ), initialN1en, initialN2en, true));
828
829
830        //add directions parallel to neighbor segments
831        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
832        if (prevNode != null) {
833            EastNorth en = prevNode.getEastNorth();
834            possibleMoveDirections.add(new ReferenceSegment(new EastNorth(
835                    initialN1en.getX() - en.getX(),
836                    initialN1en.getY() - en.getY()
837                    ), initialN1en, en, false));
838        }
839
840        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
841        if (nextNode != null) {
842            EastNorth en = nextNode.getEastNorth();
843            possibleMoveDirections.add(new ReferenceSegment(new EastNorth(
844                    initialN2en.getX() - en.getX(),
845                    initialN2en.getY() - en.getY()
846                    ), initialN2en, en, false));
847        }
848    }
849
850    /**
851     * Gathers possible move directions - along all adjacent segments.
852     */
853    private void calculatePossibleDirectionsByNode() {
854        // remember initial positions for segment nodes.
855        initialN1en = selectedNode.getEastNorth();
856        initialN2en = initialN1en;
857        possibleMoveDirections = new ArrayList<>();
858        for (OsmPrimitive p: selectedNode.getReferrers()) {
859            if (p instanceof Way && p.isUsable()) {
860                for (Node neighbor: ((Way) p).getNeighbours(selectedNode)) {
861                    EastNorth en = neighbor.getEastNorth();
862                    possibleMoveDirections.add(new ReferenceSegment(new EastNorth(
863                        initialN1en.getX() - en.getX(),
864                        initialN1en.getY() - en.getY()
865                    ), initialN1en, en, false));
866                }
867            }
868        }
869    }
870
871    /**
872     * Checks dual alignment conditions:
873     *  1. selected segment has both neighboring segments,
874     *  2. selected segment is not parallel with neighboring segments.
875     * @return {@code true} if dual alignment conditions are satisfied
876     */
877    private boolean checkDualAlignConditions() {
878        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
879        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
880        if (prevNode == null || nextNode == null) {
881            return false;
882        }
883
884        EastNorth n1en = selectedSegment.getFirstNode().getEastNorth();
885        EastNorth n2en = selectedSegment.getSecondNode().getEastNorth();
886        if (n1en.distance(prevNode.getEastNorth()) < 1e-4 ||
887            n2en.distance(nextNode.getEastNorth()) < 1e-4) {
888            return false;
889        }
890
891        boolean prevSegmentParallel = Geometry.segmentsParallel(n1en, prevNode.getEastNorth(), n1en, n2en);
892        boolean nextSegmentParallel = Geometry.segmentsParallel(n2en, nextNode.getEastNorth(), n1en, n2en);
893        return !prevSegmentParallel && !nextSegmentParallel;
894    }
895
896    /**
897     * Gathers possible move directions - perpendicular to the selected segment only.
898     * Neighboring segments go to {@link #dualAlignSegment1} and {@link #dualAlignSegment2}.
899     */
900    private void calculatePossibleDirectionsForDualAlign() {
901        // remember initial positions for segment nodes.
902        initialN1en = selectedSegment.getFirstNode().getEastNorth();
903        initialN2en = selectedSegment.getSecondNode().getEastNorth();
904
905        // add direction perpendicular to the selected segment
906        possibleMoveDirections = new ArrayList<>();
907        possibleMoveDirections.add(new ReferenceSegment(new EastNorth(
908                initialN1en.getY() - initialN2en.getY(),
909                initialN2en.getX() - initialN1en.getX()
910                ), initialN1en, initialN2en, true));
911
912        // set neighboring segments
913        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
914        if (prevNode != null) {
915            EastNorth prevNodeEn = prevNode.getEastNorth();
916            dualAlignSegment1 = new ReferenceSegment(new EastNorth(
917                initialN1en.getX() - prevNodeEn.getX(),
918                initialN1en.getY() - prevNodeEn.getY()
919                ), initialN1en, prevNodeEn, false);
920        }
921
922        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
923        if (nextNode != null) {
924            EastNorth nextNodeEn = nextNode.getEastNorth();
925            dualAlignSegment2 = new ReferenceSegment(new EastNorth(
926                initialN2en.getX() - nextNodeEn.getX(),
927                initialN2en.getY() - nextNodeEn.getY()
928                ), initialN2en, nextNodeEn, false);
929        }
930    }
931
932    /**
933     * Calculate newN1en, newN2en best suitable for given mouse coordinates
934     * For dual align, calculates positions of new nodes, aligning them to neighboring segments.
935     * Elsewhere, just adds the vetor returned by calculateBestMovement to {@link #initialN1en},  {@link #initialN2en}.
936     * @param mouseEn mouse coordinates
937     * @return best movement vector
938     */
939    private EastNorth calculateBestMovementAndNewNodes(EastNorth mouseEn) {
940        EastNorth bestMovement = calculateBestMovement(mouseEn);
941        EastNorth n1movedEn = initialN1en.add(bestMovement);
942        EastNorth n2movedEn;
943
944        // find out the movement distance, in metres
945        double distance = ProjectionRegistry.getProjection().eastNorth2latlon(initialN1en).greatCircleDistance(
946                (ILatLon) ProjectionRegistry.getProjection().eastNorth2latlon(n1movedEn));
947        MainApplication.getMap().statusLine.setDist(distance);
948        updateStatusLine();
949
950        if (dualAlignActive) {
951            // new positions of selected segment's nodes, without applying dual alignment
952            n1movedEn = initialN1en.add(bestMovement);
953            n2movedEn = initialN2en.add(bestMovement);
954
955            // calculate intersections of parallel shifted segment and the adjacent lines
956            newN1en = Geometry.getLineLineIntersection(n1movedEn, n2movedEn, dualAlignSegment1.p1, dualAlignSegment1.p2);
957            newN2en = Geometry.getLineLineIntersection(n1movedEn, n2movedEn, dualAlignSegment2.p1, dualAlignSegment2.p2);
958            if (newN1en == null || newN2en == null) return bestMovement;
959            if (keepSegmentDirection && isOppositeDirection(newN1en, newN2en, initialN1en, initialN2en)) {
960                EastNorth collapsedSegmentPosition = Geometry.getLineLineIntersection(dualAlignSegment1.p1, dualAlignSegment1.p2,
961                        dualAlignSegment2.p1, dualAlignSegment2.p2);
962                newN1en = collapsedSegmentPosition;
963                newN2en = collapsedSegmentPosition;
964                dualAlignSegmentCollapsed = true;
965            } else {
966                dualAlignSegmentCollapsed = false;
967            }
968        } else {
969            newN1en = n1movedEn;
970            newN2en = initialN2en.add(bestMovement);
971        }
972        return bestMovement;
973    }
974
975    /**
976     * Gets a node index from selected way before given index.
977     * @param index  index of current node
978     * @return index of previous node or <code>-1</code> if there are no nodes there.
979     */
980    private int getPreviousNodeIndex(int index) {
981        if (index > 0)
982            return index - 1;
983        else if (selectedSegment.getWay().isClosed())
984            return selectedSegment.getWay().getNodesCount() - 2;
985        else
986            return -1;
987    }
988
989    /**
990     * Gets a node from selected way before given index.
991     * @param index  index of current node
992     * @return previous node or <code>null</code> if there are no nodes there.
993     */
994    private Node getPreviousNode(int index) {
995        int indexPrev = getPreviousNodeIndex(index);
996        if (indexPrev >= 0)
997            return selectedSegment.getWay().getNode(indexPrev);
998        else
999            return null;
1000    }
1001
1002    /**
1003     * Gets a node index from selected way after given index.
1004     * @param index index of current node
1005     * @return index of next node or <code>-1</code> if there are no nodes there.
1006     */
1007    private int getNextNodeIndex(int index) {
1008        int count = selectedSegment.getWay().getNodesCount();
1009        if (index < count - 1)
1010            return index + 1;
1011        else if (selectedSegment.getWay().isClosed())
1012            return 1;
1013        else
1014            return -1;
1015    }
1016
1017    /**
1018     * Gets a node from selected way after given index.
1019     * @param index index of current node
1020     * @return next node or <code>null</code> if there are no nodes there.
1021     */
1022    private Node getNextNode(int index) {
1023        int indexNext = getNextNodeIndex(index);
1024        if (indexNext >= 0)
1025            return selectedSegment.getWay().getNode(indexNext);
1026        else
1027            return null;
1028    }
1029
1030    // -------------------------------------------------------------------------
1031    // paint methods
1032    // -------------------------------------------------------------------------
1033
1034    @Override
1035    public void paint(Graphics2D g, MapView mv, Bounds box) {
1036        Graphics2D g2 = g;
1037        if (mode == Mode.select) {
1038            // Nothing to do
1039        } else {
1040            if (newN1en != null) {
1041
1042                EastNorth p1 = initialN1en;
1043                EastNorth p2 = initialN2en;
1044                EastNorth p3 = newN1en;
1045                EastNorth p4 = newN2en;
1046
1047                Point2D normalUnitVector = activeMoveDirection != null ? getNormalUniVector() : null;
1048
1049                if (mode == Mode.extrude || mode == Mode.create_new) {
1050                    g2.setColor(mainColor);
1051                    g2.setStroke(mainStroke);
1052                    // Draw rectangle around new area.
1053                    MapViewPath b = new MapViewPath(mv);
1054                    b.moveTo(p1);
1055                    b.lineTo(p3);
1056                    b.lineTo(p4);
1057                    b.lineTo(p2);
1058                    b.lineTo(p1);
1059                    g2.draw(b);
1060
1061                    if (dualAlignActive) {
1062                        // Draw reference ways
1063                        drawReferenceSegment(g2, mv, dualAlignSegment1);
1064                        drawReferenceSegment(g2, mv, dualAlignSegment2);
1065                    } else if (activeMoveDirection != null && normalUnitVector != null) {
1066                        // Draw reference way
1067                        drawReferenceSegment(g2, mv, activeMoveDirection);
1068
1069                        // Draw right angle marker on first node position, only when moving at right angle
1070                        if (activeMoveDirection.perpendicular) {
1071                            // mirror RightAngle marker, so it is inside the extrude
1072                            double headingRefWS = activeMoveDirection.p1.heading(activeMoveDirection.p2);
1073                            double headingMoveDir = Math.atan2(normalUnitVector.getY(), normalUnitVector.getX());
1074                            double headingDiff = headingRefWS - headingMoveDir;
1075                            if (headingDiff < 0)
1076                                headingDiff += 2 * Math.PI;
1077                            boolean mirrorRA = Math.abs(headingDiff - Math.PI) > 1e-5;
1078                            Point pr1 = mv.getPoint(activeMoveDirection.p1);
1079                            drawAngleSymbol(g2, pr1, normalUnitVector, mirrorRA);
1080                        }
1081                    }
1082                } else if (mode == Mode.translate || mode == Mode.translate_node) {
1083                    g2.setColor(mainColor);
1084                    if (p1.distance(p2) < 3) {
1085                        g2.setStroke(mainStroke);
1086                        g2.draw(new MapViewPath(mv).shapeAround(p1, SymbolShape.CIRCLE, symbolSize));
1087                    } else {
1088                        g2.setStroke(oldLineStroke);
1089                        g2.draw(new MapViewPath(mv).moveTo(p1).lineTo(p2));
1090                    }
1091
1092                    if (dualAlignActive) {
1093                        // Draw reference ways
1094                        drawReferenceSegment(g2, mv, dualAlignSegment1);
1095                        drawReferenceSegment(g2, mv, dualAlignSegment2);
1096                    } else if (activeMoveDirection != null) {
1097
1098                        g2.setColor(helperColor);
1099                        g2.setStroke(helperStrokeDash);
1100                        // Draw a guideline along the normal.
1101                        Point2D centerpoint = mv.getPoint2D(p1.interpolate(p2, .5));
1102                        g2.draw(createSemiInfiniteLine(centerpoint, normalUnitVector, g2));
1103                        // Draw right angle marker on initial position, only when moving at right angle
1104                        if (activeMoveDirection.perpendicular) {
1105                            // EastNorth units per pixel
1106                            g2.setStroke(helperStrokeRA);
1107                            g2.setColor(mainColor);
1108                            drawAngleSymbol(g2, centerpoint, normalUnitVector, false);
1109                        }
1110                    }
1111                }
1112            }
1113            g2.setStroke(helperStrokeRA); // restore default stroke to prevent starnge occasional drawings
1114        }
1115    }
1116
1117    private Point2D getNormalUniVector() {
1118        double fac = 1.0 / activeMoveDirection.en.length();
1119        // mult by factor to get unit vector.
1120        Point2D normalUnitVector = new Point2D.Double(activeMoveDirection.en.getX() * fac, activeMoveDirection.en.getY() * fac);
1121
1122        // Check to see if our new N1 is in a positive direction with respect to the normalUnitVector.
1123        // Even if the x component is zero, we should still be able to discern using +0.0 and -0.0
1124        if (newN1en != null && ((newN1en.getX() > initialN1en.getX()) != (normalUnitVector.getX() > -0.0))) {
1125            // If not, use a sign-flipped version of the normalUnitVector.
1126            normalUnitVector = new Point2D.Double(-normalUnitVector.getX(), -normalUnitVector.getY());
1127        }
1128
1129        //HACK: swap Y, because the target pixels are top down, but EastNorth is bottom-up.
1130        //This is normally done by MapView.getPoint, but it does not work on vectors.
1131        normalUnitVector.setLocation(normalUnitVector.getX(), -normalUnitVector.getY());
1132        return normalUnitVector;
1133    }
1134
1135    /**
1136     * Determines if from1-to1 and from2-to2 vectors directions are opposite
1137     * @param from1 vector1 start
1138     * @param to1 vector1 end
1139     * @param from2 vector2 start
1140     * @param to2 vector2 end
1141     * @return true if from1-to1 and from2-to2 vectors directions are opposite
1142     */
1143    private static boolean isOppositeDirection(EastNorth from1, EastNorth to1, EastNorth from2, EastNorth to2) {
1144        return (from1.getX()-to1.getX())*(from2.getX()-to2.getX())
1145              +(from1.getY()-to1.getY())*(from2.getY()-to2.getY()) < 0;
1146    }
1147
1148    /**
1149     * Draws right angle symbol at specified position.
1150     * @param g2 the Graphics2D object used to draw on
1151     * @param center center point of angle
1152     * @param normal vector of normal
1153     * @param mirror {@code true} if symbol should be mirrored by the normal
1154     */
1155    private void drawAngleSymbol(Graphics2D g2, Point2D center, Point2D normal, boolean mirror) {
1156        // EastNorth units per pixel
1157        double factor = 1.0/g2.getTransform().getScaleX();
1158        double raoffsetx = symbolSize*factor*normal.getX();
1159        double raoffsety = symbolSize*factor*normal.getY();
1160
1161        final double cx = center.getX();
1162        final double cy = center.getY();
1163        double k = mirror ? -1 : 1;
1164        Point2D ra1 = new Point2D.Double(cx + raoffsetx, cy + raoffsety);
1165        Point2D ra3 = new Point2D.Double(cx - raoffsety*k, cy + raoffsetx*k);
1166        Point2D ra2 = new Point2D.Double(ra1.getX() - raoffsety*k, ra1.getY() + raoffsetx*k);
1167
1168        GeneralPath ra = new GeneralPath();
1169        ra.moveTo((float) ra1.getX(), (float) ra1.getY());
1170        ra.lineTo((float) ra2.getX(), (float) ra2.getY());
1171        ra.lineTo((float) ra3.getX(), (float) ra3.getY());
1172        g2.setStroke(helperStrokeRA);
1173        g2.draw(ra);
1174    }
1175
1176    /**
1177     * Draws given reference segment.
1178     * @param g2 the Graphics2D object used to draw on
1179     * @param mv map view
1180     * @param seg the reference segment
1181     */
1182    private void drawReferenceSegment(Graphics2D g2, MapView mv, ReferenceSegment seg) {
1183        g2.setColor(helperColor);
1184        g2.setStroke(helperStrokeDash);
1185        g2.draw(new MapViewPath(mv).moveTo(seg.p1).lineTo(seg.p2));
1186    }
1187
1188    /**
1189     * Creates a new Line that extends off the edge of the viewport in one direction
1190     * @param start The start point of the line
1191     * @param unitvector A unit vector denoting the direction of the line
1192     * @param g the Graphics2D object  it will be used on
1193     * @return created line
1194     */
1195    private static Line2D createSemiInfiniteLine(Point2D start, Point2D unitvector, Graphics2D g) {
1196        Rectangle bounds = g.getClipBounds();
1197        try {
1198            AffineTransform invtrans = g.getTransform().createInverse();
1199            Point2D widthpoint = invtrans.deltaTransform(new Point2D.Double(bounds.width, 0), null);
1200            Point2D heightpoint = invtrans.deltaTransform(new Point2D.Double(0, bounds.height), null);
1201
1202            // Here we should end up with a gross overestimate of the maximum viewport diagonal in what
1203            // Graphics2D calls 'user space'. Essentially a manhattan distance of manhattan distances.
1204            // This can be used as a safe length of line to generate which will always go off-viewport.
1205            double linelength = Math.abs(widthpoint.getX()) + Math.abs(widthpoint.getY())
1206                    + Math.abs(heightpoint.getX()) + Math.abs(heightpoint.getY());
1207
1208            return new Line2D.Double(start, new Point2D.Double(start.getX() + (unitvector.getX() * linelength), start.getY()
1209                    + (unitvector.getY() * linelength)));
1210        } catch (NoninvertibleTransformException e) {
1211            Logging.debug(e);
1212            return new Line2D.Double(start, new Point2D.Double(start.getX() + (unitvector.getX() * 10), start.getY()
1213                    + (unitvector.getY() * 10)));
1214        }
1215    }
1216}