public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way) { lock (this) { if (!bitmapCreated) { try { shaderBitmap = CreateBitmap(relativePathPrefix, src); } catch (IOException) { // no-op } bitmapCreated = true; } IPaint strokePaint = getStrokePaint(renderContext.rendererJob.tile.ZoomLevel); if (shaderBitmap != null) { strokePaint.BitmapShader = shaderBitmap; strokePaint.SetBitmapShaderShift = way.Tile.Origin; } float dyScale = this.dyScaled[renderContext.rendererJob.tile.ZoomLevel] ?? this.dy; renderCallback.RenderWay(renderContext, strokePaint, dyScale, this.level, way); } }
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(); } } }
/// <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 override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way) { lock (this) { // this needs to be synchronized as we potentially set a shift in the shader and // the shift is particular to the tile when rendered in multi-thread mode IPaint fillPaint = getFillPaint(renderContext.rendererJob.tile.ZoomLevel); if (shaderBitmap == null && !bitmapInvalid) { try { shaderBitmap = CreateBitmap(relativePathPrefix, src); if (shaderBitmap != null) { fillPaint.BitmapShader = shaderBitmap; shaderBitmap.DecrementRefCount(); } } catch (IOException) { bitmapInvalid = true; } } fillPaint.SetBitmapShaderShift = way.Tile.Origin; renderCallback.RenderArea(renderContext, fillPaint, getStrokePaint(renderContext.rendererJob.tile.ZoomLevel), this.level, way); } }
public override void RenderWay(RenderCallback renderCallback, RenderContext renderContext, PolylineContainer way) { if (Display.NEVER == this.display) { return; } if (this.bitmap == null && !this.bitmapInvalid) { try { this.bitmap = CreateBitmap(relativePathPrefix, src); } catch (IOException) { this.bitmapInvalid = true; } } float dyScale = this.dyScaled[renderContext.rendererJob.tile.ZoomLevel] ?? this.dy; if (this.bitmap != null) { renderCallback.RenderWaySymbol(renderContext, this.display, this.priority, this.bitmap, dyScale, this.alignCenter, this.repeat, this.repeatGap, this.repeatStart, this.rotate, way); } }
public virtual void FrameFinished(MapPosition frameMapPosition) { lock (this) { // swap both bitmap references IBitmap bitmapTemp = this.bitmap1; this.bitmap1 = this.bitmap2; this.bitmap2 = bitmapTemp; } // taking this out of the synchronized region removes a deadlock potential // at the small risk of an inconsistent zoom this.frameBufferModel.MapPosition = frameMapPosition; }
private void DestroyBitmaps() { if (this.bitmap1 != null) { this.bitmap1.DecrementRefCount(); this.bitmap1 = null; } if (this.bitmap2 != null) { this.bitmap2.DecrementRefCount(); this.bitmap2 = null; } }
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); } }
public MapScaleBar(MapViewPosition mapViewPosition, MapViewDimension mapViewDimension, DisplayModel displayModel, IGraphicFactory graphicFactory, int width, int height) { this.mapViewPosition = mapViewPosition; this.mapViewDimension = mapViewDimension; this.displayModel = displayModel; this.graphicFactory = graphicFactory; this.mapScaleBitmap = graphicFactory.CreateBitmap((int)(width * this.displayModel.ScaleFactor), (int)(height * this.displayModel.ScaleFactor)); this.marginHorizontal = DEFAULT_HORIZONTAL_MARGIN; this.marginVertical = DEFAULT_VERTICAL_MARGIN; this.scaleBarPosition = DEFAULT_SCALE_BAR_POSITION; this.mapScaleCanvas = graphicFactory.CreateCanvas(); this.mapScaleCanvas.Bitmap = this.mapScaleBitmap; this.distanceUnitAdapter = MetricUnitAdapter.INSTANCE; this.visible = true; this.redrawNeeded = true; }
public void RenderWaySymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, float dy, bool alignCenter, bool repeat, float repeatGap, float repeatStart, bool rotate, PolylineContainer way) { WayDecorator.RenderSymbol(symbol, display, priority, dy, alignCenter, repeat, repeatGap, repeatStart, rotate, way.CoordinatesAbsolute, renderContext.labels); }
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 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)); }
public Caption(IGraphicFactory graphicFactory, DisplayModel displayModel, string elementName, XmlReader reader, IDictionary <string, Symbol> symbols) : base(graphicFactory, displayModel) { this.fill = graphicFactory.CreatePaint(); this.fill.Color = Color.BLACK; this.fill.Style = Style.FILL; this.fills = new Dictionary <sbyte?, IPaint>(); this.stroke = graphicFactory.CreatePaint(); this.stroke.Color = Color.BLACK; this.stroke.Style = Style.STROKE; this.strokes = new Dictionary <sbyte?, IPaint>(); this.dyScaled = new Dictionary <sbyte?, float?>(); this.display = Display.IFSPACE; this.gap = DEFAULT_GAP * displayModel.ScaleFactor; ExtractValues(graphicFactory, displayModel, elementName, reader); if (!string.ReferenceEquals(this.symbolId, null)) { Symbol symbol = symbols[this.symbolId]; if (symbol != null) { this.bitmap = symbol.Bitmap; } } if (this.position == null) { // sensible defaults: below if symbolContainer is present, center if not if (this.bitmap == null) { this.position = Position.CENTER; } else { this.position = Position.BELOW; } } else if (this.position == Position.CENTER || this.position == Position.BELOW || this.position == Position.ABOVE) { this.stroke.TextAlign = Align.CENTER; this.fill.TextAlign = Align.CENTER; } else if (this.position == Position.BELOW_LEFT || this.position == Position.ABOVE_LEFT || this.position == Position.LEFT) { this.stroke.TextAlign = Align.RIGHT; this.fill.TextAlign = Align.RIGHT; } else if (this.position == Position.BELOW_RIGHT || this.position == Position.ABOVE_RIGHT || this.position == Position.RIGHT) { this.stroke.TextAlign = Align.LEFT; this.fill.TextAlign = Align.LEFT; } else { throw new System.ArgumentException("Position invalid"); } this.maxTextWidth = displayModel.MaxTextWidth; }
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; } }