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

Packages that use Node
org.openstreetmap.josm.actions   
org.openstreetmap.josm.actions.mapmode   
org.openstreetmap.josm.command   
org.openstreetmap.josm.data.osm   
org.openstreetmap.josm.data.osm.event   
org.openstreetmap.josm.data.osm.history   
org.openstreetmap.josm.data.osm.visitor   
org.openstreetmap.josm.data.osm.visitor.paint   
org.openstreetmap.josm.data.osm.visitor.paint.relations   
org.openstreetmap.josm.data.validation   
org.openstreetmap.josm.data.validation.tests   
org.openstreetmap.josm.data.validation.util   
org.openstreetmap.josm.gui   
org.openstreetmap.josm.gui.conflict.pair.nodes   
org.openstreetmap.josm.gui.dialogs   
org.openstreetmap.josm.gui.dialogs.relation   
org.openstreetmap.josm.gui.history   
org.openstreetmap.josm.gui.layer   
org.openstreetmap.josm.gui.mappaint.mapcss   
org.openstreetmap.josm.io   
org.openstreetmap.josm.tools   
 

Uses of Node in org.openstreetmap.josm.actions
 

Fields in org.openstreetmap.josm.actions declared as Node
private  Node CombineWayAction.NodePair.a
           
private  Node CombineWayAction.NodePair.b
           
private  Node UnGlueAction.selectedNode
           
 

Fields in org.openstreetmap.josm.actions with type parameters of type Node
private  java.util.HashMap<Node,java.util.List<CombineWayAction.NodePair>> CombineWayAction.NodeGraph.predecessors
           
private static java.util.HashMap<Node,EastNorth> OrthogonalizeAction.rememberMovements
          Remember movements, so the user can later undo it for certain nodes
private  java.util.Set<Node> UnGlueAction.selectedNodes
           
private  java.util.HashMap<Node,java.util.List<CombineWayAction.NodePair>> CombineWayAction.NodeGraph.successors
           
 

Methods in org.openstreetmap.josm.actions that return Node
 Node CombineWayAction.NodePair.getA()
           
 Node CombineWayAction.NodePair.getB()
           
 Node JoinAreasAction.WayTraverser.getLastWayEndNode()
           
 Node JoinAreasAction.WayTraverser.getLastWayStartNode()
           
private static Node AlignInLineAction.getNodeRelative(Way w, int refI, int i)
           
protected  Node CombineWayAction.NodeGraph.getStartNode()
           
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
private  java.util.List<java.util.List<Node>> JoinAreasAction.buildNodeChunks(Way way, java.util.Collection<Node> splitNodes)
          Simple chunking version.
protected  java.util.List<Node> CombineWayAction.NodeGraph.buildPathFromNodePairs(java.util.Stack<CombineWayAction.NodePair> path)
           
 java.util.List<Node> CombineWayAction.NodeGraph.buildSpanningPath()
          Tries to find a path through the graph which visits each edge (i.e.
protected  java.util.List<Node> CombineWayAction.NodeGraph.buildSpanningPath(Node startNode)
          Tries to find a spanning path starting from node startNode.
static java.util.List<java.util.List<Node>> SplitWayAction.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  java.util.Set<Node> CombineWayAction.NodeGraph.getNodes()
           
 java.util.List<Node> JoinAreasAction.AssembledPolygon.getNodes()
           
protected  java.util.Set<Node> CombineWayAction.NodeGraph.getNodes(java.util.Stack<CombineWayAction.NodePair> pairs)
           
private  java.util.Collection<Node> CopyCoordinatesAction.getSelectedNodes()
           
protected  java.util.Set<Node> CombineWayAction.NodeGraph.getTerminalNodes()
           
 

Methods in org.openstreetmap.josm.actions with parameters of type Node
protected  java.util.List<Node> CombineWayAction.NodeGraph.buildSpanningPath(Node startNode)
          Tries to find a spanning path starting from node startNode.
 boolean CombineWayAction.NodePair.contains(Node n)
           
private  void AlignInLineAction.createAlignNodesCommands(Node[] anchors, java.util.Collection<Node> nodes, java.util.Collection<Command> cmds)
           
static void MergeNodesAction.doMergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)
           
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  void UnGlueAction.fixRelations(Node originalNode, java.util.List<Command> cmds, java.util.List<Node> newNodes)
          put all newNodes into the same relation(s) that originalNode is in
