int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
char *outS;
Nrrd *_ncov, *ncov, *_nten[2], *nten[2], *nout;
double *cc, *t0, *t1, *out, ww[21];
size_t nn, ii;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "i4", "volume", airTypeOther, 1, 1, &_ncov, NULL,
"4th-order tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "i2", "v0 v1", airTypeOther, 2, 2, _nten, NULL,
"two 2nd-order tensor volumes", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"file to write output nrrd to");
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 (tenTensorCheck(_nten[0], nrrdTypeDefault, AIR_TRUE, AIR_TRUE)
|| tenTensorCheck(_nten[1], nrrdTypeDefault, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't like input:\n%s\n", me, err);
airMopError(mop);
return 1;
}
if (!(4 == _ncov->dim && 21 == _ncov->axis[0].size)) {
fprintf(stderr, "%s: didn't get a 4-D 21-by-X volume (got %u-D %u-by-X)\n",
me, _ncov->dim, AIR_CAST(unsigned int, _ncov->axis[0].size));
airMopError(mop);
return 1;
}
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;
}
int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
char *outS;
double _tA[6], tA[7], _tB[6], tB[7], time0, time1, conv, confThresh,
pA[3], pB[3], qA[4], qB[4], rA[9], rB[9], mat1[9], mat2[9], tmp,
stepSize, minNorm, sclA, sclB;
unsigned int NN, maxiter, refIdx[3];
int recurse, ptype, verb;
Nrrd *_nin, *nin, *nout;
tenInterpParm *tip;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "a", "tensor", airTypeDouble, 6, 6, _tA, "1 0 0 1 0 1",
"first tensor");
hestOptAdd(&hopt, "pa", "qq", airTypeDouble, 3, 3, pA, "0 0 0",
"rotation of first tensor");
hestOptAdd(&hopt, "sa", "scl", airTypeDouble, 1, 1, &sclA, "1.0",
"scaling of first tensor");
hestOptAdd(&hopt, "b", "tensor", airTypeDouble, 6, 6, _tB, "1 0 0 1 0 1",
"second tensor");
hestOptAdd(&hopt, "pb", "qq", airTypeDouble, 3, 3, pB, "0 0 0",
"rotation of second tensor");
hestOptAdd(&hopt, "sb", "scl", airTypeDouble, 1, 1, &sclB, "1.0",
"scaling of second tensor");
hestOptAdd(&hopt, "i", "nten", airTypeOther, 1, 1, &_nin, "",
"input tensor volume (makes previous options moot)",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "ri", "x y z", airTypeUInt, 3, 3, refIdx, "0 0 0",
"index of reference tensor in input tensor volume");
hestOptAdd(&hopt, "th", "thresh", airTypeDouble, 1, 1, &confThresh, "0.5",
"conf mask threshold on \"-i\"");
hestOptAdd(&hopt, "n", "# steps", airTypeUInt, 1, 1, &NN, "100",
"number of steps in between two tensors");
hestOptAdd(&hopt, "s", "stepsize", airTypeDouble, 1, 1, &stepSize, "1",
"step size in update");
hestOptAdd(&hopt, "mn", "minnorm", airTypeDouble, 1, 1, &minNorm, "0.000001",
"minnorm of something");
hestOptAdd(&hopt, "c", "conv", airTypeDouble, 1, 1, &conv, "0.0001",
"convergence threshold of length fraction");
hestOptAdd(&hopt, "mi", "maxiter", airTypeUInt, 1, 1, &maxiter, "0",
"if non-zero, max # iterations for computation");
hestOptAdd(&hopt, "r", "recurse", airTypeInt, 0, 0, &recurse, NULL,
"enable recursive solution, when useful");
hestOptAdd(&hopt, "t", "path type", airTypeEnum, 1, 1, &ptype, "lerp",
"what type of path to compute", NULL, tenInterpType);
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"file to write output nrrd to");
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1, &verb, "0",
"verbosity");
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);
tip = tenInterpParmNew();
airMopAdd(mop, tip, (airMopper)tenInterpParmNix, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
tip->verbose = verb;
tip->convStep = stepSize;
tip->enableRecurse = recurse;
tip->minNorm = minNorm;
tip->maxIter = maxiter;
tip->convEps = conv;
if (_nin) {
double refTen[7], inTen[7], *in, *out;
unsigned int xi, yi, zi, sx, sy, sz, dimOut;
int axmap[NRRD_DIM_MAX], numerical;
size_t size[NRRD_DIM_MAX];
if (tenTensorCheck(_nin, nrrdTypeDefault, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: input volume not valid:\n%s\n",
me, err);
airMopError(mop);
return 1;
}
sx = AIR_CAST(unsigned int, _nin->axis[1].size);
sy = AIR_CAST(unsigned int, _nin->axis[2].size);
sz = AIR_CAST(unsigned int, _nin->axis[3].size);
if (!( refIdx[0] < sx
&& refIdx[1] < sy
&& refIdx[2] < sz )) {
fprintf(stderr, "%s: index (%u,%u,%u) out of bounds (%u,%u,%u)\n", me,
refIdx[0], refIdx[1], refIdx[2], sx, sy, sz);
airMopError(mop);
return 1;
}
nin = nrrdNew();
airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
numerical = (ptype == tenInterpTypeGeoLoxK
|| ptype == tenInterpTypeGeoLoxR
|| ptype == tenInterpTypeLoxK
|| ptype == tenInterpTypeLoxR
|| ptype == tenInterpTypeQuatGeoLoxK
|| ptype == tenInterpTypeQuatGeoLoxR);
if (numerical) {
tip->lengthFancy = AIR_TRUE;
dimOut = 4;
size[0] = 3;
size[1] = _nin->axis[1].size;
size[2] = _nin->axis[2].size;
size[3] = _nin->axis[3].size;
axmap[0] = -1;
axmap[1] = 1;
axmap[2] = 2;
axmap[3] = 3;
} else {
dimOut = 3;
size[0] = _nin->axis[1].size;
size[1] = _nin->axis[2].size;
size[2] = _nin->axis[3].size;
axmap[0] = 1;
axmap[1] = 2;
axmap[2] = 3;
}
if (nrrdConvert(nin, _nin, nrrdTypeDouble)
|| nrrdMaybeAlloc_nva(nout, nrrdTypeDouble, dimOut, size)
|| nrrdAxisInfoCopy(nout, nin, axmap,
NRRD_AXIS_INFO_SIZE_BIT)
|| nrrdBasicInfoCopy(nout, nin,
(NRRD_BASIC_INFO_DATA_BIT
| NRRD_BASIC_INFO_TYPE_BIT
| NRRD_BASIC_INFO_DIMENSION_BIT
| NRRD_BASIC_INFO_CONTENT_BIT
| NRRD_BASIC_INFO_SAMPLEUNITS_BIT))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop);
return 1;
}
in = AIR_CAST(double *, nin->data);
out = AIR_CAST(double *, nout->data);
TEN_T_COPY(refTen, in + 7*(refIdx[0] + sx*(refIdx[1] + sy*refIdx[2])));
fprintf(stderr, "!%s: reference tensor = (%g) %g %g %g %g %g %g\n",
me, refTen[0], refTen[1], refTen[2], refTen[3],
refTen[4], refTen[5], refTen[6]);
for (zi=0; zi<sz; zi++) {
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
TEN_T_COPY(inTen, in + 7*(xi + sx*(yi + sy*zi)));
if (numerical) {
fprintf(stderr, "!%s: %u %u %u \n", me, xi, yi, zi);
if (inTen[0] < confThresh) {
out[0] = AIR_NAN;
out[1] = AIR_NAN;
out[2] = AIR_NAN;
} else {
tip->verbose = 10*(xi == refIdx[0]
&& yi == refIdx[1]
&& zi == refIdx[2]);
out[0] = tenInterpDistanceTwo_d(inTen, refTen, ptype, tip);
out[1] = tip->lengthShape;
out[2] = tip->lengthOrient;
}
out += 3;
} else {
if (inTen[0] < confThresh) {
*out = AIR_NAN;
} else {
*out = tenInterpDistanceTwo_d(inTen, refTen, ptype, tip);
}
out += 1;
}
}
if (numerical) {
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble saving output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
}
}
}
} else {
static
tenFiberContext *
_tenFiberContextCommonNew(const Nrrd *vol, int useDwi,
double thresh, double soft, double valueMin,
int ten1method, int ten2method) {
char me[]="_tenFiberContextCommonNew", err[BIFF_STRLEN];
tenFiberContext *tfx;
gageKind *kind;
if (!( tfx = (tenFiberContext *)calloc(1, sizeof(tenFiberContext)) )) {
sprintf(err, "%s: couldn't allocate new context", me);
biffAdd(TEN, err); return NULL;
}
if (useDwi) {
Nrrd *ngrad=NULL, *nbmat=NULL;
double bval=0;
unsigned int *skip, skipNum;
tfx->useDwi = AIR_TRUE;
/* default fiber type */
tfx->fiberType = tenDwiFiberTypeUnknown;
if (tenDWMRIKeyValueParse(&ngrad, &nbmat, &bval, &skip, &skipNum, vol)) {
sprintf(err, "%s: trouble parsing DWI info", me );
biffAdd(TEN, err); return NULL;
}
if (skipNum) {
sprintf(err, "%s: sorry, can't do DWI skipping here", me);
biffAdd(TEN, err); return NULL;
}
kind = tenDwiGageKindNew();
if (tenDwiGageKindSet(kind,
thresh, soft, bval, valueMin,
ngrad, NULL,
ten1method, ten2method, 42)) {
sprintf(err, "%s: trouble setting DWI kind", me);
biffAdd(TEN, err); return NULL;
}
} else {
/* it should be a tensor volume */
tfx->useDwi = AIR_FALSE;
/* default fiber type */
tfx->fiberType = tenFiberTypeUnknown;
if (tenTensorCheck(vol, nrrdTypeUnknown, AIR_TRUE, AIR_TRUE)) {
sprintf(err, "%s: didn't get a tensor volume", me);
biffAdd(TEN, err); return NULL;
}
kind = tenGageKind;
}
if ( !(tfx->gtx = gageContextNew())
|| !(tfx->pvl = gagePerVolumeNew(tfx->gtx, vol, kind))
|| (gagePerVolumeAttach(tfx->gtx, tfx->pvl)) ) {
sprintf(err, "%s: gage trouble", me);
biffMove(TEN, err, GAGE); free(tfx); return NULL;
}
tfx->nin = vol;
tfx->ksp = nrrdKernelSpecNew();
if (nrrdKernelSpecParse(tfx->ksp, tenDefFiberKernel)) {
sprintf(err, "%s: couldn't parse tenDefFiberKernel \"%s\"",
me, tenDefFiberKernel);
biffMove(TEN, err, NRRD); return NULL;
}
if (tenFiberKernelSet(tfx, tfx->ksp->kernel, tfx->ksp->parm)) {
sprintf(err, "%s: couldn't set default kernel", me);
biffAdd(TEN, err); return NULL;
}
/* looks to GK like GK says that we must set some stop criterion */
tfx->intg = tenDefFiberIntg;
tfx->anisoStopType = tenDefFiberAnisoStopType;
tfx->anisoSpeedType = tenAnisoUnknown;
tfx->stop = 0;
tfx->anisoThresh = tenDefFiberAnisoThresh;
/* so I'm not using the normal default mechanism, shoot me */
tfx->anisoSpeedFunc[0] = 0;
tfx->anisoSpeedFunc[1] = 0;
tfx->anisoSpeedFunc[2] = 0;
tfx->maxNumSteps = tenDefFiberMaxNumSteps;
tfx->minNumSteps = 0;
tfx->useIndexSpace = tenDefFiberUseIndexSpace;
tfx->verbose = 0;
tfx->stepSize = tenDefFiberStepSize;
tfx->maxHalfLen = tenDefFiberMaxHalfLen;
tfx->minWholeLen = 0.0;
tfx->confThresh = 0.5; /* why do I even bother setting these- they'll
only get read if the right tenFiberStopSet has
been called, in which case they'll be set... */
tfx->minRadius = 1; /* above lament applies here as well */
tfx->minFraction = 0.5; /* and here */
tfx->wPunct = tenDefFiberWPunct;
GAGE_QUERY_RESET(tfx->query);
tfx->mframe[0] = vol->measurementFrame[0][0];
tfx->mframe[1] = vol->measurementFrame[1][0];
tfx->mframe[2] = vol->measurementFrame[2][0];
tfx->mframe[3] = vol->measurementFrame[0][1];
tfx->mframe[4] = vol->measurementFrame[1][1];
tfx->mframe[5] = vol->measurementFrame[2][1];
tfx->mframe[6] = vol->measurementFrame[0][2];
tfx->mframe[7] = vol->measurementFrame[1][2];
tfx->mframe[8] = vol->measurementFrame[2][2];
if (ELL_3M_EXISTS(tfx->mframe)) {
tfx->mframeUse = AIR_TRUE;
ELL_3M_TRANSPOSE(tfx->mframeT, tfx->mframe);
} else {
tfx->mframeUse = AIR_FALSE;
}
tfx->gageAnisoStop = NULL;
tfx->gageAnisoSpeed = NULL;
tfx->ten2AnisoStop = AIR_NAN;
/* ... don't really see the point of initializing the ten2 stuff here;
its properly done in tenFiberTraceSet() ... */
tfx->radius = AIR_NAN;
return tfx;
}
int
tenTripleCalc(Nrrd *nout, int ttype, const Nrrd *nten) {
static const char me[]="tenTripleCalc";
size_t II, NN, size[NRRD_DIM_MAX];
double (*ins)(void *, size_t, double), (*lup)(const void *, size_t);
if (!( nout && nten )) {
biffAddf(TEN, "%s: got NULL pointer", me);
return 1;
}
if (airEnumValCheck(tenTripleType, ttype)) {
biffAddf(TEN, "%s: got invalid %s (%d)", me,
tenTripleType->name, ttype);
return 1;
}
if (tenTensorCheck(nten, nrrdTypeDefault, AIR_FALSE, AIR_TRUE)) {
biffAddf(TEN, "%s: didn't get a valid DT array", me);
return 1;
}
if (!( nrrdTypeFloat == nten->type ||
nrrdTypeDouble == nten->type )) {
biffAddf(TEN, "%s: need input type %s or %s, not %s\n", me,
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nten->type));
}
nrrdAxisInfoGet_nva(nten, nrrdAxisInfoSize, size);
size[0] = 3;
if (nrrdMaybeAlloc_nva(nout, nten->type, nten->dim, size)) {
biffMovef(TEN, NRRD, "%s: couldn't alloc output", me);
return 1;
}
NN = nrrdElementNumber(nten)/7;
lup = nrrdDLookup[nten->type];
ins = nrrdDInsert[nten->type];
for (II=0; II<NN; II++) {
double ten[7], trip[3];
unsigned int vv;
for (vv=0; vv<7; vv++) {
ten[vv] = lup(nten->data, vv + 7*II);
}
tenTripleCalcSingle_d(trip, ttype, ten);
for (vv=0; vv<3; vv++) {
ins(nout->data, vv + 3*II, trip[vv]);
}
}
if (nrrdAxisInfoCopy(nout, nten, NULL, (NRRD_AXIS_INFO_SIZE_BIT))) {
biffMovef(TEN, NRRD, "%s: couldn't copy axis info", me);
return 1;
}
nout->axis[0].kind = nrrdKindUnknown;
if (nrrdBasicInfoCopy(nout, nten,
NRRD_BASIC_INFO_ALL ^ NRRD_BASIC_INFO_SPACE)) {
biffAddf(TEN, "%s:", me);
return 1;
}
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
unsigned int sx, sy, sz, ss, ii, anisoTypeNum, anisoTypeIdx,
roiVoxNum, roiVoxIdx, statNum, statIdx;
float *ten, *roi, *aniso, eval[3], *stat;
Nrrd *nten, *_nroi, *nroi, *naniso, *nstat;
int *anisoType, *measr;
size_t anisoSize[2];
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "r,roi", "roi", airTypeOther, 1, 1, &_nroi, NULL,
"ROI volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "i,input", "volume", airTypeOther, 1, 1, &nten, "-",
"tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "a,aniso", "aniso", airTypeEnum, 1, -1, &anisoType, NULL,
"which anisotropy measures to measure",
&anisoTypeNum, tenAniso);
hestOptAdd(&hopt, "m,measr", "measr", airTypeEnum, 1, -1, &measr, NULL,
"which measures/statistics to calculate",
&statNum, nrrdMeasure);
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 (tenTensorCheck(nten, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't get tensor input:\n%s\n", me, err);
airMopError(mop);
return 1;
}
nroi = nrrdNew();
airMopAdd(mop, nroi, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
if (nrrdConvert(nroi, _nroi, nrrdTypeFloat)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't convert ROI to float:\n%s\n", me, err);
airMopError(mop);
return 1;
}
sx = nten->axis[1].size;
sy = nten->axis[2].size;
sz = nten->axis[3].size;
if (!(3 == nroi->dim
&& sx == nroi->axis[0].size
&& sy == nroi->axis[1].size
&& sz == nroi->axis[2].size)) {
fprintf(stderr, "%s: ROI dimension or axis sizes don't match volume", me);
airMopError(mop);
return 1;
}
ss = sx*sy*sz;
ten = AIR_CAST(float*, nten->data);
roi = AIR_CAST(float*, nroi->data);
/* NOTE: for time being the statistics are not weighted, because
nrrdMeasureLine[]() can't take a weight vector... */
/* find number of voxels in ROI */
roiVoxNum = 0;
for (ii=0; ii<ss; ii++) {
roiVoxNum += (roi[ii] > 0);
}
/* fprintf(stderr, "%s: # voxels in ROI == %u\n", me, roiVoxNum); */
/* allocate anisotropy buffers */
naniso = nrrdNew();
airMopAdd(mop, naniso, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
anisoSize[0] = roiVoxNum;
anisoSize[1] = anisoTypeNum;
if (nrrdMaybeAlloc_nva(naniso, nrrdTypeFloat, 2, anisoSize)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate aniso:\n%s\n", me, err);
airMopError(mop);
return 1;
}
aniso = AIR_CAST(float *, naniso->data);
/* store all anisotropies in all ROI voxels */
roiVoxIdx = 0;
for (ii=0; ii<ss; ii++) {
if (roi[ii] > 0) {
tenEigensolve_f(eval, NULL, ten + 7*ii);
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
aniso[roiVoxIdx + roiVoxNum*anisoTypeIdx]
= tenAnisoEval_f(eval, anisoType[anisoTypeIdx]);
}
roiVoxIdx++;
}
}
printf("statistic:");
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
printf(" %s", airEnumStr(tenAniso, anisoType[anisoTypeIdx]));
}
printf("\n");
/* do per-anisotropy statistics */
nstat = nrrdNew();
airMopAdd(mop, nstat, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
for (statIdx=0; statIdx<statNum; statIdx++) {
printf("%s:", airEnumStr(nrrdMeasure, measr[statIdx]));
if (nrrdProject(nstat, naniso, 0, measr[statIdx], nrrdTypeFloat)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't measure:\n%s\n", me, err);
airMopError(mop);
return 1;
}
stat = AIR_CAST(float *, nstat->data);
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
printf(" %g", stat[anisoTypeIdx]);
}
printf("\n");
}
airMopOkay(mop);
return 0;
}
int
tend_evecMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
int ret, *comp, compLen, cc;
Nrrd *nin, *nout;
char *outS;
float thresh, *edata, *tdata, eval[3], evec[9], scl;
size_t N, I, sx, sy, sz;
hestOptAdd(&hopt, "c", "c0 ", airTypeInt, 1, 3, &comp, NULL,
"which eigenvalues should be saved out. \"0\" for the "
"largest, \"1\" for the middle, \"2\" for the smallest, "
"\"0 1\", \"1 2\", \"0 1 2\" or similar for more than one",
&compLen);
hestOptAdd(&hopt, "t", "thresh", airTypeFloat, 1, 1, &thresh, "0.5",
"confidence threshold");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_evecInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
for (cc=0; cc<compLen; cc++) {
if (!AIR_IN_CL(0, comp[cc], 2)) {
fprintf(stderr, "%s: requested component %d (%d of 3) not in [0..2]\n",
me, comp[cc], cc+1);
airMopError(mop); return 1;
}
}
if (tenTensorCheck(nin, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't get a valid DT volume:\n%s\n", me, err);
airMopError(mop); return 1;
}
sx = nin->axis[1].size;
sy = nin->axis[2].size;
sz = nin->axis[3].size;
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
ret = nrrdMaybeAlloc_va(nout, nrrdTypeFloat, 4,
AIR_CAST(size_t, 3*compLen), sx, sy, sz);
if (ret) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating output:\n%s\n", me, err);
airMopError(mop); return 1;
}
N = sx*sy*sz;
edata = (float *)nout->data;
tdata = (float *)nin->data;
if (1 == compLen) {
for (I=0; I<N; I++) {
tenEigensolve_f(eval, evec, tdata);
scl = AIR_CAST(float, tdata[0] >= thresh);
ELL_3V_SCALE(edata, scl, evec+3*comp[0]);
edata += 3;
tdata += 7;
}
} else {
for (I=0; I<N; I++) {
static int
theFunc(Nrrd *nout, const Nrrd *nin, int func, funcParm *parm) {
static const char me[]="theFunc";
float *tin, *tout, eval[3], evec[9], weight[3], size, mean;
size_t NN, II;
unsigned int ri;
if (!AIR_IN_OP(funcUnknown, func, funcLast)) {
biffAddf(TEN, "%s: given func %d out of range [%d,%d]", me, func,
funcUnknown+1, funcLast-1);
return 1;
}
if (!(nout && nin && parm)) {
biffAddf(TEN, "%s: got NULL pointer", me);
return 1;
}
if (tenTensorCheck(nin, nrrdTypeFloat, AIR_FALSE, AIR_TRUE)) {
biffAddf(TEN, "%s: didn't get a tensor nrrd", me);
return 1;
}
if (nout != nin) {
if (nrrdCopy(nout, nin)) {
biffMovef(TEN, NRRD, "%s: couldn't allocate output", me);
return 1;
}
}
tin = (float*)(nin->data);
tout = (float*)(nout->data);
NN = nrrdElementNumber(nin)/7;
switch(func) {
case funcSizeNormalize:
ELL_3V_COPY_TT(weight, float, parm->weight);
size = weight[0] + weight[1] + weight[2];
if (!size) {
biffAddf(TEN, "%s: some of eigenvalue weights is zero", me);
return 1;
}
weight[0] /= size;
weight[1] /= size;
weight[2] /= size;
for (II=0; II<=NN-1; II++) {
tenEigensolve_f(eval, evec, tin);
size = (weight[0]*AIR_ABS(eval[0])
+ weight[1]*AIR_ABS(eval[1])
+ weight[2]*AIR_ABS(eval[2]));
ELL_3V_SET_TT(eval, float,
AIR_AFFINE(0, parm->amount, 1,
eval[0], parm->target*eval[0]/size),
AIR_AFFINE(0, parm->amount, 1,
eval[1], parm->target*eval[1]/size),
AIR_AFFINE(0, parm->amount, 1,
eval[2], parm->target*eval[2]/size));
tenMakeSingle_f(tout, tin[0], eval, evec);
tin += 7;
tout += 7;
}
break;
case funcSizeScale:
for (II=0; II<=NN-1; II++) {
TEN_T_SET_TT(tout, float,
tin[0],
parm->amount*tin[1],
parm->amount*tin[2],
parm->amount*tin[3],
parm->amount*tin[4],
parm->amount*tin[5],
parm->amount*tin[6]);
tin += 7;
tout += 7;
}
break;
case funcAnisoScale:
for (II=0; II<=NN-1; II++) {
tenEigensolve_f(eval, evec, tin);
if (parm->fixDet) {
eval[0] = AIR_MAX(eval[0], 0.00001f);
eval[1] = AIR_MAX(eval[1], 0.00001f);
eval[2] = AIR_MAX(eval[2], 0.00001f);
ELL_3V_SET_TT(eval, float, log(eval[0]), log(eval[1]), log(eval[2]));
}
mean = (eval[0] + eval[1] + eval[2])/3.0f;
ELL_3V_SET_TT(eval, float,
AIR_LERP(parm->scale, mean, eval[0]),
AIR_LERP(parm->scale, mean, eval[1]),
AIR_LERP(parm->scale, mean, eval[2]));
if (parm->fixDet) {
ELL_3V_SET_TT(eval, float, exp(eval[0]), exp(eval[1]), exp(eval[2]));
}
if (eval[2] < 0 && parm->makePositive) {
eval[0] = AIR_MAX(eval[0], 0.0f);
eval[1] = AIR_MAX(eval[1], 0.0f);
eval[2] = AIR_MAX(eval[2], 0.0f);
}
tenMakeSingle_f(tout, tin[0], eval, evec);
tin += 7;
tout += 7;
}
break;
case funcEigenvalueClamp:
for (II=0; II<=NN-1; II++) {
tenEigensolve_f(eval, evec, tin);
if (AIR_EXISTS(parm->min)) {
ELL_3V_SET_TT(eval, float,
AIR_MAX(eval[0], parm->min),
AIR_MAX(eval[1], parm->min),
AIR_MAX(eval[2], parm->min));
}
if (AIR_EXISTS(parm->max)) {
ELL_3V_SET_TT(eval, float,
AIR_MIN(eval[0], parm->max),
AIR_MIN(eval[1], parm->max),
AIR_MIN(eval[2], parm->max));
}
tenMakeSingle_f(tout, tin[0], eval, evec);
tin += 7;
tout += 7;
}
int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
char *outTenS, *outCovarS, *outRmvS;
int seed, E;
unsigned int NN;
Nrrd *_ninTen, *ninTen, *ngrad, *_ninB0, *ninB0, *nmask,
*noutCovar, *noutTen, *noutRmv, *ntbuff;
float sigma, bval;
size_t sizeX, sizeY, sizeZ;
tenEstimateContext *tec;
int axmap[NRRD_DIM_MAX], randrot;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "i", "ten", airTypeOther, 1, 1, &_ninTen, NULL,
"input tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "n", "#sim", airTypeUInt, 1, 1, &NN, "100",
"number of simulations to run");
hestOptAdd(&hopt, "seed", "seed", airTypeInt, 1, 1, &seed, "42",
"seed value for RNG which creates noise");
hestOptAdd(&hopt, "r", "reference field", airTypeOther, 1, 1, &_ninB0, NULL,
"reference anatomical scan, with no diffusion weighting",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "rr", NULL, airTypeOther, 0, 0, &randrot, NULL,
"randomize gradient set orientation");
hestOptAdd(&hopt, "g", "grad list", airTypeOther, 1, 1, &ngrad, "",
"gradient list, one row per diffusion-weighted image",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "b", "b", airTypeFloat, 1, 1, &bval, "1000",
"b value for simulated scan");
hestOptAdd(&hopt, "sigma", "sigma", airTypeFloat, 1, 1, &sigma, "0.0",
"Rician noise parameter");
hestOptAdd(&hopt, "ot", "filename", airTypeString, 1, 1, &outTenS,
"tout.nrrd", "file to write output tensor nrrd to");
hestOptAdd(&hopt, "oc", "filename", airTypeString, 1, 1, &outCovarS,
"cout.nrrd", "file to write output covariance nrrd to");
hestOptAdd(&hopt, "or", "filename", airTypeString, 1, 1, &outRmvS,
"rout.nrrd", "file to write output R_i means, variances to");
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 (tenGradientCheck(ngrad, nrrdTypeDefault, 7)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: problem with gradient list:\n%s\n", me, err);
airMopError(mop);
return 1;
}
if (tenTensorCheck(_ninTen, nrrdTypeDefault, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't like input:\n%s\n", me, err);
airMopError(mop);
return 1;
}
sizeX = _ninTen->axis[1].size;
sizeY = _ninTen->axis[2].size;
sizeZ = _ninTen->axis[3].size;
if (!(3 == _ninB0->dim &&
sizeX == _ninB0->axis[0].size &&
sizeY == _ninB0->axis[1].size &&
sizeZ == _ninB0->axis[2].size)) {
fprintf(stderr, "%s: given B0 (%u-D) volume not 3-D " _AIR_SIZE_T_CNV
"x" _AIR_SIZE_T_CNV "x" _AIR_SIZE_T_CNV, me, _ninB0->dim,
sizeX, sizeY, sizeZ);
airMopError(mop);
return 1;
}
ninTen = nrrdNew();
airMopAdd(mop, ninTen, (airMopper)nrrdNuke, airMopOnError);
nmask = nrrdNew();
airMopAdd(mop, nmask, (airMopper)nrrdNuke, airMopOnError);
ninB0 = nrrdNew();
airMopAdd(mop, ninB0, (airMopper)nrrdNuke, airMopOnError);
noutCovar = nrrdNew();
airMopAdd(mop, noutCovar, (airMopper)nrrdNuke, airMopOnError);
noutTen = nrrdNew();
airMopAdd(mop, noutTen, (airMopper)nrrdNuke, airMopOnError);
noutRmv = nrrdNew();
airMopAdd(mop, noutRmv, (airMopper)nrrdNuke, airMopOnError);
ntbuff = nrrdNew();
airMopAdd(mop, ntbuff, (airMopper)nrrdNuke, airMopOnError);
if (nrrdConvert(ninTen, _ninTen, nrrdTypeDouble)
|| nrrdSlice(nmask, ninTen, 0, 0)
|| nrrdConvert(ninB0, _ninB0, nrrdTypeDouble)
|| nrrdMaybeAlloc_va(noutTen, nrrdTypeDouble, 4,
AIR_CAST(size_t, 7), sizeX, sizeY, sizeZ)
|| nrrdMaybeAlloc_va(noutCovar, nrrdTypeDouble, 4,
AIR_CAST(size_t, 21), sizeX, sizeY, sizeZ)
|| nrrdMaybeAlloc_va(noutRmv, nrrdTypeDouble, 4,
AIR_CAST(size_t, 6), sizeX, sizeY, sizeZ)
|| nrrdMaybeAlloc_va(ntbuff, nrrdTypeDouble, 2,
AIR_CAST(size_t, 7), NN)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble setting up tec:\n%s\n", me, err);
airMopError(mop);
return 1;
}
tec = tenEstimateContextNew();
airMopAdd(mop, tec, (airMopper)tenEstimateContextNix, airMopAlways);
E = 0;
if (!E) E |= tenEstimateMethodSet(tec, tenEstimate1MethodLLS);
if (!E) E |= tenEstimateValueMinSet(tec, 0.000000001);
if (!E) E |= tenEstimateGradientsSet(tec, ngrad, bval, AIR_TRUE);
if (!E) E |= tenEstimateThresholdSet(tec, 0, 0);
if (!E) E |= tenEstimateUpdate(tec);
if (E) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble setting up tec:\n%s\n", me, err);
airMopError(mop);
return 1;
}
airSrandMT(seed);
fprintf(stderr, "!%s: randrot = %d\n", me, randrot);
if (1) {
unsigned int II;
unsigned int nsamp;
double *inTen, *outTen, *outCovar, *outRmv,
*dwibuff, (*lup)(const void *, size_t);
char doneStr[AIR_STRLEN_SMALL];
dwibuff = AIR_CAST(double *, calloc(ngrad->axis[1].size, sizeof(double)));
airMopAdd(mop, dwibuff, airFree, airMopAlways);
nsamp = sizeX*sizeY*sizeZ;
inTen = AIR_CAST(double *, ninTen->data);
lup = nrrdDLookup[nrrdTypeDouble];
outTen = AIR_CAST(double *, noutTen->data);
outCovar = AIR_CAST(double *, noutCovar->data);
outRmv = AIR_CAST(double *, noutRmv->data);
fprintf(stderr, "!%s: simulating ... ", me);
fflush(stderr);
for (II=0; II<nsamp; II++) {
if (!(II % sizeX)) {
fprintf(stderr, "%s", airDoneStr(0, II, nsamp, doneStr));
fflush(stderr);
}
if (csimDo(outTen, outCovar, outRmv + 0, outRmv + 3, ntbuff,
tec, dwibuff, sigma,
bval, lup(ninB0->data, II), NN, randrot, inTen)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop);
return 1;
}
inTen += 7;
outTen += 7;
outCovar += 21;
outRmv += 6;
}
fprintf(stderr, "%s\n", airDoneStr(0, II, nsamp, doneStr));
}
