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