CanvasGraph.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Graphs.Canvas2D.Operations;
 
namespace Waher.Script.Graphs.Canvas2D
{
    public class CanvasGraph : Graph
    {
        private readonly ChunkedList<CanvasOperation> operations = new ChunkedList<CanvasOperation>();
        private SKColor? defaultColor;
        private SKColor? bgColor;
        private int width;
        private int height;
 
        public CanvasGraph()
            : this(new Variables())
        {
        }
 
        public CanvasGraph(Variables Variables)
            : this(Variables, null, null)
        {
        }
 
        public CanvasGraph(Variables Variables, int? DefaultWidth, int? DefaultHeight)
            : base(Variables, DefaultWidth, DefaultHeight)
        {
            this.width = this.Settings.Width;
            this.height = this.Settings.Height;
            this.bgColor = this.Settings.BackgroundColor;
        }
 
        public CanvasGraph(Variables Variables, int Width, int Height, SKColor? DefaultColor, SKColor? BackgroundColor)
            : this(Variables, Width, Height)
        {
            this.bgColor = BackgroundColor;
            this.defaultColor = DefaultColor;
        }
 
        public CanvasGraph(GraphSettings Settings, int Width, int Height, SKColor? DefaultColor, SKColor? BackgroundColor)
            : base(Settings, Width, Height)
        {
            this.width = this.Settings.Width;
            this.height = this.Settings.Height;
            this.bgColor = BackgroundColor;
            this.defaultColor = DefaultColor;
        }
 
        public SKColor? BgColor => this.bgColor;
 
        public new SKColor? DefaultColor => this.defaultColor;
 
        public int Width => this.width;
 
        public int Height => this.height;
 
        public override bool UsesDefaultColor => this.defaultColor != SKColors.Empty;
 
        public override bool TrySetDefaultColor(SKColor Color)
        {
            this.defaultColor = Color;
            return true;
        }
 
        public override ISemiGroupElement AddLeft(ISemiGroupElement Element)
        {
            if (Element is CanvasGraph G)
            {
                CanvasGraph Result = new CanvasGraph(G.Settings, G.width, G.height, G.bgColor, G.defaultColor);
 
                Result.operations.AddRange(G.operations);
                Result.operations.AddRange(this.operations);
 
                return Result;
            }
            else
                return null;
        }
 
        public override ISemiGroupElement AddRight(ISemiGroupElement Element)
        {
            if (Element is CanvasGraph G)
            {
                CanvasGraph Result = new CanvasGraph(this.Settings, this.width, this.height, this.bgColor, this.defaultColor);
 
                Result.operations.AddRange(this.operations);
                Result.operations.AddRange(G.operations);
 
                return Result;
            }
            else
                return null;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is CanvasGraph G) ||
                this.width != G.width ||
                this.height != G.height ||
                this.bgColor != G.bgColor ||
                this.defaultColor != G.defaultColor)
            {
                return false;
            }
 
            IEnumerator<CanvasOperation> e1 = this.operations.GetEnumerator();
            IEnumerator<CanvasOperation> e2 = G.operations.GetEnumerator();
            bool b1, b2;
 
