/// <summary> /// /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> public static Quaterniond CreateFromTo(Vec3d from, Vec3d to) { // impl refs // https://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another // http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors if (!from.Unitize() || !to.Unitize()) { return(Identity); } var ca = Vec3d.Dot(from, to); // parallel check if (zMath.ApproxEquals(Math.Abs(ca), 1.0)) { //opposite check if (ca < 0.0) { var perp = from.X < 1.0 ? from.CrossX() : from.CrossY(); var t = 1.0 / perp.Length; return(new Quaterniond(perp.X * t, perp.Y * t, perp.Z * t, 0.0)); } return(Identity); } // can assume axis is valid var axis = Vec3d.Cross(from, to); var q = new Quaterniond(axis.X, axis.Y, axis.Z, ca + 1); q.Unitize(); return(q); }
/// <summary> /// Returns the area gradient of the given trianglue with respect to p0. /// http://www.cs.cmu.edu/~kmcrane/Projects/Other/TriangleMeshDerivativesCheatSheet.pdf /// </summary> /// <param name="p0"></param> /// <param name="p1"></param> /// <param name="p2"></param> /// <returns></returns> public static Vec3d GetTriAreaGradient(Vec3d p0, Vec3d p1, Vec3d p2) { var d = p2 - p1; var n = Vec3d.Cross(d, p0 - p1); n.Unitize(); return(Vec3d.Cross(n, d) * 0.5); }
/// <summary> /// /// </summary> /// <param name="start"></param> /// <param name="end"></param> /// <param name="rightNormal"></param> /// <param name="leftNormal"></param> /// <returns></returns> public static double GetDihedralAngle(Vec3d unitAxis, Vec3d leftNormal, Vec3d rightNormal) { // impl ref // http://brickisland.net/DDGFall2017/2017/10/12/assignment-1-coding-investigating-curvature/ return (Math.Atan2( Vec3d.Dot(unitAxis, Vec3d.Cross(leftNormal, rightNormal)), Vec3d.Dot(leftNormal, rightNormal) ) + Math.PI); }
/// <summary> /// Returns true if the given vectors form a valid orthonormal basis i.e. they aren't parallel or zero length. /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public bool Set(Vec3d x, Vec3d y) { Vec3d z = Vec3d.Cross(x, y); double m = z.SquareLength; if (m > 0.0) { SetZX(z / Math.Sqrt(m), x / x.Length); return(true); } return(false); }
/// <summary> /// /// </summary> /// <param name="p0"></param> /// <param name="p1"></param> /// <param name="p2"></param> /// <returns></returns> public bool Set(Vec3d p0, Vec3d p1, Vec3d p2) { var n = Vec3d.Cross(p1 - p0, p2 - p1); if (!n.Unitize()) { return(false); } _normal = n; _distance = Vec3d.Dot(p0, n); return(true); }
/// <summary> /// Returns the area gradient of the given triangle with respect to each vertex /// http://www.cs.cmu.edu/~kmcrane/Projects/Other/TriangleMeshDerivativesCheatSheet.pdf /// </summary> /// <param name="p0"></param> /// <param name="p1"></param> /// <param name="p2"></param> /// <param name="g0"></param> /// <param name="g1"></param> /// <param name="g2"></param> /// <returns></returns> public static void GetTriAreaGradients(Vec3d p0, Vec3d p1, Vec3d p2, out Vec3d g0, out Vec3d g1, out Vec3d g2) { var d0 = p1 - p0; var d1 = p2 - p1; var d2 = p0 - p2; var n = Vec3d.Cross(d0, d1); n.Unitize(); g0 = Vec3d.Cross(n, d1) * 0.5; g1 = Vec3d.Cross(n, d2) * 0.5; g2 = g0 + g1; }
/// <summary> /// Returns false if the 2 given vectors are parallel. /// The direction of the first vector is maintained. /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> public static bool Orthonormalize(ref Vec3d x, ref Vec3d y, out Vec3d z) { z = Vec3d.Cross(x, y); double m = z.SquareLength; if (m > 0.0) { x /= x.Length; z /= Math.Sqrt(m); y = Vec3d.Cross(z, x); return(true); } return(false); }
/// <summary> /// Creates the rotation between v0 and v1 /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> public static OrthoBasis3d CreateFromTo(Vec3d from, Vec3d to) { // impl ref // https://math.stackexchange.com/questions/180418/calculate-rotation-matrix-to-align-vector-a-to-vector-b-in-3d if (!from.Unitize() || !to.Unitize()) { return(Identity); } var v = Vec3d.Cross(from, to); var c = Vec3d.Dot(from, to); var k = 1.0 / (1.0 + c); return(new OrthoBasis3d { _x = new Vec3d(v.X * v.X * k + c, v.X * v.Y * k + v.Z, v.X * v.Z * k - v.Y), _y = new Vec3d(v.Y * v.X * k - v.Z, v.Y * v.Y * k + c, v.Y * v.Z * k + v.X), _z = new Vec3d(v.Z * v.X * k + v.Y, v.Z * v.Y * k - v.X, v.Z * v.Z * k + c) }); }
/// <summary> /// /// </summary> /// <param name="points"></param> /// <returns></returns> public static double GetPolygonArea(IEnumerable <Vec3d> points, Vec3d unitNormal) { var itr = points.GetEnumerator(); itr.MoveNext(); var first = itr.Current; var p0 = first; var sum = Vec3d.Zero; while (itr.MoveNext()) { var p1 = itr.Current; sum += Vec3d.Cross(p0, p1); p0 = p1; } sum += Vec3d.Cross(p0, first); return(Vec3d.Dot(sum, unitNormal) * 0.5); }
/// <summary> /// /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> public static AxisAngle3d CreateFromTo(Vec3d from, Vec3d to) { if (!from.Unitize() || !to.Unitize()) { return(Identity); } var ct = Vec3d.Dot(from, to); // parallel check if (1.0 - Math.Abs(ct) < zMath.ZeroTolerance) { // opposite check if (ct < 0.0) { var perp = from.X < 1.0 ? from.CrossX() : from.CrossY(); return(new AxisAngle3d() { _axis = perp / perp.Length, _angle = Math.PI, _cosAngle = -1.0, _sinAngle = 0.0 }); } return(Identity); } // can assume axis is valid var axis = Vec3d.Cross(from, to); var st = axis.Length; return(new AxisAngle3d() { _axis = axis / st, _angle = Math.Acos(ct), _sinAngle = st, _cosAngle = ct }); }
/// <summary> /// Returns the aspect ratio of the tetrahedra defined by 4 given points. /// This is defined as the longest edge / shortest altitude. /// </summary> /// <param name="points"></param> /// <returns></returns> public static double GetTetraAspect(Vec3d p0, Vec3d p1, Vec3d p2, Vec3d p3) { double minEdge = 0.0; double maxAlt = double.PositiveInfinity; Vec3d v0 = p1 - p0; Vec3d v1 = p2 - p1; Vec3d v2 = p3 - p2; Vec3d v3 = p0 - p3; Sub(v0, v1, v2); Sub(v1, v2, v3); Sub(v2, v3, v0); Sub(v3, v0, v1); return(Math.Sqrt(minEdge) / Math.Sqrt(maxAlt)); void Sub(Vec3d a, Vec3d b, Vec3d c) { minEdge = Math.Max(minEdge, a.SquareLength); maxAlt = Math.Min(maxAlt, Vec3d.Project(c, Vec3d.Cross(a, b)).SquareLength); } }
/// <summary> /// Assumes the given vectors are orthonormal. /// </summary> /// <param name="x"></param> /// <param name="y"></param> internal void SetXY(Vec3d x, Vec3d y) { _x = x; _y = y; _z = Vec3d.Cross(x, y); }
/// <summary> /// Assumes the given vectors are orthonormal. /// </summary> /// <param name="y"></param> /// <param name="z"></param> internal void SetYZ(Vec3d y, Vec3d z) { _x = Vec3d.Cross(y, z); _y = y; _z = z; }
/// <summary> /// Assumes the given vectors are orthonormal. /// </summary> /// <param name="z"></param> /// <param name="x"></param> private void SetZX(Vec3d z, Vec3d x) { _x = x; _y = Vec3d.Cross(z, x); _z = z; }
/// <summary> /// http://www.block.arch.ethz.ch/brg/files/2013-ijss-vanmele-shaping-tension-structures-with-actively-bent-linear-elements_1386929572.pdf /// </summary> /// <param name="v0"></param> /// <param name="v1"></param> /// <returns></returns> public static Vec3d GetCurvatureVector(Vec3d v0, Vec3d v1) { Vec3d v2 = Vec3d.Cross(v0, v1); return(Vec3d.Cross((v0.SquareLength * v1 - v1.SquareLength * v0), v2) / (2.0 * v2.SquareLength)); }
/// <summary> /// Applies this rotation to the given vector. /// </summary> /// <param name="vector"></param> /// <returns></returns> public Vec3d Apply(Vec3d vector) { return(_cosAngle * vector + _sinAngle * Vec3d.Cross(_axis, vector) + Vec3d.Dot(_axis, vector) * (1.0 - _cosAngle) * _axis); }
/// <summary> /// Assumes the given vectors are orthonormal. /// </summary> /// <param name="z"></param> /// <param name="x"></param> internal void SetZX(Vec3d z, Vec3d x) { _x = x; _y = Vec3d.Cross(z, x); _z = z; }
/// <summary> /// Assumes the given vectors are orthonormal. /// </summary> /// <param name="y"></param> /// <param name="z"></param> private void SetYZ(Vec3d y, Vec3d z) { _x = Vec3d.Cross(y, z); _y = y; _z = z; }
/// <summary> /// /// </summary> /// <param name="start"></param> /// <param name="end"></param> /// <param name="right"></param> /// <param name="left"></param> /// <returns></returns> public static double GetDihedralAngle(Vec3d start, Vec3d end, Vec3d left, Vec3d right) { var d = end - start; return(GetDihedralAngle(d.Unit, Vec3d.Cross(d, left - end), Vec3d.Cross(d, start - right))); }
/// <summary> /// Assumes the given vectors are orthonormal. /// </summary> /// <param name="x"></param> /// <param name="y"></param> private void SetXY(Vec3d x, Vec3d y) { _x = x; _y = y; _z = Vec3d.Cross(x, y); }