opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/curves/NURBSCurve.js

@@ -0,0 +1,122 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../curves/NURBSUtils.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../curves/NURBSUtils.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.NURBSUtils);
+    global.NURBSCurve = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, NURBSUtils) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.NURBSCurve = void 0;
+  NURBSUtils = _interopRequireWildcard(NURBSUtils);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   * NURBS curve object
+   *
+   * Derives from Curve, overriding getPoint and getTangent.
+   *
+   * Implementation is based on (x, y [, z=0 [, w=1]]) control points with w=weight.
+   *
+   **/
+  var NURBSCurve = /*#__PURE__*/function (_Curve) {
+    _inherits(NURBSCurve, _Curve);
+
+    var _super = _createSuper(NURBSCurve);
+
+    function NURBSCurve(degree, knots
+    /* array of reals */
+    , controlPoints
+    /* array of Vector(2|3|4) */
+    , startKnot
+    /* index in knots */
+    , endKnot
+    /* index in knots */
+    ) {
+      var _this;
+
+      _classCallCheck(this, NURBSCurve);
+
+      _this = _super.call(this);
+      _this.degree = degree;
+      _this.knots = knots;
+      _this.controlPoints = []; // Used by periodic NURBS to remove hidden spans
+
+      _this.startKnot = startKnot || 0;
+      _this.endKnot = endKnot || _this.knots.length - 1;
+
+      for (var i = 0; i < controlPoints.length; ++i) {
+        // ensure Vector4 for control points
+        var point = controlPoints[i];
+        _this.controlPoints[i] = new _three.Vector4(point.x, point.y, point.z, point.w);
+      }
+
+      return _this;
+    }
+
+    _createClass(NURBSCurve, [{
+      key: "getPoint",
+      value: function getPoint(t) {
+        var optionalTarget = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector3();
+        var point = optionalTarget;
+        var u = this.knots[this.startKnot] + t * (this.knots[this.endKnot] - this.knots[this.startKnot]); // linear mapping t->u
+        // following results in (wx, wy, wz, w) homogeneous point
+
+        var hpoint = NURBSUtils.calcBSplinePoint(this.degree, this.knots, this.controlPoints, u);
+
+        if (hpoint.w !== 1.0) {
+          // project to 3D space: (wx, wy, wz, w) -> (x, y, z, 1)
+          hpoint.divideScalar(hpoint.w);
+        }
+
+        return point.set(hpoint.x, hpoint.y, hpoint.z);
+      }
+    }, {
+      key: "getTangent",
+      value: function getTangent(t) {
+        var optionalTarget = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector3();
+        var tangent = optionalTarget;
+        var u = this.knots[0] + t * (this.knots[this.knots.length - 1] - this.knots[0]);
+        var ders = NURBSUtils.calcNURBSDerivatives(this.degree, this.knots, this.controlPoints, u, 1);
+        tangent.copy(ders[1]).normalize();
+        return tangent;
+      }
+    }]);
+
+    return NURBSCurve;
+  }(_three.Curve);
+
+  _exports.NURBSCurve = NURBSCurve;
+});

data/lib-opal/js_wrap/three/curves/NURBSSurface.js

@@ -0,0 +1,78 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../curves/NURBSUtils.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../curves/NURBSUtils.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.NURBSUtils);
+    global.NURBSSurface = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, NURBSUtils) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.NURBSSurface = void 0;
+  NURBSUtils = _interopRequireWildcard(NURBSUtils);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  /**
+   * NURBS surface object
+   *
+   * Implementation is based on (x, y [, z=0 [, w=1]]) control points with w=weight.
+   **/
+  var NURBSSurface = /*#__PURE__*/function () {
+    function NURBSSurface(degree1, degree2, knots1, knots2
+    /* arrays of reals */
+    , controlPoints
+    /* array^2 of Vector(2|3|4) */
+    ) {
+      _classCallCheck(this, NURBSSurface);
+
+      this.degree1 = degree1;
+      this.degree2 = degree2;
+      this.knots1 = knots1;
+      this.knots2 = knots2;
+      this.controlPoints = [];
+      var len1 = knots1.length - degree1 - 1;
+      var len2 = knots2.length - degree2 - 1; // ensure Vector4 for control points
+
+      for (var i = 0; i < len1; ++i) {
+        this.controlPoints[i] = [];
+
+        for (var j = 0; j < len2; ++j) {
+          var point = controlPoints[i][j];
+          this.controlPoints[i][j] = new _three.Vector4(point.x, point.y, point.z, point.w);
+        }
+      }
+    }
+
+    _createClass(NURBSSurface, [{
+      key: "getPoint",
+      value: function getPoint(t1, t2, target) {
+        var u = this.knots1[0] + t1 * (this.knots1[this.knots1.length - 1] - this.knots1[0]); // linear mapping t1->u
+
+        var v = this.knots2[0] + t2 * (this.knots2[this.knots2.length - 1] - this.knots2[0]); // linear mapping t2->u
+
+        NURBSUtils.calcSurfacePoint(this.degree1, this.degree2, this.knots1, this.knots2, this.controlPoints, u, v, target);
+      }
+    }]);
+
+    return NURBSSurface;
+  }();
+
+  _exports.NURBSSurface = NURBSSurface;
+});

