private static void DrawContent(CalloutStyle callout, SKCanvas canvas) { // Draw content if (callout.Content >= 0) { var strokeWidth = callout.StrokeWidth < 1 ? 1 : callout.StrokeWidth; var offsetX = callout.ShadowWidth + strokeWidth * 2 + (callout.Padding.Left < callout.RectRadius * 0.5 ? callout.RectRadius * 0.5f : (float)callout.Padding.Left); var offsetY = callout.ShadowWidth + strokeWidth * 2 + (callout.Padding.Top < callout.RectRadius * 0.5 ? callout.RectRadius * 0.5f : (float)callout.Padding.Top); switch (callout.ArrowAlignment) { case ArrowAlignment.Left: offsetX += callout.ArrowHeight; break; case ArrowAlignment.Top: offsetY += callout.ArrowHeight; break; } var offset = new SKPoint(offsetX, offsetY); if (callout.Type == CalloutType.Custom) { // Get size of content var bitmapInfo = BitmapHelper.LoadBitmap(BitmapRegistry.Instance.Get(callout.Content)); switch (bitmapInfo?.Type) { case BitmapType.Bitmap: canvas.DrawImage(bitmapInfo.Bitmap, offset); break; case BitmapType.Sprite: throw new Exception(); case BitmapType.Svg: if (bitmapInfo.Svg != null) { using var skPaint = new SKPaint() { IsAntialias = true }; canvas.DrawPicture(bitmapInfo.Svg.Picture, offset, skPaint); } break; } } else if (callout.Type == CalloutType.Single || callout.Type == CalloutType.Detail) { var picture = (SKPicture)BitmapRegistry.Instance.Get(callout.Content); using var skPaint = new SKPaint() { IsAntialias = true }; canvas.DrawPicture(picture, offset, skPaint); } } }
public void DrawPicture(SKPicture picture, ref SKMatrix matrix, SKPaint paint = null) { canvas.DrawPicture(picture, ref matrix, paint); if (calculateBounds) { displayObject.addBoundingRect(matrix.TransX, matrix.TransY, picture.CullRect.Width, picture.CullRect.Height); } }
void canvasFront_PaintSurface(System.Object sender, SkiaSharp.Views.Forms.SKPaintSurfaceEventArgs e) { SKCanvas canvas = e.Surface.Canvas; canvas.Clear(); SKMatrix matrix = DrawHelper.GetFullSvgScaledMatrix(e.Info.Width, e.Info.Height, pictureFront); canvas.DrawPicture(pictureFront, ref matrix); float offsetY = e.Info.Height / 5; foreach (DrawItem item in DrawData.DrawnPathsFront) { SKPath p = new SKPath(item.Path); float offsetCalcY = (float)DrawHelper.GetOffsetCalculationsForFullDisplay(item.Area, offsetY); float offsetCalcX = ((e.Info.Width - matrix.TransX) / 2.0f) * 0.375f; p.Transform(SKMatrix.CreateScaleTranslation(0.25f, 0.25f, offsetCalcX, offsetCalcY)); _data.Add(new SvgData { BodyRegion = item.Area.ToString(), IsFront = true, StrokeColor = item.Paint.Color.ToFormsColor(), StrokeWidth = item.Paint.StrokeWidth, SvgPath = p.ToSvgPathData(), ConcernName = item.Name }); canvas.DrawPath(p, DrawHelper.GetScaledPaintObject(item.Paint.Color, item.Paint.StrokeWidth)); } imageDataF = e.Surface.Snapshot(); }
private void SaveVector(Shape shape) { var svg = new SkiaSharp.Extended.Svg.SKSvg(); svg.Load(shape.OutputPath); var svgRect = svg.Picture.CullRect; var(w, h) = CalculateResized((int)svgRect.Width, (int)svgRect.Height); float svgMax = Math.Max(w, h); float scale = w / svgRect.Width; var matrixS = SKMatrix.MakeScale(scale, scale); var matrixT = SKMatrix.MakeTranslation((MAX_SIZE - w) / 2, (MAX_SIZE - h) / 2); var matrix = SKMatrix.MakeIdentity(); SKMatrix.Concat(ref matrix, matrixT, matrixS); var target = new SKBitmap(MAX_SIZE, MAX_SIZE, SKImageInfo.PlatformColorType, SKAlphaType.Premul); using (target) using (var canvas = new SKCanvas(target)) { canvas.Clear(); canvas.DrawPicture(svg.Picture, ref matrix, _skPaint); SaveToFile(shape.Id, "svg", target); } }
public static void Draw(SKCanvas canvas, SkiaSharp.Extended.Svg.SKSvg svg, float x, float y, float orientation = 0, float offsetX = 0, float offsetY = 0, LabelStyle.HorizontalAlignmentEnum horizontalAlignment = LabelStyle.HorizontalAlignmentEnum.Left, LabelStyle.VerticalAlignmentEnum verticalAlignment = LabelStyle.VerticalAlignmentEnum.Top, float opacity = 1f, float scale = 1f) { // todo: I assume we also need to apply opacity. // todo: It seems horizontalAlignment and verticalAlignment would make sense too. Is this similar to Anchor? canvas.Save(); canvas.Translate(x, y); canvas.RotateDegrees(orientation, 0, 0); // todo: degrees or radians? canvas.Scale(scale, scale); var halfWidth = svg.CanvasSize.Width / 2; var halfHeight = svg.CanvasSize.Height / 2; // 0/0 are assumed at center of image, but Svg has 0/0 at left top position canvas.Translate(-halfWidth + offsetX, -halfHeight - offsetY); canvas.DrawPicture(svg.Picture, new SKPaint() { IsAntialias = true }); canvas.Restore(); }
public static void Draw(SKCanvas canvas, SKSvg svg, float x, float y, float orientation = 0, float offsetX = 0, float offsetY = 0, float opacity = 1f, float scale = 1f) { if (svg.Picture == null) { return; } canvas.Save(); canvas.Translate(x, y); canvas.RotateDegrees(orientation, 0, 0); // todo: degrees or radians? canvas.Scale(scale, scale); var halfWidth = svg.Picture.CullRect.Width / 2; var halfHeight = svg.Picture.CullRect.Height / 2; // 0/0 are assumed at center of image, but Svg has 0/0 at left top position canvas.Translate(-halfWidth + offsetX, -halfHeight - offsetY); var alpha = Convert.ToByte(255 * opacity); var transparency = SKColors.White.WithAlpha(alpha); using (var cf = SKColorFilter.CreateBlendMode(transparency, SKBlendMode.DstIn)) { using var skPaint = new SKPaint { IsAntialias = true, ColorFilter = cf, }; canvas.DrawPicture(svg.Picture, skPaint); } canvas.Restore(); }
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args) { SKCanvas canvas = args.Surface.Canvas; canvas.Clear(); SKPaint tempPaint = DrawHelper.GetCurrentPaintObject(true, brushColourToBeUsed, brushThickness); SKMatrix matrix = DrawHelper.GetAreaSvgScaledMatrix(args.Info.Width, args.Info.Height, picture, areaUsed); canvas.DrawPicture(picture, ref matrix); foreach (DrawItem item in isFrontBody ? DrawData.DrawnPathsFront : DrawData.DrawnPathsBack) { if (areaUsed == item.Area) { canvas.DrawPath(item.Path, item.Paint); } } foreach (DrawItem drawItem in completedPaths) { canvas.DrawPath(drawItem.Path, drawItem.Paint); } foreach (SKPath path in inProgressPaths.Values) { canvas.DrawPath(path, tempPaint); } btnSave.IsVisible = completedPaths.Count > 0; btnUndo.IsVisible = completedPaths.Count > 0; btnMirror.IsVisible = completedPaths.Count > 0; imageData = args.Surface.Snapshot(); }
public ImageSource ProvideValue(IServiceProvider serviceProvider) { if (string.IsNullOrEmpty(ResourceName)) { return(null); } if (!imagedataDictionary.TryGetValue(ResourceName, out var imagedata)) { var assembly = GetType().GetTypeInfo().Assembly; var assemblyName = assembly.GetName().Name; var skSvg = new SkiaSharp.Extended.Svg.SKSvg(new SKSize(Width, Height)); skSvg.Load(assembly.GetManifestResourceStream(assemblyName + "." + ResourceName)); var bitmap = new SKBitmap(Width, Height); var canvas = new SKCanvas(bitmap); canvas.Clear(SKColors.Transparent); canvas.DrawPicture(skSvg.Picture); canvas.Flush(); canvas.Save(); imagedata = SKImage.FromBitmap(bitmap).ToRasterImage().Encode(SKEncodedImageFormat.Png, 100); imagedataDictionary.Add(ResourceName, imagedata); } return(ImageSource.FromStream(() => imagedata.AsStream())); }
/// <summary> /// Creates the image. /// </summary> /// <returns>The image.</returns> /// <param name="stream">Stream.</param> /// <param name="width">Width.</param> /// <param name="height">Height.</param> /// <param name="color">Color.</param> public static Task <Stream> CreateImage(Stream stream, double width, double height, Color color) { var screenScale = SvgImageSource.ScreenScale; var svg = new SkiaSharp.Extended.Svg.SKSvg(); svg.Load(stream); var size = CalcSize(svg.Picture.CullRect.Size, width, height); var scale = CalcScale(svg.Picture.CullRect.Size, size, screenScale); var matrix = SKMatrix.MakeScale(scale.Item1, scale.Item2); using (var bitmap = new SKBitmap((int)(size.Width * screenScale), (int)(size.Height * screenScale))) using (var canvas = new SKCanvas(bitmap)) using (var paint = new SKPaint()) { if (!color.IsDefault) { paint.ColorFilter = SKColorFilter.CreateBlendMode(ToSKColor(color), SKBlendMode.SrcIn); } canvas.Clear(SKColors.Transparent); // very very important! canvas.DrawPicture(svg.Picture, ref matrix, paint); using (var image = SKImage.FromBitmap(bitmap)) using (var encoded = image.Encode()) { var imageStream = new MemoryStream(); encoded.SaveTo(imageStream); imageStream.Position = 0; return(Task.FromResult(imageStream as Stream)); } } }
public override void DrawUnscaled(SKCanvas canvas, float scale) { if (scale >= 1) { // draw using default scaling canvas.DrawPicture(svg.Picture, Paint); } else { // draw using raster downscaling var size = GetOriginalSize(); // vector scaling has rounding issues, so first draw as intended var info = new SKImageInfo((int)size.Width, (int)size.Height); using var bmp = new SKBitmap(info); using var cvn = new SKCanvas(bmp); // draw to a larger canvas first cvn.Clear(SKColors.Transparent); cvn.DrawPicture(svg.Picture, Paint); // set the paint to be the highest quality it can find var paint = new SKPaint { IsAntialias = true, FilterQuality = SKFilterQuality.High }; // draw to the main canvas using the correct quality settings canvas.DrawBitmap(bmp, 0, 0, paint); } }
private void SKElement_OnPaintSurface(object sender, SKPaintSurfaceEventArgs e) { SKCanvas canvas = e.Surface.Canvas; canvas.Clear(); if (Svg == null) { return; } SKImageInfo info = e.Info; canvas.Translate(info.Width / 2f, info.Height / 2f); SKRect bounds = Svg.ViewBox; float xRatio = info.Width / bounds.Width; float yRatio = info.Height / bounds.Height; float ratio = Math.Min(xRatio, yRatio); canvas.Scale(ratio); canvas.Translate(-bounds.MidX, -bounds.MidY); using (var paint = new SKPaint()) { paint.ColorFilter = SKColorFilter.CreateBlendMode(Colors.Red.ToSKColor(), SKBlendMode.SrcIn); canvas.DrawPicture(Svg.Picture, paint); } }
private void CanvasViewOnPaintSurface(object sender, SKPaintSurfaceEventArgs args) { SKCanvas canvas = args.Surface.Canvas; canvas.Clear(); if (string.IsNullOrEmpty(SvgPath)) { return; } using (Stream stream = SvgAssembly.GetManifestResourceStream(SvgPath)) { SKSvg svg = new SKSvg(); svg.Load(stream); SKImageInfo info = args.Info; canvas.Translate(info.Width / 2f, info.Height / 2f); SKRect bounds = svg.ViewBox; float xRatio = info.Width / bounds.Width; float yRatio = info.Height / bounds.Height; float ratio = Math.Min(xRatio, yRatio); canvas.Scale(ratio); canvas.Translate(-bounds.MidX, -bounds.MidY); canvas.DrawPicture(svg.Picture); } }
public static SKData EncodeSvg(FsPath svgFile, int maxWidht, int maxHeight, SKEncodedImageFormat format = SKEncodedImageFormat.Png) { var svg = new SKSvg(); svg.Load(svgFile.ToString()); if (svg.Picture == null) { return(SKData.Empty); } SKRect svgSize = svg.Picture.CullRect; (int renderWidth, int renderHeight, float scale)sizeData = CalcNewSize(svgSize, maxWidht, maxHeight); var matrix = SKMatrix.CreateScale(sizeData.scale, sizeData.scale); using (SKBitmap bitmap = new SKBitmap(sizeData.renderWidth, sizeData.renderHeight)) { using (SKCanvas canvas = new SKCanvas(bitmap)) { canvas.DrawPicture(svg.Picture, ref matrix); canvas.Flush(); } using (SKImage image = SKImage.FromBitmap(bitmap)) { return(image.Encode(format, 100)); } } }
public void SvgLoadsDashes() { var path = Path.Combine(PathToImages, "dashes.svg"); var svg = new SKSvg(); svg.Load(path); var bmp = new SKBitmap((int)svg.CanvasSize.Width, (int)svg.CanvasSize.Height); var canvas = new SKCanvas(bmp); canvas.Clear(SKColors.White); canvas.DrawPicture(svg.Picture); canvas.Flush(); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 3, 20)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 7, 20)); Assert.AreEqual(SKColors.White, bmp.GetPixel(10 + 13, 20)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 3, 40)); Assert.AreEqual(SKColors.White, bmp.GetPixel(10 + 7, 40)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 13, 40)); Assert.AreEqual(SKColors.White, bmp.GetPixel(10 + 3, 60)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 7, 60)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 13, 60)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 3, 80)); Assert.AreEqual(SKColors.Black, bmp.GetPixel(10 + 7, 80)); Assert.AreEqual(SKColors.White, bmp.GetPixel(10 + 13, 80)); }
public static void RenderSvg(SKCanvas canvas, SkiaSharp.Extended.Svg.SKSvg svg, float x, float y, float orientation = 0, float offsetX = 0, float offsetY = 0, LabelStyle.HorizontalAlignmentEnum horizontalAlignment = LabelStyle.HorizontalAlignmentEnum.Left, LabelStyle.VerticalAlignmentEnum verticalAlignment = LabelStyle.VerticalAlignmentEnum.Top, float opacity = 1f, float scale = 1f) { canvas.Save(); canvas.Translate(x, y); canvas.RotateDegrees(orientation, 0, 0); // todo: degrees or radians? canvas.Scale(scale, scale); var halfWidth = svg.CanvasSize.Width / 2; var halfHeight = svg.CanvasSize.Height / 2; // 0/0 are assumed at center of image, but Svg has 0/0 at left top position canvas.Translate(-halfWidth + offsetX, -halfHeight - offsetY); var rect = new SKRect(-halfWidth, -halfHeight, +halfWidth, +halfHeight); //var color = new SKColor(255, 255, 255, (byte)(255 * opacity)); //var paint = new SKPaint { Color = color, FilterQuality = SKFilterQuality.High }; canvas.DrawPicture(svg.Picture, null); canvas.Restore(); }
private void Canvas_PaintSurface(object sender, SKPaintSurfaceEventArgs e) { SKImageInfo info = e.Info; SKSurface surface = e.Surface; SKCanvas canvas = surface.Canvas; var paint = new SKPaint { Style = SKPaintStyle.Stroke, Color = Color.Violet.ToSKColor(), StrokeWidth = 25, }; if (ShowBase) { canvas.DrawPath(this.basePath, paint); } paths.ForEach(p => canvas.DrawPath(p, paint)); if (null != path) { canvas.DrawPath(path, paint); } canvas.DrawPicture(sKSvg.Value.Picture); //canvas.DrawCircle(info.Width / 2, info.Height / 2, 100, paint); }
private void OnPaintSurfaceSvg(SKCanvas canvas, int width, int height) { if (items.SelectedItem is Item item) { var stopwatch = Stopwatch.StartNew(); canvas.Clear(SKColors.White); if (item.Picture != null) { float pwidth = item.Picture.CullRect.Width; float pheight = item.Picture.CullRect.Height; if (pwidth > 0f && pheight > 0f) { skElementSvg.Width = pwidth; skElementSvg.Height = pheight; canvas.DrawPicture(item.Picture); } } stopwatch.Stop(); TextDrawTime.Text = $"{Math.Round(stopwatch.Elapsed.TotalMilliseconds, 3)}ms"; Debug.WriteLine($"Draw: {Math.Round(stopwatch.Elapsed.TotalMilliseconds, 3)}ms"); } else { canvas.Clear(SKColors.White); } }
public void Render(SKCanvas canvas) { if (AbsoluteVisible) { var textureBox = Texture.ViewBox; var textureWidth = textureBox.Width; var textureHeight = textureBox.Height; var scaleX = this.Width / textureWidth; var scaleY = this.Height / textureHeight; SKMatrix scaleMatrix = SKMatrix.MakeScale(scaleX, scaleY); // Gum uses counter clockwise rotation, Skia uses clockwise, so invert: SKMatrix rotationMatrix = SKMatrix.MakeRotationDegrees(-Rotation); SKMatrix translateMatrix = SKMatrix.MakeTranslation(this.GetAbsoluteX(), this.GetAbsoluteY()); SKMatrix result = SKMatrix.MakeIdentity(); SKMatrix.Concat( ref result, rotationMatrix, scaleMatrix); SKMatrix.Concat( ref result, translateMatrix, result); canvas.DrawPicture(Texture.Picture, ref result); } }
public void SvgRespectsClipPath() { var path = Path.Combine(PathToImages, "clipping.svg"); var background = (SKColor)0xffffffff; var fill = (SKColor)0xff000000; var svg = new SKSvg(); svg.Load(path); var bmp = new SKBitmap((int)svg.CanvasSize.Width, (int)svg.CanvasSize.Height); var canvas = new SKCanvas(bmp); canvas.Clear(background); canvas.DrawPicture(svg.Picture); canvas.Flush(); for (int x = 1; x < 20; x++) { for (int y = 1; y < 20; y++) { Assert.Equal(fill, bmp.GetPixel(x, y)); Assert.Equal(background, bmp.GetPixel(x + 20, y + 20)); } } }
private void DrawPicture(SKCanvas canvas, SKPicture picture, double dx, double dy, double zx, double zy) { canvas.Save(); canvas.Translate((float)dx, (float)dy); canvas.Scale((float)zx, (float)zy); canvas.DrawPicture(picture); canvas.Restore(); }
public static void Draw(this SKPicture skPicture, SKColor background, float scaleX, float scaleY, SKCanvas skCanvas) { skCanvas.DrawColor(background); skCanvas.Save(); skCanvas.Scale(scaleX, scaleY); skCanvas.DrawPicture(skPicture); skCanvas.Restore(); }
/// <summary> /// Назначить из Assets\svg SVG-картинку на ImageView /// </summary> /// <param name="imgView"></param> /// <param name="fileName"></param> /// <param name="wantedWidth"></param> /// <param name="wantedHeight"></param> /// <param name="preprocess"></param> public static void AssignSvg([NotNull] ImageView imgView, string fileName, Action <XmlDocument> preprocess, int?wantedWidth = null, int?wantedHeight = null) { if (wantedWidth == null) { wantedWidth = imgView.Width; } if (wantedHeight == null) { wantedHeight = imgView.Height; } const int bestQuality = 100; var parentColor = TryGetBackgroundColor(imgView); var viewActivity = (Activity)imgView.Context; using (var reader = new StreamReader(viewActivity.Assets.Open(Path.Combine("svg", Path.ChangeExtension(fileName, "svg").AssertNull())))) { var xmlDoc = new XmlDocument(); xmlDoc.Load(reader); xmlDoc.DocumentElement.VoidAssertNull(); xmlDoc.DocumentElement.SetAttribute("width", wantedWidth.ToString()); xmlDoc.DocumentElement.SetAttribute("height", wantedHeight.ToString()); preprocess?.Invoke(xmlDoc); if (parentColor.HasValue) { var bkColorRect = xmlDoc.CreateElement("rect"); bkColorRect.SetAttribute("style", $"fill: {parentColor.Value.ToHtmlValue()}"); bkColorRect.SetAttribute("x", "0"); bkColorRect.SetAttribute("y", "0"); bkColorRect.SetAttribute("width", wantedWidth.ToString()); bkColorRect.SetAttribute("height", wantedHeight.ToString()); xmlDoc.DocumentElement.AssertNull().InsertAfter(bkColorRect, null); } using (var alterStream = new MemoryStream()) { xmlDoc.Save(alterStream); alterStream.Seek(0, SeekOrigin.Begin); var svg = new SkiaSharp.Extended.Svg.SKSvg(new SKSize(wantedWidth.Value, wantedHeight.Value)); svg.Load(alterStream); using (var svgBitmap = new SKBitmap((int)svg.CanvasSize.Width, (int)svg.CanvasSize.Height)) { using (var canvas = new SKCanvas(svgBitmap)) { canvas.DrawPicture(svg.Picture); canvas.Flush(); canvas.Save(); } using (var image = SKImage.FromBitmap(svgBitmap)) using (var data = image.Encode(SKEncodedImageFormat.Png, bestQuality)) { var bmpArray = data.ToArray(); imgView.SetImageBitmap(BitmapFactory.DecodeByteArray(bmpArray, 0, bmpArray.Length)); } } } } }
public void Render(SKCanvas canvas, float angleInRadians, SKPoint center, float scale) { if (_svgScene == null) { _svgScene = LoadScene(); } canvas.Clear(SKColors.White); canvas.DrawPicture(_svgScene); }
public static ImageSource GetAsImageSource(string svgImage, float width, float height, Color color) { var scaleFactor = PlatformHelper.GetScaleFactor(); SkiaSharp.Extended.Svg.SKSvg svg = PlatformHelper.Load(svgImage); var svgSize = svg.Picture.CullRect; var svgMax = Math.Max(svgSize.Width, svgSize.Height); var canvasMin = Math.Min((int)(width * scaleFactor), (int)(height * scaleFactor)); var scale = canvasMin / svgMax; var matrix = SKMatrix.MakeScale(scale, scale); var bitmap = new SKBitmap((int)(width * scaleFactor), (int)(height * scaleFactor)); var canvas = new SKCanvas(bitmap); canvas.Clear(); if (color != Color.Default) { var paint = new SKPaint() { ColorFilter = SKColorFilter.CreateBlendMode(color.ToSKColor(), SKBlendMode.SrcIn) }; canvas.DrawPicture(svg.Picture, ref matrix, paint); } else { canvas.DrawPicture(svg.Picture, ref matrix); } var image = SKImage.FromBitmap(bitmap); var encoded = image.Encode(); var stream = encoded.AsStream(); var bytes = ReadFully(stream); var source = ImageSource.FromStream(() => new MemoryStream(bytes)); return(source); }
private void SkCanvas_OnPaintSurface(object sender, SKPaintGLSurfaceEventArgs e) { SKImageInfo info = new SKImageInfo(e.BackendRenderTarget.Width, e.BackendRenderTarget.Height, e.ColorType); SKSurface surface = e.Surface; SKCanvas surfaceCanvas = surface.Canvas; surfaceCanvas.Clear(); surfaceCanvas.SetMatrix(_canvasMatrix); if (_picture == null) { using (SKPictureRecorder pictureRecorder = new SKPictureRecorder()) using (SKCanvas canvas = pictureRecorder.BeginRecording(info.Rect)) using (SKPath path = new SKPath()) { /* * Draw path with multiple segments(>=3). * Then every time you translate the surfaceCanvas, it consumes more GPU memory. */ path.CubicTo(150, 50, 200, 125, 300, 25); // path.LineTo(80, 125); // path.LineTo(130, 75); // path.LineTo(200, 205); canvas.DrawPath(path, _paint); // Fine with DrawRoundRect or DrawText // canvas.DrawText("TEXT", new SKPoint(50, 50), _paint); // canvas.DrawRoundRect(120,120,300,220,12,12,paint); _picture = pictureRecorder.EndRecording(); } } surfaceCanvas.DrawPicture(_picture); /* * Directly drawing on surfaceCanvas is fine. */ // using (SKPath path = new SKPath()) // { // path.CubicTo(150, 50, 200, 125, 300, 25); // // path.LineTo(80, 125); // path.LineTo(130, 75); // path.LineTo(200, 205); // // surfaceCanvas.DrawPath(path, _paint); // } }
public static void Draw(SKCanvas canvas, IReadOnlyViewport viewport, float opacity, Point destination, CalloutStyle calloutStyle) { if (calloutStyle.BitmapId < 0 || calloutStyle.Invalidated) { if (calloutStyle.Content < 0 && calloutStyle.Type == CalloutType.Custom) { return; } if (calloutStyle.Invalidated) { UpdateContent(calloutStyle); } RenderCallout(calloutStyle); } // Now we have the complete callout rendered, so we could draw it if (calloutStyle.BitmapId < 0) { return; } var picture = (SKPicture)BitmapRegistry.Instance.Get(calloutStyle.BitmapId); // Calc offset (relative or absolute) var symbolOffsetX = calloutStyle.SymbolOffset.IsRelative ? picture.CullRect.Width * (float)calloutStyle.SymbolOffset.X : (float)calloutStyle.SymbolOffset.X; var symbolOffsetY = calloutStyle.SymbolOffset.IsRelative ? picture.CullRect.Height * (float)calloutStyle.SymbolOffset.Y : (float)calloutStyle.SymbolOffset.Y; var rotation = (float)calloutStyle.SymbolRotation; if (calloutStyle.RotateWithMap) { rotation += (float)viewport.Rotation; } // Save state of the canvas, so we could move and rotate the canvas canvas.Save(); // Move 0/0 to the Anchor point of Callout canvas.Translate((float)destination.X - symbolOffsetX, (float)destination.Y - symbolOffsetY); canvas.Scale((float)calloutStyle.SymbolScale, (float)calloutStyle.SymbolScale); // 0/0 are assumed at center of image, but Picture has 0/0 at left top position canvas.RotateDegrees(rotation); canvas.Translate((float)calloutStyle.Offset.X, (float)calloutStyle.Offset.Y); canvas.DrawPicture(picture, new SKPaint() { IsAntialias = true }); canvas.Restore(); }
public bool Draw(SKCanvas canvas, IReadOnlyViewport viewport, ILayer layer, IFeature feature, IStyle style, ISymbolCache symbolCache) { var image = ((SvgStyle)style).GetImage(); if (image == null) { return(true); } var center = viewport.Center; //SvgRenderer.Draw(canvas, image, -(float)viewport.Center.X, (float)viewport.Center.Y, (float)viewport.Rotation, 0,0,default, default, default, (float)viewport.Resolution); canvas.Save(); var zoom = 1 / (float)viewport.Resolution; var canvasSize = canvas.LocalClipBounds; var canvasCenterX = canvasSize.Width / 2; var canvasCenterY = canvasSize.Height / 2; //float width = (float)MapPage.currentBounds.Width; //float height = (float)MapPage.currentBounds.Height; float width = image.Picture.CullRect.Width; float height = image.Picture.CullRect.Height; float num1 = (width / 2) * zoom; float num2 = (-height) * zoom; canvas.Translate(canvasCenterX, num2 + canvasCenterY); canvas.Translate(-(float)viewport.Center.X * zoom, (float)viewport.Center.Y * zoom); canvas.Scale(zoom, zoom); canvas.RotateDegrees((float)viewport.Rotation, 0.0f, 0.0f); canvas.DrawPicture(image.Picture, new SKPaint() { IsAntialias = true }); canvas.Restore(); return(true); }
public void Render(LayerTree layer_tree) { if (layer_tree == null) { return; } SKSizeI frame_size = new SKSizeI((int)_physicalWidth, (int)_physicalHeight); if (frame_size.IsEmpty) { return; } layer_tree.set_frame_size(frame_size); // ** Start Hack // I just wanted it outputted at this time, rather than frame dependant // var picture = layer_tree.Flatten(new SKRect(0, 0, frame_size.Width, frame_size.Height)); var picture = ((PictureLayer)((ContainerLayer)layer_tree.root_layer_).layers_[0]).picture(); //// get the screen density for scaling //var scale = _scale; //var scaledSize = new SKSize(frame_size.Width / scale, frame_size.Height / scale); ////// handle the device screen density //_canvas.Scale(_scale); //// make sure the canvas is blank //_canvas.Clear(SKColors.White); //// draw some text //var paint = new SKPaint //{ // Color = SKColors.Black, // IsAntialias = true, // Style = SKPaintStyle.Fill, // TextAlign = SKTextAlign.Center, // TextSize = 24 //}; //var coord = new SKPoint(scaledSize.Width / 2, (scaledSize.Height + paint.TextSize) / 2); //_canvas.DrawText("Xamarin.Flutter", coord, paint); _canvas.DrawPicture(picture); //_canvas.DrawText("Hello", scaledSize.Width / 2, (scaledSize.Height + paint.TextSize) / 2, paint); // ** End Hack // This is where we are meant to go //animator_.Render(layer_tree); }
protected override void OnDrawSample(SKCanvas canvas, int width, int height) { canvas.Clear(SKColors.White); float canvasMin = Math.Min(width, height); float svgMax = Math.Max(svg.Picture.CullRect.Width, svg.Picture.CullRect.Height); float scale = canvasMin / svgMax; var matrix = SKMatrix.MakeScale(scale, scale); canvas.DrawPicture(svg.Picture, ref matrix); }
private void CanvasViewOnPaintSurface(object sender, SKPaintSurfaceEventArgs args) { SKCanvas canvas = args.Surface.Canvas; canvas.Clear(); using (Stream stream = GetType().Assembly.GetManifestResourceStream("debugSVG.demo.svg")) { SKSvg svg = new SKSvg(); svg.Load(stream); canvas.DrawPicture(svg.Picture); } }