protected  java.util.List<CombineWayAction.NodePair> CombineWayAction.NodeGraph.getOutboundPairs(Node node)
           
protected  boolean SimplifyWayAction.isRequiredNode(Way way, Node node)
          Replies true if node is a required node which can't be removed in order to simplify the way.
protected  boolean CombineWayAction.NodeGraph.isTerminalNode(Node n)
           
static Command MergeNodesAction.mergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)
           
static Command MergeNodesAction.mergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetNode, Node targetLocationNode)
          Merges the nodes in nodes onto one of the nodes.
private  Way 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 OrginalNode is in the way -> the new node will be put into the parameter newNodes.
private  void AlignInLineAction.nodePairFurthestApart(java.util.ArrayList<Node> nodes, Node[] resultOut)
           
 void UploadSelectionAction.UploadHullBuilder.visit(Node n)
           
 

Method parameters in org.openstreetmap.josm.actions with type arguments of type Node
private  java.util.List<java.util.List<Node>> JoinAreasAction.buildNodeChunks(Way way, java.util.Collection<Node> splitNodes)
          Simple chunking version.
protected  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  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
static java.util.List<java.util.List<Node>> SplitWayAction.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.
private  void AlignInLineAction.createAlignNodesCommands(Node[] anchors, java.util.Collection<Node> nodes, java.util.Collection<Command> cmds)
           
static void MergeNodesAction.doMergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)
           
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  void UnGlueAction.fixRelations(Node originalNode, java.util.List<Command> cmds, java.util.List<Node> newNodes)
          put all newNodes into the same relation(s) that originalNode is in
private  java.util.List<Way> SplitWayAction.getApplicableWays(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)
           
static Command MergeNodesAction.mergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetLocationNode)
           
static Command MergeNodesAction.mergeNodes(OsmDataLayer layer, java.util.Collection<Node> nodes, Node targetNode, Node targetLocationNode)
          Merges the nodes in nodes onto one of the nodes.
private  Way 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 OrginalNode is in the way -> the new node will be put into the parameter newNodes.
private  void AlignInLineAction.nodePairFurthestApart(java.util.ArrayList<Node> nodes, Node[] resultOut)
           
