/// <summary>
/// Adds the given node.
/// </summary>
/// <param name="node"></param>
public override void AddNode(Node node)
{
if (!_preIndexMode)
{
if (_nodesToCache != null &&
_nodesToCache.Contains(node.Id.Value))
{ // cache this node?
_dataCache.AddNode(node);
}
if (_preIndex != null && _preIndex.Contains(node.Id.Value))
{ // only save the coordinates for relevant nodes.
// save the node-coordinates.
// add the relevant nodes.
_coordinates[node.Id.Value] = new GeoCoordinateSimple()
{
Latitude = (float)node.Latitude.Value,
Longitude = (float)node.Longitude.Value
};
// add the node as a possible restriction.
if (_interpreter.IsRestriction(OsmGeoType.Node, node.Tags))
{ // tests quickly if a given node is possibly a restriction.
var vehicleTypes = _interpreter.CalculateRestrictions(node);
if (vehicleTypes != null &&
vehicleTypes.Count > 0)
{ // add all the restrictions.
this._relevantNodes.Add(node.Id.Value);
var vertexId = this.AddRoadNode(node.Id.Value).Value; // will always exists, has just been added to coordinates.
var restriction = new uint[] { vertexId };
if (vehicleTypes.Contains(null))
{ // restriction is valid for all vehicles.
_graph.AddRestriction(restriction);
}
else
{ // restriction is restricted to some vehicles only.
foreach (string vehicle in vehicleTypes)
{
_graph.AddRestriction(vehicle, restriction);
}
}
}
}
}
}
}
/// <summary>
/// Adds a given way.
/// </summary>
/// <param name="way"></param>
public override void AddWay(Way way)
{
if (!_preIndexMode && _waysToCache != null &&
_waysToCache.Contains(way.Id.Value))
{ // cache this way?
_dataCache.AddWay(way);
}
// initialize the way interpreter.
if (_interpreter.EdgeInterpreter.IsRoutable(way.Tags))
{ // the way is a road.
if (_preIndexMode)
{ // index relevant and used nodes.
if (way.Nodes != null)
{ // this way has nodes.
// add new routable tags type.
var routableWayTags = new TagsCollection(way.Tags);
routableWayTags.RemoveAll(x =>
{
return(!_interpreter.IsRelevantRouting(x.Key) &&
!Vehicle.IsRelevantForOneOrMore(x.Key));
});
if (_storeTags)
{
_tagsIndex.Add(routableWayTags);
}
int wayNodesCount = way.Nodes.Count;
for (int idx = 0; idx < wayNodesCount; idx++)
{
var node = way.Nodes[idx];
if (_preIndex.Contains(node))
{ // node is relevant.
_relevantNodes.Add(node);
}
else
{ // node is used.
_preIndex.Add(node);
}
}
if (wayNodesCount > 0)
{ // first node is always relevant.
_relevantNodes.Add(way.Nodes[0]);
if (wayNodesCount > 1)
{ // last node is always relevant.
_relevantNodes.Add(way.Nodes[wayNodesCount - 1]);
}
}
}
}
else
{ // add actual edges.
if (way.Nodes != null && way.Nodes.Count > 1)
{ // way has at least two nodes.
if (this.CalculateIsTraversable(_interpreter.EdgeInterpreter, _tagsIndex,
way.Tags))
{ // the edge is traversable, add the edges.
uint? from = this.AddRoadNode(way.Nodes[0]);
long fromNodeId = way.Nodes[0];
List <long> intermediates = new List <long>();
for (int idx = 1; idx < way.Nodes.Count; idx++)
{ // the to-node.
long currentNodeId = way.Nodes[idx];
if (!_collectIntermediates ||
_relevantNodes.Contains(currentNodeId) ||
idx == way.Nodes.Count - 1)
{ // node is an important node.
uint?to = this.AddRoadNode(currentNodeId);
long toNodeId = currentNodeId;
// add the edge(s).
if (from.HasValue && to.HasValue)
{ // add a road edge.
while (from.Value == to.Value)
{
if (intermediates.Count > 0)
{
uint?dummy = this.AddRoadNode(intermediates[0]);
intermediates.RemoveAt(0);
if (dummy.HasValue && from.Value != dummy.Value)
{
this.AddRoadEdge(way.Tags, from.Value, dummy.Value, null);
from = dummy;
}
}
else
{ // no use to continue.
break;
}
}
// build coordinates.
var intermediateCoordinates = new List <GeoCoordinateSimple>(intermediates.Count);
for (int coordIdx = 0; coordIdx < intermediates.Count; coordIdx++)
{
ICoordinate coordinate;
if (!_coordinates.TryGet(intermediates[coordIdx], out coordinate))
{
break;
}
intermediateCoordinates.Add(new GeoCoordinateSimple()
{
Latitude = coordinate.Latitude,
Longitude = coordinate.Longitude
});
}
if (intermediateCoordinates.Count == intermediates.Count &&
from.Value != to.Value)
{ // all coordinates have been found.
this.AddRoadEdge(way.Tags, from.Value, to.Value, intermediateCoordinates);
}
}
// if this way has a restriction save the collapsed nodes information.
if (_restricedWays.Contains(way.Id.Value) && to.HasValue && from.HasValue)
{ // loop over all intermediates and save.
var collapsedInfo = new KeyValuePair <KeyValuePair <long, uint>, KeyValuePair <long, uint> >(
new KeyValuePair <long, uint>(fromNodeId, from.Value), new KeyValuePair <long, uint>(toNodeId, to.Value));
foreach (var intermedidate in intermediates)
{
_collapsedNodes[intermedidate] = collapsedInfo;
}
}
from = to; // the to node becomes the from.
intermediates.Clear();
}
else
{ // this node is just an intermediate.
intermediates.Add(currentNodeId);
}
}
}
}
}
}
}
public override void AddNode(Node node)
{
if (this._firstPass)
{
this._nodeCount = this._nodeCount + 1L;
double num1 = node.Latitude.Value;
if (num1 < this._minLatitude)
{
this._minLatitude = num1;
}
if (num1 > this._maxLatitude)
{
this._maxLatitude = num1;
}
double num2 = node.Longitude.Value;
if (num2 < this._minLongitude)
{
this._minLongitude = num2;
}
if (num2 > this._maxLongitude)
{
this._maxLongitude = num2;
}
if (this.Processors == null)
{
return;
}
foreach (ITwoPassProcessor processor in this.Processors)
{
processor.FirstPass(node);
}
}
else
{
if (this.Processors != null)
{
foreach (ITwoPassProcessor processor in this.Processors)
{
processor.SecondPass(node);
}
}
long?id1;
if (!this._stages[this._stage].Contains(node.Longitude.Value, node.Latitude.Value))
{
ILongIndex anyStageNodes = this._anyStageNodes;
id1 = ((OsmGeo)node).Id;
long number = id1.Value;
if (!anyStageNodes.Contains(number))
{
return;
}
}
ILongIndex allRoutingNodes = this._allRoutingNodes;
id1 = ((OsmGeo)node).Id;
long number1 = id1.Value;
if (!allRoutingNodes.Contains(number1))
{
return;
}
NodeCoordinatesDictionary stageCoordinates = this._stageCoordinates;
id1 = ((OsmGeo)node).Id;
long id2 = id1.Value;
// ISSUE: variable of a boxed type
GeoCoordinateSimple local = new GeoCoordinateSimple()
{
Latitude = (float)node.Latitude.Value,
Longitude = (float)node.Longitude.Value
};
stageCoordinates.Add(id2, (ICoordinate)local);
}
}
public float Calculate(ILongIndex contractedFlags, uint vertex)
{
int num1 = 0;
int num2 = 0;
List <Edge> edgeList = new List <Edge>((IEnumerable <Edge>) this._graph.Graph.GetEdgeEnumerator(vertex));
int index1 = 0;
while (index1 < edgeList.Count)
{
DirectedMetaGraph.EdgeEnumerator edgeEnumerator = this._graph.GetEdgeEnumerator(edgeList[index1].Neighbour);
edgeEnumerator.Reset();
while (edgeEnumerator.MoveNext())
{
if ((int)edgeEnumerator.Neighbour == (int)vertex)
{
++num1;
}
}
if (contractedFlags.Contains((long)edgeList[index1].Neighbour))
{
edgeEnumerator.MoveTo(vertex);
edgeEnumerator.Reset();
while (edgeEnumerator.MoveNext())
{
if ((int)edgeEnumerator.Neighbour == (int)edgeList[index1].Neighbour)
{
++num1;
}
}
edgeList.RemoveAt(index1);
}
else
{
++index1;
}
}
for (int capacity = 1; capacity < edgeList.Count; ++capacity)
{
Edge edge1 = edgeList[capacity];
float weight1;
bool? direction1;
ContractedEdgeDataSerializer.Deserialize(edge1.Data[0], out weight1, out direction1);
bool flag1 = !direction1.HasValue || direction1.Value;
bool flag2 = !direction1.HasValue || !direction1.Value;
bool[] forwardWitness = new bool[capacity];
bool[] backwardWitness = new bool[capacity];
List <uint> targets = new List <uint>(capacity);
List <float> weights = new List <float>(capacity);
for (int index2 = 0; index2 < capacity; ++index2)
{
Edge edge2 = edgeList[index2];
float weight2;
bool? direction2;
ContractedEdgeDataSerializer.Deserialize(edge2.Data[0], out weight2, out direction2);
bool flag3 = !direction2.HasValue || direction2.Value;
bool flag4 = !direction2.HasValue || !direction2.Value;
forwardWitness[index2] = !(flag2 & flag3);
backwardWitness[index2] = !(flag1 & flag4);
targets.Add(edge2.Neighbour);
weights.Add(weight1 + weight2);
}
this._witnessCalculator.Calculate(this._graph.Graph, edge1.Neighbour, targets, weights, ref forwardWitness, ref backwardWitness, vertex);
for (int index2 = 0; index2 < capacity; ++index2)
{
Edge edge2 = edgeList[index2];
int removed = 0;
int added = 0;
if (!forwardWitness[index2] && !backwardWitness[index2])
{
this._graph.TryAddOrUpdateEdge(edge1.Neighbour, edge2.Neighbour, weights[index2], new bool?(), vertex, out added, out removed);
int num3 = num2 + added;
int num4 = num1 + removed;
this._graph.TryAddOrUpdateEdge(edge2.Neighbour, edge1.Neighbour, weights[index2], new bool?(), vertex, out added, out removed);
num2 = num3 + added;
num1 = num4 + removed;
}
else if (!forwardWitness[index2])
{
this._graph.TryAddOrUpdateEdge(edge1.Neighbour, edge2.Neighbour, weights[index2], new bool?(true), vertex, out added, out removed);
int num3 = num2 + added;
int num4 = num1 + removed;
this._graph.TryAddOrUpdateEdge(edge2.Neighbour, edge1.Neighbour, weights[index2], new bool?(false), vertex, out added, out removed);
num2 = num3 + added;
num1 = num4 + removed;
}
else if (!backwardWitness[index2])
{
this._graph.TryAddOrUpdateEdge(edge1.Neighbour, edge2.Neighbour, weights[index2], new bool?(false), vertex, out added, out removed);
int num3 = num2 + added;
int num4 = num1 + removed;
this._graph.TryAddOrUpdateEdge(edge2.Neighbour, edge1.Neighbour, weights[index2], new bool?(true), vertex, out added, out removed);
num2 = num3 + added;
num1 = num4 + removed;
}
}
}
int num5 = 0;
this._contractionCount.TryGetValue(vertex, out num5);
int num6 = 0;
this._depth.TryGetValue((long)vertex, out num6);
return((float)(this.DifferenceFactor * (num2 - num1) + this.DepthFactor * num6 + this.ContractedFactor * num5));
}