Uses of Class
org.openstreetmap.josm.data.osm.Node

Packages that use Node

Package	Description
org.openstreetmap.josm.actions	Provides the classes for JOSM user actions.
org.openstreetmap.josm.actions.mapmode	Provides the classes for JOSM map modes.
org.openstreetmap.josm.command	Provides the classes for JOSM commands allowing to modify an OSM data set.
org.openstreetmap.josm.command.conflict	Provides commands for handling conflicts.
org.openstreetmap.josm.data.algorithms	General purpose algorithm classes for OSM data validation.
org.openstreetmap.josm.data.osm	Provides the classes for OSM data: Primitives: Node, Way, Relation Users Tags Changesets Utilities classes
org.openstreetmap.josm.data.osm.event	Provides the classes for OSM dataset events.
org.openstreetmap.josm.data.osm.history	Provides the classes for OSM primitives history (edition revisions).
org.openstreetmap.josm.data.osm.visitor	Provides the classes for performing actions on OSM primitives using Visitor design pattern.
org.openstreetmap.josm.data.osm.visitor.paint.relations	Provides the classes for painting and caching Multipolygon relations.
org.openstreetmap.josm.data.validation	Provides the classes for JOSM data validation.
org.openstreetmap.josm.data.validation.tests	Provides the classes for JOSM data validation tests.
org.openstreetmap.josm.data.validation.util	Provides utilities classes for JOSM data validation.
org.openstreetmap.josm.gui	Provides the classes for JOSM graphical user interface.
org.openstreetmap.josm.gui.conflict.pair.nodes	Provides the classes for displaying conflicts in ways list of nodes.
org.openstreetmap.josm.gui.dialogs	Provides three kinds of dialogs: Toggle dialogs on the right side of the GUI, that can be turned on, off, attached or detached from the GUI Changeset dialog based on a standalone implementation, dedicated to OSM changesets management Extended dialogs for everything else
org.openstreetmap.josm.gui.history	Provides GUI classes for handling history of OSM objects.
org.openstreetmap.josm.gui.layer	Provides classes for handling the different kinds of map layers.
org.openstreetmap.josm.gui.layer.validation	Provides classes for handling validation layer.
org.openstreetmap.josm.io	Provides the classes for JOSM input/output support.
org.openstreetmap.josm.io.remotecontrol.handler	Provides the classes for remote control handlers (features exposed to the browser).
org.openstreetmap.josm.tools	Provides the classes for various utilities and tools called from all other packages.

Uses of Node in org.openstreetmap.josm.actions

Fields in org.openstreetmap.josm.actions declared as Node

Modifier and Type	Field	Description
private Node	CreateCircleAction.PolarNode.node
private Node	UnGlueAction.selectedNode

Fields in org.openstreetmap.josm.actions with type parameters of type Node

Modifier and Type	Field	Description
private java.util.Set<Node>	SelectNonBranchingWaySequences.nodes	endpoints of selected ways
private java.util.Set<Node>	SelectNonBranchingWaySequences.outerNodes	outer endpoints of selected ways
private static java.util.Map<Node,EastNorth>	OrthogonalizeAction.rememberMovements	Remember movements, so the user can later undo it for certain nodes
(package private) java.util.List<Node>	SplitWayAction.SegmentToKeepSelectionDialog.selectedNodes
private java.util.Set<Node>	UnGlueAction.selectedNodes
java.util.List<Node>	OrthogonalizeAction.WayData.wayNodes	The assigned way

Methods in org.openstreetmap.josm.actions that return Node