private static java.util.Collection<Command> OrthogonalizeAction.orthogonalize(java.util.ArrayList<OrthogonalizeAction.WayData> wayDataList, java.util.ArrayList<Node> headingNodes)
          Outline: 1.
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.
static SplitWayAction.SplitWayResult SplitWayAction.split(OsmDataLayer layer, 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 SplitWayAction.SplitWayResult.
static SplitWayAction.SplitWayResult SplitWayAction.splitWay(OsmDataLayer layer, 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 SplitWayAction.SplitWayResult.
private  java.util.ArrayList<Way> JoinAreasAction.splitWayOnNodes(Way way, java.util.Set<Node> nodes)
          This is a method splits way into smaller parts, using the prepared nodes list as split points.
 

Constructors in org.openstreetmap.josm.actions with parameters of type Node
CombineWayAction.NodePair(Node a, Node b)
           
 

Constructor parameters in org.openstreetmap.josm.actions with type arguments of type Node
CombineWayAction.NodePair(Pair<Node,Node> pair)
           
CombineWayAction.NodePair(Pair<Node,Node> pair)
           
 

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

Fields in org.openstreetmap.josm.actions.mapmode declared as Node
private  Node ImproveWayAccuracyAction.candidateNode
           
private  Node DrawAction.currentBaseNode
           
private  Node DrawAction.lastUsedNode
           
private  Node DrawAction.mouseOnExistingNode
           
(package private)  Node DeleteAction.DeleteParameters.nearestNode
           
private  Node DrawAction.previousNode
           
private  Node SelectAction.VirtualManager.virtualNode
           
 

Fields in org.openstreetmap.josm.actions.mapmode with type parameters of type Node
private  java.util.List<Node> ParallelWays.sortedNodes
           
 

Methods in org.openstreetmap.josm.actions.mapmode that return Node
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()
           
private  Node ExtrudeAction.getNextNode(int index)
          Gets a node from selected way before 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
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 Node ParallelWays.copyNode(Node source, boolean copyTags)
           
private  Node DrawAction.findNodeToContinueFrom(Node selectedNode, Way selectedWay)
          Finds a node to continue drawing from.
static Way DrawAction.getWayForNode(Node n)
           
private  boolean ExtrudeAction.hasNodeOtherWays(Node node, Way myWay)
          This method tests if a 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.ArrayList<Way> replacedWays, java.util.ArrayList<Way> 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.
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
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).
 

Uses of Node in org.openstreetmap.josm.command
 

Fields in org.openstreetmap.josm.command with type parameters of type Node
private  java.util.List<Node> WayNodesConflictResolverCommand.mergedNodeList
          the list of merged nodes.
private  java.util.List<Node> ChangeNodesCommand.newNodes
           
protected  java.util.Collection<Node> TransformNodesCommand.nodes
          The nodes to transform.
private  java.util.Collection<Node> MoveCommand.nodes
          The objects that should be moved.
protected  java.util.Map<Node,TransformNodesCommand.OldState> TransformNodesCommand.oldStates
          List of all old states of the nodes.
 

Methods in org.openstreetmap.josm.command that return types with arguments of type Node
protected static java.util.Collection<Node> DeleteCommand.computeNodesToDelete(OsmDataLayer layer, 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
 void Command.CloneVisitor.visit(Node n)
           
 

Constructors in org.openstreetmap.josm.command with parameters of type Node
MoveCommand(Node node, LatLon position)
           
 

Constructor parameters in org.openstreetmap.josm.command with type arguments of type Node
ChangeNodesCommand(Way way, java.util.List<Node> newNodes)
           
WayNodesConflictResolverCommand(Conflict<? extends OsmPrimitive> conflict, java.util.List<Node> mergedNodeList)
           
 

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

Fields in org.openstreetmap.josm.data.osm declared as Node
private  Node[] Way.nodes
          All way nodes in this way
 

Fields in org.openstreetmap.josm.data.osm with type parameters of type Node
private  QuadBuckets<Node> DataSet.nodes
          All nodes goes here, even when included in other data (ways etc).
 java.util.List<Node> MultipolygonCreate.JoinedPolygon.nodes
           
 

Methods in org.openstreetmap.josm.data.osm that return Node
 Node DatasetFactory.addNode(long id)
           
 Node DatasetFactory.addNode(long id, int version)
           
 Node Way.firstNode()
          Returns the first node of this way.
 Node Way.firstNode(boolean respectOneway)
          Replies the first node of this way, respecting or not its oneway state.
 Node WaySegment.getFirstNode()
           
 Node RelationMember.getNode()
           
 Node Way.getNode(int index)
          Replies the node at position index.
 Node DatasetFactory.getNode(long id)
           
 Node WaySegment.getSecondNode()
           
 Node Way.lastNode()
          Returns the last node of this way.
 Node Way.lastNode(boolean respectOneway)
          Replies the last node of this way, respecting or not its oneway state.
 

Methods in org.openstreetmap.josm.data.osm that return types with arguments of type Node
 java.util.Set<Node> Way.getNeighbours(Node node)
          Return nodes adjacent to node
 java.util.Comparator<Node> NameFormatter.getNodeComparator()
           
 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.List<Node> Way.getNodes()
          You can modify returned list but changes will not be propagated back to the Way.
 java.util.Collection<Node> DataSet.getNodes()
          Replies an unmodifiable collection of nodes in this dataset
private  java.util.List<Node> MultipolygonCreate.JoinedPolygon.getNodes()
          Builds a list of nodes for this polygon.
 java.util.Collection<Node> DataSet.getSelectedNodes()
          Return selected nodes.
private  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
 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.
 int NodePositionComparator.compare(Node n1, Node n2)
           
 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)
           
 java.lang.String NameFormatter.format(Node node)
           
 java.util.Set<Node> Way.getNeighbours(Node node)
          Return nodes adjacent to node
 boolean Way.isFirstLastNode(Node n)
          Replies true if the given node is the first or the last one of this way, false otherwise.
 boolean Way.isInnerNode(Node n)
          Replies true if the given node is an inner node of this way, false otherwise.
private  void DataSet.reindexNode(Node node, LatLon newCoor, EastNorth eastNorth)
           
 void Way.removeNode(Node n)
          Removes the given Node from this way.
 void 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
private  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)
          Set new list of nodes to way.
 

