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;
// 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
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");
params[i] = 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;
- // 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");
projects / nt3d / blobdiff