nodeGroup = new HashSet<>();
+
+ for (int i = segment.startIndex; i <= segment.startIndex + segment.length; i++) {
+ nodeGroup.add(way.getNode(i));
+ }
+ sRefDiscontinuities.add(nodeGroup);
+ }
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Checks if parameter segments align. The {@code reference} is expected to be at least as long as the {@code candidate}.
+ * @param reference Reference segment to check against
+ * @param candidate Candidate segment
+ * @return {@code true} if the two segments ref=* numbering align
+ */
+ private static boolean isSegmentAlign(SegmentInfo reference, SegmentInfo candidate) {
+ if (reference.direction == NumberingDirection.NONE
+ || reference.direction == candidate.direction
+ || candidate.direction == NumberingDirection.NONE)
+ return Math.abs(candidate.startIndex - reference.startIndex) == Math.abs(candidate.startRef - reference.startRef);
+ return false;
+ }
+
+ /**
+ * Detects continuous reference numbering sequences. Ignores the first and last node because
+ * ways can be connected, and the connection nodes can have different numbering.
+ *
+ * If the numbering switches in the middle of the way, this can also be seen as error,
+ * because line relations would require split ways.
+ */
+ static class RefChecker {
+ private final List segments = new ArrayList<>();
+ private NumberingDirection direction = NumberingDirection.NONE;
+ private Integer startIndex;
+ private Integer previousRef;
+
+ RefChecker(final Way way) {
+ run(way);
+ }
+
+ private void run(Way way) {
+ final int wayLength = way.getNodesCount();
+
+ // first and last node skipped
+ for (int i = 1; i < wayLength - 1; i++) {
+ Node n = way.getNode(i);
+ if (!isPowerTower(n)) {
+ continue;
+ }
+ maintain(parseRef(n.get("ref")), i);
+ }
+
+ // needed for creation of the last segment
+ maintain(null, wayLength - 1);
+ }
+
+ /**
+ * Maintains class variables and constructs a new segment when necessary.
+ * @param ref recognised ref=* number
+ * @param index node index in a {@link Way}
+ */
+ private void maintain(Integer ref, int index) {
+ if (previousRef == null && ref != null) {
+ // ref change: null -> number
+ startIndex = index;
+ } else if (previousRef != null && ref == null) {
+ // ref change: number -> null
+ segments.add(new SegmentInfo(startIndex, index - 1 - startIndex, previousRef, direction));
+ direction = NumberingDirection.NONE; // to fix directionality
+ } else if (previousRef != null) {
+ // ref change: number -> number
+ if (Math.abs(ref - previousRef) != 1) {
+ segments.add(new SegmentInfo(startIndex, index - 1 - startIndex, previousRef, direction));
+ startIndex = index;
+ previousRef = ref; // to fix directionality
+ }
+ direction = detectDirection(ref, previousRef);
+ }
+ previousRef = ref;
+ }
+
+ /**
+ * Parses integer tag values. Later can be relatively easily extended or rewritten to handle
+ * complex references like 25/A, 25/B etc.
+ * @param value the value to be parsed
+ * @return parsed int or {@code null} in case of {@link NumberFormatException}
+ */
+ private static Integer parseRef(String value) {
+ try {
+ return Integer.parseInt(value);
+ } catch (NumberFormatException ignore) {
+ Logging.trace("The " + RefChecker.class + " couldn't parse ref=" + value + ", consider rewriting the parser");
+ return null;
+ }
+ }
+
+ /**
+ * Detects numbering direction. The parameters should follow way direction.
+ * @param ref last known reference value
+ * @param previousRef reference value before {@code ref}
+ * @return recognised direction
+ */
+ private static NumberingDirection detectDirection(int ref, int previousRef) {
+ if (ref > previousRef)
+ return NumberingDirection.SAME;
+ else if (ref < previousRef)
+ return NumberingDirection.OPPOSITE;
+ return NumberingDirection.NONE;
+ }
+
+ /**
+ * Calculates the longest segment.
+ * @return the longest segment, or the lowest index if there are more than one with same length and direction,
+ * or {@code null} if there are more than one with same length and different direction
+ */
+ SegmentInfo getLongestSegment() {
+ final Set directions = EnumSet.noneOf(NumberingDirection.class);
+ int longestLength = -1;
+ int counter = 0;
+ SegmentInfo longest = null;
+
+ for (SegmentInfo segment : segments) {
+ if (segment.length > longestLength) {
+ longestLength = segment.length;
+ longest = segment;
+ counter = 0;
+ directions.clear();
+ directions.add(segment.direction);
+ } else if (segment.length == longestLength) {
+ counter++;
+ directions.add(segment.direction);
+ }
+ }
+
+ // there are multiple segments with the same longest length and their directions don't match
+ if (counter > 0 && directions.size() > 1)
+ return null;
+
+ return longest;
+ }
+
+ /**
+ * @return the detected segments
+ */
+ List getSegments() {
+ return segments;
+ }
+ }
+
+ private static boolean isRelatedToPower(Way way) {
+ if (way.hasTag("power") || way.hasTag("building"))
+ return true;
+ for (OsmPrimitive ref : way.getReferrers()) {
+ if (ref instanceof Relation && ref.isMultipolygon() && (ref.hasTag("power") || ref.hasTag("building"))) {
+ for (RelationMember rm : ((Relation) ref).getMembers()) {
+ if (way == rm.getMember())
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Determines if the current node connected to a line which usually used inside power stations.
+ * @param n node to check
+ * @param w parent way of {@code n}
+ * @return {@code true} if {@code n} connected to power=line + line=*
+ */
+ private static boolean isConnectedToStationLine(Node n, Way w) {
+ for (OsmPrimitive p : n.getReferrers()) {
+ if (p instanceof Way && !p.equals(w) && isPowerLine((Way) p) && p.hasKey("line"))
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Checks if the way continues as a power=minor_line.
+ * @param way Way to be checked
+ * @return {@code true} if the way continues as a power=minor_line
+ */
+ private static boolean isContinuesAsMinorLine(Way way) {
+ return way.firstNode().referrers(Way.class).filter(referrer -> !way.equals(referrer)).anyMatch(PowerLines::isMinorLine) ||
+ way.lastNode().referrers(Way.class).filter(referrer -> !way.equals(referrer)).anyMatch(PowerLines::isMinorLine);
+ }
+
+ /**
+ * Checks if the given primitive denotes a power=minor_line.
+ * @param p primitive to be checked
+ * @return {@code true} if the given primitive denotes a power=minor_line
+ */
+ private static boolean isMinorLine(OsmPrimitive p) {
+ return p.hasTag("power", "minor_line");
+ }
+
+ /**
+ * Check if primitive has a tag that marks it as a water area or boundary of a water area.
+ * @param p the primitive
+ * @return {@code true} if primitive has a tag that marks it as a water area or boundary of a water area
+ */
+ private static boolean concernsWaterArea(OsmPrimitive p) {
+ return p.hasTag("water", "river", "lake") || p.hasKey("waterway") || p.hasTag("natural", "coastline");
+ }
+
+ /**
+ * Checks if the given node is inside a power station.
+ * @param n Node to be checked
+ * @return true if the given node is inside a power station
+ */
protected final boolean isInPowerStation(Node n) {
for (OsmPrimitive station : powerStations) {
List> nodesLists = new ArrayList<>();
@@ -164,35 +630,36 @@
* @param w The way to be tested
* @return {@code true} if power key is set and equal to line/minor_line
*/
- protected static final boolean isPowerLine(Way w) {
+ protected static boolean isPowerLine(Way w) {
return isPowerIn(w, POWER_LINE_TAGS);
}
/**
* Determines if the specified primitive denotes a power station.
* @param p The primitive to be tested
- * @return {@code true} if power key is set and equal to station/sub_station/plant
+ * @return {@code true} if power key is set and equal to generator/substation/plant
*/
- protected static final boolean isPowerStation(OsmPrimitive p) {
+ protected static boolean isPowerStation(OsmPrimitive p) {
return isPowerIn(p, POWER_STATION_TAGS) || isBuildingIn(p, BUILDING_STATION_TAGS);
}
/**
- * Determines if the specified node denotes a power tower/pole.
+ * Determines if the specified node denotes a power support feature.
* @param n The node to be tested
- * @return {@code true} if power key is set and equal to tower/pole
+ * @return {@code true} if power key is set and equal to pole/tower/portal/catenary_mast
*/
- protected static final boolean isPowerTower(Node n) {
+ protected static boolean isPowerTower(Node n) {
return isPowerIn(n, POWER_TOWER_TAGS);
}
/**
* Determines if the specified node denotes a power infrastructure allowed on a power line.
* @param n The node to be tested
- * @return True if power key is set and equal to switch/tranformer/busbar/generator
+ * @return {@code true} if power key is set and equal to compensator/converter/generator/insulator
+ * /switch/switchgear/terminal/transformer
*/
- protected static final boolean isPowerAllowed(Node n) {
- return isPowerIn(n, POWER_ALLOWED_TAGS);
+ protected static boolean isPowerInfrastructure(Node n) {
+ return isPowerIn(n, POWER_INFRASTRUCTURE_TAGS);
}
/**
@@ -215,9 +682,16 @@
return p.hasTag("building", values);
}
- private void clearCollections() {
+ @Override
+ public void clear() {
+ super.clear();
powerStations.clear();
badConnections.clear();
- missingTowerOrPole.clear();
+ missingTags.clear();
+ missingNodes.clear();
+ wrongLineType.clear();
+ refDiscontinuities.clear();
+ segmentRefDiscontinuities.clear();
+ datasetWaterways.clear();
}
}
Index: src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDataText.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDataText.java b/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDataText.java
--- a/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDataText.java (revision 18531)
+++ b/src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDataText.java (date 1659452763597)
@@ -32,6 +32,7 @@
import org.openstreetmap.josm.data.projection.proj.TransverseMercator.Hemisphere;
import org.openstreetmap.josm.tools.Geometry;
import org.openstreetmap.josm.tools.Pair;
+import org.openstreetmap.josm.tools.Utils;
/**
* Textual representation of primitive contents, used in {@code InspectPrimitiveDialog}.
@@ -174,9 +175,17 @@
add(tr("Centroid: "), toStringCSV(false,
ProjectionRegistry.getProjection().eastNorth2latlon(Geometry.getCentroid(((IWay) o).getNodes()))));
if (o instanceof Way) {
- double dist = ((Way) o).getLength();
- String distText = SystemOfMeasurement.getSystemOfMeasurement().getDistText(dist);
- add(tr("Length: {0}", distText));
+ double length = ((Way) o).getLength();
+ String lenText = SystemOfMeasurement.getSystemOfMeasurement().getDistText(length);
+ add(tr("Length: {0}", lenText));
+
+ double avgNodeDistance = length / (((Way) o).getNodesCount() - 1);
+ String nodeDistText = SystemOfMeasurement.getSystemOfMeasurement().getDistText(avgNodeDistance);
+ add(tr("Average segment length: {0}", nodeDistText));
+
+ double stdDev = Utils.getStandardDeviation(((Way) o).getSegmentLengths(), avgNodeDistance);
+ String stdDevText = SystemOfMeasurement.getSystemOfMeasurement().getDistText(stdDev);
+ add(tr("Standard deviation: {0}", stdDevText));
}
if (o instanceof Way && ((Way) o).concernsArea() && ((Way) o).isClosed()) {
double area = Geometry.closedWayArea((Way) o);
Index: src/org/openstreetmap/josm/tools/Geometry.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/src/org/openstreetmap/josm/tools/Geometry.java b/src/org/openstreetmap/josm/tools/Geometry.java
--- a/src/org/openstreetmap/josm/tools/Geometry.java (revision 18531)
+++ b/src/org/openstreetmap/josm/tools/Geometry.java (date 1659460727435)
@@ -287,13 +287,16 @@
* @param p3 the coordinates of the start point of the second specified line segment
* @param p4 the coordinates of the end point of the second specified line segment
* @return EastNorth null if no intersection was found, the EastNorth coordinates of the intersection otherwise
+ * @see #getSegmentSegmentIntersection(ILatLon, ILatLon, ILatLon, ILatLon)
*/
public static EastNorth getSegmentSegmentIntersection(EastNorth p1, EastNorth p2, EastNorth p3, EastNorth p4) {
-
- CheckParameterUtil.ensureThat(p1.isValid(), () -> p1 + " invalid");
- CheckParameterUtil.ensureThat(p2.isValid(), () -> p2 + " invalid");
- CheckParameterUtil.ensureThat(p3.isValid(), () -> p3 + " invalid");
- CheckParameterUtil.ensureThat(p4.isValid(), () -> p4 + " invalid");
+ // see the ILatLon version for an explanation why the checks are in the if statement
+ if (!(p1.isValid() && p2.isValid() && p3.isValid() && p4.isValid())) {
+ CheckParameterUtil.ensureThat(p1.isValid(), () -> p1 + " invalid");
+ CheckParameterUtil.ensureThat(p2.isValid(), () -> p2 + " invalid");
+ CheckParameterUtil.ensureThat(p3.isValid(), () -> p3 + " invalid");
+ CheckParameterUtil.ensureThat(p4.isValid(), () -> p4 + " invalid");
+ }
double x1 = p1.getX();
double y1 = p1.getY();
@@ -303,6 +306,63 @@
double y3 = p3.getY();
double x4 = p4.getX();
double y4 = p4.getY();
+ double[] en = getSegmentSegmentIntersection(x1, y1, x2, y2, x3, y3, x4, y4);
+ if (en != null && en.length == 2) {
+ return new EastNorth(en[0], en[1]);
+ }
+ return null;
+ }
+
+ /**
+ * Finds the intersection of two line segments.
+ * @param p1 the coordinates of the start point of the first specified line segment
+ * @param p2 the coordinates of the end point of the first specified line segment
+ * @param p3 the coordinates of the start point of the second specified line segment
+ * @param p4 the coordinates of the end point of the second specified line segment
+ * @return LatLon null if no intersection was found, the LatLon coordinates of the intersection otherwise
+ * @see #getSegmentSegmentIntersection(EastNorth, EastNorth, EastNorth, EastNorth)
+ * @since xxx
+ */
+ public static ILatLon getSegmentSegmentIntersection(ILatLon p1, ILatLon p2, ILatLon p3, ILatLon p4) {
+ // Avoid lambda creation if at all possible -- this pretty much removes all memory allocations
+ // from this method (11.4 GB to 0) when testing #20716 with Mesa County, CO (overpass download).
+ // There was also a 2/3 decrease in CPU samples for the method.
+ if (!(p1.isLatLonKnown() && p2.isLatLonKnown() && p3.isLatLonKnown() && p4.isLatLonKnown())) {
+ CheckParameterUtil.ensureThat(p1.isLatLonKnown(), () -> p1 + " invalid");
+ CheckParameterUtil.ensureThat(p2.isLatLonKnown(), () -> p2 + " invalid");
+ CheckParameterUtil.ensureThat(p3.isLatLonKnown(), () -> p3 + " invalid");
+ CheckParameterUtil.ensureThat(p4.isLatLonKnown(), () -> p4 + " invalid");
+ }
+
+ double x1 = p1.lon();
+ double y1 = p1.lat();
+ double x2 = p2.lon();
+ double y2 = p2.lat();
+ double x3 = p3.lon();
+ double y3 = p3.lat();
+ double x4 = p4.lon();
+ double y4 = p4.lat();
+ double[] en = getSegmentSegmentIntersection(x1, y1, x2, y2, x3, y3, x4, y4);
+ if (en != null && en.length == 2) {
+ return new LatLon(en[1], en[0]);
+ }
+ return null;
+ }
+
+ /**
+ * Get the segment segment intersection of two line segments
+ * @param x1 The x coordinate of the first point (first segment)
+ * @param y1 The y coordinate of the first point (first segment)
+ * @param x2 The x coordinate of the second point (first segment)
+ * @param y2 The y coordinate of the second point (first segment)
+ * @param x3 The x coordinate of the third point (second segment)
+ * @param y3 The y coordinate of the third point (second segment)
+ * @param x4 The x coordinate of the fourth point (second segment)
+ * @param y4 The y coordinate of the fourth point (second segment)
+ * @return {@code null} if no intersection was found, otherwise [x, y]
+ */
+ private static double[] getSegmentSegmentIntersection(double x1, double y1, double x2, double y2, double x3, double y3,
+ double x4, double y4) {
//TODO: do this locally.
//TODO: remove this check after careful testing
@@ -333,7 +393,7 @@
if (u > -1e-8 && u < 1+1e-8 && v > -1e-8 && v < 1+1e-8) {
if (u < 0) u = 0;
if (u > 1) u = 1.0;
- return new EastNorth(x1+a1*u, y1+a2*u);
+ return new double[] {x1+a1*u, y1+a2*u};
} else {
return null;
}
Index: src/org/openstreetmap/josm/tools/Utils.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/src/org/openstreetmap/josm/tools/Utils.java b/src/org/openstreetmap/josm/tools/Utils.java
--- a/src/org/openstreetmap/josm/tools/Utils.java (revision 18531)
+++ b/src/org/openstreetmap/josm/tools/Utils.java (date 1659452763688)
@@ -226,7 +226,7 @@
if (array != null) {
return Arrays.copyOf(array, array.length);
}
- return array;
+ return null;
}
/**
@@ -239,7 +239,7 @@
if (array != null) {
return Arrays.copyOf(array, array.length);
}
- return array;
+ return null;
}
/**
@@ -252,7 +252,7 @@
if (array != null) {
return Arrays.copyOf(array, array.length);
}
- return array;
+ return null;
}
/**
@@ -265,7 +265,7 @@
if (array != null) {
return Arrays.copyOf(array, array.length);
}
- return array;
+ return null;
}
/**
@@ -1303,6 +1303,44 @@
}
}
+ /**
+ * Calculates the standard deviation of population.
+ * @param values an array of values
+ * @return standard deviation of the given array, or -1.0 if the array has less than two values
+ * @see #getStandardDeviation(double[], double)
+ * @since xxx
+ */
+ public static double getStandardDeviation(double[] values) {
+ return getStandardDeviation(values, Double.NaN);
+ }
+
+ /**
+ * Calculates the standard deviation of population with the given
+ * mean value.
+ * @param values an array of values
+ * @param mean precalculated average value of the array
+ * @return standard deviation of the given array, or -1.0 if the array has less than two values
+ * @see #getStandardDeviation(double[])
+ * @since xxx
+ */
+ public static double getStandardDeviation(double[] values, double mean) {
+ if (values.length < 2) {
+ return -1.0;
+ }
+
+ double standardDeviation = 0;
+
+ if (Double.isNaN(mean)) {
+ mean = Arrays.stream(values).average().orElse(0);
+ }
+
+ for (double length : values) {
+ standardDeviation += Math.pow(length - mean, 2);
+ }
+
+ return Math.sqrt(standardDeviation / values.length);
+ }
+
/**
* A ForkJoinWorkerThread that will always inherit caller permissions,
* unlike JDK's InnocuousForkJoinWorkerThread, used if a security manager exists.
Index: test/unit/org/openstreetmap/josm/data/osm/WayTest.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/test/unit/org/openstreetmap/josm/data/osm/WayTest.java b/test/unit/org/openstreetmap/josm/data/osm/WayTest.java
--- a/test/unit/org/openstreetmap/josm/data/osm/WayTest.java (revision 18531)
+++ b/test/unit/org/openstreetmap/josm/data/osm/WayTest.java (date 1659452763768)
@@ -134,4 +134,28 @@
void testLoadIAE() {
assertThrows(IllegalArgumentException.class, () -> new Way().load(new NodeData()));
}
+
+ @Test
+ void getLongestSegmentLength() {
+ DataSet ds = new DataSet();
+ Node n1 = new Node(1);
+ Node n2 = new Node(2);
+ Node n3 = new Node(3);
+ Node n4 = new Node(4);
+ n1.setCoor(new LatLon(0.01, 0.01));
+ n2.setCoor(new LatLon(0.02, 0.02));
+ n3.setCoor(new LatLon(0.03, 0.03));
+ n4.setCoor(new LatLon(0.05, 0.05));
+ ds.addPrimitive(n1);
+ ds.addPrimitive(n2);
+ ds.addPrimitive(n3);
+ ds.addPrimitive(n4);
+ Way way = new Way(1);
+ ds.addPrimitive(way);
+
+ assertEquals(0.0, way.getLongestSegmentLength());
+ way.setNodes(Arrays.asList(n1, n2, n2, n3, n4));
+
+ assertEquals(3148.5902810874577, way.getLongestSegmentLength());
+ }
}
Index: test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java b/test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java
new file mode 100644
--- /dev/null (date 1659451627154)
+++ b/test/unit/org/openstreetmap/josm/data/validation/tests/PowerLinesTest.java (date 1659451627154)
@@ -0,0 +1,116 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.openstreetmap.josm.JOSMFixture;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.TagMap;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+
+
+public class PowerLinesTest {
+ private PowerLines powerLines;
+ private DataSet ds;
+
+ @BeforeEach
+ public void setUp() throws Exception {
+ JOSMFixture.createUnitTestFixture().init();
+ ds = new DataSet();
+ MainApplication.getLayerManager().addLayer(new OsmDataLayer(ds, null, null));
+
+ powerLines = new PowerLines();
+ powerLines.initialize();
+ powerLines.startTest(null);
+ }
+
+ @Test
+ void testNoBreakInLine() {
+ Way powerline = new Way();
+ powerline.setKeys(new TagMap("power", "line"));
+ ds.addPrimitive(powerline);
+
+ for (int i = 0; i < 10; i++) {
+ Node node = new Node(new LatLon(0, 0.001 * i));
+ node.setKeys(new TagMap("power", "tower"));
+ ds.addPrimitive(node);
+ powerline.addNode(node);
+ }
+ powerLines.visit(powerline);
+ powerLines.endTest();
+ assertTrue(powerLines.getErrors().isEmpty());
+ }
+
+ @Test
+ void testBreakInLine() {
+ Way powerline = new Way();
+ powerline.setKeys(new TagMap("power", "line"));
+ ds.addPrimitive(powerline);
+
+ for (int i = 0; i < 10; i++) {
+ if (i != 4 && i != 5) {
+ Node node = new Node(new LatLon(0, 0.001 * i));
+ node.setKeys(new TagMap("power", "tower"));
+ ds.addPrimitive(node);
+ powerline.addNode(node);
+ }
+ }
+ powerLines.visit(powerline);
+ powerLines.endTest();
+ assertFalse(powerLines.getErrors().isEmpty());
+ }
+
+ @Test
+ void testConnectionAndRefInLine() {
+ Way powerline = new Way();
+ powerline.setKeys(new TagMap("power", "line"));
+ ds.addPrimitive(powerline);
+
+ int connectionCount = 0;
+
+ for (int i = 0; i < 10; i++) {
+ Node node = new Node(new LatLon(0, 0.001 * i));
+ node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i)));
+ if (i == 4 || i == 5) {
+ node.setKeys(new TagMap("power", "connection"));
+ connectionCount++;
+ }
+ if (i > 5) {
+ node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i - connectionCount)));
+ }
+ ds.addPrimitive(node);
+ powerline.addNode(node);
+ }
+ powerLines.visit(powerline);
+ powerLines.endTest();
+ assertTrue(powerLines.getErrors().isEmpty());
+ }
+
+ @Test
+ void testRefDiscontinuityInLine() {
+ Way powerline = new Way();
+ powerline.setKeys(new TagMap("power", "minor_line"));
+ ds.addPrimitive(powerline);
+
+ for (int i = 0; i < 10; i++) {
+ Node node = new Node(new LatLon(0, 0.001 * i));
+ node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i)));
+ if (i < 4) {
+ // add discontinuity
+ node.setKeys(new TagMap("power", "tower", "ref", Integer.toString(i + 1)));
+ }
+ ds.addPrimitive(node);
+ powerline.addNode(node);
+ }
+ powerLines.visit(powerline);
+ powerLines.endTest();
+ assertFalse(powerLines.getErrors().isEmpty());
+ }
+}
Index: test/unit/org/openstreetmap/josm/tools/UtilsTest.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/test/unit/org/openstreetmap/josm/tools/UtilsTest.java b/test/unit/org/openstreetmap/josm/tools/UtilsTest.java
--- a/test/unit/org/openstreetmap/josm/tools/UtilsTest.java (revision 18531)
+++ b/test/unit/org/openstreetmap/josm/tools/UtilsTest.java (date 1659452763771)
@@ -250,7 +250,7 @@
*/
@Test
void testJoinAsHtmlUnorderedList() {
- List items = Arrays.asList("1", Integer.valueOf(2));
+ List items = Arrays.asList("1", 2);
assertEquals("", Utils.joinAsHtmlUnorderedList(items));
assertEquals("", Utils.joinAsHtmlUnorderedList(Collections.emptyList()));
}
@@ -531,4 +531,17 @@
final String output = Utils.execOutput(Arrays.asList("echo", "Hello", "World"));
assertEquals("Hello World", output);
}
+
+ /**
+ * Test of {@link Utils#getStandardDeviation(double[])} and {@link Utils#getStandardDeviation(double[], double)}
+ */
+ @Test
+ void testGetStandardDeviation() {
+ assertEquals(0.0, Utils.getStandardDeviation(new double[]{1, 1, 1, 1}));
+ assertEquals(0.0, Utils.getStandardDeviation(new double[]{1, 1, 1, 1}, 1.0));
+ assertEquals(0.5, Utils.getStandardDeviation(new double[]{1, 1, 2, 2}));
+
+ assertEquals(-1.0, Utils.getStandardDeviation(new double[]{}));
+ assertEquals(-1.0, Utils.getStandardDeviation(new double[]{0}));
+ }
}