int
_nrrdHestIterParse(void *ptr, char *str, char err[AIR_STRLEN_HUGE]) {
char me[]="_nrrdHestIterParse", *nerr;
Nrrd *nrrd;
NrrdIter **iterP;
airArray *mop;
double val;
int ret;
if (!(ptr && str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
iterP = (NrrdIter **)ptr;
mop = airMopNew();
*iterP = nrrdIterNew();
airMopAdd(mop, *iterP, (airMopper)nrrdIterNix, airMopOnError);
/* the challenge here is determining if a given string represents a
filename or a number. Obviously there are cases where it could
be both, so we'll assume its a filename first. Because: there
are different ways of writing the same number, such as "3" -->
"+3", "3.1" --> "3.10", so someone accidently using the file when
they mean to use the number has easy ways of changing the number
representation, since these trivial transformations will probably
not all result in valid filenames. Another problem is that one
really wants a general robust test to see if a given string is a
valid number representation AND NOTHING BUT THAT, and sscanf() is
not that test. In any case, if there are to be improved smarts
about this matter, they need to be implemented below and nowhere
else. */
nrrd = nrrdNew();
ret = nrrdLoad(nrrd, str, NULL);
if (!ret) {
/* first attempt at nrrdLoad() was SUCCESSFUL */
nrrdIterSetOwnNrrd(*iterP, nrrd);
} else {
/* so it didn't load as a nrrd- if its because fopen() failed,
then we'll try it as a number. If its for another reason,
then we complain */
nrrdNuke(nrrd);
if (2 != ret) {
/* it failed because of something besides the fopen(), so complain */
nerr = biffGetDone(NRRD);
airStrcpy(err, AIR_STRLEN_HUGE, nerr);
airMopError(mop); return 1;
} else {
/* fopen() failed, so it probably wasn't meant to be a filename */
free(biffGetDone(NRRD));
ret = airSingleSscanf(str, "%lf", &val);
if (_nrrdLooksLikeANumber(str)
|| (1 == ret && (!AIR_EXISTS(val)
|| AIR_ABS(AIR_PI - val) < 0.0001))) {
/* either it patently looks like a number, or,
it already parsed as a number and it is a special value */
if (1 == ret) {
nrrdIterSetValue(*iterP, val);
} else {
/* oh, this is bad. */
fprintf(stderr, "%s: PANIC, is it a number or not?", me);
exit(1);
}
} else {
/* it doesn't look like a number, but the fopen failed, so
we'll let it fail again and pass back the error messages */
if (nrrdLoad(nrrd = nrrdNew(), str, NULL)) {
nerr = biffGetDone(NRRD);
airStrcpy(err, AIR_STRLEN_HUGE, nerr);
airMopError(mop); return 1;
} else {
/* what the hell? */
fprintf(stderr, "%s: PANIC, is it a nrrd or not?", me);
exit(1);
}
}
}
}
airMopAdd(mop, iterP, (airMopper)airSetNull, airMopOnError);
airMopOkay(mop);
return 0;
}
int
unrrdu_affineMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
NrrdIter *minIn, *in, *maxIn, *minOut, *maxOut, *args[5];
Nrrd *nout, *ntmp=NULL;
int type, E, pret, clamp;
airArray *mop;
unsigned int ai, nn;
hestOptAdd(&opt, NULL, "minIn", airTypeOther, 1, 1, &minIn, NULL,
"Lower end of input value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in", airTypeOther, 1, 1, &in, NULL,
"Input value.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "maxIn", airTypeOther, 1, 1, &maxIn, NULL,
"Upper end of input value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "minOut", airTypeOther, 1, 1, &minOut, NULL,
"Lower end of output value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "maxOut", airTypeOther, 1, 1, &maxOut, NULL,
"Upper end of output value range.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to convert all nrrd inputs to, prior to "
"doing operation. This also determines output type. "
"By default (not using this option), the types of the input "
"nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
hestOptAdd(&opt, "clamp", "bool", airTypeBool, 1, 1, &clamp, "false",
"clamp output values to specified output range");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_affineInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
args[0] = minIn;
args[1] = in;
args[2] = maxIn;
args[3] = minOut;
args[4] = maxOut;
nn = 0;
for (ai=0; ai<5; ai++) {
nn += !!args[ai]->ownNrrd;
}
if (nrrdTypeDefault != type) {
/* they wanted to convert nrrds to some other type first */
E = 0;
for (ai=0; ai<5; ai++) {
if (args[ai]->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), args[ai]->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(args[ai], ntmp);
}
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err);
airMopError(mop);
return 1;
}
}
if (0 == nn) {
/* actually, there are no nrrds; we represent the functionality
of the previous stand-alone binary "affine" */
double valOut;
valOut = AIR_AFFINE(minIn->val, in->val, maxIn->val,
minOut->val, maxOut->val);
if (clamp) {
double mmin = AIR_MIN(minOut->val, maxOut->val);
double mmax = AIR_MAX(minOut->val, maxOut->val);
valOut = AIR_CLAMP(mmin, valOut, mmax);
}
printf("%g\n", valOut);
} else {
/* we have a nrrd output */
if (1 == nn && in->ownNrrd) {
E = nrrdArithAffine(nout, minIn->val, in->ownNrrd, maxIn->val,
minOut->val, maxOut->val, clamp);
} else {
E = nrrdArithIterAffine(nout, minIn, in, maxIn, minOut, maxOut, clamp);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing ternary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
}
airMopOkay(mop);
return 0;
}
int
unrrdu_2opMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err, *seedS;
NrrdIter *in1, *in2;
Nrrd *nout, *ntmp=NULL;
int op, type, E, pret;
airArray *mop;
unsigned int seed;
hestOptAdd(&opt, NULL, "operator", airTypeEnum, 1, 1, &op, NULL,
"Binary operator. Possibilities include:\n "
"\b\bo \"+\", \"-\", \"x\", \"/\": "
"add, subtract, multiply, divide\n "
"\b\bo \"^\": exponentiation (pow)\n "
"\b\bo \"spow\": signed exponentiation: sgn(x)pow(abs(x),p)\n "
"\b\bo \"%\": integer modulo\n "
"\b\bo \"fmod\": same as fmod() in C\n "
"\b\bo \"atan2\": same as atan2() in C\n "
"\b\bo \"min\", \"max\": minimum, maximum\n "
"\b\bo \"lt\", \"lte\", \"gt\", \"gte\": same as C's <, <=, >, <=\n "
"\b\bo \"eq\", \"neq\": same as C's == and !=\n "
"\b\bo \"comp\": -1, 0, or 1 if 1st value is less than, "
"equal to, or greater than 2nd value\n "
"\b\bo \"if\": if 1st value is non-zero, use it, "
"else use 2nd value\n "
"\b\bo \"exists\": if 1st value exists, use it, "
"else use 2nd value\n "
"\b\bo \"nrand\": scale unit-stdv Gaussian noise by 2nd value "
"and add to first value",
NULL, nrrdBinaryOp);
hestOptAdd(&opt, NULL, "in1", airTypeOther, 1, 1, &in1, NULL,
"First input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in2", airTypeOther, 1, 1, &in2, NULL,
"Second input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, "s,seed", "seed", airTypeString, 1, 1, &seedS, "",
"seed value for RNG for nrand, so that you "
"can get repeatable results between runs, or, "
"by not using this option, the RNG seeding will be "
"based on the current time");
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to convert all INPUT nrrds to, prior to "
"doing operation, useful for doing, for instance, the difference "
"between two unsigned char nrrds. This will also determine "
"output type. By default (not using this option), the types of "
"the input nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_2opInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/*
fprintf(stderr, "%s: op = %d\n", me, op);
fprintf(stderr, "%s: in1->left = %d, in2->left = %d\n", me,
(int)(in1->left), (int)(in2->left));
*/
if (nrrdTypeDefault != type) {
/* they wanted to convert nrrds to some other type first */
E = 0;
if (in1->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in1->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in1, ntmp);
}
if (in2->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in2->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in2, ntmp);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err);
airMopError(mop);
return 1;
}
/* this will still leave a nrrd in the NrrdIter for nrrdIterNix()
(called by hestParseFree() called be airMopOkay()) to clear up */
}
if (nrrdBinaryOpNormalRandScaleAdd == op) {
if (airStrlen(seedS)) {
if (1 != sscanf(seedS, "%u", &seed)) {
fprintf(stderr, "%s: couldn't parse seed \"%s\" as uint\n", me, seedS);
airMopError(mop);
return 1;
} else {
airSrandMT(seed);
}
} else {
/* got no request for specific seed */
airSrandMT(AIR_CAST(unsigned int, airTime()));
}
}
if (nrrdArithIterBinaryOp(nout, op, in1, in2)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing binary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_3opMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
NrrdIter *in1, *in2, *in3;
Nrrd *nout, *ntmp=NULL;
int op, type, E, pret;
airArray *mop;
hestOptAdd(&opt, NULL, "operator", airTypeEnum, 1, 1, &op, NULL,
"Ternary operator. Possibilities include:\n "
"\b\bo \"+\", \"x\": sum or product of three values\n "
"\b\bo \"min\", \"max\": minimum, maximum\n "
"\b\bo \"clamp\": second value is clamped to range between "
"the first and the third\n "
"\b\bo \"ifelse\": if 1st value non-zero, then 2nd value, else "
"3rd value\n "
"\b\bo \"lerp\": linear interpolation between the 2nd and "
"3rd values, as the 1st value varies between 0.0 and 1.0, "
"respectively\n "
"\b\bo \"exists\": if the first value exists, use the second "
"value, otherwise use the third\n "
"\b\bo \"in_op\": 1 iff second value is > first and < "
"third, 0 otherwise\n "
"\b\bo \"in_cl\": 1 iff second value is >= first and <= "
"third, 0 otherwise",
NULL, nrrdTernaryOp);
hestOptAdd(&opt, NULL, "in1", airTypeOther, 1, 1, &in1, NULL,
"First input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in2", airTypeOther, 1, 1, &in2, NULL,
"Second input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, NULL, "in3", airTypeOther, 1, 1, &in3, NULL,
"Third input. Can be a single value or a nrrd.",
NULL, NULL, nrrdHestIter);
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to convert all nrrd inputs to, prior to "
"doing operation. This also determines output type. "
"By default (not using this option), the types of the input "
"nrrds are left unchanged.",
NULL, NULL, &unrrduHestMaybeTypeCB);
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_3opInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/*
fprintf(stderr, "%s: op = %d\n", me, op);
fprintf(stderr, "%s: in1->left = %d, in2->left = %d\n", me,
(int)(in1->left), (int)(in2->left));
*/
if (nrrdTypeDefault != type) {
/* they wanted to convert nrrds to some other type first */
E = 0;
if (in1->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in1->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in1, ntmp);
}
if (in2->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in2->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in2, ntmp);
}
if (in3->ownNrrd) {
if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in3->ownNrrd, type);
if (!E) nrrdIterSetOwnNrrd(in3, ntmp);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err);
airMopError(mop);
return 1;
}
/* this will still leave a nrrd in the NrrdIter for nrrdIterNix()
(called by hestParseFree() called be airMopOkay()) to clear up */
}
if (nrrdArithIterTernaryOp(nout, op, in1, in2, in3)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing ternary operation:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
