int miteRayBegin(miteThread *mtt, miteRender *mrr, miteUser *muu, int uIndex, int vIndex, double rayLen, double rayStartWorld[3], double rayStartIndex[3], double rayDirWorld[3], double rayDirIndex[3]) { airPtrPtrUnion appu; AIR_UNUSED(mrr); AIR_UNUSED(rayStartWorld); AIR_UNUSED(rayStartIndex); AIR_UNUSED(rayDirIndex); mtt->ui = uIndex; mtt->vi = vIndex; mtt->rayStep = (muu->rayStep*rayLen / (muu->hctx->cam->vspFaar - muu->hctx->cam->vspNeer)); if (!uIndex) { fprintf(stderr, "%d/%d ", vIndex, muu->hctx->imgSize[1]); fflush(stderr); } mtt->verbose = (uIndex == muu->verbUi && vIndex == muu->verbVi); mtt->skip = (muu->verbUi >= 0 && muu->verbVi >= 0 && !mtt->verbose); if (mtt->verbose) { /* create muu->ndebug */ muu->ndebug = nrrdNew(); /* we want to store the value and index for each txf domain variable, plus the RGBAZ computed for that sample */ muu->ndebug->axis[0].size = 2*mtt->stageNum + 5; /* we really do want to associate ndebug with the miteUser's mop, because the information stored in it has to persist for as long as the user wants: mite itself doesn't call miteUserNix */ airMopAdd(muu->umop, muu->ndebug, (airMopper)nrrdNuke, airMopAlways); /* but the scope of the debug array allocation is within this ray */ muu->debugArr = airArrayNew((appu.d = &(muu->debug), appu.v), NULL, sizeof(double), 128); } mtt->raySample = 0; mtt->RR = mtt->GG = mtt->BB = 0.0; mtt->TT = 1.0; mtt->ZZ = AIR_NAN; ELL_3V_SCALE(mtt->V, -1, rayDirWorld); return 0; }
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; }
int unrrdu_projectMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; unsigned int axis; int measr, pret, type; airArray *mop; OPT_ADD_AXIS(axis, "axis to project along"); hestOptAdd(&opt, "m,measure", "measr", airTypeEnum, 1, 1, &measr, NULL, "How to \"measure\" a scanline, by summarizing all its values " "with a single scalar. " NRRD_MEASURE_DESC, NULL, nrrdMeasure); hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default", "type to use for output. By default (not using this option), " "the output type is determined auto-magically", NULL, NULL, &unrrduHestMaybeTypeCB); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_projectInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdProject(nout, nin, axis, measr, type)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error projecting nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int unrrdu_ccsettleMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err, *valS; Nrrd *nin, *nout, *nval=NULL; airArray *mop; int pret; mop = airMopNew(); hestOptAdd(&opt, "i,input", "nin", airTypeOther, 1, 1, &nin, NULL, "input nrrd", NULL, NULL, nrrdHestNrrd); hestOptAdd(&opt, "v,values", "filename", airTypeString, 1, 1, &valS, "", "Giving a filename here allows you to save out the mapping " "from new (settled) values to old values, in the form of a " "1-D lookup table"); OPT_ADD_NOUT(out, "output nrrd"); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_ccsettleInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdCCSettle(nout, airStrlen(valS) ? &nval : NULL, nin)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error settling 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 limnpu_measMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *hopt = NULL; char *err, *perr; airArray *mop; int pret; limnPolyData *pld; Nrrd *nout; char *out; 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 (limnPolyDataPrimitiveArea(nout, pld)) { 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_permuteMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; unsigned int *perm, permLen; int pret; airArray *mop; hestOptAdd(&opt, "p,permute", "ax0 ax1", airTypeUInt, 1, -1, &perm, NULL, "new axis ordering", &permLen); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_permuteInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (!( permLen == nin->dim )) { fprintf(stderr,"%s: # axes in permutation (%u) != nrrd dim (%d)\n", me, permLen, nin->dim); airMopError(mop); return 1; } if (nrrdAxesPermute(nout, nin, perm)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error permuting nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int unrrdu_untileMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; unsigned int axes[3]; int pret; size_t size[2]; airArray *mop; hestOptAdd(&opt, "a,axis", "axMerge ax0 ax1", airTypeUInt, 3, 3, axes, NULL, "the slow parts of axes ax0 and ax1 are merged into a (new) " "axis axMerge, with the axis ax0 part being faster than ax1."); hestOptAdd(&opt, "s,size", "size0 size1", airTypeSize_t, 2, 2, size, NULL, "the slow parts of axes ax0 and ax1 are taken to have size " "size0 and size1, respectively, and axis axMerge will have " "size size0*size1."); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_untileInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdUntile2D(nout, nin, axes[1], axes[2], axes[0], size[0], size[1])) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error tiling nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int tend_sliceMain(int argc, char **argv, char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; char *outS; int axis, pos, dim; Nrrd *nin, *nout; hestOptAdd(&hopt, "a", "axis", airTypeInt, 1, 1, &axis, NULL, "axis along which to slice"); hestOptAdd(&hopt, "p", "pos", airTypeInt, 1, 1, &pos, NULL, "position to slice at"); hestOptAdd(&hopt, "d", "dim", airTypeInt, 1, 1, &dim, "3", "dimension of desired tensor output, can be either 2 or 3"); hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-", "input diffusion tensor volume", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output tensor slice"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_sliceInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); airMopAdd(mop, nout=nrrdNew(), (airMopper)nrrdNuke, airMopAlways); if (tenSlice(nout, nin, axis, pos, dim)) { 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; }
Nrrd* LBLReader::Convert(int t, int c, bool get_max) { int64_t pos = m_path_name.find_last_of('.'); if (pos == -1) return 0; wstring str_name = m_path_name.substr(0, pos); wostringstream strs; strs << str_name /*<< "_t" << t << "_c" << c*/ << ".lbl"; str_name = strs.str(); Nrrd *output = nrrdNew(); NrrdIoState *nio = nrrdIoStateNew(); nrrdIoStateSet(nio, nrrdIoStateSkipData, AIR_TRUE); string str; str.assign(str_name.length(), 0); for (int i=0; i<(int)str_name.length(); i++) str[i] = (char)str_name[i]; if (nrrdLoad(output, str.c_str(), nio)) return 0; nio = nrrdIoStateNix(nio); if (output->dim != 3 || (output->type != nrrdTypeInt && output->type != nrrdTypeUInt)) { delete []output->data; nrrdNix(output); return 0; } int slice_num = int(output->axis[2].size); int x_size = int(output->axis[0].size); int y_size = int(output->axis[1].size); int data_size = slice_num * x_size * y_size; output->data = new unsigned int[data_size]; if (nrrdLoad(output, str.c_str(), NULL)) { delete []output->data; nrrdNix(output); return 0; } return output; }
int tend_tconvMain(int argc, const char **argv, const char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; int ttype[2]; Nrrd *nin, *nout; char *outS; hestOptAdd(&hopt, "t", "inType outType", airTypeEnum, 2, 2, ttype, NULL, "given input and desired output type of triples", NULL, tenTripleType); hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-", "input array of triples", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output array"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_tconvInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (tenTripleConvert(nout, ttype[1], nin, ttype[0])) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble converting:\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_unmfMain(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; hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL, "input diffusion tensor volume " "(sorry, can't use usual default of \"-\" for stdin " "because of hest quirk)", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output tensor volume"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_unmfInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (tenMeasurementFrameReduce(nout, nin)) { 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 unrrdu_convertMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; int type, pret, E, doClamp; airArray *mop; OPT_ADD_TYPE(type, "type to convert to", NULL); OPT_ADD_NIN(nin, "input nrrd"); hestOptAdd(&opt, "clamp", NULL, airTypeInt, 0, 0, &doClamp, NULL, "clamp input values to representable range of values of " "output type, to avoid wrap-around problems"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_convertInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (doClamp) { E = nrrdClampConvert(nout, nin, type); } else { E = nrrdConvert(nout, nin, type); } if (E) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error converting nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int rva_gridMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *hopt = NULL; char *err; airArray *mop; rvaLattSpec *lsp; double radius; char *outStr; Nrrd *nout; mop = airMopNew(); hopt = NULL; hestOptAdd(&hopt, NULL, "latt", airTypeOther, 1, 1, &lsp, NULL, "lattice definition", NULL, NULL, rvaHestLattSpec); hestOptAdd(&hopt, "r", "radius", airTypeDouble, 1, 1, &radius, "1", "radius limit"); hestOptAdd(&hopt, "o", "fname", airTypeString, 1, 1, &outStr, "-", "output filename"); hestParseOrDie(hopt, argc, argv, hparm, me, longInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (rvaGrid(nout, lsp, radius)) { airMopAdd(mop, err=biffGetDone(RVA), airFree, airMopAlways); fprintf(stderr, "%s: problem:\n%s", me, err); airMopError(mop); return 1; } if (nrrdSave(outStr, nout, NULL)) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: problem saving:\n%s", me, err); airMopError(mop); return 1; } airMopOkay(mop); return 0; }
int _baneClipAnswer_TopN(int *countP, Nrrd *hvol, double *clipParm) { static const char me[]="_baneClipAnwer_TopN"; Nrrd *copy; int *hits, tmp; size_t num; if (nrrdCopy(copy=nrrdNew(), hvol)) { biffMovef(BANE, NRRD, "%s: couldn't create copy of histovol", me); return 1; } hits = (int *)copy->data; num = nrrdElementNumber(copy); qsort(hits, num, sizeof(int), nrrdValCompare[nrrdTypeInt]); tmp = AIR_CLAMP(0, (int)clipParm[0], (int)num-1); *countP = hits[num-tmp-1]; nrrdNuke(copy); return 0; }
int unrrdu_tileMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; int pret; size_t size[2]; unsigned int axes[3]; airArray *mop; hestOptAdd(&opt, "a,axis", "axSplit ax0 ax1", airTypeUInt, 3, 3, axes, NULL, "axSplit is divided and merged with ax0 and ax1"); hestOptAdd(&opt, "s,size", "fast slow", airTypeSize_t, 2, 2, size, NULL, "fast and slow axis sizes to produce as result of splitting " "the axSplit axis."); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_tileInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdTile2D(nout, nin, axes[1], axes[2], axes[0], size[0], size[1])) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error tiling nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int unrrdu_axsplitMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; int pret; size_t size[2]; unsigned int axis; airArray *mop; OPT_ADD_AXIS(axis, "dimension (axis index) to split at"); hestOptAdd(&opt, "s,size", "fast, slow sizes", airTypeSize_t, 2, 2, size, NULL, "fast and slow axis sizes to produce as result of splitting " "given axis."); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_axsplitInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdAxesSplit(nout, nin, axis, size[0], size[1])) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error splitting axis:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
void makeSceneAntialias(limnCamera *cam, echoRTParm *parm, echoObject **sceneP, airArray **lightArrP) { echoObject *scene, *rect; Nrrd *ntext; *sceneP = scene = echoObjectNew(echoList); *lightArrP = echoLightArrayNew(); ELL_3V_SET(cam->from, 0, 0, 10); ELL_3V_SET(cam->at, 0, 0, 0); ELL_3V_SET(cam->up, 0, 1, 0); cam->uRange[0] = -3.7; cam->uRange[1] = 3.7; cam->vRange[0] = -3.7; cam->vRange[1] = 3.7; parm->jitterType = echoJitterGrid; parm->numSamples = 1; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->shadow = 1.0; nrrdLoad(ntext = nrrdNew(), "chirp.nrrd", NULL); rect = echoObjectNew(echoRectangle); echoRectangleSet(rect, -3, -3, 0, 6, 0, 0, 0, 6, 0); echoMatterPhongSet(rect, 1, 1, 1, 1.0, 1.0, 0.0, 0.0, 1); echoMatterTextureSet(rect, ntext); echoObjectAdd(scene, rect); return; }
int unrrdu_axinsertMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err, *label; Nrrd *nin, *nout; int pret; unsigned int axis; airArray *mop; OPT_ADD_AXIS(axis, "dimension (axis index) at which to insert the new axis"); hestOptAdd(&opt, "l,label", "label", airTypeString, 1, 1, &label, "", "label to associate with new axis"); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_axinsertInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdAxesInsert(nout, nin, axis)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error inserting axis:\n%s", me, err); airMopError(mop); return 1; } if (strlen(label)) { nout->axis[axis].label = (char *)airFree(nout->axis[axis].label); nout->axis[axis].label = airStrdup(label); } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int tend_evalpowMain(int argc, char **argv, char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; Nrrd *nin, *nout; char *outS; float expo; hestOptAdd(&hopt, "p", "power", airTypeFloat, 1, 1, &expo, NULL, "Power to which to raise all the eigenvalues."); hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-", "input diffusion tensor volume", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output tensor volume"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_evalpowInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (tenEigenvaluePower(nout, nin, expo)) { 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 unrrdu_unblockMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; int type, pret; size_t blockSize; airArray *mop; OPT_ADD_TYPE(type, "type to unblock to", NULL); hestOptAdd(&opt, "bs", "blocksize", airTypeSize_t, 1, 1, &blockSize, "0", "Useful only if *output* type is also block: the size of " "blocks in output nrrd"); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_unblockInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); nout->blockSize = blockSize; airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdUnblock(nout, nin, type)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error unblocking nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int unrrdu_ccadjMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; airArray *mop; int pret; unsigned int conny; 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_ccadjInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdCCAdjacency(nout, nin, conny)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error finding adjacencies:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int tend_shrinkMain(int argc, char **argv, char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; Nrrd *nin, *nout; char *outS; hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-", "input diffusion tensor volume, with 9 matrix components " "per sample", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, NULL, "output tensor volume, with the 7 values per sample"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_shrinkInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (tenShrink(nout, NULL, nin)) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble shrinking tensors:\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 tkwbExpandImageInfo(tkwbSlide **slide) { char me[]="tkwbExpandImageInfo", err[BIFF_STRLEN], *image; Nrrd *nimg; int si, sx, sy, len; airArray *mop; mop = airMopNew(); nimg = nrrdNew(); airMopAdd(mop, nimg, (airMopper)nrrdNuke, airMopAlways); for (si=0; slide[si]; si++) { if (nrrdLoad(nimg, slide[si]->image, NULL)) { sprintf(err, "%s: trouble reading slide image \"%s\"", me, slide[si]->image); biffMove(TKWB, err, NRRD); airMopError(mop); return 1; } if (!nrrdFormatPNG->fitsInto(nimg, nrrdEncodingGzip, AIR_TRUE)) { sprintf(err, "%s: slide image \"%s\" doesn't seem to be an image", me, slide[si]->image); biffMove(TKWB, err, NRRD); airMopError(mop); return 1; } sx = nimg->axis[nimg->dim-2].size; sy = nimg->axis[nimg->dim-1].size; len = (strlen("<img width=xxxx height=xxxx src=\"\">") + strlen(slide[si]->image) + 1); image = (char *)calloc(len, sizeof(char)); sprintf(image, "<img width=%d height=%d src=\"%s\">", sx, sy, slide[si]->image); free(slide[si]->image); slide[si]->image = image; } airMopOkay(mop); return 0; }
float * _baneTRexRead(char *fname) { char me[]="_baneTRexRead"; if (nrrdLoad(baneNpos=nrrdNew(), fname, NULL)) { fprintf(stderr, "%s: !!! trouble reading \"%s\":\n%s\n", me, fname, biffGet(NRRD)); return NULL; } if (banePosCheck(baneNpos, 1)) { fprintf(stderr, "%s: !!! didn't get a valid p(x) file:\n%s\n", me, biffGet(BANE)); return NULL; } if (TREX_LUTLEN != baneNpos->axis[0].size) { fprintf(stderr, "%s: !!! need a length %d p(x) (not " _AIR_SIZE_T_CNV ")\n", me, TREX_LUTLEN, baneNpos->axis[0].size); return NULL; } return (float *)baneNpos->data; }
//struct Function; void callDiderot(char *Outfile, int type, void *valM, int imgResU,int imgResV, float stepSize){ basic_d2s_sample_World_t *wrld = basic_d2s_sample_New (); if (wrld == 0) { //fprintf (stderr, "Unable to create Diderot world\n"); exit (1); } basic_d2s_sample_Init (wrld);//initialize it. //initialize input vars basic_d2s_sample_InVarSet_m (wrld, valM); basic_d2s_sample_InVarSet_stepSize(wrld,stepSize); basic_d2s_sample_InVarSet_imgResU(wrld,imgResU); basic_d2s_sample_InVarSet_imgResV(wrld,imgResV); // nrrd for getting computational state Nrrd *nData = nrrdNew(); if (basic_d2s_sample_Initially (wrld)) {//intialize set of strands // error fprintf(stderr, "Error initializing world: %s", basic_d2s_sample_GetErrors(wrld)); exit(1); } int nSteps = basic_d2s_sample_Run (wrld, 0); //second paramter is the limit to # of steps. //0-to termination // change here for output var if (basic_d2s_sample_OutputGet_out(wrld, nData)) { // error fprintf(stderr, "Error getting nrrd data: %s", basic_d2s_sample_GetErrors(wrld)); exit(1); } WriteFile(nData, type, Outfile); basic_d2s_sample_Shutdown (wrld); }
int tend_makeMain(int argc, char **argv, char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; Nrrd *nin[3], *nout; char *outS; hestOptAdd(&hopt, "i", "conf evals evecs", airTypeOther, 3, 3, nin, NULL, "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_makeInfoL); JUSTPARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (tenMake(nout, nin[0], nin[1], nin[2])) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble making tensor volume:\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_swapMain(int argc, const char **argv, const char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; int pret; unsigned int ax[2]; airArray *mop; hestOptAdd(&opt, "a,axis", "axisA axisB", airTypeUInt, 2, 2, ax, NULL, "the two axes to switch (0-based numbering)"); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_swapInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdAxesSwap(nout, nin, ax[0], ax[1])) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error swapping nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int unrrdu_reshapeMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; Nrrd *nin, *nout; int pret; size_t *size; unsigned int sizeLen; airArray *mop; hestOptAdd(&opt, "s,size", "sz0 sz1 ", airTypeSize_t, 1, -1, &size, NULL, "new axes sizes", &sizeLen); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_reshapeInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdReshape_nva(nout, nin, sizeLen, size)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error reshaping nrrd:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
/* ** DOES use biff */ meetPullVol * meetPullVolCopy(const meetPullVol *mpv) { static const char me[]="meetPullVolCopy"; meetPullVol *ret; unsigned int si; airArray *mop; mop = airMopNew(); ret = meetPullVolNew(); airMopAdd(mop, ret, (airMopper)meetPullVolNix, airMopOnError); /* HEY: hope this is okay for dynamic kinds */ ret->kind = mpv->kind; ret->fileName = airStrdup(mpv->fileName); ret->volName = airStrdup(mpv->volName); if (mpv->sbp) { ret->sbp = gageStackBlurParmNew(); if (gageStackBlurParmCopy(ret->sbp, mpv->sbp)) { biffMovef(MEET, GAGE, "%s: problem", me); airMopError(mop); return NULL; } } ret->leeching = AIR_FALSE; ret->derivNormSS = mpv->derivNormSS; ret->recomputedSS = AIR_FALSE; ret->derivNormBiasSS = mpv->derivNormBiasSS; if (mpv->sbp) { ret->nin = NULL; ret->ninSS = AIR_CALLOC(ret->sbp->num, Nrrd *); for (si=0; si<mpv->sbp->num; si++) { ret->ninSS[si] = nrrdNew(); if (nrrdCopy(ret->ninSS[si], mpv->ninSS[si])) { biffMovef(MEET, NRRD, "%s: problem with ninSS[%u]", me, si); airMopError(mop); return NULL; } } } else {
int unrrdu_substMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err; int pret; Nrrd *nin, *nsubst, *nout; airArray *mop; hestOptAdd(&opt, "s,subst", "subst", airTypeOther, 1, 1, &nsubst, NULL, "substition table to map input nrrd through", NULL, NULL, nrrdHestNrrd); OPT_ADD_NIN(nin, "input nrrd"); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_substInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdApply1DSubstitution(nout, nin, nsubst)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble applying SUBST:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }