public void Parse(string rootPoint, string unitVector, string pds, string vds)
{
var plane = new Plane(Point3D.Parse(rootPoint), UnitVector3D.Parse(unitVector));
AssertGeometry.AreEqual(Point3D.Parse(pds), plane.RootPoint);
AssertGeometry.AreEqual(Vector3D.Parse(vds), plane.Normal);
}
public void SetToRotateToTest(string vs, string vts, string axisString)
{
var v = UnitVector3D.Parse(vs, tolerance: 1);
var vt = UnitVector3D.Parse(vts, tolerance: 1);
UnitVector3D?axis = null;
if (axisString != null)
{
axis = UnitVector3D.Parse(axisString);
}
var cs = CoordinateSystem.RotateTo(v, vt, axis);
var rv = cs.Transform(v);
AssertGeometry.AreEqual(vt, rv);
var invert = cs.Invert();
var rotateBack = invert.Transform(rv);
AssertGeometry.AreEqual(v, rotateBack);
cs = CoordinateSystem.RotateTo(vt, v, axis);
rotateBack = cs.Transform(rv);
AssertGeometry.AreEqual(v, rotateBack);
}
public void Scale(string vs, double s, string evs)
{
var v = Vector3D.Parse(vs);
var actual = v.ScaleBy(s);
AssertGeometry.AreEqual(Vector3D.Parse(evs), actual, 1e-6);
}
public void Scale(string ivs, double s, string exs)
{
var uv = UnitVector3D.Parse(ivs);
var v = uv.ScaleBy(s);
AssertGeometry.AreEqual(Vector3D.Parse(exs), v, float.Epsilon);
}
public void DirectionsTest(string p1s, string p2s, string evs)
{
var l = LineSegment3D.Parse(p1s, p2s);
var excpected = UnitVector3D.Parse(evs, tolerance: 1);
AssertGeometry.AreEqual(excpected, l.Direction);
}
public void IndexAccessorTest(string points, int index, string expected)
{
var testElement = new PolyLine3D(from x in points.Split(';') select Point3D.Parse(x));
var checkElement = Point3D.Parse(expected);
AssertGeometry.AreEqual(checkElement, testElement.Vertices.Skip(index).First());
}
public void XmlRoundtrip()
{
var p = new Point3D(1, -2, 3);
var xml = @"<Point3D X=""1"" Y=""-2"" Z=""3"" />";
AssertXml.XmlRoundTrips(p, xml, (expected, actual) => AssertGeometry.AreEqual(expected, actual));
}
public void Multiply(string vectorAsString, double mulitplier, string expected)
{
var vector = Vector3D.Parse(vectorAsString);
AssertGeometry.AreEqual(Vector3D.Parse(expected), mulitplier * vector, 1e-6);
AssertGeometry.AreEqual(Vector3D.Parse(expected), mulitplier * vector, 1e-6);
}
public void XmlElements()
{
var v = new Point2D(1, 2);
var serializer = new XmlSerializer(typeof(Point2D));
AssertGeometry.AreEqual(v, (Point2D)serializer.Deserialize(new StringReader(@"<Point2D><X>1</X><Y>2</Y></Point2D>")));
}
private void ProjectPoint(Point3D pointToProject, Point3D planeRootPoint, UnitVector3D planeNormal, Point3D projectedresult)
{
var plane = new Plane(planeNormal, planeRootPoint);
var projectOn = plane.Project(pointToProject);
AssertGeometry.AreEqual(projectedresult, projectOn, float.Epsilon);
}
public void ParseTest(string vs, double[] ep)
{
Vector3D point3D = Vector3D.Parse(vs);
Vector3D expected = new Vector3D(ep);
AssertGeometry.AreEqual(point3D, expected, 1e-9);
}
public void ParseTest(string s, double[] pds, double[] vds)
{
var plane = Plane.Parse(s);
AssertGeometry.AreEqual(new Point3D(pds), plane.RootPoint);
AssertGeometry.AreEqual(new Vector3D(vds), plane.Normal);
}
public void XmlRoundtrip()
{
var uv = UnitVector3D.Create(0.2672612419124244, -0.53452248382484879, 0.80178372573727319);
var xml = "<UnitVector3D X=\"0.2672612419124244\" Y=\"-0.53452248382484879\" Z=\"0.80178372573727319\" />";
AssertXml.XmlRoundTrips(uv, xml, (expected, actual) => AssertGeometry.AreEqual(expected, actual));
}
public void Parse2(string s, string pds, string vds)
{
var plane = this.GetPlaneFrom4Doubles(s);
AssertGeometry.AreEqual(Point3D.Parse(pds), plane.RootPoint);
AssertGeometry.AreEqual(Vector3D.Parse(vds), plane.Normal);
}
public void ParseTest(string pointAsString, double[] expectedPoint)
{
Point3D point3D = Point3D.Parse(pointAsString);
Point3D expected = new Point3D(expectedPoint);
AssertGeometry.AreEqual(expected, point3D, 1e-9);
}
public void Normalize(string vs, string evs)
{
var v1 = Vector2D.Parse(vs);
var expected = Vector2D.Parse(evs);
AssertGeometry.AreEqual(expected, v1.Normalize());
}
public void Parse(string rootPoint, string unitVector, string eps, string evs)
{
var ray = new Ray3D(Point3D.Parse(rootPoint), UnitVector3D.Parse(unitVector));
AssertGeometry.AreEqual(Point3D.Parse(eps), ray.ThroughPoint);
AssertGeometry.AreEqual(Vector3D.Parse(evs), ray.Direction);
}
public void DirectionsTest(string p1s, string p2s, string evs)
{
Line3D l = Line3D.Parse(p1s, p2s);
var excpected = UnitVector3D.Parse(evs);
AssertGeometry.AreEqual(excpected, l.Direction);
}
public void CoordinateSystemJson()
{
var cs = new CoordinateSystem(new Point3D(1, -2, 3), new Vector3D(0, 1, 0), new Vector3D(0, 0, 1), new Vector3D(1, 0, 0));
var result = this.JsonRoundTrip(cs);
AssertGeometry.AreEqual(cs, result);
}
public void XmlElements()
{
var v = new Vector3D(1, 2, 3);
var serializer = new XmlSerializer(typeof(Vector3D));
AssertGeometry.AreEqual(v, (Vector3D)serializer.Deserialize(new StringReader(@"<Vector3D><X>1</X><Y>2</Y><Z>3</Z></Vector3D>")));
}
public void Parse(string rs, string eps, string evs)
{
var ray = Ray3D.Parse(rs);
AssertGeometry.AreEqual(Point3D.Parse(eps), ray.ThroughPoint);
AssertGeometry.AreEqual(Vector3D.Parse(evs), ray.Direction);
}
public void MirrorPointTest()
{
var plane = new Plane(UnitVector3D.ZAxis, new Point3D(0, 0, 0));
var point3D = new Point3D(1, 2, 3);
Point3D mirrorAbout = plane.MirrorAbout(point3D);
AssertGeometry.AreEqual(new Point3D(1, 2, -3), mirrorAbout, float.Epsilon);
}
public void ProjectPointOnTest(string ps, string pls, string eps)
{
var plane = Plane.Parse(pls);
var projectedPoint = plane.Project(Point3D.Parse(ps));
var expected = Point3D.Parse(eps);
AssertGeometry.AreEqual(expected, projectedPoint, float.Epsilon);
}
public void PolarCtorTest(int r, string avs, string eps)
{
var av = Angle.Parse(avs);
var p = new Vector2D(r, av);
var ep = Vector2D.Parse(eps);
AssertGeometry.AreEqual(ep, p, 1e-2);
}
public void VectorProjection(string v1s, string v2s, string exs)
{
var v1 = Vector2D.Parse(v1s);
var v2 = Vector2D.Parse(v2s);
var ex = Vector2D.Parse(exs);
AssertGeometry.AreEqual(ex, v1.ProjectOn(v2), 1e-3);
}
public void Ray3DDataContract(string ps, string vs, bool asElements, string xml)
{
var ray = new Ray3D(Point3D.Parse(ps), UnitVector3D.Parse(vs));
var result = this.DataContractRoundTrip(ray, xml);
Assert.AreEqual(ray, result);
AssertGeometry.AreEqual(ray, result, 1e-6);
}
public void TransformUnitVector()
{
var cs = CoordinateSystem.Rotation(90, AngleUnit.Degrees, UnitVector3D.ZAxis);
var uv = UnitVector3D.XAxis;
var actual = cs.Transform(uv);
AssertGeometry.AreEqual(UnitVector3D.YAxis, actual);
}
public void FromPolar(int radius, string avs, string eps)
{
var angle = Angle.Parse(avs);
var v = Vector2D.FromPolar(radius, angle);
var ep = Vector2D.Parse(eps);
AssertGeometry.AreEqual(ep, v, 1e-2);
}
public void Rotate(string vs, string @as, string evs)
{
var v = Vector2D.Parse(vs);
var angle = Angle.Parse(@as);
var expected = Vector2D.Parse(evs);
AssertGeometry.AreEqual(expected, v.Rotate(angle), 0.01);
}
public void ToString(string vs, string format, string expected, double tolerance)
{
var v = UnitVector3D.Parse(vs);
string actual = v.ToString(format);
Assert.AreEqual(expected, actual);
AssertGeometry.AreEqual(v, UnitVector3D.Parse(actual), tolerance);
}
