PathState.cs

using System;
using SkiaSharp;
 
namespace Waher.Layout.Layout2D.Model.Figures.SegmentNodes
{
    public class PathState
    {
        private readonly Path pathDef;
        private readonly SKPath path;
        private readonly bool calcStart;
        private readonly bool calcEnd;
        private float x0, y0;
        private float x, y;
        private float xPrev, yPrev;
        private float? angle;
        private bool drawingSpline = false;
        private PathSpline currentSpline = null;
        private bool nonSpline = false;
 
        public PathState(Path PathDef, SKPath Path, bool CalcStart, bool CalcEnd)
        {
            this.pathDef = PathDef;
            this.path = Path;
            this.calcStart = CalcStart;
            this.calcEnd = CalcEnd;
        }
 
        public float X => this.x;
 
        public float Y => this.y;
 
        public float XPrev => this.xPrev;
 
        public float YPrev => this.yPrev;
 
        public bool CalcStart => this.calcStart;
 
        public bool CalcEnd => this.calcEnd;
 
        public float Angle
        {
            get
            {
                if (!this.angle.HasValue)
                {
                    float dx = this.x - this.xPrev;
                    float dy = this.y - this.yPrev;
 
                    if (dx == 0 && dy == 0)
                        this.angle = 0;
                    else
                        this.angle = (float)Math.Atan2(dy, dx);
                }
 
                return this.angle.Value;
            }
        }
 
        public void Set0(float X, float Y)
        {
            this.Set(X, Y);
            this.x0 = X;
            this.y0 = Y;
            this.nonSpline = false;
        }
 
        public SKPoint Add0(float DeltaX, float DeltaY)
        {
            SKPoint P = this.Add(DeltaX, DeltaY);
 
            this.nonSpline = false;
            this.x0 = P.X;
            this.y0 = P.Y;
 
            return P;
        }
 
        public void CloseLine()
        {
            this.Set(this.x0, this.y0);
            this.path?.Close();
            this.nonSpline = false;
        }
 
        public void CloseLoop()
        {
            if (this.drawingSpline)
            {
                if (this.nonSpline)
                {
                    this.AddSplineVertex(this.x0, this.y0);
                    this.FlushSpline();
                    this.path?.Close();
                    this.nonSpline = false;
                }
                else
                {
                    Loop.CreateLoop(this.path, this.currentSpline.ToArray());
                    this.currentSpline = null;
                }
 
                this.drawingSpline = false;
            }
            else
                this.CloseLine();
        }
 
        public void Set(float X, float Y)
        {
            if (this.drawingSpline)
                this.FlushSpline();
 
            this.nonSpline = true;
            if (X != this.x || Y != this.y)
            {
                this.xPrev = this.x;
                this.x = X;
 
                this.yPrev = this.y;
                this.y = Y;
 
                this.angle = null;
 
                this.pathDef?.IncludePoint(X, Y);
            }
        }
 
        public SKPoint Add(float DeltaX, float DeltaY)
        {
            DeltaX += this.x;
            DeltaY += this.y;
 
            this.Set(DeltaX, DeltaY);
 
            return new SKPoint(DeltaX, DeltaY);
        }
 
        public SKPoint Forward(float Distance)
        {
            if (this.drawingSpline)
                this.FlushSpline();
 
            if (Distance != 0)
            {
                float Radians = this.Angle;
                float Dx = (float)(Distance * Math.Cos(Radians));
                float Dy = (float)(Distance * Math.Sin(Radians));
 
                return this.Add(Dx, Dy);
            }
            else
                return new SKPoint(this.x, this.y);
        }
 
        public SKPoint Backward(float Distance)
        {
            return this.Forward(-Distance);
        }
 
        public void TurnLeft(float DeltaDegrees)
        {
            if (this.drawingSpline)
                this.FlushSpline();
 
            this.angle = this.Angle - DeltaDegrees * LayoutElement.DegreesToRadians;
        }
 
        public void TurnRight(float DeltaDegrees)
        {
            if (this.drawingSpline)
                this.FlushSpline();
 
            this.angle = this.Angle + DeltaDegrees * LayoutElement.DegreesToRadians;
        }
 
        public void TurnTowards(float X, float Y)
        {
            this.TurnTowardsRel(X - this.x, Y - this.y);
        }
 
        public void TurnTowardsRel(float DeltaX, float DeltaY)
        {
            if (this.drawingSpline)
                this.FlushSpline();
 
            if (DeltaX == 0 && DeltaY == 0)
                this.angle = 0;
            else
                this.angle = (float)Math.Atan2(DeltaY, DeltaX);
        }
 
        public void TurnTowards(float Angle)
        {
            if (this.drawingSpline)
                this.FlushSpline();
 
            this.angle = Angle;
        }
 
        public void FlushSpline()
        {
            if (this.drawingSpline)
            {
                this.drawingSpline = false;
 
                Spline.CreateSpline(this.path, this.currentSpline.ToArray());
                this.currentSpline = null;
                this.nonSpline = false;
            }
        }
 
        public PathSpline SetSplineVertex(float X, float Y)
        {
            if (this.path is null)
            {
                this.Set(X, Y);
                return null;
            }
            else
            {
                if (this.currentSpline is null)
                    this.currentSpline = new PathSpline(this.x, this.y);
 
                this.currentSpline.Add(X, Y);
                this.drawingSpline = true;
 
                if (X != this.x || Y != this.y)
                {
                    this.xPrev = this.x;
                    this.x = X;
 
                    this.yPrev = this.y;
                    this.y = Y;
 
                    this.angle = null;
 
                    this.pathDef?.IncludePoint(X, Y);
                }
 
                return this.currentSpline;
            }
        }
 
        public PathSpline AddSplineVertex(float DeltaX, float DeltaY)
        {
            return this.SetSplineVertex(this.x + DeltaX, this.y + DeltaY);
        }
    }
}