Constructors in org.openstreetmap.josm.data.osm with parameters of type Node
BBox(Node n)
           
Node(Node clone)
          Constructs an identical clone of the argument (including the id).
Node(Node clone, boolean clearId)
          Constructs an identical clone of the argument.
 

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

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

Methods in org.openstreetmap.josm.data.osm.event that return Node
 Node NodeMovedEvent.getNode()
           
 

Constructors in org.openstreetmap.josm.data.osm.event with parameters of type Node
NodeMovedEvent(DataSet dataSet, Node node)
           
 

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

Constructors in org.openstreetmap.josm.data.osm.history with parameters of type Node
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
 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
static java.util.Collection<Node> AllNodesVisitor.getAllNodes(java.util.Collection<? extends OsmPrimitive> osms)
           
 

Methods in org.openstreetmap.josm.data.osm.visitor with parameters of type Node
protected  void MergeSourceBuildingVisitor.rememberNode(Node n)
          Remebers a node in the "hull"
 void AllNodesVisitor.visit(Node n)
          Nodes have only itself as nodes.
 void BoundingXYVisitor.visit(Node n)
           
 void Visitor.visit(Node n)
          Visiting call for points.
 void MergeSourceBuildingVisitor.visit(Node n)
           
 

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

Fields in org.openstreetmap.josm.data.osm.visitor.paint with type parameters of type Node
private  java.util.List<Node> MapPainter.OffsetIterator.nodes
           
 

Methods in org.openstreetmap.josm.data.osm.visitor.paint with parameters of type Node
 void StyledMapRenderer.StyleCollector.add(Node osm, int flags)
           
 void MapPainter.drawBoxText(Node n, BoxTextElemStyle bs)
           
 void MapPainter.drawNode(Node n, java.awt.Color color, int size, boolean fill)
          Draw the node as small rectangle with the given color.
 void WireframeMapRenderer.drawNode(Node n, java.awt.Color color, int size, boolean fill)
          Draw the node as small rectangle with the given color.
 void MapPainter.drawNodeIcon(Node n, java.awt.Image img, float alpha, boolean selected, boolean member)
           
 void MapPainter.drawNodeSymbol(Node n, NodeElemStyle.Symbol s, java.awt.Color fillColor, java.awt.Color strokeColor)
           
 void MapPainter.drawOrderNumber(Node n1, Node n2, int orderNumber, java.awt.Color clr)
          Draw a number of the order of the two consecutive nodes within the parents way
 void WireframeMapRenderer.visit(Node n)
          Draw a small rectangle.
 

Constructor parameters in org.openstreetmap.josm.data.osm.visitor.paint with type arguments of type Node
MapPainter.OffsetIterator(java.util.List<Node> nodes, float offset)
           
 

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
private  java.util.List<Node> Multipolygon.JoinedWay.nodes
           
private  java.util.List<Node> Multipolygon.PolyData.nodes
           
 

Methods in org.openstreetmap.josm.data.osm.visitor.paint.relations that return types with arguments of type Node
 java.util.List<Node> Multipolygon.JoinedWay.getNodes()
           
 

Constructor parameters in org.openstreetmap.josm.data.osm.visitor.paint.relations with type arguments of type Node
Multipolygon.JoinedWay(java.util.List<Node> nodes, java.util.Collection<java.lang.Long> wayIds, boolean selected)
           
Multipolygon.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 with parameters of type Node
 void TestError.PaintVisitor.drawNode(Node n, java.awt.Color color)
          Draws a circle around the node
 void TestError.PaintVisitor.drawSegment(Node n1, Node n2, java.awt.Color color)
          Draws a line around the segment
