void splineInter2D(double *Tc, double *dT, const double *T, const double *omega, const double *m, int N, const double *X, double *h, bool doDerivative, bool boundary) { // Increments in X and Y direction int xf, yf, i, j, k, m0 = m[0], m1 = m[1]; double x, y, p; //for each value X compute the value in the spline #pragma omp parallel for default(shared) private(x, y, xf, yf, p, i, j, k) for (i=0;i<N;i++) { Tc[i] = 0; x = (X[i] - omega[0]) / h[0] + .5 - 1; y = (X[i+N] - omega[2]) / h[1] + .5 - 1; //check if it is a valid x if (!boundary && (x<=-2 || y<=-2 || x>=m0+1 || y>=m1+1)) continue; xf = floor(x); yf = floor(y); x = x - xf; y = y - yf; if (doDerivative) { dT[i] = 0; dT[i+N] = 0; } for (j=-1;j<3;j++) { for (k=-1;k<3;k++) { if (boundary) { p = T[min(m0-1,max(0,xf+j))+m0*(min(m1-1,max(0,yf+k)))]; } else { p = (xf+j<0 || xf+j>m0-1 || yf+k<0 || yf+k>m1-1)? 0: T[xf+j+m0*(yf+k)]; } Tc[i] += p*b0(3-j,x-j)*b0(3-k,y-k); if (doDerivative) { dT[i] += p*db0(3-j,x-j)* b0(3-k,y-k); dT[i+N] += p* b0(3-j,x-j)*db0(3-k,y-k); } } } if (mxIsNaN(Tc[i])) mexPrintf("Is NAN. "); if (doDerivative) { dT[i] = dT[i]/h[0]; dT[i+N] = dT[i+N]/h[1]; } } }
void splineInter1D(double *Tc, double *dT, const double *T, const double *omega, const double *m, int N, const double *X, double *h, bool doDerivative, bool boundary) { int xf, i, j, m0 = m[0]; double x, p; #pragma omp parallel for default(shared) private(x, xf, p, i, j) for (i=0;i<N;i++) { Tc[i] = 0; x = (X[i] - omega[0]) / h[0] + .5 - 1; //subtract 1 for indexing purposes in C //check if it is a valid x if (!boundary && (x<=-2 || x>=m0+1)) continue; xf = floor(x); x = x - xf; if (doDerivative) { dT[i] = 0; } for (j=-1;j<3;j++) { if (boundary) { p = T[min(m0-1,max(0,xf+j))]; } else { p = (xf+j<0 || xf+j>m0-1)? 0: T[xf+j]; } Tc[i] += p*b0(3-j,x-j); if (doDerivative) { dT[i] += p*db0(3-j,x-j); } } if (mxIsNaN(Tc[i])) mexPrintf("Is NAN. "); if (doDerivative) { dT[i] = dT[i]/h[0]; } } }
static PyObject *test(PyObject *self,PyObject *args) { double r; fprintf(stderr,"overflow"); r = overflow(1.e160); printerr(r); fprintf(stderr,"\ndiv by 0"); r = db0(0.0); printerr(r); fprintf(stderr,"\nnested outer"); r = nest1(0, 0.0); printerr(r); fprintf(stderr,"\nnested inner"); r = nest1(1, 1.0); printerr(r); fprintf(stderr,"\ntrailing outer"); r = nest1(2, 2.0); printerr(r); fprintf(stderr,"\nnested prior"); r = nest2(0, 0.0); printerr(r); fprintf(stderr,"\nnested interior"); r = nest2(1, 1.0); printerr(r); fprintf(stderr,"\nnested trailing"); r = nest2(2, 2.0); printerr(r); Py_INCREF (Py_None); return Py_None; }
void splineInter3D(double *Tc, double *dT, const double *T, const double *omega, const double *m, int N, const double *X, double *h, bool doDerivative, bool boundary) { int xf, yf, zf, i, j, k, l; int i1 = 1, m0 = m[0], m1 = m[1], m2 = m[2], m01 = m0*m1; double x, y, z, p; // Increments in X,Y and Z direction #pragma omp parallel for default(shared) private(x, y, z, xf, yf, zf, p, i, j, k, l) for (i=0;i<N;i++) { Tc[i] = 0; x = (X[i] - omega[0]) / h[0] + .5 - 1; y = (X[i+N] - omega[2]) / h[1] + .5 - 1; z = (X[i+2*N] - omega[4]) / h[2] + .5 - 1; xf = floor(x); yf = floor(y); zf = floor(z); //check if it is a valid x if (!boundary && (x<=-2 || y<=-2 || z<=-2 || x>=m[0]+1 || y>=m1+1|| z>=m2+1)) continue; // Extract remainder x = x - xf; y = y - yf; z = z - zf; if (doDerivative) { dT[i] = 0; dT[i+N] = 0; dT[i+2*N] = 0; } for (j=-1;j<3;j++) { for (k=-1;k<3;k++) { for (l=-1;l<3;l++) { if (boundary) { p = T[min(m0-1,max(0,xf+j))+m0*(min(m1-1,max(0,yf+k)))+m01*(min(m2-1,max(0,zf+l)))]; } else { p = (xf+j<0 || xf+j>m0-1 || yf+k<0 || yf+k>m1-1 || zf+l<0 || zf+l>m2-1)? 0: T[xf+j+m0*(yf+k)+m01*(zf+l)]; } Tc[i] += p*b0(3-j,x-j)*b0(3-k,y-k)*b0(3-l,z-l); if (doDerivative) { dT[i] += p*db0(3-j,x-j)* b0(3-k,y-k)* b0(3-l,z-l); dT[i+N] += p* b0(3-j,x-j)*db0(3-k,y-k)* b0(3-l,z-l); dT[i+2*N] += p* b0(3-j,x-j)* b0(3-k,y-k)*db0(3-l,z-l); } } } } if (mxIsNaN(Tc[i])) mexPrintf("Is NAN. "); if (doDerivative) { dT[i] = dT[i]/h[0]; dT[i+N] = dT[i+N]/h[1]; dT[i+2*N] = dT[i+2*N]/h[2]; } } }
// Compute the normal at a specific point in the patch. // The s and t values vary between 0 and 1. QVector3D QGLBezierPatch::normal(qreal s, qreal t) const { qreal a[4]; qreal b[4]; qreal tx, ty, tz; qreal sx, sy, sz; // Compute the derivative of the surface in t. a[0] = b0(s); a[1] = b1(s); a[2] = b2(s); a[3] = b3(s); b[0] = db0(t); b[1] = db1(t); b[2] = db2(t); b[3] = db3(t); tx = 0.0f; ty = 0.0f; tz = 0.0f; for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) { tx += a[i] * points[j * 4 + i].x() * b[j]; ty += a[i] * points[j * 4 + i].y() * b[j]; tz += a[i] * points[j * 4 + i].z() * b[j]; } } // Compute the derivative of the surface in s. a[0] = db0(s); a[1] = db1(s); a[2] = db2(s); a[3] = db3(s); b[0] = b0(t); b[1] = b1(t); b[2] = b2(t); b[3] = b3(t); sx = 0.0f; sy = 0.0f; sz = 0.0f; for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) { sx += a[i] * points[j * 4 + i].x() * b[j]; sy += a[i] * points[j * 4 + i].y() * b[j]; sz += a[i] * points[j * 4 + i].z() * b[j]; } } // The normal is the cross-product of the two derivatives, // normalized to a unit vector. QVector3D n = QVector3D::normal(QVector3D(sx, sy, sz), QVector3D(tx, ty, tz)); if (n.isNull()) { // A zero normal may occur if one of the patch edges is zero-length. // We correct for this by substituting an overall patch normal that // we compute from two of the sides that are not zero in length. QVector3D sides[4]; QVector3D vectors[2]; sides[0] = points[3] - points[0]; sides[1] = points[15] - points[3]; sides[2] = points[12] - points[15]; sides[3] = points[0] - points[12]; int i = 0; int j = 0; vectors[0] = QVector3D(1.0f, 0.0f, 0.0f); vectors[1] = QVector3D(0.0f, 1.0f, 0.0f); while (i < 2 && j < 4) { if (sides[j].isNull()) ++j; else vectors[i++] = sides[j++]; } n = QVector3D::normal(vectors[0], vectors[1]); } return n; }