int tenFiberKernelSet(tenFiberContext *tfx, const NrrdKernel *kern, const double parm[NRRD_KERNEL_PARMS_NUM]) { char me[]="tenFiberKernelSet", err[BIFF_STRLEN]; if (!(tfx && kern)) { sprintf(err, "%s: got NULL pointer", me); biffAdd(TEN, err); return 1; } nrrdKernelSpecSet(tfx->ksp, kern, parm); if (gageKernelSet(tfx->gtx, gageKernel00, tfx->ksp->kernel, tfx->ksp->parm)) { sprintf(err, "%s: problem setting kernel", me); biffMove(TEN, err, GAGE); return 1; } return 0; }
int main(int argc, char *argv[]) { char *me, *kS, *minS, *stepS, *maxS, *outS, *err, kstr[AIR_STRLEN_LARGE]; const NrrdKernel *k; NrrdKernelSpec *ksp; double parm[NRRD_KERNEL_PARMS_NUM], min, step, max, integral, *dom_d, *ran_d; float *dom_f, *ran_f, v, r_f, r_d; FILE *fout; int i, len; airArray *mop; me = argv[0]; if (6 != argc) { usage(me); } kS = argv[1]; minS = argv[2]; stepS = argv[3]; maxS = argv[4]; outS = argv[5]; mop = airMopNew(); if (nrrdKernelParse(&k, parm, kS)) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble:\n%s\n", me, err); airMopError(mop); exit(1); } ksp = nrrdKernelSpecNew(); airMopAdd(mop, ksp, (airMopper)nrrdKernelSpecNix, airMopAlways); nrrdKernelSpecSet(ksp, k, parm); if (nrrdKernelSpecSprint(kstr, ksp)) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble:\n%s\n", me, err); airMopError(mop); exit(1); } printf("%s: printed kernel as \"%s\"\n", me, kstr); if (3 != (sscanf(minS, "%lf", &min) + sscanf(stepS, "%lf", &step) + sscanf(maxS, "%lf", &max))) { fprintf(stderr, "%s: couldn't parse \"%s\", \"%s\", \"%s\" as 3 doubles\n", me, minS, stepS, maxS); exit(1); } if (!( min <= -k->support(parm) && max >= k->support(parm) )) { fprintf(stderr, "%s: WARNING: support=%g => lower min (%g) or raise max (%g)\n", me, k->support(parm), min, max); } /* see how many values are in the interval */ len = 0; for (v=min; v<=max; v+=step) { len++; } /* allocate domain and range for both float and double */ if (!( (dom_d = (double *)calloc(len, sizeof(double))) && (ran_d = (double *)calloc(len, sizeof(double))) && (dom_f = (float *)calloc(len, sizeof(float))) && (ran_f = (float *)calloc(len, sizeof(float))) )) { fprintf(stderr, "%s: PANIC: couldn't allocate buffers\n", me); exit(1); } airMopAdd(mop, dom_d, airFree, airMopAlways); airMopAdd(mop, ran_d, airFree, airMopAlways); airMopAdd(mop, dom_f, airFree, airMopAlways); airMopAdd(mop, ran_f, airFree, airMopAlways); /* set values in both domains */ i=0; for (v=min; v<=max; v+=step) { /* note that the value stored in dom_d[i] is only a single-precision float, so that it is really equal to dom_f[i] */ dom_d[i] = v; dom_f[i] = v; i++; } /* do the vector evaluations */ k->evalN_f(ran_f, dom_f, len, parm); k->evalN_d(ran_d, dom_d, len, parm); /* do the single evaluations, and make sure everything agrees */ i = 0; integral = 0; for (v=min; v<=max; v+=step) { /* compare two single evaluations */ r_f = k->eval1_f(v, parm); r_d = k->eval1_d(v, parm); if (!CLOSE(r_f,r_d)) { fprintf(stderr, "%s: (eval1_f(%g)== %f) != (eval1_d(%g)== %f)\n", me, v, r_f, v, r_d); } /* compare single float with vector float */ if (!CLOSE(r_f,ran_f[i])) { fprintf(stderr, "%s: (eval1_f(%g)== %f) != (evalN_f[%d]== %f)\n", me, v, r_f, i, ran_f[i]); } /* compare single float with vector double */ r_d = ran_d[i]; if (!CLOSE(r_f,r_d)) { fprintf(stderr, "%s: (eval1_f(%g)== %f) != (evalN_d[%d]== %f)\n", me, v, r_f, i, r_d); } integral += step*ran_d[i]; i++; } if (!KINDACLOSE(integral, k->integral(parm))) { fprintf(stderr, "discrete integral %f != %f\n", integral, k->integral(parm)); /* not a fatal error */ } /* it all checks out; write the file */ if (!(fout = fopen(outS, "w"))) { fprintf(stderr, "%s: couldn't open \"%s\" for writing\n", me, outS); exit(1); } for (i=0; i<=len-1; i++) { fprintf(fout, "%g %g\n", dom_f[i], ran_f[i]); } fclose(fout); fprintf(stderr, "(for matlab:)\n"); fprintf(stderr, "x = dlmread(\'%s\', \' \'); plot(x(:,1), x(:,2));\n", outS); airMopOkay(mop); exit(0); }
int main(int argc, char *argv[]) { char *me, *kernS[2], *minS, *stepS, *maxS, *outS, *err, kstr[AIR_STRLEN_LARGE]; const NrrdKernel *kern[2]; NrrdKernelSpec *ksp[2]; double parm[NRRD_KERNEL_PARMS_NUM], min, step, max, integral, *dom_d, *ran_d; float *dom_f, *ran_f, val, r_f, r_d; FILE *fout; int i, len; airArray *mop; unsigned int kii; me = argv[0]; if (!( 6 == argc || 7 == argc )) { usage(me); } kernS[0] = argv[1]; minS = argv[2]; stepS = argv[3]; maxS = argv[4]; outS = argv[5]; if (7 == argc) { kernS[1] = argv[6]; } else { kernS[1] = NULL; } if (3 != (sscanf(minS, "%lf", &min) + sscanf(stepS, "%lf", &step) + sscanf(maxS, "%lf", &max))) { fprintf(stderr, "%s: couldn't parse \"%s\", \"%s\", \"%s\" as 3 doubles\n", me, minS, stepS, maxS); exit(1); } mop = airMopNew(); for (kii=0; kii<=(kernS[1] ? 1 : 0); kii++) { if (nrrdKernelParse(&(kern[kii]), parm, kernS[kii])) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: (kii %u) trouble:\n%s\n", me, kii, err); airMopError(mop); exit(1); } ksp[kii] = nrrdKernelSpecNew(); airMopAdd(mop, ksp[kii], (airMopper)nrrdKernelSpecNix, airMopAlways); nrrdKernelSpecSet(ksp[kii], kern[kii], parm); if (nrrdKernelSpecSprint(kstr, ksp[kii])) { airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: trouble:\n%s\n", me, err); airMopError(mop); exit(1); } fprintf(stderr, "%s: printed kernel as \"%s\"\n", me, kstr); if (!( min <= -kern[kii]->support(parm) && max >= kern[kii]->support(parm) )) { fprintf(stderr, "%s: WARNING: support=%g => lower min (%g) or raise max (%g)\n", me, kern[kii]->support(parm), min, max); } fprintf(stderr, "%s: support(%s) = %g\n", me, kstr, kern[kii]->support(parm)); } /* see how many values are in the interval */ len = 0; for (val=min; val<=max; val+=step) { len++; } /* allocate domain and range for both float and double */ if (!( (dom_d = (double *)calloc(len, sizeof(double))) && (ran_d = (double *)calloc(len, sizeof(double))) && (dom_f = (float *)calloc(len, sizeof(float))) && (ran_f = (float *)calloc(len, sizeof(float))) )) { fprintf(stderr, "%s: PANIC: couldn't allocate buffers\n", me); exit(1); } airMopAdd(mop, dom_d, airFree, airMopAlways); airMopAdd(mop, ran_d, airFree, airMopAlways); airMopAdd(mop, dom_f, airFree, airMopAlways); airMopAdd(mop, ran_f, airFree, airMopAlways); /* set values in both domains */ i=0; for (val=min; val<=max; val+=step) { /* note that the value stored in dom_d[i] is only a single-precision float, so that it is really equal to dom_f[i] */ dom_d[i] = val; dom_f[i] = val; i++; } /* do the vector evaluations */ kern[0]->evalN_f(ran_f, dom_f, len, parm); kern[0]->evalN_d(ran_d, dom_d, len, parm); /* do the single evaluations, and make sure everything agrees */ i = 0; integral = 0; for (val=min; val<=max; val+=step) { /* compare two single evaluations */ r_f = kern[0]->eval1_f(val, parm); r_d = kern[0]->eval1_d(val, parm); if (!CLOSE(r_f,r_d, 0.00001)) { fprintf(stderr, "%s: (eval1_f(%g)== %f) != (eval1_d(%g)== %f)\n", me, val, r_f, val, r_d); } /* compare single float with vector float */ if (!CLOSE(r_f,ran_f[i], 0.00001)) { fprintf(stderr, "%s: (eval1_f(%g)== %f) != (evalN_f[%d]== %f)\n", me, val, r_f, i, ran_f[i]); } /* compare single float with vector double */ r_d = ran_d[i]; if (!CLOSE(r_f,r_d, 0.00001)) { fprintf(stderr, "%s: (eval1_f(%g)== %f) != (evalN_d[%d]== %f)\n", me, val, r_f, i, r_d); } integral += step*ran_d[i]; /* possibly check on given derivatives */ if (kern[1]) { double numd; numd = (kern[0]->eval1_d(val+step/2, parm) - kern[0]->eval1_d(val-step/2, parm))/step; if (!CLOSE(numd, kern[1]->eval1_d(val+step, parm), 0.005)) { fprintf(stderr, "%s: |numerical f'(%g) %g - true %g| = %g > 0.005\n", me, val, numd, kern[1]->eval1_d(val+step, parm), fabs(numd - kern[1]->eval1_d(val+step, parm))); /* exit(1); */ } } i++; } if (!CLOSE(integral, kern[0]->integral(parm), 0.0005)) { fprintf(stderr, "%s: HEY HEY HEY HEY HEY HEY!\n", me); fprintf(stderr, "%s: discrete integral %f != %f\n", me, integral, kern[0]->integral(parm)); /* exit(1); */ } /* it all checks out; write the file */ if (!(fout = airFopen(outS, stdout, "w"))) { fprintf(stderr, "%s: couldn't open \"%s\" for writing\n", me, outS); exit(1); } for (i=0; i<=len-1; i++) { fprintf(fout, "%g %g\n", dom_f[i], ran_f[i]); } fclose(fout); airMopOkay(mop); exit(0); }
int main(int argc, char *argv[]) { char *me, *err; hestOpt *hopt=NULL; airArray *mop; char *outS[3]; char *gravStr, *gravGradStr, *seedStr; pushContext *pctx; Nrrd *_nin, *nin, *nPosIn, *nPosOut, *nTenOut, *nEnrOut; NrrdKernelSpec *ksp00, *ksp11, *ksp22; pushEnergySpec *ensp; int E; me = argv[0]; mop = airMopNew(); pctx = pushContextNew(); airMopAdd(mop, pctx, (airMopper)pushContextNix, airMopAlways); hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &_nin, NULL, "input volume to filter", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "np", "# points", airTypeUInt, 1, 1, &(pctx->pointNum), "1000", "number of points to use in simulation"); hestOptAdd(&hopt, "pi", "npos", airTypeOther, 1, 1, &nPosIn, "", "positions to start at (overrides \"-np\")", NULL, NULL, nrrdHestNrrd); hestOptAdd(&hopt, "step", "step", airTypeDouble, 1, 1, &(pctx->stepInitial), "1", "step size for gradient descent"); hestOptAdd(&hopt, "scl", "scale", airTypeDouble, 1, 1, &(pctx->scale), "1500", "scaling from tensor size to glyph size"); hestOptAdd(&hopt, "wall", "wall", airTypeDouble, 1, 1, &(pctx->wall), "0.0", "spring constant of containing walls"); hestOptAdd(&hopt, "cnts", "scale", airTypeDouble, 1, 1, &(pctx->cntScl), "0.0", "scaling of containment force"); hestOptAdd(&hopt, "limit", "frac", airTypeDouble, 1, 1, &(pctx->deltaLimit), "0.3", "speed limit on particles' motion"); hestOptAdd(&hopt, "dfmin", "frac", airTypeDouble, 1, 1, &(pctx->deltaFracMin), "0.2", "decrease step size if deltaFrac goes below this"); hestOptAdd(&hopt, "esf", "frac", airTypeDouble, 1, 1, &(pctx->energyStepFrac), "0.9", "when energy goes up instead of down, fraction by " "which to scale step size"); hestOptAdd(&hopt, "dfsf", "frac", airTypeDouble, 1, 1, &(pctx->deltaFracStepFrac), "0.5", "when deltaFrac goes below deltaFracMin, fraction by " "which to scale step size"); hestOptAdd(&hopt, "eimin", "frac", airTypeDouble, 1, 1, &(pctx->energyImprovMin), "0.01", "convergence threshold: stop when fracional improvement " "(decrease) in energy dips below this"); hestOptAdd(&hopt, "detr", NULL, airTypeBool, 0, 0, &(pctx->detReject), NULL, "do determinant-based rejection of initial sample locations"); hestOptAdd(&hopt, "rng", "seed", airTypeUInt, 1, 1, &(pctx->seedRNG), "42", "seed value for RNG which determines initial point locations"); hestOptAdd(&hopt, "nt", "# threads", airTypeUInt, 1, 1, &(pctx->threadNum), "1", "number of threads to run"); hestOptAdd(&hopt, "nprob", "# iters", airTypeDouble, 1, 1, &(pctx->neighborTrueProb), "1.0", "do full neighbor traversal with this probability"); hestOptAdd(&hopt, "pprob", "# iters", airTypeDouble, 1, 1, &(pctx->probeProb), "1.0", "do field probing with this probability"); hestOptAdd(&hopt, "maxi", "# iters", airTypeUInt, 1, 1, &(pctx->maxIter), "0", "if non-zero, max # iterations to run"); hestOptAdd(&hopt, "snap", "iters", airTypeUInt, 1, 1, &(pctx->snap), "0", "if non-zero, # iterations between which a snapshot " "is saved"); hestOptAdd(&hopt, "grv", "item", airTypeString, 1, 1, &gravStr, "none", "item to act as gravity"); hestOptAdd(&hopt, "grvgv", "item", airTypeString, 1, 1, &gravGradStr, "none", "item to act as gravity gradient"); hestOptAdd(&hopt, "grvs", "scale", airTypeDouble, 1, 1, &(pctx->gravScl), "nan", "magnitude and scaling of gravity vector"); hestOptAdd(&hopt, "grvz", "scale", airTypeDouble, 1, 1, &(pctx->gravZero), "nan", "height (WRT gravity) of zero potential energy"); hestOptAdd(&hopt, "seed", "item", airTypeString, 1, 1, &seedStr, "none", "item to act as seed threshold"); hestOptAdd(&hopt, "seedth", "thresh", airTypeDouble, 1, 1, &(pctx->seedThresh), "nan", "seed threshold threshold"); hestOptAdd(&hopt, "energy", "spec", airTypeOther, 1, 1, &ensp, "cotan", "specification of energy function to use", NULL, NULL, pushHestEnergySpec); hestOptAdd(&hopt, "nobin", NULL, airTypeBool, 0, 0, &(pctx->binSingle), NULL, "turn off spatial binning (which prevents multi-threading " "from being useful), for debugging or speed-up measurement"); hestOptAdd(&hopt, "k00", "kernel", airTypeOther, 1, 1, &ksp00, "tent", "kernel for tensor field sampling", NULL, NULL, nrrdHestKernelSpec); hestOptAdd(&hopt, "k11", "kernel", airTypeOther, 1, 1, &ksp11, "fordif", "kernel for finding containment gradient from mask", NULL, NULL, nrrdHestKernelSpec); hestOptAdd(&hopt, "k22", "kernel", airTypeOther, 1, 1, &ksp22, "cubicdd:1,0", "kernel for 2nd derivatives", NULL, NULL, nrrdHestKernelSpec); hestOptAdd(&hopt, "o", "nout", airTypeString, 3, 3, outS, "p.nrrd t.nrrd e.nrrd", "output files to save position and tensor info into"); hestParseOrDie(hopt, argc-1, argv+1, NULL, me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE); airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways); airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways); nPosOut = nrrdNew(); airMopAdd(mop, nPosOut, (airMopper)nrrdNuke, airMopAlways); nTenOut = nrrdNew(); airMopAdd(mop, nTenOut, (airMopper)nrrdNuke, airMopAlways); nEnrOut = nrrdNew(); airMopAdd(mop, nEnrOut, (airMopper)nrrdNuke, airMopAlways); if (3 == _nin->spaceDim && AIR_EXISTS(_nin->measurementFrame[0][0])) { nin = nrrdNew(); airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways); if (tenMeasurementFrameReduce(nin, _nin)) { airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways); fprintf(stderr, "%s: trouble undoing measurement frame:\n%s", me, err); airMopError(mop); exit(1); } } else { nin = _nin; } pctx->nin = nin; pctx->npos = nPosIn; pctx->verbose = 0; pctx->binIncr = 84; /* random small-ish value */ pushEnergySpecSet(pctx->ensp, ensp->energy, ensp->parm); nrrdKernelSpecSet(pctx->ksp00, ksp00->kernel, ksp00->parm); nrrdKernelSpecSet(pctx->ksp11, ksp11->kernel, ksp11->parm); nrrdKernelSpecSet(pctx->ksp22, ksp22->kernel, ksp22->parm); if (strcmp("none", gravStr)) { pctx->gravItem = airEnumVal(tenGage, gravStr); if (tenGageUnknown == pctx->gravItem) { fprintf(stderr, "%s: couldn't parse \"%s\" as a %s (gravity)\n", me, gravStr, tenGage->name); airMopError(mop); return 1; } pctx->gravGradItem = airEnumVal(tenGage, gravGradStr); if (tenGageUnknown == pctx->gravGradItem) { fprintf(stderr, "%s: couldn't parse \"%s\" as a %s (gravity grad)\n", me, gravGradStr, tenGage->name); airMopError(mop); return 1; } } else { pctx->gravItem = tenGageUnknown; pctx->gravGradItem = tenGageUnknown; pctx->gravZero = AIR_NAN; pctx->gravScl = AIR_NAN; } if (strcmp("none", seedStr)) { pctx->seedThreshItem = airEnumVal(tenGage, seedStr); if (tenGageUnknown == pctx->seedThreshItem) { fprintf(stderr, "%s: couldn't parse \"%s\" as a %s (seedthresh)\n", me, seedStr, tenGage->name); airMopError(mop); return 1; } } else { pctx->seedThreshItem = 0; pctx->seedThresh = AIR_NAN; } E = 0; if (!E) E |= pushStart(pctx); if (!E) E |= pushRun(pctx); if (!E) E |= pushOutputGet(nPosOut, nTenOut, nEnrOut, pctx); if (!E) E |= pushFinish(pctx); if (E) { airMopAdd(mop, err = biffGetDone(PUSH), airFree, airMopAlways); fprintf(stderr, "%s: trouble:\n%s\n", me, err); airMopError(mop); return 1; } fprintf(stderr, "%s: time for %d iterations= %g secs\n", me, pctx->iter, pctx->timeRun); if (nrrdSave(outS[0], nPosOut, NULL) || nrrdSave(outS[1], nTenOut, NULL) || nrrdSave(outS[2], nEnrOut, NULL)) { airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways); fprintf(stderr, "%s: couldn't save output:\n%s\n", me, err); airMopError(mop); return 1; } airMopOkay(mop); return 0; }