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;
}
/**
* Get the detected segments
* @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<>();
if (station instanceof Way) {
nodesLists.add(((Way) station).getNodes());
} else if (station instanceof Relation) {
Multipolygon polygon = MultipolygonCache.getInstance().get((Relation) station);
if (polygon != null) {
for (JoinedWay outer : Multipolygon.joinWays(polygon.getOuterWays())) {
nodesLists.add(outer.getNodes());
}
}
}
for (List nodes : nodesLists) {
if (Geometry.nodeInsidePolygon(n, nodes)) {
return true;
}
}
}
return false;
}
/**
* Determines if the specified way denotes a power line.
* @param w The way to be tested
* @return {@code true} if power key is set and equal to line/minor_line
*/
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 generator/substation/plant
*/
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 support feature.
* @param n The node to be tested
* @return {@code true} if power key is set and equal to pole/tower/portal/catenary_mast
*/
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 {@code true} if power key is set and equal to compensator/converter/generator/insulator
* /switch/switchgear/terminal/transformer
*/
protected static boolean isPowerInfrastructure(Node n) {
return isPowerIn(n, POWER_INFRASTRUCTURE_TAGS);
}
/**
* Helper function to check if power tag is a certain value.
* @param p The primitive to be tested
* @param values List of possible values
* @return {@code true} if power key is set and equal to possible values
*/
private static boolean isPowerIn(OsmPrimitive p, Collection values) {
return p.hasTag(POWER, values);
}
/**
* Helper function to check if building tag is a certain value.
* @param p The primitive to be tested
* @param values List of possible values
* @return {@code true} if power key is set and equal to possible values
*/
private static boolean isBuildingIn(OsmPrimitive p, Collection values) {
return p.hasTag(BUILDING, values);
}
@Override
public void clear() {
super.clear();
badConnections.clear();
cellSegmentsWater.clear();
foundPowerLines.clear();
missingNodes.clear();
missingTags.clear();
powerStations.clear();
refDiscontinuities.clear();
segmentRefDiscontinuities.clear();
wrongLineType.clear();
}
}