/* ******** tenGradientRandom ** ** generates num random unit vectors of type double */ int tenGradientRandom(Nrrd *ngrad, unsigned int num, unsigned int seed) { static const char me[]="tenGradientRandom"; double *grad, len; unsigned int gi; if (nrrdMaybeAlloc_va(ngrad, nrrdTypeDouble, 2, AIR_CAST(size_t, 3), AIR_CAST(size_t, num))) { biffMovef(TEN, NRRD, "%s: couldn't allocate output", me); return 1; } airSrandMT(seed); grad = AIR_CAST(double*, ngrad->data); for (gi=0; gi<num; gi++) { do { grad[0] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1); grad[1] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1); grad[2] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1); len = ELL_3V_LEN(grad); } while (len > 1 || !len); ELL_3V_SCALE(grad, 1.0/len, grad); grad += 3; } return 0; }
int main(int argc, const char *argv[]) { airArray *mop; hestOpt *hopt=NULL; int i, N, M, P, yes, *year; unsigned int E; const char *me; double crct; me = argv[0]; mop = airMopNew(); hestOptAdd(&hopt, "N", "days", airTypeInt, 1, 1, &N, "365", "# of days in year"); /* E != P */ hestOptAdd(&hopt, "E", "exps", airTypeInt, 1, 1, &P, "100000", "number of experiments after which to print out newly " "computed probability"); hestOptAdd(&hopt, NULL, "people", airTypeInt, 1, 1, &M, NULL, "# of people in room"); hestParseOrDie(hopt, argc-1, argv+1, NULL, me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); if (!( N > 1 && M > 0 && P > 1)) { fprintf(stderr, "%s: need both M, P all > 1, M > 0\n", me); airMopError(mop); exit(1); } if (!(year = (int*)calloc(N, sizeof(int)))) { fprintf(stderr, "%s: couldn't calloc(%d,sizeof(int))\n", me, N); airMopError(mop); exit(1); } airMopMem(mop, year, airMopAlways); crct = 1; for (i=0; i<M; i++) { crct *= (double)(N-i)/N; } crct = 1-crct; yes = 0; E = 1; airSrandMT((int)airTime()); while (E) { yes += runexp(year, N, M); if (!(E % P)) { printf("P = %10d/%10d = %22.20f =?= %22.20f\n", yes, E, (double)yes/E, crct); } E++; } airMopOkay(mop); exit(0); }
int pushStart(pushContext *pctx) { char me[]="pushStart", err[BIFF_STRLEN]; unsigned int tidx; if (_pushContextCheck(pctx)) { sprintf(err, "%s: trouble", me); biffAdd(PUSH, err); return 1; } airSrandMT(pctx->seed); /* the ordering of things below is important: gage and fiber contexts have to be set up before they're copied by task setup */ if (_pushTensorFieldSetup(pctx) || _pushGageSetup(pctx) || _pushFiberSetup(pctx) || _pushTaskSetup(pctx) || _pushBinSetup(pctx) || _pushThingSetup(pctx)) { sprintf(err, "%s: trouble setting up context", me); biffAdd(PUSH, err); return 1; } /* HEY: this should be done by the user */ pctx->process[0] = _pushForce; pctx->process[1] = _pushUpdate; pctx->finished = AIR_FALSE; if (pctx->numThread > 1) { pctx->binMutex = airThreadMutexNew(); pctx->stageBarrierA = airThreadBarrierNew(pctx->numThread); pctx->stageBarrierB = airThreadBarrierNew(pctx->numThread); } /* start threads 1 and up running; they'll all hit stageBarrierA */ for (tidx=1; tidx<pctx->numThread; tidx++) { if (pctx->verbose > 1) { fprintf(stderr, "%s: spawning thread %d\n", me, tidx); } airThreadStart(pctx->task[tidx]->thread, _pushWorker, (void *)(pctx->task[tidx])); } return 0; }
int tend_msimMain(int argc, const char **argv, const char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; airArray *mop; tenExperSpec *espec; const tenModel *model; int E, seed, keyValueSet, outType, plusB0, insertB0; Nrrd *nin, *nT2, *_ngrad, *ngrad, *nout; char *outS, *modS; double bval, sigma; /* maybe this can go in tend.c, but for some reason its explicitly set to AIR_FALSE there */ hparm->elideSingleOtherDefault = AIR_TRUE; hestOptAdd(&hopt, "sigma", "sigma", airTypeDouble, 1, 1, &sigma, "0.0", "Gaussian/Rician noise parameter"); hestOptAdd(&hopt, "seed", "seed", airTypeInt, 1, 1, &seed, "42", "seed value for RNG which creates noise"); hestOptAdd(&hopt, "g", "grad list", airTypeOther, 1, 1, &_ngrad, NULL, "gradient list, one row per diffusion-weighted image", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "b0", "b0 image", airTypeOther, 1, 1, &nT2, "", "reference non-diffusion-weighted (\"B0\") image, which " "may be needed if it isn't part of give model param image", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "i", "model image", airTypeOther, 1, 1, &nin, "-", "input model image", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "m", "model", airTypeString, 1, 1, &modS, NULL, "model with which to simulate DWIs, which must be specified if " "it is not indicated by the first axis in input model image."); hestOptAdd(&hopt, "ib0", "bool", airTypeBool, 1, 1, &insertB0, "false", "insert a non-DW B0 image at the beginning of the experiment " "specification (useful if the given gradient list doesn't " "already have one) and hence also insert a B0 image at the " "beginning of the output simulated DWIs"); hestOptAdd(&hopt, "b", "b", airTypeDouble, 1, 1, &bval, "1000", "b value for simulated scan"); hestOptAdd(&hopt, "kvp", "bool", airTypeBool, 1, 1, &keyValueSet, "true", "generate key/value pairs in the NRRD header corresponding " "to the input b-value and gradients."); hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &outType, "float", "output type of DWIs", NULL, nrrdType); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output dwis"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_msimInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); espec = tenExperSpecNew(); airMopAdd(mop, espec, (airMopper)tenExperSpecNix, airMopAlways); airSrandMT(seed); if (nrrdTypeDouble == _ngrad->type) { ngrad = _ngrad; } else { ngrad = nrrdNew(); airMopAdd(mop, ngrad, (airMopper)nrrdNuke, airMopAlways); if (nrrdConvert(ngrad, _ngrad, nrrdTypeDouble)) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble converting grads to %s:\n%s\n", me, airEnumStr(nrrdType, nrrdTypeDouble), err); airMopError(mop); return 1; } } plusB0 = AIR_FALSE; if (airStrlen(modS)) { if (tenModelParse(&model, &plusB0, AIR_FALSE, modS)) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble parsing model \"%s\":\n%s\n", me, modS, err); airMopError(mop); return 1; } } else if (tenModelFromAxisLearnPossible(nin->axis + 0)) { if (tenModelFromAxisLearn(&model, &plusB0, nin->axis + 0)) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble parsing model frmo axis 0 of nin:\n%s\n", me, err); airMopError(mop); return 1; } } else { fprintf(stderr, "%s: need model specified either via \"-m\" or input " "model image axis 0\n", me); airMopError(mop); return 1; } /* we have learned plusB0, but we don't actually need it; either: it describes the given model param image (which is courteous but not necessary since the logic inside tenModeSimulate will see this), or: it is trying to say something about including B0 amongst model parameters (which isn't actually meaningful in the context of simulated DWIs */ E = 0; if (!E) E |= tenGradientCheck(ngrad, nrrdTypeDouble, 1); if (!E) E |= tenExperSpecGradSingleBValSet(espec, insertB0, bval, AIR_CAST(const double *, ngrad->data), ngrad->axis[1].size); if (!E) E |= tenModelSimulate(nout, outType, espec, model, nT2, nin, keyValueSet); if (E) { 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 main() { airArray *mop, *submop; char *err; int typi; unsigned int supi, probePass, cti /* context copy index */, pvlIdx[NRRD_TYPE_MAX+1], sx, sy, sz, subnum; size_t sizes[3] = {42,61,50} /* one of these must be even */, ii, nn; Nrrd *norigScl, *nucharScl, *nunquant, *nqdiff, *nconvScl[NRRD_TYPE_MAX+1]; unsigned char *ucharScl; gageContext *gctx[2][KERN_SIZE_MAX+1]; gagePerVolume *gpvl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1]; const double *vansScl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1], *gansScl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1], *hansScl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1]; double *origScl, omin, omax, dsx, dsy, dsz, spcOrig[NRRD_SPACE_DIM_MAX] = {0.0, 0.0, 0.0}, spcVec[3][NRRD_SPACE_DIM_MAX] = { {1.1, 0.0, 0.0}, {0.0, 2.2, 0.0}, {0.0, 0.0, 3.3}}; mop = airMopNew(); #define NRRD_NEW(name, mop) \ (name) = nrrdNew(); \ airMopAdd((mop), (name), (airMopper)nrrdNuke, airMopAlways) /* --------------------------------------------------------------- */ /* Creating initial volume */ NRRD_NEW(norigScl, mop); if (nrrdMaybeAlloc_nva(norigScl, nrrdTypeDouble, 3, sizes)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "trouble allocating:\n%s", err); airMopError(mop); return 1; } origScl = AIR_CAST(double *, norigScl->data); nn = nrrdElementNumber(norigScl); airSrandMT(42*42); for (ii=0; ii<nn/2; ii++) { airNormalRand(origScl + 2*ii + 0, origScl + 2*ii + 1); } /* learn real range */ omin = omax = origScl[0]; for (ii=1; ii<nn; ii++) { omin = AIR_MIN(omin, origScl[ii]); omax = AIR_MAX(omax, origScl[ii]); } ELL_3V_SET(spcOrig, 0.0, 0.0, 0.0); if (nrrdSpaceSet(norigScl, nrrdSpaceRightAnteriorSuperior) || nrrdSpaceOriginSet(norigScl, spcOrig)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "trouble setting space:\n%s", err); airMopError(mop); return 1; } nrrdAxisInfoSet_nva(norigScl, nrrdAxisInfoSpaceDirection, spcVec); dsx = AIR_CAST(double, sizes[0]); dsy = AIR_CAST(double, sizes[1]); dsz = AIR_CAST(double, sizes[2]); sx = AIR_CAST(unsigned int, sizes[0]); sy = AIR_CAST(unsigned int, sizes[1]); sz = AIR_CAST(unsigned int, sizes[2]); subnum = AIR_CAST(unsigned int, PROBE_NUM*0.9); /* --------------------------------------------------------------- */ /* Quantizing to 8-bits and checking */ submop = airMopNew(); NRRD_NEW(nucharScl, mop); NRRD_NEW(nunquant, submop); NRRD_NEW(nqdiff, submop); if (nrrdQuantize(nucharScl, norigScl, NULL, 8) || nrrdUnquantize(nunquant, nucharScl, nrrdTypeDouble) || nrrdArithBinaryOp(nqdiff, nrrdBinaryOpSubtract, norigScl, nunquant)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "trouble quantizing and back:\n%s", err); airMopError(submop); airMopError(mop); return 1; } if (!( nucharScl->oldMin == omin && nucharScl->oldMax == omax )) { fprintf(stderr, "quantization range [%g,%g] != real range [%g,%g]\n", nucharScl->oldMin, nucharScl->oldMax, omin, omax); airMopError(submop); airMopError(mop); return 1; } { double *qdiff, *unquant; /* empirically determined tolerance, which had to be increased in order to work under valgrind (!)- perhaps because of a difference in the use of 80-bit registers */ double epsilon=0.50000000000004; qdiff = AIR_CAST(double *, nqdiff->data); unquant = AIR_CAST(double *, nunquant->data); for (ii=0; ii<nn; ii++) { double dd; /* with infinite precision, the max difference between original and quantized values should be exactly half the width (in value) of 1/256 of value range ==> dd = 0.5 */ dd = qdiff[ii]*256/(omax - omin); if (AIR_ABS(dd) > epsilon) { unsigned int ui; ui = AIR_CAST(unsigned int, ii); fprintf(stderr, "|orig[%u]=%.17g - unquant=%.17g|*256/%.17g " "= %.17g > %.17g!\n", ui, origScl[ii], unquant[ii], omax - omin, AIR_ABS(dd), epsilon); airMopError(submop); airMopError(mop); return 1; } } }
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 unrrdu_2opMain(int argc, char **argv, char *me, hestParm *hparm) { hestOpt *opt = NULL; char *out, *err, *seedS; NrrdIter *in1, *in2; Nrrd *nout, *ntmp=NULL; int op, type, E, pret; airArray *mop; unsigned int seed; hestOptAdd(&opt, NULL, "operator", airTypeEnum, 1, 1, &op, NULL, "Binary operator. Possibilities include:\n " "\b\bo \"+\", \"-\", \"x\", \"/\": " "add, subtract, multiply, divide\n " "\b\bo \"^\": exponentiation (pow)\n " "\b\bo \"spow\": signed exponentiation: sgn(x)pow(abs(x),p)\n " "\b\bo \"%\": integer modulo\n " "\b\bo \"fmod\": same as fmod() in C\n " "\b\bo \"atan2\": same as atan2() in C\n " "\b\bo \"min\", \"max\": minimum, maximum\n " "\b\bo \"lt\", \"lte\", \"gt\", \"gte\": same as C's <, <=, >, <=\n " "\b\bo \"eq\", \"neq\": same as C's == and !=\n " "\b\bo \"comp\": -1, 0, or 1 if 1st value is less than, " "equal to, or greater than 2nd value\n " "\b\bo \"if\": if 1st value is non-zero, use it, " "else use 2nd value\n " "\b\bo \"exists\": if 1st value exists, use it, " "else use 2nd value\n " "\b\bo \"nrand\": scale unit-stdv Gaussian noise by 2nd value " "and add to first value", NULL, nrrdBinaryOp); hestOptAdd(&opt, NULL, "in1", airTypeOther, 1, 1, &in1, NULL, "First input. Can be a single value or a nrrd.", NULL, NULL, nrrdHestIter); hestOptAdd(&opt, NULL, "in2", airTypeOther, 1, 1, &in2, NULL, "Second input. Can be a single value or a nrrd.", NULL, NULL, nrrdHestIter); hestOptAdd(&opt, "s,seed", "seed", airTypeString, 1, 1, &seedS, "", "seed value for RNG for nrand, so that you " "can get repeatable results between runs, or, " "by not using this option, the RNG seeding will be " "based on the current time"); hestOptAdd(&opt, "t,type", "type", airTypeOther, 1, 1, &type, "default", "type to convert all INPUT nrrds to, prior to " "doing operation, useful for doing, for instance, the difference " "between two unsigned char nrrds. This will also determine " "output type. By default (not using this option), the types of " "the input nrrds are left unchanged.", NULL, NULL, &unrrduHestMaybeTypeCB); OPT_ADD_NOUT(out, "output nrrd"); mop = airMopNew(); airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways); USAGE(_unrrdu_2opInfoL); PARSE(); airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); /* fprintf(stderr, "%s: op = %d\n", me, op); fprintf(stderr, "%s: in1->left = %d, in2->left = %d\n", me, (int)(in1->left), (int)(in2->left)); */ if (nrrdTypeDefault != type) { /* they wanted to convert nrrds to some other type first */ E = 0; if (in1->ownNrrd) { if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in1->ownNrrd, type); if (!E) nrrdIterSetOwnNrrd(in1, ntmp); } if (in2->ownNrrd) { if (!E) E |= nrrdConvert(ntmp=nrrdNew(), in2->ownNrrd, type); if (!E) nrrdIterSetOwnNrrd(in2, ntmp); } if (E) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error converting input nrrd(s):\n%s", me, err); airMopError(mop); return 1; } /* this will still leave a nrrd in the NrrdIter for nrrdIterNix() (called by hestParseFree() called be airMopOkay()) to clear up */ } if (nrrdBinaryOpNormalRandScaleAdd == op) { if (airStrlen(seedS)) { if (1 != sscanf(seedS, "%u", &seed)) { fprintf(stderr, "%s: couldn't parse seed \"%s\" as uint\n", me, seedS); airMopError(mop); return 1; } else { airSrandMT(seed); } } else { /* got no request for specific seed */ airSrandMT(AIR_CAST(unsigned int, airTime())); } } if (nrrdArithIterBinaryOp(nout, op, in1, in2)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: error doing binary operation:\n%s", me, err); airMopError(mop); return 1; } SAVE(out, nout, NULL); airMopOkay(mop); return 0; }
int main(int argc, const char *argv[]) { const char *me; size_t vi, ii, qvalLen; Nrrd *nval, *nhist, *nimg, *nread, *ncorr; double aa, bb, *val; airArray *mop; char *corrname, explain[AIR_STRLEN_LARGE]; int differ; AIR_UNUSED(argc); me = argv[0]; mop = airMopNew(); qvalLen = 10*BINS; nrrdAlloc_va(nval=nrrdNew(), nrrdTypeDouble, 1, 4*qvalLen); airMopAdd(mop, nval, (airMopper)nrrdNuke, airMopAlways); val = AIR_CAST(double*, nval->data); airSrandMT(999); vi = 0; for (ii=0; ii<qvalLen; ii++) { airNormalRand(&aa, NULL); val[vi++] = aa; } for (ii=0; ii<qvalLen; ii++) { airNormalRand(NULL, &bb); val[vi++] = bb; } for (ii=0; ii<qvalLen; ii++) { airNormalRand(&aa, &bb); val[vi++] = aa; val[vi++] = bb; } nhist=nrrdNew(); airMopAdd(mop, nhist, (airMopper)nrrdNuke, airMopAlways); nimg=nrrdNew(); airMopAdd(mop, nimg, (airMopper)nrrdNuke, airMopAlways); if (nrrdHisto(nhist, nval, NULL, NULL, BINS, nrrdTypeInt) || nrrdHistoDraw(nimg, nhist, HGHT, AIR_TRUE, 0.0) || nrrdSave(THISNAME, nimg, NULL)) { char *err; airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble producing histo:\n%s", me, err); airMopError(mop); return 1; } nread = nrrdNew(); airMopAdd(mop, nread, (airMopper)nrrdNuke, airMopAlways); ncorr = nrrdNew(); airMopAdd(mop, ncorr, (airMopper)nrrdNuke, airMopAlways); corrname = testDataPathPrefix(CORRNAME); airMopAdd(mop, corrname, airFree, airMopAlways); if (nrrdLoad(ncorr, corrname, NULL) || nrrdLoad(nread, THISNAME, NULL)) { char *err; airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble reading:\n%s", me, err); airMopError(mop); return 1; } if (nrrdCompare(ncorr, nread, AIR_FALSE /* onlyData */, 0.0 /* epsilon */, &differ, explain)) { char *err; airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble comparing:\n%s", me, err); airMopError(mop); return 1; } if (differ) { fprintf(stderr, "%s: new and correct (%s) images differ: %s\n", me, corrname, explain); airMopError(mop); return 1; } else { printf("%s: all good\n", me); } airMopOkay(mop); return 0; }
int main(int argc, const char *argv[]) { const char *me; char *err; hestOpt *hopt = NULL; airArray *mop; char *outS; alanContext *actx; int *size, sizeLen, fi, si, wrap, nt, cfn, ha, maxi; unsigned int srnd; double deltaT, mch, xch, alphabeta[2], time0, time1, deltaX, react, rrange; Nrrd *ninit=NULL, *nten=NULL, *nparm=NULL; me = argv[0]; hestOptAdd(&hopt, "s", "sx sy", airTypeInt, 2, 3, &size, "128 128", "size of texture, and also determines its dimension", &sizeLen); hestOptAdd(&hopt, "srand", "N", airTypeUInt, 1, 1, &srnd, "42", "number to seed random number generator with. This uses " "airDrandMT(), so it should be portable."); hestOptAdd(&hopt, "i", "tensors", airTypeOther, 1, 1, &nten, "", "diffusion tensors to use for guiding the texture generation. " "If used, over-rides the \"-s\" option, both for setting " "texture dimension and size. If you want upsampling, you " "do it yourself before sending it here.", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "ha", NULL, airTypeInt, 0, 0, &ha, NULL, "use the homogenous anisotropy assumption- that the spatial " "derivative of the diffusion tensor is negligible when " "computing the diffusive term "); hestOptAdd(&hopt, "wrap", NULL, airTypeInt, 0, 0, &wrap, NULL, "wrap edges of texture around a topological torus (which " "makes a texture suitable for tiling)"); hestOptAdd(&hopt, "ab", "alpha beta", airTypeDouble, 2, 2, alphabeta, "16.0 12.0", "the growth and decay parameters appearing in the reaction " "terms of the reaction-diffusion equations. The default " "values were the ones published by Turing."); hestOptAdd(&hopt, "sr", "react", airTypeDouble, 1, 1, &react, "1.0", "scaling of reaction term"); hestOptAdd(&hopt, "rr", "range range", airTypeDouble, 1, 1, &rrange, "4.0", "amount of random noise to add to inital textures"); hestOptAdd(&hopt, "dt", "time", airTypeDouble, 1, 1, &deltaT, "1.0", "time-step size in Euler integration. Can be larger, at " "risk of hitting divergent instability."); hestOptAdd(&hopt, "dx", "size", airTypeDouble, 1, 1, &deltaX, "1.3", "nominal size of simulation grid element."); hestOptAdd(&hopt, "mch", "change", airTypeDouble, 1, 1, &mch, "0.00001", "the minimum significant change (averaged over the whole " "texture) in the first morphogen: to signify convergence"); hestOptAdd(&hopt, "xch", "change", airTypeDouble, 1, 1, &xch, "6", "the maximum allowable change (averaged over the whole " "texture) in the first morphogen: to signify divergence"); hestOptAdd(&hopt, "maxi", "# iter", airTypeInt, 1, 1, &maxi, "0", "maximum number of iterations to run for, or \"0\" to have " "no limit based on iteration count"); hestOptAdd(&hopt, "fi", "frame inter", airTypeInt, 1, 1, &fi, "0", "the number of iterations between which to save out an 8-bit " "image of the texture, or \"0\" to disable such action"); hestOptAdd(&hopt, "si", "snap inter", airTypeInt, 1, 1, &si, "0", "the number of iterations between which to save out a complete " "floating-point snapshot of the morphogen state, suitable for " "later re-initialization, or \"0\" to disable such action"); hestOptAdd(&hopt, "cfn", NULL, airTypeInt, 0, 0, &cfn, NULL, "when saving out frames or snapshots, use a constant filename, " "instead of incrementing it each save"); hestOptAdd(&hopt, "nt", "# threads", airTypeInt, 1, 1, &nt, "1", (airThreadCapable ? "number of threads to use in computation" : "number of \"threads\" to use in computation, which is " "moot here because this Teem build doesn't support " "multi-threading. ")); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, NULL, "filename for output of final converged (two-channel) texture"); hestParseOrDie(hopt, argc-1, argv+1, NULL, me, spotsInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); actx = alanContextNew(); airMopAdd(mop, actx, (airMopper)alanContextNix, airMopAlways); if (nten) { if (alanDimensionSet(actx, nten->dim - 1) || alanTensorSet(actx, nten, 1)) { airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways); fprintf(stderr, "%s: trouble setting parameters:\n%s\n", me, err); airMopError(mop); return 1; } } else { alanDimensionSet(actx, sizeLen); if (2 == sizeLen) { alan2DSizeSet(actx, size[0], size[1]); } else { alan3DSizeSet(actx, size[0], size[1], size[2]); } } airSrandMT(srnd); if (alanParmSet(actx, alanParmVerbose, 1) || alanParmSet(actx, alanParmTextureType, alanTextureTypeTuring) || alanParmSet(actx, alanParmK, 0.0125) || alanParmSet(actx, alanParmAlpha, alphabeta[0]) || alanParmSet(actx, alanParmBeta, alphabeta[1]) || alanParmSet(actx, alanParmDeltaX, deltaX) || alanParmSet(actx, alanParmDeltaT, deltaT) || alanParmSet(actx, alanParmReact, react) || alanParmSet(actx, alanParmMinAverageChange, mch) || alanParmSet(actx, alanParmMaxPixelChange, xch) || alanParmSet(actx, alanParmMaxIteration, maxi) || alanParmSet(actx, alanParmRandRange, rrange) || alanParmSet(actx, alanParmSaveInterval, si) || alanParmSet(actx, alanParmFrameInterval, fi) || alanParmSet(actx, alanParmConstantFilename, cfn) || alanParmSet(actx, alanParmWrapAround, wrap) || alanParmSet(actx, alanParmHomogAniso, ha) || alanParmSet(actx, alanParmNumThreads, nt)) { airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways); fprintf(stderr, "%s: trouble setting parameters:\n%s\n", me, err); airMopError(mop); return 1; } if (alanUpdate(actx) || alanInit(actx, ninit, nparm)) { airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways); fprintf(stderr, "%s: trouble initializing texture: %s\n", me, err); airMopError(mop); return 1; } fprintf(stderr, "%s: going to run (%d threads) ...\n", me, actx->numThreads); time0 = airTime(); if (alanRun(actx)) { airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways); fprintf(stderr, "%s: trouble generating texture: %s\n", me, err); airMopError(mop); return 1; } time1 = airTime(); fprintf(stderr, "%s: stopped after %d iterations (%g seconds): %s\n", me, actx->iter, time1 - time0, airEnumDesc(alanStop, actx->stop)); if (nrrdSave(outS, actx->nlev, NULL)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble saving output:\n%s\n", me, err); airMopError(mop); return 1; } airMopOkay(mop); return 0; }
int tend_simMain(int argc, char **argv, char *me, hestParm *hparm) { int pret; hestOpt *hopt = NULL; char *perr, *err; tenEstimateContext *tec; airArray *mop; int E, oldstuff, seed; Nrrd *nin, *nT2, *nbmat, *nout; char *outS; float b, sigma; hestOptAdd(&hopt, "old", NULL, airTypeInt, 0, 0, &oldstuff, NULL, "don't use the new tenEstimateContext functionality"); hestOptAdd(&hopt, "sigma", "sigma", airTypeFloat, 1, 1, &sigma, "0.0", "Rician noise parameter"); hestOptAdd(&hopt, "seed", "seed", airTypeInt, 1, 1, &seed, "42", "seed value for RNG which creates noise"); hestOptAdd(&hopt, "B", "B matrix", airTypeOther, 1, 1, &nbmat, NULL, "B matrix, one row per diffusion-weighted image", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "r", "reference field", airTypeOther, 1, 1, &nT2, "-", "reference anatomical scan, with no diffusion weighting", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "i", "tensor field", airTypeOther, 1, 1, &nin, "-", "input diffusion tensor field", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "b", "b", airTypeFloat, 1, 1, &b, "1", "b value for simulated scan"); hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-", "output image (floating point)"); mop = airMopNew(); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); USAGE(_tend_simInfoL); PARSE(); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nout = nrrdNew(); airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways); if (!oldstuff) { airSrandMT(seed); tec = tenEstimateContextNew(); airMopAdd(mop, tec, (airMopper)tenEstimateContextNix, airMopAlways); E = 0; if (!E) E |= tenEstimateMethodSet(tec, tenEstimateMethodLLS); if (!E) E |= tenEstimateValueMinSet(tec, 0.0001); if (!E) E |= tenEstimateBMatricesSet(tec, nbmat, b, AIR_TRUE); if (!E) E |= tenEstimateThresholdSet(tec, 0, 0); if (!E) E |= tenEstimateUpdate(tec); if (!E) E |= tenEstimate1TensorSimulateVolume(tec, nout, sigma, b, nT2, nin, nrrdTypeFloat); if (E) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble making DWI volume (new):\n%s\n", me, err); airMopError(mop); return 1; } } else { if (tenSimulate(nout, nT2, nin, nbmat, b)) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble making DWI 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 main(int argc, char *argv[]) { char *me, *err; hestOpt *hopt=NULL; airArray *mop; char *outTenS, *outCovarS, *outRmvS; int seed, E; unsigned int NN; Nrrd *_ninTen, *ninTen, *ngrad, *_ninB0, *ninB0, *nmask, *noutCovar, *noutTen, *noutRmv, *ntbuff; float sigma, bval; size_t sizeX, sizeY, sizeZ; tenEstimateContext *tec; int axmap[NRRD_DIM_MAX], randrot; mop = airMopNew(); me = argv[0]; hestOptAdd(&hopt, "i", "ten", airTypeOther, 1, 1, &_ninTen, NULL, "input tensor volume", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "n", "#sim", airTypeUInt, 1, 1, &NN, "100", "number of simulations to run"); hestOptAdd(&hopt, "seed", "seed", airTypeInt, 1, 1, &seed, "42", "seed value for RNG which creates noise"); hestOptAdd(&hopt, "r", "reference field", airTypeOther, 1, 1, &_ninB0, NULL, "reference anatomical scan, with no diffusion weighting", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "rr", NULL, airTypeOther, 0, 0, &randrot, NULL, "randomize gradient set orientation"); hestOptAdd(&hopt, "g", "grad list", airTypeOther, 1, 1, &ngrad, "", "gradient list, one row per diffusion-weighted image", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "b", "b", airTypeFloat, 1, 1, &bval, "1000", "b value for simulated scan"); hestOptAdd(&hopt, "sigma", "sigma", airTypeFloat, 1, 1, &sigma, "0.0", "Rician noise parameter"); hestOptAdd(&hopt, "ot", "filename", airTypeString, 1, 1, &outTenS, "tout.nrrd", "file to write output tensor nrrd to"); hestOptAdd(&hopt, "oc", "filename", airTypeString, 1, 1, &outCovarS, "cout.nrrd", "file to write output covariance nrrd to"); hestOptAdd(&hopt, "or", "filename", airTypeString, 1, 1, &outRmvS, "rout.nrrd", "file to write output R_i means, variances to"); hestParseOrDie(hopt, argc-1, argv+1, NULL, me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); if (tenGradientCheck(ngrad, nrrdTypeDefault, 7)) { airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: problem with gradient list:\n%s\n", me, err); airMopError(mop); return 1; } if (tenTensorCheck(_ninTen, nrrdTypeDefault, AIR_TRUE, AIR_TRUE)) { airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: didn't like input:\n%s\n", me, err); airMopError(mop); return 1; } sizeX = _ninTen->axis[1].size; sizeY = _ninTen->axis[2].size; sizeZ = _ninTen->axis[3].size; if (!(3 == _ninB0->dim && sizeX == _ninB0->axis[0].size && sizeY == _ninB0->axis[1].size && sizeZ == _ninB0->axis[2].size)) { fprintf(stderr, "%s: given B0 (%u-D) volume not 3-D " _AIR_SIZE_T_CNV "x" _AIR_SIZE_T_CNV "x" _AIR_SIZE_T_CNV, me, _ninB0->dim, sizeX, sizeY, sizeZ); airMopError(mop); return 1; } ninTen = nrrdNew(); airMopAdd(mop, ninTen, (airMopper)nrrdNuke, airMopOnError); nmask = nrrdNew(); airMopAdd(mop, nmask, (airMopper)nrrdNuke, airMopOnError); ninB0 = nrrdNew(); airMopAdd(mop, ninB0, (airMopper)nrrdNuke, airMopOnError); noutCovar = nrrdNew(); airMopAdd(mop, noutCovar, (airMopper)nrrdNuke, airMopOnError); noutTen = nrrdNew(); airMopAdd(mop, noutTen, (airMopper)nrrdNuke, airMopOnError); noutRmv = nrrdNew(); airMopAdd(mop, noutRmv, (airMopper)nrrdNuke, airMopOnError); ntbuff = nrrdNew(); airMopAdd(mop, ntbuff, (airMopper)nrrdNuke, airMopOnError); if (nrrdConvert(ninTen, _ninTen, nrrdTypeDouble) || nrrdSlice(nmask, ninTen, 0, 0) || nrrdConvert(ninB0, _ninB0, nrrdTypeDouble) || nrrdMaybeAlloc_va(noutTen, nrrdTypeDouble, 4, AIR_CAST(size_t, 7), sizeX, sizeY, sizeZ) || nrrdMaybeAlloc_va(noutCovar, nrrdTypeDouble, 4, AIR_CAST(size_t, 21), sizeX, sizeY, sizeZ) || nrrdMaybeAlloc_va(noutRmv, nrrdTypeDouble, 4, AIR_CAST(size_t, 6), sizeX, sizeY, sizeZ) || nrrdMaybeAlloc_va(ntbuff, nrrdTypeDouble, 2, AIR_CAST(size_t, 7), NN)) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble setting up tec:\n%s\n", me, err); airMopError(mop); return 1; } tec = tenEstimateContextNew(); airMopAdd(mop, tec, (airMopper)tenEstimateContextNix, airMopAlways); E = 0; if (!E) E |= tenEstimateMethodSet(tec, tenEstimate1MethodLLS); if (!E) E |= tenEstimateValueMinSet(tec, 0.000000001); if (!E) E |= tenEstimateGradientsSet(tec, ngrad, bval, AIR_TRUE); if (!E) E |= tenEstimateThresholdSet(tec, 0, 0); if (!E) E |= tenEstimateUpdate(tec); if (E) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble setting up tec:\n%s\n", me, err); airMopError(mop); return 1; } airSrandMT(seed); fprintf(stderr, "!%s: randrot = %d\n", me, randrot); if (1) { unsigned int II; unsigned int nsamp; double *inTen, *outTen, *outCovar, *outRmv, *dwibuff, (*lup)(const void *, size_t); char doneStr[AIR_STRLEN_SMALL]; dwibuff = AIR_CAST(double *, calloc(ngrad->axis[1].size, sizeof(double))); airMopAdd(mop, dwibuff, airFree, airMopAlways); nsamp = sizeX*sizeY*sizeZ; inTen = AIR_CAST(double *, ninTen->data); lup = nrrdDLookup[nrrdTypeDouble]; outTen = AIR_CAST(double *, noutTen->data); outCovar = AIR_CAST(double *, noutCovar->data); outRmv = AIR_CAST(double *, noutRmv->data); fprintf(stderr, "!%s: simulating ... ", me); fflush(stderr); for (II=0; II<nsamp; II++) { if (!(II % sizeX)) { fprintf(stderr, "%s", airDoneStr(0, II, nsamp, doneStr)); fflush(stderr); } if (csimDo(outTen, outCovar, outRmv + 0, outRmv + 3, ntbuff, tec, dwibuff, sigma, bval, lup(ninB0->data, II), NN, randrot, inTen)) { airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble:\n%s\n", me, err); airMopError(mop); return 1; } inTen += 7; outTen += 7; outCovar += 21; outRmv += 6; } fprintf(stderr, "%s\n", airDoneStr(0, II, nsamp, doneStr)); }