int
rva_aboutMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
char buff[AIR_STRLEN_LARGE], fmt[AIR_STRLEN_MED];
char par1[] = "\t\t\t\t"
"\"reva\" is very much under construction.\n";
char par2[] = "\t\t\t\t"
"Users should remain cautious.\n";
AIR_UNUSED(argc);
AIR_UNUSED(argv);
AIR_UNUSED(me);
fprintf(stderr, "\n");
sprintf(buff, "--- reva: Brevais Lattice Hacking ---");
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stderr, fmt, buff);
airTeemVersionSprint(buff);
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stderr, fmt, buff);
fprintf(stderr, "\n");
_hestPrintStr(stderr, 1, 0, 78, par1, AIR_FALSE);
_hestPrintStr(stderr, 1, 0, 78, par2, AIR_FALSE);
return 0;
}
int
limnpu_aboutMain(int argc, char **argv, char *me, hestParm *hparm) {
char buff[AIR_STRLEN_MED], fmt[AIR_STRLEN_MED];
char par1[] = "\t\t\t\t"
"\"lpu\" is a complete hack.\n";
char par2[] = "\t\t\t\t"
"Users are encouraged to take cover.\n";
AIR_UNUSED(argc);
AIR_UNUSED(argv);
AIR_UNUSED(me);
fprintf(stderr, "\n");
sprintf(buff, "--- lpu: LimnPolyData command-line interface ---");
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stderr, fmt, buff);
sprintf(buff, "(Teem version %s, %s)",
airTeemVersion, airTeemReleaseDate);
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stderr, fmt, buff);
fprintf(stderr, "\n");
_hestPrintStr(stderr, 1, 0, 78, par1, AIR_FALSE);
_hestPrintStr(stderr, 1, 0, 78, par2, AIR_FALSE);
return 0;
}
int
tend_aboutMain(int argc, char **argv, char *me, hestParm *hparm) {
char buff[AIR_STRLEN_MED], fmt[AIR_STRLEN_MED];
char par1[] = "\t\t\t\t"
"\"tend\" is a command-line interface to much of the functionality "
"in \"ten\", a C library for diffusion image processing. Ten is one "
"library in the \"Teem\" collection of libraries. More information "
"about Teem is at <http://teem.sourceforge.net>.\n";
char par2[] = "\t\t\t\t"
"Users are strongly encouraged to join the teem-users mailing list: "
"<http://lists.sourceforge.net/lists/listinfo/teem-users>. This is "
"the primary forum for feedback, questions, and feature requests.\n";
char par3[] = "\t\t\t\t"
"Like \"unu\", another Teem command-line binary, it is often useful "
"to chain together invocations of tend with pipes, as in the "
"following, which estimates tensors from DWIs, takes a slice of the "
"tensor volume, computes the standard RGB colormap of the principal "
"eigenvector, and then quantizes it to an 8-bit PNG:\n";
char par4[] = "\ttend estim -i dwi.nhdr -B kvp -knownB0 true \\\n "
" | tend slice -a 2 -p 30 \\\n "
" | tend evecrgb -c 0 -a cl2 -gam 1.2 \\\n "
" | unu quantize -b 8 -min 0 -max 1 -o z30-rgb.png\n";
char par5[] = "\t\t\t\t"
"If tend repeatedly proves itself useful for your research, an "
"acknowledgment to that effect in your publication would be greatly "
"appreciated, such as (for LaTeX): "
"\"Dataset processing performed with the {\\tt tend} tool "
"part of the {\\tt Teem} toolkit available at "
"{\\tt\t$<$http://teem.sf.net$>$}\"\n ";
AIR_UNUSED(argc);
AIR_UNUSED(argv);
AIR_UNUSED(me);
fprintf(stdout, "\n");
sprintf(buff, "--- tend: Diffusion Image Processing and Analysis ---");
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stdout, fmt, buff);
sprintf(buff, "(Teem version %s, %s)",
airTeemVersion, airTeemReleaseDate);
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stdout, fmt, buff);
fprintf(stdout, "\n");
_hestPrintStr(stdout, 1, 0, 78, par1, AIR_FALSE);
_hestPrintStr(stdout, 1, 0, 78, par2, AIR_FALSE);
_hestPrintStr(stdout, 1, 0, 78, par3, AIR_FALSE);
_hestPrintStr(stdout, 2, 0, 78, par4, AIR_FALSE);
_hestPrintStr(stdout, 1, 0, 78, par5, AIR_FALSE);
return 0;
}
/*
******** limnpuUsage
**
** prints out a little banner, and a listing of all available commands
** with their one-line descriptions
*/
void
limnpuUsage(char *me, hestParm *hparm) {
int i, maxlen, len, c;
char buff[AIR_STRLEN_LARGE], fmt[AIR_STRLEN_LARGE];
maxlen = 0;
for (i=0; limnpuCmdList[i]; i++) {
maxlen = AIR_MAX(maxlen, (int)strlen(limnpuCmdList[i]->name));
}
sprintf(buff, "--- LimnPolyData Hacking ---");
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stderr, fmt, buff);
for (i=0; limnpuCmdList[i]; i++) {
len = strlen(limnpuCmdList[i]->name);
strcpy(buff, "");
for (c=len; c<maxlen; c++)
strcat(buff, " ");
strcat(buff, me);
strcat(buff, " ");
strcat(buff, limnpuCmdList[i]->name);
strcat(buff, " ... ");
len = strlen(buff);
fprintf(stderr, "%s", buff);
_hestPrintStr(stderr, len, len, hparm->columns,
limnpuCmdList[i]->info, AIR_FALSE);
}
}
/*
******** unrrduUsage
**
** prints out a little banner, and a listing of all available commands
** with their one-line descriptions
*/
void
unrrduUsage(const char *me, hestParm *hparm) {
int i, maxlen, len, c;
char buff[AIR_STRLEN_LARGE], fmt[AIR_STRLEN_LARGE];
maxlen = 0;
for (i=0; unrrduCmdList[i]; i++) {
maxlen = AIR_MAX(maxlen, (int)strlen(unrrduCmdList[i]->name));
}
sprintf(buff, "--- unu: Utah Nrrd Utilities command-line interface ---");
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stderr, fmt, buff);
for (i=0; unrrduCmdList[i]; i++) {
len = strlen(unrrduCmdList[i]->name);
strcpy(buff, "");
for (c=len; c<maxlen; c++)
strcat(buff, " ");
strcat(buff, me);
strcat(buff, " ");
strcat(buff, unrrduCmdList[i]->name);
strcat(buff, " ... ");
len = strlen(buff);
fprintf(stderr, "%s", buff);
_hestPrintStr(stderr, len, len, hparm->columns,
unrrduCmdList[i]->info, AIR_FALSE);
}
}
void
_unrrdu_envBool(FILE *file, const char *envKey, int currVal,
const char *varName, const char *desc, int columns) {
int val, ret;
char *envVal;
fprintf(file, "%s (bool): ", envKey);
ret = nrrdGetenvBool(&val, &envVal, envKey);
switch(ret) {
case -1:
fprintf(file, "not set\n");
break;
case AIR_TRUE:
fprintf(file, "set to \"%s\"\n", envVal);
break;
case AIR_FALSE:
fprintf(file, "set to \"%s\"? (invalid) \n", envVal);
break;
}
switch(ret) {
case -1:
case AIR_FALSE:
fprintf(file, " (%s == %s; unchanged)\n",
varName, airEnumStr(airBool, currVal));
break;
case AIR_TRUE:
fprintf(file, " ==> %s = %s **********************\n",
varName, airEnumStr(airBool, currVal));
break;
}
_hestPrintStr(file, 0, 0, columns, desc, AIR_FALSE);
fprintf(file, "\n");
}
void
hestInfo(FILE *file, const char *argv0, const char *info, hestParm *_parm) {
hestParm *parm;
parm = !_parm ? hestParmNew() : _parm;
if (info) {
fprintf(file, "\n%s: ", argv0);
_hestPrintStr(file, 0, strlen(argv0) + 2, parm->columns, info, AIR_FALSE);
}
parm = !_parm ? hestParmFree(parm) : NULL;
}
void
_unrrdu_envUInt(FILE *file, const char *envKey,
unsigned int currVal, const char *varName,
const char *desc, int columns) {
int ret;
unsigned int val;
char *envVal;
/* !!! HEY: CUT + PASTE !!! */
fprintf(file, "%s (unsigned int): ", envKey);
ret = nrrdGetenvUInt(&val, &envVal, envKey);
switch(ret) {
case -1:
fprintf(file, "not set\n");
break;
case AIR_TRUE:
fprintf(file, "set to \"%s\"\n", envVal);
break;
case AIR_FALSE:
fprintf(file, "set to \"%s\"? (invalid) \n", envVal);
break;
}
switch(ret) {
case -1:
case AIR_FALSE:
fprintf(file, " (%s == %d; unchanged)\n",
varName, currVal);
break;
case AIR_TRUE:
fprintf(file, " ==> %s = %u **********************\n",
varName, currVal);
break;
}
_hestPrintStr(file, 0, 0, columns, desc, AIR_FALSE);
fprintf(file, "\n");
/* !!! HEY: CUT + PASTE !!! */
}
void
hestUsage(FILE *f, hestOpt *opt, const char *argv0, hestParm *_parm) {
int i, numOpts;
char buff[2*AIR_STRLEN_HUGE], tmpS[AIR_STRLEN_HUGE];
hestParm *parm;
parm = !_parm ? hestParmNew() : _parm;
if (_hestPanic(opt, NULL, parm)) {
/* we can't continue; the opt array is botched */
parm = !_parm ? hestParmFree(parm) : NULL;
return;
}
numOpts = _hestNumOpts(opt);
fprintf(f, "\n");
strcpy(buff, "Usage: ");
strcat(buff, argv0 ? argv0 : "");
if (parm && parm->respFileEnable) {
sprintf(tmpS, " [%cfile\t...]", parm->respFileFlag);
strcat(buff, tmpS);
}
for (i=0; i<numOpts; i++) {
strcat(buff, " ");
if (1 == opt[i].kind || (opt[i].flag && opt[i].dflt))
strcat(buff, "[");
_hestSetBuff(buff, opt + i, parm, AIR_TRUE, AIR_TRUE);
if (1 == opt[i].kind || (opt[i].flag && opt[i].dflt))
strcat(buff, "]");
}
_hestPrintStr(f, strlen("Usage: "), 0, parm->columns, buff, AIR_TRUE);
parm = !_parm ? hestParmFree(parm) : NULL;
return;
}
void
_unrrdu_envEnum(FILE *file, const airEnum *enm, const char *envKey,
int currVal, const char *varName,
const char *desc, int columns) {
int val, ret;
char *envVal;
/* !!! HEY: CUT + PASTE !!! */
fprintf(file, "%s (%s enum): ", envKey, enm->name);
ret = nrrdGetenvEnum(&val, &envVal, enm, envKey);
switch(ret) {
case -1:
fprintf(file, "not set\n");
break;
case AIR_TRUE:
fprintf(file, "set to \"%s\"\n", envVal);
break;
case AIR_FALSE:
fprintf(file, "set to \"%s\"? (invalid) \n", envVal);
break;
}
switch(ret) {
case -1:
case AIR_FALSE:
fprintf(file, " (%s == %s; unchanged)\n",
varName, airEnumStr(enm, currVal));
break;
case AIR_TRUE:
fprintf(file, " ==> %s = %s **********************\n",
varName, airEnumStr(enm, currVal));
break;
}
_hestPrintStr(file, 0, 0, columns, desc, AIR_FALSE);
fprintf(file, "\n");
/* !!! HEY: CUT + PASTE !!! */
}
void
hestGlossary(FILE *f, hestOpt *opt, hestParm *_parm) {
int i, j, len, maxlen, numOpts;
char buff[2*AIR_STRLEN_HUGE], tmpS[AIR_STRLEN_HUGE];
hestParm *parm;
parm = !_parm ? hestParmNew() : _parm;
if (_hestPanic(opt, NULL, parm)) {
/* we can't continue; the opt array is botched */
parm = !_parm ? hestParmFree(parm) : NULL;
return;
}
numOpts = _hestNumOpts(opt);
maxlen = 0;
if (numOpts) {
fprintf(f, "\n");
}
for (i=0; i<numOpts; i++) {
strcpy(buff, "");
_hestSetBuff(buff, opt + i, parm, AIR_TRUE, AIR_FALSE);
maxlen = AIR_MAX((int)strlen(buff), maxlen);
}
if (parm && parm->respFileEnable) {
sprintf(buff, "%cfile ...", parm->respFileFlag);
len = strlen(buff);
for (j=len; j<maxlen; j++) {
fprintf(f, " ");
}
fprintf(f, "%s = ", buff);
strcpy(buff, "response file(s) containing command-line arguments");
_hestPrintStr(f, maxlen + 3, maxlen + 3, parm->columns, buff, AIR_FALSE);
}
for (i=0; i<numOpts; i++) {
strcpy(buff, "");
_hestSetBuff(buff, opt + i, parm, AIR_TRUE, AIR_FALSE);
airOneLinify(buff);
len = strlen(buff);
for (j=len; j<maxlen; j++) {
fprintf(f, " ");
}
fprintf(f, "%s", buff);
strcpy(buff, "");
#if 1
if (opt[i].flag && strchr(opt[i].flag, parm->multiFlagSep)) {
/* there is a long-form flag as well as short */
_hestSetBuff(buff, opt + i, parm, AIR_FALSE, AIR_TRUE);
strcat(buff, " = ");
fprintf(f, " , ");
} else {
/* there is only a short-form flag */
fprintf(f, " = ");
}
#else
fprintf(f, " = ");
#endif
if (opt[i].info) {
strcat(buff, opt[i].info);
}
if ((opt[i].min || _hestMax(opt[i].max))
&& (!( 2 == opt[i].kind
&& airTypeEnum == opt[i].type
&& parm->elideSingleEnumType ))
&& (!( 2 == opt[i].kind
&& airTypeOther == opt[i].type
&& parm->elideSingleOtherType ))
) {
/* if there are newlines in the info, then we want to clarify the
type by printing it on its own line */
if (opt[i].info && strchr(opt[i].info, '\n')) {
strcat(buff, "\n ");
}
else {
strcat(buff, " ");
}
strcat(buff, "(");
if (opt[i].min == 0 && _hestMax(opt[i].max) == 1) {
strcat(buff, "optional\t");
}
else {
if ((int)opt[i].min == _hestMax(opt[i].max) && _hestMax(opt[i].max) > 1) { /* HEY scrutinize casts */
sprintf(tmpS, "%d\t", _hestMax(opt[i].max));
strcat(buff, tmpS);
}
else if ((int)opt[i].min < _hestMax(opt[i].max)) { /* HEY scrutinize casts */
if (-1 == opt[i].max) {
sprintf(tmpS, "%d\tor\tmore\t", opt[i].min);
}
else {
sprintf(tmpS, "%d..%d\t", opt[i].min, _hestMax(opt[i].max));
}
strcat(buff, tmpS);
}
}
sprintf(tmpS, "%s%s",
(airTypeEnum == opt[i].type
? opt[i].enm->name
: (airTypeOther == opt[i].type
? opt[i].CB->type
: airTypeStr[opt[i].type])),
(_hestMax(opt[i].max) > 1
? (airTypeOther == opt[i].type
&& 'y' == opt[i].CB->type[airStrlen(opt[i].CB->type)-1]
&& parm->cleverPluralizeOtherY
? "\bies"
: "s")
: ""));
strcat(buff, tmpS);
strcat(buff, ")");
}
/*
fprintf(stderr, "!%s: parm->elideSingleOtherDefault = %d\n",
"hestGlossary", parm->elideSingleOtherDefault);
*/
if (opt[i].dflt
&& (opt[i].min || _hestMax(opt[i].max))
&& (!( 2 == opt[i].kind
&& (airTypeFloat == opt[i].type || airTypeDouble == opt[i].type)
&& !AIR_EXISTS(airAtod(opt[i].dflt))
&& parm->elideSingleNonExistFloatDefault ))
&& (!( (3 == opt[i].kind || 5 == opt[i].kind)
&& (airTypeFloat == opt[i].type || airTypeDouble == opt[i].type)
&& !AIR_EXISTS(airAtod(opt[i].dflt))
&& parm->elideMultipleNonExistFloatDefault ))
&& (!( 2 == opt[i].kind
&& airTypeOther == opt[i].type
&& parm->elideSingleOtherDefault ))
&& (!( 2 == opt[i].kind
&& airTypeString == opt[i].type
&& parm->elideSingleEmptyStringDefault
&& 0 == airStrlen(opt[i].dflt) ))
&& (!( (3 == opt[i].kind || 5 == opt[i].kind)
&& airTypeString == opt[i].type
&& parm->elideMultipleEmptyStringDefault
&& 0 == airStrlen(opt[i].dflt) ))
) {
/* if there are newlines in the info, then we want to clarify the
default by printing it on its own line */
if (opt[i].info && strchr(opt[i].info, '\n')) {
strcat(buff, "\n ");
}
else {
strcat(buff, "; ");
}
strcat(buff, "default:\t");
strcpy(tmpS, opt[i].dflt);
airStrtrans(tmpS, ' ', '\t');
strcat(buff, "\"");
strcat(buff, tmpS);
strcat(buff, "\"");
}
_hestPrintStr(f, maxlen + 3, maxlen + 3, parm->columns, buff, AIR_FALSE);
}
parm = !_parm ? hestParmFree(parm) : NULL;
return;
}
/*
******** unrrduCmdMain
**
** A "main" function for unu-like programs, which is very similar to
** teem/src/bin/unu.c:main(), and
** teem/src/bin/tend.c:main(), and
** teem/src/limn/test/lpu.c:main().
** With more time (and a major Teem release), this function may change,
** and those programs may use this.
**
** A sneaky but basic issue is the const-correctness of how the hestParm
** is used; we'd like to take a const hestParm* to communicate parameters
** the caller has set, but the show-stopper is that unrrduCmd->main()
** takes a non-const hestParm, and it has to be that way, because some
** unu commands alter the given hparm (which probably shouldn't happen).
** Until that's fixed, we have a non-const hestParm* coming in here.
*/
int
unrrduCmdMain(int argc, const char **argv,
const char *cmd, const char *title,
const unrrduCmd *const *cmdList,
hestParm *_hparm, FILE *fusage) {
int i, ret;
const char *me;
char *argv0 = NULL;
hestParm *hparm;
airArray *mop;
me = argv[0];
/* parse environment variables first, in case they break nrrdDefault*
or nrrdState* variables in a way that nrrdSanity() should see */
nrrdDefaultGetenv();
nrrdStateGetenv();
/* unu does some unu-specific environment-variable handling here */
nrrdSanityOrDie(me);
mop = airMopNew();
if (_hparm) {
hparm = _hparm;
} else {
hparm = hestParmNew();
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hparm->elideSingleEnumType = AIR_TRUE;
hparm->elideSingleOtherType = AIR_TRUE;
hparm->elideSingleOtherDefault = AIR_FALSE;
hparm->elideSingleNonExistFloatDefault = AIR_TRUE;
hparm->elideMultipleNonExistFloatDefault = AIR_TRUE;
hparm->elideSingleEmptyStringDefault = AIR_TRUE;
hparm->elideMultipleEmptyStringDefault = AIR_TRUE;
hparm->cleverPluralizeOtherY = AIR_TRUE;
/* learning columns from current window; if ioctl is available
if (1) {
struct winsize ws;
ioctl(1, TIOCGWINSZ, &ws);
hparm->columns = ws.ws_col - 1;
}
*/
hparm->columns = 78;
}
/* if there are no arguments, then we give general usage information */
if (1 >= argc) {
/* this is like unrrduUsageUnu() */
unsigned int ii, maxlen = 0;
char *buff, *fmt, tdash[] = "--- %s ---";
for (ii=0; cmdList[ii]; ii++) {
if (cmdList[ii]->hidden) {
continue;
}
maxlen = AIR_MAX(maxlen, AIR_UINT(strlen(cmdList[ii]->name)));
}
if (!maxlen) {
fprintf(fusage, "%s: problem: maxlen = %u\n", me, maxlen);
airMopError(mop); return 1;
}
buff = AIR_CALLOC(strlen(tdash) + strlen(title) + 1, char);
airMopAdd(mop, buff, airFree, airMopAlways);
sprintf(buff, tdash, title);
fmt = AIR_CALLOC(hparm->columns + strlen(buff) + 1, char); /* generous */
airMopAdd(mop, buff, airFree, airMopAlways);
sprintf(fmt, "%%%us\n",
AIR_UINT((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(fusage, fmt, buff);
for (ii=0; cmdList[ii]; ii++) {
unsigned int cc, len;
if (cmdList[ii]->hidden) {
continue;
}
len = AIR_UINT(strlen(cmdList[ii]->name));
strcpy(buff, "");
for (cc=len; cc<maxlen; cc++)
strcat(buff, " ");
strcat(buff, cmd);
strcat(buff, " ");
strcat(buff, cmdList[ii]->name);
strcat(buff, " ... ");
len = strlen(buff);
fprintf(fusage, "%s", buff);
_hestPrintStr(fusage, len, len, hparm->columns,
cmdList[ii]->info, AIR_FALSE);
}
airMopError(mop);
return 1;
}
int
unrrdu_envMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
FILE *out;
AIR_UNUSED(argc);
AIR_UNUSED(argv);
AIR_UNUSED(me);
out = stdout;
hestInfo(out, me, _unrrdu_envInfoL, hparm);
fprintf(out, "\n");
_hestPrintStr(out, 0, 0, hparm->columns,
("Each variable in the listing below starts with the name of "
"the environment variable (\"NRRD_...\"), what type of value "
"it represents (e.g. \"int\", \"bool\"), what the "
"environment variable is currently set to, what the "
"corresponding Nrrd global variable is set to, and a "
"description of the variable."),
AIR_FALSE);
fprintf(out, "\n");
_hestPrintStr(out, 0, 0, hparm->columns,
("Bool variables may be set to true simply by setting the "
"environment variable; setting the value to \"true\" or "
"\"false\" sets the bool accordingly. Enum variables may "
"be set by setting the environment variable to any string "
"that parses as one of the enum values. Int and unsigned "
"int variables are set via a string parse-able as a numeric "
"value."),
AIR_FALSE);
fprintf(out, "\n");
/* UNRRDU_QUIET_QUIT functionality implemented in privateUnrrdu.h */
_hestPrintStr(out, 0, 0, hparm->columns,
("In addition to the the \"NRRD_\" environment variables, "
"there is this one, " UNRRDU_QUIET_QUIT_ENV ", which "
"determines whether unu exits "
"quietly (without error and usage info) when it fails "
"because an input nrrd read immediately hit EOF (as "
"happens when many unu invocations are piped together). "
"This is currently detected by seeing if the error message "
"ends with \n \"" UNRRDU_QUIET_QUIT_STR "\"."),
AIR_FALSE);
fprintf(out, "\n");
fprintf(out, "%s: ", UNRRDU_QUIET_QUIT_ENV);
if (getenv(UNRRDU_QUIET_QUIT_ENV)) {
fprintf(out, "is set (to what doesn't matter); quiet-quit enabled\n");
} else {
fprintf(out, "is NOT set; quiet-quit NOT enabled\n");
}
fprintf(out, "\n");
_unrrdu_envBool(out,
nrrdEnvVarStateKeyValuePairsPropagate,
nrrdStateKeyValuePairsPropagate,
"nrrdStateKeyValuePairsPropagate",
"When true, key/value pairs are copied from input "
"nrrd to output nrrd just like other basic info that hasn't "
"just been modified (e.g. type, dimension, block size).",
hparm->columns);
_unrrdu_envEnum(out,
nrrdCenter, nrrdEnvVarDefaultCenter,
nrrdDefaultCenter,
"nrrdDefaultCenter",
"The type of sample centering to use when none has been "
"set but one has to be chosen for some operation "
"(e.g. resampling).",
hparm->columns);
_unrrdu_envEnum(out,
nrrdEncodingType, nrrdEnvVarDefaultWriteEncodingType,
nrrdDefaultWriteEncodingType,
"nrrdDefaultWriteEncodingType",
"When writing nrrds, what encoding to use. Only "
"\"unu save\" affords explicit control of output encoding.",
hparm->columns);
_unrrdu_envBool(out,
nrrdEnvVarStateKindNoop,
nrrdStateKindNoop,
"nrrdStateKindNoop",
"When true, Nrrd makes not even the slightest effort to be "
"smart about setting the \"kind\" field of an axis after "
"some operation that modified its samples.",
hparm->columns);
_unrrdu_envInt(out,
nrrdEnvVarStateVerboseIO,
nrrdStateVerboseIO,
"nrrdStateVerboseIO",
"The verbosity level of Nrrd input/output operations.",
hparm->columns);
_unrrdu_envBool(out,
nrrdEnvVarStateBlind8BitRange,
nrrdStateBlind8BitRange,
"nrrdStateBlind8BitRange",
"When true, the determined range of 8-bit data will always "
"be [0,255] (for uchar) or [-128,127] (for signed char), "
"instead of actually looking into the data to find its "
"range.",
hparm->columns);
_unrrdu_envBool(out,
nrrdEnvVarDefaultWriteBareText,
nrrdDefaultWriteBareText,
"nrrdDefaultWriteBareText",
"When false, text files used for saving nrrds start with "
"comment (\"# ...\") lines containing nrrd fields.",
hparm->columns);
_unrrdu_envEnum(out,
nrrdType, nrrdEnvVarStateMeasureType,
nrrdStateMeasureType,
"nrrdStateMeasureType",
"For measurements (\"unu project\") like sum and product, "
"the type of the output result, when one hasn't been "
"explicitly requested.",
hparm->columns);
_unrrdu_envInt(out,
nrrdEnvVarStateMeasureModeBins,
nrrdStateMeasureModeBins,
"nrrdStateMeasureModeBins",
"When measuring mode but without a given histogram, how many "
"bins to use in the temporary internal histogram.",
hparm->columns);
_unrrdu_envEnum(out,
nrrdType, nrrdEnvVarStateMeasureHistoType,
nrrdStateMeasureHistoType,
"nrrdStateMeasureHistoType",
"Output type for most measurements of histograms, when one "
"hasn't been explicitly requested",
hparm->columns);
_unrrdu_envBool(out,
nrrdEnvVarStateAlwaysSetContent,
nrrdStateAlwaysSetContent,
"nrrdStateAlwaysSetContent",
"If true, the output content string is set even when the "
"input content string is not set.",
hparm->columns);
_unrrdu_envBool(out,
nrrdEnvVarStateDisableContent,
nrrdStateDisableContent,
"nrrdStateDisableContent",
"If true, output content is never set.",
hparm->columns);
_unrrdu_envUInt(out,
nrrdEnvVarDefaultWriteCharsPerLine,
nrrdDefaultWriteCharsPerLine,
"nrrdDefaultWriteCharsPerLine",
"When using text encoding, maximum # characters allowed "
"per line.",
hparm->columns);
_unrrdu_envUInt(out,
nrrdEnvVarDefaultWriteValsPerLine,
nrrdDefaultWriteValsPerLine,
"nrrdDefaultWriteValsPerLine",
"When using text encoding, maximum # values allowed "
"per line",
hparm->columns);
_unrrdu_envBool(out,
nrrdEnvVarStateGrayscaleImage3D,
nrrdStateGrayscaleImage3D,
"nrrdStateGrayscaleImage3D",
"If true, reading a 2-D grayscale image results in a "
"3-D image with a single sample (size=1) on the first "
"(fastest) axis.",
hparm->columns);
#if 0
/* GLK is ambivalent about the continued existence of these ... */
nrrdGetenvDouble(/**/ &nrrdDefaultKernelParm0,
nrrdEnvVarDefaultKernelParm0);
nrrdGetenvDouble(/**/ &nrrdDefaultSpacing,
nrrdEnvVarDefaultSpacing);
#endif
/* NOTE: this is an exceptional unu command that doesn't rely on
privateUnrrdu.h USAGE() macro; so we determine our own return value */
return 0;
}
int
tend_aboutMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
char buff[AIR_STRLEN_LARGE], fmt[AIR_STRLEN_MED];
char par1[] = "\t\t\t\t"
"\"tend\" is a command-line interface to much of the functionality "
"in \"ten\", a C library for diffusion image processing. Ten is one "
"library in the \"Teem\" collection of libraries. More information "
"about Teem is at <http://teem.sf.net>. A checkout of Teem source "
"is available via:\n "
"svn co http://svn.code.sf.net/p/teem/code/teem/trunk teem\n ";
/* "svn co http://teem.svn.sf.net/svnroot/teem/teem/trunk teem\n "; */
char par2[] = "\t\t\t\t"
"Long-term maintenance of this software depends on funding, and "
"funding depends on being able to document who is using it for what. "
"If tend or Ten has helped in your research, including for simple one-off "
"experiments or mundane data hacking, the developers of Teem would love "
"to know. There are multiple ways of communicating this. "
"In your publications, consider adding a line such as this "
"in the Acknowledgments: "
"\"Data processing performed with the tend tool, "
"part of the Teem toolkit available at "
"http://teem.sf.net\". "
"Alternatively, please email [email protected] and briefly describe "
"how Teem software has helped in your work. "
"Please also consider joining the teem-users mailing list: "
"<http://lists.sourceforge.net/lists/listinfo/teem-users>. This is "
"the primary forum for feedback, questions, and feature requests.\n ";
char par3[] = "\t\t\t\t"
"Like \"unu\", another Teem command-line binary, it is often useful "
"to chain together invocations of tend with pipes, as in the "
"following, which estimates tensors from DWIs, takes a slice of the "
"tensor volume, computes the standard RGB colormap of the principal "
"eigenvector, and then quantizes it to an 8-bit PNG:\n";
char par4[] = "\ttend estim -i dwi.nhdr -B kvp -knownB0 true \\\n "
" | tend slice -a 2 -p 30 \\\n "
" | tend evecrgb -c 0 -a cl2 -gam 1.2 \\\n "
" | unu quantize -b 8 -min 0 -max 1 -o z30-rgb.png\n";
AIR_UNUSED(argc);
AIR_UNUSED(argv);
AIR_UNUSED(me);
fprintf(stdout, "\n");
sprintf(buff, "--- %s ---", tendTitle);
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stdout, fmt, buff);
airTeemVersionSprint(buff);
sprintf(fmt, "%%%ds\n",
(int)((hparm->columns-strlen(buff))/2 + strlen(buff) - 1));
fprintf(stdout, fmt, buff);
fprintf(stdout, "\n");
_hestPrintStr(stdout, 1, 0, 78, par1, AIR_FALSE);
_hestPrintStr(stdout, 1, 0, 78, par2, AIR_FALSE);
_hestPrintStr(stdout, 1, 0, 78, par3, AIR_FALSE);
_hestPrintStr(stdout, 2, 0, 78, par4, AIR_FALSE);
return 0;
}