Index: applications/editors/josm/plugins/utilsplugin2/README
===================================================================
--- applications/editors/josm/plugins/utilsplugin2/README (revision 27617)
+++ applications/editors/josm/plugins/utilsplugin2/README (revision 27618)
@@ -12,4 +12,6 @@
* Selection actions (by akks)
+ * Curves - Draw Arc (by olejorgenb)
+
* Paste Relations, Replace Geometry and other actions (by Zverik)
Index: applications/editors/josm/plugins/utilsplugin2/images_nodist/circlearc.svg
===================================================================
--- applications/editors/josm/plugins/utilsplugin2/images_nodist/circlearc.svg (revision 27618)
+++ applications/editors/josm/plugins/utilsplugin2/images_nodist/circlearc.svg (revision 27618)
@@ -0,0 +1,281 @@
+
+
+
+
Index: applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/UtilsPlugin2.java
===================================================================
--- applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/UtilsPlugin2.java (revision 27617)
+++ applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/UtilsPlugin2.java (revision 27618)
@@ -12,4 +12,5 @@
import utilsplugin2.selection.*;
import utilsplugin2.dumbutils.*;
+import utilsplugin2.curves.*;
import org.openstreetmap.josm.Main;
@@ -51,4 +52,6 @@
JMenuItem selectURL;
+
+ JMenuItem drawArc;
public UtilsPlugin2(PluginInformation info) {
@@ -89,5 +92,5 @@
selectURL = MainMenu.add(toolsMenu, new ChooseURLAction());
-
+ drawArc = MainMenu.add(toolsMenu, new CurveAction());
}
@@ -122,5 +125,8 @@
selectURL.setEnabled(enabled);
allInside.setEnabled(enabled);
+
+ drawArc.setEnabled(enabled);
}
+
@Override
public PreferenceSetting getPreferenceSetting() {
Index: applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/curves/CircleArcMaker.java
===================================================================
--- applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/curves/CircleArcMaker.java (revision 27618)
+++ applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/curves/CircleArcMaker.java (revision 27618)
@@ -0,0 +1,347 @@
+// License: GPL. Copyright 2011 by Ole Jørgen Brønner
+package utilsplugin2.curves;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.openstreetmap.josm.command.AddCommand;
+import org.openstreetmap.josm.command.ChangeCommand;
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Way;
+
+public class CircleArcMaker {
+ public static Collection doCircleArc(List selectedNodes, List selectedWays, int angleSeparation) {
+ Collection cmds = new LinkedList();
+
+ //// Decides which nodes to use as anchors based on selection
+ /*
+ * Rules goes like this:
+ * If there are selected ways, at least one of these are used as target ways for the arc.
+ * Selected ways override selected nodes. If nodes not part of the ways are selected they're ignored.
+ *
+ * When existing ways are reused for the arc, all ways overlapping these are transformed too.
+ *
+ * 1. Exactly 3 nodes selected:
+ * Use these nodes.
+ * - No way selected: create a new way.
+ * 2. Exactly 1 node selected, node part of exactly 1 way with 3 or more nodes:
+ * Node selected used as first node, consequent nodes in the way's direction used as the rest.
+ * - Reversed if not enough nodes in forward direction
+ * - Selected node used as middle node its the middle node in a 3 node way
+ * - Parent way used
+ */
+
+ //// Anchor nodes
+ Node n1 = null, n2 = null, n3 = null;
+
+ if (false) {
+ int nodeCount = selectedNodes.size();
+ int wayCount = selectedWays.size();
+
+ // TODO: filter garbage nodes based on selected ways
+
+ // Never interested in more than 3 nodes. Nodes prioritized by reverse selection order, but keep their order.
+ // TODO: replace by helper function (eg. getPostFixList(int count))
+ Node[] nodesOfInterest = new Node[3];
+ int nodesOfInterestCount = Math.min(nodeCount, 3);
+ for (int i = nodesOfInterestCount - 1; i >= 0; i--) {
+ nodesOfInterest[i] = selectedNodes.get(nodeCount - 1 - i);
+ }
+ }
+
+ Set targetWays = new HashSet();
+
+ boolean nodesHasBeenChoosen = false;
+ if (selectedNodes.size() == 3) {
+ Iterator nodeIter = selectedNodes.iterator();
+ n1 = nodeIter.next();
+ n2 = nodeIter.next();
+ n3 = nodeIter.next();
+ nodesHasBeenChoosen = true;
+ if (selectedWays.isEmpty()) { // Create a brand new way
+ Way newWay = new Way();
+ targetWays.add(newWay);
+ cmds.add(new AddCommand(newWay));
+ newWay.addNode(n1);
+ newWay.addNode(n2);
+ newWay.addNode(n3);
+ }
+ }
+ if (selectedWays.isEmpty() == false) {
+ // TODO: use only two nodes inferring the orientation from the parent way.
+
+ if (nodesHasBeenChoosen == false) {
+ // Use the three last nodes in the way as anchors. This is intended to be used with the
+ // built in draw mode
+ Way w = selectedWays.iterator().next(); //TODO: select last selected way instead
+ int nodeCount = w.getNodesCount();
+ if (nodeCount < 3)
+ return null;
+ n3 = w.getNode(nodeCount - 1);
+ n2 = w.getNode(nodeCount - 2);
+ n1 = w.getNode(nodeCount - 3);
+ nodesHasBeenChoosen = true;
+ }
+ targetWays.addAll(OsmPrimitive.getFilteredList(n1.getReferrers(), Way.class));
+ targetWays.addAll(OsmPrimitive.getFilteredList(n2.getReferrers(), Way.class));
+ targetWays.addAll(OsmPrimitive.getFilteredList(n3.getReferrers(), Way.class));
+ // for(Way w : selectedWays) {
+ // targetWays.add(w);
+ // }
+
+ }
+ if (nodesHasBeenChoosen == false) {
+ return null;
+ }
+
+
+ EastNorth p1 = n1.getEastNorth();
+ EastNorth p2 = n2.getEastNorth();
+ EastNorth p3 = n3.getEastNorth();
+ // TODO: Check that the points are distinct
+
+ // // Calculate the new points in the arc
+ ReturnValue p2Index = new ReturnValue();
+ List points = circleArcPoints(p1, p2, p3, angleSeparation, false, p2Index);
+
+ //// Create the new arc nodes. Insert anchor nodes at correct positions.
+ List arcNodes = new ArrayList(points.size());
+ arcNodes.add(n1);
+ {
+ int i = 1;
+ for (EastNorth p : slice(points, 1, -2)) {
+ // if (p == p2) {
+ if (i == p2Index.value) {
+ Node n2new = new Node(n2);
+ n2new.setEastNorth(p);
+ arcNodes.add(n2); // add the original n2, or else we can't find it in the target ways
+ cmds.add(new ChangeCommand(n2, n2new));
+ } else {
+ Node n = new Node(p);
+ arcNodes.add(n);
+ cmds.add(new AddCommand(n));
+ }
+ i++;
+ }
+ }
+ arcNodes.add(n3);
+
+ Node[] anchorNodes = { n1, n2, n3 };
+ //// "Fuse" the arc with all target ways
+ fuseArc(anchorNodes, arcNodes, targetWays, cmds);
+
+ return cmds;
+ }
+
+ private static void fuseArc(Node[] anchorNodes, List arcNodes, Set targetWays, Collection cmds) {
+
+ for (Way originalTw : targetWays) {
+ Way tw = new Way(originalTw);
+ boolean didChangeTw = false;
+ /// Do one segment at the time (so ways only sharing one segment is fused too)
+ for (int a = 0; a < 2; a++) {
+ int anchorBi = arcNodes.indexOf(anchorNodes[a]); // TODO: optimize away
+ int anchorEi = arcNodes.indexOf(anchorNodes[a + 1]);
+ /// Find the anchor node indices in current target way
+ int bi = -1, ei = -1;
+ int i = -1;
+ // Caution: nodes might appear multiple times. For now only handle simple closed ways
+ for (Node n : tw.getNodes()) {
+ i++;
+ // We look for the first anchor node. The next should be directly to the left or right.
+ // Exception when the way is closed
+ if (n == anchorNodes[a]) {
+ bi = i;
+ Node otherAnchor = anchorNodes[a + 1];
+ if (i > 0 && tw.getNode(i - 1) == otherAnchor) {
+ ei = i - 1;
+ } else if (i < (tw.getNodesCount() - 1) && tw.getNode(i + 1) == otherAnchor) {
+ ei = i + 1;
+ } else {
+ continue; // this can happen with closed ways. Continue searching for the correct index
+ }
+ break;
+ }
+ }
+ if (bi == -1 || ei == -1) {
+ continue; // this segment is not part of the target way
+ }
+ didChangeTw = true;
+
+ /// Insert the nodes of this segment
+ // Direction of target way relative to the arc node order
+ int twDirection = ei > bi ? 1 : 0;
+ int anchorI = anchorBi + 1; // don't insert the anchor nodes again
+ int twI = bi + (twDirection == 1 ? 1 : 0); // TODO: explain
+ while (anchorI < anchorEi) {
+ tw.addNode(twI, arcNodes.get(anchorI));
+ anchorI++;
+ twI += twDirection;
+ }
+ }
+ if (didChangeTw)
+ cmds.add(new ChangeCommand(originalTw, tw));
+ }
+ }
+
+ /**
+ * Return a list of coordinates lying an the circle arc determined by n1, n2 and n3.
+ * The order of the list and which of the 3 possible arcs to construct are given by the order of n1, n2, n3
+ *
+ * @param includeAnchors include the anchorpoints in the list. The original objects will be used, not copies.
+ * If {@code false}, p2 will be replaced by the closest arcpoint.
+ * @param anchor2Index if non-null, it's value will be set to p2's index in the returned list.
+ * @param angleSparation maximum angle separation between the arc points
+ */
+ private static List circleArcPoints(EastNorth p1, EastNorth p2, EastNorth p3,
+ int angleSeparation, boolean includeAnchors, ReturnValue anchor2Index) {
+
+ // triangle: three single nodes needed or a way with three nodes
+
+ // let's get some shorter names
+ double x1 = p1.east();
+ double y1 = p1.north();
+ double x2 = p2.east();
+ double y2 = p2.north();
+ double x3 = p3.east();
+ double y3 = p3.north();
+
+ // calculate the center (xc,yc)
+ double s = 0.5 * ((x2 - x3) * (x1 - x3) - (y2 - y3) * (y3 - y1));
+ double sUnder = (x1 - x2) * (y3 - y1) - (y2 - y1) * (x1 - x3);
+
+ assert (sUnder == 0);
+
+ s /= sUnder;
+
+ double xc = 0.5 * (x1 + x2) + s * (y2 - y1);
+ double yc = 0.5 * (y1 + y2) + s * (x1 - x2);
+
+ // calculate the radius (r)
+ double r = Math.sqrt(Math.pow(xc - x1, 2) + Math.pow(yc - y1, 2));
+
+ // The angles of the anchor points relative to the center
+ double realA1 = calcang(xc, yc, x1, y1);
+ double realA2 = calcang(xc, yc, x2, y2);
+ double realA3 = calcang(xc, yc, x3, y3);
+
+ double startAngle = realA1;
+ // Transform the angles to get a consistent starting point
+ double a1 = 0;
+ double a2 = normalizeAngle(realA2 - startAngle);
+ double a3 = normalizeAngle(realA3 - startAngle);
+ int direction = a3 > a2 ? 1 : -1;
+
+ double radialLength = 0;
+ if (direction == 1) { // counter clockwise
+ radialLength = a3;
+ } else { // clockwise
+ radialLength = Math.PI * 2 - a3;
+ // make the angles consistent with the direction.
+ a2 = (Math.PI * 2 - a2);
+ a3 = (Math.PI * 2 - a3);
+ }
+ int numberOfNodesInArc = Math.max((int) Math.ceil((radialLength / Math.PI) * 180 / angleSeparation)+1,
+ 3);
+ List points = new ArrayList(numberOfNodesInArc);
+
+ // Calculate the circle points in order
+ double stepLength = radialLength / (numberOfNodesInArc-1);
+ // Determine closest index to p2
+
+ int indexJustBeforeP2 = (int) Math.floor(a2 / stepLength);
+ int closestIndexToP2 = indexJustBeforeP2;
+ if ((a2 - indexJustBeforeP2 * stepLength) > ((indexJustBeforeP2 + 1) * stepLength - a2)) {
+ closestIndexToP2 = indexJustBeforeP2 + 1;
+ }
+ // can't merge with end node
+ if (closestIndexToP2 == numberOfNodesInArc - 1) {
+ closestIndexToP2--;
+ } else if (closestIndexToP2 == 0) {
+ closestIndexToP2++;
+ }
+ assert (closestIndexToP2 != 0);
+
+ double a = direction * (stepLength);
+ points.add(p1);
+ if (indexJustBeforeP2 == 0 && includeAnchors) {
+ points.add(p2);
+ }
+ // i is ahead of the real index by one, since we need to be ahead in the angle calculation
+ for (int i = 2; i < numberOfNodesInArc; i++) {
+ double nextA = direction * (i * stepLength);
+ double realAngle = a + startAngle;
+ double x = xc + r * Math.cos(realAngle);
+ double y = yc + r * Math.sin(realAngle);
+
+ points.add(new EastNorth(x, y));
+ if (i - 1 == indexJustBeforeP2 && includeAnchors) {
+ points.add(p2);
+ }
+ a = nextA;
+ }
+ points.add(p3);
+ if (anchor2Index != null) {
+ anchor2Index.value = closestIndexToP2;
+ }
+ return points;
+ }
+
+ // gah... why can't java support "reverse indices"?
+ private static List slice(List list, int from, int to) {
+ if (to < 0)
+ to += list.size() + 1;
+ return list.subList(from, to);
+ }
+
+ /**
+ * Normalizes {@code a} so it is between 0 and 2 PI
+ */
+ private static double normalizeAngle(double angle) {
+ double PI2 = Math.PI * 2;
+ if (angle < 0) {
+ angle = angle + (Math.floor(-angle / PI2) + 1) * PI2;
+ } else if (angle >= PI2) {
+ angle = angle - Math.floor(angle / PI2) * PI2;
+ }
+ return angle;
+ }
+
+ private static double calcang(double xc, double yc, double x, double y) {
+ // calculate the angle from xc|yc to x|y
+ if (xc == x && yc == y)
+ return 0; // actually invalid, but we won't have this case in this context
+ double yd = Math.abs(y - yc);
+ if (yd == 0 && xc < x)
+ return 0;
+ if (yd == 0 && xc > x)
+ return Math.PI;
+ double xd = Math.abs(x - xc);
+ double a = Math.atan2(xd, yd);
+ if (y > yc) {
+ a = Math.PI - a;
+ }
+ if (x < xc) {
+ a = -a;
+ }
+ a = 1.5 * Math.PI + a;
+ if (a < 0) {
+ a += 2 * Math.PI;
+ }
+ if (a >= 2 * Math.PI) {
+ a -= 2 * Math.PI;
+ }
+ return a;
+ }
+ public static class ReturnValue {
+ public T value;
+ }
+}
Index: applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/curves/CurveAction.java
===================================================================
--- applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/curves/CurveAction.java (revision 27618)
+++ applications/editors/josm/plugins/utilsplugin2/src/utilsplugin2/curves/CurveAction.java (revision 27618)
@@ -0,0 +1,81 @@
+// License: GPL. Copyright 2011 by Ole Jørgen Brønner
+package utilsplugin2.curves;
+
+import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.KeyEvent;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.JosmAction;
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.command.SequenceCommand;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.tools.Shortcut;
+
+// TODO: investigate splines
+
+public class CurveAction extends JosmAction {
+
+ private static final long serialVersionUID = 1L;
+
+ private int angleSeparation = -1;
+
+ public CurveAction() {
+ super(tr("Circle arc"), "circlearc", tr("Create a circle arc"),
+ Shortcut.registerShortcut("tools:createcurve", tr("Tool: {0}", tr("Create a circle arc")), KeyEvent.VK_C,
+ Shortcut.GROUP_EDIT, Shortcut.SHIFT_DEFAULT), true);
+ putValue("help", ht("/Action/CreateCircleArc"));
+ updatePreferences();
+ }
+
+ private void updatePreferences() {
+ // @formatter:off
+ angleSeparation = Main.pref.getInteger(prefKey("circlearc.angle-separation"), 20);
+ // @formatter:on
+ }
+
+ private String prefKey(String subKey) {
+ return "curves." + subKey;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ if (!isEnabled())
+ return;
+
+ updatePreferences();
+
+ List selectedNodes = new ArrayList(getCurrentDataSet().getSelectedNodes());
+ List selectedWays = new ArrayList(getCurrentDataSet().getSelectedWays());
+
+ // Collection cmds = doSpline(selectedNodes, selectedWays);
+ Collection cmds = CircleArcMaker.doCircleArc(selectedNodes, selectedWays, angleSeparation);
+ if (cmds != null)
+ Main.main.undoRedo.add(new SequenceCommand("Create a curve", cmds));
+ }
+
+ @Override
+ protected void updateEnabledState() {
+ if (getCurrentDataSet() == null) {
+ setEnabled(false);
+ } else {
+ updateEnabledState(getCurrentDataSet().getSelected());
+ }
+ }
+
+ @Override
+ protected void updateEnabledState(Collection selection) {
+ setEnabled(selection != null && !selection.isEmpty());
+ }
+
+ public static void main(String[] args) {
+ }
+
+}