/// <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);
}
}
}
}
}
}
}
