001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.data.osm;
003
004import static org.openstreetmap.josm.tools.I18n.tr;
005
006import java.util.ArrayList;
007import java.util.Arrays;
008import java.util.HashSet;
009import java.util.List;
010import java.util.Map;
011import java.util.Set;
012import java.util.stream.Collectors;
013import java.util.stream.DoubleStream;
014import java.util.stream.IntStream;
015
016import org.openstreetmap.josm.data.coor.ILatLon;
017import org.openstreetmap.josm.data.osm.visitor.OsmPrimitiveVisitor;
018import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
019import org.openstreetmap.josm.spi.preferences.Config;
020import org.openstreetmap.josm.tools.CopyList;
021import org.openstreetmap.josm.tools.Geometry;
022import org.openstreetmap.josm.tools.Pair;
023import org.openstreetmap.josm.tools.Utils;
024
025/**
026 * One full way, consisting of a list of way {@link Node nodes}.
027 *
028 * @author imi
029 * @since 64
030 */
031public final class Way extends OsmPrimitive implements IWay<Node> {
032
033    static final UniqueIdGenerator idGenerator = new UniqueIdGenerator();
034    private static final Node[] EMPTY_NODES = new Node[0];
035
036    /**
037     * All way nodes in this way
038     */
039    private Node[] nodes = EMPTY_NODES;
040    private BBox bbox;
041
042    @Override
043    public List<Node> getNodes() {
044        return new CopyList<>(nodes);
045    }
046
047    @Override
048    public void setNodes(List<Node> nodes) {
049        checkDatasetNotReadOnly();
050        boolean locked = writeLock();
051        try {
052            for (Node node:this.nodes) {
053                node.removeReferrer(this);
054                node.clearCachedStyle();
055            }
056
057            if (Utils.isEmpty(nodes)) {
058                this.nodes = EMPTY_NODES;
059            } else {
060                this.nodes = nodes.toArray(EMPTY_NODES);
061            }
062            for (Node node: this.nodes) {
063                node.addReferrer(this);
064                node.clearCachedStyle();
065            }
066
067            clearCachedStyle();
068            fireNodesChanged();
069        } finally {
070            writeUnlock(locked);
071        }
072    }
073
074    /**
075     * Prevent directly following identical nodes in ways.
076     * @param nodes list of nodes
077     * @return {@code nodes} with consecutive identical nodes removed
078     */
079    private static List<Node> removeDouble(List<Node> nodes) {
080        Node last = null;
081        int count = nodes.size();
082        for (int i = 0; i < count && count > 2;) {
083            Node n = nodes.get(i);
084            if (last == n) {
085                nodes.remove(i);
086                --count;
087            } else {
088                last = n;
089                ++i;
090            }
091        }
092        return nodes;
093    }
094
095    @Override
096    public int getNodesCount() {
097        return nodes.length;
098    }
099
100    @Override
101    public Node getNode(int index) {
102        return nodes[index];
103    }
104
105    @Override
106    public long getNodeId(int idx) {
107        return nodes[idx].getUniqueId();
108    }
109
110    @Override
111    public List<Long> getNodeIds() {
112        return Arrays.stream(nodes).map(Node::getId).collect(Collectors.toList());
113    }
114
115    /**
116     * Replies true if this way contains the node <code>node</code>, false
117     * otherwise. Replies false if  <code>node</code> is null.
118     *
119     * @param node the node. May be null.
120     * @return true if this way contains the node <code>node</code>, false
121     * otherwise
122     * @since 1911
123     */
124    public boolean containsNode(Node node) {
125        return node != null && Arrays.asList(nodes).contains(node);
126    }
127
128    /**
129     * Return nodes adjacent to <code>node</code>
130     *
131     * @param node the node. May be null.
132     * @return Set of nodes adjacent to <code>node</code>
133     * @since 4671
134     */
135    public Set<Node> getNeighbours(Node node) {
136        Set<Node> neigh = new HashSet<>();
137
138        if (node == null) return neigh;
139
140        for (int i = 0; i < nodes.length; i++) {
141            if (nodes[i].equals(node)) {
142                if (i > 0)
143                    neigh.add(nodes[i-1]);
144                if (i < nodes.length-1)
145                    neigh.add(nodes[i+1]);
146            }
147        }
148        return neigh;
149    }
150
151    /**
152     * Replies the ordered {@link List} of chunks of this way. Each chunk is replied as a {@link Pair} of {@link Node nodes}.
153     * @param sort If true, the nodes of each pair are sorted as defined by {@link Pair#sort}.
154     *             If false, Pair.a and Pair.b are in the way order
155     *             (i.e for a given Pair(n), Pair(n-1).b == Pair(n).a, Pair(n).b == Pair(n+1).a, etc.)
156     * @return The ordered list of chunks of this way.
157     * @since 3348
158     */
159    public List<Pair<Node, Node>> getNodePairs(boolean sort) {
160        // For a way of size n, there are n - 1 pairs (a -> b, b -> c, c -> d, etc., 4 nodes -> 3 pairs)
161        List<Pair<Node, Node>> chunkSet = new ArrayList<>(Math.max(0, this.getNodesCount() - 1));
162        if (isIncomplete()) return chunkSet;
163        Node lastN = null;
164        for (Node n : nodes) {
165            if (lastN == null) {
166                lastN = n;
167                continue;
168            }
169            Pair<Node, Node> np = new Pair<>(lastN, n);
170            if (sort) {
171                Pair.sort(np);
172            }
173            chunkSet.add(np);
174            lastN = n;
175        }
176        return chunkSet;
177    }
178
179    @Override public void accept(OsmPrimitiveVisitor visitor) {
180        visitor.visit(this);
181    }
182
183    @Override public void accept(PrimitiveVisitor visitor) {
184        visitor.visit(this);
185    }
186
187    Way(long id, boolean allowNegative) {
188        super(id, allowNegative);
189    }
190
191    /**
192     * Constructs a new {@code Way} with id 0.
193     * @since 86
194     */
195    public Way() {
196        super(0, false);
197    }
198
199    /**
200     * Constructs a new {@code Way} from an existing {@code Way}.
201     * This adds links from all way nodes to the clone. See #19885 for possible memory leaks.
202     * @param original The original {@code Way} to be identically cloned. Must not be null
203     * @param clearMetadata If {@code true}, clears the OSM id and other metadata as defined by {@link #clearOsmMetadata}.
204     * If {@code false}, does nothing
205     * @param copyNodes whether to copy nodes too
206     * @since 16212
207     */
208    public Way(Way original, boolean clearMetadata, boolean copyNodes) {
209        super(original.getUniqueId(), true);
210        cloneFrom(original, copyNodes);
211        if (clearMetadata) {
212            clearOsmMetadata();
213        }
214    }
215
216    /**
217     * Constructs a new {@code Way} from an existing {@code Way}.
218     * This adds links from all way nodes to the clone. See #19885 for possible memory leaks.
219     * @param original The original {@code Way} to be identically cloned. Must not be null
220     * @param clearMetadata If {@code true}, clears the OSM id and other metadata as defined by {@link #clearOsmMetadata}.
221     * If {@code false}, does nothing
222     * @since 2410
223     */
224    public Way(Way original, boolean clearMetadata) {
225        this(original, clearMetadata, true);
226    }
227
228    /**
229     * Constructs a new {@code Way} from an existing {@code Way} (including its id).
230     * This adds links from all way nodes to the clone. See #19885 for possible memory leaks.
231     * @param original The original {@code Way} to be identically cloned. Must not be null
232     * @since 86
233     */
234    public Way(Way original) {
235        this(original, false);
236    }
237
238    /**
239     * Constructs a new {@code Way} for the given id. If the id &gt; 0, the way is marked
240     * as incomplete. If id == 0 then way is marked as new
241     *
242     * @param id the id. &gt;= 0 required
243     * @throws IllegalArgumentException if id &lt; 0
244     * @since 343
245     */
246    public Way(long id) {
247        super(id, false);
248    }
249
250    /**
251     * Constructs a new {@code Way} with given id and version.
252     * @param id the id. &gt;= 0 required
253     * @param version the version
254     * @throws IllegalArgumentException if id &lt; 0
255     * @since 2620
256     */
257    public Way(long id, int version) {
258        super(id, version, false);
259    }
260
261    @Override
262    public void load(PrimitiveData data) {
263        if (!(data instanceof WayData))
264            throw new IllegalArgumentException("Not a way data: " + data);
265        boolean locked = writeLock();
266        try {
267            super.load(data);
268
269            List<Long> nodeIds = ((WayData) data).getNodeIds();
270
271            if (!nodeIds.isEmpty() && getDataSet() == null) {
272                throw new AssertionError("Data consistency problem - way without dataset detected");
273            }
274
275            List<Node> newNodes = new ArrayList<>(nodeIds.size());
276            for (Long nodeId : nodeIds) {
277                Node node = (Node) getDataSet().getPrimitiveById(nodeId, OsmPrimitiveType.NODE);
278                if (node != null) {
279                    newNodes.add(node);
280                } else {
281                    throw new AssertionError("Data consistency problem - way with missing node detected");
282                }
283            }
284            setNodes(newNodes);
285        } finally {
286            writeUnlock(locked);
287        }
288    }
289
290    @Override
291    public WayData save() {
292        WayData data = new WayData();
293        saveCommonAttributes(data);
294        for (Node node:nodes) {
295            data.getNodeIds().add(node.getUniqueId());
296        }
297        return data;
298    }
299
300    @Override
301    public void cloneFrom(OsmPrimitive osm, boolean copyNodes) {
302        if (!(osm instanceof Way))
303            throw new IllegalArgumentException("Not a way: " + osm);
304        boolean locked = writeLock();
305        try {
306            super.cloneFrom(osm, copyNodes);
307            if (copyNodes) {
308                setNodes(((Way) osm).getNodes());
309            }
310        } finally {
311            writeUnlock(locked);
312        }
313    }
314
315    @Override
316    public String toString() {
317        String nodesDesc = isIncomplete() ? "(incomplete)" : ("nodes=" + Arrays.toString(nodes));
318        return "{Way id=" + getUniqueId() + " version=" + getVersion()+ ' ' + getFlagsAsString() + ' ' + nodesDesc + '}';
319    }
320
321    @Override
322    public boolean hasEqualSemanticAttributes(OsmPrimitive other, boolean testInterestingTagsOnly) {
323        if (!(other instanceof Way))
324            return false;
325        Way w = (Way) other;
326        if (getNodesCount() != w.getNodesCount()) return false;
327        if (!super.hasEqualSemanticAttributes(other, testInterestingTagsOnly))
328            return false;
329        return IntStream.range(0, getNodesCount())
330                .allMatch(i -> getNode(i).hasEqualSemanticAttributes(w.getNode(i)));
331    }
332
333    /**
334     * Removes the given {@link Node} from this way. Ignored, if n is null.
335     * @param n The node to remove. Ignored, if null
336     * @since 1463
337     */
338    public void removeNode(Node n) {
339        checkDatasetNotReadOnly();
340        if (n == null || isIncomplete()) return;
341        boolean locked = writeLock();
342        try {
343            boolean closed = lastNode() == n && firstNode() == n;
344            int i;
345            List<Node> copy = getNodes();
346            while ((i = copy.indexOf(n)) >= 0) {
347                copy.remove(i);
348            }
349            i = copy.size();
350            if (closed && i > 2) {
351                copy.add(copy.get(0));
352            } else if (i >= 2 && i <= 3 && copy.get(0) == copy.get(i-1)) {
353                copy.remove(i-1);
354            }
355            setNodes(removeDouble(copy));
356            n.clearCachedStyle();
357        } finally {
358            writeUnlock(locked);
359        }
360    }
361
362    /**
363     * Removes the given set of {@link Node nodes} from this way. Ignored, if selection is null.
364     * @param selection The selection of nodes to remove. Ignored, if null
365     * @since 5408
366     */
367    public void removeNodes(Set<? extends Node> selection) {
368        checkDatasetNotReadOnly();
369        if (selection == null || isIncomplete()) return;
370        boolean locked = writeLock();
371        try {
372            setNodes(calculateRemoveNodes(selection));
373            for (Node n : selection) {
374                n.clearCachedStyle();
375            }
376        } finally {
377            writeUnlock(locked);
378        }
379    }
380
381    /**
382     * Calculate the remaining nodes after a removal of the given set of {@link Node nodes} from this way.
383     * @param selection The selection of nodes to remove. Ignored, if null
384     * @return result of the removal, can be empty
385     * @since 17102
386     */
387    public List<Node> calculateRemoveNodes(Set<? extends Node> selection) {
388        if (selection == null || isIncomplete())
389            return getNodes();
390        boolean closed = isClosed() && selection.contains(lastNode());
391        List<Node> copy = Arrays.stream(nodes)
392                .filter(n -> !selection.contains(n))
393                .collect(Collectors.toList());
394
395        int i = copy.size();
396        if (closed && i > 2) {
397            copy.add(copy.get(0));
398        } else if (i >= 2 && i <= 3 && copy.get(0) == copy.get(i-1)) {
399            copy.remove(i-1);
400        }
401        return removeDouble(copy);
402    }
403
404    /**
405     * Adds a node to the end of the list of nodes. Ignored, if n is null.
406     *
407     * @param n the node. Ignored, if null
408     * @throws IllegalStateException if this way is marked as incomplete. We can't add a node
409     * to an incomplete way
410     * @since 1313
411     */
412    public void addNode(Node n) {
413        checkDatasetNotReadOnly();
414        if (n == null) return;
415
416        boolean locked = writeLock();
417        try {
418            if (isIncomplete())
419                throw new IllegalStateException(tr("Cannot add node {0} to incomplete way {1}.", n.getId(), getId()));
420            clearCachedStyle();
421            n.addReferrer(this);
422            nodes = Utils.addInArrayCopy(nodes, n);
423            n.clearCachedStyle();
424            fireNodesChanged();
425        } finally {
426            writeUnlock(locked);
427        }
428    }
429
430    /**
431     * Adds a node at position offs.
432     *
433     * @param offs the offset
434     * @param n the node. Ignored, if null.
435     * @throws IllegalStateException if this way is marked as incomplete. We can't add a node
436     * to an incomplete way
437     * @throws IndexOutOfBoundsException if offs is out of bounds
438     * @since 1313
439     */
440    public void addNode(int offs, Node n) {
441        checkDatasetNotReadOnly();
442        if (n == null) return;
443
444        boolean locked = writeLock();
445        try {
446            if (isIncomplete())
447                throw new IllegalStateException(tr("Cannot add node {0} to incomplete way {1}.", n.getId(), getId()));
448
449            clearCachedStyle();
450            n.addReferrer(this);
451            Node[] newNodes = new Node[nodes.length + 1];
452            System.arraycopy(nodes, 0, newNodes, 0, offs);
453            System.arraycopy(nodes, offs, newNodes, offs + 1, nodes.length - offs);
454            newNodes[offs] = n;
455            nodes = newNodes;
456            n.clearCachedStyle();
457            fireNodesChanged();
458        } finally {
459            writeUnlock(locked);
460        }
461    }
462
463    @Override
464    public void setDeleted(boolean deleted) {
465        boolean locked = writeLock();
466        try {
467            for (Node n:nodes) {
468                if (deleted) {
469                    n.removeReferrer(this);
470                } else {
471                    n.addReferrer(this);
472                }
473                n.clearCachedStyle();
474            }
475            fireNodesChanged();
476            super.setDeleted(deleted);
477        } finally {
478            writeUnlock(locked);
479        }
480    }
481
482    @Override
483    public boolean isClosed() {
484        if (isIncomplete()) return false;
485
486        return nodes.length >= 3 && nodes[nodes.length-1] == nodes[0];
487    }
488
489    /**
490     * Determines if this way denotes an area (closed way with at least three distinct nodes).
491     * @return {@code true} if this way is closed and contains at least three distinct nodes
492     * @see #isClosed
493     * @since 5490
494     */
495    public boolean isArea() {
496        if (this.nodes.length >= 4 && isClosed()) {
497            Node distinctNode = null;
498            for (int i = 1; i < nodes.length-1; i++) {
499                if (distinctNode == null && nodes[i] != nodes[0]) {
500                    distinctNode = nodes[i];
501                } else if (distinctNode != null && nodes[i] != nodes[0] && nodes[i] != distinctNode) {
502                    return true;
503                }
504            }
505        }
506        return false;
507    }
508
509    @Override
510    public Node lastNode() {
511        if (isIncomplete() || nodes.length == 0) return null;
512        return nodes[nodes.length-1];
513    }
514
515    @Override
516    public Node firstNode() {
517        if (isIncomplete() || nodes.length == 0) return null;
518        return nodes[0];
519    }
520
521    @Override
522    public boolean isFirstLastNode(INode n) {
523        if (isIncomplete() || nodes.length == 0) return false;
524        return n == nodes[0] || n == nodes[nodes.length -1];
525    }
526
527    @Override
528    public boolean isInnerNode(INode n) {
529        if (isIncomplete() || nodes.length <= 2) return false;
530        /* circular ways have only inner nodes, so return true for them! */
531        if (n == nodes[0] && n == nodes[nodes.length-1]) return true;
532        return IntStream.range(1, nodes.length - 1)
533                .anyMatch(i -> nodes[i] == n);
534    }
535
536    @Override
537    public OsmPrimitiveType getType() {
538        return OsmPrimitiveType.WAY;
539    }
540
541    @Override
542    public OsmPrimitiveType getDisplayType() {
543        return isClosed() ? OsmPrimitiveType.CLOSEDWAY : OsmPrimitiveType.WAY;
544    }
545
546    private void checkNodes() {
547        DataSet dataSet = getDataSet();
548        if (dataSet != null) {
549            for (Node n: nodes) {
550                if (n.getDataSet() != dataSet)
551                    throw new DataIntegrityProblemException("Nodes in way must be in the same dataset",
552                            tr("Nodes in way must be in the same dataset"));
553                if (n.isDeleted())
554                    throw new DataIntegrityProblemException("Deleted node referenced: " + toString(),
555                            "<html>" + tr("Deleted node referenced by {0}",
556                                    DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(this)) + "</html>",
557                            this, n);
558            }
559            if (Config.getPref().getBoolean("debug.checkNullCoor", true)) {
560                for (Node n: nodes) {
561                    if (n.isVisible() && !n.isIncomplete() && !n.isLatLonKnown())
562                        throw new DataIntegrityProblemException("Complete visible node with null coordinates: " + toString(),
563                                "<html>" + tr("Complete node {0} with null coordinates in way {1}",
564                                        DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(n),
565                                        DefaultNameFormatter.getInstance().formatAsHtmlUnorderedList(this)) + "</html>",
566                                this, n);
567                }
568            }
569        }
570    }
571
572    private void fireNodesChanged() {
573        checkNodes();
574        if (getDataSet() != null) {
575            getDataSet().fireWayNodesChanged(this);
576        }
577    }
578
579    @Override
580    void setDataset(DataSet dataSet) {
581        super.setDataset(dataSet);
582        checkNodes();
583    }
584
585    @Override
586    public BBox getBBox() {
587        if (getDataSet() == null)
588            return new BBox(this);
589        if (bbox == null) {
590            setBBox(new BBox(this));
591        }
592        return bbox;
593    }
594
595    @Override
596    protected void addToBBox(BBox box, Set<PrimitiveId> visited) {
597        box.add(getBBox());
598    }
599
600    private void setBBox(BBox bbox) {
601        this.bbox = bbox == null ? null : bbox.toImmutable();
602    }
603
604    @Override
605    public void updatePosition() {
606        setBBox(new BBox(this));
607        clearCachedStyle();
608    }
609
610    @Override
611    public boolean hasIncompleteNodes() {
612        /*
613         * Ideally, we would store this as a flag, but a node may become
614         * incomplete under some circumstances without being able to notify the
615         * way to recalculate the flag.
616         *
617         * When profiling #20716 on Mesa County, CO (overpass download), the
618         * Arrays.stream method was fairly expensive. When switching to the for
619         * loop, the CPU samples for hasIncompleteNodes went from ~150k samples
620         * to ~8.5k samples (94% improvement) and the memory allocations for
621         * hasIncompleteNodes went from ~15.6 GB to 0.
622         */
623        for (Node node : nodes) {
624            if (node.isIncomplete()) {
625                return true;
626            }
627        }
628        return false;
629    }
630
631    /**
632     * Replies true if all nodes of the way have known lat/lon, false otherwise.
633     * @return true if all nodes of the way have known lat/lon, false otherwise
634     * @since 13033
635     */
636    public boolean hasOnlyLocatableNodes() {
637        // This is used in various places, some of which are on the UI thread.
638        // If this is called many times, the memory allocations can become prohibitive, if
639        // we use Java streams.
640        // This can be easily tested by loading a large amount of ways into JOSM, and then
641        // selecting everything.
642        for (Node node : nodes) {
643            if (!node.isLatLonKnown()) {
644                return false;
645            }
646        }
647        return true;
648    }
649
650    @Override
651    public boolean isUsable() {
652        return super.isUsable() && !hasIncompleteNodes();
653    }
654
655    @Override
656    public boolean isDrawable() {
657        return super.isDrawable() && hasOnlyLocatableNodes();
658    }
659
660    /**
661     * Replies the length of the way, in metres, as computed by {@link ILatLon#greatCircleDistance}.
662     * @return The length of the way, in metres
663     * @since 4138
664     */
665    public double getLength() {
666        double length = 0;
667        Node lastN = null;
668        for (Node n:nodes) {
669            if (lastN != null && lastN.isLatLonKnown() && n.isLatLonKnown()) {
670                length += n.greatCircleDistance(lastN);
671            }
672            lastN = n;
673        }
674        return length;
675    }
676
677    /**
678     * Replies the segment lengths of the way as computed by {@link ILatLon#greatCircleDistance}.
679     *
680     * @return The segment lengths of a way in metres, following way direction
681     * @since 18553
682     */
683    public double[] getSegmentLengths() {
684        return this.segmentLengths().toArray();
685    }
686
687    /**
688     * Replies the length of the longest segment of the way, in metres, as computed by {@link ILatLon#greatCircleDistance}.
689     * @return The length of the segment, in metres
690     * @since 8320
691     */
692    public double getLongestSegmentLength() {
693        return this.segmentLengths().max().orElse(0);
694    }
695
696    /**
697     * Get the segment lengths as a stream
698     * @return The stream of segment lengths (ordered)
699     */
700    private DoubleStream segmentLengths() {
701        DoubleStream.Builder builder = DoubleStream.builder();
702        Node lastN = null;
703        for (Node n : nodes) {
704            if (lastN != null && n.isLatLonKnown() && lastN.isLatLonKnown()) {
705                double distance = n.greatCircleDistance(lastN);
706                builder.accept(distance);
707            }
708            lastN = n;
709        }
710        return builder.build();
711    }
712
713    /**
714     * Tests if this way is a oneway.
715     * @return {@code 1} if the way is a oneway,
716     *         {@code -1} if the way is a reversed oneway,
717     *         {@code 0} otherwise.
718     * @since 5199
719     */
720    public int isOneway() {
721        String oneway = get("oneway");
722        if (oneway != null) {
723            if ("-1".equals(oneway)) {
724                return -1;
725            } else {
726                Boolean isOneway = OsmUtils.getOsmBoolean(oneway);
727                if (isOneway != null && isOneway) {
728                    return 1;
729                }
730            }
731        }
732        return 0;
733    }
734
735    /**
736     * Replies the first node of this way, respecting or not its oneway state.
737     * @param respectOneway If true and if this way is a reversed oneway, replies the last node. Otherwise, replies the first node.
738     * @return the first node of this way, according to {@code respectOneway} and its oneway state.
739     * @since 5199
740     */
741    public Node firstNode(boolean respectOneway) {
742        return !respectOneway || isOneway() != -1 ? firstNode() : lastNode();
743    }
744
745    /**
746     * Replies the last node of this way, respecting or not its oneway state.
747     * @param respectOneway If true and if this way is a reversed oneway, replies the first node. Otherwise, replies the last node.
748     * @return the last node of this way, according to {@code respectOneway} and its oneway state.
749     * @since 5199
750     */
751    public Node lastNode(boolean respectOneway) {
752        return !respectOneway || isOneway() != -1 ? lastNode() : firstNode();
753    }
754
755    @Override
756    public boolean concernsArea() {
757        return hasAreaTags();
758    }
759
760    @Override
761    public boolean isOutsideDownloadArea() {
762        return Arrays.stream(nodes).anyMatch(Node::isOutsideDownloadArea);
763    }
764
765    @Override
766    protected void keysChangedImpl(Map<String, String> originalKeys) {
767        super.keysChangedImpl(originalKeys);
768        clearCachedNodeStyles();
769    }
770
771    /**
772     * Clears all cached styles for all nodes of this way. This should not be called from outside.
773     * @see Node#clearCachedStyle()
774     */
775    public void clearCachedNodeStyles() {
776        for (final Node n : nodes) {
777            n.clearCachedStyle();
778        }
779    }
780
781    /**
782     * Returns angles of vertices.
783     * @return angles of the way
784     * @since 13670
785     */
786    public synchronized List<Pair<Double, Node>> getAngles() {
787        List<Pair<Double, Node>> angles = new ArrayList<>();
788
789        for (int i = 1; i < nodes.length - 1; i++) {
790            Node n0 = nodes[i - 1];
791            Node n1 = nodes[i];
792            Node n2 = nodes[i + 1];
793
794            double angle = Geometry.getNormalizedAngleInDegrees(Geometry.getCornerAngle(
795                    n0.getEastNorth(), n1.getEastNorth(), n2.getEastNorth()));
796            angles.add(new Pair<>(angle, n1));
797        }
798
799        angles.add(new Pair<>(Geometry.getNormalizedAngleInDegrees(Geometry.getCornerAngle(
800                nodes[nodes.length - 2].getEastNorth(),
801                nodes[0].getEastNorth(),
802                nodes[1].getEastNorth())), nodes[0]));
803
804        return angles;
805    }
806
807    @Override
808    public UniqueIdGenerator getIdGenerator() {
809        return idGenerator;
810    }
811}