/// <summary> /// Draws a point on the target. The coordinates given are scene coordinates. /// </summary> /// <param name="x">The x coordinate.</param> /// <param name="y">The y coordinate.</param> /// <param name="color">Color.</param> /// <param name="size">Size.</param> protected override void DrawPoint(Target2DWrapper <global::Android.Graphics.Canvas> target, double x, double y, int color, double size) { float sizeInPixels = this.ToPixels(size) * this.Density; _paint.Color = new global::Android.Graphics.Color(color); _paint.StrokeWidth = 1; _paint.SetStyle(global::Android.Graphics.Paint.Style.Fill); double transformedX, transformedY; _toViewPort.Apply(x, y, out transformedX, out transformedY); target.Target.DrawCircle((float)transformedX, (float)transformedY, sizeInPixels, _paint); }
/// <summary> /// Draws a line on the target. The coordinates given are scene coordinates. /// </summary> /// <param name="target"></param> /// <param name="x">The x coordinate.</param> /// <param name="y">The y coordinate.</param> /// <param name="color">Color.</param> /// <param name="width">Width.</param> /// <param name="lineJoin"></param> /// <param name="dashes"></param> protected override void DrawLine(Target2DWrapper <RenderContext> target, double[] x, double[] y, int color, double width, LineJoin lineJoin, int[] dashes) { width = ToPixels(width); var points = new Point[x.Length]; for (var idx = 0; idx < x.Length; idx++) { points[idx] = Tranform(x[idx], y[idx]); } target.Render().DrawLine(points, width, color.ToColor(), PenLineCap.Round, PenLineCap.Round, lineJoin.ToPenLineJoin(), dashes.ToDashStyle(0)); }
/// <summary> /// Draws a point on the target. The coordinates given are scene coordinates. /// </summary> /// <param name="target"></param> /// <param name="x">The x coordinate.</param> /// <param name="y">The y coordinate.</param> /// <param name="color">Color.</param> /// <param name="size">Size.</param> protected override void DrawPoint(Target2DWrapper <CGContextWrapper> target, double x, double y, int color, double size) { var transformed = this.Transform(x, y); var colorSimple = SimpleColor.FromArgb(color); var radius = (float)(this.ToPixels(size) * _scaleFactor) / 2.0f;; target.Target.CGContext.SetFillColor(colorSimple.R / 256.0f, colorSimple.G / 256.0f, colorSimple.B / 256.0f, colorSimple.A / 256.0f); _rectangle.X = (float)transformed[0] - radius; _rectangle.Y = (float)transformed[1] - radius; _rectangle.Width = radius * 2; _rectangle.Height = radius * 2; target.Target.CGContext.FillEllipseInRect(_rectangle); }
/// <summary> /// Draws text along a line. /// </summary> /// <param name="target"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="text"></param> /// <param name="color"></param> /// <param name="size"></param> /// <param name="haloColor"></param> /// <param name="haloRadius"></param> /// <param name="fontName"></param> protected override void DrawLineText(Target2DWrapper <RenderContext> target, double[] x, double[] y, string text, int color, double size, int?haloColor, int?haloRadius, string fontName) { if (x.Length > 1) { size = ToPixels(size); var points = new Point[x.Length]; for (var idx = 0; idx < x.Length; idx++) { points[idx] = Tranform(x[idx], y[idx]); } target.Render().DrawTextLine(text, points, new Typeface(fontName), size, color.ToColor(), haloColor.ToColor(), haloRadius); } }
/// <summary> /// Called right before rendering starts. /// </summary> /// <param name="target"></param> /// <param name="view"></param> protected override void OnBeforeRender(Target2DWrapper <Graphics> target, View2D view) { //// create a bitmap and render there. //var bitmap = new Bitmap((int)target.Width, (int)target.Height); //target.BackTarget = target.Target; //target.BackTarget.CompositingMode = CompositingMode.SourceOver; //target.Target = Graphics.FromImage(bitmap); //target.Target.CompositingMode = CompositingMode.SourceOver; //target.Target.SmoothingMode = target.BackTarget.SmoothingMode; //target.Target.PixelOffsetMode = target.BackTarget.PixelOffsetMode; //target.Target.InterpolationMode = target.BackTarget.InterpolationMode; //target.Tag = bitmap; }
/// <summary> /// Draws text along a given line. /// </summary> /// <param name="target"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="color"></param> /// <param name="size"></param> /// <param name="text">Text.</param> protected override void DrawLineText(Target2DWrapper <global::Android.Graphics.Canvas> target, double[] xa, double[] ya, string text, int color, double size, int?haloColor, int?haloRadius, string fontName) { if (xa.Length > 1) { float sizeInPixels = this.ToPixels(size); _paint.SubpixelText = true; _paint.TextSize = (float)sizeInPixels; _paint.AntiAlias = true; // transform first. double[] xTransformed = new double[xa.Length]; double[] yTransformed = new double[ya.Length]; for (int idx = 0; idx < xa.Length; idx++) { double[] transformed = this.Tranform(xa[idx], ya[idx]); xTransformed [idx] = transformed [0]; yTransformed [idx] = transformed [1]; } // get some metrics on the texts. float[] characterWidths = new float[text.Length]; _paint.GetTextWidths(text, characterWidths); // for (int idx = 0; idx < characterWidths.Length; idx++) // { // characterWidths[idx] = _target, _view, characterWidths[idx]; // } var characterHeight = (float)sizeInPixels; var textLength = characterWidths.Sum(); // calculate line length. var lineLength = Polyline2D.Length(xTransformed, yTransformed); if (lineLength > textLength * 1.2f) { // calculate the number of labels. int labelCount = (int)System.Math.Floor(lineLength / (textLength * 10)) + 1; // calculate positions of label(s). double positionGap = lineLength / (labelCount + 1); // draw each label. for (double position = positionGap; position < lineLength; position = position + positionGap) { this.DrawLineTextSegment(target, xTransformed, yTransformed, text, color, size, haloColor, haloRadius, position, characterWidths, textLength, characterHeight); } } } }
/// <summary> /// Draws an icon unscaled but at the given scene coordinates. /// </summary> /// <param name="target"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="imageData"></param> protected override void DrawIcon(Target2DWrapper <RenderContext> target, double x, double y, byte[] imageData) { using (var stream = new MemoryStream(imageData)) { var imageSource = new BitmapImage(); imageSource.BeginInit(); imageSource.CacheOption = BitmapCacheOption.OnLoad; imageSource.StreamSource = stream; imageSource.EndInit(); var leftTop = Tranform(x, y); leftTop.Offset(-imageSource.Width / 2, -imageSource.Height / 2); target.Render().DrawImage(leftTop, imageSource); } }
/// <summary> /// Returns the target wrapper. /// </summary> /// <param name="target"></param> /// <returns></returns> public override Target2DWrapper <global::Android.Graphics.Canvas> CreateTarget2DWrapper(global::Android.Graphics.Canvas target) { if (_wrapper == null) { // create the wrapper. _wrapper = new Target2DWrapper <global::Android.Graphics.Canvas>( target, target.Width, target.Height); } else { // updated the exist wrapper. _wrapper.Width = target.Width; _wrapper.Height = target.Height; _wrapper.Target = target; } return(_wrapper); }
/// <summary> /// Draws an image. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="nativeImage"></param> protected override void DrawImage(Target2DWrapper <RenderContext> target, double left, double top, double right, double bottom, INativeImage nativeImage) { var wpfNativeImage = nativeImage as NativeImage; if (wpfNativeImage != null) { var leftTop = Tranform(left, top); var rightBottom = Tranform(right, bottom); var width = rightBottom.X - leftTop.X; var height = rightBottom.Y - leftTop.Y; var destRect = new Rect(leftTop, new Size(width, height)); target.Render().DrawImage(destRect, wpfNativeImage.Image); } }
/// <summary> /// Draws a line on the target. The coordinates given are scene coordinates. /// </summary> /// <param name="target"></param> /// <param name="x">The x coordinate.</param> /// <param name="y">The y coordinate.</param> /// <param name="color">Color.</param> /// <param name="width">Width.</param> /// <param name="lineJoin"></param> /// <param name="dashes"></param> protected override void DrawLine(Target2DWrapper <OpenGLTarget2D> target, double[] x, double[] y, int color, double width, LineJoin lineJoin, int[] dashes) { _z = _z + 0.0001f; float[] points = new float[x.Length * 3]; for (int idx = 0; idx < x.Length; idx++) { int pathIdx = idx * 3; points[pathIdx + 0] = (float)x[idx]; points[pathIdx + 1] = (float)y[idx]; points[pathIdx + 2] = _z; } _target.Target.AddLine(points, this.ToPixels(width), color); }
/// <summary> /// Draws an image on the target. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="imageData"></param> /// <returns>The image.</returns> /// <param name="tag">Tag.</param> protected override object DrawImage(Target2DWrapper <CGContextWrapper> target, double left, double top, double right, double bottom, byte[] imageData, object tag) { CGImage image = null; CGLayer layer = null; if (tag != null && tag is CGImage) { image = (tag as CGImage); } else if (tag != null && tag is CGLayer) { layer = (tag as CGLayer); } else { // TODO: figurate out how to use this horroble IOS api to instantiate an image from a bytearray. //CGImage image = CGImage.FromPNG( } if (image != null) { // there is an image. draw it! double[] topleft = this.Tranform(left, top); double[] bottomright = this.Tranform(right, bottom); float leftPixels = (float)topleft[0]; float topPixels = (float)topleft[1]; float rightPixels = (float)bottomright[0]; float bottomPixels = (float)bottomright[1]; target.Target.CGContext.DrawImage(new RectangleF(leftPixels, topPixels, (rightPixels - leftPixels), (bottomPixels - topPixels)), image); } else if (layer != null) { double[] topleft = this.Tranform(left, top); double[] bottomright = this.Tranform(right, bottom); float leftPixels = (float)topleft[0]; float topPixels = (float)topleft[1]; float rightPixels = (float)bottomright[0]; float bottomPixels = (float)bottomright[1]; target.Target.CGContext.DrawLayer(layer, new RectangleF(leftPixels, topPixels, (rightPixels - leftPixels), (bottomPixels - topPixels))); } return(image); }
// /// <summary> // /// Holds the bitmap cache. // /// </summary> // private global::Android.Graphics.Bitmap _cache; /// <summary> /// Called right before rendering starts. /// </summary> /// <param name="target"></param> /// <param name="scenes"></param> /// <param name="view"></param> protected override void OnBeforeRender(Target2DWrapper <global::Android.Graphics.Canvas> target, List <Scene2D> scenes, View2D view) { // if (_cache == null || _cache.Width != target.Width || _cache.Height != target.Height) { // // create a bitmap and render there. // _cache = global::Android.Graphics.Bitmap.CreateBitmap ((int)target.Width, (int)target.Height, // global::Android.Graphics.Bitmap.Config.Argb8888); // } else { // // clear the cache??? // } // target.BackTarget = target.Target; // target.Target = new global::Android.Graphics.Canvas(_cache); // target.Target.DrawColor(global::Android.Graphics.Color.Transparent); // // target.Tag = _cache; _path = new global::Android.Graphics.Path(); }
/// <summary> /// Render the specified target, projection, layers, zoomFactor and coordinate. /// </summary> /// <param name="target">Target.</param> /// <param name="projection">Projection.</param> /// <param name="layers">Layers.</param> /// <param name="view">View</param> public bool Render(TTarget target, List <ILayer> layers, View2D view) { // create the view for this control. Target2DWrapper <TTarget> target2DWrapper = _renderer.CreateTarget2DWrapper(target); // draw all layers seperatly but in the correct order. var scenes = new List <Scene2D>(); for (int layerIdx = 0; layerIdx < layers.Count; layerIdx++) { // get the layer. scenes.Add(layers[layerIdx].Scene); } // render the scenes. return(_renderer.Render(target, scenes, view)); }
/// <summary> /// Draws text along a line. /// </summary> /// <param name="target"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="text"></param> /// <param name="color"></param> /// <param name="size"></param> /// <param name="haloColor"></param> /// <param name="haloRadius"></param> /// <param name="fontName"></param> protected override void DrawLineText(Target2DWrapper <Graphics> target, double[] x, double[] y, string text, int color, double size, int?haloColor, int?haloRadius, string fontName) { if (x.Length > 1) { float sizeInPixels = this.ToPixels(size); Color textColor = Color.FromArgb(color); Brush brush = new SolidBrush(textColor); Brush haloBrush = null; if (haloColor.HasValue && haloRadius.HasValue && haloRadius.Value > 0) { haloBrush = new SolidBrush(Color.FromArgb(haloColor.Value)); } Font font = new Font(FontFamily.GenericSansSerif, sizeInPixels); // get some metrics on the texts. var characterWidths = GetCharacterWidths(target.Target, text, font); for (int idx = 0; idx < characterWidths.Length; idx++) { characterWidths[idx] = (float)this.FromPixels(_target, _view, characterWidths[idx]); } var characterHeight = target.Target.MeasureString(text, font).Height; var textLength = characterWidths.Sum(); // var avgCharacterWidth = textLength / characterWidths.Length; // calculate line length. var lineLength = Polyline2D.Length(x, y); if (lineLength > textLength * 1.1f) { // calculate the number of labels. int labelCount = (int)System.Math.Floor(lineLength / (textLength * 10)) + 1; // calculate positions of label(s). double positionGap = lineLength / (labelCount + 1); // draw each label. for (double position = positionGap; position < lineLength; position = position + positionGap) { this.DrawLineTextSegment(target, x, y, text, color, size, haloColor, haloRadius, position, characterWidths, textLength, font, characterHeight, haloBrush, brush); } } } }
/// <summary> /// Draws an icon on the target unscaled but centered at the given scene coordinates. /// </summary> /// <param name="target"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="imageData"></param> protected override void DrawIcon(Target2DWrapper <global::Android.Graphics.Canvas> target, double x, double y, byte[] imageData) { global::Android.Graphics.Bitmap image = global::Android.Graphics.BitmapFactory.DecodeByteArray( imageData, 0, imageData.Length); // // calculate target rectangle. // double sceneSizeX = this.FromPixels(target, _view, image.Width) / 2.0f; // double sceneSizeY = this.FromPixels(target, _view, image.Height) / 2.0f; // double sceneTop = x + sceneSizeX; // double sceneBottom = x - sceneSizeX; // double sceneLeft = y - sceneSizeY; // double sceneRight = y + sceneSizeY; double[] transformed = this.Tranform(x, y); target.Target.DrawBitmap(image, (float)transformed [0], (float)transformed [1], null); image.Dispose(); }
/// <summary> /// Builds the cached scene. /// </summary> /// <param name="target"></param> /// <param name="currentCache"></param> /// <param name="currentScenes"></param> /// <param name="view"></param> /// <returns></returns> protected override Scene2D BuildSceneCache(Target2DWrapper <Graphics> target, Scene2D currentCache, List <Scene2D> currentScenes, View2D view) { var scene = new Scene2DSimple(); // scene.BackColor = currentScenes[0].BackColor; // // var bitmap = target.Tag as Bitmap; // if (bitmap != null) // { // // // 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])); // // scene.AddImage(0, float.MinValue, float.MaxValue, // view.Left, view.Top, view.Right, view.Bottom, new byte[0], bitmap); // } return(scene); }
/// <summary> /// Draws an image on the target. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="nativeImage"></param> /// <returns>The image.</returns> protected override void DrawImage(Target2DWrapper <CGContextWrapper> target, double left, double top, double right, double bottom, INativeImage nativeImage) { // get the native image. var iosNativeImage = (nativeImage as NativeImage); // get CGImage. CGImage image = iosNativeImage.Image; var bounds = new RectangleF2D(left, bottom, (left - right), (top - bottom)); target.Target.CGContext.SetAllowsFontSubpixelQuantization(true); target.Target.CGContext.SetAllowsFontSmoothing(true); target.Target.CGContext.SetAllowsAntialiasing(true); target.Target.CGContext.SetAllowsSubpixelPositioning(true); target.Target.CGContext.SetShouldAntialias(true); PointF2D bottomLeft = new PointF2D(this.Transform(bounds.BottomLeft[0], bounds.BottomLeft[1])); PointF2D bottomRight = new PointF2D(this.Transform(bounds.BottomRight[0], bounds.BottomRight[1])); PointF2D topLeft = new PointF2D(this.Transform(bounds.TopLeft[0], bounds.TopLeft[1])); //PointF2D topRight = new PointF2D(this.Tranform (bounds.TopRight [0], bounds.TopRight [1])); RectangleF2D transformed = new RectangleF2D(bottomLeft, bottomLeft.Distance(bottomRight), bottomLeft.Distance(topLeft), topLeft - bottomLeft); target.Target.CGContext.SaveState(); target.Target.CGContext.TranslateCTM((float)transformed.BottomLeft[0], (float)transformed.BottomLeft[1]); target.Target.CGContext.RotateCTM(-(float)((Radian)transformed.Angle).Value); target.Target.CGContext.ScaleCTM(-1, 1); // build rectangle. _rectangle.X = 0; _rectangle.Y = 0; _rectangle.Width = (float)transformed.Width; _rectangle.Height = (float)transformed.Height; target.Target.CGContext.DrawImage(_rectangle, image); target.Target.CGContext.RestoreState(); }
/// <summary> /// Draws an image. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="imageData"></param> /// <param name="tag"></param> protected override object DrawImage(Target2DWrapper <Graphics> target, double left, double top, double right, double bottom, byte[] imageData, object tag) { // get the image. var image = (tag as Image); if (image == null) { image = Image.FromStream(new MemoryStream(imageData)); } double[] topleft = this.Tranform(left, top); double[] bottomright = this.Tranform(right, bottom); float x = (float)topleft[0]; float y = (float)topleft[1]; float width = (float)bottomright[0] - x; float height = (float)bottomright[1] - y; target.Target.DrawImage(image, new RectangleF(x, y, width, height)); return(image); }
/// <summary> /// Builds the cached scene. /// </summary> /// <param name="target"></param> /// <param name="currentCache"></param> /// <param name="currentScenes"></param> /// <param name="view"></param> /// <returns></returns> protected override Scene2D BuildSceneCache(Target2DWrapper <global::Android.Graphics.Canvas> target, Scene2D currentCache, List <Scene2D> currentScenes, View2D view) { var scene = new Scene2DSimple(); // scene.BackColor = currentScenes[0].BackColor; // // var bitmap = target.Tag as global::Android.Graphics.Bitmap; // if (bitmap != null) // { // byte[] imageData = null; // using (var stream = new MemoryStream()) // { // bitmap.Compress(global::Android.Graphics.Bitmap.CompressFormat.Png, 0, stream); // // imageData = stream.ToArray(); // } // scene.AddImage(0, float.MinValue, float.MaxValue, // view.Left, view.Top, view.Right, view.Bottom, imageData); // } return(scene); }
/// <summary> /// Draws a polygon on the target. The coordinates given are scene coordinates. /// </summary> /// <param name="target"></param> /// <param name="x">The x coordinate.</param> /// <param name="y">The y coordinate.</param> /// <param name="color">Color.</param> /// <param name="width">Width.</param> /// <param name="fill">If set to <c>true</c> fill.</param> protected override void DrawPolygon(Target2DWrapper <Graphics> target, double[] x, double[] y, int color, double width, bool fill) { float widthInPixels = this.ToPixels(width); var points = new PointF[x.Length]; for (int idx = 0; idx < x.Length; idx++) { double[] transformed = this.Tranform(x[idx], y[idx]); points[idx] = new PointF((float)transformed[0], (float)transformed[1]); } if (fill) { // var pen = new Pen(Color.FromArgb(color), widthInPixels); target.Target.FillPolygon(new SolidBrush(Color.FromArgb(color)), points); } else { var pen = new Pen(Color.FromArgb(color), widthInPixels); target.Target.DrawPolygon(pen, points); } }
/// <summary> /// Draws an image on the target. /// </summary> /// <param name="target"></param> /// <param name="left"></param> /// <param name="top"></param> /// <param name="right"></param> /// <param name="bottom"></param> /// <param name="imageData"></param> /// <param name="tag"></param> protected override object DrawImage(Target2DWrapper <global::Android.Graphics.Canvas> target, double left, double top, double right, double bottom, byte[] imageData, object tag) { global::Android.Graphics.Bitmap image = (tag as global::Android.Graphics.Bitmap); if (image == null) { image = global::Android.Graphics.BitmapFactory.DecodeByteArray( imageData, 0, imageData.Length); } double[] topleft = this.Tranform(left, top); double[] bottomright = this.Tranform(right, bottom); float leftPixels = (float)topleft[0]; float topPixels = (float)topleft[1]; float rightPixels = (float)bottomright[0]; float bottomPixels = (float)bottomright[1]; target.Target.DrawBitmap(image, new global::Android.Graphics.Rect(0, 0, image.Width, image.Height), new global::Android.Graphics.RectF(leftPixels, topPixels, rightPixels, bottomPixels), null); return(image); }
/// <summary> /// Draws the image. /// </summary> /// <returns>The image.</returns> /// <param name="target">Target.</param> /// <param name="bounds">Bounds.</param> /// <param name="nativeImage">Image data.</param> protected override void DrawImage(Target2DWrapper <Canvas> target, RectangleF2D bounds, INativeImage nativeImage) { double transformed1_0, transformed1_1; var nativeAndroidImage = (nativeImage as NativeImage); global::Android.Graphics.Bitmap image = nativeAndroidImage.Image; // this.Transform(bounds.BottomLeft[0], bounds.BottomLeft[1], _transformed1); _toViewPort.Apply(bounds.BottomLeft[0], bounds.BottomLeft[1], out transformed1_0, out transformed1_1); var bottomLeft = new PointF2D(transformed1_0, transformed1_1); // this.Transform(bounds.BottomRight[0], bounds.BottomRight[1], _transformed1); _toViewPort.Apply(bounds.BottomRight[0], bounds.BottomRight[1], out transformed1_0, out transformed1_1); var bottomRight = new PointF2D(transformed1_0, transformed1_1); // this.Transform(bounds.TopLeft[0], bounds.TopLeft[1], _transformed1); _toViewPort.Apply(bounds.TopLeft[0], bounds.TopLeft[1], out transformed1_0, out transformed1_1); var topLeft = new PointF2D(transformed1_0, transformed1_1); //PointF2D topRight = new PointF2D(this.Tranform (bounds.TopRight [0], bounds.TopRight [1])); var transformed = new RectangleF2D(bottomLeft, bottomLeft.Distance(bottomRight), bottomLeft.Distance(topLeft), topLeft - bottomLeft); _paint.AntiAlias = true; _paint.FilterBitmap = true; target.Target.Save(); target.Target.Translate((float)transformed.BottomLeft [0], (float)transformed.BottomLeft [1]); target.Target.Rotate(-(float)((Degree)transformed.Angle).Value); if (image != null) { target.Target.DrawBitmap(image, new global::Android.Graphics.Rect(0, 0, image.Width, image.Height), new global::Android.Graphics.RectF(0, 0, (float)transformed.Width, (float)transformed.Height), _paint); } target.Target.Restore(); }
public static void CloseRender(this Target2DWrapper <RenderContext> target) { target.Target.CloseDrawingContext(); }
public static DrawingContext Render(this Target2DWrapper <RenderContext> target) { return(target.Target.GetDrawingContext()); }
public static void OpenRender(this Target2DWrapper <RenderContext> target) { target.Target.OpenDrawingContext(); }
protected override double FromPixels(Target2DWrapper <OpenGLTarget2D> target, View2D view, double sizeInPixels) { double scaleX = target.Width / view.Width; return(sizeInPixels / scaleX); }
protected override void DrawLineText(Target2DWrapper <OpenGLTarget2D> target, double[] x, double[] y, string text, int color, double size, int?haloColor, int?haloRadius, string fontName) { }
protected override void DrawImage(Target2DWrapper <OpenGLTarget2D> target, OsmSharp.Math.Primitives.RectangleF2D bounds, INativeImage tag) { }
protected override void DrawImage(Target2DWrapper <OpenGLTarget2D> target, double left, double top, double right, double bottom, INativeImage tag) { }
protected override void DrawIcon(Target2DWrapper <OpenGLTarget2D> target, double x, double y, byte[] imageData) { }