jsxgraph 1.4.4 → 1.4.6

package/distrib/sketch.min.js

@@ -1,5 +1,5 @@
 /*
-    JSXGraph 1.4.4
+    JSXGraph 1.4.6
 
     Copyright 2008-2022
         Matthias Ehmann,

package/package.json

@@ -2,7 +2,7 @@
   "name": "jsxgraph",
   "description": "Interactive geometry, plotting, visualization",
   "homepage": "https://jsxgraph.org",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "main": "distrib/jsxgraphcore.js",
   "types": "distrib/index.d.ts",
   "maintainers": [

package/src/3d/box3d.js

@@ -30,13 +30,12 @@
 
 /**
  * Create axes and rear and front walls of the
- * view3d bounding box bbox3d.
+ * view3d bounding box bbox3D.
  */
-define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
-], function (JXG, Type, Mat, Geometry, ThreeD) {
+define(['jxg', 'utils/type', 'math/math', 'math/geometry'], function (JXG, Type, Mat, Geometry) {
     "use strict";
 
-    ThreeD.createAxes = function (board, parents, attributes) {
+    JXG.createAxes3D = function (board, parents, attributes) {
         var view = parents[0],
             i, j, k, i1, i2,
             attr,
@@ -53,10 +52,10 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
             ticks_attr,
             axes = {};
 
-        if (Type.exists(view.D3)) {
+        if (Type.exists(view.bbox3D)) {
             for (i = 0; i < directions.length; i++) {
-                rear[i] = view.D3.bbox3d[i][0];
-                front[i] = view.D3.bbox3d[i][1];
+                rear[i] = view.bbox3D[i][0];
+                front[i] = view.bbox3D[i][1];
             }
         } else {
             for (i = 0; i < directions.length; i++) {
@@ -108,7 +107,7 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
         }
 
         // Origin (2D point)
-        axes.O = board.create('intersection', [
+        axes.O = view.create('intersection', [
                 axes[directions[0] + suffixAxis],
                 axes[directions[1] + suffixAxis]
             ], {
@@ -136,9 +135,8 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
                 na = dir + 'Plane' + sides[j];
 
                 attr = Type.copyAttributes(attributes, board.options, 'axes3d', na);
-                axes[na] =
-                    view.create('plane3d', [from, vec1, vec2, range1, range2], attr);
-                axes[na].D3.elType = 'axisplane3d';
+                axes[na] = view.create('plane3d', [from, vec1, vec2, range1, range2], attr);
+                axes[na].elType = 'axisplane3d';
             }
         }
 
@@ -163,16 +161,16 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
                     attr = Type.copyAttributes(attributes, board.options, 'axes3d', na);
                     axes[na] = view.create('axis3d', [from, to], attr);
                     axes[na_parent].addChild(axes[na]);
-                    axes[na_parent].inherits.push(axes[na]);
+                    axes[na_parent].element2D.inherits.push(axes[na]);  // TODO: Access of element2D is not nice
                 }
             }
         }
 
         return axes;
     };
-    JXG.registerElement('axes3d', ThreeD.createAxes);
+    JXG.registerElement('axes3d', JXG.createAxes3D);
 
-    ThreeD.createAxis = function (board, parents, attributes) {
+    JXG.createAxis3D = function (board, parents, attributes) {
         var view = parents[0],
             attr,
             start = parents[1],
@@ -181,7 +179,7 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
 
         // Use 2D points to create axis
         attr = Type.copyAttributes(attributes.point1, board.options, 'axis3d', 'point1');
-        el_start = board.create('point', [
+        el_start = view.create('point', [
             (function (xx, yy, zz) {
                 return function () { return view.project3DTo2D(xx, yy, zz)[1]; };
             })(start[0], start[1], start[2]),
@@ -191,7 +189,7 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
         ], attr);
 
         attr = Type.copyAttributes(attributes.point2, board.options, 'axis3d', 'point2');
-        el_end = board.create('point', [
+        el_end = view.create('point', [
             (function (xx, yy, zz) {
                 return function () { return view.project3DTo2D(xx, yy, zz)[1]; };
             })(end[0], end[1], end[2]),
@@ -201,22 +199,22 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
         ], attr);
 
         attr = Type.copyAttributes(attributes, board.options, 'axis3d');
-        el = board.create('arrow', [el_start, el_end], attr);
+        el = view.create('arrow', [el_start, el_end], attr);
 
         return el;
     };
-    JXG.registerElement('axis3d', ThreeD.createAxis);
+    JXG.registerElement('axis3d', JXG.createAxis3D);
 
-    ThreeD.createMesh = function (board, parents, attr) {
+    JXG.createMesh3D = function (board, parents, attr) {
         var view = parents[0],
             point = parents[1],
-            vec1 = parents[2],
+            dir1 = parents[2],
             range1 = parents[3],
-            vec2 = parents[4],
+            dir2 = parents[4],
             range2 = parents[5],
             el;
 
-        el = board.create('curve', [[], []], attr);
+        el = view.create('curve', [[], []], attr);
         el.updateDataArray = function () {
             var s1 = range1[0],
                 e1 = range1[1],
@@ -231,10 +229,16 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
             this.dataX = [];
             this.dataY = [];
 
+            if (Type.isFunction(point)) {
+                q = point().slice(1);
+            } else {
+                for (i = 0; i < 3; i++) {
+                    q[i] = Type.evaluate(point[i]);
+                }
+            }
             for (i = 0; i < 3; i++) {
-                q[i] = Type.evaluate(point[i]);
-                v1[i] = Type.evaluate(vec1[i]);
-                v2[i] = Type.evaluate(vec2[i]);
+                v1[i] = Type.evaluate(dir1[i]);
+                v2[i] = Type.evaluate(dir2[i]);
             }
             l1 = JXG.Math.norm(v1, 3);
             l2 = JXG.Math.norm(v2, 3);
@@ -242,20 +246,21 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
                 v1[i] /= l1;
                 v2[i] /= l2;
             }
-            if (false) {
-                sol = Mat.Geometry.getPlaneBounds(v1, v2, q, s1, e1);
-                if (sol !== null) {
-                    s1 = sol[0];
-                    e1 = sol[1];
-                    s2 = sol[2];
-                    e2 = sol[3];
-                }
-            }
+
+            // sol = Mat.Geometry.getPlaneBounds(v1, v2, q, s1, e1);
+            // if (sol !== null) {
+            //     s1 = sol[0];
+            //     e1 = sol[1];
+            //     s2 = sol[2];
+            //     e2 = sol[3];
+            // }
 
             res = view.getMesh(
-                function(u, v) { return q[0] + u * v1[0] + v * v2[0]; },
-                function(u, v) { return q[1] + u * v1[1] + v * v2[1]; },
-                function(u, v) { return q[2] + u * v1[2] + v * v2[2]; },
+                [
+                    function(u, v) { return q[0] + u * v1[0] + v * v2[0]; },
+                    function(u, v) { return q[1] + u * v1[1] + v * v2[1]; },
+                    function(u, v) { return q[2] + u * v1[2] + v * v2[2]; }
+                ],
                 [Math.ceil(s1), Math.floor(e1), (Math.ceil(e1) - Math.floor(s1)) / step],
                 [Math.ceil(s2), Math.floor(e2), (Math.ceil(e2) - Math.floor(s2)) / step]);
             this.dataX = res[0];
@@ -263,6 +268,6 @@ define(['jxg', 'utils/type', 'math/math', 'math/geometry', '3d/view3d'
         };
         return el;
     };
-    JXG.registerElement('mesh3d', ThreeD.createMesh);
+    JXG.registerElement('mesh3d', JXG.createMesh3D);
 
 });

package/src/3d/curve3d.js

@@ -28,70 +28,174 @@
  */
 /*global JXG:true, define: true*/
 
-define(['jxg', 'utils/type', '3d/view3d'
-], function (JXG, Type, ThreeD) {
+define(['jxg', 'base/constants', 'utils/type'], function (JXG, Const, Type) {
     "use strict";
 
-    ThreeD.createCurve = function (board, parents, attr) {
-        var view = parents[0],
-            D3, el;
+    /**
+     * Constructor for 3D curves.
+     * @class Creates a new 3D curve object. Do not use this constructor to create a 3D curve. Use {@link JXG.Board#create} with type {@link Curve3D} instead.
+     *
+     * @augments JXG.GeometryElement3D
+     * @augments JXG.GeometryElement
+     * @param {View3D} view
+     * @param {Function} F
+     * @param {Function} X
+     * @param {Function} Y
+     * @param {Function} Z
+     * @param {Array} range
+     * @param {Object} attributes
+     * @see JXG.Board#generateName
+     */
+     JXG.Curve3D = function (view, F, X, Y, Z, range, attributes) {
+        this.constructor(view.board, attributes, Const.OBJECT_TYPE_CURVE3D, Const.OBJECT_CLASS_3D);
+        this.constructor3D(view, 'surface3d');
+
+        this.id = this.view.board.setId(this, 'S3D');
+        this.board.finalizeAdding(this);
+
+        this.F = F;
+
+        /**
+         * Function which maps u to x; i.e. it defines the x-coordinate of the curve
+         * @function
+         * @returns Number
+         */
+        this.X = X;
+
+        /**
+         * Function which maps u to y; i.e. it defines the y-coordinate of the curve
+         * @function
+         * @returns Number
+         */
+        this.Y = Y;
+
+        /**
+         * Function which maps u to z; i.e. it defines the x-coordinate of the curve
+         * @function
+         * @returns Number
+         */
+        this.Z = Z;
+
+        if (this.F !== null) {
+            this.X = function(u) { return this.F(u)[0]; };
+            this.Y = function(u) { return this.F(u)[1]; };
+            this.Z = function(u) { return this.F(u)[2]; };
+        }
 
-        D3 = {
-            elType: 'curve3D',
-            X: parents[1],
-            Y: parents[2],
-            Z: parents[3],
-        };
-        D3.F = [D3.X, D3.Y, D3.Z];
+        this.range = range;
 
-        el = board.create('curve', [[], []], attr);
-        el.D3 = D3;
+        this.methodMap = Type.deepCopy(this.methodMap, {
+            // TODO
+        });
+    };
+    JXG.Curve3D.prototype = new JXG.GeometryElement();
+    Type.copyPrototypeMethods(JXG.Curve3D, JXG.GeometryElement3D, 'constructor3D');
+
+    JXG.extend(JXG.Curve3D.prototype, /** @lends JXG.Curve3D.prototype */ {
+
+        updateDataArray: function () {
+            var steps = Type.evaluate(this.visProp.numberpointshigh),
+                r, s, e, delta,
+                c2d, u,
+                dataX, dataY,
+                p = [0, 0, 0];
+
+            dataX = [];
+            dataY = [];
+
+            if (Type.isArray(this.X)) {
+                steps = this.X.length;
+                for (u = 0; u < steps; u++) {
+                    p = [this.X[u], this.Y[u], this.Z[u]];
+                    c2d = this.view.project3DTo2D(p);
+                    dataX.push(c2d[1]);
+                    dataY.push(c2d[2]);
+                }
+            } else {
+                r = Type.evaluate(this.range);
+                s = r[0];
+                e = r[1];
+                delta = (e - s) / (steps - 1);
+                for (u = s; u <= e; u += delta) {
+                    if (this.F !== null){
+                        p = this.F(u);
+                    } else {
+                        p = [this.X(u), this.Y(u), this.Z(u)];
+                    }
+                    c2d = this.view.project3DTo2D(p);
+                    dataX.push(c2d[1]);
+                    dataY.push(c2d[2]);
+                }
+            }
+            return {'X': dataX, 'Y': dataY};
+        },
 
-        if (Type.isFunction(el.D3.X)) {
-            // 3D curve given as t -> [X(t), Y(t), Z(t)]
+        update: function () { return this; },
 
-            el.D3.range = parents[4];
-            el.updateDataArray = function () {
-                var steps = Type.evaluate(this.visProp.numberpointshigh),
-                    s = Type.evaluate(this.D3.range[0]),
-                    e = Type.evaluate(this.D3.range[1]),
-                    delta = (e - s) / (steps - 1),
-                    c2d, t, i,
-                    p = [0, 0, 0];
+        updateRenderer: function () {
+            this.needsUpdate = false;
+            return this;
+        }
+    });
+
+    /**
+     * @class This element creates a 3D parametric curves.
+     * @pseudo
+     * @description A 3D parametric curve is defined by a function
+     *    <i>F: R<sup>1</sup> &rarr; R<sup>3</sup></i>.
+     *
+     * @name Curve3D
+     * @augments Curve
+     * @constructor
+     * @type Object
+     * @throws {Exception} If the element cannot be constructed with the given parent objects an exception is thrown.
+     * @param {Function_Function_Function_Array,Function} F<sub>X</sub>,F<sub>Y</sub>,F<sub>Z</sub>,range
+     * F<sub>X</sub>(u), F<sub>Y</sub>(u), F<sub>Z</sub>(u) are functions returning a number, range is the array containing
+     * lower and upper bound for the range of the parameter u. range may also be a function returning an array of length two.
+     * @param {Function_Array,Function} F,range Alternatively: F<sub>[X,Y,Z]</sub>(u) a function returning an array [x,y,z] of
+     * numbers, range as above.
+     * @param {Array_Array_Array} X,Y,Z Three arrays containing the coordinate points which define the curve.
+     */
+    JXG.createCurve3D = function (board, parents, attributes) {
+        var view = parents[0],
+            F, X, Y, Z, range,
+            attr, el;
+
+        if (parents.length === 3) {
+            F = parents[1];
+            range = parents[2];
+            X = null;
+            Y = null;
+            Z = null;
+        } else {
+            X = parents[1];
+            Y = parents[2];
+            Z = parents[3];
+            range = parents[4];
+            F = null;
+        }
+        // TODO Throw error
 
-                this.dataX = [];
-                this.dataY = [];
+        attr = Type.copyAttributes(attributes, board.options, 'curve3d');
+        el = new JXG.Curve3D(view, F, X, Y, Z, range, attr);
 
-                for (t = s; t <= e; t += delta) {
-                    for (i = 0; i < 3; i++) {
-                        p[i] = this.D3.F[i](t);
-                    }
-                    c2d = view.project3DTo2D(p);
-                    this.dataX.push(c2d[1]);
-                    this.dataY.push(c2d[2]);
-                }
-            };
-        } else if (Type.isArray(el.D3.X)) {
-            // 3D curve given as array of 3D points
-
-            el.updateDataArray = function () {
-                var i,
-                    le = this.D3.X.length,
-                    c2d;
-
-                this.dataX = [];
-                this.dataY = [];
-
-                for (i = 0; i < le; i++) {
-                    c2d = view.project3DTo2D([this.D3.X[i], this.D3.Y[i], this.D3.Z[i]]);
-                    this.dataX.push(c2d[1]);
-                    this.dataY.push(c2d[2]);
-                }
-            };
+        el.element2D = board.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);
+
+        el.element2D.prepareUpdate().update();
+        if (!board.isSuspendedUpdate) {
+            el.element2D.updateVisibility().updateRenderer();
         }
 
         return el;
     };
-    JXG.registerElement('curve3d', ThreeD.createCurve);
+    JXG.registerElement('curve3d', JXG.createCurve3D);
 
 });

package/src/3d/element3d.js

@@ -0,0 +1,84 @@
+/*
+    Copyright 2008-2022
+        Matthias Ehmann,
+        Carsten Miller,
+        Andreas Walter,
+        Alfred Wassermann
+
+    This file is part of JSXGraph.
+
+    JSXGraph is free software dual licensed under the GNU LGPL or MIT License.
+
+    You can redistribute it and/or modify it under the terms of the
+
+      * GNU Lesser General Public License as published by
+        the Free Software Foundation, either version 3 of the License, or
+        (at your option) any later version
+      OR
+      * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT
+
+    JSXGraph is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License and
+    the MIT License along with JSXGraph. If not, see <http://www.gnu.org/licenses/>
+    and <http://opensource.org/licenses/MIT/>.
+ */
+/*global JXG:true, define: true*/
+
+define(['jxg'], function (JXG) {
+    "use strict";
+
+    /**
+     * Constructs a new GeometryElement3D object.
+     * @class This is the basic class for 3D geometry elements like Point3D and Line3D.
+     * @constructor
+     * @param {string} elType
+     * @borrows JXG.EventEmitter#on as this.on
+     * @borrows JXG.EventEmitter#off as this.off
+     * @borrows JXG.EventEmitter#triggerEventHandlers as this.triggerEventHandlers
+     * @borrows JXG.EventEmitter#eventHandlers as this.eventHandlers
+     */
+    JXG.GeometryElement3D = function (view, elType) {
+        this.elType = elType;
+        this.id = this.board.setId(this, elType);
+
+        /**
+         * Pointer to the view3D in which the elemtn is constructed
+         * @type JXG.View3D
+         * @private
+         */
+        this.view = view;
+
+        /**
+         * Link to the 2D element(s) used to visualize the 3D element
+         * in a view. In case, there are several 2D elements, it is an array.
+         *
+         * @type JXG.GeometryElement,Array
+         * @private
+         *
+         * @example
+         *   p.element2D;
+         */
+        this.element2D = null;
+
+        /**
+         * If this property exists (and is true) the element is a 3D element.
+         *
+         * @type Boolean
+         * @private
+         */
+        this.is3D = true;
+        this.view.objects[this.id] = this;
+        this.view.objectsList.push(this);
+
+        if (this.name !== '') {
+            this.view.elementsByName[this.name] = this;
+        }
+
+    };
+
+    return JXG.GeometryElement3D;
+});