Debian Codegraph @

closure-library/closure/goog/vec/vec3d_test.js

raw
1 // Copyright 2013 The Closure Library Authors. All Rights Reserved.
2 // Use of this source code is governed by the Apache License, Version 2.0.
3
4 ////////////////////////// NOTE ABOUT EDITING THIS FILE ///////////////////////
5 // //
6 // Any edits to this file must be applied to vec3f_test.js by running: //
7 // swap_type.sh vec3d_test.js > vec3f_test.js //
8 // //
9 ////////////////////////// NOTE ABOUT EDITING THIS FILE ///////////////////////
10
11 goog.provide('goog.vec.vec3dTest');
12 goog.setTestOnly('goog.vec.vec3dTest');
13
14 goog.require('goog.vec.Float64Array');
15 goog.require('goog.vec.vec3d');
16 goog.require('goog.testing.jsunit');
17
18 function testCreate() {
19 var v = goog.vec.vec3d.create();
20 assertElementsEquals([0, 0, 0], v);
21 }
22
23 function testCreateFromArray() {
24 var v = goog.vec.vec3d.createFromArray([1, 2, 3]);
25 assertElementsEquals([1, 2, 3], v);
26 }
27
28 function testCreateFromValues() {
29 var v = goog.vec.vec3d.createFromValues(1, 2, 3);
30 assertElementsEquals([1, 2, 3], v);
31 }
32
33 function testClone() {
34 var v0 = goog.vec.vec3d.createFromValues(1, 2, 3);
35 var v1 = goog.vec.vec3d.clone(v0);
36 assertElementsEquals([1, 2, 3], v1);
37 }
38
39 function testSet() {
40 var v = goog.vec.vec3d.create();
41 goog.vec.vec3d.setFromValues(v, 1, 2, 3);
42 assertElementsEquals([1, 2, 3], v);
43
44 goog.vec.vec3d.setFromArray(v, [4, 5, 6]);
45 assertElementsEquals([4, 5, 6], v);
46
47 var w = goog.vec.vec3d.create();
48 goog.vec.vec3d.setFromValues(w, 1, 2, 3);
49 assertElementsEquals([1, 2, 3], w);
50
51 goog.vec.vec3d.setFromArray(w, [4, 5, 6]);
52 assertElementsEquals([4, 5, 6], w);
53 }
54
55 function testAdd() {
56 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
57 var v1 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [4, 5, 6]);
58 var v2 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
59
60 goog.vec.vec3d.add(v2, v1, v2);
61 assertElementsEquals([1, 2, 3], v0);
62 assertElementsEquals([4, 5, 6], v1);
63 assertElementsEquals([5, 7, 9], v2);
64
65 goog.vec.vec3d.add(goog.vec.vec3d.add(v0, v1, v2), v0, v2);
66 assertElementsEquals([6, 9, 12], v2);
67 }
68
69 function testSubtract() {
70 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
71 var v1 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [4, 5, 6]);
72 var v2 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
73
74 goog.vec.vec3d.subtract(v2, v1, v2);
75 assertElementsEquals([1, 2, 3], v0);
76 assertElementsEquals([4, 5, 6], v1);
77 assertElementsEquals([-3, -3, -3], v2);
78
79 goog.vec.vec3d.setFromValues(v2, 0, 0, 0);
80 goog.vec.vec3d.subtract(v1, v0, v2);
81 assertElementsEquals([3, 3, 3], v2);
82
83 v2 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
84 goog.vec.vec3d.subtract(v2, v1, v2);
85 assertElementsEquals([-3, -3, -3], v2);
86
87 goog.vec.vec3d.subtract(goog.vec.vec3d.subtract(v1, v0, v2), v0, v2);
88 assertElementsEquals([2, 1, 0], v2);
89 }
90
91 function testNegate() {
92 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
93 var v1 = goog.vec.vec3d.create();
94
95 goog.vec.vec3d.negate(v0, v1);
96 assertElementsEquals([-1, -2, -3], v1);
97 assertElementsEquals([1, 2, 3], v0);
98
99 goog.vec.vec3d.negate(v0, v0);
100 assertElementsEquals([-1, -2, -3], v0);
101 }
102
103 function testAbs() {
104 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [-1, -2, -3]);
105 var v1 = goog.vec.vec3d.create();
106
107 goog.vec.vec3d.abs(v0, v1);
108 assertElementsEquals([1, 2, 3], v1);
109 assertElementsEquals([-1, -2, -3], v0);
110
111 goog.vec.vec3d.abs(v0, v0);
112 assertElementsEquals([1, 2, 3], v0);
113 }
114
115 function testScale() {
116 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
117 var v1 = goog.vec.vec3d.create();
118
119 goog.vec.vec3d.scale(v0, 4, v1);
120 assertElementsEquals([4, 8, 12], v1);
121 assertElementsEquals([1, 2, 3], v0);
122
123 goog.vec.vec3d.setFromArray(v1, v0);
124 goog.vec.vec3d.scale(v1, 5, v1);
125 assertElementsEquals([5, 10, 15], v1);
126 }
127
128 function testMagnitudeSquared() {
129 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
130 assertEquals(14, goog.vec.vec3d.magnitudeSquared(v0));
131 }
132
133 function testMagnitude() {
134 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
135 assertEquals(Math.sqrt(14), goog.vec.vec3d.magnitude(v0));
136 }
137
138 function testNormalize() {
139 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [2, 3, 4]);
140 var v1 = goog.vec.vec3d.create();
141 var v2 = goog.vec.vec3d.create();
142 goog.vec.vec3d.scale(
143 v0, 1 / goog.vec.vec3d.magnitude(v0), v2);
144
145 goog.vec.vec3d.normalize(v0, v1);
146 assertElementsEquals(v2, v1);
147 assertElementsEquals([2, 3, 4], v0);
148
149 goog.vec.vec3d.setFromArray(v1, v0);
150 goog.vec.vec3d.normalize(v1, v1);
151 assertElementsEquals(v2, v1);
152 }
153
154 function testDot() {
155 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
156 var v1 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [4, 5, 6]);
157 assertEquals(32, goog.vec.vec3d.dot(v0, v1));
158 assertEquals(32, goog.vec.vec3d.dot(v1, v0));
159 }
160
161 function testCross() {
162 var v0 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [1, 2, 3]);
163 var v1 = goog.vec.vec3d.setFromArray(goog.vec.vec3d.create(), [4, 5, 6]);
164 var crossVec = goog.vec.vec3d.create();
165
166 goog.vec.vec3d.cross(v0, v1, crossVec);
167 assertElementsEquals([1, 2, 3], v0);
168 assertElementsEquals([4, 5, 6], v1);
169 assertElementsEquals([-3, 6, -3], crossVec);
170
171 goog.vec.vec3d.setFromArray(crossVec, v1);
172 goog.vec.vec3d.cross(crossVec, v0, crossVec);
173 assertElementsEquals([1, 2, 3], v0);
174 assertElementsEquals([4, 5, 6], v1);
175 assertElementsEquals([3, -6, 3], crossVec);
176
177 goog.vec.vec3d.cross(v0, v0, v0);
178 assertElementsEquals([0, 0, 0], v0);
179 }
180
181 function testDistanceSquared() {
182 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
183 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
184 assertEquals(0, goog.vec.vec3d.distanceSquared(v0, v1));
185 goog.vec.vec3d.setFromValues(v0, 1, 2, 3);
186 goog.vec.vec3d.setFromValues(v1, -1, -2, -1);
187 assertEquals(36, goog.vec.vec3d.distanceSquared(v0, v1));
188 }
189
190 function testDistance() {
191 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
192 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
193 assertEquals(0, goog.vec.vec3d.distance(v0, v1));
194 goog.vec.vec3d.setFromValues(v0, 1, 2, 3);
195 goog.vec.vec3d.setFromValues(v1, -1, -2, -1);
196 assertEquals(6, goog.vec.vec3d.distance(v0, v1));
197 }
198
199 function testDirection() {
200 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
201 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
202 var dirVec = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 4, 5, 6);
203 goog.vec.vec3d.direction(v0, v1, dirVec);
204 assertElementsEquals([0, 0, 0], dirVec);
205 goog.vec.vec3d.setFromValues(v0, 0, 0, 0);
206 goog.vec.vec3d.setFromValues(v1, 1, 0, 0);
207 goog.vec.vec3d.direction(v0, v1, dirVec);
208 assertElementsEquals([1, 0, 0], dirVec);
209 goog.vec.vec3d.setFromValues(v0, 1, 1, 1);
210 goog.vec.vec3d.setFromValues(v1, 0, 0, 0);
211 goog.vec.vec3d.direction(v0, v1, dirVec);
212 assertElementsRoughlyEqual(
213 [-0.5773502588272095, -0.5773502588272095, -0.5773502588272095],
214 dirVec, goog.vec.EPSILON);
215 }
216
217 function testLerp() {
218 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
219 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 10, 20, 30);
220 var v2 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
221
222 goog.vec.vec3d.lerp(v2, v1, 0, v2);
223 assertElementsEquals([1, 2, 3], v2);
224 goog.vec.vec3d.lerp(v2, v1, 1, v2);
225 assertElementsEquals([10, 20, 30], v2);
226 goog.vec.vec3d.lerp(v0, v1, .5, v2);
227 assertElementsEquals([5.5, 11, 16.5], v2);
228 }
229
230 function testSlerp() {
231 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 0, 0, 1);
232 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 0, 0);
233 var v2 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), -1, 0, 0);
234 var v3 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), -5, 0, 0);
235 var v4 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 0, 0, -1);
236 var v5 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
237
238 // Try f == 0 and f == 1.
239 goog.vec.vec3d.slerp(v5, v1, 0, v5);
240 assertElementsEquals([0, 0, 1], v5);
241 goog.vec.vec3d.slerp(v5, v1, 1, v5);
242 assertElementsEquals([1, 0, 0], v5);
243
244 // Try slerp between perpendicular vectors.
245 goog.vec.vec3d.slerp(v0, v1, .5, v5);
246 assertElementsRoughlyEqual(
247 [ Math.sqrt(2) / 2, 0, Math.sqrt(2) / 2 ], v5,
248 goog.vec.EPSILON);
249
250 // Try slerp between vectors of opposite directions (+Z and -Z).
251 v5 = goog.vec.vec3d.slerp(v0, v4, .5, v5);
252 // Axis of rotation is arbitrary, but result should be 90 degrees from both
253 // v0 and v4 when f = 0.5.
254 assertRoughlyEquals(Math.PI / 2, Math.acos(goog.vec.vec3d.dot(v5, v0)),
255 goog.vec.EPSILON);
256 assertRoughlyEquals(Math.PI / 2, Math.acos(goog.vec.vec3d.dot(v5, v4)),
257 goog.vec.EPSILON);
258
259 // f == 0.25, result should be 45-degrees to v0, and 135 to v4.
260 v5 = goog.vec.vec3d.slerp(v0, v4, .25, v5);
261 assertRoughlyEquals(Math.PI / 4, Math.acos(goog.vec.vec3d.dot(v5, v0)),
262 goog.vec.EPSILON);
263 assertRoughlyEquals(Math.PI * 3 / 4, Math.acos(goog.vec.vec3d.dot(v5, v4)),
264 goog.vec.EPSILON);
265
266 // f = 0.75, result should be 135-degrees to v0, and 45 to v4.
267 v5 = goog.vec.vec3d.slerp(v0, v4, .75, v5);
268 assertRoughlyEquals(Math.PI * 3 / 4, Math.acos(goog.vec.vec3d.dot(v5, v0)),
269 goog.vec.EPSILON);
270 assertRoughlyEquals(Math.PI / 4, Math.acos(goog.vec.vec3d.dot(v5, v4)),
271 goog.vec.EPSILON);
272
273 // Same as above, but on opposite directions of the X-axis.
274 v5 = goog.vec.vec3d.slerp(v1, v2, .5, v5);
275 // Axis of rotation is arbitrary, but result should be 90 degrees from both
276 // v1 and v2 when f = 0.5.
277 assertRoughlyEquals(Math.PI / 2, Math.acos(goog.vec.vec3d.dot(v5, v1)),
278 goog.vec.EPSILON);
279 assertRoughlyEquals(Math.PI / 2, Math.acos(goog.vec.vec3d.dot(v5, v2)),
280 goog.vec.EPSILON);
281
282 // f == 0.25, result should be 45-degrees to v1, and 135 to v2.
283 v5 = goog.vec.vec3d.slerp(v1, v2, .25, v5);
284 assertRoughlyEquals(Math.PI / 4, Math.acos(goog.vec.vec3d.dot(v5, v1)),
285 goog.vec.EPSILON);
286 assertRoughlyEquals(Math.PI * 3 / 4, Math.acos(goog.vec.vec3d.dot(v5, v2)),
287 goog.vec.EPSILON);
288
289 // f = 0.75, result should be 135-degrees to v1, and 45 to v2.
290 v5 = goog.vec.vec3d.slerp(v1, v2, .75, v5);
291 assertRoughlyEquals(Math.PI * 3 / 4, Math.acos(goog.vec.vec3d.dot(v5, v1)),
292 goog.vec.EPSILON);
293 assertRoughlyEquals(Math.PI / 4, Math.acos(goog.vec.vec3d.dot(v5, v2)),
294 goog.vec.EPSILON);
295
296 // Try vectors that aren't perpendicular or opposite/same direction.
297 var v6 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(),
298 Math.sqrt(2) / 2, Math.sqrt(2) / 2, 0);
299 goog.vec.vec3d.slerp(v1, v6, .9, v5);
300
301 // The vectors are 45 degrees apart, for f == 0.9, results should be 1/10 of
302 // that from v6 and 9/10 of that away from v1.
303 assertRoughlyEquals((Math.PI / 4) * 0.9, Math.acos(goog.vec.vec3d.dot(v1, v5)),
304 goog.vec.EPSILON);
305 assertRoughlyEquals((Math.PI / 4) * 0.1, Math.acos(goog.vec.vec3d.dot(v6, v5)),
306 goog.vec.EPSILON);
307
308 // Between vectors of the same direction, where one is non-unit-length
309 // (magnitudes should be lerp-ed).
310 goog.vec.vec3d.slerp(v2, v3, .5, v5);
311 assertElementsEquals([-3, 0, 0], v5);
312
313 // Between perpendicular vectors, where one is non-unit length.
314 goog.vec.vec3d.slerp(v0, v3, .5, v5);
315 assertRoughlyEquals(3, goog.vec.vec3d.magnitude(v5), goog.vec.EPSILON);
316 assertElementsRoughlyEqual(
317 [ -3 * (Math.sqrt(2) / 2), 0, 3 * (Math.sqrt(2) / 2) ], v5,
318 goog.vec.EPSILON);
319
320 // And vectors of opposite directions, where one is non-unit length.
321 goog.vec.vec3d.slerp(v1, v3, .5, v5);
322 // Axis of rotation is arbitrary, but result should be 90 degrees from both
323 // v1 and v3.
324 assertRoughlyEquals(
325 Math.PI / 2,
326 Math.acos(goog.vec.vec3d.dot(v5, v1) / (goog.vec.vec3d.magnitude(v5) *
327 goog.vec.vec3d.magnitude(v1))),
328 goog.vec.EPSILON);
329 assertRoughlyEquals(
330 Math.PI / 2,
331 Math.acos(goog.vec.vec3d.dot(v5, v3) / (goog.vec.vec3d.magnitude(v3) *
332 goog.vec.vec3d.magnitude(v5))),
333 goog.vec.EPSILON);
334 // Magnitude should be linearly interpolated.
335 assertRoughlyEquals(3, goog.vec.vec3d.magnitude(v5), goog.vec.EPSILON);
336
337 // Try a case where the vectors are the same direction (the same vector in
338 // this case), but where numerical error results in a dot product
339 // slightly greater than 1. Taking the acos of this would result in NaN.
340 var v7 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 0.009, 0.147,
341 0.989);
342 goog.vec.vec3d.slerp(v7, v7, .25, v5);
343 assertElementsRoughlyEqual([ v7[0], v7[1], v7[2] ], v5, goog.vec.EPSILON);
344 }
345
346 function testMax() {
347 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 10, 20, 30);
348 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 5, 25, 35);
349 var v2 = goog.vec.vec3d.create();
350
351 goog.vec.vec3d.max(v0, v1, v2);
352 assertElementsEquals([10, 25, 35], v2);
353 goog.vec.vec3d.max(v1, v0, v1);
354 assertElementsEquals([10, 25, 35], v1);
355 goog.vec.vec3d.max(v2, 20, v2);
356 assertElementsEquals([20, 25, 35], v2);
357 }
358
359 function testMin() {
360 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 10, 20, 30);
361 var v1 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 5, 25, 35);
362 var v2 = goog.vec.vec3d.create();
363
364 goog.vec.vec3d.min(v0, v1, v2);
365 assertElementsEquals([5, 20, 30], v2);
366 goog.vec.vec3d.min(v1, v0, v1);
367 assertElementsEquals([5, 20, 30], v1);
368 goog.vec.vec3d.min(v2, 20, v2);
369 assertElementsEquals([5, 20, 20], v2);
370 }
371
372 function testEquals() {
373 var v0 = goog.vec.vec3d.setFromValues(goog.vec.vec3d.create(), 1, 2, 3);
374 var v1 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
375 assertElementsEquals(v0, v1);
376
377 v1[0] = 4;
378 assertFalse(goog.vec.vec3d.equals(v0, v1));
379
380 v1 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
381 v1[1] = 4;
382 assertFalse(goog.vec.vec3d.equals(v0, v1));
383
384 v1 = goog.vec.vec3d.setFromVec3d(goog.vec.vec3d.create(), v0);
385 v1[2] = 4;
386 assertFalse(goog.vec.vec3d.equals(v0, v1));
387 }