public void CoordinateSystemXml()
{
var cs = new CoordinateSystem(new Point3D(1, -2, 3), new Vector3D(0, 1, 0), new Vector3D(0, 0, 1), new Vector3D(1, 0, 0));
string xml = @"
<CoordinateSystem>
<Origin X=""1"" Y=""-2"" Z=""3"" />
<XAxis X=""0"" Y=""1"" Z=""0"" />
<YAxis X=""0"" Y=""0"" Z=""1"" />
<ZAxis X=""1"" Y=""0"" Z=""0"" />
</CoordinateSystem>";
var result = AssertXml.XmlSerializerRoundTrip(cs, xml);
AssertGeometry.AreEqual(cs, result);
}
public void BinaryRountrip()
{
var v = new Ray3D(new Point3D(1, 2, -3), new UnitVector3D(1, 2, 3));
using (var ms = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, v);
ms.Flush();
ms.Position = 0;
var roundTrip = (Ray3D)formatter.Deserialize(ms);
AssertGeometry.AreEqual(v, roundTrip);
}
}
public void BinaryRountrip(string pls)
{
var plane = Plane.Parse(pls);
using (var ms = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, plane);
ms.Flush();
ms.Position = 0;
var roundTrip = (Plane)formatter.Deserialize(ms);
AssertGeometry.AreEqual(plane, roundTrip);
}
}
public void BinaryRountrip()
{
var line = new Line3D(new Point3D(1, 2, 3), new Point3D(4, 5, 6));
using (var ms = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, line);
ms.Flush();
ms.Position = 0;
var roundTrip = (Line3D)formatter.Deserialize(ms);
AssertGeometry.AreEqual(line, roundTrip);
}
}
public void BinaryRountrip()
{
var v = new Vector2D(1, 2);
using (var ms = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, v);
ms.Flush();
ms.Position = 0;
var roundTrip = (Vector2D)formatter.Deserialize(ms);
AssertGeometry.AreEqual(v, roundTrip);
}
}
public void CoordinateSystemDataContract()
{
var cs = new CoordinateSystem(new Point3D(1, -2, 3), new Vector3D(0, 1, 0), new Vector3D(0, 0, 1), new Vector3D(1, 0, 0));
const string xml = @"
<CoordinateSystem>
<Origin><X>1</X><Y>-2</Y><Z>3</Z><Origin>
<XAxis><X>0</X><Y>1</Y><Z>0</Z></XAxis>
<YAxis><X>0</X><Y>0</Y><Z>1</Z></YAxis>
<ZAxis><X>1</X><Y>0</Y><Z>0</Z><ZAxis>
</CoordinateSystem>";
var result = this.DataContractRoundTrip(cs, xml);
AssertGeometry.AreEqual(cs, result);
}
public void RotateToTest(string v1s, string v2s, string @as)
{
UnitVector3D? axis = string.IsNullOrEmpty(@as) ? (UnitVector3D?)null : UnitVector3D.Parse(@as);
UnitVector3D v1 = UnitVector3D.Parse(v1s);
UnitVector3D v2 = UnitVector3D.Parse(v2s);
CoordinateSystem actual = CoordinateSystem.RotateTo(v1, v2, axis);
Console.WriteLine(actual);
var rv = actual.Transform(v1);
AssertGeometry.AreEqual(v2, rv);
actual = CoordinateSystem.RotateTo(v2, v1, axis);
rv = actual.Transform(v2);
AssertGeometry.AreEqual(v1, rv);
}
public void XmlContainerRoundtrip()
{
var container = new AssertXml.Container <Point3D>
{
Value1 = new Point3D(1, 2, 3),
Value2 = new Point3D(4, 5, 6)
};
var expected = "<ContainerOfPoint3D>\r\n" +
" <Value1 X=\"1\" Y=\"2\" Z=\"3\"></Value1>\r\n" +
" <Value2 X=\"4\" Y=\"5\" Z=\"6\"></Value2>\r\n" +
"</ContainerOfPoint3D>";
var roundTrip = AssertXml.XmlSerializerRoundTrip(container, expected);
AssertGeometry.AreEqual(container.Value1, roundTrip.Value1);
AssertGeometry.AreEqual(container.Value2, roundTrip.Value2);
}
public void XmlContainerRoundtrip()
{
var container = new AssertXml.Container <Vector2D>
{
Value1 = new Vector2D(1, 2),
Value2 = new Vector2D(3, 4)
};
var expected = "<ContainerOfVector2D>\r\n" +
" <Value1 X=\"1\" Y=\"2\"></Value1>\r\n" +
" <Value2 X=\"3\" Y=\"4\"></Value2>\r\n" +
"</ContainerOfVector2D>";
var roundTrip = AssertXml.XmlSerializerRoundTrip(container, expected);
AssertGeometry.AreEqual(container.Value1, roundTrip.Value1);
AssertGeometry.AreEqual(container.Value2, roundTrip.Value2);
}
public void Rotate(string vs, string @as, string evs)
{
var v = Vector2D.Parse(vs);
var angle = Angle.Parse(@as);
var actuals = new[]
{
v.Rotate(angle),
v.Rotate(angle.Degrees, AngleUnit.Degrees)
};
var expected = Vector2D.Parse(evs);
foreach (var actual in actuals)
{
AssertGeometry.AreEqual(expected, actual, 0.01);
}
}
public void XmlContainerRoundtrip()
{
var container = new AssertXml.Container <UnitVector3D>
{
Value1 = UnitVector3D.Create(0.2672612419124244, -0.53452248382484879, 0.80178372573727319),
Value2 = UnitVector3D.Create(1, 0, 0)
};
var expected = "<ContainerOfUnitVector3D>\r\n" +
" <Value1 X=\"0.2672612419124244\" Y=\"-0.53452248382484879\" Z=\"0.80178372573727319\"></Value1>\r\n" +
" <Value2 X=\"1\" Y=\"0\" Z=\"0\"></Value2>\r\n" +
"</ContainerOfUnitVector3D>";
var roundTrip = AssertXml.XmlSerializerRoundTrip(container, expected);
AssertGeometry.AreEqual(container.Value1, roundTrip.Value1);
AssertGeometry.AreEqual(container.Value2, roundTrip.Value2);
}
public void InterSectionWithPlane(string rootPoint1, string unitVector1, string rootPoint2, string unitVector2, string eps, string evs)
{
var plane1 = new Plane(Point3D.Parse(rootPoint1), UnitVector3D.Parse(unitVector1));
var plane2 = new Plane(Point3D.Parse(rootPoint2), UnitVector3D.Parse(unitVector2));
var intersections = new[]
{
plane1.IntersectionWith(plane2),
plane2.IntersectionWith(plane1)
};
foreach (var intersection in intersections)
{
AssertGeometry.AreEqual(Point3D.Parse(eps), intersection.ThroughPoint);
AssertGeometry.AreEqual(UnitVector3D.Parse(evs), intersection.Direction);
}
}
public void MidPoint(string p1s, string p2s, string eps)
{
var p1 = Point2D.Parse(p1s);
var p2 = Point2D.Parse(p2s);
var centroids = new[]
{
Point2D.Centroid(p1, p2),
Point2D.MidPoint(p1, p2),
};
var expected = Point2D.Parse(eps);
foreach (var centroid in centroids)
{
AssertGeometry.AreEqual(expected, centroid);
}
}
public void InterSectionWithPlaneTest(string pl1s, string pl2s, string eps, string evs)
{
var plane1 = Plane.Parse(pl1s);
var plane2 = Plane.Parse(pl2s);
var intersections = new[]
{
plane1.IntersectionWith(plane2),
plane2.IntersectionWith(plane1)
};
foreach (var intersection in intersections)
{
AssertGeometry.AreEqual(Point3D.Parse(eps), intersection.ThroughPoint);
AssertGeometry.AreEqual(UnitVector3D.Parse(evs), intersection.Direction);
}
}
public void FromPlanes(string rootPoint1, string unitVector1, string rootPoint2, string unitVector2, string rootPoint3, string unitVector3, string eps)
{
var plane1 = new Plane(Point3D.Parse(rootPoint1), UnitVector3D.Parse(unitVector1));
var plane2 = new Plane(Point3D.Parse(rootPoint2), UnitVector3D.Parse(unitVector2));
var plane3 = new Plane(Point3D.Parse(rootPoint3), UnitVector3D.Parse(unitVector3));
var p1 = Point3D.IntersectionOf(plane1, plane2, plane3);
var p2 = Point3D.IntersectionOf(plane2, plane1, plane3);
var p3 = Point3D.IntersectionOf(plane2, plane3, plane1);
var p4 = Point3D.IntersectionOf(plane3, plane1, plane2);
var p5 = Point3D.IntersectionOf(plane3, plane2, plane1);
var ep = Point3D.Parse(eps);
foreach (var p in new[] { p1, p2, p3, p4, p5 })
{
AssertGeometry.AreEqual(ep, p);
}
}
public void FromPlanes(string pl1s, string pl2s, string pl3s, string eps)
{
var plane1 = Plane.Parse(pl1s);
var plane2 = Plane.Parse(pl2s);
var plane3 = Plane.Parse(pl3s);
var p1 = Point3D.ItersectionOf(plane1, plane2, plane3);
var p2 = Point3D.ItersectionOf(plane2, plane1, plane3);
var p3 = Point3D.ItersectionOf(plane2, plane3, plane1);
var p4 = Point3D.ItersectionOf(plane3, plane1, plane2);
var p5 = Point3D.ItersectionOf(plane3, plane2, plane1);
var ep = Point3D.Parse(eps);
foreach (var p in new[] { p1, p2, p3, p4, p5 })
{
AssertGeometry.AreEqual(ep, p);
}
}
public void RotationAroundVector(string ps, string @as, string vs, string eps)
{
var p = Point3D.Parse(ps);
var angle = Angle.Parse(@as);
var coordinateSystems = new[]
{
CoordinateSystem.Rotation(angle, UnitVector3D.Parse(vs)),
CoordinateSystem.Rotation(angle, Vector3D.Parse(vs)),
};
var expected = Point3D.Parse(eps);
foreach (var coordinateSystem in coordinateSystems)
{
var rotatedPoint = coordinateSystem.Transform(p);
AssertGeometry.AreEqual(expected, rotatedPoint);
}
}
public void XmlContainerElements()
{
var container = new AssertXml.Container <Point2D>
{
Value1 = new Point2D(1, 2),
Value2 = new Point2D(3, 4)
};
var xml = "<ContainerOfPoint2D>\r\n" +
" <Value1><X>1</X><Y>2</Y></Value1>\r\n" +
" <Value2><X>3</X><Y>4</Y></Value2>\r\n" +
"</ContainerOfPoint2D>";
var serializer = new XmlSerializer(typeof(AssertXml.Container <Point2D>));
var deserialized = (AssertXml.Container <Point2D>)serializer.Deserialize(new StringReader(xml));
AssertGeometry.AreEqual(container.Value1, deserialized.Value1);
AssertGeometry.AreEqual(container.Value2, deserialized.Value2);
}
public void RotationYawPitchRoll(string yaws, string pitchs, string rolls, string ps, string eps)
{
var p = Point3D.Parse(ps);
var yaw = Angle.Parse(yaws);
var pitch = Angle.Parse(pitchs);
var roll = Angle.Parse(rolls);
var coordinateSystems = new[]
{
CoordinateSystem.Rotation(yaw, pitch, roll),
};
var expected = Point3D.Parse(eps);
foreach (var coordinateSystem in coordinateSystems)
{
var rotatedPoint = coordinateSystem.Transform(p);
AssertGeometry.AreEqual(expected, rotatedPoint);
}
}
public void XmlRoundTrips()
{
var uv = new UnitVector3D(0.2672612419124244, -0.53452248382484879, 0.80178372573727319);
var xml = @"<UnitVector3D X=""0.2672612419124244"" Y=""-0.53452248382484879"" Z=""0.80178372573727319"" />";
var elementXml = @"<UnitVector3D><X>0.2672612419124244</X><Y>-0.53452248382484879</Y><Z>0.80178372573727319</Z></UnitVector3D>";
AssertXml.XmlRoundTrips(uv, xml, (e, a) => AssertGeometry.AreEqual(e, a));
var serializer = new XmlSerializer(typeof(UnitVector3D));
var actuals = new[]
{
UnitVector3D.ReadFrom(XmlReader.Create(new StringReader(xml))),
(UnitVector3D)serializer.Deserialize(new StringReader(xml)),
(UnitVector3D)serializer.Deserialize(new StringReader(elementXml))
};
foreach (var actual in actuals)
{
AssertGeometry.AreEqual(uv, actual);
}
}
public void ConstructorTest(string ps, string xs, string ys, string zs)
{
var origin = Point3D.Parse(ps);
var xAxis = Vector3D.Parse(xs);
var yAxis = Vector3D.Parse(ys);
var zAxis = Vector3D.Parse(zs);
var css = new[]
{
new CoordinateSystem(origin, xAxis, yAxis, zAxis),
new CoordinateSystem(xAxis, yAxis, zAxis, origin)
};
foreach (var cs in css)
{
AssertGeometry.AreEqual(origin, cs.Origin);
AssertGeometry.AreEqual(xAxis, cs.XAxis);
AssertGeometry.AreEqual(yAxis, cs.YAxis);
AssertGeometry.AreEqual(zAxis, cs.ZAxis);
}
}
public void PointFromPlanes(string rootPoint1, string unitVector1, string rootPoint2, string unitVector2, string rootPoint3, string unitVector3, string eps)
{
var plane1 = new Plane(Point3D.Parse(rootPoint1), UnitVector3D.Parse(unitVector1));
var plane2 = new Plane(Point3D.Parse(rootPoint2), UnitVector3D.Parse(unitVector2));
var plane3 = new Plane(Point3D.Parse(rootPoint3), UnitVector3D.Parse(unitVector3));
var points = new[]
{
Plane.PointFromPlanes(plane1, plane2, plane3),
Plane.PointFromPlanes(plane2, plane1, plane3),
Plane.PointFromPlanes(plane1, plane3, plane2),
Plane.PointFromPlanes(plane2, plane3, plane1),
Plane.PointFromPlanes(plane3, plane2, plane1),
Plane.PointFromPlanes(plane3, plane1, plane2),
};
var expected = Point3D.Parse(eps);
foreach (var point in points)
{
AssertGeometry.AreEqual(expected, point);
}
}
public void PointFromPlanes2(string planeString1, string planeString2, string planeString3, string eps)
{
var plane1 = this.GetPlaneFrom4Doubles(planeString1);
var plane2 = this.GetPlaneFrom4Doubles(planeString2);
var plane3 = this.GetPlaneFrom4Doubles(planeString3);
var points = new[]
{
Plane.PointFromPlanes(plane1, plane2, plane3),
Plane.PointFromPlanes(plane2, plane1, plane3),
Plane.PointFromPlanes(plane1, plane3, plane2),
Plane.PointFromPlanes(plane2, plane3, plane1),
Plane.PointFromPlanes(plane3, plane2, plane1),
Plane.PointFromPlanes(plane3, plane1, plane2),
};
var expected = Point3D.Parse(eps);
foreach (var point in points)
{
AssertGeometry.AreEqual(expected, point);
}
}
public void PointFromPlanes(string pl1s, string pl2s, string pl3s, string eps)
{
var plane1 = Plane.Parse(pl1s);
var plane2 = Plane.Parse(pl2s);
var plane3 = Plane.Parse(pl3s);
var points = new[]
{
Plane.PointFromPlanes(plane1, plane2, plane3),
Plane.PointFromPlanes(plane2, plane1, plane3),
Plane.PointFromPlanes(plane1, plane3, plane2),
Plane.PointFromPlanes(plane2, plane3, plane1),
Plane.PointFromPlanes(plane3, plane2, plane1),
Plane.PointFromPlanes(plane3, plane1, plane2),
};
var expected = Point3D.Parse(eps);
foreach (var point in points)
{
AssertGeometry.AreEqual(expected, point);
}
}
public void RotationYawPitchRoll(string yaws, string pitchs, string rolls, string ps, string eps)
{
var p = Point3D.Parse(ps);
var yaw = Angle.Parse(yaws);
var pitch = Angle.Parse(pitchs);
var roll = Angle.Parse(rolls);
var coordinateSystems = new[]
{
CoordinateSystem.Rotation(yaw, pitch, roll),
CoordinateSystem.Rotation(yaw.Degrees, pitch.Degrees, roll.Degrees, AngleUnit.Degrees),
CoordinateSystem.Rotation(yaw.Radians, pitch.Radians, roll.Radians, AngleUnit.Radians),
};
var expected = Point3D.Parse(eps);
foreach (var coordinateSystem in coordinateSystems)
{
var rotatedPoint = coordinateSystem.Transform(p);
//Console.WriteLine(coordinateSystem.ToString());
AssertGeometry.AreEqual(expected, rotatedPoint);
}
}
public void XmlRoundtrip()
{
var p = new Point3D(1, -2, 3);
const string Xml = @"<Point3D X=""1"" Y=""-2"" Z=""3"" />";
const string ElementXml = @"<Point3D><X>1</X><Y>-2</Y><Z>3</Z></Point3D>";
AssertXml.XmlRoundTrips(p, Xml, (expected, actual) => AssertGeometry.AreEqual(expected, actual));
var serializer = new XmlSerializer(typeof(Point3D));
var actuals = new[]
{
Point3D.ReadFrom(XmlReader.Create(new StringReader(Xml))),
Point3D.ReadFrom(XmlReader.Create(new StringReader(ElementXml))),
(Point3D)serializer.Deserialize(new StringReader(Xml)),
(Point3D)serializer.Deserialize(new StringReader(ElementXml))
};
foreach (var actual in actuals)
{
AssertGeometry.AreEqual(p, actual);
}
}
public void XmlRountrip()
{
var p = new Point2D(1, 2);
const string Xml = @"<Point2D X=""1"" Y=""2"" />";
const string ElementXml = @"<Point2D><X>1</X><Y>2</Y></Point2D>";
AssertXml.XmlRoundTrips(p, Xml, (e, a) => AssertGeometry.AreEqual(e, a));
var serializer = new XmlSerializer(typeof(Point2D));
var actuals = new[]
{
Point2D.ReadFrom(XmlReader.Create(new StringReader(Xml))),
Point2D.ReadFrom(XmlReader.Create(new StringReader(ElementXml))),
(Point2D)serializer.Deserialize(new StringReader(Xml)),
(Point2D)serializer.Deserialize(new StringReader(ElementXml))
};
foreach (var actual in actuals)
{
AssertGeometry.AreEqual(p, actual);
}
}
public void XmlRoundtrip()
{
const string Xml = @"<Vector2D X=""1"" Y=""2"" />";
const string ElementXml = @"<Vector2D><X>1</X><Y>2</Y></Vector2D>";
var v = new Vector2D(1, 2);
AssertXml.XmlRoundTrips(v, Xml, (e, a) => AssertGeometry.AreEqual(e, a));
var serializer = new XmlSerializer(typeof(Vector2D));
var actuals = new[]
{
Vector2D.ReadFrom(XmlReader.Create(new StringReader(Xml))),
Vector2D.ReadFrom(XmlReader.Create(new StringReader(ElementXml))),
(Vector2D)serializer.Deserialize(new StringReader(Xml)),
(Vector2D)serializer.Deserialize(new StringReader(ElementXml))
};
foreach (var actual in actuals)
{
AssertGeometry.AreEqual(v, actual);
}
}
public void SetToAlignCoordinateSystemsTest(string fcss, string tcss)
{
var fcs = CoordinateSystem.Parse(fcss);
var tcs = CoordinateSystem.Parse(tcss);
var css = new[]
{
CoordinateSystem.SetToAlignCoordinateSystems(fcs.Origin, fcs.XAxis, fcs.YAxis, fcs.ZAxis, tcs.Origin, tcs.XAxis, tcs.YAxis, tcs.ZAxis),
CoordinateSystem.CreateMappingCoordinateSystem(fcs, tcs)
};
foreach (var cs in css)
{
var aligned = cs.Transform(fcs);
AssertGeometry.AreEqual(tcs.Origin, aligned.Origin);
AssertGeometry.AreEqual(tcs.XAxis, aligned.XAxis);
AssertGeometry.AreEqual(tcs.YAxis, aligned.YAxis);
AssertGeometry.AreEqual(tcs.ZAxis, aligned.ZAxis);
}
}
public void SerializeDeserialize()
{
var v = new Vector3D(1, -2, 3);
const string Xml = @"<Vector3D X=""1"" Y=""-2"" Z=""3"" />";
const string ElementXml = @"<Vector3D><X>1</X><Y>-2</Y><Z>3</Z></Vector3D>";
var roundTrip = AssertXml.XmlSerializerRoundTrip(v, Xml);
AssertGeometry.AreEqual(v, roundTrip);
var serializer = new XmlSerializer(typeof(Vector3D));
var actuals = new[]
{
Vector3D.ReadFrom(XmlReader.Create(new StringReader(Xml))),
Vector3D.ReadFrom(XmlReader.Create(new StringReader(ElementXml))),
(Vector3D)serializer.Deserialize(new StringReader(Xml)),
(Vector3D)serializer.Deserialize(new StringReader(ElementXml))
};
foreach (var actual in actuals)
{
AssertGeometry.AreEqual(v, actual);
}
}
