/// <summary>
/// Gets the target vertex.
/// </summary>
public static uint GetTargetVertex(this Graph.EdgeEnumerator enumerator, long directedEdgeId)
{
enumerator.MoveToEdge(directedEdgeId);
if (directedEdgeId > 0)
{
if (!enumerator.DataInverted)
{
return(enumerator.To);
}
else
{
return(enumerator.From);
}
}
else
{
if (enumerator.DataInverted)
{
return(enumerator.To);
}
else
{
return(enumerator.From);
}
}
}
/// <summary>
/// Finds the best edge between the two given vertices.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="graph"></param>
/// <param name="weightHandler"></param>
/// <param name="vertex1"></param>
/// <param name="vertex2"></param>
/// <returns></returns>
public static long FindBestEdge <T>(this Graph.EdgeEnumerator edgeEnumerator, WeightHandler <T> weightHandler, uint vertex1, uint vertex2, out T bestWeight)
where T : struct
{
edgeEnumerator.MoveTo(vertex1);
bestWeight = weightHandler.Infinite;
long bestEdge = Constants.NO_EDGE;
Factor factor;
while (edgeEnumerator.MoveNext())
{
if (edgeEnumerator.To == vertex2)
{
float distance;
ushort edgeProfile;
EdgeDataSerializer.Deserialize(edgeEnumerator.Data0, out distance, out edgeProfile);
var weight = weightHandler.Calculate(edgeProfile, distance, out factor);
if (factor.Value > 0 && (factor.Direction == 0 ||
((factor.Direction == 1) && !edgeEnumerator.DataInverted) ||
((factor.Direction == 2) && edgeEnumerator.DataInverted)))
{ // it's ok; the edge can be traversed by the given vehicle.
if (weightHandler.IsSmallerThan(weight, bestWeight))
{
bestWeight = weight;
bestEdge = edgeEnumerator.IdDirected();
}
}
}
}
return(bestEdge);
}
/// <summary>
/// Returns a directed version of the edge-id. Smaller than 0 if inverted, as-is if not inverted.
/// </summary>
/// <remarks>
/// The relationship between a regular edge id and a directed edge id:
/// - 0 -> 1 forward, -1 backward.
/// - all other id's are offset by 1 and postive when forward, negative when backward.
/// </remarks>
public static long IdDirected(this Graph.EdgeEnumerator enumerator)
{
if (enumerator.DataInverted)
{
return(-(enumerator.Id + 1));
}
return(enumerator.Id + 1);
}
/// <summary>
/// Gets the weight for the current edge.
/// </summary>
public static float GetWeight(this Graph.EdgeEnumerator enumerator, Func <ushort, Factor> getFactor, out short direction)
{
float distance;
ushort edgeProfile;
Data.Edges.EdgeDataSerializer.Deserialize(enumerator.Data0, out distance, out edgeProfile);
var factor = getFactor(edgeProfile);
direction = factor.Direction;
return(factor.Value * distance);
}
/// <summary>
/// Moves to the given directed edge-id.
/// </summary>
public static void MoveToEdge(this Graph.EdgeEnumerator enumerator, long directedEdgeId)
{
if (directedEdgeId == 0)
{
throw new ArgumentOutOfRangeException("directedEdgeId");
}
uint edgeId;
if (directedEdgeId > 0)
{
edgeId = (uint)directedEdgeId - 1;
}
else
{
edgeId = (uint)((-directedEdgeId) - 1);
}
enumerator.MoveToEdge(edgeId);
}
/// <summary>
/// Gets the weight for the current edge.
/// </summary>
public static float GetWeight(this Graph.EdgeEnumerator enumerator, Func <ushort, Factor> getFactor)
{
short direction;
return(enumerator.GetWeight(getFactor, out direction));
}
/// <summary>
/// Returns a directed version of the edge-id. Smaller than 0 if inverted, as-is if not inverted.
/// </summary>
/// <remarks>
/// The relationship between a regular edge id and a directed edge id:
/// - 0 -> 1 forward, -1 backward.
/// - all other id's are offset by 1 and postive when forward, negative when backward.
/// </remarks>
public static DirectedEdgeId DirectedEdgeId(this Graph.EdgeEnumerator enumerator)
{
return(new DirectedEdgeId(enumerator.Id, !enumerator.DataInverted));
}
