int
main(int argc, char *argv[]) {
char *me, *outS, *err;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
Nrrd *_ninA, *_ninB, *ninA, *ninB, *nmul;
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, NULL, "matrix", airTypeOther, 1, 1, &_ninA, NULL,
"first matrix",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, NULL, "matrix", airTypeOther, 1, 1, &_ninB, NULL,
"first matrix",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"file to write output nrrd to");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, mulInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
ninA = nrrdNew();
airMopAdd(mop, ninA, (airMopper)nrrdNuke, airMopAlways);
ninB = nrrdNew();
airMopAdd(mop, ninB, (airMopper)nrrdNuke, airMopAlways);
nmul = nrrdNew();
airMopAdd(mop, nmul, (airMopper)nrrdNuke, airMopAlways);
nrrdConvert(ninA, _ninA, nrrdTypeDouble);
nrrdConvert(ninB, _ninB, nrrdTypeDouble);
if (ell_Nm_mul(nmul, ninA, ninB)) {
airMopAdd(mop, err = biffGetDone(ELL), airFree, airMopAlways);
fprintf(stderr, "%s: problem inverting:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nmul, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: problem saving output:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
exit(0);
}
/*
******** tenGradientJitter
**
** moves all gradients by amount dist on tangent plane, in a random
** direction, and then renormalizes. The distance is a fraction
** of the ideal edge length (via tenGradientIdealEdge)
*/
int
tenGradientJitter(Nrrd *nout, const Nrrd *nin, double dist) {
static const char me[]="tenGradientJitter";
double *grad, perp0[3], perp1[3], len, theta, cc, ss, edge;
unsigned int gi, num;
if (nrrdConvert(nout, nin, nrrdTypeDouble)) {
biffMovef(TEN, NRRD, "%s: trouble converting input to double", me);
return 1;
}
if (tenGradientCheck(nout, nrrdTypeDouble, 3)) {
biffAddf(TEN, "%s: didn't get valid gradients", me);
return 1;
}
grad = AIR_CAST(double*, nout->data);
num = AIR_UINT(nout->axis[1].size);
/* HEY: possible confusion between single and not */
edge = tenGradientIdealEdge(num, AIR_FALSE);
for (gi=0; gi<num; gi++) {
ELL_3V_NORM(grad, grad, len);
ell_3v_perp_d(perp0, grad);
ELL_3V_CROSS(perp1, perp0, grad);
theta = AIR_AFFINE(0, airDrandMT(), 1, 0, 2*AIR_PI);
cc = dist*edge*cos(theta);
ss = dist*edge*sin(theta);
ELL_3V_SCALE_ADD3(grad, 1.0, grad, cc, perp0, ss, perp1);
ELL_3V_NORM(grad, grad, len);
grad += 3;
}
return 0;
}
int
_miteNtxfCopy(miteRender *mrr, miteUser *muu) {
static const char me[]="_miteNtxfCopy";
int ni, E;
mrr->ntxf = AIR_CALLOC(muu->ntxfNum, Nrrd *);
if (!mrr->ntxf) {
biffAddf(MITE, "%s: couldn't calloc %d ntxf pointers", me, muu->ntxfNum);
return 1;
}
mrr->ntxfNum = muu->ntxfNum;
airMopAdd(mrr->rmop, mrr->ntxf, airFree, airMopAlways);
E = 0;
for (ni=0; ni<mrr->ntxfNum; ni++) {
mrr->ntxf[ni] = nrrdNew();
if (!E) airMopAdd(mrr->rmop, mrr->ntxf[ni],
(airMopper)nrrdNuke, airMopAlways);
if (!( nrrdTypeUChar == muu->ntxf[ni]->type
|| nrrdTypeFloat == muu->ntxf[ni]->type
|| nrrdTypeDouble == muu->ntxf[ni]->type )) {
biffAddf(MITE,
"%s: sorry, can't handle txf of type %s (only %s, %s, %s)",
me, airEnumStr(nrrdType, muu->ntxf[ni]->type),
airEnumStr(nrrdType, nrrdTypeUChar),
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nrrdTypeDouble));
return 1;
}
/* note that key/values need to be copied for the sake of
identifying a non-default miteStageOp */
switch(muu->ntxf[ni]->type) {
case nrrdTypeUChar:
if (!E) E |= nrrdUnquantize(mrr->ntxf[ni], muu->ntxf[ni], nrrdTypeUChar);
if (!E) E |= nrrdKeyValueCopy(mrr->ntxf[ni], muu->ntxf[ni]);
break;
case mite_nt:
if (!E) E |= nrrdCopy(mrr->ntxf[ni], muu->ntxf[ni]);
break;
default: /* will be either float or double (whatever mite_nt isn't) */
if (!E) E |= nrrdConvert(mrr->ntxf[ni], muu->ntxf[ni], mite_nt);
if (!E) E |= nrrdKeyValueCopy(mrr->ntxf[ni], muu->ntxf[ni]);
break;
}
}
if (E) {
biffMovef(MITE, NRRD, "%s: troubling copying/converting all ntxfs", me);
return 1;
}
return 0;
}
int
alanTensorSet(alanContext *actx, Nrrd *nten, int oversample) {
static const char me[]="alanTensorSet";
if (!( actx && nten )) {
biffAddf(ALAN, "%s: got NULL pointer", me);
return 1;
}
DIM_SET;
if (!( oversample > 0 )) {
biffAddf(ALAN, "%s: oversample %d invalid", me, oversample);
return 1;
}
if (2 == actx->dim) {
if (!( 3 == nten->dim && 4 == nten->axis[0].size )) {
biffAddf(ALAN, "%s: didn't get 3-D (4,X,Y) nrrd", me);
return 1;
}
} else {
if (!( 4 == nten->dim && 7 == nten->axis[0].size )) {
biffAddf(ALAN, "%s: didn't get 4-D (7,X,Y,Z) nrrd", me);
return 1;
}
}
if (1 != oversample) {
biffAddf(ALAN, "%s: sorry, can only handle oversample==1 now", me);
return 1;
}
actx->nten = nrrdNuke(actx->nten);
actx->nten = nrrdNew();
if (nrrdConvert(actx->nten, nten, alan_nt)) {
biffMovef(ALAN, NRRD, "%s: trouble converting tensors to alan_t", me);
return 1;
}
actx->size[0] = AIR_UINT(oversample*nten->axis[1].size);
actx->size[1] = AIR_UINT(oversample*nten->axis[2].size);
if (3 == actx->dim) {
actx->size[2] = AIR_UINT(oversample*nten->axis[3].size);
} else {
actx->size[2] = 1;
}
return 0;
}
int
unrrdu_convertMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int type, pret, E, doClamp;
airArray *mop;
OPT_ADD_TYPE(type, "type to convert to", NULL);
OPT_ADD_NIN(nin, "input nrrd");
hestOptAdd(&opt, "clamp", NULL, airTypeInt, 0, 0, &doClamp, NULL,
"clamp input values to representable range of values of "
"output type, to avoid wrap-around problems");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_convertInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (doClamp) {
E = nrrdClampConvert(nout, nin, type);
} else {
E = nrrdConvert(nout, nin, type);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
/*
******** nrrdApply1DSubstitution
**
** A "subst" is a substitution table, i.e. a list of pairs that
** describes what values should be substituted with what (substitution
** rules). So, nsubst must be a scalar 2xN array. The output is a
** copy of the input with values substituted using this table.
**
** Unlike with lookup tables and maps (irregular and regular), we
** aren't at liberty to change the dimensionality of the data (can't
** substitute a grayscale with a color). The ability to apply
** substitutions to non-scalar data will be in a different function.
** Also unlike lookup tables and maps, the output type is the SAME as
** the input type; the output does NOT inherit the type of the
** substitution
*/
int
nrrdApply1DSubstitution(Nrrd *nout, const Nrrd *nin, const Nrrd *_nsubst) {
char me[]="nrrdApply1DSubstitution", err[BIFF_STRLEN];
double (*lup)(const void *, size_t);
double (*ins)(void *, size_t, double);
Nrrd *nsubst;
double val, *subst;
size_t ii, num;
int jj, asize0, asize1, changed;
airArray *mop;
if (!(nout && _nsubst && nin)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdTypeBlock == nin->type || nrrdTypeBlock == _nsubst->type) {
sprintf(err, "%s: input or substitution type is %s, need scalar",
me, airEnumStr(nrrdType, nrrdTypeBlock));
biffAdd(NRRD, err); return 1;
}
if (2 != _nsubst->dim) {
sprintf(err, "%s: substitution table has to be 2-D, not %d-D",
me, _nsubst->dim);
biffAdd(NRRD, err); return 1;
}
nrrdAxisInfoGet_va(_nsubst, nrrdAxisInfoSize, &asize0, &asize1);
if (2 != asize0) {
sprintf(err, "%s: substitution table has to be 2xN, not %dxN",
me, asize0);
biffAdd(NRRD, err); return 1;
}
if (nout != nin) {
if (nrrdCopy(nout, nin)) {
sprintf(err, "%s: couldn't initialize by copy to output", me);
biffAdd(NRRD, err); return 1;
}
}
mop = airMopNew();
nsubst = nrrdNew();
airMopAdd(mop, nsubst, (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(nsubst, _nsubst, nrrdTypeDouble)) {
sprintf(err, "%s: couldn't create double copy of substitution table", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
lup = nrrdDLookup[nout->type];
ins = nrrdDInsert[nout->type];
subst = (double *)nsubst->data;
num = nrrdElementNumber(nout);
for (ii=0; ii<num; ii++) {
val = lup(nout->data, ii);
changed = AIR_FALSE;
for (jj=0; jj<asize1; jj++) {
if (val == subst[jj*2+0]) {
val = subst[jj*2+1];
changed = AIR_TRUE;
}
}
if (changed) {
ins(nout->data, ii, val);
}
}
airMopOkay(mop);
return 0;
}
int
tend_fiberMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
char *outS;
tenFiberContext *tfx;
tenFiberSingle *tfbs;
NrrdKernelSpec *ksp;
double start[3], step, *_stop, *stop;
airEnum *ftypeEnum;
char *ftypeS;
int E, intg, useDwi, allPaths, verbose, worldSpace, worldSpaceOut,
ftype, ftypeDef;
Nrrd *nin, *nseed, *nmat, *_nmat;
unsigned int si, stopLen, whichPath;
double matx[16]={1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
tenFiberMulti *tfml;
limnPolyData *fiberPld;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "dwi", NULL, airTypeInt, 0, 0, &useDwi, NULL,
"input volume is a DWI volume, not a single tensor volume");
hestOptAdd(&hopt, "s", "seed point", airTypeDouble, 3, 3, start, "0 0 0",
"seed point for fiber; it will propogate in two opposite "
"directions starting from here");
hestOptAdd(&hopt, "ns", "seed nrrd", airTypeOther, 1, 1, &nseed, "",
"3-by-N nrrd of seedpoints", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "wsp", NULL, airTypeInt, 0, 0, &worldSpace, NULL,
"define seedpoint and output path in worldspace. Otherwise, "
"(without using this option) everything is in index space");
hestOptAdd(&hopt, "t", "type", airTypeString, 1, 1, &ftypeS, "",
"fiber type; defaults to something");
hestOptAdd(&hopt, "n", "intg", airTypeEnum, 1, 1, &intg, "rk4",
"integration method for fiber tracking",
NULL, tenFiberIntg);
hestOptAdd(&hopt, "k", "kernel", airTypeOther, 1, 1, &ksp, "tent",
"kernel for reconstructing tensor field",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "wp", "which", airTypeUInt, 1, 1, &whichPath, "0",
"when doing multi-tensor tracking, index of path to follow "
"(made moot by \"-ap\")");
hestOptAdd(&hopt, "ap", "allpaths", airTypeInt, 0, 0, &allPaths, NULL,
"follow all paths from (all) seedpoint(s), output will be "
"polydata, rather than a single 3-by-N nrrd, even if only "
"a single path is generated");
hestOptAdd(&hopt, "wspo", NULL, airTypeInt, 0, 0, &worldSpaceOut, NULL,
"output should be in worldspace, even if input is not "
"(this feature is unstable and/or confusing)");
hestOptAdd(&hopt, "step", "step size", airTypeDouble, 1, 1, &step, "0.01",
"stepsize along fiber, in world space");
hestOptAdd(&hopt, "stop", "stop1", airTypeOther, 1, -1, &_stop, NULL,
"the conditions that should signify the end of a fiber, or "
"when to discard a fiber that is done propagating. "
"Multiple stopping criteria are logically OR-ed and tested at "
"every point along the fiber. Possibilities include:\n "
"\b\bo \"aniso:<type>,<thresh>\": require anisotropy to be "
"above the given threshold. Which anisotropy type is given "
"as with \"tend anvol\" (see its usage info)\n "
"\b\bo \"len:<length>\": limits the length, in world space, "
"of each fiber half\n "
"\b\bo \"steps:<N>\": the number of steps in each fiber half "
"is capped at N\n "
"\b\bo \"conf:<thresh>\": requires the tensor confidence value "
"to be above the given thresh\n "
"\b\bo \"radius:<thresh>\": requires that the radius of "
"curvature of the fiber stay above given thr\n "
"\b\bo \"frac:<F>\": in multi-tensor tracking, the fraction "
"of the tracked component must stay above F\n "
"\b\bo \"minlen:<len>\": discard fiber if its final whole "
"length is below len (not really a termination criterion)\n "
"\b\bo \"minsteps:<N>\": discard fiber if its final number of "
"steps is below N (not really a termination criterion)",
&stopLen, NULL, tendFiberStopCB);
hestOptAdd(&hopt, "v", "verbose", airTypeInt, 1, 1, &verbose, "0",
"verbosity level");
hestOptAdd(&hopt, "nmat", "transform", airTypeOther, 1, 1, &_nmat, "",
"a 4x4 homogenous transform matrix (as a nrrd, or just a text "
"file) given with this option will be applied to the output "
"tractography vertices just prior to output",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "out", airTypeString, 1, 1, &outS, "-",
"output fiber(s)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_fiberInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
tfbs = tenFiberSingleNew();
airMopAdd(mop, tfbs, (airMopper)tenFiberSingleNix, airMopAlways);
if (_nmat) {
if (!(2 == _nmat->dim
&& 4 == _nmat->axis[0].size
&& 4 == _nmat->axis[1].size)) {
fprintf(stderr, "%s: transform matrix must be 2-D 4-by-4 array "
"not %u-D %u-by-?\n", me,
AIR_CAST(unsigned int, _nmat->dim),
AIR_CAST(unsigned int, _nmat->axis[0].size));
airMopError(mop); return 1;
}
nmat = nrrdNew();
airMopAdd(mop, nmat, (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(nmat, _nmat, nrrdTypeDouble)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: problem with transform matrix\n%s\n", me, err);
airMopError(mop); return 1;
}
ELL_4M_COPY(matx, AIR_CAST(double *, nmat->data));
fprintf(stderr, "%s: transforming output by:\n", me);
ell_4m_print_d(stderr, matx);
}
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
gageDeconvolve(Nrrd *_nout, double *lastDiffP,
const Nrrd *nin, const gageKind *kind,
const NrrdKernelSpec *ksp, int typeOut,
unsigned int maxIter, int saveAnyway,
double step, double epsilon, int verbose) {
static const char me[]="gageDeconvolve";
gageContext *ctx[2];
gagePerVolume *pvl[2];
double *out[2], *val[2], alpha, (*lup)(const void *, size_t), meandiff=0;
const double *ans[2];
Nrrd *nout[2];
airArray *mop;
unsigned int sx, sy, sz, xi, yi, zi, anslen, thiz=0, last, inIdx, iter;
int E, valItem;
if (!(_nout && lastDiffP && nin && kind && ksp)) {
biffAddf(GAGE, "%s: got NULL pointer", me);
return 1;
}
if (!(nrrdTypeDefault == typeOut
|| !airEnumValCheck(nrrdType, typeOut))) {
biffAddf(GAGE, "%s: typeOut %d not valid", me, typeOut);
return 1;
}
if (!( maxIter >= 1 )) {
biffAddf(GAGE, "%s: need maxIter >= 1 (not %u)", me, maxIter);
return 1;
}
if (!( epsilon >= 0 )) {
biffAddf(GAGE, "%s: need epsilon >= 0.0 (not %g)", me, epsilon);
return 1;
}
/* this once changed from 0 to 1, but is unlikely to change again */
valItem = 1;
mop = airMopNew();
for (iter=0; iter<2; iter++) {
nout[iter] = nrrdNew();
airMopAdd(mop, nout[iter], (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(nout[iter], nin, nrrdTypeDouble)) {
biffMovef(GAGE, NRRD, "%s: couldn't allocate working buffer %u",
me, iter);
airMopError(mop); return 1;
}
ctx[iter] = gageContextNew();
airMopAdd(mop, ctx[iter], (airMopper)gageContextNix, airMopAlways);
E = 0;
if (!E) E |= !(pvl[iter] = gagePerVolumeNew(ctx[iter], nout[iter], kind));
if (!E) E |= gagePerVolumeAttach(ctx[iter], pvl[iter]);
if (!E) E |= gageKernelSet(ctx[iter], gageKernel00,
ksp->kernel, ksp->parm);
if (!E) E |= gageQueryItemOn(ctx[iter], pvl[iter], valItem);
if (!E) E |= gageUpdate(ctx[iter]);
if (E) {
biffAddf(GAGE, "%s: trouble setting up context %u", me, iter);
airMopError(mop); return 1;
}
out[iter] = AIR_CAST(double*, nout[iter]->data);
ans[iter] = gageAnswerPointer(ctx[iter], pvl[iter], valItem);
}
anslen = kind->table[valItem].answerLength;
lup = nrrdDLookup[nin->type];
alpha = ksp->kernel->eval1_d(0.0, ksp->parm);
sx = ctx[0]->shape->size[0];
sy = ctx[0]->shape->size[1];
sz = ctx[0]->shape->size[2];
for (iter=0; iter<maxIter; iter++) {
thiz = (iter+1) % 2;
last = (iter+0) % 2;
val[thiz] = out[thiz];
val[last] = out[last];
inIdx = 0;
meandiff = 0;
for (zi=0; zi<sz; zi++) {
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
unsigned int ai;
double in, aa;
gageProbe(ctx[last], xi, yi, zi);
for (ai=0; ai<anslen; ai++) {
in = lup(nin->data, ai + anslen*inIdx);
aa = ans[last][ai];
val[thiz][ai] = val[last][ai] + step*(in - aa)/alpha;
meandiff += 2*(in - aa)*(in - aa)/(DBL_EPSILON + in*in + aa*aa);
}
val[thiz] += anslen;
val[last] += anslen;
++inIdx;
}
}
}
meandiff /= sx*sy*sz;
if (verbose) {
fprintf(stderr, "%s: iter %u meandiff = %g\n", me, iter, meandiff);
}
if (meandiff < epsilon) {
/* we have indeed converged while iter < maxIter */
break;
}
}
if (iter == maxIter) {
if (!saveAnyway) {
biffAddf(GAGE, "%s: failed to converge in %u iterations, meandiff = %g",
me, maxIter, meandiff);
airMopError(mop); return 1;
} else {
if (verbose) {
fprintf(stderr, "%s: at maxIter %u; err %g still > thresh %g\n", me,
iter, meandiff, epsilon);
}
}
}
if (nrrdClampConvert(_nout, nout[thiz], (nrrdTypeDefault == typeOut
? nin->type
: typeOut))) {
biffAddf(GAGE, "%s: couldn't create output", me);
airMopError(mop); return 1;
}
*lastDiffP = meandiff;
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, *ndist, *nmask, *nupdate, *nout;
NrrdKernelSpec *k00, *k11, *k22;
int E;
unsigned int sx, sy, sz, xi, yi, zi, si, iter, maxIter;
gageContext *ctx;
gagePerVolume *pvl;
double dt, *dist, *mask, *update, thresh, eps, rmsMin;
const double *valu, *gmag, *mcrv;
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, "k00", "kernel", airTypeOther, 1, 1, &k00,
"tent", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kernel", airTypeOther, 1, 1, &k11,
"cubicd:0,0.5", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kernel", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "dt", "step", airTypeDouble, 1, 1, &dt, "0.17",
"time step size");
hestOptAdd(&hopt, "th", "val", airTypeDouble, 1, 1, &thresh, "0.0",
"the value to use for thresholding the input "
"volume, to create the binary constraint image.");
hestOptAdd(&hopt, "eps", "val", airTypeDouble, 1, 1, &eps, "0.05",
"width of value bracket around threshold, to constrain the "
"the update from letting to value, originally on either "
"side of the threshold, from getting too close.");
hestOptAdd(&hopt, "rms", "thresh", airTypeDouble, 1, 1, &rmsMin, "0.01",
"RMS change below this terminates updates.");
hestOptAdd(&hopt, "mi", "max", airTypeUInt, 1, 1, &maxIter, "100",
"maximum # iterations");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"fixed volume output");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, aaliasInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
ndist = nrrdNew();
nmask = nrrdNew();
nupdate = nrrdNew();
airMopAdd(mop, ndist, (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nmask, (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nupdate, (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(ndist, nin, nrrdTypeDouble)
|| nrrdConvert(nmask, nin, nrrdTypeDouble)
|| nrrdConvert(nupdate, nin, nrrdTypeDouble)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate buffers:\n%s", me, err);
airMopError(mop); return 1;
}
dist = AIR_CAST(double *, ndist->data);
mask = AIR_CAST(double *, nmask->data);
update = AIR_CAST(double *, nupdate->data);
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, ndist, 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, gageSclValue);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclGradMag);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclMeanCurv);
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;
}
valu = gageAnswerPointer(ctx, pvl, gageSclValue);
gmag = gageAnswerPointer(ctx, pvl, gageSclGradMag);
mcrv = gageAnswerPointer(ctx, pvl, gageSclMeanCurv);
sx = nin->axis[0].size;
sy = nin->axis[1].size;
sz = nin->axis[2].size;
for (iter=0; iter<maxIter; iter++) {
double rms;
unsigned count;
fprintf(stderr, "%s: iter %u: ", me, iter);
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++) {
si = xi + sx*(yi + sy*zi);
gageProbe(ctx, xi, yi, zi);
update[si] = -dt*(*gmag)*(*mcrv);
}
}
}
rms = 0;
count = 0;
for (si=0; si<sx*sy*sz; si++) {
double newval;
if (update[si]) {
/* NOTE: this update behavior is only slightly different than
what's described in Equation 18 of the paper. That update
rule ensures that the value never changes "sign" (with
respect to the threshold value), by clamping the values
above or below to 0.0. But worst-case scenario is that two
adjacent samples that were on other side of the threshold
(i.e. 0), could then equal the threshold, which would
confuse a marching-cubes type algorithm. So the "eps"
enforces a small value range around the treshold, and keeps
the values on either side of it. */
newval = dist[si] + update[si];
if (mask[si] > thresh) {
newval = AIR_MAX(newval, thresh+eps/2);
} else {
newval = AIR_MIN(newval, thresh-eps/2);
}
rms += (dist[si] - newval)*(dist[si] - newval);
dist[si] = newval;
count++;
}
}
fprintf(stderr, "%s", airDoneStr(0, zi, sz-1, done));
rms /= count;
rms = sqrt(rms);
if (rms < rmsMin) {
fprintf(stderr, "\n%s: RMS %g below threshold %g\n", me, rms, rmsMin);
break;
} else {
fprintf(stderr, " rms = %g > %g\n", rms, rmsMin);
}
}
if (iter == maxIter) {
fprintf(stderr, "%s: hit max iter %u\n", me, maxIter);
}
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, ndist)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s", me, err);
airMopError(mop); return 1;
}
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);
}
int
unrrdu_1opMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout, *ntmp=NULL;
int op, pret, type;
airArray *mop;
hestOptAdd(&opt, NULL, "operator", airTypeEnum, 1, 1, &op, NULL,
"Unary operator. Possibilities include:\n "
"\b\bo \"-\": negative (multiply by -1.0)\n "
"\b\bo \"r\": reciprocal (1.0/value)\n "
"\b\bo \"sin\", \"cos\", \"tan\", \"asin\", \"acos\", \"atan\": "
"same as in C\n "
"\b\bo \"exp\", \"log\", \"log10\", \"log1p\": same as in C\n "
"\b\bo \"log2\": log base 2\n "
"\b\bo \"sqrt\", \"cbrt\", \"ceil\", \"floor\": same as in C\n "
"\b\bo \"erf\": error function (integral of Gaussian)\n "
"\b\bo \"rup\", \"rdn\": round up or down to integral value\n "
"\b\bo \"abs\": absolute value\n "
"\b\bo \"sgn\": -1, 0, 1 if value is <0, ==0, or >0\n "
"\b\bo \"exists\": 1 iff not NaN or +/-Inf, 0 otherwise\n "
"\b\bo \"rand\": random value in [0.0,1.0), no relation to input",
NULL, nrrdUnaryOp);
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"convert input nrrd to this type prior to "
"doing operation. Useful when desired output is float "
"(e.g., with log1p), but input is integral. By default "
"(not using this option), the types of "
"the input nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_1opInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdTypeDefault != type) {
/* they requested conversion to another type prior to the 1op */
airMopAdd(mop, ntmp=nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(ntmp, nin, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
} else {
ntmp = nin;
}
if (nrrdUnaryOpRand == op
|| nrrdUnaryOpNormalRand == op) {
airSrandMT(AIR_CAST(unsigned int, airTime()));
}
if (nrrdArithUnaryOp(nout, op, ntmp)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing unary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
/* if we had to create ntmp with nrrdConvert, it will be mopped,
otherwise ntmp is an alias for nin, which will also be mopped */
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
/*
******** tenGradientDistribute
**
** Takes the given list of gradients, normalizes their lengths,
** optionally jitters their positions, does point repulsion, and then
** (optionally) selects a combination of directions with minimum vector sum.
**
** The complicated part of this is the point repulsion, which uses a
** gradient descent with variable set size. The progress of the system
** is measured by decrease in potential (when its measurement doesn't
** overflow to infinity) or an increase in the minimum angle. When a
** step results in negative progress, the step size is halved, and the
** iteration is attempted again. Based on the observation that at
** some points the step size must be made very small to get progress,
** the step size is cautiously increased ("nudged") at every
** iteration, to try to avoid using an overly small step. The amount
** by which the step is nudged is halved everytime the step is halved,
** to avoid endless cycling through step sizes.
*/
int
tenGradientDistribute(Nrrd *nout, const Nrrd *nin,
tenGradientParm *tgparm) {
static const char me[]="tenGradientDistribute";
char filename[AIR_STRLEN_SMALL];
unsigned int ii, num, iter, oldIdx, newIdx, edgeShrink;
airArray *mop;
Nrrd *npos[2];
double *pos, len, meanVelocity, pot, potNew, potD,
edge, edgeMin, angle, angleNew;
int E;
if (!nout || tenGradientCheck(nin, nrrdTypeUnknown, 2) || !tgparm) {
biffAddf(TEN, "%s: got NULL pointer or invalid input", me);
return 1;
}
num = AIR_UINT(nin->axis[1].size);
mop = airMopNew();
npos[0] = nrrdNew();
npos[1] = nrrdNew();
airMopAdd(mop, npos[0], (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, npos[1], (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(npos[0], nin, nrrdTypeDouble)
|| nrrdConvert(npos[1], nin, nrrdTypeDouble)) {
biffMovef(TEN, NRRD, "%s: trouble allocating temp buffers", me);
airMopError(mop); return 1;
}
pos = (double*)(npos[0]->data);
for (ii=0; ii<num; ii++) {
ELL_3V_NORM(pos, pos, len);
pos += 3;
}
if (tgparm->jitter) {
if (tenGradientJitter(npos[0], npos[0], tgparm->jitter)) {
biffAddf(TEN, "%s: problem jittering input", me);
airMopError(mop); return 1;
}
}
/* initialize things prior to first iteration; have to
make sure that loop body tests pass 1st time around */
meanVelocity = 2*tgparm->minVelocity;
potD = -2*tgparm->minPotentialChange;
oldIdx = 0;
newIdx = 1;
tgparm->step = tgparm->initStep;
tgparm->nudge = 0.1;
tenGradientMeasure(&pot, &angle, NULL,
npos[oldIdx], tgparm, AIR_TRUE);
for (iter = 0;
((!!tgparm->minIteration && iter < tgparm->minIteration)
||
(iter < tgparm->maxIteration
&& (!tgparm->minPotentialChange
|| !AIR_EXISTS(potD)
|| -potD > tgparm->minPotentialChange)
&& (!tgparm->minVelocity
|| meanVelocity > tgparm->minVelocity)
&& tgparm->step > FLT_MIN));
iter++) {
/* copy positions from old to new */
memcpy(npos[newIdx]->data, npos[oldIdx]->data, 3*num*sizeof(double));
edge = tenGradientIdealEdge(num, tgparm->single);
edgeShrink = 0;
/* try to do a position update, which will fail if repulsion values
explode, from having an insufficiently small edge normalization,
so retry with smaller edge next time */
do {
E = _tenGradientUpdate(&meanVelocity, &edgeMin,
npos[newIdx], edge, tgparm);
if (E) {
if (edgeShrink > tgparm->maxEdgeShrink) {
biffAddf(TEN, "%s: %u > %u edge shrinks (%g), update still failed",
me, edgeShrink, tgparm->maxEdgeShrink, edge);
airMopError(mop); return 1;
}
edgeShrink++;
/* re-initialize positions (HEY ugly code logic) */
memcpy(npos[newIdx]->data, npos[oldIdx]->data, 3*num*sizeof(double));
edge = edgeMin;
}
} while (E);
tenGradientMeasure(&potNew, &angleNew, NULL,
npos[newIdx], tgparm, AIR_TRUE);
if ((AIR_EXISTS(pot) && AIR_EXISTS(potNew) && potNew <= pot)
|| angleNew >= angle) {
/* there was progress of some kind, either through potential
decrease, or angle increase */
potD = 2*(potNew - pot)/(potNew + pot);
if (!(iter % tgparm->report) && tgparm->verbose) {
fprintf(stderr, "%s(%d): . . . . . . step = %g, edgeShrink = %u\n"
" velo = %g<>%g, phi = %g ~ %g<>%g, angle = %g ~ %g\n",
me, iter, tgparm->step, edgeShrink,
meanVelocity, tgparm->minVelocity,
pot, potD, tgparm->minPotentialChange,
angle, angleNew - angle);
}
if (tgparm->snap && !(iter % tgparm->snap)) {
sprintf(filename, "%05d.nrrd", iter/tgparm->snap);
if (tgparm->verbose) {
fprintf(stderr, "%s(%d): . . . . . . saving %s\n",
me, iter, filename);
}
if (nrrdSave(filename, npos[newIdx], NULL)) {
char *serr;
serr = biffGetDone(NRRD);
if (tgparm->verbose) { /* perhaps shouldn't have this check */
fprintf(stderr, "%s: iter=%d, couldn't save snapshot:\n%s"
"continuing ...\n", me, iter, serr);
}
free(serr);
}
}
tgparm->step *= 1 + tgparm->nudge;
tgparm->step = AIR_MIN(tgparm->initStep, tgparm->step);
pot = potNew;
angle = angleNew;
/* swap buffers */
newIdx = 1 - newIdx;
oldIdx = 1 - oldIdx;
} else {
/* oops, did not make progress; back off and try again */
if (tgparm->verbose) {
fprintf(stderr, "%s(%d): ######## step %g --> %g\n"
" phi = %g --> %g ~ %g, angle = %g --> %g\n",
me, iter, tgparm->step, tgparm->step/2,
pot, potNew, potD, angle, angleNew);
}
tgparm->step /= 2;
tgparm->nudge /= 2;
}
}
/* when the for-loop test fails, we stop before computing the next
iteration (which starts with copying from npos[oldIdx] to
npos[newIdx]) ==> the final results are in npos[oldIdx] */
if (tgparm->verbose) {
fprintf(stderr, "%s: .......................... done distribution:\n"
" (%d && %d) || (%d \n"
" && (%d || %d || %d) \n"
" && (%d || %d) \n"
" && %d) is false\n", me,
!!tgparm->minIteration, iter < tgparm->minIteration,
iter < tgparm->maxIteration,
!tgparm->minPotentialChange,
!AIR_EXISTS(potD), AIR_ABS(potD) > tgparm->minPotentialChange,
!tgparm->minVelocity, meanVelocity > tgparm->minVelocity,
tgparm->step > FLT_MIN);
fprintf(stderr, " iter=%d, velo = %g<>%g, phi = %g ~ %g<>%g;\n",
iter, meanVelocity, tgparm->minVelocity, pot,
potD, tgparm->minPotentialChange);
fprintf(stderr, " minEdge = %g; idealEdge = %g\n",
2*sin(angle/2), tenGradientIdealEdge(num, tgparm->single));
}
tenGradientMeasure(&pot, NULL, NULL, npos[oldIdx], tgparm, AIR_FALSE);
tgparm->potential = pot;
tenGradientMeasure(&pot, &angle, &edge, npos[oldIdx], tgparm, AIR_TRUE);
tgparm->potentialNorm = pot;
tgparm->angle = angle;
tgparm->edge = edge;
tgparm->itersUsed = iter;
if ((tgparm->minMeanImprovement || tgparm->minMean)
&& !tgparm->single) {
if (tgparm->verbose) {
fprintf(stderr, "%s: optimizing balance:\n", me);
}
if (tenGradientBalance(nout, npos[oldIdx], tgparm)) {
biffAddf(TEN, "%s: failed to minimize vector sum of gradients", me);
airMopError(mop); return 1;
}
if (tgparm->verbose) {
fprintf(stderr, "%s: .......................... done balancing.\n", me);
}
} else {
if (tgparm->verbose) {
fprintf(stderr, "%s: .......................... (no balancing)\n", me);
}
if (nrrdConvert(nout, npos[oldIdx], nrrdTypeDouble)) {
biffMovef(TEN, NRRD, "%s: couldn't set output", me);
airMopError(mop); return 1;
}
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *outS, *err;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
Nrrd *nin, *nmat, *ninv, *nidn;
int (*func)(Nrrd *, Nrrd *);
double m3[9], m4[16];
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, NULL, "matrix", airTypeOther, 1, 1, &nin, NULL,
"transform(s) to apply to image",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"file to write output nrrd to");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, invInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
ninv = nrrdNew();
airMopAdd(mop, ninv, (airMopper)nrrdNuke, airMopAlways);
nidn = nrrdNew();
airMopAdd(mop, nidn, (airMopper)nrrdNuke, airMopAlways);
nmat = nrrdNew();
airMopAdd(mop, nmat, (airMopper)nrrdNuke, airMopAlways);
nrrdConvert(nmat, nin, nrrdTypeDouble);
if (3 == nmat->axis[0].size && 3 == nmat->axis[1].size) {
ell_3m_inv_d(m3, (double *)nmat->data);
fprintf(stderr, "%s: input:\n", me);
ell_3m_print_d(stderr, (double *)nmat->data);
fprintf(stderr, "%s: inverse:\n", me);
ell_3m_print_d(stderr, m3);
}
if (4 == nmat->axis[0].size && 4 == nmat->axis[1].size) {
ell_4m_inv_d(m4, (double *)nmat->data);
fprintf(stderr, "%s: input:\n", me);
ell_4m_print_d(stderr, (double *)nmat->data);
fprintf(stderr, "%s: inverse:\n", me);
ell_4m_print_d(stderr, m4);
}
func = (nmat->axis[0].size == nmat->axis[1].size
? ell_Nm_inv
: ell_Nm_pseudo_inv);
if (func(ninv, nmat)) {
airMopAdd(mop, err = biffGetDone(ELL), airFree, airMopAlways);
fprintf(stderr, "%s: problem inverting:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, ninv, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: problem saving output:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
exit(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
unrrdu_3opMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
NrrdIter *in1, *in2, *in3;
Nrrd *nout, *ntmp=NULL;
int op, type, E, pret;
airArray *mop;
hestOptAdd(&opt, NULL, "operator", airTypeEnum, 1, 1, &op, NULL,
"Ternary operator. Possibilities include:\n "
"\b\bo \"+\", \"x\": sum or product of three values\n "
"\b\bo \"min\", \"max\": minimum, maximum\n "
"\b\bo \"clamp\": second value is clamped to range between "
"the first and the third\n "
"\b\bo \"ifelse\": if 1st value non-zero, then 2nd value, else "
"3rd value\n "
"\b\bo \"lerp\": linear interpolation between the 2nd and "
"3rd values, as the 1st value varies between 0.0 and 1.0, "
"respectively\n "
"\b\bo \"exists\": if the first value exists, use the second "
"value, otherwise use the third\n "
"\b\bo \"in_op\": 1 iff second value is > first and < "
"third, 0 otherwise\n "
"\b\bo \"in_cl\": 1 iff second value is >= first and <= "
"third, 0 otherwise",
NULL, nrrdTernaryOp);
hestOptAdd(&opt, NULL, "in1", airTypeOther, 1, 1, &in1, NULL,
"First input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in2", airTypeOther, 1, 1, &in2, NULL,
"Second input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in3", airTypeOther, 1, 1, &in3, NULL,
"Third input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to convert all nrrd inputs to, prior to "
"doing operation. This also determines output type. "
"By default (not using this option), the types of the input "
"nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_3opInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/*
fprintf(stderr, "%s: op = %d\n", me, op);
fprintf(stderr, "%s: in1->left = %d, in2->left = %d\n", me,
(int)(in1->left), (int)(in2->left));
*/
if (nrrdTypeDefault != type) {
/* they wanted to convert nrrds to some other type first */
E = 0;
if (in1->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in1->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in1, ntmp);
}
if (in2->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in2->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in2, ntmp);
}
if (in3->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in3->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in3, ntmp);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err);
airMopError(mop);
return 1;
}
/* this will still leave a nrrd in the NrrdIter for nrrdIterNix()
(called by hestParseFree() called be airMopOkay()) to clear up */
}
if (nrrdArithIterTernaryOp(nout, op, in1, in2, in3)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing ternary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
/*
** parties until the gradients settle down
*/
int
tenGradientBalance(Nrrd *nout, const Nrrd *nin,
tenGradientParm *tgparm) {
static const char me[]="tenGradientBalance";
double len, lastLen, improv;
airRandMTState *rstate;
Nrrd *ncopy;
unsigned int iter, maxIter;
int done;
airArray *mop;
if (!nout || tenGradientCheck(nin, nrrdTypeUnknown, 2) || !tgparm) {
biffAddf(TEN, "%s: got NULL pointer (%p,%p) or invalid nin", me,
AIR_VOIDP(nout), AIR_VOIDP(tgparm));
return 1;
}
if (nrrdConvert(nout, nin, nrrdTypeDouble)) {
biffMovef(TEN, NRRD, "%s: can't initialize output with input", me);
return 1;
}
mop = airMopNew();
ncopy = nrrdNew();
airMopAdd(mop, ncopy, (airMopper)nrrdNuke, airMopAlways);
rstate = airRandMTStateNew(tgparm->seed);
airMopAdd(mop, rstate, (airMopper)airRandMTStateNix, airMopAlways);
/* HEY: factor of 100 is an approximate hack */
maxIter = 100*tgparm->maxIteration;
lastLen = 1.0;
done = AIR_FALSE;
do {
iter = 0;
do {
iter++;
len = party(nout, rstate);
} while (len > lastLen && iter < maxIter);
if (iter >= maxIter) {
if (tgparm->verbose) {
fprintf(stderr, "%s: stopping at max iter %u\n", me, maxIter);
}
if (nrrdCopy(nout, ncopy)) {
biffMovef(TEN, NRRD, "%s: trouble copying", me);
airMopError(mop); return 1;
}
done = AIR_TRUE;
} else {
if (nrrdCopy(ncopy, nout)) {
biffMovef(TEN, NRRD, "%s: trouble copying", me);
airMopError(mop); return 1;
}
improv = lastLen - len;
lastLen = len;
if (tgparm->verbose) {
fprintf(stderr, "%s: (iter %u) improvement: %g (mean length = %g)\n",
me, iter, improv, len);
}
done = (improv <= tgparm->minMeanImprovement
|| len < tgparm->minMean);
}
} while (!done);
airMopOkay(mop);
return 0;
}
int
tend_estimMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
Nrrd **nin, *nin4d, *nbmat, *nterr, *nB0, *nout;
char *outS, *terrS, *bmatS, *eb0S;
float soft, scale, sigma;
int dwiax, EE, knownB0, oldstuff, estmeth, verbose, fixneg;
unsigned int ninLen, axmap[4], wlsi, *skip, skipNum, skipIdx;
double valueMin, thresh;
Nrrd *ngradKVP=NULL, *nbmatKVP=NULL;
double bKVP, bval;
tenEstimateContext *tec;
hestOptAdd(&hopt, "old", NULL, airTypeInt, 0, 0, &oldstuff, NULL,
"instead of the new tenEstimateContext code, use "
"the old tenEstimateLinear code");
hestOptAdd(&hopt, "sigma", "sigma", airTypeFloat, 1, 1, &sigma, "nan",
"Rician noise parameter");
hestOptAdd(&hopt, "v", "verbose", airTypeInt, 1, 1, &verbose, "0",
"verbosity level");
hestOptAdd(&hopt, "est", "estimate method", airTypeEnum, 1, 1, &estmeth,
"lls",
"estimation method to use. \"lls\": linear-least squares",
NULL, tenEstimate1Method);
hestOptAdd(&hopt, "wlsi", "WLS iters", airTypeUInt, 1, 1, &wlsi, "1",
"when using weighted-least-squares (\"-est wls\"), how "
"many iterations to do after the initial weighted fit.");
hestOptAdd(&hopt, "fixneg", NULL, airTypeInt, 0, 0, &fixneg, NULL,
"after estimating the tensor, ensure that there are no negative "
"eigenvalues by adding (to all eigenvalues) the amount by which "
"the smallest is negative (corresponding to increasing the "
"non-DWI image value).");
hestOptAdd(&hopt, "ee", "filename", airTypeString, 1, 1, &terrS, "",
"Giving a filename here allows you to save out the tensor "
"estimation error: a value which measures how much error there "
"is between the tensor model and the given diffusion weighted "
"measurements for each sample. By default, no such error "
"calculation is saved.");
hestOptAdd(&hopt, "eb", "filename", airTypeString, 1, 1, &eb0S, "",
"In those cases where there is no B=0 reference image given "
"(\"-knownB0 false\"), "
"giving a filename here allows you to save out the B=0 image "
"which is estimated from the data. By default, this image value "
"is estimated but not saved.");
hestOptAdd(&hopt, "t", "thresh", airTypeDouble, 1, 1, &thresh, "nan",
"value at which to threshold the mean DWI value per pixel "
"in order to generate the \"confidence\" mask. By default, "
"the threshold value is calculated automatically, based on "
"histogram analysis.");
hestOptAdd(&hopt, "soft", "soft", airTypeFloat, 1, 1, &soft, "0",
"how fuzzy the confidence boundary should be. By default, "
"confidence boundary is perfectly sharp");
hestOptAdd(&hopt, "scale", "scale", airTypeFloat, 1, 1, &scale, "1",
"After estimating the tensor, scale all of its elements "
"(but not the confidence value) by this amount. Can help with "
"downstream numerical precision if values are very large "
"or small.");
hestOptAdd(&hopt, "mv", "min val", airTypeDouble, 1, 1, &valueMin, "1.0",
"minimum plausible value (especially important for linear "
"least squares estimation)");
hestOptAdd(&hopt, "B", "B-list", airTypeString, 1, 1, &bmatS, NULL,
"6-by-N list of B-matrices characterizing "
"the diffusion weighting for each "
"image. \"tend bmat\" is one source for such a matrix; see "
"its usage info for specifics on how the coefficients of "
"the B-matrix are ordered. "
"An unadorned plain text file is a great way to "
"specify the B-matrix.\n **OR**\n "
"Can say just \"-B kvp\" to try to learn B matrices from "
"key/value pair information in input images.");
hestOptAdd(&hopt, "b", "b", airTypeDouble, 1, 1, &bval, "nan",
"\"b\" diffusion-weighting factor (units of sec/mm^2)");
hestOptAdd(&hopt, "knownB0", "bool", airTypeBool, 1, 1, &knownB0, NULL,
"Determines of the B=0 non-diffusion-weighted reference image "
"is known, or if it has to be estimated along with the tensor "
"elements.\n "
"\b\bo if \"true\": in the given list of diffusion gradients or "
"B-matrices, there are one or more with zero norm, which are "
"simply averaged to find the B=0 reference image value\n "
"\b\bo if \"false\": there may or may not be diffusion-weighted "
"images among the input; the B=0 image value is going to be "
"estimated along with the diffusion model");
hestOptAdd(&hopt, "i", "dwi0 dwi1", airTypeOther, 1, -1, &nin, "-",
"all the diffusion-weighted images (DWIs), as seperate 3D nrrds, "
"**OR**: One 4D nrrd of all DWIs stacked along axis 0",
&ninLen, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output tensor volume");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_estimInfoL);
JUSTPARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
nbmat = nrrdNew();
airMopAdd(mop, nbmat, (airMopper)nrrdNuke, airMopAlways);
/* figure out B-matrix */
if (strcmp("kvp", airToLower(bmatS))) {
/* its NOT coming from key/value pairs */
if (!AIR_EXISTS(bval)) {
fprintf(stderr, "%s: need to specify scalar b-value\n", me);
airMopError(mop); return 1;
}
if (nrrdLoad(nbmat, bmatS, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble loading B-matrix:\n%s\n", me, err);
airMopError(mop); return 1;
}
nin4d = nin[0];
skip = NULL;
skipNum = 0;
} else {
/* it IS coming from key/value pairs */
if (1 != ninLen) {
fprintf(stderr, "%s: require a single 4-D DWI volume for "
"key/value pair based calculation of B-matrix\n", me);
airMopError(mop); return 1;
}
if (oldstuff) {
if (knownB0) {
fprintf(stderr, "%s: sorry, key/value-based DWI info not compatible "
"with older implementation of knownB0\n", me);
airMopError(mop); return 1;
}
}
if (tenDWMRIKeyValueParse(&ngradKVP, &nbmatKVP, &bKVP,
&skip, &skipNum, nin[0])) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (AIR_EXISTS(bval)) {
fprintf(stderr, "%s: WARNING: key/value pair derived b-value %g "
"over-riding %g from command-line", me, bKVP, bval);
}
bval = bKVP;
if (ngradKVP) {
airMopAdd(mop, ngradKVP, (airMopper)nrrdNuke, airMopAlways);
if (tenBMatrixCalc(nbmat, ngradKVP)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble finding B-matrix:\n%s\n", me, err);
airMopError(mop); return 1;
}
} else {
airMopAdd(mop, nbmatKVP, (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(nbmat, nbmatKVP, nrrdTypeDouble)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble converting B-matrix:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* this will work because of the impositions of tenDWMRIKeyValueParse */
dwiax = ((nrrdKindList == nin[0]->axis[0].kind ||
nrrdKindVector == nin[0]->axis[0].kind)
? 0
: ((nrrdKindList == nin[0]->axis[1].kind ||
nrrdKindVector == nin[0]->axis[1].kind)
? 1
: ((nrrdKindList == nin[0]->axis[2].kind ||
nrrdKindVector == nin[0]->axis[2].kind)
? 2
: 3)));
if (0 == dwiax) {
nin4d = nin[0];
} else {
axmap[0] = dwiax;
axmap[1] = 1 > dwiax ? 1 : 0;
axmap[2] = 2 > dwiax ? 2 : 1;
axmap[3] = 3 > dwiax ? 3 : 2;
nin4d = nrrdNew();
airMopAdd(mop, nin4d, (airMopper)nrrdNuke, airMopAlways);
if (nrrdAxesPermute(nin4d, nin[0], axmap)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble creating DWI volume:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
}
nterr = NULL;
nB0 = NULL;
if (!oldstuff) {
if (1 != ninLen) {
fprintf(stderr, "%s: sorry, currently need single 4D volume "
"for new implementation\n", me);
airMopError(mop); return 1;
}
if (!AIR_EXISTS(thresh)) {
if (tend_estimThresholdFind(&thresh, nbmat, nin4d)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble finding threshold:\n%s\n", me, err);
airMopError(mop); return 1;
}
/* HACK to lower threshold a titch */
thresh *= 0.93;
fprintf(stderr, "%s: using mean DWI threshold %g\n", me, thresh);
}
tec = tenEstimateContextNew();
tec->progress = AIR_TRUE;
airMopAdd(mop, tec, (airMopper)tenEstimateContextNix, airMopAlways);
EE = 0;
if (!EE) tenEstimateVerboseSet(tec, verbose);
if (!EE) tenEstimateNegEvalShiftSet(tec, fixneg);
if (!EE) EE |= tenEstimateMethodSet(tec, estmeth);
if (!EE) EE |= tenEstimateBMatricesSet(tec, nbmat, bval, !knownB0);
if (!EE) EE |= tenEstimateValueMinSet(tec, valueMin);
for (skipIdx=0; skipIdx<skipNum; skipIdx++) {
/* fprintf(stderr, "%s: skipping %u\n", me, skip[skipIdx]); */
if (!EE) EE |= tenEstimateSkipSet(tec, skip[skipIdx], AIR_TRUE);
}
switch(estmeth) {
case tenEstimate1MethodLLS:
if (airStrlen(terrS)) {
tec->recordErrorLogDwi = AIR_TRUE;
/* tec->recordErrorDwi = AIR_TRUE; */
}
break;
case tenEstimate1MethodNLS:
if (airStrlen(terrS)) {
tec->recordErrorDwi = AIR_TRUE;
}
break;
case tenEstimate1MethodWLS:
if (!EE) tec->WLSIterNum = wlsi;
if (airStrlen(terrS)) {
tec->recordErrorDwi = AIR_TRUE;
}
break;
case tenEstimate1MethodMLE:
if (!(AIR_EXISTS(sigma) && sigma > 0.0)) {
fprintf(stderr, "%s: can't do %s w/out sigma > 0 (not %g)\n",
me, airEnumStr(tenEstimate1Method, tenEstimate1MethodMLE),
sigma);
airMopError(mop); return 1;
}
if (!EE) EE |= tenEstimateSigmaSet(tec, sigma);
if (airStrlen(terrS)) {
tec->recordLikelihoodDwi = AIR_TRUE;
}
break;
}
if (!EE) EE |= tenEstimateThresholdSet(tec, thresh, soft);
if (!EE) EE |= tenEstimateUpdate(tec);
if (EE) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble setting up estimation:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (tenEstimate1TensorVolume4D(tec, nout, &nB0,
airStrlen(terrS)
? &nterr
: NULL,
nin4d, nrrdTypeFloat)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble doing estimation:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (airStrlen(terrS)) {
airMopAdd(mop, nterr, (airMopper)nrrdNuke, airMopAlways);
}
} else {
EE = 0;
if (1 == ninLen) {
EE = tenEstimateLinear4D(nout, airStrlen(terrS) ? &nterr : NULL, &nB0,
nin4d, nbmat, knownB0, thresh, soft, bval);
} else {
EE = tenEstimateLinear3D(nout, airStrlen(terrS) ? &nterr : NULL, &nB0,
(const Nrrd**)nin, ninLen, nbmat,
knownB0, thresh, soft, bval);
}
if (EE) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble making tensor volume:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
if (nterr) {
/* it was allocated by tenEstimate*, we have to clean it up */
airMopAdd(mop, nterr, (airMopper)nrrdNuke, airMopAlways);
}
if (nB0) {
/* it was allocated by tenEstimate*, we have to clean it up */
airMopAdd(mop, nB0, (airMopper)nrrdNuke, airMopAlways);
}
if (1 != scale) {
if (tenSizeScale(nout, nout, scale)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble doing scaling:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
if (nterr) {
if (nrrdSave(terrS, nterr, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing error image:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
if (!knownB0 && airStrlen(eb0S)) {
if (nrrdSave(eb0S, nB0, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing estimated B=0 image:\n%s\n",
me, err);
airMopError(mop); return 1;
}
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
tend_msimMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
tenExperSpec *espec;
const tenModel *model;
int E, seed, keyValueSet, outType, plusB0, insertB0;
Nrrd *nin, *nT2, *_ngrad, *ngrad, *nout;
char *outS, *modS;
double bval, sigma;
/* maybe this can go in tend.c, but for some reason its explicitly
set to AIR_FALSE there */
hparm->elideSingleOtherDefault = AIR_TRUE;
hestOptAdd(&hopt, "sigma", "sigma", airTypeDouble, 1, 1, &sigma, "0.0",
"Gaussian/Rician noise parameter");
hestOptAdd(&hopt, "seed", "seed", airTypeInt, 1, 1, &seed, "42",
"seed value for RNG which creates noise");
hestOptAdd(&hopt, "g", "grad list", airTypeOther, 1, 1, &_ngrad, NULL,
"gradient list, one row per diffusion-weighted image",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "b0", "b0 image", airTypeOther, 1, 1, &nT2, "",
"reference non-diffusion-weighted (\"B0\") image, which "
"may be needed if it isn't part of give model param image",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "i", "model image", airTypeOther, 1, 1, &nin, "-",
"input model image", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "m", "model", airTypeString, 1, 1, &modS, NULL,
"model with which to simulate DWIs, which must be specified if "
"it is not indicated by the first axis in input model image.");
hestOptAdd(&hopt, "ib0", "bool", airTypeBool, 1, 1, &insertB0, "false",
"insert a non-DW B0 image at the beginning of the experiment "
"specification (useful if the given gradient list doesn't "
"already have one) and hence also insert a B0 image at the "
"beginning of the output simulated DWIs");
hestOptAdd(&hopt, "b", "b", airTypeDouble, 1, 1, &bval, "1000",
"b value for simulated scan");
hestOptAdd(&hopt, "kvp", "bool", airTypeBool, 1, 1, &keyValueSet, "true",
"generate key/value pairs in the NRRD header corresponding "
"to the input b-value and gradients.");
hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &outType, "float",
"output type of DWIs", NULL, nrrdType);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output dwis");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_msimInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
espec = tenExperSpecNew();
airMopAdd(mop, espec, (airMopper)tenExperSpecNix, airMopAlways);
airSrandMT(seed);
if (nrrdTypeDouble == _ngrad->type) {
ngrad = _ngrad;
} else {
ngrad = nrrdNew();
airMopAdd(mop, ngrad, (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(ngrad, _ngrad, nrrdTypeDouble)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble converting grads to %s:\n%s\n", me,
airEnumStr(nrrdType, nrrdTypeDouble), err);
airMopError(mop); return 1;
}
}
plusB0 = AIR_FALSE;
if (airStrlen(modS)) {
if (tenModelParse(&model, &plusB0, AIR_FALSE, modS)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing model \"%s\":\n%s\n",
me, modS, err);
airMopError(mop); return 1;
}
} else if (tenModelFromAxisLearnPossible(nin->axis + 0)) {
if (tenModelFromAxisLearn(&model, &plusB0, nin->axis + 0)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing model frmo axis 0 of nin:\n%s\n",
me, err);
airMopError(mop); return 1;
}
} else {
fprintf(stderr, "%s: need model specified either via \"-m\" or input "
"model image axis 0\n", me);
airMopError(mop); return 1;
}
/* we have learned plusB0, but we don't actually need it;
either: it describes the given model param image
(which is courteous but not necessary since the logic inside
tenModeSimulate will see this),
or: it is trying to say something about including B0 amongst
model parameters (which isn't actually meaningful in the
context of simulated DWIs */
E = 0;
if (!E) E |= tenGradientCheck(ngrad, nrrdTypeDouble, 1);
if (!E) E |= tenExperSpecGradSingleBValSet(espec, insertB0, bval,
AIR_CAST(const double *,
ngrad->data),
ngrad->axis[1].size);
if (!E) E |= tenModelSimulate(nout, outType, espec,
model, nT2, nin, keyValueSet);
if (E) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
unrrdu_affineMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
NrrdIter *minIn, *in, *maxIn, *minOut, *maxOut, *args[5];
Nrrd *nout, *ntmp=NULL;
int type, E, pret, clamp;
airArray *mop;
unsigned int ai, nn;
hestOptAdd(&opt, NULL, "minIn", airTypeOther, 1, 1, &minIn, NULL,
"Lower end of input value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in", airTypeOther, 1, 1, &in, NULL,
"Input value.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "maxIn", airTypeOther, 1, 1, &maxIn, NULL,
"Upper end of input value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "minOut", airTypeOther, 1, 1, &minOut, NULL,
"Lower end of output value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "maxOut", airTypeOther, 1, 1, &maxOut, NULL,
"Upper end of output value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to convert all nrrd inputs to, prior to "
"doing operation. This also determines output type. "
"By default (not using this option), the types of the input "
"nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
hestOptAdd(&opt, "clamp", "bool", airTypeBool, 1, 1, &clamp, "false",
"clamp output values to specified output range");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_affineInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
args[0] = minIn;
args[1] = in;
args[2] = maxIn;
args[3] = minOut;
args[4] = maxOut;
nn = 0;
for (ai=0; ai<5; ai++) {
nn += !!args[ai]->ownNrrd;
}
if (nrrdTypeDefault != type) {
/* they wanted to convert nrrds to some other type first */
E = 0;
for (ai=0; ai<5; ai++) {
if (args[ai]->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), args[ai]->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(args[ai], ntmp);
}
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err);
airMopError(mop);
return 1;
}
}
if (0 == nn) {
/* actually, there are no nrrds; we represent the functionality
of the previous stand-alone binary "affine" */
double valOut;
valOut = AIR_AFFINE(minIn->val, in->val, maxIn->val,
minOut->val, maxOut->val);
if (clamp) {
double mmin = AIR_MIN(minOut->val, maxOut->val);
double mmax = AIR_MAX(minOut->val, maxOut->val);
valOut = AIR_CLAMP(mmin, valOut, mmax);
}
printf("%g\n", valOut);
} else {
/* we have a nrrd output */
if (1 == nn && in->ownNrrd) {
E = nrrdArithAffine(nout, minIn->val, in->ownNrrd, maxIn->val,
minOut->val, maxOut->val, clamp);
} else {
E = nrrdArithIterAffine(nout, minIn, in, maxIn, minOut, maxOut, clamp);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing ternary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *err, *outS;
hestOpt *hopt=NULL;
airArray *mop;
int numGrth, numDtdi, numGrgr, numDtgr, numNrrd, ni;
plotPS pps;
plotParm pparm;
Nrrd **_ndata, **ndata;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "i", "data", airTypeOther, 1, -1, &_ndata, NULL,
"input nrrd containing data to plot",
&numNrrd, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "dbox", "minX minY maxX maxY", airTypeDouble,
4, 4, pparm.dbox, NULL,
"bounding box, in data space");
hestOptAdd(&hopt, "bbox", "minX minY maxX maxY", airTypeDouble,
4, 4, pps.bbox, NULL,
"bounding box, in graph space");
hestOptAdd(&hopt, "psc", "PS scale", airTypeDouble, 1, 1, &(pps.psc), "300",
"scaling from graph space to PostScript points");
hestOptAdd(&hopt, "nobg", NULL, airTypeInt, 0, 0, &(pps.nobg), NULL,
"don't fill with background color");
hestOptAdd(&hopt, "bg", "background", airTypeDouble, 3, 3,
&(pps.bgColor), "1 1 1",
"background RGB color; each component in range [0.0,1.0]");
hestOptAdd(&hopt, "grth", "graph thickness", airTypeDouble,
1, -1, &(pparm.graphThick), "0.01",
"thickness of line for graph, or \"0\" for no graph line",
&numGrth);
hestOptAdd(&hopt, "grgr", "graph gray", airTypeDouble,
1, -1, &(pparm.graphGray), "0",
"grayscale to use for graph", &numGrgr);
hestOptAdd(&hopt, "dtdi", "dot diameter", airTypeDouble,
1, -1, &(pparm.dotDiameter), "0.1",
"radius of dot drawn at data points, or \"0\" for no dots",
&numDtdi);
hestOptAdd(&hopt, "dtgr", "dot gray", airTypeDouble,
1, -1, &(pparm.dotGray), "0",
"grayscale to use for dots", &numDtgr);
hestOptAdd(&hopt, "dtid", "dot inner diam frac", airTypeDouble,
1, 1, &(pparm.dotInnerDiameterFraction), "0.0",
"fractional radius of white dot drawn within dot");
hestOptAdd(&hopt, "tihz", "pos", airTypeDouble,
0, -1, &(pparm.horzTick), "",
"locations for tickmarks on horizontal axis",
&(pparm.numHorzTick));
hestOptAdd(&hopt, "tivt", "pos", airTypeDouble,
0, -1, &(pparm.vertTick), "",
"locations for tickmarks on vertical axis",
&(pparm.numVertTick));
hestOptAdd(&hopt, "tiho", "offset", airTypeDouble,
1, 1, &(pparm.horzTickLabelOffset), "0",
"horizontal tick label offset");
hestOptAdd(&hopt, "tivo", "offset", airTypeDouble,
1, 1, &(pparm.vertTickLabelOffset), "0",
"vertical tick label offset");
hestOptAdd(&hopt, "tils", "size", airTypeDouble,
1, 1, &(pparm.tickLabelSize), "0",
"font size for labels on tick marks, or \"0\" for no labels");
hestOptAdd(&hopt, "tith", "tick thickness", airTypeDouble,
1, 1, &(pparm.tickThick), "0.01",
"thickness of lines for tick marks");
hestOptAdd(&hopt, "tiln", "tick length", airTypeDouble,
1, 1, &(pparm.tickLength), "0.08",
"length of lines for tick marks");
hestOptAdd(&hopt, "axth", "axis thickness", airTypeDouble,
1, 1, &(pparm.axisThick), "0.01",
"thickness of lines for axes");
hestOptAdd(&hopt, "axor", "axis origin", airTypeDouble,
2, 2, &(pparm.axisOrig), "0 0",
"origin of lines for axes, in data space");
hestOptAdd(&hopt, "axhl", "horiz axis label", airTypeString,
1, 1, &(pparm.axisHorzLabel), "",
"label on horizontal axis");
hestOptAdd(&hopt, "axvl", "vert axis label", airTypeString,
1, 1, &(pparm.axisVertLabel), "",
"label on vertical axis");
hestOptAdd(&hopt, "o", "output PS", airTypeString,
1, 1, &outS, "out.ps",
"output file to render postscript into");
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 (!( numGrth == numDtdi
&& numDtdi == numGrgr
&& numGrgr == numDtgr )) {
fprintf(stderr, "%s: number of arguments given to grth (%d), dtdi (%d), "
"grgr (%d), dtgr (%d) not all equal\n", me,
numGrth, numDtdi, numGrgr, numDtgr);
airMopError(mop); return 1;
}
if (!( numNrrd == numGrth )) {
fprintf(stderr, "%s: number of nrrds (%d) != number graph options (%d)\n",
me, numNrrd, numGrth);
airMopError(mop); return 1;
}
/* check nrrds */
for (ni=0; ni<numNrrd; ni++) {
if (!( (1 == _ndata[ni]->dim || 2 == _ndata[ni]->dim)
&& nrrdTypeBlock != _ndata[ni]->type )) {
fprintf(stderr, "%s: input nrrd must be 1-D or 2-D array of scalars",
me);
airMopError(mop); return 1;
}
}
ndata = (Nrrd**)calloc(numNrrd, sizeof(Nrrd *));
airMopAdd(mop, ndata, airFree, airMopAlways);
for (ni=0; ni<numNrrd; ni++) {
ndata[ni] = nrrdNew();
airMopAdd(mop, ndata[ni], (airMopper)nrrdNuke, airMopAlways);
if (nrrdConvert(ndata[ni], _ndata[ni], nrrdTypeDouble)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't convert input %d to %s:\n%s\n",
me, ni, airEnumStr(nrrdType, nrrdTypeDouble), err);
airMopError(mop); return 1;
}
if (1 == ndata[ni]->dim) {
if (nrrdAxesInsert(ndata[ni], ndata[ni], 0)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't insert axis 0 on nrrd %d:\n%s\n",
me, ni, err);
airMopError(mop); return 1;
}
}
/* currently assuming node centering */
if (!AIR_EXISTS(ndata[ni]->axis[1].min)) {
ndata[ni]->axis[1].min = 0;
}
if (!AIR_EXISTS(ndata[ni]->axis[1].max)) {
ndata[ni]->axis[1].max = ndata[ni]->axis[1].size-1;
}
}
if (!(pps.file = airFopen(outS, stdout, "wb"))) {
fprintf(stderr, "%s: couldn't open output file\n", me);
airMopError(mop); return 1;
}
airMopAdd(mop, pps.file, (airMopper)airFclose, airMopAlways);
plotPreamble(&pps, &pparm);
plotAxes(&pps, &pparm, ndata[0]);
for (ni=0; ni<numNrrd; ni++) {
plotGraph(&pps, &pparm, ndata, ni);
plotDots(&pps, &pparm, ndata, ni);
}
plotEpilog(&pps, &pparm);
airMopOkay(mop);
return 0;
}
int
unrrdu_2opMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err, *seedS;
NrrdIter *in1, *in2;
Nrrd *nout, *ntmp=NULL;
int op, type, E, pret;
airArray *mop;
unsigned int seed;
hestOptAdd(&opt, NULL, "operator", airTypeEnum, 1, 1, &op, NULL,
"Binary operator. Possibilities include:\n "
"\b\bo \"+\", \"-\", \"x\", \"/\": "
"add, subtract, multiply, divide\n "
"\b\bo \"^\": exponentiation (pow)\n "
"\b\bo \"spow\": signed exponentiation: sgn(x)pow(abs(x),p)\n "
"\b\bo \"%\": integer modulo\n "
"\b\bo \"fmod\": same as fmod() in C\n "
"\b\bo \"atan2\": same as atan2() in C\n "
"\b\bo \"min\", \"max\": minimum, maximum\n "
"\b\bo \"lt\", \"lte\", \"gt\", \"gte\": same as C's <, <=, >, <=\n "
"\b\bo \"eq\", \"neq\": same as C's == and !=\n "
"\b\bo \"comp\": -1, 0, or 1 if 1st value is less than, "
"equal to, or greater than 2nd value\n "
"\b\bo \"if\": if 1st value is non-zero, use it, "
"else use 2nd value\n "
"\b\bo \"exists\": if 1st value exists, use it, "
"else use 2nd value\n "
"\b\bo \"nrand\": scale unit-stdv Gaussian noise by 2nd value "
"and add to first value",
NULL, nrrdBinaryOp);
hestOptAdd(&opt, NULL, "in1", airTypeOther, 1, 1, &in1, NULL,
"First input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in2", airTypeOther, 1, 1, &in2, NULL,
"Second input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, "s,seed", "seed", airTypeString, 1, 1, &seedS, "",
"seed value for RNG for nrand, so that you "
"can get repeatable results between runs, or, "
"by not using this option, the RNG seeding will be "
"based on the current time");
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to convert all INPUT nrrds to, prior to "
"doing operation, useful for doing, for instance, the difference "
"between two unsigned char nrrds. This will also determine "
"output type. By default (not using this option), the types of "
"the input nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_2opInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/*
fprintf(stderr, "%s: op = %d\n", me, op);
fprintf(stderr, "%s: in1->left = %d, in2->left = %d\n", me,
(int)(in1->left), (int)(in2->left));
*/
if (nrrdTypeDefault != type) {
/* they wanted to convert nrrds to some other type first */
E = 0;
if (in1->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in1->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in1, ntmp);
}
if (in2->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in2->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in2, ntmp);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err);
airMopError(mop);
return 1;
}
/* this will still leave a nrrd in the NrrdIter for nrrdIterNix()
(called by hestParseFree() called be airMopOkay()) to clear up */
}
if (nrrdBinaryOpNormalRandScaleAdd == op) {
if (airStrlen(seedS)) {
if (1 != sscanf(seedS, "%u", &seed)) {
fprintf(stderr, "%s: couldn't parse seed \"%s\" as uint\n", me, seedS);
airMopError(mop);
return 1;
} else {
airSrandMT(seed);
}
} else {
/* got no request for specific seed */
airSrandMT(AIR_CAST(unsigned int, airTime()));
}
}
if (nrrdArithIterBinaryOp(nout, op, in1, in2)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing binary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
gageDeconvolveSeparable(Nrrd *nout, const Nrrd *nin,
const gageKind *kind,
const NrrdKernelSpec *ksp,
int typeOut) {
static const char me[]="gageDeconvolveSeparable";
double *line, (*lup)(const void *, size_t),
(*ins)(void *, size_t, double);
airArray *mop;
size_t lineLen, sx, sy, sz, idx, ii, jj;
unsigned int vi, valLen;
if (!(nout && nin && kind && ksp)) {
biffAddf(GAGE, "%s: got NULL pointer", me);
return 1;
}
if (!(nrrdTypeDefault == typeOut
|| !airEnumValCheck(nrrdType, typeOut))) {
biffAddf(GAGE, "%s: typeOut %d not valid", me, typeOut);
return 1;
}
if (!gageDeconvolveSeparableKnown(ksp)) {
biffAddf(GAGE, "%s: separable deconv not known for %s kernel",
me, ksp->kernel->name);
return 1;
}
if (gageKindVolumeCheck(kind, nin)) {
biffAddf(GAGE, "%s: given volume doesn't fit %s kind",
me, kind->name);
return 1;
}
if (nrrdTypeDefault == typeOut
? nrrdCopy(nout, nin)
: nrrdConvert(nout, nin, typeOut)) {
biffMovef(GAGE, NRRD, "%s: problem allocating output", me);
return 1;
}
if (deconvTrivial(ksp)) {
/* if there's no real work for the deconvolution, then by
copying the values we're already done; bye */
return 0;
}
valLen = kind->valLen;
sx = nin->axis[kind->baseDim + 0].size;
sy = nin->axis[kind->baseDim + 1].size;
sz = nin->axis[kind->baseDim + 2].size;
lineLen = sx;
lineLen = AIR_MAX(lineLen, sy);
lineLen = AIR_MAX(lineLen, sz);
lup = nrrdDLookup[nin->type];
ins = nrrdDInsert[nout->type];
mop = airMopNew();
line = AIR_CALLOC(lineLen*valLen, double);
airMopAdd(mop, line, airFree, airMopAlways);
/* process along X scanlines */
for (jj=0; jj<sy*sz; jj++) {
/* xi = 0, yi = jj%sy, zi = jj/sy
==> xi + sx*(yi + sy*zi)
== 0 + sx*(jj%sy + sy*(jj/sy)) == 0 + sx*jj */
idx = 0 + valLen*(0 + sx*jj);
for (ii=0; ii<sx; ii++) {
for (vi=0; vi<valLen; vi++) {
line[ii + sx*vi] = lup(nin->data, idx + vi + valLen*ii);
}
}
for (vi=0; vi<valLen; vi++) {
deconvLine(line + sx*vi, sx, ksp);
}
for (ii=0; ii<sx; ii++) {
for (vi=0; vi<valLen; vi++) {
ins(nout->data, idx + vi + valLen*ii, line[ii + sx*vi]);
}
}
}
/* process along Y scanlines */
for (jj=0; jj<sx*sz; jj++) {
/* xi = jj%sx, yi = 0, zi = jj/sx
==> xi + sx*(yi + sy*zi)
== jj%sx + sx*(0 + sy*jj/sx) */
idx = 0 + valLen*((jj%sx) + sx*(0 + sy*(jj/sx)));
for (ii=0; ii<sy; ii++) {
for (vi=0; vi<valLen; vi++) {
line[ii + sy*vi] = lup(nin->data, idx + vi + valLen*sx*ii);
}
}
for (vi=0; vi<valLen; vi++) {
deconvLine(line + sy*vi, sy, ksp);
}
for (ii=0; ii<sx; ii++) {
for (vi=0; vi<valLen; vi++) {
ins(nout->data, idx + vi + valLen*sx*ii, line[ii + sy*vi]);
}
}
}
/* process along Z scanlines */
for (jj=0; jj<sx*sy; jj++) {
/* xi = jj%sx, yi = jj/sx, zi = 0
==> xi + sx*(yi + sy*zi)
== jj%sx + sx*(jj/sx + sy*0)
== jj%sx + sx*(jj/sx) == jj */
idx = 0 + valLen*jj;
for (ii=0; ii<sz; ii++) {
for (vi=0; vi<valLen; vi++) {
line[ii + sz*vi] = lup(nin->data, idx + vi + valLen*sx*sy*ii);
}
}
for (vi=0; vi<valLen; vi++) {
deconvLine(line + sz*vi, sz, ksp);
}
for (ii=0; ii<sx; ii++) {
for (vi=0; vi<valLen; vi++) {
ins(nout->data, idx + vi + valLen*sx*sy*ii, line[ii + sz*vi]);
}
}
}
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 {
/*
******** nrrdSpatialResample()
**
** general-purpose array-resampler: resamples a nrrd of any type
** (except block) and any dimension along any or all of its axes, with
** any combination of up- or down-sampling along the axes, with any
** kernel (specified by callback), with potentially a different kernel
** for each axis. Whether or not to resample along axis d is
** controlled by the non-NULL-ity of info->kernel[ai]. Where to sample
** on the axis is controlled by info->min[ai] and info->max[ai]; these
** specify a range of "positions" aka "world space" positions, as
** determined by the per-axis min and max of the input nrrd, which must
** be set for every resampled axis.
**
** we cyclically permute those axes being resampled, and never touch
** the position (in axis ordering) of axes along which we are not
** resampling. This strategy is certainly not the most intelligent
** one possible, but it does mean that the axis along which we're
** currently resampling-- the one along which we'll have to look at
** multiple adjecent samples-- is that resampling axis which is
** currently most contiguous in memory. It may make sense to precede
** the resampling with an axis permutation which bubbles all the
** resampled axes to the front (most contiguous) end of the axis list,
** and then puts them back in place afterwards, depending on the cost
** of such axis permutation overhead.
*/
int
nrrdSpatialResample(Nrrd *nout, const Nrrd *nin,
const NrrdResampleInfo *info) {
char me[]="nrrdSpatialResample", func[]="resample", err[BIFF_STRLEN];
nrrdResample_t
*array[NRRD_DIM_MAX], /* intermediate copies of the input data
undergoing resampling; we don't need a full-
fledged nrrd for these. Only about two of
these arrays will be allocated at a time;
intermediate results will be free()d when not
needed */
*_inVec, /* current input vector being resampled;
not necessarily contiguous in memory
(if strideIn != 1) */
*inVec, /* buffer for input vector; contiguous */
*_outVec; /* output vector in context of volume;
never contiguous */
double tmpF;
double ratio, /* factor by which or up or downsampled */
ratios[NRRD_DIM_MAX]; /* record of "ratio" for all resampled axes,
used to compute new spacing in output */
Nrrd *floatNin; /* if the input nrrd type is not nrrdResample_t,
then we convert it and keep it here */
unsigned int ai,
pi, /* current pass */
topLax,
permute[NRRD_DIM_MAX], /* how to permute axes of last pass to get
axes for current pass */
ax[NRRD_DIM_MAX+1][NRRD_DIM_MAX], /* axis ordering on each pass */
passes; /* # of passes needed to resample all axes */
int i, s, e,
topRax, /* the lowest index of an axis which is
resampled. If all axes are being resampled,
then this is 0. If for some reason the
"x" axis (fastest stride) is not being
resampled, but "y" is, then topRax is 1 */
botRax, /* index of highest axis being resampled */
typeIn, typeOut; /* types of input and output of resampling */
size_t sz[NRRD_DIM_MAX+1][NRRD_DIM_MAX];
/* how many samples along each
axis, changing on each pass */
/* all these variables have to do with the spacing of elements in
memory for the current pass of resampling, and they (except
strideIn) are re-set at the beginning of each pass */
nrrdResample_t
*weight; /* sample weights */
unsigned int ci[NRRD_DIM_MAX+1],
co[NRRD_DIM_MAX+1];
int
sizeIn, sizeOut, /* lengths of input and output vectors */
dotLen, /* # input samples to dot with weights to get
one output sample */
doRound, /* actually do rounding on output: we DO NOT
round when info->round but the output
type is not integral */
*index; /* dotLen*sizeOut 2D array of input indices */
size_t
I, /* swiss-army int */
strideIn, /* the stride between samples in the input
"scanline" being resampled */
strideOut, /* stride between samples in output
"scanline" from resampling */
L, LI, LO, numLines, /* top secret */
numOut; /* # of _samples_, total, in output volume;
this is for allocating the output */
airArray *mop; /* for cleaning up */
if (!(nout && nin && info)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdBoundaryUnknown == info->boundary) {
sprintf(err, "%s: need to specify a boundary behavior", me);
biffAdd(NRRD, err); return 1;
}
typeIn = nin->type;
typeOut = nrrdTypeDefault == info->type ? typeIn : info->type;
if (_nrrdResampleCheckInfo(nin, info)) {
sprintf(err, "%s: problem with arguments", me);
biffAdd(NRRD, err); return 1;
}
_nrrdResampleComputePermute(permute, ax, sz,
&topRax, &botRax, &passes,
nin, info);
topLax = topRax ? 0 : 1;
/* not sure where else to put this:
(want to put it before 0 == passes branch)
We have to assume some centering when doing resampling, and it would
be stupid to not record it in the outgoing nrrd, since the value of
nrrdDefaultCenter could always change. */
for (ai=0; ai<nin->dim; ai++) {
if (info->kernel[ai]) {
nout->axis[ai].center = _nrrdCenter(nin->axis[ai].center);
}
}
if (0 == passes) {
/* actually, no resampling was desired. Copy input to output,
but with the clamping that we normally do at the end of resampling */
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, sz[0]);
if (nrrdMaybeAlloc_nva(nout, typeOut, nin->dim, sz[0])) {
sprintf(err, "%s: couldn't allocate output", me);
biffAdd(NRRD, err); return 1;
}
numOut = nrrdElementNumber(nout);
for (I=0; I<numOut; I++) {
tmpF = nrrdDLookup[nin->type](nin->data, I);
tmpF = nrrdDClamp[typeOut](tmpF);
nrrdDInsert[typeOut](nout->data, I, tmpF);
}
nrrdAxisInfoCopy(nout, nin, NULL, NRRD_AXIS_INFO_NONE);
/* HEY: need to create textual representation of resampling parameters */
if (nrrdContentSet_va(nout, func, nin, "")) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdBasicInfoCopy(nout, nin,
NRRD_BASIC_INFO_DATA_BIT
| NRRD_BASIC_INFO_TYPE_BIT
| NRRD_BASIC_INFO_BLOCKSIZE_BIT
| NRRD_BASIC_INFO_DIMENSION_BIT
| NRRD_BASIC_INFO_CONTENT_BIT
| NRRD_BASIC_INFO_COMMENTS_BIT
| (nrrdStateKeyValuePairsPropagate
? 0
: NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT))) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
return 0;
}
mop = airMopNew();
/* convert input nrrd to nrrdResample_t if necessary */
if (nrrdResample_nrrdType != typeIn) {
if (nrrdConvert(floatNin = nrrdNew(), nin, nrrdResample_nrrdType)) {
sprintf(err, "%s: couldn't create float copy of input", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
array[0] = (nrrdResample_t*)floatNin->data;
airMopAdd(mop, floatNin, (airMopper)nrrdNuke, airMopAlways);
} else {
floatNin = NULL;
array[0] = (nrrdResample_t*)nin->data;
}
/* compute strideIn; this is actually the same for every pass
because (strictly speaking) in every pass we are resampling
the same axis, and axes with lower indices are constant length */
strideIn = 1;
for (ai=0; ai<(unsigned int)topRax; ai++) { /* HEY scrutinize casts */
strideIn *= nin->axis[ai].size;
}
/*
printf("%s: strideIn = " _AIR_SIZE_T_CNV "\n", me, strideIn);
*/
/* go! */
for (pi=0; pi<passes; pi++) {
/*
printf("%s: --- pass %d --- \n", me, pi);
*/
numLines = strideOut = 1;
for (ai=0; ai<nin->dim; ai++) {
if (ai < (unsigned int)botRax) { /* HEY scrutinize cast */
strideOut *= sz[pi+1][ai];
}
if (ai != (unsigned int)topRax) { /* HEY scrutinize cast */
numLines *= sz[pi][ai];
}
}
sizeIn = sz[pi][topRax];
sizeOut = sz[pi+1][botRax];
numOut = numLines*sizeOut;
/* for the rest of the loop body, d is the original "dimension"
for the axis being resampled */
ai = ax[pi][topRax];
/*
printf("%s(%d): numOut = " _AIR_SIZE_T_CNV "\n", me, pi, numOut);
printf("%s(%d): numLines = " _AIR_SIZE_T_CNV "\n", me, pi, numLines);
printf("%s(%d): stride: In=%d, Out=%d\n", me, pi,
(int)strideIn, (int)strideOut);
printf("%s(%d): sizeIn = %d\n", me, pi, sizeIn);
printf("%s(%d): sizeOut = %d\n", me, pi, sizeOut);
*/
/* we can free the input to the previous pass
(if its not the given data) */
if (pi > 0) {
if (pi == 1) {
if (array[0] != nin->data) {
airMopSub(mop, floatNin, (airMopper)nrrdNuke);
floatNin = nrrdNuke(floatNin);
array[0] = NULL;
/*
printf("%s: pi %d: freeing array[0]\n", me, pi);
*/
}
} else {
airMopSub(mop, array[pi-1], airFree);
array[pi-1] = (nrrdResample_t*)airFree(array[pi-1]);
/*
printf("%s: pi %d: freeing array[%d]\n", me, pi, pi-1);
*/
}
}
/* allocate output volume */
array[pi+1] = (nrrdResample_t*)calloc(numOut, sizeof(nrrdResample_t));
if (!array[pi+1]) {
sprintf(err, "%s: couldn't create array of " _AIR_SIZE_T_CNV
" nrrdResample_t's for output of pass %d",
me, numOut, pi);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
airMopAdd(mop, array[pi+1], airFree, airMopAlways);
/*
printf("%s: allocated array[%d]\n", me, pi+1);
*/
/* allocate contiguous input scanline buffer, we alloc one more
than needed to provide a place for the pad value. That is, in
fact, the over-riding reason to copy a scanline to a local
array: so that there is a simple consistent (non-branchy) way
to incorporate the pad values */
inVec = (nrrdResample_t *)calloc(sizeIn+1, sizeof(nrrdResample_t));
airMopAdd(mop, inVec, airFree, airMopAlways);
inVec[sizeIn] = AIR_CAST(nrrdResample_t, info->padValue);
dotLen = _nrrdResampleMakeWeightIndex(&weight, &index, &ratio,
nin, info, ai);
if (!dotLen) {
sprintf(err, "%s: trouble creating weight and index vector arrays", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
ratios[ai] = ratio;
airMopAdd(mop, weight, airFree, airMopAlways);
airMopAdd(mop, index, airFree, airMopAlways);
/* the skinny: resample all the scanlines */
_inVec = array[pi];
_outVec = array[pi+1];
memset(ci, 0, (NRRD_DIM_MAX+1)*sizeof(int));
memset(co, 0, (NRRD_DIM_MAX+1)*sizeof(int));
for (L=0; L<numLines; L++) {
/* calculate the index to get to input and output scanlines,
according the coordinates of the start of the scanline */
NRRD_INDEX_GEN(LI, ci, sz[pi], nin->dim);
NRRD_INDEX_GEN(LO, co, sz[pi+1], nin->dim);
_inVec = array[pi] + LI;
_outVec = array[pi+1] + LO;
/* read input scanline into contiguous array */
for (i=0; i<sizeIn; i++) {
inVec[i] = _inVec[i*strideIn];
}
/* do the weighting */
for (i=0; i<sizeOut; i++) {
tmpF = 0.0;
/*
fprintf(stderr, "%s: i = %d (tmpF=0)\n", me, (int)i);
*/
for (s=0; s<dotLen; s++) {
tmpF += inVec[index[s + dotLen*i]]*weight[s + dotLen*i];
/*
fprintf(stderr, " tmpF += %g*%g == %g\n",
inVec[index[s + dotLen*i]], weight[s + dotLen*i], tmpF);
*/
}
_outVec[i*strideOut] = tmpF;
/*
fprintf(stderr, "--> out[%d] = %g\n",
i*strideOut, _outVec[i*strideOut]);
*/
}
/* update the coordinates for the scanline starts. We don't
use the usual NRRD_COORD macros because we're subject to
the unusual constraint that ci[topRax] and co[permute[topRax]]
must stay exactly zero */
e = topLax;
ci[e]++;
co[permute[e]]++;
while (L < numLines-1 && ci[e] == sz[pi][e]) {
ci[e] = co[permute[e]] = 0;
e++;
e += e == topRax;
ci[e]++;
co[permute[e]]++;
}
}
/* pass-specific clean up */
airMopSub(mop, weight, airFree);
airMopSub(mop, index, airFree);
airMopSub(mop, inVec, airFree);
weight = (nrrdResample_t*)airFree(weight);
index = (int*)airFree(index);
inVec = (nrrdResample_t*)airFree(inVec);
}
/* clean up second-to-last array and scanline buffers */
if (passes > 1) {
airMopSub(mop, array[passes-1], airFree);
array[passes-1] = (nrrdResample_t*)airFree(array[passes-1]);
/*
printf("%s: now freeing array[%d]\n", me, passes-1);
*/
} else if (array[passes-1] != nin->data) {
airMopSub(mop, floatNin, (airMopper)nrrdNuke);
floatNin = nrrdNuke(floatNin);
}
array[passes-1] = NULL;
/* create output nrrd and set axis info */
if (nrrdMaybeAlloc_nva(nout, typeOut, nin->dim, sz[passes])) {
sprintf(err, "%s: couldn't allocate final output nrrd", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopOnError);
nrrdAxisInfoCopy(nout, nin, NULL,
(NRRD_AXIS_INFO_SIZE_BIT
| NRRD_AXIS_INFO_MIN_BIT
| NRRD_AXIS_INFO_MAX_BIT
| NRRD_AXIS_INFO_SPACING_BIT
| NRRD_AXIS_INFO_SPACEDIRECTION_BIT /* see below */
| NRRD_AXIS_INFO_THICKNESS_BIT
| NRRD_AXIS_INFO_KIND_BIT));
for (ai=0; ai<nin->dim; ai++) {
if (info->kernel[ai]) {
/* we do resample this axis */
nout->axis[ai].spacing = nin->axis[ai].spacing/ratios[ai];
/* no way to usefully update thickness: we could be doing blurring
but maintaining the number of samples: thickness increases, or
we could be downsampling, in which the relationship between the
sampled and the skipped regions of space becomes complicated:
no single scalar can represent it, or we could be upsampling,
in which the notion of "skip" could be rendered meaningless */
nout->axis[ai].thickness = AIR_NAN;
nout->axis[ai].min = info->min[ai];
nout->axis[ai].max = info->max[ai];
/*
HEY: this is currently a bug: all this code was written long
before there were space directions, so min/max are always
set, regardless of whethere there are incoming space directions
which then disallows output space directions on the same axes
_nrrdSpaceVecScale(nout->axis[ai].spaceDirection,
1.0/ratios[ai], nin->axis[ai].spaceDirection);
*/
nout->axis[ai].kind = _nrrdKindAltered(nin->axis[ai].kind, AIR_TRUE);
} else {
/* this axis remains untouched */
nout->axis[ai].min = nin->axis[ai].min;
nout->axis[ai].max = nin->axis[ai].max;
nout->axis[ai].spacing = nin->axis[ai].spacing;
nout->axis[ai].thickness = nin->axis[ai].thickness;
nout->axis[ai].kind = nin->axis[ai].kind;
}
}
/* HEY: need to create textual representation of resampling parameters */
if (nrrdContentSet_va(nout, func, nin, "")) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
/* copy the resampling final result into the output nrrd, maybe
rounding as we go to make sure that 254.9999 is saved as 255
in uchar output, and maybe clamping as we go to insure that
integral results don't have unexpected wrap-around. */
if (info->round) {
if (nrrdTypeInt == typeOut ||
nrrdTypeUInt == typeOut ||
nrrdTypeLLong == typeOut ||
nrrdTypeULLong == typeOut) {
fprintf(stderr, "%s: WARNING: possible erroneous output with "
"rounding of %s output type due to int-based implementation "
"of rounding\n", me, airEnumStr(nrrdType, typeOut));
}
doRound = nrrdTypeIsIntegral[typeOut];
} else {
doRound = AIR_FALSE;
}
numOut = nrrdElementNumber(nout);
for (I=0; I<numOut; I++) {
tmpF = array[passes][I];
if (doRound) {
tmpF = AIR_CAST(nrrdResample_t, AIR_ROUNDUP(tmpF));
}
if (info->clamp) {
tmpF = nrrdDClamp[typeOut](tmpF);
}
nrrdDInsert[typeOut](nout->data, I, tmpF);
}
if (nrrdBasicInfoCopy(nout, nin,
NRRD_BASIC_INFO_DATA_BIT
| NRRD_BASIC_INFO_TYPE_BIT
| NRRD_BASIC_INFO_BLOCKSIZE_BIT
| NRRD_BASIC_INFO_DIMENSION_BIT
| NRRD_BASIC_INFO_CONTENT_BIT
| NRRD_BASIC_INFO_COMMENTS_BIT
| (nrrdStateKeyValuePairsPropagate
? 0
: NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT))) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
/* enough already */
airMopOkay(mop);
return 0;
}
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));
}
