-Clazz.declarePackage ("javajs.util");\r
-Clazz.load (["javajs.util.V3"], "javajs.util.Measure", ["java.lang.Float", "javajs.api.Interface", "javajs.util.Lst", "$.P3", "$.P4", "$.Quat"], function () {\r
-c$ = Clazz.declareType (javajs.util, "Measure");\r
-c$.computeAngle = Clazz.defineMethod (c$, "computeAngle", \r
-function (pointA, pointB, pointC, vectorBA, vectorBC, asDegrees) {\r
-vectorBA.sub2 (pointA, pointB);\r
-vectorBC.sub2 (pointC, pointB);\r
-var angle = vectorBA.angle (vectorBC);\r
-return (asDegrees ? angle / 0.017453292 : angle);\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3,~B");\r
-c$.computeAngleABC = Clazz.defineMethod (c$, "computeAngleABC", \r
-function (pointA, pointB, pointC, asDegrees) {\r
-var vectorBA = new javajs.util.V3 ();\r
-var vectorBC = new javajs.util.V3 ();\r
-return javajs.util.Measure.computeAngle (pointA, pointB, pointC, vectorBA, vectorBC, asDegrees);\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,~B");\r
-c$.computeTorsion = Clazz.defineMethod (c$, "computeTorsion", \r
-function (p1, p2, p3, p4, asDegrees) {\r
-var ijx = p1.x - p2.x;\r
-var ijy = p1.y - p2.y;\r
-var ijz = p1.z - p2.z;\r
-var kjx = p3.x - p2.x;\r
-var kjy = p3.y - p2.y;\r
-var kjz = p3.z - p2.z;\r
-var klx = p3.x - p4.x;\r
-var kly = p3.y - p4.y;\r
-var klz = p3.z - p4.z;\r
-var ax = ijy * kjz - ijz * kjy;\r
-var ay = ijz * kjx - ijx * kjz;\r
-var az = ijx * kjy - ijy * kjx;\r
-var cx = kjy * klz - kjz * kly;\r
-var cy = kjz * klx - kjx * klz;\r
-var cz = kjx * kly - kjy * klx;\r
-var ai2 = 1 / (ax * ax + ay * ay + az * az);\r
-var ci2 = 1 / (cx * cx + cy * cy + cz * cz);\r
-var ai = Math.sqrt (ai2);\r
-var ci = Math.sqrt (ci2);\r
-var denom = ai * ci;\r
-var cross = ax * cx + ay * cy + az * cz;\r
-var cosang = cross * denom;\r
-if (cosang > 1) {\r
-cosang = 1;\r
-}if (cosang < -1) {\r
-cosang = -1;\r
-}var torsion = Math.acos (cosang);\r
-var dot = ijx * cx + ijy * cy + ijz * cz;\r
-var absDot = Math.abs (dot);\r
-torsion = (dot / absDot > 0) ? torsion : -torsion;\r
-return (asDegrees ? torsion / 0.017453292 : torsion);\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.T3,~B");\r
-c$.computeHelicalAxis = Clazz.defineMethod (c$, "computeHelicalAxis", \r
-function (a, b, dq) {\r
-var vab = new javajs.util.V3 ();\r
-vab.sub2 (b, a);\r
-var theta = dq.getTheta ();\r
-var n = dq.getNormal ();\r
-var v_dot_n = vab.dot (n);\r
-if (Math.abs (v_dot_n) < 0.0001) v_dot_n = 0;\r
-var va_prime_d = new javajs.util.V3 ();\r
-va_prime_d.cross (vab, n);\r
-if (va_prime_d.dot (va_prime_d) != 0) va_prime_d.normalize ();\r
-var vda = new javajs.util.V3 ();\r
-var vcb = javajs.util.V3.newV (n);\r
-if (v_dot_n == 0) v_dot_n = 1.4E-45;\r
-vcb.scale (v_dot_n);\r
-vda.sub2 (vcb, vab);\r
-vda.scale (0.5);\r
-va_prime_d.scale (theta == 0 ? 0 : (vda.length () / Math.tan (theta / 2 / 180 * 3.141592653589793)));\r
-var r = javajs.util.V3.newV (va_prime_d);\r
-if (theta != 0) r.add (vda);\r
-var pt_a_prime = javajs.util.P3.newP (a);\r
-pt_a_prime.sub (r);\r
-if (v_dot_n != 1.4E-45) n.scale (v_dot_n);\r
-var pt_b_prime = javajs.util.P3.newP (pt_a_prime);\r
-pt_b_prime.add (n);\r
-theta = javajs.util.Measure.computeTorsion (a, pt_a_prime, pt_b_prime, b, true);\r
-if (Float.isNaN (theta) || r.length () < 0.0001) theta = dq.getThetaDirectedV (n);\r
-var residuesPerTurn = Math.abs (theta == 0 ? 0 : 360 / theta);\r
-var pitch = Math.abs (v_dot_n == 1.4E-45 ? 0 : n.length () * (theta == 0 ? 1 : 360 / theta));\r
-return Clazz.newArray (-1, [pt_a_prime, n, r, javajs.util.P3.new3 (theta, pitch, residuesPerTurn), pt_b_prime]);\r
-}, "javajs.util.P3,javajs.util.P3,javajs.util.Quat");\r
-c$.getPlaneThroughPoints = Clazz.defineMethod (c$, "getPlaneThroughPoints", \r
-function (pointA, pointB, pointC, vNorm, vAB, plane) {\r
-var w = javajs.util.Measure.getNormalThroughPoints (pointA, pointB, pointC, vNorm, vAB);\r
-plane.set4 (vNorm.x, vNorm.y, vNorm.z, w);\r
-return plane;\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3,javajs.util.P4");\r
-c$.getPlaneThroughPoint = Clazz.defineMethod (c$, "getPlaneThroughPoint", \r
-function (pt, normal, plane) {\r
-plane.set4 (normal.x, normal.y, normal.z, -normal.dot (pt));\r
-}, "javajs.util.T3,javajs.util.V3,javajs.util.P4");\r
-c$.distanceToPlane = Clazz.defineMethod (c$, "distanceToPlane", \r
-function (plane, pt) {\r
-return (plane == null ? NaN : (plane.dot (pt) + plane.w) / Math.sqrt (plane.dot (plane)));\r
-}, "javajs.util.P4,javajs.util.T3");\r
-c$.directedDistanceToPlane = Clazz.defineMethod (c$, "directedDistanceToPlane", \r
-function (pt, plane, ptref) {\r
-var f = plane.dot (pt) + plane.w;\r
-var f1 = plane.dot (ptref) + plane.w;\r
-return Math.signum (f1) * f / Math.sqrt (plane.dot (plane));\r
-}, "javajs.util.P3,javajs.util.P4,javajs.util.P3");\r
-c$.distanceToPlaneD = Clazz.defineMethod (c$, "distanceToPlaneD", \r
-function (plane, d, pt) {\r
-return (plane == null ? NaN : (plane.dot (pt) + plane.w) / d);\r
-}, "javajs.util.P4,~N,javajs.util.P3");\r
-c$.distanceToPlaneV = Clazz.defineMethod (c$, "distanceToPlaneV", \r
-function (norm, w, pt) {\r
-return (norm == null ? NaN : (norm.dot (pt) + w) / Math.sqrt (norm.dot (norm)));\r
-}, "javajs.util.V3,~N,javajs.util.P3");\r
-c$.calcNormalizedNormal = Clazz.defineMethod (c$, "calcNormalizedNormal", \r
-function (pointA, pointB, pointC, vNormNorm, vAB) {\r
-vAB.sub2 (pointB, pointA);\r
-vNormNorm.sub2 (pointC, pointA);\r
-vNormNorm.cross (vAB, vNormNorm);\r
-vNormNorm.normalize ();\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");\r
-c$.getDirectedNormalThroughPoints = Clazz.defineMethod (c$, "getDirectedNormalThroughPoints", \r
-function (pointA, pointB, pointC, ptRef, vNorm, vAB) {\r
-var nd = javajs.util.Measure.getNormalThroughPoints (pointA, pointB, pointC, vNorm, vAB);\r
-if (ptRef != null) {\r
-var pt0 = javajs.util.P3.newP (pointA);\r
-pt0.add (vNorm);\r
-var d = pt0.distance (ptRef);\r
-pt0.sub2 (pointA, vNorm);\r
-if (d > pt0.distance (ptRef)) {\r
-vNorm.scale (-1);\r
-nd = -nd;\r
-}}return nd;\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");\r
-c$.getNormalThroughPoints = Clazz.defineMethod (c$, "getNormalThroughPoints", \r
-function (pointA, pointB, pointC, vNorm, vTemp) {\r
-javajs.util.Measure.calcNormalizedNormal (pointA, pointB, pointC, vNorm, vTemp);\r
-vTemp.setT (pointA);\r
-return -vTemp.dot (vNorm);\r
-}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");\r
-c$.getPlaneProjection = Clazz.defineMethod (c$, "getPlaneProjection", \r
-function (pt, plane, ptProj, vNorm) {\r
-var dist = javajs.util.Measure.distanceToPlane (plane, pt);\r
-vNorm.set (plane.x, plane.y, plane.z);\r
-vNorm.normalize ();\r
-vNorm.scale (-dist);\r
-ptProj.add2 (pt, vNorm);\r
-}, "javajs.util.P3,javajs.util.P4,javajs.util.P3,javajs.util.V3");\r
-c$.getNormalToLine = Clazz.defineMethod (c$, "getNormalToLine", \r
-function (pointA, pointB, vNormNorm) {\r
-vNormNorm.sub2 (pointA, pointB);\r
-vNormNorm.cross (vNormNorm, javajs.util.Measure.axisY);\r
-vNormNorm.normalize ();\r
-if (Float.isNaN (vNormNorm.x)) vNormNorm.set (1, 0, 0);\r
-}, "javajs.util.P3,javajs.util.P3,javajs.util.V3");\r
-c$.getBisectingPlane = Clazz.defineMethod (c$, "getBisectingPlane", \r
-function (pointA, vAB, ptTemp, vTemp, plane) {\r
-ptTemp.scaleAdd2 (0.5, vAB, pointA);\r
-vTemp.setT (vAB);\r
-vTemp.normalize ();\r
-javajs.util.Measure.getPlaneThroughPoint (ptTemp, vTemp, plane);\r
-}, "javajs.util.P3,javajs.util.V3,javajs.util.T3,javajs.util.V3,javajs.util.P4");\r
-c$.projectOntoAxis = Clazz.defineMethod (c$, "projectOntoAxis", \r
-function (point, axisA, axisUnitVector, vectorProjection) {\r
-vectorProjection.sub2 (point, axisA);\r
-var projectedLength = vectorProjection.dot (axisUnitVector);\r
-point.scaleAdd2 (projectedLength, axisUnitVector, axisA);\r
-vectorProjection.sub2 (point, axisA);\r
-}, "javajs.util.P3,javajs.util.P3,javajs.util.V3,javajs.util.V3");\r
-c$.calcBestAxisThroughPoints = Clazz.defineMethod (c$, "calcBestAxisThroughPoints", \r
-function (points, axisA, axisUnitVector, vectorProjection, nTriesMax) {\r
-var nPoints = points.length;\r
-axisA.setT (points[0]);\r
-axisUnitVector.sub2 (points[nPoints - 1], axisA);\r
-axisUnitVector.normalize ();\r
-javajs.util.Measure.calcAveragePointN (points, nPoints, axisA);\r
-var nTries = 0;\r
-while (nTries++ < nTriesMax && javajs.util.Measure.findAxis (points, nPoints, axisA, axisUnitVector, vectorProjection) > 0.001) {\r
-}\r
-var tempA = javajs.util.P3.newP (points[0]);\r
-javajs.util.Measure.projectOntoAxis (tempA, axisA, axisUnitVector, vectorProjection);\r
-axisA.setT (tempA);\r
-}, "~A,javajs.util.P3,javajs.util.V3,javajs.util.V3,~N");\r
-c$.findAxis = Clazz.defineMethod (c$, "findAxis", \r
-function (points, nPoints, axisA, axisUnitVector, vectorProjection) {\r
-var sumXiYi = new javajs.util.V3 ();\r
-var vTemp = new javajs.util.V3 ();\r
-var pt = new javajs.util.P3 ();\r
-var ptProj = new javajs.util.P3 ();\r
-var a = javajs.util.V3.newV (axisUnitVector);\r
-var sum_Xi2 = 0;\r
-for (var i = nPoints; --i >= 0; ) {\r
-pt.setT (points[i]);\r
-ptProj.setT (pt);\r
-javajs.util.Measure.projectOntoAxis (ptProj, axisA, axisUnitVector, vectorProjection);\r
-vTemp.sub2 (pt, ptProj);\r
-vTemp.cross (vectorProjection, vTemp);\r
-sumXiYi.add (vTemp);\r
-sum_Xi2 += vectorProjection.lengthSquared ();\r
-}\r
-var m = javajs.util.V3.newV (sumXiYi);\r
-m.scale (1 / sum_Xi2);\r
-vTemp.cross (m, axisUnitVector);\r
-axisUnitVector.add (vTemp);\r
-axisUnitVector.normalize ();\r
-vTemp.sub2 (axisUnitVector, a);\r
-return vTemp.length ();\r
-}, "~A,~N,javajs.util.P3,javajs.util.V3,javajs.util.V3");\r
-c$.calcAveragePoint = Clazz.defineMethod (c$, "calcAveragePoint", \r
-function (pointA, pointB, pointC) {\r
-pointC.set ((pointA.x + pointB.x) / 2, (pointA.y + pointB.y) / 2, (pointA.z + pointB.z) / 2);\r
-}, "javajs.util.P3,javajs.util.P3,javajs.util.P3");\r
-c$.calcAveragePointN = Clazz.defineMethod (c$, "calcAveragePointN", \r
-function (points, nPoints, averagePoint) {\r
-averagePoint.setT (points[0]);\r
-for (var i = 1; i < nPoints; i++) averagePoint.add (points[i]);\r
-\r
-averagePoint.scale (1 / nPoints);\r
-}, "~A,~N,javajs.util.P3");\r
-c$.transformPoints = Clazz.defineMethod (c$, "transformPoints", \r
-function (vPts, m4, center) {\r
-var v = new javajs.util.Lst ();\r
-for (var i = 0; i < vPts.size (); i++) {\r
-var pt = javajs.util.P3.newP (vPts.get (i));\r
-pt.sub (center);\r
-m4.rotTrans (pt);\r
-pt.add (center);\r
-v.addLast (pt);\r
-}\r
-return v;\r
-}, "javajs.util.Lst,javajs.util.M4,javajs.util.P3");\r
-c$.isInTetrahedron = Clazz.defineMethod (c$, "isInTetrahedron", \r
-function (pt, ptA, ptB, ptC, ptD, plane, vTemp, vTemp2, fullyEnclosed) {\r
-var b = (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptC, ptD, ptA, vTemp, vTemp2, plane), pt) >= 0);\r
-if (b != (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptA, ptD, ptB, vTemp, vTemp2, plane), pt) >= 0)) return false;\r
-if (b != (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptB, ptD, ptC, vTemp, vTemp2, plane), pt) >= 0)) return false;\r
-var d = javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptA, ptB, ptC, vTemp, vTemp2, plane), pt);\r
-if (fullyEnclosed) return (b == (d >= 0));\r
-var d1 = javajs.util.Measure.distanceToPlane (plane, ptD);\r
-return d1 * d <= 0 || Math.abs (d1) > Math.abs (d);\r
-}, "javajs.util.P3,javajs.util.P3,javajs.util.P3,javajs.util.P3,javajs.util.P3,javajs.util.P4,javajs.util.V3,javajs.util.V3,~B");\r
-c$.getIntersectionPP = Clazz.defineMethod (c$, "getIntersectionPP", \r
-function (plane1, plane2) {\r
-var a1 = plane1.x;\r
-var b1 = plane1.y;\r
-var c1 = plane1.z;\r
-var d1 = plane1.w;\r
-var a2 = plane2.x;\r
-var b2 = plane2.y;\r
-var c2 = plane2.z;\r
-var d2 = plane2.w;\r
-var norm1 = javajs.util.V3.new3 (a1, b1, c1);\r
-var norm2 = javajs.util.V3.new3 (a2, b2, c2);\r
-var nxn = new javajs.util.V3 ();\r
-nxn.cross (norm1, norm2);\r
-var ax = Math.abs (nxn.x);\r
-var ay = Math.abs (nxn.y);\r
-var az = Math.abs (nxn.z);\r
-var x;\r
-var y;\r
-var z;\r
-var diff;\r
-var type = (ax > ay ? (ax > az ? 1 : 3) : ay > az ? 2 : 3);\r
-switch (type) {\r
-case 1:\r
-x = 0;\r
-diff = (b1 * c2 - b2 * c1);\r
-if (Math.abs (diff) < 0.01) return null;\r
-y = (c1 * d2 - c2 * d1) / diff;\r
-z = (b2 * d1 - d2 * b1) / diff;\r
-break;\r
-case 2:\r
-diff = (a1 * c2 - a2 * c1);\r
-if (Math.abs (diff) < 0.01) return null;\r
-x = (c1 * d2 - c2 * d1) / diff;\r
-y = 0;\r
-z = (a2 * d1 - d2 * a1) / diff;\r
-break;\r
-case 3:\r
-default:\r
-diff = (a1 * b2 - a2 * b1);\r
-if (Math.abs (diff) < 0.01) return null;\r
-x = (b1 * d2 - b2 * d1) / diff;\r
-y = (a2 * d1 - d2 * a1) / diff;\r
-z = 0;\r
-}\r
-var list = new javajs.util.Lst ();\r
-list.addLast (javajs.util.P3.new3 (x, y, z));\r
-nxn.normalize ();\r
-list.addLast (nxn);\r
-return list;\r
-}, "javajs.util.P4,javajs.util.P4");\r
-c$.getIntersection = Clazz.defineMethod (c$, "getIntersection", \r
-function (pt1, v, plane, ptRet, tempNorm, vTemp) {\r
-javajs.util.Measure.getPlaneProjection (pt1, plane, ptRet, tempNorm);\r
-tempNorm.set (plane.x, plane.y, plane.z);\r
-tempNorm.normalize ();\r
-if (v == null) v = javajs.util.V3.newV (tempNorm);\r
-var l_dot_n = v.dot (tempNorm);\r
-if (Math.abs (l_dot_n) < 0.01) return null;\r
-vTemp.sub2 (ptRet, pt1);\r
-ptRet.scaleAdd2 (vTemp.dot (tempNorm) / l_dot_n, v, pt1);\r
-return ptRet;\r
-}, "javajs.util.P3,javajs.util.V3,javajs.util.P4,javajs.util.P3,javajs.util.V3,javajs.util.V3");\r
-c$.calculateQuaternionRotation = Clazz.defineMethod (c$, "calculateQuaternionRotation", \r
-function (centerAndPoints, retStddev) {\r
-retStddev[1] = NaN;\r
-var q = new javajs.util.Quat ();\r
-if (centerAndPoints[0].length == 1 || centerAndPoints[0].length != centerAndPoints[1].length) return q;\r
-var n = centerAndPoints[0].length - 1;\r
-if (n < 2) return q;\r
-var Sxx = 0;\r
-var Sxy = 0;\r
-var Sxz = 0;\r
-var Syx = 0;\r
-var Syy = 0;\r
-var Syz = 0;\r
-var Szx = 0;\r
-var Szy = 0;\r
-var Szz = 0;\r
-var ptA = new javajs.util.P3 ();\r
-var ptB = new javajs.util.P3 ();\r
-for (var i = n + 1; --i >= 1; ) {\r
-var aij = centerAndPoints[0][i];\r
-var bij = centerAndPoints[1][i];\r
-ptA.sub2 (aij, centerAndPoints[0][0]);\r
-ptB.sub2 (bij, centerAndPoints[0][1]);\r
-Sxx += ptA.x * ptB.x;\r
-Sxy += ptA.x * ptB.y;\r
-Sxz += ptA.x * ptB.z;\r
-Syx += ptA.y * ptB.x;\r
-Syy += ptA.y * ptB.y;\r
-Syz += ptA.y * ptB.z;\r
-Szx += ptA.z * ptB.x;\r
-Szy += ptA.z * ptB.y;\r
-Szz += ptA.z * ptB.z;\r
-}\r
-retStddev[0] = javajs.util.Measure.getRmsd (centerAndPoints, q);\r
-var N = Clazz.newDoubleArray (4, 4, 0);\r
-N[0][0] = Sxx + Syy + Szz;\r
-N[0][1] = N[1][0] = Syz - Szy;\r
-N[0][2] = N[2][0] = Szx - Sxz;\r
-N[0][3] = N[3][0] = Sxy - Syx;\r
-N[1][1] = Sxx - Syy - Szz;\r
-N[1][2] = N[2][1] = Sxy + Syx;\r
-N[1][3] = N[3][1] = Szx + Sxz;\r
-N[2][2] = -Sxx + Syy - Szz;\r
-N[2][3] = N[3][2] = Syz + Szy;\r
-N[3][3] = -Sxx - Syy + Szz;\r
-var v = (javajs.api.Interface.getInterface ("javajs.util.Eigen")).setM (N).getEigenvectorsFloatTransposed ()[3];\r
-q = javajs.util.Quat.newP4 (javajs.util.P4.new4 (v[1], v[2], v[3], v[0]));\r
-retStddev[1] = javajs.util.Measure.getRmsd (centerAndPoints, q);\r
-return q;\r
-}, "~A,~A");\r
-c$.getTransformMatrix4 = Clazz.defineMethod (c$, "getTransformMatrix4", \r
-function (ptsA, ptsB, m, centerA) {\r
-var cptsA = javajs.util.Measure.getCenterAndPoints (ptsA);\r
-var cptsB = javajs.util.Measure.getCenterAndPoints (ptsB);\r
-var retStddev = Clazz.newFloatArray (2, 0);\r
-var q = javajs.util.Measure.calculateQuaternionRotation ( Clazz.newArray (-1, [cptsA, cptsB]), retStddev);\r
-var r = q.getMatrix ();\r
-if (centerA == null) r.rotate (cptsA[0]);\r
- else centerA.setT (cptsA[0]);\r
-var t = javajs.util.V3.newVsub (cptsB[0], cptsA[0]);\r
-m.setMV (r, t);\r
-return retStddev[1];\r
-}, "javajs.util.Lst,javajs.util.Lst,javajs.util.M4,javajs.util.P3");\r
-c$.getCenterAndPoints = Clazz.defineMethod (c$, "getCenterAndPoints", \r
-function (vPts) {\r
-var n = vPts.size ();\r
-var pts = new Array (n + 1);\r
-pts[0] = new javajs.util.P3 ();\r
-if (n > 0) {\r
-for (var i = 0; i < n; i++) {\r
-pts[0].add (pts[i + 1] = vPts.get (i));\r
-}\r
-pts[0].scale (1 / n);\r
-}return pts;\r
-}, "javajs.util.Lst");\r
-c$.getRmsd = Clazz.defineMethod (c$, "getRmsd", \r
-function (centerAndPoints, q) {\r
-var sum2 = 0;\r
-var ptsA = centerAndPoints[0];\r
-var ptsB = centerAndPoints[1];\r
-var cA = ptsA[0];\r
-var cB = ptsB[0];\r
-var n = ptsA.length - 1;\r
-var ptAnew = new javajs.util.P3 ();\r
-for (var i = n + 1; --i >= 1; ) {\r
-ptAnew.sub2 (ptsA[i], cA);\r
-q.transform2 (ptAnew, ptAnew).add (cB);\r
-sum2 += ptAnew.distanceSquared (ptsB[i]);\r
-}\r
-return Math.sqrt (sum2 / n);\r
-}, "~A,javajs.util.Quat");\r
-Clazz.defineStatics (c$,\r
-"radiansPerDegree", (0.017453292519943295));\r
-c$.axisY = c$.prototype.axisY = javajs.util.V3.new3 (0, 1, 0);\r
-});\r
+Clazz.declarePackage ("javajs.util");
+Clazz.load (["javajs.util.V3"], "javajs.util.Measure", ["java.lang.Float", "javajs.api.Interface", "javajs.util.Lst", "$.P3", "$.P4", "$.Quat"], function () {
+c$ = Clazz.declareType (javajs.util, "Measure");
+c$.computeAngle = Clazz.defineMethod (c$, "computeAngle",
+function (pointA, pointB, pointC, vectorBA, vectorBC, asDegrees) {
+vectorBA.sub2 (pointA, pointB);
+vectorBC.sub2 (pointC, pointB);
+var angle = vectorBA.angle (vectorBC);
+return (asDegrees ? angle / 0.017453292 : angle);
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3,~B");
+c$.computeAngleABC = Clazz.defineMethod (c$, "computeAngleABC",
+function (pointA, pointB, pointC, asDegrees) {
+var vectorBA = new javajs.util.V3 ();
+var vectorBC = new javajs.util.V3 ();
+return javajs.util.Measure.computeAngle (pointA, pointB, pointC, vectorBA, vectorBC, asDegrees);
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,~B");
+c$.computeTorsion = Clazz.defineMethod (c$, "computeTorsion",
+function (p1, p2, p3, p4, asDegrees) {
+var ijx = p1.x - p2.x;
+var ijy = p1.y - p2.y;
+var ijz = p1.z - p2.z;
+var kjx = p3.x - p2.x;
+var kjy = p3.y - p2.y;
+var kjz = p3.z - p2.z;
+var klx = p3.x - p4.x;
+var kly = p3.y - p4.y;
+var klz = p3.z - p4.z;
+var ax = ijy * kjz - ijz * kjy;
+var ay = ijz * kjx - ijx * kjz;
+var az = ijx * kjy - ijy * kjx;
+var cx = kjy * klz - kjz * kly;
+var cy = kjz * klx - kjx * klz;
+var cz = kjx * kly - kjy * klx;
+var ai2 = 1 / (ax * ax + ay * ay + az * az);
+var ci2 = 1 / (cx * cx + cy * cy + cz * cz);
+var ai = Math.sqrt (ai2);
+var ci = Math.sqrt (ci2);
+var denom = ai * ci;
+var cross = ax * cx + ay * cy + az * cz;
+var cosang = cross * denom;
+if (cosang > 1) {
+cosang = 1;
+}if (cosang < -1) {
+cosang = -1;
+}var torsion = Math.acos (cosang);
+var dot = ijx * cx + ijy * cy + ijz * cz;
+var absDot = Math.abs (dot);
+torsion = (dot / absDot > 0) ? torsion : -torsion;
+return (asDegrees ? torsion / 0.017453292 : torsion);
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.T3,~B");
+c$.computeHelicalAxis = Clazz.defineMethod (c$, "computeHelicalAxis",
+function (a, b, dq) {
+var vab = new javajs.util.V3 ();
+vab.sub2 (b, a);
+var theta = dq.getTheta ();
+var n = dq.getNormal ();
+var v_dot_n = vab.dot (n);
+if (Math.abs (v_dot_n) < 0.0001) v_dot_n = 0;
+var va_prime_d = new javajs.util.V3 ();
+va_prime_d.cross (vab, n);
+if (va_prime_d.dot (va_prime_d) != 0) va_prime_d.normalize ();
+var vda = new javajs.util.V3 ();
+var vcb = javajs.util.V3.newV (n);
+if (v_dot_n == 0) v_dot_n = 1.4E-45;
+vcb.scale (v_dot_n);
+vda.sub2 (vcb, vab);
+vda.scale (0.5);
+va_prime_d.scale (theta == 0 ? 0 : (vda.length () / Math.tan (theta / 2 / 180 * 3.141592653589793)));
+var r = javajs.util.V3.newV (va_prime_d);
+if (theta != 0) r.add (vda);
+var pt_a_prime = javajs.util.P3.newP (a);
+pt_a_prime.sub (r);
+if (v_dot_n != 1.4E-45) n.scale (v_dot_n);
+var pt_b_prime = javajs.util.P3.newP (pt_a_prime);
+pt_b_prime.add (n);
+theta = javajs.util.Measure.computeTorsion (a, pt_a_prime, pt_b_prime, b, true);
+if (Float.isNaN (theta) || r.length () < 0.0001) theta = dq.getThetaDirectedV (n);
+var residuesPerTurn = Math.abs (theta == 0 ? 0 : 360 / theta);
+var pitch = Math.abs (v_dot_n == 1.4E-45 ? 0 : n.length () * (theta == 0 ? 1 : 360 / theta));
+return Clazz.newArray (-1, [pt_a_prime, n, r, javajs.util.P3.new3 (theta, pitch, residuesPerTurn), pt_b_prime]);
+}, "javajs.util.P3,javajs.util.P3,javajs.util.Quat");
+c$.getPlaneThroughPoints = Clazz.defineMethod (c$, "getPlaneThroughPoints",
+function (pointA, pointB, pointC, vNorm, vAB, plane) {
+var w = javajs.util.Measure.getNormalThroughPoints (pointA, pointB, pointC, vNorm, vAB);
+plane.set4 (vNorm.x, vNorm.y, vNorm.z, w);
+return plane;
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3,javajs.util.P4");
+c$.getPlaneThroughPoint = Clazz.defineMethod (c$, "getPlaneThroughPoint",
+function (pt, normal, plane) {
+plane.set4 (normal.x, normal.y, normal.z, -normal.dot (pt));
+}, "javajs.util.T3,javajs.util.V3,javajs.util.P4");
+c$.distanceToPlane = Clazz.defineMethod (c$, "distanceToPlane",
+function (plane, pt) {
+return (plane == null ? NaN : (plane.dot (pt) + plane.w) / Math.sqrt (plane.dot (plane)));
+}, "javajs.util.P4,javajs.util.T3");
+c$.directedDistanceToPlane = Clazz.defineMethod (c$, "directedDistanceToPlane",
+function (pt, plane, ptref) {
+var f = plane.dot (pt) + plane.w;
+var f1 = plane.dot (ptref) + plane.w;
+return Math.signum (f1) * f / Math.sqrt (plane.dot (plane));
+}, "javajs.util.P3,javajs.util.P4,javajs.util.P3");
+c$.distanceToPlaneD = Clazz.defineMethod (c$, "distanceToPlaneD",
+function (plane, d, pt) {
+return (plane == null ? NaN : (plane.dot (pt) + plane.w) / d);
+}, "javajs.util.P4,~N,javajs.util.P3");
+c$.distanceToPlaneV = Clazz.defineMethod (c$, "distanceToPlaneV",
+function (norm, w, pt) {
+return (norm == null ? NaN : (norm.dot (pt) + w) / Math.sqrt (norm.dot (norm)));
+}, "javajs.util.V3,~N,javajs.util.P3");
+c$.calcNormalizedNormal = Clazz.defineMethod (c$, "calcNormalizedNormal",
+function (pointA, pointB, pointC, vNormNorm, vAB) {
+vAB.sub2 (pointB, pointA);
+vNormNorm.sub2 (pointC, pointA);
+vNormNorm.cross (vAB, vNormNorm);
+vNormNorm.normalize ();
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");
+c$.getDirectedNormalThroughPoints = Clazz.defineMethod (c$, "getDirectedNormalThroughPoints",
+function (pointA, pointB, pointC, ptRef, vNorm, vAB) {
+var nd = javajs.util.Measure.getNormalThroughPoints (pointA, pointB, pointC, vNorm, vAB);
+if (ptRef != null) {
+var pt0 = javajs.util.P3.newP (pointA);
+pt0.add (vNorm);
+var d = pt0.distance (ptRef);
+pt0.sub2 (pointA, vNorm);
+if (d > pt0.distance (ptRef)) {
+vNorm.scale (-1);
+nd = -nd;
+}}return nd;
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");
+c$.getNormalThroughPoints = Clazz.defineMethod (c$, "getNormalThroughPoints",
+function (pointA, pointB, pointC, vNorm, vTemp) {
+javajs.util.Measure.calcNormalizedNormal (pointA, pointB, pointC, vNorm, vTemp);
+vTemp.setT (pointA);
+return -vTemp.dot (vNorm);
+}, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");
+c$.getPlaneProjection = Clazz.defineMethod (c$, "getPlaneProjection",
+function (pt, plane, ptProj, vNorm) {
+var dist = javajs.util.Measure.distanceToPlane (plane, pt);
+vNorm.set (plane.x, plane.y, plane.z);
+vNorm.normalize ();
+vNorm.scale (-dist);
+ptProj.add2 (pt, vNorm);
+}, "javajs.util.P3,javajs.util.P4,javajs.util.P3,javajs.util.V3");
+c$.getNormalToLine = Clazz.defineMethod (c$, "getNormalToLine",
+function (pointA, pointB, vNormNorm) {
+vNormNorm.sub2 (pointA, pointB);
+vNormNorm.cross (vNormNorm, javajs.util.Measure.axisY);
+vNormNorm.normalize ();
+if (Float.isNaN (vNormNorm.x)) vNormNorm.set (1, 0, 0);
+}, "javajs.util.P3,javajs.util.P3,javajs.util.V3");
+c$.getBisectingPlane = Clazz.defineMethod (c$, "getBisectingPlane",
+function (pointA, vAB, ptTemp, vTemp, plane) {
+ptTemp.scaleAdd2 (0.5, vAB, pointA);
+vTemp.setT (vAB);
+vTemp.normalize ();
+javajs.util.Measure.getPlaneThroughPoint (ptTemp, vTemp, plane);
+}, "javajs.util.P3,javajs.util.V3,javajs.util.T3,javajs.util.V3,javajs.util.P4");
+c$.projectOntoAxis = Clazz.defineMethod (c$, "projectOntoAxis",
+function (point, axisA, axisUnitVector, vectorProjection) {
+vectorProjection.sub2 (point, axisA);
+var projectedLength = vectorProjection.dot (axisUnitVector);
+point.scaleAdd2 (projectedLength, axisUnitVector, axisA);
+vectorProjection.sub2 (point, axisA);
+}, "javajs.util.P3,javajs.util.P3,javajs.util.V3,javajs.util.V3");
+c$.calcBestAxisThroughPoints = Clazz.defineMethod (c$, "calcBestAxisThroughPoints",
+function (points, axisA, axisUnitVector, vectorProjection, nTriesMax) {
+var nPoints = points.length;
+axisA.setT (points[0]);
+axisUnitVector.sub2 (points[nPoints - 1], axisA);
+axisUnitVector.normalize ();
+javajs.util.Measure.calcAveragePointN (points, nPoints, axisA);
+var nTries = 0;
+while (nTries++ < nTriesMax && javajs.util.Measure.findAxis (points, nPoints, axisA, axisUnitVector, vectorProjection) > 0.001) {
+}
+var tempA = javajs.util.P3.newP (points[0]);
+javajs.util.Measure.projectOntoAxis (tempA, axisA, axisUnitVector, vectorProjection);
+axisA.setT (tempA);
+}, "~A,javajs.util.P3,javajs.util.V3,javajs.util.V3,~N");
+c$.findAxis = Clazz.defineMethod (c$, "findAxis",
+function (points, nPoints, axisA, axisUnitVector, vectorProjection) {
+var sumXiYi = new javajs.util.V3 ();
+var vTemp = new javajs.util.V3 ();
+var pt = new javajs.util.P3 ();
+var ptProj = new javajs.util.P3 ();
+var a = javajs.util.V3.newV (axisUnitVector);
+var sum_Xi2 = 0;
+for (var i = nPoints; --i >= 0; ) {
+pt.setT (points[i]);
+ptProj.setT (pt);
+javajs.util.Measure.projectOntoAxis (ptProj, axisA, axisUnitVector, vectorProjection);
+vTemp.sub2 (pt, ptProj);
+vTemp.cross (vectorProjection, vTemp);
+sumXiYi.add (vTemp);
+sum_Xi2 += vectorProjection.lengthSquared ();
+}
+var m = javajs.util.V3.newV (sumXiYi);
+m.scale (1 / sum_Xi2);
+vTemp.cross (m, axisUnitVector);
+axisUnitVector.add (vTemp);
+axisUnitVector.normalize ();
+vTemp.sub2 (axisUnitVector, a);
+return vTemp.length ();
+}, "~A,~N,javajs.util.P3,javajs.util.V3,javajs.util.V3");
+c$.calcAveragePoint = Clazz.defineMethod (c$, "calcAveragePoint",
+function (pointA, pointB, pointC) {
+pointC.set ((pointA.x + pointB.x) / 2, (pointA.y + pointB.y) / 2, (pointA.z + pointB.z) / 2);
+}, "javajs.util.P3,javajs.util.P3,javajs.util.P3");
+c$.calcAveragePointN = Clazz.defineMethod (c$, "calcAveragePointN",
+function (points, nPoints, averagePoint) {
+averagePoint.setT (points[0]);
+for (var i = 1; i < nPoints; i++) averagePoint.add (points[i]);
+
+averagePoint.scale (1 / nPoints);
+}, "~A,~N,javajs.util.P3");
+c$.transformPoints = Clazz.defineMethod (c$, "transformPoints",
+function (vPts, m4, center) {
+var v = new javajs.util.Lst ();
+for (var i = 0; i < vPts.size (); i++) {
+var pt = javajs.util.P3.newP (vPts.get (i));
+pt.sub (center);
+m4.rotTrans (pt);
+pt.add (center);
+v.addLast (pt);
+}
+return v;
+}, "javajs.util.Lst,javajs.util.M4,javajs.util.P3");
+c$.isInTetrahedron = Clazz.defineMethod (c$, "isInTetrahedron",
+function (pt, ptA, ptB, ptC, ptD, plane, vTemp, vTemp2, fullyEnclosed) {
+var b = (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptC, ptD, ptA, vTemp, vTemp2, plane), pt) >= 0);
+if (b != (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptA, ptD, ptB, vTemp, vTemp2, plane), pt) >= 0)) return false;
+if (b != (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptB, ptD, ptC, vTemp, vTemp2, plane), pt) >= 0)) return false;
+var d = javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptA, ptB, ptC, vTemp, vTemp2, plane), pt);
+if (fullyEnclosed) return (b == (d >= 0));
+var d1 = javajs.util.Measure.distanceToPlane (plane, ptD);
+return d1 * d <= 0 || Math.abs (d1) > Math.abs (d);
+}, "javajs.util.P3,javajs.util.P3,javajs.util.P3,javajs.util.P3,javajs.util.P3,javajs.util.P4,javajs.util.V3,javajs.util.V3,~B");
+c$.getIntersectionPP = Clazz.defineMethod (c$, "getIntersectionPP",
+function (plane1, plane2) {
+var a1 = plane1.x;
+var b1 = plane1.y;
+var c1 = plane1.z;
+var d1 = plane1.w;
+var a2 = plane2.x;
+var b2 = plane2.y;
+var c2 = plane2.z;
+var d2 = plane2.w;
+var norm1 = javajs.util.V3.new3 (a1, b1, c1);
+var norm2 = javajs.util.V3.new3 (a2, b2, c2);
+var nxn = new javajs.util.V3 ();
+nxn.cross (norm1, norm2);
+var ax = Math.abs (nxn.x);
+var ay = Math.abs (nxn.y);
+var az = Math.abs (nxn.z);
+var x;
+var y;
+var z;
+var diff;
+var type = (ax > ay ? (ax > az ? 1 : 3) : ay > az ? 2 : 3);
+switch (type) {
+case 1:
+x = 0;
+diff = (b1 * c2 - b2 * c1);
+if (Math.abs (diff) < 0.01) return null;
+y = (c1 * d2 - c2 * d1) / diff;
+z = (b2 * d1 - d2 * b1) / diff;
+break;
+case 2:
+diff = (a1 * c2 - a2 * c1);
+if (Math.abs (diff) < 0.01) return null;
+x = (c1 * d2 - c2 * d1) / diff;
+y = 0;
+z = (a2 * d1 - d2 * a1) / diff;
+break;
+case 3:
+default:
+diff = (a1 * b2 - a2 * b1);
+if (Math.abs (diff) < 0.01) return null;
+x = (b1 * d2 - b2 * d1) / diff;
+y = (a2 * d1 - d2 * a1) / diff;
+z = 0;
+}
+var list = new javajs.util.Lst ();
+list.addLast (javajs.util.P3.new3 (x, y, z));
+nxn.normalize ();
+list.addLast (nxn);
+return list;
+}, "javajs.util.P4,javajs.util.P4");
+c$.getIntersection = Clazz.defineMethod (c$, "getIntersection",
+function (pt1, v, plane, ptRet, tempNorm, vTemp) {
+javajs.util.Measure.getPlaneProjection (pt1, plane, ptRet, tempNorm);
+tempNorm.set (plane.x, plane.y, plane.z);
+tempNorm.normalize ();
+if (v == null) v = javajs.util.V3.newV (tempNorm);
+var l_dot_n = v.dot (tempNorm);
+if (Math.abs (l_dot_n) < 0.01) return null;
+vTemp.sub2 (ptRet, pt1);
+ptRet.scaleAdd2 (vTemp.dot (tempNorm) / l_dot_n, v, pt1);
+return ptRet;
+}, "javajs.util.P3,javajs.util.V3,javajs.util.P4,javajs.util.P3,javajs.util.V3,javajs.util.V3");
+c$.calculateQuaternionRotation = Clazz.defineMethod (c$, "calculateQuaternionRotation",
+function (centerAndPoints, retStddev) {
+retStddev[1] = NaN;
+var q = new javajs.util.Quat ();
+if (centerAndPoints[0].length == 1 || centerAndPoints[0].length != centerAndPoints[1].length) return q;
+var n = centerAndPoints[0].length - 1;
+if (n < 2) return q;
+var Sxx = 0;
+var Sxy = 0;
+var Sxz = 0;
+var Syx = 0;
+var Syy = 0;
+var Syz = 0;
+var Szx = 0;
+var Szy = 0;
+var Szz = 0;
+var ptA = new javajs.util.P3 ();
+var ptB = new javajs.util.P3 ();
+for (var i = n + 1; --i >= 1; ) {
+var aij = centerAndPoints[0][i];
+var bij = centerAndPoints[1][i];
+ptA.sub2 (aij, centerAndPoints[0][0]);
+ptB.sub2 (bij, centerAndPoints[0][1]);
+Sxx += ptA.x * ptB.x;
+Sxy += ptA.x * ptB.y;
+Sxz += ptA.x * ptB.z;
+Syx += ptA.y * ptB.x;
+Syy += ptA.y * ptB.y;
+Syz += ptA.y * ptB.z;
+Szx += ptA.z * ptB.x;
+Szy += ptA.z * ptB.y;
+Szz += ptA.z * ptB.z;
+}
+retStddev[0] = javajs.util.Measure.getRmsd (centerAndPoints, q);
+var N = Clazz.newDoubleArray (4, 4, 0);
+N[0][0] = Sxx + Syy + Szz;
+N[0][1] = N[1][0] = Syz - Szy;
+N[0][2] = N[2][0] = Szx - Sxz;
+N[0][3] = N[3][0] = Sxy - Syx;
+N[1][1] = Sxx - Syy - Szz;
+N[1][2] = N[2][1] = Sxy + Syx;
+N[1][3] = N[3][1] = Szx + Sxz;
+N[2][2] = -Sxx + Syy - Szz;
+N[2][3] = N[3][2] = Syz + Szy;
+N[3][3] = -Sxx - Syy + Szz;
+var v = (javajs.api.Interface.getInterface ("javajs.util.Eigen")).setM (N).getEigenvectorsFloatTransposed ()[3];
+q = javajs.util.Quat.newP4 (javajs.util.P4.new4 (v[1], v[2], v[3], v[0]));
+retStddev[1] = javajs.util.Measure.getRmsd (centerAndPoints, q);
+return q;
+}, "~A,~A");
+c$.getTransformMatrix4 = Clazz.defineMethod (c$, "getTransformMatrix4",
+function (ptsA, ptsB, m, centerA) {
+var cptsA = javajs.util.Measure.getCenterAndPoints (ptsA);
+var cptsB = javajs.util.Measure.getCenterAndPoints (ptsB);
+var retStddev = Clazz.newFloatArray (2, 0);
+var q = javajs.util.Measure.calculateQuaternionRotation ( Clazz.newArray (-1, [cptsA, cptsB]), retStddev);
+var r = q.getMatrix ();
+if (centerA == null) r.rotate (cptsA[0]);
+ else centerA.setT (cptsA[0]);
+var t = javajs.util.V3.newVsub (cptsB[0], cptsA[0]);
+m.setMV (r, t);
+return retStddev[1];
+}, "javajs.util.Lst,javajs.util.Lst,javajs.util.M4,javajs.util.P3");
+c$.getCenterAndPoints = Clazz.defineMethod (c$, "getCenterAndPoints",
+function (vPts) {
+var n = vPts.size ();
+var pts = new Array (n + 1);
+pts[0] = new javajs.util.P3 ();
+if (n > 0) {
+for (var i = 0; i < n; i++) {
+pts[0].add (pts[i + 1] = vPts.get (i));
+}
+pts[0].scale (1 / n);
+}return pts;
+}, "javajs.util.Lst");
+c$.getRmsd = Clazz.defineMethod (c$, "getRmsd",
+function (centerAndPoints, q) {
+var sum2 = 0;
+var ptsA = centerAndPoints[0];
+var ptsB = centerAndPoints[1];
+var cA = ptsA[0];
+var cB = ptsB[0];
+var n = ptsA.length - 1;
+var ptAnew = new javajs.util.P3 ();
+for (var i = n + 1; --i >= 1; ) {
+ptAnew.sub2 (ptsA[i], cA);
+q.transform2 (ptAnew, ptAnew).add (cB);
+sum2 += ptAnew.distanceSquared (ptsB[i]);
+}
+return Math.sqrt (sum2 / n);
+}, "~A,javajs.util.Quat");
+Clazz.defineStatics (c$,
+"radiansPerDegree", (0.017453292519943295));
+c$.axisY = c$.prototype.axisY = javajs.util.V3.new3 (0, 1, 0);
+});
git://source.jalview.org / jalviewjs.git / blobdiff