package net.osmand.router;
import net.osmand.Location;
import net.osmand.PlatformUtil;
import net.osmand.binary.RouteDataObject;
import net.osmand.router.GeneralRouter.GeneralRouterProfile;
import net.osmand.router.GeneralRouter.RouteAttributeContext;
import net.osmand.router.GeneralRouter.RouteDataObjectAttribute;
import net.osmand.util.Algorithms;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
public class RoutingConfiguration {
public static final int DEFAULT_MEMORY_LIMIT = 30;
public final float DEVIATION_RADIUS = 3000;
public Map<String, String> attributes = new LinkedHashMap<String, String>();
// 1. parameters of routing and different tweaks
// Influence on A* : f(x) + heuristicCoefficient*g(X)
public float heuristicCoefficient = 1;
// 1.1 tile load parameters (should not affect routing)
public int ZOOM_TO_LOAD_TILES = 16;
public int memoryLimitation;
// 1.2 Build A* graph in backward/forward direction (can affect results)
// 0 - 2 ways, 1 - direct way, -1 - reverse way
public int planRoadDirection = 0;
// 1.3 Router specific coefficients and restrictions
// use GeneralRouter and not interface to simplify native access !
public GeneralRouter router = new GeneralRouter(GeneralRouterProfile.CAR, new LinkedHashMap<String, String>());
public String routerName = "";
// 1.4 Used to calculate route in movement
public Double initialDirection;
// 1.5 Recalculate distance help
public float recalculateDistance = 20000f;
public static class Builder {
// Design time storage
private String defaultRouter = "";
private Map<String, GeneralRouter> routers = new LinkedHashMap<String, GeneralRouter>();
private Map<String, String> attributes = new LinkedHashMap<String, String>();
private HashMap<Long, Location> impassableRoadLocations = new HashMap<Long, Location>();
private List<RouteDataObject> impassableRoads = new ArrayList<RouteDataObject>();
// Example
// {
// impassableRoadLocations.add(23000069L);
// }
public RoutingConfiguration build(String router, int memoryLimitMB) {
return build(router, null, memoryLimitMB, null);
}
public RoutingConfiguration build(String router, int memoryLimitMB, Map<String, String> params) {
return build(router, null, memoryLimitMB, params);
}
public RoutingConfiguration build(String router, Double direction, int memoryLimitMB, Map<String, String> params) {
if (!routers.containsKey(router)) {
router = defaultRouter;
}
RoutingConfiguration i = new RoutingConfiguration();
if (routers.containsKey(router)) {
i.router = routers.get(router);
if (params != null) {
i.router = i.router.build(params);
}
i.routerName = router;
}
attributes.put("routerName", router);
i.attributes.putAll(attributes);
i.initialDirection = direction;
i.recalculateDistance = parseSilentFloat(getAttribute(i.router, "recalculateDistanceHelp"), i.recalculateDistance) ;
i.heuristicCoefficient = parseSilentFloat(getAttribute(i.router, "heuristicCoefficient"), i.heuristicCoefficient);
i.router.addImpassableRoads(impassableRoadLocations.keySet());
i.ZOOM_TO_LOAD_TILES = parseSilentInt(getAttribute(i.router, "zoomToLoadTiles"), i.ZOOM_TO_LOAD_TILES);
int desirable = parseSilentInt(getAttribute(i.router, "memoryLimitInMB"), 0);
if(desirable != 0) {
i.memoryLimitation = desirable * (1 << 20);
} else {
if(memoryLimitMB == 0) {
memoryLimitMB = DEFAULT_MEMORY_LIMIT;
}
i.memoryLimitation = memoryLimitMB * (1 << 20);
}
i.planRoadDirection = parseSilentInt(getAttribute(i.router, "planRoadDirection"), i.planRoadDirection);
// i.planRoadDirection = 1;
return i;
}
public List<RouteDataObject> getImpassableRoads() {
return impassableRoads;
}
public Map<Long, Location> getImpassableRoadLocations() {
return impassableRoadLocations;
}
public boolean addImpassableRoad(RouteDataObject route, Location location) {
if (!impassableRoadLocations.containsKey(route.id)){
impassableRoadLocations.put(route.id, location);
impassableRoads.add(route);
return true;
}
return false;
}
private String getAttribute(VehicleRouter router, String propertyName) {
if (router.containsAttribute(propertyName)) {
return router.getAttribute(propertyName);
}
return attributes.get(propertyName);
}
public String getDefaultRouter() {
return defaultRouter;
}
public GeneralRouter getRouter(String applicationMode) {
return routers.get(applicationMode);
}
public void removeImpassableRoad(RouteDataObject obj) {
impassableRoadLocations.remove(obj.id);
impassableRoads.remove(obj);
}
}
private static int parseSilentInt(String t, int v) {
if (t == null || t.length() == 0) {
return v;
}
return Integer.parseInt(t);
}
private static float parseSilentFloat(String t, float v) {
if (t == null || t.length() == 0) {
return v;
}
return Float.parseFloat(t);
}
private static RoutingConfiguration.Builder DEFAULT;
public static RoutingConfiguration.Builder getDefault() {
if (DEFAULT == null) {
try {
DEFAULT = parseFromInputStream(RoutingConfiguration.class.getResourceAsStream("routing.xml"));
} catch (Exception e) {
throw new IllegalStateException(e);
}
}
return DEFAULT;
}
public static RoutingConfiguration.Builder parseFromInputStream(InputStream is) throws IOException, XmlPullParserException {
XmlPullParser parser = PlatformUtil.newXMLPullParser();
final RoutingConfiguration.Builder config = new RoutingConfiguration.Builder();
GeneralRouter currentRouter = null;
RouteDataObjectAttribute currentAttribute = null;
String preType = null;
Stack<RoutingRule> rulesStck = new Stack<RoutingConfiguration.RoutingRule>();
parser.setInput(is, "UTF-8");
int tok;
while ((tok = parser.next()) != XmlPullParser.END_DOCUMENT) {
if (tok == XmlPullParser.START_TAG) {
String name = parser.getName();
if ("osmand_routing_config".equals(name)) {
config.defaultRouter = parser.getAttributeValue("", "defaultProfile");
} else if ("routingProfile".equals(name)) {
currentRouter = parseRoutingProfile(parser, config);
} else if ("attribute".equals(name)) {
parseAttribute(parser, config, currentRouter);
} else if ("parameter".equals(name)) {
parseRoutingParameter(parser, currentRouter);
} else if ("point".equals(name) || "way".equals(name)) {
String attribute = parser.getAttributeValue("", "attribute");
currentAttribute = RouteDataObjectAttribute.getValueOf(attribute);
preType = parser.getAttributeValue("", "type");
} else {
parseRoutingRule(parser, currentRouter, currentAttribute, preType, rulesStck);
}
} else if (tok == XmlPullParser.END_TAG) {
String pname = parser.getName();
if (checkTag(pname)) {
rulesStck.pop();
}
}
}
is.close();
return config;
}
private static void parseRoutingParameter(XmlPullParser parser, GeneralRouter currentRouter) {
String description = parser.getAttributeValue("", "description");
String group = parser.getAttributeValue("", "group");
String name = parser.getAttributeValue("", "name");
String id = parser.getAttributeValue("", "id");
String type = parser.getAttributeValue("", "type");
boolean defaultValue = Boolean.parseBoolean(parser.getAttributeValue("", "default"));
if (type.equalsIgnoreCase("boolean")) {
currentRouter.registerBooleanParameter(id, Algorithms.isEmpty(group) ? null : group, name, description, defaultValue);
} else if(type.equalsIgnoreCase("numeric")) {
String values = parser.getAttributeValue("", "values");
String valueDescriptions = parser.getAttributeValue("", "valueDescriptions");
String[] strValues = values.split(",");
Double[] vls = new Double[strValues.length];
for(int i =0; i< vls.length; i++) {
vls[i] =Double.parseDouble(strValues[i].trim());
}
currentRouter.registerNumericParameter(id, name, description, vls ,
valueDescriptions.split(","));
} else {
throw new UnsupportedOperationException("Unsupported routing parameter type - " + type);
}
}
private static class RoutingRule {
String tagName;
String t;
String v;
String param;
String value1;
String value2;
String type;
}
private static void parseRoutingRule(XmlPullParser parser, GeneralRouter currentRouter, RouteDataObjectAttribute attr,
String parentType, Stack<RoutingRule> stack) {
String pname = parser.getName();
if (checkTag(pname)) {
if(attr == null){
throw new NullPointerException("Select tag filter outside road attribute < " + pname + " > : "+parser.getLineNumber());
}
RoutingRule rr = new RoutingRule();
rr.tagName = pname;
rr.t = parser.getAttributeValue("", "t");
rr.v = parser.getAttributeValue("", "v");
rr.param = parser.getAttributeValue("", "param");
rr.value1 = parser.getAttributeValue("", "value1");
rr.value2 = parser.getAttributeValue("", "value2");
rr.type = parser.getAttributeValue("", "type");
if((rr.type == null || rr.type.length() == 0) &&
parentType != null && parentType.length() > 0) {
rr.type = parentType;
}
RouteAttributeContext ctx = currentRouter.getObjContext(attr);
if("select".equals(rr.tagName)) {
String val = parser.getAttributeValue("", "value");
String type = rr.type;
ctx.registerNewRule(val, type);
addSubclause(rr, ctx);
for (int i = 0; i < stack.size(); i++) {
addSubclause(stack.get(i), ctx);
}
} else if(stack.size() > 0 && stack.peek().tagName.equals("select")) {
addSubclause(rr, ctx);
}
stack.push(rr);
}
}
private static boolean checkTag(String pname) {
return "select".equals(pname) || "if".equals(pname) || "ifnot".equals(pname)
|| "gt".equals(pname) || "le".equals(pname) || "eq".equals(pname);
}
private static void addSubclause(RoutingRule rr, RouteAttributeContext ctx) {
boolean not = "ifnot".equals(rr.tagName);
if(!Algorithms.isEmpty(rr.param)) {
ctx.getLastRule().registerAndParamCondition(rr.param, not);
}
if (!Algorithms.isEmpty(rr.t)) {
ctx.getLastRule().registerAndTagValueCondition(rr.t, Algorithms.isEmpty(rr.v) ? null : rr.v, not);
}
if (rr.tagName.equals("gt")) {
ctx.getLastRule().registerGreatCondition(rr.value1, rr.value2, rr.type);
} else if (rr.tagName.equals("le")) {
ctx.getLastRule().registerLessCondition(rr.value1, rr.value2, rr.type);
} else if (rr.tagName.equals("eq")) {
ctx.getLastRule().registerEqualCondition(rr.value1, rr.value2, rr.type);
}
}
private static GeneralRouter parseRoutingProfile(XmlPullParser parser, final RoutingConfiguration.Builder config) {
String currentSelectedRouter = parser.getAttributeValue("", "name");
Map<String, String> attrs = new LinkedHashMap<String, String>();
for(int i=0; i< parser.getAttributeCount(); i++) {
attrs.put(parser.getAttributeName(i), parser.getAttributeValue(i));
}
GeneralRouterProfile c = Algorithms.parseEnumValue(GeneralRouterProfile.values(),
parser.getAttributeValue("", "baseProfile"), GeneralRouterProfile.CAR);
GeneralRouter currentRouter = new GeneralRouter(c, attrs);
config.routers.put(currentSelectedRouter, currentRouter);
return currentRouter;
}
private static void parseAttribute(XmlPullParser parser, final RoutingConfiguration.Builder config, GeneralRouter currentRouter) {
if(currentRouter != null) {
currentRouter.addAttribute(parser.getAttributeValue("", "name"),
parser.getAttributeValue("", "value"));
} else {
config.attributes.put(parser.getAttributeValue("", "name"),
parser.getAttributeValue("", "value"));
}
}
}