data/lib-opal/js_wrap/three/curves/NURBSUtils.js

@@ -0,0 +1,413 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.NURBSUtils = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.calcBSplineDerivatives = calcBSplineDerivatives;
+  _exports.calcBSplinePoint = calcBSplinePoint;
+  _exports.calcBasisFunctionDerivatives = calcBasisFunctionDerivatives;
+  _exports.calcBasisFunctions = calcBasisFunctions;
+  _exports.calcKoverI = calcKoverI;
+  _exports.calcNURBSDerivatives = calcNURBSDerivatives;
+  _exports.calcRationalCurveDerivatives = calcRationalCurveDerivatives;
+  _exports.calcSurfacePoint = calcSurfacePoint;
+  _exports.findSpan = findSpan;
+
+  /**
+   * NURBS utils
+   *
+   * See NURBSCurve and NURBSSurface.
+   **/
+
+  /**************************************************************
+   *	NURBS Utils
+   **************************************************************/
+
+  /*
+  Finds knot vector span.
+  
+  p : degree
+  u : parametric value
+  U : knot vector
+  
+  returns the span
+  */
+  function findSpan(p, u, U) {
+    var n = U.length - p - 1;
+
+    if (u >= U[n]) {
+      return n - 1;
+    }
+
+    if (u <= U[p]) {
+      return p;
+    }
+
+    var low = p;
+    var high = n;
+    var mid = Math.floor((low + high) / 2);
+
+    while (u < U[mid] || u >= U[mid + 1]) {
+      if (u < U[mid]) {
+        high = mid;
+      } else {
+        low = mid;
+      }
+
+      mid = Math.floor((low + high) / 2);
+    }
+
+    return mid;
+  }
+  /*
+  Calculate basis functions. See The NURBS Book, page 70, algorithm A2.2
+  
+  span : span in which u lies
+  u    : parametric point
+  p    : degree
+  U    : knot vector
+  
+  returns array[p+1] with basis functions values.
+  */
+
+
+  function calcBasisFunctions(span, u, p, U) {
+    var N = [];
+    var left = [];
+    var right = [];
+    N[0] = 1.0;
+
+    for (var j = 1; j <= p; ++j) {
+      left[j] = u - U[span + 1 - j];
+      right[j] = U[span + j] - u;
+      var saved = 0.0;
+
+      for (var r = 0; r < j; ++r) {
+        var rv = right[r + 1];
+        var lv = left[j - r];
+        var temp = N[r] / (rv + lv);
+        N[r] = saved + rv * temp;
+        saved = lv * temp;
+      }
+
+      N[j] = saved;
+    }
+
+    return N;
+  }
+  /*
+  Calculate B-Spline curve points. See The NURBS Book, page 82, algorithm A3.1.
+  
+  p : degree of B-Spline
+  U : knot vector
+  P : control points (x, y, z, w)
+  u : parametric point
+  
+  returns point for given u
+  */
+
+
+  function calcBSplinePoint(p, U, P, u) {
+    var span = findSpan(p, u, U);
+    var N = calcBasisFunctions(span, u, p, U);
+    var C = new _three.Vector4(0, 0, 0, 0);
+
+    for (var j = 0; j <= p; ++j) {
+      var point = P[span - p + j];
+      var Nj = N[j];
+      var wNj = point.w * Nj;
+      C.x += point.x * wNj;
+      C.y += point.y * wNj;
+      C.z += point.z * wNj;
+      C.w += point.w * Nj;
+    }
+
+    return C;
+  }
+  /*
+  Calculate basis functions derivatives. See The NURBS Book, page 72, algorithm A2.3.
+  
+  span : span in which u lies
+  u    : parametric point
+  p    : degree
+  n    : number of derivatives to calculate
+  U    : knot vector
+  
+  returns array[n+1][p+1] with basis functions derivatives
+  */
+
+
+  function calcBasisFunctionDerivatives(span, u, p, n, U) {
+    var zeroArr = [];
+
+    for (var i = 0; i <= p; ++i) {
+      zeroArr[i] = 0.0;
+    }
+
+    var ders = [];
+
+    for (var _i = 0; _i <= n; ++_i) {
+      ders[_i] = zeroArr.slice(0);
+    }
+
+    var ndu = [];
+
+    for (var _i2 = 0; _i2 <= p; ++_i2) {
+      ndu[_i2] = zeroArr.slice(0);
+    }
+
+    ndu[0][0] = 1.0;
+    var left = zeroArr.slice(0);
+    var right = zeroArr.slice(0);
+
+    for (var j = 1; j <= p; ++j) {
+      left[j] = u - U[span + 1 - j];
+      right[j] = U[span + j] - u;
+      var saved = 0.0;
+
+      for (var _r = 0; _r < j; ++_r) {
+        var rv = right[_r + 1];
+        var lv = left[j - _r];
+        ndu[j][_r] = rv + lv;
+        var temp = ndu[_r][j - 1] / ndu[j][_r];
+        ndu[_r][j] = saved + rv * temp;
+        saved = lv * temp;
+      }
+
+      ndu[j][j] = saved;
+    }
+
+    for (var _j = 0; _j <= p; ++_j) {
+      ders[0][_j] = ndu[_j][p];
+    }
+
+    for (var _r2 = 0; _r2 <= p; ++_r2) {
+      var s1 = 0;
+      var s2 = 1;
+      var a = [];
+
+      for (var _i3 = 0; _i3 <= p; ++_i3) {
+        a[_i3] = zeroArr.slice(0);
+      }
+
+      a[0][0] = 1.0;
+
+      for (var k = 1; k <= n; ++k) {
+        var d = 0.0;
+        var rk = _r2 - k;
+        var pk = p - k;
+
+        if (_r2 >= k) {
+          a[s2][0] = a[s1][0] / ndu[pk + 1][rk];
+          d = a[s2][0] * ndu[rk][pk];
+        }
+
+        var j1 = rk >= -1 ? 1 : -rk;
+        var j2 = _r2 - 1 <= pk ? k - 1 : p - _r2;
+
+        for (var _j3 = j1; _j3 <= j2; ++_j3) {
+          a[s2][_j3] = (a[s1][_j3] - a[s1][_j3 - 1]) / ndu[pk + 1][rk + _j3];
+          d += a[s2][_j3] * ndu[rk + _j3][pk];
+        }
+
+        if (_r2 <= pk) {
+          a[s2][k] = -a[s1][k - 1] / ndu[pk + 1][_r2];
+          d += a[s2][k] * ndu[_r2][pk];
+        }
+
+        ders[k][_r2] = d;
+        var _j2 = s1;
+        s1 = s2;
+        s2 = _j2;
+      }
+    }
+
+    var r = p;
+
+    for (var _k = 1; _k <= n; ++_k) {
+      for (var _j4 = 0; _j4 <= p; ++_j4) {
+        ders[_k][_j4] *= r;
+      }
+
+      r *= p - _k;
+    }
+
+    return ders;
+  }
+  /*
+  	Calculate derivatives of a B-Spline. See The NURBS Book, page 93, algorithm A3.2.
+  
+  	p  : degree
+  	U  : knot vector
+  	P  : control points
+  	u  : Parametric points
+  	nd : number of derivatives
+  
+  	returns array[d+1] with derivatives
+  	*/
+
+
+  function calcBSplineDerivatives(p, U, P, u, nd) {
+    var du = nd < p ? nd : p;
+    var CK = [];
+    var span = findSpan(p, u, U);
+    var nders = calcBasisFunctionDerivatives(span, u, p, du, U);
+    var Pw = [];
+
+    for (var i = 0; i < P.length; ++i) {
+      var point = P[i].clone();
+      var w = point.w;
+      point.x *= w;
+      point.y *= w;
+      point.z *= w;
+      Pw[i] = point;
+    }
+
+    for (var k = 0; k <= du; ++k) {
+      var _point = Pw[span - p].clone().multiplyScalar(nders[k][0]);
+
+      for (var j = 1; j <= p; ++j) {
+        _point.add(Pw[span - p + j].clone().multiplyScalar(nders[k][j]));
+      }
+
+      CK[k] = _point;
+    }
+
+    for (var _k2 = du + 1; _k2 <= nd + 1; ++_k2) {
+      CK[_k2] = new _three.Vector4(0, 0, 0);
+    }
+
+    return CK;
+  }
+  /*
+  Calculate "K over I"
+  
+  returns k!/(i!(k-i)!)
+  */
+
+
+  function calcKoverI(k, i) {
+    var nom = 1;
+
+    for (var j = 2; j <= k; ++j) {
+      nom *= j;
+    }
+
+    var denom = 1;
+
+    for (var _j5 = 2; _j5 <= i; ++_j5) {
+      denom *= _j5;
+    }
+
+    for (var _j6 = 2; _j6 <= k - i; ++_j6) {
+      denom *= _j6;
+    }
+
+    return nom / denom;
+  }
+  /*
+  Calculate derivatives (0-nd) of rational curve. See The NURBS Book, page 127, algorithm A4.2.
+  
+  Pders : result of function calcBSplineDerivatives
+  
+  returns array with derivatives for rational curve.
+  */
+
+
+  function calcRationalCurveDerivatives(Pders) {
+    var nd = Pders.length;
+    var Aders = [];
+    var wders = [];
+
+    for (var i = 0; i < nd; ++i) {
+      var point = Pders[i];
+      Aders[i] = new _three.Vector3(point.x, point.y, point.z);
+      wders[i] = point.w;
+    }
+
+    var CK = [];
+
+    for (var k = 0; k < nd; ++k) {
+      var v = Aders[k].clone();
+
+      for (var _i4 = 1; _i4 <= k; ++_i4) {
+        v.sub(CK[k - _i4].clone().multiplyScalar(calcKoverI(k, _i4) * wders[_i4]));
+      }
+
+      CK[k] = v.divideScalar(wders[0]);
+    }
+
+    return CK;
+  }
+  /*
+  Calculate NURBS curve derivatives. See The NURBS Book, page 127, algorithm A4.2.
+  
+  p  : degree
+  U  : knot vector
+  P  : control points in homogeneous space
+  u  : parametric points
+  nd : number of derivatives
+  
+  returns array with derivatives.
+  */
+
+
+  function calcNURBSDerivatives(p, U, P, u, nd) {
+    var Pders = calcBSplineDerivatives(p, U, P, u, nd);
+    return calcRationalCurveDerivatives(Pders);
+  }
+  /*
+  Calculate rational B-Spline surface point. See The NURBS Book, page 134, algorithm A4.3.
+  
+  p1, p2 : degrees of B-Spline surface
+  U1, U2 : knot vectors
+  P      : control points (x, y, z, w)
+  u, v   : parametric values
+  
+  returns point for given (u, v)
+  */
+
+
+  function calcSurfacePoint(p, q, U, V, P, u, v, target) {
+    var uspan = findSpan(p, u, U);
+    var vspan = findSpan(q, v, V);
+    var Nu = calcBasisFunctions(uspan, u, p, U);
+    var Nv = calcBasisFunctions(vspan, v, q, V);
+    var temp = [];
+
+    for (var l = 0; l <= q; ++l) {
+      temp[l] = new _three.Vector4(0, 0, 0, 0);
+
+      for (var k = 0; k <= p; ++k) {
+        var point = P[uspan - p + k][vspan - q + l].clone();
+        var w = point.w;
+        point.x *= w;
+        point.y *= w;
+        point.z *= w;
+        temp[l].add(point.multiplyScalar(Nu[k]));
+      }
+    }
+
+    var Sw = new _three.Vector4(0, 0, 0, 0);
+
+    for (var _l = 0; _l <= q; ++_l) {
+      Sw.add(temp[_l].multiplyScalar(Nv[_l]));
+    }
+
+    Sw.divideScalar(Sw.w);
+    target.set(Sw.x, Sw.y, Sw.z);
+  }
+});