int tend_helixMain(int argc, char **argv, char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; int size[3], nit; Nrrd *nout; double R, r, S, bnd, angle, ev[3], ip[3], iq[4], mp[3], mq[4], tmp[9], orig[3], i2w[9], rot[9], mf[9], spd[4][3], bge; char *outS; hestOptAdd(&hopt, "s", "size", airTypeInt, 3, 3, size, NULL, "sizes along fast, medium, and slow axes of the sampled volume, " "often called \"X\", \"Y\", and \"Z\". It is best to use " "slightly different sizes here, to expose errors in interpreting " "axis ordering (e.g. \"-s 39 40 41\")"); hestOptAdd(&hopt, "ip", "image orientation", airTypeDouble, 3, 3, ip, "0 0 0", "quaternion quotient space orientation of image"); hestOptAdd(&hopt, "mp", "measurement orientation", airTypeDouble, 3, 3, mp, "0 0 0", "quaternion quotient space orientation of measurement frame"); hestOptAdd(&hopt, "b", "boundary", airTypeDouble, 1, 1, &bnd, "10", "parameter governing how fuzzy the boundary between high and " "low anisotropy is. Use \"-b 0\" for no fuzziness"); hestOptAdd(&hopt, "r", "little radius", airTypeDouble, 1, 1, &r, "30", "(minor) radius of cylinder tracing helix"); hestOptAdd(&hopt, "R", "big radius", airTypeDouble, 1, 1, &R, "50", "(major) radius of helical turns"); hestOptAdd(&hopt, "S", "spacing", airTypeDouble, 1, 1, &S, "100", "spacing between turns of helix (along its axis)"); hestOptAdd(&hopt, "a", "angle", airTypeDouble, 1, 1, &angle, "60", "maximal angle of twist of tensors along path. There is no " "twist at helical core of path, and twist increases linearly " "with radius around this path. Positive twist angle with " "positive spacing resulting in a right-handed twist around a " "right-handed helix. "); hestOptAdd(&hopt, "nit", NULL, airTypeInt, 0, 0, &nit, NULL, "changes behavior of twist angle as function of distance from " "center of helical core: instead of increasing linearly as " "describe above, be at a constant angle"); hestOptAdd(&hopt, "ev", "eigenvalues", airTypeDouble, 3, 3, ev, "0.006 0.002 0.001", "eigenvalues of tensors (in order) along direction of coil, " "circumferential around coil, and radial around coil. "); hestOptAdd(&hopt, "bg", "background", airTypeDouble, 1, 1, &bge, "0.5", "eigenvalue of isotropic background"); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output file"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_helixInfoL); JUSTPARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (nrrdMaybeAlloc_va(nout, nrrdTypeFloat, 4, AIR_CAST(size_t, 7), AIR_CAST(size_t, size[0]), AIR_CAST(size_t, size[1]), AIR_CAST(size_t, size[2]))) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble allocating output:\n%s\n", me, err); airMopError(mop); return 1; } ELL_4V_SET(iq, 1.0, ip[0], ip[1], ip[2]); ell_q_to_3m_d(rot, iq); ELL_3V_SET(orig, -2*R + 2*R/size[0], -2*R + 2*R/size[1], -2*R + 2*R/size[2]); ELL_3M_ZERO_SET(i2w); ELL_3M_DIAG_SET(i2w, 4*R/size[0], 4*R/size[1], 4*R/size[2]); ELL_3MV_MUL(tmp, rot, orig); ELL_3V_COPY(orig, tmp); ELL_3M_MUL(tmp, rot, i2w); ELL_3M_COPY(i2w, tmp); ELL_4V_SET(mq, 1.0, mp[0], mp[1], mp[2]); ell_q_to_3m_d(mf, mq); tend_helixDoit(nout, bnd, orig, i2w, mf, r, R, S, angle*AIR_PI/180, !nit, ev, bge); nrrdSpaceSet(nout, nrrdSpaceRightAnteriorSuperior); nrrdSpaceOriginSet(nout, orig); ELL_3V_SET(spd[0], AIR_NAN, AIR_NAN, AIR_NAN); ELL_3MV_COL0_GET(spd[1], i2w); ELL_3MV_COL1_GET(spd[2], i2w); ELL_3MV_COL2_GET(spd[3], i2w); nrrdAxisInfoSet_va(nout, nrrdAxisInfoSpaceDirection, spd[0], spd[1], spd[2], spd[3]); nrrdAxisInfoSet_va(nout, nrrdAxisInfoCenter, nrrdCenterUnknown, nrrdCenterCell, nrrdCenterCell, nrrdCenterCell); nrrdAxisInfoSet_va(nout, nrrdAxisInfoKind, nrrdKind3DMaskedSymMatrix, nrrdKindSpace, nrrdKindSpace, nrrdKindSpace); nout->measurementFrame[0][0] = mf[0]; nout->measurementFrame[1][0] = mf[1]; nout->measurementFrame[2][0] = mf[2]; nout->measurementFrame[0][1] = mf[3]; nout->measurementFrame[1][1] = mf[4]; nout->measurementFrame[2][1] = mf[5]; nout->measurementFrame[0][2] = mf[6]; nout->measurementFrame[1][2] = mf[7]; nout->measurementFrame[2][2] = mf[8]; 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 _nrrdFormatVTK_read(FILE *file, Nrrd *nrrd, NrrdIoState *nio) { static const char me[]="_nrrdReadVTK"; char *three[3]; int sx, sy, sz, ret, N; double xm=0.0, ym=0.0, zm=0.0, xs=1.0, ys=1.0, zs=1.0; airArray *mop; unsigned int llen; if (!_nrrdFormatVTK_contentStartsLike(nio)) { biffAddf(NRRD, "%s: this doesn't look like a %s file", me, nrrdFormatVTK->name); return 1; } #define GETLINE(what) \ do { \ ret = _nrrdOneLine(&llen, nio, file); \ } while (!ret && (1 == llen)); \ if (ret || !llen) { \ biffAddf(NRRD, "%s: couldn't get " #what " line", me); \ return 1; \ } /* read in content */ GETLINE(content); if (strcmp(NRRD_UNKNOWN, nio->line)) { if (!(nrrd->content = airStrdup(nio->line))) { biffAddf(NRRD, "%s: couldn't read or copy content string", me); return 1; } } GETLINE(encoding); airToUpper(nio->line); if (!strcmp("ASCII", nio->line)) { nio->encoding = nrrdEncodingAscii; } else if (!strcmp("BINARY", nio->line)) { nio->encoding = nrrdEncodingRaw; } else { biffAddf(NRRD, "%s: encoding \"%s\" wasn't \"ASCII\" or \"BINARY\"", me, nio->line); return 1; } GETLINE(DATASET); airToUpper(nio->line); if (!strstr(nio->line, "STRUCTURED_POINTS")) { biffAddf(NRRD, "%s: sorry, only STRUCTURED_POINTS data is nrrd-ready", me); return 1; } GETLINE(DIMENSIONS); airToUpper(nio->line); if (!strstr(nio->line, "DIMENSIONS") || 3 != sscanf(nio->line, "DIMENSIONS %d %d %d", &sx, &sy, &sz)) { biffAddf(NRRD, "%s: couldn't parse DIMENSIONS line (\"%s\")", me, nio->line); return 1; } GETLINE(next); airToUpper(nio->line); while (!strstr(nio->line, "POINT_DATA")) { if (strstr(nio->line, "ORIGIN")) { if (3 != sscanf(nio->line, "ORIGIN %lf %lf %lf", &xm, &ym, &zm)) { biffAddf(NRRD, "%s: couldn't parse ORIGIN line (\"%s\")", me, nio->line); return 1; } } else if (strstr(nio->line, "SPACING")) { if (3 != sscanf(nio->line, "SPACING %lf %lf %lf", &xs, &ys, &zs)) { biffAddf(NRRD, "%s: couldn't parse SPACING line (\"%s\")", me, nio->line); return 1; } } else if (strstr(nio->line, "ASPECT_RATIO")) { if (3 != sscanf(nio->line, "ASPECT_RATIO %lf %lf %lf", &xs, &ys, &zs)) { biffAddf(NRRD, "%s: couldn't parse ASPECT_RATIO line (\"%s\")", me, nio->line); return 1; } } GETLINE(next); airToUpper(nio->line); } if (1 != sscanf(nio->line, "POINT_DATA %d", &N)) { biffAddf(NRRD, "%s: couldn't parse POINT_DATA line (\"%s\")", me, nio->line); return 1; } if (N != sx*sy*sz) { biffAddf(NRRD, "%s: product of sizes (%d*%d*%d == %d) != # elements (%d)", me, sx, sy, sz, sx*sy*sz, N); return 1; } GETLINE(attribute declaration); mop = airMopNew(); if (3 != airParseStrS(three, nio->line, AIR_WHITESPACE, 3, AIR_FALSE)) { biffAddf(NRRD, "%s: didn't see three words in attribute declaration \"%s\"", me, nio->line); return 1; } airMopAdd(mop, three[0], airFree, airMopAlways); airMopAdd(mop, three[1], airFree, airMopAlways); airMopAdd(mop, three[2], airFree, airMopAlways); airToLower(three[2]); if (!strcmp(three[2], "bit")) { if (nrrdEncodingAscii == nio->encoding) { fprintf(stderr, "%s: WARNING: \"bit\"-type data will be read in as " "unsigned char\n", me); nrrd->type = nrrdTypeUChar; } else { biffAddf(NRRD, "%s: can't read in \"bit\"-type data as BINARY", me); return 1; } } else if (!strcmp(three[2], "unsigned_char")) { nrrd->type = nrrdTypeUChar; } else if (!strcmp(three[2], "char")) { nrrd->type = nrrdTypeChar; } else if (!strcmp(three[2], "unsigned_short")) { nrrd->type = nrrdTypeUShort; } else if (!strcmp(three[2], "short")) { nrrd->type = nrrdTypeShort; } else if (!strcmp(three[2], "unsigned_int")) { nrrd->type = nrrdTypeUInt; } else if (!strcmp(three[2], "int")) { nrrd->type = nrrdTypeInt; } else if (!strcmp(three[2], "float")) { nrrd->type = nrrdTypeFloat; } else if (!strcmp(three[2], "double")) { nrrd->type = nrrdTypeDouble; } else { /* "unsigned_long" and "long" fall in here- I don't know what the VTK people mean by these types, since always mean different things on 32-bit versus 64-bit architectures */ biffAddf(NRRD, "%s: type \"%s\" not recognized", me, three[2]); airMopError(mop); return 1; } airToUpper(three[0]); if (!strncmp("SCALARS", three[0], strlen("SCALARS"))) { GETLINE(LOOKUP_TABLE); airToUpper(nio->line); if (strcmp(nio->line, "LOOKUP_TABLE DEFAULT")) { biffAddf(NRRD, "%s: sorry, can only deal with default LOOKUP_TABLE", me); airMopError(mop); return 1; } nrrd->dim = 3; nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoSize, AIR_CAST(size_t, sx), AIR_CAST(size_t, sy), AIR_CAST(size_t, sz)); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoSpacing, xs, ys, zs); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, xm, ym, zm); } else if (!strncmp("VECTORS", three[0], strlen("VECTORS"))) { nrrd->dim = 4; nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoSize, AIR_CAST(size_t, 3), AIR_CAST(size_t, sx), AIR_CAST(size_t, sy), AIR_CAST(size_t, sz)); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoSpacing, AIR_NAN, xs, ys, zs); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, AIR_NAN, xm, ym, zm); nrrd->axis[0].kind = nrrdKind3Vector; } else if (!strncmp("TENSORS", three[0], strlen("TENSORS"))) { nrrd->dim = 4; nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoSize, AIR_CAST(size_t, 9), AIR_CAST(size_t, sx), AIR_CAST(size_t, sy), AIR_CAST(size_t, sz)); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoSpacing, AIR_NAN, xs, ys, zs); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, AIR_NAN, xm, ym, zm); nrrd->axis[0].kind = nrrdKind3DMatrix; } else { biffAddf(NRRD, "%s: sorry, can only deal with SCALARS, VECTORS, and TENSORS " "currently, so couldn't parse attribute declaration \"%s\"", me, nio->line); airMopError(mop); return 1; } if (!nio->skipData) { if (_nrrdCalloc(nrrd, nio, file)) { biffAddf(NRRD, "%s: couldn't allocate memory for data", me); return 1; } if (nio->encoding->read(file, nrrd->data, nrrdElementNumber(nrrd), nrrd, nio)) { biffAddf(NRRD, "%s:", me); return 1; } if (1 < nrrdElementSize(nrrd) && nio->encoding->endianMatters && airMyEndian() != airEndianBig) { /* encoding exposes endianness, and its big, but we aren't */ nrrdSwapEndian(nrrd); } } else { nrrd->data = NULL; } airMopOkay(mop); return 0; }
int baneGkms_txfMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *perr, err[BIFF_STRLEN]; Nrrd *nout; airArray *mop; int pret, E, res[2], vi, gi, step; float min[2], max[2], top[2], v0, g0, *data, v, g, gwidth, width, mwidth, tvl, tvr, vl, vr, tmp, maxa; hestOptAdd(&opt, "r", "Vres Gres", airTypeInt, 2, 2, res, "256 256", "resolution of the transfer function in value and gradient " "magnitude"); hestOptAdd(&opt, "min", "Vmin Gmin", airTypeFloat, 2, 2, min, "0.0 0.0", "minimum value and grad mag in txf"); hestOptAdd(&opt, "max", "Vmax Gmax", airTypeFloat, 2, 2, max, NULL, "maximum value and grad mag in txf"); hestOptAdd(&opt, "v", "base value", airTypeFloat, 1, 1, &v0, NULL, "data value at which to position bottom of triangle"); hestOptAdd(&opt, "g", "gthresh", airTypeFloat, 1, 1, &g0, "0.0", "lowest grad mag to receive opacity"); hestOptAdd(&opt, "gw", "gwidth", airTypeFloat, 1, 1, &gwidth, "0.0", "range of grad mag values over which to apply threshold " "at low gradient magnitudes"); hestOptAdd(&opt, "top", "Vtop Gtop", airTypeFloat, 2, 2, top, NULL, "data value and grad mag at center of top of triangle"); hestOptAdd(&opt, "w", "value width", airTypeFloat, 1, 1, &width, NULL, "range of values to be spanned at top of triangle"); hestOptAdd(&opt, "mw", "value width", airTypeFloat, 1, 1, &mwidth, "0", "range of values to be spanned at BOTTOM of triangle"); hestOptAdd(&opt, "step", NULL, airTypeInt, 0, 0, &step, NULL, "instead of assigning opacity inside a triangular region, " "make it more like a step function, in which opacity never " "decreases in increasing data value"); hestOptAdd(&opt, "a", "max opac", airTypeFloat, 1, 1, &maxa, "1.0", "highest opacity to assign"); hestOptAdd(&opt, "o", "opacOut", airTypeString, 1, 1, &out, NULL, "output opacity function filename"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_baneGkms_txfInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); E = 0; if (!E) E |= nrrdMaybeAlloc_va(nout, nrrdTypeFloat, 3, AIR_CAST(size_t, 1), AIR_CAST(size_t, res[0]), AIR_CAST(size_t, res[1])); if (!E) E |= !(nout->axis[0].label = airStrdup("A")); if (!E) E |= !(nout->axis[1].label = airStrdup("gage(scalar:v)")); if (!E) nrrdAxisInfoSet_va(nout, nrrdAxisInfoMin, AIR_NAN, (double)min[0], (double)min[1]); if (!E) nrrdAxisInfoSet_va(nout, nrrdAxisInfoMax, AIR_NAN, (double)max[0], (double)max[1]); if (!E) E |= !(nout->axis[2].label = airStrdup("gage(scalar:gm)")); if (E) { sprintf(err, "%s: trouble creating opacity function nrrd", me); biffMove(BANE, err, NRRD); airMopError(mop); return 1; } data = (float *)nout->data; tvl = top[0] - width/2; tvr = top[0] + width/2; mwidth /= 2; for (gi=0; gi<res[1]; gi++) { g = AIR_CAST(float, NRRD_CELL_POS(min[1], max[1], res[1], gi)); for (vi=0; vi<res[0]; vi++) { v = AIR_CAST(float, NRRD_CELL_POS(min[0], max[0], res[0], vi)); vl = AIR_CAST(float, AIR_AFFINE(0, g, top[1], v0-mwidth, tvl)); vr = AIR_CAST(float, AIR_AFFINE(0, g, top[1], v0+mwidth, tvr)); if (g > top[1]) { data[vi + res[0]*gi] = 0; continue; } tmp = AIR_CAST(float, (v - vl)/(0.00001 + vr - vl)); tmp = 1 - AIR_ABS(2*tmp - 1); if (step && v > (vr + vl)/2) { tmp = 1; } tmp = AIR_MAX(0, tmp); data[vi + res[0]*gi] = tmp*maxa; tmp = AIR_CAST(float, AIR_AFFINE(g0 - gwidth/2, g, g0 + gwidth/2, 0.0, 1.0)); tmp = AIR_CLAMP(0, tmp, 1); data[vi + res[0]*gi] *= tmp; } } if (nrrdSave(out, nout, NULL)) { sprintf(err, "%s: trouble saving opacity function", me); biffMove(BANE, err, NRRD); airMopError(mop); return 1; } airMopOkay(mop); return 0; }
int main(int argc, char *argv[]) { int i; Nrrd *nrrd; double diff, idx, idx2, idx3, idx4, lo, hi, pos, pos2, pos3, pos4; AIR_UNUSED(argc); AIR_UNUSED(argv); if (nrrdAlloc_va(nrrd=nrrdNew(), nrrdTypeFloat, 2, AIR_CAST(size_t, 4), AIR_CAST(size_t, 4))) { printf("trouble:\n%s\n", biffGet(NRRD)); exit(1); } nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, 10.0, 10.0); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMax, 12.0, 12.0); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoCenter, nrrdCenterNode, nrrdCenterCell); idx = 0; printf("\n"); pos = nrrdAxisInfoPos(nrrd, 0, idx); printf("pos(0, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos)); pos = nrrdAxisInfoPos(nrrd, 1, idx); printf("pos(1, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos)); idx = 1; printf("\n"); pos = nrrdAxisInfoPos(nrrd, 0, idx); printf("pos(0, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos)); pos = nrrdAxisInfoPos(nrrd, 1, idx); printf("pos(1, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos)); idx = 2; printf("\n"); pos = nrrdAxisInfoPos(nrrd, 0, idx); printf("pos(0, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos)); pos = nrrdAxisInfoPos(nrrd, 1, idx); printf("pos(1, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos)); idx = 0; idx2 = 0; printf("\n"); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi); printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi); printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); idx = 0; idx2 = 1; printf("\n"); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi); printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi); printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); idx = 1; idx2 = 0; printf("\n"); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi); printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi); printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, 12.0, 12.0); nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMax, 10.0, 10.0); printf("\n(axis min,max flipped)\n"); idx = 0; printf("\n"); pos = nrrdAxisInfoPos(nrrd, 0, idx); printf("pos(0, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos)); pos = nrrdAxisInfoPos(nrrd, 1, idx); printf("pos(1, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos)); idx = 1; printf("\n"); pos = nrrdAxisInfoPos(nrrd, 0, idx); printf("pos(0, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos)); pos = nrrdAxisInfoPos(nrrd, 1, idx); printf("pos(1, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos)); idx = 2; printf("\n"); pos = nrrdAxisInfoPos(nrrd, 0, idx); printf("pos(0, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos)); pos = nrrdAxisInfoPos(nrrd, 1, idx); printf("pos(1, %g) == %g --> %g\n", idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos)); idx = 0; idx2 = 0; printf("\n"); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi); printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi); printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); idx = 0; idx2 = 2; printf("\n"); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi); printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi); printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); idx = 2; idx2 = 0; printf("\n"); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi); printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi); printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n", idx, idx2, lo, hi, idx3, idx4); nrrd->axis[0].center = nrrdCenterCell; nrrd->axis[0].size = 4; nrrd->axis[0].min = -4; nrrd->axis[0].max = 4; pos = 0; pos2 = 1; nrrdAxisInfoIdxRange(&idx, &idx2, nrrd, 0, pos, pos2); nrrdAxisInfoPosRange(&pos3, &pos4, nrrd, 0, idx, idx2); printf("min, max = %g, %g\n", nrrd->axis[0].min, nrrd->axis[0].max); printf("pos, pos2 = %g, %g\n", pos, pos2); printf("idx, idx2 = %g, %g\n", idx, idx2); printf("pos3, pos4 = %g, %g\n", pos3, pos4); exit(1); /* and now for random-ness */ airSrandMT((int)airTime()); nrrd->axis[0].center = nrrdCenterNode; nrrd->axis[0].center = nrrdCenterCell; for (i=0; i<=1000000; i++) { nrrd->axis[0].min = frand(-3.0, 3.0); nrrd->axis[0].max = frand(-3.0, 3.0); idx = frand(-3.0, 3.0); pos = nrrdAxisInfoPos(nrrd, 0, idx); diff = idx - nrrdAxisInfoIdx(nrrd, 0, pos); if (AIR_ABS(diff) > 0.00000001) { printf("PANIC 0\n"); exit(2); } pos = frand(-3.0, 3.0); idx = nrrdAxisInfoIdx(nrrd, 0, pos); diff = pos - nrrdAxisInfoPos(nrrd, 0, idx); if (AIR_ABS(diff) > 0.00000001) { printf("PANIC 1\n"); exit(2); } nrrd->axis[0].min = (int)frand(-3.0, 3.0); nrrd->axis[0].max = (int)frand(-3.0, 3.0); idx = (int)frand(-10.0, 10.0); idx2 = (int)frand(-10.0, 10.0); nrrdAxisInfoPosRange(&pos, &pos2, nrrd, 0, idx, idx2); nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, pos, pos2); diff = AIR_ABS(idx - idx3) + AIR_ABS(idx2 - idx4); if (AIR_ABS(diff) > 0.00000001) { printf("PANIC 2\n"); exit(2); } pos = (int)frand(-3.0, 3.0); pos2 = (int)frand(-3.0, 3.0); nrrdAxisInfoIdxRange(&idx, &idx2, nrrd, 0, pos, pos2); nrrdAxisInfoPosRange(&pos3, &pos4, nrrd, 0, idx, idx2); diff = AIR_ABS(pos - pos3) + AIR_ABS(pos2 - pos4); if (AIR_ABS(diff) > 0.00000001) { printf("min, max = %g, %g\n", nrrd->axis[0].min, nrrd->axis[0].max); printf("pos, pos2 = %g, %g\n", pos, pos2); printf("idx, idx2 = %g, %g\n", idx, idx2); printf("pos3, pos4 = %g, %g\n", pos3, pos4); printf("PANIC (%d) 3 %g\n", (int)nrrd->axis[0].size, diff); exit(2); } } exit(0); }
int main(int argc, const char *argv[]) { const char *me; char *err, *out; int size[3], xi, yi, zi; hestOpt *hopt; hestParm *hparm; airArray *mop; float min[3], max[3], AB[2], x, y, z, *data, off; Nrrd *nout; me = argv[0]; mop = airMopNew(); hparm = hestParmNew(); hopt = NULL; airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways); hestOptAdd(&hopt, "s", "sx sy sz", airTypeInt, 3, 3, size, "128 128 128", "dimensions of output volume"); hestOptAdd(&hopt, "min", "x y z", airTypeFloat, 3, 3, min, "-1 -1 -1", "lower bounding corner of volume"); hestOptAdd(&hopt, "max", "x y z", airTypeFloat, 3, 3, max, "1 1 1", "upper bounding corner of volume"); hestOptAdd(&hopt, "c", "A B", airTypeFloat, 2, 2, AB, NULL, "A and B quadratic coefficients"); hestOptAdd(&hopt, "off", "z offset", airTypeFloat, 1, 1, &off, "0.0", "vertical offset"); hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &out, "-", "file to write output nrrd to"); hestParseOrDie(hopt, argc-1, argv+1, hparm, me, quadInfo, 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 (nrrdAlloc_va(nout, nrrdTypeFloat, 3, AIR_CAST(size_t, size[0]), AIR_CAST(size_t, size[1]), AIR_CAST(size_t, size[2]))) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: problem allocating volume:\n%s\n", me, err); airMopError(mop); return 1; } data = (float *)nout->data; for (zi=0; zi<size[2]; zi++) { z = AIR_AFFINE(0, zi, size[2]-1, min[2], max[2]); for (yi=0; yi<size[1]; yi++) { y = AIR_AFFINE(0, yi, size[1]-1, min[1], max[1]); for (xi=0; xi<size[0]; xi++) { x = AIR_AFFINE(0, xi, size[0]-1, min[0], max[0]); *data = quadFunc(x,y,z, AB[0], AB[1], off); data += 1; } } } nrrdAxisInfoSet_va(nout, nrrdAxisInfoMin, min[0], min[1], min[2]); nrrdAxisInfoSet_va(nout, nrrdAxisInfoMax, max[0], max[1], max[2]); nrrdAxisInfoSpacingSet(nout, 0); nrrdAxisInfoSpacingSet(nout, 1); nrrdAxisInfoSpacingSet(nout, 2); if (nrrdSave(out, nout, NULL)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: problem saving output:\n%s\n", me, err); airMopError(mop); return 1; } airMopOkay(mop); exit(0); }
int NrrdWriter(HxUniformScalarField3* field, const char* filename, int encoding) { // Identify data type int nrrdType = nrrdTypeUnknown; switch ( field->primType() ) { case McPrimType::mc_uint8: nrrdType = nrrdTypeUChar; break; case McPrimType::mc_int8: nrrdType = nrrdTypeChar; break; case McPrimType::mc_uint16: nrrdType = nrrdTypeUShort; break; case McPrimType::mc_int16: nrrdType = nrrdTypeShort; break; case McPrimType::mc_int32: nrrdType = nrrdTypeInt; break; case McPrimType::mc_float: nrrdType = nrrdTypeFloat; break; case McPrimType::mc_double: nrrdType = nrrdTypeDouble; break; default: break; } if(nrrdType == nrrdTypeUnknown) { theMsg->printf("ERROR: unsupported output type: %s for nrrd",field->primType().getName()); return 0; } void* data = field->lattice.dataPtr(); Nrrd *nrrd = nrrdNew(); NrrdIoState *nios = nrrdIoStateNew(); if ( encoding == nrrdEncodingTypeGzip) { if (nrrdEncodingGzip->available() ) { nrrdIoStateEncodingSet( nios, nrrdEncodingGzip ); nrrdIoStateSet( nios, nrrdIoStateZlibLevel, 9 ); } else theMsg->printf("WARNING: Nrrd library does not support Gzip compression encoding.\n Make sure Teem_ZLIB is on in CMAKE when building Nrrd library.\n"); } else if ( encoding == nrrdEncodingTypeBzip2) { if (nrrdEncodingBzip2->available() ) { nrrdIoStateEncodingSet( nios, nrrdEncodingBzip2 ); // nrrdIoStateSet( nios, nrrdIoStateBzip2BlockSize, 9 ); } else theMsg->printf("WARNING: Nrrd library does not support Bzip2 compression encoding.\n Make sure Teem_BZIP2 is on in CMAKE when building Nrrd library.\n"); } else if ( encoding == nrrdEncodingTypeAscii) { nrrdIoStateEncodingSet( nios, nrrdEncodingAscii ); } else { theMsg->printf("ERROR: Unimplemented nrrd encoding type: %d\n",encoding); return 0; } try { if ( nrrdWrap_va( nrrd, data, nrrdType, (size_t)3, (size_t)field->lattice.dimsInt()[0], (size_t)field->lattice.dimsInt()[1], (size_t)field->lattice.dimsInt()[2] ) ) { throw( biffGetDone(NRRD) ); } nrrdSpaceDimensionSet( nrrd, 3 ); // TODO: Would be nice to set space units. How does Amira store this? // if ( writeVolume->MetaKeyExists(CMTK_META_SPACE_UNITS_STRING) ) // { // nrrd->spaceUnits[0] = strdup( writeVolume->m_MetaInformation[CMTK_META_SPACE_UNITS_STRING].c_str() ); // nrrd->spaceUnits[1] = strdup( writeVolume->m_MetaInformation[CMTK_META_SPACE_UNITS_STRING].c_str() ); // nrrd->spaceUnits[2] = strdup( writeVolume->m_MetaInformation[CMTK_META_SPACE_UNITS_STRING].c_str() ); // } int kind[NRRD_DIM_MAX] = { nrrdKindDomain, nrrdKindDomain, nrrdKindDomain }; nrrdAxisInfoSet_nva( nrrd, nrrdAxisInfoKind, kind ); // TODO: Would be nice to write some kind of space if this exists // Fetch bounding box information and voxel size float* bbox = field->bbox(); McVec3f voxelSize = field->getVoxelSize(); // Just deal with space directions orthogonal to data axes // TODO: Fetch transformation and use that double spaceDir[NRRD_DIM_MAX][NRRD_SPACE_DIM_MAX]; for ( int i = 0; i < 3; ++i ) { for ( int j = 0; j < 3; ++j ) { if (i == j) spaceDir[i][j] = (double) voxelSize[i]; else spaceDir[i][j] = 0.0; // Can't assume that memory is zeroed } } nrrdAxisInfoSet_nva( nrrd, nrrdAxisInfoSpaceDirection, spaceDir ); double origin[NRRD_DIM_MAX] = { bbox[0], bbox[2], bbox[4] }; if ( nrrdSpaceOriginSet( nrrd, origin ) ) { throw( biffGetDone(NRRD) ); } nrrdAxisInfoSet_va( nrrd, nrrdAxisInfoLabel, "x", "y", "z" ); if ( nrrdSave( filename, nrrd, nios ) ) { throw( biffGetDone(NRRD) ); } } catch ( char* err ) { theMsg->printf("ERROR: hxNrrdIO library returned error '%s'\n", err); free( err ); return 0; } nrrdIoStateNix( nios ); nrrdNix(nrrd); return 1; }