int
tenFiberUpdate(tenFiberContext *tfx) {
char me[]="tenFiberUpdate", err[BIFF_STRLEN];
if (!tfx) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
if (tenFiberTypeUnknown == tfx->fiberType) {
sprintf(err, "%s: fiber type not set", me);
biffAdd(TEN, err); return 1;
}
if (!( AIR_IN_OP(tenFiberTypeUnknown, tfx->fiberType, tenFiberTypeLast) )) {
sprintf(err, "%s: tfx->fiberType set to bogus value (%d)", me,
tfx->fiberType);
biffAdd(TEN, err); return 1;
}
if (tenFiberIntgUnknown == tfx->intg) {
sprintf(err, "%s: integration type not set", me);
biffAdd(TEN, err); return 1;
}
if (!( AIR_IN_OP(tenFiberIntgUnknown, tfx->intg, tenFiberIntgLast) )) {
sprintf(err, "%s: tfx->intg set to bogus value (%d)", me, tfx->intg);
biffAdd(TEN, err); return 1;
}
if (0 == tfx->stop) {
sprintf(err, "%s: no fiber stopping criteria set", me);
biffAdd(TEN, err); return 1;
}
if (gageQuerySet(tfx->gtx, tfx->pvl, tfx->query)
|| gageUpdate(tfx->gtx)) {
sprintf(err, "%s: trouble with gage", me);
biffMove(TEN, err, GAGE); return 1;
}
if (tfx->useDwi) {
if (!(0 == tfx->ten2Which || 1 == tfx->ten2Which)) {
sprintf(err, "%s: ten2Which must be 0 or 1 (not %u)",
me, tfx->ten2Which);
biffAdd(TEN, err); return 1;
}
}
return 0;
}
int
miteRenderBegin(miteRender **mrrP, miteUser *muu) {
static const char me[]="miteRenderBegin";
gagePerVolume *pvl;
int E, T, pvlIdx;
gageQuery queryScl, queryVec, queryTen;
gageItemSpec isp;
unsigned int axi, thr;
if (!(mrrP && muu)) {
biffAddf(MITE, "%s: got NULL pointer", me);
return 1;
}
if (_miteUserCheck(muu)) {
biffAddf(MITE, "%s: problem with user-set parameters", me);
return 1;
}
if (!( *mrrP = _miteRenderNew() )) {
biffAddf(MITE, "%s: couldn't alloc miteRender", me);
return 1;
}
if (_miteNtxfAlphaAdjust(*mrrP, muu)) {
biffAddf(MITE, "%s: trouble copying and alpha-adjusting txfs", me);
return 1;
}
GAGE_QUERY_RESET(queryScl);
GAGE_QUERY_RESET(queryVec);
GAGE_QUERY_RESET(queryTen);
GAGE_QUERY_RESET((*mrrP)->queryMite);
for (T=0; T<muu->ntxfNum; T++) {
for (axi=1; axi<muu->ntxf[T]->dim; axi++) {
miteVariableParse(&isp, muu->ntxf[T]->axis[axi].label);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite, &isp);
}
}
miteVariableParse((*mrrP)->normalSpec, muu->normalStr);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->normalSpec);
miteShadeSpecParse((*mrrP)->shadeSpec, muu->shadeStr);
miteShadeSpecQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->shadeSpec);
(*mrrP)->queryMiteNonzero = GAGE_QUERY_NONZERO((*mrrP)->queryMite);
E = 0;
pvlIdx = 0;
if (muu->nsin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nsin, gageKindScl));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryScl);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->sclPvlIdx = pvlIdx++;
}
if (muu->nvin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nvin, gageKindVec));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryVec);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->vecPvlIdx = pvlIdx++;
}
if (muu->ntin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->ntin, tenGageKind));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryTen);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->tenPvlIdx = pvlIdx++;
}
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel00,
muu->ksp[gageKernel00]->kernel,
muu->ksp[gageKernel00]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel11,
muu->ksp[gageKernel11]->kernel,
muu->ksp[gageKernel11]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel22,
muu->ksp[gageKernel22]->kernel,
muu->ksp[gageKernel22]->parm);
if (!E) E |= gageUpdate(muu->gctx0);
if (E) {
biffMovef(MITE, GAGE, "%s: gage trouble", me);
return 1;
}
fprintf(stderr, "!%s: kernel support = %d^3 samples\n",
me, 2*muu->gctx0->radius);
if (nrrdMaybeAlloc_va(muu->nout, mite_nt, 3,
AIR_CAST(size_t, 5) /* RGBAZ */ ,
AIR_CAST(size_t, muu->hctx->imgSize[0]),
AIR_CAST(size_t, muu->hctx->imgSize[1]))) {
biffMovef(MITE, NRRD, "%s: nrrd trouble", me);
return 1;
}
muu->nout->axis[1].center = nrrdCenterCell;
muu->nout->axis[1].min = muu->hctx->cam->uRange[0];
muu->nout->axis[1].max = muu->hctx->cam->uRange[1];
muu->nout->axis[2].center = nrrdCenterCell;
muu->nout->axis[2].min = muu->hctx->cam->vRange[0];
muu->nout->axis[2].max = muu->hctx->cam->vRange[1];
for (thr=0; thr<muu->hctx->numThreads; thr++) {
(*mrrP)->tt[thr] = miteThreadNew();
if (!((*mrrP)->tt[thr])) {
biffAddf(MITE, "%s: couldn't allocate thread[%d]", me, thr);
return 1;
}
airMopAdd((*mrrP)->rmop, (*mrrP)->tt[thr],
(airMopper)miteThreadNix, airMopAlways);
}
(*mrrP)->time0 = airTime();
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
main(int argc, const char *argv[]) {
const char *me;
char *err, *outS;
hestOpt *hopt=NULL;
airArray *mop;
limnPolyData *pld, *pldSub;
gageContext *gctx=NULL;
gagePerVolume *pvl;
Nrrd *nin, *nmeas;
double kparm[3], strength, scaling[3];
seekContext *sctx;
FILE *file;
unsigned int ncc;
size_t samples[3];
gageKind *kind;
char *itemGradS; /* , *itemEvalS[2], *itemEvecS[2]; */
int itemGrad; /* , itemEval[2], itemEvec[2]; */
int E;
me = argv[0];
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume to analyze",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", \"tensor\")",
NULL, NULL, &probeKindHestCB);
hestOptAdd(&hopt, "s", "strength", airTypeDouble, 1, 1, &strength, "0.01",
"strength");
hestOptAdd(&hopt, "gi", "grad item", airTypeString, 1, 1, &itemGradS, NULL,
"item for gradient vector");
hestOptAdd(&hopt, "c", "scaling", airTypeDouble, 3, 3, scaling, "1 1 1",
"amount by which to up/down-sample on each spatial axis");
hestOptAdd(&hopt, "n", "# CC", airTypeUInt, 1, 1, &ncc, "0",
"if non-zero, number of CC to save");
hestOptAdd(&hopt, "o", "output LMPD", airTypeString, 1, 1, &outS, "out.lmpd",
"output file to save LMPD into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
itemGrad = airEnumVal(kind->enm, itemGradS);
pld = limnPolyDataNew();
airMopAdd(mop, pld, (airMopper)limnPolyDataNix, airMopAlways);
pldSub = limnPolyDataNew();
airMopAdd(mop, pldSub, (airMopper)limnPolyDataNix, airMopAlways);
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
sctx = seekContextNew();
airMopAdd(mop, sctx, (airMopper)seekContextNix, airMopAlways);
gctx = gageContextNew();
airMopAdd(mop, gctx, (airMopper)gageContextNix, airMopAlways);
ELL_3V_SET(kparm, 1, 1.0, 0.0);
if (!(pvl = gagePerVolumeNew(gctx, nin, kind))
|| gagePerVolumeAttach(gctx, pvl)
|| gageKernelSet(gctx, gageKernel00, nrrdKernelBCCubic, kparm)
|| gageKernelSet(gctx, gageKernel11, nrrdKernelBCCubicD, kparm)
|| gageKernelSet(gctx, gageKernel22, nrrdKernelBCCubicDD, kparm)
|| gageQueryItemOn(gctx, pvl, itemGrad)
|| gageQueryItemOn(gctx, pvl, gageSclHessEval)
|| gageQueryItemOn(gctx, pvl, gageSclHessEval2)
|| gageQueryItemOn(gctx, pvl, gageSclHessEvec)
|| gageQueryItemOn(gctx, pvl, gageSclHessEvec2)
|| gageUpdate(gctx)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
seekVerboseSet(sctx, 10);
E = 0;
if (!E) E |= seekDataSet(sctx, NULL, gctx, 0);
ELL_3V_SET(samples,
scaling[0]*nin->axis[kind->baseDim + 0].size,
scaling[1]*nin->axis[kind->baseDim + 1].size,
scaling[2]*nin->axis[kind->baseDim + 2].size);
if (!E) E |= seekSamplesSet(sctx, samples);
if (!E) E |= seekItemGradientSet(sctx, itemGrad);
if (!E) E |= seekItemEigensystemSet(sctx, gageSclHessEval,
gageSclHessEvec);
if (!E) E |= seekItemNormalSet(sctx, gageSclHessEvec2);
if (!E) E |= seekStrengthUseSet(sctx, AIR_TRUE);
if (!E) E |= seekStrengthSet(sctx, -1, strength);
if (!E) E |= seekItemStrengthSet(sctx, gageSclHessEval2);
if (!E) E |= seekNormalsFindSet(sctx, AIR_TRUE);
if (!E) E |= seekTypeSet(sctx, seekTypeRidgeSurface);
if (!E) E |= seekUpdate(sctx);
if (!E) E |= seekExtract(sctx, pld);
if (E) {
airMopAdd(mop, err = biffGetDone(SEEK), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
fprintf(stderr, "%s: extraction time = %g\n", me, sctx->time);
nmeas = nrrdNew();
airMopAdd(mop, nmeas, (airMopper)nrrdNuke, airMopAlways);
if (limnPolyDataVertexWindingFix(pld, AIR_TRUE)
|| limnPolyDataVertexWindingFlip(pld)
|| limnPolyDataVertexNormals(pld)
|| limnPolyDataCCFind(pld)
|| limnPolyDataPrimitiveArea(nmeas, pld)
|| limnPolyDataPrimitiveSort(pld, nmeas)) {
err = biffGetDone(LIMN);
fprintf(stderr, "%s: trouble sorting:\n%s", me, err);
free(err);
}
if (ncc > 1) {
double *meas;
unsigned int ccIdx;
nrrdSave("meas.nrrd", nmeas, NULL);
ncc = AIR_MIN(ncc, nmeas->axis[0].size);
meas = AIR_CAST(double *, nmeas->data);
for (ccIdx=ncc; ccIdx<nmeas->axis[0].size; ccIdx++) {
meas[ccIdx] = 0.0;
}
if (!E) E |= limnPolyDataPrimitiveSelect(pldSub, pld, nmeas);
if (!E) E |= limnPolyDataWriteLMPD(file, pldSub);
} else {
int
main(int argc, const char **argv) {
const char *me;
Nrrd *nscl;
double *dscl;
airArray *mop;
char *fullname;
gageContext *igctx[INTERP_KERN_NUM], *bgctx[BLUR_KERN_NUM];
const NrrdKernel *ikern[INTERP_KERN_NUM] = {
nrrdKernelBox,
nrrdKernelTent,
nrrdKernelBCCubic,
nrrdKernelCatmullRom,
};
double ikparm[INTERP_KERN_NUM][NRRD_KERNEL_PARMS_NUM] = {
{1.0},
{1.0},
{1.0, 0.0, 0.5},
{AIR_NAN},
};
const NrrdKernel *bkern[BLUR_KERN_NUM] = {
nrrdKernelTent,
nrrdKernelBSpline3,
nrrdKernelBSpline5,
nrrdKernelBCCubic,
nrrdKernelGaussian,
};
const NrrdKernel *bkernD[BLUR_KERN_NUM] = {
nrrdKernelForwDiff,
nrrdKernelBSpline3D,
nrrdKernelBSpline5D,
nrrdKernelBCCubicD,
nrrdKernelGaussianD,
};
const NrrdKernel *bkernDD[BLUR_KERN_NUM] = {
nrrdKernelZero,
nrrdKernelBSpline3DD,
nrrdKernelBSpline5DD,
nrrdKernelBCCubicDD,
nrrdKernelGaussianDD,
};
double bkparm[BLUR_KERN_NUM][NRRD_KERNEL_PARMS_NUM] = {
{1.0},
{AIR_NAN},
{AIR_NAN},
{2.0, 1.0, 0.0},
{1.2, 5.0},
};
const double *ivalAns[INTERP_KERN_NUM], *bvalAns[BLUR_KERN_NUM],
*bgrdAns[BLUR_KERN_NUM], *bhesAns[BLUR_KERN_NUM];
int E;
unsigned int sx, sy, sz, ki;
AIR_UNUSED(argc);
me = argv[0];
mop = airMopNew();
nscl = nrrdNew();
airMopAdd(mop, nscl, (airMopper)nrrdNuke, airMopAlways);
fullname = testDataPathPrefix("fmob-c4h.nrrd");
airMopAdd(mop, fullname, airFree, airMopAlways);
if (nrrdLoad(nscl, fullname, NULL)) {
char *err;
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble reading data \"%s\":\n%s",
me, fullname, err);
airMopError(mop); return 1;
}
/* make sure its a double-type volume (assumed below) */
if (nrrdTypeDouble != nscl->type) {
fprintf(stderr, "%s: volume type %s != expected type %s\n", me,
airEnumStr(nrrdType, nscl->type),
airEnumStr(nrrdType, nrrdTypeDouble));
airMopError(mop); return 1;
}
dscl = AIR_CAST(double *, nscl->data);
sx = AIR_CAST(unsigned int, nscl->axis[0].size);
sy = AIR_CAST(unsigned int, nscl->axis[1].size);
sz = AIR_CAST(unsigned int, nscl->axis[2].size);
for (ki=0; ki<INTERP_KERN_NUM; ki++) {
gagePerVolume *gpvl;
igctx[ki] = gageContextNew();
airMopAdd(mop, igctx[ki], (airMopper)gageContextNix, airMopAlways);
gageParmSet(igctx[ki], gageParmRenormalize, AIR_FALSE);
gageParmSet(igctx[ki], gageParmCheckIntegrals, AIR_TRUE);
gageParmSet(igctx[ki], gageParmOrientationFromSpacing, AIR_FALSE);
E = 0;
if (!E) E |= !(gpvl = gagePerVolumeNew(igctx[ki], nscl, gageKindScl));
if (!E) E |= gageKernelSet(igctx[ki], gageKernel00,
ikern[ki], ikparm[ki]);
if (!E) E |= gagePerVolumeAttach(igctx[ki], gpvl);
if (!E) E |= gageQueryItemOn(igctx[ki], gpvl, gageSclValue);
if (!E) E |= gageUpdate(igctx[ki]);
if (E) {
char *err;
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble %s set-up:\n%s\n", me,
ikern[ki]->name, err);
airMopError(mop); return 1;
}
ivalAns[ki] = gageAnswerPointer(igctx[ki], gpvl, gageSclValue);
}
/* traverse all samples of volume, probing with the interpolating
kernels, make sure we recover the original values */
{
unsigned int xi, yi, zi;
double pval[INTERP_KERN_NUM], err, rval;
int pret;
for (zi=0; zi<sz; zi++) {
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
rval = dscl[xi + sx*(yi + sy*zi)];
for (ki=0; ki<INTERP_KERN_NUM; ki++) {
pret = gageProbeSpace(igctx[ki], xi, yi, zi,
AIR_TRUE /* indexSpace */,
AIR_FALSE /* clamp */);
if (pret) {
fprintf(stderr, "%s: %s probe error(%d): %s\n", me,
ikern[ki]->name, igctx[ki]->errNum, igctx[ki]->errStr);
airMopError(mop); return 1;
}
pval[ki] = *ivalAns[ki];
err = AIR_ABS(rval - pval[ki]);
if (err) {
fprintf(stderr, "%s: interp's [%u,%u,%u] %s probe %f "
"!= true %f (err %f)\n", me, xi, yi, zi,
ikern[ki]->name, pval[ki], rval, err);
airMopError(mop); return 1;
}
}
}
}
}
}
/* set up contexts for non-interpolating (blurring) kernels,
and their first and second derivatives */
for (ki=0; ki<BLUR_KERN_NUM; ki++) {
gagePerVolume *gpvl;
bgctx[ki] = gageContextNew();
airMopAdd(mop, bgctx[ki], (airMopper)gageContextNix, airMopAlways);
gageParmSet(bgctx[ki], gageParmRenormalize, AIR_TRUE);
gageParmSet(bgctx[ki], gageParmCheckIntegrals, AIR_TRUE);
gageParmSet(bgctx[ki], gageParmOrientationFromSpacing, AIR_FALSE);
E = 0;
if (!E) E |= !(gpvl = gagePerVolumeNew(bgctx[ki], nscl, gageKindScl));
if (!E) E |= gageKernelSet(bgctx[ki], gageKernel00,
bkern[ki], bkparm[ki]);
if (!E) E |= gageKernelSet(bgctx[ki], gageKernel11,
bkernD[ki], bkparm[ki]);
if (!E) E |= gageKernelSet(bgctx[ki], gageKernel22,
bkernDD[ki], bkparm[ki]);
if (!E) E |= gagePerVolumeAttach(bgctx[ki], gpvl);
if (!E) E |= gageQueryItemOn(bgctx[ki], gpvl, gageSclValue);
if (!E) E |= gageQueryItemOn(bgctx[ki], gpvl, gageSclGradVec);
if (!E) E |= gageQueryItemOn(bgctx[ki], gpvl, gageSclHessian);
if (!E) E |= gageUpdate(bgctx[ki]);
if (E) {
char *err;
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble %s set-up:\n%s\n", me,
bkern[ki]->name, err);
airMopError(mop); return 1;
}
fprintf(stderr, "%s radius = %u\n", bkern[ki]->name, bgctx[ki]->radius);
bvalAns[ki] = gageAnswerPointer(bgctx[ki], gpvl, gageSclValue);
bgrdAns[ki] = gageAnswerPointer(bgctx[ki], gpvl, gageSclGradVec);
bhesAns[ki] = gageAnswerPointer(bgctx[ki], gpvl, gageSclHessian);
}
{
#define POS_NUM 12
double xp[POS_NUM], yp[POS_NUM], zp[POS_NUM],
pos[POS_NUM*POS_NUM*POS_NUM][3], *prbd,
offs[POS_NUM/2] = {0, 1.22222, 2.444444, 3.777777, 5.88888, 7.55555};
Nrrd *nprbd, *ncorr;
unsigned int ii, jj, kk, qlen = 1 + 3 + 9;
char *corrfn, explain[AIR_STRLEN_LARGE];
int pret, differ;
corrfn = testDataPathPrefix("test/probeSclAns.nrrd");
airMopAdd(mop, corrfn, airFree, airMopAlways);
ncorr = nrrdNew();
airMopAdd(mop, ncorr, (airMopper)nrrdNuke, airMopAlways);
if (nrrdLoad(ncorr, corrfn, NULL)) {
char *err;
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble reading data \"%s\":\n%s",
me, corrfn, err);
airMopError(mop); return 1;
}
for (ii=0; ii<POS_NUM/2; ii++) {
xp[ii] = yp[ii] = zp[ii] = offs[ii];
xp[POS_NUM-1-ii] = AIR_CAST(double, sx)-1.0-offs[ii];
yp[POS_NUM-1-ii] = AIR_CAST(double, sy)-1.0-offs[ii];
zp[POS_NUM-1-ii] = AIR_CAST(double, sz)-1.0-offs[ii];
}
for (kk=0; kk<POS_NUM; kk++) {
for (jj=0; jj<POS_NUM; jj++) {
for (ii=0; ii<POS_NUM; ii++) {
ELL_3V_SET(pos[ii + POS_NUM*(jj + POS_NUM*kk)],
xp[ii], yp[jj], zp[kk]);
}
}
}
nprbd = nrrdNew();
airMopAdd(mop, nprbd, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(nprbd, nrrdTypeDouble, 3,
AIR_CAST(size_t, qlen),
AIR_CAST(size_t, BLUR_KERN_NUM),
AIR_CAST(size_t, POS_NUM*POS_NUM*POS_NUM))) {
char *err;
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble setting up prbd:\n%s", me, err);
airMopError(mop); return 1;
}
prbd = AIR_CAST(double *, nprbd->data);
for (ii=0; ii<POS_NUM*POS_NUM*POS_NUM; ii++) {
for (ki=0; ki<BLUR_KERN_NUM; ki++) {
pret = gageProbeSpace(bgctx[ki], pos[ii][0], pos[ii][1], pos[ii][2],
AIR_TRUE /* indexSpace */,
AIR_FALSE /* clamp */);
if (pret) {
fprintf(stderr, "%s: %s probe error(%d): %s\n", me,
bkern[ki]->name, bgctx[ki]->errNum, bgctx[ki]->errStr);
airMopError(mop); return 1;
}
prbd[0 + qlen*(ki + BLUR_KERN_NUM*(ii))] = bvalAns[ki][0];
ELL_3V_COPY(prbd + 1 + qlen*(ki + BLUR_KERN_NUM*(ii)), bgrdAns[ki]);
ELL_9V_COPY(prbd + 4 + qlen*(ki + BLUR_KERN_NUM*(ii)), bhesAns[ki]);
}
}
/* HEY: weirdly, so far its only on Windows (and more than 10 times worse
on Cygwin) this epsilon needs to be larger than zero, and only for the
radius 6 Gaussian? */
if (nrrdCompare(ncorr, nprbd, AIR_FALSE /* onlyData */,
8.0e-14 /* epsilon */, &differ, explain)) {
char *err;
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble comparing:\n%s", me, err);
airMopError(mop); return 1;
}
if (differ) {
fprintf(stderr, "%s: probed values not correct: %s\n", me, explain);
airMopError(mop); return 1;
} else {
fprintf(stderr, "all good\n");
}
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *outS;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
char *err, done[13];
Nrrd *nin, *nblur, *nout;
NrrdKernelSpec *kb0, *kb1, *k00, *k11, *k22;
NrrdResampleContext *rsmc;
int E;
unsigned int sx, sy, sz, xi, yi, zi, ai;
gageContext *ctx;
gagePerVolume *pvl;
const double *gvec, *gmag, *evec0, *eval;
double (*ins)(void *v, size_t I, double d);
double (*lup)(const void *v, size_t I);
double dotmax, dotpow, gmmax, evalshift, gmpow, _dotmax, _gmmax, scl, clamp;
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "kb0", "kernel", airTypeOther, 1, 1, &kb0,
"guass:3,5", "kernel to use for pre-process blurring",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kb1", "kernel", airTypeOther, 1, 1, &kb1,
"cubic:1.5,1,0", "kernel to use for pos-process blurring",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k00", "kernel", airTypeOther, 1, 1, &k00,
"cubic:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kernel", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kernel", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "k00", NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "dotmax", "dot", airTypeDouble, 1, 1, &dotmax, "5",
"max effective value of dot(gvec, evec0)");
hestOptAdd(&hopt, "evs", "shift", airTypeDouble, 1, 1, &evalshift, "0",
"negative shift to avoid changing mostly flat regions");
hestOptAdd(&hopt, "clamp", "clamp", airTypeDouble, 1, 1, &clamp, "nan",
"if it exists, data value can't be forced below this");
hestOptAdd(&hopt, "dotpow", "pow", airTypeDouble, 1, 1, &dotpow, "1",
"exponent for dot");
hestOptAdd(&hopt, "gmmax", "dot", airTypeDouble, 1, 1, &gmmax, "2",
"max effective value of gmag");
hestOptAdd(&hopt, "gmpow", "pow", airTypeDouble, 1, 1, &gmpow, "1",
"exponent for gmag");
hestOptAdd(&hopt, "scl", "scale", airTypeDouble, 1, 1, &scl, "0.1",
"how much to scale hack to decrease input value");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"fixed volume output");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, vhInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (!( 3 == nin->dim
&& nrrdTypeBlock != nin->type )) {
fprintf(stderr, "%s: need a 3-D scalar nrrd (not %u-D %s)", me,
nin->dim, airEnumStr(nrrdType, nin->type));
airMopError(mop); return 1;
}
nblur = nrrdNew();
airMopAdd(mop, nblur, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nblur, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s", me, err);
airMopError(mop); return 1;
}
fprintf(stderr, "%s: pre-blurring ... ", me);
fflush(stderr);
rsmc = nrrdResampleContextNew();
airMopAdd(mop, rsmc, (airMopper)nrrdResampleContextNix, airMopAlways);
E = AIR_FALSE;
if (!E) E |= nrrdResampleDefaultCenterSet(rsmc, nrrdCenterCell);
if (!E) E |= nrrdResampleNrrdSet(rsmc, nin);
for (ai=0; ai<3; ai++) {
if (!E) E |= nrrdResampleKernelSet(rsmc, ai, kb0->kernel, kb0->parm);
if (!E) E |= nrrdResampleSamplesSet(rsmc, ai, nin->axis[ai].size);
if (!E) E |= nrrdResampleRangeFullSet(rsmc, ai);
}
if (!E) E |= nrrdResampleBoundarySet(rsmc, nrrdBoundaryBleed);
if (!E) E |= nrrdResampleTypeOutSet(rsmc, nrrdTypeDefault);
if (!E) E |= nrrdResampleRenormalizeSet(rsmc, AIR_TRUE);
if (!E) E |= nrrdResampleExecute(rsmc, nblur);
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error resampling nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "done.\n");
ctx = gageContextNew();
airMopAdd(mop, ctx, (airMopper)gageContextNix, airMopAlways);
gageParmSet(ctx, gageParmRenormalize, AIR_TRUE);
gageParmSet(ctx, gageParmCheckIntegrals, AIR_TRUE);
E = 0;
if (!E) E |= !(pvl = gagePerVolumeNew(ctx, nblur, gageKindScl));
if (!E) E |= gagePerVolumeAttach(ctx, pvl);
if (!E) E |= gageKernelSet(ctx, gageKernel00, k00->kernel, k00->parm);
if (!E) E |= gageKernelSet(ctx, gageKernel11, k11->kernel, k11->parm);
if (!E) E |= gageKernelSet(ctx, gageKernel22, k22->kernel, k22->parm);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclGradVec);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclGradMag);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclHessEvec0);
if (!E) E |= gageQueryItemOn(ctx, pvl, gageSclHessEval);
if (!E) E |= gageUpdate(ctx);
if (E) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
gvec = gageAnswerPointer(ctx, pvl, gageSclGradVec);
gmag = gageAnswerPointer(ctx, pvl, gageSclGradMag);
evec0 = gageAnswerPointer(ctx, pvl, gageSclHessEvec0);
eval = gageAnswerPointer(ctx, pvl, gageSclHessEval);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s", me, err);
airMopError(mop); return 1;
}
if (!(nout->type == nin->type && nblur->type == nin->type)) {
fprintf(stderr, "%s: whoa, types (%s %s %s) not all equal\n", me,
airEnumStr(nrrdType, nin->type),
airEnumStr(nrrdType, nblur->type),
airEnumStr(nrrdType, nout->type));
}
ins = nrrdDInsert[nout->type];
lup = nrrdDLookup[nout->type];
sx = nin->axis[0].size;
sy = nin->axis[1].size;
sz = nin->axis[2].size;
gageProbe(ctx, 0, 0, 0);
_dotmax = ELL_3V_DOT(gvec, evec0);
_gmmax = *gmag;
fprintf(stderr, "%s: hacking ", me);
fflush(stderr);
for (zi=0; zi<sz; zi++) {
fprintf(stderr, "%s", airDoneStr(0, zi, sz-1, done));
fflush(stderr);
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
size_t si;
double dot, evl, gm, shift, in, out, mode;
gageProbe(ctx, xi, yi, zi);
si = xi + sx*(yi + sy*zi);
dot = ELL_3V_DOT(gvec, evec0);
_dotmax = AIR_MAX(_dotmax, dot);
dot = AIR_ABS(dot);
dot = 1 - AIR_MIN(dot, dotmax)/dotmax;
dot = pow(dot, dotpow);
evl = AIR_MAX(0, eval[0] - evalshift);
mode = airMode3_d(eval);
evl *= AIR_AFFINE(-1, mode, 1, 0, 1);
_gmmax = AIR_MAX(_gmmax, *gmag);
gm = 1 - AIR_MIN(*gmag, gmmax)/gmmax;
gm = pow(gm, gmpow);
shift = scl*gm*evl*dot;
if (AIR_EXISTS(clamp)) {
in = lup(nin->data, si);
out = in - shift;
out = AIR_MAX(out, clamp);
shift = AIR_MAX(0, in - out);
}
ins(nout->data, si, shift);
}
}
}
fprintf(stderr, "\n");
fprintf(stderr, "%s: max dot seen: %g\n", me, _dotmax);
fprintf(stderr, "%s: max gm seen: %g\n", me, _gmmax);
fprintf(stderr, "%s: post-blurring ... ", me);
fflush(stderr);
E = AIR_FALSE;
if (!E) E |= nrrdResampleNrrdSet(rsmc, nout);
for (ai=0; ai<3; ai++) {
if (!E) E |= nrrdResampleKernelSet(rsmc, ai, kb1->kernel, kb1->parm);
if (!E) E |= nrrdResampleSamplesSet(rsmc, ai, nout->axis[ai].size);
if (!E) E |= nrrdResampleRangeFullSet(rsmc, ai);
}
if (!E) E |= nrrdResampleExecute(rsmc, nblur);
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error resampling nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "done.\n");
for (zi=0; zi<sz; zi++) {
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
size_t si;
double in, shift;
si = xi + sx*(yi + sy*zi);
in = lup(nin->data, si);
shift = lup(nblur->data, si);
ins(nout->data, si, in - shift);
}
}
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
exit(0);
}
