Rotate and translate operate on lists of points

Also, change extrude's interface to take 3d points, just with the z
values at zero.

diff --git a/box_by_extrude.html b/box_by_extrude.html
index e8183f2ccf59632f570f4ec999f00a44e7eab787..6a883a60eb7e9fb6b04f1809f51d5a0c2e3df048 100644 (file)
--- a/box_by_extrude.html
+++ b/box_by_extrude.html
@@ -5,10 +5,10 @@
     <script type="text/javascript">
       function box_by_extrude(size_as_string) {
         var size = parseFloat(size_as_string);
-        var origin = [0,    0   ];
-        var x      = [size, 0   ];
-        var y      = [0,    size];
-        var xy     = [size, size];
+        var origin = [0,    0,    0];
+        var x      = [size, 0,    0];
+        var y      = [0,    size, 0];
+        var xy     = [size, size, 0];
        return nt3d.extrude([origin, x, xy, y],
                            [[0, 0, 0], [0, 0, 1]],
                            [[0, 0, 1], [0, 0, 1]],

diff --git a/nt3d.js b/nt3d.js
index d0d716125a3b9357c1820f6e23868bf5e1b57920..3d87ffb90e3ec1b5569ad71f41058a9a8bc3fae0 100644 (file)
--- a/nt3d.js
+++ b/nt3d.js
@@ -80,7 +80,8 @@ nt3d = {
                        // loop is shape in 3d with (0,0) at path[i], shape's
                        // z axis in the direction of shapenormals[i], and
                        // shape's x axis in the direction of pathnormals[i].
-                       var loop = [];
+                       var loop = shape;
+
                        // This is done in three steps:
                        // 1. Rotate shape out of the xy plane so that [0,0,1]
                        //    becomes shapenormals[i] by crossing [0,0,1] and
@@ -90,25 +91,24 @@ nt3d = {
                        //    constrain its rotation about shapenormals[i].
                        var rot1axis = this.unit(this.cross([0,0,1], shapenormals[i]));
                        var rot1angle = this.angle_between([0,0,1], this.unit(shapenormals[i]));
+                       if (rot1angle > 1e-7) {
+                               loop = this.rotate(loop, rot1axis, rot1angle);
+                       }
+
                        // 2. Rotate around shapenormals[i] so that [1,0,0]
                        //    becomes fixedpathnormals[i].
                        var rot2axis = this.unit(shapenormals[i]);
                        var rot2angle = this.angle_between([1,0,0], this.unit(fixedpathnormals[i]));
-                       // 3. Translate to path[i].
+                       if (rot2angle > 1e-7) {
+                               loop = this.rotate(loop, rot2axis, rot2angle);
+                       }
                        // This would probably be faster and more numerically stable
                        // if the two rotations were applied as one combined operation
                        // rather than separate steps.
-                       for (var j = 0; j < shape.length; j++) {
-                               var p = [shape[j][0], shape[j][1], 0];
-                               if (rot1angle > 1e-7) {
-                                       p = this.rotate(p, rot1axis, rot1angle);
-                               }
-                               if (rot2angle > 1e-7) {
-                                       p = this.rotate(p, rot2axis, rot2angle);
-                               }
-                               p = this.translate(p, path[i]);
-                               loop[j] = p;
-                       }
+
+                       // 3. Translate to path[i].
+                       loop = this.translate(loop, path[i]);
+
                        if (i == 0) {
                                result.first_loop = loop;
                        } else {
@@ -158,20 +158,32 @@ nt3d = {
                var a_magnitude = this.magnitude(a);
                return this.scale(a, this.dot(a, b) / a_magnitude * a_magnitude);
        },
-       translate: function(a, b) {
-               return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+       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]];
+               }
+               return translated;
        },
        angle_between: function(a, b) { // a and b must be unit vectors
                return Math.acos(this.dot(a, b));
        },
-       rotate: function(point, axis, angle) { // axis must be a unit vector
+       rotate: function(points, axis, angle) { // axis must be a unit vector
                // From http://inside.mines.edu/~gmurray/ArbitraryAxisRotation/
                var cosangle = Math.cos(angle);
                var sinangle = Math.sin(angle);
-               var tmp = this.dot(point, axis) * (1 - cosangle);
-               return [axis[0]*tmp + point[0]*cosangle + (-axis[2]*point[1] + axis[1]*point[2])*sinangle,
-                       axis[1]*tmp + point[1]*cosangle + ( axis[2]*point[0] - axis[0]*point[2])*sinangle,
-                       axis[2]*tmp + point[2]*cosangle + (-axis[1]*point[0] + axis[0]*point[1])*sinangle];
+               var rotated = [];
+               for (var i = 0; i < points.length; i++) {
+                       var p = points[i];
+                       var tmp = this.dot(p, axis) * (1 - cosangle);
+                       rotated[i] = [
+                               axis[0]*tmp + p[0]*cosangle + (-axis[2]*p[1] + axis[1]*p[2])*sinangle,
+                               axis[1]*tmp + p[1]*cosangle + ( axis[2]*p[0] - axis[0]*p[2])*sinangle,
+                               axis[2]*tmp + p[2]*cosangle + (-axis[1]*p[0] + axis[0]*p[1])*sinangle];
+               }
+               return rotated;
        },
        go: function() {
                // Get params from form