jsxgraph 1.3.0 → 1.4.1

package/src/math/complex.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/extrapolate.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/geometry.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -495,6 +495,38 @@ define([
             return d;
         },
 
+        /**
+         * Affine ratio of three collinear points a, b, c: (c - a) / (b - a).
+         * If r > 1 or r < 0 then c is outside of the segment ab.
+         *
+         * @param {Array|JXG.Coords} a
+         * @param {Array|JXG.Coords} b
+         * @param {Array|JXG.Coords} c
+         * @returns {Number} affine ratio (c - a) / (b - a)
+         */
+        affineRatio: function(a, b, c) {
+            var r = 0.0, dx;
+
+            if (Type.exists(a.usrCoords)) {
+                a = a.usrCoords;
+            }
+            if (Type.exists(b.usrCoords)) {
+                b = b.usrCoords;
+            }
+            if (Type.exists(c.usrCoords)) {
+                c = c.usrCoords;
+            }
+
+            dx =  b[1] - a[1];
+
+            if (Math.abs(dx) > Mat.eps) {
+                r = (c[1] - a[1]) / dx;
+            } else {
+                r = (c[2] - a[2]) / (b[2] - a[2]);
+            }
+            return r;
+        },
+
         /**
          * Sort vertices counter clockwise starting with the first point.
          *
@@ -1040,8 +1072,10 @@ define([
                 (el2.type === Const.OBJECT_TYPE_ARC || el2.type === Const.OBJECT_TYPE_SECTOR)
                 ) ? true : false;
 
-            if (el1.elementClass === Const.OBJECT_CLASS_CURVE &&
-                el2.elementClass === Const.OBJECT_CLASS_CURVE && !(el1_isArcType && el2_isArcType) ) {
+            if ((el1.elementClass === Const.OBJECT_CLASS_CURVE || el2.elementClass === Const.OBJECT_CLASS_CURVE) &&
+                (el1.elementClass === Const.OBJECT_CLASS_CURVE || el1.elementClass === Const.OBJECT_CLASS_CIRCLE) &&
+                (el2.elementClass === Const.OBJECT_CLASS_CURVE || el2.elementClass === Const.OBJECT_CLASS_CIRCLE) /*&&
+                !(el1_isArcType && el2_isArcType)*/ ) {
                 // curve - curve
                 // with the exception that both elements are arc types
                 /** @ignore */
@@ -1049,10 +1083,17 @@ define([
                     return that.meetCurveCurve(el1, el2, i, j, el1.board);
                 };
 
-            } else if ((el1.elementClass === Const.OBJECT_CLASS_CURVE &&
-                        !el1_isArcType && el2.elementClass === Const.OBJECT_CLASS_LINE) ||
-                       (el2.elementClass === Const.OBJECT_CLASS_CURVE &&
-                        !el2_isArcType && el1.elementClass === Const.OBJECT_CLASS_LINE)) {
+            } else if ((
+                        el1.elementClass === Const.OBJECT_CLASS_CURVE &&
+                        !el1_isArcType &&
+                        el2.elementClass === Const.OBJECT_CLASS_LINE
+                       ) ||
+                       (
+                        el2.elementClass === Const.OBJECT_CLASS_CURVE &&
+                        !el2_isArcType &&
+                        el1.elementClass === Const.OBJECT_CLASS_LINE
+                       )
+                    ) {
                 // curve - line (this includes intersections between conic sections and lines)
                 // with the exception that the curve is of arc type
                 /** @ignore */
@@ -1103,15 +1144,39 @@ define([
                 /** @ignore */
                 func = function () {
                     var res = that.meet(el1.stdform, el2.stdform, i, el1.board),
-                        has = true;
+                        has = true,
+                        first, last, r, dx;
 
-                    if (!alwaysintersect && el1_isArcType) {
+                    if (alwaysintersect) {
+                        return res;
+                    }
+                    if (el1.elementClass === Const.OBJECT_CLASS_LINE) {
+                        first = Type.evaluate(el1.visProp.straightfirst);
+                        last  = Type.evaluate(el1.visProp.straightlast);
+                        if (!first || !last) {
+                            r = that.affineRatio(el1.point1.coords, el1.point2.coords, res);
+                            if ( (!last && r > 1 + Mat.eps) || (!first && r < 0 - Mat.eps) ) {
+                                return (new Coords(JXG.COORDS_BY_USER, [0, NaN, NaN], el1.board));
+                            }
+                        }
+                    }
+                    if (el2.elementClass === Const.OBJECT_CLASS_LINE) {
+                        first = Type.evaluate(el2.visProp.straightfirst);
+                        last  = Type.evaluate(el2.visProp.straightlast);
+                        if (!first || !last) {
+                            r = that.affineRatio(el2.point1.coords, el2.point2.coords, res);
+                            if ( (!last && r > 1 + Mat.eps) || (!first && r < 0 - Mat.eps) ) {
+                                return (new Coords(JXG.COORDS_BY_USER, [0, NaN, NaN], el1.board));
+                            }
+                        }
+                    }
+                    if (el1_isArcType) {
                         has = that.coordsOnArc(el1, res);
                         if (has && el2_isArcType) {
                             has = that.coordsOnArc(el2, res);
                         }
                         if (!has) {
-                            res = (new Coords(JXG.COORDS_BY_USER, [0, NaN, NaN], el1.board));
+                            return (new Coords(JXG.COORDS_BY_USER, [0, NaN, NaN], el1.board));
                         }
                     }
                     return res;
@@ -1304,7 +1369,6 @@ define([
 
                 return new Coords(Const.COORDS_BY_USER, [NaN, NaN], board);
             }
-
             c = circ[0];
             b = circ.slice(1, 3);
             a = circ[3];
@@ -1396,7 +1460,7 @@ define([
             if (Type.exists(method) && method === 'newton') {
                 co = Numerics.generalizedNewton(c1, c2, nr, t2ini);
             } else {
-                if (c1.bezierDegree === 3 && c2.bezierDegree === 3) {
+                if (c1.bezierDegree === 3 || c2.bezierDegree === 3) {
                     co = this.meetBezierCurveRedBlueSegments(c1, c2, nr);
                 } else {
                     co = this.meetCurveRedBlueSegments(c1, c2, nr);
@@ -1437,11 +1501,7 @@ define([
                 li = el1;
             }
 
-            // if (Type.evaluate(cu.visProp.curvetype) === 'plot') {
-                v = this.meetCurveLineDiscrete(cu, li, nr, board, !alwaysIntersect);
-            // } else {
-            //     v = this.meetCurveLineContinuous(cu, li, nr, board);
-            // }
+            v = this.meetCurveLineDiscrete(cu, li, nr, board, !alwaysIntersect);
 
             return v;
         },
@@ -1520,80 +1580,6 @@ define([
             return (new Coords(Const.COORDS_BY_USER, [z, cu.X(t), cu.Y(t)], board));
         },
 
-        /**
-         * Intersection of line and curve, continuous case.
-         * Segments are treated as lines. Finding the nr-the intersection point
-         * works for nr=0,1 only.
-         *
-         * @private
-         * @deprecated
-         * @param {JXG.Curve} cu Curve
-         * @param {JXG.Line} li Line
-         * @param {Number} nr Will return the nr-th intersection point.
-         * @param {JXG.Board} board
-         *
-         * BUG: does not respect cu.minX() and cu.maxX()
-         */
-        meetCurveLineContinuousOld: function (cu, li, nr, board) {
-            var t, t2, i, func, z,
-                tnew, steps, delta, tstart, tend, cux, cuy,
-                eps = Mat.eps * 10;
-
-            JXG.deprecated('Geometry.meetCurveLineContinuousOld()', 'Geometry.meetCurveLineContinuous()');
-            func = function (t) {
-                var v = li.stdform[0] + li.stdform[1] * cu.X(t) + li.stdform[2] * cu.Y(t);
-                return v * v;
-            };
-
-            // Find some intersection point
-            if (this.meetCurveLineContinuous.t1memo) {
-                tstart = this.meetCurveLineContinuous.t1memo;
-                t = Numerics.root(func, tstart);
-            } else {
-                tstart = cu.minX();
-                tend = cu.maxX();
-                t = Numerics.root(func, [tstart, tend]);
-            }
-
-            this.meetCurveLineContinuous.t1memo = t;
-            cux = cu.X(t);
-            cuy = cu.Y(t);
-
-            // Find second intersection point
-            if (nr === 1) {
-                if (this.meetCurveLineContinuous.t2memo) {
-                    tstart = this.meetCurveLineContinuous.t2memo;
-                }
-                t2 = Numerics.root(func, tstart);
-
-                if (!(Math.abs(t2 - t) > 0.1 && Math.abs(cux - cu.X(t2)) > 0.1 && Math.abs(cuy - cu.Y(t2)) > 0.1)) {
-                    steps = 20;
-                    delta = (cu.maxX() - cu.minX()) / steps;
-                    tnew = cu.minX();
-
-                    for (i = 0; i < steps; i++) {
-                        t2 = Numerics.root(func, [tnew, tnew + delta]);
-
-                        if (Math.abs(func(t2)) <= eps && Math.abs(t2 - t) > 0.1 && Math.abs(cux - cu.X(t2)) > 0.1 && Math.abs(cuy - cu.Y(t2)) > 0.1) {
-                            break;
-                        }
-
-                        tnew += delta;
-                    }
-                }
-                t = t2;
-                this.meetCurveLineContinuous.t2memo = t;
-            }
-
-            // Is the point on the line?
-            if (Math.abs(func(t)) > eps) {
-                z = NaN;
-            } else {
-                z = 1.0;
-            }
-
-            return (new Coords(Const.COORDS_BY_USER, [z, cu.X(t), cu.Y(t)], board));
-        },
 
         /**
          * Intersection of line and curve, discrete case.
@@ -1630,7 +1616,7 @@ define([
             }
 
             p2 = cu.points[0].usrCoords;
-            for (i = 1; i < len; i++) {
+            for (i = 1; i < len; i += cu.bezierDegree) {
                 p1 = p2.slice(0);
                 p2 = cu.points[i].usrCoords;
                 d = this.distance(p1, p2);
@@ -1647,8 +1633,6 @@ define([
                             lip1.slice(1),
                             lip2.slice(1)
                         ], testSegment);
-
-                        i += 2;
                     } else {
                         res = [this.meetSegmentSegment(p1, p2, lip1, lip2)];
                     }
@@ -1660,7 +1644,7 @@ define([
                                 /**
                                 * If the intersection point is not part of the segment,
                                 * this intersection point is set to non-existent.
-                                * This prevents jumping of the intersection points.
+                                * This prevents jumping behavior of the intersection points.
                                 * But it may be discussed if it is the desired behavior.
                                 */
                                 if (testSegment &&
@@ -1739,32 +1723,46 @@ define([
         },
 
         /**
-         * Intersection of two segments.
-         * @param {Array} p1 First point of segment 1 using homogeneous coordinates [z,x,y]
-         * @param {Array} p2 Second point of segment 1 using homogeneous coordinates [z,x,y]
-         * @param {Array} q1 First point of segment 2 using homogeneous coordinates [z,x,y]
-         * @param {Array} q2 Second point of segment 2 using homogeneous coordinates [z,x,y]
+         * (Virtual) Intersection of two segments.
+         * @param {Array} p1 First point of segment 1 using normalized homogeneous coordinates [1,x,y]
+         * @param {Array} p2 Second point or direction of segment 1 using normalized homogeneous coordinates [1,x,y] or point at infinity [0,x,y], respectively
+         * @param {Array} q1 First point of segment 2 using normalized homogeneous coordinates [1,x,y]
+         * @param {Array} q2 Second point or direction of segment 2 using normalized homogeneous coordinates [1,x,y] or point at infinity [0,x,y], respectively
          * @returns {Array} [Intersection point, t, u] The first entry contains the homogeneous coordinates
-         * of the intersection point. The second and third entry gives the position of the intersection between the
-         * two defining points. For example, the second entry t is defined by: intersection point = t*p1 + (1-t)*p2.
+         * of the intersection point. The second and third entry give the position of the intersection with respect
+         * to the definiting parameters. For example, the second entry t is defined by: intersection point = p1 + t * deltaP, where
+         * deltaP = (p2 - p1) when both parameters are coordinates, and deltaP = p2 if p2 is a point at infinity.
          * If the two segments are collinear, [[0,0,0], Infinity, Infinity] is returned.
          **/
         meetSegmentSegment: function (p1, p2, q1, q2) {
-            var t, u, diff,
+            var t, u, i, d,
                 li1 = Mat.crossProduct(p1, p2),
                 li2 = Mat.crossProduct(q1, q2),
-                c = Mat.crossProduct(li1, li2),
-                denom = c[0];
+                c = Mat.crossProduct(li1, li2);
 
-            if (Math.abs(denom) < Mat.eps) {
+            if (Math.abs(c[0]) < Mat.eps) {
                 return [c, Infinity, Infinity];
             }
 
-            diff = [q1[1] - p1[1], q1[2] - p1[2]];
+            // Normalize the intersection coordinates
+            c[1] /= c[0];
+            c[2] /= c[0];
+            c[0] /= c[0];
 
-            // Because of speed issues, evalute the determinants directly
-            t = (diff[0] * (q2[2] - q1[2]) - diff[1] * (q2[1] - q1[1])) / denom;
-            u = (diff[0] * (p2[2] - p1[2]) - diff[1] * (p2[1] - p1[1])) / denom;
+            // Now compute in principle:
+            //    t = dist(c - p1) / dist(p2 - p1) and
+            //    u = dist(c - q1) / dist(q2 - q1)
+            // However: the points q1, q2, p1, p2 might be ideal points - or in general - the
+            // coordinates might be not normalized.
+            // Note that the z-coordinates of p2 and q2 are used to determine whether it should be interpreted
+            // as a segment coordinate or a direction.
+            i = (Math.abs(p2[1] - p2[0] * p1[1]) < Mat.eps) ? 2 : 1;
+            d = p1[i] / p1[0];
+            t = (c[i] - d) / ( (p2[0] !== 0) ? (p2[i] / p2[0] - d) : p2[i] );
+
+            i = (Math.abs(q2[1] - q2[0] * q1[1]) < Mat.eps) ? 2 : 1;
+            d = q1[i] / q1[0];
+            u = (c[i] - d) / ( (q2[0] !== 0) ? (q2[i] / q2[0] - d) : q2[i] );
 
             return [c, t, u];
         },
@@ -2004,40 +2002,71 @@ define([
          * @returns {Array} The homogeneous coordinates of the nr-th intersection point.
          */
         meetBezierCurveRedBlueSegments: function (red, blue, nr) {
-            var p, i, j,
+            var p, i, j, k, po,
                 redArr, blueArr,
-                bbr, bbb,
-                lenBlue = blue.numberPoints, //points.length,
-                lenRed = red.numberPoints, // points.length,
+                bbr, bbb, intersections,
+                startRed = 0,
+                startBlue = 0,
+                lenBlue = blue.numberPoints,
+                lenRed = red.numberPoints,
                 L = [];
 
-            if (lenBlue < 4 || lenRed < 4) {
+            if (lenBlue < blue.bezierDegree + 1 || lenRed < red.bezierDegree + 1) {
                 return [0, NaN, NaN];
             }
+            lenBlue -= blue.bezierDegree;
+            lenRed  -= red.bezierDegree;
 
-            for (i = 0; i < lenRed - 3; i += 3) {
+            // For sectors, we ignore the "legs"
+            if (red.type === Const.OBJECT_TYPE_SECTOR) {
+                startRed = 3;
+                lenRed  -= 3;
+            }
+            if (blue.type === Const.OBJECT_TYPE_SECTOR) {
+                startBlue = 3;
+                lenBlue  -= 3;
+            }
+
+            for (i = startRed; i < lenRed; i += red.bezierDegree) {
                 p = red.points;
                 redArr = [
-                    [p[i].usrCoords[1], p[i].usrCoords[2]],
-                    [p[i + 1].usrCoords[1], p[i + 1].usrCoords[2]],
-                    [p[i + 2].usrCoords[1], p[i + 2].usrCoords[2]],
-                    [p[i + 3].usrCoords[1], p[i + 3].usrCoords[2]]
+                    p[i].usrCoords.slice(1),
+                    p[i + 1].usrCoords.slice(1)
                 ];
+                if (red.bezierDegree === 3) {
+                    redArr[2] = p[i + 2].usrCoords.slice(1);
+                    redArr[3] = p[i + 3].usrCoords.slice(1);
+                }
 
                 bbr = this._bezierBbox(redArr);
 
-                for (j = 0; j < lenBlue - 3; j += 3) {
+                for (j = startBlue; j < lenBlue; j += blue.bezierDegree) {
                     p = blue.points;
                     blueArr = [
-                        [p[j].usrCoords[1], p[j].usrCoords[2]],
-                        [p[j + 1].usrCoords[1], p[j + 1].usrCoords[2]],
-                        [p[j + 2].usrCoords[1], p[j + 2].usrCoords[2]],
-                        [p[j + 3].usrCoords[1], p[j + 3].usrCoords[2]]
+                        p[j].usrCoords.slice(1),
+                        p[j + 1].usrCoords.slice(1)
                     ];
+                    if (blue.bezierDegree === 3) {
+                        blueArr[2] = p[j + 2].usrCoords.slice(1);
+                        blueArr[3] = p[j + 3].usrCoords.slice(1);
+                    }
 
                     bbb = this._bezierBbox(blueArr);
                     if (this._bezierOverlap(bbr, bbb)) {
-                        L = L.concat(this.meetBeziersegmentBeziersegment(redArr, blueArr));
+                        intersections = this.meetBeziersegmentBeziersegment(redArr, blueArr);
+                        if (intersections.length === 0) {
+                            continue;
+                        }
+                        for (k = 0; k < intersections.length; k++) {
+                            po = intersections[k];
+                            if (po[1] < -Mat.eps ||
+                                po[1] > 1 + Mat.eps ||
+                                po[2] < -Mat.eps ||
+                                po[2] > 1 + Mat.eps) {
+                                continue;
+                            }
+                            L.push(po);
+                        }
                         if (L.length > nr) {
                             return L[nr][0];
                         }