/*
******** unrrduHestEncodingCB
**
** for parsing output encoding, including compression flags
** enc[0]: which encoding, from nrrdEncodingType* enum
** enc[1]: for compressions: zlib "level" and bzip2 "blocksize"
** enc[2]: for zlib: strategy, from nrrdZlibStrategy* enum
*/
int
unrrduParseEncoding(void *ptr, char *_str, char err[AIR_STRLEN_HUGE]) {
char me[]="unrrduParseEncoding", *str, *opt;
int *enc;
airArray *mop;
if (!(ptr && _str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
enc = (int *)ptr;
/* these are the defaults, they may not get over-written */
enc[1] = -1;
enc[2] = nrrdZlibStrategyDefault;
enc[0] = airEnumVal(nrrdEncodingType, _str);
if (nrrdEncodingTypeUnknown != enc[0]) {
/* we're done; encoding was simple: "raw" or "gz" */
return 0;
}
mop = airMopNew();
str = airStrdup(_str);
airMopMem(mop, &str, airMopAlways);
opt = strchr(str, ':');
if (!opt) {
/* couldn't parse string as nrrdEncodingType, but there wasn't a colon */
sprintf(err, "%s: didn't recognize \"%s\" as an encoding", me, str);
airMopError(mop); return 1;
} else {
*opt = '\0';
opt++;
enc[0] = airEnumVal(nrrdEncodingType, str);
if (nrrdEncodingTypeUnknown == enc[0]) {
sprintf(err, "%s: didn't recognize \"%s\" as an encoding", me, str);
airMopError(mop); return 1;
}
if (!nrrdEncodingArray[enc[0]]->isCompression) {
sprintf(err, "%s: only compression encodings have parameters", me);
airMopError(mop); return 1;
}
while (*opt) {
if (isdigit(*opt)) {
enc[1] = *opt - '0';
} else if ('d' == tolower(*opt)) {
enc[2] = nrrdZlibStrategyDefault;
} else if ('h' == tolower(*opt)) {
enc[2] = nrrdZlibStrategyHuffman;
} else if ('f' == tolower(*opt)) {
enc[2] = nrrdZlibStrategyFiltered;
} else {
sprintf(err, "%s: parameter char \"%c\" not a digit or 'd','h','f'",
me, *opt);
airMopError(mop); return 1;
}
opt++;
}
}
airMopOkay(mop);
return 0;
}
unsigned int
airParseStrE(int *out, const char *_s, const char *ct, unsigned int n, ...)
{
unsigned int i;
char *tmp, *s, *last;
airArray *mop;
va_list ap;
airEnum *enm;
/* grab the enum every time, prior to error checking */
va_start(ap, n);
enm = va_arg(ap, airEnum *);
va_end(ap);
/* if we got NULL, there's nothing to do */
if (!(out && _s && ct))
{
return 0;
}
mop = airMopNew();
/* copy the input so that we don't change it */
s = airStrdup(_s);
airMopMem(mop, &s, airMopAlways);
if (1 == n)
{
/* Because it should be permissible to have spaces in what is
intended to be only a single string from an airEnum, we treat
1==n differently, and do NOT use airStrtok to tokenize the
input string s into spaces. We check the whole s string */
out[0] = airEnumVal(enm, s);
if (airEnumUnknown(enm) == out[0])
{
airMopError(mop);
return 0;
}
}
else
{
/* keep calling airStrtok() until we have everything */
for (i=0; i<n; i++)
{
tmp = airStrtok(i ? NULL : s, ct, &last);
if (!tmp)
{
airMopError(mop);
return i;
}
out[i] = airEnumVal(enm, tmp);
if (airEnumUnknown(enm) == out[i])
{
airMopError(mop);
return i;
}
}
}
airMopOkay(mop);
return n;
}
/*
******** unrrduHestMaybeTypeCB
**
** although nrrdType is an airEnum that hest already knows how
** to parse, we want the ability to have "unknown" be a valid
** parsable value, contrary to how airEnums usually work with hest.
** For instance, we might want to use "unknown" to represent
** "same type as the input, whatever that is".
**
** 18 July 03: with new nrrdTypeDefault, this function becomes
** less of a hack, and more necessary, because the notion of an
** unknown but valid type (as a default type is) falls squarely
** outside the nrrdType airEnum framework. Added a seperate test
** for "default", even though currently nrrdTypeUnknown is the same
** value as nrrdTypeDefault.
*/
int
unrrduParseMaybeType(void *ptr, char *str, char err[AIR_STRLEN_HUGE]) {
char me[]="unrrduParseMaybeType";
int *typeP;
/* fprintf(stderr, "!%s: str = \"%s\"\n", me, str); */
if (!(ptr && str)) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
typeP = (int*)ptr;
if (!strcmp("unknown", str)) {
*typeP = nrrdTypeUnknown;
} else if (!strcmp("default", str)) {
*typeP = nrrdTypeDefault;
} else {
*typeP = airEnumVal(nrrdType, str);
if (nrrdTypeUnknown == *typeP) {
sprintf(err, "%s: can't parse \"%s\" as type", me, str);
return 1;
}
}
/* fprintf(stderr, "!%s: *typeP = %d\n", me, *typeP); */
return 0;
}
int
_nrrdReadNrrdParse_space (FILE *file, Nrrd *nrrd,
NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParse_space", err[BIFF_STRLEN], *info;
int space;
AIR_UNUSED(file);
info = nio->line + nio->pos;
if (nio->seen[nrrdField_space_dimension]) {
sprintf(err, "%s: can't specify space after specifying "
"space dimension (%d)", me, nrrd->spaceDim);
biffAdd(NRRD, err); return 1;
}
if (!(space = airEnumVal(nrrdSpace, info))) {
sprintf(err, "%s: couldn't parse space \"%s\"", me, info);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
if (nrrdSpaceSet(nrrd, space)) {
sprintf(err, "%s: trouble", me);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
if (_nrrdFieldCheck[nrrdField_space](nrrd, useBiff)) {
sprintf(err, "%s: trouble", me);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
return 0;
}
unsigned int
airParseStrB(int *out, const char *_s, const char *ct, unsigned int n, ...)
{
unsigned int i;
char *tmp, *s, *last;
/* if we got NULL, there's nothing to do */
if (!(out && _s && ct))
return 0;
/* copy the input so that we don't change it */
s = airStrdup(_s);
/* keep calling airStrtok() until we have everything */
for (i=0; i<n; i++)
{
tmp = airStrtok(i ? NULL : s, ct, &last);
if (!tmp)
{
free(s);
return i;
}
out[i] = airEnumVal(airBool, tmp);
if (airEnumUnknown(airBool) == out[i])
{
free(s);
return i;
}
}
free(s);
return n;
}
int
nrrdGetenvBool(int *val, char **envStr, const char *envVar) {
char *env;
int tmp;
if (!(val && envVar)) {
return -1;
}
env = getenv(envVar);
if (envStr) {
*envStr = env;
}
if (!env) {
return -1;
}
if (!strlen(env)) {
/* for bools, being merely set (but not to any string) means "true" */
*val = AIR_TRUE;
return AIR_TRUE;
}
tmp = airEnumVal(airBool, env);
if (airEnumUnknown(airBool) == tmp) {
return AIR_FALSE;
} else {
*val = tmp;
return AIR_TRUE;
}
}
int
_nrrdReadNrrdParse_kinds (FILE *file, Nrrd *nrrd,
NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParse_kinds", err[BIFF_STRLEN];
unsigned int ai;
char *info, *tok, *last;
airArray *mop;
AIR_UNUSED(file);
mop = airMopNew();
info = airStrdup(nio->line + nio->pos);
airMopAdd(mop, info, airFree, airMopAlways);
_CHECK_HAVE_DIM;
for (ai=0; ai<nrrd->dim; ai++) {
tok = airStrtok(!ai ? info : NULL, _nrrdFieldSep, &last);
if (!tok) {
sprintf(err, "%s: couldn't extract string for kind %d of %d",
me, ai+1, nrrd->dim);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
if (!strcmp(tok, NRRD_UNKNOWN)) {
nrrd->axis[ai].kind = nrrdKindUnknown;
continue;
}
if (!strcmp(tok, NRRD_NONE)) {
nrrd->axis[ai].center = nrrdKindUnknown;
continue;
}
if (!(nrrd->axis[ai].kind = airEnumVal(nrrdKind, tok))) {
sprintf(err, "%s: couldn't parse \"%s\" kind %d of %d",
me, tok, ai+1, nrrd->dim);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
}
if (airStrtok(!ai ? info : NULL, _nrrdFieldSep, &last)) {
sprintf(err, "%s: seem to have more than expected %d kinds",
me, nrrd->dim);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
/* can't run this now because kinds can come before sizes, in which
case the kind/size check in _nrrdFieldCheck_kinds will incorrectly
flag an error ...
if (_nrrdFieldCheck[nrrdField_kinds](nrrd, useBiff)) {
sprintf(err, "%s: trouble", me);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
*/
airMopOkay(mop);
return 0;
}
int
_nrrdReadNrrdParse_endian (FILE *file, Nrrd *nrrd,
NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParse_endian", err[BIFF_STRLEN];
char *info;
AIR_UNUSED(file);
AIR_UNUSED(nrrd);
info = nio->line + nio->pos;
if (!(nio->endian = airEnumVal(airEndian, info))) {
sprintf(err, "%s: couldn't parse endian \"%s\"", me, info);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
return 0;
}
int
_nrrdReadNrrdParse_centers (FILE *file, Nrrd *nrrd,
NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParse_centers", err[BIFF_STRLEN];
unsigned int ai;
char *tok, *info, *last;
airArray *mop;
AIR_UNUSED(file);
mop = airMopNew();
info = airStrdup(nio->line + nio->pos);
airMopAdd(mop, info, airFree, airMopAlways);
_CHECK_HAVE_DIM;
for (ai=0; ai<nrrd->dim; ai++) {
tok = airStrtok(!ai ? info : NULL, _nrrdFieldSep, &last);
if (!tok) {
sprintf(err, "%s: couldn't extract string for center %d of %d",
me, ai+1, nrrd->dim);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
if (!strcmp(tok, NRRD_UNKNOWN)) {
nrrd->axis[ai].center = nrrdCenterUnknown;
continue;
}
if (!strcmp(tok, NRRD_NONE)) {
nrrd->axis[ai].center = nrrdCenterUnknown;
continue;
}
if (!(nrrd->axis[ai].center = airEnumVal(nrrdCenter, tok))) {
sprintf(err, "%s: couldn't parse center \"%s\" for axis %d",
me, tok, ai);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
}
if (airStrtok(!ai ? info : NULL, _nrrdFieldSep, &last)) {
sprintf(err, "%s: seem to have more than expected %d centers",
me, nrrd->dim);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
if (_nrrdFieldCheck[nrrdField_centers](nrrd, useBiff)) {
sprintf(err, "%s: trouble", me);
biffMaybeAdd(NRRD, err, useBiff); airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
_nrrdReadNrrdParse_type (FILE *file, Nrrd *nrrd,
NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParse_type", err[BIFF_STRLEN];
char *info;
AIR_UNUSED(file);
info = nio->line + nio->pos;
if (!(nrrd->type = airEnumVal(nrrdType, info))) {
sprintf(err, "%s: couldn't parse type \"%s\"", me, info);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
if (_nrrdFieldCheck[nrrdField_type](nrrd, useBiff)) {
sprintf(err, "%s: trouble", me);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
return 0;
}
int
_nrrdReadNrrdParse_encoding (FILE *file, Nrrd *nrrd,
NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParse_encoding", err[BIFF_STRLEN];
char *info;
int etype;
AIR_UNUSED(file);
AIR_UNUSED(nrrd);
info = nio->line + nio->pos;
if (!(etype = airEnumVal(nrrdEncodingType, info))) {
sprintf(err, "%s: couldn't parse encoding \"%s\"", me, info);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
nio->encoding = nrrdEncodingArray[etype];
return 0;
}
int
rvaLattSpecParse(rvaLattSpec *lsp, const char *_str) {
static const char me[]="rvaLattSpecParse";
char *col, *pstr, *str;
airArray *mop;
int smeth;
unsigned got;
if (!(lsp && _str)) {
biffAddf(RVA, "%s: got NULL pointer", me);
return 1;
}
if (!( str = airStrdup(_str) )) {
biffAddf(RVA, "%s: couldn't strdup", me);
return 1;
}
mop = airMopNew();
airMopAdd(mop, str, airFree, airMopAlways);
col = strchr(str, ':');
if (!col) {
biffAddf(RVA, "%s: didn't see \":\" separator in \"%s\" between "
"lattice specification method and parameters", me, _str);
airMopError(mop); return 1;
}
*col = '\0';
lsp->latt = airEnumVal(rvaLatt, str);
if (rvaLattUnknown == lsp->latt) {
biffAddf(RVA, "%s: didn't recognize \"%s\" as a %s", me,
str, rvaLatt->name);
airMopError(mop); return 1;
}
pstr = col + 1;
got = airParseStrD(lsp->parm, pstr, ",", rvaLattParmNum[lsp->latt]);
if (got != rvaLattParmNum[lsp->latt]) {
biffAddf(RVA, "%s: got %u (not %u) parms in \"%s\"", me,
got, rvaLattParmNum[lsp->latt], _str);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
nrrdGetenvEnum(int *val, char **envStr, const airEnum *enm,
const char *envVar) {
char *env;
int tmp;
if (!(val && envVar)) {
return -1;
}
env = getenv(envVar);
if (envStr) {
*envStr = env;
}
if (!env) {
return -1;
}
tmp = airEnumVal(enm, env);
if (airEnumUnknown(enm) == tmp) {
return AIR_FALSE;
} else {
*val = tmp;
return AIR_TRUE;
}
}
/*
** _nrrdReadNrrdParseField()
**
** This is for parsing the stuff BEFORE the colon
*/
int
_nrrdReadNrrdParseField (NrrdIoState *nio, int useBiff) {
char me[]="_nrrdReadNrrdParseField", err[BIFF_STRLEN], *next,
*buff, *colon, *keysep;
int ret, fld=nrrdField_unknown, noField, badField=AIR_FALSE;
next = nio->line + nio->pos;
/* determining if the line is a comment is simple */
if (NRRD_COMMENT_CHAR == next[0]) {
return nrrdField_comment;
}
if (!( buff = airStrdup(next) )) {
sprintf(err, "%s: couldn't allocate buffer!", me);
biffMaybeAdd(NRRD, err, useBiff); return nrrdField_unknown;
}
/* #1: "...if you see a colon, then look for an equal sign..." */
/* Look for colon: if no colon, or failed to parse as a field, look for
* equal sign, if that failed then error */
/* Let the separator be := */
/* Escape \n */
colon = strstr(buff, ": ");
noField = !colon;
if (colon) {
*colon = '\0';
badField = ( nrrdField_unknown == (fld = airEnumVal(nrrdField, buff)) );
}
if (noField || badField) {
keysep = strstr(buff, ":=");
if (!keysep) {
if (noField) {
sprintf(err, "%s: didn't see \": \" or \":=\" in line", me);
} else {
sprintf(err, "%s: failed to parse \"%s\" as field identifier",
me, buff);
}
free(buff); biffMaybeAdd(NRRD, err, useBiff); return nrrdField_unknown;
}
free(buff);
ret = nrrdField_keyvalue;
} else {
/* *colon = '\0'; */
/* else we successfully parsed a field identifier */
next += strlen(buff) + 2;
free(buff);
/* skip whitespace prior to start of first field descriptor */
next += strspn(next, _nrrdFieldSep);
nio->pos = next - nio->line;
ret = fld;
}
return ret;
}
int
unrrdu_basinfoMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
/* these are stock for unrrdu */
hestOpt *opt = NULL;
airArray *mop;
int pret;
char *err;
/* these are stock for things using the usual -i and -o */
char *out;
Nrrd *nin, *nout;
/* these are specific to this command */
NrrdIoState *nio;
char *spcStr, *_origStr, *origStr;
int space;
unsigned int spaceDim;
hestOptAdd(&opt, "spc,space", "space", airTypeString, 1, 1, &spcStr, "",
"identify the space (e.g. \"RAS\", \"LPS\") in which the array "
"conceptually lives, from the nrrdSpace airEnum, which in turn "
"determines the dimension of the space. Or, use an integer>0 to"
"give the dimension of a space that nrrdSpace doesn't know about. "
"By default (not using this option), the enclosing space is "
"set as unknown.");
hestOptAdd(&opt, "orig,origin", "origin", airTypeString, 1, 1, &_origStr, "",
"(NOTE: must quote vector) the origin in space of the array: "
"the location of the center "
"of the first sample, of the form \"(x,y,z)\" (or however "
"many coefficients are needed for the chosen space). Quoting the "
"vector is needed to stop interpretation from the shell");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
nio = nrrdIoStateNew();
airMopAdd(mop, nio, (airMopper)nrrdIoStateNix, airMopAlways);
USAGE(_unrrdu_basinfoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error copying input:\n%s", me, err);
airMopError(mop);
return 1;
}
/* HEY: copy and paste from unrrdu/make.c */
if (airStrlen(spcStr)) {
space = airEnumVal(nrrdSpace, spcStr);
if (!space) {
/* couldn't parse it as space, perhaps its a uint */
if (1 != sscanf(spcStr, "%u", &spaceDim)) {
fprintf(stderr, "%s: couldn't parse \"%s\" as a nrrdSpace "
"or as a uint", me, spcStr);
airMopError(mop); return 1;
}
/* else we did parse it as a uint */
nout->space = nrrdSpaceUnknown;
nout->spaceDim = spaceDim;
} else {
/* we did parse a known space */
nrrdSpaceSet(nout, space);
}
}
/* HEY: copy and paste from unrrdu/make.c */
if (airStrlen(_origStr)) {
/* why this is necessary is a bit confusing to me, both the check for
enclosing quotes, and the need to use to a separate variable (isn't
hest doing memory management of addresses, not variables?) */
if ('\"' == _origStr[0] && '\"' == _origStr[strlen(_origStr)-1]) {
_origStr[strlen(_origStr)-1] = 0;
origStr = _origStr + 1;
} else {
origStr = _origStr;
}
/* same hack about using NrrdIoState->line as basis for parsing */
nio->line = origStr;
nio->pos = 0;
if (nrrdFieldInfoParse[nrrdField_space_origin](NULL, nout,
nio, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble with origin \"%s\":\n%s",
me, origStr, err);
nio->line = NULL; airMopError(mop); return 1;
}
nio->line = NULL;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
gageKind *kind;
const char *me;
char *whatS, *err, *outS, *stackReadFormat, *stackSaveFormat;
hestParm *hparm;
hestOpt *hopt = NULL;
NrrdKernelSpec *k00, *k11, *k22, *kSS, *kSSblur;
int what, E=0, renorm, SSuniform, SSoptim, verbose, zeroZ,
orientationFromSpacing, SSnormd;
unsigned int iBaseDim, oBaseDim, axi, numSS, ninSSIdx, seed;
const double *answer;
Nrrd *nin, *nout, **ninSS=NULL;
Nrrd *ngrad=NULL, *nbmat=NULL;
size_t ai, ansLen, idx, xi, yi, zi, six, siy, siz, sox, soy, soz;
double bval=0, gmc, rangeSS[2], wrlSS, idxSS=AIR_NAN,
dsix, dsiy, dsiz, dsox, dsoy, dsoz;
gageContext *ctx;
gagePerVolume *pvl=NULL;
double t0, t1, x, y, z, scale[3], rscl[3], min[3], maxOut[3], maxIn[3];
airArray *mop;
unsigned int hackZi, *skip, skipNum;
double (*ins)(void *v, size_t I, double d);
gageStackBlurParm *sbp;
char hackKeyStr[]="TEEM_VPROBE_HACK_ZI", *hackValStr;
int otype, hackSet;
char stmp[4][AIR_STRLEN_SMALL];
me = argv[0];
/* parse environment variables first, in case they break nrrdDefault*
or nrrdState* variables in a way that nrrdSanity() should see */
nrrdDefaultGetenv();
nrrdStateGetenv();
/* no harm done in making sure we're sane */
if (!nrrdSanity()) {
fprintf(stderr, "******************************************\n");
fprintf(stderr, "******************************************\n");
fprintf(stderr, "\n");
fprintf(stderr, " %s: nrrd sanity check FAILED.\n", me);
fprintf(stderr, "\n");
fprintf(stderr, " This means that either nrrd can't work on this "
"platform, or (more likely)\n");
fprintf(stderr, " there was an error in the compilation options "
"and variable definitions\n");
fprintf(stderr, " for how Teem was built here.\n");
fprintf(stderr, "\n");
fprintf(stderr, " %s\n", err = biffGetDone(NRRD));
fprintf(stderr, "\n");
fprintf(stderr, "******************************************\n");
fprintf(stderr, "******************************************\n");
free(err);
return 1;
}
mop = airMopNew();
hparm = hestParmNew();
airMopAdd(mop, hparm, AIR_CAST(airMopper, hestParmFree), airMopAlways);
hparm->elideSingleOtherType = AIR_TRUE;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", "
"\"tensor\", or \"dwi\")",
NULL, NULL, meetHestGageKind);
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1, &verbose, "1",
"verbosity level");
hestOptAdd(&hopt, "q", "query", airTypeString, 1, 1, &whatS, NULL,
"the quantity (scalar, vector, or matrix) to learn by probing");
hestOptAdd(&hopt, "s", "sclX sclY sxlZ", airTypeDouble, 3, 3, scale,
"1.0 1.0 1.0",
"scaling factor for resampling on each axis "
"(>1.0 : supersampling)");
hestOptAdd(&hopt, "k00", "kern00", airTypeOther, 1, 1, &k00,
"tent", "kernel for gageKernel00",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kern11", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "kernel for gageKernel11",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kern22", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "kernel for gageKernel22",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "seed", "N", airTypeUInt, 1, 1, &seed, "42",
"RNG seed; mostly for debugging");
hestOptAdd(&hopt, "zz", "bool", airTypeBool, 1, 1, &zeroZ, "false",
"enable \"zeroZ\" behavior in gage that partially "
"implements working with 3D images as if they are 2D");
hestOptAdd(&hopt, "ssn", "SS #", airTypeUInt, 1, 1, &numSS,
"0", "how many scale-space samples to evaluate, or, "
"0 to turn-off all scale-space behavior");
hestOptAdd(&hopt, "ssr", "scale range", airTypeDouble, 2, 2, rangeSS,
"nan nan", "range of scales in scale-space");
hestOptAdd(&hopt, "ssrf", "SS read format", airTypeString, 1, 1,
&stackReadFormat, "",
"printf-style format (including a \"%u\") for the "
"filenames from which to *read* "
"pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "sssf", "SS save format", airTypeString, 1, 1,
&stackSaveFormat, "",
"printf-style format (including a \"%u\") for the "
"filenames in which to *save* "
"pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "ssw", "SS pos", airTypeDouble, 1, 1, &wrlSS, "0",
"\"world\"-space position (true sigma) "
"at which to sample in scale-space");
hestOptAdd(&hopt, "kssb", "kernel", airTypeOther, 1, 1, &kSSblur,
"dgauss:1,5", "blurring kernel, to sample scale space",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kssr", "kernel", airTypeOther, 1, 1, &kSS,
"hermite", "kernel for reconstructing from scale space samples",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "ssu", NULL, airTypeInt, 0, 0, &SSuniform, NULL,
"do uniform samples along sigma, and not (by default) "
"samples according to the effective diffusion scale");
hestOptAdd(&hopt, "sso", NULL, airTypeInt, 0, 0, &SSoptim, NULL,
"if not using \"-ssu\", use pre-computed optimal "
"sigmas when possible");
hestOptAdd(&hopt, "ssnd", NULL, airTypeInt, 0, 0, &SSnormd, NULL,
"normalize derivatives by scale");
hestOptAdd(&hopt, "rn", NULL, airTypeInt, 0, 0, &renorm, NULL,
"renormalize kernel weights at each new sample location. "
"\"Accurate\" kernels don't need this; doing it always "
"makes things go slower");
hestOptAdd(&hopt, "gmc", "min gradmag", airTypeDouble, 1, 1, &gmc,
"0.0", "For curvature-based queries, use zero when gradient "
"magnitude is below this");
hestOptAdd(&hopt, "ofs", "ofs", airTypeInt, 0, 0, &orientationFromSpacing,
NULL, "If only per-axis spacing is available, use that to "
"contrive full orientation info");
hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &otype, "float",
"type of output volume", NULL, nrrdType);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output volume");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, probeInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestOptFree), airMopAlways);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestParseFree), airMopAlways);
what = airEnumVal(kind->enm, whatS);
if (!what) {
/* 0 indeed always means "unknown" for any gageKind */
fprintf(stderr, "%s: couldn't parse \"%s\" as measure of \"%s\" volume\n",
me, whatS, kind->name);
hestUsage(stderr, hopt, me, hparm);
hestGlossary(stderr, hopt, hparm);
airMopError(mop);
return 1;
}
/* special set-up required for DWI kind */
if (!strcmp(TEN_DWI_GAGE_KIND_NAME, kind->name)) {
if (tenDWMRIKeyValueParse(&ngrad, &nbmat, &bval, &skip, &skipNum, nin)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (skipNum) {
fprintf(stderr, "%s: sorry, can't do DWI skipping in tenDwiGage", me);
airMopError(mop); return 1;
}
/* this could stand to use some more command-line arguments */
if (tenDwiGageKindSet(kind, 50, 1, bval, 0.001, ngrad, nbmat,
tenEstimate1MethodLLS,
tenEstimate2MethodQSegLLS, seed)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* for setting up pre-blurred scale-space samples */
if (numSS) {
unsigned int vi;
sbp = gageStackBlurParmNew();
airMopAdd(mop, sbp, (airMopper)gageStackBlurParmNix, airMopAlways);
ninSS = AIR_CAST(Nrrd **, calloc(numSS, sizeof(Nrrd *)));
if (!ninSS) {
fprintf(stderr, "%s: couldn't allocate ninSS", me);
airMopError(mop); return 1;
}
for (ninSSIdx=0; ninSSIdx<numSS; ninSSIdx++) {
ninSS[ninSSIdx] = nrrdNew();
airMopAdd(mop, ninSS[ninSSIdx], (airMopper)nrrdNuke, airMopAlways);
}
if (gageStackBlurParmScaleSet(sbp, numSS, rangeSS[0], rangeSS[1],
SSuniform, SSoptim)
|| gageStackBlurParmKernelSet(sbp, kSSblur)
|| gageStackBlurParmRenormalizeSet(sbp, AIR_TRUE)
|| gageStackBlurParmBoundarySet(sbp, nrrdBoundaryBleed, AIR_NAN)
|| gageStackBlurParmVerboseSet(sbp, verbose)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble with stack blur info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (airStrlen(stackReadFormat)) {
if (nrrdLoadMulti(ninSS, numSS,
stackReadFormat, 0, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble loading blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (gageStackBlurCheck(AIR_CAST(const Nrrd *const*, ninSS),
sbp, nin, kind)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
} else {
if (gageStackBlur(ninSS, sbp, nin, kind)) {
int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
char *outS[3];
char *gravStr, *gravGradStr, *seedStr;
pushContext *pctx;
Nrrd *_nin, *nin, *nPosIn, *nPosOut, *nTenOut, *nEnrOut;
NrrdKernelSpec *ksp00, *ksp11, *ksp22;
pushEnergySpec *ensp;
int E;
me = argv[0];
mop = airMopNew();
pctx = pushContextNew();
airMopAdd(mop, pctx, (airMopper)pushContextNix, airMopAlways);
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &_nin, NULL,
"input volume to filter", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "np", "# points", airTypeUInt, 1, 1,
&(pctx->pointNum), "1000",
"number of points to use in simulation");
hestOptAdd(&hopt, "pi", "npos", airTypeOther, 1, 1, &nPosIn, "",
"positions to start at (overrides \"-np\")",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "step", "step", airTypeDouble, 1, 1,
&(pctx->stepInitial), "1",
"step size for gradient descent");
hestOptAdd(&hopt, "scl", "scale", airTypeDouble, 1, 1,
&(pctx->scale), "1500",
"scaling from tensor size to glyph size");
hestOptAdd(&hopt, "wall", "wall", airTypeDouble, 1, 1,
&(pctx->wall), "0.0",
"spring constant of containing walls");
hestOptAdd(&hopt, "cnts", "scale", airTypeDouble, 1, 1,
&(pctx->cntScl), "0.0",
"scaling of containment force");
hestOptAdd(&hopt, "limit", "frac", airTypeDouble, 1, 1,
&(pctx->deltaLimit), "0.3",
"speed limit on particles' motion");
hestOptAdd(&hopt, "dfmin", "frac", airTypeDouble, 1, 1,
&(pctx->deltaFracMin), "0.2",
"decrease step size if deltaFrac goes below this");
hestOptAdd(&hopt, "esf", "frac", airTypeDouble, 1, 1,
&(pctx->energyStepFrac), "0.9",
"when energy goes up instead of down, fraction by "
"which to scale step size");
hestOptAdd(&hopt, "dfsf", "frac", airTypeDouble, 1, 1,
&(pctx->deltaFracStepFrac), "0.5",
"when deltaFrac goes below deltaFracMin, fraction by "
"which to scale step size");
hestOptAdd(&hopt, "eimin", "frac", airTypeDouble, 1, 1,
&(pctx->energyImprovMin), "0.01",
"convergence threshold: stop when fracional improvement "
"(decrease) in energy dips below this");
hestOptAdd(&hopt, "detr", NULL, airTypeBool, 0, 0,
&(pctx->detReject), NULL,
"do determinant-based rejection of initial sample locations");
hestOptAdd(&hopt, "rng", "seed", airTypeUInt, 1, 1,
&(pctx->seedRNG), "42",
"seed value for RNG which determines initial point locations");
hestOptAdd(&hopt, "nt", "# threads", airTypeUInt, 1, 1,
&(pctx->threadNum), "1",
"number of threads to run");
hestOptAdd(&hopt, "nprob", "# iters", airTypeDouble, 1, 1,
&(pctx->neighborTrueProb), "1.0",
"do full neighbor traversal with this probability");
hestOptAdd(&hopt, "pprob", "# iters", airTypeDouble, 1, 1,
&(pctx->probeProb), "1.0",
"do field probing with this probability");
hestOptAdd(&hopt, "maxi", "# iters", airTypeUInt, 1, 1,
&(pctx->maxIter), "0",
"if non-zero, max # iterations to run");
hestOptAdd(&hopt, "snap", "iters", airTypeUInt, 1, 1, &(pctx->snap), "0",
"if non-zero, # iterations between which a snapshot "
"is saved");
hestOptAdd(&hopt, "grv", "item", airTypeString, 1, 1, &gravStr, "none",
"item to act as gravity");
hestOptAdd(&hopt, "grvgv", "item", airTypeString, 1, 1, &gravGradStr, "none",
"item to act as gravity gradient");
hestOptAdd(&hopt, "grvs", "scale", airTypeDouble, 1, 1, &(pctx->gravScl),
"nan", "magnitude and scaling of gravity vector");
hestOptAdd(&hopt, "grvz", "scale", airTypeDouble, 1, 1, &(pctx->gravZero),
"nan", "height (WRT gravity) of zero potential energy");
hestOptAdd(&hopt, "seed", "item", airTypeString, 1, 1, &seedStr, "none",
"item to act as seed threshold");
hestOptAdd(&hopt, "seedth", "thresh", airTypeDouble, 1, 1,
&(pctx->seedThresh), "nan",
"seed threshold threshold");
hestOptAdd(&hopt, "energy", "spec", airTypeOther, 1, 1, &ensp, "cotan",
"specification of energy function to use",
NULL, NULL, pushHestEnergySpec);
hestOptAdd(&hopt, "nobin", NULL, airTypeBool, 0, 0,
&(pctx->binSingle), NULL,
"turn off spatial binning (which prevents multi-threading "
"from being useful), for debugging or speed-up measurement");
hestOptAdd(&hopt, "k00", "kernel", airTypeOther, 1, 1, &ksp00,
"tent", "kernel for tensor field sampling",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kernel", airTypeOther, 1, 1, &ksp11,
"fordif", "kernel for finding containment gradient from mask",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kernel", airTypeOther, 1, 1, &ksp22,
"cubicdd:1,0", "kernel for 2nd derivatives",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "o", "nout", airTypeString, 3, 3, outS,
"p.nrrd t.nrrd e.nrrd",
"output files to save position and tensor info into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nPosOut = nrrdNew();
airMopAdd(mop, nPosOut, (airMopper)nrrdNuke, airMopAlways);
nTenOut = nrrdNew();
airMopAdd(mop, nTenOut, (airMopper)nrrdNuke, airMopAlways);
nEnrOut = nrrdNew();
airMopAdd(mop, nEnrOut, (airMopper)nrrdNuke, airMopAlways);
if (3 == _nin->spaceDim && AIR_EXISTS(_nin->measurementFrame[0][0])) {
nin = nrrdNew();
airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
if (tenMeasurementFrameReduce(nin, _nin)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble undoing measurement frame:\n%s", me, err);
airMopError(mop);
exit(1);
}
} else {
nin = _nin;
}
pctx->nin = nin;
pctx->npos = nPosIn;
pctx->verbose = 0;
pctx->binIncr = 84; /* random small-ish value */
pushEnergySpecSet(pctx->ensp, ensp->energy, ensp->parm);
nrrdKernelSpecSet(pctx->ksp00, ksp00->kernel, ksp00->parm);
nrrdKernelSpecSet(pctx->ksp11, ksp11->kernel, ksp11->parm);
nrrdKernelSpecSet(pctx->ksp22, ksp22->kernel, ksp22->parm);
if (strcmp("none", gravStr)) {
pctx->gravItem = airEnumVal(tenGage, gravStr);
if (tenGageUnknown == pctx->gravItem) {
fprintf(stderr, "%s: couldn't parse \"%s\" as a %s (gravity)\n", me,
gravStr, tenGage->name);
airMopError(mop);
return 1;
}
pctx->gravGradItem = airEnumVal(tenGage, gravGradStr);
if (tenGageUnknown == pctx->gravGradItem) {
fprintf(stderr, "%s: couldn't parse \"%s\" as a %s (gravity grad)\n",
me, gravGradStr, tenGage->name);
airMopError(mop);
return 1;
}
} else {
pctx->gravItem = tenGageUnknown;
pctx->gravGradItem = tenGageUnknown;
pctx->gravZero = AIR_NAN;
pctx->gravScl = AIR_NAN;
}
if (strcmp("none", seedStr)) {
pctx->seedThreshItem = airEnumVal(tenGage, seedStr);
if (tenGageUnknown == pctx->seedThreshItem) {
fprintf(stderr, "%s: couldn't parse \"%s\" as a %s (seedthresh)\n", me,
seedStr, tenGage->name);
airMopError(mop);
return 1;
}
} else {
pctx->seedThreshItem = 0;
pctx->seedThresh = AIR_NAN;
}
E = 0;
if (!E) E |= pushStart(pctx);
if (!E) E |= pushRun(pctx);
if (!E) E |= pushOutputGet(nPosOut, nTenOut, nEnrOut, pctx);
if (!E) E |= pushFinish(pctx);
if (E) {
airMopAdd(mop, err = biffGetDone(PUSH), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "%s: time for %d iterations= %g secs\n",
me, pctx->iter, pctx->timeRun);
if (nrrdSave(outS[0], nPosOut, NULL)
|| nrrdSave(outS[1], nTenOut, NULL)
|| nrrdSave(outS[2], nEnrOut, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
int
pushEnergySpecParse(pushEnergySpec *ensp, const char *_str) {
char me[]="pushEnergySpecParse", err[BIFF_STRLEN];
char *str, *col, *_pstr, *pstr;
int etype;
unsigned int pi, haveParm;
airArray *mop;
double pval;
if (!( ensp && _str )) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(PUSH, err);
return 1;
}
/* see if its the name of something that needs no parameters */
etype = airEnumVal(pushEnergyType, _str);
if (pushEnergyTypeUnknown != etype) {
/* the string is the name of some energy */
ensp->energy = pushEnergyAll[etype];
if (0 != ensp->energy->parmNum) {
sprintf(err, "%s: need %u parms for %s energy, but got none", me,
ensp->energy->parmNum, ensp->energy->name);
biffAdd(PUSH, err);
return 1;
}
/* the energy needs 0 parameters */
for (pi=0; pi<PUSH_ENERGY_PARM_NUM; pi++) {
ensp->parm[pi] = AIR_NAN;
}
return 0;
}
/* start parsing parms after ':' */
mop = airMopNew();
str = airStrdup(_str);
airMopAdd(mop, str, (airMopper)airFree, airMopAlways);
col = strchr(str, ':');
if (!col) {
sprintf(err, "%s: \"%s\" isn't a parameter-free energy, but it has no "
"\":\" separator to indicate parameters", me, str);
biffAdd(PUSH, err);
airMopError(mop);
return 1;
}
*col = '\0';
etype = airEnumVal(pushEnergyType, str);
if (pushEnergyTypeUnknown == etype) {
sprintf(err, "%s: didn't recognize \"%s\" as a %s", me,
str, pushEnergyType->name);
biffAdd(PUSH, err);
airMopError(mop);
return 1;
}
ensp->energy = pushEnergyAll[etype];
if (0 == ensp->energy->parmNum) {
sprintf(err, "%s: \"%s\" energy has no parms, but got something", me,
ensp->energy->name);
biffAdd(PUSH, err);
return 1;
}
_pstr = pstr = col+1;
/* code lifted from teem/src/nrrd/kernel.c, should probably refactor... */
for (haveParm=0; haveParm<ensp->energy->parmNum; haveParm++) {
if (!pstr) {
break;
}
if (1 != sscanf(pstr, "%lg", &pval)) {
sprintf(err, "%s: trouble parsing \"%s\" as double (in \"%s\")",
me, _pstr, _str);
biffAdd(PUSH, err);
airMopError(mop);
return 1;
}
ensp->parm[haveParm] = pval;
if ((pstr = strchr(pstr, ','))) {
pstr++;
if (!*pstr) {
sprintf(err, "%s: nothing after last comma in \"%s\" (in \"%s\")",
me, _pstr, _str);
biffAdd(PUSH, err);
airMopError(mop);
return 1;
}
}
}
/* haveParm is now the number of parameters that were parsed. */
if (haveParm < ensp->energy->parmNum) {
sprintf(err, "%s: parsed only %u of %u required parms (for %s energy)"
"from \"%s\" (in \"%s\")",
me, haveParm, ensp->energy->parmNum,
ensp->energy->name, _pstr, _str);
biffAdd(PUSH, err);
airMopError(mop);
return 1;
} else {
if (pstr) {
sprintf(err, "%s: \"%s\" (in \"%s\") has more than %u doubles",
me, _pstr, _str, ensp->energy->parmNum);
biffAdd(PUSH, err);
airMopError(mop);
return 1;
}
}
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
const char *me;
char *err, *outS;
hestOpt *hopt=NULL;
airArray *mop;
limnPolyData *pld, *pldSub;
gageContext *gctx=NULL;
gagePerVolume *pvl;
Nrrd *nin, *nmeas;
double kparm[3], strength, scaling[3];
seekContext *sctx;
FILE *file;
unsigned int ncc;
size_t samples[3];
gageKind *kind;
char *itemGradS; /* , *itemEvalS[2], *itemEvecS[2]; */
int itemGrad; /* , itemEval[2], itemEvec[2]; */
int E;
me = argv[0];
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume to analyze",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", \"tensor\")",
NULL, NULL, &probeKindHestCB);
hestOptAdd(&hopt, "s", "strength", airTypeDouble, 1, 1, &strength, "0.01",
"strength");
hestOptAdd(&hopt, "gi", "grad item", airTypeString, 1, 1, &itemGradS, NULL,
"item for gradient vector");
hestOptAdd(&hopt, "c", "scaling", airTypeDouble, 3, 3, scaling, "1 1 1",
"amount by which to up/down-sample on each spatial axis");
hestOptAdd(&hopt, "n", "# CC", airTypeUInt, 1, 1, &ncc, "0",
"if non-zero, number of CC to save");
hestOptAdd(&hopt, "o", "output LMPD", airTypeString, 1, 1, &outS, "out.lmpd",
"output file to save LMPD into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
itemGrad = airEnumVal(kind->enm, itemGradS);
pld = limnPolyDataNew();
airMopAdd(mop, pld, (airMopper)limnPolyDataNix, airMopAlways);
pldSub = limnPolyDataNew();
airMopAdd(mop, pldSub, (airMopper)limnPolyDataNix, airMopAlways);
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
sctx = seekContextNew();
airMopAdd(mop, sctx, (airMopper)seekContextNix, airMopAlways);
gctx = gageContextNew();
airMopAdd(mop, gctx, (airMopper)gageContextNix, airMopAlways);
ELL_3V_SET(kparm, 1, 1.0, 0.0);
if (!(pvl = gagePerVolumeNew(gctx, nin, kind))
|| gagePerVolumeAttach(gctx, pvl)
|| gageKernelSet(gctx, gageKernel00, nrrdKernelBCCubic, kparm)
|| gageKernelSet(gctx, gageKernel11, nrrdKernelBCCubicD, kparm)
|| gageKernelSet(gctx, gageKernel22, nrrdKernelBCCubicDD, kparm)
|| gageQueryItemOn(gctx, pvl, itemGrad)
|| gageQueryItemOn(gctx, pvl, gageSclHessEval)
|| gageQueryItemOn(gctx, pvl, gageSclHessEval2)
|| gageQueryItemOn(gctx, pvl, gageSclHessEvec)
|| gageQueryItemOn(gctx, pvl, gageSclHessEvec2)
|| gageUpdate(gctx)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
seekVerboseSet(sctx, 10);
E = 0;
if (!E) E |= seekDataSet(sctx, NULL, gctx, 0);
ELL_3V_SET(samples,
scaling[0]*nin->axis[kind->baseDim + 0].size,
scaling[1]*nin->axis[kind->baseDim + 1].size,
scaling[2]*nin->axis[kind->baseDim + 2].size);
if (!E) E |= seekSamplesSet(sctx, samples);
if (!E) E |= seekItemGradientSet(sctx, itemGrad);
if (!E) E |= seekItemEigensystemSet(sctx, gageSclHessEval,
gageSclHessEvec);
if (!E) E |= seekItemNormalSet(sctx, gageSclHessEvec2);
if (!E) E |= seekStrengthUseSet(sctx, AIR_TRUE);
if (!E) E |= seekStrengthSet(sctx, -1, strength);
if (!E) E |= seekItemStrengthSet(sctx, gageSclHessEval2);
if (!E) E |= seekNormalsFindSet(sctx, AIR_TRUE);
if (!E) E |= seekTypeSet(sctx, seekTypeRidgeSurface);
if (!E) E |= seekUpdate(sctx);
if (!E) E |= seekExtract(sctx, pld);
if (E) {
airMopAdd(mop, err = biffGetDone(SEEK), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
fprintf(stderr, "%s: extraction time = %g\n", me, sctx->time);
nmeas = nrrdNew();
airMopAdd(mop, nmeas, (airMopper)nrrdNuke, airMopAlways);
if (limnPolyDataVertexWindingFix(pld, AIR_TRUE)
|| limnPolyDataVertexWindingFlip(pld)
|| limnPolyDataVertexNormals(pld)
|| limnPolyDataCCFind(pld)
|| limnPolyDataPrimitiveArea(nmeas, pld)
|| limnPolyDataPrimitiveSort(pld, nmeas)) {
err = biffGetDone(LIMN);
fprintf(stderr, "%s: trouble sorting:\n%s", me, err);
free(err);
}
if (ncc > 1) {
double *meas;
unsigned int ccIdx;
nrrdSave("meas.nrrd", nmeas, NULL);
ncc = AIR_MIN(ncc, nmeas->axis[0].size);
meas = AIR_CAST(double *, nmeas->data);
for (ccIdx=ncc; ccIdx<nmeas->axis[0].size; ccIdx++) {
meas[ccIdx] = 0.0;
}
if (!E) E |= limnPolyDataPrimitiveSelect(pldSub, pld, nmeas);
if (!E) E |= limnPolyDataWriteLMPD(file, pldSub);
} else {
/*
******** miteVariableParse()
**
** takes a string (usually the label from a nrrd axis) and parses it
** to determine the gageItemSpec from it (which means finding the
** kind and item). The valid formats are:
**
** "" : NULL kind, 0 item
** <item> : miteValGageKind (DEPRECATED)
** mite(<item>) : miteValGageKind
** gage(<item>) : gageKindScl (DEPRECATED)
** gage(scalar:<item>) : gageKindScl
** gage(vector:<item>) : gageKindVec
** gage(tensor:<item>) : tenGageKind
**
** Notice that "scalar", "vector", and "tensor" do NOT refer to the type
** of the quantity being measured, but rather to the type of volume in
** which quantity is measured (i.e., the gageKind used)
*/
int
miteVariableParse(gageItemSpec *isp, const char *label) {
static const char me[]="miteVariableParse";
char *buff, *endparen, *kqstr, *col, *kstr, *qstr;
airArray *mop;
if (!( isp && label )) {
biffAddf(MITE, "%s: got NULL pointer", me);
return 1;
}
if (0 == strlen(label)) {
/* nothing was specified; we try to indicate that by mimicking
the return of gageItemSpecNew() */
isp->item = 0;
isp->kind = NULL;
return 0;
}
/* else given string was non-empty */
mop = airMopNew();
buff = airStrdup(label);
if (!buff) {
biffAddf(MITE, "%s: couldn't strdup label!", me);
airMopError(mop); return 1;
}
airMopAdd(mop, buff, airFree, airMopAlways);
if (strstr(buff, "gage(") == buff) {
/* txf domain variable is to be measured directly by gage */
if (!(endparen = strstr(buff, ")"))) {
biffAddf(MITE, "%s: didn't see close paren after \"gage(\"", me);
airMopError(mop); return 1;
}
*endparen = 0;
kqstr = buff + strlen("gage(");
/* first see if its a (deprecated) gageKindScl specification */
isp->item = airEnumVal(gageScl, kqstr);
if (0 != isp->item) {
isp->kind = gageKindScl;
fprintf(stderr, "\n%s: WARNING: deprecated use of txf domain "
"\"gage(%s)\" without explicit gage kind specification; "
"should use \"gage(%s:%s)\" instead\n\n",
me, kqstr, gageKindScl->name, kqstr);
} else {
/* should be of form "<kind>:<item>" */
col = strstr(kqstr, ":");
if (!col) {
biffAddf(MITE, "%s: didn't see \":\" separator between gage "
"kind and item", me);
airMopError(mop); return 1;
}
*col = 0;
kstr = kqstr;
qstr = col+1;
if (!strcmp(gageKindScl->name, kstr)) {
isp->kind = gageKindScl;
} else if (!strcmp(gageKindVec->name, kstr)) {
isp->kind = gageKindVec;
} else if (!strcmp(tenGageKind->name, kstr)) {
isp->kind = tenGageKind;
} else {
biffAddf(MITE, "%s: don't recognized \"%s\" gage kind", me, kstr);
airMopError(mop); return 1;
}
isp->item = airEnumVal(isp->kind->enm, qstr);
if (0 == isp->item) {
biffAddf(MITE, "%s: couldn't parse \"%s\" as a %s variable",
me, qstr, isp->kind->name);
airMopError(mop); return 1;
}
}
} else if (strstr(buff, "mite(") == buff) {
/* txf domain variable is *not* directly measured by gage */
if (!(endparen = strstr(buff, ")"))) {
biffAddf(MITE, "%s: didn't see close paren after \"mite(\"", me);
airMopError(mop); return 1;
}
*endparen = 0;
qstr = buff + strlen("mite(");
isp->item = airEnumVal(miteVal, qstr);
if (0 == isp->item) {
biffAddf(MITE, "%s: couldn't parse \"%s\" as a miteVal variable",
me, qstr);
airMopError(mop); return 1;
}
isp->kind = miteValGageKind;
} else {
/* didn't start with "gage(" or "mite(" */
isp->item = airEnumVal(miteVal, label);
if (0 != isp->item) {
/* its measured by mite */
isp->kind = miteValGageKind;
fprintf(stderr, "\n%s: WARNING: deprecated use of txf domain "
"\"%s\"; should use \"mite(%s)\" instead\n\n",
me, label, label);
} else {
biffAddf(MITE, "%s: \"%s\" not a recognized variable", me, label);
airMopError(mop); return 1;
}
}
airMopOkay(mop);
return 0;
}
int
unrrdu_axinfoMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err, *label, *units, *centerStr, *kindStr;
Nrrd *nin, *nout;
int pret, center, kind;
unsigned int *axes, axesLen, axi;
double mm[2], spc;
airArray *mop;
hestOptAdd(&opt, "a,axes", "ax0", airTypeUInt, 1, -1, &axes, NULL,
"the one or more axes that should be modified", &axesLen);
hestOptAdd(&opt, "l,label", "label", airTypeString, 1, 1, &label, "",
"label to associate with axis");
hestOptAdd(&opt, "u,units", "units", airTypeString, 1, 1, &units, "",
"units of measurement");
hestOptAdd(&opt, "mm,minmax", "min max", airTypeDouble, 2, 2, mm, "nan nan",
"min and max values along axis");
hestOptAdd(&opt, "sp,spacing", "spacing", airTypeDouble, 1, 1, &spc, "nan",
"spacing between samples along axis");
/* HEY: this is currently a fundamental (but only rarely annoying)
problem in hest. Because there is functionally no difference
between whether an option's information comes from the default
string or from the command-line, there is no real way to tell
hest, "hey, its just fine for this option to not be used, and
if its not used, DON'T DO ANYTHING". The games of setting strings
to "" and floats/doubles to NaN are ways of compensating for
this. However, there is no analogous trick for airEnums.
hestOptAdd(&opt, "c,center", "center", airTypeEnum, 1, 1, ¢, "unknown",
"centering of axis: \"cell\" or \"node\"",
NULL, nrrdCenter);
*/
/* but this hack will do for now */
hestOptAdd(&opt, "c,center", "center", airTypeString, 1, 1, ¢erStr, "",
"axis centering: \"cell\" or \"node\". Not using this option "
"leaves the centering as it is on input");
hestOptAdd(&opt, "k,kind", "kind", airTypeString, 1, 1, &kindStr, "",
"axis kind. Not using this option "
"leaves the kind as it is on input");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_axinfoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
for (axi=0; axi<axesLen; axi++) {
if (!( axes[axi] < nin->dim )) {
fprintf(stderr, "%s: axis %u not in valid range [0,%u]\n",
me, axes[axi], nin->dim-1);
airMopError(mop);
return 1;
}
}
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error copying input:\n%s", me, err);
airMopError(mop);
return 1;
}
for (axi=0; axi<axesLen; axi++) {
unsigned int axis;
axis = axes[axi];
if (strlen(label)) {
nout->axis[axis].label = (char *)airFree(nout->axis[axis].label);
nout->axis[axis].label = airStrdup(label);
}
if (strlen(units)) {
nout->axis[axis].units = (char *)airFree(nout->axis[axis].units);
nout->axis[axis].units = airStrdup(units);
}
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;
}
/* see above
if (nrrdCenterUnknown != cent) {
nout->axis[axis].center = cent;
}
*/
if (airStrlen(centerStr)) {
if (!strcmp("none", centerStr)
|| !strcmp("???", centerStr)) {
center = nrrdCenterUnknown;
} else {
if (!(center = airEnumVal(nrrdCenter, centerStr))) {
fprintf(stderr, "%s: couldn't parse \"%s\" as %s\n", me,
centerStr, nrrdCenter->name);
airMopError(mop);
return 1;
}
}
nout->axis[axis].center = center;
}
if (airStrlen(kindStr)) {
if (!strcmp("none", kindStr)
|| !strcmp("???", kindStr)) {
kind = nrrdKindUnknown;
} else {
if (!(kind = airEnumVal(nrrdKind, kindStr))) {
fprintf(stderr, "%s: couldn't parse \"%s\" as %s\n", me,
kindStr, nrrdKind->name);
airMopError(mop);
return 1;
}
}
nout->axis[axis].kind = kind;
}
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
/*
** _miteStageSet
**
** ALLOCATES and initializes stage array in a miteThread
*/
int
_miteStageSet(miteThread *mtt, miteRender *mrr) {
static const char me[]="_miteStageSet";
char *value;
int ni, di, stageIdx, rii, stageNum, ilog2;
Nrrd *ntxf;
miteStage *stage;
gageItemSpec isp;
char rc;
stageNum = _miteStageNum(mrr);
/* fprintf(stderr, "!%s: stageNum = %d\n", me, stageNum); */
mtt->stage = AIR_CALLOC(stageNum, miteStage);
if (!mtt->stage) {
biffAddf(MITE, "%s: couldn't alloc array of %d stages", me, stageNum);
return 1;
}
airMopAdd(mtt->rmop, mtt->stage, airFree, airMopAlways);
mtt->stageNum = stageNum;
stageIdx = 0;
for (ni=0; ni<mrr->ntxfNum; ni++) {
ntxf = mrr->ntxf[ni];
for (di=ntxf->dim-1; di>=1; di--) {
stage = mtt->stage + stageIdx;
_miteStageInit(stage);
miteVariableParse(&isp, ntxf->axis[di].label);
stage->val = _miteAnswerPointer(mtt, &isp);
stage->label = ntxf->axis[di].label;
/*
fprintf(stderr, "!%s: ans=%p + offset[%d]=%d == %p\n", me,
mtt->ans, dom, kind->ansOffset[dom], stage->val);
*/
stage->size = ntxf->axis[di].size;
stage->min = ntxf->axis[di].min;
stage->max = ntxf->axis[di].max;
if (di > 1) {
stage->data = NULL;
} else {
stage->data = (mite_t *)ntxf->data;
value = nrrdKeyValueGet(ntxf, "miteStageOp");
if (value) {
stage->op = airEnumVal(miteStageOp, value);
if (miteStageOpUnknown == stage->op) {
stage->op = miteStageOpMultiply;
}
} else {
stage->op = miteStageOpMultiply;
}
if (1 == isp.kind->table[isp.item].answerLength) {
stage->qn = NULL;
} else if (3 == isp.kind->table[isp.item].answerLength) {
char stmp[AIR_STRLEN_SMALL];
ilog2 = airLog2(ntxf->axis[di].size);
switch(ilog2) {
case 8: stage->qn = limnVtoQN_d[ limnQN8octa]; break;
case 9: stage->qn = limnVtoQN_d[ limnQN9octa]; break;
case 10: stage->qn = limnVtoQN_d[limnQN10octa]; break;
case 11: stage->qn = limnVtoQN_d[limnQN11octa]; break;
case 12: stage->qn = limnVtoQN_d[limnQN12octa]; break;
case 13: stage->qn = limnVtoQN_d[limnQN13octa]; break;
case 14: stage->qn = limnVtoQN_d[limnQN14octa]; break;
case 15: stage->qn = limnVtoQN_d[limnQN15octa]; break;
case 16: stage->qn = limnVtoQN_d[limnQN16octa]; break;
default:
biffAddf(MITE, "%s: txf axis %d size %s not usable for "
"vector txf domain variable %s", me, di,
airSprintSize_t(stmp, ntxf->axis[di].size),
ntxf->axis[di].label);
return 1;
break;
}
} else {
biffAddf(MITE, "%s: %s not scalar or vector (len = %d): can't be "
"a txf domain variable", me,
ntxf->axis[di].label,
isp.kind->table[isp.item].answerLength);
return 1;
}
stage->rangeNum = ntxf->axis[0].size;
for (rii=0; rii<stage->rangeNum; rii++) {
rc = ntxf->axis[0].label[rii];
stage->rangeIdx[rii] = strchr(miteRangeChar, rc) - miteRangeChar;
/*
fprintf(stderr, "!%s: range: %c -> %d\n", "_miteStageSet",
ntxf->axis[0].label[rii], stage->rangeIdx[rii]);
*/
}
}
stageIdx++;
}
}
return 0;
}
int
main(int argc, char *argv[]) {
gageKind *kind;
char *me, *whatS, *err, *outS, *stackSavePath;
hestParm *hparm;
hestOpt *hopt = NULL;
NrrdKernelSpec *k00, *k11, *k22, *kSS, *kSSblur;
float pos[3], lineInfo[4];
double gmc, rangeSS[2], posSS, *scalePos;
unsigned int ansLen, numSS, ninSSIdx, lineStepNum;
int what, E=0, renorm, SSrenorm, SSuniform, verbose;
const double *answer;
Nrrd *nin, **ninSS=NULL, *nout=NULL;
gageContext *ctx;
gagePerVolume *pvl;
limnPolyData *lpld=NULL;
airArray *mop;
int worldSpace;
Nrrd *ngrad=NULL, *nbmat=NULL;
double bval, eps;
unsigned int *skip, skipNum;
mop = airMopNew();
me = argv[0];
hparm = hestParmNew();
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hparm->elideSingleOtherType = AIR_TRUE;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", or \"tensor\")",
NULL, NULL, &probeKindHestCB);
hestOptAdd(&hopt, "p", "x y z", airTypeFloat, 3, 3, pos, NULL,
"the position in space at which to probe");
hestOptAdd(&hopt, "wsp", NULL, airTypeInt, 0, 0, &worldSpace, NULL,
"if using this option, position (\"-p\") will be in world "
"space, instead of index space (the default)");
hestOptAdd(&hopt, "pi", "lpld in", airTypeOther, 1, 1, &lpld, "",
"input polydata (overrides \"-p\")",
NULL, NULL, limnHestPolyDataLMPD);
hestOptAdd(&hopt, "pl", "x y z s", airTypeFloat, 4, 4, lineInfo, "0 0 0 0",
"probe along line, instead of at point. "
"The \"-p\" three coords are the line start point. "
"If \"s\" is zero, (x,y,z) is the line end point. "
"If \"s\" is non-zero, (x,y,z) is the line direction, "
"which is scaled to have length \"s\", "
"and then used as the step between line samples. ");
hestOptAdd(&hopt, "pln", "num", airTypeUInt, 1, 1, &lineStepNum, "0",
"if non-zero, number of steps of probing to do along line, "
"which overrides \"-p\" and \"-pi\"");
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1, &verbose, "1",
"verbosity level");
hestOptAdd(&hopt, "q", "query", airTypeString, 1, 1, &whatS, NULL,
"the quantity (scalar, vector, or matrix) to learn by probing");
hestOptAdd(&hopt, "eps", "epsilon", airTypeDouble, 1, 1, &eps, "0",
"if non-zero, and if query is a scalar, epsilon around probe "
"location where we will do discrete differences to find the "
"gradient and hessian (for debugging)");
hestOptAdd(&hopt, "k00", "kern00", airTypeOther, 1, 1, &k00,
"tent", "kernel for gageKernel00",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kern11", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "kernel for gageKernel11",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kern22", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "kernel for gageKernel22",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "ssn", "SS #", airTypeUInt, 1, 1, &numSS,
"0", "how many scale-space samples to evaluate, or, "
"0 to turn-off all scale-space behavior");
hestOptAdd(&hopt, "ssr", "scale range", airTypeDouble, 2, 2, rangeSS,
"nan nan", "range of scales in scale-space");
hestOptAdd(&hopt, "sss", "scale save path", airTypeString, 1, 1,
&stackSavePath, "",
"give a non-empty path string (like \"./\") to save out "
"the pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "ssp", "SS pos", airTypeDouble, 1, 1, &posSS, "0",
"position at which to sample in scale-space");
hestOptAdd(&hopt, "kssblur", "kernel", airTypeOther, 1, 1, &kSSblur,
"dgauss:1,5", "blurring kernel, to sample scale space",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kss", "kernel", airTypeOther, 1, 1, &kSS,
"tent", "kernel for reconstructing from scale space samples",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "ssrn", "ssrn", airTypeInt, 1, 1, &SSrenorm, "0",
"enable derivative normalization based on scale space");
hestOptAdd(&hopt, "ssu", NULL, airTypeInt, 0, 0, &SSuniform, NULL,
"do uniform samples along sigma, and not (by default) "
"samples according to the logarithm of diffusion time");
hestOptAdd(&hopt, "rn", NULL, airTypeInt, 0, 0, &renorm, NULL,
"renormalize kernel weights at each new sample location. "
"\"Accurate\" kernels don't need this; doing it always "
"makes things go slower");
hestOptAdd(&hopt, "gmc", "min gradmag", airTypeDouble, 1, 1, &gmc,
"0.0", "For curvature-based queries, use zero when gradient "
"magnitude is below this");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output array, when probing on polydata vertices");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, probeInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
what = airEnumVal(kind->enm, whatS);
if (!what) {
/* 0 indeed always means "unknown" for any gageKind */
fprintf(stderr, "%s: couldn't parse \"%s\" as measure of \"%s\" volume\n",
me, whatS, kind->name);
hestUsage(stderr, hopt, me, hparm);
hestGlossary(stderr, hopt, hparm);
airMopError(mop);
return 1;
}
if (ELL_4V_LEN(lineInfo) && !lineStepNum) {
fprintf(stderr, "%s: gave line info (\"-pl\") but not "
"# samples (\"-pln\")", me);
hestUsage(stderr, hopt, me, hparm);
hestGlossary(stderr, hopt, hparm);
airMopError(mop);
return 1;
}
/* special set-up required for DWI kind */
if (!strcmp(TEN_DWI_GAGE_KIND_NAME, kind->name)) {
if (tenDWMRIKeyValueParse(&ngrad, &nbmat, &bval, &skip, &skipNum, nin)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (skipNum) {
fprintf(stderr, "%s: sorry, can't do DWI skipping in tenDwiGage", me);
airMopError(mop); return 1;
}
/* this could stand to use some more command-line arguments */
if (tenDwiGageKindSet(kind, 50, 1, bval, 0.001, ngrad, nbmat,
tenEstimate1MethodLLS,
tenEstimate2MethodQSegLLS,
/* randSeed */ 7919)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
ansLen = kind->table[what].answerLength;
/* for setting up pre-blurred scale-space samples */
if (numSS) {
unsigned int vi;
ninSS = AIR_CAST(Nrrd **, calloc(numSS, sizeof(Nrrd *)));
scalePos = AIR_CAST(double *, calloc(numSS, sizeof(double)));
if (!(ninSS && scalePos)) {
fprintf(stderr, "%s: couldn't allocate ninSS", me);
airMopError(mop); return 1;
}
for (ninSSIdx=0; ninSSIdx<numSS; ninSSIdx++) {
ninSS[ninSSIdx] = nrrdNew();
airMopAdd(mop, ninSS[ninSSIdx], (airMopper)nrrdNuke, airMopAlways);
}
if (SSuniform) {
for (vi=0; vi<numSS; vi++) {
scalePos[vi] = AIR_AFFINE(0, vi, numSS-1, rangeSS[0], rangeSS[1]);
}
} else {
double rangeTau[2], tau;
rangeTau[0] = gageTauOfSig(rangeSS[0]);
rangeTau[1] = gageTauOfSig(rangeSS[1]);
for (vi=0; vi<numSS; vi++) {
tau = AIR_AFFINE(0, vi, numSS-1, rangeTau[0], rangeTau[1]);
scalePos[vi] = gageSigOfTau(tau);
}
}
if (verbose > 2) {
fprintf(stderr, "%s: sampling scale range %g--%g %suniformly:\n", me,
rangeSS[0], rangeSS[1], SSuniform ? "" : "non-");
for (vi=0; vi<numSS; vi++) {
fprintf(stderr, " scalePos[%u] = %g\n", vi, scalePos[vi]);
}
}
if (gageStackBlur(ninSS, scalePos, numSS,
nin, kind->baseDim, kSSblur,
nrrdBoundaryBleed, AIR_TRUE,
verbose)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble pre-computing blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (airStrlen(stackSavePath)) {
char fnform[AIR_STRLEN_LARGE];
sprintf(fnform, "%s/blur-%%02u.nrrd", stackSavePath);
fprintf(stderr, "%s: |%s|\n", me, fnform);
if (nrrdSaveMulti(fnform, AIR_CAST(const Nrrd *const *, ninSS),
numSS, 0, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble saving blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
} else {
int
main(int argc, char *argv[]) {
gageKind *kind;
char *me, *outS, *whatS, *err, hackKeyStr[]="TEEM_VPROBE_HACK_ZI",
*hackValStr, *stackSavePath;
hestParm *hparm;
hestOpt *hopt = NULL;
NrrdKernelSpec *k00, *k11, *k22, *kSS, *kSSblur;
int what, E=0, otype, renorm, hackSet, SSrenorm, SSuniform, verbose;
unsigned int iBaseDim, oBaseDim, axi, numSS, ninSSIdx, seed;
const double *answer;
Nrrd *nin, *nout, **ninSS=NULL;
Nrrd *ngrad=NULL, *nbmat=NULL;
size_t ai, ansLen, idx, xi, yi, zi, six, siy, siz, sox, soy, soz;
double bval=0, gmc, rangeSS[2], wrlSS, idxSS=AIR_NAN, *scalePos;
gageContext *ctx;
gagePerVolume *pvl=NULL;
double t0, t1, x, y, z, scale[3], rscl[3], min[3], maxOut[3], maxIn[3];
airArray *mop;
unsigned int hackZi, *skip, skipNum;
double (*ins)(void *v, size_t I, double d);
mop = airMopNew();
me = argv[0];
hparm = hestParmNew();
airMopAdd(mop, hparm, AIR_CAST(airMopper, hestParmFree), airMopAlways);
hparm->elideSingleOtherType = AIR_TRUE;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", "
"\"tensor\", or \"dwi\")",
NULL, NULL, &probeKindHestCB);
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1, &verbose, "1",
"verbosity level");
hestOptAdd(&hopt, "q", "query", airTypeString, 1, 1, &whatS, NULL,
"the quantity (scalar, vector, or matrix) to learn by probing");
hestOptAdd(&hopt, "s", "sclX sclY sxlZ", airTypeDouble, 3, 3, scale,
"1.0 1.0 1.0",
"scaling factor for resampling on each axis "
"(>1.0 : supersampling)");
hestOptAdd(&hopt, "k00", "kern00", airTypeOther, 1, 1, &k00,
"tent", "kernel for gageKernel00",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kern11", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "kernel for gageKernel11",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kern22", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "kernel for gageKernel22",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "seed", "N", airTypeUInt, 1, 1, &seed, "42",
"RNG seed; mostly for debugging");
hestOptAdd(&hopt, "ssn", "SS #", airTypeUInt, 1, 1, &numSS,
"0", "how many scale-space samples to evaluate, or, "
"0 to turn-off all scale-space behavior");
hestOptAdd(&hopt, "ssr", "scale range", airTypeDouble, 2, 2, rangeSS,
"nan nan", "range of scales in scale-space");
hestOptAdd(&hopt, "sss", "scale save path", airTypeString, 1, 1,
&stackSavePath, "",
"give a non-empty path string (like \"./\") to save out "
"the pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "ssw", "SS pos", airTypeDouble, 1, 1, &wrlSS, "0",
"\"world\"-space position (true sigma) "
"at which to sample in scale-space");
hestOptAdd(&hopt, "kssblur", "kernel", airTypeOther, 1, 1, &kSSblur,
"dgauss:1,5", "blurring kernel, to sample scale space",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kss", "kernel", airTypeOther, 1, 1, &kSS,
"tent", "kernel for reconstructing from scale space samples",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "ssrn", "ssrn", airTypeInt, 1, 1, &SSrenorm, "0",
"enable derivative normalization based on scale space");
hestOptAdd(&hopt, "ssu", NULL, airTypeInt, 0, 0, &SSuniform, NULL,
"do uniform samples along sigma, and not (by default) "
"samples according to the logarithm of diffusion time");
hestOptAdd(&hopt, "rn", NULL, airTypeInt, 0, 0, &renorm, NULL,
"renormalize kernel weights at each new sample location. "
"\"Accurate\" kernels don't need this; doing it always "
"makes things go slower");
hestOptAdd(&hopt, "gmc", "min gradmag", airTypeDouble, 1, 1, &gmc,
"0.0", "For curvature-based queries, use zero when gradient "
"magnitude is below this");
hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &otype, "float",
"type of output volume", NULL, nrrdType);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output volume");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, probeInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestOptFree), airMopAlways);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestParseFree), airMopAlways);
what = airEnumVal(kind->enm, whatS);
if (!what) {
/* 0 indeed always means "unknown" for any gageKind */
fprintf(stderr, "%s: couldn't parse \"%s\" as measure of \"%s\" volume\n",
me, whatS, kind->name);
hestUsage(stderr, hopt, me, hparm);
hestGlossary(stderr, hopt, hparm);
airMopError(mop);
return 1;
}
/* special set-up required for DWI kind */
if (!strcmp(TEN_DWI_GAGE_KIND_NAME, kind->name)) {
if (tenDWMRIKeyValueParse(&ngrad, &nbmat, &bval, &skip, &skipNum, nin)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (skipNum) {
fprintf(stderr, "%s: sorry, can't do DWI skipping in tenDwiGage", me);
airMopError(mop); return 1;
}
/* this could stand to use some more command-line arguments */
if (tenDwiGageKindSet(kind, 50, 1, bval, 0.001, ngrad, nbmat,
tenEstimate1MethodLLS,
tenEstimate2MethodQSegLLS, seed)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* for setting up pre-blurred scale-space samples */
if (numSS) {
unsigned int vi;
ninSS = AIR_CAST(Nrrd **, calloc(numSS, sizeof(Nrrd *)));
scalePos = AIR_CAST(double *, calloc(numSS, sizeof(double)));
if (!(ninSS && scalePos)) {
fprintf(stderr, "%s: couldn't allocate ninSS", me);
airMopError(mop); return 1;
}
for (ninSSIdx=0; ninSSIdx<numSS; ninSSIdx++) {
ninSS[ninSSIdx] = nrrdNew();
airMopAdd(mop, ninSS[ninSSIdx], (airMopper)nrrdNuke, airMopAlways);
}
if (SSuniform) {
for (vi=0; vi<numSS; vi++) {
scalePos[vi] = AIR_AFFINE(0, vi, numSS-1, rangeSS[0], rangeSS[1]);
}
} else {
double rangeTau[2], tau;
rangeTau[0] = gageTauOfSig(rangeSS[0]);
rangeTau[1] = gageTauOfSig(rangeSS[1]);
for (vi=0; vi<numSS; vi++) {
tau = AIR_AFFINE(0, vi, numSS-1, rangeTau[0], rangeTau[1]);
scalePos[vi] = gageSigOfTau(tau);
}
}
if (verbose > 2) {
fprintf(stderr, "%s: sampling scale range %g--%g %suniformly:\n", me,
rangeSS[0], rangeSS[1], SSuniform ? "" : "non-");
for (vi=0; vi<numSS; vi++) {
fprintf(stderr, " scalePos[%u] = %g\n", vi, scalePos[vi]);
}
}
if (gageStackBlur(ninSS, scalePos, numSS,
nin, kind->baseDim, kSSblur,
nrrdBoundaryBleed, AIR_TRUE,
verbose)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble pre-computing blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (airStrlen(stackSavePath)) {
char fnform[AIR_STRLEN_LARGE];
sprintf(fnform, "%s/blur-%%02u.nrrd", stackSavePath);
fprintf(stderr, "%s: |%s|\n", me, fnform);
if (nrrdSaveMulti(fnform, AIR_CAST(const Nrrd *const *, ninSS),
numSS, 0, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble saving blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* there's actually work to do here, weirdly: gageProbe can either
work in index space, or in world space, but vprobe has
basically always been index-space-centric. For doing any kind
scale/stack space hacking for which vprobe is suited, its nicer
to have the stack position be in the stack's "world" space, not
the (potentially non-uniform) index space. So here, we have to
actually replicate work that is done by _gageProbeSpace() in
converting from world to index space */
for (vi=0; vi<numSS-1; vi++) {
if (AIR_IN_CL(scalePos[vi], wrlSS, scalePos[vi+1])) {
idxSS = vi + AIR_AFFINE(scalePos[vi], wrlSS, scalePos[vi+1], 0, 1);
if (verbose > 1) {
fprintf(stderr, "%s: scale pos %g -> idx %g = %u + %g\n", me,
wrlSS, idxSS, vi,
AIR_AFFINE(scalePos[vi], wrlSS, scalePos[vi+1], 0, 1));
}
break;
}
}
if (vi == numSS-1) {
fprintf(stderr, "%s: scale pos %g outside range %g=%g, %g=%g\n", me,
wrlSS, rangeSS[0], scalePos[0], rangeSS[1], scalePos[numSS-1]);
airMopError(mop); return 1;
}
} else {
