jsxgraph 1.4.4 → 1.4.6

package/src/3d/linspace3d.js

@@ -32,10 +32,125 @@
  * Create linear spaces of dimension at least one,
  * i.e. lines and planes.
  */
-define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
-], function (JXG, Type, Mat, Geometry, ThreeD) {
+define(['jxg', 'base/constants', 'utils/type', 'math/math', 'math/geometry'
+], function (JXG, Const, Type, Mat, Geometry) {
     "use strict";
 
+    // -----------------------
+    //  Lines
+    // -----------------------
+
+    /**
+     * Constructor for 3D lines.
+     * @class Creates a new 3D line object. Do not use this constructor to create a 3D line. Use {@link JXG.Board#create} with type {@link Line3D} instead.
+     *
+     * @augments JXG.GeometryElement3D
+     * @augments JXG.GeometryElement
+     * @param {View3D} view
+     * @param {Point3D|Array} point
+     * @param {Array} direction
+     * @param {Array} range
+     * @param {Object} attributes
+     * @see JXG.Board#generateName
+     */
+    JXG.Line3D = function (view, point, direction, range, attributes) {
+        this.constructor(view.board, attributes, Const.OBJECT_TYPE_LINE3D, Const.OBJECT_CLASS_3D);
+        this.constructor3D(view, 'line3d');
+
+        this.id = this.view.board.setId(this, 'L3D');
+        this.board.finalizeAdding(this);
+
+        /**
+         * 3D point which - together with a direction - defines the line.
+         * @type JXG.Point3D
+         *
+         * @see JXG.Line3D#direction
+         */
+        this.point = point;
+
+        /**
+         * Direction which - together with a point - defines the line. Array of numbers or functions (of length 3) or function
+         * returning array of length 3.
+         *
+         * @type Array,Function
+         * @see JXG.Line3D#point
+         */
+        this.direction = direction;
+
+        /**
+         * Range [r1, r2] of the line. r1, r2 can be numbers or functions.
+         * The 3D line goes from (point + r1 * direction) to (point + r2 * direction)
+         * @type Array
+         */
+        this.range = range || [-Infinity, Infinity];
+
+        /**
+         * Starting point of the 3D line
+         * @type JXG.Point3D
+         * @private
+         */
+        this.point1 = null;
+
+        /**
+         * End point of the 3D line
+         * @type JXG.Point3D
+         * @private
+         */
+        this.point2 = null;
+
+        this.methodMap = Type.deepCopy(this.methodMap, {
+            // TODO
+        });
+    };
+    JXG.Line3D.prototype = new JXG.GeometryElement();
+    Type.copyPrototypeMethods(JXG.Line3D, JXG.GeometryElement3D, 'constructor3D');
+
+    JXG.extend(JXG.Line3D.prototype, /** @lends JXG.Line3D.prototype */ {
+
+        /**
+         * Determine one end point of a 3D line from point, direction and range.
+         *
+         * @param {Number|function} r
+         * @private
+         * @returns Array
+         */
+        getPointCoords: function (r) {
+            var p = [],
+                d = [],
+                i, r0;
+
+            p = [this.point.X(), this.point.Y(), this.point.Z()];
+
+            if (Type.isFunction(this.direction)) {
+                d = this.direction();
+            } else {
+                for (i = 1; i < 4; i++) {
+                    d.push(Type.evaluate(this.direction[i]));
+                }
+            }
+
+            r0 = Type.evaluate(r);
+            // TODO: test also in the finite case
+            if (Math.abs(r0) === Infinity) {
+                r = this.view.intersectionLineCube(p, d, r0);
+            }
+
+            return [
+                p[0] + d[0] * r0,
+                p[1] + d[1] * r0,
+                p[2] + d[2] * r0
+            ];
+        },
+
+        update: function () { return this; },
+
+        updateRenderer: function () {
+            this.needsUpdate = false;
+            return this;
+        }
+
+    });
+
     /**
      * @class This element is used to provide a constructor for a 3D line.
      * @pseudo
@@ -51,168 +166,288 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
      * All numbers can also be provided as functions returning a number.
      *
      * @name Line3D
-     * @augments JXG.Curve
+     * @augments JXG.GeometryElement3D
      * @constructor
-     * @type JXG.Curve
+     * @type JXG.Line3D
      * @throws {Exception} If the element cannot be constructed with the given parent
      * objects an exception is thrown.
-     * @param {JXG.Point_number,JXG.Point,JXG.Line,JXG.Circle} center,radius The center must be given as a {@link JXG.Point}, see {@link JXG.providePoints}, but the radius can be given
-     * as a number (which will create a circle with a fixed radius), another {@link JXG.Point}, a {@link JXG.Line} (the distance of start and end point of the
-     * line will determine the radius), or another {@link JXG.Circle}.
+     * @param {JXG.Point3D,array_JXG.Point3D,array} point1,point2 First and second defining point.
+     * @param {JXG.Point3D,array_array,function_array,function} point,direction,range Alternatively, point, direction and range can be supplied.
+     * <ul>
+     * <li> point: Point3D or array of length 3
+     * <li> direction: array of length 3 or function returning an array of numbers or function returning an array
+     * <li> range: array of length 2, elements can also be functions.
+     * </ul>
+     *
+     * @example
+     *     var bound = [-5, 5];
+     *     var view = board.create('view3d',
+     *         [[-6, -3], [8, 8],
+     *         [bound, bound, bound]],
+     *         {});
+     *     var p = view.create('point3d', [1, 2, 2], { name:'A', size: 5 });
+     *     // Lines through 2 points
+     *     var l1 = view.create('line3d', [[1, 3, 3], [-3, -3, -3]], {point1: {visible: true}, point2: {visible: true} });
+     *     var l2 = view.create('line3d', [p, l1.point1]);
+     *
+     *     // Line by point, direction, range
+     *     var l3 = view.create('line3d', [p, [0, 0, 1], [-2, 4]]);
+     *
+     * </pre><div id="JXG05f9baa4-6059-4502-8911-6a934f823b3d" class="jxgbox" style="width: 300px; height: 300px;"></div>
+     * <script type="text/javascript">
+     *     (function() {
+     *         var board = JXG.JSXGraph.initBoard('JXG05f9baa4-6059-4502-8911-6a934f823b3d',
+     *             {boundingbox: [-8, 8, 8,-8], axis: false, showcopyright: false, shownavigation: false});
+     *         var bound = [-5, 5];
+     *         var view = board.create('view3d',
+     *             [[-6, -3], [8, 8],
+     *             [bound, bound, bound]],
+     *             {});
+     *         var p = view.create('point3d', [1, 2, 2], { name:'A', size: 5 });
+     *         // Lines through 2 points
+     *         var l1 = view.create('line3d', [[1, 3, 3], [-3, -3, -3]], {name: 'll1', point1: {visible: true}, point2: {visible: true} });
+     *         var l2 = view.create('line3d', [p, l1.point1]);
+     *         // Line by point, direction, range
+     *         var l3 = view.create('line3d', [p, [0, 0, 1], [-2, 4]]);
+     *     })();
+     *
+     * </script><pre>
      *
      */
-    ThreeD.createLine = function (board, parents, attributes) {
+    JXG.createLine3D = function (board, parents, attributes) {
         var view = parents[0],
-            attr, D3, point, point1, point2,
+            attr, points,
+            point, direction, range,
+            point1, point2,
             el;
 
-        // Range
-        D3 = {
-            elType: 'line3d',
-            range: parents[3] || [-Infinity, Infinity]
-        };
+        attr = Type.copyAttributes(attributes, board.options, 'line3d');
 
-        // Point
-        if (Type.isPoint(parents[1])) {
-            point = parents[1];
-        } else {
-            point = view.create('point3d', parents[1], { visible: false, name: '', withLabel: false });
-        }
-        D3.point = point;
+        // In any case, parents[1] contains a point or point coordinates
+        point = Type.providePoints3D(view, [parents[1]], attributes, 'line3d', ['point'])[0];
 
-        // Direction
-        if (Type.isPoint(parents[2]) && Type.exists(parents[2].D3)) {
+        if (Type.isPoint3D(parents[2]) || (Type.isArray(parents[2]) && parents.length === 3)) {
             // Line defined by two points
 
             point1 = point;
-            point2 = parents[2];
-            D3.direction = function () {
+            point2 = Type.providePoints3D(view, [parents[2]], attributes, 'line3d', ['point2'])[0];
+            direction = function () {
                 return [
-                    point2.D3.X() - point.D3.X(),
-                    point2.D3.Y() - point.D3.Y(),
-                    point2.D3.Z() - point.D3.Z()
+                    point2.X() - point.X(),
+                    point2.Y() - point.Y(),
+                    point2.Z() - point.Z()
                 ];
             };
-            D3.range = [0, 1];
+            range = [0, 1];
+            el = new JXG.Line3D(view, point, direction, range, attr);
         } else {
             // Line defined by point, direction and range
 
             // Directions are handled as arrays of length 4,
             // i.e. with homogeneous coordinates.
             if (Type.isFunction(parents[2])) {
-                D3.direction = parents[2];
+                direction = parents[2];
             } else if (parents[2].length === 3) {
-                D3.direction = [1].concat(parents[2]);
+                direction = [1].concat(parents[2]);
             } else if (parents[2].length === 4) {
-                D3.direction = parents[2];
+                direction = parents[2];
             } else {
-                // Throw error
+                // TODO Throw error
             }
+            range = parents[3];
 
-            // Direction given as array
-            D3.getPointCoords = function (r) {
-                var p = [],
-                    d = [],
-                    i;
-
-                p.push(point.D3.X());
-                p.push(point.D3.Y());
-                p.push(point.D3.Z());
-
-                if (Type.isFunction(D3.direction)) {
-                    d = D3.direction();
-                } else {
-                    for (i = 1; i < 4; i++) {
-                        d.push(Type.evaluate(D3.direction[i]));
-                    }
-                }
-                if (Math.abs(r) === Infinity) {
-                    r = view.intersectionLineCube(p, d, r);
-                }
-                return [
-                    p[0] + d[0] * r,
-                    p[1] + d[1] * r,
-                    p[2] + d[2] * r
-                ];
+            points = Type.providePoints3D(view, [[0, 0, 0], [0, 0, 0]], attributes, 'line3d', ['point1', 'point2']);
+
+            // Create a line3d with two dummy points
+            el = new JXG.Line3D(view, point, direction, range, attr);
 
+            // Now set the real points which define the line
+            points[0].F = function () {
+                return el.getPointCoords(Type.evaluate(el.range[0]));
             };
+            points[0].prepareUpdate().update();
+            point1 = points[0];
 
-            attr = Type.copyAttributes(attributes, board.options, 'line3d', 'point1');
-            point1 = view.create('point3d', [
-                function () {
-                    return D3.getPointCoords(Type.evaluate(D3.range[0]));
-                }
-            ], attr);
-            attr = Type.copyAttributes(attributes, board.options, 'line3d', 'point2');
-            point2 = view.create('point3d', [
-                function () {
-                    return D3.getPointCoords(Type.evaluate(D3.range[1]));
-                }
-            ], attr);
+            points[1].F = function () {
+                return el.getPointCoords(Type.evaluate(el.range[1]));
+            };
+            points[1].prepareUpdate().update();
+            point2 = points[1];
         }
+        // TODO Throw error
+
+        el.element2D = view.create('segment', [point1.element2D, point2.element2D], attr);
+        el.addChild(el.element2D);
+        el.inherits.push(el.element2D);
+        el.element2D.setParents(el);
 
-        attr = Type.copyAttributes(attributes, board.options, 'line3d');
-        el = view.create('segment', [point1, point2], attr);
-        el.point1 = point1;
-        el.point2 = point2;
         point1.addChild(el);
         point2.addChild(el);
-        el.D3 = D3;
+        el.point1 = point1;
+        el.point2 = point2;
 
+        el.update();
+        el.element2D.prepareUpdate().update().updateRenderer();
         return el;
     };
-    JXG.registerElement('line3d', ThreeD.createLine);
+    JXG.registerElement('line3d', JXG.createLine3D);
 
-    ThreeD.createPlane = function (board, parents, attributes) {
-        var view = parents[0],
-            attr, D3,
-            point,
-            vec1 = parents[2],
-            vec2 = parents[3],
-            el, grid, update;
-
-        // D3: {
-        //    point,
-        //    vec1,
-        //    vec2,
-        //    poin1,
-        //    point2,
-        //    normal array of len 3
-        //    d
-        // }
-        D3 = {
-            elType: 'plane3d',
-            dir1: [],
-            dir2: [],
-            range1: parents[4],
-            range2: parents[5],
-            vec1: vec1,
-            vec2: vec2
-        };
+    // -----------------------
+    //  Planes
+    // -----------------------
 
-        if (Type.isPoint(parents[1])) {
-            point = parents[1];
-        } else {
-            point = view.create('point3d', parents[1], { visible: false, name: '', withLabel: false });
-        }
-        D3.point = point;
-
-        D3.updateNormal = function () {
-            var i;
+    /**
+     * Constructor for 3D planes.
+     * @class Creates a new 3D plane object. Do not use this constructor to create a 3D plane. Use {@link JXG.Board#create} with type {@link Plane3D} instead.
+     *
+     * @augments JXG.GeometryElement3D
+     * @augments JXG.GeometryElement
+     * @param {View3D} view
+     * @param {Point3D,Array} point
+     * @param {Array} direction1
+     * @param {Array} range1
+     * @param {Array} direction2
+     * @param {Array} range2
+     * @param {Object} attributes
+     * @see JXG.Board#generateName
+     */
+    JXG.Plane3D = function (view, point, dir1, range1, dir2, range2, attributes) {
+        this.constructor(view.board, attributes, Const.OBJECT_TYPE_PLANE3D, Const.OBJECT_CLASS_3D);
+        this.constructor3D(view, 'plane3d');
+
+        this.id = this.view.board.setId(this, 'PL3D');
+        this.board.finalizeAdding(this);
+
+        /**
+         * 3D point which - together with two direction vectors - defines the plane.
+         *
+         * @type JXG.Point3D
+         *
+         * @see JXG.3D#direction1
+         * @see JXG.3D#direction2
+         */
+        this.point = point;
+
+        /**
+         * Two linearly independent vectors - together with a point - define the plane. Each of these direction vectors is an
+         * array of numbers or functions (of length 3) or function returning array of length 3.
+         *
+         * @type Array,Function
+         *
+         * @see JXG.Plane3D#point
+         * @see JXG.Plane3D#direction2
+         */
+        this.direction1 = dir1;
+
+        /**
+         * Two linearly independent vectors - together with a point - define the plane. Each of these direction vectors is an
+         * array of numbers or functions (of length 3) or function returning array of length 3.
+         *
+         * @type Array,Function
+         * @see JXG.Plane3D#point
+         * @see JXG.Plane3D#direction1
+         */
+        this.direction2 = dir2;
+
+        /**
+         * Range [r1, r2] of {@link direction1}. The 3D line goes from (point + r1 * direction1) to (point + r2 * direction1)
+         * @type {Array}
+         */
+        this.range1 = range1 || [-Infinity, Infinity];
+
+        /**
+         * Range [r1, r2] of {@link direction2}. The 3D line goes from (point + r1 * direction2) to (point + r2 * direction2)
+         * @type {Array}
+         */
+        this.range2 = range2 || [-Infinity, Infinity];
+
+        /**
+         * Direction vector 1 of the 3D plane. Contains the evaluated coordinates from {@link direction1} and {@link range1}.
+         * @type Array
+         * @private
+         *
+         * @see updateNormal
+         */
+        this.vec1 =  [0, 0, 0];
+
+        /**
+         * Direction vector 2 of the 3D plane. Contains the evaluated coordinates from {@link direction2} and {@link range2}.
+         *
+         * @type Array
+         * @private
+         *
+         * @see updateNormal
+         */
+        this.vec2 =  [0, 0, 0];
+
+        this.grid = null;
+
+        /**
+         * Normal vector of the plane. Left hand side of the Hesse normal form.
+
+        * @type Array
+         * @private
+         *
+         * @see updateNormal
+         *
+         */
+        this.normal = [0, 0, 0];
+
+        /**
+         * Right hand side of the Hesse normal form.
+
+        * @type Array
+         * @private
+         *
+         * @see updateNormal
+         *
+         */
+        this.d = 0;
+
+        this.updateNormal();
+
+        this.methodMap = Type.deepCopy(this.methodMap, {
+            // TODO
+        });
+    };
+    JXG.Plane3D.prototype = new JXG.GeometryElement();
+    Type.copyPrototypeMethods(JXG.Plane3D, JXG.GeometryElement3D, 'constructor3D');
+
+    JXG.extend(JXG.Plane3D.prototype, /** @lends JXG.Plane3D.prototype */ {
+
+        /**
+         * Update the Hesse normal form of the plane, i.e. update normal vector and right hand side.
+         * Updates also {@link vec1} and {@link vec2}.
+         *
+         * @name updateNormal
+         * @function
+         * @returns {Object} Reference to the Plane3D object
+         * @private
+         * @example
+         *    plane.updateNormal();
+         *
+         */
+        updateNormal: function () {
+            var i, len;
             for (i = 0; i < 3; i++) {
-                D3.dir1[i] = Type.evaluate(D3.vec1[i]);
-                D3.dir2[i] = Type.evaluate(D3.vec2[i]);
+                this.vec1[i] = Type.evaluate(this.direction1[i]);
+                this.vec2[i] = Type.evaluate(this.direction2[i]);
             }
-            D3.normal = Mat.crossProduct(D3.dir1, D3.dir2);
-            D3.d = Mat.innerProduct(D3.point.D3.coords.slice(1), D3.normal, 3);
-        };
-        D3.updateNormal();
 
-        attr = Type.copyAttributes(attributes, board.options, 'plane3d');
-        el = board.create('curve', [[], []], attr);
-        el.D3 = D3;
+            this.normal = Mat.crossProduct(this.vec1, this.vec2);
+
+            len = Mat.norm(this.normal);
+            if (Math.abs(len) > Mat.eps) {
+                for (i = 0; i < 3; i++) {
+                    this.normal[i] /= len;
+                }
+            }
+            this.d = Mat.innerProduct(this.point.coords.slice(1), this.normal, 3);
 
-        el.updateDataArray = function () {
+            return this;
+        },
+
+        updateDataArray: function () {
             var s1, e1, s2, e2,
                 c2d, l1, l2,
                 planes = ['xPlaneRear', 'yPlaneRear', 'zPlaneRear'],
@@ -220,17 +455,19 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
                 v1 = [0, 0, 0],
                 v2 = [0, 0, 0],
                 q = [0, 0, 0],
-                p = [0, 0, 0], d, i, j, a, b, first, pos, pos_akt;
+                p = [0, 0, 0], d, i, j, a, b, first, pos, pos_akt,
+                view = this.view;
 
             this.dataX = [];
             this.dataY = [];
 
-            this.D3.updateNormal();
+            this.updateNormal();
 
             // Infinite plane
-            if (this.D3.elType !== 'axisplane3d' && view.defaultAxes &&
-                (!D3.range1 || !D3.range2)
-                ) {
+            if (this.elType !== 'axisplane3d' && view.defaultAxes &&
+                Type.evaluate(this.range1[0]) === -Infinity && Type.evaluate(this.range1[1]) === Infinity &&
+                Type.evaluate(this.range2[0]) === -Infinity && Type.evaluate(this.range2[1]) === Infinity
+            ) {
 
                 // Start with the rear plane.
                 // Determine the intersections with the view bbox3d
@@ -256,10 +493,10 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
 
                     // Point on the front plane of the bbox3d
                     p = [0, 0, 0];
-                    p[j] = view.D3.bbox3d[j][1];
+                    p[j] = view.bbox3D[j][1];
 
                     // d is the rhs of the Hesse normal form of the front plane.
-                    d = Mat.innerProduct(p, view.defaultAxes[planes[j]].D3.normal, 3);
+                    d = Mat.innerProduct(p, view.defaultAxes[planes[j]].normal, 3);
                     p = view.intersectionPlanePlane(this, view.defaultAxes[planes[j]], d);
 
                     if (p[0].length === 3 && p[1].length === 3) {
@@ -310,21 +547,22 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
                         break;
                     }
                 } while (pos !== first);
+
                 c2d = view.project3DTo2D(points[first][0]);
                 this.dataX.push(c2d[1]);
                 this.dataY.push(c2d[2]);
 
             } else {
                 // 3D bounded flat
-                s1 = Type.evaluate(this.D3.range1[0]);
-                e1 = Type.evaluate(this.D3.range1[1]);
-                s2 = Type.evaluate(this.D3.range2[0]);
-                e2 = Type.evaluate(this.D3.range2[1]);
+                s1 = Type.evaluate(this.range1[0]);
+                e1 = Type.evaluate(this.range1[1]);
+                s2 = Type.evaluate(this.range2[0]);
+                e2 = Type.evaluate(this.range2[1]);
 
-                q = this.D3.point.D3.coords.slice(1);
+                q = this.point.coords.slice(1);
 
-                v1 = this.D3.dir1.slice();
-                v2 = this.D3.dir2.slice();
+                v1 = this.vec1.slice();
+                v2 = this.vec2.slice();
                 l1 = Mat.norm(v1, 3);
                 l2 = Mat.norm(v2, 3);
                 for (i = 0; i < 3; i++) {
@@ -350,26 +588,69 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
                 this.dataX.push(this.dataX[0]);
                 this.dataY.push(this.dataY[0]);
             }
+            return { 'X': this.dataX, 'Y': this.dataY};
+        },
+
+        update: function () {
+            return this;
+        },
+
+        updateRenderer: function () {
+            this.needsUpdate = false;
+            return this;
+        }
+    });
+
+    JXG.createPlane3D = function (board, parents, attributes) {
+        var view = parents[0],
+            attr,
+            point,
+            dir1 = parents[2],
+            dir2 = parents[3],
+            range1 = parents[4] || [-Infinity, Infinity],
+            range2 = parents[5] || [-Infinity, Infinity],
+            el, grid;
+
+
+        point = Type.providePoints3D(view, [parents[1]], attributes, 'plane3d', ['point'])[0];
+        if (point === false) {
+            // TODO Throw error
+        }
+
+        attr = Type.copyAttributes(attributes, board.options, 'plane3d');
+        el = new JXG.Plane3D(view, point, dir1, range1, dir2, range2, attr);
+        point.addChild(el);
+
+
+        el.element2D = view.create('curve', [[], []], attr);
+        el.element2D.updateDataArray = function() {
+            var ret = el.updateDataArray();
+            this.dataX = ret.X;
+            this.dataY = ret.Y;
         };
+        el.addChild(el.element2D);
+        el.inherits.push(el.element2D);
+        el.element2D.setParents(el);
 
-        attr = Type.copyAttributes(attributes.mesh3d, board.options, 'mesh3d');
 
-        if (D3.range1 && D3.range2) {
-            grid = view.create('mesh3d', [point.D3.coords.slice(1), vec1, D3.range1, vec2, D3.range2], attr);
+        attr = Type.copyAttributes(attributes.mesh3d, board.options, 'mesh3d');
+        if (Math.abs(el.range1[0]) !== Infinity && Math.abs(el.range1[1]) !== Infinity &&
+            Math.abs(el.range2[0]) !== Infinity && Math.abs(el.range2[1]) !== Infinity
+        ) {
+            grid = view.create('mesh3d', [ function() { return point.coords; }, dir1, range1, dir2, range2 ], attr);
             el.grid = grid;
+            el.addChild(grid);
             el.inherits.push(grid);
+            grid.setParents(el);
         }
 
-        // update = el.update;
-        // el.update = function () {
-        //     if (el.needsUpdate) {
-        //         update.apply(el);
-        //     }
-        //     return this;
-        // };
+        el.element2D.prepareUpdate().update();
+        if (!board.isSuspendedUpdate) {
+            el.element2D.updateVisibility().updateRenderer();
+        }
 
         return el;
     };
-    JXG.registerElement('plane3d', ThreeD.createPlane);
+    JXG.registerElement('plane3d', JXG.createPlane3D);
 
 });