internal void GeneratePoi(GeoCoordinateBox box, List<PointPoi> list, RelativeDirection direction) { // create a new instruction first. Instruction instruction = new Instruction(box, list); Instruction direction_instruction = null; // pass the instruction to the languate generator. if (direction == null) { instruction = _generator.GeneratePoi(instruction, list, null); } else { // create a direction instruction. if (direction.Direction == RelativeDirectionEnum.TurnBack) { direction_instruction = new Instruction(box, list); direction_instruction = _generator.GenerateSimpleTurn(direction_instruction, direction.Direction); } // generates the instructions. instruction = _generator.GeneratePoi(instruction, list, null); } // add the instruction to the instructions list. _instructions.Add(instruction); // add the direction instruction. if (direction_instruction != null) { _instructions.Add(direction_instruction); } }
/// <summary> /// Returns the data from the given data source that is inside the given box. /// </summary> /// <param name="dataSourceName">The name of the datasource.</param> /// <param name="box">The bounding box.</param> /// <returns></returns> public string RequestData(string dataSourceName, GeoCoordinateBox box) { string dataPath = ConfigurationManager.AppSettings["datapath"]; // check of the file exists. var pbfFile = new FileInfo(dataPath + dataSourceName + ".pbf"); var xmlFile = new FileInfo(dataPath + dataSourceName); DataProcessorSource source = null; FileStream sourceStream = null; NamedSource namedSource; if (pbfFile.Exists) { // first try PBF: more efficient. // create PBF source. sourceStream = pbfFile.OpenRead(); source = new PBFDataProcessorSource(sourceStream); // create filter. DataProcessorFilter filter = new DataProcessorFilterBoundingBox(box); filter.RegisterSource(source); source = filter; } else if (xmlFile.Exists) { // then try XML. // create XML source. sourceStream = xmlFile.OpenRead(); source = new XmlDataProcessorSource(sourceStream); // create filter. DataProcessorFilter filter = new DataProcessorFilterBoundingBox(box); filter.RegisterSource(source); source = filter; } else if (NamedSourceCollection.Instance.TryGetSource(dataSourceName, out namedSource)) { // then try a named source. source = namedSource.Get(box); } else { // oeps! file or named source not found! throw new FileNotFoundException("File or name source {0} not found!", dataSourceName); } // create the target. var result = new StringBuilder(); var writer = new StringWriter(result); var target = new XmlDataProcessorTarget(writer); // execute the processing. target.RegisterSource(source); target.Pull(); // close the source stream if needed. if (sourceStream != null) { sourceStream.Close(); sourceStream.Dispose(); } return result.ToString(); }
internal void GenerateImmidiateTurn(GeoCoordinateBox box, List<KeyValuePair<string, string>> before_name, RelativeDirection first_direction, int first_street_count_to, RelativeDirection second_direction, List<KeyValuePair<string, string>> first_street_to, List<KeyValuePair<string, string>> second_street_to, List<PointPoi> list) { // create a new instruction first. Instruction instruction = new Instruction(box); // pass the instruction to the language generator. instruction = _generator.GenerateImmidiateTurn( instruction, first_street_count_to, first_street_to, first_direction, second_street_to, second_direction); // add the instruction to the instructions list. _instructions.Add(instruction); }
public override void Succes() { List<Routing.ArcAggregation.Output.PointPoi> pois = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point.Points; // construct the box indicating the location of the resulting find by this machine. GeoCoordinate point1 = pois[0].Location; GeoCoordinateBox box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GeneratePoi(box, pois, null); }
/// <summary> /// Creates an image that scales. /// </summary> /// <param name="top"></param> /// <param name="bottom"></param> /// <param name="left"></param> /// <param name="right"></param> /// <param name="image"></param> public ElementImage( double top, double bottom, double left, double right, Image image, double? min_zoom, double? max_zoom) : base(min_zoom, max_zoom) { _image = image; GeoCoordinate top_left = new GeoCoordinate(top, left); GeoCoordinate bottom_right = new GeoCoordinate(bottom, right); _box = new GeoCoordinateBox(top_left, bottom_right); }
/// <summary> /// Generates a turn instruction. /// </summary> /// <param name="entryIdx"></param> /// <param name="box"></param> /// <param name="direction"></param> /// <param name="streetCountTurn"></param> /// <param name="streetCountBeforeTurn"></param> /// <param name="streetFrom"></param> /// <param name="streetTo"></param> /// <param name="list"></param> internal void GenerateTurn(int entryIdx, GeoCoordinateBox box, RelativeDirection direction, int streetCountTurn, int streetCountBeforeTurn, TagsCollectionBase streetFrom, TagsCollectionBase streetTo, List <PointPoi> list) { // create a new instruction first. Instruction instruction = new Instruction(entryIdx, box, list); // pass the instruction to the languate generator. // test if the street is the same but a turn needs to be taken anyway. if (streetFrom == streetTo) { if (streetCountTurn == 0) {// there are no other streets between the one being turned into and the street coming from in the same // direction as the turn. instruction = _generator.GenerateDirectFollowTurn( instruction, streetCountBeforeTurn, streetTo, direction.Direction, list); } else { // there is another street; this is tricky to explain. instruction = _generator.GenerateIndirectFollowTurn( instruction, streetCountTurn, streetCountBeforeTurn, streetTo, direction.Direction, list); } } else { if (streetCountTurn == 0) { // there are no other streets between the one being turned into and the street coming from in the same // direction as the turn. instruction = _generator.GenerateDirectTurn( instruction, streetCountBeforeTurn, streetTo, direction.Direction, list); } else { // there is another street; this is tricky to explain. instruction = _generator.GenerateIndirectTurn( instruction, streetCountTurn, streetCountBeforeTurn, streetTo, direction.Direction, list); } } // add the instruction to the instructions list. _instructions.Add(instruction); }
/// <summary> /// Called when this machine is succesfull. /// </summary> public override void Succes() { // get first point. AggregatedPoint firstPoint = null; if (this.FinalMessages[0] is MicroPlannerMessagePoint) { // machine started on a point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessagePoint).Point; } else { // get the previous point. firstPoint = (this.FinalMessages[0] as MicroPlannerMessageArc).Arc.Previous; } var poisPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; var previousArc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; // get the pois list. var pois = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point.Points; // get the angle from the pois point. var direction = poisPoint.Angle; // calculate the box. var coordinates = new List <GeoCoordinate>(); foreach (Routing.ArcAggregation.Output.PointPoi poi in pois) { coordinates.Add(poi.Location); } coordinates.Add(poisPoint.Location); var box = new GeoCoordinateBox(coordinates.ToArray()); // let the scentence planner generate the correct information. var metaData = new Dictionary <string, object>(); metaData["direction"] = direction; metaData["pois"] = pois; metaData["type"] = "poi"; this.Planner.SentencePlanner.GenerateInstruction(metaData, firstPoint.SegmentIdx, poisPoint.SegmentIdx, box, pois); }
/// <summary> /// Returns all objects within the given bounding box. /// </summary> /// <param name="box"></param> /// <returns></returns> public List <OsmGeo> BoundingBoxGet(GeoCoordinateBox box) { string response = this.DoApiCall(false, string.Format( "/api/0.6/map?bbox={0},{1},{2},{3}", box.MinLon.ToString(System.Globalization.CultureInfo.InvariantCulture), box.MinLat.ToString(System.Globalization.CultureInfo.InvariantCulture), box.MaxLon.ToString(System.Globalization.CultureInfo.InvariantCulture), box.MaxLat.ToString(System.Globalization.CultureInfo.InvariantCulture)), Method.GET, null); if (response != null && response.Trim().Length > 0) { XmlReaderSource xml_source = new XmlReaderSource(XmlReader.Create(new StringReader(response))); OsmDocument osm = new OsmDocument(xml_source); List <OsmGeo> box_objects = new List <OsmGeo>(); OsmSharp.Osm.Xml.v0_6.osm xml_osm = (osm.Osm as OsmSharp.Osm.Xml.v0_6.osm); if (xml_osm.node != null) { foreach (Osm.Xml.v0_6.node xml_node in xml_osm.node) { box_objects.Add(this.Convertv6XmlNode(xml_node)); } } if (xml_osm.way != null) { foreach (Osm.Xml.v0_6.way xml_way in xml_osm.way) { box_objects.Add(this.Convertv6XmlWay(xml_way)); } } if (xml_osm.relation != null) { foreach (Osm.Xml.v0_6.relation xml_relation in xml_osm.relation) { box_objects.Add(this.Convertv6XmlRelation(xml_relation)); } } return(box_objects); } return(null); }
public override void Succes() { // get the last arc and the last point. AggregatedArc latestArc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; AggregatedPoint latestPoint = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; AggregatedArc secondLatestArc = (this.FinalMessages[this.FinalMessages.Count - 4] as MicroPlannerMessageArc).Arc; AggregatedPoint secondLatestPoint = (this.FinalMessages[this.FinalMessages.Count - 3] as MicroPlannerMessagePoint).Point; // count the number of streets in the same turning direction as the turn // that was found. int count = 0; if (MicroPlannerHelper.IsLeft(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetLeft(this.FinalMessages, this.Planner.Interpreter); } else if (MicroPlannerHelper.IsRight(latestPoint.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetRight(this.FinalMessages, this.Planner.Interpreter); } // construct the box indicating the location of the resulting find by this machine. GeoCoordinate point1 = latestPoint.Location; GeoCoordinateBox box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); // get all the names/direction/counts. TagsCollectionBase nextName = latestPoint.Next.Tags; TagsCollectionBase betweenName = latestArc.Tags; TagsCollectionBase beforeName = secondLatestArc.Tags; int firstCount = count; RelativeDirection firstTurn = secondLatestPoint.Angle; RelativeDirection secondTurn = latestPoint.Angle; // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GenerateImmidiateTurn(latestPoint.EntryIdx, box, beforeName, firstTurn, firstCount, secondTurn, betweenName, nextName, latestPoint.Points); }
/// <summary> /// Returns all edges inside the given boundingbox. /// </summary> /// <param name="box"></param> /// <returns></returns> public KeyValuePair <uint, KeyValuePair <uint, CHEdgeData> >[] GetArcs( GeoCoordinateBox box) { // load the missing tiles. this.LoadMissingTile(box); // get all the vertices in the given box. IEnumerable <uint> vertices = _vertexIndex.GetInside( box); // loop over all vertices and get the arcs. var arcs = new List <KeyValuePair <uint, KeyValuePair <uint, CHEdgeData> > >(); foreach (uint vertexId in vertices) { var location = _coordinates[(int)vertexId]; if (location != null) { // load tile if needed. this.LoadMissingTile(new GeoCoordinate( location.Latitude, location.Longitude)); // get the arcs and return. if (_vertices.Length > vertexId) { var vertex = _vertices[(int)vertexId]; if (vertex != null && vertex.Arcs != null) { KeyValuePair <uint, CHEdgeData>[] localArcs = vertex.Arcs; foreach (KeyValuePair <uint, CHEdgeData> localArc in localArcs) { arcs.Add(new KeyValuePair <uint, KeyValuePair <uint, CHEdgeData> >( vertexId, localArc)); } } } } } return(arcs.ToArray()); }
/// <summary> /// Returns all arcs inside the given bounding box. /// </summary> /// <param name="box"></param> /// <returns></returns> public KeyValuePair <uint, KeyValuePair <uint, TEdgeData> >[] GetArcs( GeoCoordinateBox box) { // get all the vertices in the given box. IEnumerable <uint> vertices = _vertexIndex.GetInside( box); // loop over all vertices and get the arcs. var arcs = new List <KeyValuePair <uint, KeyValuePair <uint, TEdgeData> > >(); foreach (uint vertex in vertices) { KeyValuePair <uint, TEdgeData>[] localArcs = this.GetArcs(vertex); foreach (KeyValuePair <uint, TEdgeData> localArc in localArcs) { arcs.Add(new KeyValuePair <uint, KeyValuePair <uint, TEdgeData> >( vertex, localArc)); } } return(arcs.ToArray()); }
/// <summary> /// Adds a point. /// </summary> public void AddPoint(GeoCoordinate coordinate, float sizePixels, int color) { if (coordinate == null) { throw new ArgumentNullException(); } // update envelope. if (_envelope == null) { // create initial envelope. _envelope = new GeoCoordinateBox(coordinate, coordinate); } // also include the current point. _envelope.ExpandWith(coordinate); double[] projectedCoordinates = _projection.ToPixel(coordinate); uint pointId = _scene.AddPoint(projectedCoordinates[0], projectedCoordinates[1]); _scene.AddStylePoint(pointId, 0, float.MinValue, float.MaxValue, color, sizePixels); this.RaiseLayerChanged(); }
/// <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) { // 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])); var zoomLevel = (int)map.Projection.ToZoomLevel(zoomFactor); if (_lastBox != null && _lastBox.Contains(box) && zoomLevel == _lastZoom) { return; } _lastBox = box; _lastZoom = zoomLevel; lock (_index) { _primitives = _index.Get(view, zoomFactor); } }
void AddMarkers() { var from = new GeoCoordinate(51.261203, 4.780760); var to = new GeoCoordinate(51.267797, 4.801362); var box = new GeoCoordinateBox(from, to); _mapView.ClearMarkers(); MapMarker marker; for (int idx = 0; idx < 20; idx++) { var pos = box.GenerateRandomIn(); marker = _mapView.AddMarker(pos); var popupTextView = new UITextView(); popupTextView.Text = "Hey, this is popup text!"; popupTextView.BackgroundColor = UIColor.FromWhiteAlpha(0.5f, 0.5f); marker.AddPopup(popupTextView, 100, 100); } }
/// <summary> /// Returns all arcs inside the given bounding box. /// </summary> /// <param name="box"></param> /// <returns></returns> public override INeighbourEnumerator <TEdgeData> GetEdges( GeoCoordinateBox box) { if (_vertexIndex == null) { // rebuild on-the-fly. this.RebuildVertexIndex(); } // get all the vertices in the given box. var vertices = _vertexIndex.GetInside( box); // loop over all vertices and get the arcs. var neighbours = new List <Tuple <uint, uint, uint, TEdgeData> >(); foreach (uint vertexId in vertices) { var localArcs = this.GetEdges(vertexId); uint arcIdx = 0; while (localArcs.MoveNext()) { if (localArcs.EdgeData.RepresentsNeighbourRelations) { //if (localArcs.isInverted) //{ // neighbours.Add(new Tuple<uint, uint, uint, TEdgeData>(vertexId, localArcs.Neighbour, arcIdx, // (TEdgeData)localArcs.EdgeData.Reverse())); //} //else //{ // not inverted. neighbours.Add(new Tuple <uint, uint, uint, TEdgeData>(vertexId, localArcs.Neighbour, arcIdx, localArcs.EdgeData)); //} } arcIdx++; } } return(new NeighbourEnumerator(this, neighbours)); }
/// <summary> /// Adds a new OsmSharpRoute. /// </summary> /// <param name="route">Stream.</param> /// <param name="argb">Stream.</param> /// <param name="width"></param> public void AddRoute(Route route, int argb, double width) { if (route != null && route.Segments != null && route.Segments.Length > 0) { // there are entries. // get x/y. var x = new double[route.Segments.Length]; var y = new double[route.Segments.Length]; for (int idx = 0; idx < route.Segments.Length; idx++) { x[idx] = _projection.LongitudeToX( route.Segments[idx].Longitude); y[idx] = _projection.LatitudeToY( route.Segments[idx].Latitude); // update envelope. if (_envelope == null) { // create initial envelope. _envelope = new GeoCoordinateBox( new GeoCoordinate(route.Segments[idx].Latitude, route.Segments[idx].Longitude), new GeoCoordinate(route.Segments[idx].Latitude, route.Segments[idx].Longitude)); } // also include the current point. _envelope.ExpandWith(new GeoCoordinate(route.Segments[idx].Latitude, route.Segments[idx].Longitude)); } // set the default color if none is given. var color = SimpleColor.FromArgb(argb); var pointsId = _scene.AddPoints(x, y); if (pointsId.HasValue) { _scene.AddStyleLine(pointsId.Value, 0, float.MinValue, float.MaxValue, color.Value, (float)width, Renderer.Primitives.LineJoin.Round, null); } } this.RaiseLayerChanged(); }
/// <summary> /// Returns all edges inside the given boundingbox. /// </summary> /// <param name="box"></param> /// <returns></returns> public INeighbourEnumerator <LiveEdge> GetEdges( GeoCoordinateBox box) { // load the missing tiles. this.LoadMissingTile(box); // get all the vertices in the given box. var vertices = _vertexIndex.GetInside(box); // loop over all vertices and get the arcs. var neighbours = new List <Tuple <uint, uint, uint, LiveEdge> >(); foreach (uint vertexId in vertices) { var location = _coordinates[(int)vertexId]; if (location != null) { //// load tile if needed. //this.LoadMissingTile(new GeoCoordinate( // location.Latitude, location.Longitude)); // get the arcs and return. if (_vertices.Length > vertexId) { var vertex = _vertices[(int)vertexId]; if (vertex != null && vertex.Arcs != null) { var localArcs = vertex.Arcs; for (int arcIdx = 0; arcIdx < vertex.Arcs.Length; arcIdx++) { neighbours.Add(new Tuple <uint, uint, uint, LiveEdge>(vertexId, (uint)arcIdx, localArcs[arcIdx].Item1, localArcs[arcIdx].Item2)); } } } } } return(new NeighbourEnumerator(this, neighbours)); }
public override IList <OsmGeo> Get(GeoCoordinateBox box, Filter filter) { IList <OsmGeo> osmGeoList = this._source.Get(box, filter); long? id; foreach (OsmGeo osmGeo in (IEnumerable <OsmGeo>)osmGeoList) { switch (osmGeo.Type) { case OsmGeoType.Node: LRUCache <long, Node> nodesCache = this._nodesCache; id = osmGeo.Id; long key1 = id.Value; Node node = osmGeo as Node; nodesCache.Add(key1, node); continue; case OsmGeoType.Way: LRUCache <long, Way> waysCache = this._waysCache; id = osmGeo.Id; long key2 = id.Value; Way way = osmGeo as Way; waysCache.Add(key2, way); continue; case OsmGeoType.Relation: LRUCache <long, Relation> relationsCache = this._relationsCache; id = osmGeo.Id; long key3 = id.Value; Relation relation = osmGeo as Relation; relationsCache.Add(key3, relation); continue; default: continue; } } return(osmGeoList); }
/// <summary> /// Returns all data in the given bounding box. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public override IList <OsmGeo> Get(GeoCoordinateBox box, Filter filter) { IList <OsmGeo> objects = _source.Get(box, filter); foreach (OsmGeo osmGeo in objects) { switch (osmGeo.Type) { case OsmGeoType.Node: _nodesCache.Add(osmGeo.Id.Value, osmGeo as Node); break; case OsmGeoType.Way: _waysCache.Add(osmGeo.Id.Value, osmGeo as Way); break; case OsmGeoType.Relation: _relationsCache.Add(osmGeo.Id.Value, osmGeo as Relation); break; } } return(objects); }
/// <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) { // 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])); var zoomLevel = (int)map.Projection.ToZoomLevel(zoomFactor); if (_lastBox != null && _lastBox.IsInside(box) && zoomLevel == _lastZoom) { return; } _lastBox = box; _lastZoom = zoomLevel; // reset the scene. _scene2DSimple = new Scene2DSimple(); // get from the index. this.Scene.BackColor = SimpleColor.FromKnownColor(KnownColor.White).Value; _index.Get(_scene2DSimple, view, zoomFactor); }
public override void Succes() { OsmSharp.Routing.ArcAggregation.Output.AggregatedPoint pois_point = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; OsmSharp.Routing.ArcAggregation.Output.AggregatedArc previous_arc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; // get the pois list. List<Routing.ArcAggregation.Output.PointPoi> pois = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point.Points; // get the angle from the pois point. RelativeDirection direction = pois_point.Angle; // calculate the box. List<GeoCoordinate> coordinates = new List<GeoCoordinate>(); foreach (Routing.ArcAggregation.Output.PointPoi poi in pois) { coordinates.Add(poi.Location); } coordinates.Add(pois_point.Location); GeoCoordinateBox box = new GeoCoordinateBox(coordinates.ToArray()); // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GeneratePoi(box, pois, direction); }
/// <summary> /// Loads all vertices inside the given boundingbox. /// </summary> /// <param name="box"></param> /// <returns></returns> private List <uint> LoadVerticesIn(GeoCoordinateBox box) { List <uint> vertices = new List <uint>(); TileRange range = TileRange.CreateAroundBoundingBox(box, _zoom); foreach (Tile tile in range) { CHVertexRegion region; if (!_regions.TryGet(tile.Id, out region)) { region = this.DeserializeRegion(tile.Id); if (region != null) { _regions.Add(tile.Id, region); } } if (region != null) { vertices.AddRange(region.Vertices); } } return(vertices); }
/// <summary> /// Tests routing from a serialized routing file. /// </summary> /// <param name="data"></param> /// <param name="box"></param> /// <param name="testCount"></param> public static void TestSerializedResolved(RouterDataSource <CHEdgeData> data, GeoCoordinateBox box, int testCount = 100) { var successCount = 0; var totalCount = testCount; var router = Router.CreateCHFrom(data, new CHRouter(), new OsmRoutingInterpreter()); var performanceInfo = new PerformanceInfoConsumer("CHRouting"); performanceInfo.Start(); performanceInfo.Report("Routing {0} routes...", testCount); while (testCount > 0) { var point1 = router.Resolve(Vehicle.Car, box.GenerateRandomIn()); var point2 = router.Resolve(Vehicle.Car, box.GenerateRandomIn()); Route route = null; if (point1 != null && point2 != null) { route = router.Calculate(Vehicle.Car, point1, point2); } if (route != null) { successCount++; } testCount--; } performanceInfo.Stop(); OsmSharp.Logging.Log.TraceEvent("CHRouting", OsmSharp.Logging.TraceEventType.Information, string.Format("{0}/{1} routes successfull!", successCount, totalCount)); }
public override void Succes() { OsmSharp.Routing.ArcAggregation.Output.AggregatedPoint pois_point = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; OsmSharp.Routing.ArcAggregation.Output.AggregatedArc previous_arc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; // get the pois list. List <Routing.ArcAggregation.Output.PointPoi> pois = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point.Points; // get the angle from the pois point. RelativeDirection direction = pois_point.Angle; // calculate the box. List <GeoCoordinate> coordinates = new List <GeoCoordinate>(); foreach (Routing.ArcAggregation.Output.PointPoi poi in pois) { coordinates.Add(poi.Location); } coordinates.Add(pois_point.Location); GeoCoordinateBox box = new GeoCoordinateBox(coordinates.ToArray()); // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GeneratePoi(box, pois, direction); }
/// <summary> /// Creates a new instruction with only a location. /// </summary> /// <param name="location"></param> public Instruction(GeoCoordinateBox location) { this.Location = location; }
/// <summary> /// Filters the geo objects in the changeset and omits the ones not inside the bb. /// </summary> /// <param name="simpleChangeSet"></param> /// <returns></returns> private KeyValuePair<SimpleChangeSet, GeoCoordinateBox> FilterChanges(SimpleChangeSet simpleChangeSet) { List<GeoCoordinate> changes_coordinates = new List<GeoCoordinate>(); SimpleChangeSet filtered_changeset = new SimpleChangeSet(); filtered_changeset.Changes = new List<SimpleChange>(); // keep a list of tested relation to prevent circular references from hanging this process. _tested_relations = new List<long>(); // keep all the objects that could not be checked and check them later. List<KeyValuePair<SimpleOsmGeo, SimpleChange>> objects_not_checked = new List<KeyValuePair<SimpleOsmGeo, SimpleChange>>(); // loop over all objects inside this box and if they are nodes they can be checked. HashSet<long> nodes_inside = new HashSet<long>(); // keep track of all the nodes inside for quick checks later! foreach (SimpleChange change in simpleChangeSet.Changes) { // keep the changed nodes that are ok for the filter. List<SimpleOsmGeo> nodes_changed = new List<SimpleOsmGeo>(); // loop over all objects in this set and keep the nodes. foreach (SimpleOsmGeo geo in change.OsmGeo) { if (geo is SimpleNode) { SimpleNode node = geo as SimpleNode; GeoCoordinate coord = new GeoCoordinate(node.Latitude.Value, node.Longitude.Value); if (_box.IsInsideAny(new OsmSharp.Tools.Math.PointF2D[] { coord })) { nodes_changed.Add(node); nodes_inside.Add(node.Id.Value); changes_coordinates.Add(coord); } } else { objects_not_checked.Add(new KeyValuePair<SimpleOsmGeo,SimpleChange>(geo as SimpleOsmGeo,change)); } } // are there changes in the nodes? if (nodes_changed.Count > 0) { SimpleChange nodes_change = new SimpleChange(); nodes_change.OsmGeo = nodes_changed; nodes_change.Type = change.Type; filtered_changeset.Changes.Add(nodes_change); } } // try all ways. HashSet<long> ways_inside = new HashSet<long>(); // keep the ways inside for quick checks later! foreach(KeyValuePair<SimpleOsmGeo,SimpleChange> change_pair in objects_not_checked) { SimpleOsmGeo geo = change_pair.Key; SimpleChange change = change_pair.Value; // keep the changed ways that are ok for the filter. List<SimpleOsmGeo> ways_changed = new List<SimpleOsmGeo>(); // detect if the way is part of the filter! if (geo is SimpleWay && (geo as SimpleWay).Nodes != null) { // try the cached nodes. foreach (long node_id in (geo as SimpleWay).Nodes) { if (nodes_inside.Contains(node_id)) { ways_changed.Add(geo); ways_inside.Add(geo.Id.Value); break; } } // first try to load the complete way. OsmSharp.Osm.Way way = _data_source.GetWay(geo.Id.Value); if (way != null && way.Nodes != null) { foreach (Osm.Node node in way.Nodes) { if (node != null) { // only if the node is found changes_coordinates.Add(node.Coordinate); if (_box.IsInsideAny(new OsmSharp.Tools.Math.PointF2D[] { node.Coordinate })) { changes_coordinates.Add(node.Coordinate); ways_changed.Add(geo); ways_inside.Add(geo.Id.Value); break; } } } } if (change.Type == SimpleChangeType.Delete && way != null && (way.Nodes == null || way.Nodes.Count == 0)) { // alway delete empty ways! ways_changed.Add(geo); ways_inside.Add(geo.Id.Value); } // second try to load the nodes individually. foreach (long node_id in (geo as SimpleWay).Nodes) { OsmSharp.Osm.Node node = _data_source.GetNode(node_id); if (node != null) { // only if the node is found if (_box.IsInsideAny(new OsmSharp.Tools.Math.PointF2D[] { node.Coordinate })) { changes_coordinates.Add(node.Coordinate); ways_changed.Add(geo); ways_inside.Add(geo.Id.Value); break; } } } } // are there changes in the nodes? if (ways_changed.Count > 0) { SimpleChange ways_change = new SimpleChange(); ways_change.OsmGeo = ways_changed; ways_change.Type = change.Type; filtered_changeset.Changes.Add(ways_change); } } // try all relations. foreach(KeyValuePair<SimpleOsmGeo,SimpleChange> change_pair in objects_not_checked) { SimpleOsmGeo geo = change_pair.Key; SimpleChange change = change_pair.Value; // keep the changed ways that are ok for the filter. List<SimpleOsmGeo> relations_changed = new List<SimpleOsmGeo>(); // test all relations. if (geo is SimpleRelation) { if (!_tested_relations.Contains(geo.Id.Value)) { _tested_relations.Add(geo.Id.Value); if (this.IsInsideBoxRelation((geo as SimpleRelation).Members,nodes_inside,ways_inside)) { relations_changed.Add(geo); } } } // are there changes in the nodes? if (relations_changed.Count > 0) { SimpleChange relations_change = new SimpleChange(); relations_change.OsmGeo = relations_changed; relations_change.Type = change.Type; filtered_changeset.Changes.Add(relations_change); } } // create bounding box of the found changes! GeoCoordinateBox box = null; if (changes_coordinates.Count > 0) { box = new GeoCoordinateBox(changes_coordinates); } return new KeyValuePair<SimpleChangeSet, GeoCoordinateBox>(filtered_changeset, box); }
/// <summary> /// Returns all objects in the given bounding box that are valid according to the given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { // initialize connection. OracleConnection con = this.CreateConnection(); List<OsmGeo> base_list = new List<OsmGeo>(); // calculate bounding box parameters to query db. long latitude_min = (long)(box.MinLat * 10000000.0); long longitude_min = (long)(box.MinLon * 10000000.0); long latitude_max = (long)(box.MaxLat * 10000000.0); long longitude_max = (long)(box.MaxLon * 10000000.0); // TODO: improve this to allow loading of bigger bb's. uint x_min = lon2x(box.MinLon); uint x_max = lon2x(box.MaxLon); uint y_min = lat2y(box.MinLat); uint y_max = lat2y(box.MaxLat); IList<long> boxes = new List<long>(); for (uint x = x_min; x <= x_max; x++) { for (uint y = y_min; y <= y_max; y++) { boxes.Add(this.xy2tile(x, y)); } } // STEP 1: query nodes table. //id latitude longitude changeset_id visible timestamp tile version string sql = "SELECT * FROM node WHERE (visible = 1) AND (tile IN ({4})) AND (latitude BETWEEN {0} AND {1} AND longitude BETWEEN {2} AND {3})"; sql = string.Format(sql, latitude_min.ToString(), latitude_max.ToString(), longitude_min.ToString(), longitude_max.ToString(), this.ConstructIdList(boxes)); // TODO: parameters. OracleCommand com = new OracleCommand(sql); com.Connection = con; OracleDataReader reader = com.ExecuteReader(); Node node = null; Dictionary<long, Node> nodes = new Dictionary<long, Node>(); List<long> node_ids = new List<long>(); while (reader.Read()) { // load/parse data. long returned_id = reader.GetInt64(0); int latitude_int = reader.GetInt32(1); int longitude_int = reader.GetInt32(2); long changeset_id = reader.GetInt64(3); bool visible = reader.GetInt64(4)==1; DateTime timestamp = reader.GetDateTime(5); long tile = reader.GetInt64(6); long version = reader.GetInt64(7); // create node. node = OsmBaseFactory.CreateNode(returned_id); node.Version = version; //node.UserId = user_id; node.TimeStamp = timestamp; node.ChangeSetId = changeset_id; node.Coordinate = new GeoCoordinate( ((double)latitude_int) / 10000000.0, ((double)longitude_int) / 10000000.0); nodes.Add(node.Id,node); node_ids.Add(node.Id); } reader.Close(); // STEP2: Load all node tags. this.LoadNodeTags(nodes); // STEP3: Load all ways for the given nodes. IList<Way> ways = this.GetWaysForNodes(nodes); // Add all objects to the base list. foreach (Node node_result in nodes.Values.ToList<Node>()) { base_list.Add(node_result); } foreach (Way way in ways) { base_list.Add(way); } return base_list; }
/// <summary> /// Returns all the elements in the given box. /// </summary> /// <param name="coordinate"></param> /// <returns></returns> public MapQueryResult GetElementsAt(GeoCoordinateBox box, double zoom_factor) { List<IElement> elements = new List<IElement>(); for(int idx = this.Layers.Count-1;idx>=0;idx--) { if (this.Layers[idx].Visible) { // only add elements from visible layers. elements.AddRange( this.Layers[idx].GetElements(box, zoom_factor)); } } return new MapQueryResult(box.Center,elements); }
/// <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. if (_box == null || _box.Contains(new GeoCoordinate((float)node.Latitude.Value, (float)node.Longitude.Value))) { // the coordinate is acceptable. _coordinates[node.Id.Value] = new GeoCoordinateSimple() { Latitude = (float)node.Latitude.Value, Longitude = (float)node.Longitude.Value }; if (_coordinates.Count == _preIndex.Count) { _preIndex.Clear(); _preIndex = null; } if (_bounds == null) { // create bounds. _bounds = new GeoCoordinateBox( new GeoCoordinate(node.Latitude.Value, node.Longitude.Value), new GeoCoordinate(node.Latitude.Value, node.Longitude.Value)); } else { // expand bounds. _bounds.ExpandWith( new GeoCoordinate(node.Latitude.Value, 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. List <Vehicle> vehicles = _interpreter.CalculateRestrictions(node); if (vehicles != null && vehicles.Count > 0) { // add all the restrictions. uint vertexId = this.AddRoadNode(node.Id.Value).Value; // will always exists, has just been added to coordinates. uint[] restriction = new uint[] { vertexId }; if (vehicles.Contains(null)) { // restriction is valid for all vehicles. _dynamicGraph.AddRestriction(restriction); } else { // restriction is restricted to some vehicles only. foreach (Vehicle vehicle in vehicles) { _dynamicGraph.AddRestriction(vehicle, restriction); } } } } } } } }
/// <summary> /// Writes to the osm document. /// </summary> private void WriteToDocument() { _read = true; // collect all needed data. _bb = this.BoundingBox; // generate osm document. OsmSharp.Osm.Xml.v0_6.osm osm = new OsmSharp.Osm.Xml.v0_6.osm(); // dimension the arrays. osm.node = new node[_nodes.Count]; osm.way = new way[_ways.Count]; osm.relation = new relation[_relations.Count]; // iterate over all objects and convert them. IList<Node> nodes = _nodes.Values.ToList<Node>(); for(int idx = 0;idx < nodes.Count;idx++) { node xml_obj = nodes[idx].ConvertTo(); osm.node[idx] = xml_obj; } IList<Way> ways = _ways.Values.ToList<Way>(); for (int idx = 0; idx < ways.Count; idx++) { way xml_obj = ways[idx].ConvertTo(); osm.way[idx] = xml_obj; } IList<Relation> relations = _relations.Values.ToList<Relation>(); for (int idx = 0; idx < relations.Count; idx++) { relation xml_obj = relations[idx].ConvertTo(); osm.relation[idx] = xml_obj; } // convert the bounds as well. osm.bounds = _bb.ConvertTo(); _document.Osm = osm; _document.Save(); }
public override bool IsVisibleIn(GeoCoordinateBox box) { return this.Line.Inside(box); }
/// <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.Key, Vertex2 = arc.Value.Key }; 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.Value.Value.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.Value.Value.Tags)); _styleInterpreter.Translate(_scene, map.Projection, way); interpretedObjects.Add(arcId); } } }
/// <summary> /// Returns all the objects within a given bounding box and filtered by a given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { return new List<OsmGeo>(); }
/// <summary> /// Returns the elements in this layer. /// </summary> /// <param name="box"></param> /// <returns></returns> public IList<IElement> GetElements(GeoCoordinateBox box, double zoom_factor) { // TODO: implement the boundingbox cache. return _elements; }
/// <summary> /// Reads all the data from the osm document if needed. /// </summary> private void ReadFromDocument() { if (!_read) { _read = true; OsmSharp.Osm.Xml.v0_6.osm osm = (_document.Osm as OsmSharp.Osm.Xml.v0_6.osm); if (osm != null) { // if there was no data to begin with. if (osm.node != null) { foreach (Osm.Xml.v0_6.node node in osm.node) { Node new_node = node.ConvertFrom(); _nodes.Add(new_node.Id, new_node); this.RegisterChangeSetId(new_node.ChangeSetId); } } if (osm.way != null) { foreach (Osm.Xml.v0_6.way way in osm.way) { Way new_way = way.ConvertFrom(this); if (new_way != null) { _ways.Add(new_way.Id, new_way); this.RegisterNodeWayRelation(new_way); this.RegisterChangeSetId(new_way.ChangeSetId); } } } if (osm.relation != null) { foreach (Osm.Xml.v0_6.relation relation in osm.relation) { Relation new_relation = relation.ConvertFrom(this, this, this); if (new_relation != null) { _relations.Add(new_relation.Id, new_relation); this.RegisterRelationMemberRelation(new_relation); this.RegisterChangeSetId(new_relation.ChangeSetId); } } } _bb = osm.bounds.ConvertFrom(); if(_bb == null) { _bb = osm.bound.ConvertFrom(); } } } }
public void TestGetBoundingBox() { var dataSource = new MemoryDataSource(); // test nodes. Node node = new Node(); node.Id = 1; node.Longitude = -2; node.Latitude = -1; dataSource.AddNode(node); node = new Node(); node.Id = 2; node.Longitude = 2; node.Latitude = 1; dataSource.AddNode(node); GeoCoordinateBox box = dataSource.BoundingBox; IList <OsmGeo> boxResults = dataSource.Get(box, null); Assert.IsNotNull(boxResults); Assert.AreEqual(1, boxResults.Count); boxResults = dataSource.Get(box.Resize(0.1), null); Assert.IsNotNull(boxResults); Assert.AreEqual(2, boxResults.Count); node = new Node(); node.Id = 3; node.Latitude = 10; node.Longitude = 10; dataSource.AddNode(node); node = new Node(); node.Id = 4; node.Latitude = -10; node.Longitude = -10; dataSource.AddNode(node); boxResults = dataSource.Get(box, null); Assert.IsNotNull(boxResults); Assert.AreEqual(1, boxResults.Count); boxResults = dataSource.Get(box.Resize(0.1), null); Assert.IsNotNull(boxResults); Assert.AreEqual(2, boxResults.Count); // test ways. Way positive = new Way(); positive.Id = 1; positive.Nodes = new List <long>(); positive.Nodes.Add(1); positive.Nodes.Add(2); dataSource.AddWay(positive); Way halfPositive = new Way(); halfPositive.Id = 2; halfPositive.Nodes = new List <long>(); halfPositive.Nodes.Add(1); halfPositive.Nodes.Add(3); dataSource.AddWay(halfPositive); Way negative = new Way(); negative.Id = 3; negative.Nodes = new List <long>(); negative.Nodes.Add(3); negative.Nodes.Add(4); dataSource.AddWay(negative); HashSet <OsmGeo> boxResultWithWays = new HashSet <OsmGeo>(dataSource.Get(box, null)); Assert.IsTrue(boxResultWithWays.Contains(positive)); Assert.IsTrue(boxResultWithWays.Contains(halfPositive)); Assert.IsFalse(boxResultWithWays.Contains(negative)); // test relations. Relation positiveRelation1 = new Relation(); positiveRelation1.Id = 1; positiveRelation1.Members = new List <RelationMember>(); positiveRelation1.Members.Add(new RelationMember() { MemberId = 1, MemberType = OsmGeoType.Node, MemberRole = "node" }); dataSource.AddRelation(positiveRelation1); Relation positiveRelation2 = new Relation(); positiveRelation2.Id = 2; positiveRelation2.Members = new List <RelationMember>(); positiveRelation2.Members.Add(new RelationMember() { MemberId = 1, MemberType = OsmGeoType.Way, MemberRole = "way" }); dataSource.AddRelation(positiveRelation2); Relation negativeRelation3 = new Relation(); negativeRelation3.Id = 3; negativeRelation3.Members = new List <RelationMember>(); negativeRelation3.Members.Add(new RelationMember() { MemberId = 3, MemberType = OsmGeoType.Way, MemberRole = "way" }); dataSource.AddRelation(positiveRelation2); HashSet <OsmGeo> boxResultWithWaysAndRelations = new HashSet <OsmGeo>(dataSource.Get(box, null)); Assert.IsTrue(boxResultWithWaysAndRelations.Contains(positiveRelation1)); Assert.IsTrue(boxResultWithWaysAndRelations.Contains(positiveRelation2)); Assert.IsFalse(boxResultWithWaysAndRelations.Contains(negativeRelation3)); // test recursive relations. Relation recusive1 = new Relation(); recusive1.Id = 10; recusive1.Members = new List <RelationMember>(); recusive1.Members.Add(new RelationMember() { MemberId = 1, MemberType = OsmGeoType.Relation, MemberRole = "relation" }); dataSource.AddRelation(recusive1); Relation recusive2 = new Relation(); recusive2.Id = 11; recusive2.Members = new List <RelationMember>(); recusive2.Members.Add(new RelationMember() { MemberId = 10, MemberType = OsmGeoType.Relation, MemberRole = "relation" }); dataSource.AddRelation(recusive2); Relation recusive3 = new Relation(); recusive3.Id = 12; recusive3.Members = new List <RelationMember>(); recusive3.Members.Add(new RelationMember() { MemberId = 11, MemberType = OsmGeoType.Relation, MemberRole = "relation" }); dataSource.AddRelation(recusive3); boxResultWithWaysAndRelations = new HashSet <OsmGeo>(dataSource.Get(box, null)); Assert.IsTrue(boxResultWithWaysAndRelations.Contains(recusive1)); Assert.IsTrue(boxResultWithWaysAndRelations.Contains(recusive2)); Assert.IsTrue(boxResultWithWaysAndRelations.Contains(recusive3)); }
private bool IsInBB(OsmGeo osmGeo) { bool flag = false; switch (osmGeo.Type) { case OsmGeoType.Node: GeoCoordinateBox box = this._box; double? nullable = (osmGeo as Node).Latitude; double latitude = nullable.Value; nullable = (osmGeo as Node).Longitude; double longitude = nullable.Value; GeoCoordinate geoCoordinate = new GeoCoordinate(latitude, longitude); flag = box.Contains((PointF2D)geoCoordinate); break; case OsmGeoType.Way: foreach (long node in (osmGeo as Way).Nodes) { if (this._nodesIn.Contains(node)) { flag = true; break; } } if (flag) { using (List <long> .Enumerator enumerator = (osmGeo as Way).Nodes.GetEnumerator()) { while (enumerator.MoveNext()) { this._nodesToInclude.Add(enumerator.Current); } break; } } else { break; } case OsmGeoType.Relation: if (!this._relationsConsidered.Contains(osmGeo.Id.Value)) { foreach (RelationMember member in (osmGeo as Relation).Members) { switch (member.MemberType.Value) { case OsmGeoType.Node: if (this._nodesIn.Contains(member.MemberId.Value)) { flag = true; continue; } continue; case OsmGeoType.Way: if (this._waysIn.Contains(member.MemberId.Value)) { flag = true; continue; } continue; case OsmGeoType.Relation: if (this._relationIn.Contains(member.MemberId.Value)) { flag = true; continue; } continue; default: continue; } } if (flag) { using (List <RelationMember> .Enumerator enumerator = (osmGeo as Relation).Members.GetEnumerator()) { while (enumerator.MoveNext()) { RelationMember current = enumerator.Current; switch (current.MemberType.Value) { case OsmGeoType.Node: this._nodesToInclude.Add(current.MemberId.Value); continue; case OsmGeoType.Way: this._waysToInclude.Add(current.MemberId.Value); continue; case OsmGeoType.Relation: this._relationsToInclude.Add(current.MemberId.Value); continue; default: continue; } } break; } } else { break; } } else { break; } } return(flag); }
/// <summary> /// Creates a new bounding box filter. /// </summary> /// <param name="box"></param> public DataProcessorFilterBoundingBox(GeoCoordinateBox box) : base() { _box = box; }
public TileRange GetTileToLoadFor(GeoCoordinateBox bbox, int zoom) { int n = (int)System.Math.Floor(System.Math.Pow(2, zoom)); Radian rad = new Degree(bbox.MaxLat); int x_tile_min = (int)(((bbox.MinLon + 180.0f) / 360.0f) * (double)n); int y_tile_min = (int)( (1.0f - (System.Math.Log(System.Math.Tan(rad.Value) + (1.0f / System.Math.Cos(rad.Value)))) / System.Math.PI) / 2f * (double)n); rad = new Degree(bbox.MinLat); int x_tile_max = (int)(((bbox.MaxLon + 180.0f) / 360.0f) * (double)n); int y_tile_max = (int)( (1.0f - (System.Math.Log(System.Math.Tan(rad.Value) + (1.0f / System.Math.Cos(rad.Value)))) / System.Math.PI) / 2f * (double)n); TileRange range = new TileRange(); range.XMax = x_tile_max; range.XMin = x_tile_min; range.YMax = y_tile_max; range.YMin = y_tile_min; return range; }
/// <summary> /// Creates a new view. /// </summary> /// <param name="box"></param> public View(GeoCoordinateBox box, float zoom_factor) { _box = box; _zoom_factor = zoom_factor; }
/// <summary> /// Returns the elements. /// </summary> /// <param name="box"></param> /// <param name="zoom_factor"></param> /// <returns></returns> public IList<IElement> GetElements(GeoCoordinateBox box, double zoom_factor) { List<IElement> elements = new List<IElement>(); List<IElement> local_elements; lock (_elements) { local_elements = new List<IElement>(_elements); } foreach (IElement element in local_elements) { if (element.IsVisibleIn(box)) { elements.Add(element); } } return elements; }
/// <summary> /// Tests adding some simple data. /// </summary> protected void DoTestSimple() { // create the index. ILocatedObjectIndex<GeoCoordinate, LocatedObjectData> index = this.CreateIndex(); // add the data. GeoCoordinate point1 = new GeoCoordinate(0, 0); LocatedObjectData point1_data = new LocatedObjectData() { SomeData = point1.ToString() }; GeoCoordinate point2 = new GeoCoordinate(1, 1); LocatedObjectData point2_data = new LocatedObjectData() { SomeData = point2.ToString() }; GeoCoordinateBox location_box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.0001, point1.Longitude - 0.0001), new GeoCoordinate(point1.Latitude + 0.0001, point1.Longitude + 0.0001)); // try and get data from empty index. // regression test for issue: https://osmsharp.codeplex.com/workitem/1244 IEnumerable<LocatedObjectData> location_box_data = index.GetInside(location_box); Assert.IsNotNull(location_box_data); Assert.AreEqual(0, location_box_data.Count()); // try point1. index.Add(point1, point1_data); location_box_data = index.GetInside( location_box); Assert.IsNotNull(location_box_data); bool found = false; foreach (LocatedObjectData location_data in location_box_data) { if (location_data.SomeData == point1.ToString()) { found = true; } } Assert.IsTrue(found, string.Format("Data added at location {0} not found in box {1}!", point1, location_box)); // try point2. index.Add(point2, point2_data); location_box = new GeoCoordinateBox( new GeoCoordinate(point2.Latitude - 0.0001, point2.Longitude - 0.0001), new GeoCoordinate(point2.Latitude + 0.0001, point2.Longitude + 0.0001)); location_box_data = index.GetInside( location_box); Assert.IsNotNull(location_box_data); found = false; foreach (LocatedObjectData location_data in location_box_data) { if (location_data.SomeData == point2.ToString()) { found = true; } } Assert.IsTrue(found, string.Format("Data added at location {0} not found in box {1}!", point2, location_box)); }
/// <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> public SearchClosestResult SearchClosest(IBasicRouterDataSource <TEdgeData> graph, IRoutingInterpreter interpreter, Vehicle vehicle, GeoCoordinate coordinate, float delta, IEdgeMatcher matcher, TagsCollection pointTags, bool verticesOnly) { var closestWithMatch = new SearchClosestResult(double.MaxValue, 0); var closestWithoutMatch = new SearchClosestResult(double.MaxValue, 0); 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. KeyValuePair <uint, KeyValuePair <uint, TEdgeData> >[] arcs = graph.GetArcs(searchBox); if (!verticesOnly) { // find both closest arcs and vertices. // loop over all. foreach (KeyValuePair <uint, KeyValuePair <uint, TEdgeData> > arc in arcs) { TagsCollection arcTags = graph.TagsIndex.Get(arc.Value.Value.Tags); bool canBeTraversed = vehicle.CanTraverse(arcTags); if (canBeTraversed) { // the edge can be traversed. // test the two points. float fromLatitude, fromLongitude; float toLatitude, toLongitude; double distance; if (graph.GetVertex(arc.Key, out fromLatitude, out fromLongitude) && graph.GetVertex(arc.Value.Key, out toLatitude, out toLongitude)) { // return the vertex. var fromCoordinates = new GeoCoordinate(fromLatitude, fromLongitude); distance = coordinate.Distance(fromCoordinates); if (distance < 0.00001) { // the distance is smaller than the tolerance value. closestWithoutMatch = new SearchClosestResult( distance, arc.Key); if (matcher == null || (pointTags == null || pointTags.Count == 0) || matcher.MatchWithEdge(vehicle, pointTags, arcTags)) { closestWithMatch = new SearchClosestResult( distance, arc.Key); break; } } if (distance < closestWithoutMatch.Distance) { // the distance is smaller for the without match. closestWithoutMatch = new SearchClosestResult( distance, arc.Key); } 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(arc.Value.Value.Tags))) { closestWithMatch = new SearchClosestResult( distance, arc.Key); } } var toCoordinates = new GeoCoordinate(toLatitude, toLongitude); distance = coordinate.Distance(toCoordinates); if (distance < closestWithoutMatch.Distance) { // the distance is smaller for the without match. closestWithoutMatch = new SearchClosestResult( distance, arc.Value.Key); } 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)) { closestWithMatch = new SearchClosestResult( distance, arc.Value.Key); } } // create a line. double distanceTotal = fromCoordinates.Distance(toCoordinates); if (distanceTotal > 0) { // the from/to are not the same location. var line = new GeoCoordinateLine(fromCoordinates, toCoordinates, true, true); distance = line.Distance(coordinate); if (distance < closestWithoutMatch.Distance) { // the distance is smaller. PointF2D projectedPoint = line.ProjectOn(coordinate); // calculate the position. if (projectedPoint != null) { // calculate the distance double distancePoint = fromCoordinates.Distance(projectedPoint); double position = distancePoint / distanceTotal; closestWithoutMatch = new SearchClosestResult( distance, arc.Key, arc.Value.Key, position); } } if (distance < closestWithMatch.Distance) { PointF2D projectedPoint = line.ProjectOn(coordinate); // calculate the position. if (projectedPoint != null) { // calculate the distance double distancePoint = fromCoordinates.Distance(projectedPoint); double position = distancePoint / distanceTotal; if (matcher == null || (pointTags == null || pointTags.Count == 0) || matcher.MatchWithEdge(vehicle, pointTags, arcTags)) { closestWithMatch = new SearchClosestResult( distance, arc.Key, arc.Value.Key, position); } } } } } } } } else { // only find closest vertices. // loop over all. foreach (KeyValuePair <uint, KeyValuePair <uint, TEdgeData> > arc in arcs) { float fromLatitude, fromLongitude; float toLatitude, toLongitude; if (graph.GetVertex(arc.Key, out fromLatitude, out fromLongitude) && graph.GetVertex(arc.Value.Key, out toLatitude, out toLongitude)) { var vertexCoordinate = new GeoCoordinate(fromLatitude, fromLongitude); double distance = coordinate.Distance(vertexCoordinate); if (distance < closestWithoutMatch.Distance) { // the distance found is closer. closestWithoutMatch = new SearchClosestResult( distance, arc.Key); } vertexCoordinate = new GeoCoordinate(toLatitude, toLongitude); distance = coordinate.Distance(vertexCoordinate); if (distance < closestWithoutMatch.Distance) { // the distance found is closer. closestWithoutMatch = new SearchClosestResult( distance, arc.Value.Key); } } } } // return the best result. if (closestWithMatch.Distance < double.MaxValue) { return(closestWithMatch); } return(closestWithoutMatch); }
/// <summary> /// Tests adding a lot of random data. /// </summary> /// <param name="count"></param> public void DoTestAddingRandom(int count) { ILocatedObjectIndex<GeoCoordinate, LocatedObjectData> index = this.CreateIndex(); GeoCoordinateBox box = new GeoCoordinateBox(new GeoCoordinate(50, 3), new GeoCoordinate(40, 2)); HashSet<GeoCoordinate> locations = new HashSet<GeoCoordinate>(); Random random = new Random(); while (count > 0) { GeoCoordinate location = box.GenerateRandomIn(random); LocatedObjectData data = new LocatedObjectData() { SomeData = location.ToString() }; locations.Add(location); index.Add(location, data); // try immidiately after. GeoCoordinateBox location_box = new GeoCoordinateBox( new GeoCoordinate(location.Latitude - 0.0001, location.Longitude - 0.0001), new GeoCoordinate(location.Latitude + 0.0001, location.Longitude + 0.0001)); IEnumerable<LocatedObjectData> location_box_data = index.GetInside( location_box); Assert.IsNotNull(location_box_data); bool found = false; foreach (LocatedObjectData location_data in location_box_data) { if (location_data.SomeData == location.ToString()) { found = true; } } Assert.IsTrue(found, string.Format("Data added at location {0} not found in box {1}!", location, location_box)); count--; } foreach (GeoCoordinate location in locations) { GeoCoordinateBox location_box = new GeoCoordinateBox( new GeoCoordinate(location.Latitude - 0.0001, location.Longitude - 0.0001), new GeoCoordinate(location.Latitude + 0.0001, location.Longitude + 0.0001)); IEnumerable<LocatedObjectData> location_box_data = index.GetInside( location_box); Assert.IsNotNull(location_box_data); bool found = false; foreach (LocatedObjectData location_data in location_box_data) { if (location_data.SomeData == location.ToString()) { found = true; } } Assert.IsTrue(found, string.Format("Data added at location {0} not found in box {1}!", location, location_box)); } }
/// <summary> /// Returns the objects that exist withing the given box and evaluate the filter to true. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { this.ReadFromDocument(); IList<OsmGeo> res = new List<OsmGeo>(); foreach (Node node in _nodes.Values) { if (filter.Evaluate(node) && node.Shape.Inside(box)) { res.Add(node); } } foreach (Way way in _ways.Values) { if (filter.Evaluate(way) && way.Shape.Inside(box)) { res.Add(way); } } foreach (Relation relation in _relations.Values) { if (filter.Evaluate(relation) && relation.Shape.Inside(box)) { res.Add(relation); } } return res; }
/// <summary> /// Returns all edges inside the given bounding box. /// </summary> /// <returns></returns> public abstract INeighbourEnumerator <TEdgeData> GetEdges(GeoCoordinateBox box);
/// <summary> /// Creates a new changeset filter. /// </summary> /// <param name="data_source"></param> /// <param name="box"></param> /// <param name="listener"></param> public DataProcessorChangeSetFilterBoundingBox(Osm.Data.IDataSourceReadOnly data_source, GeoCoordinateBox box, IChangeSetFilterListener listener) : base() { _box = box; _data_source = data_source; _listener = listener; }
/// <summary> /// Utility method for ensuring a view stays within a bounding box of geo coordinated. /// </summary> /// <param name="center">The map center we want to move to.</param> /// <param name="boundingBox">A GeoCoordinateBox defining the bounding box.</param> /// <param name="view" The current view.</param> /// <returns>Returns a center geo coordinate that is corrected so the view stays within the bounding box.</returns> public GeoCoordinate EnsureViewWithinBoundingBox(GeoCoordinate center, GeoCoordinateBox boundingBox, View2D view) { double[] mapCenterSceneCoords = this.Projection.ToPixel(center); var toViewPort = view.CreateToViewPort(view.Width, view.Height); double mapCenterPixelsX, mapCenterPixelsY; toViewPort.Apply(mapCenterSceneCoords[0], mapCenterSceneCoords[1], out mapCenterPixelsX, out mapCenterPixelsY); //double[] mapCenterPixels = view.ToViewPort(view.Width, view.Height, mapCenterSceneCoords[0], mapCenterSceneCoords[1]); var fromViewPort = view.CreateFromViewPort(view.Height, view.Width); double leftScene, topScene, rightScene, bottomScene; fromViewPort.Apply(mapCenterPixelsX - (view.Width) / 2.0, mapCenterPixelsY - (view.Height) / 2.0, out leftScene, out topScene); //double[] topLeftSceneCoordinates = view.FromViewPort(view.Width, // view.Height, // mapCenterPixels[0] - (view.Width) / 2.0, // mapCenterPixels[1] - (view.Height) / 2.0); GeoCoordinate topLeft = this.Projection.ToGeoCoordinates(leftScene, topScene); //GeoCoordinate topLeft = this.Projection.ToGeoCoordinates(topLeftSceneCoordinates[0], topLeftSceneCoordinates[1]); fromViewPort.Apply(mapCenterPixelsX + (view.Width) / 2.0, mapCenterPixelsY + (view.Height) / 2.0, out rightScene, out bottomScene); //double[] bottomRightSceneCoordinates = view.FromViewPort(view.Width, // view.Height, // mapCenterPixels[0] + (view.Width) / 2.0, // mapCenterPixels[1] + (view.Height) / 2.0); GeoCoordinate bottomRight = this.Projection.ToGeoCoordinates(rightScene, bottomScene); // Early exit when the view is inside the box. if (boundingBox.Contains(topLeft) && boundingBox.Contains(bottomRight)) { return(center); } double viewNorth = topLeft.Latitude; double viewEast = bottomRight.Longitude; double viewSouth = bottomRight.Latitude; double viewWest = topLeft.Longitude; double boxNorth = boundingBox.MaxLat; double boxEast = boundingBox.MaxLon; double boxSouth = boundingBox.MinLat; double boxWest = boundingBox.MinLon; //TODO: Check if the view acrually fits the bounding box, if not resize the view. // Correct all view bounds if neccecary. if (viewNorth > boxNorth) { viewSouth -= viewNorth - boxNorth; viewNorth = boxNorth; } if (viewEast > boxEast) { viewWest -= viewEast - boxEast; viewEast = boxEast; } if (viewSouth < boxSouth) { viewNorth += boxSouth - viewSouth; viewSouth = boxSouth; } if (viewWest < boxWest) { viewEast += boxWest - viewWest; viewWest = boxWest; } // Compute and return corrected map center return(new GeoCoordinate(viewSouth + (viewNorth - viewSouth) / 2.0f, viewWest + (viewEast - viewWest) / 2.0f)); }
/// <summary> /// Creates a new instruction with a location and points of interest. /// </summary> /// <param name="location"></param> /// <param name="pois"></param> public Instruction(GeoCoordinateBox location, List<PointPoi> pois) { this.Location = location; this.Pois = pois; }
/// <summary> /// Generates an instruction from the given meta data and given pois. /// </summary> /// <param name="metaData"></param> /// <param name="segmentIdx"></param> /// <param name="box"></param> /// <param name="pois"></param> internal void GenerateInstruction(Dictionary <string, object> metaData, int segmentIdx, GeoCoordinateBox box, List <PointPoi> pois) { string text; if (_generator.Generate(metaData, out text)) { // add the instruction to the instructions list. _instructions.Add(new Instruction(metaData, segmentIdx, box, text, pois)); } }
/// <summary> /// Returns true if this geometry is inside the given bounding box. /// </summary> /// <param name="box"></param> /// <returns></returns> public abstract bool IsInside(GeoCoordinateBox box);
public IList<IElement> GetElements(GeoCoordinateBox box, double zoom_factor) { zoom_factor = zoom_factor + _zoom_offset; if (zoom_factor > _max_zoom) { zoom_factor = _max_zoom; } else if (zoom_factor < _min_zoom) { zoom_factor = _min_zoom; } return this.GetTiles(box, zoom_factor); }
public override void Succes() { // get the last arc and the last point. AggregatedArc latest_arc = (this.FinalMessages[this.FinalMessages.Count - 2] as MicroPlannerMessageArc).Arc; AggregatedPoint latest_point = (this.FinalMessages[this.FinalMessages.Count - 1] as MicroPlannerMessagePoint).Point; // count the number of streets in the same turning direction as the turn // that was found. int count = 0; if (MicroPlannerHelper.IsLeft(latest_point.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetLeft(this.FinalMessages, this.Planner.Interpreter); } else if (MicroPlannerHelper.IsRight(latest_point.Angle.Direction, this.Planner.Interpreter)) { count = MicroPlannerHelper.GetRight(this.FinalMessages, this.Planner.Interpreter); } // construct the box indicating the location of the resulting find by this machine. GeoCoordinate point1 = latest_point.Location; GeoCoordinateBox box = new GeoCoordinateBox( new GeoCoordinate(point1.Latitude - 0.001f, point1.Longitude - 0.001f), new GeoCoordinate(point1.Latitude + 0.001f, point1.Longitude + 0.001f)); //string next_street = latest_point.Next.Name; // let the scentence planner generate the correct information. this.Planner.SentencePlanner.GenerateRoundabout(box, count - 1, latest_point.Next.Tags); }
/// <summary> /// Returns all the tile filling the given bounding box. /// </summary> /// <param name="bbox"></param> /// <param name="zoom_factor"></param> /// <returns></returns> public IList<IElement> GetTiles(GeoCoordinateBox bbox, double zoom_factor) { int zoom = (int)System.Math.Floor(zoom_factor); TileRange range = this.GetTileToLoadFor(bbox, zoom); IList<IElement> return_list = new List<IElement>(); double tile_size = 360.0f / (double)(System.Math.Pow(2, zoom)); for (int x = range.XMin; x < range.XMax + 1; x++) { for (int y = range.YMin; y < range.YMax + 1; y++) { IElement new_tile = this.GetTile(x, y, zoom); if (new_tile != null) { return_list.Add(new_tile); } } } return return_list; }
/// <summary> /// Returns all data within the given bounding box and filtered by the given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public override IList <OsmGeo> Get(GeoCoordinateBox box, OsmSharp.Osm.Filters.Filter filter) { // initialize connection. NpgsqlConnection con = this.CreateConnection(); List <OsmGeo> res = new List <OsmGeo>(); // calculate bounding box parameters to query db. long latitude_min = (long)(box.MinLat * 10000000.0); long longitude_min = (long)(box.MinLon * 10000000.0); long latitude_max = (long)(box.MaxLat * 10000000.0); long longitude_max = (long)(box.MaxLon * 10000000.0); // calculate bounding box parameters to query db. TileRange range = TileRange.CreateAroundBoundingBox(box, 14); IList <long> boxes = new List <long>(); foreach (Tile tile in range) { boxes.Add((long)tile.Id); } // STEP 1: query nodes table. //id latitude longitude changeset_id visible timestamp tile version string sql = "SELECT id, latitude, longitude, changeset_id, visible, timestamp, tile, version, usr, usr_id FROM node WHERE (visible = true) AND (tile IN ({4})) AND (latitude >= {0} AND latitude < {1} AND longitude >= {2} AND longitude < {3})"; sql = string.Format(sql, latitude_min.ToString(), latitude_max.ToString(), longitude_min.ToString(), longitude_max.ToString(), this.ConstructIdList(boxes)); // TODO: parameters. NpgsqlCommand com = new NpgsqlCommand(sql); com.Connection = con; NpgsqlDataReader reader = com.ExecuteReader(); Node node = null; Dictionary <long, Node> nodes = new Dictionary <long, Node>(); List <long> nodeIds = new List <long>(); while (reader.Read()) { // load/parse data. long returned_id = reader.GetInt64(0); int latitude_int = reader.GetInt32(1); int longitude_int = reader.GetInt32(2); long? changeset_id = reader.IsDBNull(3) ? null : (long?)reader.GetInt64(3); bool? visible = reader.IsDBNull(4) ? null : (bool?)reader.GetBoolean(4); DateTime?timestamp = reader.IsDBNull(5) ? null : (DateTime?)reader.GetDateTime(5); long tile = reader.GetInt64(6); ulong? version = reader.IsDBNull(7) ? null : (ulong?)reader.GetInt32(7); string usr = reader.IsDBNull(8) ? null : reader.GetString(8); long? usr_id = reader.IsDBNull(9) ? null : (long?)reader.GetInt32(9); if (!nodes.ContainsKey(returned_id)) { // create node. node = new Node(); node.Id = returned_id; node.Version = version; node.UserId = usr_id; node.UserName = usr; node.TimeStamp = timestamp; node.ChangeSetId = changeset_id; node.Latitude = ((double)latitude_int) / 10000000.0; node.Longitude = ((double)longitude_int) / 10000000.0; node.Visible = visible; nodes.Add(node.Id.Value, node); nodeIds.Add(node.Id.Value); } } reader.Close(); // STEP2: Load all node tags. this.LoadNodeTags(nodes); res.AddRange(nodes.Values); // load all ways that contain the nodes that have been found. res.AddRange(this.GetWaysFor(nodeIds)); // get relations containing any of the nodes or ways in the current results-list. List <Relation> relations = new List <Relation>(); HashSet <long> relationIds = new HashSet <long>(); foreach (OsmGeo osmGeo in res) { IList <Relation> relationsFor = this.GetRelationsFor(osmGeo); foreach (Relation relation in relationsFor) { if (!relationIds.Contains(relation.Id.Value)) { relations.Add(relation); relationIds.Add(relation.Id.Value); } } } // recursively add all relations containing other relations as a member. do { res.AddRange(relations); // add previous relations-list. List <Relation> newRelations = new List <Relation>(); foreach (OsmGeo osmGeo in relations) { IList <Relation> relationsFor = this.GetRelationsFor(osmGeo); foreach (Relation relation in relationsFor) { if (!relationIds.Contains(relation.Id.Value)) { newRelations.Add(relation); relationIds.Add(relation.Id.Value); } } } relations = newRelations; } while (relations.Count > 0); if (filter != null) { var filtered = new List <OsmGeo>(); foreach (OsmGeo geo in res) { if (filter.Evaluate(geo)) { filtered.Add(geo); } } return(filtered); } return(res); }
public override bool IsVisibleIn(GeoCoordinateBox box) { return box.IsInside(_dot.Point); }
/// <summary> /// Returns all data in this source for the given bounding box. /// </summary> /// <param name="box"></param> /// <returns></returns> public DataProcessorSource Get(GeoCoordinateBox box) { return new OsmGeoListDataProcessorSource( _dataSourceReadOnly.Get(box, null)); }
/// <summary> /// Creates a new osm edge data processing target. /// </summary> /// <param name="dynamicGraph"></param> /// <param name="interpreter"></param> /// <param name="tagsIndex"></param> /// <param name="box"></param> public LiveGraphOsmStreamTarget(IDynamicGraphRouterDataSource <LiveEdge> dynamicGraph, IOsmRoutingInterpreter interpreter, ITagsIndex tagsIndex, GeoCoordinateBox box) : this(dynamicGraph, interpreter, tagsIndex, new Dictionary <long, uint>(), box, null) { }
public void Scene2DSimpleSerializeDeserializeTest() { // create the MapCSS image source. var imageSource = new MapCSSDictionaryImageSource(); // load mapcss style interpreter. var mapCSSInterpreter = new MapCSSInterpreter( Assembly.GetExecutingAssembly().GetManifestResourceStream( "OsmSharp.UI.Test.Unittests.Data.MapCSS.test.mapcss"), imageSource); // initialize the data source. var xmlSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream( "OsmSharp.UI.Test.Unittests.Data.test.osm")); IEnumerable <OsmGeo> dataSource = xmlSource; MemoryDataSource source = MemoryDataSource.CreateFrom(xmlSource); // get data. var scene = new Scene2DSimple(); var projection = new WebMercator(); GeoCoordinateBox box = null; foreach (var osmGeo in dataSource) { CompleteOsmGeo completeOsmGeo = null; switch (osmGeo.Type) { case OsmGeoType.Node: completeOsmGeo = CompleteNode.CreateFrom(osmGeo as Node); break; case OsmGeoType.Way: completeOsmGeo = CompleteWay.CreateFrom(osmGeo as Way, source); break; case OsmGeoType.Relation: completeOsmGeo = CompleteRelation.CreateFrom(osmGeo as Relation, source); break; } // update box. if (completeOsmGeo != null) { if (box == null) { box = completeOsmGeo.BoundingBox; } else if (completeOsmGeo.BoundingBox != null) { box = box + completeOsmGeo.BoundingBox; } } // translate each object into scene object. mapCSSInterpreter.Translate(scene, projection, source, osmGeo as OsmGeo); } // create the stream. var stream = new MemoryStream(); scene.Serialize(stream, false); // deserialize the stream. IScene2DPrimitivesSource sceneSource = Scene2DSimple.Deserialize(stream, false); if (box != null) { // query both and get the same results. int counter = 100; var rand = new Random(); while (counter > 0) { var queryBox = new GeoCoordinateBox( box.GenerateRandomIn(rand), box.GenerateRandomIn(rand)); var zoomFactor = (float)projection.ToZoomFactor(15); View2D testView = View2D.CreateFromBounds( projection.LatitudeToY(queryBox.MaxLat), projection.LongitudeToX(queryBox.MinLon), projection.LatitudeToY(queryBox.MinLat), projection.LongitudeToX(queryBox.MaxLon)); var testScene = new Scene2DSimple(); sceneSource.Get(testScene, testView, zoomFactor); // var resultIndex = new HashSet<Scene2DPrimitive>(testScene.Get(testView, zoomFactor)); // var resultReference = new HashSet<Scene2DPrimitive>(scene.Get(testView, zoomFactor)); //Assert.AreEqual(resultReference.Count, resultIndex.Count); //foreach (var data in resultIndex) //{ // Assert.IsTrue(resultReference.Contains(data)); //} //foreach (var data in resultReference) //{ // Assert.IsTrue(resultIndex.Contains(data)); //} counter--; } } }
public override bool IsVisibleIn(GeoCoordinateBox box) { return box.IsInside(_center); }