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;
}
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;
}
