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