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