int
unrrdu_histaxMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int type, bins, pret, blind8BitRange;
unsigned int axis;
double min, max;
airArray *mop;
NrrdRange *range;
OPT_ADD_AXIS(axis, "axis to histogram along");
hestOptAdd(&opt, "b,bin", "bins", airTypeInt, 1, 1, &bins, NULL,
"# of bins in histogram");
OPT_ADD_TYPE(type, "output type", "uchar");
hestOptAdd(&opt, "min,minimum", "value", airTypeDouble, 1, 1, &min, "nan",
"Value at low end of histogram. Defaults to lowest value "
"found in input nrrd.");
hestOptAdd(&opt, "max,maximum", "value", airTypeDouble, 1, 1, &max, "nan",
"Value at high end of histogram. Defaults to highest value "
"found in input nrrd.");
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]).");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_histaxInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
range = nrrdRangeNew(min, max);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nrrdRangeSafeSet(range, nin, blind8BitRange);
if (nrrdHistoAxis(nout, nin, range, axis, bins, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing axis histogramming:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
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;
}
int
unrrdu_unblockMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int type, pret;
size_t blockSize;
airArray *mop;
OPT_ADD_TYPE(type, "type to unblock to", NULL);
hestOptAdd(&opt, "bs", "blocksize", airTypeSize_t, 1, 1, &blockSize, "0",
"Useful only if *output* type is also block: the size of "
"blocks in output nrrd");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_unblockInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
nout->blockSize = blockSize;
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdUnblock(nout, nin, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error unblocking nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_histaxMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
char *minStr, *maxStr;
int type, pret, blind8BitRange;
unsigned int axis, bins;
airArray *mop;
NrrdRange *range;
OPT_ADD_AXIS(axis, "axis to histogram along");
hestOptAdd(&opt, "b,bin", "bins", airTypeUInt, 1, 1, &bins, NULL,
"# of bins in histogram");
OPT_ADD_TYPE(type, "output type", "uchar");
/* HEY copy and paste from unrrdu/quantize.c */
hestOptAdd(&opt, "min,minimum", "value", airTypeString, 1, 1,
&minStr, "nan",
"The value to map to zero, given explicitly as a regular number, "
"*or*, if the number is given with a \"" NRRD_MINMAX_PERC_SUFF
"\" suffix, this "
"minimum is specified in terms of the percentage of samples in "
"input that are lower. "
"\"0" NRRD_MINMAX_PERC_SUFF "\" means the "
"lowest input value is used, "
"\"1" NRRD_MINMAX_PERC_SUFF "\" means that the "
"1% of the lowest values are all mapped to zero. "
"By default (not using this option), the lowest input value is "
"used.");
hestOptAdd(&opt, "max,maximum", "value", airTypeString, 1, 1,
&maxStr, "nan",
"The value to map to the highest unsigned integral value, given "
"explicitly as a regular number, "
"*or*, if the number is given with "
"a \"" NRRD_MINMAX_PERC_SUFF "\" suffix, "
"this maximum is specified "
"in terms of the percentage of samples in input that are higher. "
"\"0" NRRD_MINMAX_PERC_SUFF "\" means the highest input value is "
"used, which is also the default "
"behavior (same as not using this option).");
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]).");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_histaxInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
range = nrrdRangeNew(AIR_NAN, AIR_NAN);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdRangePercentileFromStringSet(range, nin, minStr, maxStr,
10*bins /* HEY magic */,
blind8BitRange)
|| nrrdHistoAxis(nout, nin, range, axis, bins, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing axis histogramming:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_histoMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout, *nwght;
char *minStr, *maxStr;
int type, pret, blind8BitRange;
unsigned int bins;
NrrdRange *range;
airArray *mop;
hestOptAdd(&opt, "b,bins", "num", airTypeUInt, 1, 1, &bins, NULL,
"# of bins in histogram");
hestOptAdd(&opt, "w,weight", "nweight", airTypeOther, 1, 1, &nwght, "",
"how to weigh contributions to histogram. By default "
"(not using this option), the increment is one bin count per "
"sample, but by giving a nrrd, the value in the nrrd at the "
"corresponding location will be the bin count increment ",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "min,minimum", "value", airTypeString, 1, 1,
&minStr, "nan",
"Value at low end of histogram, given explicitly as a "
"regular number, "
"*or*, if the number is given with a \"" NRRD_MINMAX_PERC_SUFF
"\" suffix, this "
"minimum is specified in terms of the percentage of samples in "
"input that are lower. "
"By default (not using this option), the lowest value "
"found in input nrrd.");
hestOptAdd(&opt, "max,maximum", "value", airTypeString, 1, 1,
&maxStr, "nan",
"Value at high end of histogram, given "
"explicitly as a regular number, "
"*or*, if the number is given with "
"a \"" NRRD_MINMAX_PERC_SUFF "\" suffix, "
"this maximum is specified "
"in terms of the percentage of samples in input that are higher. "
"Defaults to highest value found in input nrrd.");
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]).");
OPT_ADD_TYPE(type, "type to use for bins in output histogram", "uint");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_histoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
range = nrrdRangeNew(AIR_NAN, AIR_NAN);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdRangePercentileFromStringSet(range, nin, minStr, maxStr,
10*bins /* HEY magic */,
blind8BitRange)
|| nrrdHisto(nout, nin, range, nwght, bins, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error with range or quantizing:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_jhistoMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd **nin;
Nrrd *nout, *nwght;
size_t *bin;
int type, clamp[NRRD_DIM_MAX], pret;
unsigned int binLen, minLen, maxLen, ninLen, ai;
airArray *mop;
double *min, *max;
NrrdRange **range;
hestOptAdd(&opt, "b,bin", "bins0 bins1", airTypeSize_t, 2, -1, &bin, NULL,
"bins<i> is the number of bins to use along axis i (of joint "
"histogram), which represents the values of nin<i> ",
&binLen);
hestOptAdd(&opt, "w,weight", "nweight", airTypeOther, 1, 1, &nwght, "",
"how to weigh contributions to joint histogram. By default "
"(not using this option), the increment is one bin count per "
"sample, but by giving a nrrd, the value in the nrrd at the "
"corresponding location will be the bin count increment ",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "min,minimum", "min0 min1", airTypeDouble, 2, -1,
&min, "nan nan",
"min<i> is the low range of values to be quantized along "
"axis i; use \"nan\" to represent lowest value present ",
&minLen);
hestOptAdd(&opt, "max,maximum", "max0 max1", airTypeDouble, 2, -1,
&max, "nan nan",
"max<i> is the high range of values to be quantized along "
"axis i; use \"nan\" to represent highest value present ",
&maxLen);
OPT_ADD_TYPE(type, "type to use for output (the type used to store hit "
"counts in the joint histogram). Clamping is done on hit "
"counts so that they never overflow a fixed-point type",
"uint");
hestOptAdd(&opt, "i,input", "nin0 nin1", airTypeOther, 2, -1, &nin, NULL,
"All input nrrds",
&ninLen, NULL, nrrdHestNrrd);
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_jhistoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
if (ninLen != binLen) {
fprintf(stderr, "%s: # input nrrds (%d) != # bin specifications (%d)\n",
me, ninLen, binLen);
airMopError(mop);
return 1;
}
range = (NrrdRange **)calloc(ninLen, sizeof(NrrdRange*));
airMopAdd(mop, range, airFree, airMopAlways);
for (ai=0; ai<ninLen; ai++) {
range[ai] = nrrdRangeNew(AIR_NAN, AIR_NAN);
airMopAdd(mop, range[ai], (airMopper)nrrdRangeNix, airMopAlways);
}
if (2 != minLen || (AIR_EXISTS(min[0]) || AIR_EXISTS(min[1]))) {
if (minLen != ninLen) {
fprintf(stderr, "%s: # mins (%d) != # input nrrds (%d)\n", me,
minLen, ninLen);
airMopError(mop); return 1;
}
for (ai=0; ai<ninLen; ai++) {
range[ai]->min = min[ai];
}
}
if (2 != maxLen || (AIR_EXISTS(max[0]) || AIR_EXISTS(max[1]))) {
if (maxLen != ninLen) {
fprintf(stderr, "%s: # maxs (%d) != # input nrrds (%d)\n", me,
maxLen, ninLen);
airMopError(mop); return 1;
}
for (ai=0; ai<ninLen; ai++) {
range[ai]->max = max[ai];
}
}
for (ai=0; ai<ninLen; ai++) {
clamp[ai] = 0;
}
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdHistoJoint(nout, (const Nrrd**)nin, (const NrrdRange**)range,
ninLen, nwght, bin, type, clamp)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing joint histogram:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_jhistoMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd **nin, **npass;
Nrrd *nout, *nwght;
size_t *bin, binLen;
int type, clamp[NRRD_DIM_MAX], pret;
unsigned int minLen, maxLen, ninLen, ai, diceax;
airArray *mop;
double *min, *max;
NrrdRange **range;
hestOptAdd(&opt, "b,bin", "bins0 bins1", airTypeSize_t, 2, -1, &bin, NULL,
"bins<i> is the number of bins to use along axis i (of joint "
"histogram), which represents the values of nin<i> ",
&binLen);
hestOptAdd(&opt, "w,weight", "nweight", airTypeOther, 1, 1, &nwght, "",
"how to weigh contributions to joint histogram. By default "
"(not using this option), the increment is one bin count per "
"sample, but by giving a nrrd, the value in the nrrd at the "
"corresponding location will be the bin count increment ",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "min,minimum", "min0 min1", airTypeDouble, 2, -1,
&min, "nan nan",
"min<i> is the low range of values to be quantized along "
"axis i; use \"nan\" to represent lowest value present ",
&minLen);
hestOptAdd(&opt, "max,maximum", "max0 max1", airTypeDouble, 2, -1,
&max, "nan nan",
"max<i> is the high range of values to be quantized along "
"axis i; use \"nan\" to represent highest value present ",
&maxLen);
OPT_ADD_TYPE(type, "type to use for output (the type used to store hit "
"counts in the joint histogram). Clamping is done on hit "
"counts so that they never overflow a fixed-point type",
"uint");
hestOptAdd(&opt, "i,input", "nin0 [nin1]", airTypeOther, 1, -1, &nin, NULL,
"list of nrrds (one for each axis of joint histogram), "
"or, single nrrd that will be sliced along specified axis.",
&ninLen, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "a,axis", "axis", airTypeUInt, 1, 1, &diceax, "0",
"axis to slice along when working with single nrrd. ");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_jhistoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
if (ninLen == 1) {
/* Slice a nrrd on the fly */
size_t asize;
if (!( diceax <= nin[0]->dim-1 )) {
fprintf(stderr, "%s: slice axis %u not valid for single %u-D nrrd",
me, diceax, nin[0]->dim);
airMopError(mop);
return 1;
}
asize = nin[0]->axis[diceax].size;
if (asize != binLen) {
fprintf(stderr,
"%s: size (%u) of slice axis %u != # bins given (%u)\n", me,
AIR_CAST(unsigned int, asize), diceax,
AIR_CAST(unsigned int, binLen));
airMopError(mop);
return 1;
}
int
unrrdu_histoMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout, *nwght;
int type, pret, blind8BitRange;
unsigned int bins;
double min, max;
NrrdRange *range;
airArray *mop;
hestOptAdd(&opt, "b,bins", "num", airTypeUInt, 1, 1, &bins, NULL,
"# of bins in histogram");
hestOptAdd(&opt, "w,weight", "nweight", airTypeOther, 1, 1, &nwght, "",
"how to weigh contributions to histogram. By default "
"(not using this option), the increment is one bin count per "
"sample, but by giving a nrrd, the value in the nrrd at the "
"corresponding location will be the bin count increment ",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "min,minimum", "value", airTypeDouble, 1, 1, &min, "nan",
"Value at low end of histogram. Defaults to lowest value "
"found in input nrrd.");
hestOptAdd(&opt, "max,maximum", "value", airTypeDouble, 1, 1, &max, "nan",
"Value at high end of histogram. Defaults to highest value "
"found in input nrrd.");
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]).");
OPT_ADD_TYPE(type, "type to use for bins in output histogram", "uint");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_histoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/* If the input nrrd never specified min and max, then they'll be
AIR_NAN, and nrrdRangeSafeSet will find them, and will do so
according to blind8BitRange */
range = nrrdRangeNew(min, max);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nrrdRangeSafeSet(range, nin, blind8BitRange);
if (nrrdHisto(nout, nin, range, nwght, bins, type)) {
err = biffGet(NRRD);
fprintf(stderr, "%s: error calculating histogram:\n%s", me, err);
free(err);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
