/// <summary> /// Creates a new router point. /// </summary> /// <param name="id"></param> /// <param name="vehicle"></param> /// <param name="location"></param> public RouterPoint(long id, Vehicle vehicle, GeoCoordinate location) { _id = id; this.Location = location; this.Vehicle = vehicle; this.Tags = new List<KeyValuePair<string, string>>(); }
/// <summary> /// Builds a dummy route (as the crow flies) for segments of a route not found. /// </summary> /// <returns></returns> public virtual Route BuildDummyRoute(Vehicle vehicle, GeoCoordinate coordinate1, GeoCoordinate coordinate2) { var route = new Route(); route.Vehicle = vehicle.UniqueName; var segments = new RouteSegment[2]; segments[0] = new RouteSegment(); segments[0].Distance = 0; segments[0].Time = 0; segments[0].Type = RouteSegmentType.Start; segments[0].Vehicle = vehicle.UniqueName; segments[0].Latitude = (float)coordinate1.Latitude; segments[0].Longitude = (float)coordinate1.Longitude; var distance = coordinate1.DistanceReal(coordinate2).Value; var timeEstimage = distance / (vehicle.MaxSpeed().Value) * 3.6; var tags = new TagsCollection(); tags.Add("route", "not_found"); segments[1] = new RouteSegment(); segments[1].Distance = distance; segments[1].Time = timeEstimage; segments[1].Type = RouteSegmentType.Stop; segments[1].Vehicle = vehicle.UniqueName; segments[1].Latitude = (float)coordinate2.Latitude; segments[1].Longitude = (float)coordinate2.Longitude; segments[1].Tags = RouteTagsExtensions.ConvertFrom(tags); route.Segments = segments; return route; }
/// <summary> /// Compares the two given routes. /// </summary> /// <param name="reference"></param> /// <param name="route"></param> protected void CompareRoutes(Route reference, Route route) { double delta = 0.0001; if (reference.Segments == null) { // both routes are empty. Assert.IsNull(route.Segments); } else { // compare the geometry of the routes. for (int idx = 0; idx < reference.Segments.Length; idx++) { var referenceCoordinate = new GeoCoordinate(reference.Segments[idx].Latitude, reference.Segments[idx].Longitude); Meter referenceDistance, distance; GeoCoordinate referenceProjected, projected; Second referenceTime, time; reference.ProjectOn(referenceCoordinate, out referenceProjected, out referenceDistance, out referenceTime); route.ProjectOn(referenceCoordinate, out projected, out distance, out time); Assert.AreEqual(0, referenceProjected.DistanceReal(projected).Value, delta); // projected points have to match. Assert.AreEqual(referenceDistance.Value, distance.Value, 0.1); // compare calculated distance to 10cm accuracy. Assert.AreEqual(referenceProjected.Latitude, projected.Latitude, delta); Assert.AreEqual(referenceProjected.Longitude, projected.Longitude, delta); } } }
public void RoutingRegressionTest1() { var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, interpreter, tagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_routing_regression1.osm")); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); var basicRouter = new Dykstra(); var router = Router.CreateLiveFrom(memoryData, basicRouter, interpreter); // resolve the three points in question. var point35 = new GeoCoordinate(51.01257, 4.000753); var point35resolved = router.Resolve(Vehicle.Car, point35); var point45 = new GeoCoordinate(51.01315, 3.999588); var point45resolved = router.Resolve(Vehicle.Car, point45); // route between 35 and 45. var routebefore = router.Calculate(Vehicle.Car, point35resolved, point45resolved); // route between 35 and 45. var routeafter = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Assert.AreEqual(routebefore.TotalDistance, routeafter.TotalDistance); }
/// <summary> /// Adds a line. /// </summary> public void AddLine(GeoCoordinate point1, GeoCoordinate point2, float sizePixels, int color) { if (point1 == null) { throw new ArgumentNullException(); } if (point2 == null) { throw new ArgumentNullException(); } // update envelope. if (_envelope == null) { // create initial envelope. _envelope = new GeoCoordinateBox(point1, point2); } // also include the current point. _envelope.ExpandWith(point1); _envelope.ExpandWith(point2); var projected1 = _projection.ToPixel(point1); var projected2 = _projection.ToPixel(point2); var x = new double[] { projected1[0], projected2[0] }; var y = new double[] { projected1[1], projected2[1] }; uint? pointsId = _scene.AddPoints(x, y); if (pointsId.HasValue) { _scene.AddStyleLine(pointsId.Value, 0, float.MinValue, float.MaxValue, color, sizePixels, Renderer.Primitives.LineJoin.Round, null); this.RaiseLayerChanged(); } }
public void TestGeoCoordinateOffsetWithDirection() { var distance = 1000; // 1km var start = new GeoCoordinate(53.32056, 1.72972); var offset = start.OffsetWithDirection(distance, DirectionEnum.North); Assert.AreEqual(53.32950, offset.Latitude, 0.0001); Assert.AreEqual(1.72970, offset.Longitude, 0.0001); offset = start.OffsetWithDirection(distance, DirectionEnum.NorthEast); Assert.AreEqual(53.32690, offset.Latitude, 0.0001); Assert.AreEqual(1.74040, offset.Longitude, 0.0001); start = new GeoCoordinate(0, 0); offset = start.OffsetWithDirection(distance, DirectionEnum.West); Assert.AreEqual(0, offset.Latitude, 0.0001); Assert.AreEqual(-0.008984, offset.Longitude, 0.0001); offset = start.OffsetWithDirection(distance, DirectionEnum.East); Assert.AreEqual(0, offset.Latitude, 0.0001); Assert.AreEqual(0.008984, offset.Longitude, 0.0001); offset = start.OffsetWithDirection(distance, DirectionEnum.North); Assert.AreEqual(0.008896, offset.Latitude, 0.0001); Assert.AreEqual(0, offset.Longitude, 0.0001); offset = start.OffsetWithDirection(distance, DirectionEnum.South); Assert.AreEqual(-0.008896, offset.Latitude, 0.0001); Assert.AreEqual(0, offset.Longitude, 0.0001); }
/// <summary> /// Creates a geo coordinate line. /// </summary> /// <param name="point1"></param> /// <param name="point2"></param> /// <param name="is_segment1"></param> /// <param name="is_segment2"></param> public GeoCoordinateLine( GeoCoordinate point1, GeoCoordinate point2, bool is_segment1, bool is_segment2) : base(point1, point2, is_segment1, is_segment2) { }
/// <summary> /// Returns true if the given coordinate is contained in this ring. /// /// See: http://geomalgorithms.com/a03-_inclusion.html /// </summary> /// <param name="coordinate"></param> /// <returns></returns> public bool Contains(GeoCoordinate coordinate) { int number = 0; if (this.Coordinates[0] == coordinate) { // the given point is one of the corners. return true; } // loop over all edges and calculate if they possibly intersect. for (int idx = 0; idx < this.Coordinates.Count - 1; idx++) { if (this.Coordinates[idx + 1] == coordinate) { // the given point is one of the corners. return true; } bool idxRight = this.Coordinates[idx].Longitude > coordinate.Longitude; bool idx1Right = this.Coordinates[idx + 1].Longitude > coordinate.Longitude; if (idxRight || idx1Right) { // at least on of the coordinates is to the right of the point to calculate for. if ((this.Coordinates[idx].Latitude <= coordinate.Latitude && this.Coordinates[idx + 1].Latitude >= coordinate.Latitude) && !(this.Coordinates[idx].Latitude == coordinate.Latitude && this.Coordinates[idx + 1].Latitude == coordinate.Latitude)) { // idx is lower than idx+1 if (idxRight && idx1Right) { // no need for the left/right algorithm the result is already known. number++; } else { // one of the coordinates is not to the 'right' now we need the left/right algorithm. LineF2D localLine = new LineF2D(this.Coordinates[idx], this.Coordinates[idx + 1]); if (localLine.PositionOfPoint(coordinate) == LinePointPosition.Left) { number++; } } } else if ((this.Coordinates[idx].Latitude >= coordinate.Latitude && this.Coordinates[idx + 1].Latitude <= coordinate.Latitude) && !(this.Coordinates[idx].Latitude == coordinate.Latitude && this.Coordinates[idx + 1].Latitude == coordinate.Latitude)) { // idx is higher than idx+1 if (idxRight && idx1Right) { // no need for the left/right algorithm the result is already known. number--; } else { // one of the coordinates is not to the 'right' now we need the left/right algorithm. LineF2D localLine = new LineF2D(this.Coordinates[idx], this.Coordinates[idx + 1]); if (localLine.PositionOfPoint(coordinate) == LinePointPosition.Right) { number--; } } } } } return number != 0; }
/// <summary> /// Calculates a solution to the ATSP. /// </summary> /// <param name="weights">The weights between all the customers.</param> /// <param name="locations">The locations of all customers.</param> /// <param name="first">The first customer.</param> /// <param name="is_round">Return to the first customer or not.</param> /// <returns></returns> public IRoute CalculateTSP(double[][] weights, GeoCoordinate[] locations, int first, bool is_round) { // create solver. ISolver solver = this.DoCreateSolver(locations.Length); solver.IntermidiateResult += new SolverDelegates.IntermidiateDelegate(solver_IntermidiateResult); // calculate the TSP. return solver.Solve(this.GenerateProblem(weights, first, null, is_round)); }
/// <summary> /// Initializes a new instance of the <see cref="SomeTestProject.MapMarker"/> class. /// </summary> /// <param name="location">Coordinate.</param> /// <param name="image">Bitmap.</param> /// <param name="alignment">Alignment.</param> public MapMarker(GeoCoordinate location, MapMarkerAlignmentType alignment, UIImage image) : base(UIButtonType.Custom){ _image = image; this.Location = location; _alignment = alignment; this.Frame = new System.Drawing.RectangleF (new System.Drawing.PointF (0, 0), image.Size); this.SetImage (image, UIControlState.Normal); this.SetImage (image, UIControlState.Highlighted); this.SetImage (image, UIControlState.Disabled); }
public void TestGeoCoordinateOffsetRandom() { var generator = new OsmSharp.Math.Random.RandomGenerator(10124613); for(int idx = 0; idx < 1000; idx++) { GeoCoordinate start = new GeoCoordinate(51, 4.8); GeoCoordinate offset = start.OffsetRandom(generator, 20); double distance = offset.DistanceReal(start).Value; Assert.IsTrue(distance <= 20.001); } }
/// <summary> /// Adds a line. /// </summary> /// <param name="point1"></param> /// <param name="point2"></param> /// <param name="sizePixels"></param> /// <param name="color"></param> /// <returns></returns> public void AddLine(GeoCoordinate point1, GeoCoordinate point2, float sizePixels, int color) { double[] projected1 = _projection.ToPixel(point1); double[] projected2 = _projection.ToPixel(point2); double[] x = new double[] { projected1[0], projected2[0] }; double[] y = new double[] { projected1[1], projected2[1] }; uint? pointsId = _scene.AddPoints(x, y); if (pointsId.HasValue) { _scene.AddStyleLine(pointsId.Value, 0, float.MinValue, float.MaxValue, color, sizePixels, Renderer.Primitives.LineJoin.Round, null); this.RaiseLayerChanged(); } }
public override Tuple<string, double[][]>[] GetMatrix(Vehicle vehicle, GeoCoordinate[] source, GeoCoordinate[] target, string[] outputs, out Tuple<string, int, string>[] errors) { var errorsList = new List<Tuple<string, int, string>>(); for (var i = 0; i < source.Length; i++) { if (source[i] == null || source[i].Latitude > 180) { // dummy incorrect coordinates had a lat bigger than 180. errorsList.Add(new Tuple<string, int, string>("source", i, "Coordinate invalid.")); source[i] = null; } } for (var i = 0; i < target.Length; i++) { if (target[i] == null || target[i].Latitude > 180) { // dummy incorrect coordinates had a lat bigger than 180. errorsList.Add(new Tuple<string, int, string>("target", i, "Coordinate invalid.")); target[i] = null; } } errors = errorsList.ToArray(); // remove invalid coordinates. var sourceList = new List<GeoCoordinate>(source); sourceList.RemoveAll(x => x == null); source = sourceList.ToArray(); var targetList = new List<GeoCoordinate>(target); targetList.RemoveAll(x => x == null); target = targetList.ToArray(); // build a dummy response. var matrices = new Tuple<string, double[][]>[outputs.Length]; for (var i = 0; i < outputs.Length; i++) { var weights = new double[source.Length][]; for (var x = 0; x < weights.Length; x++) { weights[x] = new double[target.Length]; for (var y = 0; y < target.Length; y++) { weights[x][y] = 100; } } matrices[i] = new Tuple<string, double[][]>(outputs[i], weights); } return matrices; }
/// <summary> /// Handles the tap event. /// </summary> /// <param name="coordinate"></param> async void _mapView_MapTapEvent(GeoCoordinate coordinate) { if (_previous != null) { var route = RouterFacade.Calculate(_previous, coordinate); _routeLayer.Clear(); if (route != null) { _routeLayer.AddRoute(route); // TODO: issue #120. (_mapView as IMapView).Invalidate(); } } _previous = coordinate; }
public void TestGeoCoordinateOffsetEstimate() { GeoCoordinate coord1 = new GeoCoordinate(51, 4.8); Meter distance = 10000; GeoCoordinate coord3 = coord1.OffsetWithDistances(distance); GeoCoordinate coord3_lat = new GeoCoordinate(coord3.Latitude, coord1.Longitude); GeoCoordinate coord3_lon = new GeoCoordinate(coord1.Latitude, coord3.Longitude); Meter distance_lat = coord3_lat.DistanceReal(coord1); Meter distance_lon = coord3_lon.DistanceReal(coord1); Assert.AreEqual(distance.Value, distance_lat.Value, 0.001); Assert.AreEqual(distance.Value, distance_lon.Value, 0.001); }
/// <summary> /// Calculate a simple route. /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> public static async Task<Route> Calculate(GeoCoordinate from, GeoCoordinate to) { // REMARK1: this sample needs ServiceStack.Client.Pcl // REMARK2: this sample could need a fix for a bug related to System.IO.Compression: https://github.com/ServiceStack/Hello#issues // REMARK3: to have a strongly type client to the OsmSharp.Service.Routing service the package OsmSharp.Service.Routing needs to be installed. try { // create Json client. var client = new JsonServiceClient("http://build.osmsharp.com:666/"); client.Timeout = new TimeSpan(0, 5, 0); // creates the array of the routing hook. var hooks = new RoutingHook[2]; // create the array of geocoordinates. hooks[0] = new RoutingHook() { Id = 0, Latitude = (float)from.Latitude, Longitude = (float)from.Longitude, Tags = new RoutingHookTag[0] }; hooks[1] = new RoutingHook() { Id = 1, Latitude = (float)to.Latitude, Longitude = (float)to.Longitude, Tags = new RoutingHookTag[0] }; // set the request. var routingResponse = client.Get<RoutingResponse>( new RoutingOperation() { Vehicle = Vehicle.Car.UniqueName, Hooks = hooks, Type = RoutingOperationType.Regular }); return routingResponse.Route; } catch(Exception ex) { OsmSharp.Logging.Log.TraceEvent("Router", OsmSharp.Logging.TraceEventType.Critical, "Unhandled exception occured: {0}", ex.ToString()); } return null; }
/// <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> /// Calculates a number of routes from one source to many targets. /// </summary> /// <param name="vehicle"></param> /// <param name="coordinates"></param> /// <param name="complete"></param> public override Route[] GetOneToMany(Vehicle vehicle, GeoCoordinate[] coordinates, bool complete) { // resolve all points. var resolved = _router.Resolve(vehicle, coordinates); // calculate one-to-many routes. if (resolved[0] != null) { var targets = new List<RouterPoint>(); foreach(var point in resolved) { if (point != null) { targets.Add(point); } } return _router.CalculateOneToMany(vehicle, resolved[0], targets.ToArray()); } return new Route[coordinates.Length - 1]; }
public void TestLineairRingContainsPoint() { LineairRing ring = new LineairRing(new GeoCoordinate(0, 0), new GeoCoordinate(3, 0), new GeoCoordinate(0, 3), new GeoCoordinate(0, 0)); foreach (GeoCoordinate ringCoordinate in ring.Coordinates) { Assert.IsTrue(ring.Contains(ringCoordinate)); } GeoCoordinate coordinate = new GeoCoordinate(1, 1); Assert.IsTrue(ring.Contains(coordinate)); coordinate = new GeoCoordinate(2, 2); Assert.IsFalse(ring.Contains(coordinate)); coordinate = new GeoCoordinate(-1, 1); Assert.IsFalse(ring.Contains(coordinate)); coordinate = new GeoCoordinate(0, 1); Assert.IsTrue(ring.Contains(coordinate)); coordinate = new GeoCoordinate(1, 0); Assert.IsTrue(ring.Contains(coordinate)); }
public void RoutingRegressionTest1() { OsmRoutingInterpreter interpreter = new OsmRoutingInterpreter(); SimpleTagsIndex tags_index = new SimpleTagsIndex(); // do the data processing. DynamicGraphRouterDataSource<LiveEdge> memory_data = new DynamicGraphRouterDataSource<LiveEdge>(tags_index); LiveGraphOsmStreamTarget target_data = new LiveGraphOsmStreamTarget( memory_data, interpreter, memory_data.TagsIndex); XmlOsmStreamSource data_processor_source = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_routing_regression1.osm")); OsmStreamFilterSort sorter = new OsmStreamFilterSort(); sorter.RegisterSource(data_processor_source); target_data.RegisterSource(sorter); target_data.Pull(); IBasicRouter<LiveEdge> basic_router = new DykstraRoutingLive(memory_data.TagsIndex); Router router = Router.CreateLiveFrom(memory_data, basic_router, interpreter); // resolve the three points in question. GeoCoordinate point35 = new GeoCoordinate(51.01257, 4.000753); RouterPoint point35resolved = router.Resolve(Vehicle.Car, point35); // GeoCoordinate point40 = new GeoCoordinate(51.01250, 4.000013); // RouterPoint point40resolved = router.Resolve(Vehicle.Car, point40); GeoCoordinate point45 = new GeoCoordinate(51.01315, 3.999588); RouterPoint point45resolved = router.Resolve(Vehicle.Car, point45); // route between 35 and 45. Route routebefore = router.Calculate(Vehicle.Car, point35resolved, point45resolved); // GeoCoordinate point129 = new GeoCoordinate(51.01239, 3.999573); // RouterPoint point129resolved = router.Resolve(Vehicle.Car, point129); // route between 35 and 45. Route routeafter = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Assert.AreEqual(routebefore.TotalDistance, routeafter.TotalDistance); }
/// <summary> /// Returns true if the given coordinate is contained in the inner area of the ring or lying on the border of the ring. /// Fast way based on the winding number aproach. /// </summary> /// <param name="coordinate"></param> /// <returns></returns> public bool Contains(GeoCoordinate coordinate) { bool flipflop = false; const bool includeBorder = true; // Algoritm could be parameterized to optionally include the border. for (int i = 0, j = Coordinates.Count - 1; i < Coordinates.Count; j = i++) { if (Coordinates[j].Equals(coordinate)) return includeBorder; bool b = Coordinates[i].Latitude <= coordinate.Latitude; if (b != (Coordinates[j].Latitude <= coordinate.Latitude)) { var triangularOrientation = (Coordinates[j].Longitude - Coordinates[i].Longitude) * (coordinate.Latitude - Coordinates[i].Latitude) - (Coordinates[j].Latitude - Coordinates[i].Latitude) * (coordinate.Longitude - Coordinates[i].Longitude); if (triangularOrientation > 0 && b || triangularOrientation < 0 && !b) flipflop = !flipflop; else if (triangularOrientation == 0) return includeBorder; } } return flipflop; }
/// <summary> /// Adds a new entry. /// </summary> /// <param name="country"></param> /// <param name="postalCode"></param> /// <param name="commune"></param> /// <param name="street"></param> /// <param name="houseNumber"></param> /// <param name="value"></param> public void Add(string country, string postalCode, string commune, string street, string houseNumber, GeoCoordinate value) { IndexCommunes communes = _index.SearchExact(postalCode); if (communes == null) { communes = new IndexCommunes(); _index.Add(postalCode, communes); } IndexStreets streets = communes.SearchExact(commune); if (streets == null) { streets = new IndexStreets(); communes.Add(commune, streets); } IndexHouseNumbers numbers = streets.SearchExact(street); if (numbers == null) { numbers = new IndexHouseNumbers(); streets.Add(street, numbers); } numbers.Add(houseNumber, value); }
/// <summary> /// Calculate a simple route. /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> public static Route Calculate(GeoCoordinate from, GeoCoordinate to) { try { lock(_graph) { var router = Router.CreateCHFrom(_graph, new CHRouter(), new OsmRoutingInterpreter()); var fromResolved = router.Resolve(Vehicle.Car, from); var toResolved = router.Resolve(Vehicle.Car, to); if(fromResolved != null && toResolved !=null) { return router.Calculate(Vehicle.Car, fromResolved, toResolved); } } } catch(Exception ex) { OsmSharp.Logging.Log.TraceEvent("Router", OsmSharp.Logging.TraceEventType.Critical, "Unhandled exception occured: {0}", ex.ToString()); } return null; }
public void TestSimpleWebMercator() { // TODO: stabalize the webmercator projection numerically for lower zoom levels (0-9). var mercator = new WebMercator(); for (int zoomLevel = 10; zoomLevel <= 25; zoomLevel++) { var tile = Tile.CreateAroundLocation(new GeoCoordinate(0, 0), zoomLevel); var topleft = mercator.ToPixel(tile.Box.TopLeft); var bottomright = mercator.ToPixel(tile.Box.BottomRight); var scaleFactor = mercator.ToZoomFactor(zoomLevel); Assert.AreEqual(-256, (topleft[0] - bottomright[0]) * scaleFactor, 0.01); Assert.AreEqual(-256, (topleft[1] - bottomright[1]) * scaleFactor, 0.01); } var coordinate = new GeoCoordinate(51.26337, 4.78739); var projected = mercator.ToPixel(coordinate); var reProjected = mercator.ToGeoCoordinates(projected[0], projected[1]); Assert.AreEqual(coordinate.Longitude, reProjected.Longitude, 0.0001); Assert.AreEqual(coordinate.Latitude, reProjected.Latitude, 0.0001); }
/// <summary> /// Sets the map view. /// </summary> /// <param name="center">Center.</param> /// <param name="mapTilt">Map tilt.</param> /// <param name="mapZoom">Map zoom.</param> void IMapView.SetMapView(GeoCoordinate center, Degree mapTilt, float mapZoom) { _mapView.SetMapView(center, mapTilt, mapZoom); }
/// <summary> /// Adds the marker. /// </summary> /// <returns>The marker.</returns> /// <param name="location">Coordinate.</param> public MapMarker AddMarker(GeoCoordinate location) { if (location == null) { throw new ArgumentNullException("location"); } ; var marker = new MapMarker(this.Context, location); this.AddMarker(marker); return marker; }
/// <summary> /// Raises the map tap event. /// </summary> /// <param name="coordinate"></param> internal void RaiseMapTapEvent(GeoCoordinate coordinate) { if (this.MapTapEvent != null) { this.MapTapEvent(coordinate); } this.NotifyMapTapToControls(); }
/// <summary> /// Called when the view on the map has changed. /// </summary> /// <param name="map"></param> /// <param name="zoomFactor"></param> /// <param name="center"></param> /// <param name="view"></param> /// <param name="extraView"></param> protected internal override void ViewChanged(Map map, float zoomFactor, GeoCoordinate center, View2D view, View2D extraView) { // all data is preloaded for now. // when displaying huge amounts of GPX-data use another approach. }
/// <summary> /// Adds a polyline. /// </summary> /// <param name="points"></param> /// <param name="sizePixels"></param> /// <param name="color"></param> /// <returns></returns> public void AddPolyline(GeoCoordinate[] points, float sizePixels, int color) { var x = new double[points.Length]; var y = new double[points.Length]; for(int idx = 0; idx < points.Length; idx++) { // update envelope. if (_envelope == null) { // create initial envelope. _envelope = new GeoCoordinateBox(points[idx], points[idx]); } // also include the current point. _envelope.ExpandWith(points[idx]); var projected =_projection.ToPixel(points[idx]); x[idx] = projected[0]; y[idx] = projected[1]; } uint? pointsId = _scene.AddPoints(x, y); if (pointsId.HasValue) { _scene.AddStyleLine(pointsId.Value, 0, float.MinValue, float.MaxValue, color, sizePixels, Renderer.Primitives.LineJoin.Round, null); this.RaiseLayerChanged(); } }
/// <summary> /// Adds a polyline. /// </summary> /// <param name="points"></param> /// <param name="color"></param> /// <param name="width"></param> /// <param name="fill"></param> /// <returns></returns> public void AddPolygon(GeoCoordinate[] points, int color, float width, bool fill) { var x = new double[points.Length]; var y = new double[points.Length]; for (int idx = 0; idx < points.Length; idx++) { // update envelope. if (_envelope == null) { // create initial envelope. _envelope = new GeoCoordinateBox(points[idx], points[idx]); } // also include the current point. _envelope.ExpandWith(points[idx]); var projected = _projection.ToPixel(points[idx]); x[idx] = projected[0]; y[idx] = projected[1]; } var pointsId = _scene.AddPoints(x, y); if (pointsId.HasValue) { _scene.AddStylePolygon(pointsId.Value, 0, float.MinValue, float.MaxValue, color, width, fill); this.RaiseLayerChanged(); } }
public static double DistanceEstimateInMeter(ICoordinate location1, ICoordinate location2) { return(GeoCoordinate.DistanceEstimateInMeter((double)location1.Latitude, (double)location1.Longitude, (double)location2.Latitude, (double)location2.Longitude)); }
/// <summary> /// Creates a geo coordinate line. /// </summary> /// <param name="point1"></param> /// <param name="point2"></param> public GeoCoordinateLine( GeoCoordinate point1, GeoCoordinate point2) : base(point1, point2) { }
/// <summary> /// Calculates the distance between this point and the given point. /// </summary> /// <param name="point"></param> /// <returns></returns> public double Distance(GeoCoordinate point) { return(PointF2D.Distance(this, point)); }
public Meter DistanceEstimate(GeoCoordinate point) { return((Meter)GeoCoordinate.DistanceEstimateInMeter(this.Latitude, this.Longitude, point.Latitude, point.Longitude)); }