]> git.scottworley.com Git - nt3d/blame_incremental - nt3d.js
Explicitly bounds-check in angle_between()
[nt3d] / nt3d.js
... / ...
CommitLineData
1/* nt3d - Javascript library for doing some 3D stuff.
2 * Copyright (C) 2012 Scott Worley <ScottWorley@ScottWorley.com>
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Affero General Public License as
6 * published by the Free Software Foundation, either version 3 of the
7 * License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU Affero General Public License for more details.
13 *
14 * You should have received a copy of the GNU Affero General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18nt3d = {
19 triangle: function(a, b, c) {
20 return [a, b, c];
21 },
22 quad: function(a, b, c, d) {
23 return this.triangle(a, b, c).concat(
24 this.triangle(c, d, a));
25 },
26 trianglefan: function(fan) {
27 var result = [];
28 for (var i = 2; i < fan.length; i++) {
29 result.push(fan[0], fan[i-1], fan[i]);
30 }
31 return result;
32 },
33 closed_trianglefan: function(fan) {
34 return this.trianglefan(fan.concat([fan[1]]));
35 },
36 quadstrip: function(strip) {
37 if (strip.length % 2 != 0) {
38 alert("quadstrip length not divisble by 2!");
39 }
40 var result = [];
41 for (var i = 2; i < strip.length; i += 2) {
42 result = result.concat(this.quad(strip[i-2], strip[i-1], strip[i+1], strip[i]));
43 }
44 return result;
45 },
46 closed_quadstrip: function(strip) {
47 return this.quadstrip(strip.concat([strip[0], strip[1]]));
48 },
49 circle: function(r, n) {
50 var points = [];
51 for (var i = 0; i < n; i++) {
52 points.push([r*Math.cos(2*Math.PI*i/n),
53 r*Math.sin(2*Math.PI*i/n),
54 0]);
55 }
56 return points;
57 },
58 cone: function(base_center, apex, radius, steps) {
59 var base = this.circle(radius, steps);
60 base = this.rotate_onto(base, [0,0,1], this.sub(apex, base_center));
61 base = this.translate(base, base_center);
62 return this.closed_trianglefan([apex].concat(base)).concat(
63 this.trianglefan(base.reverse()));
64 },
65 sphere: function(center, radius, latitude_steps, longitude_steps) {
66 return this.oriented_sphere(center, radius, [0,0,1], [1,0,0], latitude_steps, longitude_steps);
67 },
68 oriented_sphere: function(center, radius, north, greenwich, latitude_steps, longitude_steps) {
69 var unit_north = this.unit(north);
70 var north_pole = this.translate_point(this.scale(unit_north, radius), center);
71 var south_pole = this.translate_point(this.scale(unit_north, -radius), center);
72 return this.spheroid(north_pole, south_pole, radius, greenwich, latitude_steps, longitude_steps);
73 },
74 spheroid: function(north_pole, south_pole, radius, greenwich, latitude_steps, longitude_steps) {
75 var delta = this.sub(north_pole, south_pole);
76 var path = [];
77 for (var i = 0; i < latitude_steps-1; i++) {
78 path.push(this.translate_point(south_pole, this.scale(delta, (1-Math.cos(Math.PI*i/(latitude_steps-1)))/2)));
79 }
80 path.push(north_pole);
81 function shape(i) {
82 return nt3d.circle(radius*Math.sin(Math.PI*i/(latitude_steps-1)), longitude_steps);
83 }
84 return this.extrude(path, shape, delta, greenwich);
85 },
86 shapenormals_from_closed_path: function(path) {
87 return function(i) {
88 var prev = (i == 0) ? path.length-1 : i-1;
89 var next = (i == path.length-1) ? 0 : i+1;
90 return nt3d.sub(path[next], path[prev]);
91 };
92 },
93 shapenormals_from_path_and_extra_points: function(path, first_point, last_point) {
94 return function(i) {
95 var prev = (i == 0) ? first_point : path[i-1];
96 var next = (i == path.length-1) ? last_point : path[i+1];
97 return nt3d.sub(next, prev);
98 };
99 },
100 shapenormals_from_path_and_first_and_last_normals: function(path, first_normal, last_normal) {
101 return function(i) {
102 if (i == 0) { return first_normal; }
103 if (i == path.length-1) { return last_normal; }
104 return nt3d.sub(path[i+1], path[i-1]);
105 };
106 },
107 pathnormals_from_point: function(path, p) {
108 // Use this with any point that is not on any path tangent line
109 var pathnormals = [];
110 for (var i = 0; i < path.length; i++) {
111 pathnormals.push(this.sub(path[i], p));
112 }
113 return pathnormals;
114 },
115 to_function: function(thing, make_indexer) {
116 // If thing is a point, just yield thing every time.
117 // If thing is a list of points && make_indexer, index into thing.
118 // If thing is already a function, just return it.
119 if (({}).toString.call(thing) === "[object Function]") {
120 return thing; // Already a function
121 }
122 if (make_indexer && Array.isArray(thing[0])) {
123 // Looks like a list of points.
124 return function(i) { return thing[i]; }
125 }
126 return function() { return thing; }
127 },
128 extrude: function(path, shape, shapenormals, pathnormals) {
129
130 var guts_result = this._extrude_guts(path, shape, shapenormals, pathnormals);
131 // Add the end-caps
132 // XXX: This doesn't work if shape is not convex
133 return guts_result.points.concat(
134 this.trianglefan(guts_result.first_loop.reverse()),
135 this.trianglefan(guts_result.last_loop));
136
137 },
138 closed_extrude: function(path, shape, shapenormals, pathnormals) {
139 var guts_result = this._extrude_guts(path, shape, shapenormals, pathnormals);
140 // Stitch the ends together
141 return guts_result.points.concat(
142 this.closed_quadstrip(this.zip(guts_result.first_loop, guts_result.last_loop)));
143 },
144 _extrude_guts: function(path, shape, shapenormals, pathnormals) {
145 var shape_fun = this.to_function(shape, false);
146 var shapenormal_fun = this.to_function(shapenormals, true);
147 var pathnormal_fun = this.to_function(pathnormals, true);
148 var result = { points: [] };
149 var prev_loop;
150 for (var i = 0; i < path.length; i++) {
151 var shapenormali = shapenormal_fun(i, path[i]);
152 var pathnormali = pathnormal_fun(i, path[i], shapenormali);
153
154 // Fix pathnormali to be perfectly perpendicular to
155 // shapenormali. pathnormali must be perpendicular to
156 // shapenormali or the second rotation will take loop
157 // back out of the shapenormali plane that the first
158 // rotation so carefully placed it in. But, letting
159 // callers be sloppy with the pathnormals can greatly
160 // simplify generating them -- so much so that you can
161 // often just pass a constant to use the same value
162 // along the whole path.
163 pathnormali = this.project_to_orthogonal(shapenormali, pathnormali);
164
165 var shapei = shape_fun(i, path[i], shapenormali, pathnormali);
166
167 // loop is shapei in 3d with (0,0) at path[i], shape's
168 // z axis in the direction of shapenormali, and shape's
169 // x axis in the direction of pathnormali. We tack
170 // [1,0,0] onto the end as a hack to see where it ends
171 // up after the first rotation. This is removed later.
172 var loop = shapei.concat([[1,0,0]]);
173
174 // This is done in three steps:
175 // 1. Rotate shape out of the xy plane so that [0,0,1]
176 // becomes shapenormali. This puts the shape in
177 // the correct plane, but does not constrain its
178 // rotation about shapenormali.
179 loop = this.rotate_onto(loop, [0,0,1], shapenormali);
180 var shapex = loop.pop();
181
182 // 2. Rotate around shapenormali so that [1,0,0]
183 // becomes pathnormali.
184 loop = this.rotate_onto(loop, shapex, pathnormali);
185
186 // (This would probably be faster and more numerically stable
187 // if the two rotations were applied as one combined operation
188 // rather than separate steps.)
189
190 // 3. Translate to path[i].
191 loop = this.translate(loop, path[i]);
192
193 if (i == 0) {
194 result.first_loop = loop;
195 } else {
196 result.points = result.points.concat(this.closed_quadstrip(this.zip(loop, prev_loop)));
197 }
198 prev_loop = loop;
199 }
200 result.last_loop = prev_loop;
201 return result;
202 },
203 zip: function(a, b) {
204 var result = [];
205 if (a.length != b.length) {
206 alert("Zip over different-sized inputs");
207 }
208 for (var i = 0; i < a.length; i++) {
209 result.push(a[i], b[i]);
210 }
211 return result;
212 },
213 magnitude: function(a) {
214 return Math.sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]);
215 },
216 unit: function(a) {
217 return this.scale(a, 1 / this.magnitude(a));
218 },
219 sub: function(a, b) {
220 return [a[0] - b[0],
221 a[1] - b[1],
222 a[2] - b[2]];
223 },
224 neg: function(a) {
225 return [-a[0], -a[1], -a[2]];
226 },
227 dot: function(a, b) {
228 return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
229 },
230 scale: function(v, s) { // Scale vector v by scalar s
231 return [s*v[0], s*v[1], s*v[2]];
232 },
233 cross: function(a, b) {
234 return [a[1]*b[2] - a[2]*b[1],
235 a[2]*b[0] - a[0]*b[2],
236 a[0]*b[1] - a[1]*b[0]];
237 },
238 normal: function(a, b, c) {
239 return this.cross(this.sub(a, b), this.sub(b, c));
240 },
241 project: function(a, b) { // Project b onto a
242 var a_magnitude = this.magnitude(a);
243 return this.scale(a, this.dot(a, b) / (a_magnitude * a_magnitude));
244 },
245 project_to_orthogonal: function(a, b) {
246 // The nearest thing to b that is orthogonal to a
247 return this.sub(b, this.project(a, b));
248 },
249 translate: function(points, offset) {
250 var translated = [];
251 for (var i = 0; i < points.length; i++) {
252 translated[i] = this.translate_point(points[i], offset);
253 }
254 return translated;
255 },
256 translate_point: function(point, offset) {
257 return [point[0] + offset[0],
258 point[1] + offset[1],
259 point[2] + offset[2]];
260 },
261 angle_between: function(a, b) { // a and b must be unit vectors
262 var the_dot = this.dot(a, b);
263 if (the_dot <= -1) {
264 return Math.PI;
265 }
266 if (the_dot >= 1) {
267 return 0;
268 }
269 return Math.acos(the_dot);
270 },
271 rotate_about_origin: function(points, axis, angle) { // axis must be a unit vector
272 // From http://inside.mines.edu/~gmurray/ArbitraryAxisRotation/
273 var cosangle = Math.cos(angle);
274 var sinangle = Math.sin(angle);
275 var rotated = [];
276 for (var i = 0; i < points.length; i++) {
277 var p = points[i];
278 var tmp = this.dot(p, axis) * (1 - cosangle);
279 rotated[i] = [
280 axis[0]*tmp + p[0]*cosangle + (-axis[2]*p[1] + axis[1]*p[2])*sinangle,
281 axis[1]*tmp + p[1]*cosangle + ( axis[2]*p[0] - axis[0]*p[2])*sinangle,
282 axis[2]*tmp + p[2]*cosangle + (-axis[1]*p[0] + axis[0]*p[1])*sinangle];
283 }
284 return rotated;
285 },
286 rotate_onto: function(points, a, b) {
287 // Rotate points such that a (in points-space) maps onto b
288 // by crossing a and b to get a rotation axis and using
289 // angle_between to get a rotation angle.
290 var angle = this.angle_between(this.unit(a), this.unit(b));
291 if (Math.abs(angle) < 1e-15) {
292 // No siginificant rotation to perform. Bail to avoid
293 // NaNs and numerical error
294 return points;
295 }
296 var axis = this.unit(this.cross(a, b));
297 return this.rotate_about_origin(points, axis, angle);
298 },
299 rotate: function(points, center, axis, angle) { // axis must be a unit vector
300 return this.translate(
301 this.rotate_about_origin(
302 this.translate(points, this.neg(center)),
303 axis,
304 angle),
305 center);
306 },
307 point_equal: function(a, b, epsilon) {
308 return Math.abs(a[0] - b[0]) < epsilon &&
309 Math.abs(a[1] - b[1]) < epsilon &&
310 Math.abs(a[2] - b[2]) < epsilon;
311 },
312 degenerate_face_epsilon: 1e-10,
313 is_degenerate: function(a, b, c) {
314 return this.point_equal(a, b, this.degenerate_face_epsilon) ||
315 this.point_equal(b, c, this.degenerate_face_epsilon) ||
316 this.point_equal(c, a, this.degenerate_face_epsilon);
317 },
318 go: function() {
319 // Remove any previous download links
320 var old_download_link = document.getElementById("nt3d_download");
321 if (old_download_link) {
322 old_download_link.parentNode.removeChild(old_download_link);
323 }
324
325 // Continue in a callback, so that there's not a stale download
326 // link hanging around while we process.
327 setTimeout(function(the_this) { (function() {
328
329 // Get params from form
330 var params = [];
331 for (var i = 0; i < this.user_params.length; i++) {
332 var as_string = this.form.elements["param"+i].value;
333 var as_num = +as_string;
334 params[i] = isNaN(as_num) ? as_string : as_num;
335 }
336
337 // Run user_function
338 this.points = this.user_function.apply(null, params);
339
340 // Do a little validation
341 if (this.points.length % 3 != 0) {
342 alert("Points list length not divisble by 3!");
343 }
344 var nan_count = 0;
345 var nan_point_count = 0;
346 var nan_face_count = 0;
347 for (var i = 0; i < this.points.length/3; i++) {
348 var nan_in_face = false;
349 for (var j = 0; j < 3; j++) {
350 var nan_in_point = false;
351 for (var k = 0; k < 3; k++) {
352 if (isNaN(this.points[i*3+j][k])) {
353 nan_count++;
354 nan_in_point = true;
355 nan_in_face = true;
356 }
357 }
358 if (nan_in_point) nan_point_count ++;
359 }
360 if (nan_in_face) nan_face_count ++;
361 }
362 if (nan_count != 0) {
363 alert(nan_count + " NaNs in " + nan_point_count + " points in " + nan_face_count + " faces (" + (100 * nan_face_count / (this.points.length/3)) + "% of faces).");
364 }
365
366 // Remove degenerate faces
367 var degenerate_face_count = 0;
368 for (var i = 0; i < this.points.length/3; i++) {
369 if (this.is_degenerate(this.points[i*3+0],
370 this.points[i*3+1],
371 this.points[i*3+2])) {
372 this.points.splice(i*3, 3);
373 i--;
374 degenerate_face_count ++;
375 }
376 }
377 if (degenerate_face_count != 0) {
378 console.log("Removed " + degenerate_face_count + " degenerate faces");
379 }
380
381 // Make STL
382 this.stl = "solid " + this.user_function.name + "\n";
383 for (var i = 0; i < this.points.length/3; i++) {
384 var a = this.points[i*3+0];
385 var b = this.points[i*3+1];
386 var c = this.points[i*3+2];
387 var normal = this.normal(a, b, c);
388 this.stl += "facet normal " + normal[0] + " " + normal[1] + " " + normal[2] + "\n" +
389 "outer loop\n" +
390 "vertex " + a[0] + " " + a[1] + " " + a[2] + "\n"+
391 "vertex " + b[0] + " " + b[1] + " " + b[2] + "\n"+
392 "vertex " + c[0] + " " + c[1] + " " + c[2] + "\n"+
393 "endloop\n" +
394 "endfacet\n";
395 }
396 this.stl += "endsolid " + this.user_function.name + "\n";
397
398
399 // Offer result as download
400 var download_link = document.createElement("a");
401 download_link.appendChild(document.createTextNode("Download!"));
402 download_link.setAttribute("id", "nt3d_download");
403 download_link.setAttribute("style", "background-color: blue");
404 download_link.setAttribute("download", this.user_function.name + ".stl");
405 download_link.setAttribute("href", "data:application/sla," + encodeURIComponent(this.stl));
406 this.ui.appendChild(download_link);
407 setTimeout(function() { download_link.setAttribute("style", "-webkit-transition: background-color 0.4s; -moz-transition: background-color 0.4s; -o-transition: background-color 0.4s; -ms-transition: background-color 0.4s; transition: background-color 0.4s; background-color: inherit"); }, 0);
408
409 }).call(the_this); }, 0, this); // (We were in a callback this whole time, remember?)
410 },
411 framework: function (f, params) {
412 this.user_function = f;
413 this.user_params = params;
414
415 // Make the UI
416 this.ui = document.getElementById("nt3dui");
417 if (!this.ui) {
418 this.ui = document.createElement("div");
419 this.ui.setAttribute("id", "nt3dui");
420 document.body.appendChild(this.ui);
421 }
422 this.form = document.createElement("form");
423 this.form.setAttribute("onsubmit", "nt3d.go(); return false");
424 this.ui.appendChild(this.form);
425 var table = document.createElement("table");
426 this.form.appendChild(table);
427 var tr = document.createElement("tr");
428 table.appendChild(tr);
429 var th = document.createElement("th");
430 th.appendChild(document.createTextNode("Variable"));
431 tr.appendChild(th);
432 th = document.createElement("th");
433 th.appendChild(document.createTextNode("Value"));
434 tr.appendChild(th);
435 for (var i = 0; i < params.length; i++) {
436 tr = document.createElement("tr");
437 table.appendChild(tr);
438 var td = document.createElement("td");
439 td.appendChild(document.createTextNode(params[i][0]));
440 tr.appendChild(td);
441 td = document.createElement("td");
442 var input = document.createElement("input");
443 input.setAttribute("name", "param" + i);
444 input.setAttribute("value", params[i][1]);
445 td.appendChild(input);
446 tr.appendChild(td);
447 }
448 var go = document.createElement("input");
449 go.setAttribute("type", "button");
450 go.setAttribute("value", "Go!");
451 go.setAttribute("onclick", "nt3d.go()");
452 this.form.appendChild(go);
453 }
454};