void
testeigen(double tt[7], double eval[3], double evec[9]) {
double mat[9], dot[3], cross[3];
unsigned int ii;
TEN_T2M(mat, tt);
printf("evals %g %g %g\n", eval[0], eval[1], eval[2]);
printf("evec0 (%g) %g %g %g\n",
ELL_3V_LEN(evec + 0), evec[0], evec[1], evec[2]);
printf("evec1 (%g) %g %g %g\n",
ELL_3V_LEN(evec + 3), evec[3], evec[4], evec[5]);
printf("evec2 (%g) %g %g %g\n",
ELL_3V_LEN(evec + 6), evec[6], evec[7], evec[8]);
printf("Mv - lv: (len) X Y Z (should be ~zeros)\n");
for (ii=0; ii<3; ii++) {
double uu[3], vv[3], dd[3];
ELL_3MV_MUL(uu, mat, evec + 3*ii);
ELL_3V_SCALE(vv, eval[ii], evec + 3*ii);
ELL_3V_SUB(dd, uu, vv);
printf("%d: (%g) %g %g %g\n", ii, ELL_3V_LEN(dd), dd[0], dd[1], dd[2]);
}
dot[0] = ELL_3V_DOT(evec + 0, evec + 3);
dot[1] = ELL_3V_DOT(evec + 0, evec + 6);
dot[2] = ELL_3V_DOT(evec + 3, evec + 6);
printf("pairwise dots: (%g) %g %g %g\n",
ELL_3V_LEN(dot), dot[0], dot[1], dot[2]);
ELL_3V_CROSS(cross, evec+0, evec+3);
printf("right-handed: %g\n", ELL_3V_DOT(evec+6, cross));
return;
}
void
_tenFiberAlign(tenFiberContext *tfx, double vec[3]) {
if (!(tfx->lastDirSet)) {
/* this is the first step (or one of the intermediate steps
for RK4) in this fiber half; 1st half follows the
eigenvector determined at seed point, 2nd goes opposite */
if (!tfx->dir) {
/* 1st half */
if (ELL_3V_DOT(tfx->firstEvec, vec) < 0) {
ELL_3V_SCALE(vec, -1, vec);
}
} else {
/* 2nd half */
if (ELL_3V_DOT(tfx->firstEvec, vec) > 0) {
ELL_3V_SCALE(vec, -1, vec);
}
}
} else {
/* we have some history in this fiber half */
if (ELL_3V_DOT(tfx->lastDir, vec) < 0) {
ELL_3V_SCALE(vec, -1, vec);
}
}
return;
}
int
_echoRayIntx_Sphere(RAYINTX_ARGS(Sphere)) {
echoPos_t t, A, B, C, r[3], dscr, pos[3], tmp;
AIR_UNUSED(parm);
AIR_UNUSED(tstate);
ELL_3V_SUB(r, ray->from, obj->pos);
A = ELL_3V_DOT(ray->dir, ray->dir);
B = 2*ELL_3V_DOT(ray->dir, r);
C = ELL_3V_DOT(r, r) - obj->rad*obj->rad;
dscr = B*B - 4*A*C;
if (dscr <= 0) {
/* grazes or misses (most common case) */
return AIR_FALSE;
}
/* else */
dscr = sqrt(dscr);
t = (-B - dscr)/(2*A);
if (!AIR_IN_CL(ray->neer, t, ray->faar)) {
t = (-B + dscr)/(2*A);
if (!AIR_IN_CL(ray->neer, t, ray->faar)) {
return AIR_FALSE;
}
}
/* else one of the intxs is in [neer,faar] segment */
intx->t = t;
ELL_3V_SCALE_ADD2(pos, 1, ray->from, t, ray->dir);
ELL_3V_SUB(intx->norm, pos, obj->pos);
ELL_3V_NORM(intx->norm, intx->norm, tmp);
intx->obj = OBJECT(obj);
/* does NOT set u, v */
return AIR_TRUE;
}
void
_coilKind7TensorFilterFinish(coil_t *delta, coil_t **iv3,
double spacing[3],
double parm[COIL_PARMS_NUM]) {
coil_t rspX, rspY, rspZ,
rspsqX, rspsqY, rspsqZ;
double eval[3], evec[9], tens[7], tengrad[21], grad[3], LL, KK,
cnd,
dmu1[7], dmu2[7], dskw[7], phi3[7];
rspX = AIR_CAST(coil_t, 1.0/spacing[0]); rspsqX = rspX*rspX;
rspY = AIR_CAST(coil_t, 1.0/spacing[1]); rspsqY = rspY*rspY;
rspZ = AIR_CAST(coil_t, 1.0/spacing[2]); rspsqZ = rspZ*rspZ;
TENS(tens, iv3);
TENGRAD(tengrad, iv3, rspX, rspY, rspZ);
tenEigensolve_d(eval, evec, tens);
tenInvariantGradientsK_d(dmu1, dmu2, dskw, tens, 0.000001);
tenRotationTangents_d(NULL, NULL, phi3, evec);
/* \midhat{\nabla} \mu_1 ----------------- */
ELL_3V_SET(grad,
TEN_T_DOT(dmu1, tengrad + 0*7),
TEN_T_DOT(dmu1, tengrad + 1*7),
TEN_T_DOT(dmu1, tengrad + 2*7));
LL = ELL_3V_DOT(grad,grad);
KK = parm[1]*parm[1];
cnd = _COIL_CONDUCT(LL, KK);
/* \midhat{\nabla} \mu_2 ----------------- */
ELL_3V_SET(grad,
TEN_T_DOT(dmu2, tengrad + 0*7),
TEN_T_DOT(dmu2, tengrad + 1*7),
TEN_T_DOT(dmu2, tengrad + 2*7));
LL = ELL_3V_DOT(grad,grad);
KK = parm[2]*parm[2];
cnd *= _COIL_CONDUCT(LL, KK);
/* \midhat{\nabla} \skw and twist! ----------------- */
ELL_3V_SET(grad,
TEN_T_DOT(dskw, tengrad + 0*7),
TEN_T_DOT(dskw, tengrad + 1*7),
TEN_T_DOT(dskw, tengrad + 2*7));
LL = ELL_3V_DOT(grad,grad);
ELL_3V_SET(grad,
TEN_T_DOT(phi3, tengrad + 0*7),
TEN_T_DOT(phi3, tengrad + 1*7),
TEN_T_DOT(phi3, tengrad + 2*7));
LL += ELL_3V_DOT(grad,grad);
KK = AIR_CAST(coil_t, parm[3]*parm[3]);
cnd *= _COIL_CONDUCT(LL, KK);
delta[0]= 0.0f;
delta[1]= AIR_CAST(coil_t, parm[0]*cnd*LAPL(iv3, 1, rspsqX, rspsqY, rspsqZ));
delta[2]= AIR_CAST(coil_t, parm[0]*cnd*LAPL(iv3, 2, rspsqX, rspsqY, rspsqZ));
delta[3]= AIR_CAST(coil_t, parm[0]*cnd*LAPL(iv3, 3, rspsqX, rspsqY, rspsqZ));
delta[4]= AIR_CAST(coil_t, parm[0]*cnd*LAPL(iv3, 4, rspsqX, rspsqY, rspsqZ));
delta[5]= AIR_CAST(coil_t, parm[0]*cnd*LAPL(iv3, 5, rspsqX, rspsqY, rspsqZ));
delta[6]= AIR_CAST(coil_t, parm[0]*cnd*LAPL(iv3, 6, rspsqX, rspsqY, rspsqZ));
}
/* Calculate the Q-ball profile from DWIs */
void
_tenQball(const double b, const int gradcount, const double svals[],
const double grads[], double qvals[] ) {
/* Not an optimal Q-ball implementation! (Taken from submission to
MICCAI 2006) Should be solved analytically in the future,
implemented from recent papers. */
int i,j;
double d, dist, weight, min, max;
AIR_UNUSED(b);
min = max = svals[1] / svals[0];
for( i = 0; i < gradcount; i++ ) {
d = svals[i+1] / svals[0];
if( d > max )
max = d;
else if( d < min )
min = d;
}
for( i = 0; i < gradcount; i++ ) {
qvals[i] = 0;
for( j = 0; j < gradcount; j++ ) {
d = AIR_AFFINE( min, svals[j+1] / svals[0], max, 0,1 );
dist = ELL_3V_DOT(grads + 3*i, grads + 3*j);
dist = AIR_ABS(dist);
weight = cos( 0.5 * AIR_PI * dist );
qvals[i] += d * weight*weight*weight*weight;
}
}
return;
}
void
limnLightDiffuseCB(float rgb[3], float vec[3], void *_lit) {
float dot, r, g, b, norm;
limnLight *lit;
int i;
lit = (limnLight *)_lit;
ELL_3V_NORM_TT(vec, float, vec, norm);
r = lit->amb[0];
g = lit->amb[1];
b = lit->amb[2];
for (i=0; i<LIMN_LIGHT_NUM; i++) {
if (!lit->on[i])
continue;
dot = ELL_3V_DOT(vec, lit->dir[i]);
dot = AIR_MAX(0, dot);
r += dot*lit->col[i][0];
g += dot*lit->col[i][1];
b += dot*lit->col[i][2];
}
/* not really our job to be doing clamping here ... */
rgb[0] = r;
rgb[1] = g;
rgb[2] = b;
}
/*
** makes sure that v+3*2 has a positive dot product with
** cross product of v+3*0 and v+3*1
*/
void
_ell_3m_make_right_handed_d(double v[9]) {
double x[3];
ELL_3V_CROSS(x, v+3*0, v+3*1);
if (0 > ELL_3V_DOT(x, v+3*2)) {
ELL_3V_SCALE(v+3*2, -1, v+3*2);
}
}
static void
simulate(double *dwiSim, const double *parm, const tenExperSpec *espec) {
unsigned int ii;
double th0, frac, th1, vec0[3], vec1[3];
/* not used: b0 = parm[0]; */
th0 = parm[1];
frac = parm[2];
th1 = parm[3];
ELL_3V_SET(vec0, cos(th0), sin(th0), 0.0);
ELL_3V_SET(vec1, cos(th1), sin(th1), 0.0);
for (ii=0; ii<espec->imgNum; ii++) {
double dot0, dot1;
dot0 = ELL_3V_DOT(vec0, espec->grad + 3*ii);
dot1 = ELL_3V_DOT(vec1, espec->grad + 3*ii);
dwiSim[ii] = AIR_LERP(frac, dot0, dot1);
}
return;
}
void
_ell_align3_d(double v[9]) {
double d0, d1, d2;
int Mi, ai, bi;
d0 = ELL_3V_DOT(v+0, v+0);
d1 = ELL_3V_DOT(v+3, v+3);
d2 = ELL_3V_DOT(v+6, v+6);
Mi = ELL_MAX3_IDX(d0, d1, d2);
ai = (Mi + 1) % 3;
bi = (Mi + 2) % 3;
/* lop A */
if (ELL_3V_DOT(v+3*Mi, v+3*ai) < 0) {
ELL_3V_SCALE(v+3*ai, -1, v+3*ai);
}
if (ELL_3V_DOT(v+3*Mi, v+3*bi) < 0) {
ELL_3V_SCALE(v+3*bi, -1, v+3*bi);
}
/* lob B */
/* we can't guarantee that dot(v+3*ai,v+3*bi) > 0 . . . */
}
void
_coilKindScalarFilterPeronaMalik(coil_t *delta, coil_t **iv3,
double spacing[3],
double parm[COIL_PARMS_NUM]) {
coil_t forwX[3], backX[3], forwY[3], backY[3], forwZ[3], backZ[3],
KK, rspX, rspY, rspZ;
/* reciprocals of spacings in X, Y, and Z */
rspX = AIR_CAST(coil_t, 1.0/spacing[0]);
rspY = AIR_CAST(coil_t, 1.0/spacing[1]);
rspZ = AIR_CAST(coil_t, 1.0/spacing[2]);
_coilKindScalar3x3x3Gradients(forwX, backX,
forwY, backY,
forwZ, backZ,
iv3,
rspX, rspY, rspZ);
/* compute fluxes */
KK = AIR_CAST(coil_t, parm[1]*parm[1]);
forwX[0] *= _COIL_CONDUCT(ELL_3V_DOT(forwX, forwX), KK);
forwY[1] *= _COIL_CONDUCT(ELL_3V_DOT(forwY, forwY), KK);
forwZ[2] *= _COIL_CONDUCT(ELL_3V_DOT(forwZ, forwZ), KK);
backX[0] *= _COIL_CONDUCT(ELL_3V_DOT(backX, backX), KK);
backY[1] *= _COIL_CONDUCT(ELL_3V_DOT(backY, backY), KK);
backZ[2] *= _COIL_CONDUCT(ELL_3V_DOT(backZ, backZ), KK);
delta[0] = AIR_CAST(coil_t, parm[0])*(rspX*(forwX[0] - backX[0])
+ rspY*(forwY[1] - backY[1])
+ rspZ*(forwZ[2] - backZ[2]));
}
static void
simulate(double *dwiSim, const double *parm, const tenExperSpec *espec) {
unsigned int ii;
double theta, vec[3];
/* not used: b0 = parm[0]; */
theta = parm[1];
ELL_3V_SET(vec, cos(theta), sin(theta), 0.0);
for (ii=0; ii<espec->imgNum; ii++) {
dwiSim[ii] = ELL_3V_DOT(vec, espec->grad + 3*ii);
}
return;
}
/*
** leaves v+3*0 untouched, but makes sure that v+3*0, v+3*1, and v+3*2
** are mutually orthogonal. Also leaves the magnitudes of all
** vectors unchanged.
*/
void
_ell_3m_enforce_orthogonality(double v[9]) {
double d00, d10, d11, d20, d21, d22, scl, tv[3];
d00 = ELL_3V_DOT(v+3*0, v+3*0);
d10 = ELL_3V_DOT(v+3*1, v+3*0);
d11 = ELL_3V_DOT(v+3*1, v+3*1);
ELL_3V_SCALE_ADD2(tv, 1, v+3*1, -d10/d00, v+3*0);
scl = sqrt(d11/ELL_3V_DOT(tv, tv));
ELL_3V_SCALE(v+3*1, scl, tv);
d20 = ELL_3V_DOT(v+3*2, v+3*0);
d21 = ELL_3V_DOT(v+3*2, v+3*1);
d22 = ELL_3V_DOT(v+3*2, v+3*2);
ELL_3V_SCALE_ADD3(tv, 1, v+3*2, -d20/d00, v+3*0, -d21/d00, v+3*1);
scl = sqrt(d22/ELL_3V_DOT(tv, tv));
ELL_3V_SCALE(v+3*2, scl, tv);
return;
}
static void
simulate(double *dwiSim, const double *parm, const tenExperSpec *espec) {
unsigned int ii;
double b0, diff, frac, vec[3];
b0 = parm[0];
diff = parm[1];
frac = parm[2];
vec[0] = parm[3];
vec[1] = parm[4];
vec[2] = parm[5];
for (ii=0; ii<espec->imgNum; ii++) {
double dwiBall, dwiStck, dot;
dwiBall = exp(-espec->bval[ii]*diff);
dot = ELL_3V_DOT(vec, espec->grad + 3*ii);
dwiStck = exp(-espec->bval[ii]*diff*dot*dot);
dwiSim[ii] = b0*((1-frac)*dwiBall + frac*dwiStck);
}
return;
}
void
_coilKindScalarFilterModifiedCurvature(coil_t *delta, coil_t **iv3,
double spacing[3],
double parm[COIL_PARMS_NUM]) {
coil_t forwX[3], backX[3], forwY[3], backY[3], forwZ[3], backZ[3],
grad[3], gm, eps, KK, LL, denom, rspX, rspY, rspZ, lerp;
/* reciprocals of spacings in X, Y, and Z */
rspX = AIR_CAST(coil_t, 1.0/spacing[0]);
rspY = AIR_CAST(coil_t, 1.0/spacing[1]);
rspZ = AIR_CAST(coil_t, 1.0/spacing[2]);
_coilKindScalar3x3x3Gradients(forwX, backX,
forwY, backY,
forwZ, backZ,
iv3,
rspX, rspY, rspZ);
grad[0] = rspX*(iv3[2][4] - iv3[0][4]);
grad[1] = rspY*(iv3[1][5] - iv3[1][3]);
grad[2] = rspZ*(iv3[1][7] - iv3[1][1]);
gm = AIR_CAST(coil_t, ELL_3V_LEN(grad));
/* compute fluxes */
eps = 0.000001f;
KK = AIR_CAST(coil_t, parm[1]*parm[1]);
LL = ELL_3V_DOT(forwX, forwX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwY, forwY);
forwY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwZ, forwZ);
forwZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backX, backX);
backX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backY, backY);
backY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backZ, backZ);
backZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
lerp = AIR_CAST(coil_t, parm[2]);
delta[0] = (lerp*_coilLaplacian3(iv3, spacing)
+ (1-lerp)*gm*(rspX*(forwX[0] - backX[0])
+ rspY*(forwY[1] - backY[1])
+ rspZ*(forwZ[2] - backZ[2])));
delta[0] *= AIR_CAST(coil_t, parm[0]);
}
int
tenGlyphGen(limnObject *glyphsLimn, echoScene *glyphsEcho,
tenGlyphParm *parm,
const Nrrd *nten, const Nrrd *npos, const Nrrd *nslc) {
static const char me[]="tenGlyphGen";
gageShape *shape;
airArray *mop;
float *tdata, eval[3], evec[9], *cvec, rotEvec[9], mA_f[16],
absEval[3], glyphScl[3];
double pI[3], pW[3], cl, cp, sRot[16], mA[16], mB[16], msFr[9], tmpvec[3],
R, G, B, qA, qB, qC, glyphAniso, sliceGray;
unsigned int duh;
int slcCoord[3], idx, glyphIdx, axis, numGlyphs,
svRGBAfl=AIR_FALSE;
limnLook *look; int lookIdx;
echoObject *eglyph, *inst, *list=NULL, *split, *esquare;
echoPos_t eM[16], originOffset[3], edge0[3], edge1[3];
char stmp[AIR_STRLEN_SMALL];
/*
int eret;
double tmp1[3], tmp2[3];
*/
if (!( (glyphsLimn || glyphsEcho) && nten && parm)) {
biffAddf(TEN, "%s: got NULL pointer", me);
return 1;
}
mop = airMopNew();
shape = gageShapeNew();
shape->defaultCenter = nrrdCenterCell;
airMopAdd(mop, shape, (airMopper)gageShapeNix, airMopAlways);
if (npos) {
if (!( 2 == nten->dim && 7 == nten->axis[0].size )) {
biffAddf(TEN, "%s: nten isn't 2-D 7-by-N array", me);
airMopError(mop); return 1;
}
if (!( 2 == npos->dim && 3 == npos->axis[0].size
&& nten->axis[1].size == npos->axis[1].size )) {
biffAddf(TEN, "%s: npos isn't 2-D 3-by-%s array", me,
airSprintSize_t(stmp, nten->axis[1].size));
airMopError(mop); return 1;
}
if (!( nrrdTypeFloat == nten->type && nrrdTypeFloat == npos->type )) {
biffAddf(TEN, "%s: nten and npos must be %s, not %s and %s", me,
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nten->type),
airEnumStr(nrrdType, npos->type));
airMopError(mop); return 1;
}
} else {
if (tenTensorCheck(nten, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
biffAddf(TEN, "%s: didn't get a valid DT volume", me);
airMopError(mop); return 1;
}
}
if (tenGlyphParmCheck(parm, nten, npos, nslc)) {
biffAddf(TEN, "%s: trouble", me);
airMopError(mop); return 1;
}
if (!npos) {
if (gageShapeSet(shape, nten, tenGageKind->baseDim)) {
biffMovef(TEN, GAGE, "%s: trouble", me);
airMopError(mop); return 1;
}
}
if (parm->doSlice) {
ELL_3V_COPY(edge0, shape->spacing);
ELL_3V_COPY(edge1, shape->spacing);
edge0[parm->sliceAxis] = edge1[parm->sliceAxis] = 0.0;
switch(parm->sliceAxis) {
case 0:
edge0[1] = edge1[2] = 0;
ELL_4M_ROTATE_Y_SET(sRot, AIR_PI/2);
break;
case 1:
edge0[0] = edge1[2] = 0;
ELL_4M_ROTATE_X_SET(sRot, AIR_PI/2);
break;
case 2: default:
edge0[0] = edge1[1] = 0;
ELL_4M_IDENTITY_SET(sRot);
break;
}
ELL_3V_COPY(originOffset, shape->spacing);
ELL_3V_SCALE(originOffset, -0.5, originOffset);
originOffset[parm->sliceAxis] *= -2*parm->sliceOffset;
}
if (glyphsLimn) {
/* create limnLooks for diffuse and ambient-only shading */
/* ??? */
/* hack: save old value of setVertexRGBAFromLook, and set to true */
svRGBAfl = glyphsLimn->setVertexRGBAFromLook;
glyphsLimn->setVertexRGBAFromLook = AIR_TRUE;
}
if (glyphsEcho) {
list = echoObjectNew(glyphsEcho, echoTypeList);
}
if (npos) {
numGlyphs = AIR_UINT(nten->axis[1].size);
} else {
numGlyphs = shape->size[0] * shape->size[1] * shape->size[2];
}
/* find measurement frame transform */
if (3 == nten->spaceDim
&& AIR_EXISTS(nten->measurementFrame[0][0])) {
/* msFr nten->measurementFrame
** 0 1 2 [0][0] [1][0] [2][0]
** 3 4 5 [0][1] [1][1] [2][1]
** 6 7 8 [0][2] [1][2] [2][2]
*/
msFr[0] = nten->measurementFrame[0][0];
msFr[3] = nten->measurementFrame[0][1];
msFr[6] = nten->measurementFrame[0][2];
msFr[1] = nten->measurementFrame[1][0];
msFr[4] = nten->measurementFrame[1][1];
msFr[7] = nten->measurementFrame[1][2];
msFr[2] = nten->measurementFrame[2][0];
msFr[5] = nten->measurementFrame[2][1];
msFr[8] = nten->measurementFrame[2][2];
} else {
ELL_3M_IDENTITY_SET(msFr);
}
for (idx=0; idx<numGlyphs; idx++) {
tdata = (float*)(nten->data) + 7*idx;
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: hello %g %g %g %g %g %g %g\n",
me, idx, numGlyphs, tdata[0],
tdata[1], tdata[2], tdata[3],
tdata[4], tdata[5], tdata[6]);
}
if (!( TEN_T_EXISTS(tdata) )) {
/* there's nothing we can do here */
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: non-existent data\n",
me, idx, numGlyphs);
}
continue;
}
if (npos) {
ELL_3V_COPY(pW, (float*)(npos->data) + 3*idx);
if (!( AIR_EXISTS(pW[0]) && AIR_EXISTS(pW[1]) && AIR_EXISTS(pW[2]) )) {
/* position doesn't exist- perhaps because its from the push
library, which might kill points by setting coords to nan */
continue;
}
} else {
NRRD_COORD_GEN(pI, shape->size, 3, idx);
/* this does take into account full orientation */
gageShapeItoW(shape, pW, pI);
if (parm->nmask) {
if (!( nrrdFLookup[parm->nmask->type](parm->nmask->data, idx)
>= parm->maskThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: doesn't meet mask thresh\n",
me, idx, numGlyphs);
}
continue;
}
}
}
tenEigensolve_f(eval, evec, tdata);
/* transform eigenvectors by measurement frame */
ELL_3MV_MUL(tmpvec, msFr, evec + 0);
ELL_3V_COPY_TT(evec + 0, float, tmpvec);
ELL_3MV_MUL(tmpvec, msFr, evec + 3);
ELL_3V_COPY_TT(evec + 3, float, tmpvec);
ELL_3MV_MUL(tmpvec, msFr, evec + 6);
ELL_3V_COPY_TT(evec + 6, float, tmpvec);
ELL_3V_CROSS(tmpvec, evec + 0, evec + 3);
if (0 > ELL_3V_DOT(tmpvec, evec + 6)) {
ELL_3V_SCALE(evec + 6, -1, evec + 6);
}
ELL_3M_TRANSPOSE(rotEvec, evec);
if (parm->doSlice
&& pI[parm->sliceAxis] == parm->slicePos) {
/* set sliceGray */
if (nslc) {
/* we aren't masked by confidence, as anisotropy slice is */
for (duh=0; duh<parm->sliceAxis; duh++) {
slcCoord[duh] = (int)(pI[duh]);
}
for (duh=duh<parm->sliceAxis; duh<2; duh++) {
slcCoord[duh] = (int)(pI[duh+1]);
}
/* HEY: GLK has no idea what's going here */
slcCoord[0] = (int)(pI[0]);
slcCoord[1] = (int)(pI[1]);
slcCoord[2] = (int)(pI[2]);
sliceGray =
nrrdFLookup[nslc->type](nslc->data, slcCoord[0]
+ nslc->axis[0].size*slcCoord[1]);
} else {
if (!( tdata[0] >= parm->confThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d (slice): conf %g < thresh %g\n",
me, idx, numGlyphs, tdata[0], parm->confThresh);
}
continue;
}
sliceGray = tenAnisoEval_f(eval, parm->sliceAnisoType);
}
if (parm->sliceGamma > 0) {
sliceGray = AIR_AFFINE(0, sliceGray, 1, parm->sliceBias, 1);
sliceGray = pow(sliceGray, 1.0/parm->sliceGamma);
} else {
sliceGray = AIR_AFFINE(0, sliceGray, 1, 0, 1-parm->sliceBias);
sliceGray = 1.0 - pow(sliceGray, -1.0/parm->sliceGamma);
}
/* make slice contribution */
/* HEY: this is *NOT* aware of shape->fromOrientation */
if (glyphsLimn) {
lookIdx = limnObjectLookAdd(glyphsLimn);
look = glyphsLimn->look + lookIdx;
ELL_4V_SET_TT(look->rgba, float, sliceGray, sliceGray, sliceGray, 1);
ELL_3V_SET(look->kads, 1, 0, 0);
look->spow = 0;
glyphIdx = limnObjectSquareAdd(glyphsLimn, lookIdx);
ELL_4M_IDENTITY_SET(mA);
ell_4m_post_mul_d(mA, sRot);
if (!npos) {
ELL_4M_SCALE_SET(mB,
shape->spacing[0],
shape->spacing[1],
shape->spacing[2]);
}
ell_4m_post_mul_d(mA, mB);
ELL_4M_TRANSLATE_SET(mB, pW[0], pW[1], pW[2]);
ell_4m_post_mul_d(mA, mB);
ELL_4M_TRANSLATE_SET(mB,
originOffset[0],
originOffset[1],
originOffset[2]);
ell_4m_post_mul_d(mA, mB);
ELL_4M_COPY_TT(mA_f, float, mA);
limnObjectPartTransform(glyphsLimn, glyphIdx, mA_f);
}
if (glyphsEcho) {
esquare = echoObjectNew(glyphsEcho,echoTypeRectangle);
ELL_3V_ADD2(((echoRectangle*)esquare)->origin, pW, originOffset);
ELL_3V_COPY(((echoRectangle*)esquare)->edge0, edge0);
ELL_3V_COPY(((echoRectangle*)esquare)->edge1, edge1);
echoColorSet(esquare,
AIR_CAST(echoCol_t, sliceGray),
AIR_CAST(echoCol_t, sliceGray),
AIR_CAST(echoCol_t, sliceGray), 1);
/* this is pretty arbitrary- but I want shadows to have some effect.
Previously, the material was all ambient: (A,D,S) = (1,0,0),
which avoided all shadow effects. */
echoMatterPhongSet(glyphsEcho, esquare, 0.4f, 0.6f, 0, 40);
echoListAdd(list, esquare);
}
}
if (parm->onlyPositive) {
if (eval[2] < 0) {
/* didn't have all positive eigenvalues, its outta here */
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: not all evals %g %g %g > 0\n",
me, idx, numGlyphs, eval[0], eval[1], eval[2]);
}
continue;
}
}
if (!( tdata[0] >= parm->confThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: conf %g < thresh %g\n",
me, idx, numGlyphs, tdata[0], parm->confThresh);
}
continue;
}
if (!( tenAnisoEval_f(eval, parm->anisoType) >= parm->anisoThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: aniso[%d] %g < thresh %g\n",
me, idx, numGlyphs, parm->anisoType,
tenAnisoEval_f(eval, parm->anisoType), parm->anisoThresh);
}
continue;
}
glyphAniso = tenAnisoEval_f(eval, parm->colAnisoType);
/*
fprintf(stderr, "%s: eret = %d; evals = %g %g %g\n", me,
eret, eval[0], eval[1], eval[2]);
ELL_3V_CROSS(tmp1, evec+0, evec+3); tmp2[0] = ELL_3V_LEN(tmp1);
ELL_3V_CROSS(tmp1, evec+0, evec+6); tmp2[1] = ELL_3V_LEN(tmp1);
ELL_3V_CROSS(tmp1, evec+3, evec+6); tmp2[2] = ELL_3V_LEN(tmp1);
fprintf(stderr, "%s: crosses = %g %g %g\n", me,
tmp2[0], tmp2[1], tmp2[2]);
*/
/* set transform (in mA) */
ELL_3V_ABS(absEval, eval);
ELL_4M_IDENTITY_SET(mA); /* reset */
ELL_3V_SCALE(glyphScl, parm->glyphScale, absEval); /* scale by evals */
ELL_4M_SCALE_SET(mB, glyphScl[0], glyphScl[1], glyphScl[2]);
ell_4m_post_mul_d(mA, mB);
ELL_43M_INSET(mB, rotEvec); /* rotate by evecs */
ell_4m_post_mul_d(mA, mB);
ELL_4M_TRANSLATE_SET(mB, pW[0], pW[1], pW[2]); /* translate */
ell_4m_post_mul_d(mA, mB);
/* set color (in R,G,B) */
cvec = evec + 3*(AIR_CLAMP(0, parm->colEvec, 2));
R = AIR_ABS(cvec[0]); /* standard mapping */
G = AIR_ABS(cvec[1]);
B = AIR_ABS(cvec[2]);
/* desaturate by colMaxSat */
R = AIR_AFFINE(0.0, parm->colMaxSat, 1.0, parm->colIsoGray, R);
G = AIR_AFFINE(0.0, parm->colMaxSat, 1.0, parm->colIsoGray, G);
B = AIR_AFFINE(0.0, parm->colMaxSat, 1.0, parm->colIsoGray, B);
/* desaturate some by anisotropy */
R = AIR_AFFINE(0.0, parm->colAnisoModulate, 1.0,
R, AIR_AFFINE(0.0, glyphAniso, 1.0, parm->colIsoGray, R));
G = AIR_AFFINE(0.0, parm->colAnisoModulate, 1.0,
G, AIR_AFFINE(0.0, glyphAniso, 1.0, parm->colIsoGray, G));
B = AIR_AFFINE(0.0, parm->colAnisoModulate, 1.0,
B, AIR_AFFINE(0.0, glyphAniso, 1.0, parm->colIsoGray, B));
/* clamp and do gamma */
R = AIR_CLAMP(0.0, R, 1.0);
G = AIR_CLAMP(0.0, G, 1.0);
B = AIR_CLAMP(0.0, B, 1.0);
R = pow(R, parm->colGamma);
G = pow(G, parm->colGamma);
B = pow(B, parm->colGamma);
/* find axis, and superquad exponents qA and qB */
if (eval[2] > 0) {
/* all evals positive */
cl = AIR_MIN(0.99, tenAnisoEval_f(eval, tenAniso_Cl1));
cp = AIR_MIN(0.99, tenAnisoEval_f(eval, tenAniso_Cp1));
if (cl > cp) {
axis = 0;
qA = pow(1-cp, parm->sqdSharp);
qB = pow(1-cl, parm->sqdSharp);
} else {
axis = 2;
qA = pow(1-cl, parm->sqdSharp);
qB = pow(1-cp, parm->sqdSharp);
}
qC = qB;
} else if (eval[0] < 0) {
/* all evals negative */
float aef[3];
aef[0] = absEval[2];
aef[1] = absEval[1];
aef[2] = absEval[0];
cl = AIR_MIN(0.99, tenAnisoEval_f(aef, tenAniso_Cl1));
cp = AIR_MIN(0.99, tenAnisoEval_f(aef, tenAniso_Cp1));
if (cl > cp) {
axis = 2;
qA = pow(1-cp, parm->sqdSharp);
qB = pow(1-cl, parm->sqdSharp);
} else {
axis = 0;
qA = pow(1-cl, parm->sqdSharp);
qB = pow(1-cp, parm->sqdSharp);
}
qC = qB;
} else {
#define OOSQRT2 0.70710678118654752440
#define OOSQRT3 0.57735026918962576451
/* double poleA[3]={OOSQRT3, OOSQRT3, OOSQRT3}; */
double poleB[3]={1, 0, 0};
double poleC[3]={OOSQRT2, OOSQRT2, 0};
double poleD[3]={OOSQRT3, -OOSQRT3, -OOSQRT3};
double poleE[3]={OOSQRT2, 0, -OOSQRT2};
double poleF[3]={OOSQRT3, OOSQRT3, -OOSQRT3};
double poleG[3]={0, -OOSQRT2, -OOSQRT2};
double poleH[3]={0, 0, -1};
/* double poleI[3]={-OOSQRT3, -OOSQRT3, -OOSQRT3}; */
double funk[3]={0,4,2}, thrn[3]={1,4,4};
double octa[3]={0,2,2}, cone[3]={1,2,2};
double evalN[3], tmp, bary[3];
double qq[3];
ELL_3V_NORM(evalN, eval, tmp);
if (eval[1] >= -eval[2]) {
/* inside B-F-C */
ell_3v_barycentric_spherical_d(bary, poleB, poleF, poleC, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], octa, bary[1], thrn, bary[2], cone);
axis = 2;
} else if (eval[0] >= -eval[2]) {
/* inside B-D-F */
if (eval[1] >= 0) {
/* inside B-E-F */
ell_3v_barycentric_spherical_d(bary, poleB, poleE, poleF, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], octa, bary[1], funk, bary[2], thrn);
axis = 2;
} else {
/* inside B-D-E */
ell_3v_barycentric_spherical_d(bary, poleB, poleD, poleE, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], cone, bary[1], thrn, bary[2], funk);
axis = 0;
}
} else if (eval[0] < -eval[1]) {
/* inside D-G-H */
ell_3v_barycentric_spherical_d(bary, poleD, poleG, poleH, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], thrn, bary[1], cone, bary[2], octa);
axis = 0;
} else if (eval[1] < 0) {
/* inside E-D-H */
ell_3v_barycentric_spherical_d(bary, poleE, poleD, poleH, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], funk, bary[1], thrn, bary[2], octa);
axis = 0;
} else {
/* inside F-E-H */
ell_3v_barycentric_spherical_d(bary, poleF, poleE, poleH, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], thrn, bary[1], funk, bary[2], cone);
axis = 2;
}
qA = qq[0];
qB = qq[1];
qC = qq[2];
#undef OOSQRT2
#undef OOSQRT3
}
/* add the glyph */
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: the glyph stays!\n",
me, idx, numGlyphs);
}
if (glyphsLimn) {
lookIdx = limnObjectLookAdd(glyphsLimn);
look = glyphsLimn->look + lookIdx;
ELL_4V_SET_TT(look->rgba, float, R, G, B, 1);
ELL_3V_SET(look->kads, parm->ADSP[0], parm->ADSP[1], parm->ADSP[2]);
look->spow = 0;
switch(parm->glyphType) {
case tenGlyphTypeBox:
glyphIdx = limnObjectCubeAdd(glyphsLimn, lookIdx);
break;
case tenGlyphTypeSphere:
glyphIdx = limnObjectPolarSphereAdd(glyphsLimn, lookIdx, axis,
2*parm->facetRes, parm->facetRes);
break;
case tenGlyphTypeCylinder:
glyphIdx = limnObjectCylinderAdd(glyphsLimn, lookIdx, axis,
parm->facetRes);
break;
case tenGlyphTypeSuperquad:
default:
glyphIdx =
limnObjectPolarSuperquadFancyAdd(glyphsLimn, lookIdx, axis,
AIR_CAST(float, qA),
AIR_CAST(float, qB),
AIR_CAST(float, qC), 0,
2*parm->facetRes,
parm->facetRes);
break;
}
ELL_4M_COPY_TT(mA_f, float, mA);
limnObjectPartTransform(glyphsLimn, glyphIdx, mA_f);
}
if (glyphsEcho) {
switch(parm->glyphType) {
case tenGlyphTypeBox:
eglyph = echoObjectNew(glyphsEcho, echoTypeCube);
/* nothing else to set */
break;
case tenGlyphTypeSphere:
eglyph = echoObjectNew(glyphsEcho, echoTypeSphere);
echoSphereSet(eglyph, 0, 0, 0, 1);
break;
case tenGlyphTypeCylinder:
eglyph = echoObjectNew(glyphsEcho, echoTypeCylinder);
echoCylinderSet(eglyph, axis);
break;
case tenGlyphTypeSuperquad:
default:
eglyph = echoObjectNew(glyphsEcho, echoTypeSuperquad);
echoSuperquadSet(eglyph, axis, qA, qB);
break;
}
echoColorSet(eglyph,
AIR_CAST(echoCol_t, R),
AIR_CAST(echoCol_t, G),
AIR_CAST(echoCol_t, B), 1);
echoMatterPhongSet(glyphsEcho, eglyph,
parm->ADSP[0], parm->ADSP[1],
parm->ADSP[2], parm->ADSP[3]);
inst = echoObjectNew(glyphsEcho, echoTypeInstance);
ELL_4M_COPY(eM, mA);
echoInstanceSet(inst, eM, eglyph);
echoListAdd(list, inst);
}
}
if (glyphsLimn) {
glyphsLimn->setVertexRGBAFromLook = svRGBAfl;
}
if (glyphsEcho) {
split = echoListSplit3(glyphsEcho, list, 10);
echoObjectAdd(glyphsEcho, split);
}
airMopOkay(mop);
return 0;
}
/*
** parm vector:
** 0 1 2 3 4 5 (6)
** step K_perp K_tan lerp X_ring Y_ring
*/
void
_coilKindScalarFilterModifiedCurvatureRings(coil_t *delta,
int xi, int yi, int zi,
coil_t **iv3, double spacing[3],
double parm[COIL_PARMS_NUM]) {
coil_t forwX[3], backX[3], forwY[3], backY[3], forwZ[3], backZ[3],
grad[3], gm, eps, KK, LL, denom, rspX, rspY, rspZ, lerp;
double bas0[3], bas1[3], bas2[3], len, norm[3], sk;
AIR_UNUSED(zi);
ELL_3V_SET(bas0, 0, 0, 1);
ELL_3V_SET(bas1, xi - parm[4], yi - parm[5], 0);
ELL_3V_NORM(bas1, bas1, len);
ELL_3V_CROSS(bas2, bas0, bas1);
rspX = AIR_CAST(coil_t, 1.0/spacing[0]);
rspY = AIR_CAST(coil_t, 1.0/spacing[1]);
rspZ = AIR_CAST(coil_t, 1.0/spacing[2]);
_coilKindScalar3x3x3Gradients(forwX, backX,
forwY, backY,
forwZ, backZ,
iv3,
rspX, rspY, rspZ);
grad[0] = rspX*(iv3[2][4] - iv3[0][4]);
grad[1] = rspY*(iv3[1][5] - iv3[1][3]);
grad[2] = rspZ*(iv3[1][7] - iv3[1][1]);
gm = AIR_CAST(coil_t, ELL_3V_LEN(grad));
if (gm) {
double tc, rcsq;
ELL_3V_SCALE(norm, 1.0/gm, grad);
tc = ELL_3V_DOT(norm, bas2);
rcsq = 1 - tc*tc;
sk = AIR_LERP(rcsq, parm[1], parm[2]);
} else {
sk = parm[1];
}
/* compute fluxes */
eps = 0.0000000001f;
KK = AIR_CAST(coil_t, sk*sk);
LL = ELL_3V_DOT(forwX, forwX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwY, forwY);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwZ, forwZ);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backX, backX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backY, backY);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backZ, backZ);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
lerp = AIR_CAST(coil_t, parm[2]);
delta[0] = (lerp*_coilLaplacian3(iv3, spacing)
+ (1-lerp)*gm*(rspX*(forwX[0] - backX[0])
+ rspY*(forwY[1] - backY[1])
+ rspZ*(forwZ[2] - backZ[2])));
delta[0] *= AIR_CAST(coil_t, parm[0]);
}
/*
** (mcde)
** parm vector:
** 0 1 2 (3)
** step K lerp (lerp=1: all laplacian)
*/
void
_coilKindScalarFilterModifiedCurvature(coil_t *delta,
int xi, int yi, int zi,
coil_t **iv3, double spacing[3],
double parm[COIL_PARMS_NUM]) {
/* char me[]="_coilKindScalarFilterModifiedCurvature"; */
coil_t forwX[3], backX[3], forwY[3], backY[3], forwZ[3], backZ[3],
grad[3], gm, eps, KK, LL, denom, rspX, rspY, rspZ, lerp;
AIR_UNUSED(xi);
AIR_UNUSED(yi);
AIR_UNUSED(zi);
/*
if (coilVerbose) {
fprintf(stderr, "!%s: --------- hello --------\n", me);
}
*/
/* reciprocals of spacings in X, Y, and Z */
rspX = AIR_CAST(coil_t, 1.0/spacing[0]);
rspY = AIR_CAST(coil_t, 1.0/spacing[1]);
rspZ = AIR_CAST(coil_t, 1.0/spacing[2]);
_coilKindScalar3x3x3Gradients(forwX, backX,
forwY, backY,
forwZ, backZ,
iv3,
rspX, rspY, rspZ);
grad[0] = rspX*(iv3[2][4] - iv3[0][4]);
grad[1] = rspY*(iv3[1][5] - iv3[1][3]);
grad[2] = rspZ*(iv3[1][7] - iv3[1][1]);
gm = AIR_CAST(coil_t, ELL_3V_LEN(grad));
/*
if (coilVerbose) {
fprintf(stderr, "forwX = %g %g %g backX = %g %g %g\n",
forwX[0], forwX[1], forwX[2],
backX[0], backX[1], backX[2]);
fprintf(stderr, "forwY = %g %g %g backY = %g %g %g\n",
forwY[0], forwY[1], forwY[2],
backY[0], backY[1], backY[2]);
fprintf(stderr, "forwZ = %g %g %g backZ = %g %g %g\n",
forwZ[0], forwZ[1], forwZ[2],
backZ[0], backZ[1], backZ[2]);
fprintf(stderr, "grad = %g %g %g --> gm = %g\n",
grad[0], grad[1], grad[2], gm);
}
*/
/* compute fluxes */
eps = 0.0000000001f;
KK = AIR_CAST(coil_t, parm[1]*parm[1]);
LL = ELL_3V_DOT(forwX, forwX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwY, forwY);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwZ, forwZ);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backX, backX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backY, backY);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backZ, backZ);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
lerp = AIR_CAST(coil_t, parm[2]);
delta[0] = (lerp*_coilLaplacian3(iv3, spacing)
+ (1-lerp)*gm*(rspX*(forwX[0] - backX[0])
+ rspY*(forwY[1] - backY[1])
+ rspZ*(forwZ[2] - backZ[2])));
delta[0] *= AIR_CAST(coil_t, parm[0]);
/*
if (coilVerbose) {
fprintf(stderr, "!%s: delta = %g\n", me, delta[0]);
}
*/
}
void
_gageVecAnswer(gageContext *ctx, gagePerVolume *pvl) {
char me[]="_gageVecAnswer";
double cmag, tmpMat[9], mgevec[9], mgeval[3];
double symm[9], asym[9], tran[9], eval[3], tmpVec[3], norm;
gage_t *vecAns, *normAns, *jacAns, *curlAns, *hesAns, *curlGradAns,
*helGradAns, *dirHelDirAns, *curlnormgradAns;
/* int asw; */
vecAns = pvl->directAnswer[gageVecVector];
normAns = pvl->directAnswer[gageVecNormalized];
jacAns = pvl->directAnswer[gageVecJacobian];
curlAns = pvl->directAnswer[gageVecCurl];
hesAns = pvl->directAnswer[gageVecHessian];
curlGradAns = pvl->directAnswer[gageVecCurlGradient];
curlnormgradAns = pvl->directAnswer[gageVecCurlNormGrad];
helGradAns = pvl->directAnswer[gageVecHelGradient];
dirHelDirAns = pvl->directAnswer[gageVecDirHelDeriv];
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecVector)) {
/* done if doV */
if (ctx->verbose) {
fprintf(stderr, "vec = ");
ell_3v_PRINT(stderr, vecAns);
}
}
/* done if doV
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecVector{0,1,2})) {
}
*/
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecLength)) {
pvl->directAnswer[gageVecLength][0] = AIR_CAST(gage_t, ELL_3V_LEN(vecAns));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecNormalized)) {
if (pvl->directAnswer[gageVecLength][0]) {
ELL_3V_SCALE_TT(normAns, gage_t,
1.0/pvl->directAnswer[gageVecLength][0], vecAns);
} else {
ELL_3V_COPY(normAns, gageZeroNormal);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecJacobian)) {
/* done if doD1 */
/*
0:dv_x/dx 1:dv_x/dy 2:dv_x/dz
3:dv_y/dx 4:dv_y/dy 5:dv_y/dz
6:dv_z/dx 7:dv_z/dy 8:dv_z/dz
*/
if (ctx->verbose) {
fprintf(stderr, "%s: jac = \n", me);
ell_3m_PRINT(stderr, jacAns);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecDivergence)) {
pvl->directAnswer[gageVecDivergence][0] = jacAns[0] + jacAns[4] + jacAns[8];
if (ctx->verbose) {
fprintf(stderr, "%s: div = %g + %g + %g = %g\n", me,
jacAns[0], jacAns[4], jacAns[8],
pvl->directAnswer[gageVecDivergence][0]);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurl)) {
ELL_3V_SET(curlAns,
jacAns[7] - jacAns[5],
jacAns[2] - jacAns[6],
jacAns[3] - jacAns[1]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurlNorm)) {
pvl->directAnswer[gageVecCurlNorm][0] =
AIR_CAST(gage_t, ELL_3V_LEN(curlAns));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecHelicity)) {
pvl->directAnswer[gageVecHelicity][0] =
ELL_3V_DOT(vecAns, curlAns);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecNormHelicity)) {
cmag = ELL_3V_LEN(curlAns);
pvl->directAnswer[gageVecNormHelicity][0] =
AIR_CAST(gage_t, cmag ? ELL_3V_DOT(normAns, curlAns)/cmag : 0);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecLambda2)) {
ELL_3M_TRANSPOSE(tran, jacAns);
/* symmetric part */
ELL_3M_SCALE_ADD2(symm, 0.5, jacAns, 0.5, tran);
/* antisymmetric part */
ELL_3M_SCALE_ADD2(asym, 0.5, jacAns, -0.5, tran);
/* square symmetric part */
ELL_3M_MUL(tmpMat, symm, symm);
ELL_3M_COPY(symm, tmpMat);
/* square antisymmetric part */
ELL_3M_MUL(tmpMat, asym, asym);
/* sum of both */
ELL_3M_ADD2(symm, symm, tmpMat);
/* get eigenvalues in sorted order */
/* asw = */ ell_3m_eigenvalues_d(eval, symm, AIR_TRUE);
pvl->directAnswer[gageVecLambda2][0] = AIR_CAST(gage_t, eval[1]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecImaginaryPart)) {
pvl->directAnswer[gageVecImaginaryPart][0] =
AIR_CAST(gage_t, gage_imaginary_part_eigenvalues(jacAns));
}
/* 2nd order vector derivative continued */
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecHessian)) {
/* done if doD2 */
/* the ordering is induced by the scalar hessian computation :
0:d2v_x/dxdx 1:d2v_x/dxdy 2:d2v_x/dxdz
3:d2v_x/dydx 4:d2v_x/dydy 5:d2v_x/dydz
6:d2v_x/dzdx 7:d2v_x/dzdy 8:d2v_x/dzdz
9:d2v_y/dxdx [...]
[...]
24:dv2_z/dzdx 25:d2v_z/dzdy 26:d2v_z/dzdz
*/
if (ctx->verbose) {
fprintf(stderr, "%s: hes = \n", me);
ell_3m_PRINT(stderr, hesAns); /* ?? */
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecDivGradient)) {
pvl->directAnswer[gageVecDivGradient][0] = hesAns[0] + hesAns[12] + hesAns[24];
pvl->directAnswer[gageVecDivGradient][1] = hesAns[1] + hesAns[13] + hesAns[25];
pvl->directAnswer[gageVecDivGradient][2] = hesAns[2] + hesAns[14] + hesAns[26];
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurlGradient)) {
pvl->directAnswer[gageVecCurlGradient][0] = hesAns[21]-hesAns[15];
pvl->directAnswer[gageVecCurlGradient][1] = hesAns[22]-hesAns[16];
pvl->directAnswer[gageVecCurlGradient][2] = hesAns[23]-hesAns[17];
pvl->directAnswer[gageVecCurlGradient][3] = hesAns[ 6]-hesAns[18];
pvl->directAnswer[gageVecCurlGradient][4] = hesAns[ 7]-hesAns[19];
pvl->directAnswer[gageVecCurlGradient][5] = hesAns[ 8]-hesAns[20];
pvl->directAnswer[gageVecCurlGradient][6] = hesAns[ 9]-hesAns[ 1];
pvl->directAnswer[gageVecCurlGradient][7] = hesAns[10]-hesAns[ 2];
pvl->directAnswer[gageVecCurlGradient][8] = hesAns[11]-hesAns[ 3];
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecCurlNormGrad)) {
norm = 1./ELL_3V_LEN(curlAns);
tmpVec[0] = hesAns[21] - hesAns[15];
tmpVec[1] = hesAns[ 6] - hesAns[18];
tmpVec[2] = hesAns[ 9] - hesAns[ 3];
pvl->directAnswer[gageVecCurlNormGrad][0]=
AIR_CAST(gage_t, norm*ELL_3V_DOT(tmpVec, curlAns));
tmpVec[0] = hesAns[22] - hesAns[16];
tmpVec[1] = hesAns[ 7] - hesAns[19];
tmpVec[2] = hesAns[10] - hesAns[ 4];
pvl->directAnswer[gageVecCurlNormGrad][1]=
AIR_CAST(gage_t, norm*ELL_3V_DOT(tmpVec, curlAns));
tmpVec[0] = hesAns[23] - hesAns[17];
tmpVec[1] = hesAns[ 8] - hesAns[20];
tmpVec[2] = hesAns[11] - hesAns[ 5];
pvl->directAnswer[gageVecCurlNormGrad][2]=
AIR_CAST(gage_t, norm*ELL_3V_DOT(tmpVec, curlAns));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecNCurlNormGrad)) {
norm = 1./ELL_3V_LEN(curlnormgradAns);
ELL_3V_SCALE_TT(pvl->directAnswer[gageVecNCurlNormGrad], gage_t,
norm, pvl->directAnswer[gageVecCurlNormGrad]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecHelGradient)) {
pvl->directAnswer[gageVecHelGradient][0] =
jacAns[0]*curlAns[0]+
jacAns[3]*curlAns[1]+
jacAns[6]*curlAns[2]+
curlGradAns[0]*vecAns[0]+
curlGradAns[3]*vecAns[1]+
curlGradAns[6]*vecAns[2];
pvl->directAnswer[gageVecHelGradient][1] =
jacAns[1]*curlAns[0]+
jacAns[4]*curlAns[1]+
jacAns[7]*curlAns[2]+
curlGradAns[1]*vecAns[0]+
curlGradAns[4]*vecAns[1]+
curlGradAns[7]*vecAns[2];
pvl->directAnswer[gageVecHelGradient][0] =
jacAns[2]*curlAns[0]+
jacAns[5]*curlAns[1]+
jacAns[8]*curlAns[2]+
curlGradAns[2]*vecAns[0]+
curlGradAns[5]*vecAns[1]+
curlGradAns[8]*vecAns[2];
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecDirHelDeriv)) {
pvl->directAnswer[gageVecDirHelDeriv][0] =
ELL_3V_DOT(normAns, helGradAns);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecProjHelGradient)) {
pvl->directAnswer[gageVecDirHelDeriv][0] =
helGradAns[0]-dirHelDirAns[0]*normAns[0];
pvl->directAnswer[gageVecDirHelDeriv][1] =
helGradAns[1]-dirHelDirAns[0]*normAns[1];
pvl->directAnswer[gageVecDirHelDeriv][2] =
helGradAns[2]-dirHelDirAns[0]*normAns[2];
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecGradient0)) {
ELL_3V_SET(pvl->directAnswer[gageVecGradient0],
jacAns[0],
jacAns[1],
jacAns[2]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecGradient1)) {
ELL_3V_SET(pvl->directAnswer[gageVecGradient1],
jacAns[3],
jacAns[4],
jacAns[5]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecGradient2)) {
ELL_3V_SET(pvl->directAnswer[gageVecGradient2],
jacAns[6],
jacAns[7],
jacAns[8]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMultiGrad)) {
ELL_3M_IDENTITY_SET(pvl->directAnswer[gageVecMultiGrad]);
ELL_3MV_OUTER_ADD(pvl->directAnswer[gageVecMultiGrad],
pvl->directAnswer[gageVecGradient0],
pvl->directAnswer[gageVecGradient0]);
ELL_3MV_OUTER_ADD(pvl->directAnswer[gageVecMultiGrad],
pvl->directAnswer[gageVecGradient1],
pvl->directAnswer[gageVecGradient1]);
ELL_3MV_OUTER_ADD(pvl->directAnswer[gageVecMultiGrad],
pvl->directAnswer[gageVecGradient2],
pvl->directAnswer[gageVecGradient2]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMGFrob)) {
pvl->directAnswer[gageVecMGFrob][0]
= AIR_CAST(gage_t, ELL_3M_FROB(pvl->directAnswer[gageVecMultiGrad]));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMGEval)) {
ELL_3M_COPY(tmpMat, pvl->directAnswer[gageVecMultiGrad]);
/* HEY: look at the return value for root multiplicity? */
ell_3m_eigensolve_d(mgeval, mgevec, tmpMat, AIR_TRUE);
ELL_3V_COPY_TT(pvl->directAnswer[gageVecMGEval], gage_t, mgeval);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageVecMGEvec)) {
ELL_3M_COPY_TT(pvl->directAnswer[gageVecMGEvec], gage_t, mgevec);
}
return;
}
void *
_hooverThreadBody(void *_arg) {
_hooverThreadArg *arg;
void *thread;
int ret, /* to catch return values from callbacks */
sampleI, /* which sample we're on */
inside, /* we're inside the volume */
vI, uI; /* integral coords in image */
double tmp,
mm, /* lowest position in index space, for all axes */
Mx, My, Mz, /* highest position in index space on each axis */
u, v, /* floating-point coords in image */
uvScale, /* how to scale (u,v) to go from image to
near plane, according to ortho or perspective */
lx, ly, lz, /* half edge-lengths of volume */
rayLen=0, /* length of segment formed by ray line intersecting
the near and far clipping planes */
rayT, /* current position along ray (world-space) */
rayDirW[3], /* unit-length ray direction (world-space) */
rayDirI[3], /* rayDirW transformed into index space;
not unit length, but a unit change in
world space along rayDirW translates to
this change in index space along rayDirI */
rayPosW[3], /* current ray location (world-space) */
rayPosI[3], /* current ray location (index-space) */
rayStartW[3], /* ray start on near plane (world-space) */
rayStartI[3], /* ray start on near plane (index-space) */
rayStep, /* distance between samples (world-space) */
vOff[3], uOff[3]; /* offsets in arg->ec->wU and arg->ec->wV
directions towards start of ray */
arg = (_hooverThreadArg *)_arg;
if ( (ret = (arg->ctx->threadBegin)(&thread,
arg->render,
arg->ctx->user,
arg->whichThread)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrThreadBegin;
return arg;
}
lx = arg->ec->volHLen[0];
ly = arg->ec->volHLen[1];
lz = arg->ec->volHLen[2];
if (nrrdCenterNode == arg->ctx->volCentering) {
mm = 0;
Mx = arg->ctx->volSize[0]-1;
My = arg->ctx->volSize[1]-1;
Mz = arg->ctx->volSize[2]-1;
} else {
mm = -0.5;
Mx = arg->ctx->volSize[0]-0.5;
My = arg->ctx->volSize[1]-0.5;
Mz = arg->ctx->volSize[2]-0.5;
}
if (arg->ctx->cam->orthographic) {
ELL_3V_COPY(rayDirW, arg->ctx->cam->N);
rayDirI[0] = AIR_DELTA(-lx, rayDirW[0], lx, mm, Mx);
rayDirI[1] = AIR_DELTA(-ly, rayDirW[1], ly, mm, My);
rayDirI[2] = AIR_DELTA(-lz, rayDirW[2], lz, mm, Mz);
rayLen = arg->ctx->cam->vspFaar - arg->ctx->cam->vspNeer;
uvScale = 1.0;
} else {
uvScale = arg->ctx->cam->vspNeer/arg->ctx->cam->vspDist;
}
while (1) {
/* the work assignment is simply the next scanline to be rendered:
the result of all this is setting vI */
if (arg->ctx->workMutex) {
airThreadMutexLock(arg->ctx->workMutex);
}
vI = arg->ctx->workIdx;
if (arg->ctx->workIdx < arg->ctx->imgSize[1]) {
arg->ctx->workIdx += 1;
}
if (arg->ctx->workMutex) {
airThreadMutexUnlock(arg->ctx->workMutex);
}
if (vI == arg->ctx->imgSize[1]) {
/* we're done! */
break;
}
if (nrrdCenterCell == arg->ctx->imgCentering) {
v = uvScale*AIR_AFFINE(-0.5, vI, arg->ctx->imgSize[1]-0.5,
arg->ctx->cam->vRange[0],
arg->ctx->cam->vRange[1]);
} else {
v = uvScale*AIR_AFFINE(0.0, vI, arg->ctx->imgSize[1]-1.0,
arg->ctx->cam->vRange[0],
arg->ctx->cam->vRange[1]);
}
ELL_3V_SCALE(vOff, v, arg->ctx->cam->V);
for (uI=0; uI<arg->ctx->imgSize[0]; uI++) {
if (nrrdCenterCell == arg->ctx->imgCentering) {
u = uvScale*AIR_AFFINE(-0.5, uI, arg->ctx->imgSize[0]-0.5,
arg->ctx->cam->uRange[0],
arg->ctx->cam->uRange[1]);
} else {
u = uvScale*AIR_AFFINE(0.0, uI, arg->ctx->imgSize[0]-1.0,
arg->ctx->cam->uRange[0],
arg->ctx->cam->uRange[1]);
}
ELL_3V_SCALE(uOff, u, arg->ctx->cam->U);
ELL_3V_ADD3(rayStartW, uOff, vOff, arg->ec->rayZero);
rayStartI[0] = AIR_AFFINE(-lx, rayStartW[0], lx, mm, Mx);
rayStartI[1] = AIR_AFFINE(-ly, rayStartW[1], ly, mm, My);
rayStartI[2] = AIR_AFFINE(-lz, rayStartW[2], lz, mm, Mz);
if (!arg->ctx->cam->orthographic) {
ELL_3V_SUB(rayDirW, rayStartW, arg->ctx->cam->from);
ELL_3V_NORM(rayDirW, rayDirW, tmp);
rayDirI[0] = AIR_DELTA(-lx, rayDirW[0], lx, mm, Mx);
rayDirI[1] = AIR_DELTA(-ly, rayDirW[1], ly, mm, My);
rayDirI[2] = AIR_DELTA(-lz, rayDirW[2], lz, mm, Mz);
rayLen = ((arg->ctx->cam->vspFaar - arg->ctx->cam->vspNeer)/
ELL_3V_DOT(rayDirW, arg->ctx->cam->N));
}
if ( (ret = (arg->ctx->rayBegin)(thread,
arg->render,
arg->ctx->user,
uI, vI, rayLen,
rayStartW, rayStartI,
rayDirW, rayDirI)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrRayBegin;
return arg;
}
sampleI = 0;
rayT = 0;
while (1) {
ELL_3V_SCALE_ADD2(rayPosW, 1.0, rayStartW, rayT, rayDirW);
ELL_3V_SCALE_ADD2(rayPosI, 1.0, rayStartI, rayT, rayDirI);
inside = (AIR_IN_CL(mm, rayPosI[0], Mx) &&
AIR_IN_CL(mm, rayPosI[1], My) &&
AIR_IN_CL(mm, rayPosI[2], Mz));
rayStep = (arg->ctx->sample)(thread,
arg->render,
arg->ctx->user,
sampleI, rayT,
inside,
rayPosW, rayPosI);
if (!AIR_EXISTS(rayStep)) {
/* sampling failed */
arg->errCode = 0;
arg->whichErr = hooverErrSample;
return arg;
}
if (!rayStep) {
/* ray decided to finish itself */
break;
}
/* else we moved to a new location along the ray */
rayT += rayStep;
if (!AIR_IN_CL(0, rayT, rayLen)) {
/* ray stepped outside near-far clipping region, its done. */
break;
}
sampleI++;
}
if ( (ret = (arg->ctx->rayEnd)(thread,
arg->render,
arg->ctx->user)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrRayEnd;
return arg;
}
} /* end this scanline */
} /* end while(1) assignment of scanlines */
if ( (ret = (arg->ctx->threadEnd)(thread,
arg->render,
arg->ctx->user)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrThreadEnd;
return arg;
}
/* returning NULL actually indicates that there was NOT an error */
return NULL;
}
/*
** Thanks to:
** http://jgt.akpeters.com/papers/MollerHughes99/code.html
*/
void
ell_3m_rotate_between_d(double rot[9], double from[3], double to[3]) {
double vv[3];
double e, h, f;
if (!( rot && from && to)) {
return;
}
ELL_3V_CROSS(vv, from, to);
e = ELL_3V_DOT(from, to);
f = AIR_ABS(e);
if (f > 0.9999999) { /* "from" and "to"-vector almost parallel */
double tu[3], tv[3]; /* temporary storage vectors */
double xx[3]; /* vector most nearly orthogonal to "from" */
double c1, c2, c3; /* coefficients for later use */
int i, j;
xx[0] = AIR_ABS(from[0]);
xx[1] = AIR_ABS(from[1]);
xx[2] = AIR_ABS(from[2]);
if (xx[0] < xx[1]) {
if (xx[0] < xx[2]) {
xx[0] = 1.0; xx[1] = xx[2] = 0.0;
} else {
xx[2] = 1.0; xx[0] = xx[1] = 0.0;
}
} else {
if (xx[1] < xx[2]) {
xx[1] = 1.0; xx[0] = xx[2] = 0.0;
} else {
xx[2] = 1.0; xx[0] = xx[1] = 0.0;
}
}
tu[0] = xx[0] - from[0]; tu[1] = xx[1] - from[1]; tu[2] = xx[2] - from[2];
tv[0] = xx[0] - to[0]; tv[1] = xx[1] - to[1]; tv[2] = xx[2] - to[2];
c1 = 2.0 / ELL_3V_DOT(tu, tu);
c2 = 2.0 / ELL_3V_DOT(tv, tv);
c3 = c1 * c2 * ELL_3V_DOT(tu, tv);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
rot[3*i + j] = - c1 * tu[i] * tu[j]
- c2 * tv[i] * tv[j]
+ c3 * tv[i] * tu[j];
}
rot[3*i + i] += 1.0;
}
} else { /* the most common case, unless "from"="to", or "from"=-"to" */
double hvx, hvz, hvxy, hvxz, hvyz;
h = 1.0/(1.0 + e); /* optimization by Gottfried Chen */
hvx = h * vv[0];
hvz = h * vv[2];
hvxy = hvx * vv[1];
hvxz = hvx * vv[2];
hvyz = hvz * vv[1];
rot[3*0 + 0] = e + hvx * vv[0];
rot[3*0 + 1] = hvxy - vv[2];
rot[3*0 + 2] = hvxz + vv[1];
rot[3*1 + 0] = hvxy + vv[2];
rot[3*1 + 1] = e + h * vv[1] * vv[1];
rot[3*1 + 2] = hvyz - vv[0];
rot[3*2 + 0] = hvxz - vv[1];
rot[3*2 + 1] = hvyz + vv[0];
rot[3*2 + 2] = e + hvz * vv[2];
}
return;
}
void
_miteRGBACalc(mite_t *R, mite_t *G, mite_t *B, mite_t *A,
miteThread *mtt, miteRender *mrr, miteUser *muu) {
static const char me[]="_miteRGBACalc";
mite_t tmp,
ad[3], /* ambient+diffuse light contribution */
s[3] = {0,0,0}, /* specular light contribution */
col[3], E, ka, kd, ks, sp, /* txf-determined rendering variables */
LdotN=0, HdotN, H[3], N[3]; /* for lighting calculation */
col[0] = mtt->range[miteRangeRed];
col[1] = mtt->range[miteRangeGreen];
col[2] = mtt->range[miteRangeBlue];
E = mtt->range[miteRangeEmissivity];
ka = mtt->range[miteRangeKa];
kd = mtt->range[miteRangeKd];
ks = mtt->range[miteRangeKs];
ELL_3V_SCALE(ad, ka, muu->lit->amb);
switch (mrr->shadeSpec->method) {
case miteShadeMethodNone:
/* nothing to do */
break;
case miteShadeMethodPhong:
if (kd || ks) {
ELL_3V_NORM(N, mtt->shadeVec0, tmp);
if (1 == muu->normalSide) {
ELL_3V_SCALE(N, -1, N);
}
/* else -1==side --> N = -1*-1*N = N
or 0==side --> N = N, so there's nothing to do */
if (kd) {
LdotN = ELL_3V_DOT(muu->lit->dir[0], N);
if (!muu->normalSide) {
LdotN = AIR_ABS(LdotN);
}
if (LdotN > 0) {
ELL_3V_SCALE_INCR(ad, LdotN*kd, muu->lit->col[0]);
}
}
if (ks) {
sp = mtt->range[miteRangeSP];
ELL_3V_ADD2(H, muu->lit->dir[0], mtt->V);
ELL_3V_NORM(H, H, tmp);
HdotN = ELL_3V_DOT(H, N);
if (!muu->normalSide) {
HdotN = AIR_ABS(HdotN);
}
if (HdotN > 0) {
HdotN = pow(HdotN, sp);
ELL_3V_SCALE(s, HdotN*ks, muu->lit->col[0]);
}
}
}
break;
case miteShadeMethodLitTen:
fprintf(stderr, "!%s: lit-tensor not yet implemented\n", me);
break;
default:
fprintf(stderr, "!%s: PANIC, shadeMethod %d unimplemented\n",
me, mrr->shadeSpec->method);
exit(1);
break;
}
*R = (E - 1 + ad[0])*col[0] + s[0];
*G = (E - 1 + ad[1])*col[1] + s[1];
*B = (E - 1 + ad[2])*col[2] + s[2];
*A = mtt->range[miteRangeAlpha];
*A = AIR_CLAMP(0.0, *A, 1.0);
/*
if (mtt->verbose) {
fprintf(stderr, "%s: col[] = %g,%g,%g; A,E = %g,%g; Kads = %g,%g,%g\n", me,
col[0], col[1], col[2], mtt->range[miteRangeAlpha], E, ka, kd, ks);
fprintf(stderr, "%s: N = (%g,%g,%g), L = (%g,%g,%g) ---> LdotN = %g\n",
me, N[0], N[1], N[2], muu->lit->dir[0][0], muu->lit->dir[0][1],
muu->lit->dir[0][2], LdotN);
fprintf(stderr, "%s: ad[] = %g,%g,%g\n", me, ad[0], ad[1], ad[2]);
fprintf(stderr, "%s: --> R,G,B,A = %g,%g,%g,%g\n", me, *R, *G, *B, *A);
}
*/
return;
}
double
miteSample(miteThread *mtt, miteRender *mrr, miteUser *muu,
int num, double rayT, int inside,
double samplePosWorld[3],
double samplePosIndex[3]) {
static const char me[]="miteSample";
mite_t R, G, B, A;
double *NN;
double NdotV, kn[3], knd[3], ref[3], len, *dbg=NULL;
if (!inside) {
return mtt->rayStep;
}
if (mtt->skip) {
/* we have one verbose pixel, but we're not on it */
return 0.0;
}
/* early ray termination */
if (1-mtt->TT >= muu->opacNear1) {
mtt->TT = 0.0;
return 0.0;
}
/* set (fake) view based on fake from */
if (AIR_EXISTS(muu->fakeFrom[0])) {
ELL_3V_SUB(mtt->V, samplePosWorld, muu->fakeFrom);
ELL_3V_NORM(mtt->V, mtt->V, len);
}
/* do probing at this location to determine values of everything
that might appear in the txf domain */
if (gageProbe(mtt->gctx,
samplePosIndex[0],
samplePosIndex[1],
samplePosIndex[2])) {
biffAddf(MITE, "%s: gage trouble: %s (%d)", me,
mtt->gctx->errStr, mtt->gctx->errNum);
return AIR_NAN;
}
if (mrr->queryMiteNonzero) {
/* There is some optimal trade-off between slowing things down
with too many branches on all possible checks of queryMite,
and slowing things down with doing the work of setting them all.
This code has not been profiled whatsoever */
mtt->directAnsMiteVal[miteValXw][0] = samplePosWorld[0];
mtt->directAnsMiteVal[miteValXi][0] = samplePosIndex[0];
mtt->directAnsMiteVal[miteValYw][0] = samplePosWorld[1];
mtt->directAnsMiteVal[miteValYi][0] = samplePosIndex[1];
mtt->directAnsMiteVal[miteValZw][0] = samplePosWorld[2];
mtt->directAnsMiteVal[miteValZi][0] = samplePosIndex[2];
mtt->directAnsMiteVal[miteValRw][0] = ELL_3V_LEN(samplePosWorld);
mtt->directAnsMiteVal[miteValRi][0] = ELL_3V_LEN(samplePosIndex);
mtt->directAnsMiteVal[miteValTw][0] = rayT;
mtt->directAnsMiteVal[miteValTi][0] = num;
ELL_3V_COPY(mtt->directAnsMiteVal[miteValView], mtt->V);
NN = mtt->directAnsMiteVal[miteValNormal];
if (mtt->_normal) {
if (1 == muu->normalSide) {
ELL_3V_SCALE(NN, -1, mtt->_normal);
} else {
ELL_3V_COPY(NN, mtt->_normal);
}
}
if ((GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValNdotV)
|| GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValNdotL)
|| GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValVrefN))) {
mtt->directAnsMiteVal[miteValNdotV][0] = ELL_3V_DOT(NN, mtt->V);
mtt->directAnsMiteVal[miteValNdotL][0] =
ELL_3V_DOT(NN, muu->lit->dir[0]);
if (!muu->normalSide) {
mtt->directAnsMiteVal[miteValNdotV][0] =
AIR_ABS(mtt->directAnsMiteVal[miteValNdotV][0]);
mtt->directAnsMiteVal[miteValNdotL][0] =
AIR_ABS(mtt->directAnsMiteVal[miteValNdotL][0]);
}
NdotV = mtt->directAnsMiteVal[miteValNdotV][0];
ELL_3V_SCALE_ADD2(ref, 2*NdotV, NN, -1, mtt->V);
ELL_3V_NORM(mtt->directAnsMiteVal[miteValVrefN], ref, len);
}
if (GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValGTdotV)) {
ELL_3MV_MUL(kn, mtt->nPerp, mtt->V);
ELL_3V_NORM(kn, kn, len);
ELL_3MV_MUL(knd, mtt->geomTens, kn);
mtt->directAnsMiteVal[miteValGTdotV][0] = ELL_3V_DOT(knd, kn);
}
}
/* initialize txf range quantities, and apply all txfs */
if (mtt->verbose) {
muu->debugIdx = airArrayLenIncr(muu->debugArr, muu->ndebug->axis[0].size);
}
memcpy(mtt->range, muu->rangeInit, MITE_RANGE_NUM*sizeof(mite_t));
_miteStageRun(mtt, muu);
/* if there's opacity, do shading and compositing */
if (mtt->range[miteRangeAlpha]) {
/* fprintf(stderr, "%s: mtt->TT = %g\n", me, mtt->TT); */
/*
if (mtt->verbose) {
fprintf(stderr, "%s: before compositing: RGBT = %g,%g,%g,%g\n",
me, mtt->RR, mtt->GG, mtt->BB, mtt->TT);
}
*/
_miteRGBACalc(&R, &G, &B, &A, mtt, mrr, muu);
mtt->RR += mtt->TT*A*R;
mtt->GG += mtt->TT*A*G;
mtt->BB += mtt->TT*A*B;
mtt->TT *= 1-A;
/*
if (mtt->verbose) {
fprintf(stderr, "%s: after compositing: RGBT = %g,%g,%g,%g\n",
me, mtt->RR, mtt->GG, mtt->BB, mtt->TT);
}
*/
/* fprintf(stderr, "%s: mtt->TT = %g\n", me, mtt->TT); */
} else {
R = G = B = A = 0;
}
if (mtt->verbose) {
dbg = muu->debug + muu->debugIdx;
dbg[0 + 2*mtt->stageNum] = R;
dbg[1 + 2*mtt->stageNum] = G;
dbg[2 + 2*mtt->stageNum] = B;
dbg[3 + 2*mtt->stageNum] = A;
dbg[4 + 2*mtt->stageNum] = rayT;
}
/* set Z if it hasn't been set already */
if (1-mtt->TT >= muu->opacMatters && !AIR_EXISTS(mtt->ZZ)) {
mtt->ZZ = rayT;
}
/* this is used to index mtt->debug */
mtt->raySample += 1;
return mtt->rayStep;
}
int
fixproj(Nrrd *nproj[3], Nrrd *nvol) {
char me[]="fixproj", err[BIFF_STRLEN];
airArray *mop;
Nrrd *ntmp[3], *nt;
int sz[3], ii, map[3], h[3], E, mi;
size_t rsz[3];
double vec[3][3], dot[3], sp[3], parm[NRRD_KERNEL_PARMS_NUM];
mop = airMopNew();
if (!( ELL_3V_EXISTS(nvol->axis[0].spaceDirection)
&& ELL_3V_EXISTS(nvol->axis[1].spaceDirection)
&& ELL_3V_EXISTS(nvol->axis[2].spaceDirection) )) {
sprintf(err, "%s: space directions don't exist for all 3 axes", me);
biffAdd(NINSPECT, err);
airMopError(mop); return 1;
}
airMopAdd(mop, nt = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ntmp[0] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ntmp[1] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ntmp[2] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
/* RL AP SI */
ELL_3V_SET(vec[0], 1, 0, 0);
ELL_3V_SET(vec[1], 0, 1, 0);
ELL_3V_SET(vec[2], 0, 0, 1);
for (ii=0; ii<3; ii++) {
dot[0] = ELL_3V_DOT(vec[ii], nvol->axis[0].spaceDirection);
dot[1] = ELL_3V_DOT(vec[ii], nvol->axis[1].spaceDirection);
dot[2] = ELL_3V_DOT(vec[ii], nvol->axis[2].spaceDirection);
dot[0] = AIR_ABS(dot[0]);
dot[1] = AIR_ABS(dot[1]);
dot[2] = AIR_ABS(dot[2]);
map[ii] = ELL_MAX3_IDX(dot[0], dot[1], dot[2]);
}
ELL_3V_SET(h, 1, 0, 0);
E = 0;
for (ii=0; ii<3; ii++) {
if (h[map[ii]] != map[h[ii]]) {
if (!E) E |= nrrdAxesSwap(ntmp[ii], nproj[map[ii]], 1, 2);
} else {
if (!E) E |= nrrdCopy(ntmp[ii], nproj[map[ii]]);
}
}
if (E) {
sprintf(err, "%s: trouble with nrrd operations", me);
biffMove(NINSPECT, err, NRRD);
airMopError(mop); return 1;
}
E = 0;
if (nvol->axis[map[0]].spaceDirection[0] > 0) {
if (!E) E |= nrrdFlip(nt, ntmp[1], 0+1);
if (!E) E |= nrrdCopy(ntmp[1], nt);
if (!E) E |= nrrdFlip(nt, ntmp[2], 0+1);
if (!E) E |= nrrdCopy(ntmp[2], nt);
}
if (nvol->axis[map[1]].spaceDirection[1] > 0) {
if (!E) E |= nrrdFlip(nt, ntmp[0], 0+1);
if (!E) E |= nrrdCopy(ntmp[0], nt);
if (!E) E |= nrrdFlip(nt, ntmp[2], 1+1);
if (!E) E |= nrrdCopy(ntmp[2], nt);
}
if (nvol->axis[map[2]].spaceDirection[2] > 0) {
if (!E) E |= nrrdFlip(nt, ntmp[0], 1+1);
if (!E) E |= nrrdCopy(ntmp[0], nt);
if (!E) E |= nrrdFlip(nt, ntmp[1], 1+1);
if (!E) E |= nrrdCopy(ntmp[1], nt);
}
if (E) {
sprintf(err, "%s: trouble with nrrd operations", me);
biffMove(NINSPECT, err, NRRD);
airMopError(mop); return 1;
}
for (ii=0; ii<3; ii++) {
sz[ii] = nvol->axis[map[ii]].size;
sp[ii] = ELL_3V_LEN(nvol->axis[map[ii]].spaceDirection);
}
mi = ELL_MIN3_IDX(sp[0], sp[1], sp[2]);
sz[0] = (int)(sz[0]*sp[0]/sp[mi]);
sz[1] = (int)(sz[1]*sp[1]/sp[mi]);
sz[2] = (int)(sz[2]*sp[2]/sp[mi]);
parm[0] = 1;
ELL_3V_SET(rsz, 3, sz[1], sz[2]);
nrrdSimpleResample(nproj[0], ntmp[0], nrrdKernelBox, parm, rsz, NULL);
ELL_3V_SET(rsz, 3, sz[0], sz[2]);
nrrdSimpleResample(nproj[1], ntmp[1], nrrdKernelBox, parm, rsz, NULL);
ELL_3V_SET(rsz, 3, sz[0], sz[1]);
nrrdSimpleResample(nproj[2], ntmp[2], nrrdKernelBox, parm, rsz, NULL);
airMopOkay(mop);
return 0;
}
void
_gageSclAnswer (gageContext *ctx, gagePerVolume *pvl) {
char me[]="_gageSclAnswer";
double gmag=0, *hess, *norm, *gvec, *gten, *k1, *k2, curv=0,
sHess[9]={0,0,0,0,0,0,0,0,0};
double tmpMat[9], tmpVec[3], hevec[9], heval[3];
double len, gp1[3], gp2[3], *nPerp, ncTen[9], nProj[9]={0,0,0,0,0,0,0,0,0};
double alpha = 0.5;
double beta = 0.5;
double gamma = 5;
double cc = 1e-6;
#define FD_MEDIAN_MAX 16
int fd, nidx, xi, yi, zi;
double *fw, iv3wght[2*FD_MEDIAN_MAX*FD_MEDIAN_MAX*FD_MEDIAN_MAX],
wghtSum, wght;
/* convenience pointers for work below */
hess = pvl->directAnswer[gageSclHessian];
gvec = pvl->directAnswer[gageSclGradVec];
norm = pvl->directAnswer[gageSclNormal];
nPerp = pvl->directAnswer[gageSclNPerp];
gten = pvl->directAnswer[gageSclGeomTens];
k1 = pvl->directAnswer[gageSclK1];
k2 = pvl->directAnswer[gageSclK2];
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclValue)) {
/* done if doV */
if (ctx->verbose) {
fprintf(stderr, "%s: val = % 15.7f\n", me,
(double)(pvl->directAnswer[gageSclValue][0]));
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGradVec)) {
/* done if doD1 */
if (ctx->verbose) {
fprintf(stderr, "%s: gvec = ", me);
ell_3v_print_d(stderr, gvec);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGradMag)) {
/* this is the true value of gradient magnitude */
gmag = pvl->directAnswer[gageSclGradMag][0] = sqrt(ELL_3V_DOT(gvec, gvec));
}
/* NB: it would seem that gageParmGradMagMin is completely ignored ... */
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclNormal)) {
if (gmag) {
ELL_3V_SCALE(norm, 1/gmag, gvec);
/* polishing ...
len = sqrt(ELL_3V_DOT(norm, norm));
ELL_3V_SCALE(norm, 1/len, norm);
*/
} else {
ELL_3V_COPY(norm, gageZeroNormal);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclNPerp)) {
/* nPerp = I - outer(norm, norm) */
/* NB: this sets both nPerp and nProj */
ELL_3MV_OUTER(nProj, norm, norm);
ELL_3M_SCALE(nPerp, -1, nProj);
nPerp[0] += 1;
nPerp[4] += 1;
nPerp[8] += 1;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessian)) {
/* done if doD2 */
if (ctx->verbose) {
fprintf(stderr, "%s: hess = \n", me);
ell_3m_print_d(stderr, hess);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclLaplacian)) {
pvl->directAnswer[gageSclLaplacian][0] = hess[0] + hess[4] + hess[8];
if (ctx->verbose) {
fprintf(stderr, "%s: lapl = %g + %g + %g = %g\n", me,
hess[0], hess[4], hess[8],
pvl->directAnswer[gageSclLaplacian][0]);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessFrob)) {
pvl->directAnswer[gageSclHessFrob][0] = ELL_3M_FROB(hess);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessEval)) {
/* HEY: look at the return value for root multiplicity? */
ell_3m_eigensolve_d(heval, hevec, hess, AIR_TRUE);
ELL_3V_COPY(pvl->directAnswer[gageSclHessEval], heval);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessEvec)) {
ELL_3M_COPY(pvl->directAnswer[gageSclHessEvec], hevec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessRidgeness)) {
double A, B, S;
if (heval[1] >0 || heval[2]>0) {
pvl->directAnswer[gageSclHessRidgeness][0] = 0;
}
else if (AIR_ABS(heval[1])<1e-10 || AIR_ABS(heval[2])<1e-10) {
pvl->directAnswer[gageSclHessRidgeness][0] = 0;
}
else {
double *ans;
A = AIR_ABS(heval[1])/AIR_ABS(heval[2]);
B = AIR_ABS(heval[0])/sqrt(AIR_ABS(heval[1]*heval[2]));
S = sqrt(heval[0]*heval[0] + heval[1]*heval[1] + heval[2]*heval[2]);
ans = pvl->directAnswer[gageSclHessRidgeness];
ans[0] = (1-exp(-A*A/(2*alpha*alpha))) *
exp(-B*B/(2*beta*beta)) *
(1-exp(-S*S/(2*gamma*gamma))) *
exp(-2*cc*cc/(AIR_ABS(heval[1])*heval[2]*heval[2]));
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessValleyness)) {
double A, B, S;
if (heval[0] <0 || heval[1]<0) {
pvl->directAnswer[gageSclHessValleyness][0] = 0;
}
else if (AIR_ABS(heval[0])<1e-10 || AIR_ABS(heval[1])<1e-10) {
pvl->directAnswer[gageSclHessValleyness][0] = 0;
}
else {
double *ans;
A = AIR_ABS(heval[1])/AIR_ABS(heval[0]);
B = AIR_ABS(heval[2])/sqrt(AIR_ABS(heval[1]*heval[0]));
S = sqrt(heval[0]*heval[0] + heval[1]*heval[1] + heval[2]*heval[2]);
ans = pvl->directAnswer[gageSclHessValleyness];
ans[0] = (1-exp(-A*A/(2*alpha*alpha))) *
exp(-B*B/(2*beta*beta)) *
(1-exp(-S*S/(2*gamma*gamma))) *
exp(-2*cc*cc/(AIR_ABS(heval[1])*heval[0]*heval[0]));
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessMode)) {
pvl->directAnswer[gageSclHessMode][0] = airMode3_d(heval);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageScl2ndDD)) {
ELL_3MV_MUL(tmpVec, hess, norm);
pvl->directAnswer[gageScl2ndDD][0] = ELL_3V_DOT(norm, tmpVec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGeomTens)) {
if (gmag > ctx->parm.gradMagCurvMin) {
/* parm.curvNormalSide applied here to determine the sense of the
normal when doing all curvature calculations */
ELL_3M_SCALE(sHess, -(ctx->parm.curvNormalSide)/gmag, hess);
/* gten = nPerp * sHess * nPerp */
ELL_3M_MUL(tmpMat, sHess, nPerp);
ELL_3M_MUL(gten, nPerp, tmpMat);
if (ctx->verbose) {
fprintf(stderr, "%s: gten: \n", me);
ell_3m_print_d(stderr, gten);
ELL_3MV_MUL(tmpVec, gten, norm);
len = ELL_3V_LEN(tmpVec);
fprintf(stderr, "%s: should be small: %30.15f\n", me, (double)len);
ell_3v_perp_d(gp1, norm);
ELL_3MV_MUL(tmpVec, gten, gp1);
len = ELL_3V_LEN(tmpVec);
fprintf(stderr, "%s: should be bigger: %30.15f\n", me, (double)len);
ELL_3V_CROSS(gp2, gp1, norm);
ELL_3MV_MUL(tmpVec, gten, gp2);
len = ELL_3V_LEN(tmpVec);
fprintf(stderr, "%s: should (also) be bigger: %30.15f\n",
me, (double)len);
}
} else {
ELL_3M_ZERO_SET(gten);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclTotalCurv)) {
curv = pvl->directAnswer[gageSclTotalCurv][0] = ELL_3M_FROB(gten);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclShapeTrace)) {
pvl->directAnswer[gageSclShapeTrace][0] = (curv
? ELL_3M_TRACE(gten)/curv
: 0);
}
if ( (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclK1)) ||
(GAGE_QUERY_ITEM_TEST(pvl->query, gageSclK2)) ){
double T, N, D;
T = ELL_3M_TRACE(gten);
N = curv;
D = 2*N*N - T*T;
/*
if (D < -0.0000001) {
fprintf(stderr, "%s: %g %g\n", me, T, N);
fprintf(stderr, "%s: !!! D curv determinant % 22.10f < 0.0\n", me, D);
fprintf(stderr, "%s: gten: \n", me);
ell_3m_print_d(stderr, gten);
}
*/
D = AIR_MAX(D, 0);
D = sqrt(D);
k1[0] = 0.5*(T + D);
k2[0] = 0.5*(T - D);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclMeanCurv)) {
pvl->directAnswer[gageSclMeanCurv][0] = (*k1 + *k2)/2;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGaussCurv)) {
pvl->directAnswer[gageSclGaussCurv][0] = (*k1)*(*k2);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclShapeIndex)) {
pvl->directAnswer[gageSclShapeIndex][0] =
-(2/AIR_PI)*atan2(*k1 + *k2, *k1 - *k2);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclCurvDir1)) {
/* HEY: this only works when K1, K2, 0 are all well mutually distinct,
since these are the eigenvalues of the geometry tensor, and this
code assumes that the eigenspaces are all one-dimensional */
ELL_3M_COPY(tmpMat, gten);
ELL_3M_DIAG_SET(tmpMat, gten[0] - *k1, gten[4]- *k1, gten[8] - *k1);
ell_3m_1d_nullspace_d(tmpVec, tmpMat);
ELL_3V_COPY(pvl->directAnswer[gageSclCurvDir1], tmpVec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclCurvDir2)) {
/* HEY: this only works when K1, K2, 0 are all well mutually distinct,
since these are the eigenvalues of the geometry tensor, and this
code assumes that the eigenspaces are all one-dimensional */
ELL_3M_COPY(tmpMat, gten);
ELL_3M_DIAG_SET(tmpMat, gten[0] - *k2, gten[4] - *k2, gten[8] - *k2);
ell_3m_1d_nullspace_d(tmpVec, tmpMat);
ELL_3V_COPY(pvl->directAnswer[gageSclCurvDir2], tmpVec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclFlowlineCurv)) {
if (gmag >= ctx->parm.gradMagCurvMin) {
/* because of the gageSclGeomTens prerequisite, sHess, nPerp, and
nProj are all already set */
/* ncTen = nPerp * sHess * nProj */
ELL_3M_MUL(tmpMat, sHess, nProj);
ELL_3M_MUL(ncTen, nPerp, tmpMat);
} else {
ELL_3M_ZERO_SET(ncTen);
}
/* there used to be a wrong extra sqrt() here */
pvl->directAnswer[gageSclFlowlineCurv][0] = ELL_3M_FROB(ncTen);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclMedian)) {
/* this item is currently a complete oddball in that it does not
benefit from anything done in the "filter" stage, which is in
fact a waste of time if the query consists only of this item */
fd = 2*ctx->radius;
if (fd > FD_MEDIAN_MAX) {
fprintf(stderr, "%s: PANIC: current filter diameter = %d "
"> FD_MEDIAN_MAX = %d\n", me, fd, FD_MEDIAN_MAX);
exit(1);
}
fw = ctx->fw + fd*3*gageKernel00;
/* HEY: this needs some optimization help */
wghtSum = 0;
nidx = 0;
for (xi=0; xi<fd; xi++) {
for (yi=0; yi<fd; yi++) {
for (zi=0; zi<fd; zi++) {
iv3wght[0 + 2*nidx] = pvl->iv3[nidx];
iv3wght[1 + 2*nidx] = fw[xi + 0*fd]*fw[yi + 1*fd]*fw[zi + 2*fd];
wghtSum += iv3wght[1 + 2*nidx];
nidx++;
}
}
}
qsort(iv3wght, fd*fd*fd, 2*sizeof(double), nrrdValCompare[nrrdTypeDouble]);
wght = 0;
for (nidx=0; nidx<fd*fd*fd; nidx++) {
wght += iv3wght[1 + 2*nidx];
if (wght > wghtSum/2) {
break;
}
}
pvl->directAnswer[gageSclMedian][0] = iv3wght[0 + 2*nidx];
}
return;
}
int
main(int argc, char *argv[]) {
float angleA_f, axisA_f[3], angleB_f, axisB_f[3],
qA_f[4], qB_f[4], qC_f[4],
mat3A_f[9], mat4A_f[16], mat3B_f[9], mat4B_f[16], mat3C_f[9], mat4C_f[16],
pntA_f[4], pntB_f[4], pntC_f[4];
double angleA_d, axisA_d[3], angleB_d, axisB_d[3],
qA_d[4], qB_d[4], qC_d[4],
mat3A_d[9], mat4A_d[16], mat3B_d[9], mat4B_d[16], mat3C_d[9], mat4C_d[16],
pntA_d[4], pntB_d[4], pntC_d[4];
int I, N;
double tmp, det, frob;
me = argv[0];
N = 100000;
AIR_UNUSED(pntA_d);
AIR_UNUSED(pntB_d);
AIR_UNUSED(pntC_d);
AIR_UNUSED(mat4C_d);
AIR_UNUSED(mat3C_d);
AIR_UNUSED(mat4B_d);
AIR_UNUSED(mat3B_d);
AIR_UNUSED(mat4A_d);
AIR_UNUSED(mat3A_d);
AIR_UNUSED(qC_d);
AIR_UNUSED(qB_d);
AIR_UNUSED(qA_d);
AIR_UNUSED(axisB_d);
AIR_UNUSED(angleB_d);
AIR_UNUSED(axisA_d);
AIR_UNUSED(angleA_d);
AIR_UNUSED(argc);
for (I=0; I<N; I++) {
/* make a rotation (as a quaternion) */
ELL_3V_SET(axisA_f, 2*airDrandMT()-1, 2*airDrandMT()-1, 2*airDrandMT()-1);
ELL_3V_NORM(axisA_f, axisA_f, tmp); /* yea, not uniform, so what */
angleA_f = AIR_PI*(2*airDrandMT()-1);
ell_aa_to_q_f(qA_f, angleA_f, axisA_f);
/* convert to AA and back, and back */
angleB_f = ell_q_to_aa_f(axisB_f, qA_f);
if (ELL_3V_DOT(axisB_f, axisA_f) < 0) {
ELL_3V_SCALE(axisB_f, -1, axisB_f);
angleB_f *= -1;
}
ELL_3V_SUB(axisA_f, axisA_f, axisB_f);
printf(" aa -> q -> aa error: %g, %g\n",
CA + AIR_ABS(angleA_f - angleB_f), CA + ELL_3V_LEN(axisA_f));
/* convert to 3m and back, and back */
ell_q_to_3m_f(mat3A_f, qA_f);
ell_3m_to_q_f(qB_f, mat3A_f);
if (ELL_4V_DOT(qA_f, qB_f) < 0) {
ELL_4V_SCALE(qB_f, -1, qB_f);
}
ELL_4V_SUB(qC_f, qA_f, qB_f);
ELL_Q_TO_3M(mat3B_f, qA_f);
ELL_3M_SUB(mat3C_f, mat3B_f, mat3A_f);
printf(" q -> 3m -> q error: %g, %g\n",
CA + ELL_4V_LEN(qC_f), CA + ELL_3M_FROB(mat3C_f));
/* convert to 4m and back, and back */
ell_q_to_4m_f(mat4A_f, qA_f);
ell_4m_to_q_f(qB_f, mat4A_f);
if (ELL_4V_DOT(qA_f, qB_f) < 0) {
ELL_4V_SCALE(qB_f, -1, qB_f);
}
ELL_4V_SUB(qC_f, qA_f, qB_f);
ELL_Q_TO_4M(mat4B_f, qA_f);
ELL_4M_SUB(mat4C_f, mat4B_f, mat4A_f);
printf(" q -> 4m -> q error: %g, %g\n",
CA + ELL_4V_LEN(qC_f), CA + ELL_4M_FROB(mat4C_f));
/* make a point that we'll rotate */
ELL_3V_SET(pntA_f, 2*airDrandMT()-1, 2*airDrandMT()-1, 2*airDrandMT()-1);
/* effect rotation in two different ways, and compare results */
ELL_3MV_MUL(pntB_f, mat3A_f, pntA_f);
ell_q_3v_rotate_f(pntC_f, qA_f, pntA_f);
ELL_3V_SUB(pntA_f, pntB_f, pntC_f);
printf(" rotation error = %g\n", CA + ELL_3V_LEN(pntA_f));
/* mix up inversion with conversion */
ell_3m_inv_f(mat3C_f, mat3A_f);
ell_3m_to_q_f(qB_f, mat3C_f);
ell_q_mul_f(qC_f, qA_f, qB_f);
if (ELL_4V_DOT(qA_f, qC_f) < 0) {
ELL_4V_SCALE(qC_f, -1, qC_f);
}
printf(" inv mul = %g %g %g %g\n", qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
ell_q_inv_f(qC_f, qB_f);
ELL_4V_SUB(qC_f, qB_f, qB_f);
printf(" inv diff = %g %g %g %g\n", CA + qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
/* exp and log */
ell_q_log_f(qC_f, qA_f);
ell_q_log_f(qB_f, qC_f);
ell_q_exp_f(qC_f, qB_f);
ell_q_exp_f(qB_f, qC_f);
ELL_4V_SUB(qC_f, qB_f, qA_f);
printf(" exp/log diff = %g %g %g %g\n", CA + qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
/* pow, not very exhaustive */
ell_q_to_3m_f(mat3A_f, qA_f);
ell_3m_post_mul_f(mat3A_f, mat3A_f);
ell_3m_post_mul_f(mat3A_f, mat3A_f);
ell_q_pow_f(qB_f, qA_f, 4);
ell_q_to_3m_f(mat3B_f, qB_f);
ELL_3M_SUB(mat3B_f, mat3B_f, mat3A_f);
printf(" pow diff = %g\n", CA + ELL_3M_FROB(mat3B_f));
if (ELL_3M_FROB(mat3B_f) > 2) {
printf(" start q = %g %g %g %g\n", qA_f[0], qA_f[1], qA_f[2], qA_f[3]);
angleA_f = ell_q_to_aa_f(axisA_f, qA_f);
printf(" --> aa = %g (%g %g %g)\n", angleA_f,
axisA_f[0], axisA_f[1], axisA_f[2]);
printf(" q^3 = %g %g %g %g\n", qB_f[0], qB_f[1], qB_f[2], qB_f[3]);
angleA_f = ell_q_to_aa_f(axisA_f, qB_f);
printf(" --> aa = %g (%g %g %g)\n", angleA_f,
axisA_f[0], axisA_f[1], axisA_f[2]);
exit(1);
}
/* make sure it looks like a rotation matrix */
ell_q_to_3m_f(mat3A_f, qA_f);
det = ELL_3M_DET(mat3A_f);
frob = ELL_3M_FROB(mat3A_f);
ELL_3M_TRANSPOSE(mat3B_f, mat3A_f);
ell_3m_inv_f(mat3C_f, mat3A_f);
ELL_3M_SUB(mat3C_f, mat3B_f, mat3C_f);
printf(" det = %g; size = %g; err = %g\n", det, frob*frob/3,
CA + ELL_3M_FROB(mat3C_f));
}
exit(0);
}
double
_energyFromPoints(pullTask *task, pullBin *bin, pullPoint *point,
/* output */
double egradSum[4]) {
/* char me[]="_energyFromPoints"; */
double energySum, distSqSum, spaDistSqMax, wghtSum;
int nopt, /* optimiziation: we sometimes re-use neighbor lists */
ntrue; /* we search all possible neighbors, stored in the bins
(either because !nopt, or, this iter we learn true
subset of interacting neighbors). This could also
be called "dontreuse" or something like that */
unsigned int nidx,
nnum; /* how much of task->neigh[] we use */
/* set nopt and ntrue */
if (task->pctx->neighborTrueProb < 1) {
nopt = AIR_TRUE;
if (egradSum) {
/* We allow the neighbor list optimization only when we're also asked
to compute the energy gradient. When we're not getting the energy
gradient, we're being called to test the waters at possible new
locations, in which case we can't be changing the effective particle
neighborhood */
ntrue = (0 == task->pctx->iter
|| airDrandMT_r(task->rng) < task->pctx->neighborTrueProb);
} else {
ntrue = AIR_FALSE;
}
} else {
nopt = AIR_FALSE;
ntrue = AIR_TRUE;
}
/*
fprintf(stderr, "!%s(%u), nopt = %d, ntrue = %d\n", me, point->idtag,
nopt, ntrue);
*/
/* set nnum and task->neigh[] */
if (ntrue) {
nnum = _neighBinPoints(task, bin, point);
if (nopt) {
airArrayLenSet(point->neighArr, 0);
}
} else {
/* (nopt true) this iter we re-use existing neighbor list */
nnum = point->neighNum;
for (nidx=0; nidx<nnum; nidx++) {
task->neighPoint[nidx] = point->neighPoint[nidx];
}
}
/* loop through neighbor points */
spaDistSqMax = 4*task->pctx->radiusSpace*task->pctx->radiusSpace;
/*
fprintf(stderr, "%s: radiusSpace = %g -> spaDistSqMax = %g\n", me,
task->pctx->radiusSpace, spaDistSqMax);
*/
wghtSum = 0;
energySum = 0;
distSqSum = 0;
point->neighInterNum = 0;
point->neighDist = 0.0;
point->neighMode = 0.0;
if (egradSum) {
ELL_4V_SET(egradSum, 0, 0, 0, 0);
}
for (nidx=0; nidx<nnum; nidx++) {
double diff[4], spaDistSq, enr, egrad[4];
pullPoint *herPoint;
herPoint = task->neighPoint[nidx];
ELL_4V_SUB(diff, herPoint->pos, point->pos);
spaDistSq = ELL_3V_DOT(diff, diff);
/*
fprintf(stderr, "!%s: %u:%g,%g,%g <-- %u:%g,%g,%g = sqd %g %s %g\n", me,
point->idtag, point->pos[0], point->pos[1], point->pos[2],
herPoint->idtag,
herPoint->pos[0], herPoint->pos[1], herPoint->pos[2],
spaDistSq, spaDistSq > spaDistSqMax ? ">" : "<=", spaDistSqMax);
*/
if (spaDistSq > spaDistSqMax) {
continue;
}
if (AIR_ABS(diff[3] > task->pctx->radiusScale)) {
continue;
}
enr = _energyInterParticle(task, point, herPoint, egrad);
/*
fprintf(stderr, "!%s: energySum = %g + %g = %g\n", me,
energySum, enr, energySum + enr);
*/
energySum += enr;
if (egradSum) {
ELL_4V_INCR(egradSum, egrad);
if (ELL_4V_DOT(egrad, egrad)) {
point->neighInterNum++;
point->neighDist = spaDistSq;
if (task->pctx->ispec[pullInfoTangentMode]) {
double w, m;
m = _pullPointScalar(task->pctx, herPoint, pullInfoTangentMode,
NULL, NULL);
w = 1.0/spaDistSq;
point->neighMode += w*m;
wghtSum += w;
}
if (nopt && ntrue) {
unsigned int ii;
ii = airArrayLenIncr(point->neighArr, 1);
point->neighPoint[ii] = herPoint;
}
}
}
}
/* finish computing things averaged over neighbors */
if (point->neighInterNum) {
point->neighDist = sqrt(point->neighDist/point->neighInterNum);
point->neighMode /= wghtSum;
} else {
point->neighDist = -1;
point->neighMode = AIR_NAN;
}
return energySum;
}
void
tend_helixDoit(Nrrd *nout, double bnd,
double orig[3], double i2w[9], double mf[9],
double r, double R, double S, double angle, int incrtwist,
double ev[3], double bgEval) {
int sx, sy, sz, xi, yi, zi;
double th, t0, t1, t2, t3, v1, v2,
wpos[3], vpos[3], mfT[9],
W2H[9], H2W[9], H2C[9], C2H[9], fv[3], rv[3], uv[3], mA[9], mB[9], inside,
tmp[3], len;
float *out;
sx = nout->axis[1].size;
sy = nout->axis[2].size;
sz = nout->axis[3].size;
out = (float*)nout->data;
ELL_3M_TRANSPOSE(mfT, mf);
for (zi=0; zi<sz; zi++) {
fprintf(stderr, "zi = %d/%d\n", zi, sz);
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
ELL_3V_SET(tmp, xi, yi, zi);
ELL_3MV_MUL(vpos, i2w, tmp);
ELL_3V_INCR(vpos, orig);
#define WPOS(pos, th) ELL_3V_SET((pos),R*cos(th), R*sin(th), S*(th)/(2*AIR_PI))
#define VAL(th) (WPOS(wpos, th), ELL_3V_DIST(wpos, vpos))
#define RR 0.61803399
#define CC (1.0-RR)
#define SHIFT3(a,b,c,d) (a)=(b); (b)=(c); (c)=(d)
#define SHIFT2(a,b,c) (a)=(b); (b)=(c)
th = atan2(vpos[1], vpos[0]);
th += 2*AIR_PI*floor(0.5 + vpos[2]/S - th/(2*AIR_PI));
if (S*th/(2*AIR_PI) > vpos[2]) {
t0 = th - AIR_PI; t3 = th;
} else {
t0 = th; t3 = th + AIR_PI;
}
t1 = RR*t0 + CC*t3;
t2 = CC*t0 + RR*t3;
v1 = VAL(t1);
v2 = VAL(t2);
while ( t3-t0 > 0.000001*(AIR_ABS(t1)+AIR_ABS(t2)) ) {
if (v1 < v2) {
SHIFT3(t3, t2, t1, CC*t0 + RR*t2);
SHIFT2(v2, v1, VAL(t1));
} else {
SHIFT3(t0, t1, t2, RR*t1 + CC*t3);
SHIFT2(v1, v2, VAL(t2));
}
}
/* t1 (and t2) are now the th for which the point on the helix
(R*cos(th), R*sin(th), S*(th)/(2*AIR_PI)) is closest to vpos */
WPOS(wpos, t1);
ELL_3V_SUB(wpos, vpos, wpos);
ELL_3V_SET(fv, -R*sin(t1), R*cos(t1), S/AIR_PI); /* helix tangent */
ELL_3V_NORM(fv, fv, len);
ELL_3V_COPY(rv, wpos);
ELL_3V_NORM(rv, rv, len);
len = ELL_3V_DOT(rv, fv);
ELL_3V_SCALE(tmp, -len, fv);
ELL_3V_ADD2(rv, rv, tmp);
ELL_3V_NORM(rv, rv, len); /* rv now normal to helix, closest to
pointing to vpos */
ELL_3V_CROSS(uv, rv, fv);
ELL_3V_NORM(uv, uv, len); /* (rv,fv,uv) now right-handed frame */
ELL_3MV_ROW0_SET(W2H, uv); /* as is (uv,rv,fv) */
ELL_3MV_ROW1_SET(W2H, rv);
ELL_3MV_ROW2_SET(W2H, fv);
ELL_3M_TRANSPOSE(H2W, W2H);
inside = 0.5 - 0.5*airErf((ELL_3V_LEN(wpos)-r)/(bnd + 0.0001));
if (incrtwist) {
th = angle*ELL_3V_LEN(wpos)/r;
} else {
th = angle;
}
ELL_3M_ROTATE_Y_SET(H2C, th);
ELL_3M_TRANSPOSE(C2H, H2C);
ELL_3M_SCALE_SET(mA,
AIR_LERP(inside, bgEval, ev[1]),
AIR_LERP(inside, bgEval, ev[2]),
AIR_LERP(inside, bgEval, ev[0]));
ELL_3M_MUL(mB, mA, H2C);
ELL_3M_MUL(mA, mB, W2H);
ELL_3M_MUL(mB, mA, mf);
ELL_3M_MUL(mA, C2H, mB);
ELL_3M_MUL(mB, H2W, mA);
ELL_3M_MUL(mA, mfT, mB);
TEN_M2T_TT(out, float, mA);
out[0] = 1.0;
out += 7;
}
}
}
return;
}
int
main(int argc, char *argv[]) {
char *me;
hestOpt *hopt=NULL;
airArray *mop;
double tripA[3], tripB[3], evalA[3], evalB[3],
rt_A[3], rt_B[3], trip[3], eval[3], lasteval[3], lastxyz[3],
logAB[3], ndist;
int ittype, ottype, ptype, rttype;
unsigned int NN, ii;
tenInterpParm *tip;
void (*interp)(double oeval[3], const double evalA[3],
const double evalB[3], const double tt);
double (*qdist)(const double RTh_A[3], const double RTh_B[3]);
void (*qlog)(double klog[3],
const double RThZA[3], const double RThZB[3]);
void (*qexp)(double RThZB[3],
const double RThZA[3], const double klog[3]);
void (*grads)(double grad[3][3], const double eval[3]);
me = argv[0];
mop = airMopNew();
tip = tenInterpParmNew();
airMopAdd(mop, tip, (airMopper)tenInterpParmNix, airMopAlways);
hestOptAdd(&hopt, "a", "start", airTypeDouble, 3, 3, tripA, NULL,
"start triple of values");
hestOptAdd(&hopt, "b", "end", airTypeDouble, 3, 3, tripB, NULL,
"end triple of values");
hestOptAdd(&hopt, "it", "type", airTypeEnum, 1, 1, &ittype, NULL,
"type of given start and end triples", NULL, tenTripleType);
hestOptAdd(&hopt, "ot", "type", airTypeEnum, 1, 1, &ottype, NULL,
"type of triples for output", NULL, tenTripleType);
hestOptAdd(&hopt, "p", "type", airTypeEnum, 1, 1, &ptype, NULL,
"type of path interpolation", NULL, tenInterpType);
hestOptAdd(&hopt, "n", "# steps", airTypeUInt, 1, 1, &NN, "100",
"number of steps along path");
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1,
&(tip->verbose), "0", "verbosity");
hestOptAdd(&hopt, "s", "stepsize", airTypeDouble, 1, 1,
&(tip->convStep), "1", "step size in update");
hestOptAdd(&hopt, "r", "recurse", airTypeInt, 0, 0,
&(tip->enableRecurse), NULL,
"enable recursive solution, when useful");
hestOptAdd(&hopt, "mn", "minnorm", airTypeDouble, 1, 1,
&(tip->minNorm), "0.000001",
"minnorm of something");
hestOptAdd(&hopt, "mi", "maxiter", airTypeUInt, 1, 1,
&(tip->maxIter), "0",
"if non-zero, max # iterations for computation");
hestOptAdd(&hopt, "c", "conv", airTypeDouble, 1, 1,
&(tip->convEps), "0.0001",
"convergence threshold of length fraction");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (!( tenInterpTypeQuatGeoLoxK == ptype
|| tenInterpTypeQuatGeoLoxR == ptype )) {
fprintf(stderr, "%s: need type %s or %s, not %s\n", me,
airEnumStr(tenInterpType, tenInterpTypeQuatGeoLoxK),
airEnumStr(tenInterpType, tenInterpTypeQuatGeoLoxR),
airEnumStr(tenInterpType, ptype));
airMopError(mop);
return 1;
}
if (tenInterpTypeQuatGeoLoxK == ptype) {
interp = tenQGLInterpTwoEvalK;
qdist = _tenQGL_Kdist;
qlog = _tenQGL_Klog;
qexp = _tenQGL_Kexp;
grads = kgrads;
rttype = tenTripleTypeRThetaZ;
} else {
interp = tenQGLInterpTwoEvalR;
qdist = _tenQGL_Rdist;
qlog = _tenQGL_Rlog;
qexp = _tenQGL_Rexp;
grads = rgrads;
rttype = tenTripleTypeRThetaPhi;
}
fprintf(stderr, "%s: (%s) %f %f %f \n--%s--> %f %f %f\n", me,
airEnumStr(tenTripleType, ittype),
tripA[0], tripA[1], tripA[2],
airEnumStr(tenInterpType, ptype),
tripB[0], tripB[1], tripB[2]);
tenTripleConvertSingle_d(evalA, tenTripleTypeEigenvalue, tripA, ittype);
tenTripleConvertSingle_d(evalB, tenTripleTypeEigenvalue, tripB, ittype);
tenTripleConvertSingle_d(rt_A, rttype, tripA, ittype);
tenTripleConvertSingle_d(rt_B, rttype, tripB, ittype);
ndist = 0;
ELL_3V_SET(lasteval, AIR_NAN, AIR_NAN, AIR_NAN);
ELL_3V_SET(lastxyz, AIR_NAN, AIR_NAN, AIR_NAN);
qlog(logAB, rt_A, rt_B);
fprintf(stderr, "%s: log = %g %g %g (%g)\n", me,
logAB[0], logAB[1], logAB[2], ELL_3V_LEN(logAB));
for (ii=0; ii<NN; ii++) {
double tt, xyz[3], dot[3], ll[3], prayRT[3], prayO[3];
tt = AIR_AFFINE(0, ii, NN-1, 0.0, 1.0);
interp(eval, evalA, evalB, tt);
tenTripleConvertSingle_d(trip, ottype,
eval, tenTripleTypeEigenvalue);
tenTripleConvertSingle_d(xyz, tenTripleTypeXYZ,
eval, tenTripleTypeEigenvalue);
ELL_3V_SCALE(ll, tt, logAB);
qexp(prayRT, rt_A, ll);
tenTripleConvertSingle_d(prayO, ottype, prayRT, rttype);
if (ii) {
double diff[3], gr[3][3];
ELL_3V_SUB(diff, lasteval, eval);
ndist += ELL_3V_LEN(diff);
ELL_3V_SUB(diff, lastxyz, xyz);
grads(gr, eval);
dot[0] = ELL_3V_DOT(diff, gr[0]);
dot[1] = ELL_3V_DOT(diff, gr[1]);
dot[2] = ELL_3V_DOT(diff, gr[2]);
} else {
ELL_3V_SET(dot, 0, 0, 0);
}
printf("%03u %g %g %g %g %g %g 00 %g %g %g\n", ii,
trip[0], prayO[0],
trip[1], prayO[1],
trip[2], prayO[2],
dot[0], dot[1], dot[2]);
ELL_3V_COPY(lasteval, eval);
ELL_3V_COPY(lastxyz, xyz);
}
fprintf(stderr, "%s: dist %g =?= %g\n", me,
qdist(rt_A, rt_B), ndist);
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me;
hestOpt *hopt=NULL;
airArray *mop;
char *errS, *outS, *covarS;
Nrrd *_nodf, *nvec, *nhist, *ncovar;
int bins;
size_t size[NRRD_DIM_MAX];
float min;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "i", "odf", airTypeOther, 1, 1, &_nodf, NULL,
"ODF volume to analyze", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "v", "odf", airTypeOther, 1, 1, &nvec, NULL,
"list of vectors by which odf is sampled",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "min", "min", airTypeFloat, 1, 1, &min, "0.0",
"ODF values below this are ignored, and per-voxel ODF is "
"normalized to have sum 1.0. Use \"nan\" to subtract out "
"the per-voxel min.");
hestOptAdd(&hopt, "b", "bins", airTypeInt, 1, 1, &bins, "128",
"number of bins in histograms");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output file");
hestOptAdd(&hopt, "co", "covariance out", airTypeString, 1, 1,
&covarS, "covar.nrrd", "covariance output file");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (!( nrrdTypeFloat == nvec->type )) {
fprintf(stderr, "%s vector type (%s) not %s\n", me,
airEnumStr(nrrdType, nvec->type),
airEnumStr(nrrdType, nrrdTypeFloat));
airMopError(mop); return 1;
}
if (!( 2 == nvec->dim && 3 == nvec->axis[0].size )) {
fprintf(stderr, "%s: nvec not a 2-D 3-by-N array\n", me);
airMopError(mop); return 1;
}
if (!( _nodf->axis[0].size == nvec->axis[1].size )) {
fprintf(stderr, "%s mismatch of _nodf->axis[0].size (%d) vs. "
"nvec->axis[1].size (%d)\n", me,
(int)_nodf->axis[0].size, (int)nvec->axis[1].size);
airMopError(mop); return 1;
}
nrrdAxisInfoGet_nva(_nodf, nrrdAxisInfoSize, size);
size[0] = bins;
nhist = nrrdNew();
airMopAdd(mop, nhist, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_nva(nhist, nrrdTypeFloat, _nodf->dim, size)) {
airMopAdd(mop, errS = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating output:\n%s", me, errS);
airMopError(mop); return 1;
}
ncovar = nrrdNew();
airMopAdd(mop, ncovar, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(ncovar, nrrdTypeFloat, 2,
AIR_CAST(size_t, bins),
AIR_CAST(size_t, bins))) {
airMopAdd(mop, errS = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating covariance output:\n%s", me, errS);
airMopError(mop); return 1;
}
{
/* we modify the lengths of the vectors here */
int NN, VV, ii, jj=0, kk, *anglut;
float *odf, *hist, *covar, *vec, *vi, *vj, tmp, pvmin;
double *mean;
Nrrd *nodf, *nanglut;
VV = nvec->axis[1].size;
NN = nrrdElementNumber(_nodf)/VV;
nanglut = nrrdNew();
airMopAdd(mop, nanglut, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(nanglut, nrrdTypeInt, 2,
AIR_CAST(size_t, VV),
AIR_CAST(size_t, VV))) {
airMopAdd(mop, errS = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating lookup table:\n%s", me, errS);
airMopError(mop); return 1;
}
if (nrrdTypeFloat == _nodf->type) {
nodf = _nodf;
} else {
nodf = nrrdNew();
airMopAdd(mop, nodf, (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(nodf, _nodf, nrrdTypeFloat)) {
airMopAdd(mop, errS = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble converting input:\n%s", me, errS);
airMopError(mop); return 1;
}
}
/* normalize lengths (MODIFIES INPUT) */
vec = (float*)nvec->data;
for (ii=0; ii<=jj; ii++) {
vi = vec + 3*ii;
ELL_3V_NORM(vi, vi, tmp);
}
/* pre-compute pair-wise angles */
anglut = (int*)nanglut->data;
for (jj=0; jj<VV; jj++) {
vj = vec + 3*jj;
for (ii=0; ii<=jj; ii++) {
vi = vec + 3*ii;
tmp = ELL_3V_DOT(vi, vj);
tmp = AIR_ABS(tmp);
tmp = acos(tmp)/(AIR_PI/2.0);
anglut[ii + VV*jj] = airIndex(0.0, tmp, 1.0, bins);
}
}
/* process all samples (MODIFIES INPUT if input was already float) */
odf = (float*)nodf->data;
hist = (float*)nhist->data;
for (kk=0; kk<NN; kk++) {
if (!(kk % 100)) {
fprintf(stderr, "%d/%d\n", kk, NN);
}
tmp = 0;
if (AIR_EXISTS(min)) {
for (ii=0; ii<VV; ii++) {
odf[ii] = AIR_MAX(0.0, odf[ii]-min);
tmp += odf[ii];
}
} else {
/* we do the more sketchy per-voxel min subtraction */
pvmin = airFPGen_f(airFP_POS_INF);
for (ii=0; ii<VV; ii++) {
pvmin = AIR_MIN(pvmin, odf[ii]);
}
for (ii=0; ii<VV; ii++) {
odf[ii] -= pvmin;
tmp += odf[ii];
}
}
if (tmp) {
/* something left after subtracting out baseline isotropic */
for (ii=0; ii<VV; ii++) {
odf[ii] /= tmp;
}
/* odf[] is normalized to 1.0 sum */
for (jj=0; jj<VV; jj++) {
for (ii=0; ii<=jj; ii++) {
tmp = odf[ii]*odf[jj];
hist[anglut[ii + VV*jj]] += tmp;
}
}
}
odf += VV;
hist += bins;
}
odf = NULL;
hist = NULL;
/* find mean value of each bin (needed for covariance) */
mean = (double*)calloc(bins, sizeof(double));
if (!mean) {
fprintf(stderr, "%s: couldn't allocate mean array", me);
airMopError(mop); return 1;
}
hist = (float*)nhist->data;
for (kk=0; kk<NN; kk++) {
for (ii=0; ii<bins; ii++) {
mean[ii] += hist[ii];
}
hist += bins;
}
hist = NULL;
for (ii=0; ii<bins; ii++) {
mean[ii] /= NN;
}
/* make covariance matrix of from all histograms */
covar = (float*)ncovar->data;
hist = (float*)nhist->data;
for (kk=0; kk<NN; kk++) {
for (jj=0; jj<bins; jj++) {
for (ii=0; ii<jj; ii++) {
tmp = (hist[ii] - mean[ii])*(hist[jj] - mean[jj]);
covar[ii + bins*jj] += tmp;
covar[jj + bins*ii] += tmp;
}
covar[jj + bins*jj] += (hist[jj] - mean[jj])*(hist[jj] - mean[jj]);
}
hist += bins;
}
hist = NULL;
}
if (nrrdSave(outS, nhist, NULL)) {
airMopAdd(mop, errS = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s\n", me, errS);
airMopError(mop); return 1;
}
if (nrrdSave(covarS, ncovar, NULL)) {
airMopAdd(mop, errS = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save covariance output:\n%s\n", me, errS);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *outS;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
char *err, done[13];
Nrrd *nin, *nblur, *nout;
NrrdKernelSpec *kb0, *kb1, *k00, *k11, *k22;
NrrdResampleContext *rsmc;
int E;
unsigned int sx, sy, sz, xi, yi, zi, ai;
gageContext *ctx;
gagePerVolume *pvl;
const double *gvec, *gmag, *evec0, *eval;
double (*ins)(void *v, size_t I, double d);
double (*lup)(const void *v, size_t I);
double dotmax, dotpow, gmmax, evalshift, gmpow, _dotmax, _gmmax, scl, clamp;
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "kb0", "kernel", airTypeOther, 1, 1, &kb0,
"guass:3,5", "kernel to use for pre-process blurring",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kb1", "kernel", airTypeOther, 1, 1, &kb1,
"cubic:1.5,1,0", "kernel to use for pos-process blurring",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k00", "kernel", airTypeOther, 1, 1, &k00,
"cubic:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kernel", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kernel", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "dotmax", "dot", airTypeDouble, 1, 1, &dotmax, "5",
"max effective value of dot(gvec, evec0)");
hestOptAdd(&hopt, "evs", "shift", airTypeDouble, 1, 1, &evalshift, "0",
"negative shift to avoid changing mostly flat regions");
hestOptAdd(&hopt, "clamp", "clamp", airTypeDouble, 1, 1, &clamp, "nan",
"if it exists, data value can't be forced below this");
hestOptAdd(&hopt, "dotpow", "pow", airTypeDouble, 1, 1, &dotpow, "1",
"exponent for dot");
hestOptAdd(&hopt, "gmmax", "dot", airTypeDouble, 1, 1, &gmmax, "2",
"max effective value of gmag");
hestOptAdd(&hopt, "gmpow", "pow", airTypeDouble, 1, 1, &gmpow, "1",
"exponent for gmag");
hestOptAdd(&hopt, "scl", "scale", airTypeDouble, 1, 1, &scl, "0.1",
"how much to scale hack to decrease input value");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"fixed volume output");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, vhInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (!( 3 == nin->dim
&& nrrdTypeBlock != nin->type )) {
fprintf(stderr, "%s: need a 3-D scalar nrrd (not %u-D %s)", me,
nin->dim, airEnumStr(nrrdType, nin->type));
airMopError(mop); return 1;
}
nblur = nrrdNew();
airMopAdd(mop, nblur, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nblur, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s", me, err);
airMopError(mop); return 1;
}
fprintf(stderr, "%s: pre-blurring ... ", me);
fflush(stderr);
rsmc = nrrdResampleContextNew();
airMopAdd(mop, rsmc, (airMopper)nrrdResampleContextNix, airMopAlways);
E = AIR_FALSE;
if (!E) E |= nrrdResampleDefaultCenterSet(rsmc, nrrdCenterCell);
if (!E) E |= nrrdResampleNrrdSet(rsmc, nin);
for (ai=0; ai<3; ai++) {
if (!E) E |= nrrdResampleKernelSet(rsmc, ai, kb0->kernel, kb0->parm);
if (!E) E |= nrrdResampleSamplesSet(rsmc, ai, nin->axis[ai].size);
if (!E) E |= nrrdResampleRangeFullSet(rsmc, ai);
}
if (!E) E |= nrrdResampleBoundarySet(rsmc, nrrdBoundaryBleed);
if (!E) E |= nrrdResampleTypeOutSet(rsmc, nrrdTypeDefault);
if (!E) E |= nrrdResampleRenormalizeSet(rsmc, AIR_TRUE);
if (!E) E |= nrrdResampleExecute(rsmc, nblur);
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error resampling nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "done.\n");
ctx = gageContextNew();
airMopAdd(mop, ctx, (airMopper)gageContextNix, airMopAlways);
gageParmSet(ctx, gageParmRenormalize, AIR_TRUE);
gageParmSet(ctx, gageParmCheckIntegrals, AIR_TRUE);
E = 0;
if (!E) E |= !(pvl = gagePerVolumeNew(ctx, nblur, gageKindScl));
if (!E) E |= gagePerVolumeAttach(ctx, pvl);
if (!E) E |= gageKernelSet(ctx, gageKernel00, k00->kernel, k00->parm);
if (!E) E |= gageKernelSet(ctx, gageKernel11, k11->kernel, k11->parm);
if (!E) E |= gageKernelSet(ctx, gageKernel22, k22->kernel, k22->parm);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclGradVec);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclGradMag);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclHessEvec0);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclHessEval);
if (!E) E |= gageUpdate(ctx);
if (E) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
gvec = gageAnswerPointer(ctx, pvl, gageSclGradVec);
gmag = gageAnswerPointer(ctx, pvl, gageSclGradMag);
evec0 = gageAnswerPointer(ctx, pvl, gageSclHessEvec0);
eval = gageAnswerPointer(ctx, pvl, gageSclHessEval);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s", me, err);
airMopError(mop); return 1;
}
if (!(nout->type == nin->type && nblur->type == nin->type)) {
fprintf(stderr, "%s: whoa, types (%s %s %s) not all equal\n", me,
airEnumStr(nrrdType, nin->type),
airEnumStr(nrrdType, nblur->type),
airEnumStr(nrrdType, nout->type));
}
ins = nrrdDInsert[nout->type];
lup = nrrdDLookup[nout->type];
sx = nin->axis[0].size;
sy = nin->axis[1].size;
sz = nin->axis[2].size;
gageProbe(ctx, 0, 0, 0);
_dotmax = ELL_3V_DOT(gvec, evec0);
_gmmax = *gmag;
fprintf(stderr, "%s: hacking ", me);
fflush(stderr);
for (zi=0; zi<sz; zi++) {
fprintf(stderr, "%s", airDoneStr(0, zi, sz-1, done));
fflush(stderr);
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
size_t si;
double dot, evl, gm, shift, in, out, mode;
gageProbe(ctx, xi, yi, zi);
si = xi + sx*(yi + sy*zi);
dot = ELL_3V_DOT(gvec, evec0);
_dotmax = AIR_MAX(_dotmax, dot);
dot = AIR_ABS(dot);
dot = 1 - AIR_MIN(dot, dotmax)/dotmax;
dot = pow(dot, dotpow);
evl = AIR_MAX(0, eval[0] - evalshift);
mode = airMode3_d(eval);
evl *= AIR_AFFINE(-1, mode, 1, 0, 1);
_gmmax = AIR_MAX(_gmmax, *gmag);
gm = 1 - AIR_MIN(*gmag, gmmax)/gmmax;
gm = pow(gm, gmpow);
shift = scl*gm*evl*dot;
if (AIR_EXISTS(clamp)) {
in = lup(nin->data, si);
out = in - shift;
out = AIR_MAX(out, clamp);
shift = AIR_MAX(0, in - out);
}
ins(nout->data, si, shift);
}
}
}
fprintf(stderr, "\n");
fprintf(stderr, "%s: max dot seen: %g\n", me, _dotmax);
fprintf(stderr, "%s: max gm seen: %g\n", me, _gmmax);
fprintf(stderr, "%s: post-blurring ... ", me);
fflush(stderr);
E = AIR_FALSE;
if (!E) E |= nrrdResampleNrrdSet(rsmc, nout);
for (ai=0; ai<3; ai++) {
if (!E) E |= nrrdResampleKernelSet(rsmc, ai, kb1->kernel, kb1->parm);
if (!E) E |= nrrdResampleSamplesSet(rsmc, ai, nout->axis[ai].size);
if (!E) E |= nrrdResampleRangeFullSet(rsmc, ai);
}
if (!E) E |= nrrdResampleExecute(rsmc, nblur);
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error resampling nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "done.\n");
for (zi=0; zi<sz; zi++) {
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
size_t si;
double in, shift;
si = xi + sx*(yi + sy*zi);
in = lup(nin->data, si);
shift = lup(nblur->data, si);
ins(nout->data, si, in - shift);
}
}
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
exit(0);
}
