private void DrawPath(ShapePaintContainer shapePaintContainer, Point[][] coordinates, float dy) { this.path.Clear(); foreach (Point[] innerList in coordinates) { Point[] points; if (dy != 0f) { points = RendererUtils.ParallelPath(innerList, dy); } else { points = innerList; } if (points.Length >= 2) { Point point = points[0]; this.path.MoveTo((float)point.X, (float)point.Y); for (int i = 1; i < points.Length; ++i) { point = points[i]; this.path.LineTo((int)point.X, (int)point.Y); } } } this.canvas.DrawPath(this.path, shapePaintContainer.paint); }
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); }
public void RenderPointOfInterestCircle(RenderContext renderContext, float radius, IPaint fill, IPaint stroke, int level, PointOfInterest poi) { Point poiPosition = MercatorProjection.GetPixelRelativeToTile(poi.Position, renderContext.rendererJob.tile); renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(new CircleContainer(poiPosition, radius), stroke)); renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(new CircleContainer(poiPosition, radius), fill)); }
private void DrawCircleContainer(ShapePaintContainer shapePaintContainer) { CircleContainer circleContainer = (CircleContainer)shapePaintContainer.shapeContainer; Point point = circleContainer.point; this.canvas.DrawCircle((int)point.X, (int)point.Y, (int)circleContainer.radius, shapePaintContainer.paint); }
private void DrawParentTileBitmap(ICanvas canvas, Point point, Tile tile) { Tile cachedParentTile = GetCachedParentTile(tile, 4); if (cachedParentTile != null) { IBitmap bitmap = this.tileCache.GetImmediately(CreateJob(cachedParentTile)); if (bitmap != null) { int tileSize = this.displayModel.TileSize; long translateX = tile.GetShiftX(cachedParentTile) * tileSize; long translateY = tile.GetShiftY(cachedParentTile) * tileSize; sbyte zoomLevelDiff = (sbyte)(tile.ZoomLevel - cachedParentTile.ZoomLevel); float scaleFactor = (float)Math.Pow(2, zoomLevelDiff); int x = (int)Math.Round(point.X); int y = (int)Math.Round(point.Y); this.matrix.Reset(); this.matrix.Translate(x - translateX, y - translateY); this.matrix.Scale(scaleFactor, scaleFactor); canvas.SetClip(x, y, this.displayModel.TileSize, this.displayModel.TileSize); canvas.DrawBitmap(bitmap, this.matrix); canvas.ResetClip(); bitmap.DecrementRefCount(); } } }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { IList <TilePosition> tilePositions = LayerUtil.GetTilePositions(boundingBox, zoomLevel, topLeftPoint, this.displayModel.TileSize); // In a rotation situation it is possible that drawParentTileBitmap sets the // clipping bounds to portrait, while the device is just being rotated into // landscape: the result is a partially painted screen that only goes away // after zooming (which has the effect of resetting the clip bounds if drawParentTileBitmap // is called again). // Always resetting the clip bounds here seems to avoid the problem, // I assume that this is a pretty cheap operation, otherwise it would be better // to hook this into the onConfigurationChanged call chain. canvas.ResetClip(); if (!isTransparent) { canvas.FillColor(this.displayModel.BackgroundColor); } ISet <Job> jobs = new HashSet <Job>(); foreach (TilePosition tilePosition in tilePositions) { jobs.Add(CreateJob(tilePosition.Tile)); } this.tileCache.WorkingSet = jobs; for (int i = tilePositions.Count - 1; i >= 0; --i) { TilePosition tilePosition = tilePositions[i]; Point point = tilePosition.Point; Tile tile = tilePosition.Tile; T job = CreateJob(tile); ITileBitmap bitmap = this.tileCache.GetImmediately(job); if (bitmap == null) { if (this.hasJobQueue && !this.tileCache.ContainsKey(job)) { this.jobQueue.Add(job); } DrawParentTileBitmap(canvas, point, tile); } else { if (IsTileStale(tile, bitmap) && this.hasJobQueue && !this.tileCache.ContainsKey(job)) { this.jobQueue.Add(job); } RetrieveLabelsOnly(job); canvas.DrawBitmap(bitmap, (int)Math.Round(point.X), (int)Math.Round(point.Y)); bitmap.DecrementRefCount(); } } if (this.hasJobQueue) { this.jobQueue.NotifyWorkers(); } }
public virtual bool Contains(Point center, Point point) { lock (this) { Rectangle r = new Rectangle(center.X - (float)bitmap.Width / 2 + this.horizontalOffset, center.Y - (float)bitmap.Height / 2 + this.verticalOffset, center.X + (float)bitmap.Width / 2 + this.horizontalOffset, center.Y + (float)bitmap.Height / 2 + this.verticalOffset); return(r.Contains(point)); } }
private static Point[] GetTilePixelCoordinates(int tileSize) { Point[] result = new Point[5]; result[0] = new Point(0, 0); result[1] = new Point(tileSize, 0); result[2] = new Point(tileSize, tileSize); result[3] = new Point(0, tileSize); result[4] = result[0]; return(result); }
private void Scale(float scaleFactor, float pivotDistanceX, float pivotDistanceY) { if (scaleFactor != 1) { Point center = this.dimension.Center; float pivotX = (float)(pivotDistanceX + center.X); float pivotY = (float)(pivotDistanceY + center.Y); this.matrix.Scale(scaleFactor, scaleFactor, pivotX, pivotY); } }
protected internal override void DoWork() { long startTime = System.DateTime.Now.Ticks; this.redrawNeeded = false; FrameBuffer frameBuffer = this.mapView.FrameBuffer; IBitmap bitmap = frameBuffer.DrawingBitmap; if (bitmap != null) { this.drawingCanvas.Bitmap = bitmap; MapPosition mapPosition = this.mapViewPosition.MapPosition; Dimension canvasDimension = this.drawingCanvas.Dimension; int tileSize = this.mapView.Model.displayModel.TileSize; BoundingBox boundingBox = MapPositionUtil.GetBoundingBox(mapPosition, canvasDimension, tileSize); Point topLeftPoint = MapPositionUtil.GetTopLeftPoint(mapPosition, canvasDimension, tileSize); foreach (Layer layer in this.layers) { if (layer.Visible) { layer.Draw(boundingBox, mapPosition.ZoomLevel, this.drawingCanvas, topLeftPoint); } } if (!mapViewPosition.AnimationInProgress()) { // this causes a lot of flickering when an animation // is in progress frameBuffer.FrameFinished(mapPosition); this.mapView.Repaint(); } else { // make sure that we redraw at the end this.redrawNeeded = true; } } long elapsedMilliseconds = (System.DateTime.Now.Ticks - startTime) / 10000; long timeSleep = MILLISECONDS_PER_FRAME - elapsedMilliseconds; if (timeSleep > 1 && !Interrupted) { System.Threading.Tasks.Task.Delay((int)timeSleep); } }
/// <summary> /// Computes a polyline with distance dy parallel to given coordinates. /// http://objectmix.com/graphics/132987-draw-parallel-polyline-algorithm-needed.html /// </summary> internal static Point[] ParallelPath(Point[] p, double dy) { int n = p.Length - 1; Point[] u = new Point[n]; Point[] h = new Point[p.Length]; // Generate an array u[] of unity vectors of each direction for (int k = 0; k < n; ++k) { double c = p[k + 1].X - p[k].X; double s = p[k + 1].Y - p[k].Y; double l = Math.Sqrt(c * c + s * s); if (l == 0) { u[k] = new Point(0, 0); } else { u[k] = new Point(c / l, s / l); } } // For the start point calculate the normal h[0] = new Point(p[0].X - dy * u[0].Y, p[0].Y + dy * u[0].X); // For 1 to N-1 calculate the intersection of the offset lines for (int k = 1; k < n; k++) { double l = dy / (1 + u[k].X * u[k - 1].X + u[k].Y * u[k - 1].Y); h[k] = new Point(p[k].X - l * (u[k].Y + u[k - 1].Y), p[k].Y + l * (u[k].X + u[k - 1].X)); } // For the end point use the normal h[n] = new Point(p[n].X - dy * u[n - 1].Y, p[n].Y + dy * u[n - 1].X); return(h); }
private void DrawPath(ShapePaintContainer shapePaintContainer, Point[][] coordinates, float dy) { if (canvas == null) { return; } // TODO //this.path.Clear(); var path = this.graphicFactory.CreatePath(); foreach (Point[] innerList in coordinates) { Point[] points; if (dy != 0f) { points = RendererUtils.ParallelPath(innerList, dy); } else { points = innerList; } if (points.Length >= 2) { Point point = points[0]; path.MoveTo((float)point.X, (float)point.Y); for (int i = 1; i < points.Length; ++i) { point = points[i]; path.LineTo((int)point.X, (int)point.Y); } } } this.canvas.DrawPath(path, shapePaintContainer.paint); }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { lock (this) { if (this.latLong == null || (this.paintStroke == null && this.paintFill == null)) { return; } double latitude = this.latLong.Latitude; double longitude = this.latLong.Longitude; long mapSize = MercatorProjection.GetMapSize(zoomLevel, displayModel.TileSize); int pixelX = (int)(MercatorProjection.LongitudeToPixelX(longitude, mapSize) - topLeftPoint.X); int pixelY = (int)(MercatorProjection.LatitudeToPixelY(latitude, mapSize) - topLeftPoint.Y); int radiusInPixel = GetRadiusInPixels(latitude, zoomLevel); Rectangle canvasRectangle = new Rectangle(0, 0, canvas.Width, canvas.Height); if (!canvasRectangle.IntersectsCircle(pixelX, pixelY, radiusInPixel)) { return; } if (this.paintStroke != null) { if (this.keepAligned) { this.paintStroke.SetBitmapShaderShift = topLeftPoint; } canvas.DrawCircle(pixelX, pixelY, radiusInPixel, this.paintStroke); } if (this.paintFill != null) { if (this.keepAligned) { this.paintFill.SetBitmapShaderShift = topLeftPoint; } canvas.DrawCircle(pixelX, pixelY, radiusInPixel, this.paintFill); } } }
public void RenderPointOfInterestSymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, PointOfInterest poi) { Point poiPosition = MercatorProjection.GetPixelAbsolute(poi.Position, renderContext.rendererJob.tile.MapSize); renderContext.labels.Add(new SymbolContainer(poiPosition, display, priority, symbol)); }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { lock (this) { if (this.latLongs.Count == 0 || this.paintStroke == null) { return; } IEnumerator <LatLong> iterator = this.latLongs.GetEnumerator(); if (!iterator.MoveNext()) { return; } 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); IPath path = this.graphicFactory.CreatePath(); 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.keepAligned) { this.paintStroke.SetBitmapShaderShift = topLeftPoint; } canvas.DrawPath(path, this.paintStroke); } }
public void RenderPointOfInterestCaption(RenderContext renderContext, Display display, int priority, string caption, float horizontalOffset, float verticalOffset, IPaint fill, IPaint stroke, Position position, int maxTextWidth, PointOfInterest poi) { Point poiPosition = MercatorProjection.GetPixelAbsolute(poi.Position, renderContext.rendererJob.tile.MapSize); renderContext.labels.Add(this.graphicFactory.CreatePointTextContainer(poiPosition.Offset(horizontalOffset, verticalOffset), display, priority, caption, fill, stroke, null, position, maxTextWidth)); }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { if (zoomLevel < this.tileSource.ZoomLevelMin || zoomLevel > this.tileSource.ZoomLevelMax) { return; } base.Draw(boundingBox, zoomLevel, canvas, topLeftPoint); }
internal CircleContainer(Point point, float radius) { this.point = point; this.radius = radius; }
public void RenderAreaSymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, PolylineContainer way) { Point centerPosition = way.CenterAbsolute; renderContext.labels.Add(new SymbolContainer(centerPosition, display, priority, symbol)); }
internal static void RenderSymbol(IBitmap symbolBitmap, Display display, int priority, float dy, bool alignCenter, bool repeatSymbol, float repeatGap, float repeatStart, bool rotate, Point[][] coordinates, ICollection <MapElementContainer> currentItems) { int skipPixels = (int)repeatStart; Point[] c; if (dy == 0f) { c = coordinates[0]; } else { c = RendererUtils.ParallelPath(coordinates[0], dy); } // get the first way point coordinates double previousX = c[0].X; double previousY = c[0].Y; // draw the symbolContainer on each way segment float segmentLengthRemaining; float segmentSkipPercentage; float theta = 0; for (int i = 1; i < c.Length; ++i) { // get the current way point coordinates double currentX = c[i].X; double currentY = c[i].Y; // calculate the length of the current segment (Euclidian distance) double diffX = currentX - previousX; double diffY = currentY - previousY; double segmentLengthInPixel = Math.Sqrt(diffX * diffX + diffY * diffY); segmentLengthRemaining = (float)segmentLengthInPixel; while (segmentLengthRemaining - skipPixels > repeatStart) { // calculate the percentage of the current segment to skip segmentSkipPercentage = skipPixels / segmentLengthRemaining; // move the previous point forward towards the current point previousX += diffX * segmentSkipPercentage; previousY += diffY * segmentSkipPercentage; if (rotate) { // if we do not rotate theta will be 0, which is correct theta = (float)Math.Atan2(currentY - previousY, currentX - previousX); } Point point = new Point(previousX, previousY); currentItems.Add(new SymbolContainer(point, display, priority, symbolBitmap, theta, alignCenter)); // check if the symbolContainer should only be rendered once if (!repeatSymbol) { return; } // recalculate the distances diffX = currentX - previousX; diffY = currentY - previousY; // recalculate the remaining length of the current segment segmentLengthRemaining -= skipPixels; // set the amount of pixels to skip before repeating the symbolContainer skipPixels = (int)repeatGap; } skipPixels -= (int)segmentLengthRemaining; if (skipPixels < repeatStart) { skipPixels = (int)repeatStart; } // set the previous way point coordinates for the next loop previousX = currentX; previousY = currentY; } }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { lock (this) { if (this.latLong == null || this.bitmap == null) { return; } long mapSize = MercatorProjection.GetMapSize(zoomLevel, this.displayModel.TileSize); double pixelX = MercatorProjection.LongitudeToPixelX(this.latLong.Longitude, mapSize); double pixelY = MercatorProjection.LatitudeToPixelY(this.latLong.Latitude, mapSize); int halfBitmapWidth = this.bitmap.Width / 2; int halfBitmapHeight = this.bitmap.Height / 2; int left = (int)(pixelX - topLeftPoint.X - halfBitmapWidth + this.horizontalOffset); int top = (int)(pixelY - topLeftPoint.Y - halfBitmapHeight + this.verticalOffset); int right = left + this.bitmap.Width; int bottom = top + this.bitmap.Height; Rectangle bitmapRectangle = new Rectangle(left, top, right, bottom); Rectangle canvasRectangle = new Rectangle(0, 0, canvas.Width, canvas.Height); if (!canvasRectangle.Intersects(bitmapRectangle)) { return; } canvas.DrawBitmap(this.bitmap, left, top); } }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { long tileLeft = MercatorProjection.LongitudeToTileX(boundingBox.MinLongitude, zoomLevel); long tileTop = MercatorProjection.LatitudeToTileY(boundingBox.MaxLatitude, zoomLevel); long tileRight = MercatorProjection.LongitudeToTileX(boundingBox.MaxLongitude, zoomLevel); long tileBottom = MercatorProjection.LatitudeToTileY(boundingBox.MinLatitude, zoomLevel); int tileSize = this.displayModel.TileSize; int pixelX1 = (int)(MercatorProjection.TileToPixel(tileLeft, tileSize) - topLeftPoint.X); int pixelY1 = (int)(MercatorProjection.TileToPixel(tileTop, tileSize) - topLeftPoint.Y); int pixelX2 = (int)(MercatorProjection.TileToPixel(tileRight, tileSize) - topLeftPoint.X + tileSize); int pixelY2 = (int)(MercatorProjection.TileToPixel(tileBottom, tileSize) - topLeftPoint.Y + tileSize); for (int lineX = pixelX1; lineX <= pixelX2 + 1; lineX += tileSize) { canvas.DrawLine(lineX, pixelY1, lineX, pixelY2, this.paintBack); } for (int lineY = pixelY1; lineY <= pixelY2 + 1; lineY += tileSize) { canvas.DrawLine(pixelX1, lineY, pixelX2, lineY, this.paintBack); } for (int lineX = pixelX1; lineX <= pixelX2 + 1; lineX += tileSize) { canvas.DrawLine(lineX, pixelY1, lineX, pixelY2, this.paintFront); } for (int lineY = pixelY1; lineY <= pixelY2 + 1; lineY += tileSize) { canvas.DrawLine(pixelX1, lineY, pixelX2, lineY, this.paintFront); } }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { if (spacingConfig.ContainsKey(zoomLevel)) { double spacing = spacingConfig[zoomLevel].Value; double minLongitude = spacing * (Math.Floor(boundingBox.MinLongitude / spacing)); double maxLongitude = spacing * (Math.Ceiling(boundingBox.MaxLongitude / spacing)); double minLatitude = spacing * (Math.Floor(boundingBox.MinLatitude / spacing)); double maxLatitude = spacing * (Math.Ceiling(boundingBox.MaxLatitude / spacing)); long mapSize = MercatorProjection.GetMapSize(zoomLevel, this.displayModel.TileSize); int bottom = (int)(MercatorProjection.LatitudeToPixelY(minLatitude, mapSize) - topLeftPoint.Y); int top = (int)(MercatorProjection.LatitudeToPixelY(maxLatitude, mapSize) - topLeftPoint.Y); int left = (int)(MercatorProjection.LongitudeToPixelX(minLongitude, mapSize) - topLeftPoint.X); int right = (int)(MercatorProjection.LongitudeToPixelX(maxLongitude, mapSize) - topLeftPoint.X); for (double latitude = minLatitude; latitude <= maxLatitude; latitude += spacing) { int pixelY = (int)(MercatorProjection.LatitudeToPixelY(latitude, mapSize) - topLeftPoint.Y); canvas.DrawLine(left, pixelY, right, pixelY, this.lineBack); } for (double longitude = minLongitude; longitude <= maxLongitude; longitude += spacing) { int pixelX = (int)(MercatorProjection.LongitudeToPixelX(longitude, mapSize) - topLeftPoint.X); canvas.DrawLine(pixelX, bottom, pixelX, top, this.lineBack); } for (double latitude = minLatitude; latitude <= maxLatitude; latitude += spacing) { int pixelY = (int)(MercatorProjection.LatitudeToPixelY(latitude, mapSize) - topLeftPoint.Y); canvas.DrawLine(left, pixelY, right, pixelY, this.lineFront); } for (double longitude = minLongitude; longitude <= maxLongitude; longitude += spacing) { int pixelX = (int)(MercatorProjection.LongitudeToPixelX(longitude, mapSize) - topLeftPoint.X); canvas.DrawLine(pixelX, bottom, pixelX, top, this.lineFront); } for (double latitude = minLatitude; latitude <= maxLatitude; latitude += spacing) { string text = ConvertCoordinate(latitude); int pixelX = (canvas.Width - this.textFront.GetTextWidth(text)) / 2; int pixelY = (int)(MercatorProjection.LatitudeToPixelY(latitude, mapSize) - topLeftPoint.Y) + this.textFront.GetTextHeight(text) / 2; canvas.DrawText(text, pixelX, pixelY, this.textBack); canvas.DrawText(text, pixelX, pixelY, this.textFront); } for (double longitude = minLongitude; longitude <= maxLongitude; longitude += spacing) { string text = ConvertCoordinate(longitude); int pixelX = (int)(MercatorProjection.LongitudeToPixelX(longitude, mapSize) - topLeftPoint.X) - this.textFront.GetTextWidth(text) / 2; int pixelY = (canvas.Height + this.textFront.GetTextHeight(text)) / 2; canvas.DrawText(text, pixelX, pixelY, this.textBack); canvas.DrawText(text, pixelX, pixelY, this.textFront); } } }
/// <summary> /// Draws this {@code Layer} on the given canvas. /// </summary> /// <param name="boundingBox"> /// the geographical area which should be drawn. </param> /// <param name="zoomLevel"> /// the zoom level at which this {@code Layer} should draw itself. </param> /// <param name="canvas"> /// the canvas on which this {@code Layer} should draw itself. </param> /// <param name="topLeftPoint"> /// the top-left pixel position of the canvas relative to the top-left map position. </param> public abstract void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint);
public TilePosition(Tile tile, Point point) { this.Tile = tile; this.Point = point; }
/// <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); }
public static IList <TilePosition> GetTilePositions(BoundingBox boundingBox, sbyte zoomLevel, Point topLeftPoint, int tileSize) { int tileLeft = MercatorProjection.LongitudeToTileX(boundingBox.MinLongitude, zoomLevel); int tileTop = MercatorProjection.LatitudeToTileY(boundingBox.MaxLatitude, zoomLevel); int tileRight = MercatorProjection.LongitudeToTileX(boundingBox.MaxLongitude, zoomLevel); int tileBottom = MercatorProjection.LatitudeToTileY(boundingBox.MinLatitude, zoomLevel); int initialCapacity = (tileRight - tileLeft + 1) * (tileBottom - tileTop + 1); IList <TilePosition> tilePositions = new List <TilePosition>(initialCapacity); for (int tileY = tileTop; tileY <= tileBottom; ++tileY) { for (int tileX = tileLeft; tileX <= tileRight; ++tileX) { double pixelX = MercatorProjection.TileToPixel(tileX, tileSize) - topLeftPoint.X; double pixelY = MercatorProjection.TileToPixel(tileY, tileSize) - topLeftPoint.Y; tilePositions.Add(new TilePosition(new Tile(tileX, tileY, zoomLevel, tileSize), new Point(pixelX, pixelY))); } } return(tilePositions); }
public void RenderAreaCaption(RenderContext renderContext, Display display, int priority, string caption, float horizontalOffset, float verticalOffset, IPaint fill, IPaint stroke, Position position, int maxTextWidth, PolylineContainer way) { Point centerPoint = way.CenterAbsolute.Offset(horizontalOffset, verticalOffset); renderContext.labels.Add(this.graphicFactory.CreatePointTextContainer(centerPoint, display, priority, caption, fill, stroke, null, position, maxTextWidth)); }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { IList <TilePosition> tilePositions = LayerUtil.GetTilePositions(boundingBox, zoomLevel, topLeftPoint, this.displayModel.TileSize); for (int i = tilePositions.Count - 1; i >= 0; --i) { DrawTileCoordinates(tilePositions[i], canvas); } }
public override void Draw(BoundingBox boundingBox, sbyte zoomLevel, ICanvas canvas, Point topLeftPoint) { ISet <Tile> currentTileSet = LayerUtil.GetTiles(boundingBox, zoomLevel, displayModel.TileSize); if (!currentTileSet.Equals(lastTileSet) || lastLabelStoreVersion != labelStore.Version) { // only need to get new data set if either set of tiles changed or the label store lastTileSet = currentTileSet; lastLabelStoreVersion = labelStore.Version; IList <MapElementContainer> visibleItems = this.labelStore.GetVisibleItems(currentTileSet); // TODO this is code duplicated from CanvasRasterer::drawMapElements, should be factored out // what LayerUtil.collisionFreeOrdered gave us is a list where highest priority comes first, // so we need to reverse that in order to // draw elements in order of priority: lower priority first, so more important // elements will be drawn on top (in case of display=true) items. elementsToDraw = from element in LayerUtil.CollisionFreeOrdered(visibleItems) orderby element.Priority ascending select element; } foreach (MapElementContainer item in elementsToDraw) { item.Draw(canvas, topLeftPoint, this.matrix); } }