void
test_score_set(void)
{
grn_obj *v, *res2;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:>0",
GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_all(res);
grn_test_assert(grn_obj_close(&context, cond));
cond = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, res, expr, v);
PARSE(expr, "_score = size",
GRN_EXPR_SYNTAX_SCRIPT|GRN_EXPR_ALLOW_UPDATE);
GRN_TABLE_EACH(&context, res, 0, 0, id, NULL, 0, NULL, {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
});
static void test_headers(void)
{
/* only test the interface; the core parser is tested by the tests above */
struct phr_header headers[4];
size_t num_headers;
#define PARSE(s, last_len, exp, comment) \
do { \
note(comment); \
num_headers = sizeof(headers) / sizeof(headers[0]); \
ok(phr_parse_headers(s, strlen(s), headers, &num_headers, last_len) == (exp == 0 ? strlen(s) : exp)); \
} while (0)
PARSE("Host: example.com\r\nCookie: \r\n\r\n", 0, 0, "simple");
ok(num_headers == 2);
ok(bufis(headers[0].name, headers[0].name_len, "Host"));
ok(bufis(headers[0].value, headers[0].value_len, "example.com"));
ok(bufis(headers[1].name, headers[1].name_len, "Cookie"));
ok(bufis(headers[1].value, headers[1].value_len, ""));
PARSE("Host: example.com\r\nCookie: \r\n\r\n", 1, 0, "slowloris");
ok(num_headers == 2);
ok(bufis(headers[0].name, headers[0].name_len, "Host"));
ok(bufis(headers[0].value, headers[0].value_len, "example.com"));
ok(bufis(headers[1].name, headers[1].name_len, "Cookie"));
ok(bufis(headers[1].value, headers[1].value_len, ""));
PARSE("Host: example.com\r\nCookie: \r\n\r", 0, -2, "partial");
PARSE("Host: e\7fample.com\r\nCookie: \r\n\r", 0, -1, "error");
#undef PARSE
}
int
unrrdu_flipMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int pret;
unsigned int axis;
airArray *mop;
OPT_ADD_AXIS(axis, "axis to flip along");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_flipInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdFlip(nout, nin, axis)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error flipping nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
/******************************************************************************
* *
* Comments: Translate device name to the one used internally by kernel. The *
* translation is done based on minor and major device numbers *
* listed in INFO_FILE_NAME . If the names differ it is usually an *
* LVM device which is listed in kernel device mapper. *
* *
******************************************************************************/
static int get_kernel_devname(const char *devname, char *kernel_devname, size_t max_kernel_devname_len)
{
FILE *f;
char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN];
int ret = FAIL;
zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor;
zbx_stat_t dev_st;
if ('\0' == *devname)
return ret;
*dev_path = '\0';
if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX)))
strscpy(dev_path, ZBX_DEV_PFX);
strscat(dev_path, devname);
if (zbx_stat(dev_path, &dev_st) < 0 || NULL == (f = fopen(INFO_FILE_NAME, "r")))
return ret;
while (NULL != fgets(tmp, sizeof(tmp), f))
{
PARSE(tmp);
if (major(dev_st.st_rdev) != rdev_major || minor(dev_st.st_rdev) != rdev_minor)
continue;
zbx_strlcpy(kernel_devname, name, max_kernel_devname_len);
ret = SUCCEED;
break;
}
zbx_fclose(f);
return ret;
}
static int get_disk_stat(const char *interface, struct disk_stat_s *result)
{
int ret = SYSINFO_RET_FAIL;
char line[MAX_STRING_LEN];
char name[MAX_STRING_LEN];
FILE *f;
assert(result);
if(NULL != (f = fopen(INFO_FILE_NAME,"r") ))
{
while(fgets(line,MAX_STRING_LEN,f) != NULL)
{
PARSE(line);
if(strncmp(name, interface, MAX_STRING_LEN) == 0)
{
ret = SYSINFO_RET_OK;
break;
}
}
zbx_fclose(f);
}
if(ret != SYSINFO_RET_OK)
{
memset(result, 0, sizeof(struct disk_stat_s));
}
return ret;
}
int
unrrdu_axdeleteMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout, *ntmp;
int pret, _axis;
unsigned axis;
airArray *mop;
hestOptAdd(&opt, "a,axis", "axis", airTypeInt, 1, 1, &_axis, NULL,
"dimension (axis index) of the axis to remove");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_axdeleteInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (-1 == _axis) {
ntmp = nrrdNew();
airMopAdd(mop, ntmp, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, nin)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error copying axis:\n%s", me, err);
airMopError(mop); return 1;
}
for (axis=0;
axis<nout->dim && nout->axis[axis].size > 1;
axis++);
while (axis<nout->dim) {
if (nrrdAxesDelete(ntmp, nout, axis)
|| nrrdCopy(nout, ntmp)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error deleting axis:\n%s", me, err);
airMopError(mop); return 1;
}
for (axis=0;
axis<nout->dim && nout->axis[axis].size > 1;
axis++);
}
} else {
if (nrrdAxesDelete(nout, nin, _axis)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error deleting axis:\n%s", me, err);
airMopError(mop); return 1;
}
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_shuffleMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
unsigned int di, axis, permLen, *perm, *iperm, *whichperm;
size_t *realperm;
int inverse, pret;
airArray *mop;
/* so that long permutations can be read from file */
hparm->respFileEnable = AIR_TRUE;
hestOptAdd(&opt, "p,permute", "slc0 slc1", airTypeUInt, 1, -1, &perm, NULL,
"new slice ordering", &permLen);
hestOptAdd(&opt, "inv,inverse", NULL, airTypeInt, 0, 0, &inverse, NULL,
"use inverse of given permutation");
OPT_ADD_AXIS(axis, "axis to shuffle along");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_shuffleInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
/* we have to do error checking on axis in order to do error
checking on length of permutation */
if (!( axis < nin->dim )) {
fprintf(stderr, "%s: axis %d not in valid range [0,%d]\n",
me, axis, nin->dim-1);
airMopError(mop);
return 1;
}
if (!( permLen == nin->axis[axis].size )) {
char stmp[AIR_STRLEN_SMALL];
fprintf(stderr, "%s: permutation length (%u) != axis %d's size (%s)\n",
me, permLen, axis,
airSprintSize_t(stmp, nin->axis[axis].size));
airMopError(mop);
return 1;
}
if (inverse) {
iperm = AIR_CALLOC(permLen, unsigned int);
airMopAdd(mop, iperm, airFree, airMopAlways);
if (nrrdInvertPerm(iperm, perm, permLen)) {
fprintf(stderr,
"%s: couldn't compute inverse of given permutation\n", me);
airMopError(mop);
return 1;
}
whichperm = iperm;
} else {
int
tend_evecrgbMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
tenEvecRGBParm *rgbp;
Nrrd *nin, *nout;
char *outS;
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
rgbp = tenEvecRGBParmNew();
airMopAdd(mop, rgbp, AIR_CAST(airMopper, tenEvecRGBParmNix), airMopAlways);
hestOptAdd(&hopt, "c", "evec index", airTypeUInt, 1, 1, &(rgbp->which), NULL,
"which eigenvector will be colored. \"0\" for the "
"principal, \"1\" for the middle, \"2\" for the minor");
hestOptAdd(&hopt, "a", "aniso", airTypeEnum, 1, 1, &(rgbp->aniso), NULL,
"Which anisotropy to use for modulating the saturation "
"of the colors. " TEN_ANISO_DESC,
NULL, tenAniso);
hestOptAdd(&hopt, "t", "thresh", airTypeDouble, 1, 1, &(rgbp->confThresh),
"0.5", "confidence threshold");
hestOptAdd(&hopt, "bg", "background", airTypeDouble, 1, 1, &(rgbp->bgGray),
"0", "gray level to use for voxels who's confidence is zero ");
hestOptAdd(&hopt, "gr", "gray", airTypeDouble, 1, 1, &(rgbp->isoGray), "0",
"the gray level to desaturate towards as anisotropy "
"decreases (while confidence remains 1.0)");
hestOptAdd(&hopt, "gam", "gamma", airTypeDouble, 1, 1, &(rgbp->gamma), "1",
"gamma to use on color components");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
USAGE(_tend_evecrgbInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (tenEvecRGB(nout, nin, rgbp)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble doing colormapping:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
unrrdu_ccfindMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err, *valS;
Nrrd *nin, *nout, *nval=NULL;
airArray *mop;
int type, pret;
unsigned int conny;
hestOptAdd(&opt, "v,values", "filename", airTypeString, 1, 1, &valS, "",
"Giving a filename here allows you to save out the values "
"associated with each connect component. This can be used "
"later with \"ccmerge -d\". By default, no record of the "
"original CC values is kept.");
hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default",
"type to use for output, to store the CC ID values. By default "
"(not using this option), the type used will be the smallest of "
"uchar, ushort, or int, that can represent all the CC ID values. "
"Using this option allows one to specify the integral type to "
"be used.",
NULL, NULL, &unrrduHestMaybeTypeCB);
hestOptAdd(&opt, "c,connect", "connectivity", airTypeUInt, 1, 1,
&conny, NULL,
"what kind of connectivity to use: the number of coordinates "
"that vary in order to traverse the neighborhood of a given "
"sample. In 2D: \"1\": 4-connected, \"2\": 8-connected");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_ccfindInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCCFind(nout, airStrlen(valS) ? &nval : NULL, nin, type, conny)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing connected components:\n%s", me, err);
airMopError(mop);
return 1;
}
if (nval) {
airMopAdd(mop, nval, (airMopper)nrrdNuke, airMopAlways);
}
if (airStrlen(valS)) {
SAVE(valS, nval, NULL);
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_dataMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *err, *inS=NULL;
Nrrd *nin;
NrrdIoState *nio;
airArray *mop;
int car, pret;
mop = airMopNew();
hestOptAdd(&opt, NULL, "nin", airTypeString, 1, 1, &inS, NULL,
"input nrrd");
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_dataInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nio = nrrdIoStateNew();
airMopAdd(mop, nio, (airMopper)nrrdIoStateNix, airMopAlways);
nio->skipData = AIR_TRUE;
nio->keepNrrdDataFileOpen = AIR_TRUE;
nin = nrrdNew();
airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
if (nrrdLoad(nin, inS, nio)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error reading header:\n%s", me, err);
airMopError(mop);
return 1;
}
if (_nrrdDataFNNumber(nio) > 1) {
fprintf(stderr, "%s: sorry, currently can't operate with multiple "
"detached datafiles\n", me);
airMopError(mop);
return 1;
}
if (!( nrrdFormatNRRD == nio->format )) {
fprintf(stderr, "%s: can only print data of NRRD format files\n", me);
airMopError(mop); return 1;
}
car = fgetc(nio->dataFile);
#ifdef _MSC_VER
/* needed because otherwise printing a carraige return will
automatically also produce a newline */
_setmode(_fileno(stdout), _O_BINARY);
#endif
while (EOF != car) {
fputc(car, stdout);
car = fgetc(nio->dataFile);
}
airFclose(nio->dataFile);
airMopOkay(mop);
return 0;
}
int get_diskstat(const char *devname, zbx_uint64_t *dstat)
{
FILE *f;
char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN];
int i, ret = FAIL, dev_exists = FAIL;
zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor;
zbx_stat_t dev_st;
int found = 0;
for (i = 0; i < ZBX_DSTAT_MAX; i++)
dstat[i] = (zbx_uint64_t)__UINT64_C(0);
if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all"))
{
*dev_path = '\0';
if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX)))
strscpy(dev_path, ZBX_DEV_PFX);
strscat(dev_path, devname);
if (zbx_stat(dev_path, &dev_st) == 0)
dev_exists = SUCCEED;
}
if (NULL == (f = fopen(INFO_FILE_NAME, "r")))
return FAIL;
while (NULL != fgets(tmp, sizeof(tmp), f))
{
PARSE(tmp);
if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all"))
{
if (0 != strcmp(name, devname))
{
if (SUCCEED != dev_exists
|| major(dev_st.st_rdev) != rdev_major
|| minor(dev_st.st_rdev) != rdev_minor)
continue;
}
else
found = 1;
}
dstat[ZBX_DSTAT_R_OPER] += ds[ZBX_DSTAT_R_OPER];
dstat[ZBX_DSTAT_R_SECT] += ds[ZBX_DSTAT_R_SECT];
dstat[ZBX_DSTAT_W_OPER] += ds[ZBX_DSTAT_W_OPER];
dstat[ZBX_DSTAT_W_SECT] += ds[ZBX_DSTAT_W_SECT];
ret = SUCCEED;
if (1 == found)
break;
}
zbx_fclose(f);
return ret;
}
void
test_proc_call(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:>14",
GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_take_new_list_string("hoge moge moge moge",
"moge hoge fuga fuga",
"moge hoge moge moge moge",
"poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, expr, v);
PARSE(expr, "size = rand(14)", GRN_EXPR_SYNTAX_SCRIPT|GRN_EXPR_ALLOW_UPDATE);
{
grn_id id;
grn_table_cursor *tc;
tc = grn_table_cursor_open(&context, docs, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
}
grn_test_assert(grn_table_cursor_close(&context, tc));
}
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_none(res);
}
int
unrrdu_spliceMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout, *nslice;
unsigned int axis;
int pret;
long int _pos[2];
size_t pos;
airArray *mop;
OPT_ADD_AXIS(axis, "axis to splice along");
hestOptAdd(&opt, "p,position", "pos", airTypeOther, 1, 1, _pos, NULL,
"position to splice at:\n "
"\b\bo <int> gives 0-based index\n "
"\b\bo M-<int> give index relative "
"to the last sample on the axis (M == #samples-1).",
NULL, NULL, &unrrduHestPosCB);
hestOptAdd(&opt, "s,slice", "nslice", airTypeOther, 1, 1, &(nslice), NULL,
"slice nrrd. This the slice to be inserted in \"nin\"",
NULL, NULL, nrrdHestNrrd);
OPT_ADD_NIN(nin, "input nrrd. This the nrrd into which the slice will "
"be inserted");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_spliceInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
if (!( axis < nin->dim )) {
fprintf(stderr, "%s: axis %u not in range [0,%u]\n", me, axis, nin->dim-1);
return 1;
}
if (_pos[0] == -1) {
fprintf(stderr, "%s: m+<int> specification format meaningless here\n", me);
return 1;
}
pos = _pos[0]*(nin->axis[axis].size-1) + _pos[1];
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdSplice(nout, nin, nslice, axis, pos)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error splicing nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
limnpu_rastMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *hopt = NULL;
char *err, *perr;
airArray *mop;
int pret;
limnPolyData *pld;
double min[3], max[3];
Nrrd *nout;
char *out;
int type;
size_t size[NRRD_DIM_MAX];
hestOptAdd(&hopt, "min", "min", airTypeDouble, 3, 3, min, NULL,
"bottom corner");
hestOptAdd(&hopt, "max", "max", airTypeDouble, 3, 3, max, NULL,
"top corner");
hestOptAdd(&hopt, "s", "size", airTypeSize_t, 3, 3, size, NULL,
"number of samples along each axis");
hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &type, "uchar",
"type of output nrrd",
NULL, nrrdType);
hestOptAdd(&hopt, NULL, "input", airTypeOther, 1, 1, &pld, NULL,
"input polydata filename",
NULL, NULL, limnHestPolyDataLMPD);
hestOptAdd(&hopt, NULL, "output", airTypeString, 1, 1, &out, NULL,
"output nrrd filename");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(myinfo);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (limnPolyDataRasterize(nout, pld, min, max, size, type)) {
airMopAdd(mop, err = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:%s", me, err);
airMopError(mop);
return 1;
}
if (nrrdSave(out, nout, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:%s", me, err);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
int
unrrdu_histaxMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int type, bins, pret, blind8BitRange;
unsigned int axis;
double min, max;
airArray *mop;
NrrdRange *range;
OPT_ADD_AXIS(axis, "axis to histogram along");
hestOptAdd(&opt, "b,bin", "bins", airTypeInt, 1, 1, &bins, NULL,
"# of bins in histogram");
OPT_ADD_TYPE(type, "output type", "uchar");
hestOptAdd(&opt, "min,minimum", "value", airTypeDouble, 1, 1, &min, "nan",
"Value at low end of histogram. Defaults to lowest value "
"found in input nrrd.");
hestOptAdd(&opt, "max,maximum", "value", airTypeDouble, 1, 1, &max, "nan",
"Value at high end of histogram. Defaults to highest value "
"found in input nrrd.");
hestOptAdd(&opt, "blind8", "bool", airTypeBool, 1, 1, &blind8BitRange,
nrrdStateBlind8BitRange ? "true" : "false",
"Whether to know the range of 8-bit data blindly "
"(uchar is always [0,255], signed char is [-128,127]).");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_histaxInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
range = nrrdRangeNew(min, max);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nrrdRangeSafeSet(range, nin, blind8BitRange);
if (nrrdHistoAxis(nout, nin, range, axis, bins, type)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing axis histogramming:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_dhistoMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int pret, nolog, notick;
unsigned int size;
airArray *mop;
double max;
hestOptAdd(&opt, "h,height", "height", airTypeUInt, 1, 1, &size, NULL,
"height of output image (horizontal size is determined by "
"number of bins in input histogram).");
hestOptAdd(&opt, "nolog", NULL, airTypeInt, 0, 0, &nolog, NULL,
"do not show the log-scaled histogram with decade tick-marks");
hestOptAdd(&opt, "notick", NULL, airTypeInt, 0, 0, ¬ick, NULL,
"do not draw the log decade tick marks");
hestOptAdd(&opt, "max,maximum", "max # hits", airTypeDouble, 1, 1,
&max, "nan",
"constrain the top of the drawn histogram to be at this "
"number of hits. This will either scale the drawn histogram "
"downward or clip its top, depending on whether the given max "
"is higher or lower than the actual maximum bin count. By "
"not using this option (the default), the actual maximum bin "
"count is used");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_dhistoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdHistoDraw(nout, nin, size,
nolog ? AIR_FALSE : (notick ? 2 : AIR_TRUE),
max)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error drawing histogram nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_axmergeMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout[2];
int *axes, pret, ni;
unsigned int ii, jj, axesLen;
airArray *mop;
hestOptAdd(&opt, "a,axis", "ax0", airTypeInt, 1, -1, &axes, NULL,
"axis (or axes) to merge. Each axis index identified is the "
"lower of the pair of axes that will be merged. Saying \"-a 2\" "
"means to merge axis 2 and axis 3 into axis 2. If multiple "
"merges are to be done, the indices listed here are for "
"the axes prior to any merging.", &axesLen);
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_axmergeInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
airMopAdd(mop, nout[0]=nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nout[1]=nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
if (axesLen > 1) {
/* sort merge axes into ascending order */
qsort(axes, axesLen, sizeof(*axes), nrrdValCompare[nrrdTypeInt]);
}
ni = 0;
for (ii=0; ii<axesLen; ii++) {
if (nrrdAxesMerge(nout[ni], !ii ? nin : nout[1-ni], axes[ii])) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error merging axes:\n%s", me, err);
airMopError(mop);
return 1;
}
for (jj=ii+1; jj<axesLen; jj++) {
axes[jj] -= 1;
}
ni = 1-ni;
}
SAVE(out, nout[1-ni], NULL);
airMopOkay(mop);
return 0;
}
int
tend_anhistMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
int version, res, right;
Nrrd *nin, *nout, *nwght;
char *outS;
hestOptAdd(&hopt, "v", "westin version", airTypeInt, 1, 1, &version, "1",
"Which version of Westin's anisotropy metric triple "
"to use, either \"1\" or \"2\"");
hestOptAdd(&hopt, "w", "nweight", airTypeOther, 1, 1, &nwght, "",
"how to weigh contributions to histogram. By default "
"(not using this option), the increment is one bin count per "
"sample, but by giving a nrrd, the value in the nrrd at the "
"corresponding location will be the bin count increment ",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "r", "res", airTypeInt, 1, 1, &res, NULL,
"resolution of anisotropy plot");
hestOptAdd(&hopt, "right", NULL, airTypeInt, 0, 0, &right, NULL,
"sample a right-triangle-shaped region, instead of "
"a roughly equilateral triangle. ");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_anhistInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (tenAnisoHistogram(nout, nin, nwght, right, version, res)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble making histogram:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
tend_evqMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
int which, aniso, dontScaleByAniso;
Nrrd *nin, *nout;
char *outS;
hestOptAdd(&hopt, "c", "evec index", airTypeInt, 1, 1, &which, "0",
"Which eigenvector should be quantized: \"0\" for the "
"direction of fastest diffusion (eigenvector associated "
"with largest eigenvalue), \"1\" or \"2\" for other two "
"eigenvectors (associated with middle and smallest eigenvalue)");
hestOptAdd(&hopt, "a", "aniso", airTypeEnum, 1, 1, &aniso, NULL,
"Which anisotropy metric to scale the eigenvector "
"with. " TEN_ANISO_DESC,
NULL, tenAniso);
hestOptAdd(&hopt, "ns", NULL, airTypeInt, 0, 0, &dontScaleByAniso, NULL,
"Don't attenuate the color by anisotropy. By default (not "
"using this option), regions with low or no anisotropy are "
"very dark colors or black");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_evqInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (tenEvqVolume(nout, nin, which, aniso, !dontScaleByAniso)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble quantizing eigenvectors:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
unrrdu_gammaMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
double min, max, gamma;
airArray *mop;
int pret, blind8BitRange;
NrrdRange *range;
hestOptAdd(&opt, "g,gamma", "gamma", airTypeDouble, 1, 1, &gamma, NULL,
"gamma > 1.0 brightens; gamma < 1.0 darkens. "
"Negative gammas invert values (like in xv). ");
hestOptAdd(&opt, "min,minimum", "value", airTypeDouble, 1, 1, &min, "nan",
"Value to implicitly map to 0.0 prior to calling pow(). "
"Defaults to lowest value found in input nrrd.");
hestOptAdd(&opt, "max,maximum", "value", airTypeDouble, 1, 1, &max, "nan",
"Value to implicitly map to 1.0 prior to calling pow(). "
"Defaults to highest value found in input nrrd.");
hestOptAdd(&opt, "blind8", "bool", airTypeBool, 1, 1, &blind8BitRange,
nrrdStateBlind8BitRange ? "true" : "false",
"Whether to know the range of 8-bit data blindly "
"(uchar is always [0,255], signed char is [-128,127]).");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_gammaInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
range = nrrdRangeNew(min, max);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nrrdRangeSafeSet(range, nin, blind8BitRange);
if (nrrdArithGamma(nout, nin, range, gamma)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing gamma:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
unrrdu_distMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int pret;
int E, typeOut, invert, sign;
double thresh;
airArray *mop;
hestOptAdd(&opt, "th,thresh", "val", airTypeDouble, 1, 1, &thresh, NULL,
"threshold value to separate inside from outside");
hestOptAdd(&opt, "t,type", "type", airTypeEnum, 1, 1, &typeOut, "float",
"type to save output in", NULL, nrrdType);
hestOptAdd(&opt, "sgn", NULL, airTypeInt, 0, 0, &sign, NULL,
"also compute signed (negative) distances inside objects, "
"instead of leaving them as zero");
hestOptAdd(&opt, "inv", NULL, airTypeInt, 0, 0, &invert, NULL,
"values *below* threshold are considered interior to object. "
"By default (not using this option), values above threshold "
"are considered interior. ");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_distInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (sign) {
E = nrrdDistanceL2Signed(nout, nin, typeOut, NULL, thresh, !invert);
} else {
E = nrrdDistanceL2(nout, nin, typeOut, NULL, thresh, !invert);
}
if (E) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error doing distance transform:\n%s", me, err);
airMopError(mop);
return 1;
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
void Mesh::readPlyFile(std::istream& is) {
uint i, k, nVertices, nFaces;
MT::String str;
is >>PARSE("ply") >>PARSE("format") >>str;
if(str=="ascii") {
is >>PARSE("1.0");
is >>PARSE("element vertex") >>nVertices;
is >>PARSE("property float32 x") >>PARSE("property float32 y") >>PARSE("property float32 z");
is >>PARSE("property float32 nx") >>PARSE("property float32 ny") >>PARSE("property float32 nz");
is >>PARSE("element face") >>nFaces;
is >>PARSE("property list uint8 int32 vertex_indices") >>PARSE("end_header");
V.resize(nVertices, 3);
T.resize(nFaces , 3);
double nx, ny, nz;
for(i=0; i<V.d0; i++) {
is >>V(i, 0) >>V(i, 1) >>V(i, 2) >>nx >>ny >>nz;
}
for(i=0; i<T.d0; i++) {
is >>k >>T(i, 0) >>T(i, 1) >>T(i, 2);
CHECK(k==3, "can only read triangles from ply");
}
}
int
baneGkms_miteMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *perr;
Nrrd *nin, *nout;
airArray *mop;
int pret, E;
hestOptAdd(&opt, "i", "opacIn", airTypeOther, 1, 1, &nin, NULL,
"input opacity function (1 or 2 dimensional), from "
"\"gkms opac\"",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "o", "opacOut", airTypeString, 1, 1, &out, NULL,
"output opacity function filename");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_baneGkms_miteInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
if (1 == nin->axis[0].size && nin->axis[0].label &&
!strcmp("A", nin->axis[0].label)) {
fprintf(stderr, "%s: already\n", me);
nout = nin;
} else {
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
E = 0;
if (!E) E |= nrrdAxesInsert(nout, nin, 0);
if (!E) E |= !(nout->axis[0].label = airStrdup("A"));
if (!E) E |= !(nout->axis[1].label = airStrdup("gage(v)"));
if (3 == nout->dim) {
if (!E) E |= !(nout->axis[2].label = airStrdup("gage(gm)"));
}
if (E) {
biffMovef(BANE, NRRD,
"%s: trouble modifying opacity function nrrd", me);
airMopError(mop); return 1;
}
}
if (nrrdSave(out, nout, NULL)) {
biffMovef(BANE, NRRD, "%s: trouble saving opacity function", me);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
unrrdu_joinMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err, *label;
Nrrd **nin;
Nrrd *nout;
int incrDim, pret;
unsigned int ninLen, axis;
double mm[2], spc;
airArray *mop;
hparm->respFileEnable = AIR_TRUE;
hestOptAdd(&opt, "i,input", "nin0", airTypeOther, 1, -1, &nin, NULL,
"everything to be joined together",
&ninLen, NULL, nrrdHestNrrd);
OPT_ADD_AXIS(axis, "axis to join along");
hestOptAdd(&opt, "incr", NULL, airTypeInt, 0, 0, &incrDim, NULL,
"in situations where the join axis is *not* among the existing "
"axes of the input nrrds, then this flag signifies that the join "
"axis should be *inserted*, and the output dimension should "
"be one greater than input dimension. Without this flag, the "
"nrrds are joined side-by-side, along an existing axis.");
hestOptAdd(&opt, "l,label", "label", airTypeString, 1, 1, &label, "",
"label to associate with join axis");
hestOptAdd(&opt, "mm,minmax", "min max", airTypeDouble, 2, 2, mm, "nan nan",
"min and max values along join axis");
hestOptAdd(&opt, "sp,spacing", "spc", airTypeDouble, 1, 1, &spc, "nan",
"spacing between samples along join axis");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_joinInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdJoin(nout, AIR_CAST(const Nrrd*const*, nin), ninLen,
axis, incrDim)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error joining nrrds:\n%s", me, err);
airMopError(mop);
return 1;
}
int
baneGkms_infoMain(int argc, char **argv, char *me, hestParm *hparm) {
hestOpt *opt = NULL;
char *outS, *perr, err[BIFF_STRLEN];
Nrrd *hvol, *nout;
airArray *mop;
int pret, one, measr;
hestOptAdd(&opt, "m", "measr", airTypeEnum, 1, 1, &measr, "mean",
"How to project along the 2nd derivative axis. Possibilities "
"include:\n "
"\b\bo \"mean\": average value\n "
"\b\bo \"median\": value at 50th percentile\n "
"\b\bo \"mode\": most common value\n "
"\b\bo \"min\", \"max\": probably not useful",
NULL, baneGkmsMeasr);
hestOptAdd(&opt, "one", NULL, airTypeInt, 0, 0, &one, NULL,
"Create 1-dimensional info file; default is 2-dimensional");
hestOptAdd(&opt, "i", "hvolIn", airTypeOther, 1, 1, &hvol, NULL,
"input histogram volume (from \"gkms hvol\")",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&opt, "o", "infoOut", airTypeString, 1, 1, &outS, NULL,
"output info file, used by \"gkms pvg\" and \"gkms opac\"");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_baneGkms_infoInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (baneOpacInfo(nout, hvol, one ? 1 : 2, measr)) {
sprintf(err, "%s: trouble distilling histogram info", me);
biffAdd(BANE, err);
airMopError(mop);
return 1;
}
if (nrrdSave(outS, nout, NULL)) {
sprintf(err, "%s: trouble saving info file", me);
biffMove(BANE, err, NRRD);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
void
test_set_value(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:14",
GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, expr, v);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &textbuf, "size");
grn_expr_append_const(&context, expr, &textbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &intbuf, 14);
grn_expr_append_const(&context, expr, &intbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_ASSIGN, 2);
{
grn_id id;
grn_table_cursor *tc;
tc = grn_table_cursor_open(&context, docs, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
}
grn_test_assert(grn_table_cursor_close(&context, tc));
}
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_all(res);
}
std::shared_ptr<STATE> parse(std::string filePath, std::string traceFilePath = "")
{
if (!traceFilePath.empty())
{
FILE* traceFile = fopen(traceFilePath.c_str(), "w");
PARSER_TRACE(traceFile, (char*)"");
}
LEXER lexer(filePath);
while (!_state->hasParserError() && lexer.advance())
{
PARSE(_parser, lexer.getTokenId(), lexer.getToken(), &(*_state));
}
if (_state->hasParserError() || lexer.hasFailed())
{
_state->saveLastValidToken(lexer.getToken());
}
PARSE(_parser, 0, NULL, &(*_state));
return _state;
}
int
tend_anscaleMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
Nrrd *nin, *nout;
char *outS;
float scale;
int fixDet, makePositive;
hestOptAdd(&hopt, "s", "scale", airTypeFloat, 1, 1, &scale, NULL,
"Amount by which to scale deviatoric component of tensor.");
hestOptAdd(&hopt, "fd", NULL, airTypeInt, 0, 0, &fixDet, NULL,
"instead of fixing the per-sample trace (the default), fix the "
"determinant (ellipsoid volume)");
hestOptAdd(&hopt, "mp", NULL, airTypeInt, 0, 0, &makePositive, NULL,
"after changing the eigenvalues of the tensor, enforce their "
"non-negative-ness. By default, no such constraint is imposed.");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_anscaleInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (tenAnisoScale(nout, nin, scale, fixDet, makePositive)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
tend_normMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
Nrrd *nin, *nout;
char *outS;
float amount, target;
double weight[3];
hestOptAdd(&hopt, "w", "w0 w1 w2", airTypeDouble, 3, 3, weight, NULL,
"relative weights to put on major, medium, and minor "
"eigenvalue when performing normalization (internally "
"rescaled to have a 1.0 L1 norm). These weightings determine "
"the tensors's \"size\".");
hestOptAdd(&hopt, "a", "amount", airTypeFloat, 1, 1, &amount, "1.0",
"how much of the normalization to perform");
hestOptAdd(&hopt, "t", "target", airTypeFloat, 1, 1, &target, "1.0",
"target size, post normalization");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_normInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (tenSizeNormalize(nout, nin, weight, amount, target)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
static int
legal_filename_p (char *fn)
{
struct FAB fab = cc$rms_fab;
struct NAM nam = cc$rms_nam;
char esa[NAM$C_MAXRSS];
fab.fab$l_fna = fn;
fab.fab$b_fns = strlen(fn);
fab.fab$l_nam = &nam;
fab.fab$l_fop = FAB$M_NAM;
nam.nam$l_esa = esa;
nam.nam$b_ess = sizeof esa;
return SYS$PARSE(&fab, 0, 0) == RMS$_NORMAL;
}
