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}