      1 /*
      2     Copyright 2008-2025
      3         Matthias Ehmann,
      4         Michael Gerhaeuser,
      5         Carsten Miller,
      6         Alfred Wassermann
      7
      8     This file is part of JSXGraph.
      9
     10     JSXGraph is free software dual licensed under the GNU LGPL or MIT License.
     11
     12     You can redistribute it and/or modify it under the terms of the
     13
     14       * GNU Lesser General Public License as published by
     15         the Free Software Foundation, either version 3 of the License, or
     16         (at your option) any later version
     17       OR
     18       * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT
     19
     20     JSXGraph is distributed in the hope that it will be useful,
     21     but WITHOUT ANY WARRANTY; without even the implied warranty of
     22     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     23     GNU Lesser General Public License for more details.
     24
     25     You should have received a copy of the GNU Lesser General Public License and
     26     the MIT License along with JSXGraph. If not, see <https://www.gnu.org/licenses/>
     27     and <https://opensource.org/licenses/MIT/>.
     28  */
     29
     30 /*global JXG: true, define: true*/
     31 /*jslint nomen: true, plusplus: true*/
     32
     33 /**
     34  * @fileoverview This file contains the Math.Clip namespace for clipping and computing boolean operations
     35  * on polygons and curves
     36  *
     37  * // TODO:
     38  * * Check if input polygons are closed. If not, handle this case.
     39  */
     40
     41 // import JXG from "../jxg.js";
     42 import Const from "../base/constants.js";
     43 import Coords from "../base/coords.js";
     44 import Mat from "./math.js";
     45 import Geometry from "./geometry.js";
     46 import Type from "../utils/type.js";
     47
     48 /**
     49  * Math.Clip namespace definition. This namespace contains algorithms for Boolean operations on paths, i.e.
     50  * intersection, union and difference of paths. Base is the Greiner-Hormann algorithm.
     51  * @name JXG.Math.Clip
     52  * @exports Mat.Clip as JXG.Math.Clip
     53  * @namespace
     54  */
     55 Mat.Clip = {
     56     _isSeparator: function (node) {
     57         return isNaN(node.coords.usrCoords[1]) && isNaN(node.coords.usrCoords[2]);
     58     },
     59
     60     /**
     61      * Add pointers to an array S such that it is a circular doubly-linked list.
     62      *
     63      * @private
     64      * @param  {Array} S Array
     65      * @return {Array} return containing the starter indices of each component.
     66      */
     67     makeDoublyLinkedList: function (S) {
     68         var i,
     69             first = null,
     70             components = [],
     71             le = S.length;
     72
     73         if (le > 0) {
     74             for (i = 0; i < le; i++) {
     75                 // S[i]._next = S[(i + 1) % le];
     76                 // S[i]._prev = S[(le + i - 1) % le];
     77
     78                 // If S[i] is component separator we proceed with the next node.
     79                 if (this._isSeparator(S[i])) {
     80                     S[i]._next = S[(i + 1) % le];
     81                     S[i]._prev = S[(le + i - 1) % le];
     82                     continue;
     83                 }
     84
     85                 // Now we know that S[i] is a path component
     86                 if (first === null) {
     87                     // Start the component if it is not yet started.
     88                     first = i;
     89                     components.push(first);
     90                 }
     91                 if (this._isSeparator(S[(i + 1) % le]) || i === le - 1) {
     92                     // If the next node is a component separator or if the node is the last node,
     93                     // then we close the loop
     94
     95                     S[i]._next = S[first];
     96                     S[first]._prev = S[i];
     97                     S[i]._end = true;
     98                     first = null;
     99                 } else {
    100                     // Here, we are not at the end of component
    101                     S[i]._next = S[(i + 1) % le];
    102                     S[first]._prev = S[i];
    103                 }
    104                 if (!this._isSeparator(S[(le + i - 1) % le])) {
    105                     S[i]._prev = S[(le + i - 1) % le];
    106                 }
    107             }
    108         }
    109         return components;
    110     },
    111
    112     /**
    113      * JavaScript object containing the intersection of two paths. Every intersection point is on one path, but
    114      * comes with a neighbour point having the same coordinates and being on the other path.
    115      *
    116      * The intersection point is inserted into the doubly linked list of the path.
    117      *
    118      * @private
    119      * @param  {JXG.Coords} coords JSXGraph Coords object containing the coordinates of the intersection
    120      * @param  {Number} i        Number of the segment of the subject path (first path) containing the intersection.
    121      * @param  {Number} alpha    The intersection is a p_1 + alpha*(p_2 - p_1), where p_1 and p_2 are the end points
    122      *      of the i-th segment.
    123      * @param  {Array} path      Pointer to the path containing the intersection point
    124      * @param  {String} pathname Name of the path: 'S' or 'C'.
    125      */
    126     Vertex: function (coords, i, alpha, path, pathname, type) {
    127         this.pos = i;
    128         this.intersection = true;
    129         this.coords = coords;
    130         this.elementClass = Const.OBJECT_CLASS_POINT;
    131
    132         this.data = {
    133             alpha: alpha,
    134             path: path,
    135             pathname: pathname,
    136             done: false,
    137             type: type,
    138             idx: 0
    139         };
    140
    141         // Set after initialisation
    142         this.neighbour = null;
    143         this.entry_exit = false;
    144     },
    145
    146     _addToList: function (list, coords, pos) {
    147         var len = list.length,
    148             eps = Mat.eps * Mat.eps;
    149
    150         if (
    151             len > 0 &&
    152             Math.abs(list[len - 1].coords.usrCoords[0] - coords.usrCoords[0]) < eps &&
    153             Math.abs(list[len - 1].coords.usrCoords[1] - coords.usrCoords[1]) < eps &&
    154             Math.abs(list[len - 1].coords.usrCoords[2] - coords.usrCoords[2]) < eps
    155         ) {
    156             // Skip point
    157             return;
    158         }
    159         list.push({
    160             pos: pos,
    161             intersection: false,
    162             coords: coords,
    163             elementClass: Const.OBJECT_CLASS_POINT
    164         });
    165     },
    166
    167     /**
    168      * Sort the intersection points into their path.
    169      * @private
    170      * @param  {Array} P_crossings Array of arrays. Each array contains the intersections of the path
    171      *      with one segment of the other path.
    172      * @return {Array}  Array of intersection points ordered by first occurrence in the path.
    173      */
    174     sortIntersections: function (P_crossings) {
    175         var i,
    176             j,
    177             P,
    178             Q,
    179             last,
    180             next_node,
    181             P_intersect = [],
    182             P_le = P_crossings.length;
    183
    184         for (i = 0; i < P_le; i++) {
    185             P_crossings[i].sort(function (a, b) {
    186                 return a.data.alpha > b.data.alpha ? 1 : -1;
    187             });
    188
    189             if (P_crossings[i].length > 0) {
    190                 // console.log("Crossings", P_crossings[i])
    191                 last = P_crossings[i].length - 1;
    192                 P = P_crossings[i][0];
    193
    194                 //console.log("SORT", P.coords.usrCoords)
    195                 Q = P.data.path[P.pos];
    196                 next_node = Q._next; // Store the next "normal" node
    197
    198                 if (i === P_le - 1) {
    199                     Q._end = false;
    200                 }
    201
    202                 if (P.data.alpha === 0.0 && P.data.type === "T") {
    203                     // console.log("SKIP", P.coords.usrCoords, P.data.type, P.neighbour.data.type);
    204                     Q.intersection = true;
    205                     Q.data = P.data;
    206                     Q.neighbour = P.neighbour;
    207                     Q.neighbour.neighbour = Q;
    208                     Q.entry_exit = false;
    209                     P_crossings[i][0] = Q;
    210                 } else {
    211                     // Insert the first intersection point
    212                     P._prev = Q;
    213                     P._prev._next = P;
    214                 }
    215
    216                 // Insert the other intersection points, but the last
    217                 for (j = 1; j <= last; j++) {
    218                     P = P_crossings[i][j];
    219                     P._prev = P_crossings[i][j - 1];
    220                     P._prev._next = P;
    221                 }
    222
    223                 // Link last intersection point to the next node
    224                 P = P_crossings[i][last];
    225                 P._next = next_node;
    226                 P._next._prev = P;
    227
    228                 if (i === P_le - 1) {
    229                     P._end = true;
    230                     //console.log("END", P._end, P.coords.usrCoords, P._prev.coords.usrCoords, P._next.coords.usrCoords);
    231                 }
    232
    233                 P_intersect = P_intersect.concat(P_crossings[i]);
    234             }
    235         }
    236         return P_intersect;
    237     },
    238
    239     _inbetween: function (q, p1, p2) {
    240         var alpha,
    241             eps = Mat.eps * Mat.eps,
    242             px = p2[1] - p1[1],
    243             py = p2[2] - p1[2],
    244             qx = q[1] - p1[1],
    245             qy = q[2] - p1[2];
    246
    247         if (px === 0 && py === 0 && qx === 0 && qy === 0) {
    248             // All three points are equal
    249             return true;
    250         }
    251         if (Math.abs(qx) < eps && Math.abs(px) < eps) {
    252             alpha = qy / py;
    253         } else {
    254             alpha = qx / px;
    255         }
    256         if (Math.abs(alpha) < eps) {
    257             alpha = 0.0;
    258         }
    259         return alpha;
    260     },
    261
    262     _print_array: function (arr) {
    263         var i, end;
    264         for (i = 0; i < arr.length; i++) {
    265             //console.log(i, arr[i].coords.usrCoords,  arr[i].data.type);
    266             try {
    267                 end = "";
    268                 if (arr[i]._end) {
    269                     end = " end";
    270                 }
    271                 console.log(
    272                     i,
    273                     arr[i].coords.usrCoords,
    274                     arr[i].data.type,
    275                     "\t",
    276                     "prev",
    277                     arr[i]._prev.coords.usrCoords,
    278                     "next",
    279                     arr[i]._next.coords.usrCoords + end
    280                 );
    281             } catch (e) {
    282                 console.log(i, arr[i].coords.usrCoords);
    283             }
    284         }
    285     },
    286
    287     _print_list: function (P) {
    288         var cnt = 0,
    289             alpha;
    290         while (cnt < 100) {
    291             if (P.data) {
    292                 alpha = P.data.alpha;
    293             } else {
    294                 alpha = "-";
    295             }
    296             console.log(
    297                 "\t",
    298                 P.coords.usrCoords,
    299                 "\n\t\tis:",
    300                 P.intersection,
    301                 "end:",
    302                 P._end,
    303                 alpha,
    304                 "\n\t\t-:",
    305                 P._prev.coords.usrCoords,
    306                 "\n\t\t+:",
    307                 P._next.coords.usrCoords,
    308                 "\n\t\tn:",
    309                 P.intersection ? P.neighbour.coords.usrCoords : "-"
    310             );
    311             if (P._end) {
    312                 break;
    313             }
    314             P = P._next;
    315             cnt++;
    316         }
    317     },
    318
    319     _noOverlap: function (p1, p2, q1, q2) {
    320         var k,
    321             eps = Math.sqrt(Mat.eps),
    322             minp,
    323             maxp,
    324             minq,
    325             maxq,
    326             no_overlap = false;
    327
    328         for (k = 0; k < 3; k++) {
    329             minp = Math.min(p1[k], p2[k]);
    330             maxp = Math.max(p1[k], p2[k]);
    331             minq = Math.min(q1[k], q2[k]);
    332             maxq = Math.max(q1[k], q2[k]);
    333             if (maxp < minq - eps || minp > maxq + eps) {
    334                 no_overlap = true;
    335                 break;
    336             }
    337         }
    338         return no_overlap;
    339     },
    340
    341     /**
    342      * Find all intersections between two paths.
    343      * @private
    344      * @param  {Array} S     Subject path
    345      * @param  {Array} C     Clip path
    346      * @param  {JXG.Board} board JSXGraph board object. It is needed to convert between
    347      * user coordinates and screen coordinates.
    348      * @return {Array}  Array containing two arrays. The first array contains the intersection vertices
    349      * of the subject path and the second array contains the intersection vertices of the clip path.
    350      * @see JXG.Math.Clip.Vertex
    351      */
    352     findIntersections: function (S, C, board) {
    353         var res = [], eps = Mat.eps * 100,
    354             i, j, crds,
    355             S_le = S.length,
    356             C_le = C.length,
    357             Si, Si1, Cj, Cj1, d1, d2,
    358             alpha, type, IS, IC,
    359             S_intersect = [],
    360             C_intersect = [],
    361             S_crossings = [],
    362             C_crossings = [],
    363             hasMultCompsS = false,
    364             hasMultCompsC = false,
    365             DEBUG = false;
    366
    367         for (j = 0; j < C_le; j++) {
    368             C_crossings.push([]);
    369         }
    370
    371         // Run through the subject path.
    372         for (i = 0; i < S_le; i++) {
    373             S_crossings.push([]);
    374
    375             // Test if S[i] or its successor is a path separator.
    376             // If yes, we know that the path consists of multiple components.
    377             // We immediately jump to the next segment.
    378             if (this._isSeparator(S[i]) || this._isSeparator(S[(i + 1) % S_le])) {
    379                 hasMultCompsS = true;
    380                 continue;
    381             }
    382
    383             // If the path consists of multiple components then there is
    384             // no path-closing segment between the last node and the first
    385             // node. In this case we can leave the loop now.
    386             if (hasMultCompsS && i === S_le - 1) {
    387                 break;
    388             }
    389
    390             Si = S[i].coords.usrCoords;
    391             Si1 = S[(i + 1) % S_le].coords.usrCoords;
    392             // Run through the clip path.
    393             for (j = 0; j < C_le; j++) {
    394                 // Test if C[j] or its successor is a path separator.
    395                 // If yes, we know that the path consists of multiple components.
    396                 // We immediately jump to the next segment.
    397                 if (this._isSeparator(C[j]) || this._isSeparator(C[(j + 1) % C_le])) {
    398                     hasMultCompsC = true;
    399                     continue;
    400                 }
    401
    402                 // If the path consists of multiple components then there is
    403                 // no path-closing segment between the last node and the first
    404                 // node. In this case we can leave the loop now.
    405                 if (hasMultCompsC && j === C_le - 1) {
    406                     break;
    407                 }
    408
    409                 // Test if bounding boxes of the two curve segments overlap
    410                 // If not, the expensive intersection test can be skipped.
    411                 Cj = C[j].coords.usrCoords;
    412                 Cj1 = C[(j + 1) % C_le].coords.usrCoords;
    413
    414                 if (this._noOverlap(Si, Si1, Cj, Cj1)) {
    415                     continue;
    416                 }
    417
    418                 // Intersection test
    419                 res = Geometry.meetSegmentSegment(Si, Si1, Cj, Cj1);
    420
    421                 d1 = Geometry.distance(Si, Si1, 3);
    422                 d2 = Geometry.distance(Cj, Cj1, 3);
    423
    424                 // Found an intersection point
    425                 if (
    426                     // "Regular" intersection
    427                     (res[1] * d1 > -eps &&
    428                         res[1] < 1 - eps / d1 &&
    429                         res[2] * d2 > -eps &&
    430                         res[2] < 1 - eps / d2) ||
    431                     // Collinear segments
    432                     (res[1] === Infinity && res[2] === Infinity && Mat.norm(res[0], 3) < eps)
    433                 ) {
    434                     crds = new Coords(Const.COORDS_BY_USER, res[0], board);
    435                     type = "X";
    436
    437                     // Handle degenerated cases
    438                     if (Math.abs(res[1]) * d1 < eps || Math.abs(res[2]) * d2 < eps) {
    439                         // Crossing / bouncing at vertex or
    440                         // end of delayed crossing / bouncing
    441                         type = "T";
    442                         if (Math.abs(res[1]) * d1 < eps) {
    443                             res[1] = 0;
    444                         }
    445                         if (Math.abs(res[2]) * d2 < eps) {
    446                             res[2] = 0;
    447                         }
    448                         if (res[1] === 0) {
    449                             crds = new Coords(Const.COORDS_BY_USER, Si, board);
    450                         } else {
    451                             crds = new Coords(Const.COORDS_BY_USER, Cj, board);
    452                         }
    453
    454                         if (DEBUG) {
    455                             console.log(
    456                                 "Degenerate case I",
    457                                 res[1],
    458                                 res[2],
    459                                 crds.usrCoords,
    460                                 "type",
    461                                 type
    462                             );
    463                         }
    464                     } else if (
    465                         res[1] === Infinity &&
    466                         res[2] === Infinity &&
    467                         Mat.norm(res[0], 3) < eps
    468                     ) {
    469                         // console.log(C_intersect);
    470
    471                         // Collinear segments
    472                         // Here, there might be two intersection points to be added
    473
    474                         alpha = this._inbetween(Si, Cj, Cj1);
    475                         if (DEBUG) {
    476                             // console.log("alpha Si", alpha, Si);
    477                             // console.log(j, Cj)
    478                             // console.log((j + 1) % C_le, Cj1)
    479                         }
    480                         if (alpha >= 0 && alpha < 1) {
    481                             type = "T";
    482                             crds = new Coords(Const.COORDS_BY_USER, Si, board);
    483                             res[1] = 0;
    484                             res[2] = alpha;
    485                             IS = new this.Vertex(crds, i, res[1], S, "S", type);
    486                             IC = new this.Vertex(crds, j, res[2], C, "C", type);
    487                             IS.neighbour = IC;
    488                             IC.neighbour = IS;
    489                             S_crossings[i].push(IS);
    490                             C_crossings[j].push(IC);
    491                             if (DEBUG) {
    492                                 console.log(
    493                                     "Degenerate case II",
    494                                     res[1],
    495                                     res[2],
    496                                     crds.usrCoords,
    497                                     "type T"
    498                                 );
    499                             }
    500                         }
    501                         alpha = this._inbetween(Cj, Si, Si1);
    502                         if (DEBUG) {
    503                             // console.log("alpha Cj", alpha, Si, Geometry.distance(Si, Cj, 3));
    504                         }
    505                         if (Geometry.distance(Si, Cj, 3) > eps && alpha >= 0 && alpha < 1) {
    506                             type = "T";
    507                             crds = new Coords(Const.COORDS_BY_USER, Cj, board);
    508                             res[1] = alpha;
    509                             res[2] = 0;
    510                             IS = new this.Vertex(crds, i, res[1], S, "S", type);
    511                             IC = new this.Vertex(crds, j, res[2], C, "C", type);
    512                             IS.neighbour = IC;
    513                             IC.neighbour = IS;
    514                             S_crossings[i].push(IS);
    515                             C_crossings[j].push(IC);
    516                             if (DEBUG) {
    517                                 console.log(
    518                                     "Degenerate case III",
    519                                     res[1],
    520                                     res[2],
    521                                     crds.usrCoords,
    522                                     "type T"
    523                                 );
    524                             }
    525                         }
    526                         continue;
    527                     }
    528                     if (DEBUG) {
    529                         console.log("IS", i, j, crds.usrCoords, type);
    530                     }
    531
    532                     IS = new this.Vertex(crds, i, res[1], S, "S", type);
    533                     IC = new this.Vertex(crds, j, res[2], C, "C", type);
    534                     IS.neighbour = IC;
    535                     IC.neighbour = IS;
    536
    537                     S_crossings[i].push(IS);
    538                     C_crossings[j].push(IC);
    539                 }
    540             }
    541         }
    542
    543         // For both paths, sort their intersection points
    544         S_intersect = this.sortIntersections(S_crossings);
    545
    546         if (DEBUG) {
    547             console.log(">>>>>> Intersections ");
    548             console.log("S_intersect");
    549             this._print_array(S_intersect);
    550             console.log("----------");
    551         }
    552         for (i = 0; i < S_intersect.length; i++) {
    553             S_intersect[i].data.idx = i;
    554             S_intersect[i].neighbour.data.idx = i;
    555         }
    556         C_intersect = this.sortIntersections(C_crossings);
    557
    558         if (DEBUG) {
    559             console.log("C_intersect");
    560             this._print_array(C_intersect);
    561             console.log("<<<<<< Phase 1 done");
    562         }
    563         return [S_intersect, C_intersect];
    564     },
    565
    566     /**
    567      * It is testedd if the point q lies to the left or right
    568      * of the poylgonal chain [p1, p2, p3].
    569      * @param {Array} q User coords array
    570      * @param {Array} p1 User coords array
    571      * @param {Array} p2 User coords array
    572      * @param {Array} p3 User coords array
    573      * @returns string 'left' or 'right'
    574      * @private
    575      */
    576     _getPosition: function (q, p1, p2, p3) {
    577         var s1 = Geometry.det3p(q, p1, p2),
    578             s2 = Geometry.det3p(q, p2, p3),
    579             s3 = Geometry.det3p(p1, p2, p3);
    580
    581         // Left turn
    582         if (s3 >= 0) {
    583             if (s1 >= 0 && s2 >= 0) {
    584                 return "left";
    585             }
    586             return "right";
    587         }
    588         // Right turn
    589         if (s1 >= 0 || s2 >= 0) {
    590             return "left";
    591         }
    592         return "right";
    593     },
    594
    595     /**
    596      * Determine the delayed status of degenerated intersection points.
    597      * It is of the form
    598      *   ['on|left|right', 'on|left|right']
    599      * <p>
    600      * If all four determinants are zero, we add random noise to the point.
    601      *
    602      * @param {JXG.Math.Clip.Vertex} P Start of path
    603      * @private
    604      * @see JXG.Math.Clip.markEntryExit
    605      * @see JXG.Math.Clip._handleIntersectionChains
    606      */
    607     _classifyDegenerateIntersections: function (P) {
    608         var Pp, Pm, Qp, Qm,  Q,
    609             side, cnt, tmp, det,
    610             oppositeDir,
    611             s1, s2, s3, s4,
    612             endless = true,
    613             DEBUG = false;
    614
    615         if (DEBUG) {
    616             console.log(
    617                 "\n-------------- _classifyDegenerateIntersections()",
    618                 Type.exists(P.data) ? P.data.pathname : " "
    619             );
    620         }
    621         det = Geometry.det3p;
    622         cnt = 0;
    623         P._tours = 0;
    624         while (endless) {
    625             if (DEBUG) {
    626                 console.log("Inspect P:", P.coords.usrCoords, P.data ? P.data.type : " ");
    627             }
    628             if (P.intersection && P.data.type === "T") {
    629                 // Handle the degenerate cases
    630                 // Decide if they are (delayed) bouncing or crossing intersections
    631                 Pp = P._next.coords.usrCoords; // P+
    632                 Pm = P._prev.coords.usrCoords; // P-
    633
    634                 // If the intersection point is degenerated and
    635                 // equal to the start and end of one component,
    636                 // then there will be two adjacent points with
    637                 // the same coordinate.
    638                 // In that case, we proceed to the next node.
    639                 if (Geometry.distance(P.coords.usrCoords, Pp, 3) < Mat.eps) {
    640                     Pp = P._next._next.coords.usrCoords;
    641                 }
    642                 if (Geometry.distance(P.coords.usrCoords, Pm, 3) < Mat.eps) {
    643                     Pm = P._prev._prev.coords.usrCoords;
    644                 }
    645
    646                 Q = P.neighbour;
    647                 Qm = Q._prev.coords.usrCoords; // Q-
    648                 Qp = Q._next.coords.usrCoords; // Q+
    649                 if (Geometry.distance(Q.coords.usrCoords, Qp, 3) < Mat.eps) {
    650                     Qp = Q._next._next.coords.usrCoords;
    651                 }
    652                 if (Geometry.distance(Q.coords.usrCoords, Qm, 3) < Mat.eps) {
    653                     Qm = Q._prev._prev.coords.usrCoords;
    654                 }
    655
    656                 if (DEBUG) {
    657                     console.log("P chain:", Pm, P.coords.usrCoords, Pp);
    658                     console.log("Q chain:", Qm, P.neighbour.coords.usrCoords, Qp);
    659                     console.log("Pm", this._getPosition(Pm, Qm, Q.coords.usrCoords, Qp));
    660                     console.log("Pp", this._getPosition(Pp, Qm, Q.coords.usrCoords, Qp));
    661                 }
    662
    663                 s1 = det(P.coords.usrCoords, Pm, Qm);
    664                 s2 = det(P.coords.usrCoords, Pp, Qp);
    665                 s3 = det(P.coords.usrCoords, Pm, Qp);
    666                 s4 = det(P.coords.usrCoords, Pp, Qm);
    667
    668                 if (s1 === 0 && s2 === 0 && s3 === 0 && s4 === 0) {
    669                     P.coords.usrCoords[1] *= 1 + Math.random() * Mat.eps;
    670                     P.coords.usrCoords[2] *= 1 + Math.random() * Mat.eps;
    671                     Q.coords.usrCoords[1] = P.coords.usrCoords[1];
    672                     Q.coords.usrCoords[2] = P.coords.usrCoords[2];
    673                     s1 = det(P.coords.usrCoords, Pm, Qm);
    674                     s2 = det(P.coords.usrCoords, Pp, Qp);
    675                     s3 = det(P.coords.usrCoords, Pm, Qp);
    676                     s4 = det(P.coords.usrCoords, Pp, Qm);
    677                     if (DEBUG) {
    678                         console.log("Random shift", P.coords.usrCoords);
    679                         console.log(s1, s2, s3, s4, s2 === 0);
    680                         console.log(
    681                             this._getPosition(Pm, Qm, Q.coords.usrCoords, Qp),
    682                             this._getPosition(Pp, Qm, Q.coords.usrCoords, Qp)
    683                         );
    684                     }
    685                 }
    686                 oppositeDir = false;
    687                 if (s1 === 0) {
    688                     // Q-, Q=P, P- on straight line
    689                     if (Geometry.affineRatio(P.coords.usrCoords, Pm, Qm) < 0) {
    690                         oppositeDir = true;
    691                     }
    692                 } else if (s2 === 0) {
    693                     if (Geometry.affineRatio(P.coords.usrCoords, Pp, Qp) < 0) {
    694                         oppositeDir = true;
    695                     }
    696                 } else if (s3 === 0) {
    697                     if (Geometry.affineRatio(P.coords.usrCoords, Pm, Qp) > 0) {
    698                         oppositeDir = true;
    699                     }
    700                 } else if (s4 === 0) {
    701                     if (Geometry.affineRatio(P.coords.usrCoords, Pp, Qm) > 0) {
    702                         oppositeDir = true;
    703                     }
    704                 }
    705                 if (oppositeDir) {
    706                     // Swap Qm and Qp
    707                     // Then Qm Q Qp has the same direction as Pm P Pp
    708                     tmp = Qm;
    709                     Qm = Qp;
    710                     Qp = tmp;
    711                     tmp = s1;
    712                     s1 = s3;
    713                     s3 = tmp;
    714                     tmp = s2;
    715                     s2 = s4;
    716                     s4 = tmp;
    717                 }
    718
    719                 if (DEBUG) {
    720                     console.log(s1, s2, s3, s4, oppositeDir);
    721                 }
    722
    723                 if (!Type.exists(P.delayedStatus)) {
    724                     P.delayedStatus = [];
    725                 }
    726
    727                 if (s1 === 0 && s2 === 0) {
    728                     // Line [P-,P] equals [Q-,Q] and line [P,P+] equals [Q,Q+]
    729                     // Interior of delayed crossing / bouncing
    730                     P.delayedStatus = ["on", "on"];
    731                 } else if (s1 === 0) {
    732                     // P- on line [Q-,Q], P+ not on line [Q,Q+]
    733                     // Begin / end of delayed crossing / bouncing
    734                     side = this._getPosition(Pp, Qm, Q.coords.usrCoords, Qp);
    735                     P.delayedStatus = ["on", side];
    736                 } else if (s2 === 0) {
    737                     // P+ on line [Q,Q+], P- not on line [Q-,Q]
    738                     // Begin / end of delayed crossing / bouncing
    739                     side = this._getPosition(Pm, Qm, Q.coords.usrCoords, Qp);
    740                     P.delayedStatus = [side, "on"];
    741                 } else {
    742                     // Neither P+ on line [Q,Q+], nor P- on line [Q-,Q]
    743                     // No delayed crossing / bouncing
    744                     if (P.delayedStatus.length === 0) {
    745                         if (
    746                             this._getPosition(Pm, Qm, Q.coords.usrCoords, Qp) !==
    747                             this._getPosition(Pp, Qm, Q.coords.usrCoords, Qp)
    748                         ) {
    749                             P.data.type = "X";
    750                         } else {
    751                             P.data.type = "B";
    752                         }
    753                     }
    754                 }
    755
    756                 if (DEBUG) {
    757                     console.log(
    758                         ">>>> P:",
    759                         P.coords.usrCoords,
    760                         "delayedStatus:",
    761                         P.delayedStatus.toString(),
    762                         P.data ? P.data.type : " ",
    763                         "\n---"
    764                     );
    765                 }
    766             }
    767
    768             if (Type.exists(P._tours)) {
    769                 P._tours++;
    770             }
    771
    772             if (P._tours > 3 || P._end || cnt > 1000) {
    773                 // Jump out if either
    774                 // - we reached the end
    775                 // - there are more than 1000 intersection points
    776                 // - P._tours > 3: We went already 4 times through this path.
    777                 if (cnt > 1000) {
    778                     console.log("Clipping: _classifyDegenerateIntersections exit");
    779                 }
    780                 if (Type.exists(P._tours)) {
    781                     delete P._tours;
    782                 }
    783                 break;
    784             }
    785             if (P.intersection) {
    786                 cnt++;
    787             }
    788             P = P._next;
    789         }
    790         if (DEBUG) {
    791             console.log("------------------------");
    792         }
    793     },
    794
    795     /**
    796      * At this point the degenerated intersections have been classified.
    797      * Now we decide if the intersection chains of the given path
    798      * ultimatively cross the other path or bounce.
    799      *
    800      * @param {JXG.Math.Clip.Vertex} P Start of path
    801      *
    802      * @see JXG.Math.Clip.markEntryExit
    803      * @see JXG.Math.Clip._classifyDegenerateIntersections
    804      * @private
    805      */
    806     _handleIntersectionChains: function (P) {
    807         var cnt = 0,
    808             start_status = "Null",
    809             P_start,
    810             endless = true,
    811             intersection_chain = false,
    812             wait_for_exit = false,
    813             DEBUG = false;
    814
    815         if (DEBUG) {
    816             console.log(
    817                 "\n-------------- _handleIntersectionChains()",
    818                 Type.exists(P.data) ? P.data.pathname : " "
    819             );
    820         }
    821         while (endless) {
    822             if (P.intersection === true) {
    823                 if (DEBUG) {
    824                     if (P.data.type === "T") {
    825                         console.log(
    826                             "Degenerate point",
    827                             P.coords.usrCoords,
    828                             P.data.type,
    829                             P.data.type === "T" ? P.delayedStatus : " "
    830                         );
    831                     } else {
    832                         console.log("Intersection point", P.coords.usrCoords, P.data.type);
    833                     }
    834                 }
    835                 if (P.data.type === "T") {
    836                     if (P.delayedStatus[0] !== "on" && P.delayedStatus[1] === "on") {
    837                         // First point of intersection chain
    838                         intersection_chain = true;
    839                         P_start = P;
    840                         start_status = P.delayedStatus[0];
    841                     } else if (
    842                         intersection_chain &&
    843                         P.delayedStatus[0] === "on" &&
    844                         P.delayedStatus[1] === "on"
    845                     ) {
    846                         // Interior of intersection chain
    847                         P.data.type = "B";
    848                         if (DEBUG) {
    849                             console.log("Interior", P.coords.usrCoords);
    850                         }
    851                     } else if (
    852                         intersection_chain &&
    853                         P.delayedStatus[0] === "on" &&
    854                         P.delayedStatus[1] !== "on"
    855                     ) {
    856                         // Last point of intersection chain
    857                         intersection_chain = false;
    858                         if (start_status === P.delayedStatus[1]) {
    859                             // Intersection chain is delayed bouncing
    860                             P_start.data.type = "DB";
    861                             P.data.type = "DB";
    862                             if (DEBUG) {
    863                                 console.log(
    864                                     "Chain: delayed bouncing",
    865                                     P_start.coords.usrCoords,
    866                                     "...",
    867                                     P.coords.usrCoords
    868                                 );
    869                             }
    870                         } else {
    871                             // Intersection chain is delayed crossing
    872                             P_start.data.type = "DX";
    873                             P.data.type = "DX";
    874                             if (DEBUG) {
    875                                 console.log(
    876                                     "Chain: delayed crossing",
    877                                     P_start.coords.usrCoords,
    878                                     "...",
    879                                     P.coords.usrCoords
    880                                 );
    881                             }
    882                         }
    883                     }
    884                 }
    885                 cnt++;
    886             }
    887             if (P._end) {
    888                 wait_for_exit = true;
    889             }
    890             if (wait_for_exit && !intersection_chain) {
    891                 break;
    892             }
    893             if (cnt > 1000) {
    894                 console.log(
    895                     "Warning: _handleIntersectionChains: intersection chain reached maximum numbers of iterations"
    896                 );
    897                 break;
    898             }
    899             P = P._next;
    900         }
    901     },
    902
    903     /**
    904      * Handle the case that all vertices of one path are contained
    905      * in the other path. In this case we search for a midpoint of an edge
    906      * which is not contained in the other path and add it to the path.
    907      * It will be used as starting point for the entry/exit algorithm.
    908      *
    909      * @private
    910      * @param {Array} S Subject path
    911      * @param {Array} C Clip path
    912      * @param {JXG.board} board JSXGraph board object. It is needed to convert between
    913      * user coordinates and screen coordinates.
    914      */
    915     _handleFullyDegenerateCase: function (S, C, board) {
    916         var P, Q, l, M, crds,
    917             q1, q2, node, i, j,
    918             leP, leQ, is_on_Q,
    919             tmp, is_fully_degenerated,
    920             arr = [S, C];
    921
    922         for (l = 0; l < 2; l++) {
    923             P = arr[l];
    924             leP = P.length;
    925             for (i = 0, is_fully_degenerated = true; i < leP; i++) {
    926                 if (!P[i].intersection) {
    927                     is_fully_degenerated = false;
    928                     break;
    929                 }
    930             }
    931
    932             if (is_fully_degenerated) {
    933                 // All nodes of P are also on the other path.
    934                 Q = arr[(l + 1) % 2];
    935                 leQ = Q.length;
    936
    937                 // We search for a midpoint of one edge of P which is not the other path and
    938                 // we add that midpoint to P.
    939                 for (i = 0; i < leP; i++) {
    940                     q1 = P[i].coords.usrCoords;
    941                     q2 = P[i]._next.coords.usrCoords;
    942
    943                     // M is the midpoint
    944                     M = [(q1[0] + q2[0]) * 0.5, (q1[1] + q2[1]) * 0.5, (q1[2] + q2[2]) * 0.5];
    945
    946                     // Test if M is on path Q. If this is not the case,
    947                     // we take M as additional point of P.
    948                     for (j = 0, is_on_Q = false; j < leQ; j++) {
    949                         if (
    950                             Math.abs(
    951                                 Geometry.det3p(
    952                                     Q[j].coords.usrCoords,
    953                                     Q[(j + 1) % leQ].coords.usrCoords,
    954                                     M
    955                                 )
    956                             ) < Mat.eps
    957                         ) {
    958                             is_on_Q = true;
    959                             break;
    960                         }
    961                     }
    962                     if (!is_on_Q) {
    963                         // The midpoint is added to the doubly-linked list.
    964                         crds = new Coords(Const.COORDS_BY_USER, M, board);
    965                         node = {
    966                             pos: i,
    967                             intersection: false,
    968                             coords: crds,
    969                             elementClass: Const.OBJECT_CLASS_POINT
    970                         };
    971
    972                         tmp = P[i]._next;
    973                         P[i]._next = node;
    974                         node._prev = P[i];
    975                         node._next = tmp;
    976                         tmp._prev = node;
    977
    978                         if (P[i]._end) {
    979                             P[i]._end = false;
    980                             node._end = true;
    981                         }
    982
    983                         break;
    984                     }
    985                 }
    986             }
    987         }
    988     },
    989
    990     _getStatus: function (P, path) {
    991         var status;
    992         while (P.intersection) {
    993             if (P._end) {
    994                 break;
    995             }
    996             P = P._next;
    997         }
    998         if (Geometry.windingNumber(P.coords.usrCoords, path) === 0) {
    999             // Outside
    1000             status = "entry";
    1001             // console.log(P.coords.usrCoords, ' is outside')
    1002         } else {
    1003             // Inside
    1004             status = "exit";
    1005             // console.log(P.coords.usrCoords, ' is inside')
    1006         }
    1007
    1008         return [P, status];
    1009     },
    1010
    1011     /**
    1012      * Mark the intersection vertices of path1 as entry points or as exit points
    1013      * in respect to path2.
    1014      * <p>
    1015      * This is the simple algorithm as in
    1016      * Greiner, Günther; Kai Hormann (1998). "Efficient clipping of arbitrary polygons".
    1017      * ACM Transactions on Graphics. 17 (2): 71–83
    1018      * <p>
    1019      * The algorithm handles also "delayed crossings" from
    1020      * Erich, L. Foster, and Kai Hormann, Kai, and Romeo Traaian Popa (2019),
    1021      * "Clipping simple polygons with degenerate intersections", Computers & Graphics:X, 2.
    1022      * and - as an additional improvement -
    1023      * handles self intersections of delayed crossings (A.W. 2021).
    1024      *
    1025      * @private
    1026      * @param  {Array} path1 First path
    1027      * @param  {Array} path2 Second path
    1028      */
    1029     markEntryExit: function (path1, path2, starters) {
    1030         var status, P, cnt, res,
    1031             i, len, start,
    1032             endless = true,
    1033             chain_start = null,
    1034             intersection_chain = 0,
    1035             DEBUG = false;
    1036
    1037         len = starters.length;
    1038         for (i = 0; i < len; i++) {
    1039             start = starters[i];
    1040             if (DEBUG) {
    1041                 console.log(
    1042                     "\n;;;;;;;;;; Labelling phase",
    1043                     Type.exists(path1[start].data) ? path1[start].data.pathname : " ",
    1044                     path1[start].coords.usrCoords
    1045                 );
    1046             }
    1047             this._classifyDegenerateIntersections(path1[start]);
    1048             this._handleIntersectionChains(path1[start]);
    1049             if (DEBUG) {
    1050                 console.log("\n---- back to markEntryExit");
    1051             }
    1052
    1053             // Decide if the first point of the component is inside or outside
    1054             // of the other path.
    1055             res = this._getStatus(path1[start], path2);
    1056             P = res[0];
    1057             status = res[1];
    1058             if (DEBUG) {
    1059                 console.log("Start node:", P.coords.usrCoords, status);
    1060             }
    1061
    1062             P._starter = true;
    1063
    1064             // Greiner-Hormann entry/exit algorithm
    1065             // with additional handling of delayed crossing / bouncing
    1066             cnt = 0;
    1067             chain_start = null;
    1068             intersection_chain = 0;
    1069
    1070             while (endless) {
    1071                 if (P.intersection === true) {
    1072                     if (P.data.type === "X" && intersection_chain === 1) {
    1073                         // While we are in an intersection chain, i.e. a delayed crossing,
    1074                         // we stumble on a crossing intersection.
    1075                         // Probably, the other path is self intersecting.
    1076                         // We end the intersection chain here and
    1077                         // mark this event by setting intersection_chain = 2.
    1078                         chain_start.entry_exit = status;
    1079                         if (status === "exit") {
    1080                             chain_start.data.type = "X";
    1081                         }
    1082                         intersection_chain = 2;
    1083                     }
    1084
    1085                     if (P.data.type === "X" || P.data.type === "DB") {
    1086                         P.entry_exit = status;
    1087                         status = status === "entry" ? "exit" : "entry";
    1088                         if (DEBUG) {
    1089                             console.log("mark:", P.coords.usrCoords, P.data.type, P.entry_exit);
    1090                         }
    1091                     }
    1092
    1093                     if (P.data.type === "DX") {
    1094                         if (intersection_chain === 0) {
    1095                             // Start of intersection chain.
    1096                             // No active intersection chain yet,
    1097                             // i.e. we did not pass a the first node of a delayed crossing.
    1098                             chain_start = P;
    1099                             intersection_chain = 1;
    1100                             if (DEBUG) {
    1101                                 console.log(
    1102                                     "Start intersection chain:",
    1103                                     P.coords.usrCoords,
    1104                                     P.data.type,
    1105                                     status
    1106                                 );
    1107                             }
    1108                         } else if (intersection_chain === 1) {
    1109                             // Active intersection chain (intersection_chain===1)!
    1110                             // End of delayed crossing chain reached
    1111                             P.entry_exit = status;
    1112                             chain_start.entry_exit = status;
    1113                             if (status === "exit") {
    1114                                 chain_start.data.type = "X";
    1115                             } else {
    1116                                 P.data.type = "X";
    1117                             }
    1118                             status = status === "entry" ? "exit" : "entry";
    1119
    1120                             if (DEBUG) {
    1121                                 console.log(
    1122                                     "mark':",
    1123                                     chain_start.coords.usrCoords,
    1124                                     chain_start.data.type,
    1125                                     chain_start.entry_exit
    1126                                 );
    1127                                 console.log(
    1128                                     "mark:",
    1129                                     P.coords.usrCoords,
    1130                                     P.data.type,
    1131                                     P.entry_exit
    1132                                 );
    1133                             }
    1134                             chain_start = null;
    1135                             intersection_chain = 0;
    1136                         } else if (intersection_chain === 2) {
    1137                             // The delayed crossing had been interrupted by a crossing intersection.
    1138                             // Now we treat the end of the delayed crossing as regular crossing.
    1139                             P.entry_exit = status;
    1140                             P.data.type = "X";
    1141                             status = status === "entry" ? "exit" : "entry";
    1142                             chain_start = null;
    1143                             intersection_chain = 0;
    1144                         }
    1145                     }
    1146                 }
    1147
    1148                 P = P._next;
    1149                 if (Type.exists(P._starter) || cnt > 10000) {
    1150                     break;
    1151                 }
    1152
    1153                 cnt++;
    1154             }
    1155         }
    1156     },
    1157
    1158     /**
    1159      *
    1160      * @private
    1161      * @param {Array} P
    1162      * @param {Boolean} isBackward
    1163      * @returns {Boolean} True, if the node is an intersection and is of type 'X'
    1164      */
    1165     _stayOnPath: function (P, status) {
    1166         var stay = true;
    1167
    1168         if (P.intersection && P.data.type !== "B") {
    1169             stay = status === P.entry_exit;
    1170         }
    1171         return stay;
    1172     },
    1173
    1174     /**
    1175      * Add a point to the clipping path and returns if the algorithms
    1176      * arrived at an intersection point which has already been visited.
    1177      * In this case, true is returned.
    1178      *
    1179      * @param {Array} path Resulting path
    1180      * @param {JXG.Math.Clip.Vertex} vertex Point to be added
    1181      * @param {Boolean} DEBUG debug output to console.log
    1182      * @returns {Boolean} true: point has been visited before, false otherwise
    1183      * @private
    1184      */
    1185     _addVertex: function (path, vertex, DEBUG) {
    1186         if (!isNaN(vertex.coords.usrCoords[1]) && !isNaN(vertex.coords.usrCoords[2])) {
    1187             path.push(vertex);
    1188         }
    1189         if (vertex.intersection && vertex.data.done) {
    1190             if (DEBUG) {
    1191                 console.log(
    1192                     "Add last intersection point",
    1193                     vertex.coords.usrCoords,
    1194                     "on",
    1195                     vertex.data.pathname,
    1196                     vertex.entry_exit,
    1197                     vertex.data.type
    1198                 );
    1199             }
    1200             return true;
    1201         }
    1202         if (vertex.intersection) {
    1203             vertex.data.done = true;
    1204
    1205             if (DEBUG) {
    1206                 console.log(
    1207                     "Add intersection point",
    1208                     vertex.coords.usrCoords,
    1209                     "on",
    1210                     vertex.data.pathname,
    1211                     vertex.entry_exit,
    1212                     vertex.data.type
    1213                 );
    1214             }
    1215         }
    1216         return false;
    1217     },
    1218
    1219     /**
    1220      * Tracing phase of the Greiner-Hormann algorithm, see
    1221      * Greiner, Günther; Kai Hormann (1998).
    1222      * "Efficient clipping of arbitrary polygons". ACM Transactions on Graphics. 17 (2): 71–83
    1223      *
    1224      * Boolean operations on polygons are distinguished: 'intersection', 'union', 'difference'.
    1225      *
    1226      * @private
    1227      * @param  {Array} S           Subject path
    1228      * @param  {Array} S_intersect Array containing the intersection vertices of the subject path
    1229      * @param  {String} clip_type  contains the Boolean operation: 'intersection', 'union', or 'difference'
    1230      * @return {Array}             Array consisting of two arrays containing the x-coordinates and the y-coordintaes of
    1231      *      the resulting path.
    1232      */
    1233     tracing: function (S, S_intersect, clip_type) {
    1234         var P, status, current, start,
    1235             cnt = 0,
    1236             maxCnt = 10000,
    1237             S_idx = 0,
    1238             path = [],
    1239             done = false,
    1240             DEBUG = false;
    1241
    1242         if (DEBUG) {
    1243             console.log("\n------ Start Phase 3");
    1244         }
    1245
    1246         // reverse = (clip_type === 'difference' || clip_type === 'union') ? true : false;
    1247         while (S_idx < S_intersect.length && cnt < maxCnt) {
    1248             // Take the first intersection node of the subject path
    1249             // which is not yet included as start point.
    1250             current = S_intersect[S_idx];
    1251             if (
    1252                 current.data.done ||
    1253                 current.data.type !== "X" /*|| !this._isCrossing(current, reverse)*/
    1254             ) {
    1255                 S_idx++;
    1256                 continue;
    1257             }
    1258
    1259             if (DEBUG) {
    1260                 console.log(
    1261                     "\nStart",
    1262                     current.data.pathname,
    1263                     current.coords.usrCoords,
    1264                     current.data.type,
    1265                     current.entry_exit,
    1266                     S_idx
    1267                 );
    1268             }
    1269             if (path.length > 0) {
    1270                 // Add a new path
    1271                 path.push([NaN, NaN]);
    1272             }
    1273
    1274             // Start now the tracing with that node of the subject path
    1275             start = current.data.idx;
    1276             P = S;
    1277
    1278             done = this._addVertex(path, current, DEBUG);
    1279             status = current.entry_exit;
    1280             do {
    1281                 if (done) {
    1282                     break;
    1283                 }
    1284                 //
    1285                 // Decide if we follow the current path forward or backward.
    1286                 // for example, in case the clipping is of type "intersection"
    1287                 // and the current intersection node is of type entry, we go forward.
    1288                 //
    1289                 if (
    1290                     (clip_type === "intersection" && current.entry_exit === "entry") ||
    1291                     (clip_type === "union" && current.entry_exit === "exit") ||
    1292                     (clip_type === "difference" &&
    1293                         (P === S) === (current.entry_exit === "exit"))
    1294                 ) {
    1295                     if (DEBUG) {
    1296                         console.log("Go forward on", current.data.pathname, current.entry_exit);
    1297                     }
    1298
    1299                     //
    1300                     // Take the next nodes and add them to the path
    1301                     // as long as they are not intersection nodes of type 'X'.
    1302                     //
    1303                     do {
    1304                         current = current._next;
    1305                         done = this._addVertex(path, current, DEBUG);
    1306                         if (done) {
    1307                             break;
    1308                         }
    1309                     } while (this._stayOnPath(current, status));
    1310                     cnt++;
    1311                 } else {
    1312                     if (DEBUG) {
    1313                         console.log("Go backward on", current.data.pathname);
    1314                     }
    1315                     //
    1316                     // Here, we go backward:
    1317                     // Take the previous nodes and add them to the path
    1318                     // as long as they are not intersection nodes of type 'X'.
    1319                     //
    1320                     do {
    1321                         current = current._prev;
    1322                         done = this._addVertex(path, current, DEBUG);
    1323                         if (done) {
    1324                             break;
    1325                         }
    1326                     } while (this._stayOnPath(current, status));
    1327                     cnt++;
    1328                 }
    1329
    1330                 if (done) {
    1331                     break;
    1332                 }
    1333
    1334                 if (!current.neighbour) {
    1335                     console.log(
    1336                         "Tracing: emergency break - no neighbour!!!!!!!!!!!!!!!!!",
    1337                         cnt
    1338                     );
    1339                     return [[0], [0]];
    1340                 }
    1341                 //
    1342                 // We stopped the forward or backward loop, because we've
    1343                 // arrived at a crossing intersection node, i.e. we have to
    1344                 // switch to the other path now.
    1345                 if (DEBUG) {
    1346                     console.log(
    1347                         "Switch from",
    1348                         current.coords.usrCoords,
    1349                         current.data.pathname,
    1350                         "to",
    1351                         current.neighbour.coords.usrCoords,
    1352                         "on",
    1353                         current.neighbour.data.pathname
    1354                     );
    1355                 }
    1356                 current = current.neighbour;
    1357                 if (current.data.done) {
    1358                     break;
    1359                 }
    1360                 current.data.done = true;
    1361                 status = current.entry_exit;
    1362
    1363                 // if (current.data.done) {
    1364                 //     // We arrived at an intersection node which is already
    1365                 //     // added to the clipping path.
    1366                 //     // We add it again to close the clipping path and jump out of the
    1367                 //     // loop.
    1368                 //     path.push(current);
    1369                 //     if (DEBUG) {
    1370                 //         console.log("Push last", current.coords.usrCoords);
    1371                 //     }
    1372                 //     break;
    1373                 // }
    1374                 P = current.data.path;
    1375
    1376                 // Polygon closed:
    1377                 // if (DEBUG) {
    1378                 //     console.log("End of loop:", "start=", start, "idx=", current.data.idx);
    1379                 // }
    1380                 // } while (!(current.data.pathname === 'S' && current.data.idx === start) && cnt < maxCnt);
    1381             } while (current.data.idx !== start && cnt < maxCnt);
    1382
    1383             if (cnt >= maxCnt) {
    1384                 console.log("Tracing: stopping an infinite loop!", cnt);
    1385             }
    1386
    1387             S_idx++;
    1388         }
    1389         return this._getCoordsArrays(path, false);
    1390     },
    1391
    1392     /**
    1393      * Handle path clipping if one of the two paths is empty.
    1394      * @private
    1395      * @param  {Array} S        First path, array of JXG.Coords
    1396      * @param  {Array} C        Second path, array of JXG.Coords
    1397      * @param  {String} clip_type Type of Boolean operation: 'intersection', 'union', 'differrence'.
    1398      * @return {Boolean}        true, if one of the input paths is empty, false otherwise.
    1399      */
    1400     isEmptyCase: function (S, C, clip_type) {
    1401         if (clip_type === "intersection" && (S.length === 0 || C.length === 0)) {
    1402             return true;
    1403         }
    1404         if (clip_type === "union" && S.length === 0 && C.length === 0) {
    1405             return true;
    1406         }
    1407         if (clip_type === "difference" && S.length === 0) {
    1408             return true;
    1409         }
    1410
    1411         return false;
    1412     },
    1413
    1414     _getCoordsArrays: function (path, doClose) {
    1415         var pathX = [],
    1416             pathY = [],
    1417             i,
    1418             le = path.length;
    1419
    1420         for (i = 0; i < le; i++) {
    1421             if (path[i].coords) {
    1422                 pathX.push(path[i].coords.usrCoords[1]);
    1423                 pathY.push(path[i].coords.usrCoords[2]);
    1424             } else {
    1425                 pathX.push(path[i][0]);
    1426                 pathY.push(path[i][1]);
    1427             }
    1428         }
    1429         if (doClose && le > 0) {
    1430             if (path[0].coords) {
    1431                 pathX.push(path[0].coords.usrCoords[1]);
    1432                 pathY.push(path[0].coords.usrCoords[2]);
    1433             } else {
    1434                 pathX.push(path[0][0]);
    1435                 pathY.push(path[0][1]);
    1436             }
    1437         }
    1438
    1439         return [pathX, pathY];
    1440     },
    1441
    1442     /**
    1443      * Handle cases when there are no intersection points of the two paths. This is the case if the
    1444      * paths are disjoint or one is contained in the other.
    1445      * @private
    1446      * @param  {Array} S        First path, array of JXG.Coords
    1447      * @param  {Array} C        Second path, array of JXG.Coords
    1448      * @param  {String} clip_type Type of Boolean operation: 'intersection', 'union', 'differrence'.
    1449      * @return {Array}          Array consisting of two arrays containing the x-coordinates and the y-coordinates of
    1450      *      the resulting path.
    1451      */
    1452     handleEmptyIntersection: function (S, C, clip_type) {
    1453         var P,
    1454             Q,
    1455             doClose = false,
    1456             path = [];
    1457
    1458         // Handle trivial cases
    1459         if (S.length === 0) {
    1460             if (clip_type === "union") {
    1461                 // S cup C = C
    1462                 path = C;
    1463             } else {
    1464                 // S cap C = S \ C = {}
    1465                 path = [];
    1466             }
    1467             return this._getCoordsArrays(path, true);
    1468         }
    1469         if (C.length === 0) {
    1470             if (clip_type === "intersection") {
    1471                 // S cap C = {}
    1472                 path = [];
    1473             } else {
    1474                 // S cup C = S \ C = S
    1475                 path = S;
    1476             }
    1477             return this._getCoordsArrays(path, true);
    1478         }
    1479
    1480         // From now on, both paths have non-zero length.
    1481         // The two paths have no crossing intersections,
    1482         // but there might be bouncing intersections.
    1483
    1484         // First, we find -- if possible -- on each path a point which is not an intersection point.
    1485         if (S.length > 0) {
    1486             P = S[0];
    1487             while (P.intersection) {
    1488                 P = P._next;
    1489                 if (P._end) {
    1490                     break;
    1491                 }
    1492             }
    1493         }
    1494         if (C.length > 0) {
    1495             Q = C[0];
    1496             while (Q.intersection) {
    1497                 Q = Q._next;
    1498                 if (Q._end) {
    1499                     break;
    1500                 }
    1501             }
    1502         }
    1503
    1504         // Test if one curve is contained by the other
    1505         if (Geometry.windingNumber(P.coords.usrCoords, C) === 0) {
    1506             // P is outside of C:
    1507             // Either S is disjoint from C or C is inside of S
    1508             if (Geometry.windingNumber(Q.coords.usrCoords, S) !== 0) {
    1509                 // C is inside of S, i.e. C subset of S
    1510
    1511                 if (clip_type === "union") {
    1512                     Type.concat(path, S);
    1513                     path.push(S[0]);
    1514                 } else if (clip_type === "difference") {
    1515                     Type.concat(path, S);
    1516                     path.push(S[0]);
    1517                     if (Geometry.signedPolygon(S) * Geometry.signedPolygon(C) > 0) {
    1518                         // Pathes have same orientation, we have to revert one.
    1519                         path.reverse();
    1520                     }
    1521                     path.push([NaN, NaN]);
    1522                 }
    1523                 if (clip_type === "difference" || clip_type === "intersection") {
    1524                     Type.concat(path, C);
    1525                     path.push(C[0]);
    1526                     doClose = false;
    1527                 }
    1528             } else {
    1529                 // The curves are disjoint
    1530                 if (clip_type === "difference") {
    1531                     Type.concat(path, S);
    1532                     doClose = true;
    1533                 } else if (clip_type === "union") {
    1534                     Type.concat(path, S);
    1535                     path.push(S[0]);
    1536                     path.push([NaN, NaN]);
    1537                     Type.concat(path, C);
    1538                     path.push(C[0]);
    1539                 }
    1540             }
    1541         } else {
    1542             // S inside of C, i.e. S subset of C
    1543             if (clip_type === "intersection") {
    1544                 Type.concat(path, S);
    1545                 doClose = true;
    1546             } else if (clip_type === "union") {
    1547                 Type.concat(path, C);
    1548                 path.push(C[0]);
    1549             }
    1550
    1551             // 'difference': path is empty
    1552         }
    1553
    1554         return this._getCoordsArrays(path, doClose);
    1555     },
    1556
    1557     /**
    1558      * Count intersection points of type 'X'.
    1559      * @param {JXG.Mat.Clip.Vertex} intersections
    1560      * @returns Number
    1561      * @private
    1562      */
    1563     _countCrossingIntersections: function (intersections) {
    1564         var i,
    1565             le = intersections.length,
    1566             sum = 0;
    1567
    1568         for (i = 0; i < le; i++) {
    1569             if (intersections[i].data.type === "X") {
    1570                 sum++;
    1571             }
    1572         }
    1573         return sum;
    1574     },
    1575
    1576     /**
    1577      * Create path from all sorts of input elements and convert it
    1578      * to a suitable input path for greinerHormann().
    1579      *
    1580      * @private
    1581      * @param {Object} obj Maybe curve, arc, sector, circle, polygon, array of points, array of JXG.Coords,
    1582      * array of coordinate pairs.
    1583      * @param  {JXG.Board} board   JSXGraph board object. It is needed to convert between
    1584      * user coordinates and screen coordinates.
    1585      * @returns {Array} Array of JXG.Coords elements containing a path.
    1586      * @see JXG.Math.Clip.greinerHormann
    1587      */
    1588     _getPath: function (obj, board) {
    1589         var i, len, r,
    1590             rad, angle, alpha, steps,
    1591             S = [];
    1592
    1593         // Collect all points into path array S
    1594         if (
    1595             obj.elementClass === Const.OBJECT_CLASS_CURVE &&
    1596             (obj.type === Const.OBJECT_TYPE_ARC || obj.type === Const.OBJECT_TYPE_SECTOR)
    1597         ) {
    1598             angle = Geometry.rad(obj.radiuspoint, obj.center, obj.anglepoint);
    1599             steps = Math.floor((angle * 180) / Math.PI);
    1600             r = obj.Radius();
    1601             rad = angle / steps;
    1602             alpha = Math.atan2(
    1603                 obj.radiuspoint.coords.usrCoords[2] - obj.center.coords.usrCoords[2],
    1604                 obj.radiuspoint.coords.usrCoords[1] - obj.center.coords.usrCoords[1]
    1605             );
    1606
    1607             if (obj.type === Const.OBJECT_TYPE_SECTOR) {
    1608                 this._addToList(S, obj.center.coords, 0);
    1609             }
    1610             for (i = 0; i <= steps; i++) {
    1611                 this._addToList(
    1612                     S,
    1613                     new Coords(
    1614                         Const.COORDS_BY_USER,
    1615                         [
    1616                             obj.center.coords.usrCoords[0],
    1617                             obj.center.coords.usrCoords[1] + Math.cos(i * rad + alpha) * r,
    1618                             obj.center.coords.usrCoords[2] + Math.sin(i * rad + alpha) * r
    1619                         ],
    1620                         board
    1621                     ),
    1622                     i + 1
    1623                 );
    1624             }
    1625             if (obj.type === Const.OBJECT_TYPE_SECTOR) {
    1626                 this._addToList(S, obj.center.coords, steps + 2);
    1627             }
    1628         } else if (obj.elementClass === Const.OBJECT_CLASS_CURVE && Type.exists(obj.points)) {
    1629             len = obj.numberPoints;
    1630             for (i = 0; i < len; i++) {
    1631                 this._addToList(S, obj.points[i], i);
    1632             }
    1633         } else if (obj.type === Const.OBJECT_TYPE_POLYGON) {
    1634             for (i = 0; i < obj.vertices.length; i++) {
    1635                 this._addToList(S, obj.vertices[i].coords, i);
    1636             }
    1637         } else if (obj.elementClass === Const.OBJECT_CLASS_CIRCLE) {
    1638             steps = 359;
    1639             r = obj.Radius();
    1640             rad = (2 * Math.PI) / steps;
    1641             for (i = 0; i <= steps; i++) {
    1642                 this._addToList(
    1643                     S,
    1644                     new Coords(
    1645                         Const.COORDS_BY_USER,
    1646                         [
    1647                             obj.center.coords.usrCoords[0],
    1648                             obj.center.coords.usrCoords[1] + Math.cos(i * rad) * r,
    1649                             obj.center.coords.usrCoords[2] + Math.sin(i * rad) * r
    1650                         ],
    1651                         board
    1652                     ),
    1653                     i
    1654                 );
    1655             }
    1656         } else if (Type.isArray(obj)) {
    1657             len = obj.length;
    1658             for (i = 0; i < len; i++) {
    1659                 if (Type.exists(obj[i].coords)) {
    1660                     // Point type
    1661                     this._addToList(S, obj[i].coords, i);
    1662                 } else if (Type.isArray(obj[i])) {
    1663                     // Coordinate pair
    1664                     this._addToList(S, new Coords(Const.COORDS_BY_USER, obj[i], board), i);
    1665                 } else if (Type.exists(obj[i].usrCoords)) {
    1666                     // JXG.Coordinates
    1667                     this._addToList(S, obj[i], i);
    1668                 }
    1669             }
    1670         }
    1671
    1672         return S;
    1673     },
    1674
    1675     /**
    1676      * Determine the intersection, union or difference of two closed paths.
    1677      * <p>
    1678      * This is an implementation of the Greiner-Hormann algorithm, see
    1679      * Günther Greiner and Kai Hormann (1998).
    1680      * "Efficient clipping of arbitrary polygons". ACM Transactions on Graphics. 17 (2): 71–83.
    1681      * and
    1682      * Erich, L. Foster, and Kai Hormann, Kai, and Romeo Traaian Popa (2019),
    1683      * "Clipping simple polygons with degenerate intersections", Computers & Graphics:X, 2.
    1684      * <p>
    1685      * It is assumed that the pathes are closed, whereby it does not matter if the last point indeed
    1686      * equals the first point. In contrast to the original Greiner-Hormann algorithm,
    1687      * this algorithm can cope with many degenerate cases. A degenerate case is a vertext of one path
    1688      * which is contained in the other path.
    1689      * <p>
    1690      *
    1691      * <p>Problematic are:
    1692      * <ul>
    1693      *   <li>degenerate cases where one path additionally has self-intersections
    1694      *   <li>differences with one path having self-intersections.
    1695      * </ul>
    1696      *
    1697      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} subject   First closed path, usually called 'subject'.
    1698      * Maybe curve, arc, sector, circle, polygon, array of points, array of JXG.Coords,
    1699      * array of coordinate pairs.
    1700      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} clip      Second closed path, usually called 'clip'.
    1701      * Maybe curve, arc, sector, circle, polygon, array of points, array of JXG.Coords,
    1702      * array of coordinate pairs.
    1703      * @param  {String} clip_type Determines the type of boolean operation on the two paths.
    1704      *  Possible values are 'intersection', 'union', or 'difference'.
    1705      * @param  {JXG.Board} board   JSXGraph board object. It is needed to convert between
    1706      * user coordinates and screen coordinates.
    1707      * @return {Array}          Array consisting of two arrays containing the x-coordinates and the y-coordinates of
    1708      *      the resulting path.
    1709      *
    1710      * @see JXG.Math.Clip.intersection
    1711      * @see JXG.Math.Clip.union
    1712      * @see JXG.Math.Clip.difference
    1713      *
    1714      * @example
    1715      *     var curve1 = board.create('curve', [
    1716      *             [-3, 3, 0, -3],
    1717      *             [3, 3, 0, 3]
    1718      *         ],
    1719      *         {strokeColor: 'black'});
    1720      *
    1721      *     var curve2 = board.create('curve', [
    1722      *             [-4, 4, 0, -4],
    1723      *             [2, 2, 4, 2]
    1724      *         ],
    1725      *         {strokeColor: 'blue'});
    1726      *
    1727      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.6});
    1728      *     clip_path.updateDataArray = function() {
    1729      *         var a = JXG.Math.Clip.greinerHormann(curve2, curve1, 'intersection', this.board);
    1730      *
    1731      *         this.dataX = a[0];
    1732      *         this.dataY = a[1];
    1733      *     };
    1734      *
    1735      *     board.update();
    1736      *
    1737      * </pre><div id="JXG9d2a6acf-a43b-4035-8f8a-9b1bee580210" class="jxgbox" style="width: 300px; height: 300px;"></div>
    1738      * <script type="text/javascript">
    1739      *     (function() {
    1740      *         var board = JXG.JSXGraph.initBoard('JXG9d2a6acf-a43b-4035-8f8a-9b1bee580210',
    1741      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    1742      *
    1743      *         var curve1 = board.create('curve', [
    1744      *                 [-3, 3, 0, -3],
    1745      *                 [3, 3, 0, 3]
    1746      *             ],
    1747      *             {strokeColor: 'black'});
    1748      *
    1749      *         var curve2 = board.create('curve', [
    1750      *                 [-4, 4, 0, -4],
    1751      *                 [2, 2, 4, 2]
    1752      *             ],
    1753      *             {strokeColor: 'blue'});
    1754      *
    1755      *         var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.6});
    1756      *         clip_path.updateDataArray = function() {
    1757      *             var a = JXG.Math.Clip.greinerHormann(curve2, curve1, 'intersection', this.board);
    1758      *
    1759      *             this.dataX = a[0];
    1760      *             this.dataY = a[1];
    1761      *         };
    1762      *
    1763      *         board.update();
    1764      *
    1765      *     })();
    1766      *
    1767      * </script><pre>
    1768      *
    1769      * @example
    1770      *     var curve1 = board.create('curve', [
    1771      *             [-3, 3, 0, -3],
    1772      *             [3, 3, 0, 3]
    1773      *         ],
    1774      *         {strokeColor: 'black', fillColor: 'none', fillOpacity: 0.8});
    1775      *
    1776      *     var curve2 = board.create('polygon', [[3, 4], [-4, 0], [-4, 4]],
    1777      *             {strokeColor: 'blue', fillColor: 'none'});
    1778      *
    1779      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.6});
    1780      *     clip_path.updateDataArray = function() {
    1781      *         var a = JXG.Math.Clip.greinerHormann(curve1, curve2, 'union', this.board);
    1782      *         this.dataX = a[0];
    1783      *         this.dataY = a[1];
    1784      *     };
    1785      *
    1786      *     board.update();
    1787      *
    1788      * </pre><div id="JXG6075c918-4d57-4b72-b600-6597a6a4f44e" class="jxgbox" style="width: 300px; height: 300px;"></div>
    1789      * <script type="text/javascript">
    1790      *     (function() {
    1791      *         var board = JXG.JSXGraph.initBoard('JXG6075c918-4d57-4b72-b600-6597a6a4f44e',
    1792      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    1793      *         var curve1 = board.create('curve', [
    1794      *                 [-3, 3, 0, -3],
    1795      *                 [3, 3, 0, 3]
    1796      *             ],
    1797      *             {strokeColor: 'black', fillColor: 'none', fillOpacity: 0.8});
    1798      *
    1799      *         var curve2 = board.create('polygon', [[3, 4], [-4, 0], [-4, 4]],
    1800      *                 {strokeColor: 'blue', fillColor: 'none'});
    1801      *
    1802      *
    1803      *         var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.6});
    1804      *         clip_path.updateDataArray = function() {
    1805      *             var a = JXG.Math.Clip.greinerHormann(curve1, curve2, 'union', this.board);
    1806      *             this.dataX = a[0];
    1807      *             this.dataY = a[1];
    1808      *         };
    1809      *
    1810      *         board.update();
    1811      *
    1812      *     })();
    1813      *
    1814      * </script><pre>
    1815      *
    1816      * @example
    1817      *     var curve1 = board.create('curve', [
    1818      *             [-4, 4, 0, -4],
    1819      *             [4, 4, -2, 4]
    1820      *         ],
    1821      *         {strokeColor: 'black', fillColor: 'none', fillOpacity: 0.8});
    1822      *
    1823      *     var curve2 = board.create('circle', [[0, 0], [0, -2]],
    1824      *             {strokeColor: 'blue', strokeWidth: 1, fillColor: 'red', fixed: true, fillOpacity: 0.3,
    1825      *             center: {visible: true, size: 5}, point2: {size: 5}});
    1826      *
    1827      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.6});
    1828      *     clip_path.updateDataArray = function() {
    1829      *         var a = JXG.Math.Clip.greinerHormann(curve1, curve2, 'difference', this.board);
    1830      *
    1831      *         this.dataX = a[0];
    1832      *         this.dataY = a[1];
    1833      *     };
    1834      *
    1835      *     board.update();
    1836      *
    1837      * </pre><div id="JXG46b3316b-5ab9-4928-9473-ccb476ca4185" class="jxgbox" style="width: 300px; height: 300px;"></div>
    1838      * <script type="text/javascript">
    1839      *     (function() {
    1840      *         var board = JXG.JSXGraph.initBoard('JXG46b3316b-5ab9-4928-9473-ccb476ca4185',
    1841      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    1842      *         var curve1 = board.create('curve', [
    1843      *                 [-4, 4, 0, -4],
    1844      *                 [4, 4, -2, 4]
    1845      *             ],
    1846      *             {strokeColor: 'black', fillColor: 'none', fillOpacity: 0.8});
    1847      *
    1848      *         var curve2 = board.create('circle', [[0, 0], [0, -2]],
    1849      *                 {strokeColor: 'blue', strokeWidth: 1, fillColor: 'red', fixed: true, fillOpacity: 0.3,
    1850      *                 center: {visible: true, size: 5}, point2: {size: 5}});
    1851      *
    1852      *
    1853      *         var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.6});
    1854      *         clip_path.updateDataArray = function() {
    1855      *             var a = JXG.Math.Clip.greinerHormann(curve1, curve2, 'difference', this.board);
    1856      *
    1857      *             this.dataX = a[0];
    1858      *             this.dataY = a[1];
    1859      *         };
    1860      *
    1861      *         board.update();
    1862      *
    1863      *     })();
    1864      *
    1865      * </script><pre>
    1866      *
    1867      * @example
    1868      * var clip_path = board.create('curve', [[], []], {strokeWidth: 1, fillColor: 'yellow', fillOpacity: 0.6});
    1869      * clip_path.updateDataArray = function() {
    1870      *     var bbox = this.board.getBoundingBox(),
    1871      *         canvas, triangle;
    1872      *
    1873      *     canvas = [[bbox[0], bbox[1]], // ul
    1874      *          [bbox[0], bbox[3]], // ll
    1875      *          [bbox[2], bbox[3]], // lr
    1876      *          [bbox[2], bbox[1]], // ur
    1877      *          [bbox[0], bbox[1]]] // ul
    1878      *     triangle = [[-1,1], [1,1], [0,-1], [-1,1]];
    1879      *
    1880      *     var a = JXG.Math.Clip.greinerHormann(canvas, triangle, 'difference', this.board);
    1881      *     this.dataX = a[0];
    1882      *     this.dataY = a[1];
    1883      * };
    1884      *
    1885      * </pre><div id="JXGe94da07a-2a01-4498-ad62-f71a327f8e25" class="jxgbox" style="width: 300px; height: 300px;"></div>
    1886      * <script type="text/javascript">
    1887      *     (function() {
    1888      *         var board = JXG.JSXGraph.initBoard('JXGe94da07a-2a01-4498-ad62-f71a327f8e25',
    1889      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    1890      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 1, fillColor: 'yellow', fillOpacity: 0.6});
    1891      *     clip_path.updateDataArray = function() {
    1892      *         var bbox = this.board.getBoundingBox(),
    1893      *             canvas, triangle;
    1894      *
    1895      *         canvas = [[bbox[0], bbox[1]], // ul
    1896      *              [bbox[0], bbox[3]], // ll
    1897      *              [bbox[2], bbox[3]], // lr
    1898      *              [bbox[2], bbox[1]], // ur
    1899      *              [bbox[0], bbox[1]]] // ul
    1900      *         triangle = [[-1,1], [1,1], [0,-1], [-1,1]];
    1901      *
    1902      *         var a = JXG.Math.Clip.greinerHormann(canvas, triangle, 'difference', this.board);
    1903      *         this.dataX = a[0];
    1904      *         this.dataY = a[1];
    1905      *     };
    1906      *
    1907      *     })();
    1908      *
    1909      * </script><pre>
    1910      *
    1911      */
    1912     greinerHormann: function (subject, clip, clip_type, board) {
    1913         //},
    1914         // subject_first_point_type, clip_first_point_type) {
    1915
    1916         var len,
    1917             S = [],
    1918             C = [],
    1919             S_intersect = [],
    1920             // C_intersect = [],
    1921             S_starters,
    1922             C_starters,
    1923             res = [],
    1924             DEBUG = false;
    1925
    1926         if (DEBUG) {
    1927             console.log("\n------------ GREINER-HORMANN --------------");
    1928         }
    1929         // Collect all subject points into subject array S
    1930         S = this._getPath(subject, board);
    1931         len = S.length;
    1932         if (
    1933             len > 0 &&
    1934             Geometry.distance(S[0].coords.usrCoords, S[len - 1].coords.usrCoords, 3) < Mat.eps
    1935         ) {
    1936             S.pop();
    1937         }
    1938
    1939         // Collect all points into clip array C
    1940         C = this._getPath(clip, board);
    1941         len = C.length;
    1942         if (
    1943             len > 0 &&
    1944             Geometry.distance(C[0].coords.usrCoords, C[len - 1].coords.usrCoords, 3) <
    1945                 Mat.eps * Mat.eps
    1946         ) {
    1947             C.pop();
    1948         }
    1949
    1950         // Handle cases where at least one of the paths is empty
    1951         if (this.isEmptyCase(S, C, clip_type)) {
    1952             return [[], []];
    1953         }
    1954
    1955         // Add pointers for doubly linked lists
    1956         S_starters = this.makeDoublyLinkedList(S);
    1957         C_starters = this.makeDoublyLinkedList(C);
    1958
    1959         if (DEBUG) {
    1960             this._print_array(S);
    1961             console.log("Components:", S_starters);
    1962             this._print_array(C);
    1963             console.log("Components:", C_starters);
    1964         }
    1965
    1966         res = this.findIntersections(S, C, board);
    1967         S_intersect = res[0];
    1968
    1969         this._handleFullyDegenerateCase(S, C, board);
    1970
    1971         // Phase 2: mark intersection points as entry or exit points
    1972         this.markEntryExit(S, C, S_starters);
    1973
    1974         // if (S[0].coords.distance(Const.COORDS_BY_USER, C[0].coords) === 0) {
    1975         //     // Randomly disturb the first point of the second path
    1976         //     // if both paths start at the same point.
    1977         //     C[0].usrCoords[1] *= 1 + Math.random() * 0.0001 - 0.00005;
    1978         //     C[0].usrCoords[2] *= 1 + Math.random() * 0.0001 - 0.00005;
    1979         // }
    1980         this.markEntryExit(C, S, C_starters);
    1981
    1982         // Handle cases without intersections
    1983         if (this._countCrossingIntersections(S_intersect) === 0) {
    1984             return this.handleEmptyIntersection(S, C, clip_type);
    1985         }
    1986
    1987         // Phase 3: tracing
    1988         return this.tracing(S, S_intersect, clip_type);
    1989     },
    1990
    1991     /**
    1992      * Union of two closed paths. The paths could be JSXGraph elements circle, curve, or polygon.
    1993      * Computed by the Greiner-Hormann algorithm.
    1994      *
    1995      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} subject   First closed path.
    1996      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} clip      Second closed path.
    1997      * @param  {JXG.Board} board   JSXGraph board object. It is needed to convert between
    1998      * user coordinates and screen coordinates.
    1999      * @return {Array}          Array consisting of two arrays containing the x-coordinates and the y-coordinates of
    2000      *      the resulting path.
    2001      *
    2002      * @see JXG.Math.Clip.greinerHormann
    2003      * @see JXG.Math.Clip.intersection
    2004      * @see JXG.Math.Clip.difference
    2005      *
    2006      * @example
    2007      *     var curve1 = board.create('curve', [
    2008      *             [-3, 3, 0, -3],
    2009      *             [3, 3, 0, 3]
    2010      *         ],
    2011      *         {strokeColor: 'black'});
    2012      *
    2013      *     var curve2 = board.create('polygon', [[3, 4], [-4, 0], [-4, 4]],
    2014      *             {strokeColor: 'blue', fillColor: 'none'});
    2015      *
    2016      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.3});
    2017      *     clip_path.updateDataArray = function() {
    2018      *         var a = JXG.Math.Clip.union(curve1, curve2, this.board);
    2019      *         this.dataX = a[0];
    2020      *         this.dataY = a[1];
    2021      *     };
    2022      *
    2023      *     board.update();
    2024      *
    2025      * </pre><div id="JXG7c5204aa-3824-4464-819c-80df7bf1d917" class="jxgbox" style="width: 300px; height: 300px;"></div>
    2026      * <script type="text/javascript">
    2027      *     (function() {
    2028      *         var board = JXG.JSXGraph.initBoard('JXG7c5204aa-3824-4464-819c-80df7bf1d917',
    2029      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    2030      *         var curve1 = board.create('curve', [
    2031      *                 [-3, 3, 0, -3],
    2032      *                 [3, 3, 0, 3]
    2033      *             ],
    2034      *             {strokeColor: 'black'});
    2035      *
    2036      *         var curve2 = board.create('polygon', [[3, 4], [-4, 0], [-4, 4]],
    2037      *                 {strokeColor: 'blue', fillColor: 'none'});
    2038      *
    2039      *
    2040      *         var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.3});
    2041      *         clip_path.updateDataArray = function() {
    2042      *             var a = JXG.Math.Clip.union(curve1, curve2, this.board);
    2043      *             this.dataX = a[0];
    2044      *             this.dataY = a[1];
    2045      *         };
    2046      *
    2047      *         board.update();
    2048      *
    2049      *     })();
    2050      *
    2051      * </script><pre>
    2052      *
    2053      */
    2054     union: function (path1, path2, board) {
    2055         return this.greinerHormann(path1, path2, "union", board);
    2056     },
    2057
    2058     /**
    2059      * Intersection of two closed paths. The paths could be JSXGraph elements circle, curve, or polygon.
    2060      * Computed by the Greiner-Hormann algorithm.
    2061      *
    2062      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} subject   First closed path.
    2063      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} clip      Second closed path.
    2064      * @param  {JXG.Board} board   JSXGraph board object. It is needed to convert between
    2065      * user coordinates and screen coordinates.
    2066      * @return {Array}          Array consisting of two arrays containing the x-coordinates and the y-coordinates of
    2067      *      the resulting path.
    2068      *
    2069      * @see JXG.Math.Clip.greinerHormann
    2070      * @see JXG.Math.Clip.union
    2071      * @see JXG.Math.Clip.difference
    2072      *
    2073      * @example
    2074      * var p = [];
    2075      * p.push(board.create('point', [0, -5]));
    2076      * p.push(board.create('point', [-5, 0]));
    2077      * p.push(board.create('point', [-3, 3]));
    2078      *
    2079      * var curve1 = board.create('ellipse', p,
    2080      *                 {strokeColor: 'black'});
    2081      *
    2082      * var curve2 = board.create('curve', [function(phi){return 4 * Math.cos(2*phi); },
    2083      *                                     [0, 0],
    2084      *                                     0, 2 * Math.PI],
    2085      *                       {curveType:'polar', strokeColor: 'blue', strokewidth:1});
    2086      *
    2087      * var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.3});
    2088      * clip_path.updateDataArray = function() {
    2089      *     var a = JXG.Math.Clip.intersection(curve2, curve1, this.board);
    2090      *
    2091      *     this.dataX = a[0];
    2092      *     this.dataY = a[1];
    2093      * };
    2094      *
    2095      * board.update();
    2096      *
    2097      * </pre><div id="JXG7ad547eb-7b6c-4a1a-a4d4-4ed298fc7998" class="jxgbox" style="width: 300px; height: 300px;"></div>
    2098      * <script type="text/javascript">
    2099      *     (function() {
    2100      *         var board = JXG.JSXGraph.initBoard('JXG7ad547eb-7b6c-4a1a-a4d4-4ed298fc7998',
    2101      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    2102      *     var p = [];
    2103      *     p.push(board.create('point', [0, -5]));
    2104      *     p.push(board.create('point', [-5, 0]));
    2105      *     p.push(board.create('point', [-3, 3]));
    2106      *
    2107      *     var curve1 = board.create('ellipse', p,
    2108      *                     {strokeColor: 'black'});
    2109      *
    2110      *     var curve2 = board.create('curve', [function(phi){return 4 * Math.cos(2*phi); },
    2111      *                                         [0, 0],
    2112      *                                         0, 2 * Math.PI],
    2113      *                           {curveType:'polar', strokeColor: 'blue', strokewidth:1});
    2114      *
    2115      *
    2116      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.3});
    2117      *     clip_path.updateDataArray = function() {
    2118      *         var a = JXG.Math.Clip.intersection(curve2, curve1, this.board);
    2119      *
    2120      *         this.dataX = a[0];
    2121      *         this.dataY = a[1];
    2122      *     };
    2123      *
    2124      *     board.update();
    2125      *
    2126      *     })();
    2127      *
    2128      * </script><pre>
    2129      *
    2130      *
    2131      */
    2132     intersection: function (path1, path2, board) {
    2133         return this.greinerHormann(path1, path2, "intersection", board);
    2134     },
    2135
    2136     /**
    2137      * Difference of two closed paths, i.e. path1 minus path2.
    2138      * The paths could be JSXGraph elements circle, curve, or polygon.
    2139      * Computed by the Greiner-Hormann algorithm.
    2140      *
    2141      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} subject   First closed path.
    2142      * @param  {JXG.Circle|JXG.Curve|JXG.Polygon} clip      Second closed path.
    2143      * @param  {JXG.Board} board   JSXGraph board object. It is needed to convert between
    2144      * user coordinates and screen coordinates.
    2145      * @return {Array}          Array consisting of two arrays containing the x-coordinates and the y-coordinates of
    2146      *      the resulting path.
    2147      *
    2148      * @see JXG.Math.Clip.greinerHormann
    2149      * @see JXG.Math.Clip.intersection
    2150      * @see JXG.Math.Clip.union
    2151      *
    2152      * @example
    2153      *     var curve1 = board.create('polygon', [[-4, 4], [4, 4], [0, -1]],
    2154      *             {strokeColor: 'blue', fillColor: 'none'});
    2155      *
    2156      *     var curve2 = board.create('curve', [
    2157      *             [-1, 1, 0, -1],
    2158      *             [1, 1, 3, 1]
    2159      *         ],
    2160      *         {strokeColor: 'black', fillColor: 'none', fillOpacity: 0.8});
    2161      *
    2162      *     var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.3});
    2163      *     clip_path.updateDataArray = function() {
    2164      *         var a = JXG.Math.Clip.difference(curve1, curve2, this.board);
    2165      *         this.dataX = a[0];
    2166      *         this.dataY = a[1];
    2167      *     };
    2168      *
    2169      *     board.update();
    2170      *
    2171      * </pre><div id="JXGc5ce6bb3-146c-457f-a48b-6b9081fb68a3" class="jxgbox" style="width: 300px; height: 300px;"></div>
    2172      * <script type="text/javascript">
    2173      *     (function() {
    2174      *         var board = JXG.JSXGraph.initBoard('JXGc5ce6bb3-146c-457f-a48b-6b9081fb68a3',
    2175      *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
    2176      *         var curve1 = board.create('polygon', [[-4, 4], [4, 4], [0, -1]],
    2177      *                 {strokeColor: 'blue', fillColor: 'none'});
    2178      *
    2179      *         var curve2 = board.create('curve', [
    2180      *                 [-1, 1, 0, -1],
    2181      *                 [1, 1, 3, 1]
    2182      *             ],
    2183      *             {strokeColor: 'black', fillColor: 'none', fillOpacity: 0.8});
    2184      *
    2185      *
    2186      *         var clip_path = board.create('curve', [[], []], {strokeWidth: 3, fillColor: 'yellow', fillOpacity: 0.3});
    2187      *         clip_path.updateDataArray = function() {
    2188      *             var a = JXG.Math.Clip.difference(curve1, curve2, this.board);
    2189      *             this.dataX = a[0];
    2190      *             this.dataY = a[1];
    2191      *         };
    2192      *
    2193      *         board.update();
    2194      *
    2195      *     })();
    2196      *
    2197      * </script><pre>
    2198      *
    2199      */
    2200     difference: function (path1, path2, board) {
    2201         return this.greinerHormann(path1, path2, "difference", board);
    2202     }
    2203 };
    2204
    2205 // JXG.extend(Mat.Clip, /** @lends JXG.Math.Clip */ {});
    2206
    2207 export default Mat.Clip;
    2208