1 Clazz.declarePackage ("javajs.util");
2 Clazz.load (["javajs.util.V3"], "javajs.util.Measure", ["java.lang.Float", "javajs.api.Interface", "javajs.util.Lst", "$.P3", "$.P4", "$.Quat"], function () {
3 c$ = Clazz.declareType (javajs.util, "Measure");
4 c$.computeAngle = Clazz.defineMethod (c$, "computeAngle",
5 function (pointA, pointB, pointC, vectorBA, vectorBC, asDegrees) {
6 vectorBA.sub2 (pointA, pointB);
7 vectorBC.sub2 (pointC, pointB);
8 var angle = vectorBA.angle (vectorBC);
9 return (asDegrees ? angle / 0.017453292 : angle);
10 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3,~B");
11 c$.computeAngleABC = Clazz.defineMethod (c$, "computeAngleABC",
12 function (pointA, pointB, pointC, asDegrees) {
13 var vectorBA = new javajs.util.V3 ();
14 var vectorBC = new javajs.util.V3 ();
15 return javajs.util.Measure.computeAngle (pointA, pointB, pointC, vectorBA, vectorBC, asDegrees);
16 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,~B");
17 c$.computeTorsion = Clazz.defineMethod (c$, "computeTorsion",
18 function (p1, p2, p3, p4, asDegrees) {
19 var ijx = p1.x - p2.x;
20 var ijy = p1.y - p2.y;
21 var ijz = p1.z - p2.z;
22 var kjx = p3.x - p2.x;
23 var kjy = p3.y - p2.y;
24 var kjz = p3.z - p2.z;
25 var klx = p3.x - p4.x;
26 var kly = p3.y - p4.y;
27 var klz = p3.z - p4.z;
28 var ax = ijy * kjz - ijz * kjy;
29 var ay = ijz * kjx - ijx * kjz;
30 var az = ijx * kjy - ijy * kjx;
31 var cx = kjy * klz - kjz * kly;
32 var cy = kjz * klx - kjx * klz;
33 var cz = kjx * kly - kjy * klx;
34 var ai2 = 1 / (ax * ax + ay * ay + az * az);
35 var ci2 = 1 / (cx * cx + cy * cy + cz * cz);
36 var ai = Math.sqrt (ai2);
37 var ci = Math.sqrt (ci2);
39 var cross = ax * cx + ay * cy + az * cz;
40 var cosang = cross * denom;
45 }var torsion = Math.acos (cosang);
46 var dot = ijx * cx + ijy * cy + ijz * cz;
47 var absDot = Math.abs (dot);
48 torsion = (dot / absDot > 0) ? torsion : -torsion;
49 return (asDegrees ? torsion / 0.017453292 : torsion);
50 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.T3,~B");
51 c$.computeHelicalAxis = Clazz.defineMethod (c$, "computeHelicalAxis",
53 var vab = new javajs.util.V3 ();
55 var theta = dq.getTheta ();
56 var n = dq.getNormal ();
57 var v_dot_n = vab.dot (n);
58 if (Math.abs (v_dot_n) < 0.0001) v_dot_n = 0;
59 var va_prime_d = new javajs.util.V3 ();
60 va_prime_d.cross (vab, n);
61 if (va_prime_d.dot (va_prime_d) != 0) va_prime_d.normalize ();
62 var vda = new javajs.util.V3 ();
63 var vcb = javajs.util.V3.newV (n);
64 if (v_dot_n == 0) v_dot_n = 1.4E-45;
68 va_prime_d.scale (theta == 0 ? 0 : (vda.length () / Math.tan (theta / 2 / 180 * 3.141592653589793)));
69 var r = javajs.util.V3.newV (va_prime_d);
70 if (theta != 0) r.add (vda);
71 var pt_a_prime = javajs.util.P3.newP (a);
73 if (v_dot_n != 1.4E-45) n.scale (v_dot_n);
74 var pt_b_prime = javajs.util.P3.newP (pt_a_prime);
76 theta = javajs.util.Measure.computeTorsion (a, pt_a_prime, pt_b_prime, b, true);
77 if (Float.isNaN (theta) || r.length () < 0.0001) theta = dq.getThetaDirectedV (n);
78 var residuesPerTurn = Math.abs (theta == 0 ? 0 : 360 / theta);
79 var pitch = Math.abs (v_dot_n == 1.4E-45 ? 0 : n.length () * (theta == 0 ? 1 : 360 / theta));
80 return Clazz.newArray (-1, [pt_a_prime, n, r, javajs.util.P3.new3 (theta, pitch, residuesPerTurn), pt_b_prime]);
81 }, "javajs.util.P3,javajs.util.P3,javajs.util.Quat");
82 c$.getPlaneThroughPoints = Clazz.defineMethod (c$, "getPlaneThroughPoints",
83 function (pointA, pointB, pointC, vNorm, vAB, plane) {
84 var w = javajs.util.Measure.getNormalThroughPoints (pointA, pointB, pointC, vNorm, vAB);
85 plane.set4 (vNorm.x, vNorm.y, vNorm.z, w);
87 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3,javajs.util.P4");
88 c$.getPlaneThroughPoint = Clazz.defineMethod (c$, "getPlaneThroughPoint",
89 function (pt, normal, plane) {
90 plane.set4 (normal.x, normal.y, normal.z, -normal.dot (pt));
91 }, "javajs.util.T3,javajs.util.V3,javajs.util.P4");
92 c$.distanceToPlane = Clazz.defineMethod (c$, "distanceToPlane",
93 function (plane, pt) {
94 return (plane == null ? NaN : (plane.dot (pt) + plane.w) / Math.sqrt (plane.dot (plane)));
95 }, "javajs.util.P4,javajs.util.T3");
96 c$.directedDistanceToPlane = Clazz.defineMethod (c$, "directedDistanceToPlane",
97 function (pt, plane, ptref) {
98 var f = plane.dot (pt) + plane.w;
99 var f1 = plane.dot (ptref) + plane.w;
100 return Math.signum (f1) * f / Math.sqrt (plane.dot (plane));
101 }, "javajs.util.P3,javajs.util.P4,javajs.util.P3");
102 c$.distanceToPlaneD = Clazz.defineMethod (c$, "distanceToPlaneD",
103 function (plane, d, pt) {
104 return (plane == null ? NaN : (plane.dot (pt) + plane.w) / d);
105 }, "javajs.util.P4,~N,javajs.util.P3");
106 c$.distanceToPlaneV = Clazz.defineMethod (c$, "distanceToPlaneV",
107 function (norm, w, pt) {
108 return (norm == null ? NaN : (norm.dot (pt) + w) / Math.sqrt (norm.dot (norm)));
109 }, "javajs.util.V3,~N,javajs.util.P3");
110 c$.calcNormalizedNormal = Clazz.defineMethod (c$, "calcNormalizedNormal",
111 function (pointA, pointB, pointC, vNormNorm, vAB) {
112 vAB.sub2 (pointB, pointA);
113 vNormNorm.sub2 (pointC, pointA);
114 vNormNorm.cross (vAB, vNormNorm);
115 vNormNorm.normalize ();
116 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");
117 c$.getDirectedNormalThroughPoints = Clazz.defineMethod (c$, "getDirectedNormalThroughPoints",
118 function (pointA, pointB, pointC, ptRef, vNorm, vAB) {
119 var nd = javajs.util.Measure.getNormalThroughPoints (pointA, pointB, pointC, vNorm, vAB);
121 var pt0 = javajs.util.P3.newP (pointA);
123 var d = pt0.distance (ptRef);
124 pt0.sub2 (pointA, vNorm);
125 if (d > pt0.distance (ptRef)) {
129 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");
130 c$.getNormalThroughPoints = Clazz.defineMethod (c$, "getNormalThroughPoints",
131 function (pointA, pointB, pointC, vNorm, vTemp) {
132 javajs.util.Measure.calcNormalizedNormal (pointA, pointB, pointC, vNorm, vTemp);
134 return -vTemp.dot (vNorm);
135 }, "javajs.util.T3,javajs.util.T3,javajs.util.T3,javajs.util.V3,javajs.util.V3");
136 c$.getPlaneProjection = Clazz.defineMethod (c$, "getPlaneProjection",
137 function (pt, plane, ptProj, vNorm) {
138 var dist = javajs.util.Measure.distanceToPlane (plane, pt);
139 vNorm.set (plane.x, plane.y, plane.z);
142 ptProj.add2 (pt, vNorm);
143 }, "javajs.util.P3,javajs.util.P4,javajs.util.P3,javajs.util.V3");
144 c$.getNormalToLine = Clazz.defineMethod (c$, "getNormalToLine",
145 function (pointA, pointB, vNormNorm) {
146 vNormNorm.sub2 (pointA, pointB);
147 vNormNorm.cross (vNormNorm, javajs.util.Measure.axisY);
148 vNormNorm.normalize ();
149 if (Float.isNaN (vNormNorm.x)) vNormNorm.set (1, 0, 0);
150 }, "javajs.util.P3,javajs.util.P3,javajs.util.V3");
151 c$.getBisectingPlane = Clazz.defineMethod (c$, "getBisectingPlane",
152 function (pointA, vAB, ptTemp, vTemp, plane) {
153 ptTemp.scaleAdd2 (0.5, vAB, pointA);
156 javajs.util.Measure.getPlaneThroughPoint (ptTemp, vTemp, plane);
157 }, "javajs.util.P3,javajs.util.V3,javajs.util.T3,javajs.util.V3,javajs.util.P4");
158 c$.projectOntoAxis = Clazz.defineMethod (c$, "projectOntoAxis",
159 function (point, axisA, axisUnitVector, vectorProjection) {
160 vectorProjection.sub2 (point, axisA);
161 var projectedLength = vectorProjection.dot (axisUnitVector);
162 point.scaleAdd2 (projectedLength, axisUnitVector, axisA);
163 vectorProjection.sub2 (point, axisA);
164 }, "javajs.util.P3,javajs.util.P3,javajs.util.V3,javajs.util.V3");
165 c$.calcBestAxisThroughPoints = Clazz.defineMethod (c$, "calcBestAxisThroughPoints",
166 function (points, axisA, axisUnitVector, vectorProjection, nTriesMax) {
167 var nPoints = points.length;
168 axisA.setT (points[0]);
169 axisUnitVector.sub2 (points[nPoints - 1], axisA);
170 axisUnitVector.normalize ();
171 javajs.util.Measure.calcAveragePointN (points, nPoints, axisA);
173 while (nTries++ < nTriesMax && javajs.util.Measure.findAxis (points, nPoints, axisA, axisUnitVector, vectorProjection) > 0.001) {
175 var tempA = javajs.util.P3.newP (points[0]);
176 javajs.util.Measure.projectOntoAxis (tempA, axisA, axisUnitVector, vectorProjection);
178 }, "~A,javajs.util.P3,javajs.util.V3,javajs.util.V3,~N");
179 c$.findAxis = Clazz.defineMethod (c$, "findAxis",
180 function (points, nPoints, axisA, axisUnitVector, vectorProjection) {
181 var sumXiYi = new javajs.util.V3 ();
182 var vTemp = new javajs.util.V3 ();
183 var pt = new javajs.util.P3 ();
184 var ptProj = new javajs.util.P3 ();
185 var a = javajs.util.V3.newV (axisUnitVector);
187 for (var i = nPoints; --i >= 0; ) {
190 javajs.util.Measure.projectOntoAxis (ptProj, axisA, axisUnitVector, vectorProjection);
191 vTemp.sub2 (pt, ptProj);
192 vTemp.cross (vectorProjection, vTemp);
194 sum_Xi2 += vectorProjection.lengthSquared ();
196 var m = javajs.util.V3.newV (sumXiYi);
197 m.scale (1 / sum_Xi2);
198 vTemp.cross (m, axisUnitVector);
199 axisUnitVector.add (vTemp);
200 axisUnitVector.normalize ();
201 vTemp.sub2 (axisUnitVector, a);
202 return vTemp.length ();
203 }, "~A,~N,javajs.util.P3,javajs.util.V3,javajs.util.V3");
204 c$.calcAveragePoint = Clazz.defineMethod (c$, "calcAveragePoint",
205 function (pointA, pointB, pointC) {
206 pointC.set ((pointA.x + pointB.x) / 2, (pointA.y + pointB.y) / 2, (pointA.z + pointB.z) / 2);
207 }, "javajs.util.P3,javajs.util.P3,javajs.util.P3");
208 c$.calcAveragePointN = Clazz.defineMethod (c$, "calcAveragePointN",
209 function (points, nPoints, averagePoint) {
210 averagePoint.setT (points[0]);
211 for (var i = 1; i < nPoints; i++) averagePoint.add (points[i]);
213 averagePoint.scale (1 / nPoints);
214 }, "~A,~N,javajs.util.P3");
215 c$.transformPoints = Clazz.defineMethod (c$, "transformPoints",
216 function (vPts, m4, center) {
217 var v = new javajs.util.Lst ();
218 for (var i = 0; i < vPts.size (); i++) {
219 var pt = javajs.util.P3.newP (vPts.get (i));
226 }, "javajs.util.Lst,javajs.util.M4,javajs.util.P3");
227 c$.isInTetrahedron = Clazz.defineMethod (c$, "isInTetrahedron",
228 function (pt, ptA, ptB, ptC, ptD, plane, vTemp, vTemp2, fullyEnclosed) {
229 var b = (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptC, ptD, ptA, vTemp, vTemp2, plane), pt) >= 0);
230 if (b != (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptA, ptD, ptB, vTemp, vTemp2, plane), pt) >= 0)) return false;
231 if (b != (javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptB, ptD, ptC, vTemp, vTemp2, plane), pt) >= 0)) return false;
232 var d = javajs.util.Measure.distanceToPlane (javajs.util.Measure.getPlaneThroughPoints (ptA, ptB, ptC, vTemp, vTemp2, plane), pt);
233 if (fullyEnclosed) return (b == (d >= 0));
234 var d1 = javajs.util.Measure.distanceToPlane (plane, ptD);
235 return d1 * d <= 0 || Math.abs (d1) > Math.abs (d);
236 }, "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");
237 c$.getIntersectionPP = Clazz.defineMethod (c$, "getIntersectionPP",
238 function (plane1, plane2) {
247 var norm1 = javajs.util.V3.new3 (a1, b1, c1);
248 var norm2 = javajs.util.V3.new3 (a2, b2, c2);
249 var nxn = new javajs.util.V3 ();
250 nxn.cross (norm1, norm2);
251 var ax = Math.abs (nxn.x);
252 var ay = Math.abs (nxn.y);
253 var az = Math.abs (nxn.z);
258 var type = (ax > ay ? (ax > az ? 1 : 3) : ay > az ? 2 : 3);
262 diff = (b1 * c2 - b2 * c1);
263 if (Math.abs (diff) < 0.01) return null;
264 y = (c1 * d2 - c2 * d1) / diff;
265 z = (b2 * d1 - d2 * b1) / diff;
268 diff = (a1 * c2 - a2 * c1);
269 if (Math.abs (diff) < 0.01) return null;
270 x = (c1 * d2 - c2 * d1) / diff;
272 z = (a2 * d1 - d2 * a1) / diff;
276 diff = (a1 * b2 - a2 * b1);
277 if (Math.abs (diff) < 0.01) return null;
278 x = (b1 * d2 - b2 * d1) / diff;
279 y = (a2 * d1 - d2 * a1) / diff;
282 var list = new javajs.util.Lst ();
283 list.addLast (javajs.util.P3.new3 (x, y, z));
287 }, "javajs.util.P4,javajs.util.P4");
288 c$.getIntersection = Clazz.defineMethod (c$, "getIntersection",
289 function (pt1, v, plane, ptRet, tempNorm, vTemp) {
290 javajs.util.Measure.getPlaneProjection (pt1, plane, ptRet, tempNorm);
291 tempNorm.set (plane.x, plane.y, plane.z);
292 tempNorm.normalize ();
293 if (v == null) v = javajs.util.V3.newV (tempNorm);
294 var l_dot_n = v.dot (tempNorm);
295 if (Math.abs (l_dot_n) < 0.01) return null;
296 vTemp.sub2 (ptRet, pt1);
297 ptRet.scaleAdd2 (vTemp.dot (tempNorm) / l_dot_n, v, pt1);
299 }, "javajs.util.P3,javajs.util.V3,javajs.util.P4,javajs.util.P3,javajs.util.V3,javajs.util.V3");
300 c$.calculateQuaternionRotation = Clazz.defineMethod (c$, "calculateQuaternionRotation",
301 function (centerAndPoints, retStddev) {
303 var q = new javajs.util.Quat ();
304 if (centerAndPoints[0].length == 1 || centerAndPoints[0].length != centerAndPoints[1].length) return q;
305 var n = centerAndPoints[0].length - 1;
316 var ptA = new javajs.util.P3 ();
317 var ptB = new javajs.util.P3 ();
318 for (var i = n + 1; --i >= 1; ) {
319 var aij = centerAndPoints[0][i];
320 var bij = centerAndPoints[1][i];
321 ptA.sub2 (aij, centerAndPoints[0][0]);
322 ptB.sub2 (bij, centerAndPoints[0][1]);
323 Sxx += ptA.x * ptB.x;
324 Sxy += ptA.x * ptB.y;
325 Sxz += ptA.x * ptB.z;
326 Syx += ptA.y * ptB.x;
327 Syy += ptA.y * ptB.y;
328 Syz += ptA.y * ptB.z;
329 Szx += ptA.z * ptB.x;
330 Szy += ptA.z * ptB.y;
331 Szz += ptA.z * ptB.z;
333 retStddev[0] = javajs.util.Measure.getRmsd (centerAndPoints, q);
334 var N = Clazz.newDoubleArray (4, 4, 0);
335 N[0][0] = Sxx + Syy + Szz;
336 N[0][1] = N[1][0] = Syz - Szy;
337 N[0][2] = N[2][0] = Szx - Sxz;
338 N[0][3] = N[3][0] = Sxy - Syx;
339 N[1][1] = Sxx - Syy - Szz;
340 N[1][2] = N[2][1] = Sxy + Syx;
341 N[1][3] = N[3][1] = Szx + Sxz;
342 N[2][2] = -Sxx + Syy - Szz;
343 N[2][3] = N[3][2] = Syz + Szy;
344 N[3][3] = -Sxx - Syy + Szz;
345 var v = (javajs.api.Interface.getInterface ("javajs.util.Eigen")).setM (N).getEigenvectorsFloatTransposed ()[3];
346 q = javajs.util.Quat.newP4 (javajs.util.P4.new4 (v[1], v[2], v[3], v[0]));
347 retStddev[1] = javajs.util.Measure.getRmsd (centerAndPoints, q);
350 c$.getTransformMatrix4 = Clazz.defineMethod (c$, "getTransformMatrix4",
351 function (ptsA, ptsB, m, centerA) {
352 var cptsA = javajs.util.Measure.getCenterAndPoints (ptsA);
353 var cptsB = javajs.util.Measure.getCenterAndPoints (ptsB);
354 var retStddev = Clazz.newFloatArray (2, 0);
355 var q = javajs.util.Measure.calculateQuaternionRotation ( Clazz.newArray (-1, [cptsA, cptsB]), retStddev);
356 var r = q.getMatrix ();
357 if (centerA == null) r.rotate (cptsA[0]);
358 else centerA.setT (cptsA[0]);
359 var t = javajs.util.V3.newVsub (cptsB[0], cptsA[0]);
362 }, "javajs.util.Lst,javajs.util.Lst,javajs.util.M4,javajs.util.P3");
363 c$.getCenterAndPoints = Clazz.defineMethod (c$, "getCenterAndPoints",
365 var n = vPts.size ();
366 var pts = new Array (n + 1);
367 pts[0] = new javajs.util.P3 ();
369 for (var i = 0; i < n; i++) {
370 pts[0].add (pts[i + 1] = vPts.get (i));
372 pts[0].scale (1 / n);
374 }, "javajs.util.Lst");
375 c$.getRmsd = Clazz.defineMethod (c$, "getRmsd",
376 function (centerAndPoints, q) {
378 var ptsA = centerAndPoints[0];
379 var ptsB = centerAndPoints[1];
382 var n = ptsA.length - 1;
383 var ptAnew = new javajs.util.P3 ();
384 for (var i = n + 1; --i >= 1; ) {
385 ptAnew.sub2 (ptsA[i], cA);
386 q.transform2 (ptAnew, ptAnew).add (cB);
387 sum2 += ptAnew.distanceSquared (ptsB[i]);
389 return Math.sqrt (sum2 / n);
390 }, "~A,javajs.util.Quat");
391 Clazz.defineStatics (c$,
392 "radiansPerDegree", (0.017453292519943295));
393 c$.axisY = c$.prototype.axisY = javajs.util.V3.new3 (0, 1, 0);