protected  boolean TestError.PaintVisitor.isNodeVisible(Node n)
          Checks if the given node is in the visible area.
protected  boolean TestError.PaintVisitor.isSegmentVisible(Node n1, Node n2)
          Checks if the given segment is in the visible area.
 void Test.visit(Node n)
           
 void TestError.PaintVisitor.visit(Node n)
          Draw a small rectangle.
 

Method parameters in org.openstreetmap.josm.data.validation with type arguments of type Node
 void ValidatorVisitor.visit(java.util.List<Node> nodes)
           
 void TestError.PaintVisitor.visit(java.util.List<Node> nodes)
           
 

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

Fields in org.openstreetmap.josm.data.validation.tests declared as Node
(package private)  Node UnconnectedWays.MyWaySegment.n1
           
 Node CrossingWays.ExtendedSegment.n1
           
(package private)  Node UnconnectedWays.MyWaySegment.n2
           
 Node CrossingWays.ExtendedSegment.n2
           
 

Fields in org.openstreetmap.josm.data.validation.tests with type parameters of type Node
(package private)  QuadBuckets<Node> UnconnectedWays.endnodes
           
(package private)  QuadBuckets<Node> UnconnectedWays.endnodes_highway
           
(package private)  QuadBuckets<Node> UnconnectedWays.middlenodes
           
private  java.util.Map<java.lang.String,java.util.List<Node>> NodesWithSameName.namesToNodes
           
private  java.util.Set<Node> UnconnectedWays.MyWaySegment.nearbyNodeCache
           
(package private)  QuadBuckets<Node> UnconnectedWays.nodecache
           
(package private)  MultiMap<Pair<Node,Node>,WaySegment> OverlappingWays.nodePairs
          Bag of all way segments
(package private)  MultiMap<Pair<Node,Node>,WaySegment> OverlappingWays.nodePairs
          Bag of all way segments
(package private)  java.util.Collection<Node> RelationChecker.RoleInfo.nodes
           
private  java.util.List<java.util.List<Node>> MultipolygonTest.nonClosedWays
           
(package private)  java.util.Set<Node> UnconnectedWays.othernodes
           
 

Methods in org.openstreetmap.josm.data.validation.tests that return Node
 Node PowerLines.PowerLineError.getNode()
           
 

Methods in org.openstreetmap.josm.data.validation.tests that return types with arguments of type Node
private  java.util.List<java.util.List<Node>> MultipolygonTest.joinWays(java.util.Collection<Way> ways)
           
 java.util.Collection<Node> UnconnectedWays.MyWaySegment.nearbyNodes(double dist)
           
 

Methods in org.openstreetmap.josm.data.validation.tests with parameters of type Node
private  void WayConnectedToArea.addError(Way w, Node wayNode, OsmPrimitive p)
           
private  void UnconnectedWays.addNode(Node n, QuadBuckets<Node> s)
           
 java.util.List<java.util.List<CrossingWays.ExtendedSegment>> CrossingWays.getSegments(Node n1, Node n2)
          Returns all the cells this segment crosses.
private static boolean BuildingInBuilding.isInPolygon(Node n, java.util.List<Node> polygon)
           
protected  boolean PowerLines.isInPowerStation(Node n)
           
