internal static void RunTest(MapFile mapFile) { int tileX = MercatorProjection.LongitudeToTileX(0, ZOOM_LEVEL); int tileY = MercatorProjection.LatitudeToTileY(0, ZOOM_LEVEL); Tile tile = new Tile(tileX, tileY, ZOOM_LEVEL, 256); MapReadResult mapReadResult = mapFile.ReadMapData(tile); mapFile.Close(); Assert.AreEqual(mapReadResult.PointOfInterests.Count, 0); Assert.AreEqual(1, mapReadResult.Ways.Count); LatLong latLong1 = new LatLong(0.0, 0.0, true); LatLong latLong2 = new LatLong(0.0, 0.1, true); LatLong latLong3 = new LatLong(-0.1, 0.1, true); LatLong latLong4 = new LatLong(-0.1, 0.0, true); LatLong[][] latLongsExpected = new LatLong[][] { new LatLong[] { latLong1, latLong2, latLong3, latLong4, latLong1 } }; Way way = mapReadResult.Ways[0]; // TODO: Was ArrayEquals() Assert.AreEqual(latLongsExpected, way.LatLongs); }
/// <summary> /// Converts geographic coordinates to view x/y coordinates in the map view. /// </summary> /// <param name="in"> /// the geographic coordinates </param> /// <returns> x/y view coordinates for the given location </returns> public virtual Point ToPixels(LatLong @in) { if (@in == null || this.mapView.Width <= 0 || this.mapView.Height <= 0) { return(null); } MapPosition mapPosition = this.mapView.Model.mapViewPosition.MapPosition; // this means somehow the mapview is not yet properly set up, see issue #308. if (mapPosition == null) { return(null); } // calculate the pixel coordinates of the top left corner LatLong latLong = mapPosition.LatLong; long mapSize = MercatorProjection.GetMapSize(mapPosition.ZoomLevel, this.mapView.Model.displayModel.TileSize); double pixelX = MercatorProjection.LongitudeToPixelX(latLong.Longitude, mapSize); double pixelY = MercatorProjection.LatitudeToPixelY(latLong.Latitude, mapSize); pixelX -= this.mapView.Width >> 1; pixelY -= this.mapView.Height >> 1; // create a new point and return it return(new Point((int)(MercatorProjection.LongitudeToPixelX(@in.Longitude, mapSize) - pixelX), (int)(MercatorProjection.LatitudeToPixelY(@in.Latitude, mapSize) - pixelY))); }
/// <param name="latLong"> /// the initial geographical coordinates of this marker (may be null). </param> /// <param name="bitmap"> /// the initial {@code IBitmap} of this marker (may be null). </param> /// <param name="horizontalOffset"> /// the horizontal marker offset. </param> /// <param name="verticalOffset"> /// the vertical marker offset. </param> public Marker(LatLong latLong, IBitmap bitmap, int horizontalOffset, int verticalOffset) : base() { this.latLong = latLong; this.bitmap = bitmap; this.horizontalOffset = horizontalOffset; this.verticalOffset = verticalOffset; }
public virtual void FromStringValidTest() { LatLong latLong = LatLongUtils.FromString(LATITUDE + DELIMITER + LONGITUDE); Assert.AreEqual(LATITUDE, latLong.Latitude, 0); Assert.AreEqual(LONGITUDE, latLong.Longitude, 0); }
/// <param name="latLong"> /// the initial center point of this circle (may be null). </param> /// <param name="radius"> /// the initial non-negative radius of this circle in meters. </param> /// <param name="paintFill"> /// the initial {@code Paint} used to fill this circle (may be null). </param> /// <param name="paintStroke"> /// the initial {@code Paint} used to stroke this circle (may be null). </param> /// <param name="keepAligned"> /// if set to true it will keep the bitmap aligned with the map, /// to avoid a moving effect of a bitmap shader. </param> /// <exception cref="IllegalArgumentException"> /// if the given {@code radius} is negative or <seealso cref="Float#NaN"/>. /// </exception> public Circle(LatLong latLong, float radius, IPaint paintFill, IPaint paintStroke, bool keepAligned) : base() { this.keepAligned = keepAligned; this.latLong = latLong; RadiusInternal = radius; this.paintFill = paintFill; this.paintStroke = paintStroke; }
public static Point GetTopLeftPoint(MapPosition mapPosition, Dimension canvasDimension, int tileSize) { LatLong centerPoint = mapPosition.LatLong; int halfCanvasWidth = canvasDimension.Width / 2; int halfCanvasHeight = canvasDimension.Height / 2; long mapSize = MercatorProjection.GetMapSize(mapPosition.ZoomLevel, tileSize); double pixelX = Math.Round(MercatorProjection.LongitudeToPixelX(centerPoint.Longitude, mapSize)); double pixelY = Math.Round(MercatorProjection.LatitudeToPixelY(centerPoint.Latitude, mapSize)); return(new Point((int)pixelX - halfCanvasWidth, (int)pixelY - halfCanvasHeight)); }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { lock (this) { if (this.latLongs.Count < 2 || (this.paintStroke == null && this.paintFill == null)) { return; } IEnumerator <LatLong> iterator = this.latLongs.GetEnumerator(); IPath path = this.graphicFactory.CreatePath(); LatLong latLong = iterator.Current; long mapSize = MercatorProjection.GetMapSize(zoomLevel, displayModel.TileSize); float x = (float)(MercatorProjection.LongitudeToPixelX(latLong.Longitude, mapSize) - topLeftPoint.X); float y = (float)(MercatorProjection.LatitudeToPixelY(latLong.Latitude, mapSize) - topLeftPoint.Y); path.MoveTo(x, y); while (iterator.MoveNext()) { latLong = iterator.Current; x = (float)(MercatorProjection.LongitudeToPixelX(latLong.Longitude, mapSize) - topLeftPoint.X); y = (float)(MercatorProjection.LatitudeToPixelY(latLong.Latitude, mapSize) - topLeftPoint.Y); path.LineTo(x, y); } if (this.paintStroke != null) { if (this.keepAligned) { this.paintStroke.SetBitmapShaderShift = topLeftPoint; } canvas.DrawPath(path, this.paintStroke); } if (this.paintFill != null) { if (this.keepAligned) { this.paintFill.SetBitmapShaderShift = topLeftPoint; } canvas.DrawPath(path, this.paintFill); } } }
private static void AssertLatLongsEquals(LatLong[][] latLongs1, LatLong[][] latLongs2) { Assert.AreEqual(latLongs1.Length, latLongs2.Length); for (int i = 0; i < latLongs1.Length; ++i) { Assert.AreEqual(latLongs1[i].Length, latLongs2[i].Length); for (int j = 0; j < latLongs1[i].Length; ++j) { LatLong latLong1 = latLongs1[i][j]; LatLong latLong2 = latLongs2[i][j]; Assert.AreEqual(latLong1.Latitude, latLong2.Latitude, 0.000001); Assert.AreEqual(latLong1.Longitude, latLong2.Longitude, 0.000001); } } }
private static void CheckWay(Way way) { Assert.AreEqual(4, way.Layer); Assert.Null(way.LabelPosition); LatLong latLong1 = new LatLong(0.00, 0.00, true); LatLong latLong2 = new LatLong(0.04, 0.08, true); LatLong latLong3 = new LatLong(0.08, 0.00, true); LatLong[][] latLongsExpected = new LatLong[][] { new LatLong[] { latLong1, latLong2, latLong3 } }; AssertLatLongsEquals(latLongsExpected, way.LatLongs); Assert.AreEqual(3, way.Tags.Count); Assert.True(way.Tags.Contains(new Tag("highway=motorway"))); Assert.True(way.Tags.Contains(new Tag("name=ÄÖÜ"))); Assert.True(way.Tags.Contains(new Tag("ref=äöü"))); }
public void OnChange() { Dimension mapViewDimension = this.model.mapViewDimension.Dimension; if (mapViewDimension == null) { // at this point map view not visible return; } double overdrawFactor = this.model.frameBufferModel.OverdrawFactor; if (DimensionChangeNeeded(mapViewDimension, overdrawFactor)) { Dimension newDimension = CalculateFrameBufferDimension(mapViewDimension, overdrawFactor); if (!useSquareFrameBuffer || frameBuffer.Dimension == null || newDimension.Width > frameBuffer.Dimension.Width || newDimension.Height > frameBuffer.Dimension.Height) { // new dimensions if we either always reallocate on config change or if new dimension // is larger than the old this.frameBuffer.Dimension = newDimension; } this.lastMapViewDimension = mapViewDimension; this.lastOverdrawFactor = overdrawFactor; } lock (this.model.mapViewPosition) { lock (this.frameBuffer) { // we need resource ordering here to avoid deadlock MapPosition mapPositionFrameBuffer = this.model.frameBufferModel.MapPosition; if (mapPositionFrameBuffer != null) { double scaleFactor = this.model.mapViewPosition.ScaleFactor; LatLong pivot = this.model.mapViewPosition.Pivot; AdjustFrameBufferMatrix(mapPositionFrameBuffer, mapViewDimension, scaleFactor, pivot); } } } }
/// <summary> /// Computes the geographic coordinates of a screen point. /// </summary> /// <returns> the coordinates of the x/y point </returns> public virtual LatLong FromPixels(double x, double y) { if (this.mapView.Width <= 0 || this.mapView.Height <= 0) { return(null); } // this uses the framebuffer position, the mapview position can be out of sync with // what the user sees on the screen if an animation is in progress MapPosition mapPosition = this.mapView.Model.frameBufferModel.MapPosition; // this means somehow the mapview is not yet properly set up, see issue #308. if (mapPosition == null) { return(null); } // calculate the pixel coordinates of the top left corner LatLong latLong = mapPosition.LatLong; long mapSize = MercatorProjection.GetMapSize(mapPosition.ZoomLevel, this.mapView.Model.displayModel.TileSize); double pixelX = MercatorProjection.LongitudeToPixelX(latLong.Longitude, mapSize); double pixelY = MercatorProjection.LatitudeToPixelY(latLong.Latitude, mapSize); pixelX -= this.mapView.Width >> 1; pixelY -= this.mapView.Height >> 1; // catch outer map limits try { // convert the pixel coordinates to a LatLong and return it return(new LatLong(MercatorProjection.PixelYToLatitude(pixelY + y, mapSize), MercatorProjection.PixelXToLongitude(pixelX + x, mapSize))); } catch (Exception) { return(null); } }
/// <summary> /// Start animating the map towards the given point. /// </summary> public virtual void AnimateTo(LatLong pos) { new Task(async() => { int totalSteps = 25; // Define the Step Number int signX = 1; // Define the Sign for Horizontal Movement int signY = 1; // Define the Sign for Vertical Movement long mapSize = MercatorProjection.GetMapSize(ZoomLevel, displayModel.TileSize); double targetPixelX = MercatorProjection.LongitudeToPixelX(pos.Longitude, mapSize); double targetPixelY = MercatorProjection.LatitudeToPixelY(pos.Latitude, mapSize); double currentPixelX = MercatorProjection.LongitudeToPixelX(longitude, mapSize); double currentPixelY = MercatorProjection.LatitudeToPixelY(latitude, mapSize); double stepSizeX = Math.Abs(targetPixelX - currentPixelX) / totalSteps; double stepSizeY = Math.Abs(targetPixelY - currentPixelY) / totalSteps; /* Check the Signs */ if (currentPixelX < targetPixelX) { signX = -1; } if (currentPixelY < targetPixelY) { signY = -1; } /* Compute Scroll */ for (int i = 0; i < totalSteps; i++) { MoveCenter(stepSizeX * signX, stepSizeY * signY); await Task.Delay(10); } }).Start(); }
/// <summary> /// Handles a long press event. A long press event is only triggered if the map was not moved. A return value of true /// indicates that the long press event has been handled by this overlay and stops its propagation to other overlays. /// <para> /// The default implementation of this method does nothing and returns false. /// /// </para> /// </summary> /// <param name="tapLatLong"> /// the geographic position of the long press. </param> /// <param name="layerXY"> /// the xy position of the layer element (if available) </param> /// <param name="tapXY"> /// the xy position of the tap </param> /// <returns> true if the long press event was handled, false otherwise. </returns> public virtual bool OnLongPress(LatLong tapLatLong, Point layerXY, Point tapXY) { return(false); }
private void AdjustFrameBufferMatrix(MapPosition mapPositionFrameBuffer, Dimension mapViewDimension, double scaleFactor, LatLong pivot) { MapPosition mapViewPosition = this.model.mapViewPosition.MapPosition; long mapSize = MercatorProjection.GetMapSize(mapPositionFrameBuffer.ZoomLevel, model.displayModel.TileSize); Point pointFrameBuffer = MercatorProjection.GetPixel(mapPositionFrameBuffer.LatLong, mapSize); Point pointMapPosition = MercatorProjection.GetPixel(mapViewPosition.LatLong, mapSize); double diffX = pointFrameBuffer.X - pointMapPosition.X; double diffY = pointFrameBuffer.Y - pointMapPosition.Y; // we need to compute the pivot distance from the map center // as we will need to find the pivot point for the // frame buffer (which generally has not the same size as the // map view). double pivotDistanceX = 0d; double pivotDistanceY = 0d; if (pivot != null) { Point pivotXY = MercatorProjection.GetPixel(pivot, mapSize); pivotDistanceX = pivotXY.X - pointFrameBuffer.X; pivotDistanceY = pivotXY.Y - pointFrameBuffer.Y; } float currentScaleFactor = (float)(scaleFactor / Math.Pow(2, mapPositionFrameBuffer.ZoomLevel)); this.frameBuffer.AdjustMatrix((float)diffX, (float)diffY, currentScaleFactor, mapViewDimension, (float)pivotDistanceX, (float)pivotDistanceY); }
/// <param name="latLong"> /// the initial center point of this circle (may be null). </param> /// <param name="radius"> /// the initial non-negative radius of this circle in meters. </param> /// <param name="paintFill"> /// the initial {@code Paint} used to fill this circle (may be null). </param> /// <param name="paintStroke"> /// the initial {@code Paint} used to stroke this circle (may be null). </param> /// <exception cref="IllegalArgumentException"> /// if the given {@code radius} is negative or <seealso cref="Float#NaN"/>. </exception> public Circle(LatLong latLong, float radius, IPaint paintFill, IPaint paintStroke) : this(latLong, radius, paintFill, paintStroke, false) { }
/// <param name="latLong"> /// the initial center point of this circle (may be null). </param> /// <param name="radius"> /// the initial non-negative radius of this circle in pixels. </param> /// <param name="paintFill"> /// the initial {@code Paint} used to fill this circle (may be null). </param> /// <param name="paintStroke"> /// the initial {@code Paint} used to stroke this circle (may be null). </param> /// <param name="keepAligned"> if set to true it will keep the bitmap aligned with the map, to avoid /// a moving effect of a bitmap shader. </param> /// <exception cref="IllegalArgumentException"> /// if the given {@code radius} is negative or <seealso cref="Float#NaN"/>. </exception> public FixedPixelCircle(LatLong latLong, float radius, IPaint paintFill, IPaint paintStroke, bool keepAligned) : base(latLong, radius, paintFill, paintStroke, keepAligned) { }