return this.closed_trianglefan([apex].concat(base)).concat(
this.trianglefan(base.reverse()));
},
+ sphere: function(center, radius, latitude_steps, longitude_steps) {
+ return this.oriented_sphere(center, radius, [0,0,1], [1,0,0], latitude_steps, longitude_steps);
+ },
+ oriented_sphere: function(center, radius, north, greenwich, latitude_steps, longitude_steps) {
+ var unit_north = this.unit(north);
+ var north_pole = this.translate_point(this.scale(unit_north, radius), center);
+ var south_pole = this.translate_point(this.scale(unit_north, -radius), center);
+ return this.spheroid(north_pole, south_pole, radius, greenwich, latitude_steps, longitude_steps);
+ },
+ spheroid: function(north_pole, south_pole, radius, greenwich, latitude_steps, longitude_steps) {
+ var delta = this.sub(north_pole, south_pole);
+ var path = [];
+ for (var i = 0; i < latitude_steps-1; i++) {
+ path.push(this.translate_point(south_pole, this.scale(delta, (1-Math.cos(Math.PI*i/(latitude_steps-1)))/2)));
+ }
+ path.push(north_pole);
+ function shape(i) {
+ return nt3d.circle(radius*Math.sin(Math.PI*i/(latitude_steps-1)), longitude_steps);
+ }
+ return this.extrude(path, shape, delta, greenwich);
+ },
shapenormals_from_closed_path: function(path) {
return function(i) {
var prev = (i == 0) ? path.length-1 : i-1;
return nt3d.sub(path[i+1], path[i-1]);
};
},
+ pathnormals_from_point: function(path, p) {
+ // Use this with any point that is not on any path tangent line
+ var pathnormals = [];
+ for (var i = 0; i < path.length; i++) {
+ pathnormals.push(this.sub(path[i], p));
+ }
+ return pathnormals;
+ },
to_function: function(thing, make_indexer) {
// If thing is a point, just yield thing every time.
// If thing is a list of points && make_indexer, index into thing.
// 2. Rotate around shapenormali so that [1,0,0]
// becomes pathnormali.
- loop = this.rotate_onto(loop, shapex, pathnormali);
+ if (!this.opposite(shapex, pathnormali)) {
+ loop = this.rotate_onto(loop, shapex, pathnormali);
+ } else {
+ // Rare edge case: When shapex and pathnormali are
+ // opposite, rotate_onto cannot cross them to get
+ // an axis of rotation. In this case, we (extrude)
+ // already know what to do -- just rotate PI around
+ // shapenormali!
+ loop = this.rotate_about_origin(loop, shapenormali, Math.PI);
+ }
// (This would probably be faster and more numerically stable
// if the two rotations were applied as one combined operation
translate: function(points, offset) {
var translated = [];
for (var i = 0; i < points.length; i++) {
- translated[i] = [points[i][0] + offset[0],
- points[i][1] + offset[1],
- points[i][2] + offset[2]];
+ translated[i] = this.translate_point(points[i], offset);
}
return translated;
},
+ translate_point: function(point, offset) {
+ return [point[0] + offset[0],
+ point[1] + offset[1],
+ point[2] + offset[2]];
+ },
angle_between: function(a, b) { // a and b must be unit vectors
- return Math.acos(this.dot(a, b));
+ var the_dot = this.dot(a, b);
+ if (the_dot <= -1) {
+ return Math.PI;
+ }
+ if (the_dot >= 1) {
+ return 0;
+ }
+ return Math.acos(the_dot);
},
rotate_about_origin: function(points, axis, angle) { // axis must be a unit vector
// From http://inside.mines.edu/~gmurray/ArbitraryAxisRotation/
}
return rotated;
},
+ angle_epsilon: 1e-7,
+ opposite: function(a, b) {
+ // Do a and b point in exactly opposite directions?
+ return Math.abs(this.angle_between(this.unit(a), this.unit(b)) - Math.PI) < this.angle_epsilon;
+ },
rotate_onto: function(points, a, b) {
// Rotate points such that a (in points-space) maps onto b
// by crossing a and b to get a rotation axis and using
// angle_between to get a rotation angle.
var angle = this.angle_between(this.unit(a), this.unit(b));
- if (Math.abs(angle) < 1e-15) {
- // No siginificant rotation to perform. Bail to avoid
+ var abs_angle = Math.abs(angle);
+ if (Math.abs(angle) < this.angle_epsilon) {
+ // No significant rotation to perform. Bail to avoid
// NaNs and numerical error
return points;
}
- var axis = this.unit(this.cross(a, b));
+ var axis;
+ if (Math.abs(abs_angle - Math.PI) < this.angle_epsilon) {
+ // a and b point in opposite directions, so
+ // we cannot cross them. So just pick something.
+ // If the caller wishes to avoid this behaviour,
+ // they should check with this.opposite() first.
+ axis = this.project_to_orthogonal(a, [1,0,0]);
+ console.log("rotate_onto: a and b are opposite! If you carefully chose them to meet some other constraint, you will be sad! Arbitrarily using axis [1,0,0] ->", axis);
+ if (this.magnitude(axis) < this.angle_epsilon) {
+ // Oh, double bad luck! Our arbitrary choice
+ // lines up too! A second, orthogonal arbitrary
+ // choice is now guaranteed to succeed.
+ axis = this.project_to_orthogonal(a, [0,1,0]);
+ console.log("rotate_onto: Double bad luck! Arbitrarily using axis [0,1,0] ->", axis);
+ }
+ } else {
+ axis = this.unit(this.cross(a, b));
+ }
return this.rotate_about_origin(points, axis, angle);
},
rotate: function(points, center, axis, angle) { // axis must be a unit vector
angle),
center);
},
+ point_equal: function(a, b, epsilon) {
+ return Math.abs(a[0] - b[0]) < epsilon &&
+ Math.abs(a[1] - b[1]) < epsilon &&
+ Math.abs(a[2] - b[2]) < epsilon;
+ },
+ degenerate_face_epsilon: 1e-10,
+ is_degenerate: function(a, b, c) {
+ return this.point_equal(a, b, this.degenerate_face_epsilon) ||
+ this.point_equal(b, c, this.degenerate_face_epsilon) ||
+ this.point_equal(c, a, this.degenerate_face_epsilon);
+ },
+ validate: function(points) {
+ // Do a little validation
+ if (points.length % 3 != 0) {
+ alert("Points list length not divisble by 3!");
+ }
+ var nan_count = 0;
+ var nan_point_count = 0;
+ var nan_face_count = 0;
+ for (var i = 0; i < points.length/3; i++) {
+ var nan_in_face = false;
+ for (var j = 0; j < 3; j++) {
+ var nan_in_point = false;
+ for (var k = 0; k < 3; k++) {
+ if (isNaN(points[i*3+j][k])) {
+ nan_count++;
+ nan_in_point = true;
+ nan_in_face = true;
+ }
+ }
+ if (nan_in_point) nan_point_count ++;
+ }
+ if (nan_in_face) nan_face_count ++;
+ }
+ if (nan_count != 0) {
+ alert(nan_count + " NaNs in " + nan_point_count + " points in " + nan_face_count + " faces (" + (100 * nan_face_count / (points.length/3)) + "% of faces).");
+ }
+ },
+ remove_degenerate_faces: function(points) {
+ // Note: This modifies points
+ var degenerate_face_count = 0;
+ for (var i = 0; i < points.length/3; i++) {
+ if (this.is_degenerate(points[i*3+0],
+ points[i*3+1],
+ points[i*3+2])) {
+ points.splice(i*3, 3);
+ i--;
+ degenerate_face_count ++;
+ }
+ }
+ if (degenerate_face_count != 0) {
+ console.log("Removed " + degenerate_face_count + " degenerate faces");
+ }
+ return points;
+ },
+ to_stl: function(points, name) {
+ var stl = "solid " + name + "\n";
+ for (var i = 0; i < points.length/3; i++) {
+ var a = points[i*3+0];
+ var b = points[i*3+1];
+ var c = points[i*3+2];
+ var normal = this.normal(a, b, c);
+ stl += "facet normal " + normal[0] + " " + normal[1] + " " + normal[2] + "\n" +
+ "outer loop\n" +
+ "vertex " + a[0] + " " + a[1] + " " + a[2] + "\n"+
+ "vertex " + b[0] + " " + b[1] + " " + b[2] + "\n"+
+ "vertex " + c[0] + " " + c[1] + " " + c[2] + "\n"+
+ "endloop\n" +
+ "endfacet\n";
+ }
+ stl += "endsolid " + name + "\n";
+ return stl;
+ },
go: function() {
// Remove any previous download links
var old_download_link = document.getElementById("nt3d_download");
// Continue in a callback, so that there's not a stale download
// link hanging around while we process.
- setTimeout(function(the_this) { (function() {
+ setTimeout(function() {
// Get params from form
- var params = [];
+ var params = {};
for (var i = 0; i < this.user_params.length; i++) {
var as_string = this.form.elements["param"+i].value;
var as_num = +as_string;
- params[i] = isNaN(as_num) ? as_string : as_num;
+ params[this.user_params[i][0]] = isNaN(as_num) ? as_string : as_num;
}
- // Run user_function
- this.points = this.user_function.apply(null, params);
- if (this.points.length % 3 != 0) {
- alert("Points list length not divisble by 3!");
- }
- var n = this.points.length / 3;
+ this.points = this.user_function.call(null, params);
- // Make STL
- this.stl = "solid " + this.user_function.name + "\n";
- for (var i = 0; i < n; i++) {
- var a = this.points[i*3+0];
- var b = this.points[i*3+1];
- var c = this.points[i*3+2];
- var normal = this.normal(a, b, c);
- this.stl += "facet normal " + normal[0] + " " + normal[1] + " " + normal[2] + "\n" +
- "outer loop\n" +
- "vertex " + a[0] + " " + a[1] + " " + a[2] + "\n"+
- "vertex " + b[0] + " " + b[1] + " " + b[2] + "\n"+
- "vertex " + c[0] + " " + c[1] + " " + c[2] + "\n"+
- "endloop\n" +
- "endfacet\n";
- }
- this.stl += "endsolid " + this.user_function.name + "\n";
+ this.validate(this.points);
+ this.remove_degenerate_faces(this.points);
+
+ this.stl = this.to_stl(this.points, this.user_function.name);
// Offer result as download
var download_link = document.createElement("a");
this.ui.appendChild(download_link);
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);
- }).call(the_this); }, 0, this); // (We were in a callback this whole time, remember?)
+ }.bind(this), 0); // (We were in a callback this whole time, remember?)
},
framework: function (f, params) {
this.user_function = f;
tr = document.createElement("tr");
table.appendChild(tr);
var td = document.createElement("td");
- td.appendChild(document.createTextNode(params[i][0]));
+ var description;
+ if (params[i].length > 2) {
+ description = params[i][2];
+ } else {
+ description = params[i][0];
+ description = description[0].toUpperCase() + description.substr(1);
+ description = description.replace(/_(.)/g, function(_, c) {
+ return " " + c.toUpperCase();
+ });
+ description = description.replace("Num ", "Number of ");
+ }
+ td.appendChild(document.createTextNode(description));
tr.appendChild(td);
td = document.createElement("td");
var input = document.createElement("input");
projects / nt3d / blobdiff