/// <summary>
/// Build graph from OSM elements. May contains duplicated elements (from multiple calls)
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
private static RoadGraph BuildGraph(List <Element> elements, bool ignoreOneWays)
{
RoadGraph result = new RoadGraph();
IEnumerable <Way> ways = elements.Where(x => x is Way).Select(x => x as Way).Distinct();
var nodeLookup = new Dictionary <long, OsmNode>();
foreach (var node in elements.Where(x => x is OsmNode).Select(x => x as OsmNode))
{
nodeLookup[node.Id] = node;
}
var intersectionCounter = ways.Select(x => x.Nodes).CountRepeatedIds();
foreach (var way in ways)
{
string wayName = way.ParseName();
var subways = way.Nodes.InclusivePartitioning(id => intersectionCounter[id] > 1);
foreach (var subway in subways)
{
// TODO : why are ids not in dictinoary sometimes? Data problem?
var roadShape = subway.Where(id => nodeLookup.ContainsKey(id)).Select(id => nodeLookup[id].ToCoord()).ToList();
DirectedRoad road = new DirectedRoad(subway.First().ToString(), subway.Last().ToString(), roadShape, wayName);
result.AddRoad(road);
if (!way.IsOneWay() || ignoreOneWays)
{
DirectedRoad reverseRoad = road.Reverse();
result.AddRoad(reverseRoad);
}
}
}
return(result);
}
public CandidateInfo(DirectedRoad from, double p_from, double p_transition, Emission emission, double p_final)
{
From = from;
P_From = p_from;
P_Transition = p_transition;
Emission = emission;
P_Final = p_final;
}
public static Transition ImpossibleTransition(DirectedRoad from, DirectedRoad to)
{
var result = new Transition();
result.From = from;
result.To = to;
result.Probability = 0;
result.OnRoadDistInMeters = double.NaN;
result.HaversineDistInMeters = double.NaN;
return(result);
}
public static Transition TransitionProbability(RoadGraph graph, ProjectToRoad projection1, ProjectToRoad projection2, MapMatcherParameters parameters)
{
DirectedRoad road1 = projection1.Road;
DirectedRoad road2 = projection2.Road;
//calculate on road distance
double onRoadDistanceInMeters;
Distance startingDist = projection1.DistanceToEnd;
Distance endDist = projection2.DistanceFromStart;
// Roads are the same:
if (road1.Equals(road2))
{
//negative if going backwards along road
onRoadDistanceInMeters = projection2.DistanceFromStart.DistanceInMeters - projection1.DistanceFromStart.DistanceInMeters;
}
// Road start or end on the same node
else if (road1.End == road2.End || road1.Start == road2.Start)
{
//make this transition impossible
return(Transition.ImpossibleTransition(road1, road2));
}
// Roads are connected (can be same road in opposite direction)
else if (road1.End == road2.Start)
{
onRoadDistanceInMeters = startingDist.DistanceInMeters + endDist.DistanceInMeters;
}
// Try connect roads using Dijstra
else
{
List <DirectedRoad> path;
if (PathFinding.DijstraTryFindPath(graph, road1.End, road2.Start, parameters.DijstraUpperSearchLimit, out path))
{
Distance connectingDist = Distance.Zero;
foreach (var road in path)
{
connectingDist += road.Length;
}
onRoadDistanceInMeters = startingDist.DistanceInMeters + connectingDist.DistanceInMeters + endDist.DistanceInMeters;
}
else
{
//cannot connect up roads. transition probability is zero
return(Transition.ImpossibleTransition(road1, road2));
}
}
Distance haversineDistance = projection1.Coordinate.HaversineDistance(projection2.Coordinate);
return(new Transition(onRoadDistanceInMeters, haversineDistance.DistanceInMeters, road1, road2, parameters));
}
public List <DirectedRoad> GetMostLikelySequence()
{
if (Probabilities != null && Probabilities.Count > 0)
{
// get most probable road
DirectedRoad mostLikelyRoad = Probabilities.GetMostProbableItem();
// trace back most likely sequence
List <DirectedRoad> result = TransitionMemory.TraceBackSequence(mostLikelyRoad);
return(result);
}
else
{
return(new List <DirectedRoad>());
}
}
public ProjectToRoad(Coord coord, DirectedRoad road)
{
Coordinate = coord;
Road = road;
int position = -1;
Coord projection = coord.SnapToPolyline(road.Geometry, out position);
IndexInRoad = position;
Projection = projection;
ProjectedDistance = coord.HaversineDistance(projection);
DistanceFromStart = computeDistanceFromStart();
DistanceToEnd = computeDistanceToEnd();
}
public static RoadGraph BuildGraph1()
{
RoadGraph result = new RoadGraph();
DirectedRoad roadAB = new DirectedRoad("1000", "1001", GeometryAB().ToCoordList(), "AB");
DirectedRoad roadAC = new DirectedRoad("1000", "1002", GeometryAC().ToCoordList(), "AC");
DirectedRoad roadAD = new DirectedRoad("1000", "1003", GeometryAD().ToCoordList(), "AD");
DirectedRoad roadDB = new DirectedRoad("1003", "1001", GeometryDB().ToCoordList(), "DB");
result.AddRoad(roadAB);
result.AddRoad(roadAC);
result.AddRoad(roadAD);
result.AddRoad(roadDB);
return result;
}
////////////////
// Graph where A->B, B->C is shorter than going A->C
public static RoadGraph BuildGraphTwoShortRoadsOneLong()
{
RoadGraph result = new RoadGraph();
// Two short roads
DirectedRoad roadAB = new DirectedRoad("1000", "1001", StraightAB().ToCoordList(), "AB");
DirectedRoad roadBC = new DirectedRoad("1001", "1002", StraightBC().ToCoordList(), "BC");
//Long road
DirectedRoad roadAC = new DirectedRoad("1000", "1002", BigTriangleAC().ToCoordList(), "AC");
result.AddRoad(roadAB);
result.AddRoad(roadBC);
result.AddRoad(roadAC);
return result;
}
public Transition(double onRoadDistanceInMeters, double haversineDistanceInMeters, DirectedRoad from, DirectedRoad to, MapMatcherParameters parameters)
{
OnRoadDistInMeters = onRoadDistanceInMeters;
HaversineDistInMeters = haversineDistanceInMeters;
From = from;
To = to;
// COMPUTE TRANSITION PROBABILITY
double diffInMeters = Math.Abs(haversineDistanceInMeters - onRoadDistanceInMeters);
if (diffInMeters > parameters.TransitionDiffThreshold)
{
Probability = 0;
}
else
{
Probability = ProbabilityFunctions.ExponentialDistribution(diffInMeters, parameters.Beta);
}
}
public static DirectedRoad Reverse(this DirectedRoad road)
{
return(new DirectedRoad(road.End, road.Start, Enumerable.Reverse(road.Geometry).ToList(), road.Name));
}
public MapState(DirectedRoad road, T datum)
{
Road = road;
Datum = datum;
}
