int
ninspect_proj(Nrrd *nout, Nrrd *nin, int axis, int smart, float amount) {
static const char me[]="ninspect_proj";
airArray *mop;
Nrrd *ntmpA, *ntmpB, **nrgb;
int bins;
if (!(nout && nin)) {
biffAddf(NINSPECT, "%s: got NULL pointer", me);
return 1;
}
if (!( AIR_IN_CL(0, axis, 2) )) {
biffAddf(NINSPECT, "%s: given axis %d outside valid range [0,1,2]",
me, axis);
return 1;
}
/* allocate a bunch of nrrds to use as basically temp variables */
mop = airMopNew();
airMopAdd(mop, ntmpA = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ntmpB = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
/* HEY: this used to be nrgb[3], but its passing to nrrdJoin caused
"dereferencing type-punned pointer might break strict-aliasing rules"
warning; GLK not sure how else to fix it */
nrgb = AIR_CALLOC(3, Nrrd*);
airMopAdd(mop, nrgb, airFree, airMopAlways);
airMopAdd(mop, nrgb[0] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nrgb[1] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nrgb[2] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
/* these arguments to nrrdHistoEq will control its behavior */
bins = 3000; /* equalization will use a histogram with this many bins */
/* the following idiom is one way of handling the fact that any
non-trivial nrrd call can fail, and if it does, then any subsequent
nrrd calls should be avoided (to be perfectly safe), so that you can
get the error message from biff. Because of the left-to-right ordering
ensured for logical expressions, this will all be called in sequence
until one of them has a non-zero return. If he had exception handling,
we'd put all the nrrd calls in one "try" block. */
if (nrrdProject(ntmpA, nin, axis, nrrdMeasureSum, nrrdTypeDefault)
|| nrrdHistoEq(ntmpB, ntmpA, NULL, bins, smart, amount)
|| nrrdQuantize(nrgb[0], ntmpB, NULL, 8)
|| nrrdProject(ntmpA, nin, axis, nrrdMeasureVariance, nrrdTypeDefault)
|| nrrdHistoEq(ntmpB, ntmpA, NULL, bins, smart, amount)
|| nrrdQuantize(nrgb[1], ntmpB, NULL, 8)
|| nrrdProject(ntmpA, nin, axis, nrrdMeasureMax, nrrdTypeDefault)
|| nrrdQuantize(nrgb[2], ntmpA, NULL, 8)
|| nrrdJoin(nout, (const Nrrd*const*)nrgb, 3, 0, AIR_TRUE)) {
biffMovef(NINSPECT, NRRD, "%s: trouble with nrrd operations", me);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
/*
** hist[0]: hue vs sat
** hist[1]: hue vs val
*/
void
imageProc(Nrrd *nhproj[3], Nrrd *nhist[2], unsigned int sH,
float *rgb, unsigned int size0, unsigned int sXY,
unsigned int overSampleNum, float overSampleScale) {
unsigned int xyi, hi, si, vi, oi;
float rr, gg, bb, hh, ss, vv, *hist[2];
double rndA, rndB;
nrrdZeroSet(nhist[0]);
nrrdZeroSet(nhist[1]);
hist[0] = AIR_CAST(float *, nhist[0]->data);
hist[1] = AIR_CAST(float *, nhist[1]->data);
for (xyi=0; xyi<sXY; xyi++) {
rr = AIR_CLAMP(0, rgb[0], 255);
gg = AIR_CLAMP(0, rgb[1], 255);
bb = AIR_CLAMP(0, rgb[2], 255);
rr = AIR_AFFINE(-1, rr, 256, 0, 1);
gg = AIR_AFFINE(-1, gg, 256, 0, 1);
bb = AIR_AFFINE(-1, bb, 256, 0, 1);
dyeRGBtoHSV(&hh, &ss, &vv, rr, gg, bb);
si = airIndexClamp(0, ss, 1, sH);
vi = airIndexClamp(0, vv, 1, sH);
#define UPDATE_HIST(rnd) \
hi = airIndexClamp(0, hh + overSampleScale*(1-ss)*(rnd), 1, sH); \
hist[0][hi + sH*si] += 1.0/overSampleNum; \
hist[1][hi + sH*vi] += 1.0/overSampleNum
if (overSampleNum % 2 == 1) {
airNormalRand(&rndA, NULL);
UPDATE_HIST(rndA);
overSampleNum -= 1;
}
for (oi=0; oi<overSampleNum; oi+=2) {
airNormalRand(&rndA, &rndB);
UPDATE_HIST(rndA);
UPDATE_HIST(rndB);
}
rgb += size0;
}
nrrdProject(nhproj[0], nhist[0], 1, nrrdMeasureHistoMean, nrrdTypeFloat);
nrrdProject(nhproj[1], nhist[1], 1, nrrdMeasureHistoMean, nrrdTypeFloat);
nrrdProject(nhproj[2], nhist[1], 1, nrrdMeasureSum, nrrdTypeFloat);
}
int
unrrdu_projectMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
unsigned int axis;
int measr, pret, type;
airArray *mop;
OPT_ADD_AXIS(axis, "axis to project along");
hestOptAdd(&opt, "m,measure", "measr", airTypeEnum, 1, 1, &measr, NULL,
"How to \"measure\" a scanline, by summarizing all its values "
"with a single scalar. " NRRD_MEASURE_DESC,
NULL, nrrdMeasure);
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to use for output. By default (not using this option), "
"the output type is determined auto-magically",
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_projectInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdProject(nout, nin, axis, measr, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error projecting nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
baneRawScatterplots(Nrrd *nvg, Nrrd *nvh, Nrrd *hvol, int histEq) {
Nrrd *gA, *hA, *gB, *hB;
char me[]="baneRawScatterplots", err[BIFF_STRLEN];
int E;
if (!( nvg && nvh && hvol )) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(BANE, err); return 1;
}
if (baneHVolCheck(hvol)) {
sprintf(err, "%s: didn't get a valid histogram volume", me);
biffAdd(BANE, err); return 1;
}
gA = nrrdNew(); gB = nrrdNew();
hA = nrrdNew(); hB = nrrdNew();
/* create initial projections */
E = 0;
if (!E) E |= nrrdProject(gA, hvol, 1, nrrdMeasureSum, nrrdTypeDefault);
if (!E) E |= nrrdProject(hA, hvol, 0, nrrdMeasureSum, nrrdTypeDefault);
if (E) {
sprintf(err, "%s: trouble creating raw scatterplots", me);
biffMove(BANE, err, NRRD); return 1;
}
/* do histogram equalization on them */
if (histEq) {
if (!E) E |= nrrdHistoEq(gB, gA, NULL, baneStateHistEqBins,
baneStateHistEqSmart, 1.0);
if (!E) E |= nrrdHistoEq(hB, hA, NULL, baneStateHistEqBins,
baneStateHistEqSmart, 1.0);
} else {
if (!E) E |= nrrdCopy(gB, gA);
if (!E) E |= nrrdCopy(hB, hA);
}
if (E) {
sprintf(err, "%s: couldn't histogram equalize or copy", me);
biffMove(BANE, err, NRRD); return 1;
}
/* re-orient them so they look correct on the screen */
if (!E) E |= nrrdAxesSwap(gA, gB, 0, 1);
if (!E) E |= nrrdAxesSwap(hA, hB, 0, 1);
if (!E) E |= nrrdFlip(gB, gA, 1);
if (!E) E |= nrrdFlip(hB, hA, 1);
if (E) {
sprintf(err, "%s: couldn't re-orient scatterplots", me);
biffMove(BANE, err, NRRD); return 1;
}
if (!E) E |= nrrdCopy(nvg, gB);
if (!E) E |= nrrdCopy(nvh, hB);
if (E) {
sprintf(err, "%s: trouble saving results to given nrrds", me);
biffMove(BANE, err, NRRD); return 1;
}
nrrdNuke(gA); nrrdNuke(gB);
nrrdNuke(hA); nrrdNuke(hB);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
unsigned int sx, sy, sz, ss, ii, anisoTypeNum, anisoTypeIdx,
roiVoxNum, roiVoxIdx, statNum, statIdx;
float *ten, *roi, *aniso, eval[3], *stat;
Nrrd *nten, *_nroi, *nroi, *naniso, *nstat;
int *anisoType, *measr;
size_t anisoSize[2];
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "r,roi", "roi", airTypeOther, 1, 1, &_nroi, NULL,
"ROI volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "i,input", "volume", airTypeOther, 1, 1, &nten, "-",
"tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "a,aniso", "aniso", airTypeEnum, 1, -1, &anisoType, NULL,
"which anisotropy measures to measure",
&anisoTypeNum, tenAniso);
hestOptAdd(&hopt, "m,measr", "measr", airTypeEnum, 1, -1, &measr, NULL,
"which measures/statistics to calculate",
&statNum, nrrdMeasure);
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (tenTensorCheck(nten, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't get tensor input:\n%s\n", me, err);
airMopError(mop);
return 1;
}
nroi = nrrdNew();
airMopAdd(mop, nroi, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
if (nrrdConvert(nroi, _nroi, nrrdTypeFloat)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't convert ROI to float:\n%s\n", me, err);
airMopError(mop);
return 1;
}
sx = nten->axis[1].size;
sy = nten->axis[2].size;
sz = nten->axis[3].size;
if (!(3 == nroi->dim
&& sx == nroi->axis[0].size
&& sy == nroi->axis[1].size
&& sz == nroi->axis[2].size)) {
fprintf(stderr, "%s: ROI dimension or axis sizes don't match volume", me);
airMopError(mop);
return 1;
}
ss = sx*sy*sz;
ten = AIR_CAST(float*, nten->data);
roi = AIR_CAST(float*, nroi->data);
/* NOTE: for time being the statistics are not weighted, because
nrrdMeasureLine[]() can't take a weight vector... */
/* find number of voxels in ROI */
roiVoxNum = 0;
for (ii=0; ii<ss; ii++) {
roiVoxNum += (roi[ii] > 0);
}
/* fprintf(stderr, "%s: # voxels in ROI == %u\n", me, roiVoxNum); */
/* allocate anisotropy buffers */
naniso = nrrdNew();
airMopAdd(mop, naniso, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
anisoSize[0] = roiVoxNum;
anisoSize[1] = anisoTypeNum;
if (nrrdMaybeAlloc_nva(naniso, nrrdTypeFloat, 2, anisoSize)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate aniso:\n%s\n", me, err);
airMopError(mop);
return 1;
}
aniso = AIR_CAST(float *, naniso->data);
/* store all anisotropies in all ROI voxels */
roiVoxIdx = 0;
for (ii=0; ii<ss; ii++) {
if (roi[ii] > 0) {
tenEigensolve_f(eval, NULL, ten + 7*ii);
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
aniso[roiVoxIdx + roiVoxNum*anisoTypeIdx]
= tenAnisoEval_f(eval, anisoType[anisoTypeIdx]);
}
roiVoxIdx++;
}
}
printf("statistic:");
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
printf(" %s", airEnumStr(tenAniso, anisoType[anisoTypeIdx]));
}
printf("\n");
/* do per-anisotropy statistics */
nstat = nrrdNew();
airMopAdd(mop, nstat, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
for (statIdx=0; statIdx<statNum; statIdx++) {
printf("%s:", airEnumStr(nrrdMeasure, measr[statIdx]));
if (nrrdProject(nstat, naniso, 0, measr[statIdx], nrrdTypeFloat)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't measure:\n%s\n", me, err);
airMopError(mop);
return 1;
}
stat = AIR_CAST(float *, nstat->data);
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
printf(" %g", stat[anisoTypeIdx]);
}
printf("\n");
}
airMopOkay(mop);
return 0;
}
