Index: trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java =================================================================== --- trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java (revision 7389) +++ trunk/src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java (revision 7392) @@ -27,6 +27,6 @@ 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.MultipolygonBuilder; +import org.openstreetmap.josm.data.osm.MultipolygonBuilder.JoinedPolygon; import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.Relation; @@ -191,5 +191,5 @@ ways.addAll(selectedMultipolygonRelation.getMemberPrimitives(Way.class)); - final MultipolygonCreate polygon = analyzeWays(ways, true); + final MultipolygonBuilder polygon = analyzeWays(ways, true); if (polygon == null) { return null; //could not make multipolygon. @@ -204,5 +204,5 @@ public static Pair createMultipolygonRelation(Collection selectedWays, boolean showNotif) { - final MultipolygonCreate polygon = analyzeWays(selectedWays, showNotif); + final MultipolygonBuilder polygon = analyzeWays(selectedWays, showNotif); if (polygon == null) { return null; //could not make multipolygon. @@ -265,7 +265,7 @@ * @return null, if there was a problem with the ways. */ - private static MultipolygonCreate analyzeWays(Collection < Way > selectedWays, boolean showNotif) { - - MultipolygonCreate pol = new MultipolygonCreate(); + private static MultipolygonBuilder analyzeWays(Collection < Way > selectedWays, boolean showNotif) { + + MultipolygonBuilder pol = new MultipolygonBuilder(); String error = pol.makeFromWays(selectedWays); @@ -287,5 +287,5 @@ * @return multipolygon relation */ - private static Relation createRelation(MultipolygonCreate pol, final Relation rel) { + private static Relation createRelation(MultipolygonBuilder pol, final Relation rel) { // Create new relation rel.put("type", "multipolygon"); Index: trunk/src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java =================================================================== --- trunk/src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java (revision 7392) +++ trunk/src/org/openstreetmap/josm/data/osm/MultipolygonBuilder.java (revision 7392) @@ -0,0 +1,322 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.data.osm; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.geom.Area; +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; + +/** + * Helper class to build multipolygons from multiple ways. + * @author viesturs + * @since 7392 (rename) + * @since 3704 + */ +public class MultipolygonBuilder { + + /** + * Represents one polygon that consists of multiple ways. + */ + public static class JoinedPolygon { + public final List ways; + public final List reversed; + public final List nodes; + public final Area area; + + /** + * Constructs a new {@code JoinedPolygon} from given list of ways. + * @param ways The ways used to build joined polygon + */ + public JoinedPolygon(List ways, List reversed) { + this.ways = ways; + this.reversed = reversed; + this.nodes = this.getNodes(); + this.area = Geometry.getArea(nodes); + } + + /** + * Creates a polygon from single way. + * @param way the way to form the polygon + */ + public JoinedPolygon(Way way) { + this(Collections.singletonList(way), Collections.singletonList(Boolean.FALSE)); + } + + /** + * Builds a list of nodes for this polygon. First node is not duplicated as last node. + * @return list of nodes + */ + public 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 + */ + 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<>(); + } + } + + /** List of outer ways **/ + public final List outerWays; + /** List of inner ways **/ + public final List innerWays; + + /** + * Constructs a new {@code MultipolygonBuilder} initialized with given ways. + * @param outerWays The outer ways + * @param innerWays The inner ways + */ + public MultipolygonBuilder(List outerWays, List innerWays) { + this.outerWays = outerWays; + this.innerWays = innerWays; + } + + /** + * Constructs a new empty {@code MultipolygonBuilder}. + */ + public MultipolygonBuilder() { + this.outerWays = new ArrayList<>(0); + this.innerWays = new ArrayList<>(0); + } + + /** + * Splits ways into inner and outer JoinedWays. Sets {@link #innerWays} and {@link #outerWays} to the result. + * TODO: Currently cannot process touching polygons. See code in JoinAreasAction. + * @param ways ways to analyze + * @return error description if the ways cannot be split, {@code null} if all fine. + */ + public String makeFromWays(Collection ways) { + try { + List joinedWays = joinWays(ways); + //analyze witch way is inside witch outside. + return makeFromPolygons(joinedWays); + } catch (JoinedPolygonCreationException ex) { + return ex.getMessage(); + } + } + + /** + * An exception indicating an error while joining ways to multipolygon rings. + */ + public static class JoinedPolygonCreationException extends RuntimeException { + /** + * Constructs a new {@code JoinedPolygonCreationException}. + * @param message the detail message. The detail message is saved for + * later retrieval by the {@link #getMessage()} method + */ + public JoinedPolygonCreationException(String message) { + super(message); + } + } + + /** + * Joins the given {@code ways} to multipolygon rings. + * @param ways the ways to join. + * @return a list of multipolygon rings. + * @throws JoinedPolygonCreationException if the creation fails. + */ + public static List joinWays(Collection ways) throws JoinedPolygonCreationException { + 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) { + throw new JoinedPolygonCreationException(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) { + throw new JoinedPolygonCreationException(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)); + } + + return joinedWays; + } + + /** + * This method analyzes which ways are inner and which outer. Sets {@link #innerWays} and {@link #outerWays} to the result. + * @param polygons polygons to analyze + * @return error description if the ways cannot be split, {@code 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.clear(); + this.innerWays.clear(); + + //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 {@code 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.area, innerWay.area); + + 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.isEmpty()) { + 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/data/osm/MultipolygonCreate.java =================================================================== --- trunk/src/org/openstreetmap/josm/data/osm/MultipolygonCreate.java (revision 7389) +++ (revision ) @@ -1,302 +1,0 @@ -// License: GPL. For details, see LICENSE file. -package org.openstreetmap.josm.data.osm; - -import static org.openstreetmap.josm.tools.I18n.tr; - -import java.awt.geom.Area; -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 final Area area; - - public JoinedPolygon(List ways, List reversed) { - this.ways = ways; - this.reversed = reversed; - this.nodes = this.getNodes(); - this.area = Geometry.getArea(nodes); - } - - /** - * Creates a polygon from single way. - * @param way the way to form the polygon - */ - public JoinedPolygon(Way way) { - this(Collections.singletonList(way), Collections.singletonList(Boolean.FALSE)); - } - - /** - * Builds a list of nodes for this polygon. First node is not duplicated as last node. - * @return list of nodes - */ - public 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 {@link #innerWays} and {@link #outerWays} to the result. - * TODO: Currently cannot process touching polygons. See code in JoinAreasAction. - * @param ways ways to analyze - * @return error description if the ways cannot be split, {@code null} if all fine. - */ - public String makeFromWays(Collection ways) { - try { - List joinedWays = joinWays(ways); - //analyze witch way is inside witch outside. - return makeFromPolygons(joinedWays); - } catch (JoinedPolygonCreationException ex) { - return ex.getMessage(); - } - } - - /** - * An exception indicating an error while joining ways to multipolygon rings. - */ - public static class JoinedPolygonCreationException extends RuntimeException { - public JoinedPolygonCreationException(String message) { - super(message); - } - } - - /** - * Joins the given {@code ways} to multipolygon rings. - * @param ways the ways to join. - * @return a list of multipolygon rings. - * @throws JoinedPolygonCreationException if the creation fails. - */ - public static List joinWays(Collection ways) throws JoinedPolygonCreationException { - 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) { - throw new JoinedPolygonCreationException(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) { - throw new JoinedPolygonCreationException(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)); - } - - return joinedWays; - } - - /** - * This method analyzes which ways are inner and which outer. Sets {@link #innerWays} and {@link #outerWays} to the result. - * @param polygons polygons to analyze - * @return error description if the ways cannot be split, {@code 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 {@code 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.area, innerWay.area); - - 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.isEmpty()) { - 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/io/FileImporter.java =================================================================== --- trunk/src/org/openstreetmap/josm/io/FileImporter.java (revision 7389) +++ trunk/src/org/openstreetmap/josm/io/FileImporter.java (revision 7392) @@ -21,8 +21,15 @@ public abstract class FileImporter implements Comparable, LayerChangeListener { + /** + * The extension file filter used to accept files. + */ public final ExtensionFileFilter filter; private boolean enabled; + /** + * Constructs a new {@code FileImporter} with the given extension file filter. + * @param filter The extension file filter + */ public FileImporter(ExtensionFileFilter filter) { this.filter = filter; @@ -30,4 +37,9 @@ } + /** + * Determines if this file importer accepts the given file. + * @param pathname The file to test + * @return {@code true} if this file importer accepts the given file, {@code false} otherwise + */ public boolean acceptFile(File pathname) { return filter.acceptName(pathname.getName()); Index: trunk/src/org/openstreetmap/josm/io/OsmImporter.java =================================================================== --- trunk/src/org/openstreetmap/josm/io/OsmImporter.java (revision 7389) +++ trunk/src/org/openstreetmap/josm/io/OsmImporter.java (revision 7392) @@ -18,11 +18,16 @@ import org.openstreetmap.josm.gui.progress.ProgressMonitor; import org.openstreetmap.josm.gui.util.GuiHelper; -import org.openstreetmap.josm.tools.Utils; public class OsmImporter extends FileImporter { + /** + * The OSM file filter (*.osm and *.xml files). + */ public static final ExtensionFileFilter FILE_FILTER = new ExtensionFileFilter( "osm,xml", "osm", tr("OSM Server Files") + " (*.osm *.xml)"); + /** + * Utility class containing imported OSM layer, and a task to run after it is added to MapView. + */ public static class OsmImporterData { @@ -51,4 +56,8 @@ } + /** + * Constructs a new {@code OsmImporter} with the given extension file filter. + * @param filter The extension file filter + */ public OsmImporter(ExtensionFileFilter filter) { super(filter); Index: trunk/src/org/openstreetmap/josm/tools/Geometry.java =================================================================== --- trunk/src/org/openstreetmap/josm/tools/Geometry.java (revision 7389) +++ trunk/src/org/openstreetmap/josm/tools/Geometry.java (revision 7392) @@ -24,5 +24,5 @@ import org.openstreetmap.josm.data.coor.LatLon; import org.openstreetmap.josm.data.osm.BBox; -import org.openstreetmap.josm.data.osm.MultipolygonCreate; +import org.openstreetmap.josm.data.osm.MultipolygonBuilder; import org.openstreetmap.josm.data.osm.Node; import org.openstreetmap.josm.data.osm.NodePositionComparator; @@ -899,15 +899,15 @@ final MultiPolygonMembers mpm = new MultiPolygonMembers(multiPolygon); // Construct complete rings for the inner/outer members - final List outerRings; - final List innerRings; + final List outerRings; + final List innerRings; try { - outerRings = MultipolygonCreate.joinWays(mpm.outers); - innerRings = MultipolygonCreate.joinWays(mpm.inners); - } catch (MultipolygonCreate.JoinedPolygonCreationException ex) { + outerRings = MultipolygonBuilder.joinWays(mpm.outers); + innerRings = MultipolygonBuilder.joinWays(mpm.inners); + } catch (MultipolygonBuilder.JoinedPolygonCreationException ex) { Main.debug("Invalid multipolygon " + multiPolygon); return false; } // Test if object is inside an outer member - for (MultipolygonCreate.JoinedPolygon out : outerRings) { + for (MultipolygonBuilder.JoinedPolygon out : outerRings) { if (nodes.size() == 1 ? nodeInsidePolygon(nodes.get(0), out.getNodes()) @@ -915,5 +915,5 @@ boolean insideInner = false; // If inside an outer, check it is not inside an inner - for (MultipolygonCreate.JoinedPolygon in : innerRings) { + for (MultipolygonBuilder.JoinedPolygon in : innerRings) { if (polygonIntersection(in.getNodes(), out.getNodes()) == PolygonIntersection.FIRST_INSIDE_SECOND && (nodes.size() == 1