/// <summary>
/// Tests the the given router class by comparing calculated routes agains a given reference router.
/// </summary>
/// <param name="data"></param>
/// <param name="referenceRouter"></param>
/// <param name="router"></param>
protected void TestCompareAll <TEdgeData>(IRoutingAlgorithmData <TEdgeData> data, Router referenceRouter, Router router)
where TEdgeData : IGraphEdgeData
{
// loop over all nodes and resolve their locations.
var resolvedReference = new RouterPoint[data.VertexCount - 1];
var resolved = new RouterPoint[data.VertexCount - 1];
for (uint idx = 1; idx < data.VertexCount; idx++)
{ // resolve each vertex.
float latitude, longitude;
if (data.GetVertex(idx, out latitude, out longitude))
{
resolvedReference[idx - 1] = referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude), true);
resolved[idx - 1] = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude), true);
}
// reference and resolved have to exist.
Assert.IsNotNull(resolvedReference[idx - 1]);
Assert.IsNotNull(resolved[idx - 1]);
// reference and resolved cannot be more than 10cm apart.
Assert.AreEqual(0, resolvedReference[idx - 1].Location.DistanceReal(
resolved[idx - 1].Location).Value, 0.1, "Reference and resolved are more than 10cm apart.");
}
// limit tests to a fixed number.
int maxTestCount = 100;
int testEveryOther = (resolved.Length * resolved.Length) / maxTestCount;
testEveryOther = System.Math.Max(testEveryOther, 1);
// check all the routes having the same weight(s).
for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++)
{
for (int toIdx = 0; toIdx < resolved.Length; toIdx++)
{
int testNumber = fromIdx * resolved.Length + toIdx;
if (testNumber % testEveryOther == 0)
{
OsmSharp.Logging.Log.TraceEvent("RoutingComparisonTestBase.TestCompareAll", Logging.TraceEventType.Information,
"Testing point {0} -> {1}", fromIdx, toIdx);
var referenceRoute = referenceRouter.Calculate(Vehicle.Car,
resolvedReference[fromIdx], resolvedReference[toIdx]);
var route = router.Calculate(Vehicle.Car,
resolved[fromIdx], resolved[toIdx]);
if (referenceRoute != null)
{
Assert.IsNotNull(referenceRoute);
Assert.IsNotNull(route);
this.CompareRoutes(referenceRoute, route);
}
}
}
}
}
/// <summary>
/// Tests that a router actually finds the shortest route.
/// </summary>
/// <param name="vehicle"></param>
/// <param name="accessTags"></param>
protected void DoTestShortestWithAccess(Vehicle vehicle, List <KeyValuePair <string, string> > accessTags)
{
var interpreter = new OsmRoutingInterpreter();
IRoutingAlgorithmData <EdgeData> data = this.BuildData(interpreter, vehicle, accessTags);
IRoutingAlgorithm <EdgeData> basicRouter = this.BuildBasicRouter(data, vehicle);
Router router = this.BuildRouter(
data, interpreter, basicRouter);
RouterPoint source = router.Resolve(vehicle, new GeoCoordinate(51.0582205, 3.7192647)); // -52
RouterPoint target = router.Resolve(vehicle, new GeoCoordinate(51.0579530, 3.7196168)); // -56
Route route = router.Calculate(vehicle, source, target);
Assert.IsNotNull(route);
Assert.AreEqual(4, route.Segments.Length);
float latitude, longitude;
data.GetVertex(19, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[0].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[0].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Start, route.Segments[0].Type);
data.GetVertex(8, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[1].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[1].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[1].Type);
data.GetVertex(9, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[2].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[2].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[2].Type);
data.GetVertex(10, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[3].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[3].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Stop, route.Segments[3].Type);
}
/// <summary>
/// Test if the resolving of nodes returns those same nodes.
///
/// (does not work on a lazy loading data source!)
/// </summary>
protected void DoTestResolveAllNodes()
{
var interpreter = new OsmRoutingInterpreter();
IRoutingAlgorithmData <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");
IRoutingAlgorithm <TEdgeData> basicRouter = this.BuildBasicRouter(data);
Router router = this.BuildRouter(
data, interpreter, basicRouter);
for (int idx = 1; idx < data.VertexCount; idx++)
{
float latitude, longitude;
if (data.GetVertex((uint)idx, out latitude, out longitude))
{
var point = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
Assert.AreEqual(idx, (point as RouterPoint).Id);
}
}
}
/// <summary>
/// Tests that a router actually finds the shortest route.
/// </summary>
protected void DoTestShortestAgainstDirection()
{
var interpreter = new OsmRoutingInterpreter();
IRoutingAlgorithmData <EdgeData> data = this.BuildData(interpreter);
IRoutingAlgorithm <EdgeData> basicRouter = this.BuildBasicRouter(data);
Router router = this.BuildRouter(
data, interpreter, basicRouter);
RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0579530, 3.7196168)); // -56
RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0582205, 3.7192647)); // -52
Route route = router.Calculate(Vehicle.Car, source, target);
Assert.IsNotNull(route);
Assert.AreEqual(6, route.Segments.Length);
float latitude, longitude;
data.GetVertex(10, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[0].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[0].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Start, route.Segments[0].Type);
data.GetVertex(12, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[1].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[1].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[1].Type);
data.GetVertex(13, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[2].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[2].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[2].Type);
data.GetVertex(14, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[3].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[3].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[3].Type);
data.GetVertex(15, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[4].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[4].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[4].Type);
data.GetVertex(19, out latitude, out longitude);
Assert.AreEqual(latitude, route.Segments[5].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Segments[5].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Stop, route.Segments[5].Type);
}
/// <summary>
/// Searches the data for a point on an edge closest to the given coordinate.
/// </summary>
/// <param name="graph"></param>
/// <param name="vehicle"></param>
/// <param name="coordinate"></param>
/// <param name="delta"></param>
/// <param name="matcher"></param>
/// <param name="pointTags"></param>
/// <param name="interpreter"></param>
/// <param name="verticesOnly"></param>
/// <param name="parameters"></param>
public SearchClosestResult <TEdgeData> SearchClosest(IRoutingAlgorithmData <TEdgeData> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
GeoCoordinate coordinate, float delta, IEdgeMatcher matcher, TagsCollectionBase pointTags, bool verticesOnly, Dictionary <string, object> parameters)
{
Meter distanceEpsilon = .1; // 10cm is the tolerance to distinguish points.
var closestWithMatch = new SearchClosestResult <TEdgeData>(double.MaxValue, 0);
GeoCoordinateBox closestWithMatchBox = null;
var closestWithoutMatch = new SearchClosestResult <TEdgeData>(double.MaxValue, 0);
GeoCoordinateBox closestWithoutMatchBox = null;
double searchBoxSize = delta;
// create the search box.
var searchBox = new GeoCoordinateBox(new GeoCoordinate(
coordinate.Latitude - searchBoxSize, coordinate.Longitude - searchBoxSize),
new GeoCoordinate(
coordinate.Latitude + searchBoxSize, coordinate.Longitude + searchBoxSize));
// get the arcs from the data source.
var edges = graph.GetEdges(searchBox);
if (!verticesOnly)
{ // find both closest arcs and vertices.
// loop over all.
while (edges.MoveNext())
{
//if (!graph.TagsIndex.Contains(edges.EdgeData.Tags))
//{ // skip this edge, no valid tags found.
// continue;
//}
// test the two points.
float fromLatitude, fromLongitude;
float toLatitude, toLongitude;
double distance;
if (graph.GetVertex(edges.Vertex1, out fromLatitude, out fromLongitude) &&
graph.GetVertex(edges.Vertex2, out toLatitude, out toLongitude))
{ // return the vertex.
var vertex1Coordinate = new GeoCoordinate(fromLatitude, fromLongitude);
var vertex2Coordinate = new GeoCoordinate(toLatitude, toLongitude);
if (edges.EdgeData.ShapeInBox)
{ // ok, check if it is needed to even check this edge.
var edgeBox = new GeoCoordinateBox(vertex1Coordinate, vertex2Coordinate);
var edgeBoxOverlap = false;
if (closestWithoutMatchBox == null ||
closestWithoutMatchBox.Overlaps(edgeBox))
{ // edge box overlap.
edgeBoxOverlap = true;
}
else if (closestWithMatchBox == null ||
closestWithMatchBox.Overlaps(edgeBox))
{ // edge box overlap.
edgeBoxOverlap = true;
}
if (!edgeBoxOverlap)
{ // no overlap, impossible this edge is a candidate.
continue;
}
}
var arcTags = graph.TagsIndex.Get(edges.EdgeData.Tags);
var canBeTraversed = vehicle.CanTraverse(arcTags);
if (canBeTraversed)
{ // the edge can be traversed.
distance = coordinate.DistanceEstimate(vertex1Coordinate).Value;
if (distance < distanceEpsilon.Value)
{ // the distance is smaller than the tolerance value.
var diff = coordinate - vertex1Coordinate;
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1);
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
closestWithMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1);
break;
}
}
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller for the without match.
var diff = coordinate - vertex1Coordinate;
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1);
}
if (distance < closestWithMatch.Distance)
{ // the distance is smaller for the with match.
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, graph.TagsIndex.Get(edges.EdgeData.Tags)))
{
var diff = coordinate - vertex1Coordinate;
closestWithMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1);
}
}
distance = coordinate.DistanceEstimate(vertex2Coordinate).Value;
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller for the without match.
var diff = coordinate - vertex2Coordinate;
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex2);
}
if (distance < closestWithMatch.Distance)
{ // the distance is smaller for the with match.
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
var diff = coordinate - vertex2Coordinate;
closestWithMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex2);
}
}
// search along the line.
var coordinatesArray = new ICoordinate[0];
var distanceTotal = 0.0;
var arcValueValueCoordinates = edges.Intermediates;
if (arcValueValueCoordinates != null)
{ // calculate distance along all coordinates.
coordinatesArray = arcValueValueCoordinates.ToArray();
}
// loop over all edges that are represented by this arc (counting intermediate coordinates).
var previous = vertex1Coordinate;
GeoCoordinateLine line;
var distanceToSegment = 0.0;
if (arcValueValueCoordinates != null)
{
for (int idx = 0; idx < coordinatesArray.Length; idx++)
{
var current = new GeoCoordinate(
coordinatesArray[idx].Latitude, coordinatesArray[idx].Longitude);
var edgeBox = new GeoCoordinateBox(previous, current);
var edgeBoxOverlap = false;
if (closestWithoutMatchBox == null ||
closestWithoutMatchBox.Overlaps(edgeBox))
{ // edge box overlap.
edgeBoxOverlap = true;
}
else if (closestWithMatchBox == null ||
closestWithMatchBox.Overlaps(edgeBox))
{ // edge box overlap.
edgeBoxOverlap = true;
}
if (edgeBoxOverlap)
{ // overlap, possible this edge is a candidate.
line = new GeoCoordinateLine(previous, current, true, true);
distance = line.DistanceReal(coordinate).Value;
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller.
var projectedPoint = line.ProjectOn(coordinate);
// calculate the position.
if (projectedPoint != null)
{ // calculate the distance.
if (distanceTotal == 0)
{ // calculate total distance.
var pCoordinate = vertex1Coordinate;
for (int cIdx = 0; cIdx < coordinatesArray.Length; cIdx++)
{
var cCoordinate = new GeoCoordinate(coordinatesArray[cIdx].Latitude, coordinatesArray[cIdx].Longitude);
distanceTotal = distanceTotal + cCoordinate.DistanceReal(pCoordinate).Value;
pCoordinate = cCoordinate;
}
distanceTotal = distanceTotal + vertex2Coordinate.DistanceReal(pCoordinate).Value;
}
var distancePoint = previous.DistanceReal(new GeoCoordinate(projectedPoint)).Value + distanceToSegment;
var position = distancePoint / distanceTotal;
var diff = coordinate - new GeoCoordinate(projectedPoint);
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1, edges.Vertex2, position, edges.EdgeData, coordinatesArray);
}
}
if (distance < closestWithMatch.Distance)
{
var projectedPoint = line.ProjectOn(coordinate);
// calculate the position.
if (projectedPoint != null)
{ // calculate the distance
if (distanceTotal == 0)
{ // calculate total distance.
var pCoordinate = vertex1Coordinate;
for (int cIdx = 0; cIdx < coordinatesArray.Length; cIdx++)
{
var cCoordinate = new GeoCoordinate(coordinatesArray[cIdx].Latitude, coordinatesArray[cIdx].Longitude);
distanceTotal = distanceTotal + cCoordinate.DistanceReal(pCoordinate).Value;
pCoordinate = cCoordinate;
}
distanceTotal = distanceTotal + vertex2Coordinate.DistanceReal(pCoordinate).Value;
}
var distancePoint = previous.DistanceReal(new GeoCoordinate(projectedPoint)).Value + distanceToSegment;
var position = distancePoint / distanceTotal;
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
var diff = coordinate - new GeoCoordinate(projectedPoint);
closestWithMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1, edges.Vertex2, position, edges.EdgeData, coordinatesArray);
}
}
}
}
// add current segment distance to distanceToSegment for the next segment.
distanceToSegment = distanceToSegment + previous.DistanceEstimate(current).Value;
// set previous.
previous = current;
}
}
// check the last segment.
line = new GeoCoordinateLine(previous, vertex2Coordinate, true, true);
distance = line.DistanceReal(coordinate).Value;
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller.
var projectedPoint = line.ProjectOn(coordinate);
// calculate the position.
if (projectedPoint != null)
{ // calculate the distance
if (distanceTotal == 0)
{ // calculate total distance.
var pCoordinate = vertex1Coordinate;
for (int cIdx = 0; cIdx < coordinatesArray.Length; cIdx++)
{
var cCoordinate = new GeoCoordinate(coordinatesArray[cIdx].Latitude, coordinatesArray[cIdx].Longitude);
distanceTotal = distanceTotal + cCoordinate.DistanceReal(pCoordinate).Value;
pCoordinate = cCoordinate;
}
distanceTotal = distanceTotal + vertex2Coordinate.DistanceReal(pCoordinate).Value;
}
double distancePoint = previous.DistanceReal(new GeoCoordinate(projectedPoint)).Value + distanceToSegment;
double position = distancePoint / distanceTotal;
var diff = coordinate - new GeoCoordinate(projectedPoint);
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1, edges.Vertex2, position, edges.EdgeData, coordinatesArray);
}
}
if (distance < closestWithMatch.Distance)
{
var projectedPoint = line.ProjectOn(coordinate);
// calculate the position.
if (projectedPoint != null)
{ // calculate the distance
if (distanceTotal == 0)
{ // calculate total distance.
var pCoordinate = vertex1Coordinate;
for (int cIdx = 0; cIdx < coordinatesArray.Length; cIdx++)
{
var cCoordinate = new GeoCoordinate(coordinatesArray[cIdx].Latitude, coordinatesArray[cIdx].Longitude);
distanceTotal = distanceTotal + cCoordinate.DistanceReal(pCoordinate).Value;
pCoordinate = cCoordinate;
}
distanceTotal = distanceTotal + vertex2Coordinate.DistanceReal(pCoordinate).Value;
}
double distancePoint = previous.DistanceReal(new GeoCoordinate(projectedPoint)).Value + distanceToSegment;
double position = distancePoint / distanceTotal;
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
var diff = coordinate - new GeoCoordinate(projectedPoint);
closestWithMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1, edges.Vertex2, position, edges.EdgeData, coordinatesArray);
}
}
}
}
}
}
}
else
{ // only find closest vertices.
// loop over all.
while (edges.MoveNext())
{
float fromLatitude, fromLongitude;
float toLatitude, toLongitude;
if (graph.GetVertex(edges.Vertex1, out fromLatitude, out fromLongitude) &&
graph.GetVertex(edges.Vertex2, out toLatitude, out toLongitude))
{
var vertexCoordinate = new GeoCoordinate(fromLatitude, fromLongitude);
double distance = coordinate.DistanceReal(vertexCoordinate).Value;
if (distance < closestWithoutMatch.Distance)
{ // the distance found is closer.
var diff = coordinate - vertexCoordinate;
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1);
}
vertexCoordinate = new GeoCoordinate(toLatitude, toLongitude);
distance = coordinate.DistanceReal(vertexCoordinate).Value;
if (distance < closestWithoutMatch.Distance)
{ // the distance found is closer.
var diff = coordinate - vertexCoordinate;
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex2);
}
var arcValueValueCoordinates = edges.Intermediates;
if (arcValueValueCoordinates != null)
{ // search over intermediate points.
var arcValueValueCoordinatesArray = arcValueValueCoordinates.ToArray();
for (int idx = 0; idx < arcValueValueCoordinatesArray.Length; idx++)
{
vertexCoordinate = new GeoCoordinate(
arcValueValueCoordinatesArray[idx].Latitude,
arcValueValueCoordinatesArray[idx].Longitude);
distance = coordinate.DistanceReal(vertexCoordinate).Value;
if (distance < closestWithoutMatch.Distance)
{ // the distance found is closer.
var diff = coordinate - vertexCoordinate;
closestWithoutMatchBox = new GeoCoordinateBox(new GeoCoordinate(coordinate + diff),
new GeoCoordinate(coordinate - diff));
closestWithoutMatch = new SearchClosestResult <TEdgeData>(
distance, edges.Vertex1, edges.Vertex2, idx, edges.EdgeData, arcValueValueCoordinatesArray);
}
}
}
}
}
}
// return the best result.
if (closestWithMatch.Distance < double.MaxValue)
{
return(closestWithMatch);
}
return(closestWithoutMatch);
}
/// <summary>
/// Builds the scene.
/// </summary>
/// <param name="map"></param>
/// <param name="zoomFactor"></param>
/// <param name="center"></param>
/// <param name="view"></param>
private void BuildScene(Map map, float zoomFactor, GeoCoordinate center, View2D view)
{
// get the indexed object at this zoom.
HashSet <ArcId> interpretedObjects;
if (!_interpretedObjects.TryGetValue((int)zoomFactor, out interpretedObjects))
{
interpretedObjects = new HashSet <ArcId>();
_interpretedObjects.Add((int)zoomFactor, interpretedObjects);
}
// build the boundingbox.
var viewBox = view.OuterBox;
var box = new GeoCoordinateBox(map.Projection.ToGeoCoordinates(viewBox.Min[0], viewBox.Min[1]),
map.Projection.ToGeoCoordinates(viewBox.Max[0], viewBox.Max[1]));
foreach (var requestedBox in _requestedBoxes)
{
if (requestedBox.Contains(box))
{
return;
}
}
_requestedBoxes.Add(box);
//// set the scene backcolor.
//SimpleColor? color = _styleInterpreter.GetCanvasColor ();
//_scene.BackColor = color.HasValue
// ? color.Value.Value
// : SimpleColor.FromArgb (0, 255, 255, 255).Value;
// get data.
foreach (var arc in _dataSource.GetEdges(box))
{
// translate each object into scene object.
var arcId = new ArcId()
{
Vertex1 = arc.Vertex1,
Vertex2 = arc.Vertex2
};
if (!interpretedObjects.Contains(arcId))
{
interpretedObjects.Add(arcId);
// create nodes.
float latitude, longitude;
_dataSource.GetVertex(arcId.Vertex1, out latitude, out longitude);
var node1 = new Node();
node1.Id = arcId.Vertex1;
node1.Latitude = latitude;
node1.Longitude = longitude;
_dataSource.GetVertex(arcId.Vertex2, out latitude, out longitude);
var node2 = new Node();
node2.Id = arcId.Vertex2;
node2.Latitude = latitude;
node2.Longitude = longitude;
// create way.
var way = CompleteWay.Create(-1);
if (arc.EdgeData.Forward)
{
way.Nodes.Add(node1);
way.Nodes.Add(node2);
}
else
{
way.Nodes.Add(node2);
way.Nodes.Add(node1);
}
way.Tags.AddOrReplace(_dataSource.TagsIndex.Get(arc.EdgeData.Tags));
_styleInterpreter.Translate(_scene, map.Projection, way);
interpretedObjects.Add(arcId);
}
}
}