Modifier and Type	Method	Description
private static Node	UnGlueAction.cloneNode(Node originalNode, java.util.List<Command> cmds)
private Node	JoinAreasAction.WayTraverser.getHeadNode()	Walking through JoinAreasAction.WayInPolygon segments, head node is the current position
private Node	JoinAreasAction.WayTraverser.getPrevNode()	Node just before head node.
private static Node[]	AlignInLineAction.nodeFurthestAppart(java.util.List<Node> nodes)	Return the two nodes the most distant from the provided list.
private static Node[]	AlignInLineAction.nodePairFurthestApart(java.util.List<Node> nodes)	Return 2 nodes making up the line along which provided nodes must be aligned.
static Node	MergeNodesAction.selectTargetLocationNode(java.util.List<Node> candidates)	Select the location of the target node after merge.
static Node	MergeNodesAction.selectTargetNode(java.util.Collection<Node> candidates)	Find which node to merge into (i.e.

Methods in org.openstreetmap.josm.actions that return types with arguments of type Node

Modifier and Type	Method	Description
private static java.util.List<java.util.List<Node>>	JoinAreasAction.buildNodeChunks(Way way, java.util.Collection<Node> splitNodes)	Simple chunking version.
private java.util.List<Node>	UnJoinNodeWayAction.cleanSelectedNodes(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)	Removes irrelevant nodes from user selection.
private static java.util.List<Node>	AlignInCircleAction.collectNodesAnticlockwise(java.util.List<Way> ways)	Assuming all ways can be joined into polygon, create an ordered list of node.
private static java.util.List<Node>	AlignInCircleAction.collectNodesWithExternReferrers(java.util.List<Way> ways)	Collect all nodes with more than one referrer.
private static java.util.Set<Node>	SimplifyWayAction.getMultiUseNodes(Way w)	Calculate a set of nodes which occurs more than once in the way
java.util.List<Node>	JoinAreasAction.AssembledPolygon.getNodes()
private java.util.Collection<Node>	CopyCoordinatesAction.getSelectedNodes()
private static java.util.List<Node>	CombineWayAction.joinWithMultipolygonCode(java.util.Collection<Way> ways)	Use Multipolygon.joinWays(Collection) to join ways.
private static java.util.List<Node>	UnGlueAction.modifyWay(Node originalNode, Way w, java.util.List<Command> cmds, java.util.List<Node> newNodes)	dupe the given node of the given way assume that originalNode is in the way the new node will be put into the parameter newNodes. the add-node command will be put into the parameter cmds. the changed way will be returned and must be put into cmds by the caller!
private static java.util.List<Node>	CreateCircleAction.orderNodesByTrafficHand(java.util.List<Node> nodes)	Order nodes according to left/right hand traffic.
private static java.util.List<Node>	CreateCircleAction.orderNodesByWay(java.util.List<Node> nodes, Way way)	Order nodes according to way direction.
private static java.util.Set<Node>	DistributeAction.removeNodesWithoutCoordinates(java.util.Collection<Node> col)	Remove nodes without known coordinates from a collection.
private static java.util.List<Node>	AlignInCircleAction.sortByAngle(java.util.List<Node> nodes)
protected static java.util.List<Node>	CombineWayAction.tryJoin(java.util.Collection<Way> ways)

Methods in org.openstreetmap.josm.actions with parameters of type Node

Modifier and Type	Method	Description
static void	AlignInCircleAction.addMoveCommandIfNeeded(Node n, PolarCoor coor, java.util.List<Command> cmds)	Add a MoveCommand to move a node to a PolarCoor if there is a significant move.
private void	SelectNonBranchingWaySequences.addNodes(Node node)	Add a way endpoint to nodes, outerNodes
private static Command	AlignInLineAction.alignSingleNode(Node node, java.util.List<AlignInLineAction.Line> lines)	Align a single node relative to a set of lines #9081
private static Node	UnGlueAction.cloneNode(Node originalNode, java.util.List<Command> cmds)
int	JoinNodeWayAction.NodeDistanceToRefNodeComparator.compare(Node first, Node second)
static void	MergeNodesAction.doMergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)	Merges the nodes in nodes at the specified node's location.
private static Way	SelectNonBranchingWaySequences.findWay(java.util.Collection<OsmPrimitive> selection, Node node)	Finds out if the current selection can be extended.
protected static java.util.List<Command>	MergeNodesAction.fixParentWays(java.util.Collection<Node> nodesToDelete, Node targetNode)	Fixes the parent ways referring to one of the nodes.
private static double	JoinAreasAction.WayTraverser.getAngle(Node n1, Node n2, Node n3)	Returns oriented angle (N1N2, N1N3) in range [0; 2*Math.PI[
private static java.util.List<AlignInLineAction.Line>	AlignInLineAction.getInvolvedLines(Node node, java.util.List<Way> refWays)	Get lines useful to do alignment of a single node
Command	AlignInLineAction.Line.intersectionCommand(Node n, AlignInLineAction.Line other)	Intersection of two line.
protected static boolean	SimplifyWayAction.isRequiredNode(Way way, Node node, java.util.Set<Node> multipleUseNodes)	Replies true if node is a required node which can't be removed in order to simplify the way.
static Command	MergeNodesAction.mergeNodes(java.util.Collection<Node> nodes, Node targetLocationNode)	Merges the nodes in nodes at the specified node's location.
static Command	MergeNodesAction.mergeNodes(java.util.Collection<Node> nodes, Node targetNode, Node targetLocationNode)	Merges the nodes in nodes onto one of the nodes.
private static java.util.List<Node>	UnGlueAction.modifyWay(Node originalNode, Way w, java.util.List<Command> cmds, java.util.List<Node> newNodes)	dupe the given node of the given way assume that originalNode is in the way the new node will be put into the parameter newNodes. the add-node command will be put into the parameter cmds. the changed way will be returned and must be put into cmds by the caller!
private static Command	OrthogonalizeAction.orthogonalize(java.util.List<OrthogonalizeAction.WayData> wayDataList, Node singleNode)	Try to orthogonalize the given ways by moving only a single given node
Command	AlignInLineAction.Line.projectionCommand(Node n)	Orthogonal projection of a node N along this line.
(package private) static void	UnGlueAction.update(PropertiesMembershipChoiceDialog dialog, Node existingNode, java.util.List<Node> newNodes, java.util.List<Command> cmds)
private static void	UnGlueAction.updateMemberships(PropertiesMembershipChoiceDialog.ExistingBothNew memberships, Node originalNode, java.util.List<Node> newNodes, java.util.List<Command> cmds)	put all newNodes into the same relation(s) that originalNode is in
private static void	UnGlueAction.updateProperties(PropertiesMembershipChoiceDialog.ExistingBothNew tags, Node existingNode, java.lang.Iterable<Node> newNodes, java.util.List<Command> cmds)
void	UploadSelectionAction.UploadHullBuilder.visit(Node n)

Method parameters in org.openstreetmap.josm.actions with type arguments of type Node

Modifier and Type	Method	Description
private static Command	AlignInLineAction.alignOnlyNodes(java.util.List<Node> nodes)	Align nodes in case 3 or more nodes are selected.
private static java.util.List<java.util.List<Node>>	JoinAreasAction.buildNodeChunks(Way way, java.util.Collection<Node> splitNodes)	Simple chunking version.
protected static void	SimplifyWayAction.buildSimplifiedNodeList(java.util.List<Node> wnew, int from, int to, double threshold, java.util.List<Node> simplifiedNodes)	Builds the simplified list of nodes for a way segment given by a lower index from and an upper index to.
protected static void	CombineWayAction.detectReversedWays(java.util.Collection<Way> ways, java.util.List<Node> path, java.util.List<Way> reversedWays, java.util.List<Way> unreversedWays)
private static java.util.Collection<Command>	DistributeAction.distributeNodes(java.util.Collection<Node> nodes)	Distribute nodes when only nodes are selected.
static void	MergeNodesAction.doMergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)	Merges the nodes in nodes at the specified node's location.
static void	SplitWayAction.doSplitWayShowSegmentSelection(Way splitWay, java.util.List<Node> splitNodes, java.util.List<OsmPrimitive> selection)	Perform way splitting after presenting the user with a choice which way segment history should be preserved (in expert mode)
protected static java.util.List<Command>	MergeNodesAction.fixParentWays(java.util.Collection<Node> nodesToDelete, Node targetNode)	Fixes the parent ways referring to one of the nodes.
private static boolean	UnGlueAction.isRelationAffected(Relation r, java.util.Set<Node> affectedNodes, java.util.Collection<Way> ways)
protected static boolean	SimplifyWayAction.isRequiredNode(Way way, Node node, java.util.Set<Node> multipleUseNodes)	Replies true if node is a required node which can't be removed in order to simplify the way.
private Way	JoinAreasAction.keepOlder(Way way, java.util.Map<Node,Way> oldestWayMap, java.util.List<Way> discardedWays)	Create copy of given way using an older id so that we don't create a new way instead of a modified old one.
static Command	MergeNodesAction.mergeNodes(java.util.Collection<Node> nodes, Node targetLocationNode)	Merges the nodes in nodes at the specified node's location.
static Command	MergeNodesAction.mergeNodes(java.util.Collection<Node> nodes, Node targetNode, Node targetLocationNode)	Merges the nodes in nodes onto one of the nodes.
static Command	AlignInCircleAction.moveNodesCommand(java.util.List<Node> nodes, java.util.Set<Node> fixNodes, EastNorth center, double radius)	Move each node of the list of nodes to be arranged in a circle.
static Command	AlignInCircleAction.moveNodesCommand(java.util.List<Node> nodes, java.util.Set<Node> fixNodes, EastNorth center, double radius)	Move each node of the list of nodes to be arranged in a circle.
private static Node[]	AlignInLineAction.nodeFurthestAppart(java.util.List<Node> nodes)	Return the two nodes the most distant from the provided list.
private static Node[]	AlignInLineAction.nodePairFurthestApart(java.util.List<Node> nodes)	Return 2 nodes making up the line along which provided nodes must be aligned.
private static java.util.List<Node>	CreateCircleAction.orderNodesByTrafficHand(java.util.List<Node> nodes)	Order nodes according to left/right hand traffic.
private static java.util.List<Node>	CreateCircleAction.orderNodesByWay(java.util.List<Node> nodes, Way way)	Order nodes according to way direction.
private static java.util.Set<Node>	DistributeAction.removeNodesWithoutCoordinates(java.util.Collection<Node> col)	Remove nodes without known coordinates from a collection.
static Node	MergeNodesAction.selectTargetLocationNode(java.util.List<Node> candidates)	Select the location of the target node after merge.
static Node	MergeNodesAction.selectTargetNode(java.util.Collection<Node> candidates)	Find which node to merge into (i.e.
private static java.util.List<Node>	AlignInCircleAction.sortByAngle(java.util.List<Node> nodes)
private java.util.List<Way>	JoinAreasAction.splitWayOnNodes(Way way, java.util.Set<Node> nodes, java.util.Map<Node,Way> oldestWayMap)	This is a method that splits way into smaller parts, using the prepared nodes list as split points.
private java.util.List<Way>	JoinAreasAction.splitWayOnNodes(Way way, java.util.Set<Node> nodes, java.util.Map<Node,Way> oldestWayMap)	This is a method that splits way into smaller parts, using the prepared nodes list as split points.
(package private) static void	UnGlueAction.update(PropertiesMembershipChoiceDialog dialog, Node existingNode, java.util.List<Node> newNodes, java.util.List<Command> cmds)
private static void	UnGlueAction.updateMemberships(PropertiesMembershipChoiceDialog.ExistingBothNew memberships, Node originalNode, java.util.List<Node> newNodes, java.util.List<Command> cmds)	put all newNodes into the same relation(s) that originalNode is in
private static void	UnGlueAction.updateProperties(PropertiesMembershipChoiceDialog.ExistingBothNew tags, Node existingNode, java.lang.Iterable<Node> newNodes, java.util.List<Command> cmds)
private static boolean	AlignInCircleAction.validateGeometry(java.util.List<Node> nodes)

Constructors in org.openstreetmap.josm.actions with parameters of type Node

Constructor	Description
Line(Node first, Node last)	Init a line by 2 nodes.
NodeDistanceToRefNodeComparator(Node referenceNode, Node referenceNode2, boolean projectFirst)
PolarNode(EastNorth center, Node n)

Constructor parameters in org.openstreetmap.josm.actions with type arguments of type Node

Constructor	Description
WayData(java.util.List<Node> wayNodes)

Uses of Node in org.openstreetmap.josm.actions.mapmode

Fields in org.openstreetmap.josm.actions.mapmode declared as Node

Modifier and Type	Field	Description
private Node	ImproveWayAccuracyAction.candidateNode
private Node	DrawAction.currentBaseNode
private Node	DrawAction.lastUsedNode
private Node	DrawAction.mouseOnExistingNode
private Node	DeleteAction.DeleteParameters.nearestNode
private Node	DrawAction.previousNode
private Node	ExtrudeAction.selectedNode
private Node	SelectAction.VirtualManager.virtualNode

Fields in org.openstreetmap.josm.actions.mapmode with type parameters of type Node

Modifier and Type	Field	Description
private java.util.List<Node>	ExtrudeAction.movingNodeList	Collection of nodes that is moved
private java.util.List<Node>	ParallelWays.sortedNodes
private java.util.List<Node>	SplitMode.SplitWayActionConcrete.splitNodes

Methods in org.openstreetmap.josm.actions.mapmode that return Node

Modifier and Type	Method	Description
private static Node	ParallelWays.copyNode(Node source, boolean copyTags)
static Node	ImproveWayAccuracyHelper.findCandidateNode(MapView mv, Way w, java.awt.Point p)	Returns the nearest node to cursor.
private Node	DrawAction.findNodeToContinueFrom(Node selectedNode, Way selectedWay)	Finds a node to continue drawing from.
private Node	SelectAction.findNodeToMergeTo(java.awt.Point p)	Tries to find a node to merge to when in move-merge mode for the current mouse position.
Node	DrawAction.getCurrentBaseNode()	Replies the current base node, after having checked it is still usable (see #11105).
private Node	ExtrudeAction.getNextNode(int index)	Gets a node from selected way after given index.
private Node	ExtrudeAction.getPreviousNode(int index)	Gets a node from selected way before given index.

Methods in org.openstreetmap.josm.actions.mapmode with parameters of type Node

Modifier and Type	Method	Description
private static void	DrawAction.adjustNode(java.util.Collection<Pair<Node,Node>> segs, Node n)	Adjusts the position of a node to lie on a segment (or a segment intersection).
private static void	DrawAction.adjustNodeDefault(java.util.Collection<Pair<Node,Node>> segs, Node n)
private static void	DrawAction.adjustNodeTwoSegments(java.util.Collection<Pair<Node,Node>> segs, Node n)
private void	DrawAction.continueWayFromNode(Way way, Node node)	if one of the ends of way is given node, then set currentBaseNode = node and previousNode = adjacent node of way
private static Node	ParallelWays.copyNode(Node source, boolean copyTags)
private static void	ParallelWays.copyNodeInMap(java.util.Map<Node,Node> splitNodeMap, Node node, boolean copyTags)
private javax.swing.JPopupMenu	SplitMode.createPopup(Node n, java.util.Collection<Way> applicableWays)	Create a new split way selection popup
private static boolean	ImproveWayAccuracyHelper.ensureCandidateIsNotBehindSegments(java.lang.Iterable<Pair<Node,Node>> wpps, Node n, EastNorth pEN, EastNorth nEN)	Check to see if a candidate node is underneath a way segment
private Node	DrawAction.findNodeToContinueFrom(Node selectedNode, Way selectedWay)	Finds a node to continue drawing from.
private static java.util.List<Way>	SplitMode.getApplicableWays(Node n, java.util.Collection<Way> preferredWays)	Get a list of potential ways to be split for a given node
private static java.lang.String	DrawAction.getTitle(boolean newNode, Node n, java.util.Collection<OsmPrimitive> newSelection, java.util.Map<Way,java.util.List<Node>> reuseWays, boolean extendedWay)
static Way	DrawAction.getWayForNode(Node n)	Replies the parent way of a node, if it is the end of exactly one usable way.
private static boolean	ExtrudeAction.hasNodeOtherWays(Node node, Way myWay)	This method tests if node has other ways apart from the given one.
private void	DrawAction.insertNodeIntoAllNearbySegments(java.util.List<WaySegment> wss, Node n, java.util.Collection<OsmPrimitive> newSelection, java.util.Collection<Command> cmds, java.util.Map<Way,java.util.List<Node>> reuseWays)
private boolean	DrawAction.isSelfContainedWay(Way selectedWay, Node currentNode, Node targetNode)	Prevent creation of ways that look like this: <----> This happens if users want to draw a no-exit-sideway from the main way like this: ^ |<----> | The solution isn't ideal because the main way will end in the side way, which is bad for navigation software ("drive straight on") but at least easier to fix.
void	SelectAction.mergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)	Merge nodes using MergeNodesAction.
private void	DrawAction.tryToMoveNodeOnIntersection(java.util.List<WaySegment> wss, Node n)

Method parameters in org.openstreetmap.josm.actions.mapmode with type arguments of type Node

Modifier and Type	Method	Description
private static void	DrawAction.adjustNode(java.util.Collection<Pair<Node,Node>> segs, Node n)	Adjusts the position of a node to lie on a segment (or a segment intersection).
private static void	DrawAction.adjustNode(java.util.Collection<Pair<Node,Node>> segs, Node n)	Adjusts the position of a node to lie on a segment (or a segment intersection).
private static void	DrawAction.adjustNodeDefault(java.util.Collection<Pair<Node,Node>> segs, Node n)
private static void	DrawAction.adjustNodeDefault(java.util.Collection<Pair<Node,Node>> segs, Node n)
private static void	DrawAction.adjustNodeTwoSegments(java.util.Collection<Pair<Node,Node>> segs, Node n)
private static void	DrawAction.adjustNodeTwoSegments(java.util.Collection<Pair<Node,Node>> segs, Node n)
private static void	ParallelWays.copyNodeInMap(java.util.Map<Node,Node> splitNodeMap, Node node, boolean copyTags)
private static void	ParallelWays.copyNodeInMap(java.util.Map<Node,Node> splitNodeMap, Node node, boolean copyTags)
private static boolean	SelectAction.doesImpactStatusLine(java.util.Collection<Node> affectedNodes, java.util.Collection<Way> selectedWays)
private static boolean	ImproveWayAccuracyHelper.ensureCandidateIsNotBehindSegments(java.lang.Iterable<Pair<Node,Node>> wpps, Node n, EastNorth pEN, EastNorth nEN)	Check to see if a candidate node is underneath a way segment
private static boolean	ImproveWayAccuracyHelper.ensureCandidateIsNotBehindSegments(java.lang.Iterable<Pair<Node,Node>> wpps, Node n, EastNorth pEN, EastNorth nEN)	Check to see if a candidate node is underneath a way segment
private static java.lang.String	DrawAction.getTitle(boolean newNode, Node n, java.util.Collection<OsmPrimitive> newSelection, java.util.Map<Way,java.util.List<Node>> reuseWays, boolean extendedWay)
private void	DrawAction.insertNodeIntoAllNearbySegments(java.util.List<WaySegment> wss, Node n, java.util.Collection<OsmPrimitive> newSelection, java.util.Collection<Command> cmds, java.util.Map<Way,java.util.List<Node>> reuseWays)
private void	ExtrudeAction.joinNodesIfCollapsed(java.util.List<Node> changedNodes)
void	SelectAction.mergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)	Merge nodes using MergeNodesAction.

Constructor parameters in org.openstreetmap.josm.actions.mapmode with type arguments of type Node

Constructor	Description
SplitWayActionConcrete(Way splitWay, java.util.List<Node> splitNodes, java.util.List<OsmPrimitive> selection)	Construct an action to split way splitWay at nodes splitNodes

Uses of Node in org.openstreetmap.josm.command

Classes in org.openstreetmap.josm.command with type parameters of type Node

Modifier and Type	Class	Description
class	AbstractNodesCommand<C extends java.util.Collection<Node>>	Abstracts superclass of ChangeNodesCommand / RemoveNodesCommand.

Fields in org.openstreetmap.josm.command with type parameters of type Node

Modifier and Type	Field	Description
private java.util.Collection<Node>	MoveCommand.nodes	The objects that should be moved.
protected java.util.Collection<Node>	TransformNodesCommand.nodes	The nodes to transform.
protected java.util.Map<Node,Command.OldNodeState>	TransformNodesCommand.oldStates	List of all old states of the nodes.

Methods in org.openstreetmap.josm.command that return types with arguments of type Node

Modifier and Type	Method	Description
static java.util.List<java.util.List<Node>>	SplitWayCommand.buildSplitChunks(Way wayToSplit, java.util.List<Node> splitPoints)	Splits the nodes of wayToSplit into a list of node sequences which are separated at the nodes in splitPoints.
protected static java.util.Collection<Node>	DeleteCommand.computeNodesToDelete(java.util.Collection<OsmPrimitive> primitivesToDelete)	Replies the collection of nodes referred to by primitives in primitivesToDelete which can be deleted too.
java.util.Collection<Node>	MoveCommand.getParticipatingPrimitives()
java.util.Collection<Node>	TransformNodesCommand.getTransformedNodes()	Get the nodes with the current transformation applied.

Methods in org.openstreetmap.josm.command with parameters of type Node

Modifier and Type	Method	Description
void	Command.CloneVisitor.visit(Node n)

Method parameters in org.openstreetmap.josm.command with type arguments of type Node

Modifier and Type	Method	Description
static java.util.List<java.util.List<Node>>	SplitWayCommand.buildSplitChunks(Way wayToSplit, java.util.List<Node> splitPoints)	Splits the nodes of wayToSplit into a list of node sequences which are separated at the nodes in splitPoints.
static java.util.List<Way>	SplitWayCommand.createNewWaysFromChunks(Way way, java.lang.Iterable<java.util.List<Node>> wayChunks)	Creates new way objects for the way chunks and transfers the keys from the original way.
double	MoveCommand.getDistance(java.util.function.Predicate<Node> predicate)	Computes the move distance for one node matching the specified predicate
static SplitWayCommand	SplitWayCommand.split(Way way, java.util.List<Node> atNodes, java.util.Collection<? extends OsmPrimitive> selection)	Splits the way way at the nodes in atNodes and replies the result of this process in an instance of SplitWayCommand.
static SplitWayCommand	SplitWayCommand.splitWay(Way way, java.util.List<java.util.List<Node>> wayChunks, java.util.Collection<? extends OsmPrimitive> selection)	Splits the way way into chunks of wayChunks and replies the result of this process in an instance of SplitWayCommand.
static SplitWayCommand	SplitWayCommand.splitWay(Way way, java.util.List<java.util.List<Node>> wayChunks, java.util.Collection<? extends OsmPrimitive> selection, SplitWayCommand.Strategy splitStrategy)	Splits the way way into chunks of wayChunks and replies the result of this process in an instance of SplitWayCommand.
static java.util.Optional<SplitWayCommand>	SplitWayCommand.splitWay(Way way, java.util.List<java.util.List<Node>> wayChunks, java.util.Collection<? extends OsmPrimitive> selection, SplitWayCommand.Strategy splitStrategy, SplitWayCommand.WhenRelationOrderUncertain whenRelationOrderUncertain)	Splits the way way into chunks of wayChunks and replies the result of this process in an instance of SplitWayCommand.
private static SplitWayCommand.RelationInformation	SplitWayCommand.treatAsRestriction(Relation r, RelationMember rm, Relation c, java.util.Collection<Way> newWays, Way way, java.util.List<Node> changedWayNodes)

Constructors in org.openstreetmap.josm.command with parameters of type Node

Constructor	Description
MoveCommand(Node node, LatLon position)	Constructs a new MoveCommand to move a node.
OldNodeState(Node node)	Constructs a new OldNodeState for the given node.

Constructor parameters in org.openstreetmap.josm.command with type arguments of type Node

Constructor	Description
ChangeNodesCommand(DataSet ds, Way way, java.util.List<Node> newNodes)	Constructs a new ChangeNodesCommand.
ChangeNodesCommand(Way way, java.util.List<Node> newNodes)	Constructs a new ChangeNodesCommand.
RemoveNodesCommand(DataSet ds, Way way, java.util.Set<Node> rmNodes)	Constructs a new RemoveNodesCommand.
RemoveNodesCommand(Way way, java.util.Set<Node> rmNodes)	Constructs a new RemoveNodesCommand.

Uses of Node in org.openstreetmap.josm.command.conflict

Fields in org.openstreetmap.josm.command.conflict with type parameters of type Node

Modifier and Type	Field	Description
private java.util.List<Node>	WayNodesConflictResolverCommand.mergedNodeList	the list of merged nodes.

Constructor parameters in org.openstreetmap.josm.command.conflict with type arguments of type Node

Constructor	Description
WayNodesConflictResolverCommand(Conflict<? extends OsmPrimitive> conflict, java.util.List<Node> mergedNodeList)	Constructs a new WayNodesConflictResolverCommand.

Uses of Node in org.openstreetmap.josm.data.algorithms

Fields in org.openstreetmap.josm.data.algorithms with type parameters of type Node

Modifier and Type	Field	Description
private java.util.Map<Node,java.util.List<Node>>	Tarjan.graphMap	Used to store the graph data as a map.
private java.util.Map<Node,java.util.List<Node>>	Tarjan.graphMap	Used to store the graph data as a map.
private java.util.Collection<java.util.List<Node>>	Tarjan.scc	Used to store strongly connected components.
private java.util.Deque<Node>	Tarjan.stack	Used on algorithm runtime to keep track discovery progress.

Methods in org.openstreetmap.josm.data.algorithms that return types with arguments of type Node

Modifier and Type	Method	Description
java.util.Map<Node,java.util.List<Node>>	Tarjan.getGraphMap()	Returns the graph data as a map.
java.util.Map<Node,java.util.List<Node>>	Tarjan.getGraphMap()	Returns the graph data as a map.
java.util.Collection<java.util.List<Node>>	Tarjan.getSCC()	Returns the strongly connected components in the current graph.
private java.util.List<Node>	Tarjan.getSuccessors(Node node)	Returns the next direct successors from the graph of the given node.

Methods in org.openstreetmap.josm.data.algorithms with parameters of type Node

Modifier and Type	Method	Description
private java.util.List<Node>	Tarjan.getSuccessors(Node node)	Returns the next direct successors from the graph of the given node.
private void	Tarjan.strongConnect(Node u0)	Calculates strongly connected components available from the given node, in an iterative fashion.

Uses of Node in org.openstreetmap.josm.data.osm

Fields in org.openstreetmap.josm.data.osm declared as Node

Modifier and Type	Field	Description
private Node	NodePair.a
private Node	NodePair.b
private static Node[]	Way.EMPTY_NODES
private Node[]	Way.nodes	All way nodes in this way

Fields in org.openstreetmap.josm.data.osm with type parameters of type Node

Modifier and Type	Field	Description
java.util.List<Node>	MultipolygonBuilder.JoinedPolygon.nodes	the nodes of the polygon, first node is not duplicated as last node.
private java.util.Map<Node,java.util.List<NodePair>>	NodeGraph.predecessors
private QuadBucketPrimitiveStore<Node,Way,Relation>	DataSet.store
private java.util.Map<Node,java.util.List<NodePair>>	NodeGraph.successors

Methods in org.openstreetmap.josm.data.osm that return Node

Modifier and Type	Method	Description
Node	Way.firstNode()
Node	Way.firstNode(boolean respectOneway)	Replies the first node of this way, respecting or not its oneway state.
Node	NodePair.getA()	Replies the first node.
Node	NodePair.getB()	Replies the second node
Node	RelationMember.getNode()	Returns the relation member as a node.
Node	Way.getNode(int index)
Node	Way.lastNode()
Node	Way.lastNode(boolean respectOneway)	Replies the last node of this way, respecting or not its oneway state.
private static Node	OsmUtils.newNode(LatLon around)

Methods in org.openstreetmap.josm.data.osm that return types with arguments of type Node

Modifier and Type	Method	Description
protected java.util.List<Node>	NodeGraph.buildPathFromNodePairs(java.util.Deque<NodePair> path)
java.util.List<Node>	NodeGraph.buildSpanningPath()	Tries to find a path through the graph which visits each edge (i.e.
protected java.util.List<Node>	NodeGraph.buildSpanningPath(Node startNode)	Tries to find a spanning path starting from node startNode.
java.util.List<Node>	NodeGraph.buildSpanningPathNoRemove()	Tries to find a path through the graph which visits each edge (i.e.
java.util.List<Node>	Way.calculateRemoveNodes(java.util.Set<? extends Node> selection)	Calculate the remaining nodes after a removal of the given set of nodes from this way.
java.util.Map<Node,java.util.List<Node>>	NodeGraph.createMap()	Constructs a lookup table from the existing edges in the graph to enable efficient querying.
java.util.Map<Node,java.util.List<Node>>	NodeGraph.createMap()	Constructs a lookup table from the existing edges in the graph to enable efficient querying.
java.util.List<Pair<java.lang.Double,Node>>	Way.getAngles()	Returns angles of vertices.
private java.util.Set<Node>	NodeGraph.getMostFrequentVisitedNodesFirst()	Sort the nodes by number of appearances in the edges.
java.util.Set<Node>	Way.getNeighbours(Node node)	Return nodes adjacent to node
java.util.List<Pair<Node,Node>>	Way.getNodePairs(boolean sort)	Replies the ordered List of chunks of this way.
java.util.List<Pair<Node,Node>>	Way.getNodePairs(boolean sort)	Replies the ordered List of chunks of this way.
java.util.Collection<Node>	DataSet.getNodes()
java.util.List<Node>	MultipolygonBuilder.JoinedPolygon.getNodes()	Builds a list of nodes for this polygon.
java.util.Collection<Node>	NodeGraph.getNodes()	Return the graph's nodes.
java.util.List<Node>	Way.getNodes()
protected java.util.Set<Node>	NodeGraph.getTerminalNodes()	Return the terminal nodes of the graph.
private static java.util.List<Node>	Way.removeDouble(java.util.List<Node> nodes)	Prevent directly following identical nodes in ways.
java.util.List<Node>	DataSet.searchNodes(BBox bbox)

Methods in org.openstreetmap.josm.data.osm with parameters of type Node

Modifier and Type	Method	Description
void	Way.addNode(int offs, Node n)	Adds a node at position offs.
void	Way.addNode(Node n)	Adds a node to the end of the list of nodes.
protected java.util.List<Node>	NodeGraph.buildSpanningPath(Node startNode)	Tries to find a spanning path starting from node startNode.
int	NodePositionComparator.compare(Node n1, Node n2)
boolean	NodePair.contains(Node n)	Determines if this pair contains the given node.
boolean	DataSet.containsNode(Node n)	Determines if the given node can be retrieved in the data set through its bounding box.
boolean	Way.containsNode(Node node)	Replies true if this way contains the node node, false otherwise.
(package private) void	DataSet.fireNodeMoved(Node node, LatLon newCoor, EastNorth eastNorth)
static WaySegment	WaySegment.forNodePair(Way way, Node first, Node second)	Determines and returns the way segment for the given way and node pair.
private java.util.List<NodePair>	NodeGraph.getConnectedPairs(Node node)
java.util.Set<Node>	Way.getNeighbours(Node node)	Return nodes adjacent to node
protected java.util.List<NodePair>	NodeGraph.getOutboundPairs(Node node)
private boolean	Node.hasEqualCoordinates(Node other)
protected boolean	NodeGraph.isTerminalNode(Node n)	Replies true if n is a terminal node of the graph.
void	Way.removeNode(Node n)	Removes the given Node from this way.
java.util.Set<Way>	DataSet.unlinkNodeFromWays(Node node)	Removes all references from ways in this dataset to a particular node.

Method parameters in org.openstreetmap.josm.data.osm with type arguments of type Node

Modifier and Type	Method	Description
java.util.List<Node>	Way.calculateRemoveNodes(java.util.Set<? extends Node> selection)	Calculate the remaining nodes after a removal of the given set of nodes from this way.
java.util.Map<OsmPrimitive,OsmPrimitive>	DataSet.clonePrimitives(java.lang.Iterable<Node> nodes, java.lang.Iterable<Way> ways, java.lang.Iterable<Relation> relations)	Clones the specified primitives into this data set.
private static java.util.List<Node>	Way.removeDouble(java.util.List<Node> nodes)	Prevent directly following identical nodes in ways.
void	Way.removeNodes(java.util.Set<? extends Node> selection)	Removes the given set of nodes from this way.
void	Way.setNodes(java.util.List<Node> nodes)

Constructors in org.openstreetmap.josm.data.osm with parameters of type Node

Constructor	Description
Node(Node clone)	Constructs an identical clone of the argument (including the id).
Node(Node clone, boolean clearMetadata)	Constructs an identical clone of the argument.
NodePair(Node a, Node b)	Constructs a new NodePair.

Constructor parameters in org.openstreetmap.josm.data.osm with type arguments of type Node

Constructor	Description
NodePair(Pair<Node,Node> pair)	Constructs a new NodePair.
NodePair(Pair<Node,Node> pair)	Constructs a new NodePair.

Uses of Node in org.openstreetmap.josm.data.osm.event

Fields in org.openstreetmap.josm.data.osm.event declared as Node

Modifier and Type	Field	Description
private Node	NodeMovedEvent.node

Methods in org.openstreetmap.josm.data.osm.event that return Node

Modifier and Type	Method	Description
Node	NodeMovedEvent.getNode()	Returns the node affected by the move.

Constructors in org.openstreetmap.josm.data.osm.event with parameters of type Node

Constructor	Description
NodeMovedEvent(DataSet dataSet, Node node)	Constructs a new NodeMovedEvent.

Uses of Node in org.openstreetmap.josm.data.osm.history

Constructors in org.openstreetmap.josm.data.osm.history with parameters of type Node

Constructor	Description
HistoryNode(Node n)	Constructs a new HistoryNode from an existing Node.

Uses of Node in org.openstreetmap.josm.data.osm.visitor

Fields in org.openstreetmap.josm.data.osm.visitor with type parameters of type Node

Modifier and Type	Field	Description
java.util.Collection<Node>	AllNodesVisitor.nodes	The resulting nodes collected so far.

Methods in org.openstreetmap.josm.data.osm.visitor that return types with arguments of type Node

Modifier and Type	Method	Description
static java.util.Collection<Node>	AllNodesVisitor.getAllNodes(java.util.Collection<? extends OsmPrimitive> osms)	Replies all nodes contained by the given primitives

Methods in org.openstreetmap.josm.data.osm.visitor with parameters of type Node

Modifier and Type	Method	Description
protected void	MergeSourceBuildingVisitor.rememberNode(Node n)	Remembers a node in the "hull"
void	AllNodesVisitor.visit(Node n)	Nodes have only itself as nodes.
void	BoundingXYVisitor.visit(Node n)
void	MergeSourceBuildingVisitor.visit(Node n)
void	OsmPrimitiveVisitor.visit(Node n)	Visiting call for points.

Uses of Node in org.openstreetmap.josm.data.osm.visitor.paint.relations

Fields in org.openstreetmap.josm.data.osm.visitor.paint.relations with type parameters of type Node

Modifier and Type	Field	Description
protected java.util.List<Node>	Multipolygon.JoinedWay.nodes
private java.util.List<Node>	Multipolygon.openEnds

Methods in org.openstreetmap.josm.data.osm.visitor.paint.relations that return Node

Modifier and Type	Method	Description
Node	Multipolygon.JoinedWay.getFirstNode()	Returns the first node.
Node	Multipolygon.JoinedWay.getLastNode()	Returns the last node.

Methods in org.openstreetmap.josm.data.osm.visitor.paint.relations that return types with arguments of type Node

Modifier and Type	Method	Description
java.util.List<Node>	Multipolygon.JoinedWay.getNodes()	Replies the list of nodes.
java.util.List<Node>	Multipolygon.getOpenEnds()	Returns the start and end node of non-closed rings.

Constructor parameters in org.openstreetmap.josm.data.osm.visitor.paint.relations with type arguments of type Node

Constructor	Description
JoinedWay(java.util.List<Node> nodes, java.util.Collection<java.lang.Long> wayIds, boolean selected)	Constructs a new JoinedWay.
PolyData(java.util.List<Node> nodes, boolean selected, java.util.Collection<java.lang.Long> wayIds)

Uses of Node in org.openstreetmap.josm.data.validation

Methods in org.openstreetmap.josm.data.validation that return types with arguments of type Node

Modifier and Type	Method	Description
private static java.util.List<java.util.List<Node>>	TestError.getHiliteNodesForArea(java.awt.geom.Area area)	Calculate list of node pairs describing the area.

Methods in org.openstreetmap.josm.data.validation with parameters of type Node

Modifier and Type	Method	Description
void	Test.TagTest.visit(Node n)
void	Test.visit(Node n)

Method parameters in org.openstreetmap.josm.data.validation with type arguments of type Node

Modifier and Type	Method	Description
TestError.Builder	TestError.Builder.highlightNodePairs(java.util.Collection<java.util.List<Node>> highlighted)	Sets the node pairs to highlight when selecting this error.
void	ValidatorVisitor.visit(java.util.List<Node> nodes)	Visit a list of nodes that are part of the error

Uses of Node in org.openstreetmap.josm.data.validation.tests

Fields in org.openstreetmap.josm.data.validation.tests declared as Node

Modifier and Type	Field	Description
private Node	UnconnectedWays.MyWaySegment.n1
private Node	UnconnectedWays.MyWaySegment.n2

Fields in org.openstreetmap.josm.data.validation.tests with type parameters of type Node

Modifier and Type	Field	Description
private java.util.Set<Node>	PowerLines.badConnections
private java.util.Set<Node>	UnconnectedWays.endnodes
private java.util.Set<Node>	UnconnectedWays.middlenodes
private java.util.Set<Node>	PowerLines.missingTags
private MultiMap<Pair<Node,Node>,WaySegment>	OverlappingWays.nodePairs	Bag of all way segments
private MultiMap<Pair<Node,Node>,WaySegment>	OverlappingWays.nodePairs	Bag of all way segments
private java.util.Set<Node>	UnconnectedWays.nodesToTest
private java.util.Set<Node>	UnconnectedWays.othernodes
private QuadBuckets<Node>	UnconnectedWays.searchNodes
private java.util.List<java.util.Set<Node>>	PowerLines.segmentRefDiscontinuities
private java.util.Set<Node>	MultipolygonTest.PolygonLevelFinder.sharedNodes

Methods in org.openstreetmap.josm.data.validation.tests that return Node

Modifier and Type	Method	Description
private Node	MultipolygonTest.PolygonLevelFinder.getNonIntersectingNode(Multipolygon.PolyData pd1, Multipolygon.PolyData pd2)	Find node of pd2 which is not an intersection node with pd1.

Methods in org.openstreetmap.josm.data.validation.tests that return types with arguments of type Node

Modifier and Type	Method	Description
protected java.util.Map<Node,UnconnectedWays.MyWaySegment>	UnconnectedWays.getHighwayEndNodesNearOtherHighway()
protected java.util.Map<Node,UnconnectedWays.MyWaySegment>	UnconnectedWays.getWayEndNodesNearOtherWay()
protected java.util.Map<Node,UnconnectedWays.MyWaySegment>	UnconnectedWays.getWayNodesNearOtherWay()
(package private) java.util.Collection<Node>	UnconnectedWays.MyWaySegment.nearbyNodes(double dist)	We know that any point near the line segment must be at least as close as the other end of the line, plus a little fudge for the distance away (dist)

Methods in org.openstreetmap.josm.data.validation.tests with parameters of type Node

Modifier and Type	Method	Description
private void	Coastlines.addError(int errCode, Way w, java.util.Collection<Way> otherWays, Node n)	Add error if not already done
private void	UnconnectedWays.addIfNewOrCloser(java.util.Map<Node,UnconnectedWays.MyWaySegment> map, Node node, UnconnectedWays.MyWaySegment ws)
private void	UnconnectedWays.addNode(Node n, java.util.Set<Node> s)
private void	WayConnectedToArea.addPossibleError(Way w, Node wayNode, OsmPrimitive p, OsmPrimitive area)
private EastNorth	UnconnectedWays.MyWaySegment.calcClosest(Node n)
private static double	PowerLines.calculateIntersectingLen(Node ref, java.util.Set<ILatLon> crossingNodes)	The summarized length (in metres) of a way where a power line hangs over a water area.
private void	SharpAngles.checkAngle(Node node1, Node node2, Node node3, int i, Way way, boolean last)
private static boolean	MultipolygonTest.checkIfNodeIsInsidePolygon(Node n, Multipolygon.PolyData p)	Check if a node is inside the polygon according to the insideness rules of Shape.
private void	Coastlines.checkIfReversed(Way w, Way other, Node n1)	Check if a reversed way would fit, if yes, add fixable "reversed" error, "unordered" else
private static boolean	Highways.checkLayer(Node connection, java.util.List<Way> ways)	Check if there are at least two neighbouring nodes on the given ways.
private void	DirectionNodes.checkParents(Node n, java.lang.String tag)
(package private) double	UnconnectedWays.MyWaySegment.getDist(Node n)
protected Way	UnconnectedWays.getWantedParentWay(Node endnode)	An unconnected node might have multiple parent ways, e.g.
private void	Highways.handleCarWay(Node n, Way w)
private void	Highways.handleCyclistWay(Node n, Way w)
private void	Highways.handlePedestrianWay(Node n, Way w)
protected boolean	UnconnectedWays.ignoreUnconnectedEndNode(Node n)	Check if unconnected end node should be ignored.
protected boolean	UnconnectedWays.UnconnectedHighways.ignoreUnconnectedEndNode(Node n)
protected boolean	UnconnectedWays.UnconnectedPower.ignoreUnconnectedEndNode(Node n)
protected boolean	UnconnectedWays.UnconnectedRailways.ignoreUnconnectedEndNode(Node n)
(package private) boolean	UnconnectedWays.MyWaySegment.isConnectedTo(Node startNode)	Check if the given node is connected to this segment using a reasonable short way.
private boolean	UnconnectedWays.MyWaySegment.isConnectedTo(Node node, java.util.Set<Node> visited, double len, Way parent)	Check if the given node is connected to this segment using a reasonable short way.
private static boolean	PowerLines.isConnectedToStationLine(Node n, Way w)	Determines if the current node connected to a line which usually used inside power stations.
private static boolean	CycleDetector.isConsecutive(Way w, Node n, Node m)	Determines if the given nodes are consecutive part of the parent way.
protected boolean	PowerLines.isInPowerStation(Node n)	Checks if the given node is inside a power station.
protected static boolean	PowerLines.isPowerInfrastructure(Node n)	Determines if the specified node denotes a power infrastructure allowed on a power line.
protected static boolean	PowerLines.isPowerTower(Node n)	Determines if the specified node denotes a power support feature.
private boolean	UnconnectedWays.MyWaySegment.nearby(Node n, double dist)
private boolean	UnconnectedWays.MyWaySegment.obstacleBetween(Node endnode)
private void	SharpAngles.processSharpAngleForErrorCreation(double angle, int i, Way way, boolean last, Node pointNode)
private void	Highways.testDifferentLayers(Node connection)	See #9304: Find Highways connected to bridges or tunnels at the wrong place.
private void	WayConnectedToArea.testForError(Way w, Node wayNode, OsmPrimitive p)
private void	Highways.testMissingPedestrianCrossing(Node n)
void	Addresses.visit(Node n)
void	BarriersEntrances.visit(Node n)
void	DirectionNodes.visit(Node n)
void	DuplicateNode.visit(Node n)
void	Highways.visit(Node n)
void	LongSegment.visit(Node n)
void	PowerLines.visit(Node n)
void	UnconnectedWays.visit(Node n)
void	UntaggedNode.visit(Node n)

Method parameters in org.openstreetmap.josm.data.validation.tests with type arguments of type Node

Modifier and Type	Method	Description
protected void	UnconnectedWays.addErrors(Severity severity, java.util.Map<Node,UnconnectedWays.MyWaySegment> errorMap, java.lang.String message)
private void	UnconnectedWays.addIfNewOrCloser(java.util.Map<Node,UnconnectedWays.MyWaySegment> map, Node node, UnconnectedWays.MyWaySegment ws)
private void	UnconnectedWays.addNode(Node n, java.util.Set<Node> s)
java.util.List<TestError>	DuplicateNode.buildTestErrors(Test parentTest, java.util.List<Node> nodes)	Returns the list of "duplicate nodes" errors for the given selection of node and parent test
private void	MultipolygonTest.checkOrSetRoles(Relation r, java.util.List<Multipolygon.PolyData> allPolygons, java.util.Map<java.lang.Long,RelationMember> wayMap, java.util.Set<Node> sharedNodes)	Calculate the nesting levels of the polygon rings and check if calculated role matches
private static MultipolygonTest.ExtPolygonIntersection	MultipolygonTest.checkOverlapAtSharedNodes(java.util.Set<Node> shared, Multipolygon.PolyData pd1, Multipolygon.PolyData pd2)
private void	MultipolygonTest.checkPolygonsForSharedNodes(Relation r, Multipolygon.PolyData pd1, Multipolygon.PolyData pd2, java.util.Set<Node> allSharedNodes)
private static java.util.Collection<WaySegment>	CycleDetector.createSegments(java.util.Map<Node,java.util.List<Node>> graphMap, java.util.Collection<Node> nodes)	Creates WaySegments from Nodes for the error highlight function.
private static java.util.Collection<WaySegment>	CycleDetector.createSegments(java.util.Map<Node,java.util.List<Node>> graphMap, java.util.Collection<Node> nodes)	Creates WaySegments from Nodes for the error highlight function.
private static java.util.Collection<WaySegment>	CycleDetector.createSegments(java.util.Map<Node,java.util.List<Node>> graphMap, java.util.Collection<Node> nodes)	Creates WaySegments from Nodes for the error highlight function.
(package private) static boolean	PowerLines.detectDiscontinuity(Way way, java.util.Set<OsmPrimitive> nRefDiscontinuities, java.util.List<java.util.Set<Node>> sRefDiscontinuities)	Detects ref=* numbering discontinuities in the given way.
private void	UnconnectedWays.fillSearchNodes(java.util.Collection<Node> nodes)
private static void	MultipolygonTest.findIntersectionNodes(Relation r, java.util.Set<Node> sharedNodes, java.util.Set<Way> intersectionWays)	Detect intersections of multipolygon ways at nodes.
private boolean	UnconnectedWays.MyWaySegment.isConnectedTo(Node node, java.util.Set<Node> visited, double len, Way parent)	Check if the given node is connected to this segment using a reasonable short way.

Constructors in org.openstreetmap.josm.data.validation.tests with parameters of type Node

Constructor	Description
MyWaySegment(Way w, Node n1, Node n2, boolean concersArea)

Constructor parameters in org.openstreetmap.josm.data.validation.tests with type arguments of type Node

Constructor	Description
PolygonLevelFinder(java.util.Set<Node> sharedNodes)

Uses of Node in org.openstreetmap.josm.data.validation.util

Methods in org.openstreetmap.josm.data.validation.util with parameters of type Node

Modifier and Type	Method	Description
static java.util.List<java.awt.geom.Point2D>	ValUtil.getSegmentCells(Node n1, Node n2, double gridDetail)	Returns the coordinates of all cells in a grid that a line between 2 nodes intersects with.
void	AggregatePrimitivesVisitor.visit(Node n)
void	NameVisitor.visit(Node n)	If the node has a name-key or id-key, this is displayed.

Uses of Node in org.openstreetmap.josm.gui

Methods in org.openstreetmap.josm.gui that return Node

Modifier and Type	Method	Description
Node	NavigatableComponent.getNearestNode(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate)	Convenience method to NavigatableComponent.getNearestNode(Point, Predicate, boolean).
Node	NavigatableComponent.getNearestNode(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate, boolean useSelected)	The *result* depends on the current map selection state IF use_selected is true.
Node	NavigatableComponent.getNearestNode(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate, boolean useSelected, java.util.Collection<OsmPrimitive> preferredRefs)	The *result* depends on the current map selection state IF use_selected is true

Methods in org.openstreetmap.josm.gui that return types with arguments of type Node

Modifier and Type	Method	Description
java.util.List<Node>	NavigatableComponent.getNearestNodes(java.awt.Point p, java.util.Collection<Node> ignore, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.
java.util.List<Node>	NavigatableComponent.getNearestNodes(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.
private java.util.Map<java.lang.Double,java.util.List<Node>>	NavigatableComponent.getNearestNodesImpl(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.

Methods in org.openstreetmap.josm.gui with parameters of type Node

Modifier and Type	Method	Description
java.awt.Point	NavigatableComponent.getPoint(Node n)	looses precision, may overflow (depends on p and current scale)
java.awt.geom.Point2D	NavigatableComponent.getPoint2D(Node n)	Return the point on the screen where this Node would be.
MapViewState.MapViewPoint	MapViewState.getPointFor(Node node)	Gets the MapViewState.MapViewPoint for the given node.
private boolean	NavigatableComponent.isPrecedenceNode(Node osm, java.awt.Point p, boolean useSelected)	This is used as a helper routine to NavigatableComponent.getNearestNodeOrWay(Point, Predicate, boolean) It decides, whether to yield the node to be tested or look for further (way) candidates.

Method parameters in org.openstreetmap.josm.gui with type arguments of type Node

Modifier and Type	Method	Description
java.util.List<Node>	NavigatableComponent.getNearestNodes(java.awt.Point p, java.util.Collection<Node> ignore, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.

Uses of Node in org.openstreetmap.josm.gui.conflict.pair.nodes

Methods in org.openstreetmap.josm.gui.conflict.pair.nodes that return Node

Modifier and Type	Method	Description
protected Node	NodeListMergeModel.cloneEntryForMergedList(Node entry)

Methods in org.openstreetmap.josm.gui.conflict.pair.nodes with parameters of type Node

Modifier and Type	Method	Description
protected Node	NodeListMergeModel.cloneEntryForMergedList(Node entry)
boolean	NodeListMergeModel.isEqualEntry(Node e1, Node e2)
protected void	NodeListTableCellRenderer.renderNode(AbstractListMergeModel.EntriesTableModel model, Node node, int row, boolean isSelected)	render a node

Constructor parameters in org.openstreetmap.josm.gui.conflict.pair.nodes with type arguments of type Node

Constructor	Description
NodeListTable(java.lang.String name, AbstractListMergeModel<Node,WayNodesConflictResolverCommand> model, OsmPrimitivesTableModel dm, javax.swing.ListSelectionModel sm)	Constructs a new NodeListTable.

Uses of Node in org.openstreetmap.josm.gui.dialogs

Methods in org.openstreetmap.josm.gui.dialogs with parameters of type Node

Modifier and Type	Method	Description
void	ConflictDialog.ConflictPainter.visit(Node n)
private void	ConflictDialog.ConflictPainter.visit(Node n1, Node n2)

Method parameters in org.openstreetmap.josm.gui.dialogs with type arguments of type Node

Modifier and Type	Method	Description
private static boolean	PropertiesMembershipChoiceDialog.isTagged(java.util.Collection<Node> existingNodes)
private static boolean	PropertiesMembershipChoiceDialog.isUsedInRelations(java.util.Collection<Node> existingNodes)
static PropertiesMembershipChoiceDialog	PropertiesMembershipChoiceDialog.showIfNecessary(java.util.Collection<Node> selectedNodes, boolean preselectNew)	Creates and shows a new PropertiesMembershipChoiceDialog if necessary.
void	ValidatorDialog.ValidatorBoundingXYVisitor.visit(java.util.List<Node> nodes)

Uses of Node in org.openstreetmap.josm.gui.history

Methods in org.openstreetmap.josm.gui.history with parameters of type Node

Modifier and Type	Method	Description
void	HistoryBrowserModel.HistoryPrimitiveBuilder.visit(Node n)

Uses of Node in org.openstreetmap.josm.gui.layer

Methods in org.openstreetmap.josm.gui.layer with parameters of type Node

Modifier and Type	Method	Description
static WayPoint	OsmDataLayer.nodeToWayPoint(Node n, long time)	Converts a node to a waypoint with default GpxConstants.GPX_PREFIX for tags.
static WayPoint	OsmDataLayer.nodeToWayPoint(Node n, long time, java.lang.String gpxPrefix)	Converts a node to a waypoint with a configurable GPX prefix for tags.
void	OsmDataLayer.DataCountVisitor.visit(Node n)

Method parameters in org.openstreetmap.josm.gui.layer with type arguments of type Node

Modifier and Type	Method	Description
private static void	OsmDataLayer.nodesToGpxData(java.util.Collection<Node> nodes, GpxData gpxData, java.util.Set<Node> doneNodes, java.lang.String gpxPrefix)
private static void	OsmDataLayer.nodesToGpxData(java.util.Collection<Node> nodes, GpxData gpxData, java.util.Set<Node> doneNodes, java.lang.String gpxPrefix)
private static void	OsmDataLayer.waysToGpxData(java.util.Collection<Way> ways, GpxData gpxData, java.util.Set<Node> doneNodes, java.lang.String gpxPrefix)

Uses of Node in org.openstreetmap.josm.gui.layer.validation

Methods in org.openstreetmap.josm.gui.layer.validation with parameters of type Node

Modifier and Type	Method	Description
protected void	PaintVisitor.drawNode(Node n, java.awt.Color color)	Draws a circle around the node
protected void	PaintVisitor.drawSegment(Node n1, Node n2, java.awt.Color color)	Draws a line around the segment
protected boolean	PaintVisitor.isNodeVisible(Node n)	Checks if the given node is in the visible area.
protected boolean	PaintVisitor.isSegmentVisible(Node n1, Node n2)	Checks if the given segment is in the visible area.
void	PaintVisitor.visit(Node n)	Draw a small rectangle.

Method parameters in org.openstreetmap.josm.gui.layer.validation with type arguments of type Node

Modifier and Type	Method	Description
void	PaintVisitor.visit(java.util.List<Node> nodes)

Uses of Node in org.openstreetmap.josm.io

Methods in org.openstreetmap.josm.io that return Node

Modifier and Type	Method	Description
private Node	AbstractReader.addNode(NodeData nd, AbstractReader.NodeReader nodeReader)
private Node	GeoJSONReader.createNode(LatLon latlon)
protected Node	AbstractReader.parseNode(double lat, double lon, AbstractReader.CommonReader commonReader, AbstractReader.NodeReader nodeReader)
protected Node	AbstractReader.parseNode(java.lang.String lat, java.lang.String lon, AbstractReader.CommonReader commonReader, AbstractReader.NodeReader nodeReader)
protected Node	OsmReader.parseNode()

Methods in org.openstreetmap.josm.io that return types with arguments of type Node

Modifier and Type	Method	Description
private java.util.Optional<Node>	GeoJSONReader.parsePoint(jakarta.json.JsonObject feature, jakarta.json.JsonArray coordinates)

Methods in org.openstreetmap.josm.io with parameters of type Node

Modifier and Type	Method	Description
MultiFetchServerObjectReader	MultiFetchServerObjectReader.appendNode(Node node)	appends a Node id to the list of ids which will be fetched from the server.
void	GeoJSONWriter.GeometryPrimitiveVisitor.visit(Node n)

Method parameters in org.openstreetmap.josm.io with type arguments of type Node

Modifier and Type	Method	Description
private jakarta.json.JsonArrayBuilder	GeoJSONWriter.GeometryPrimitiveVisitor.getCoorsArray(java.lang.Iterable<Node> nodes)
void	OsmWriter.writeNodes(java.util.Collection<Node> nodes)	Writes the given nodes sorted by id

Uses of Node in org.openstreetmap.josm.io.remotecontrol.handler

Fields in org.openstreetmap.josm.io.remotecontrol.handler with type parameters of type Node

Modifier and Type	Field	Description
private java.util.Map<LatLon,Node>	AddWayHandler.addedNodes	The place to remember already added nodes (they are reused if needed @since 5845

Methods in org.openstreetmap.josm.io.remotecontrol.handler that return Node

Modifier and Type	Method	Description
(package private) Node	AddWayHandler.findOrCreateNode(LatLon ll, java.util.List<Command> commands)	Find the node with almost the same coords in dataset or in already added nodes

Uses of Node in org.openstreetmap.josm.tools

Methods in org.openstreetmap.josm.tools that return types with arguments of type Node

Modifier and Type	Method	Description
static java.util.Set<Node>	Geometry.addIntersections(java.util.List<Way> ways, boolean test, java.util.List<Command> cmds)	Will find all intersection and add nodes there for list of given ways.

Methods in org.openstreetmap.josm.tools with parameters of type Node

Modifier and Type	Method	Description
static double	Geometry.getDistanceSegmentSegment(Node ws1Node1, Node ws1Node2, Node ws2Node1, Node ws2Node2)	Get the distance between different WaySegments
static double	Geometry.getDistanceWayNode(Way way, Node node)	Get the distance between a way and a node
static java.lang.Double	RotationAngle.WayDirectionRotationAngle.getRotationAngleForNodeOnWay(Node n, Way w)	Calculates the rotation angle of a node in a way based on the preceding way segment.