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); } }