]> git.scottworley.com Git - nt3d/blob - nt3d.js
33e271b406648189e2642000cd2785e6ae208681
[nt3d] / nt3d.js
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
18 nt3d = {
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 return Math.acos(this.dot(a, b));
263 },
264 rotate_about_origin: function(points, axis, angle) { // axis must be a unit vector
265 // From http://inside.mines.edu/~gmurray/ArbitraryAxisRotation/
266 var cosangle = Math.cos(angle);
267 var sinangle = Math.sin(angle);
268 var rotated = [];
269 for (var i = 0; i < points.length; i++) {
270 var p = points[i];
271 var tmp = this.dot(p, axis) * (1 - cosangle);
272 rotated[i] = [
273 axis[0]*tmp + p[0]*cosangle + (-axis[2]*p[1] + axis[1]*p[2])*sinangle,
274 axis[1]*tmp + p[1]*cosangle + ( axis[2]*p[0] - axis[0]*p[2])*sinangle,
275 axis[2]*tmp + p[2]*cosangle + (-axis[1]*p[0] + axis[0]*p[1])*sinangle];
276 }
277 return rotated;
278 },
279 rotate_onto: function(points, a, b) {
280 // Rotate points such that a (in points-space) maps onto b
281 // by crossing a and b to get a rotation axis and using
282 // angle_between to get a rotation angle.
283 var angle = this.angle_between(this.unit(a), this.unit(b));
284 if (Math.abs(angle) < 1e-15) {
285 // No siginificant rotation to perform. Bail to avoid
286 // NaNs and numerical error
287 return points;
288 }
289 var axis = this.unit(this.cross(a, b));
290 return this.rotate_about_origin(points, axis, angle);
291 },
292 rotate: function(points, center, axis, angle) { // axis must be a unit vector
293 return this.translate(
294 this.rotate_about_origin(
295 this.translate(points, this.neg(center)),
296 axis,
297 angle),
298 center);
299 },
300 go: function() {
301 // Remove any previous download links
302 var old_download_link = document.getElementById("nt3d_download");
303 if (old_download_link) {
304 old_download_link.parentNode.removeChild(old_download_link);
305 }
306
307 // Continue in a callback, so that there's not a stale download
308 // link hanging around while we process.
309 setTimeout(function(the_this) { (function() {
310
311 // Get params from form
312 var params = [];
313 for (var i = 0; i < this.user_params.length; i++) {
314 var as_string = this.form.elements["param"+i].value;
315 var as_num = +as_string;
316 params[i] = isNaN(as_num) ? as_string : as_num;
317 }
318
319 // Run user_function
320 this.points = this.user_function.apply(null, params);
321
322 // Do a little validation
323 if (this.points.length % 3 != 0) {
324 alert("Points list length not divisble by 3!");
325 }
326 var n = this.points.length / 3;
327 var nan_count = 0;
328 var nan_point_count = 0;
329 var nan_face_count = 0;
330 for (var i = 0; i < n; i++) {
331 var nan_in_face = false;
332 for (var j = 0; j < 3; j++) {
333 var nan_in_point = false;
334 for (var k = 0; k < 3; k++) {
335 if (isNaN(this.points[i*3+j][k])) {
336 nan_count++;
337 nan_in_point = true;
338 nan_in_face = true;
339 }
340 }
341 if (nan_in_point) nan_point_count ++;
342 }
343 if (nan_in_face) nan_face_count ++;
344 }
345 if (nan_count != 0) {
346 alert(nan_count + " NaNs in " + nan_point_count + " points in " + nan_face_count + " faces.");
347 }
348
349 // Make STL
350 this.stl = "solid " + this.user_function.name + "\n";
351 for (var i = 0; i < n; i++) {
352 var a = this.points[i*3+0];
353 var b = this.points[i*3+1];
354 var c = this.points[i*3+2];
355 var normal = this.normal(a, b, c);
356 this.stl += "facet normal " + normal[0] + " " + normal[1] + " " + normal[2] + "\n" +
357 "outer loop\n" +
358 "vertex " + a[0] + " " + a[1] + " " + a[2] + "\n"+
359 "vertex " + b[0] + " " + b[1] + " " + b[2] + "\n"+
360 "vertex " + c[0] + " " + c[1] + " " + c[2] + "\n"+
361 "endloop\n" +
362 "endfacet\n";
363 }
364 this.stl += "endsolid " + this.user_function.name + "\n";
365
366
367 // Offer result as download
368 var download_link = document.createElement("a");
369 download_link.appendChild(document.createTextNode("Download!"));
370 download_link.setAttribute("id", "nt3d_download");
371 download_link.setAttribute("style", "background-color: blue");
372 download_link.setAttribute("download", this.user_function.name + ".stl");
373 download_link.setAttribute("href", "data:application/sla," + encodeURIComponent(this.stl));
374 this.ui.appendChild(download_link);
375 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);
376
377 }).call(the_this); }, 0, this); // (We were in a callback this whole time, remember?)
378 },
379 framework: function (f, params) {
380 this.user_function = f;
381 this.user_params = params;
382
383 // Make the UI
384 this.ui = document.getElementById("nt3dui");
385 if (!this.ui) {
386 this.ui = document.createElement("div");
387 this.ui.setAttribute("id", "nt3dui");
388 document.body.appendChild(this.ui);
389 }
390 this.form = document.createElement("form");
391 this.form.setAttribute("onsubmit", "nt3d.go(); return false");
392 this.ui.appendChild(this.form);
393 var table = document.createElement("table");
394 this.form.appendChild(table);
395 var tr = document.createElement("tr");
396 table.appendChild(tr);
397 var th = document.createElement("th");
398 th.appendChild(document.createTextNode("Variable"));
399 tr.appendChild(th);
400 th = document.createElement("th");
401 th.appendChild(document.createTextNode("Value"));
402 tr.appendChild(th);
403 for (var i = 0; i < params.length; i++) {
404 tr = document.createElement("tr");
405 table.appendChild(tr);
406 var td = document.createElement("td");
407 td.appendChild(document.createTextNode(params[i][0]));
408 tr.appendChild(td);
409 td = document.createElement("td");
410 var input = document.createElement("input");
411 input.setAttribute("name", "param" + i);
412 input.setAttribute("value", params[i][1]);
413 td.appendChild(input);
414 tr.appendChild(td);
415 }
416 var go = document.createElement("input");
417 go.setAttribute("type", "button");
418 go.setAttribute("value", "Go!");
419 go.setAttribute("onclick", "nt3d.go()");
420 this.form.appendChild(go);
421 }
422 };