protected static boolean PowerLines.isPowerAllowed(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 tower/pole.
 boolean UnconnectedWays.MyWaySegment.nearby(Node n, double dist)
           
private  void WayConnectedToArea.testForError(Way w, Node wayNode, OsmPrimitive p)
           
 void NodesWithSameName.visit(Node n)
           
 void UnconnectedWays.visit(Node n)
           
 void UntaggedNode.visit(Node n)
           
 void DeprecatedTags.visit(Node n)
           
 void BuildingInBuilding.visit(Node n)
           
 void DuplicateNode.visit(Node n)
           
 void TagChecker.visit(Node n)
           
 

Method parameters in org.openstreetmap.josm.data.validation.tests with type arguments of type Node
private  void UnconnectedWays.addNode(Node n, QuadBuckets<Node> s)
           
 java.util.List<TestError> DuplicateNode.buildTestErrors(Test parentTest, java.util.List<Node> nodes)
           
private  java.awt.geom.GeneralPath MultipolygonTest.createPath(java.util.List<Node> nodes)
           
private  java.util.List<java.awt.geom.GeneralPath> MultipolygonTest.createPolygons(java.util.List<java.util.List<Node>> joinedWays)
           
private  Multipolygon.PolyData.Intersection MultipolygonTest.getPolygonIntersection(java.awt.geom.GeneralPath outer, java.util.List<Node> inner)
           
private static boolean BuildingInBuilding.isInPolygon(Node n, java.util.List<Node> polygon)
           
private static boolean BuildingInBuilding.isInPolygon(Way w, java.util.List<Node> polygon)
          Return true if w is in polygon.
 

Constructors in org.openstreetmap.josm.data.validation.tests with parameters of type Node
PowerLines.PowerLineError(Node n, Way line)
           
UnconnectedWays.MyWaySegment(Way w, Node n1, Node n2)
           
 

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

Methods in org.openstreetmap.josm.data.validation.util with parameters of type Node
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 NameVisitor.visit(Node n)
          If the node has a name-key or id-key, this is displayed.
 void AggregatePrimitivesVisitor.visit(Node n)
           
 

Uses of Node in org.openstreetmap.josm.gui
 

Fields in org.openstreetmap.josm.gui with type parameters of type Node
private  java.util.Comparator<Node> DefaultNameFormatter.nodeComparator
           
 

Methods in org.openstreetmap.josm.gui that return Node
 Node NavigatableComponent.getNearestNode(java.awt.Point p, Predicate<OsmPrimitive> predicate)
          Convenience method to NavigatableComponent.getNearestNode(Point, Predicate, boolean).
 Node NavigatableComponent.getNearestNode(java.awt.Point p, Predicate<OsmPrimitive> predicate, boolean use_selected)
          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
 java.util.List<Node> NavigatableComponent.getNearestNodes(java.awt.Point p, java.util.Collection<Node> ignore, 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, 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, Predicate<OsmPrimitive> predicate)
          The *result* does not depend on the current map selection state, neither does the result *order*.
 java.util.Comparator<Node> DefaultNameFormatter.getNodeComparator()
           
 

Methods in org.openstreetmap.josm.gui with parameters of type Node
 java.lang.String DefaultNameFormatter.format(Node node)
          Formats a name for a node
 java.awt.Point NavigatableComponent.getPoint(Node n)
           
 java.awt.geom.Point2D NavigatableComponent.getPoint2D(Node n)
           
private  boolean NavigatableComponent.isPrecedenceNode(Node osm, java.awt.Point p, boolean use_selected)
          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
 java.util.List<Node> NavigatableComponent.getNearestNodes(java.awt.Point p, java.util.Collection<Node> ignore, 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
protected  Node NodeListMergeModel.cloneEntryForMergedList(Node entry)
           
 

Methods in org.openstreetmap.josm.gui.conflict.pair.nodes with parameters of type Node
protected  Node NodeListMergeModel.cloneEntryForMergedList(Node entry)
           
 boolean NodeListMergeModel.isEqualEntry(Node e1, Node e2)
           
protected  void NodeListTableCellRenderer.renderNode(ListMergeModel.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
NodeListTable(java.lang.String name, ListMergeModel<Node> model, OsmPrimitivesTableModel dm, javax.swing.ListSelectionModel sm)
           
 

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

Methods in org.openstreetmap.josm.gui.dialogs with parameters of type Node
(package private)  void InspectPrimitiveDialog.DataText.addCoordinates(Node n)
           
 

Method parameters in org.openstreetmap.josm.gui.dialogs with type arguments of type Node
 void ValidatorDialog.ValidatorBoundingXYVisitor.visit(java.util.List<Node> nodes)
           
 

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

Fields in org.openstreetmap.josm.gui.dialogs.relation declared as Node
(package private)  Node RelationNodeMap.firstCircular
           
(package private)  Node RelationNodeMap.lastOnewayNode
           
 

Fields in org.openstreetmap.josm.gui.dialogs.relation with type parameters of type Node
 java.util.Map<Node,java.util.Set<java.lang.Integer>> RelationNodeMap.NodesWays.nodes
           
private  java.util.Map<java.lang.Integer,java.util.Set<Node>> RelationNodeMap.remainingOneway
           
 java.util.Map<java.lang.Integer,java.util.Set<Node>> RelationNodeMap.NodesWays.ways
           
 

Methods in org.openstreetmap.josm.gui.dialogs.relation that return Node
static Node RelationNodeMap.firstOnewayNode(RelationMember m)
           
static Node RelationNodeMap.lastOnewayNode(RelationMember m)
           
private  Node RelationNodeMap.processBackwardIfEndOfLoopReached(java.lang.Integer way)
           
 

Methods in org.openstreetmap.josm.gui.dialogs.relation with parameters of type Node
private  void RelationNodeMap.addNodeWayMap(Node n, int i)
           
private  void RelationNodeMap.addNodeWayMapReverse(Node n, int i)
           
private  void RelationNodeMap.addPair(Node n, int i)
           
private  void RelationNodeMap.addRemainingForward(Node n, int i)
           
private  void RelationNodeMap.addWayNodeMap(Node n, int i)
           
private  void RelationNodeMap.addWayNodeMapReverse(Node n, int i)
           
private  java.lang.Integer RelationNodeMap.deleteAndGetAdjacentNode(RelationNodeMap.NodesWays nw, Node n)
          find next node in nw NodeWays structure, if the node is found delete and return it
private  void RelationNodeMap.deleteWayNode(RelationNodeMap.NodesWays nw, java.lang.Integer way, Node n)
           
private  java.lang.Integer RelationNodeMap.findAdjacentWay(RelationNodeMap.NodesWays nw, Node n)
           
 

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

Methods in org.openstreetmap.josm.gui.history with parameters of type Node
 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
 void OsmDataLayer.DataCountVisitor.visit(Node n)
           
 

Uses of Node in org.openstreetmap.josm.gui.mappaint.mapcss
 

Methods in org.openstreetmap.josm.gui.mappaint.mapcss with parameters of type Node
 void Selector.ChildOrParentSelector.MatchingReferrerFinder.visit(Node n)
           
 

Uses of Node in org.openstreetmap.josm.io
 

Methods in org.openstreetmap.josm.io that return Node
protected  Node OsmReader.parseNode()
           
 

Methods in org.openstreetmap.josm.io with parameters of type Node
 MultiFetchServerObjectReader MultiFetchServerObjectReader.appendNode(Node node)
          appends a Node id to the list of ids which will be fetched from the server.
 void GeoJSONWriter.visit(Node n)
           
 

Uses of Node in org.openstreetmap.josm.tools
 

Methods in org.openstreetmap.josm.tools that return types with arguments of type Node
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
static boolean Geometry.angleIsClockwise(Node commonNode, Node firstNode, Node secondNode)
          This method tests if secondNode is clockwise to first node.
protected static double Geometry.calcX(Node p1)
           
protected static double Geometry.calcY(Node p1)
           
static boolean Geometry.isToTheRightSideOfLine(Node lineP1, Node lineP2, Node lineP3, Node testPoint)
          Tests if given point is to the right side of path consisting of 3 points.
static boolean Geometry.nodeInsidePolygon(Node point, java.util.List<Node> polygonNodes)
          Tests if point is inside a polygon.
 

Method parameters in org.openstreetmap.josm.tools with type arguments of type Node
static EastNorth Geometry.getCentroid(java.util.List<Node> nodes)
           
private static BBox Geometry.getNodesBounds(java.util.ArrayList<Node> nodes)
           
static boolean Geometry.nodeInsidePolygon(Node point, java.util.List<Node> polygonNodes)
          Tests if point is inside a polygon.
static Geometry.PolygonIntersection Geometry.polygonIntersection(java.util.List<Node> first, java.util.List<Node> second)
          Tests if two polygons intersect.
static Geometry.PolygonIntersection Geometry.polygonIntersection(java.util.List<Node> first, java.util.List<Node> second)
          Tests if two polygons intersect.
 



JOSM