      1 /*
      2     Copyright 2008-2023
      3         Matthias Ehmann,
      4         Michael Gerhaeuser,
      5         Carsten Miller,
      6         Bianca Valentin,
      7         Alfred Wassermann,
      8         Peter Wilfahrt
      9
     10     This file is part of JSXGraph.
     11
     12     JSXGraph is free software dual licensed under the GNU LGPL or MIT License.
     13
     14     You can redistribute it and/or modify it under the terms of the
     15
     16       * GNU Lesser General Public License as published by
     17         the Free Software Foundation, either version 3 of the License, or
     18         (at your option) any later version
     19       OR
     20       * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT
     21
     22     JSXGraph is distributed in the hope that it will be useful,
     23     but WITHOUT ANY WARRANTY; without even the implied warranty of
     24     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     25     GNU Lesser General Public License for more details.
     26
     27     You should have received a copy of the GNU Lesser General Public License and
     28     the MIT License along with JSXGraph. If not, see <https://www.gnu.org/licenses/>
     29     and <https://opensource.org/licenses/MIT/>.
     30
     31
     32     Metapost/Hobby curves, see e.g. https://bosker.wordpress.com/2013/11/13/beyond-bezier-curves/
     33
     34     * Ported to Python for the project PyX. Copyright (C) 2011 Michael Schindler <m-schindler@users.sourceforge.net>
     35     * Ported to javascript from the PyX implementation (https://pyx-project.org/) by Vlad-X.
     36     * Adapted to JSXGraph and some code changes by Alfred Wassermann 2020.
     37
     38     This program is distributed in the hope that it will be useful,
     39     but WITHOUT ANY WARRANTY; without even the implied warranty of
     40     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     41     GNU General Public License for more details.
     42
     43     You should have received a copy of the GNU General Public License
     44     along with this program; if not, write to the Free Software
     45     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     46
     47     Internal functions of MetaPost
     48     This file re-implements some of the functionality of MetaPost
     49     (https://tug.org/metapost.html). MetaPost was developed by John D. Hobby and
     50     others. The code of Metapost is in the public domain, which we understand as
     51     an implicit permission to reuse the code here (see the comment at
     52     https://www.gnu.org/licenses/license-list.html)
     53
     54     This file is based on the MetaPost version distributed by TeXLive:
     55     svn://tug.org/texlive/trunk/Build/source/texk/web2c/mplibdir revision 22737 #
     56     (2011-05-31)
     57 */
     58
     59 /*global JXG: true, define: true*/
     60 /*jslint nomen: true, plusplus: true*/
     61
     62 /**
     63  * @fileoverview In this file the namespace Math.Metapost is defined which holds algorithms translated from Metapost
     64  * by D.E. Knuth and J.D. Hobby.
     65  */
     66
     67 import Type from "../utils/type";
     68 import Mat from "./math";
     69
     70 /**
     71  * The JXG.Math.Metapost namespace holds algorithms translated from Metapost
     72  * by D.E. Knuth and J.D. Hobby.
     73  *
     74  * @name JXG.Math.Metapost
     75  * @exports Mat.Metapost as JXG.Math.Metapost
     76  * @namespace
     77  */
     78 Mat.Metapost = {
     79     MP_ENDPOINT: 0,
     80     MP_EXPLICIT: 1,
     81     MP_GIVEN: 2,
     82     MP_CURL: 3,
     83     MP_OPEN: 4,
     84     MP_END_CYCLE: 5,
     85
     86     UNITY: 1.0,
     87     // two: 2,
     88     // fraction_half: 0.5,
     89     FRACTION_ONE: 1.0,
     90     FRACTION_THREE: 3.0,
     91     ONE_EIGHTY_DEG: Math.PI,
     92     THREE_SIXTY_DEG: 2 * Math.PI,
     93     // EPSILON: 1e-5,
     94     EPS_SQ: 1e-5 * 1e-5,
     95
     96     /**
     97      * @private
     98      */
     99     make_choices: function (knots) {
    100         var dely, h, k, delx, n, q, p, s, cosine, t, sine, delta_x, delta_y, delta, psi,
    101             endless = true;
    102
    103         p = knots[0];
    104         do {
    105             if (!p) {
    106                 break;
    107             }
    108             q = p.next;
    109
    110             // Join two identical knots by setting the control points to the same
    111             // coordinates.
    112             // MP 291
    113             if (
    114                 p.rtype > this.MP_EXPLICIT &&
    115                 (p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y) < this.EPS_SQ
    116             ) {
    117                 p.rtype = this.MP_EXPLICIT;
    118                 if (p.ltype === this.MP_OPEN) {
    119                     p.ltype = this.MP_CURL;
    120                     p.set_left_curl(this.UNITY);
    121                 }
    122
    123                 q.ltype = this.MP_EXPLICIT;
    124                 if (q.rtype === this.MP_OPEN) {
    125                     q.rtype = this.MP_CURL;
    126                     q.set_right_curl(this.UNITY);
    127                 }
    128
    129                 p.rx = p.x;
    130                 q.lx = p.x;
    131                 p.ry = p.y;
    132                 q.ly = p.y;
    133             }
    134             p = q;
    135         } while (p !== knots[0]);
    136
    137         // Find the first breakpoint, h, on the path
    138         // MP 292
    139         h = knots[0];
    140         while (endless) {
    141             if (h.ltype !== this.MP_OPEN || h.rtype !== this.MP_OPEN) {
    142                 break;
    143             }
    144             h = h.next;
    145             if (h === knots[0]) {
    146                 h.ltype = this.MP_END_CYCLE;
    147                 break;
    148             }
    149         }
    150
    151         p = h;
    152         while (endless) {
    153             if (!p) {
    154                 break;
    155             }
    156
    157             // Fill in the control points between p and the next breakpoint,
    158             // then advance p to that breakpoint
    159             // MP 299
    160             q = p.next;
    161             if (p.rtype >= this.MP_GIVEN) {
    162                 while (q.ltype === this.MP_OPEN && q.rtype === this.MP_OPEN) {
    163                     q = q.next;
    164                 }
    165
    166                 // Calculate the turning angles psi_ k and the distances d_{k,k+1};
    167                 // set n to the length of the path
    168                 // MP 302
    169                 k = 0;
    170                 s = p;
    171                 n = knots.length;
    172
    173                 delta_x = [];
    174                 delta_y = [];
    175                 delta = [];
    176                 psi = [null];
    177
    178                 // tuple([]) = tuple([[], [], [], [null]]);
    179                 while (endless) {
    180                     t = s.next;
    181                     // None;
    182                     delta_x.push(t.x - s.x);
    183                     delta_y.push(t.y - s.y);
    184                     delta.push(this.mp_pyth_add(delta_x[k], delta_y[k]));
    185                     if (k > 0) {
    186                         sine = delta_y[k - 1] / delta[k - 1];
    187                         cosine = delta_x[k - 1] / delta[k - 1];
    188                         psi.push(
    189                             Math.atan2(
    190                                 delta_y[k] * cosine - delta_x[k] * sine,
    191                                 delta_x[k] * cosine + delta_y[k] * sine
    192                             )
    193                         );
    194                     }
    195                     k++;
    196                     s = t;
    197                     if (s === q) {
    198                         n = k;
    199                     }
    200                     if (k >= n && s.ltype !== this.MP_END_CYCLE) {
    201                         break;
    202                     }
    203                 }
    204                 if (k === n) {
    205                     psi.push(0);
    206                 } else {
    207                     psi.push(psi[1]);
    208                 }
    209
    210                 // Remove open types at the breakpoints
    211                 // MP 303
    212                 if (q.ltype === this.MP_OPEN) {
    213                     delx = q.rx - q.x;
    214                     dely = q.ry - q.y;
    215                     if (delx * delx + dely * dely < this.EPS_SQ) {
    216                         q.ltype = this.MP_CURL;
    217                         q.set_left_curl(this.UNITY);
    218                     } else {
    219                         q.ltype = this.MP_GIVEN;
    220                         q.set_left_given(Math.atan2(dely, delx));
    221                     }
    222                 }
    223                 if (p.rtype === this.MP_OPEN && p.ltype === this.MP_EXPLICIT) {
    224                     delx = p.x - p.lx;
    225                     dely = p.y - p.ly;
    226                     if (delx * delx + dely * dely < this.EPS_SQ) {
    227                         p.rtype = this.MP_CURL;
    228                         p.set_right_curl(this.UNITY);
    229                     } else {
    230                         p.rtype = this.MP_GIVEN;
    231                         p.set_right_given(Math.atan2(dely, delx));
    232                     }
    233                 }
    234                 this.mp_solve_choices(p, q, n, delta_x, delta_y, delta, psi);
    235             } else if (p.rtype === this.MP_ENDPOINT) {
    236                 // MP 294
    237                 p.rx = p.x;
    238                 p.ry = p.y;
    239                 q.lx = q.x;
    240                 q.ly = q.y;
    241             }
    242             p = q;
    243
    244             if (p === h) {
    245                 break;
    246             }
    247         }
    248     },
    249
    250     /**
    251      * Implements solve_choices form metapost
    252      * MP 305
    253      * @private
    254      */
    255     mp_solve_choices: function (p, q, n, delta_x, delta_y, delta, psi) {
    256         var aa, acc, vv, bb, ldelta, ee, k,
    257             s, ww, uu, lt, r, t, ff,
    258             theta, rt, dd, cc, ct_st,
    259             ct, st, cf_sf, cf, sf, i, k_idx,
    260             endless = true;
    261
    262         ldelta = delta.length + 1;
    263         uu = new Array(ldelta);
    264         ww = new Array(ldelta);
    265         vv = new Array(ldelta);
    266         theta = new Array(ldelta);
    267         for (i = 0; i < ldelta; i++) {
    268             theta[i] = vv[i] = ww[i] = uu[i] = 0;
    269         }
    270         k = 0;
    271         s = p;
    272         r = 0;
    273         while (endless) {
    274             t = s.next;
    275             if (k === 0) {
    276                 // MP 306
    277                 if (s.rtype === this.MP_GIVEN) {
    278                     // MP 314
    279                     if (t.ltype === this.MP_GIVEN) {
    280                         aa = Math.atan2(delta_y[0], delta_x[0]);
    281                         ct_st = this.mp_n_sin_cos(p.right_given() - aa);
    282                         ct = ct_st[0];
    283                         st = ct_st[1];
    284                         cf_sf = this.mp_n_sin_cos(q.left_given() - aa);
    285                         cf = cf_sf[0];
    286                         sf = cf_sf[1];
    287                         this.mp_set_controls(p, q, delta_x[0], delta_y[0], st, ct, -sf, cf);
    288                         return;
    289                     }
    290                     vv[0] = s.right_given() - Math.atan2(delta_y[0], delta_x[0]);
    291                     vv[0] = this.reduce_angle(vv[0]);
    292                     uu[0] = 0;
    293                     ww[0] = 0;
    294                 } else if (s.rtype === this.MP_CURL) {
    295                     // MP 315
    296                     if (t.ltype === this.MP_CURL) {
    297                         p.rtype = this.MP_EXPLICIT;
    298                         q.ltype = this.MP_EXPLICIT;
    299                         lt = Math.abs(q.left_tension());
    300                         rt = Math.abs(p.right_tension());
    301                         ff = this.UNITY / (3.0 * rt);
    302                         p.rx = p.x + delta_x[0] * ff;
    303                         p.ry = p.y + delta_y[0] * ff;
    304                         ff = this.UNITY / (3.0 * lt);
    305                         q.lx = q.x - delta_x[0] * ff;
    306                         q.ly = q.y - delta_y[0] * ff;
    307                         return;
    308                     }
    309                     cc = s.right_curl();
    310                     lt = Math.abs(t.left_tension());
    311                     rt = Math.abs(s.right_tension());
    312                     uu[0] = this.mp_curl_ratio(cc, rt, lt);
    313                     vv[0] = -psi[1] * uu[0];
    314                     ww[0] = 0;
    315                 } else {
    316                     if (s.rtype === this.MP_OPEN) {
    317                         uu[0] = 0;
    318                         vv[0] = 0;
    319                         ww[0] = this.FRACTION_ONE;
    320                     }
    321                 }
    322             } else {
    323                 if (s.ltype === this.MP_END_CYCLE || s.ltype === this.MP_OPEN) {
    324                     // MP 308
    325                     aa = this.UNITY / (3.0 * Math.abs(r.right_tension()) - this.UNITY);
    326                     dd =
    327                         delta[k] *
    328                         (this.FRACTION_THREE - this.UNITY / Math.abs(r.right_tension()));
    329                     bb = this.UNITY / (3 * Math.abs(t.left_tension()) - this.UNITY);
    330                     ee =
    331                         delta[k - 1] *
    332                         (this.FRACTION_THREE - this.UNITY / Math.abs(t.left_tension()));
    333                     cc = this.FRACTION_ONE - uu[k - 1] * aa;
    334                     dd = dd * cc;
    335                     lt = Math.abs(s.left_tension());
    336                     rt = Math.abs(s.right_tension());
    337                     if (lt < rt) {
    338                         dd *= Math.pow(lt / rt, 2);
    339                     } else {
    340                         if (lt > rt) {
    341                             ee *= Math.pow(rt / lt, 2);
    342                         }
    343                     }
    344                     ff = ee / (ee + dd);
    345                     uu[k] = ff * bb;
    346                     acc = -psi[k + 1] * uu[k];
    347                     if (r.rtype === this.MP_CURL) {
    348                         ww[k] = 0;
    349                         vv[k] = acc - psi[1] * (this.FRACTION_ONE - ff);
    350                     } else {
    351                         ff = (this.FRACTION_ONE - ff) / cc;
    352                         acc = acc - psi[k] * ff;
    353                         ff = ff * aa;
    354                         vv[k] = acc - vv[k - 1] * ff;
    355                         ww[k] = -ww[k - 1] * ff;
    356                     }
    357                     if (s.ltype === this.MP_END_CYCLE) {
    358                         aa = 0;
    359                         bb = this.FRACTION_ONE;
    360                         while (endless) {
    361                             k -= 1;
    362                             if (k === 0) {
    363                                 k = n;
    364                             }
    365                             aa = vv[k] - aa * uu[k];
    366                             bb = ww[k] - bb * uu[k];
    367                             if (k === n) {
    368                                 break;
    369                             }
    370                         }
    371                         aa = aa / (this.FRACTION_ONE - bb);
    372                         theta[n] = aa;
    373                         vv[0] = aa;
    374                         // k_val = range(1, n);
    375                         // for (k_idx in k_val) {
    376                         // k = k_val[k_idx];
    377                         for (k_idx = 1; k_idx < n; k_idx++) {
    378                             vv[k_idx] = vv[k_idx] + aa * ww[k_idx];
    379                         }
    380                         break;
    381                     }
    382                 } else {
    383                     if (s.ltype === this.MP_CURL) {
    384                         cc = s.left_curl();
    385                         lt = Math.abs(s.left_tension());
    386                         rt = Math.abs(r.right_tension());
    387                         ff = this.mp_curl_ratio(cc, lt, rt);
    388                         theta[n] = -(vv[n - 1] * ff) / (this.FRACTION_ONE - ff * uu[n - 1]);
    389                         break;
    390                     }
    391                     if (s.ltype === this.MP_GIVEN) {
    392                         theta[n] = s.left_given() - Math.atan2(delta_y[n - 1], delta_x[n - 1]);
    393                         theta[n] = this.reduce_angle(theta[n]);
    394                         break;
    395                     }
    396                 }
    397             }
    398             r = s;
    399             s = t;
    400             k += 1;
    401         }
    402
    403         // MP 318
    404         for (k = n - 1; k > -1; k--) {
    405             theta[k] = vv[k] - theta[k + 1] * uu[k];
    406         }
    407
    408         s = p;
    409         k = 0;
    410         while (endless) {
    411             t = s.next;
    412             ct_st = this.mp_n_sin_cos(theta[k]);
    413             ct = ct_st[0];
    414             st = ct_st[1];
    415             cf_sf = this.mp_n_sin_cos(-psi[k + 1] - theta[k + 1]);
    416             cf = cf_sf[0];
    417             sf = cf_sf[1];
    418             this.mp_set_controls(s, t, delta_x[k], delta_y[k], st, ct, sf, cf);
    419             k++;
    420             s = t;
    421             if (k === n) {
    422                 break;
    423             }
    424         }
    425     },
    426
    427     /**
    428      * @private
    429      */
    430     mp_n_sin_cos: function (z) {
    431         return [Math.cos(z), Math.sin(z)];
    432     },
    433
    434     /**
    435      * @private
    436      */
    437     mp_set_controls: function (p, q, delta_x, delta_y, st, ct, sf, cf) {
    438         var rt, ss, lt, sine, rr;
    439         lt = Math.abs(q.left_tension());
    440         rt = Math.abs(p.right_tension());
    441         rr = this.mp_velocity(st, ct, sf, cf, rt);
    442         ss = this.mp_velocity(sf, cf, st, ct, lt);
    443
    444         // console.log('lt rt rr ss', lt, rt, rr, ss);
    445         if (p.right_tension() < 0 || q.left_tension() < 0) {
    446             if ((st >= 0 && sf >= 0) || (st <= 0 && sf <= 0)) {
    447                 sine = Math.abs(st) * cf + Math.abs(sf) * ct;
    448                 if (sine > 0) {
    449                     sine *= 1.00024414062;
    450                     if (p.right_tension() < 0) {
    451                         if (this.mp_ab_vs_cd(Math.abs(sf), this.FRACTION_ONE, rr, sine) < 0) {
    452                             rr = Math.abs(sf) / sine;
    453                         }
    454                     }
    455                     if (q.left_tension() < 0) {
    456                         if (this.mp_ab_vs_cd(Math.abs(st), this.FRACTION_ONE, ss, sine) < 0) {
    457                             ss = Math.abs(st) / sine;
    458                         }
    459                     }
    460                 }
    461             }
    462         }
    463         p.rx = p.x + (delta_x * ct - delta_y * st) * rr;
    464         p.ry = p.y + (delta_y * ct + delta_x * st) * rr;
    465         q.lx = q.x - (delta_x * cf + delta_y * sf) * ss;
    466         q.ly = q.y - (delta_y * cf - delta_x * sf) * ss;
    467         p.rtype = this.MP_EXPLICIT;
    468         q.ltype = this.MP_EXPLICIT;
    469     },
    470
    471     /**
    472      * @private
    473      */
    474     mp_pyth_add: function (a, b) {
    475         return Mat.hypot(a, b);
    476     },
    477
    478     /**
    479      *
    480      * @private
    481      */
    482     mp_curl_ratio: function (gamma, a_tension, b_tension) {
    483         var alpha = 1.0 / a_tension,
    484             beta = 1.0 / b_tension;
    485
    486         return Math.min(
    487             4.0,
    488             ((3.0 - alpha) * alpha * alpha * gamma + beta * beta * beta) /
    489             (alpha * alpha * alpha * gamma + (3.0 - beta) * beta * beta)
    490         );
    491     },
    492
    493     /**
    494      * @private
    495      */
    496     mp_ab_vs_cd: function (a, b, c, d) {
    497         if (a * b === c * d) {
    498             return 0;
    499         }
    500         if (a * b > c * d) {
    501             return 1;
    502         }
    503         return -1;
    504     },
    505
    506     /**
    507      * @private
    508      */
    509     mp_velocity: function (st, ct, sf, cf, t) {
    510         return Math.min(
    511             4.0,
    512             (2.0 + Math.sqrt(2) * (st - sf / 16.0) * (sf - st / 16.0) * (ct - cf)) /
    513             (1.5 * t * (2 + (Math.sqrt(5) - 1) * ct + (3 - Math.sqrt(5)) * cf))
    514         );
    515     },
    516
    517     /**
    518      * @private
    519      * @param {Number} A
    520      */
    521     reduce_angle: function (A) {
    522         if (Math.abs(A) > this.ONE_EIGHTY_DEG) {
    523             if (A > 0) {
    524                 A -= this.THREE_SIXTY_DEG;
    525             } else {
    526                 A += this.THREE_SIXTY_DEG;
    527             }
    528         }
    529         return A;
    530     },
    531
    532     /**
    533      *
    534      * @private
    535      * @param {Array} p
    536      * @param {Number} tension
    537      * @param {Boolean} cycle
    538      */
    539     makeknots: function (p, tension) {
    540         var i, len,
    541             knots = [];
    542
    543         len = p.length;
    544         for (i = 0; i < len; i++) {
    545             knots.push({
    546                 x: p[i][0],
    547                 y: p[i][1],
    548                 ltype: this.MP_OPEN,
    549                 rtype: this.MP_OPEN,
    550                 lx: false,
    551                 rx: false,
    552                 ly: tension,
    553                 ry: tension,
    554                 left_curl: function () {
    555                     return this.lx || 0;
    556                 },
    557                 right_curl: function () {
    558                     return this.rx || 0;
    559                 },
    560                 left_tension: function () {
    561                     return this.ly || 1;
    562                 },
    563                 right_tension: function () {
    564                     return this.ry || 1;
    565                 },
    566                 set_right_curl: function (v) {
    567                     this.rx = v || 0;
    568                 },
    569                 set_left_curl: function (v) {
    570                     this.lx = v || 0;
    571                 }
    572             });
    573         }
    574
    575         len = knots.length;
    576         for (i = 0; i < len; i++) {
    577             knots[i].next = knots[i + 1] || knots[i];
    578             knots[i].set_right_given = knots[i].set_right_curl;
    579             knots[i].set_left_given = knots[i].set_left_curl;
    580             knots[i].right_given = knots[i].right_curl;
    581             knots[i].left_given = knots[i].left_curl;
    582         }
    583         knots[len - 1].next = knots[0];
    584
    585         return knots;
    586     },
    587
    588     /**
    589      *
    590      * @param {Array} point_list
    591      * @param {Object} controls
    592      *
    593      * @returns {Array}
    594      */
    595     curve: function (point_list, controls) {
    596         var knots, len, i, ii,
    597             val, obj,
    598             isClosed = false,
    599             x = [],
    600             y = [];
    601
    602         controls = controls || {
    603             tension: 1,
    604             direction: {},
    605             curl: {},
    606             isClosed: false
    607         };
    608
    609         // Change default tension
    610         val = 1;
    611         if (controls.hasOwnProperty('tension')) {
    612             val = Type.evaluate(controls.tension);
    613         }
    614
    615         knots = this.makeknots(point_list, val);
    616
    617         len = knots.length;
    618         if (Type.exists(controls.isClosed) && Type.evaluate(controls.isClosed)) {
    619             isClosed = true;
    620         }
    621
    622         if (!isClosed) {
    623             knots[0].ltype = this.MP_ENDPOINT;
    624             knots[0].rtype = this.MP_CURL;
    625             knots[len - 1].rtype = this.MP_ENDPOINT;
    626             knots[len - 1].ltype = this.MP_CURL;
    627         }
    628
    629         // for (i in controls.direction) {
    630         //     if (controls.direction.hasOwnProperty(i)) {
    631         //         val = Type.evaluate(controls.direction[i]);
    632         //         if (Type.isArray(val)) {
    633         //             if (val[0] !== false) {
    634         //                 knots[i].lx = (val[0] * Math.PI) / 180;
    635         //                 knots[i].ltype = this.MP_GIVEN;
    636         //             }
    637         //             if (val[1] !== false) {
    638         //                 knots[i].rx = (val[1] * Math.PI) / 180;
    639         //                 knots[i].rtype = this.MP_GIVEN;
    640         //             }
    641         //         } else {
    642         //             knots[i].lx = (val * Math.PI) / 180;
    643         //             knots[i].rx = (val * Math.PI) / 180;
    644         //             knots[i].ltype = knots[i].rtype = this.MP_GIVEN;
    645         //         }
    646         //     }
    647         // }
    648
    649         // for (i in controls.curl) {
    650         //     if (controls.curl.hasOwnProperty(i)) {
    651         //         val = Type.evaluate(controls.curl[i]);
    652         //         if (parseInt(i, 10) === 0) {
    653         //             knots[i].rtype = this.MP_CURL;
    654         //             knots[i].set_right_curl(val);
    655         //         } else if (parseInt(i, 10) === len - 1) {
    656         //             knots[i].ltype = this.MP_CURL;
    657         //             knots[i].set_left_curl(val);
    658         //         }
    659         //     }
    660         // }
    661
    662         // Set individual point control values
    663         for (ii in controls) {
    664             if (controls.hasOwnProperty(ii)) {
    665                 i = parseInt(ii, 10);
    666                 if (isNaN(i) || i < 0 || i >= len) {
    667                     continue;
    668                 }
    669
    670                 // Handle individual curl
    671                 obj = controls[i];
    672                 if (Type.exists(obj.type)) {
    673                     switch (obj.type) {
    674                         case 'curl':
    675                             val = Type.evaluate(obj.curl);
    676                             if (i === 0) {
    677                                 knots[i].rtype = this.MP_CURL;
    678                                 knots[i].set_right_curl(val);
    679                             } else if (i === len - 1) {
    680                                 knots[i].ltype = this.MP_CURL;
    681                                 knots[i].set_left_curl(val);
    682                             } else {
    683                                 knots[i].ltype = this.MP_CURL;
    684                                 knots[i].rtype = this.MP_CURL;
    685                                 knots[i].lx = val;
    686                                 knots[i].rx = val;
    687                             }
    688                             break;
    689                         }
    690                     }
    691
    692                     // Handle individual directions
    693                     if (Type.exists(obj.direction)) {
    694                         val = Type.evaluate(obj.direction);
    695                         if (Type.isArray(val)) {
    696                             if (val[0] !== false) {
    697                                 knots[i].lx = (val[0] * Math.PI) / 180;
    698                                 knots[i].ltype = this.MP_GIVEN;
    699                             }
    700                             if (val[1] !== false) {
    701                                 knots[i].rx = (val[1] * Math.PI) / 180;
    702                                 knots[i].rtype = this.MP_GIVEN;
    703                             }
    704                         } else {
    705                             knots[i].lx = (val * Math.PI) / 180;
    706                             knots[i].rx = (val * Math.PI) / 180;
    707                             knots[i].ltype = knots[i].rtype = this.MP_GIVEN;
    708                         }
    709                     }
    710
    711                     // Handle individual tension
    712                     if (Type.exists(obj.tension)) {
    713                         val = Type.evaluate(obj.tension);
    714                         if (Type.isArray(val)) {
    715                             if (val[0] !== false) {
    716                                 knots[i].ly = Type.evaluate(val[0]);
    717                             }
    718                             if (val[1] !== false) {
    719                                 knots[i].ry = Type.evaluate(val[1]);
    720                             }
    721                         } else {
    722                             knots[i].ly = val;
    723                             knots[i].ry = val;
    724                         }
    725                     }
    726                 }
    727             }
    728
    729             // Generate ths Bezier curve
    730             this.make_choices(knots);
    731
    732             // Return the coordinates
    733             for (i = 0; i < len - 1; i++) {
    734                 x.push(knots[i].x);
    735                 x.push(knots[i].rx);
    736                 x.push(knots[i + 1].lx);
    737                 y.push(knots[i].y);
    738                 y.push(knots[i].ry);
    739                 y.push(knots[i + 1].ly);
    740             }
    741             x.push(knots[len - 1].x);
    742             y.push(knots[len - 1].y);
    743
    744             if (isClosed) {
    745                 x.push(knots[len - 1].rx);
    746                 y.push(knots[len - 1].ry);
    747                 x.push(knots[0].lx);
    748                 y.push(knots[0].ly);
    749                 x.push(knots[0].x);
    750                 y.push(knots[0].y);
    751             }
    752
    753             return [x, y];
    754         }
    755     };
    756
    757     export default Mat.Metapost;
    758