GraphBitmap.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Script.Graphs
{
    public class GraphBitmap : Graph, IDisposable
    {
        private PixelInformation pixels;
 
        public GraphBitmap(Variables Variables)
            : this(Variables, null, null)
        {
        }
 
        public GraphBitmap(Variables Variables, int? DefaultWidth, int? DefaultHeight)
            : base(Variables, DefaultWidth, DefaultHeight)
        {
        }
 
        public GraphBitmap(Variables Variables, PixelInformation Pixels)
            : base(Variables, Pixels.Width, Pixels.Height)
        {
            this.pixels = Pixels;
        }
 
        public GraphBitmap(GraphSettings Settings, PixelInformation Pixels)
            : base(Settings, Pixels.Width, Pixels.Height)
        {
            this.pixels = Pixels;
        }
 
        public override ISemiGroupElement AddLeft(ISemiGroupElement Element)
        {
            if (!(Element is Graph G))
                return null;
 
            GraphSettings Settings = new GraphSettings();
            if (!(this.pixels is null))
            {
                Settings.Width = this.pixels.Width;
                Settings.Height = this.pixels.Height;
            }
 
            PixelInformation Pixels = G.CreatePixels(Settings);
 
            using (SKSurface Surface = SKSurface.Create(new SKImageInfo(Math.Max(Pixels.Width, this.pixels?.Width ?? 0),
                Math.Max(Pixels.Height, this.pixels?.Height ?? 0), SKImageInfo.PlatformColorType, SKAlphaType.Premul)))
            {
                SKCanvas Canvas = Surface.Canvas;
 
                using (SKImage Bmp = Pixels.CreateBitmap())
                {
                    Canvas.DrawImage(Bmp, 0, 0);
                }
 
                if (!(this.pixels is null))
                {
                    using (SKImage Image = this.pixels.CreateBitmap())
                    {
                        Canvas.DrawImage(Image, 0, 0);
                    }
                }
 
                using (SKImage Result = Surface.Snapshot())
                {
                    return new GraphBitmap(this.Settings, PixelInformation.FromImage(Result));
                }
            }
        }
 
        public override ISemiGroupElement AddRight(ISemiGroupElement Element)
        {
            if (!(Element is Graph G))
                return null;
 
            GraphSettings Settings = new GraphSettings();
            if (!(this.pixels is null))
            {
                Settings.Width = this.pixels.Width;
                Settings.Height = this.pixels.Height;
            }
 
            PixelInformation Pixels = G.CreatePixels(Settings);
 
            using (SKSurface Surface = SKSurface.Create(new SKImageInfo(Math.Max(Pixels.Width, this.pixels?.Width ?? 0),
                Math.Max(Pixels.Height, this.pixels?.Height ?? 0), SKImageInfo.PlatformColorType, SKAlphaType.Premul)))
            {
                SKCanvas Canvas = Surface.Canvas;
 
                if (!(this.pixels is null))
                {
                    using (SKImage Image = this.pixels.CreateBitmap())
                    {
                        Canvas.DrawImage(Image, 0, 0);
                    }
                }
 
                using (SKImage Bmp = Pixels.CreateBitmap())
                {
                    Canvas.DrawImage(Bmp, 0, 0);
                }
 
                using (SKImage Result = Surface.Snapshot())
                {
                    return new GraphBitmap(this.Settings, PixelInformation.FromImage(Result));
                }
            }
        }
 
        public override PixelInformation CreatePixels(GraphSettings Settings, out object[] States)
        {
            States = new object[0];
            return this.pixels;
        }
 
        public override Tuple<int, int> RecommendedBitmapSize
        {
            get
            {
                return new Tuple<int, int>(this.pixels?.Width ?? 0, this.pixels?.Height ?? 0);
            }
        }
 
        public override string GetBitmapClickScript(double X, double Y, object[] States)
        {
            return "[" + Expression.ToString(X) + "," + Expression.ToString(Y) + "]";
        }
 
        public override bool Equals(object obj)
        {
            return (obj is GraphBitmap B && (this.pixels?.Equals(B.pixels) ?? (B.pixels is null)));
        }
 
        public override int GetHashCode()
        {
            return this.pixels?.GetHashCode() ?? 0;
        }
 
        public void Dispose()
        {
        }
 
        public override void ExportGraph(XmlWriter Output)
        {
            if (!(this.pixels is null))
            {
                Output.WriteStartElement("GraphBitmap");
                Output.WriteAttributeString("width", this.pixels.Width.ToString());
                Output.WriteAttributeString("height", this.pixels.Height.ToString());
 
                Output.WriteElementString("Png", Convert.ToBase64String(this.pixels.EncodeAsPng()));
 
                Output.WriteEndElement();
            }
        }
 
        public override Task ImportGraphAsync(XmlElement Xml)
        {
            int Width = int.Parse(Xml.GetAttribute("width"));
            int Height = int.Parse(Xml.GetAttribute("height"));
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "Png")
                {
                    byte[] Data = Convert.FromBase64String(E.InnerText);
                    this.pixels = new PixelInformationPng(Data, Width, Height);
                    break;
                }
            }
 
            return Task.CompletedTask;
        }
 
        public override bool UsesDefaultColor => false;
 
        public override bool TrySetDefaultColor(SKColor Color)
        {
            return false;
        }
 
    }
}