/// <inheritdoc/>
public void Reset()
{
_remainder = null;
_increase = !RouteMode.HasFlag(RouteMode.Reverse);
CurrentIndex = CInd;
NextIndex = NInd;
}
public RoutingData(SwimHost host, int routeId, RouteExecution execution, RouteMode mode)
{
Host = host;
RouteId = routeId;
Execution = execution;
Mode = mode;
}
void RouteBox()
{
int boxWidth = 300;
int boxHeight = 40;
int boxX = Screen.width / 2 - (boxWidth / 2);
int boxY = (Screen.height - boxHeight) - 52;
GUI.BeginGroup(new Rect(boxX, boxY, boxWidth, boxHeight));
GUI.Box(new Rect(00, 00, boxWidth, boxHeight), "");
if (route.patrol.Count > 0)
{
for (int i = 0; i < route.patrol.Count; i++)
{
if (GUI.Button(new Rect(0 + (i * 65) + (i * 5), 10, 65, 20), "Route " + (i + 1).ToString()))
{
route.RouteGraphicsClean();
route.RouteGraphicsPopulate((i));
}
}
}
switch (routemode)
{
case RouteMode.AddRoute:
if (GUI.Button(new Rect(0 + (route.patrol.Count * 65) + (route.patrol.Count * 5), 10, 75, 20), "Add Route"))
{
// new route.patrol();
clicker.Lclick = s_Clicker.LClicker.RouteStartClick;
clicker.Rclick = s_Clicker.RClicker.WayPointRemoveClick;
routemode = RouteMode.CompleteRoute;
}
break;
case RouteMode.CompleteRoute:
Btn_Name = "Complete Route";
if (GUI.Button(new Rect(0 + (route.patrol.Count * 65) + (route.patrol.Count * 5), 10, 115, 20), "Complete Route"))
{
//route.patrol.add();
clicker.Lclick = s_Clicker.LClicker.LNoneClick;
clicker.Rclick = s_Clicker.RClicker.RNoneClick;
routemode = RouteMode.AddRoute;
}
break;
}
if (new Rect(boxX, (Screen.height - (boxY + boxHeight)), boxWidth, boxHeight).Contains(Input.mousePosition))
{
clickSecondTaskBar = true;
}
else
{
clickSecondTaskBar = false;
}
GUI.EndGroup();
}
private string CreateRequestUri(RouteMode mode = RouteMode.Car)
{
var modeStr = (mode.ToString()).ToCamelCase();
return $"/2/matchroute.json?app_id={_apiSettings.AppId}" +
$"&app_code={_apiSettings.AppCode}" +
$"&routemode={modeStr}" +
$"&Te=gzip,deflate" +
$"&Accept-encoding=gzip,deflate";
}
/// <summary>
/// Initializes a new instance of the <see cref="RoutedList{T}"/> class that is empty and has the specified initial capacity, route type and route mode.
/// </summary>
/// <param name="capacity"></param>
/// <param name="routeType"></param>
/// <param name="routeMode"></param>
public RoutedList(int capacity, RouteType routeType, RouteMode routeMode) : base(capacity)
{
_remainder = null;
RouteType = routeType;
RouteMode = routeMode;
_increase = !RouteMode.HasFlag(RouteMode.Reverse);
CurrentIndex = CInd;
BeginIndex = BInd;
EndIndex = EInd;
NextIndex = NInd;
}
/// <summary>
/// Initializes a new instance of the <see cref="RoutedList{T}"/> class that is empty and has the specified initial capacity and the default initial route type and route mode.
/// </summary>
/// <param name="capacity"></param>
public RoutedList(int capacity) : base(capacity)
{
_remainder = null;
RouteType = RouteType.Linear;
RouteMode = RouteMode.Default;
_increase = !RouteMode.HasFlag(RouteMode.Reverse);
CurrentIndex = CInd;
BeginIndex = BInd;
EndIndex = EInd;
NextIndex = NInd;
}
/// <summary>
/// Initializes a new instance of the <see cref="RoutedList{T}"/> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied and the specified initial route type and route mode.
/// </summary>
/// <param name="collection"></param>
/// <param name="routeType"></param>
/// <param name="routeMode"></param>
public RoutedList(IEnumerable <T> collection, RouteType routeType, RouteMode routeMode) : base(collection)
{
_remainder = null;
RouteType = routeType;
RouteMode = routeMode;
_increase = !RouteMode.HasFlag(RouteMode.Reverse);
CurrentIndex = CInd;
BeginIndex = BInd;
EndIndex = EInd;
NextIndex = NInd;
}
/// <inheritdoc/>
public XmlElement ToXmlElement(XmlDocument xmlDocument, ref IList <object> id_source, string name = "")
{
if (xmlDocument is null)
{
throw new ArgumentNullException(nameof(xmlDocument));
}
if (id_source is null)
{
throw new ArgumentNullException(nameof(id_source));
}
if (name is null)
{
throw new ArgumentNullException(nameof(name));
}
if (name == "")
{
name = GetType().Name;
}
XmlElement xmlThis = xmlDocument.CreateElement(name);
if (id_source.Contains(this))
{
xmlThis.SetAttribute("ref", id_source.IndexOf(this).ToString("x16"));
}
else
{
xmlThis.SetAttribute("id", id_source.Count.ToString("x16"));
id_source.Add(this);
xmlThis.SetAttribute("type", GetType().FullName);
XmlElement xmlRoute = xmlDocument.CreateElement("RouteType");
xmlThis.AppendChild(xmlRoute);
xmlRoute.InnerText = RouteType.ToString();
XmlElement xmlRouteMode = xmlDocument.CreateElement("RouteMode");
xmlThis.AppendChild(xmlRouteMode);
xmlRouteMode.InnerText = RouteMode.ToString();
XmlElement xmlIncrease = xmlDocument.CreateElement("Increase");
xmlThis.AppendChild(xmlIncrease);
xmlIncrease.InnerText = _increase.ToString();
XmlElement xmlCurrentIndex = xmlDocument.CreateElement("CurrentIndex");
xmlThis.AppendChild(xmlCurrentIndex);
xmlCurrentIndex.InnerText = CurrentIndex is null ? "null" : CurrentIndex.ToString();
XmlElement xmlEntries = xmlDocument.CreateElement("Entries");
xmlThis.AppendChild(xmlEntries);
foreach (T entry in this)
{
XmlElement xmlEntry = CyclicalMethods.ToXmlElement(entry, xmlDocument, ref id_source, "Entry");
xmlEntries.AppendChild(xmlEntry);
}
}
return(xmlThis);
}
/// <inheritdoc/>
public void SetRouteMode(RouteMode routeMode)
{
if (RouteMode != routeMode)
{
_remainder = null;
}
else
{
return;
}
if (RouteMode.HasFlag(RouteMode.Reverse) != routeMode.HasFlag(RouteMode.Reverse))
{
_increase = !_increase;
}
RouteMode = routeMode;
BeginIndex = BInd;
EndIndex = EInd;
NextIndex = NInd;
}
/// <summary>
/// Returns the route through points "nodes" starting with Vehicles "vehicles",
/// without using any vehicletype from "forbiddenVehicles" and using myVehicles "myVehicles".
/// </summary>
public Route CalcRoute(long[] nodes, List<Vehicle> vehicles, List<Vehicle> forbiddenVehicles, List<MyVehicle> myVehicles, RouteMode mode)
{
Route res = new Route(new Node[0], Vehicle.Foot);
res.Length = double.PositiveInfinity;
res.Time = double.PositiveInfinity;
Route r = null;
double min = double.PositiveInfinity;
for (int i = 0; i < myVehicles.Count; i++ )
{
MyVehicle v = myVehicles[i];
if (!forbiddenVehicles.Contains(v.VehicleType))
{
// Calc route to the MyVehicle
List<MyVehicle> newMyVehicles = new List<MyVehicle>();
foreach (MyVehicle vNew in myVehicles)
if (vNew != v)
newMyVehicles.Add(vNew);
Route toVehicle = CalcRoute(new long[] { nodes[0], v.Location.ID }, vehicles, forbiddenVehicles, newMyVehicles, mode);
Route fromVehicle = null;
v.Route = toVehicle;
if (toVehicle != null && !Double.IsPositiveInfinity(toVehicle.Length))
{
// Calc route from MyVehicle through the given points
long[] through = new long[nodes.Length];
Array.Copy(nodes, through, nodes.Length);
through[0] = v.Location.ID;
fromVehicle = CalcRoute(through, new List<Vehicle>() { v.VehicleType, Vehicle.Foot }, forbiddenVehicles, newMyVehicles, mode);
// Route from source to destination using MyVehicle is
r = toVehicle + fromVehicle;
if (v.VehicleType == Vehicle.Bicycle) {
r.Time += 60; //assuming it costs 1 minute to get your bicycle.
}
else if (v.VehicleType == Vehicle.Car) {
r.Time += 4; //assumin it costs 4 minutes to get and park your car.
}
}
if (r != null && (r.Time < min && mode == RouteMode.Fastest || r.Length < min && mode == RouteMode.Shortest))
{
res = r;
switch (mode)
{
case RouteMode.Fastest:
min = r.Time;
break;
case RouteMode.Shortest:
min = r.Length;
break;
}
}
}
}
if (nodes.Length >= 2)
{
r = Dijkstra(nodes[0], nodes[1], vehicles.ToArray(), mode, !forbiddenVehicles.Contains(Vehicle.Bus));
if (nodes.Length > 2)
{
r += CalcRoute(SubArray(nodes, 1, nodes.Length), vehicles, forbiddenVehicles, myVehicles, mode);
}
}
if (r != null && (r.Time <= min && mode == RouteMode.Fastest || r.Length <= min && mode == RouteMode.Shortest))
res = r;
return res;
}
public Task RegisterBusHandlerAsync(IRequestMatcher pattern, Func <Message, CancellationToken, Task> handler, RouteExecution execution = RouteExecution.Asynchronous, RouteMode mode = RouteMode.Observe, CancellationToken cancellationToken = default)
{
_busRouter.Register(string.Empty, pattern, new BusRoutingData(handler));
return(Task.CompletedTask);
}
public void SetRouteMode(RouteMode routeMode) => _workers.SetRouteMode(routeMode);
public Manager(RouteType routeType, RouteMode routeMode) : base()
{
_workers = new RoutedList <IWorker>(routeType, routeMode);
}
void RouteBox()
{
int boxWidth = 300;
int boxHeight = 40;
int boxX = Screen.width / 2 - (boxWidth / 2);
int boxY = (Screen.height - boxHeight) - 52;
GUI.BeginGroup(new Rect(boxX, boxY, boxWidth, boxHeight));
GUI.Box(new Rect(00, 00, boxWidth, boxHeight), "");
if (route.patrol.Count > 0)
{
for (int i = 0; i < route.patrol.Count; i++)
{
if (GUI.Button(new Rect(0 + (i * 65) + (i * 5), 10, 65, 20), "Route " + (i + 1).ToString()))
{
route.RouteGraphicsClean();
route.RouteGraphicsPopulate((i));
}
}
}
switch (routemode)
{
case RouteMode.AddRoute:
if (GUI.Button(new Rect(0 + (route.patrol.Count * 65) + (route.patrol.Count * 5), 10, 75, 20), "Add Route"))
{
// new route.patrol();
clicker.Lclick = s_Clicker.LClicker.RouteStartClick;
clicker.Rclick = s_Clicker.RClicker.WayPointRemoveClick;
routemode = RouteMode.CompleteRoute;
}
break;
case RouteMode.CompleteRoute:
Btn_Name = "Complete Route";
if (GUI.Button(new Rect(0 + (route.patrol.Count * 65) + (route.patrol.Count * 5), 10, 115, 20), "Complete Route"))
{
//route.patrol.add();
clicker.Lclick = s_Clicker.LClicker.LNoneClick;
clicker.Rclick = s_Clicker.RClicker.RNoneClick;
routemode = RouteMode.AddRoute;
}
break;
}
if (new Rect(boxX, (Screen.height - (boxY + boxHeight)), boxWidth, boxHeight).Contains(Input.mousePosition))
clickSecondTaskBar = true;
else
clickSecondTaskBar = false;
GUI.EndGroup();
}
public async Task<IEnumerable<PointDTO>> GetRouteMatchingPoints(CancellationToken ct, string content, RouteMode mode = RouteMode.Car)
{
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_apiSettings.BaseUrl);
var requestUri = CreateRequestUri(mode);
using (var request = new HttpRequestMessage(HttpMethod.Post, requestUri))
{
request.Content = new StringContent(content, Encoding.UTF8, "text/plain");
using (var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct).ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
return await GetPointsFromResponse(response);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Dijkstra in graph gr, from source to destination, using vehicle v.
/// </summary>
/// <param name="source"> the startpoint </param>
/// <param name="destination"> the destination </param>
/// <param name="v"> vehicle that is used </param>
/// <returns></returns>
public Route Dijkstra(long from, long to, Vehicle[] vehicles, RouteMode mode, bool useBus)
{
Route result = null;
if (from == 0 || to == 0 || graph == null)
{
return(result);
}
Node source = graph.GetNode(from);
Node destination = graph.GetNode(to);
//all nodes that are completely solved
SortedList <long, Node> solved = new SortedList <long, Node>();
//nodes that are encountered but not completely solved
SortedList <double, Node> unsolved = new SortedList <double, Node>();
RBTree <Node> prevs = new RBTree <Node>();
RBTree <double> times = new RBTree <double>();
RBTree <double> distances = new RBTree <double>();
RBTree <Vehicle> vehicleUse = new RBTree <Vehicle>();
ListTree <Vehicle> forbiddenVehicles = new ListTree <Vehicle>();
List <Edge> abstractBusses = graph.GetAbstractBusEdges();
Node current = source;
bool found = false;
//if there's no new current node it means the algorithm should stop
while (current != null)
{
//if we encounter the destination it means we found the shortest route so we break
if (current == destination)
{
found = true;
break;
}
List <Edge> edges = new List <Edge>(graph.GetEdgesFromNode(current.ID));
foreach (Edge busEdge in abstractBusses)
{
if (busEdge.End == current.ID || busEdge.Start == current.ID)
{
edges.Add(busEdge);
}
}
Node prev = prevs.Get(current.ID);
if (prev != null)
{
foreach (Vehicle vehicle in forbiddenVehicles.Get(prev.ID))
{
forbiddenVehicles.Insert(current.ID, vehicle);
}
}
foreach (Edge e in edges)
{
if (IsAllowed(e, vehicles, useBus))
{
Node start = graph.GetNode(e.Start);
Node end = graph.GetNode(e.End);
double distance = double.PositiveInfinity;
double time = double.PositiveInfinity;
Vehicle v = vehicles[0];
if (e.Type != CurveType.AbstractBusRoute)
{
if (e.Type != CurveType.Bus)
{
double speed = 0;
foreach (Vehicle vehicle in vehicles)
{
if (!forbiddenVehicles.Get(current.ID).Contains(vehicle))
{
double vSpeed = GetSpeed(vehicle, e);
if (vSpeed > speed && IsAllowed(e, vehicle, useBus))
{
speed = vSpeed;
v = vehicle;
}
}
}
distance = NodeCalcExtensions.Distance(start, end);
time = distance / speed;
}
else if (e.Route != null)
{
// Take busroute if better
if (mode == RouteMode.Fastest && time > e.Route.Time || mode == RouteMode.Shortest && distance > e.Route.Length)
{
distance = e.Route.Length;
time = e.Route.Time;
v = Vehicle.Foot;
foreach (Vehicle vehicle in vehicles)
{
if (vehicle != Vehicle.Foot)
{
forbiddenVehicles.Insert(current.ID, vehicle);
}
}
}
}
}
else
{
Node n1 = null, n2 = null;
if (start.Longitude != 0 || start.Latitude != 0)
{
n1 = graph.GetNodeByPos(start.Longitude, start.Latitude, Vehicle.Bus);
}
if (end.Longitude != 0 || end.Latitude != 0)
{
n2 = graph.GetNodeByPos(end.Longitude, end.Latitude, Vehicle.Bus);
}
if (n1 != default(Node) && n2 != default(Node))
{
Curve curve = new Curve(new long[] { start.ID, end.ID }, e.Name);
Route r = this.Dijkstra(n1.ID, n2.ID, new Vehicle[] { Vehicle.Bus }, RouteMode.Fastest, false);
r = new Route(new Node[] { start }, Vehicle.Bus) + r + new Route(new Node[] { end }, Vehicle.Bus);
curve.Type = CurveType.Bus;
curve.Route = r;
// We calculate with 60 seconds of switch over to the bus.
r.Time += 60;
graph.AddWay(start.ID, curve);
graph.AddWay(end.ID, curve);
e.Route = r;
e.Type = CurveType.Bus;
// Take busroute if better
if (mode == RouteMode.Fastest && time > e.Route.Time || mode == RouteMode.Shortest && distance > e.Route.Length)
{
distance = e.Route.Length;
time = e.Route.Time;
v = Vehicle.Foot;
foreach (Vehicle vehicle in vehicles)
{
if (vehicle != Vehicle.Foot)
{
forbiddenVehicles.Insert(current.ID, vehicle);
}
}
}
}
graph.RemoveAbstractBus(e);
abstractBusses.Remove(e);
}
time += times.Get(current.ID);
double trueDist = distances.Get(current.ID) + distance;
if (!solved.ContainsValue(end) && current != end)
{
if (end.Latitude != 0 && end.Longitude != 0)
{
if (times.Get(end.ID) == 0 || distances.Get(end.ID) == 0)
{
times.Insert(end.ID, double.PositiveInfinity);
distances.Insert(end.ID, double.PositiveInfinity);
vehicleUse.Insert(end.ID, v);
}
if ((mode == RouteMode.Fastest &&
times.Get(end.ID) > time) ||
(mode == RouteMode.Shortest &&
distances.Get(end.ID) > trueDist))
{
times.GetNode(end.ID).Content = time;
distances.GetNode(end.ID).Content = trueDist;
vehicleUse.GetNode(end.ID).Content = v;
if (prevs.GetNode(end.ID).Content == null)
{
prevs.Insert(end.ID, current);
}
else
{
prevs.GetNode(end.ID).Content = current;
}
if (!unsolved.ContainsValue(end))
{
if (mode == RouteMode.Fastest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(times.Get(end.ID)))
{
times.GetNode(end.ID).Content += 0.0000000001;
}
unsolved.Add(times.Get(end.ID), end);
}
else if (mode == RouteMode.Shortest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(distances.Get(end.ID)))
{
distances.GetNode(end.ID).Content += 0.0000000001;
}
unsolved.Add(distances.Get(end.ID), end);
}
if (prevs.GetNode(current.ID).Content != null &&
vehicleUse.Get(prevs.GetNode(current.ID).Content.ID) == Vehicle.Car)
{
if (v == Vehicle.Foot)
{
forbiddenVehicles.Insert(end.ID, Vehicle.Car);
}
}
}
}
}
}
else if (!solved.ContainsValue(start) && current != start)
{
if (start.Latitude != 0 && start.Longitude != 0)
{
if (times.Get(start.ID) == 0 || distances.Get(start.ID) == 0)
{
times.Insert(start.ID, double.PositiveInfinity);
distances.Insert(start.ID, double.PositiveInfinity);
vehicleUse.Insert(start.ID, v);
}
if ((mode == RouteMode.Fastest &&
times.Get(start.ID) > time) ||
(mode == RouteMode.Shortest &&
distances.Get(start.ID) > trueDist))
{
times.GetNode(start.ID).Content = time;
distances.GetNode(start.ID).Content = trueDist;
vehicleUse.GetNode(start.ID).Content = v;
if (prevs.GetNode(start.ID).Content == null)
{
prevs.Insert(start.ID, current);
}
else
{
prevs.GetNode(start.ID).Content = current;
}
if (!unsolved.ContainsValue(start))
{
if (mode == RouteMode.Fastest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(times.Get(start.ID)))
{
times.GetNode(start.ID).Content += 0.0000000001;
}
unsolved.Add(times.Get(start.ID), start);
}
else if (mode == RouteMode.Shortest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(distances.Get(start.ID)))
{
distances.GetNode(start.ID).Content += 0.0000000001;
}
unsolved.Add(distances.Get(start.ID), start);
}
}
if (prevs.GetNode(current.ID).Content != null &&
vehicleUse.Get(prevs.GetNode(current.ID).Content.ID) == Vehicle.Car)
{
if (v == Vehicle.Foot)
{
forbiddenVehicles.Insert(start.ID, Vehicle.Car);
}
}
}
}
}
}
}
//dit zou niet voor moeten komen maar toch gebeurt het...
if (!solved.ContainsKey(current.ID))
{
solved.Add(current.ID, current);
}
if (unsolved.Count > 0)
{
current = unsolved.Values[0];
unsolved.RemoveAt(0);
}
else
{
current = null;
}
}
if (found)
{
List <Node> nodes = new List <Node>();
List <long> extras = graph.GetExtras();
Node n = destination;
List <long> busStartStop = new List <long>();
do
{
bool foundRoute = false;
if (extras.Contains(n.ID))
{
// Change straigt buslines in for the actual route.
foreach (Edge e in graph.GetEdgesFromNode(n.ID))
{
if (prevs.Get(n.ID) != null && e.Route != null)
{
if (n.ID == e.Start &&
prevs.Get(n.ID).ID == e.End)
{
Node[] busNodes = e.Route.Points;
if (busNodes[0].ID == e.Start)
{
Array.Reverse(busNodes);
}
busStartStop.Add(busNodes[busNodes.Length - 1].ID);
busStartStop.Add(busNodes[0].ID);
nodes.InsertRange(0, busNodes);
n = prevs.Get(n.ID);
foundRoute = true;
break;
}
else if (n.ID == e.End &&
prevs.Get(n.ID).ID == e.Start)
{
Node[] busNodes = e.Route.Points;
if (busNodes[0].ID == e.End)
{
Array.Reverse(busNodes);
}
busStartStop.Add(busNodes[busNodes.Length - 1].ID);
busStartStop.Add(busNodes[0].ID);
nodes.InsertRange(0, busNodes);
n = prevs.Get(n.ID);
foundRoute = true;
break;
}
}
}
}
if (!foundRoute)
{
nodes.Insert(0, n);
n = prevs.Get(n.ID);
}
} while (n != null);
result = new Route(nodes.ToArray(), vehicles[0]);
result.Time = times.Get(destination.ID);
result.Length = distances.Get(destination.ID);
// Set bus as vehicle
if (busStartStop.Count > 0)
{
int i = busStartStop.Count - 1;
Node[] routePoints = result.Points;
for (int j = 0; j < routePoints.Length; j++)
{
if (routePoints[j].ID == busStartStop[i])
{
if (i % 2 == 1)
{
result.SetVehicle(Vehicle.Bus, j);
i--;
}
else
{
result.SetVehicle(Vehicle.Foot, j);
i--;
}
}
if (i < 0)
{
break;
}
}
}
Vehicle cur = result.GetVehicle(0), prev;
for (int i = 2; i < result.NumOfNodes; i++)
{
if (result.GetVehicle(i) != Vehicle.Bus)
{
prev = vehicleUse.Get(result[i].ID);
if (prev != cur && i > 1)
{
result.SetVehicle(prev, i - 1);
}
cur = prev;
}
}
}
else
{
result = new Route(new Node[] { source }, vehicles[0]);
result.Time = double.PositiveInfinity;
result.Length = double.PositiveInfinity;
}
return(result);
}
/// <summary>
/// Returns the route through points "nodes" starting with Vehicles "vehicles",
/// without using any vehicletype from "forbiddenVehicles" and using myVehicles "myVehicles".
/// </summary>
public Route CalcRoute(long[] nodes, List <Vehicle> vehicles, List <Vehicle> forbiddenVehicles, List <MyVehicle> myVehicles, RouteMode mode)
{
Route res = new Route(new Node[0], Vehicle.Foot);
res.Length = double.PositiveInfinity;
res.Time = double.PositiveInfinity;
Route r = null;
double min = double.PositiveInfinity;
for (int i = 0; i < myVehicles.Count; i++)
{
MyVehicle v = myVehicles[i];
if (!forbiddenVehicles.Contains(v.VehicleType))
{
// Calc route to the MyVehicle
List <MyVehicle> newMyVehicles = new List <MyVehicle>();
foreach (MyVehicle vNew in myVehicles)
{
if (vNew != v)
{
newMyVehicles.Add(vNew);
}
}
Route toVehicle = CalcRoute(new long[] { nodes[0], v.Location.ID }, vehicles, forbiddenVehicles, newMyVehicles, mode);
Route fromVehicle = null;
v.Route = toVehicle;
if (toVehicle != null && !Double.IsPositiveInfinity(toVehicle.Length))
{
// Calc route from MyVehicle through the given points
long[] through = new long[nodes.Length];
Array.Copy(nodes, through, nodes.Length);
through[0] = v.Location.ID;
fromVehicle = CalcRoute(through, new List <Vehicle>()
{
v.VehicleType, Vehicle.Foot
}, forbiddenVehicles, newMyVehicles, mode);
// Route from source to destination using MyVehicle is
r = toVehicle + fromVehicle;
if (v.VehicleType == Vehicle.Bicycle)
{
r.Time += 60; //assuming it costs 1 minute to get your bicycle.
}
else if (v.VehicleType == Vehicle.Car)
{
r.Time += 4; //assumin it costs 4 minutes to get and park your car.
}
}
if (r != null && (r.Time < min && mode == RouteMode.Fastest || r.Length < min && mode == RouteMode.Shortest))
{
res = r;
switch (mode)
{
case RouteMode.Fastest:
min = r.Time;
break;
case RouteMode.Shortest:
min = r.Length;
break;
}
}
}
}
if (nodes.Length >= 2)
{
r = Dijkstra(nodes[0], nodes[1], vehicles.ToArray(), mode, !forbiddenVehicles.Contains(Vehicle.Bus));
if (nodes.Length > 2)
{
r += CalcRoute(SubArray(nodes, 1, nodes.Length), vehicles, forbiddenVehicles, myVehicles, mode);
}
}
if (r != null && (r.Time <= min && mode == RouteMode.Fastest || r.Length <= min && mode == RouteMode.Shortest))
{
res = r;
}
return(res);
}
public Task RegisterRpcHandlerAsync(IRequestMatcher pattern, Func <Message, CancellationToken, Task <Message> > handler, RouteExecution execution = RouteExecution.Synchronous, RouteMode mode = RouteMode.Capture, CancellationToken cancellationToken = default)
{
return(_policy.ExecuteAsync((_, registerPolicyToken) => _registration.RegisterRpcHandlerAsync(
pattern,
(message, handlerToken) => _policy.AsAsyncPolicy <Message>().ExecuteAsync((__, handlerPolicyToken) => handler(message, handlerPolicyToken), new Context(), handlerToken),
execution,
mode,
registerPolicyToken
), new Context(), cancellationToken));
}
public bool IsModeSelected(RouteMode routeEnum)
{
return(false);
}
public Task RegisterRpcHandlerAsync(IRequestMatcher pattern, Func <Message, CancellationToken, Task <Message> > handler, RouteExecution execution = RouteExecution.Synchronous, RouteMode mode = RouteMode.Capture, CancellationToken cancellationToken = default)
{
return(_registration.RegisterRpcHandlerAsync(
pattern,
async(message, handlerToken) =>
{
Trace.Current = ExtractTracing(message);
var trace = Trace.Current;
trace.Record(Annotations.ServerRecv());
trace.Record(Annotations.ServiceName(_serviceName));
trace.Record(Annotations.Rpc("TODO"));
try
{
var response = await handler(message, handlerToken);
trace.Record(Annotations.ServerSend());
return response;
}
catch (Exception ex)
{
trace.Record(Annotations.Tag("error", ex.Message));
trace.Record(Annotations.LocalOperationStop());
throw;
}
},
execution,
mode,
cancellationToken));
}
public void SetRideMode(RouteMode routeEnum)
{
this._routeEnum = routeEnum;
}
public Manager(IEnumerable <IWorker> workers, RouteType routeType, RouteMode routeMode) : base()
{
_workers = new RoutedList <IWorker>(workers, routeType, routeMode);
}
public async Task RegisterRpcHandlerAsync(IRequestMatcher pattern, Func <Message, CancellationToken, Task <Message> > handler, RouteExecution execution = RouteExecution.Synchronous, RouteMode mode = RouteMode.Capture, CancellationToken cancellationToken = default)
{
// TODO better route key? needs to be consistent across a cluster of services per route
var route = $"{_serviceKey}-{pattern}";
await _rpc.SendAsync("toxon.micro.router.register", JsonMessage.Write(new RegisterRoute
{
ServiceKey = _serviceKey,
RouteKey = route,
ServiceHealthEndpoint = await _serviceHealthEndpoint.Value,
RequestMatcher = pattern,
Execution = execution,
Mode = mode
}), cancellationToken).ConfigureAwait(false);
await _rpc.RegisterHandlerAsync(route, handler, cancellationToken);
}
public async Task <IEnumerable <PointDTO> > Get(CancellationToken ct, string pathToFile, RouteMode mode = RouteMode.Car, bool useRM = false)
{
if (string.IsNullOrEmpty(pathToFile))
{
return(null);
}
var points = await _pointsService.GetPoints(ct, pathToFile);
if (!useRM)
{
return(points);
}
_csvFileWriter.WriteToFile(points);
return(await _routeMatchingIntegrator.GetRouteMatchingPoints(ct, await _csvFileWriter.ReadAndDeleteFile(ct)));
}
/// <summary>
/// Dijkstra in graph gr, from source to destination, using vehicle v.
/// </summary>
/// <param name="source"> the startpoint </param>
/// <param name="destination"> the destination </param>
/// <param name="v"> vehicle that is used </param>
/// <returns></returns>
public Route Dijkstra(long from, long to, Vehicle[] vehicles, RouteMode mode, bool useBus)
{
Route result = null;
if (from == 0 || to == 0 || graph == null)
return result;
Node source = graph.GetNode(from);
Node destination = graph.GetNode(to);
//all nodes that are completely solved
SortedList<long, Node> solved = new SortedList<long, Node>();
//nodes that are encountered but not completely solved
SortedList<double, Node> unsolved = new SortedList<double, Node>();
RBTree<Node> prevs = new RBTree<Node>();
RBTree<double> times = new RBTree<double>();
RBTree<double> distances = new RBTree<double>();
RBTree<Vehicle> vehicleUse = new RBTree<Vehicle>();
ListTree<Vehicle> forbiddenVehicles = new ListTree<Vehicle>();
List<Edge> abstractBusses = graph.GetAbstractBusEdges();
Node current = source;
bool found = false;
//if there's no new current node it means the algorithm should stop
while (current != null)
{
//if we encounter the destination it means we found the shortest route so we break
if (current == destination)
{
found = true;
break;
}
List<Edge> edges = new List<Edge>(graph.GetEdgesFromNode(current.ID));
foreach (Edge busEdge in abstractBusses)
{
if (busEdge.End == current.ID || busEdge.Start == current.ID)
edges.Add(busEdge);
}
Node prev = prevs.Get(current.ID);
if (prev != null)
{
foreach (Vehicle vehicle in forbiddenVehicles.Get(prev.ID))
{
forbiddenVehicles.Insert(current.ID, vehicle);
}
}
foreach (Edge e in edges)
{
if (IsAllowed(e, vehicles, useBus))
{
Node start = graph.GetNode(e.Start);
Node end = graph.GetNode(e.End);
double distance = double.PositiveInfinity;
double time = double.PositiveInfinity;
Vehicle v = vehicles[0];
if (e.Type != CurveType.AbstractBusRoute)
{
if (e.Type != CurveType.Bus)
{
double speed = 0;
foreach (Vehicle vehicle in vehicles)
{
if (!forbiddenVehicles.Get(current.ID).Contains(vehicle))
{
double vSpeed = GetSpeed(vehicle, e);
if (vSpeed > speed && IsAllowed(e, vehicle, useBus))
{
speed = vSpeed;
v = vehicle;
}
}
}
distance = NodeCalcExtensions.Distance(start, end);
time = distance / speed;
}
else if (e.Route != null)
{
// Take busroute if better
if (mode == RouteMode.Fastest && time > e.Route.Time || mode == RouteMode.Shortest && distance > e.Route.Length)
{
distance = e.Route.Length;
time = e.Route.Time;
v = Vehicle.Foot;
foreach (Vehicle vehicle in vehicles)
if (vehicle != Vehicle.Foot)
forbiddenVehicles.Insert(current.ID, vehicle);
}
}
}
else
{
Node n1 = null, n2 = null;
if (start.Longitude != 0 || start.Latitude != 0)
n1 = graph.GetNodeByPos(start.Longitude, start.Latitude, Vehicle.Bus);
if (end.Longitude != 0 || end.Latitude != 0)
n2 = graph.GetNodeByPos(end.Longitude, end.Latitude, Vehicle.Bus);
if (n1 != default(Node) && n2 != default(Node))
{
Curve curve = new Curve(new long[] { start.ID, end.ID }, e.Name);
Route r = this.Dijkstra(n1.ID, n2.ID, new Vehicle[] { Vehicle.Bus }, RouteMode.Fastest, false);
r = new Route(new Node[] { start }, Vehicle.Bus) + r + new Route(new Node[] { end }, Vehicle.Bus);
curve.Type = CurveType.Bus;
curve.Route = r;
// We calculate with 60 seconds of switch over to the bus.
r.Time += 60;
graph.AddWay(start.ID, curve);
graph.AddWay(end.ID, curve);
e.Route = r;
e.Type = CurveType.Bus;
// Take busroute if better
if (mode == RouteMode.Fastest && time > e.Route.Time || mode == RouteMode.Shortest && distance > e.Route.Length)
{
distance = e.Route.Length;
time = e.Route.Time;
v = Vehicle.Foot;
foreach (Vehicle vehicle in vehicles)
if (vehicle != Vehicle.Foot)
forbiddenVehicles.Insert(current.ID, vehicle);
}
}
graph.RemoveAbstractBus(e);
abstractBusses.Remove(e);
}
time += times.Get(current.ID);
double trueDist = distances.Get(current.ID) + distance;
if (!solved.ContainsValue(end) && current != end)
{
if (end.Latitude != 0 && end.Longitude != 0)
{
if (times.Get(end.ID) == 0 || distances.Get(end.ID) == 0)
{
times.Insert(end.ID, double.PositiveInfinity);
distances.Insert(end.ID, double.PositiveInfinity);
vehicleUse.Insert(end.ID, v);
}
if ((mode == RouteMode.Fastest &&
times.Get(end.ID) > time) ||
(mode == RouteMode.Shortest &&
distances.Get(end.ID) > trueDist))
{
times.GetNode(end.ID).Content = time;
distances.GetNode(end.ID).Content = trueDist;
vehicleUse.GetNode(end.ID).Content = v;
if (prevs.GetNode(end.ID).Content == null)
prevs.Insert(end.ID, current);
else
prevs.GetNode(end.ID).Content = current;
if (!unsolved.ContainsValue(end))
{
if (mode == RouteMode.Fastest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(times.Get(end.ID)))
{
times.GetNode(end.ID).Content += 0.0000000001;
}
unsolved.Add(times.Get(end.ID), end);
}
else if (mode == RouteMode.Shortest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(distances.Get(end.ID)))
{
distances.GetNode(end.ID).Content += 0.0000000001;
}
unsolved.Add(distances.Get(end.ID), end);
}
if (prevs.GetNode(current.ID).Content != null &&
vehicleUse.Get(prevs.GetNode(current.ID).Content.ID) == Vehicle.Car)
{
if (v == Vehicle.Foot)
{
forbiddenVehicles.Insert(end.ID, Vehicle.Car);
}
}
}
}
}
}
else if (!solved.ContainsValue(start) && current != start)
{
if (start.Latitude != 0 && start.Longitude != 0)
{
if (times.Get(start.ID) == 0 || distances.Get(start.ID) == 0)
{
times.Insert(start.ID, double.PositiveInfinity);
distances.Insert(start.ID, double.PositiveInfinity);
vehicleUse.Insert(start.ID, v);
}
if ((mode == RouteMode.Fastest &&
times.Get(start.ID) > time) ||
(mode == RouteMode.Shortest &&
distances.Get(start.ID) > trueDist))
{
times.GetNode(start.ID).Content = time;
distances.GetNode(start.ID).Content = trueDist;
vehicleUse.GetNode(start.ID).Content = v;
if (prevs.GetNode(start.ID).Content == null)
prevs.Insert(start.ID, current);
else
prevs.GetNode(start.ID).Content = current;
if (!unsolved.ContainsValue(start))
{
if (mode == RouteMode.Fastest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(times.Get(start.ID)))
{
times.GetNode(start.ID).Content += 0.0000000001;
}
unsolved.Add(times.Get(start.ID), start);
}
else if (mode == RouteMode.Shortest)
{
// Very bad solution but I couldn't think of a simple better one.
while (unsolved.ContainsKey(distances.Get(start.ID)))
{
distances.GetNode(start.ID).Content += 0.0000000001;
}
unsolved.Add(distances.Get(start.ID), start);
}
}
if (prevs.GetNode(current.ID).Content != null &&
vehicleUse.Get(prevs.GetNode(current.ID).Content.ID) == Vehicle.Car)
{
if (v == Vehicle.Foot)
{
forbiddenVehicles.Insert(start.ID, Vehicle.Car);
}
}
}
}
}
}
}
//dit zou niet voor moeten komen maar toch gebeurt het...
if (!solved.ContainsKey(current.ID))
solved.Add(current.ID, current);
if (unsolved.Count > 0)
{
current = unsolved.Values[0];
unsolved.RemoveAt(0);
}
else
{
current = null;
}
}
if (found)
{
List<Node> nodes = new List<Node>();
List<long> extras = graph.GetExtras();
Node n = destination;
List<long> busStartStop = new List<long>();
do
{
bool foundRoute = false;
if (extras.Contains(n.ID))
{
// Change straigt buslines in for the actual route.
foreach (Edge e in graph.GetEdgesFromNode(n.ID))
{
if (prevs.Get(n.ID) != null && e.Route != null)
{
if (n.ID == e.Start &&
prevs.Get(n.ID).ID == e.End)
{
Node[] busNodes = e.Route.Points;
if (busNodes[0].ID == e.Start)
Array.Reverse(busNodes);
busStartStop.Add(busNodes[busNodes.Length - 1].ID);
busStartStop.Add(busNodes[0].ID);
nodes.InsertRange(0, busNodes);
n = prevs.Get(n.ID);
foundRoute = true;
break;
}
else if (n.ID == e.End &&
prevs.Get(n.ID).ID == e.Start)
{
Node[] busNodes = e.Route.Points;
if (busNodes[0].ID == e.End)
Array.Reverse(busNodes);
busStartStop.Add(busNodes[busNodes.Length - 1].ID);
busStartStop.Add(busNodes[0].ID);
nodes.InsertRange(0, busNodes);
n = prevs.Get(n.ID);
foundRoute = true;
break;
}
}
}
}
if (!foundRoute)
{
nodes.Insert(0, n);
n = prevs.Get(n.ID);
}
} while (n != null);
result = new Route(nodes.ToArray(), vehicles[0]);
result.Time = times.Get(destination.ID);
result.Length = distances.Get(destination.ID);
// Set bus as vehicle
if (busStartStop.Count > 0)
{
int i = busStartStop.Count - 1;
Node[] routePoints = result.Points;
for (int j = 0; j < routePoints.Length; j++)
{
if (routePoints[j].ID == busStartStop[i])
{
if (i % 2 == 1)
{
result.SetVehicle(Vehicle.Bus, j);
i--;
}
else
{
result.SetVehicle(Vehicle.Foot, j);
i--;
}
}
if (i < 0)
break;
}
}
Vehicle cur = result.GetVehicle(0), prev;
for (int i = 2; i < result.NumOfNodes; i++)
{
if (result.GetVehicle(i) != Vehicle.Bus)
{
prev = vehicleUse.Get(result[i].ID);
if (prev != cur && i > 1)
result.SetVehicle(prev, i - 1);
cur = prev;
}
}
}
else
{
result = new Route(new Node[] { source }, vehicles[0]);
result.Time = double.PositiveInfinity;
result.Length = double.PositiveInfinity;
}
return result;
}
public Task RegisterRpcHandlerAsync(IRequestMatcher pattern, Func <Message, CancellationToken, Task <Message> > handler, RouteExecution execution = RouteExecution.Synchronous, RouteMode mode = RouteMode.Capture, CancellationToken cancellationToken = default)
{
_rpcRouter.Register(string.Empty, pattern, new RpcRoutingData(handler));
return(Task.CompletedTask);
}
/// <summary>
/// Initializes a new instance of the DirectionsRouteDestinationTask class
/// </summary>
public DirectionsRouteDestinationTask() : base()
{
// Set default values
Mode = RouteMode.Smart;
}