            try
            {
                while (true)
                {
                    b1 = e1.MoveNext();
                    b2 = e2.MoveNext();
 
                    if (b1 ^ b2)
                        return false;
 
                    if (!b1)
                        return true;
 
                    if (!e1.Current.Equals(e2.Current))
                        return false;
                }
            }
            finally
            {
                e1.Dispose();
                e2.Dispose();
            }
        }
 
        public override int GetHashCode()
        {
            int Result = this.width.GetHashCode();
            Result ^= Result << 5 ^ this.height.GetHashCode();
            Result ^= Result << 5 ^ this.bgColor.GetHashCode();
            Result ^= Result << 5 ^ this.defaultColor.GetHashCode();
 
            foreach (CanvasOperation Op in this.operations)
                Result ^= Result << 5 ^ Op.GetHashCode();
 
            return Result;
        }
 
        public override PixelInformation CreatePixels(GraphSettings Settings, out object[] States)
        {
            using (SKSurface Surface = SKSurface.Create(new SKImageInfo(this.width, this.height, SKImageInfo.PlatformColorType, SKAlphaType.Premul)))
            {
                SKCanvas Canvas = Surface.Canvas;
                CanvasState State = new CanvasState()
                {
                    FgColor = this.defaultColor ?? Graph.DefaultColor,
                    BgColor = this.bgColor ?? Settings.BackgroundColor
                };
 
                Canvas.Clear(State.BgColor);
 
                foreach (CanvasOperation Op in this.operations)
                    Op.Draw(Canvas, State);
 
                using (SKImage Result = Surface.Snapshot())
                {
                    States = Array.Empty<object>();
                    return PixelInformation.FromImage(Result);
                }
            }
        }
 
        public override void ExportGraph(XmlWriter Output)
        {
            Output.WriteStartElement("CanvasGraph");
            Output.WriteAttributeString("width", this.width.ToString());
            Output.WriteAttributeString("height", this.height.ToString());
 
            if (this.bgColor.HasValue)
                Output.WriteAttributeString("bgColor", Expression.ToExpressionString(this.bgColor.Value));
 
            if (this.defaultColor.HasValue)
                Output.WriteAttributeString("defaultColor", Expression.ToExpressionString(this.defaultColor.Value));
 
            foreach (CanvasOperation Op in this.operations)
            {
                Output.WriteStartElement(Op.GetType().Name);
                Op.ExportGraph(Output);
                Output.WriteEndElement();
            }
 
            Output.WriteEndElement();
        }
 
        public override async Task ImportGraphAsync(XmlElement Xml)
        {
            Variables Variables = new Variables();
 
            foreach (XmlAttribute Attr in Xml.Attributes)
            {
                switch (Attr.Name)
                {
                    case "width":
                        this.width = int.Parse(Attr.Value);
                        break;
 
                    case "height":
                        this.height = int.Parse(Attr.Value);
                        break;
 
                    case "bgColor":
                        this.bgColor = Graph.ToColor((await ParseAsync(Attr.Value, Variables)).AssociatedObjectValue);
                        break;
 
                    case "defaultColor":
                        this.defaultColor = Graph.ToColor((await ParseAsync(Attr.Value, Variables)).AssociatedObjectValue);
                        break;
                }
            }
 
            string OperationNamespace = typeof(CanvasOperation).Namespace + ".";
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Type T = Types.GetType(OperationNamespace + E.LocalName);
                    if (T is null)
                        continue;
 
                    if (!(Types.Instantiate(T) is CanvasOperation Op))
                        continue;
 
                    await Op.ImportGraph(E, Variables);
 
                    this.operations.Add(Op);
                }
            }
        }
 
        public override string GetBitmapClickScript(double X, double Y, object[] States)
        {
            return "[" + Expression.ToString(X) + "," + Expression.ToString(Y) + "]";
        }
 
        public void LineTo(double x, double y)
        {
            this.operations.Add(new LineTo((float)x, (float)y));
        }
 
        public void MoveTo(double x, double y)
        {
            this.operations.Add(new MoveTo((float)x, (float)y));
        }
 
        public void Line(double x1, double y1, double x2, double y2)
        {
            this.operations.Add(new Line((float)x1, (float)y1, (float)x2, (float)y2));
        }
 
        public void PenWidth(double Width)
        {
            this.operations.Add(new PenWidth((float)Width));
        }
 
        public void Color(SKColor Color)
        {
            this.operations.Add(new PenColor(Color));
        }
 
        public void Color(object Color)
        {
            this.operations.Add(new PenColor(Graph.ToColor(Color)));
        }
 
        public void Rectangle(double x1, double y1, double x2, double y2)
        {
            this.operations.Add(new Rectangle((float)x1, (float)y1, (float)x2, (float)y2));
        }
 
        public void FillRectangle(double x1, double y1, double x2, double y2)
        {
            this.operations.Add(new FillRectangle((float)x1, (float)y1, (float)x2, (float)y2));
        }
 
        public void Plot(double x, double y)
        {
            this.operations.Add(new Plot((float)x, (float)y));
        }
 
        public void Ellipse(double x1, double y1, double x2, double y2)
        {
            this.operations.Add(new Ellipse((float)x1, (float)y1, (float)x2, (float)y2));
        }
 
        public void FillEllipse(double x1, double y1, double x2, double y2)
        {
            this.operations.Add(new FillEllipse((float)x1, (float)y1, (float)x2, (float)y2));
        }
 
        public void Clear()
        {
            this.operations.Add(new Clear());
        }
 
    }
}