|
|
@@ -0,0 +1,394 @@
|
|
|
+/**
|
|
|
+ * @author renej
|
|
|
+ * NURBS utils
|
|
|
+ *
|
|
|
+ * See NURBSCurve and NURBSSurface.
|
|
|
+ *
|
|
|
+ **/
|
|
|
+
|
|
|
+
|
|
|
+/**************************************************************
|
|
|
+ * NURBS Utils
|
|
|
+ **************************************************************/
|
|
|
+
|
|
|
+THREE.NURBSUtils = {
|
|
|
+
|
|
|
+ /*
|
|
|
+ Finds knot vector span.
|
|
|
+
|
|
|
+ p : degree
|
|
|
+ u : parametric value
|
|
|
+ U : knot vector
|
|
|
+
|
|
|
+ returns the span
|
|
|
+ */
|
|
|
+ findSpan: function( 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.
|
|
|
+ */
|
|
|
+ calcBasisFunctions: function( 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
|
|
|
+ */
|
|
|
+ calcBSplinePoint: function( p, U, P, u ) {
|
|
|
+ var span = this.findSpan(p, u, U);
|
|
|
+ var N = this.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
|
|
|
+ */
|
|
|
+ calcBasisFunctionDerivatives: function( 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 i = 0; i <= p; ++i)
|
|
|
+ ndu[i] = 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 r = 0; r <= p; ++r) {
|
|
|
+ var s1 = 0;
|
|
|
+ var s2 = 1;
|
|
|
+
|
|
|
+ var a = [];
|
|
|
+ for (var i = 0; i <= p; ++i) {
|
|
|
+ a[i] = zeroArr.slice(0);
|
|
|
+ }
|
|
|
+ a[0][0] = 1.0;
|
|
|
+
|
|
|
+ for (var k = 1; k <= n; ++k) {
|
|
|
+ var d = 0.0;
|
|
|
+ var rk = r - k;
|
|
|
+ var pk = p - k;
|
|
|
+
|
|
|
+ if (r >= 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 = (r - 1 <= pk) ? k - 1 : p - r;
|
|
|
+
|
|
|
+ for (var j = j1; j <= j2; ++j) {
|
|
|
+ a[s2][j] = (a[s1][j] - a[s1][j - 1]) / ndu[pk + 1][rk + j];
|
|
|
+ d += a[s2][j] * ndu[rk + j][pk];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (r <= pk) {
|
|
|
+ a[s2][k] = -a[s1][k - 1] / ndu[pk + 1][r];
|
|
|
+ d += a[s2][k] * ndu[r][pk];
|
|
|
+ }
|
|
|
+
|
|
|
+ ders[k][r] = d;
|
|
|
+
|
|
|
+ var j = s1;
|
|
|
+ s1 = s2;
|
|
|
+ s2 = j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var r = p;
|
|
|
+
|
|
|
+ for (var k = 1; k <= n; ++k) {
|
|
|
+ for (var j = 0; j <= p; ++j) {
|
|
|
+ ders[k][j] *= 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
|
|
|
+ */
|
|
|
+ calcBSplineDerivatives: function( p, U, P, u, nd ) {
|
|
|
+ var du = nd < p ? nd : p;
|
|
|
+ var CK = [];
|
|
|
+ var span = this.findSpan(p, u, U);
|
|
|
+ var nders = this.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 k = du + 1; k <= nd + 1; ++k) {
|
|
|
+ CK[k] = new THREE.Vector4(0, 0, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ return CK;
|
|
|
+ },
|
|
|
+
|
|
|
+
|
|
|
+ /*
|
|
|
+ Calculate "K over I"
|
|
|
+
|
|
|
+ returns k!/(i!(k-i)!)
|
|
|
+ */
|
|
|
+ calcKoverI: function( k, i ) {
|
|
|
+ var nom = 1;
|
|
|
+
|
|
|
+ for (var j = 2; j <= k; ++j) {
|
|
|
+ nom *= j;
|
|
|
+ }
|
|
|
+
|
|
|
+ var denom = 1;
|
|
|
+
|
|
|
+ for (var j = 2; j <= i; ++j) {
|
|
|
+ denom *= j;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var j = 2; j <= k - i; ++j) {
|
|
|
+ denom *= j;
|
|
|
+ }
|
|
|
+
|
|
|
+ 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.
|
|
|
+ */
|
|
|
+ calcRationalCurveDerivatives: function ( 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 i = 1; i <= k; ++i) {
|
|
|
+ v.sub(CK[k - i].clone().multiplyScalar(this.calcKoverI(k,i) * wders[i]));
|
|
|
+ }
|
|
|
+
|
|
|
+ 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.
|
|
|
+ */
|
|
|
+ calcNURBSDerivatives: function( p, U, P, u, nd ) {
|
|
|
+ var Pders = this.calcBSplineDerivatives(p, U, P, u, nd);
|
|
|
+ return this.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)
|
|
|
+ */
|
|
|
+ calcSurfacePoint: function( p, q, U, V, P, u, v ) {
|
|
|
+ var uspan = this.findSpan(p, u, U);
|
|
|
+ var vspan = this.findSpan(q, v, V);
|
|
|
+ var Nu = this.calcBasisFunctions(uspan, u, p, U);
|
|
|
+ var Nv = this.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);
|
|
|
+ return new THREE.Vector3(Sw.x, Sw.y, Sw.z);
|
|
|
+ }
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+
|
renej-github