public void ImplicitZeroNumberInterpretation()
{
string input = "M 0 0 l.457.318";
IPathInstruction inst = PathData.Parse(input)[1];
Assert.AreEqual(0.457, inst.EndPosition.x);
Assert.AreEqual(0.318, inst.EndPosition.y);
Assert.AreEqual("l 0.457 0.318", inst.ToString());
}
public void ImplicitNegativeMiddleZeroNumberInterpretation()
{
string input = "M 0 0 l.004-.007";
IPathInstruction inst = PathData.Parse(input)[1];
Assert.AreEqual(0.004, inst.EndPosition.x);
Assert.AreEqual(-0.007, inst.EndPosition.y);
Assert.AreEqual("l 0.004 -0.007", inst.ToString());
}
public HorizontalLineInstruction(double x, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
if (Relative)
{
this.X = StartPosition.x + x;
}
else
{
this.X = x;
}
}
public VerticalLineInstruction(double y, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
this.Relative = Relative;
if (Relative)
{
this.Y = StartPosition.y + y;
}
else
{
this.Y = y;
}
}
public void AbsoluteQuadraticBézierCurve()
{
string input = "M 10 10 Q 20 10 10 20";
IPathInstruction inst = PathData.Parse(input)[1];
Assert.AreEqual(10, inst.EndPosition.x);
Assert.AreEqual(20, inst.EndPosition.y);
Assert.IsInstanceOf(typeof(QuadraticBézierCurveInstruction), inst);
QuadraticBézierCurveInstruction quadratic = (QuadraticBézierCurveInstruction)inst;
Assert.AreEqual((20, 10), quadratic.ControlPoints[0]);
Assert.AreEqual(input, PathData.Parse(input).AsString());
}
public LineInstruction(double x, double y, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
if (Relative)
{
this.X = StartPosition.x + x;
this.Y = StartPosition.y + y;
}
else
{
this.X = x;
this.Y = y;
}
}
public void AbsoluteShorthandQuadraticBézierCurve()
{
string input = "M 10 10 q 10 0 0 10 T 20 30";
IPathInstruction inst = PathData.Parse(input)[2];
Assert.AreEqual(20, inst.EndPosition.x);
Assert.AreEqual(30, inst.EndPosition.y);
Assert.IsInstanceOf(typeof(ShorthandQuadraticBézierCurveInstruction), inst);
ShorthandQuadraticBézierCurveInstruction quadratic = (ShorthandQuadraticBézierCurveInstruction)inst;
Assert.AreEqual((0, 30), quadratic.ReflectedPreviousInstructionsLastControlPoint);
Assert.AreEqual(input, PathData.Parse(input).AsString());
}
public void RelativeCubicBézierCurve()
{
string input = "M 10 10 c 10 0 0 10 10 10";
IPathInstruction inst = PathData.Parse(input)[1];
Assert.AreEqual(20, inst.EndPosition.x);
Assert.AreEqual(20, inst.EndPosition.y);
Assert.IsInstanceOf(typeof(CubicBézierCurveInstruction), inst);
CubicBézierCurveInstruction cubic = (CubicBézierCurveInstruction)inst;
Assert.AreEqual((20, 10), cubic.ControlPoints[0]);
Assert.AreEqual((10, 20), cubic.ControlPoints[1]);
Assert.AreEqual(input, PathData.Parse(input).AsString());
}
public void AbsoluteShorthandCubicBézierCurve()
{
string input = "M 10 10 C 20 10 10 20 20 20 S 30 30 40 40";
IPathInstruction inst = PathData.Parse(input)[2];
Assert.AreEqual(40, inst.EndPosition.x);
Assert.AreEqual(40, inst.EndPosition.y);
Assert.IsInstanceOf(typeof(ShorthandCubicBézierCurveInstruction), inst);
ShorthandCubicBézierCurveInstruction cubic = (ShorthandCubicBézierCurveInstruction)inst;
Assert.AreEqual((30, 30), cubic.ControlPoints[0]);
Assert.AreEqual((30, 20), cubic.ReflectedPreviousInstructionsLastControlPoint);
Assert.AreEqual(input, PathData.Parse(input).AsString());
}
public void RelativeEllipticalArcCurve()
{
string input = "M 10 10 a 1 1 0 1 1 10 20";
IPathInstruction inst = PathData.Parse(input)[1];
Assert.AreEqual(20, inst.EndPosition.x);
Assert.AreEqual(30, inst.EndPosition.y);
Assert.IsInstanceOf(typeof(EllipticalArcInstruction), inst);
EllipticalArcInstruction ellipticalArc = (EllipticalArcInstruction)inst;
Assert.AreEqual(1, ellipticalArc.Rx);
Assert.AreEqual(1, ellipticalArc.Ry);
Assert.AreEqual((15, 20 - Math.Sqrt(Math.Pow(5, 2) + Math.Pow(10, 2))), ellipticalArc.ControlPointYPos);
Assert.AreEqual((15, 20 + Math.Sqrt(Math.Pow(5, 2) + Math.Pow(10, 2))), ellipticalArc.ControlPointYNeg);
Assert.AreEqual((15 - Math.Sqrt(Math.Pow(5, 2) + Math.Pow(10, 2)), 20), ellipticalArc.ControlPointXNeg);
Assert.AreEqual((15 + Math.Sqrt(Math.Pow(5, 2) + Math.Pow(10, 2)), 20), ellipticalArc.ControlPointXPos);
Assert.AreEqual(input, PathData.Parse(input).AsString());
}
public static List <IPathInstruction> Parse(string input)
{
string strippedInput = input.Replace(",", " ").Replace("-", " -");
List <string> instructions = new() { "M", "m", "Z", "z", "L", "l", "H", "h", "V", "v", "C", "c", "S", "s", "Q", "q", "T", "t", "A", "a" };
string standardizedInput = instructions.Aggregate(strippedInput, (accu, curr) => accu.Replace(curr, $",{curr} ")).TrimStart(' ');
string removesDoubleSpaces = Regex.Replace(standardizedInput, @"\s+", " ");
IEnumerable <string> splitInstructionSequences = removesDoubleSpaces.Split(",").Select(seq => NormalizeArgumentSequenceWithSpaceZeroDot(seq));
List <IPathInstruction> list = Enumerable.Range(1, splitInstructionSequences.Count() - 1).Aggregate(
new List <IPathInstruction>(),
(list, curr) =>
{
IPathInstruction previous = curr == 1 ? null : list.Last();
string seq = splitInstructionSequences.ElementAt(curr).TrimEnd(' ');
string instruction = seq[..1];
if (curr == 1 && instruction is not("M" or "m"))
{
throw new ArgumentException($"The first sequence is not a move (\"m\" or \"M\") in {strippedInput}");
}
List <double> parameters = new();
if (seq != "Z" && seq != "z")
{
parameters = seq[2..].Split(" ").Select(p => p.ParseAsDouble()).ToList();
}
public QuadraticBézierCurveInstruction(double x1, double y1, double x, double y, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
if (Relative)
{
ControlPoints.Add((StartPosition.x + x1, StartPosition.y + y1));
this.X = StartPosition.x + x;
this.Y = StartPosition.y + y;
}
else
{
ControlPoints.Add((x1, y1));
this.X = x;
this.Y = y;
}
}
public ShorthandCubicBézierCurveInstruction(double x2, double y2, double x, double y, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
if (Relative)
{
ControlPoints.Add((StartPosition.x + x2, StartPosition.y + y2));
this.X = StartPosition.x + x;
this.Y = StartPosition.y + y;
}
else
{
ControlPoints.Add((x2, y2));
this.X = x;
this.Y = y;
}
}
public EllipticalArcInstruction(double rx, double ry, double xAxisRotation, bool largeArcFlag, bool sweepFlag, double x, double y, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
this.Rx = rx;
this.Ry = ry;
this.XAxisRotation = xAxisRotation;
this.LargeArcFlag = largeArcFlag;
this.SweepFlag = sweepFlag;
if (Relative)
{
this.X = StartPosition.x + x;
this.Y = StartPosition.y + y;
}
else
{
this.X = x;
this.Y = y;
}
}
public ShorthandQuadraticBézierCurveInstruction(double x, double y, bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
if (Relative)
{
this.X = StartPosition.x + x;
this.Y = StartPosition.y + y;
}
else
{
this.X = x;
this.Y = y;
}
}
public BasePathInstruction(bool Relative, IPathInstruction PreviousInstruction)
{
this.Relative = Relative;
this.PreviousInstruction = PreviousInstruction;
}
public ClosePathInstruction(bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
}
public BaseControlPointPathInstruction(bool Relative, IPathInstruction PreviousInstruction) : base(Relative, PreviousInstruction)
{
UpdateReflectedPreviousInstructionsLastControlPoint();
}
