Package | Description |
---|---|
org.openstreetmap.josm.actions |
Provides the classes for JOSM user actions.
|
org.openstreetmap.josm.actions.corrector |
Provides the classes for JOSM
tag correctors . |
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.gpx |
Provides the classes for JOSM
GPX data (points, tracks, routes). |
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.dialogs.relation.sort |
Provides the classes for sorting relations.
|
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.
|
Modifier and Type | Field and Description |
---|---|
private Way |
ReverseWayAction.ReverseWayResult.newWay |
private Way |
JoinAreasAction.Multipolygon.outerWay |
private Way |
UnGlueAction.selectedWay |
(package private) Way |
SplitWayAction.SegmentToKeepSelectionDialog.selectedWay |
Way |
JoinAreasAction.WayInPolygon.way |
(package private) Way |
SplitWayAction.SegmentToKeepSelectionDialog.wayToKeep |
Modifier and Type | Field and Description |
---|---|
private java.util.List<Way> |
JoinAreasAction.Multipolygon.innerWays |
(package private) javax.swing.JList<Way> |
SplitWayAction.SegmentToKeepSelectionDialog.list |
(package private) java.util.List<Way> |
SplitWayAction.SegmentToKeepSelectionDialog.newWays |
private java.util.Collection<Way> |
CreateMultipolygonAction.CreateUpdateMultipolygonTask.selectedWays |
Modifier and Type | Method and Description |
---|---|
private Way |
SelectNonBranchingWaySequences.findWay(java.util.Collection<OsmPrimitive> selection)
Finds out if the current selection can be extended.
|
private static Way |
SelectNonBranchingWaySequences.findWay(java.util.Collection<OsmPrimitive> selection,
Node node)
Finds out if the current selection can be extended.
|
Way |
ReverseWayAction.ReverseWayResult.getNewWay()
Gets the new way object
|
Way |
JoinAreasAction.Multipolygon.getOuterWay()
Returns the outer way.
|
protected static Way |
CombineWayAction.getTargetWay(java.util.Collection<Way> combinedWays) |
private Way |
JoinAreasAction.joinOrientedWays(java.util.List<JoinAreasAction.WayInPolygon> ways)
Joins a list of ways (using CombineWayAction and ReverseWayAction as specified in WayInPath)
|
private Way |
JoinAreasAction.joinWays(java.util.List<JoinAreasAction.WayInPolygon> ways)
Joins the outer ways and deletes all short ways that can't be part of a multipolygon anyway.
|
private static 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 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!
|
Modifier and Type | Method and Description |
---|---|
static Pair<Way,Command> |
CombineWayAction.combineWaysWorker(java.util.Collection<Way> ways)
Combine multiple ways into one.
|
(package private) static java.util.List<Way> |
UnJoinNodeWayAction.getApplicableWays(java.util.List<Way> selectedWays,
java.util.List<Node> selectedNodes)
Find ways to which the disconnect can be applied.
|
(package private) static java.util.List<Way> |
SplitWayAction.getApplicableWays(java.util.List<Way> selectedWays,
java.util.List<Node> selectedNodes)
Determine which ways to split.
|
java.util.List<Way> |
JoinAreasAction.Multipolygon.getInnerWays()
Returns the inner ways.
|
private java.util.List<Way> |
JoinAreasAction.splitWayOnNodes(Way way,
java.util.Set<Node> nodes)
This is a method that splits way into smaller parts, using the prepared nodes list as split points.
|
Modifier and Type | Method and Description |
---|---|
private void |
SelectNonBranchingWaySequences.addNodes(Way way)
Add the endpoints of the way to nodes, outerNodes
|
private static java.util.List<java.util.List<Node>> |
JoinAreasAction.buildNodeChunks(Way way,
java.util.Collection<Node> splitNodes)
Simple chunking version.
|
(package private) static void |
SplitWayAction.doSplitWay(Way way,
Way wayToKeep,
java.util.List<Way> newWays,
java.util.List<OsmPrimitive> newSelection) |
private void |
JoinAreasAction.fixRelations(java.util.List<JoinAreasAction.RelationRole> rels,
Way outer,
JoinAreasAction.RelationRole ownMultipol,
java.util.Set<Relation> relationsToDelete)
Adds the previously removed relations again to the outer way.
|
private static java.util.Set<Node> |
SimplifyWayAction.getMultiUseNodes(Way w)
Calculate a set of nodes which occurs more than once in the way
|
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 static 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 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.orderNodesByWay(java.util.List<Node> nodes,
Way way)
Order nodes according to way direction.
|
static ReverseWayAction.ReverseWayResult |
ReverseWayAction.reverseWay(Way w)
Reverses a given way.
|
SequenceCommand |
SimplifyWayAction.simplifyWay(Way w)
Simplifies a way with default threshold (read from preferences).
|
static SequenceCommand |
SimplifyWayAction.simplifyWay(Way w,
double threshold)
Simplifies a way with a given threshold.
|
private java.util.List<Way> |
JoinAreasAction.splitWayOnNodes(Way way,
java.util.Set<Node> nodes)
This is a method that splits way into smaller parts, using the prepared nodes list as split points.
|
void |
UploadSelectionAction.UploadHullBuilder.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
private JoinAreasAction.RelationRole |
JoinAreasAction.addOwnMultipolygonRelation(java.util.Collection<Way> inner)
Will add own multipolygon relation to the "previously existing" relations.
|
private static Command |
AlignInLineAction.alignMultiWay(java.util.Collection<Way> ways)
Align way in case of multiple way #6819
|
private static java.lang.Boolean |
DistributeAction.checkDistributeNodes(java.util.Collection<Way> ways,
java.util.Collection<Node> nodes)
Test if nodes oriented algorithm applies to the selection.
|
private static boolean |
DistributeAction.checkDistributeWay(java.util.Collection<Way> ways,
java.util.Collection<Node> nodes)
Test if one way, no self-crossing, is selected with at most two of its nodes.
|
private static boolean |
AlignInCircleAction.checkWaysArePolygon(java.util.Collection<Way> ways)
Determines if ways can be joined into a polygon.
|
private java.util.List<Node> |
UnJoinNodeWayAction.cleanSelectedNodes(java.util.List<Way> selectedWays,
java.util.List<Node> selectedNodes)
Removes irrelevant nodes from user selection.
|
static java.util.List<JoinAreasAction.Multipolygon> |
JoinAreasAction.collectMultipolygons(java.util.Collection<Way> selectedWays)
This method analyzes multipolygon relationships of given ways and collects addition inner ways to consider.
|
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.collectNodesWithExternReferers(java.util.List<Way> ways)
Collect all nodes with more than one referrer.
|
static Pair<Way,Command> |
CombineWayAction.combineWaysWorker(java.util.Collection<Way> ways)
Combine multiple ways into one.
|
static Pair<SequenceCommand,Relation> |
CreateMultipolygonAction.createMultipolygonCommand(java.util.Collection<Way> selectedWays,
Relation selectedMultipolygonRelation)
|
static Pair<Relation,Relation> |
CreateMultipolygonAction.createMultipolygonRelation(java.util.Collection<Way> selectedWays,
boolean showNotif)
|
private static java.util.Collection<Command> |
DistributeAction.distributeWay(java.util.Collection<Way> ways,
java.util.Collection<Node> nodes)
Distribute nodes contained by a way, keeping nodes order.
|
(package private) static void |
SplitWayAction.doSplitWay(Way way,
Way wayToKeep,
java.util.List<Way> newWays,
java.util.List<OsmPrimitive> newSelection) |
static java.util.List<JoinAreasAction.AssembledPolygon> |
JoinAreasAction.findBoundaryPolygons(java.util.Collection<JoinAreasAction.WayInPolygon> multigonWays,
java.util.List<Way> discardedResult)
Finds all ways that form inner or outer boundaries.
|
(package private) static java.util.List<Way> |
UnJoinNodeWayAction.getApplicableWays(java.util.List<Way> selectedWays,
java.util.List<Node> selectedNodes)
Find ways to which the disconnect can be applied.
|
(package private) static java.util.List<Way> |
SplitWayAction.getApplicableWays(java.util.List<Way> selectedWays,
java.util.List<Node> selectedNodes)
Determine which ways to split.
|
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
|
private static Relation |
CreateMultipolygonAction.getSelectedMultipolygonRelation(java.util.Collection<Way> selectedWays,
java.util.Collection<Relation> selectedRelations) |
protected static Way |
CombineWayAction.getTargetWay(java.util.Collection<Way> combinedWays) |
void |
JoinAreasAction.join(java.util.Collection<Way> ways)
Joins the given ways.
|
private static java.util.List<JoinAreasAction.WayInPolygon> |
JoinAreasAction.markWayInsideSide(java.util.List<Way> parts,
boolean isInner)
This method analyzes the way and assigns each part what direction polygon "inside" is.
|
protected void |
UnGlueAction.notifyWayPartOfRelation(java.util.Collection<Way> ways) |
private boolean |
JoinAreasAction.removeDuplicateNodes(java.util.List<Way> ways)
This method removes duplicate points (if any) from the input way.
|
private void |
JoinAreasAction.stripTags(java.util.Collection<Way> ways)
Remove all tags from the all the way
|
static Pair<Relation,Relation> |
CreateMultipolygonAction.updateMultipolygonRelation(java.util.Collection<Way> selectedWays,
Relation selectedMultipolygonRelation)
|
Constructor and Description |
---|
Line(Way way)
Init a line equation from a way.
|
Multipolygon(Way way)
Constructs a new
Multipolygon . |
ReverseWayResult(Way newWay,
java.util.Collection<Command> tagCorrectionCommands,
Command reverseCommand)
Create a new
ReverseWayAction.ReverseWayResult |
SegmentToKeepSelectionDialog(Way selectedWay,
java.util.List<Way> newWays,
Way wayToKeep,
java.util.List<OsmPrimitive> selection) |
WayInPolygon(Way way,
boolean insideRight) |
Constructor and Description |
---|
CreateUpdateMultipolygonTask(java.util.Collection<Way> selectedWays,
Relation multipolygonRelation) |
SegmentToKeepSelectionDialog(Way selectedWay,
java.util.List<Way> newWays,
Way wayToKeep,
java.util.List<OsmPrimitive> selection) |
SelectNonBranchingWaySequences(java.util.Collection<Way> ways)
Creates a way selection
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<Way> |
ReverseWayTagCorrector.irreversibleWays(java.util.List<Way> ways)
Returns the subset of irreversible ways.
|
Modifier and Type | Method and Description |
---|---|
static void |
ReverseWayNoTagCorrector.checkAndConfirmReverseWay(Way way)
Checks the given way can be safely reversed and asks user to confirm the operation if it not the case.
|
private static boolean |
ReverseWayNoTagCorrector.confirmReverseWay(Way way,
TagCollection tags) |
java.util.Collection<Command> |
ReverseWayTagCorrector.execute(Way oldway,
Way way) |
(package private) static java.util.List<RoleCorrection> |
ReverseWayTagCorrector.getRoleCorrections(Way oldway) |
(package private) static java.util.Map<OsmPrimitive,java.util.List<TagCorrection>> |
ReverseWayTagCorrector.getTagCorrectionsMap(Way way) |
static boolean |
ReverseWayTagCorrector.isReversible(Way way)
Tests whether way can be reversed without semantic change, i.e., whether tags have to be changed.
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<Way> |
ReverseWayTagCorrector.irreversibleWays(java.util.List<Way> ways)
Returns the subset of irreversible ways.
|
Modifier and Type | Field and Description |
---|---|
private Way |
ImproveWayAccuracyAction.targetWay |
Modifier and Type | Field and Description |
---|---|
private java.util.Set<Way> |
DrawAction.mouseOnExistingWays |
private java.util.Set<Way> |
ParallelWayAction.sourceWays |
private java.util.List<Way> |
ParallelWays.ways |
Modifier and Type | Method and Description |
---|---|
static Way |
ImproveWayAccuracyHelper.findWay(MapView mv,
java.awt.Point p)
Finds the way to work on.
|
static Way |
DrawAction.getWayForNode(Node n)
Replies the parent way of a node, if it is the end of exactly one usable way.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Way> |
ParallelWays.getWays()
Returns the resulting parallel ways.
|
Modifier and Type | Method and Description |
---|---|
private void |
ParallelWayAction.addSourceWay(Way w) |
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 |
static Node |
ImproveWayAccuracyHelper.findCandidateNode(MapView mv,
Way w,
java.awt.Point p)
Returns the nearest node to cursor.
|
static WaySegment |
ImproveWayAccuracyHelper.findCandidateSegment(MapView mv,
Way w,
java.awt.Point p)
Returns the nearest way segment to cursor.
|
private Node |
DrawAction.findNodeToContinueFrom(Node selectedNode,
Way selectedWay)
Finds a node to continue drawing from.
|
private static boolean |
ExtrudeAction.hasNodeOtherWays(Node node,
Way myWay)
This method tests if
node has other ways apart from the given one. |
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 |
ParallelWayAction.removeSourceWay(Way w) |
void |
ImproveWayAccuracyAction.startImproving(Way targetWay)
Switches to Improving state
|
Modifier and Type | Method and Description |
---|---|
private static boolean |
SelectAction.doesImpactStatusLine(java.util.Collection<Node> affectedNodes,
java.util.Collection<Way> selectedWays) |
private static java.lang.String |
DrawAction.getTitle(boolean newNode,
Node n,
java.util.Collection<OsmPrimitive> newSelection,
java.util.List<Way> 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.List<Way> replacedWays,
java.util.List<Way> reuseWays) |
private void |
DrawAction.insertNodeIntoAllNearbySegments(java.util.List<WaySegment> wss,
Node n,
java.util.Collection<OsmPrimitive> newSelection,
java.util.Collection<Command> cmds,
java.util.List<Way> replacedWays,
java.util.List<Way> reuseWays) |
private static void |
ParallelWayAction.removeWayHighlighting(java.util.Collection<Way> ways) |
Constructor and Description |
---|
ParallelWays(java.util.Collection<Way> sourceWays,
boolean copyTags,
int refWayIndex)
Constructs a new
ParallelWays . |
Modifier and Type | Field and Description |
---|---|
private Way |
SplitWayCommand.originalWay |
protected Way |
AbstractNodesCommand.way |
Modifier and Type | Field and Description |
---|---|
private java.util.List<Way> |
SplitWayCommand.newWays |
Modifier and Type | Method and Description |
---|---|
Way |
SplitWayCommand.Strategy.determineWayToKeep(java.lang.Iterable<Way> wayChunks)
Determines which way chunk should reuse the old id and its history.
|
Way |
SplitWayCommand.getOriginalWay()
Replies the original way being split
|
Modifier and Type | Method and Description |
---|---|
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.
|
java.util.List<Way> |
SplitWayCommand.getNewWays()
Replies the resulting new ways
|
Modifier and Type | Method and 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.
|
static SplitWayCommand |
SplitWayCommand.doSplitWay(Way way,
Way wayToKeep,
java.util.List<Way> newWays,
java.util.List<OsmPrimitive> newSelection)
Effectively constructs the
SplitWayCommand . |
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 . |
private static SplitWayCommand.RelationInformation |
SplitWayCommand.treatAsRestriction(Relation r,
RelationMember rm,
Relation c,
java.util.Collection<Way> newWays,
Way way,
Way changedWay) |
void |
Command.CloneVisitor.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
Way |
SplitWayCommand.Strategy.determineWayToKeep(java.lang.Iterable<Way> wayChunks)
Determines which way chunk should reuse the old id and its history.
|
static SplitWayCommand |
SplitWayCommand.doSplitWay(Way way,
Way wayToKeep,
java.util.List<Way> newWays,
java.util.List<OsmPrimitive> newSelection)
Effectively constructs the
SplitWayCommand . |
private static SplitWayCommand.RelationInformation |
SplitWayCommand.treatAsRestriction(Relation r,
RelationMember rm,
Relation c,
java.util.Collection<Way> newWays,
Way way,
Way changedWay) |
Constructor and Description |
---|
AbstractNodesCommand(DataSet ds,
Way way,
C cmdNodes)
Constructs a new
AbstractNodesCommand . |
AbstractNodesCommand(Way way,
C cmdNodes)
Constructs a new
AbstractNodesCommand . |
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.List<Node> rmNodes)
Deprecated.
|
RemoveNodesCommand(Way way,
java.util.Set<Node> rmNodes)
Constructs a new
RemoveNodesCommand . |
SplitWayCommand(java.lang.String name,
java.util.Collection<Command> commandList,
java.util.List<? extends PrimitiveId> newSelection,
Way originalWay,
java.util.List<Way> newWays)
Create a new
SplitWayCommand . |
Constructor and Description |
---|
SplitWayCommand(java.lang.String name,
java.util.Collection<Command> commandList,
java.util.List<? extends PrimitiveId> newSelection,
Way originalWay,
java.util.List<Way> newWays)
Create a new
SplitWayCommand . |
Modifier and Type | Field and Description |
---|---|
private Conflict<Way> |
WayNodesConflictResolverCommand.conflict
the conflict to resolve
|
Modifier and Type | Method and Description |
---|---|
static double |
GpxDistance.getDistanceWay(Way way,
WayPoint waypoint)
Deprecated.
Use
Geometry.getDistanceWayNode(way, new Node(waypoint.getCoor())) instead |
Modifier and Type | Field and Description |
---|---|
Way |
WaySegment.way
The way.
|
Modifier and Type | Field and Description |
---|---|
private QuadBucketPrimitiveStore<Node,Way,Relation> |
DataSet.store |
java.util.List<Way> |
MultipolygonBuilder.JoinedPolygon.ways
list of ways building this polygon
|
Modifier and Type | Method and Description |
---|---|
Way |
RelationMember.getWay()
Returns the relation member as a way.
|
private static Way |
OsmUtils.newWay(LatLon around,
boolean enforceLocation) |
Way |
WaySegment.toWay()
Returns this way segment as complete way.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Way> |
Node.getParentWays()
Replies the set of referring ways.
|
java.util.Collection<Way> |
DataSet.getWays() |
java.util.List<Way> |
DataSet.searchWays(BBox bbox) |
java.util.Set<Way> |
DataSet.unlinkNodeFromWays(Node node)
Removes all references from ways in this dataset to a particular node.
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<NodePair> |
NodeGraph.buildNodePairs(Way way,
boolean directed)
Builds a list of pair of nodes from the given way.
|
boolean |
DataSet.containsWay(Way w)
Determines if the given way can be retrieved in the data set through its bounding box.
|
private static void |
DataSet.deleteWay(Way way) |
(package private) void |
DataSet.fireWayNodesChanged(Way way) |
protected void |
DataSetMerger.fixIncomplete(Way other) |
static WaySegment |
WaySegment.forNodePair(Way way,
Node first,
Node second)
Determines and returns the way segment for the given way and node pair.
|
private void |
DataSetMerger.mergeNodeList(Way source)
Merges the node list of a source way onto its target way.
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<NodePair> |
NodeGraph.buildNodePairs(java.util.List<Way> ways,
boolean directed)
Builds a list of pair of nodes from the given ways.
|
static NodeGraph |
NodeGraph.createDirectedGraphFromWays(java.util.Collection<Way> ways) |
static NodeGraph |
NodeGraph.createNearlyUndirectedGraphFromNodeWays(java.util.Collection<Way> ways) |
static NodeGraph |
NodeGraph.createUndirectedGraphFromNodeWays(java.util.Collection<Way> ways)
Create an undirected graph from the given ways, but prevent reversing of all
non-new ways by fix one direction.
|
static java.util.List<MultipolygonBuilder.JoinedPolygon> |
MultipolygonBuilder.joinWays(java.util.Collection<Way> ways)
Joins the given
ways to multipolygon rings. |
java.lang.String |
MultipolygonBuilder.makeFromWays(java.util.Collection<Way> ways)
Splits ways into inner and outer JoinedWays.
|
Constructor and Description |
---|
JoinedPolygon(Way way)
Creates a polygon from single way.
|
Way(Way original)
Constructs a new
Way from an existing Way (including its id). |
Way(Way original,
boolean clearMetadata)
Constructs a new
Way from an existing Way . |
WaySegment(Way w,
int i)
Constructs a new
WaySegment . |
Constructor and Description |
---|
JoinedPolygon(java.util.List<Way> ways,
java.util.List<java.lang.Boolean> reversed)
Constructs a new
JoinedPolygon from given list of ways. |
Modifier and Type | Field and Description |
---|---|
private Way |
WayNodesChangedEvent.way |
Modifier and Type | Method and Description |
---|---|
Way |
WayNodesChangedEvent.getChangedWay()
Returns the way affected by the change.
|
Constructor and Description |
---|
WayNodesChangedEvent(DataSet dataSet,
Way way)
Constructs a new
WayNodesChangedEvent . |
Constructor and Description |
---|
HistoryWay(Way w)
Constructs a new
HistoryWay from an existing Way . |
Modifier and Type | Method and Description |
---|---|
protected void |
MergeSourceBuildingVisitor.rememberWay(Way w)
remembers a way in the hull
|
void |
MergeSourceBuildingVisitor.visit(Way w) |
void |
AllNodesVisitor.visit(Way w)
Ways have their way nodes.
|
void |
BoundingXYVisitor.visit(Way w) |
void |
OsmPrimitiveVisitor.visit(Way w)
Visiting call for lines.
|
Modifier and Type | Field and Description |
---|---|
private java.util.List<Way> |
Multipolygon.innerWays |
private java.util.List<Way> |
Multipolygon.outerWays |
Modifier and Type | Method and Description |
---|---|
java.util.List<Way> |
Multipolygon.getInnerWays()
Replies the list of inner ways.
|
java.util.List<Way> |
Multipolygon.getOuterWays()
Replies the list of outer ways.
|
Modifier and Type | Method and Description |
---|---|
private void |
Multipolygon.createPolygons(java.util.List<Way> ways,
java.util.List<Multipolygon.PolyData> result) |
static java.util.Collection<Multipolygon.JoinedWay> |
Multipolygon.joinWays(java.util.Collection<Way> waysToJoin)
Attempt to combine the ways in the list if they share common end nodes
|
Constructor and Description |
---|
PolyData(Way closedWay)
Constructs a new
PolyData from a closed way. |
Modifier and Type | Method and Description |
---|---|
void |
Test.visit(Way w) |
void |
Test.TagTest.visit(Way w) |
Modifier and Type | Field and Description |
---|---|
Way |
UnconnectedWays.MyWaySegment.w |
Modifier and Type | Field and Description |
---|---|
private java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> |
SimilarNamedWays.cellWays
All ways, grouped by cells
|
private java.util.List<Way> |
Coastlines.coastlineWays |
private MultiMap<Way,Way> |
SimilarNamedWays.errorWays
The already detected errors
|
private MultiMap<Way,Way> |
SimilarNamedWays.errorWays
The already detected errors
|
private java.util.Map<java.util.List<Way>,java.util.List<WaySegment>> |
CrossingWays.seenWays
The already detected ways in error
|
private java.util.Set<Way> |
LongSegment.visitedWays
set of visited ways.
|
private java.util.Set<Way> |
UntaggedWay.waysUsedInRelations |
Modifier and Type | Method and Description |
---|---|
protected java.util.Map<Node,Way> |
UnconnectedWays.getConnectedWayEndNodesNearOtherWay() |
protected java.util.Map<Node,Way> |
UnconnectedWays.getWayEndNodesNearOtherHighway() |
protected java.util.Map<Node,Way> |
UnconnectedWays.getWayEndNodesNearOtherWay() |
protected java.util.Map<Node,Way> |
UnconnectedWays.getWayNodesNearOtherWay() |
Modifier and Type | Method and Description |
---|---|
private void |
Coastlines.addError(int errCode,
Way w,
java.util.Collection<Way> otherWays,
Node n)
Add error if not already done
|
private void |
WayConnectedToArea.addPossibleError(Way w,
Node wayNode,
OsmPrimitive p,
OsmPrimitive area) |
protected static java.util.Set<WaySegment> |
OverlappingWays.checkDuplicateWaySegment(Way w) |
private void |
TurnrestrictionTest.checkIfConnected(Relation r,
Way previous,
Way current,
java.lang.String msg,
int code) |
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
|
(package private) CrossingWays.MessageHelper |
CrossingWays.createMessage(Way w1,
Way w2) |
(package private) CrossingWays.MessageHelper |
CrossingWays.Ways.createMessage(Way w1,
Way w2) |
private static void |
MultipolygonTest.findIntersectingWay(Way w,
java.util.Map<java.awt.geom.Point2D,java.util.List<WaySegment>> cellSegments,
java.util.Map<java.util.List<Way>,java.util.List<WaySegment>> crossingWays,
boolean findSharedWaySegments)
Find ways which are crossing without sharing a node.
|
static java.util.List<LatLon> |
DuplicateWay.getOrderedNodes(Way w)
Replies the ordered list of nodes of way w such as it is easier to find duplicated ways.
|
TestError |
UnclosedWays.UnclosedWaysCheck.getTestError(Way w,
UnclosedWays test)
Returns the test error of the given way, if any.
|
(package private) java.util.List<UnconnectedWays.MyWaySegment> |
UnconnectedWays.getWaySegments(Way w) |
private void |
Highways.handleCarWay(Node n,
Way w) |
private void |
Highways.handleCyclistWay(Node n,
Way w) |
private void |
Highways.handlePedestrianWay(Node n,
Way w) |
private boolean |
LongSegment.ignoreWay(Way w) |
(package private) abstract boolean |
CrossingWays.ignoreWaySegmentCombination(Way w1,
Way w2) |
(package private) boolean |
CrossingWays.Ways.ignoreWaySegmentCombination(Way w1,
Way w2) |
(package private) boolean |
CrossingWays.Boundaries.ignoreWaySegmentCombination(Way w1,
Way w2) |
(package private) boolean |
CrossingWays.Barrier.ignoreWaySegmentCombination(Way w1,
Way w2) |
(package private) boolean |
CrossingWays.SelfCrossing.ignoreWaySegmentCombination(Way w1,
Way w2) |
private static boolean |
TurnrestrictionTest.isFullOneway(Way w) |
static boolean |
Highways.isHighwayLinkOkay(Way way)
Determines if the given link road is correct, see https://wiki.openstreetmap.org/wiki/Highway_link.
|
protected static boolean |
PowerLines.isPowerLine(Way w)
Determines if the specified way denotes a power line.
|
(package private) static CrossingWays.WayType |
CrossingWays.WayType.of(Way w) |
private void |
WronglyOrderedWays.reportError(Way w,
java.lang.String msg,
int type) |
private void |
WayConnectedToArea.testForError(Way w,
Node wayNode,
OsmPrimitive p) |
private void |
Highways.testHighwayLink(Way way) |
private void |
LongSegment.testWay(Way w) |
private void |
Highways.testWrongRoundabout(Way w) |
void |
DuplicateWay.visit(Way w) |
void |
InternetTags.visit(Way w) |
void |
CrossingWays.visit(Way w) |
void |
SelfIntersectingWay.visit(Way w) |
void |
Highways.visit(Way w) |
void |
Addresses.visit(Way w) |
void |
RightAngleBuildingTest.visit(Way w) |
void |
SimilarNamedWays.visit(Way w) |
void |
OverlappingWays.visit(Way w) |
void |
DuplicatedWayNodes.visit(Way w) |
void |
Coastlines.visit(Way way) |
void |
WayConnectedToArea.visit(Way w) |
void |
UnconnectedWays.visit(Way w) |
void |
LongSegment.visit(Way w) |
void |
UntaggedWay.visit(Way w) |
void |
PowerLines.visit(Way w) |
void |
WronglyOrderedWays.visit(Way w) |
void |
ApiCapabilitiesTest.visit(Way w) |
void |
UnclosedWays.visit(Way w) |
private void |
LongSegment.visitWaySegment(Way w,
int i) |
Modifier and Type | Method and Description |
---|---|
private void |
Coastlines.addError(int errCode,
Way w,
java.util.Collection<Way> otherWays,
Node n)
Add error if not already done
|
protected void |
UnconnectedWays.addErrors(Severity severity,
java.util.Map<Node,Way> errorMap,
java.lang.String message) |
protected void |
Addresses.checkDistance(OsmPrimitive house,
java.util.Collection<Way> street) |
private static void |
MultipolygonTest.findIntersectingWay(Way w,
java.util.Map<java.awt.geom.Point2D,java.util.List<WaySegment>> cellSegments,
java.util.Map<java.util.List<Way>,java.util.List<WaySegment>> crossingWays,
boolean findSharedWaySegments)
Find ways which are crossing without sharing a node.
|
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 static boolean |
MultipolygonTest.hasIntersectionWay(Multipolygon.PolyData pd,
java.util.Set<Way> intersectionWays)
Simple check if given ring contains way that is known to intersect.
|
Relation |
MultipolygonTest.makeFromWays(java.util.Collection<Way> ways)
Create a multipolygon relation from the given ways and test it.
|
Constructor and Description |
---|
MyWaySegment(Way w,
Node n1,
Node n2) |
Modifier and Type | Method and Description |
---|---|
static java.util.List<java.util.List<Way>> |
ValUtil.getWaysInCell(Way w,
java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> cellWays)
Returns the start and end cells of a way.
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<java.util.List<Way>> |
ValUtil.getWaysInCell(Way w,
java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> cellWays)
Returns the start and end cells of a way.
|
void |
NameVisitor.visit(Way w)
If the way has a name-key or id-key, this is displayed.
|
void |
AggregatePrimitivesVisitor.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
static java.util.List<java.util.List<Way>> |
ValUtil.getWaysInCell(Way w,
java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> cellWays)
Returns the start and end cells of a way.
|
Modifier and Type | Method and Description |
---|---|
Way |
NavigatableComponent.getNearestWay(java.awt.Point p,
java.util.function.Predicate<OsmPrimitive> predicate)
The *result* depends on the current map selection state.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Way> |
NavigatableComponent.getNearestWays(java.awt.Point p,
java.util.Collection<Way> 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<Way> |
NavigatableComponent.getNearestWays(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*.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Way> |
NavigatableComponent.getNearestWays(java.awt.Point p,
java.util.Collection<Way> ignore,
java.util.function.Predicate<OsmPrimitive> predicate)
The *result* does not depend on the current map selection state,
neither does the result *order*.
|
void |
MapStatus.setDist(java.util.Collection<Way> ways)
Sets the distance text to the total sum of given ways length
|
Modifier and Type | Method and Description |
---|---|
void |
NodeListMergeModel.populate(Way my,
Way their,
java.util.Map<PrimitiveId,PrimitiveId> mergedMap)
|
Modifier and Type | Method and Description |
---|---|
void |
ConflictDialog.ConflictPainter.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
(package private) static WayConnectionType.Direction |
RelationSortUtils.roundaboutType(Way w) |
Modifier and Type | Method and Description |
---|---|
void |
HistoryBrowserModel.HistoryPrimitiveBuilder.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
void |
OsmDataLayer.DataCountVisitor.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
private static void |
OsmDataLayer.waysToGpxData(java.util.Collection<Way> ways,
GpxData gpxData,
java.util.Set<Node> doneNodes) |
Modifier and Type | Method and Description |
---|---|
void |
PaintVisitor.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
protected Way |
OsmReader.parseWay() |
protected Way |
AbstractReader.parseWay(AbstractReader.CommonReader commonReader,
AbstractReader.WayReader wayReader) |
Modifier and Type | Method and Description |
---|---|
void |
AbstractReader.WayReader.accept(Way w,
java.util.Collection<java.lang.Long> nodeIds)
Reads the way nodes and tags.
|
MultiFetchServerObjectReader |
MultiFetchServerObjectReader.appendWay(Way way)
appends a
Way id and the list of ids of nodes the way refers to the list of ids which will be fetched from the server. |
private long |
OsmReader.parseWayNode(Way w) |
private void |
OsmReader.parseWayNodesAndTags(Way w,
java.util.Collection<java.lang.Long> nodeIds) |
private static void |
OsmJsonReader.readWayNodesAndTags(javax.json.JsonObject item,
Way w,
java.util.Collection<java.lang.Long> nodeIds) |
void |
GeoJSONWriter.GeometryPrimitiveVisitor.visit(Way w) |
Modifier and Type | Method and Description |
---|---|
void |
OsmWriter.writeWays(java.util.Collection<Way> ways)
Writes the given ways sorted by id
|
Modifier and Type | Field and Description |
---|---|
private Way |
AddWayHandler.way |
Modifier and Type | Method and Description |
---|---|
private Way |
AddWayHandler.addWay() |
Modifier and Type | Method and Description |
---|---|
private static void |
RightAndLefthandTraffic.addWayIfNotInner(java.util.Collection<Way> ways,
Way w)
Adds w to ways, except if it is an inner way of another lefthand driving multipolygon,
as Lesotho in South Africa and Cyprus village in British Cyprus base.
|
static double |
Geometry.closedWayArea(Way way)
Returns area of a closed way in square meters.
|
static WaySegment |
Geometry.getClosestWaySegment(Way way,
OsmPrimitive primitive)
Get the closest
WaySegment from a way to a primitive. |
static double |
Geometry.getDistanceWayNode(Way way,
Node node)
Get the distance between a way and a node
|
static double |
Geometry.getDistanceWayWay(Way w1,
Way w2)
Get the distance between different ways.
|
static boolean |
Geometry.isClockwise(Way w)
Determines whether a way is oriented clockwise.
|
Modifier and Type | Method and 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.
|
private static void |
RightAndLefthandTraffic.addWayIfNotInner(java.util.Collection<Way> ways,
Way w)
Adds w to ways, except if it is an inner way of another lefthand driving multipolygon,
as Lesotho in South Africa and Cyprus village in British Cyprus base.
|
static boolean |
Geometry.isNodeInsideMultiPolygon(INode node,
Relation multiPolygon,
java.util.function.Predicate<Way> isOuterWayAMatch)
Tests if the
node is inside the multipolygon multiPolygon . |
static boolean |
Geometry.isPolygonInsideMultiPolygon(java.util.List<? extends INode> nodes,
Pair<java.util.List<MultipolygonBuilder.JoinedPolygon>,java.util.List<MultipolygonBuilder.JoinedPolygon>> outerInner,
java.util.function.Predicate<Way> isOuterWayAMatch)
Tests if the polygon formed by
nodes is inside the multipolygon multiPolygon . |
static boolean |
Geometry.isPolygonInsideMultiPolygon(java.util.List<? extends INode> nodes,
Relation multiPolygon,
java.util.function.Predicate<Way> isOuterWayAMatch)
Tests if the polygon formed by
nodes is inside the multipolygon multiPolygon . |
Constructor and Description |
---|
DefaultGeoProperty(java.util.Collection<Way> ways)
Create DefaultGeoProperty based on a collection of closed ways.
|