/**
* Compute weight and add edge to the graph
*
* @param way
* @param from
* @param to
*/
private void addEdge(Way way, Node from, Node to) {
LatLon fromLL = from.getCoor();
LatLon toLL = from.getCoor();
if (fromLL == null || toLL == null) {
return;
}
double length = fromLL.greatCircleDistance(toLL);
OsmEdge edge = new OsmEdge(way, from, to);
edge.setSpeed(12.1);
graph.addEdge(from, to, edge);
// weight = getWeight(way);
double weight = getWeight(way, length);
setWeight(edge, length);
logger.debug(
"edge for way "
+ way.getId()
+ "(from node "
+ from.getId()
+ " to node "
+ to.getId()
+ ") has weight: "
+ weight);
((DirectedWeightedMultigraph<Node, OsmEdge>) graph).setEdgeWeight(edge, weight);
}
@Test
public void testBackrefrenceForWay_Full() throws OsmTransferException {
Way w = lookupWay(ds, 1);
assertNotNull(w);
// way with name "way-1" is referred to by two relations
//
OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(w);
reader.setReadFull(true);
DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
assertEquals(6, referers.getWays().size()); // 6 ways referred by two relations
for (Way w1 : referers.getWays()) {
assertEquals(false, w1.isIncomplete());
}
assertEquals(2, referers.getRelations().size()); // two relations referring to
Set<Long> expectedNodeIds = new HashSet<Long>();
for (Way way : referers.getWays()) {
Way orig = (Way) ds.getPrimitiveById(way);
for (Node n : orig.getNodes()) {
expectedNodeIds.add(n.getId());
}
}
assertEquals(expectedNodeIds.size(), referers.getNodes().size());
for (Node n : referers.getNodes()) {
assertEquals(true, expectedNodeIds.contains(n.getId()));
}
Relation r = lookupRelation(referers, 0);
assertNotNull(r);
assertEquals(false, r.isIncomplete());
r = lookupRelation(referers, 1);
assertEquals(false, r.isIncomplete());
}
protected Set<Long> getNodeIdsInWay(Way way) {
HashSet<Long> ret = new HashSet<Long>();
if (way == null) return ret;
for (Node n : way.getNodes()) {
ret.add(n.getId());
}
return ret;
}
/**
* Formats a name for a node
*
* @param node the node
* @return the name
*/
@Override
public String format(Node node) {
StringBuilder name = new StringBuilder();
if (node.isIncomplete()) {
name.append(tr("incomplete"));
} else {
TaggingPreset preset = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(node);
if (preset == null) {
String n;
if (Main.pref.getBoolean("osm-primitives.localize-name", true)) {
n = node.getLocalName();
} else {
n = node.getName();
}
if (n == null) {
String s;
if ((s = node.get("addr:housename")) != null) {
/* I18n: name of house as parameter */
n = tr("House {0}", s);
}
if (n == null && (s = node.get("addr:housenumber")) != null) {
String t = node.get("addr:street");
if (t != null) {
/* I18n: house number, street as parameter, number should remain
before street for better visibility */
n = tr("House number {0} at {1}", s, t);
} else {
/* I18n: house number as parameter */
n = tr("House number {0}", s);
}
}
}
if (n == null) {
n = node.isNew() ? tr("node") : "" + node.getId();
}
name.append(n);
} else {
preset.nameTemplate.appendText(name, node);
}
if (node.getCoor() != null) {
name.append(" \u200E(")
.append(node.getCoor().latToString(CoordinateFormat.getDefaultFormat()))
.append(", ")
.append(node.getCoor().lonToString(CoordinateFormat.getDefaultFormat()))
.append(")");
}
}
decorateNameWithId(name, node);
String result = name.toString();
for (NameFormatterHook hook : formatHooks) {
String hookResult = hook.checkFormat(node, result);
if (hookResult != null) return hookResult;
}
return result;
}
/**
* Apply selected routing algorithm to the graph.
*
* @param nodes Nodes used to calculate path.
* @param algorithm Algorithm used to compute the path,
* RoutingGraph.Algorithm.ROUTING_ALG_DIJKSTRA or
* RoutingGraph.Algorithm.ROUTING_ALG_BELLMANFORD
* @return new path.
*/
public List<OsmEdge> applyAlgorithm(List<Node> nodes, Algorithm algorithm) {
List<OsmEdge> path = new ArrayList<>();
Graph<Node, OsmEdge> g;
double totalWeight = 0;
RoutingLayer layer = (RoutingLayer) Main.map.mapView.getActiveLayer();
RoutingModel routingModel = layer.getRoutingModel();
if (graph == null || routingModel.getOnewayChanged()) this.createGraph();
logger.debug("apply algorithm between nodes ");
for (Node node : nodes) {
logger.debug(node.getId());
}
logger.debug("-----------------------------------");
// Assign the graph to g
g = graph;
switch (algorithm) {
case ROUTING_ALG_DIJKSTRA:
logger.debug("Using Dijkstra algorithm");
DijkstraShortestPath<Node, OsmEdge> routingk = null;
for (int index = 1; index < nodes.size(); ++index) {
routingk = new DijkstraShortestPath<>(g, nodes.get(index - 1), nodes.get(index));
if (routingk.getPathEdgeList() == null) {
logger.debug("no path found!");
break;
}
path.addAll(routingk.getPathEdgeList());
totalWeight += routingk.getPathLength();
}
break;
case ROUTING_ALG_BELLMANFORD:
logger.debug("Using Bellman Ford algorithm");
for (int index = 1; index < nodes.size(); ++index) {
path =
BellmanFordShortestPath.findPathBetween(
rgDelegator, nodes.get(index - 1), nodes.get(index));
if (path == null) {
logger.debug("no path found!");
return null;
}
}
break;
default:
logger.debug("Wrong algorithm");
break;
}
logger.debug("shortest path found: " + path + "\nweight: " + totalWeight);
return path;
}
@Test
public void testBackrefrenceForRelation_Full() throws OsmTransferException {
Relation r = lookupRelation(ds, 1);
assertNotNull(r);
// way with name "relation-1" is referred to by four relations:
// relation-6, relation-7, relation-8, relation-9
//
OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(r);
reader.setReadFull(true);
DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
Set<Long> referringRelationsIds = new HashSet<Long>();
r = lookupRelation(referers, 6);
assertNotNull(r);
assertEquals(false, r.isIncomplete());
referringRelationsIds.add(r.getId());
r = lookupRelation(referers, 7);
assertNotNull(r);
assertEquals(false, r.isIncomplete());
referringRelationsIds.add(r.getId());
r = lookupRelation(referers, 8);
assertNotNull(r);
assertEquals(false, r.isIncomplete());
referringRelationsIds.add(r.getId());
r = lookupRelation(referers, 9);
assertNotNull(r);
assertEquals(false, r.isIncomplete());
referringRelationsIds.add(r.getId());
// all relations are fully loaded
//
for (Relation r1 : referers.getRelations()) {
assertEquals(false, r1.isIncomplete());
}
// make sure we read all ways referred to by parent relations. These
// ways are completely read after reading the relations
//
Set<Long> expectedWayIds = new HashSet<Long>();
for (RelationMember m : lookupRelation(ds, 6).getMembers()) {
if (m.isWay()) {
expectedWayIds.add(m.getMember().getId());
}
}
for (RelationMember m : lookupRelation(ds, 7).getMembers()) {
if (m.isWay()) {
expectedWayIds.add(m.getMember().getId());
}
}
for (RelationMember m : lookupRelation(ds, 8).getMembers()) {
if (m.isWay()) {
expectedWayIds.add(m.getMember().getId());
}
}
for (RelationMember m : lookupRelation(ds, 9).getMembers()) {
if (m.isWay()) {
expectedWayIds.add(m.getMember().getId());
}
}
for (long id : expectedWayIds) {
Way w = (Way) referers.getPrimitiveById(id, OsmPrimitiveType.WAY);
assertNotNull(w);
assertEquals(false, w.isIncomplete());
}
Set<Long> expectedNodeIds = new HashSet<Long>();
for (int i = 6; i < 10; i++) {
Relation r1 = lookupRelation(ds, i);
expectedNodeIds.addAll(getNodeIdsInRelation(r1));
}
assertEquals(expectedNodeIds.size(), referers.getNodes().size());
for (Node n : referers.getNodes()) {
assertEquals(true, expectedNodeIds.contains(n.getId()));
}
}
