Index: /trunk/images_nodist/multipoly_create.svg
===================================================================
--- /trunk/images_nodist/multipoly_create.svg (revision 3704)
+++ /trunk/images_nodist/multipoly_create.svg (revision 3704)
@@ -0,0 +1,198 @@
+
+
+
+
Index: /trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java
===================================================================
--- /trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java (revision 3704)
+++ /trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java (revision 3704)
@@ -0,0 +1,226 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.actions;
+
+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.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.JOptionPane;
+
+import javax.swing.SwingUtilities;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.command.AddCommand;
+import org.openstreetmap.josm.command.ChangePropertyCommand;
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.command.SequenceCommand;
+import org.openstreetmap.josm.data.osm.MultipolygonCreate;
+import org.openstreetmap.josm.data.osm.MultipolygonCreate.JoinedPolygon;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
+import org.openstreetmap.josm.tools.Shortcut;
+
+/**
+ * Create multipolygon from selected ways automatically.
+ *
+ * New relation with type=multipolygon is created
+ *
+ * If one or more of ways is already in relation with type=multipolygon or the
+ * way is not closed, then error is reported and no relation is created
+ *
+ * The "inner" and "outer" roles are guessed automatically. First, bbox is
+ * calculated for each way. then the largest area is assumed to be outside and
+ * the rest inside. In cases with one "outside" area and several cut-ins, the
+ * guess should be always good ... In more complex (multiple outer areas) or
+ * buggy (inner and outer ways intersect) scenarios the result is likely to be
+ * wrong.
+ */
+public class CreateMultipolygonAction extends JosmAction {
+
+ public CreateMultipolygonAction() {
+ super(tr("Create multipolygon"), "multipoly_create", tr("Create multipolygon."),
+ Shortcut.registerShortcut("tools:multipoly", tr("Tool: {0}", tr("Create multipolygon")),
+ KeyEvent.VK_A, Shortcut.GROUP_EDIT, Shortcut.SHIFT_DEFAULT), true);
+ }
+ /**
+ * The action button has been clicked
+ *
+ * @param e Action Event
+ */
+ public void actionPerformed(ActionEvent e) {
+ if (Main.main.getEditLayer() == null) {
+ JOptionPane.showMessageDialog(Main.parent, tr("No data loaded."));
+ return;
+ }
+
+ Collection selectedWays = Main.main.getCurrentDataSet().getSelectedWays();
+
+ if (selectedWays.size() < 1) {
+ // Sometimes it make sense creating multipoly of only one way (so it will form outer way)
+ // and then splitting the way later (so there are multiple ways forming outer way)
+ JOptionPane.showMessageDialog(Main.parent, tr("You must select at least one way."));
+ return;
+ }
+
+ MultipolygonCreate polygon = this.analyzeWays(selectedWays);
+
+ if (polygon == null)
+ return; //could not make multipolygon.
+
+ final Relation relation = this.createRelation(polygon);
+
+ if (Main.pref.getBoolean("multipoly.show-relation-editor", false)) {
+ //Open relation edit window, if set up in preferences
+ RelationEditor editor = RelationEditor.getEditor(Main.main.getEditLayer(), relation, null);
+
+ editor.setModal(true);
+ editor.setVisible(true);
+
+ //TODO: cannot get the resulting relation from RelationEditor :(.
+ /*
+ if (relationCountBefore < relationCountAfter) {
+ //relation saved, clean up the tags
+ List list = this.removeTagsFromInnerWays(relation);
+ if (list.size() > 0)
+ {
+ Main.main.undoRedo.add(new SequenceCommand(tr("Remove tags from multipolygon inner ways"), list));
+ }
+ }
+ */
+
+ } else {
+ //Just add the relation
+ List list = this.removeTagsFromInnerWays(relation);
+ list.add(new AddCommand(relation));
+ Main.main.undoRedo.add(new SequenceCommand(tr("Create multipolygon"), list));
+ Main.map.relationListDialog.unfurlDialog();
+ // Use 'SwingUtilities.invokeLater' to make sure the relationListDialog
+ // knows about the new relation before we try to select it.
+ // (Yes, we are already in event dispatch thread. But DatasetEventManager
+ // uses 'SwingUtilities.invokeLater' to fire events so we have to do
+ // the same.)
+ SwingUtilities.invokeLater(new Runnable() {
+ public void run() {
+ Main.map.relationListDialog.selectRelation(relation);
+ }
+ });
+ }
+
+
+ }
+
+ /** Enable this action only if something is selected */
+ @Override protected void updateEnabledState() {
+ if (getCurrentDataSet() == null) {
+ setEnabled(false);
+ } else {
+ updateEnabledState(getCurrentDataSet().getSelected());
+ }
+ }
+
+ /** Enable this action only if something is selected */
+ @Override protected void updateEnabledState(Collection < ? extends OsmPrimitive > selection) {
+ setEnabled(selection != null && !selection.isEmpty());
+ }
+
+ /**
+ * This method analyzes ways and creates multipolygon.
+ * @param selectedWays
+ * @return null, if there was a problem with the ways.
+ */
+ private MultipolygonCreate analyzeWays(Collection < Way > selectedWays) {
+
+ MultipolygonCreate pol = new MultipolygonCreate();
+ String error = pol.makeFromWays(selectedWays);
+
+ if (error != null) {
+ JOptionPane.showMessageDialog(Main.parent, error);
+ return null;
+ } else {
+ return pol;
+ }
+ }
+
+ /**
+ * Builds a relation from polygon ways.
+ * @param pol
+ * @return
+ */
+ private Relation createRelation(MultipolygonCreate pol) {
+ // Create new relation
+ Relation rel = new Relation();
+ rel.put("type", "multipolygon");
+ // Add ways to it
+ for (JoinedPolygon jway:pol.outerWays) {
+ for (Way way:jway.ways) {
+ rel.addMember(new RelationMember("outer", way));
+ }
+ }
+
+ for (JoinedPolygon jway:pol.innerWays) {
+ for (Way way:jway.ways) {
+ rel.addMember(new RelationMember("inner", way));
+ }
+ }
+ return rel;
+ }
+
+ /**
+ * This method removes tags/value pairs from inner ways that are present in relation or outer ways.
+ * @param relation
+ */
+ private List removeTagsFromInnerWays(Relation relation) {
+ Map values = new HashMap();
+
+ if (relation.hasKeys()){
+ for(String key: relation.keySet()) {
+ values.put(key, relation.get(key));
+ }
+ }
+
+ List innerWays = new ArrayList();
+
+ for (RelationMember m: relation.getMembers()) {
+
+ if (m.hasRole() && m.getRole() == "inner" && m.isWay() && m.getWay().hasKeys()) {
+ innerWays.add(m.getWay());
+ }
+
+ if (m.hasRole() && m.getRole() == "outer" && m.isWay() && m.getWay().hasKeys()) {
+ Way way = m.getWay();
+ for (String key: way.keySet()) {
+ if (!values.containsKey(key)) { //relation values take precedence
+ values.put(key, way.get(key));
+ }
+ }
+ }
+ }
+
+ List commands = new ArrayList();
+
+ for(String key: values.keySet()) {
+ List affectedWays = new ArrayList();
+ String value = values.get(key);
+
+ for (Way way: innerWays) {
+ if (value.equals(way.get(key))) {
+ affectedWays.add(way);
+ }
+ }
+
+ if (affectedWays.size() > 0) {
+ commands.add(new ChangePropertyCommand(affectedWays, key, null));
+ }
+ }
+
+ return commands;
+ }
+}
Index: /trunk/src/org/openstreetmap/josm/data/osm/MultipolygonCreate.java
===================================================================
--- /trunk/src/org/openstreetmap/josm/data/osm/MultipolygonCreate.java (revision 3704)
+++ /trunk/src/org/openstreetmap/josm/data/osm/MultipolygonCreate.java (revision 3704)
@@ -0,0 +1,277 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.osm;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.openstreetmap.josm.tools.Geometry;
+import org.openstreetmap.josm.tools.Geometry.PolygonIntersection;
+import org.openstreetmap.josm.tools.MultiMap;
+
+public class MultipolygonCreate {
+
+ /**
+ * Represents one polygon that consists of multiple ways.
+ * @author Viesturs
+ *
+ */
+ public static class JoinedPolygon {
+ public final List ways;
+ public final List reversed;
+ public final List nodes;
+
+ public JoinedPolygon(List ways, List reversed) {
+ this.ways = ways;
+ this.reversed = reversed;
+ this.nodes = this.getNodes();
+ }
+
+ /**
+ * Creates a polygon from single way.
+ * @param way
+ */
+ public JoinedPolygon(Way way) {
+ this.ways = Collections.singletonList(way);
+ this.reversed = Collections.singletonList(Boolean.FALSE);
+ this.nodes = this.getNodes();
+ }
+
+
+ /**
+ * Builds a list of nodes for this polygon. First node is not duplicated as last node.
+ * @return
+ */
+ private List getNodes() {
+ List nodes = new ArrayList();
+
+ for(int waypos = 0; waypos < this.ways.size(); waypos ++) {
+ Way way = this.ways.get(waypos);
+ boolean reversed = this.reversed.get(waypos).booleanValue();
+
+ if (!reversed){
+ for (int pos = 0; pos < way.getNodesCount() - 1; pos++) {
+ nodes.add(way.getNode(pos));
+ }
+ }
+ else {
+ for (int pos = way.getNodesCount() - 1; pos > 0; pos--) {
+ nodes.add(way.getNode(pos));
+ }
+ }
+ }
+
+ return nodes;
+ }
+ }
+
+
+ /**
+ * Helper storage class for finding findOuterWays
+ * @author viesturs
+ */
+ static class PolygonLevel {
+ public final int level; //nesting level , even for outer, odd for inner polygons.
+ public final JoinedPolygon outerWay;
+
+ public List innerWays;
+
+ public PolygonLevel(JoinedPolygon _pol, int _level) {
+ this.outerWay = _pol;
+ this.level = _level;
+ this.innerWays = new ArrayList();
+ }
+ }
+
+ public List outerWays;
+ public List innerWays;
+
+ public MultipolygonCreate(List outerWays, List innerWays){
+ this.outerWays = outerWays;
+ this.innerWays = innerWays;
+ }
+
+ public MultipolygonCreate(){
+ this.outerWays = new ArrayList(0);
+ this.innerWays = new ArrayList(0);
+ }
+
+ /**
+ * Splits ways into inner and outer JoinedWays. Sets innerWays and outerWays to the result.
+ * TODO: Currently cannot process touching polygons. See code in JoinAreasAction.
+ * @return error description if the ways cannot be split. Null if all fine.
+ */
+ public String makeFromWays(Collection ways){
+ List joinedWays = new ArrayList();
+
+ //collect ways connecting to each node.
+ MultiMap nodesWithConnectedWays = new MultiMap();
+ Set usedWays = new HashSet();
+
+ for(Way w: ways) {
+ if (w.getNodesCount() < 2) {
+ return tr("Cannot add a way with only {0} nodes.", w.getNodesCount());
+ }
+
+ if (w.isClosed()) {
+ //closed way, add as is.
+ JoinedPolygon jw = new JoinedPolygon(w);
+ joinedWays.add(jw);
+ usedWays.add(w);
+ }
+ else {
+ nodesWithConnectedWays.put(w.lastNode(), w);
+ nodesWithConnectedWays.put(w.firstNode(), w);
+ }
+ }
+
+ //process unclosed ways
+ for (Way startWay: ways) {
+ if (usedWays.contains(startWay)){
+ continue;
+ }
+
+ Node startNode = startWay.firstNode();
+ List collectedWays = new ArrayList();
+ List collectedWaysReverse = new ArrayList();
+ Way curWay = startWay;
+ Node prevNode = startNode;
+
+ //find polygon ways
+ while (true) {
+ boolean curWayReverse = prevNode == curWay.lastNode();
+ Node nextNode = (curWayReverse) ? curWay.firstNode(): curWay.lastNode();
+
+ //add cur way to the list
+ collectedWays.add(curWay);
+ collectedWaysReverse.add(Boolean.valueOf(curWayReverse));
+
+ if (nextNode == startNode) {
+ //way finished
+ break;
+ }
+
+ //find next way
+ Collection adjacentWays = nodesWithConnectedWays.get(nextNode);
+
+ if (adjacentWays.size() != 2) {
+ return tr("Each node must connect exactly 2 ways");
+ }
+
+ Way nextWay = null;
+ for(Way way: adjacentWays){
+ if (way != curWay){
+ nextWay = way;
+ }
+ }
+
+ //move to the next way
+ curWay = nextWay;
+ prevNode = nextNode;
+ }
+
+ usedWays.addAll(collectedWays);
+ joinedWays.add(new JoinedPolygon(collectedWays, collectedWaysReverse));
+ }
+
+ //analyze witch way is inside witch outside.
+ return makeFromPolygons(joinedWays);
+ }
+
+ /**
+ * This method analyzes which ways are inner and which outer. Sets innerWays and outerWays to the result.
+ * @param joinedWays
+ * @return error description if the ways cannot be split. Null if all fine.
+ */
+ private String makeFromPolygons(List polygons) {
+ List list = findOuterWaysRecursive(0, polygons);
+
+ if (list == null){
+ return tr("There is an intersection between ways.");
+ }
+
+ this.outerWays = new ArrayList(0);
+ this.innerWays = new ArrayList(0);
+
+ //take every other level
+ for (PolygonLevel pol : list) {
+ if (pol.level % 2 == 0) {
+ this.outerWays.add(pol.outerWay);
+ }
+ else {
+ this.innerWays.add(pol.outerWay);
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Collects outer way and corresponding inner ways from all boundaries.
+ * @param boundaryWays
+ * @return the outermostWay, or null if intersection found.
+ */
+ private List findOuterWaysRecursive(int level, Collection boundaryWays) {
+
+ //TODO: bad performance for deep nesting...
+ List result = new ArrayList();
+
+ for (JoinedPolygon outerWay : boundaryWays) {
+
+ boolean outerGood = true;
+ List innerCandidates = new ArrayList();
+
+ for (JoinedPolygon innerWay : boundaryWays) {
+ if (innerWay == outerWay) {
+ continue;
+ }
+
+ PolygonIntersection intersection = Geometry.polygonIntersection(outerWay.nodes, innerWay.nodes);
+
+ if (intersection == PolygonIntersection.FIRST_INSIDE_SECOND) {
+ outerGood = false; // outer is inside another polygon
+ break;
+ } else if (intersection == PolygonIntersection.SECOND_INSIDE_FIRST) {
+ innerCandidates.add(innerWay);
+ }
+ else if (intersection == PolygonIntersection.CROSSING)
+ {
+ //ways intersect
+ return null;
+ }
+ }
+
+ if (!outerGood) {
+ continue;
+ }
+
+ //add new outer polygon
+ PolygonLevel pol = new PolygonLevel(outerWay, level);
+
+ //process inner ways
+ if (innerCandidates.size() > 0) {
+ List innerList = this.findOuterWaysRecursive(level + 1, innerCandidates);
+ if (innerList == null) {
+ return null; //intersection found
+ }
+
+ result.addAll(innerList);
+
+ for (PolygonLevel pl : innerList) {
+ if (pl.level == level + 1) {
+ pol.innerWays.add(pl.outerWay);
+ }
+ }
+ }
+
+ result.add(pol);
+ }
+
+ return result;
+ }
+}
Index: /trunk/src/org/openstreetmap/josm/gui/MainMenu.java
===================================================================
--- /trunk/src/org/openstreetmap/josm/gui/MainMenu.java (revision 3703)
+++ /trunk/src/org/openstreetmap/josm/gui/MainMenu.java (revision 3704)
@@ -25,4 +25,5 @@
import org.openstreetmap.josm.actions.CopyAction;
import org.openstreetmap.josm.actions.CreateCircleAction;
+import org.openstreetmap.josm.actions.CreateMultipolygonAction;
import org.openstreetmap.josm.actions.DeleteAction;
import org.openstreetmap.josm.actions.DistributeAction;
@@ -135,4 +136,6 @@
/* View menu */
public final JosmAction toggleGPXLines = new ToggleGPXLinesAction();
+ public final InfoAction info = new InfoAction();
+ public final HistoryInfoAction historyinfo = new HistoryInfoAction();
/* Tools menu */
@@ -154,6 +157,5 @@
public final JosmAction simplifyWay = new SimplifyWayAction();
public final JosmAction joinAreas = new JoinAreasAction();
- public final InfoAction info = new InfoAction();
- public final HistoryInfoAction historyinfo = new HistoryInfoAction();
+ public final JosmAction createMultipolygon = new CreateMultipolygonAction();
/* Audio menu */
@@ -319,5 +321,7 @@
add(toolsMenu, joinNodeWay);
add(toolsMenu, unglueNodes);
+ toolsMenu.addSeparator();
add(toolsMenu, joinAreas);
+ add(toolsMenu, createMultipolygon);
if (!Main.pref.getBoolean("audio.menuinvisible", false)) {
Index: /trunk/src/org/openstreetmap/josm/plugins/PluginHandler.java
===================================================================
--- /trunk/src/org/openstreetmap/josm/plugins/PluginHandler.java (revision 3703)
+++ /trunk/src/org/openstreetmap/josm/plugins/PluginHandler.java (revision 3704)
@@ -89,5 +89,5 @@
{"usertools", IN_CORE},
{"AgPifoJ", IN_CORE}, {"utilsplugin", IN_CORE}, {"ghost", IN_CORE},
- {"validator", IN_CORE}}) {
+ {"validator", IN_CORE}, {"multipoly", IN_CORE}}) {
DEPRECATED_PLUGINS.put(depr[0], depr.length >= 2 ? depr[1] : null);
}