jsxgraph 1.4.3 → 1.4.4

package/src/math/clip.js

@@ -1888,7 +1888,6 @@ define([
 
             // Collect all points into clip array C
             C = this._getPath(clip, board);
-
             len = C.length;
             if (len > 0 && Geometry.distance(C[0].coords.usrCoords, C[len - 1].coords.usrCoords, 3) < Mat.eps * Mat.eps) {
                 C.pop();

package/src/math/geometry.js

@@ -1101,6 +1101,30 @@ define([
                     return that.meetCurveLine(el1, el2, i, el1.board, alwaysintersect);
                 };
 
+            } else if (el1.type === Const.OBJECT_TYPE_POLYGON || el2.type === Const.OBJECT_TYPE_POLYGON) {
+                // polygon - other
+                // Uses the Greiner-Hormann clipping algorithm
+                // Not implemented: polygon - point
+
+                if (el1.elementClass === Const.OBJECT_CLASS_LINE) {
+                    // line - path
+                    /** @ignore */
+                    func = function () {
+                        return that.meetPolygonLine(el2, el1, i, el1.board, alwaysintersect);
+                    };
+                } else if (el2.elementClass === Const.OBJECT_CLASS_LINE) {
+                    // path - line
+                    func = function () {
+                        return that.meetPolygonLine(el1, el2, i, el1.board, alwaysintersect);
+                    };
+                } else {
+                    // path - path
+                    /** @ignore */
+                    func = function () {
+                        return that.meetPathPath(el1, el2, i, el1.board);
+                    };
+                }
+
             } else if (el1.elementClass === Const.OBJECT_CLASS_LINE && el2.elementClass === Const.OBJECT_CLASS_LINE) {
                 // line - line, lines may also be segments.
                 /** @ignore */
@@ -1516,6 +1540,8 @@ define([
          * @param {JXG.Line} li Line
          * @param {Number} nr Will return the nr-th intersection point.
          * @param {JXG.Board} board
+         * @param {Boolean} testSegment Test if intersection has to be inside of the segment or somewhere on the
+         * line defined by the segment
          * @returns {JXG.Coords} Coords object containing the intersection.
          */
         meetCurveLineContinuous: function (cu, li, nr, board, testSegment) {
@@ -1580,7 +1606,6 @@ define([
             return (new Coords(Const.COORDS_BY_USER, [z, cu.X(t), cu.Y(t)], board));
         },
 
-
         /**
          * Intersection of line and curve, discrete case.
          * Segments are treated as lines.
@@ -1767,6 +1792,87 @@ define([
             return [c, t, u];
         },
 
+        /**
+         * Find the n-th intersection point of two pathes, usually given by polygons. Uses parts of the
+         * Greiner-Hormann algorithm in JXG.Math.Clip.
+         *
+         * @param {JXG.Circle|JXG.Curve|JXG.Polygon} path1
+         * @param {JXG.Circle|JXG.Curve|JXG.Polygon} path2
+         * @param {Number} n
+         * @param {JXG.Board} board
+         *
+         * @returns {JXG.Coords} Intersection point. In case no intersection point is detected,
+         * the ideal point [0,0,0] is returned.
+         *
+         */
+        meetPathPath: function(path1, path2, nr, board) {
+            var S, C, len, intersections;
+
+            S = JXG.Math.Clip._getPath(path1, board);
+            len = S.length;
+            if (len > 0 && this.distance(S[0].coords.usrCoords, S[len - 1].coords.usrCoords, 3) < Mat.eps) {
+                S.pop();
+            }
+
+            C = JXG.Math.Clip._getPath(path2, board);
+            len = C.length;
+            if (len > 0 && this.distance(C[0].coords.usrCoords, C[len - 1].coords.usrCoords, 3) < Mat.eps * Mat.eps) {
+                C.pop();
+            }
+
+            // Handle cases where at least one of the paths is empty
+            if (nr < 0 || JXG.Math.Clip.isEmptyCase(S, C, 'intersection')) {
+                return (new Coords(Const.COORDS_BY_USER, [0, 0, 0], board));
+            }
+
+            JXG.Math.Clip.makeDoublyLinkedList(S);
+            JXG.Math.Clip.makeDoublyLinkedList(C);
+
+            intersections = JXG.Math.Clip.findIntersections(S, C, board)[0];
+            if (nr < intersections.length) {
+                return intersections[nr].coords;
+            }
+            return (new Coords(Const.COORDS_BY_USER, [0, 0, 0], board));
+        },
+
+        /**
+         * Find the n-th intersection point between a polygon and a line.
+         * @param {JXG.Polygon} path
+         * @param {JXG.Line} line
+         * @param {Number} nr
+         * @param {JXG.Board} board
+         * @param {Boolean} alwaysIntersect If false just the segment between the two defining points of the line are tested for intersection.
+         *
+         * @returns {JXG.Coords} Intersection point. In case no intersection point is detected,
+         * the ideal point [0,0,0] is returned.
+         */
+        meetPolygonLine: function(path, line, nr, board, alwaysIntersect) {
+            var i, res, border,
+                crds = [0,0,0],
+                len = path.borders.length,
+                intersections = [];
+
+            for (i = 0; i < len; i++) {
+                border = path.borders[i];
+                res = this.meetSegmentSegment(
+                    border.point1.coords.usrCoords,
+                    border.point2.coords.usrCoords,
+                    line.point1.coords.usrCoords,
+                    line.point2.coords.usrCoords);
+
+                if (
+                    (!alwaysIntersect || (res[2] >= 0 && res[2] < 1)) &&
+                    res[1] >= 0 && res[1] < 1) {
+                    intersections.push(res[0]);
+                }
+            }
+
+            if (nr >= 0 && nr < intersections.length) {
+                crds = intersections[nr];
+            }
+            return (new Coords(Const.COORDS_BY_USER, crds, board));
+        },
+
         /****************************************/
         /****   BEZIER CURVE ALGORITHMS      ****/
         /****************************************/

package/src/options3d.js

@@ -13,38 +13,162 @@ define([
         },
 
         axes3d: {
+            /**#@+
+             * @visprop
+             */
+
+            /**
+             * Position of the main axes in a View3D element. Possible values are
+             * 'center' and 'border'.
+             *
+             * @type String
+             * @name View3D#axesPosition
+             * @default 'center'
+             */
             axesPosition: 'center',  // Possible values: 'center', otherwise: border
 
             // Main axes
+
+            /**
+             * Attributes of the 3D x-axis.
+             *
+             * @type Line3D
+             * @name View3D#xAxis
+             */
             xAxis: { visible: true, point2: {name: 'x'}},
+
+            /**
+             * Attributes of the 3D y-axis.
+             *
+             * @type Line3D
+             * @name View3D#yAxis
+             */
             yAxis: { visible: true, point2: {name: 'y'}},
+
+            /**
+             * Attributes of the 3D z-axis.
+             *
+             * @type Line3D
+             * @name View3D#zAxis
+             */
             zAxis: { visible: true, point2: {name: 'z'}},
 
             // Planes
+            /**
+             * Attributes of the 3D plane orthogonal to the x-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#xPlaneRear
+             */
             xPlaneRear: { visible: true, layer: 0, mesh3d: { layer: 1 } },
+            /**
+             * Attributes of the 3D plane orthogonal to the y-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#yPlaneRear
+             */
             yPlaneRear: { visible: true, layer: 0, mesh3d: { layer: 1 } },
+            /**
+             * Attributes of the 3D plane orthogonal to the z-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#zPlaneRear
+             */
             zPlaneRear: { visible: true, layer: 0, mesh3d: { layer: 1 } },
 
+            /**
+             * Attributes of the 3D plane orthogonal to the x-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#xPlaneFront
+             */
             xPlaneFront: { visible: false, layer: 0, mesh3d: { layer: 1 } },
+            /**
+             * Attributes of the 3D plane orthogonal to the y-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#yPlaneFront
+             */
             yPlaneFront: { visible: false, layer: 0, mesh3d: { layer: 1 } },
+            /**
+             * Attributes of the 3D plane orthogonal to the z-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#zPlaneFront
+             */
             zPlaneFront: { visible: false, layer: 0, mesh3d: { layer: 1 } },
 
             // Axes on the planes
-            xPlaneRearYAxis: {visible: true, strokeColor: '#888888'},
-            xPlaneRearZAxis: {visible: true, strokeColor: '#888888'},
-            xPlaneFrontYAxis: {visible: false, strokeColor: '#888888'},
-            xPlaneFrontZAxis: {visible: false, strokeColor: '#888888'},
+            /**
+             * Attributes of the 3D y-axis on the 3D plane orthogonal to the x-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#xPlaneRearYAxis
+             */
+            xPlaneRearYAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D z-axis on the 3D plane orthogonal to the x-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#xPlaneRearZAxis
+             */
+            xPlaneRearZAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D y-axis on the 3D plane orthogonal to the x-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#xPlaneFrontYAxis
+             */
+            xPlaneFrontYAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D z-axis on the 3D plane orthogonal to the x-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#xPlaneFrontZAxis
+             */
+            xPlaneFrontZAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
 
-            yPlaneRearXAxis: {visible: true, strokeColor: '#888888'},
-            yPlaneRearZAxis: {visible: true, strokeColor: '#888888'},
-            yPlaneFrontXAxis: {visible: false, strokeColor: '#888888'},
-            yPlaneFrontZAxis: {visible: false, strokeColor: '#888888'},
+            /**
+             * Attributes of the 3D x-axis on the 3D plane orthogonal to the y-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#yPlaneRearXAxis
+             */
+            yPlaneRearXAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D z-axis on the 3D plane orthogonal to the y-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#yPlaneRearZAxis
+             */
+            yPlaneRearZAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D x-axis on the 3D plane orthogonal to the y-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#yPlaneFrontXAxis
+             */
+            yPlaneFrontXAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D z-axis on the 3D plane orthogonal to the y-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#yPlaneFrontZAxis
+             */
+            yPlaneFrontZAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
 
-            zPlaneRearXAxis: {visible: true, strokeColor: '#888888'},
-            zPlaneRearYAxis: {visible: true, strokeColor: '#888888'},
-            zPlaneFrontXAxis: {visible: false, strokeColor: '#888888'},
-            zPlaneFrontYAxis: {visible: false, strokeColor: '#888888'}
+            /**
+             * Attributes of the 3D x-axis on the 3D plane orthogonal to the z-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#zPlaneRearXAxis
+             */
+            zPlaneRearXAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D y-axis on the 3D plane orthogonal to the z-axis at the "rear" of the cube.
+             * @type Plane3D
+             * @name View3D#zPlaneRearYAxis
+             */
+            zPlaneRearYAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D x-axis on the 3D plane orthogonal to the z-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#zPlaneFrontXAxis
+             */
+            zPlaneFrontXAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1},
+            /**
+             * Attributes of the 3D y-axis on the 3D plane orthogonal to the z-axis at the "front" of the cube.
+             * @type Plane3D
+             * @name View3D#zPlaneFrontYAxis
+             */
+            zPlaneFrontYAxis: {visible: 'inherit', strokeColor: '#888888', strokeWidth: 1}
 
+            /**#@-*/
         },
 
         axis3d: {
@@ -105,11 +229,29 @@ define([
         },
 
         surface3d: {
+            /**#@+
+             * @visprop
+             */
+
             highlight: false,
             tabindex: -1,
             strokeWidth: 1,
+
+            /**
+             * Number of intervals the mesh is divided into in direction of parameter u.
+             * @type Number
+             * @name Surface3D#stepsU
+             */
             stepsU: 30,
-            stepsV: 30
+
+            /**
+             * Number of intervals the mesh is divided into in direction of parameter v.
+             * @type Number
+             * @name Surface3D#stepsV
+             */
+             stepsV: 30
+
+            /**#@-*/
         },
 
         view3d: {

package/src/renderer/svg.js

@@ -1694,10 +1694,11 @@ define([
          * 	setTimeout(function() { console.log('done'); }, 400);
          */
         dumpToCanvas: function (canvasId, w, h, ignoreTexts) {
-            var svg, tmpImg, cv, ctx;
+            var svg, tmpImg, cv, ctx,
+                doc = this.container.ownerDocument;
 
             // Prepare the canvas element
-            cv = document.getElementById(canvasId);
+            cv = doc.getElementById(canvasId);
 
             // Clear the canvas
             /* eslint-disable no-self-assign */
@@ -1833,7 +1834,8 @@ define([
             } else {
                 // Debug: use canvas element 'jxgbox_canvas' from jsxdev/dump.html
                 id = 'jxgbox_canvas';
-                canvas = document.getElementById(id);
+                // canvas = document.getElementById(id);
+                canvas = doc.getElementById(id);
             }
 
             if (newImg) {
@@ -1853,7 +1855,8 @@ define([
             }
 
             // Hide navigation bar in board
-            zbar = document.getElementById(this.container.id + '_navigationbar');
+            // zbar = document.getElementById(this.container.id + '_navigationbar');
+            zbar = doc.getElementById(this.container.id + '_navigationbar');
             if (Type.exists(zbar)) {
                 zbarDisplay = zbar.style.display;
                 zbar.style.display = 'none';