|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |