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;
}
int
unrrdu_joinMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err, *label;
Nrrd **nin;
Nrrd *nout;
int incrDim, pret;
unsigned int ninLen, axis;
double mm[2], spc;
airArray *mop;
hparm->respFileEnable = AIR_TRUE;
hestOptAdd(&opt, "i,input", "nin0", airTypeOther, 1, -1, &nin, NULL,
"everything to be joined together",
&ninLen, NULL, nrrdHestNrrd);
OPT_ADD_AXIS(axis, "axis to join along");
hestOptAdd(&opt, "incr", NULL, airTypeInt, 0, 0, &incrDim, NULL,
"in situations where the join axis is *not* among the existing "
"axes of the input nrrds, then this flag signifies that the join "
"axis should be *inserted*, and the output dimension should "
"be one greater than input dimension. Without this flag, the "
"nrrds are joined side-by-side, along an existing axis.");
hestOptAdd(&opt, "l,label", "label", airTypeString, 1, 1, &label, "",
"label to associate with join axis");
hestOptAdd(&opt, "mm,minmax", "min max", airTypeDouble, 2, 2, mm, "nan nan",
"min and max values along join axis");
hestOptAdd(&opt, "sp,spacing", "spc", airTypeDouble, 1, 1, &spc, "nan",
"spacing between samples along join axis");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_joinInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdJoin(nout, (const Nrrd**)nin, ninLen, axis, incrDim)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error joining nrrds:\n%s", me, err);
airMopError(mop);
return 1;
}
if (strlen(label)) {
nout->axis[axis].label = (char *)airFree(nout->axis[axis].label);
nout->axis[axis].label = airStrdup(label);
}
if (AIR_EXISTS(mm[0])) {
nout->axis[axis].min = mm[0];
}
if (AIR_EXISTS(mm[1])) {
nout->axis[axis].max = mm[1];
}
if (AIR_EXISTS(spc)) {
nout->axis[axis].spacing = spc;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_mlutMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, **_nmlut, *nmlut, *nout;
airArray *mop;
int typeOut, rescale, pret, blind8BitRange;
unsigned int _nmlutLen, mapAxis;
double min, max;
NrrdRange *range=NULL;
hestOptAdd(&opt, "m,map", "mlut", airTypeOther, 1, -1, &_nmlut, NULL,
"one nrrd of lookup tables to map input nrrd through, or, "
"list of nrrds which contain the individual entries of "
"the lookup table at each voxel, which will be joined together.",
&_nmlutLen, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "r,rescale", NULL, airTypeInt, 0, 0, &rescale, NULL,
"rescale the input values from the input range to the "
"lut domain. The lut domain is either explicitly "
"defined by the axis min,max along axis 0 or 1, or, it "
"is implicitly defined as zero to the length of that axis "
"minus one.");
hestOptAdd(&opt, "min,minimum", "value", airTypeDouble, 1, 1, &min, "nan",
"Low end of input range. Defaults to lowest value "
"found in input nrrd. Explicitly setting this is useful "
"only with rescaling (\"-r\")");
hestOptAdd(&opt, "max,maximum", "value", airTypeDouble, 1, 1, &max, "nan",
"High end of input range. Defaults to highest value "
"found in input nrrd. Explicitly setting this is useful "
"only with rescaling (\"-r\")");
hestOptAdd(&opt, "blind8", "bool", airTypeBool, 1, 1, &blind8BitRange,
nrrdStateBlind8BitRange ? "true" : "false",
"Whether to know the range of 8-bit data blindly "
"(uchar is always [0,255], signed char is [-128,127]). "
"Explicitly setting this is useful only with rescaling (\"-r\")");
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &typeOut, "default",
"specify the type (\"int\", \"float\", etc.) of the "
"output nrrd. "
"By default (not using this option), the output type "
"is the lut's type.",
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_mlutInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/* by the end of this block we need to have nmlut and mapAxis */
if (1 == _nmlutLen) {
/* we got the mlut as a single nrrd */
nmlut = _nmlut[0];
mapAxis = nmlut->dim - nin->dim - 1;
/* its not our job to do real error checking ... */
mapAxis = AIR_MIN(mapAxis, nmlut->dim - 1);
} else {
/* we have to join together multiple nrrds to get the mlut */
nmlut = nrrdNew();
airMopAdd(mop, nmlut, (airMopper)nrrdNuke, airMopAlways);
/* assume that mlut component nrrds are all compatible sizes,
nrrdJoin will fail if they aren't */
mapAxis = _nmlut[0]->dim - nin->dim;
if (nrrdJoin(nmlut, (const Nrrd**)_nmlut, _nmlutLen, mapAxis, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble joining mlut:\n%s", me, err);
airMopError(mop);
return 1;
}
/* set these if they were given, they'll be NaN otherwise */
nmlut->axis[mapAxis].min = min;
nmlut->axis[mapAxis].max = max;
}
if (!( AIR_EXISTS(nmlut->axis[mapAxis].min) &&
AIR_EXISTS(nmlut->axis[mapAxis].max) )) {
rescale = AIR_TRUE;
}
if (rescale) {
range = nrrdRangeNew(min, max);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nrrdRangeSafeSet(range, nin, blind8BitRange);
}
if (nrrdTypeDefault == typeOut) {
typeOut = nmlut->type;
}
if (nrrdApplyMulti1DLut(nout, nin, range, nmlut, typeOut, rescale)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble applying multi-LUT:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_cmedianMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout, *ntmp, **mnout;
int pad, pret, mode, chan, ni, nsize;
unsigned int bins, radius;
airArray *mop;
float wght;
hestOptAdd(&opt, "r,radius", "radius", airTypeUInt, 1, 1, &radius, NULL,
"how big a window to filter over. \"-r 1\" leads to a "
"3x3 window in an image, and a 3x3x3 window in a volume");
hestOptAdd(&opt, "mode", NULL, airTypeInt, 0, 0, &mode, NULL,
"By default, median filtering is done. Using this option "
"enables mode filtering, in which the most common value is "
"used as output");
hestOptAdd(&opt, "b,bins", "num", airTypeUInt, 1, 1, &bins, "256",
"# of bins in histogram. It is in your interest to minimize "
"this number, since big histograms mean slower execution "
"times. 8-bit data needs at most 256 bins.");
hestOptAdd(&opt, "w,weight", "weight", airTypeFloat, 1, 1, &wght, "1.0",
"How much higher to preferentially weight samples that are "
"closer to the center of the window. \"1.0\" weight means that "
"all samples are uniformly weighted over the window, which "
"facilitates a simple speed-up. ");
hestOptAdd(&opt, "p,pad", NULL, airTypeInt, 0, 0, &pad, NULL,
"Pad the input (with boundary method \"bleed\"), "
"and crop the output, so as to "
"overcome our cheapness and correctly "
"handle the border. Obviously, this takes more memory.");
hestOptAdd(&opt, "c,channel", NULL, airTypeInt, 0, 0, &chan, NULL,
"Slice the input along axis 0, run filtering on all slices, "
"and join the results back together. This is the way you'd "
"want to process color (multi-channel) images or volumes.");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_cmedianInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (chan) {
nsize = nin->axis[0].size;
mnout = (Nrrd **)calloc(nsize, sizeof(Nrrd));
airMopAdd(mop, mnout, airFree, airMopAlways);
ntmp = nrrdNew();
airMopAdd(mop, ntmp, (airMopper)nrrdNuke, airMopAlways);
for (ni=0; ni<nsize; ni++) {
if (nrrdSlice(ntmp, nin, 0, ni)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error slicing input at pos = %d:\n%s",
me, ni, err);
airMopError(mop);
return 1;
}
airMopAdd(mop, mnout[ni] = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
if (nrrdCheapMedian(mnout[ni], ntmp, pad, mode, radius, wght, bins)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing cheap median:\n%s", me, err);
airMopError(mop);
return 1;
}
}
if (nrrdJoin(nout, (const Nrrd**)mnout, nsize, 0, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing final join:\n%s", me, err);
airMopError(mop);
return 1;
}
} else {
if (nrrdCheapMedian(nout, nin, pad, mode, radius, wght, bins)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing cheap median:\n%s", me, err);
airMopError(mop);
return 1;
}
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
