SvgResource.cs

using System.Drawing;
using SkiaSharp;
using Svg.Skia;
 
namespace Gondwana.Drawing;

public sealed class SvgResource : IDisposable
{
    private readonly SKPicture _picture;
    private readonly object _cacheLock = new();
    private readonly Dictionary<(int Width, int Height), SKBitmap> _cachedBitmaps = new();
    private bool _disposed;
 
    private SvgResource(SKPicture picture, SizeF intrinsicSize)
    {
        _picture = picture;
        IntrinsicSize = intrinsicSize;
    }

    public static SvgResource Load(string path)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        using var stream = File.OpenRead(path);
        return Load(stream);
    }
 
    internal static SvgResource Load(Stream stream)
    {
        ArgumentNullException.ThrowIfNull(stream);
 
        var svg = new SKSvg();
        svg.Load(stream);
 
        if (svg.Picture is null)
            throw new InvalidOperationException("Failed to parse SVG content.");
 
        var cull = svg.Picture.CullRect;
        var intrinsic = new SizeF(cull.Width > 0 ? cull.Width : 1f,
                                  cull.Height > 0 ? cull.Height : 1f);
 
        return new SvgResource(svg.Picture, intrinsic);
    }

    public SizeF IntrinsicSize { get; }

    public SKBitmap Rasterize(int width, int height)
    {
        ThrowIfDisposed();
 
        if (width <= 0)
            throw new ArgumentOutOfRangeException(nameof(width), "Width must be greater than 0.");
 
        if (height <= 0)
            throw new ArgumentOutOfRangeException(nameof(height), "Height must be greater than 0.");
 
        lock (_cacheLock)
        {
            if (_cachedBitmaps.TryGetValue((width, height), out var cachedBitmap))
                return cachedBitmap;
 
            var bitmap = new SKBitmap(width, height, SKColorType.Bgra8888, SKAlphaType.Premul);
            using var canvas = new SKCanvas(bitmap);
            canvas.Clear(SKColors.Transparent);
 
            var src = _picture.CullRect;
            if (src.Width <= 0 || src.Height <= 0)
            {
                src = new SKRect(0, 0, Math.Max(1f, IntrinsicSize.Width), Math.Max(1f, IntrinsicSize.Height));
            }
 
            canvas.Scale(width / src.Width, height / src.Height);
            canvas.DrawPicture(_picture);
            canvas.Flush();
 
            _cachedBitmaps[(width, height)] = bitmap;
            return bitmap;
        }
    }

    public SKBitmap Rasterize(float scale = 1.0f)
    {
        ThrowIfDisposed();
 
        if (scale <= 0f)
            throw new ArgumentOutOfRangeException(nameof(scale), "Scale must be greater than 0.");
 
        int width = Math.Max(1, (int)MathF.Round(IntrinsicSize.Width * scale));
        int height = Math.Max(1, (int)MathF.Round(IntrinsicSize.Height * scale));
        return Rasterize(width, height);
    }

    public void Dispose()
    {
        if (_disposed)
            return;
 
        lock (_cacheLock)
        {
            foreach (var bitmap in _cachedBitmaps.Values)
                bitmap.Dispose();
 
            _cachedBitmaps.Clear();
            _picture.Dispose();
            _disposed = true;
        }
    }
 
    private void ThrowIfDisposed()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
    }
}