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;
}
void *
_alanTuringWorker(void *_task) {
alan_t *tendata, *ten, react,
conf, Dxx, Dxy, Dyy, /* Dxz, Dyz, */
*tpx, *tmx, *tpy, *tmy, /* *tpz, *tmz, */
*lev0, *lev1, *parm, deltaT, alpha, beta, A, B,
*v[27], lapA, lapB, corrA, corrB,
deltaA, deltaB, diffA, diffB, change;
int dim, iter, stop, startW, endW, idx,
px, mx, py, my, pz, mz,
startY, endY, startZ, endZ, sx, sy, sz, x, y, z;
alanTask *task;
task = (alanTask *)_task;
dim = task->actx->dim;
sx = task->actx->size[0];
sy = task->actx->size[1];
sz = (2 == dim ? 1 : task->actx->size[2]);
parm = (alan_t*)(task->actx->nparm->data);
diffA = AIR_CAST(alan_t, task->actx->diffA/pow(task->actx->deltaX, dim));
diffB = AIR_CAST(alan_t, task->actx->diffB/pow(task->actx->deltaX, dim));
startW = task->idx*sy/task->actx->numThreads;
endW = (task->idx+1)*sy/task->actx->numThreads;
tendata = task->actx->nten ? (alan_t *)task->actx->nten->data : NULL;
react = task->actx->react;
if (2 == dim) {
startZ = 0;
endZ = 1;
startY = startW;
endY = endW;
} else {
startZ = startW;
endZ = endW;
startY = 0;
endY = sy;
}
for (iter = 0;
(alanStopNot == task->actx->stop
&& (0 == task->actx->maxIteration
|| iter < task->actx->maxIteration));
iter++) {
if (0 == task->idx) {
task->actx->iter = iter;
task->actx->nlev = task->actx->_nlev[(iter+1) % 2];
}
lev0 = (alan_t*)(task->actx->_nlev[iter % 2]->data);
lev1 = (alan_t*)(task->actx->_nlev[(iter+1) % 2]->data);
stop = alanStopNot;
change = 0;
conf = 1; /* if you have no data; this will stay 1 */
for (z = startZ; z < endZ; z++) {
if (task->actx->wrap) {
pz = AIR_MOD(z+1, sz);
mz = AIR_MOD(z-1, sz);
} else {
pz = AIR_MIN(z+1, sz-1);
mz = AIR_MAX(z-1, 0);
}
for (y = startY; y < endY; y++) {
if (task->actx->wrap) {
py = AIR_MOD(y+1, sy);
my = AIR_MOD(y-1, sy);
} else {
py = AIR_MIN(y+1, sy-1);
my = AIR_MAX(y-1, 0);
}
for (x = 0; x < sx; x++) {
if (task->actx->wrap) {
px = AIR_MOD(x+1, sx);
mx = AIR_MOD(x-1, sx);
} else {
px = AIR_MIN(x+1, sx-1);
mx = AIR_MAX(x-1, 0);
}
idx = x + sx*(y + sy*z);
A = lev0[0 + 2*idx];
B = lev0[1 + 2*idx];
deltaT = parm[0 + 3*idx];
alpha = parm[1 + 3*idx];
beta = parm[2 + 3*idx];
lapA = lapB = corrA = corrB = 0;
if (2 == dim) {
/*
** 0 1 2 ----> X
** 3 4 5
** 6 7 8
** |
** v Y
*/
v[1] = lev0 + 2*( x + sx*(my));
v[3] = lev0 + 2*(mx + sx*( y));
v[5] = lev0 + 2*(px + sx*( y));
v[7] = lev0 + 2*( x + sx*(py));
if (tendata) {
/*
** 0 1 2 Dxy/2 Dyy -Dxy/2
** 3 4 5 Dxx -2*(Dxx + Dyy) Dxx
** 6 7 8 -Dxy/2 Dyy Dxy/2
*/
v[0] = lev0 + 2*(mx + sx*(my));
v[2] = lev0 + 2*(px + sx*(my));
v[6] = lev0 + 2*(mx + sx*(py));
v[8] = lev0 + 2*(px + sx*(py));
ten = tendata + 4*idx;
conf = AIR_CAST(alan_t, (AIR_CLAMP(0.3, ten[0], 1) - 0.3)/0.7);
if (conf) {
Dxx = ten[1];
Dxy = ten[2];
Dyy = ten[3];
lapA = (Dxy*(v[0][0] + v[8][0] - v[2][0] - v[6][0])/2
+ Dxx*(v[3][0] + v[5][0]) + Dyy*(v[1][0] + v[7][0])
- 2*(Dxx + Dyy)*A);
lapB = (Dxy*(v[0][1] + v[8][1] - v[2][1] - v[6][1])/2
+ Dxx*(v[3][1] + v[5][1]) + Dyy*(v[1][1] + v[7][1])
- 2*(Dxx + Dyy)*B);
if (!(task->actx->homogAniso)) {
tpx = tendata + 4*(px + sx*( y + sy*( z)));
tmx = tendata + 4*(mx + sx*( y + sy*( z)));
tpy = tendata + 4*( x + sx*(py + sy*( z)));
tmy = tendata + 4*( x + sx*(my + sy*( z)));
corrA = ((tpx[1]-tmx[1])*(v[5][0]-v[3][0])/4+ /* Dxx,x*A,x */
(tpx[2]-tmx[2])*(v[7][0]-v[1][0])/4+ /* Dxy,x*A,y */
(tpy[2]-tmy[2])*(v[5][0]-v[3][0])/4+ /* Dxy,y*A,x */
(tpy[3]-tmy[3])*(v[7][0]-v[1][0])); /* Dyy,y*A,y */
corrB = ((tpx[1]-tmx[1])*(v[5][1]-v[3][1])/4+ /* Dxx,x*B,x */
(tpx[2]-tmx[2])*(v[7][1]-v[1][1])/4+ /* Dxy,x*B,y */
(tpy[2]-tmy[2])*(v[5][1]-v[3][1])/4+ /* Dxy,y*B,x */
(tpy[3]-tmy[3])*(v[7][1]-v[1][1])); /* Dyy,y*B,y */
}
} else {
/* no confidence; you diffuse */
lapA = v[1][0] + v[3][0] + v[5][0] + v[7][0] - 4*A;
lapB = v[1][1] + v[3][1] + v[5][1] + v[7][1] - 4*B;
}
} else {
/* no data; you diffuse */
lapA = v[1][0] + v[3][0] + v[5][0] + v[7][0] - 4*A;
lapB = v[1][1] + v[3][1] + v[5][1] + v[7][1] - 4*B;
}
} else {
/* 3 == dim */
/*
** 0 1 2 ---- X
** 3 4 5
** 6 7 8
** /
** / 9 10 11
** Y 12 13 14
** 15 16 17
**
** 18 19 20
** 21 22 23
** 24 25 26
** |
** |
** Z
*/
v[ 4] = lev0 + 2*( x + sx*( y + sy*(mz)));
v[10] = lev0 + 2*( x + sx*(my + sy*( z)));
v[12] = lev0 + 2*(mx + sx*( y + sy*( z)));
v[14] = lev0 + 2*(px + sx*( y + sy*( z)));
v[16] = lev0 + 2*( x + sx*(py + sy*( z)));
v[22] = lev0 + 2*( x + sx*( y + sy*(pz)));
if (tendata) {
if (!(task->actx->homogAniso)) {
}
} else {
lapA = (v[ 4][0] + v[10][0] + v[12][0]
+ v[14][0] + v[16][0] + v[22][0] - 6*A);
lapB = (v[ 4][1] + v[10][1] + v[12][1]
+ v[14][1] + v[16][1] + v[22][1] - 6*B);
}
}
deltaA = deltaT*(react*conf*task->actx->K*(alpha - A*B)
+ diffA*(lapA + corrA));
if (AIR_ABS(deltaA) > task->actx->maxPixelChange) {
stop = alanStopDiverged;
}
change += AIR_ABS(deltaA);
deltaB = deltaT*(react*conf*task->actx->K*(A*B - B - beta)
+ diffB*(lapB + corrB));
if (!( AIR_EXISTS(deltaA) && AIR_EXISTS(deltaB) )) {
stop = alanStopNonExist;
}
A += deltaA;
B = AIR_MAX(0, B + deltaB);
lev1[0 + 2*idx] = A;
lev1[1 + 2*idx] = B;
}
}
}
/* add change to global sum in a threadsafe way */
airThreadMutexLock(task->actx->changeMutex);
task->actx->averageChange += change/(sx*sy*sz);
task->actx->changeCount += 1;
if (task->actx->changeCount == task->actx->numThreads) {
/* I must be the last thread to reach this point; all
others must have passed the mutex unlock, and are
sitting at the barrier */
if (alanStopNot != stop) {
/* there was some problem in going from lev0 to lev1, which
we deal with now by setting actx->stop */
task->actx->stop = stop;
} else if (task->actx->averageChange < task->actx->minAverageChange) {
/* we converged */
task->actx->stop = alanStopConverged;
} else {
/* we keep going */
_alanPerIteration(task->actx, iter);
if (task->actx->perIteration) {
task->actx->perIteration(task->actx, iter);
}
}
task->actx->averageChange = 0;
task->actx->changeCount = 0;
}
airThreadMutexUnlock(task->actx->changeMutex);
/* force all threads to line up here, once per iteration */
airThreadBarrierWait(task->actx->iterBarrier);
}
if (iter == task->actx->maxIteration) {
/* HEY: all threads will agree on this, right? */
task->actx->stop = alanStopMaxIteration;
}
/* else: the non-alanStopNot value of task->actx->stop made us stop */
return _task;
}
int
unrrdu_fftMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *_nin, *nout;
int pret;
airArray *mop;
int sign, rigor, rescale, realInput;
char *wispath;
FILE *fwise;
unsigned int *axes, axesLen;
hestOptAdd(&opt, NULL, "dir", airTypeEnum, 1, 1, &sign, NULL,
"forward (\"forw\", \"f\") or backward/inverse "
"(\"back\", \"b\") transform ", NULL, direction_enm);
hestOptAdd(&opt, "a,axes", "ax0", airTypeUInt, 1, -1, &axes, NULL,
"the one or more axes that should be transformed", &axesLen);
hestOptAdd(&opt, "pr,planrigor", "pr", airTypeEnum, 1, 1, &rigor, "est",
"rigor with which fftw plan is constructed. Options include:\n "
"\b\bo \"e\", \"est\", \"estimate\": only an estimate\n "
"\b\bo \"m\", \"meas\", \"measure\": standard amount of "
"measurements of system properties\n "
"\b\bo \"p\", \"pat\", \"patient\": slower, more measurements\n "
"\b\bo \"x\", \"ex\", \"exhaustive\": slowest, most measurements",
NULL, nrrdFFTWPlanRigor);
hestOptAdd(&opt, "r,rescale", "bool", airTypeBool, 1, 1, &rescale, "true",
"scale fftw output (by sqrt(1/N)) so that forward and backward "
"transforms will get back to original values");
hestOptAdd(&opt, "w,wisdom", "filename", airTypeString, 1, 1, &wispath, "",
"A filename here is used to read in fftw wisdom (if the file "
"exists already), and is used to save out updated wisdom "
"after the transform. By default (not using this option), "
"no wisdom is read or saved. Note: no wisdom is gained "
"(that is, learned by FFTW) with planning rigor \"estimate\".");
OPT_ADD_NIN(_nin, "input nrrd");
hestOptAdd(&opt, "ri,realinput", NULL, airTypeInt, 0, 0, &realInput, NULL,
"input is real-valued, so insert new length-2 axis 0 "
"and set complex component to 0.0. Axes to transform "
"(indicated by \"-a\") will be incremented accordingly.");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
if (nrrdFFTWEnabled) {
USAGE(_unrrdu_fftInfoL_yes);
} else {
USAGE(_unrrdu_fftInfoL_no);
}
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (realInput) {
ptrdiff_t minPad[NRRD_DIM_MAX], maxPad[NRRD_DIM_MAX];
unsigned int axi;
Nrrd *ntmp;
ntmp = nrrdNew();
airMopAdd(mop, ntmp, (airMopper)nrrdNuke, airMopAlways);
if (nrrdAxesInsert(ntmp, _nin, 0)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error creating complex axis:\n%s", me, err);
airMopError(mop);
return 1;
}
nin = nrrdNew();
airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
minPad[0] = 0;
maxPad[0] = 1;
for (axi=1; axi<ntmp->dim; axi++) {
minPad[axi] = 0;
maxPad[axi] = AIR_CAST(ptrdiff_t, ntmp->axis[axi].size-1);
}
if (nrrdPad_nva(nin, ntmp, minPad, maxPad, nrrdBoundaryPad, 0.0)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error padding out complex axis:\n%s", me, err);
airMopError(mop);
return 1;
}
/* increment specified axes to transform */
for (axi=0; axi<axesLen; axi++) {
axes[axi]++;
}
/* ntmp is really done with, we can free up the space now; this
is one of the rare times we want airMopSub */
airMopSub(mop, ntmp, (airMopper)nrrdNuke);
nrrdNuke(ntmp);
} else {
/* input is apparently already complex */
nin = _nin;
}
if (airStrlen(wispath) && nrrdFFTWEnabled) {
fwise = fopen(wispath, "r");
if (fwise) {
if (nrrdFFTWWisdomRead(fwise)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error with fft wisdom:\n%s", me, err);
airMopError(mop);
return 1;
}
fclose(fwise);
} else {
fprintf(stderr, "%s: (\"%s\" couldn't be opened, will try to save "
"wisdom afterwards)", me, wispath);
}
}
if (nrrdFFT(nout, nin, axes, axesLen, sign, rescale, rigor)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error with fft:\n%s", me, err);
airMopError(mop);
return 1;
}
if (airStrlen(wispath) && nrrdFFTWEnabled) {
if (!(fwise = fopen(wispath, "w"))) {
fprintf(stderr, "%s: couldn't open %s for writing: %s\n",
me, wispath, strerror(errno));
airMopError(mop);
return 1;
}
if (nrrdFFTWWisdomWrite(fwise)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error with fft wisdom:\n%s", me, err);
airMopError(mop);
return 1;
}
fclose(fwise);
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
/*
** nio->byteSkip < 0 functionality contributed by Katharina Quintus
*/
static int
_nrrdEncodingGzip_read(FILE *file, void *_data, size_t elNum,
Nrrd *nrrd, NrrdIoState *nio) {
static const char me[]="_nrrdEncodingGzip_read";
#if TEEM_ZLIB
size_t sizeData, sizeRed;
int error;
long int bi;
unsigned int didread, sizeChunk, maxChunk;
char *data;
gzFile gzfin;
airPtrPtrUnion appu;
sizeData = nrrdElementSize(nrrd)*elNum;
/* Create the gzFile for reading in the gzipped data. */
if ((gzfin = _nrrdGzOpen(file, "rb")) == Z_NULL) {
/* there was a problem */
biffAddf(NRRD, "%s: error opening gzFile", me);
return 1;
}
/* keeps track of how many bytes have been successfully read in */
sizeRed = 0;
/* zlib can only handle data sizes up to UINT_MAX ==> if there's more than
UINT_MAX bytes to read in, we read in in chunks. However, we wrap a value
_nrrdZlibMaxChunk around UINT_MAX for testing purposes. Given how
sizeChunk is used below, we also cap chunk size at _nrrdZlibMaxChunk/2 to
prevent overflow. */
maxChunk = _nrrdZlibMaxChunk/2;
sizeChunk = AIR_CAST(unsigned int, AIR_MIN(sizeData, maxChunk));
if (nio->byteSkip < 0) {
/* We don't know the size of the size to skip before the data, so
decompress the data first into a temporary memory buffer. Then
the byteskipping is then just memcpy-ing the appropriate region
of memory from "buff" into the given "_data" pointer */
char *buff;
airArray *buffArr;
long backwards;
/* setting the airArray increment to twice the chunk size means that for
headers that are small compared to the data, the airArray never
actually has to reallocate. The unit is 1 because we are managing
the reading in terms of bytes (sizeof(char)==1 by definition) */
buff = NULL;
appu.c = &buff;
buffArr = airArrayNew(appu.v, NULL, 1, 2*sizeChunk);
airArrayLenSet(buffArr, sizeChunk);
if (!( buffArr && buffArr->data )) {
biffAddf(NRRD, "%s: couldn't initialize airArray\n", me);
return 1;
}
/* we keep reading in chunks as long as there hasn't been an error,
and we haven't hit EOF (EOF signified by read == 0). Unlike the
code below (for positive byteskip), we are obligated to read until
the bitter end, and can't update sizeChunk to encompass only the
required data. */
while (!(error = _nrrdGzRead(gzfin, buff + sizeRed,
sizeChunk, &didread))
&& didread > 0) {
sizeRed += didread;
if (didread >= sizeChunk) {
/* we were able to read as much data as we requested, maybe there is
more, so we need to make our temp buffer bigger */
unsigned int newlen = buffArr->len + sizeChunk;
if (newlen < buffArr->len) {
biffAddf(NRRD, "%s: array size will exceed uint capacity", me);
return 1;
}
airArrayLenSet(buffArr, newlen);
if (!buffArr->data) {
biffAddf(NRRD, "%s: couldn't re-allocate data buffer", me);
return 1;
}
}
}
if (error) {
biffAddf(NRRD, "%s: error reading from gzFile", me);
return 1;
}
/* backwards is (positive) number of bytes AFTER data that we ignore */
backwards = -nio->byteSkip - 1;
if (sizeRed < sizeData + AIR_CAST(size_t, backwards)) {
char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL];
biffAddf(NRRD, "%s: expected %s bytes but received only %s", me,
airSprintSize_t(stmp1, sizeData + AIR_CAST(size_t, backwards)),
airSprintSize_t(stmp2, sizeRed));
return 1;
}
/* also handles nio->byteSkip == -N-1 signifying extra N bytes at end */
memcpy(_data, buff + sizeRed - sizeData - backwards, sizeData);
airArrayNuke(buffArr);
} else {
/* no negative byteskip: after byteskipping, we can read directly
into given data buffer */
if (nio->byteSkip > 0) {
for (bi=0; bi<nio->byteSkip; bi++) {
unsigned char b;
/* Check to see if a single byte was able to be read. */
if (_nrrdGzRead(gzfin, &b, 1, &didread) != 0 || didread != 1) {
biffAddf(NRRD, "%s: hit an error skipping byte %ld of %ld",
me, bi, nio->byteSkip);
return 1;
}
}
}
/* Pointer to chunks as we read them. */
data = AIR_CAST(char *, _data);
while (!(error = _nrrdGzRead(gzfin, data, sizeChunk, &didread))
&& didread > 0) {
/* Increment the data pointer to the next available chunk. */
data += didread;
sizeRed += didread;
/* We only want to read as much data as we need, so we need to check
to make sure that we don't request data that might be there but that
we don't want. This will reduce sizeChunk when we get to the last
block (which may be smaller than the original sizeChunk). */
if (sizeData >= sizeRed
&& sizeData - sizeRed < sizeChunk) {
sizeChunk = AIR_CAST(unsigned int, sizeData - sizeRed);
}
}
if (error) {
biffAddf(NRRD, "%s: error reading from gzFile", me);
return 1;
}
/* Check to see if we got out as much as we thought we should. */
if (sizeRed != sizeData) {
char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL];
biffAddf(NRRD, "%s: expected %s bytes but received %s", me,
airSprintSize_t(stmp1, sizeData),
airSprintSize_t(stmp2, sizeRed));
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
main(int argc, const char *argv[]) {
hestOpt *hopt=NULL;
hestParm *hparm;
Nrrd *nlight, *nmap, *ndebug;
const char *me;
char *outS, *errS, *debugS;
airArray *mop;
float amb[3], *linfo, *debug, *map, vscl;
unsigned li, ui, vi;
int qn, bits, method, doerr;
limnLight *light;
limnCamera *cam;
double u, v, r, w, V2W[9], diff, WW[3], VV[3];
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hparm->elideSingleEmptyStringDefault = AIR_TRUE;
cam = limnCameraNew();
airMopAdd(mop, cam, (airMopper)limnCameraNix, airMopAlways);
hestOptAdd(&hopt, "i", "nlight", airTypeOther, 1, 1, &nlight, NULL,
"input nrrd containing light information",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "b", "# bits", airTypeInt, 1, 1, &bits, "16",
"number of bits to use for normal quantization, "
"between 8 and 16 inclusive. ");
hestOptAdd(&hopt, "amb", "ambient RGB", airTypeFloat, 3, 3, amb, "0 0 0",
"ambient light color");
hestOptAdd(&hopt, "fr", "from point", airTypeDouble, 3, 3, cam->from,"1 0 0",
"position of camera, used to determine view vector");
hestOptAdd(&hopt, "at", "at point", airTypeDouble, 3, 3, cam->at, "0 0 0",
"camera look-at point, used to determine view vector");
hestOptAdd(&hopt, "up", "up vector", airTypeDouble, 3, 3, cam->up, "0 0 1",
"camera pseudo-up vector, used to determine view coordinates");
hestOptAdd(&hopt, "rh", NULL, airTypeInt, 0, 0, &(cam->rightHanded), NULL,
"use a right-handed UVN frame (V points down)");
hestOptAdd(&hopt, "vs", "view-dir scaling", airTypeFloat, 1, 1, &vscl, "1",
"scaling along view-direction of location of "
"view-space lights");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, NULL,
"file to write output envmap to");
hestOptAdd(&hopt, "d", "filename", airTypeString, 1, 1, &debugS, "",
"Use this option to save out (to the given filename) a rendering "
"of the front (on the left) and back (on the right) of a sphere "
"as shaded with the new environment map. U increases "
"right-ward, V increases downward. The back sphere half is "
"rendered as though the front half was removed");
hestOptAdd(&hopt, "err", NULL, airTypeInt, 0, 0, &doerr, NULL,
"If using \"-d\", make the image represent the error between the "
"real and quantized vector");
hestParseOrDie(hopt, argc-1, argv+1, hparm, me, emapInfo,
AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
switch(bits) {
case 16:
method = limnQN16octa;
break;
case 15:
method = limnQN15octa;
break;
case 14:
method = limnQN14octa;
break;
case 13:
method = limnQN13octa;
break;
case 12:
method = limnQN12octa;
break;
case 11:
method = limnQN11octa;
break;
case 10:
method = limnQN10octa;
break;
case 9:
method = limnQN9octa;
break;
case 8:
method = limnQN8octa;
break;
default:
fprintf(stderr, "%s: requested #bits (%d) not in valid range [8,16]\n",
me, bits);
airMopError(mop);
return 1;
}
if (!(nrrdTypeFloat == nlight->type &&
2 == nlight->dim &&
7 == nlight->axis[0].size &&
LIMN_LIGHT_NUM >= nlight->axis[1].size)) {
fprintf(stderr, "%s: nlight isn't valid format for light specification, "
"must be: float type, 2-dimensional, 7\tx\tN size, N <= %d\n",
me, LIMN_LIGHT_NUM);
airMopError(mop);
return 1;
}
cam->neer = -0.000000001;
cam->dist = 0;
cam->faar = 0.0000000001;
cam->atRelative = AIR_TRUE;
if (limnCameraUpdate(cam)) {
airMopAdd(mop, errS = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: problem with camera:\n%s\n", me, errS);
airMopError(mop);
return 1;
}
light = limnLightNew();
airMopAdd(mop, light, (airMopper)limnLightNix, airMopAlways);
limnLightAmbientSet(light, amb[0], amb[1], amb[2]);
for (li=0; li<nlight->axis[1].size; li++) {
int vsp;
float lxyz[3];
linfo = (float *)(nlight->data) + 7*li;
vsp = !!linfo[0];
ELL_3V_COPY(lxyz, linfo + 4);
if (vsp) {
lxyz[2] *= vscl;
}
limnLightSet(light, li, vsp,
linfo[1], linfo[2], linfo[3], lxyz[0], lxyz[1], lxyz[2]);
}
if (limnLightUpdate(light, cam)) {
airMopAdd(mop, errS = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: problem with lights:\n%s\n", me, errS);
airMopError(mop);
return 1;
}
nmap=nrrdNew();
airMopAdd(mop, nmap, (airMopper)nrrdNuke, airMopAlways);
if (limnEnvMapFill(nmap, limnLightDiffuseCB, method, light)) {
airMopAdd(mop, errS = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: problem making environment map:\n%s\n", me, errS);
airMopError(mop);
return 1;
}
map = (float *)nmap->data;
if (nrrdSave(outS, nmap, NULL)) {
fprintf(stderr, "%s: trouble:\n%s", me, errS = biffGetDone(NRRD));
free(errS);
return 1;
}
if (airStrlen(debugS)) {
ELL_34M_EXTRACT(V2W, cam->V2W);
ndebug = nrrdNew();
nrrdMaybeAlloc_va(ndebug, nrrdTypeFloat, 3,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, 1024),
AIR_CAST(size_t, 512));
airMopAdd(mop, ndebug, (airMopper)nrrdNuke, airMopAlways);
debug = (float *)ndebug->data;
for (vi=0; vi<=511; vi++) {
v = AIR_AFFINE(0, vi, 511, -0.999, 0.999);
for (ui=0; ui<=511; ui++) {
u = AIR_AFFINE(0, ui, 511, -0.999, 0.999);
r = sqrt(u*u + v*v);
if (r > 1) {
continue;
}
w = sqrt(1 - r*r);
/* first, the near side of the sphere */
ELL_3V_SET(VV, u, v, -w);
ELL_3MV_MUL(WW, V2W, VV);
qn = limnVtoQN_d[method](WW);
if (doerr) {
limnQNtoV_d[method](VV, qn);
ELL_3V_SUB(WW, WW, VV);
diff = ELL_3V_LEN(WW);
ELL_3V_SET_TT(debug + 3*(ui + 1024*vi), float,
diff, diff, diff);
} else {
ELL_3V_COPY(debug + 3*(ui + 1024*vi), map + 3*qn);
}
/* second, the far side of the sphere */
ELL_3V_SET(VV, u, v, w);
ELL_3MV_MUL(WW, V2W, VV);
qn = limnVtoQN_d[method](WW);
if (doerr) {
limnQNtoV_d[method](VV, qn);
ELL_3V_SUB(WW, WW, VV);
diff = ELL_3V_LEN(WW);
ELL_3V_SET_TT(debug + 3*(ui + 512 + 1024*vi), float,
diff, diff, diff);
} else {
ELL_3V_COPY(debug + 3*(ui + 512 + 1024*vi), map + 3*qn);
}
}
}
/*
** _nrrdResampleMakeWeightIndex()
**
** _allocate_ and fill the arrays of indices and weights that are
** needed to process all the scanlines along a given axis; also
** be so kind as to set the sampling ratio (<1: downsampling,
** new sample spacing larger, >1: upsampling, new sample spacing smaller)
**
** returns "dotLen", the number of input samples which are required
** for resampling this axis, or 0 if there was an error. Uses biff.
*/
int
_nrrdResampleMakeWeightIndex(nrrdResample_t **weightP,
int **indexP, double *ratioP,
const Nrrd *nin, const NrrdResampleInfo *info,
unsigned int ai) {
char me[]="_nrrdResampleMakeWeightIndex", err[BIFF_STRLEN];
int sizeIn, sizeOut, center, dotLen, halfLen, *index, base, idx;
nrrdResample_t minIn, maxIn, minOut, maxOut, spcIn, spcOut,
ratio, support, integral, pos, idxD, wght;
nrrdResample_t *weight;
double parm[NRRD_KERNEL_PARMS_NUM];
int e, i;
if (!(info->kernel[ai])) {
sprintf(err, "%s: don't see a kernel for dimension %d", me, ai);
biffAdd(NRRD, err); *weightP = NULL; *indexP = NULL; return 0;
}
center = _nrrdCenter(nin->axis[ai].center);
sizeIn = nin->axis[ai].size;
sizeOut = info->samples[ai];
minIn = AIR_CAST(nrrdResample_t, nin->axis[ai].min);
maxIn = AIR_CAST(nrrdResample_t, nin->axis[ai].max);
minOut = AIR_CAST(nrrdResample_t, info->min[ai]);
maxOut = AIR_CAST(nrrdResample_t, info->max[ai]);
spcIn = NRRD_SPACING(center, minIn, maxIn, sizeIn);
spcOut = NRRD_SPACING(center, minOut, maxOut, sizeOut);
*ratioP = ratio = spcIn/spcOut;
support = AIR_CAST(nrrdResample_t,
info->kernel[ai]->support(info->parm[ai]));
integral = AIR_CAST(nrrdResample_t,
info->kernel[ai]->integral(info->parm[ai]));
/*
fprintf(stderr,
"!%s(%d): size{In,Out} = %d, %d, support = %f; ratio = %f\n",
me, d, sizeIn, sizeOut, support, ratio);
*/
if (ratio > 1) {
/* if upsampling, we need only as many samples as needed for
interpolation with the given kernel */
dotLen = (int)(2*ceil(support));
} else {
/* if downsampling, we need to use all the samples covered by
the stretched out version of the kernel */
if (info->cheap) {
dotLen = (int)(2*ceil(support));
} else {
dotLen = (int)(2*ceil(support/ratio));
}
}
/*
fprintf(stderr, "!%s(%d): dotLen = %d\n", me, d, dotLen);
*/
weight = (nrrdResample_t*)calloc(sizeOut*dotLen, sizeof(nrrdResample_t));
index = (int*)calloc(sizeOut*dotLen, sizeof(int));
if (!(weight && index)) {
sprintf(err, "%s: can't allocate weight and index arrays", me);
biffAdd(NRRD, err); *weightP = NULL; *indexP = NULL; return 0;
}
/* calculate sample locations and do first pass on indices */
halfLen = dotLen/2;
for (i=0; i<sizeOut; i++) {
pos = AIR_CAST(nrrdResample_t,
NRRD_POS(center, minOut, maxOut, sizeOut, i));
idxD = AIR_CAST(nrrdResample_t,
NRRD_IDX(center, minIn, maxIn, sizeIn, pos));
base = (int)floor(idxD) - halfLen + 1;
for (e=0; e<dotLen; e++) {
index[e + dotLen*i] = base + e;
weight[e + dotLen*i] = idxD - index[e + dotLen*i];
}
/* ********
if (!i) {
fprintf(stderr, "%s: sample locations:\n", me);
}
fprintf(stderr, "%s: %d (sample locations)\n ", me, i);
for (e=0; e<dotLen; e++) {
fprintf(stderr, "%d/%g ", index[e + dotLen*i], weight[e + dotLen*i]);
}
fprintf(stderr, "\n");
******** */
}
/*
nrrdBoundaryPad, 1: fill with some user-specified value
nrrdBoundaryBleed, 2: copy the last/first value out as needed
nrrdBoundaryWrap, 3: wrap-around
nrrdBoundaryWeight, 4: normalize the weighting on the existing samples;
ONLY sensible for a strictly positive kernel
which integrates to unity (as in blurring)
*/
/* figure out what to do with the out-of-range indices */
for (i=0; i<dotLen*sizeOut; i++) {
idx = index[i];
if (!AIR_IN_CL(0, idx, sizeIn-1)) {
switch(info->boundary) {
case nrrdBoundaryPad:
case nrrdBoundaryWeight: /* this will be further handled later */
idx = sizeIn;
break;
case nrrdBoundaryBleed:
idx = AIR_CLAMP(0, idx, sizeIn-1);
break;
case nrrdBoundaryWrap:
idx = AIR_MOD(idx, sizeIn);
break;
default:
sprintf(err, "%s: boundary behavior %d unknown/unimplemented",
me, info->boundary);
biffAdd(NRRD, err); *weightP = NULL; *indexP = NULL; return 0;
}
index[i] = idx;
}
}
/* run the sample locations through the chosen kernel. We play a
sneaky trick on the kernel parameter 0 in case of downsampling
to create the blurring of the old index space, but only if !cheap */
memcpy(parm, info->parm[ai], NRRD_KERNEL_PARMS_NUM*sizeof(double));
if (ratio < 1 && !(info->cheap)) {
parm[0] /= ratio;
}
info->kernel[ai]->EVALN(weight, weight, dotLen*sizeOut, parm);
/* ********
for (i=0; i<sizeOut; i++) {
fprintf(stderr, "%s: %d (sample weights)\n ", me, i);
for (e=0; e<dotLen; e++) {
fprintf(stderr, "%d/%g ", index[e + dotLen*i], weight[e + dotLen*i]);
}
fprintf(stderr, "\n");
}
******** */
if (nrrdBoundaryWeight == info->boundary) {
if (integral) {
/* above, we set to sizeIn all the indices that were out of
range. We now use that to determine the sum of the weights
for the indices that were in-range */
for (i=0; i<sizeOut; i++) {
wght = 0;
for (e=0; e<dotLen; e++) {
if (sizeIn != index[e + dotLen*i]) {
wght += weight[e + dotLen*i];
}
}
for (e=0; e<dotLen; e++) {
idx = index[e + dotLen*i];
if (sizeIn != idx) {
weight[e + dotLen*i] *= integral/wght;
} else {
weight[e + dotLen*i] = 0;
}
}
}
}
} else {
/* try to remove ripple/grating on downsampling */
/* if (ratio < 1 && info->renormalize && integral) { */
if (info->renormalize && integral) {
for (i=0; i<sizeOut; i++) {
wght = 0;
for (e=0; e<dotLen; e++) {
wght += weight[e + dotLen*i];
}
if (wght) {
for (e=0; e<dotLen; e++) {
/* this used to normalize the weights so that they summed
to integral ("*= integral/wght"), which meant that if
you use a very truncated Gaussian, then your over-all
image brightness goes down. This seems very contrary
to the whole point of renormalization. */
weight[e + dotLen*i] *= AIR_CAST(nrrdResample_t, 1.0/wght);
}
}
}
}
}
/* ********
fprintf(stderr, "%s: sample weights:\n", me);
for (i=0; i<sizeOut; i++) {
fprintf(stderr, "%s: %d\n ", me, i);
wght = 0;
for (e=0; e<dotLen; e++) {
fprintf(stderr, "%d/%g ", index[e + dotLen*i], weight[e + dotLen*i]);
wght += weight[e + dotLen*i];
}
fprintf(stderr, " (sum = %g)\n", wght);
}
******** */
*weightP = weight;
*indexP = index;
/*
fprintf(stderr, "!%s: dotLen = %d\n", me, dotLen);
*/
return dotLen;
}
int
miteRenderBegin(miteRender **mrrP, miteUser *muu) {
static const char me[]="miteRenderBegin";
gagePerVolume *pvl;
int E, T, pvlIdx;
gageQuery queryScl, queryVec, queryTen;
gageItemSpec isp;
unsigned int axi, thr;
if (!(mrrP && muu)) {
biffAddf(MITE, "%s: got NULL pointer", me);
return 1;
}
if (_miteUserCheck(muu)) {
biffAddf(MITE, "%s: problem with user-set parameters", me);
return 1;
}
if (!( *mrrP = _miteRenderNew() )) {
biffAddf(MITE, "%s: couldn't alloc miteRender", me);
return 1;
}
if (_miteNtxfAlphaAdjust(*mrrP, muu)) {
biffAddf(MITE, "%s: trouble copying and alpha-adjusting txfs", me);
return 1;
}
GAGE_QUERY_RESET(queryScl);
GAGE_QUERY_RESET(queryVec);
GAGE_QUERY_RESET(queryTen);
GAGE_QUERY_RESET((*mrrP)->queryMite);
for (T=0; T<muu->ntxfNum; T++) {
for (axi=1; axi<muu->ntxf[T]->dim; axi++) {
miteVariableParse(&isp, muu->ntxf[T]->axis[axi].label);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite, &isp);
}
}
miteVariableParse((*mrrP)->normalSpec, muu->normalStr);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->normalSpec);
miteShadeSpecParse((*mrrP)->shadeSpec, muu->shadeStr);
miteShadeSpecQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->shadeSpec);
(*mrrP)->queryMiteNonzero = GAGE_QUERY_NONZERO((*mrrP)->queryMite);
E = 0;
pvlIdx = 0;
if (muu->nsin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nsin, gageKindScl));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryScl);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->sclPvlIdx = pvlIdx++;
}
if (muu->nvin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nvin, gageKindVec));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryVec);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->vecPvlIdx = pvlIdx++;
}
if (muu->ntin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->ntin, tenGageKind));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryTen);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->tenPvlIdx = pvlIdx++;
}
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel00,
muu->ksp[gageKernel00]->kernel,
muu->ksp[gageKernel00]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel11,
muu->ksp[gageKernel11]->kernel,
muu->ksp[gageKernel11]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel22,
muu->ksp[gageKernel22]->kernel,
muu->ksp[gageKernel22]->parm);
if (!E) E |= gageUpdate(muu->gctx0);
if (E) {
biffMovef(MITE, GAGE, "%s: gage trouble", me);
return 1;
}
fprintf(stderr, "!%s: kernel support = %d^3 samples\n",
me, 2*muu->gctx0->radius);
if (nrrdMaybeAlloc_va(muu->nout, mite_nt, 3,
AIR_CAST(size_t, 5) /* RGBAZ */ ,
AIR_CAST(size_t, muu->hctx->imgSize[0]),
AIR_CAST(size_t, muu->hctx->imgSize[1]))) {
biffMovef(MITE, NRRD, "%s: nrrd trouble", me);
return 1;
}
muu->nout->axis[1].center = nrrdCenterCell;
muu->nout->axis[1].min = muu->hctx->cam->uRange[0];
muu->nout->axis[1].max = muu->hctx->cam->uRange[1];
muu->nout->axis[2].center = nrrdCenterCell;
muu->nout->axis[2].min = muu->hctx->cam->vRange[0];
muu->nout->axis[2].max = muu->hctx->cam->vRange[1];
for (thr=0; thr<muu->hctx->numThreads; thr++) {
(*mrrP)->tt[thr] = miteThreadNew();
if (!((*mrrP)->tt[thr])) {
biffAddf(MITE, "%s: couldn't allocate thread[%d]", me, thr);
return 1;
}
airMopAdd((*mrrP)->rmop, (*mrrP)->tt[thr],
(airMopper)miteThreadNix, airMopAlways);
}
(*mrrP)->time0 = airTime();
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;
}
/*
** _gageShapeSet
**
** we are serving two masters here. If ctx is non-NULL, we are being called
** from within gage, and we are to be lax or strict according to the settings
** of ctx->parm.requireAllSpacings and ctx->parm.requireEqualCenters. If
** ctx is NULL, gageShapeSet was called, in which case we go with lax
** behavior (nothing "required")
**
** This function has subsumed the old gageVolumeCheck, and hence has
** become this weird beast- part error checker and part (gageShape)
** initializer. Oh well...
*/
int
_gageShapeSet(const gageContext *ctx, gageShape *shape,
const Nrrd *nin, unsigned int baseDim) {
char me[]="_gageShapeSet", err[BIFF_STRLEN];
int i, ai, cx, cy, cz, defCenter, statCalc[3];
unsigned int minsize, sx, sy, sz, num[3];
const NrrdAxisInfo *ax[3];
double maxLen, xs, ys, zs, defSpacing,
vecA[4], vecB[3], vecC[3], vecD[4],
spcCalc[3], vecCalc[3][NRRD_SPACE_DIM_MAX], orig[NRRD_SPACE_DIM_MAX];
/* ------ basic error checking */
if (!( shape && nin )) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(GAGE, err); if (shape) { gageShapeReset(shape); }
return 1;
}
if (nrrdCheck(nin)) {
sprintf(err, "%s: basic nrrd validity check failed", me);
biffMove(GAGE, err, NRRD); gageShapeReset(shape);
return 1;
}
if (nrrdTypeBlock == nin->type) {
sprintf(err, "%s: need a non-block type nrrd", me);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
if (!(nin->dim == 3 + baseDim)) {
sprintf(err, "%s: nrrd should be %u-D, not %u-D",
me, 3 + baseDim, nin->dim);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
ax[0] = &(nin->axis[baseDim+0]);
ax[1] = &(nin->axis[baseDim+1]);
ax[2] = &(nin->axis[baseDim+2]);
statCalc[0] = nrrdSpacingCalculate(nin, baseDim + 0,
spcCalc + 0, vecCalc[0]);
statCalc[1] = nrrdSpacingCalculate(nin, baseDim + 1,
spcCalc + 1, vecCalc[1]);
statCalc[2] = nrrdSpacingCalculate(nin, baseDim + 2,
spcCalc + 2, vecCalc[2]);
/* see if nrrdSpacingCalculate ever *failed* */
if (nrrdSpacingStatusUnknown == statCalc[0] ||
nrrdSpacingStatusUnknown == statCalc[1] ||
nrrdSpacingStatusUnknown == statCalc[2]) {
sprintf(err, "%s: nrrdSpacingCalculate trouble on axis %d, %d, or %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
/* see if nrrdSpacingCalculate encountered an axis with no space
direction in a nrrd that nominally has a surrounding space */
if (nrrdSpacingStatusScalarWithSpace == statCalc[0] ||
nrrdSpacingStatusScalarWithSpace == statCalc[1] ||
nrrdSpacingStatusScalarWithSpace == statCalc[2]) {
sprintf(err, "%s: nrrdSpacingCalculate weirdness on axis %d, %d, or %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
if (!( (nrrdSpacingStatusDirection == statCalc[0] &&
nrrdSpacingStatusDirection == statCalc[1] &&
nrrdSpacingStatusDirection == statCalc[2])
||
(nrrdSpacingStatusDirection != statCalc[0] &&
nrrdSpacingStatusDirection != statCalc[1] &&
nrrdSpacingStatusDirection != statCalc[2])
)) {
sprintf(err, "%s: inconsistent space directions use "
"in axis %d, %d, and %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
if (nrrdSpacingStatusDirection == statCalc[0] &&
nrrdSpacingStatusDirection == statCalc[1] &&
nrrdSpacingStatusDirection == statCalc[2]) {
/* this will get reset to false in case of error */
shape->fromOrientation = AIR_TRUE;
} else {
shape->fromOrientation = AIR_FALSE;
}
/* oh yea, we should make sure the space dimension is right! */
if (shape->fromOrientation && 3 != nin->spaceDim) {
sprintf(err, "%s: orientation space dimension %d != 3",
me, nin->spaceDim);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
/* ------ find centering (set shape->center) */
/* HEY: when we have full orientation information (via spaceDirections
and spaceOrigin) the centering information is moot for determining
shape, but until all usage of gageShape stuff is properly overhauled
to take orientation into account, we'll still set shape->center */
cx = ax[0]->center;
cy = ax[1]->center;
cz = ax[2]->center;
if (ctx && ctx->parm.requireEqualCenters) {
if (!( cx == cy && cx == cz )) {
sprintf(err, "%s: axes %d,%d,%d centerings (%s,%s,%s) not equal", me,
baseDim+0, baseDim+1, baseDim+2,
airEnumStr(nrrdCenter, cx),
airEnumStr(nrrdCenter, cy),
airEnumStr(nrrdCenter, cz));
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
} else {
if ( (nrrdCenterUnknown != cx && nrrdCenterUnknown != cy && cx != cy) ||
(nrrdCenterUnknown != cy && nrrdCenterUnknown != cz && cy != cz) ||
(nrrdCenterUnknown != cx && nrrdCenterUnknown != cz && cx != cz) ) {
sprintf(err, "%s: two known centerings (of %s,%s,%s) are unequal", me,
airEnumStr(nrrdCenter, cx),
airEnumStr(nrrdCenter, cy),
airEnumStr(nrrdCenter, cz));
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
}
defCenter = ctx ? ctx->parm.defaultCenter : shape->defaultCenter;
shape->center = (nrrdCenterUnknown != cx ? cx
: (nrrdCenterUnknown != cy ? cy
: (nrrdCenterUnknown != cz ? cz
: defCenter)));
/* ------ find sizes (set shape->size[0,1,2]) */
sx = ax[0]->size;
sy = ax[1]->size;
sz = ax[2]->size;
minsize = (nrrdCenterCell == shape->center ? 1 : 2);
/* HEY: perhaps this should be relaxed if we have full orientation info */
if (!(sx >= minsize && sy >= minsize && sz >= minsize )) {
sprintf(err, "%s: sizes (%u,%u,%u) must all be >= %u "
"(min number of %s-centered samples)", me,
sx, sy, sz, minsize, airEnumStr(nrrdCenter, shape->center));
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
shape->size[0] = sx;
shape->size[1] = sy;
shape->size[2] = sz;
/* ------ find spacings (set shape->spacing[0,1,2]) */
if (shape->fromOrientation) {
xs = spcCalc[0];
ys = spcCalc[1];
zs = spcCalc[2];
} else {
xs = ax[0]->spacing;
ys = ax[1]->spacing;
zs = ax[2]->spacing;
if (ctx && ctx->parm.requireAllSpacings) {
if (!( AIR_EXISTS(xs) && AIR_EXISTS(ys) && AIR_EXISTS(zs) )) {
sprintf(err, "%s: spacings for axes %d,%d,%d don't all exist",
me, baseDim+0, baseDim+1, baseDim+2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
}
/* there is no shape->defaultSpacing, we'll go out on a limb ... */
defSpacing = ctx ? ctx->parm.defaultSpacing : nrrdDefaultSpacing;
xs = AIR_EXISTS(xs) ? xs : defSpacing;
ys = AIR_EXISTS(ys) ? ys : defSpacing;
zs = AIR_EXISTS(zs) ? zs : defSpacing;
if (!( xs != 0 && ys != 0 && zs != 0 )) {
sprintf(err, "%s: spacings (%g,%g,%g) for axes %d,%d,%d not all "
"non-zero", me, xs, ys, zs, baseDim+0, baseDim+1, baseDim+2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
}
shape->spacing[0] = AIR_CAST(gage_t, AIR_ABS(xs));
shape->spacing[1] = AIR_CAST(gage_t, AIR_ABS(ys));
shape->spacing[2] = AIR_CAST(gage_t, AIR_ABS(zs));
/* ------ set spacing-dependent filter weight scalings */
for (i=0; i<GAGE_KERNEL_NUM; i++) {
switch (i) {
case gageKernel00:
case gageKernel10:
case gageKernel20:
/* interpolation requires no re-weighting for non-unit spacing */
for (ai=0; ai<=2; ai++) {
shape->fwScale[i][ai] = 1.0;
}
break;
case gageKernel11:
case gageKernel21:
for (ai=0; ai<=2; ai++) {
shape->fwScale[i][ai] = 1.0f/(shape->spacing[ai]);
}
break;
case gageKernel22:
for (ai=0; ai<=2; ai++) {
shape->fwScale[i][ai] =
1.0f/((shape->spacing[ai])*(shape->spacing[ai]));
}
break;
}
}
/* ------ learn lengths for bounding nrrd in bi-unit cube
(set shape->volHalfLen[0,1,2] and shape->voxLen[0,1,2]) */
/* HEY: does it make any sense to be setting this if fromOrientation? */
maxLen = 0.0;
for (ai=0; ai<=2; ai++) {
num[ai] = (nrrdCenterNode == shape->center
? shape->size[ai]-1
: shape->size[ai]);
shape->volHalfLen[ai] = num[ai]*shape->spacing[ai];
maxLen = AIR_MAX(maxLen, shape->volHalfLen[ai]);
}
for (ai=0; ai<=2; ai++) {
shape->volHalfLen[ai] /= maxLen;
shape->voxLen[ai] = 2*shape->volHalfLen[ai]/num[ai];
}
/* ------ set transform matrices */
if (shape->fromOrientation) {
/* find translation vector (we check above that spaceDim == 3) */
nrrdSpaceOriginGet(nin, orig);
if (!( AIR_EXISTS(orig[0]) &&
AIR_EXISTS(orig[1]) &&
AIR_EXISTS(orig[2]) )) {
/* don't have origin, so set it to come from the middle of volume */
ELL_3V_SET(orig, 0.0f, 0.0f, 0.0f);
ELL_3V_SCALE_INCR(orig, -(shape->size[0] - 1.0f)*spcCalc[0]/2.0f,
vecCalc[0]);
ELL_3V_SCALE_INCR(orig, -(shape->size[1] - 1.0f)*spcCalc[1]/2.0f,
vecCalc[1]);
ELL_3V_SCALE_INCR(orig, -(shape->size[2] - 1.0f)*spcCalc[2]/2.0f,
vecCalc[2]);
}
vecD[3] = 0;
ELL_3V_SCALE(vecD, spcCalc[0], vecCalc[0]);
ELL_4MV_COL0_SET(shape->ItoW, vecD);
ELL_3V_SCALE(vecD, spcCalc[1], vecCalc[1]);
ELL_4MV_COL1_SET(shape->ItoW, vecD);
ELL_3V_SCALE(vecD, spcCalc[2], vecCalc[2]);
ELL_4MV_COL2_SET(shape->ItoW, vecD);
vecD[3] = 1;
ELL_3V_COPY(vecD, orig);
ELL_4MV_COL3_SET(shape->ItoW, vecD);
/*
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[0], vecCalc[0][0], vecCalc[0][1], vecCalc[0][2]);
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[1], vecCalc[1][0], vecCalc[1][1], vecCalc[1][2]);
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[2], vecCalc[2][0], vecCalc[2][1], vecCalc[2][2]);
*/
} else {
ELL_3V_SET(vecC, 0, 0, 0);
gageShapeUnitItoW(shape, vecA, vecC);
ELL_3V_SET(vecC, 1, 0, 0);
gageShapeUnitItoW(shape, vecB, vecC);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL0_SET(shape->ItoW, vecD);
ELL_3V_SET(vecC, 0, 1, 0);
gageShapeUnitItoW(shape, vecB, vecC);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL1_SET(shape->ItoW, vecD);
ELL_3V_SET(vecC, 0, 0, 1);
gageShapeUnitItoW(shape, vecB, vecC);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL2_SET(shape->ItoW, vecD);
vecA[3] = 1;
ELL_4MV_COL3_SET(shape->ItoW, vecA);
}
ell_4m_inv_d(shape->WtoI, shape->ItoW);
return 0;
}
int
main(int argc, const char *argv[]) {
gageKind *kind;
const char *me;
char *whatS, *err, *outS, *stackReadFormat, *stackSaveFormat;
hestParm *hparm;
hestOpt *hopt = NULL;
NrrdKernelSpec *k00, *k11, *k22, *kSS, *kSSblur;
int what, E=0, renorm, SSuniform, SSoptim, verbose, zeroZ,
orientationFromSpacing, SSnormd;
unsigned int iBaseDim, oBaseDim, axi, numSS, ninSSIdx, seed;
const double *answer;
Nrrd *nin, *nout, **ninSS=NULL;
Nrrd *ngrad=NULL, *nbmat=NULL;
size_t ai, ansLen, idx, xi, yi, zi, six, siy, siz, sox, soy, soz;
double bval=0, gmc, rangeSS[2], wrlSS, idxSS=AIR_NAN,
dsix, dsiy, dsiz, dsox, dsoy, dsoz;
gageContext *ctx;
gagePerVolume *pvl=NULL;
double t0, t1, x, y, z, scale[3], rscl[3], min[3], maxOut[3], maxIn[3];
airArray *mop;
unsigned int hackZi, *skip, skipNum;
double (*ins)(void *v, size_t I, double d);
gageStackBlurParm *sbp;
char hackKeyStr[]="TEEM_VPROBE_HACK_ZI", *hackValStr;
int otype, hackSet;
char stmp[4][AIR_STRLEN_SMALL];
me = argv[0];
/* parse environment variables first, in case they break nrrdDefault*
or nrrdState* variables in a way that nrrdSanity() should see */
nrrdDefaultGetenv();
nrrdStateGetenv();
/* no harm done in making sure we're sane */
if (!nrrdSanity()) {
fprintf(stderr, "******************************************\n");
fprintf(stderr, "******************************************\n");
fprintf(stderr, "\n");
fprintf(stderr, " %s: nrrd sanity check FAILED.\n", me);
fprintf(stderr, "\n");
fprintf(stderr, " This means that either nrrd can't work on this "
"platform, or (more likely)\n");
fprintf(stderr, " there was an error in the compilation options "
"and variable definitions\n");
fprintf(stderr, " for how Teem was built here.\n");
fprintf(stderr, "\n");
fprintf(stderr, " %s\n", err = biffGetDone(NRRD));
fprintf(stderr, "\n");
fprintf(stderr, "******************************************\n");
fprintf(stderr, "******************************************\n");
free(err);
return 1;
}
mop = airMopNew();
hparm = hestParmNew();
airMopAdd(mop, hparm, AIR_CAST(airMopper, hestParmFree), airMopAlways);
hparm->elideSingleOtherType = AIR_TRUE;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", "
"\"tensor\", or \"dwi\")",
NULL, NULL, meetHestGageKind);
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1, &verbose, "1",
"verbosity level");
hestOptAdd(&hopt, "q", "query", airTypeString, 1, 1, &whatS, NULL,
"the quantity (scalar, vector, or matrix) to learn by probing");
hestOptAdd(&hopt, "s", "sclX sclY sxlZ", airTypeDouble, 3, 3, scale,
"1.0 1.0 1.0",
"scaling factor for resampling on each axis "
"(>1.0 : supersampling)");
hestOptAdd(&hopt, "k00", "kern00", airTypeOther, 1, 1, &k00,
"tent", "kernel for gageKernel00",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kern11", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "kernel for gageKernel11",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kern22", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "kernel for gageKernel22",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "seed", "N", airTypeUInt, 1, 1, &seed, "42",
"RNG seed; mostly for debugging");
hestOptAdd(&hopt, "zz", "bool", airTypeBool, 1, 1, &zeroZ, "false",
"enable \"zeroZ\" behavior in gage that partially "
"implements working with 3D images as if they are 2D");
hestOptAdd(&hopt, "ssn", "SS #", airTypeUInt, 1, 1, &numSS,
"0", "how many scale-space samples to evaluate, or, "
"0 to turn-off all scale-space behavior");
hestOptAdd(&hopt, "ssr", "scale range", airTypeDouble, 2, 2, rangeSS,
"nan nan", "range of scales in scale-space");
hestOptAdd(&hopt, "ssrf", "SS read format", airTypeString, 1, 1,
&stackReadFormat, "",
"printf-style format (including a \"%u\") for the "
"filenames from which to *read* "
"pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "sssf", "SS save format", airTypeString, 1, 1,
&stackSaveFormat, "",
"printf-style format (including a \"%u\") for the "
"filenames in which to *save* "
"pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "ssw", "SS pos", airTypeDouble, 1, 1, &wrlSS, "0",
"\"world\"-space position (true sigma) "
"at which to sample in scale-space");
hestOptAdd(&hopt, "kssb", "kernel", airTypeOther, 1, 1, &kSSblur,
"dgauss:1,5", "blurring kernel, to sample scale space",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kssr", "kernel", airTypeOther, 1, 1, &kSS,
"hermite", "kernel for reconstructing from scale space samples",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "ssu", NULL, airTypeInt, 0, 0, &SSuniform, NULL,
"do uniform samples along sigma, and not (by default) "
"samples according to the effective diffusion scale");
hestOptAdd(&hopt, "sso", NULL, airTypeInt, 0, 0, &SSoptim, NULL,
"if not using \"-ssu\", use pre-computed optimal "
"sigmas when possible");
hestOptAdd(&hopt, "ssnd", NULL, airTypeInt, 0, 0, &SSnormd, NULL,
"normalize derivatives by scale");
hestOptAdd(&hopt, "rn", NULL, airTypeInt, 0, 0, &renorm, NULL,
"renormalize kernel weights at each new sample location. "
"\"Accurate\" kernels don't need this; doing it always "
"makes things go slower");
hestOptAdd(&hopt, "gmc", "min gradmag", airTypeDouble, 1, 1, &gmc,
"0.0", "For curvature-based queries, use zero when gradient "
"magnitude is below this");
hestOptAdd(&hopt, "ofs", "ofs", airTypeInt, 0, 0, &orientationFromSpacing,
NULL, "If only per-axis spacing is available, use that to "
"contrive full orientation info");
hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &otype, "float",
"type of output volume", NULL, nrrdType);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output volume");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, probeInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestOptFree), airMopAlways);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestParseFree), airMopAlways);
what = airEnumVal(kind->enm, whatS);
if (!what) {
/* 0 indeed always means "unknown" for any gageKind */
fprintf(stderr, "%s: couldn't parse \"%s\" as measure of \"%s\" volume\n",
me, whatS, kind->name);
hestUsage(stderr, hopt, me, hparm);
hestGlossary(stderr, hopt, hparm);
airMopError(mop);
return 1;
}
/* special set-up required for DWI kind */
if (!strcmp(TEN_DWI_GAGE_KIND_NAME, kind->name)) {
if (tenDWMRIKeyValueParse(&ngrad, &nbmat, &bval, &skip, &skipNum, nin)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (skipNum) {
fprintf(stderr, "%s: sorry, can't do DWI skipping in tenDwiGage", me);
airMopError(mop); return 1;
}
/* this could stand to use some more command-line arguments */
if (tenDwiGageKindSet(kind, 50, 1, bval, 0.001, ngrad, nbmat,
tenEstimate1MethodLLS,
tenEstimate2MethodQSegLLS, seed)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* for setting up pre-blurred scale-space samples */
if (numSS) {
unsigned int vi;
sbp = gageStackBlurParmNew();
airMopAdd(mop, sbp, (airMopper)gageStackBlurParmNix, airMopAlways);
ninSS = AIR_CAST(Nrrd **, calloc(numSS, sizeof(Nrrd *)));
if (!ninSS) {
fprintf(stderr, "%s: couldn't allocate ninSS", me);
airMopError(mop); return 1;
}
for (ninSSIdx=0; ninSSIdx<numSS; ninSSIdx++) {
ninSS[ninSSIdx] = nrrdNew();
airMopAdd(mop, ninSS[ninSSIdx], (airMopper)nrrdNuke, airMopAlways);
}
if (gageStackBlurParmScaleSet(sbp, numSS, rangeSS[0], rangeSS[1],
SSuniform, SSoptim)
|| gageStackBlurParmKernelSet(sbp, kSSblur)
|| gageStackBlurParmRenormalizeSet(sbp, AIR_TRUE)
|| gageStackBlurParmBoundarySet(sbp, nrrdBoundaryBleed, AIR_NAN)
|| gageStackBlurParmVerboseSet(sbp, verbose)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble with stack blur info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (airStrlen(stackReadFormat)) {
if (nrrdLoadMulti(ninSS, numSS,
stackReadFormat, 0, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble loading blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (gageStackBlurCheck(AIR_CAST(const Nrrd *const*, ninSS),
sbp, nin, kind)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
} else {
if (gageStackBlur(ninSS, sbp, nin, kind)) {
void
_tenGageAnswer (gageContext *ctx, gagePerVolume *pvl) {
/* char me[]="_tenGageAnswer"; */
gage_t epsilon=1.0E-10f;
gage_t *tenAns, *evalAns, *evecAns, *vecTmp=NULL,
*gradDtA=NULL, *gradDtB=NULL, *gradDtC=NULL,
*gradDtD=NULL, *gradDtE=NULL, *gradDtF=NULL,
gradDdXYZ[21]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
*gradCbS=NULL, *gradCbB=NULL, *gradCbQ=NULL, *gradCbR=NULL;
gage_t tmp0, tmp1, magTmp=0,
gradCbA[3]={0,0,0}, gradCbC[3]={0,0,0},
dtA=0, dtB=0, dtC=0, dtD=0, dtE=0, dtF=0,
cbQQQ=0, cbQ=0, cbR=0, cbA=0, cbB=0, cbC=0, cbS=0;
#if !GAGE_TYPE_FLOAT
int ci;
float evalAnsF[3], aniso[TEN_ANISO_MAX+1];
#endif
tenAns = pvl->directAnswer[tenGageTensor];
evalAns = pvl->directAnswer[tenGageEval];
evecAns = pvl->directAnswer[tenGageEvec];
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTensor)) {
/* done if doV */
tenAns[0] = AIR_CLAMP(0.0f, tenAns[0], 1.0f);
dtA = tenAns[1];
dtB = tenAns[2];
dtC = tenAns[3];
dtD = tenAns[4];
dtE = tenAns[5];
dtF = tenAns[6];
if (ctx->verbose) {
fprintf(stderr, "tensor = (%g) %g %g %g %g %g %g\n", tenAns[0],
dtA, dtB, dtC, dtD, dtE, dtF);
}
}
/* done if doV
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageConfidence)) {
}
*/
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTrace)) {
cbA = -(pvl->directAnswer[tenGageTrace][0] = dtA + dtD + dtF);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageB)) {
cbB = pvl->directAnswer[tenGageB][0] =
dtA*dtD + dtA*dtF + dtD*dtF - dtB*dtB - dtC*dtC - dtE*dtE;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageDet)) {
cbC = -(pvl->directAnswer[tenGageDet][0] =
2.0f*dtB*dtC*dtE + dtA*dtD*dtF
- dtC*dtC*dtD - dtA*dtE*dtE - dtB*dtB*dtF);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageS)) {
cbS = (pvl->directAnswer[tenGageS][0] =
dtA*dtA + dtD*dtD + dtF*dtF
+ 2.0f*dtB*dtB + 2.0f*dtC*dtC + 2.0f*dtE*dtE);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageQ)) {
cbQ = pvl->directAnswer[tenGageQ][0] = (cbS - cbB)/9.0f;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageFA)) {
pvl->directAnswer[tenGageFA][0] =
AIR_CAST(gage_t, 3*sqrt(cbQ/(epsilon + cbS)));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageR)) {
cbR = pvl->directAnswer[tenGageR][0] =
(5.0f*cbA*cbB - 27.0f*cbC - 2.0f*cbA*cbS)/54.0f;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTheta)) {
cbQQQ = cbQ*cbQ*cbQ;
tmp0 = AIR_CAST(gage_t, cbR/(epsilon + sqrt(cbQQQ)));
tmp0 = AIR_CLAMP(-1.0f, tmp0, 1.0f);
pvl->directAnswer[tenGageTheta][0] = AIR_CAST(gage_t, acos(tmp0)/AIR_PI);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageEvec)) {
/* we do the longer process to get eigenvectors, and in the process
we always find the eigenvalues, whether or not they were asked for */
#if GAGE_TYPE_FLOAT
tenEigensolve_f(evalAns, evecAns, tenAns);
#else
tenEigensolve_d(evalAns, evecAns, tenAns);
#endif
} else if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageEval)) {
/* else eigenvectors are NOT needed, but eigenvalues ARE needed */
#if GAGE_TYPE_FLOAT
tenEigensolve_f(evalAns, NULL, tenAns);
#else
tenEigensolve_d(evalAns, NULL, tenAns);
#endif
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTensorGrad)) {
/* done if doD1 */
/* still have to set up pointer variables that item answers
below will rely on as short-cuts */
vecTmp = pvl->directAnswer[tenGageTensorGrad];
gradDtA = vecTmp + 1*3;
gradDtB = vecTmp + 2*3;
gradDtC = vecTmp + 3*3;
gradDtD = vecTmp + 4*3;
gradDtE = vecTmp + 5*3;
gradDtF = vecTmp + 6*3;
TEN_T_SET(gradDdXYZ + 0*7, tenAns[0],
gradDtA[0], gradDtB[0], gradDtC[0],
gradDtD[0], gradDtE[0],
gradDtF[0]);
TEN_T_SET(gradDdXYZ + 1*7, tenAns[0],
gradDtA[1], gradDtB[1], gradDtC[1],
gradDtD[1], gradDtE[1],
gradDtF[1]);
TEN_T_SET(gradDdXYZ + 2*7, tenAns[0],
gradDtA[2], gradDtB[2], gradDtC[2],
gradDtD[2], gradDtE[2],
gradDtF[2]);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTensorGradMag)) {
vecTmp = pvl->directAnswer[tenGageTensorGradMag];
vecTmp[0] = AIR_CAST(gage_t, sqrt(TEN_T_DOT(gradDdXYZ + 0*7,
gradDdXYZ + 0*7)));
vecTmp[1] = AIR_CAST(gage_t, sqrt(TEN_T_DOT(gradDdXYZ + 1*7,
gradDdXYZ + 1*7)));
vecTmp[2] = AIR_CAST(gage_t, sqrt(TEN_T_DOT(gradDdXYZ + 2*7,
gradDdXYZ + 2*7)));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTensorGradMag)) {
pvl->directAnswer[tenGageTensorGradMagMag][0] =
AIR_CAST(gage_t, ELL_3V_LEN(vecTmp));
}
/* --- Trace --- */
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTraceGradVec)) {
vecTmp = pvl->directAnswer[tenGageTraceGradVec];
ELL_3V_ADD3(vecTmp, gradDtA, gradDtD, gradDtF);
ELL_3V_SCALE(gradCbA, -1, vecTmp);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTraceGradMag)) {
magTmp = pvl->directAnswer[tenGageTraceGradMag][0] =
AIR_CAST(gage_t, ELL_3V_LEN(vecTmp));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageTraceNormal)) {
ELL_3V_SCALE(pvl->directAnswer[tenGageTraceNormal],
1.0f/(epsilon + magTmp), vecTmp);
}
/* --- B --- */
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageBGradVec)) {
gradCbB = vecTmp = pvl->directAnswer[tenGageBGradVec];
ELL_3V_SCALE_ADD6(vecTmp,
dtD + dtF, gradDtA,
-2.0f*dtB, gradDtB,
-2.0f*dtC, gradDtC,
dtA + dtF, gradDtD,
-2.0f*dtE, gradDtE,
dtA + dtD, gradDtF);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageBGradMag)) {
magTmp = pvl->directAnswer[tenGageBGradMag][0] =
AIR_CAST(gage_t, ELL_3V_LEN(vecTmp));
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageBNormal)) {
ELL_3V_SCALE(pvl->directAnswer[tenGageBNormal],
1.0f/(epsilon + magTmp), vecTmp);
}
/* --- Det --- */
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageDetGradVec)) {
vecTmp = pvl->directAnswer[tenGageDetGradVec];
ELL_3V_SCALE_ADD6(vecTmp,
dtD*dtF - dtE*dtE, gradDtA,
2.0f*(dtC*dtE - dtB*dtF), gradDtB,
2.0f*(dtB*dtE - dtC*dtD), gradDtC,
dtA*dtF - dtC*dtC, gradDtD,
2.0f*(dtB*dtC - dtA*dtE), gradDtE,
dtA*dtD - dtB*dtB, gradDtF);
ELL_3V_SCALE(gradCbC, -1, vecTmp);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, tenGageDetGradMag)) {
magTmp = pvl->directAnswer[tenGageDetGradMag][0] =
AIR_CAST(float, ELL_3V_LEN(vecTmp));
}
/*
******** tenFiberTraceSet
**
** slightly more flexible API for fiber tracking than tenFiberTrace
**
** EITHER: pass a non-NULL nfiber, and NULL, 0, NULL, NULL for
** the following arguments, and things are the same as with tenFiberTrace:
** data inside the nfiber is allocated, and the tract vertices are copied
** into it, having been stored in dynamically allocated airArrays
**
** OR: pass a NULL nfiber, and a buff allocated for 3*(2*halfBuffLen + 1)
** (note the "+ 1" !!!) doubles. The fiber tracking on each half will stop
** at halfBuffLen points. The given seedpoint will be stored in
** buff[0,1,2 + 3*halfBuffLen]. The indices for the end of the first
** tract half, and the end of the second tract half, will be set in
** *startIdxP and *endIdxP respectively.
*/
int
tenFiberTraceSet(tenFiberContext *tfx, Nrrd *nfiber,
double *buff, unsigned int halfBuffLen,
unsigned int *startIdxP, unsigned int *endIdxP,
double seed[3]) {
char me[]="tenFiberTraceSet", err[BIFF_STRLEN];
airArray *fptsArr[2]; /* airArrays of backward (0) and forward (1)
fiber points */
double *fpts[2]; /* arrays storing forward and backward
fiber points */
double
tmp[3],
iPos[3],
currPoint[3],
forwDir[3],
*fiber; /* array of both forward and backward points,
when finished */
int ret, whyStop, buffIdx, fptsIdx, outIdx, oldStop;
unsigned int i;
airArray *mop;
if (!(tfx)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
/* HEY: a hack to preserve the state inside tenFiberContext so that
we have fewer side effects (tfx->maxNumSteps may still be set) */
oldStop = tfx->stop;
if (!nfiber) {
if (!( buff && halfBuffLen > 0 && startIdxP && startIdxP )) {
sprintf(err, "%s: need either non-NULL nfiber or fpts buffer info", me);
biffAdd(TEN, err); return 1;
}
if (tenFiberStopSet(tfx, tenFiberStopNumSteps, halfBuffLen)) {
sprintf(err, "%s: error setting new fiber stop", me);
biffAdd(TEN, err); return 1;
}
}
/* initialize the quantities which describe the fiber halves */
tfx->halfLen[0] = tfx->halfLen[1] = 0.0;
tfx->numSteps[0] = tfx->numSteps[1] = 0;
tfx->whyStop[0] = tfx->whyStop[1] = tenFiberStopUnknown;
/* try probing once */
if (tfx->useIndexSpace) {
ret = gageProbe(tfx->gtx,
AIR_CAST(gage_t, seed[0]),
AIR_CAST(gage_t, seed[1]),
AIR_CAST(gage_t, seed[2]));
} else {
gageShapeWtoI(tfx->gtx->shape, tmp, seed);
ret = gageProbe(tfx->gtx,
AIR_CAST(gage_t, tmp[0]),
AIR_CAST(gage_t, tmp[1]),
AIR_CAST(gage_t, tmp[2]));
}
if (ret) {
sprintf(err, "%s: first gageProbe failed: %s (%d)",
me, tfx->gtx->errStr, tfx->gtx->errNum);
biffAdd(TEN, err); return 1;
}
/* see if we're doomed */
if ((whyStop = _tenFiberStopCheck(tfx))) {
/* stopped immediately at seed point, but that's not an error */
tfx->whyNowhere = whyStop;
if (nfiber) {
nrrdEmpty(nfiber);
} else {
*startIdxP = *endIdxP = 0;
}
return 0;
} else {
/* did not immediately halt */
tfx->whyNowhere = tenFiberStopUnknown;
}
/* record the principal eigenvector at the seed point, which
is needed to align the 4 intermediate steps of RK4 for the
FIRST step of each half of the tract */
ELL_3V_COPY(tfx->firstEvec, tfx->evec + 3*0);
/* airMop{Error,Okay}() can safely be called on NULL */
mop = nfiber ? airMopNew() : NULL;
for (tfx->dir=0; tfx->dir<=1; tfx->dir++) {
if (nfiber) {
fptsArr[tfx->dir] = airArrayNew((void**)&(fpts[tfx->dir]), NULL,
3*sizeof(double), TEN_FIBER_INCR);
airMopAdd(mop, fptsArr[tfx->dir], (airMopper)airArrayNuke, airMopAlways);
buffIdx = -1;
} else {
fptsArr[tfx->dir] = NULL;
fpts[tfx->dir] = NULL;
buffIdx = halfBuffLen;
fptsIdx = -1;
}
tfx->halfLen[tfx->dir] = 0;
if (tfx->useIndexSpace) {
ELL_3V_COPY(iPos, seed);
gageShapeItoW(tfx->gtx->shape, tfx->wPos, iPos);
} else {
gageShapeWtoI(tfx->gtx->shape, iPos, seed);
ELL_3V_COPY(tfx->wPos, seed);
}
ELL_3V_SET(tfx->lastDir, 0, 0, 0);
tfx->lastDirSet = AIR_FALSE;
for (tfx->numSteps[tfx->dir] = 0; AIR_TRUE; tfx->numSteps[tfx->dir]++) {
if (_tenFiberProbe(tfx, tfx->wPos)) {
/* even if gageProbe had an error OTHER than going out of bounds,
we're not going to report it any differently here, alas */
tfx->whyStop[tfx->dir] = tenFiberStopBounds;
break;
}
if ((whyStop = _tenFiberStopCheck(tfx))) {
if (tenFiberStopNumSteps == whyStop) {
/* we stopped along this direction because tfx->numSteps[tfx->dir]
exceeded tfx->maxNumSteps. Okay. But tfx->numSteps[tfx->dir]
is supposed to be a record of how steps were (successfully)
taken. So we need to decrementing before moving on ... */
tfx->numSteps[tfx->dir]--;
}
tfx->whyStop[tfx->dir] = whyStop;
break;
}
if (tfx->useIndexSpace) {
gageShapeWtoI(tfx->gtx->shape, iPos, tfx->wPos);
ELL_3V_COPY(currPoint, iPos);
} else {
ELL_3V_COPY(currPoint, tfx->wPos);
}
if (nfiber) {
fptsIdx = airArrayLenIncr(fptsArr[tfx->dir], 1);
ELL_3V_COPY(fpts[tfx->dir] + 3*fptsIdx, currPoint);
} else {
ELL_3V_COPY(buff + 3*buffIdx, currPoint);
/*
fprintf(stderr, "!%s: (dir %d) saving to %d pnt %g %g %g\n", me,
tfx->dir, buffIdx,
currPoint[0], currPoint[1], currPoint[2]);
*/
buffIdx += !tfx->dir ? -1 : 1;
}
/* forwDir is set by this to point to the next fiber point */
if (_tenFiberIntegrate[tfx->intg](tfx, forwDir)) {
tfx->whyStop[tfx->dir] = tenFiberStopBounds;
break;
}
ELL_3V_COPY(tfx->lastDir, forwDir);
tfx->lastDirSet = AIR_TRUE;
ELL_3V_ADD2(tfx->wPos, tfx->wPos, forwDir);
tfx->halfLen[tfx->dir] += ELL_3V_LEN(forwDir);
}
}
if (nfiber) {
if (nrrdMaybeAlloc_va(nfiber, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, (fptsArr[0]->len
+ fptsArr[1]->len - 1)))) {
sprintf(err, "%s: couldn't allocate fiber nrrd", me);
biffMove(TEN, err, NRRD); airMopError(mop); return 1;
}
fiber = (double*)(nfiber->data);
outIdx = 0;
for (i=fptsArr[0]->len-1; i>=1; i--) {
ELL_3V_COPY(fiber + 3*outIdx, fpts[0] + 3*i);
outIdx++;
}
for (i=0; i<=fptsArr[1]->len-1; i++) {
ELL_3V_COPY(fiber + 3*outIdx, fpts[1] + 3*i);
outIdx++;
}
} else {
*startIdxP = halfBuffLen - tfx->numSteps[0];
*endIdxP = halfBuffLen + tfx->numSteps[1];
}
tfx->stop = oldStop;
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
gageKind *kind;
char *me, *outS, *whatS, *err, hackKeyStr[]="TEEM_VPROBE_HACK_ZI",
*hackValStr, *stackSavePath;
hestParm *hparm;
hestOpt *hopt = NULL;
NrrdKernelSpec *k00, *k11, *k22, *kSS, *kSSblur;
int what, E=0, otype, renorm, hackSet, SSrenorm, SSuniform, verbose;
unsigned int iBaseDim, oBaseDim, axi, numSS, ninSSIdx, seed;
const double *answer;
Nrrd *nin, *nout, **ninSS=NULL;
Nrrd *ngrad=NULL, *nbmat=NULL;
size_t ai, ansLen, idx, xi, yi, zi, six, siy, siz, sox, soy, soz;
double bval=0, gmc, rangeSS[2], wrlSS, idxSS=AIR_NAN, *scalePos;
gageContext *ctx;
gagePerVolume *pvl=NULL;
double t0, t1, x, y, z, scale[3], rscl[3], min[3], maxOut[3], maxIn[3];
airArray *mop;
unsigned int hackZi, *skip, skipNum;
double (*ins)(void *v, size_t I, double d);
mop = airMopNew();
me = argv[0];
hparm = hestParmNew();
airMopAdd(mop, hparm, AIR_CAST(airMopper, hestParmFree), airMopAlways);
hparm->elideSingleOtherType = AIR_TRUE;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", "
"\"tensor\", or \"dwi\")",
NULL, NULL, &probeKindHestCB);
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1, &verbose, "1",
"verbosity level");
hestOptAdd(&hopt, "q", "query", airTypeString, 1, 1, &whatS, NULL,
"the quantity (scalar, vector, or matrix) to learn by probing");
hestOptAdd(&hopt, "s", "sclX sclY sxlZ", airTypeDouble, 3, 3, scale,
"1.0 1.0 1.0",
"scaling factor for resampling on each axis "
"(>1.0 : supersampling)");
hestOptAdd(&hopt, "k00", "kern00", airTypeOther, 1, 1, &k00,
"tent", "kernel for gageKernel00",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k11", "kern11", airTypeOther, 1, 1, &k11,
"cubicd:1,0", "kernel for gageKernel11",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "k22", "kern22", airTypeOther, 1, 1, &k22,
"cubicdd:1,0", "kernel for gageKernel22",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "seed", "N", airTypeUInt, 1, 1, &seed, "42",
"RNG seed; mostly for debugging");
hestOptAdd(&hopt, "ssn", "SS #", airTypeUInt, 1, 1, &numSS,
"0", "how many scale-space samples to evaluate, or, "
"0 to turn-off all scale-space behavior");
hestOptAdd(&hopt, "ssr", "scale range", airTypeDouble, 2, 2, rangeSS,
"nan nan", "range of scales in scale-space");
hestOptAdd(&hopt, "sss", "scale save path", airTypeString, 1, 1,
&stackSavePath, "",
"give a non-empty path string (like \"./\") to save out "
"the pre-blurred volumes computed for the stack");
hestOptAdd(&hopt, "ssw", "SS pos", airTypeDouble, 1, 1, &wrlSS, "0",
"\"world\"-space position (true sigma) "
"at which to sample in scale-space");
hestOptAdd(&hopt, "kssblur", "kernel", airTypeOther, 1, 1, &kSSblur,
"dgauss:1,5", "blurring kernel, to sample scale space",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "kss", "kernel", airTypeOther, 1, 1, &kSS,
"tent", "kernel for reconstructing from scale space samples",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "ssrn", "ssrn", airTypeInt, 1, 1, &SSrenorm, "0",
"enable derivative normalization based on scale space");
hestOptAdd(&hopt, "ssu", NULL, airTypeInt, 0, 0, &SSuniform, NULL,
"do uniform samples along sigma, and not (by default) "
"samples according to the logarithm of diffusion time");
hestOptAdd(&hopt, "rn", NULL, airTypeInt, 0, 0, &renorm, NULL,
"renormalize kernel weights at each new sample location. "
"\"Accurate\" kernels don't need this; doing it always "
"makes things go slower");
hestOptAdd(&hopt, "gmc", "min gradmag", airTypeDouble, 1, 1, &gmc,
"0.0", "For curvature-based queries, use zero when gradient "
"magnitude is below this");
hestOptAdd(&hopt, "t", "type", airTypeEnum, 1, 1, &otype, "float",
"type of output volume", NULL, nrrdType);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output volume");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, probeInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestOptFree), airMopAlways);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestParseFree), airMopAlways);
what = airEnumVal(kind->enm, whatS);
if (!what) {
/* 0 indeed always means "unknown" for any gageKind */
fprintf(stderr, "%s: couldn't parse \"%s\" as measure of \"%s\" volume\n",
me, whatS, kind->name);
hestUsage(stderr, hopt, me, hparm);
hestGlossary(stderr, hopt, hparm);
airMopError(mop);
return 1;
}
/* special set-up required for DWI kind */
if (!strcmp(TEN_DWI_GAGE_KIND_NAME, kind->name)) {
if (tenDWMRIKeyValueParse(&ngrad, &nbmat, &bval, &skip, &skipNum, nin)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (skipNum) {
fprintf(stderr, "%s: sorry, can't do DWI skipping in tenDwiGage", me);
airMopError(mop); return 1;
}
/* this could stand to use some more command-line arguments */
if (tenDwiGageKindSet(kind, 50, 1, bval, 0.001, ngrad, nbmat,
tenEstimate1MethodLLS,
tenEstimate2MethodQSegLLS, seed)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble parsing DWI info:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* for setting up pre-blurred scale-space samples */
if (numSS) {
unsigned int vi;
ninSS = AIR_CAST(Nrrd **, calloc(numSS, sizeof(Nrrd *)));
scalePos = AIR_CAST(double *, calloc(numSS, sizeof(double)));
if (!(ninSS && scalePos)) {
fprintf(stderr, "%s: couldn't allocate ninSS", me);
airMopError(mop); return 1;
}
for (ninSSIdx=0; ninSSIdx<numSS; ninSSIdx++) {
ninSS[ninSSIdx] = nrrdNew();
airMopAdd(mop, ninSS[ninSSIdx], (airMopper)nrrdNuke, airMopAlways);
}
if (SSuniform) {
for (vi=0; vi<numSS; vi++) {
scalePos[vi] = AIR_AFFINE(0, vi, numSS-1, rangeSS[0], rangeSS[1]);
}
} else {
double rangeTau[2], tau;
rangeTau[0] = gageTauOfSig(rangeSS[0]);
rangeTau[1] = gageTauOfSig(rangeSS[1]);
for (vi=0; vi<numSS; vi++) {
tau = AIR_AFFINE(0, vi, numSS-1, rangeTau[0], rangeTau[1]);
scalePos[vi] = gageSigOfTau(tau);
}
}
if (verbose > 2) {
fprintf(stderr, "%s: sampling scale range %g--%g %suniformly:\n", me,
rangeSS[0], rangeSS[1], SSuniform ? "" : "non-");
for (vi=0; vi<numSS; vi++) {
fprintf(stderr, " scalePos[%u] = %g\n", vi, scalePos[vi]);
}
}
if (gageStackBlur(ninSS, scalePos, numSS,
nin, kind->baseDim, kSSblur,
nrrdBoundaryBleed, AIR_TRUE,
verbose)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble pre-computing blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
if (airStrlen(stackSavePath)) {
char fnform[AIR_STRLEN_LARGE];
sprintf(fnform, "%s/blur-%%02u.nrrd", stackSavePath);
fprintf(stderr, "%s: |%s|\n", me, fnform);
if (nrrdSaveMulti(fnform, AIR_CAST(const Nrrd *const *, ninSS),
numSS, 0, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble saving blurrings:\n%s\n", me, err);
airMopError(mop); return 1;
}
}
/* there's actually work to do here, weirdly: gageProbe can either
work in index space, or in world space, but vprobe has
basically always been index-space-centric. For doing any kind
scale/stack space hacking for which vprobe is suited, its nicer
to have the stack position be in the stack's "world" space, not
the (potentially non-uniform) index space. So here, we have to
actually replicate work that is done by _gageProbeSpace() in
converting from world to index space */
for (vi=0; vi<numSS-1; vi++) {
if (AIR_IN_CL(scalePos[vi], wrlSS, scalePos[vi+1])) {
idxSS = vi + AIR_AFFINE(scalePos[vi], wrlSS, scalePos[vi+1], 0, 1);
if (verbose > 1) {
fprintf(stderr, "%s: scale pos %g -> idx %g = %u + %g\n", me,
wrlSS, idxSS, vi,
AIR_AFFINE(scalePos[vi], wrlSS, scalePos[vi+1], 0, 1));
}
break;
}
}
if (vi == numSS-1) {
fprintf(stderr, "%s: scale pos %g outside range %g=%g, %g=%g\n", me,
wrlSS, rangeSS[0], scalePos[0], rangeSS[1], scalePos[numSS-1]);
airMopError(mop); return 1;
}
} else {
int
doit(Nrrd *nout, Nrrd *nin, int smart, float amount) {
static const char me[]="doit";
Nrrd *nproj[3];
airArray *mop;
int axis, srl, sap, ssi, E, margin, which;
size_t min[3];
if (!(nout && nin)) {
biffAddf(NINSPECT, "%s: got NULL pointer", me);
return 1;
}
if (!(3 == nin->dim)) {
biffAddf(NINSPECT, "%s: given nrrd has dimension %d, not 3\n",
me, nin->dim);
return 1;
}
mop = airMopNew();
airMopAdd(mop, nproj[0]=nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nproj[1]=nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nproj[2]=nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
/* how much space to put between and around the projections */
margin = 6;
/* do projections for each axis, with some progress indication to sterr */
for (axis=0; axis<=2; axis++) {
fprintf(stderr, "%s: doing axis %d projections ... ", me, axis);
fflush(stderr);
if (ninspect_proj(nproj[axis], nin, axis, smart, amount)) {
fprintf(stderr, "ERROR\n");
biffAddf(NINSPECT, "%s: trouble doing projections for axis %d",
me, axis);
airMopError(mop); return 1;
}
fprintf(stderr, "done\n");
}
if (nrrdSpaceRightAnteriorSuperior == nin->space) {
if (fixproj(nproj, nin)) {
fprintf(stderr, "ERROR\n");
biffAddf(NINSPECT, "%s: trouble orienting projections", me);
airMopError(mop); return 1;
}
}
srl = nproj[1]->axis[0+1].size;
sap = nproj[0]->axis[0+1].size;
ssi = nproj[1]->axis[1+1].size;
/* allocate output as 8-bit color image. We know output type is
nrrdTypeUChar because ninspect_proj finishes each projection
with nrrdQuantize to 8-bits */
if (nrrdMaybeAlloc_va(nout, nrrdTypeUChar, 3,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, srl + 3*margin + sap),
AIR_CAST(size_t, ssi + 3*margin + sap))) {
biffMovef(NINSPECT, NRRD, "%s: couldn't allocate output", me);
airMopError(mop); return 1;
}
min[0] = 0;
E = 0;
which = 0;
if (!E) { min[1] = margin; min[2] = margin; which = 1; }
if (!E) E |= nrrdInset(nout, nout, nproj[1], min);
if (!E) { min[1] = margin; min[2] = 2*margin + ssi; which = 2; }
if (!E) E |= nrrdInset(nout, nout, nproj[2], min);
if (!E) { min[1] = 2*margin + srl; min[2] = margin; which = 3; }
if (!E) E |= nrrdInset(nout, nout, nproj[0], min);
if (E) {
biffAddf(NINSPECT, NRRD, "%s: couldn't composite output (which = %d)",
me, which);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
const char *me;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
char *err, *outS;
double sigmaMax, convEps, cutoff;
int measr[2], tentRecon;
unsigned int sampleNumMax, dim, measrSampleNum, maxIter, num, ii;
gageOptimSigParm *osparm;
double *scalePos, *out, info[512];
Nrrd *nout;
double *plotPos; unsigned int plotPosNum;
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, "num", "# samp", airTypeUInt, 1, 1, &sampleNumMax, NULL,
"maximum number of samples to optimize");
hestOptAdd(&hopt, "dim", "dimension", airTypeUInt, 1, 1, &dim, "3",
"dimension of image to work with");
hestOptAdd(&hopt, "max", "sigma", airTypeDouble, 1, 1, &sigmaMax, NULL,
"sigma to use for top sample (using 0 for bottom sample)");
hestOptAdd(&hopt, "cut", "cut", airTypeDouble, 1, 1, &cutoff, "4",
"at how many sigmas to cut-off discrete gaussian");
hestOptAdd(&hopt, "mi", "max", airTypeUInt, 1, 1, &maxIter, "1000",
"maximum # iterations");
hestOptAdd(&hopt, "N", "# samp", airTypeUInt, 1, 1, &measrSampleNum, "300",
"number of samples in the measurement of error across scales");
hestOptAdd(&hopt, "eps", "eps", airTypeDouble, 1, 1, &convEps, "0.0001",
"convergence threshold for optimization");
hestOptAdd(&hopt, "m", "m1 m2", airTypeEnum, 2, 2, measr, "l2 l2",
"how to measure error across image, and across scales",
NULL, nrrdMeasure);
hestOptAdd(&hopt, "p", "s0 s1", airTypeDouble, 2, -1, &plotPos, "nan nan",
"hack: dont do optimization; just plot the recon error given "
"these samples along scale", &plotPosNum);
hestOptAdd(&hopt, "tent", NULL, airTypeInt, 0, 0, &tentRecon, NULL,
"same hack: plot error with tent recon, not hermite");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, NULL,
"output array");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, optsigInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
osparm = gageOptimSigParmNew(sampleNumMax);
airMopAdd(mop, osparm, AIR_CAST(airMopper, gageOptimSigParmNix),
airMopAlways);
scalePos = AIR_CAST(double *, calloc(sampleNumMax, sizeof(double)));
airMopAdd(mop, scalePos, airFree, airMopAlways);
osparm->plotting = (AIR_EXISTS(plotPos[0]) && AIR_EXISTS(plotPos[1]));
if (gageOptimSigTruthSet(osparm, dim, sigmaMax, cutoff, measrSampleNum)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s", me, err);
airMopError(mop); return 1;
}
if (osparm->plotting) {
if (gageOptimSigPlot(osparm, nout, plotPos, plotPosNum,
measr[0], tentRecon)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s", me, err);
airMopError(mop); return 1;
}
} else {
/* do sample position optimization */
if (nrrdMaybeAlloc_va(nout, nrrdTypeDouble, 2,
AIR_CAST(size_t, sampleNumMax+1),
AIR_CAST(size_t, sampleNumMax+1))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating output:\n%s", me, err);
airMopError(mop); return 1;
}
out = AIR_CAST(double *, nout->data);
/* hacky way of saving some of the computation information */
info[0] = cutoff;
info[1] = measrSampleNum;
info[2] = measr[0];
info[3] = measr[1];
info[4] = convEps;
info[5] = maxIter;
for (ii=0; ii<sampleNumMax+1; ii++) {
out[ii] = info[ii];
}
for (num=2; num<=sampleNumMax; num++) {
printf("\n%s: ======= optimizing %u/%u samples (sigmaMax %g) \n\n",
me, num, sampleNumMax, sigmaMax);
if (gageOptimSigCalculate(osparm, scalePos, num,
measr[0], measr[1],
convEps, maxIter)) {
airMopAdd(mop, err = biffGetDone(GAGE), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s", me, err);
airMopError(mop); return 1;
}
out[sampleNumMax + (sampleNumMax+1)*num] = osparm->finalErr;
for (ii=0; ii<num; ii++) {
out[ii + (sampleNumMax+1)*num] = scalePos[ii];
}
}
}
if (nrrdSave(outS, nout, 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);
exit(0);
}
int
unrrdu_acropMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *out, *err;
Nrrd *nin, *nout;
int pret;
airArray *mop;
size_t min[NRRD_DIM_MAX], max[NRRD_DIM_MAX];
unsigned int *axes, axesLen;
double frac;
int measr, offset;
Nrrd *nbounds;
char *boundsSave;
hestOptAdd(&opt, "a,axes", "ax0", airTypeUInt, 0, -1, &axes, "",
"the axes (if any) that should NOT be cropped", &axesLen);
hestOptAdd(&opt, "m,measure", "measr", airTypeEnum, 1, 1, &measr, NULL,
"How to measure slices (along axes to crop) as scalars, "
"to form 1-D array analyzed to determine cropping extent. "
"All the measures from \"unu project\" can be used, but "
"those that make more sense here include:\n "
"\b\bo \"max\", \"mean\", \"median\", "
"\"variance\": (self-explanatory)\n "
"\b\bo \"stdv\": standard deviation\n "
"\b\bo \"cov\": coefficient of variation\n "
"\b\bo \"product\", \"sum\": product or sum of all values\n "
"\b\bo \"L1\", \"L2\", \"NL2\", \"RMS\", \"Linf\": "
"different norms.", NULL, nrrdMeasure);
hestOptAdd(&opt, "f,frac", "frac", airTypeDouble, 1, 1, &frac, "0.1",
"threshold of cumulative sum of 1-D array at which to crop. "
"Needs to be in interval [0.0,0.5).");
hestOptAdd(&opt, "off,offset", "offset", airTypeInt, 1, 1, &offset, "1",
"how much to offset the numerically determined cropping; "
"positive offsets means expanding the interval of kept "
"indices (less cropping)");
hestOptAdd(&opt, "b,bounds", "filename", airTypeString, 1, 1,
&boundsSave, "",
"if a filename is given here, the automatically determined "
"min and max bounds for cropping are saved to this file "
"as a 2-D array; first scanline is for -min, second is for -max. "
"Unfortunately nothing using the \"m\" and \"M\" semantics "
"(above) can currently be saved in the bounds file.");
OPT_ADD_NIN(nin, "input nrrd");
OPT_ADD_NOUT(out, "output nrrd");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_acropInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCropAuto(nout, nin, min, max,
axes, axesLen,
measr, frac, offset)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error cropping nrrd:\n%s", me, err);
airMopError(mop);
return 1;
}
if (airStrlen(boundsSave)) {
unsigned int axi;
airULLong *bounds;
nbounds = nrrdNew();
airMopAdd(mop, nbounds, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(nbounds, nrrdTypeULLong, 2,
AIR_CAST(airULLong, nin->dim),
AIR_CAST(airULLong, 2))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error allocating cropping bounds array:\n%s",
me, err);
airMopError(mop);
return 1;
}
bounds = AIR_CAST(airULLong*, nbounds->data);
for (axi=0; axi<nin->dim; axi++) {
bounds[axi + 0*(nin->dim)] = AIR_CAST(airULLong, min[axi]);
bounds[axi + 1*(nin->dim)] = AIR_CAST(airULLong, max[axi]);
}
if (nrrdSave(boundsSave, nbounds, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error saving cropping bounds array:\n%s",
me, err);
airMopError(mop);
return 1;
}
}
SAVE(out, nout, NULL);
airMopOkay(mop);
return 0;
}
int
tend_evecMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
int ret, *comp, compLen, cc;
Nrrd *nin, *nout;
char *outS;
float thresh, *edata, *tdata, eval[3], evec[9], scl;
size_t N, I, sx, sy, sz;
hestOptAdd(&hopt, "c", "c0 ", airTypeInt, 1, 3, &comp, NULL,
"which eigenvalues should be saved out. \"0\" for the "
"largest, \"1\" for the middle, \"2\" for the smallest, "
"\"0 1\", \"1 2\", \"0 1 2\" or similar for more than one",
&compLen);
hestOptAdd(&hopt, "t", "thresh", airTypeFloat, 1, 1, &thresh, "0.5",
"confidence threshold");
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, "-",
"input diffusion tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output image (floating point)");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_evecInfoL);
PARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
for (cc=0; cc<compLen; cc++) {
if (!AIR_IN_CL(0, comp[cc], 2)) {
fprintf(stderr, "%s: requested component %d (%d of 3) not in [0..2]\n",
me, comp[cc], cc+1);
airMopError(mop); return 1;
}
}
if (tenTensorCheck(nin, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err=biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't get a valid DT volume:\n%s\n", me, err);
airMopError(mop); return 1;
}
sx = nin->axis[1].size;
sy = nin->axis[2].size;
sz = nin->axis[3].size;
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
ret = nrrdMaybeAlloc_va(nout, nrrdTypeFloat, 4,
AIR_CAST(size_t, 3*compLen), sx, sy, sz);
if (ret) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating output:\n%s\n", me, err);
airMopError(mop); return 1;
}
N = sx*sy*sz;
edata = (float *)nout->data;
tdata = (float *)nin->data;
if (1 == compLen) {
for (I=0; I<N; I++) {
tenEigensolve_f(eval, evec, tdata);
scl = AIR_CAST(float, tdata[0] >= thresh);
ELL_3V_SCALE(edata, scl, evec+3*comp[0]);
edata += 3;
tdata += 7;
}
} else {
for (I=0; I<N; I++) {
/*
******** limnCameraPathMake
**
** uses limnSplines to do camera paths based on key-frames
**
** output: cameras at all "numFrames" frames are set in the
** PRE-ALLOCATED array of output cameras, "cam".
**
** input:
** keycam: array of keyframe cameras
** time: times associated with the key frames
** ---> both of these arrays are length "numKeys" <---
** trackWhat: takes values from the limnCameraPathTrack* enum
** quatType: spline to control camera orientations. This is needed for
** tracking at or from, but not needed for limnCameraPathTrackBoth.
** This is the only limnSplineTypeSpec* argument that can be NULL.
** posType: spline to control whichever of from, at, and up are needed for
** the given style of tracking.
** distType: spline to control neer, faar, dist: positions of near clipping,
** far clipping, and image plane, as well as the
** distance between from and at (which is used if not doing
** limnCameraPathTrackBoth)
** viewType: spline to control fov (and aspect, if you're crazy)
**
** NOTE: The "atRelative", "orthographic", and "rightHanded" fields
** are copied from keycam[0] into all output cam[i], but you still need
** to correctly set them for all keycam[i] for limnCameraUpdate to work
** as expected. Also, for the sake of simplicity, this function only works
** with fov and aspect, instead of {u,v}Range, and hence both "fov" and
** "aspect" need to set in *all* the keycams, even if neither of them
** ever changes!
*/
int
limnCameraPathMake(limnCamera *cam, int numFrames,
limnCamera *keycam, double *time, int numKeys,
int trackWhat,
limnSplineTypeSpec *quatType,
limnSplineTypeSpec *posType,
limnSplineTypeSpec *distType,
limnSplineTypeSpec *viewType) {
static const char me[]="limnCameraPathMake";
char which[AIR_STRLEN_MED];
airArray *mop;
Nrrd *nquat, *nfrom, *natpt, *nupvc, *ndist, *nfova, *ntime, *nsample;
double fratVec[3], *quat, *from, *atpt, *upvc, *dist, *fova,
W2V[9], N[3], fratDist;
limnSpline *timeSpline, *quatSpline, *fromSpline, *atptSpline, *upvcSpline,
*distSpline, *fovaSpline;
limnSplineTypeSpec *timeType;
int ii, E;
if (!( cam && keycam && time && posType && distType && viewType )) {
biffAddf(LIMN, "%s: got NULL pointer", me);
return 1;
}
if (!( AIR_IN_OP(limnCameraPathTrackUnknown, trackWhat,
limnCameraPathTrackLast) )) {
biffAddf(LIMN, "%s: trackWhat %d not in valid range [%d,%d]", me,
trackWhat, limnCameraPathTrackUnknown+1,
limnCameraPathTrackLast-1);
return 1;
}
if (limnCameraPathTrackBoth != trackWhat && !quatType) {
biffAddf(LIMN, "%s: need the quaternion limnSplineTypeSpec if not "
"doing trackBoth", me);
return 1;
}
/* create and allocate nrrds. For the time being, we're allocating
more different nrrds, and filling their contents, than we need
to-- nquat is not needed if we're doing limnCameraPathTrackBoth,
for example. However, we do make an effort to only do the spline
evaluation on the things we actually need to know. */
mop = airMopNew();
airMopAdd(mop, nquat = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nfrom = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, natpt = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nupvc = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ndist = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nfova = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ntime = nrrdNew(), (airMopper)nrrdNix, airMopAlways);
if (nrrdWrap_va(ntime, time, nrrdTypeDouble, 1,
AIR_CAST(size_t, numKeys))) {
biffMovef(LIMN, NRRD, "%s: trouble wrapping time values", me);
airMopError(mop); return 1;
}
airMopAdd(mop, nsample = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
timeType = limnSplineTypeSpecNew(limnSplineTypeTimeWarp);
airMopAdd(mop, timeType, (airMopper)limnSplineTypeSpecNix, airMopAlways);
if (nrrdMaybeAlloc_va(nquat, nrrdTypeDouble, 2,
AIR_CAST(size_t, 4), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(nfrom, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(natpt, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(nupvc, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(ndist, nrrdTypeDouble, 2,
AIR_CAST(size_t, 4), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(nfova, nrrdTypeDouble, 2,
AIR_CAST(size_t, 2), AIR_CAST(size_t, numKeys))) {
biffMovef(LIMN, NRRD, "%s: couldn't allocate buffer nrrds", me);
airMopError(mop); return 1;
}
quat = (double*)(nquat->data);
from = (double*)(nfrom->data);
atpt = (double*)(natpt->data);
upvc = (double*)(nupvc->data);
dist = (double*)(ndist->data);
fova = (double*)(nfova->data);
/* check cameras, and put camera information into nrrds */
for (ii=0; ii<numKeys; ii++) {
if (limnCameraUpdate(keycam + ii)) {
biffAddf(LIMN, "%s: trouble with camera at keyframe %d\n", me, ii);
airMopError(mop); return 1;
}
if (!( AIR_EXISTS(keycam[ii].fov) && AIR_EXISTS(keycam[ii].aspect) )) {
biffAddf(LIMN, "%s: fov, aspect not both defined on keyframe %d",
me, ii);
airMopError(mop); return 1;
}
ell_4m_to_q_d(quat + 4*ii, keycam[ii].W2V);
if (ii) {
if (0 > ELL_4V_DOT(quat + 4*ii, quat + 4*(ii-1))) {
ELL_4V_SCALE(quat + 4*ii, -1, quat + 4*ii);
}
}
ELL_3V_COPY(from + 3*ii, keycam[ii].from);
ELL_3V_COPY(atpt + 3*ii, keycam[ii].at);
ELL_3V_COPY(upvc + 3*ii, keycam[ii].up);
ELL_3V_SUB(fratVec, keycam[ii].from, keycam[ii].at);
fratDist = ELL_3V_LEN(fratVec);
ELL_4V_SET(dist + 4*ii, fratDist,
keycam[ii].neer, keycam[ii].dist, keycam[ii].faar);
ELL_2V_SET(fova + 2*ii, keycam[ii].fov, keycam[ii].aspect);
}
/* create splines from nrrds */
if (!( (strcpy(which, "quaternion"), quatSpline =
limnSplineCleverNew(nquat, limnSplineInfoQuaternion, quatType))
&& (strcpy(which, "from point"), fromSpline =
limnSplineCleverNew(nfrom, limnSplineInfo3Vector, posType))
&& (strcpy(which, "at point"), atptSpline =
limnSplineCleverNew(natpt, limnSplineInfo3Vector, posType))
&& (strcpy(which, "up vector"), upvcSpline =
limnSplineCleverNew(nupvc, limnSplineInfo3Vector, posType))
&& (strcpy(which, "plane distances"), distSpline =
limnSplineCleverNew(ndist, limnSplineInfo4Vector, distType))
&& (strcpy(which, "field-of-view"), fovaSpline =
limnSplineCleverNew(nfova, limnSplineInfo2Vector, viewType))
&& (strcpy(which, "time warp"), timeSpline =
limnSplineCleverNew(ntime, limnSplineInfoScalar, timeType)) )) {
biffAddf(LIMN, "%s: trouble creating %s spline", me, which);
airMopError(mop); return 1;
}
airMopAdd(mop, quatSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, fromSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, atptSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, upvcSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, distSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, fovaSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, timeSpline, (airMopper)limnSplineNix, airMopAlways);
/* evaluate splines */
E = AIR_FALSE;
if (!E) E |= limnSplineSample(nsample, timeSpline,
limnSplineMinT(timeSpline), numFrames,
limnSplineMaxT(timeSpline));
quat = NULL;
from = NULL;
atpt = NULL;
upvc = NULL;
switch(trackWhat) {
case limnCameraPathTrackAt:
if (!E) E |= limnSplineNrrdEvaluate(natpt, atptSpline, nsample);
if (!E) atpt = (double*)(natpt->data);
if (!E) E |= limnSplineNrrdEvaluate(nquat, quatSpline, nsample);
if (!E) quat = (double*)(nquat->data);
break;
case limnCameraPathTrackFrom:
if (!E) E |= limnSplineNrrdEvaluate(nfrom, fromSpline, nsample);
if (!E) from = (double*)(nfrom->data);
if (!E) E |= limnSplineNrrdEvaluate(nquat, quatSpline, nsample);
if (!E) quat = (double*)(nquat->data);
break;
case limnCameraPathTrackBoth:
if (!E) E |= limnSplineNrrdEvaluate(nfrom, fromSpline, nsample);
if (!E) from = (double*)(nfrom->data);
if (!E) E |= limnSplineNrrdEvaluate(natpt, atptSpline, nsample);
if (!E) atpt = (double*)(natpt->data);
if (!E) E |= limnSplineNrrdEvaluate(nupvc, upvcSpline, nsample);
if (!E) upvc = (double*)(nupvc->data);
break;
}
dist = NULL;
if (!E) E |= limnSplineNrrdEvaluate(ndist, distSpline, nsample);
if (!E) dist = (double*)(ndist->data);
fova = NULL;
if (!E) E |= limnSplineNrrdEvaluate(nfova, fovaSpline, nsample);
if (!E) fova = (double*)(nfova->data);
if (E) {
biffAddf(LIMN, "%s: trouble evaluating splines", me);
airMopError(mop); return 1;
}
/* copy information from nrrds back into cameras */
for (ii=0; ii<numFrames; ii++) {
cam[ii].atRelative = keycam[0].atRelative;
cam[ii].orthographic = keycam[0].orthographic;
cam[ii].rightHanded = keycam[0].rightHanded;
if (limnCameraPathTrackBoth == trackWhat) {
ELL_3V_COPY(cam[ii].from, from + 3*ii);
ELL_3V_COPY(cam[ii].at, atpt + 3*ii);
ELL_3V_COPY(cam[ii].up, upvc + 3*ii);
} else {
fratDist = (dist + 4*ii)[0];
ell_q_to_3m_d(W2V, quat + 4*ii);
ELL_3MV_ROW1_GET(cam[ii].up, W2V);
if (cam[ii].rightHanded) {
ELL_3V_SCALE(cam[ii].up, -1, cam[ii].up);
}
ELL_3MV_ROW2_GET(N, W2V);
if (limnCameraPathTrackFrom == trackWhat) {
ELL_3V_COPY(cam[ii].from, from + 3*ii);
ELL_3V_SCALE_ADD2(cam[ii].at, 1.0, cam[ii].from, fratDist, N);
} else {
ELL_3V_COPY(cam[ii].at, atpt + 3*ii);
ELL_3V_SCALE_ADD2(cam[ii].from, 1.0, cam[ii].at, -fratDist, N);
}
}
cam[ii].neer = (dist + 4*ii)[1];
cam[ii].dist = (dist + 4*ii)[2];
cam[ii].faar = (dist + 4*ii)[3];
cam[ii].fov = (fova + 2*ii)[0];
cam[ii].aspect = (fova + 2*ii)[1];
if (limnCameraUpdate(cam + ii)) {
biffAddf(LIMN, "%s: trouble with output camera %d\n", me, ii);
airMopError(mop); return 1;
}
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *err;
hestOpt *hopt=NULL;
airArray *mop;
unsigned int sx, sy, sz, ss, ii, anisoTypeNum, anisoTypeIdx,
roiVoxNum, roiVoxIdx, statNum, statIdx;
float *ten, *roi, *aniso, eval[3], *stat;
Nrrd *nten, *_nroi, *nroi, *naniso, *nstat;
int *anisoType, *measr;
size_t anisoSize[2];
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "r,roi", "roi", airTypeOther, 1, 1, &_nroi, NULL,
"ROI volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "i,input", "volume", airTypeOther, 1, 1, &nten, "-",
"tensor volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "a,aniso", "aniso", airTypeEnum, 1, -1, &anisoType, NULL,
"which anisotropy measures to measure",
&anisoTypeNum, tenAniso);
hestOptAdd(&hopt, "m,measr", "measr", airTypeEnum, 1, -1, &measr, NULL,
"which measures/statistics to calculate",
&statNum, nrrdMeasure);
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 (tenTensorCheck(nten, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: didn't get tensor input:\n%s\n", me, err);
airMopError(mop);
return 1;
}
nroi = nrrdNew();
airMopAdd(mop, nroi, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
if (nrrdConvert(nroi, _nroi, nrrdTypeFloat)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't convert ROI to float:\n%s\n", me, err);
airMopError(mop);
return 1;
}
sx = nten->axis[1].size;
sy = nten->axis[2].size;
sz = nten->axis[3].size;
if (!(3 == nroi->dim
&& sx == nroi->axis[0].size
&& sy == nroi->axis[1].size
&& sz == nroi->axis[2].size)) {
fprintf(stderr, "%s: ROI dimension or axis sizes don't match volume", me);
airMopError(mop);
return 1;
}
ss = sx*sy*sz;
ten = AIR_CAST(float*, nten->data);
roi = AIR_CAST(float*, nroi->data);
/* NOTE: for time being the statistics are not weighted, because
nrrdMeasureLine[]() can't take a weight vector... */
/* find number of voxels in ROI */
roiVoxNum = 0;
for (ii=0; ii<ss; ii++) {
roiVoxNum += (roi[ii] > 0);
}
/* fprintf(stderr, "%s: # voxels in ROI == %u\n", me, roiVoxNum); */
/* allocate anisotropy buffers */
naniso = nrrdNew();
airMopAdd(mop, naniso, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
anisoSize[0] = roiVoxNum;
anisoSize[1] = anisoTypeNum;
if (nrrdMaybeAlloc_nva(naniso, nrrdTypeFloat, 2, anisoSize)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate aniso:\n%s\n", me, err);
airMopError(mop);
return 1;
}
aniso = AIR_CAST(float *, naniso->data);
/* store all anisotropies in all ROI voxels */
roiVoxIdx = 0;
for (ii=0; ii<ss; ii++) {
if (roi[ii] > 0) {
tenEigensolve_f(eval, NULL, ten + 7*ii);
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
aniso[roiVoxIdx + roiVoxNum*anisoTypeIdx]
= tenAnisoEval_f(eval, anisoType[anisoTypeIdx]);
}
roiVoxIdx++;
}
}
printf("statistic:");
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
printf(" %s", airEnumStr(tenAniso, anisoType[anisoTypeIdx]));
}
printf("\n");
/* do per-anisotropy statistics */
nstat = nrrdNew();
airMopAdd(mop, nstat, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
for (statIdx=0; statIdx<statNum; statIdx++) {
printf("%s:", airEnumStr(nrrdMeasure, measr[statIdx]));
if (nrrdProject(nstat, naniso, 0, measr[statIdx], nrrdTypeFloat)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't measure:\n%s\n", me, err);
airMopError(mop);
return 1;
}
stat = AIR_CAST(float *, nstat->data);
for (anisoTypeIdx=0; anisoTypeIdx<anisoTypeNum; anisoTypeIdx++) {
printf(" %g", stat[anisoTypeIdx]);
}
printf("\n");
}
airMopOkay(mop);
return 0;
}
/*
******** nrrdSpatialResample()
**
** general-purpose array-resampler: resamples a nrrd of any type
** (except block) and any dimension along any or all of its axes, with
** any combination of up- or down-sampling along the axes, with any
** kernel (specified by callback), with potentially a different kernel
** for each axis. Whether or not to resample along axis d is
** controlled by the non-NULL-ity of info->kernel[ai]. Where to sample
** on the axis is controlled by info->min[ai] and info->max[ai]; these
** specify a range of "positions" aka "world space" positions, as
** determined by the per-axis min and max of the input nrrd, which must
** be set for every resampled axis.
**
** we cyclically permute those axes being resampled, and never touch
** the position (in axis ordering) of axes along which we are not
** resampling. This strategy is certainly not the most intelligent
** one possible, but it does mean that the axis along which we're
** currently resampling-- the one along which we'll have to look at
** multiple adjecent samples-- is that resampling axis which is
** currently most contiguous in memory. It may make sense to precede
** the resampling with an axis permutation which bubbles all the
** resampled axes to the front (most contiguous) end of the axis list,
** and then puts them back in place afterwards, depending on the cost
** of such axis permutation overhead.
*/
int
nrrdSpatialResample(Nrrd *nout, const Nrrd *nin,
const NrrdResampleInfo *info) {
char me[]="nrrdSpatialResample", func[]="resample", err[BIFF_STRLEN];
nrrdResample_t
*array[NRRD_DIM_MAX], /* intermediate copies of the input data
undergoing resampling; we don't need a full-
fledged nrrd for these. Only about two of
these arrays will be allocated at a time;
intermediate results will be free()d when not
needed */
*_inVec, /* current input vector being resampled;
not necessarily contiguous in memory
(if strideIn != 1) */
*inVec, /* buffer for input vector; contiguous */
*_outVec, /* output vector in context of volume;
never contiguous */
tmpF;
double ratio, /* factor by which or up or downsampled */
ratios[NRRD_DIM_MAX]; /* record of "ratio" for all resampled axes,
used to compute new spacing in output */
Nrrd *floatNin; /* if the input nrrd type is not nrrdResample_t,
then we convert it and keep it here */
unsigned int ai,
pi, /* current pass */
topLax,
permute[NRRD_DIM_MAX], /* how to permute axes of last pass to get
axes for current pass */
ax[NRRD_DIM_MAX+1][NRRD_DIM_MAX], /* axis ordering on each pass */
passes; /* # of passes needed to resample all axes */
int i, s, e,
topRax, /* the lowest index of an axis which is
resampled. If all axes are being resampled,
then this is 0. If for some reason the
"x" axis (fastest stride) is not being
resampled, but "y" is, then topRax is 1 */
botRax, /* index of highest axis being resampled */
typeIn, typeOut; /* types of input and output of resampling */
size_t sz[NRRD_DIM_MAX+1][NRRD_DIM_MAX];
/* how many samples along each
axis, changing on each pass */
/* all these variables have to do with the spacing of elements in
memory for the current pass of resampling, and they (except
strideIn) are re-set at the beginning of each pass */
nrrdResample_t
*weight; /* sample weights */
unsigned int ci[NRRD_DIM_MAX+1],
co[NRRD_DIM_MAX+1];
int
sizeIn, sizeOut, /* lengths of input and output vectors */
dotLen, /* # input samples to dot with weights to get
one output sample */
doRound, /* actually do rounding on output: we DO NOT
round when info->round but the output
type is not integral */
*index; /* dotLen*sizeOut 2D array of input indices */
size_t
I, /* swiss-army int */
strideIn, /* the stride between samples in the input
"scanline" being resampled */
strideOut, /* stride between samples in output
"scanline" from resampling */
L, LI, LO, numLines, /* top secret */
numOut; /* # of _samples_, total, in output volume;
this is for allocating the output */
airArray *mop; /* for cleaning up */
if (!(nout && nin && info)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdBoundaryUnknown == info->boundary) {
sprintf(err, "%s: need to specify a boundary behavior", me);
biffAdd(NRRD, err); return 1;
}
typeIn = nin->type;
typeOut = nrrdTypeDefault == info->type ? typeIn : info->type;
if (_nrrdResampleCheckInfo(nin, info)) {
sprintf(err, "%s: problem with arguments", me);
biffAdd(NRRD, err); return 1;
}
_nrrdResampleComputePermute(permute, ax, sz,
&topRax, &botRax, &passes,
nin, info);
topLax = topRax ? 0 : 1;
/* not sure where else to put this:
(want to put it before 0 == passes branch)
We have to assume some centering when doing resampling, and it would
be stupid to not record it in the outgoing nrrd, since the value of
nrrdDefaultCenter could always change. */
for (ai=0; ai<nin->dim; ai++) {
if (info->kernel[ai]) {
nout->axis[ai].center = _nrrdCenter(nin->axis[ai].center);
}
}
if (0 == passes) {
/* actually, no resampling was desired. Copy input to output,
but with the clamping that we normally do at the end of resampling */
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, sz[0]);
if (nrrdMaybeAlloc_nva(nout, typeOut, nin->dim, sz[0])) {
sprintf(err, "%s: couldn't allocate output", me);
biffAdd(NRRD, err); return 1;
}
numOut = nrrdElementNumber(nout);
for (I=0; I<numOut; I++) {
tmpF = nrrdFLookup[nin->type](nin->data, I);
tmpF = nrrdFClamp[typeOut](tmpF);
nrrdFInsert[typeOut](nout->data, I, tmpF);
}
nrrdAxisInfoCopy(nout, nin, NULL, NRRD_AXIS_INFO_NONE);
/* HEY: need to create textual representation of resampling parameters */
if (nrrdContentSet_va(nout, func, nin, "")) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdBasicInfoCopy(nout, nin,
NRRD_BASIC_INFO_DATA_BIT
| NRRD_BASIC_INFO_TYPE_BIT
| NRRD_BASIC_INFO_BLOCKSIZE_BIT
| NRRD_BASIC_INFO_DIMENSION_BIT
| NRRD_BASIC_INFO_CONTENT_BIT
| NRRD_BASIC_INFO_COMMENTS_BIT
| (nrrdStateKeyValuePairsPropagate
? 0
: NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT))) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
return 0;
}
mop = airMopNew();
/* convert input nrrd to nrrdResample_t if necessary */
if (nrrdResample_nrrdType != typeIn) {
if (nrrdConvert(floatNin = nrrdNew(), nin, nrrdResample_nrrdType)) {
sprintf(err, "%s: couldn't create float copy of input", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
array[0] = (nrrdResample_t*)floatNin->data;
airMopAdd(mop, floatNin, (airMopper)nrrdNuke, airMopAlways);
} else {
floatNin = NULL;
array[0] = (nrrdResample_t*)nin->data;
}
/* compute strideIn; this is actually the same for every pass
because (strictly speaking) in every pass we are resampling
the same axis, and axes with lower indices are constant length */
strideIn = 1;
for (ai=0; ai<(unsigned int)topRax; ai++) { /* HEY scrutinize casts */
strideIn *= nin->axis[ai].size;
}
/*
printf("%s: strideIn = " _AIR_SIZE_T_CNV "\n", me, strideIn);
*/
/* go! */
for (pi=0; pi<passes; pi++) {
/*
printf("%s: --- pass %d --- \n", me, pi);
*/
numLines = strideOut = 1;
for (ai=0; ai<nin->dim; ai++) {
if (ai < (unsigned int)botRax) { /* HEY scrutinize cast */
strideOut *= sz[pi+1][ai];
}
if (ai != (unsigned int)topRax) { /* HEY scrutinize cast */
numLines *= sz[pi][ai];
}
}
sizeIn = sz[pi][topRax];
sizeOut = sz[pi+1][botRax];
numOut = numLines*sizeOut;
/* for the rest of the loop body, d is the original "dimension"
for the axis being resampled */
ai = ax[pi][topRax];
/*
printf("%s(%d): numOut = " _AIR_SIZE_T_CNV "\n", me, pi, numOut);
printf("%s(%d): numLines = " _AIR_SIZE_T_CNV "\n", me, pi, numLines);
printf("%s(%d): stride: In=%d, Out=%d\n", me, pi,
(int)strideIn, (int)strideOut);
printf("%s(%d): sizeIn = %d\n", me, pi, sizeIn);
printf("%s(%d): sizeOut = %d\n", me, pi, sizeOut);
*/
/* we can free the input to the previous pass
(if its not the given data) */
if (pi > 0) {
if (pi == 1) {
if (array[0] != nin->data) {
airMopSub(mop, floatNin, (airMopper)nrrdNuke);
floatNin = nrrdNuke(floatNin);
array[0] = NULL;
/*
printf("%s: pi %d: freeing array[0]\n", me, pi);
*/
}
} else {
airMopSub(mop, array[pi-1], airFree);
array[pi-1] = (nrrdResample_t*)airFree(array[pi-1]);
/*
printf("%s: pi %d: freeing array[%d]\n", me, pi, pi-1);
*/
}
}
/* allocate output volume */
array[pi+1] = (nrrdResample_t*)calloc(numOut, sizeof(nrrdResample_t));
if (!array[pi+1]) {
sprintf(err, "%s: couldn't create array of " _AIR_SIZE_T_CNV
" nrrdResample_t's for output of pass %d",
me, numOut, pi);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
airMopAdd(mop, array[pi+1], airFree, airMopAlways);
/*
printf("%s: allocated array[%d]\n", me, pi+1);
*/
/* allocate contiguous input scanline buffer, we alloc one more
than needed to provide a place for the pad value. That is, in
fact, the over-riding reason to copy a scanline to a local
array: so that there is a simple consistent (non-branchy) way
to incorporate the pad values */
inVec = (nrrdResample_t *)calloc(sizeIn+1, sizeof(nrrdResample_t));
airMopAdd(mop, inVec, airFree, airMopAlways);
inVec[sizeIn] = AIR_CAST(nrrdResample_t, info->padValue);
dotLen = _nrrdResampleMakeWeightIndex(&weight, &index, &ratio,
nin, info, ai);
if (!dotLen) {
sprintf(err, "%s: trouble creating weight and index vector arrays", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
ratios[ai] = ratio;
airMopAdd(mop, weight, airFree, airMopAlways);
airMopAdd(mop, index, airFree, airMopAlways);
/* the skinny: resample all the scanlines */
_inVec = array[pi];
_outVec = array[pi+1];
memset(ci, 0, (NRRD_DIM_MAX+1)*sizeof(int));
memset(co, 0, (NRRD_DIM_MAX+1)*sizeof(int));
for (L=0; L<numLines; L++) {
/* calculate the index to get to input and output scanlines,
according the coordinates of the start of the scanline */
NRRD_INDEX_GEN(LI, ci, sz[pi], nin->dim);
NRRD_INDEX_GEN(LO, co, sz[pi+1], nin->dim);
_inVec = array[pi] + LI;
_outVec = array[pi+1] + LO;
/* read input scanline into contiguous array */
for (i=0; i<sizeIn; i++) {
inVec[i] = _inVec[i*strideIn];
}
/* do the weighting */
for (i=0; i<sizeOut; i++) {
tmpF = 0.0;
/*
fprintf(stderr, "%s: i = %d (tmpF=0)\n", me, (int)i);
*/
for (s=0; s<dotLen; s++) {
tmpF += inVec[index[s + dotLen*i]]*weight[s + dotLen*i];
/*
fprintf(stderr, " tmpF += %g*%g == %g\n",
inVec[index[s + dotLen*i]], weight[s + dotLen*i], tmpF);
*/
}
_outVec[i*strideOut] = tmpF;
/*
fprintf(stderr, "--> out[%d] = %g\n",
i*strideOut, _outVec[i*strideOut]);
*/
}
/* update the coordinates for the scanline starts. We don't
use the usual NRRD_COORD macros because we're subject to
the unusual constraint that ci[topRax] and co[permute[topRax]]
must stay exactly zero */
e = topLax;
ci[e]++;
co[permute[e]]++;
while (L < numLines-1 && ci[e] == sz[pi][e]) {
ci[e] = co[permute[e]] = 0;
e++;
e += e == topRax;
ci[e]++;
co[permute[e]]++;
}
}
/* pass-specific clean up */
airMopSub(mop, weight, airFree);
airMopSub(mop, index, airFree);
airMopSub(mop, inVec, airFree);
weight = (nrrdResample_t*)airFree(weight);
index = (int*)airFree(index);
inVec = (nrrdResample_t*)airFree(inVec);
}
/* clean up second-to-last array and scanline buffers */
if (passes > 1) {
airMopSub(mop, array[passes-1], airFree);
array[passes-1] = (nrrdResample_t*)airFree(array[passes-1]);
/*
printf("%s: now freeing array[%d]\n", me, passes-1);
*/
} else if (array[passes-1] != nin->data) {
airMopSub(mop, floatNin, (airMopper)nrrdNuke);
floatNin = nrrdNuke(floatNin);
}
array[passes-1] = NULL;
/* create output nrrd and set axis info */
if (nrrdMaybeAlloc_nva(nout, typeOut, nin->dim, sz[passes])) {
sprintf(err, "%s: couldn't allocate final output nrrd", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopOnError);
nrrdAxisInfoCopy(nout, nin, NULL,
(NRRD_AXIS_INFO_SIZE_BIT
| NRRD_AXIS_INFO_MIN_BIT
| NRRD_AXIS_INFO_MAX_BIT
| NRRD_AXIS_INFO_SPACING_BIT
| NRRD_AXIS_INFO_SPACEDIRECTION_BIT /* see below */
| NRRD_AXIS_INFO_THICKNESS_BIT
| NRRD_AXIS_INFO_KIND_BIT));
for (ai=0; ai<nin->dim; ai++) {
if (info->kernel[ai]) {
/* we do resample this axis */
nout->axis[ai].spacing = nin->axis[ai].spacing/ratios[ai];
/* no way to usefully update thickness: we could be doing blurring
but maintaining the number of samples: thickness increases, or
we could be downsampling, in which the relationship between the
sampled and the skipped regions of space becomes complicated:
no single scalar can represent it, or we could be upsampling,
in which the notion of "skip" could be rendered meaningless */
nout->axis[ai].thickness = AIR_NAN;
nout->axis[ai].min = info->min[ai];
nout->axis[ai].max = info->max[ai];
/*
HEY: this is currently a bug: all this code was written long
before there were space directions, so min/max are always
set, regardless of whethere there are incoming space directions
which then disallows output space directions on the same axes
_nrrdSpaceVecScale(nout->axis[ai].spaceDirection,
1.0/ratios[ai], nin->axis[ai].spaceDirection);
*/
nout->axis[ai].kind = _nrrdKindAltered(nin->axis[ai].kind, AIR_TRUE);
} else {
/* this axis remains untouched */
nout->axis[ai].min = nin->axis[ai].min;
nout->axis[ai].max = nin->axis[ai].max;
nout->axis[ai].spacing = nin->axis[ai].spacing;
nout->axis[ai].thickness = nin->axis[ai].thickness;
nout->axis[ai].kind = nin->axis[ai].kind;
}
}
/* HEY: need to create textual representation of resampling parameters */
if (nrrdContentSet_va(nout, func, nin, "")) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
/* copy the resampling final result into the output nrrd, maybe
rounding as we go to make sure that 254.9999 is saved as 255
in uchar output, and maybe clamping as we go to insure that
integral results don't have unexpected wrap-around. */
if (info->round) {
if (nrrdTypeInt == typeOut ||
nrrdTypeUInt == typeOut ||
nrrdTypeLLong == typeOut ||
nrrdTypeULLong == typeOut) {
fprintf(stderr, "%s: WARNING: possible erroneous output with "
"rounding of %s output type due to int-based implementation "
"of rounding\n", me, airEnumStr(nrrdType, typeOut));
}
doRound = nrrdTypeIsIntegral[typeOut];
} else {
doRound = AIR_FALSE;
}
numOut = nrrdElementNumber(nout);
for (I=0; I<numOut; I++) {
tmpF = array[passes][I];
if (doRound) {
tmpF = AIR_CAST(nrrdResample_t, AIR_ROUNDUP(tmpF));
}
if (info->clamp) {
tmpF = nrrdFClamp[typeOut](tmpF);
}
nrrdFInsert[typeOut](nout->data, I, tmpF);
}
if (nrrdBasicInfoCopy(nout, nin,
NRRD_BASIC_INFO_DATA_BIT
| NRRD_BASIC_INFO_TYPE_BIT
| NRRD_BASIC_INFO_BLOCKSIZE_BIT
| NRRD_BASIC_INFO_DIMENSION_BIT
| NRRD_BASIC_INFO_CONTENT_BIT
| NRRD_BASIC_INFO_COMMENTS_BIT
| (nrrdStateKeyValuePairsPropagate
? 0
: NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT))) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
/* enough already */
airMopOkay(mop);
return 0;
}
int
alanParmSet(alanContext *actx, int whichParm, double parm) {
static const char me[]="alanParmSet";
int parmI;
GOT_NULL;
DIM_SET;
switch (whichParm) {
case alanParmVerbose:
parmI = !!parm;
actx->verbose = parmI;
break;
case alanParmTextureType:
parmI = !!parm;
switch(parmI) {
case alanTextureTypeTuring:
actx->initA = 4.0;
actx->initB = 4.0;
actx->diffA = 0.25;
actx->diffB = 0.0625;
break;
case alanTextureTypeGrayScott:
actx->initA = 1;
actx->initB = 0;
actx->diffA = 0.00002f;
actx->diffB = 0.00002f;
break;
default:
biffAddf(ALAN, "%s: texture type %d invalid", me, parmI);
return 1;
break;
}
actx->textureType = parmI;
break;
case alanParmNumThreads:
parmI = !!parm;
if (!airThreadCapable) {
fprintf(stderr, "%s: WARNING: no multi-threading available, so 1 thread "
"will be used, not %d\n", me, parmI);
parmI = 1;
}
actx->numThreads = parmI;
break;
case alanParmHomogAniso:
parmI = !!parm;
actx->homogAniso = parmI;
break;
case alanParmSaveInterval:
parmI = !!parm;
actx->saveInterval = parmI;
break;
case alanParmFrameInterval:
parmI = !!parm;
actx->frameInterval = parmI;
break;
case alanParmMaxIteration:
parmI = !!parm;
actx->maxIteration = parmI;
break;
case alanParmConstantFilename:
parmI = !!parm;
actx->constFilename = parmI;
break;
case alanParmDeltaT:
actx->deltaT = AIR_CAST(alan_t, parm);
break;
case alanParmDeltaX:
actx->deltaX = AIR_CAST(alan_t, parm);
break;
case alanParmReact:
actx->react = AIR_CAST(alan_t, parm);
break;
case alanParmDiffA:
actx->diffA = AIR_CAST(alan_t, parm);
break;
case alanParmDiffB:
actx->diffB = AIR_CAST(alan_t, parm);
break;
case alanParmRandRange:
actx->randRange = AIR_CAST(alan_t, parm);
break;
case alanParmK:
actx->K = AIR_CAST(alan_t, parm);
break;
case alanParmF:
actx->F = AIR_CAST(alan_t, parm);
break;
case alanParmMinAverageChange:
actx->minAverageChange = AIR_CAST(alan_t, parm);
break;
case alanParmMaxPixelChange:
actx->maxPixelChange = AIR_CAST(alan_t, parm);
break;
case alanParmAlpha:
actx->alpha = AIR_CAST(alan_t, parm);
break;
case alanParmBeta:
actx->beta = AIR_CAST(alan_t, parm);
break;
case alanParmWrapAround:
parmI = !!parm;
actx->wrap = parmI;
break;
default:
biffAddf(ALAN, "%s: parameter %d invalid", me, whichParm);
return 1;
break;
}
return 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
main(int argc, char *argv[]) {
char *me, *outS;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
char *err;
Nrrd *nin, *nhist;
double vmin, vmax, rmax, val, cent[2], rad;
int bins[2], sx, sy, xi, yi, ridx, hidx, rbins, hbins;
NrrdRange *range;
double (*lup)(const void *v, size_t I), *hist;
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input image", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "b", "rbins hbins", airTypeInt, 2, 2, bins, NULL,
"# of histogram bins: radial and value");
hestOptAdd(&hopt, "min", "value", airTypeDouble, 1, 1, &vmin, "nan",
"Value at low end of histogram. Defaults to lowest value "
"found in input nrrd.");
hestOptAdd(&hopt, "max", "value", airTypeDouble, 1, 1, &vmax, "nan",
"Value at high end of histogram. Defaults to highest value "
"found in input nrrd.");
hestOptAdd(&hopt, "rmax", "max radius", airTypeDouble, 1, 1, &rmax, "nan",
"largest radius to include in histogram");
hestOptAdd(&hopt, "c", "center x, y", airTypeDouble, 2, 2, cent, NULL,
"The center point around which to build radial histogram");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"file to write histogram to");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, histradInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (2 != nin->dim) {
fprintf(stderr, "%s: need 2-D input (not %d-D)\n", me, nin->dim);
airMopError(mop); return 1;
}
rbins = bins[0];
hbins = bins[1];
nhist = nrrdNew();
airMopAdd(mop, nhist, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(nhist, nrrdTypeDouble, 2,
AIR_CAST(size_t, rbins),
AIR_CAST(size_t, hbins))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate histogram:\n%s", me, err);
airMopError(mop); return 1;
}
if (!( AIR_EXISTS(vmin) && AIR_EXISTS(vmax) )) {
range = nrrdRangeNewSet(nin, nrrdStateBlind8BitRange);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
vmin = AIR_EXISTS(vmin) ? vmin : range->min;
vmax = AIR_EXISTS(vmax) ? vmax : range->max;
}
#define DIST(x0, y0, x1, y1) (sqrt((x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)))
sx = nin->axis[0].size;
sy = nin->axis[1].size;
if (!AIR_EXISTS(rmax)) {
rmax = 0;
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], 0, 0));
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], sx-1, 0));
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], 0, sy-1));
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], sx-1, sy-1));
}
lup = nrrdDLookup[nin->type];
hist = (double*)(nhist->data);
for (xi=0; xi<sx; xi++) {
for (yi=0; yi<sy; yi++) {
rad = DIST(cent[0], cent[1], xi, yi);
if (!AIR_IN_OP(0, rad, rmax)) {
continue;
}
val = lup(nin->data, xi + sx*yi);
if (!AIR_IN_OP(vmin, val, vmax)) {
continue;
}
ridx = airIndex(0, rad, rmax, rbins);
hidx = airIndex(vmin, val, vmax, hbins);
hist[ridx + rbins*hidx] += 1;
}
}
nhist->axis[0].min = 0;
nhist->axis[0].max = rmax;
nhist->axis[1].min = vmin;
nhist->axis[1].max = vmax;
if (nrrdSave(outS, nhist, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
exit(0);
}
int
alanInit(alanContext *actx, const Nrrd *nlevInit, const Nrrd *nparmInit) {
char me[]="alanInit", err[BIFF_STRLEN];
alan_t *levInit=NULL, *lev0, *parmInit=NULL, *parm;
size_t I, N;
if (_alanCheck(actx)) {
sprintf(err, "%s: ", me);
biffAdd(ALAN, err); return 1;
}
if (!( actx->_nlev[0] && actx->_nlev[0] && actx->nparm )) {
sprintf(err, "%s: _nlev[0,1] not allocated: call alanUpdate", me);
biffAdd(ALAN, err); return 1;
}
if (nlevInit) {
if (nrrdCheck(nlevInit)) {
sprintf(err, "%s: given nlevInit has problems", me);
biffMove(ALAN, err, NRRD); return 1;
}
if (!( alan_nt == nlevInit->type
&& nlevInit->dim == 1 + actx->dim
&& actx->_nlev[0]->axis[0].size == nlevInit->axis[0].size
&& actx->size[0] == nlevInit->axis[1].size
&& actx->size[1] == nlevInit->axis[2].size
&& (2 == actx->dim || actx->size[2] == nlevInit->axis[3].size) )) {
sprintf(err, "%s: type/size mismatch with given nlevInit", me);
biffAdd(ALAN, err); return 1;
}
levInit = (alan_t*)(nlevInit->data);
}
if (nparmInit) {
if (nrrdCheck(nparmInit)) {
sprintf(err, "%s: given nparmInit has problems", me);
biffMove(ALAN, err, NRRD); return 1;
}
if (!( alan_nt == nparmInit->type
&& nparmInit->dim == 1 + actx->dim
&& 3 == nparmInit->axis[0].size
&& actx->size[0] == nparmInit->axis[1].size
&& actx->size[1] == nparmInit->axis[2].size
&& (2 == actx->dim || actx->size[2] == nparmInit->axis[3].size) )) {
sprintf(err, "%s: type/size mismatch with given nparmInit", me);
biffAdd(ALAN, err); return 1;
}
parmInit = (alan_t*)(nparmInit->data);
}
#define RAND AIR_AFFINE(0, airDrandMT(), 1, -actx->randRange, actx->randRange)
N = nrrdElementNumber(actx->_nlev[0])/actx->_nlev[0]->axis[0].size;
lev0 = (alan_t*)(actx->_nlev[0]->data);
parm = (alan_t*)(actx->nparm->data);
for (I=0; I<N; I++) {
if (levInit) {
lev0[0 + 2*I] = levInit[0 + 2*I];
lev0[1 + 2*I] = levInit[1 + 2*I];
} else {
/* NOTE: the random number stuff here is OUTSIDE the multi-threaded
segment of the program- only the init thread does this */
lev0[0 + 2*I] = AIR_CAST(alan_t, actx->initA + RAND);
lev0[1 + 2*I] = AIR_CAST(alan_t, actx->initB + RAND);
}
if (parmInit) {
parm[0 + 3*I] = parmInit[0 + 3*I];
parm[1 + 3*I] = parmInit[1 + 3*I];
parm[2 + 3*I] = parmInit[2 + 3*I];
} else {
parm[0 + 3*I] = actx->deltaT;
parm[1 + 3*I] = actx->alpha;
parm[2 + 3*I] = actx->beta;
}
}
return 0;
}
int
limnEnvMapFill(Nrrd *map, limnEnvMapCB cb, int qnMethod, void *data) {
char me[]="limnEnvMapFill", err[128];
int sx, sy;
int qn;
float vec[3], *mapData;
if (!(map && cb)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(LIMN, err); return 1;
}
if (!AIR_IN_OP(limnQNUnknown, qnMethod, limnQNLast)) {
sprintf(err, "%s: QN method %d invalid", me, qnMethod);
biffAdd(LIMN, err); return 1;
}
switch(qnMethod) {
case limnQN16checker:
case limnQN16octa:
sx = sy = 256;
break;
case limnQN14checker:
case limnQN14octa:
sx = sy = 128;
break;
case limnQN12checker:
case limnQN12octa:
sx = sy = 64;
break;
case limnQN10checker:
case limnQN10octa:
sx = sy = 32;
break;
case limnQN8checker:
case limnQN8octa:
sx = sy = 16;
break;
case limnQN15octa:
sx = 128;
sy = 256;
break;
case limnQN13octa:
sx = 64;
sy = 128;
break;
case limnQN11octa:
sx = 32;
sy = 64;
break;
case limnQN9octa:
sx = 16;
sy = 32;
break;
default:
sprintf(err, "%s: sorry, QN method %d not implemented", me, qnMethod);
biffAdd(LIMN, err); return 1;
}
if (nrrdMaybeAlloc_va(map, nrrdTypeFloat, 3,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy))) {
sprintf(err, "%s: couldn't alloc output", me);
biffMove(LIMN, err, NRRD); return 1;
}
mapData = (float *)map->data;
for (qn=0; qn<sx*sy; qn++) {
limnQNtoV_f[qnMethod](vec, qn);
cb(mapData + 3*qn, vec, data);
}
return 0;
}
int
alanUpdate(alanContext *actx) {
char me[]="alanUpdate", err[BIFF_STRLEN];
int ret;
if (_alanCheck(actx)) {
sprintf(err, "%s: ", me);
biffAdd(ALAN, err); return 1;
}
if (actx->_nlev[0] || actx->_nlev[0]) {
sprintf(err, "%s: confusion: _nlev[0,1] already allocated?", me);
biffAdd(ALAN, err); return 1;
}
actx->_nlev[0] = nrrdNew();
actx->_nlev[1] = nrrdNew();
actx->nparm = nrrdNew();
if (2 == actx->dim) {
ret = (nrrdMaybeAlloc_va(actx->_nlev[0], alan_nt, 3,
AIR_CAST(size_t, 2),
AIR_CAST(size_t, actx->size[0]),
AIR_CAST(size_t, actx->size[1]))
|| nrrdCopy(actx->_nlev[1], actx->_nlev[0])
|| nrrdMaybeAlloc_va(actx->nparm, alan_nt, 3,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, actx->size[0]),
AIR_CAST(size_t, actx->size[1])));
} else {
ret = (nrrdMaybeAlloc_va(actx->_nlev[0], alan_nt, 4,
AIR_CAST(size_t, 2),
AIR_CAST(size_t, actx->size[0]),
AIR_CAST(size_t, actx->size[1]),
AIR_CAST(size_t, actx->size[2]))
|| nrrdCopy(actx->_nlev[1], actx->_nlev[0])
|| nrrdMaybeAlloc_va(actx->nparm, alan_nt, 4,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, actx->size[0]),
AIR_CAST(size_t, actx->size[1]),
AIR_CAST(size_t, actx->size[2])));
}
if (ret) {
sprintf(err, "%s: trouble allocating buffers", me);
biffMove(ALAN, err, NRRD); return 1;
}
return 0;
}
int
main(int argc, const char *argv[]) {
gageKind *kind;
const char *me;
char *outS, *err;
hestParm *hparm;
hestOpt *hopt = NULL;
NrrdKernelSpec *ksp;
int otype, separ, ret;
unsigned int maxIter;
double epsilon, lastDiff, step;
Nrrd *nin, *nout;
airArray *mop;
mop = airMopNew();
me = argv[0];
hparm = hestParmNew();
airMopAdd(mop, hparm, AIR_CAST(airMopper, hestParmFree), airMopAlways);
hparm->elideSingleOtherType = AIR_TRUE;
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input volume", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "k", "kind", airTypeOther, 1, 1, &kind, NULL,
"\"kind\" of volume (\"scalar\", \"vector\", "
"\"tensor\", or \"dwi\")",
NULL, NULL, meetHestGageKind);
hestOptAdd(&hopt, "k00", "kernel", airTypeOther, 1, 1, &ksp, NULL,
"convolution kernel",
NULL, NULL, nrrdHestKernelSpec);
hestOptAdd(&hopt, "mi", "max # iters", airTypeUInt, 1, 1, &maxIter, "100",
"maximum number of iterations with which to compute the "
"deconvolution");
hestOptAdd(&hopt, "e", "epsilon", airTypeDouble, 1, 1, &epsilon,
"0.00000001", "convergence threshold");
hestOptAdd(&hopt, "s", "step", airTypeDouble, 1, 1, &step, "1.0",
"scaling of value update");
hestOptAdd(&hopt, "t", "type", airTypeOther, 1, 1, &otype, "default",
"type to save output as. By default (not using this option), "
"the output type is the same as the input type",
NULL, NULL, &unrrduHestMaybeTypeCB);
hestOptAdd(&hopt, "sep", "bool", airTypeBool, 1, 1, &separ, "false",
"use fast separable deconvolution instead of brain-dead "
"brute-force iterative method");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output volume");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, deconvInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestOptFree), airMopAlways);
airMopAdd(mop, hopt, AIR_CAST(airMopper, hestParseFree), airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, AIR_CAST(airMopper, nrrdNuke), airMopAlways);
if (separ) {
ret = gageDeconvolveSeparable(nout, nin, kind, ksp, otype);
} else {
ret = gageDeconvolve(nout, &lastDiff,
nin, kind,
ksp, otype,
maxIter, AIR_TRUE,
step, epsilon, 1);
}
if (ret) {
airMopAdd(mop, err = biffGetDone(GAGE), 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 saving output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
int
tenGlyphGen(limnObject *glyphsLimn, echoScene *glyphsEcho,
tenGlyphParm *parm,
const Nrrd *nten, const Nrrd *npos, const Nrrd *nslc) {
char me[]="tenGlyphGen", err[BIFF_STRLEN];
gageShape *shape;
airArray *mop;
float *tdata, eval[3], evec[9], *cvec, rotEvec[9], mA_f[16];
double pI[3], pW[3], cl, cp, sRot[16], mA[16], mB[16], msFr[9], tmpvec[3],
R, G, B, qA, qB, glyphAniso, sliceGray;
unsigned int duh;
int slcCoord[3], idx, _idx=0, glyphIdx, axis, numGlyphs,
svRGBAfl=AIR_FALSE;
limnLook *look; int lookIdx;
echoObject *eglyph, *inst, *list=NULL, *split, *esquare;
echoPos_t eM[16], originOffset[3], edge0[3], edge1[3];
/*
int eret;
double tmp1[3], tmp2[3];
*/
if (!( (glyphsLimn || glyphsEcho) && nten && parm)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
mop = airMopNew();
shape = gageShapeNew();
shape->defaultCenter = nrrdCenterCell;
airMopAdd(mop, shape, (airMopper)gageShapeNix, airMopAlways);
if (npos) {
if (!( 2 == nten->dim && 7 == nten->axis[0].size )) {
sprintf(err, "%s: nten isn't 2-D 7-by-N array", me);
biffAdd(TEN, err); airMopError(mop); return 1;
}
if (!( 2 == npos->dim && 3 == npos->axis[0].size
&& nten->axis[1].size == npos->axis[1].size )) {
sprintf(err, "%s: npos isn't 2-D 3-by-" _AIR_SIZE_T_CNV " array",
me, nten->axis[1].size);
biffAdd(TEN, err); airMopError(mop); return 1;
}
if (!( nrrdTypeFloat == nten->type && nrrdTypeFloat == npos->type )) {
sprintf(err, "%s: nten and npos must be %s, not %s and %s", me,
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nten->type),
airEnumStr(nrrdType, npos->type));
biffAdd(TEN, err); airMopError(mop); return 1;
}
} else {
if (tenTensorCheck(nten, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
sprintf(err, "%s: didn't get a valid DT volume", me);
biffAdd(TEN, err); airMopError(mop); return 1;
}
}
if (tenGlyphParmCheck(parm, nten, npos, nslc)) {
sprintf(err, "%s: trouble", me);
biffAdd(TEN, err); airMopError(mop); return 1;
}
if (!npos) {
if (gageShapeSet(shape, nten, tenGageKind->baseDim)) {
sprintf(err, "%s: trouble", me);
biffMove(TEN, err, GAGE); airMopError(mop); return 1;
}
}
if (parm->doSlice) {
ELL_3V_COPY(edge0, shape->voxLen);
ELL_3V_COPY(edge1, shape->voxLen);
edge0[parm->sliceAxis] = edge1[parm->sliceAxis] = 0.0;
switch(parm->sliceAxis) {
case 0:
edge0[1] = edge1[2] = 0;
ELL_4M_ROTATE_Y_SET(sRot, AIR_PI/2);
break;
case 1:
edge0[0] = edge1[2] = 0;
ELL_4M_ROTATE_X_SET(sRot, AIR_PI/2);
break;
case 2: default:
edge0[0] = edge1[1] = 0;
ELL_4M_IDENTITY_SET(sRot);
break;
}
ELL_3V_COPY(originOffset, shape->voxLen);
ELL_3V_SCALE(originOffset, -0.5, originOffset);
originOffset[parm->sliceAxis] *= -2*parm->sliceOffset;
}
if (glyphsLimn) {
/* create limnLooks for diffuse and ambient-only shading */
/* ??? */
/* hack: save old value of setVertexRGBAFromLook, and set to true */
svRGBAfl = glyphsLimn->setVertexRGBAFromLook;
glyphsLimn->setVertexRGBAFromLook = AIR_TRUE;
}
if (glyphsEcho) {
list = echoObjectNew(glyphsEcho, echoTypeList);
}
if (npos) {
numGlyphs = nten->axis[1].size;
} else {
numGlyphs = shape->size[0] * shape->size[1] * shape->size[2];
}
/* find measurement frame transform */
if (3 == nten->spaceDim
&& AIR_EXISTS(nten->measurementFrame[0][0])) {
/* msFr nten->measurementFrame
** 0 1 2 [0][0] [1][0] [2][0]
** 3 4 5 [0][1] [1][1] [2][1]
** 6 7 8 [0][2] [1][2] [2][2]
*/
msFr[0] = nten->measurementFrame[0][0];
msFr[3] = nten->measurementFrame[0][1];
msFr[6] = nten->measurementFrame[0][2];
msFr[1] = nten->measurementFrame[1][0];
msFr[4] = nten->measurementFrame[1][1];
msFr[7] = nten->measurementFrame[1][2];
msFr[2] = nten->measurementFrame[2][0];
msFr[5] = nten->measurementFrame[2][1];
msFr[8] = nten->measurementFrame[2][2];
} else {
ELL_3M_IDENTITY_SET(msFr);
}
for (idx=0; idx<numGlyphs; idx++, _idx = idx) {
tdata = (float*)(nten->data) + 7*idx;
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: hello %g %g %g %g %g %g %g\n",
me, idx, numGlyphs, tdata[0],
tdata[1], tdata[2], tdata[3],
tdata[4], tdata[5], tdata[6]);
}
if (!( TEN_T_EXISTS(tdata) )) {
/* there's nothing we can do here */
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: non-existant data\n",
me, idx, numGlyphs);
}
continue;
}
if (npos) {
ELL_3V_COPY(pW, (float*)(npos->data) + 3*idx);
if (!( AIR_EXISTS(pW[0]) && AIR_EXISTS(pW[1]) && AIR_EXISTS(pW[2]) )) {
/* position doesn't exist- perhaps because its from the push
library, which might kill points by setting coords to nan */
continue;
}
} else {
NRRD_COORD_GEN(pI, shape->size, 3, _idx);
/* this does take into account full orientation */
gageShapeItoW(shape, pW, pI);
if (parm->nmask) {
if (!( nrrdFLookup[parm->nmask->type](parm->nmask->data, idx)
>= parm->maskThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: doesn't meet mask thresh\n",
me, idx, numGlyphs);
}
continue;
}
}
}
tenEigensolve_f(eval, evec, tdata);
/* transform eigenvectors by measurement frame */
ELL_3MV_MUL(tmpvec, msFr, evec + 0);
ELL_3V_COPY_TT(evec + 0, float, tmpvec);
ELL_3MV_MUL(tmpvec, msFr, evec + 3);
ELL_3V_COPY_TT(evec + 3, float, tmpvec);
ELL_3MV_MUL(tmpvec, msFr, evec + 6);
ELL_3V_COPY_TT(evec + 6, float, tmpvec);
ELL_3V_CROSS(tmpvec, evec + 0, evec + 3);
if (0 > ELL_3V_DOT(tmpvec, evec + 6)) {
ELL_3V_SCALE(evec + 6, -1, evec + 6);
}
ELL_3M_TRANSPOSE(rotEvec, evec);
if (parm->doSlice
&& pI[parm->sliceAxis] == parm->slicePos) {
/* set sliceGray */
if (nslc) {
/* we aren't masked by confidence, as anisotropy slice is */
for (duh=0; duh<parm->sliceAxis; duh++) {
slcCoord[duh] = (int)(pI[duh]);
}
for (duh=duh<parm->sliceAxis; duh<2; duh++) {
slcCoord[duh] = (int)(pI[duh+1]);
}
/* HEY: GLK has no idea what's going here */
slcCoord[0] = (int)(pI[0]);
slcCoord[1] = (int)(pI[1]);
slcCoord[2] = (int)(pI[2]);
sliceGray =
nrrdFLookup[nslc->type](nslc->data, slcCoord[0]
+ nslc->axis[0].size*slcCoord[1]);
} else {
if (!( tdata[0] >= parm->confThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d (slice): conf %g < thresh %g\n",
me, idx, numGlyphs, tdata[0], parm->confThresh);
}
continue;
}
sliceGray = tenAnisoEval_f(eval, parm->sliceAnisoType);
}
if (parm->sliceGamma > 0) {
sliceGray = AIR_AFFINE(0, sliceGray, 1, parm->sliceBias, 1);
sliceGray = pow(sliceGray, 1.0/parm->sliceGamma);
} else {
sliceGray = AIR_AFFINE(0, sliceGray, 1, 0, 1-parm->sliceBias);
sliceGray = 1.0 - pow(sliceGray, -1.0/parm->sliceGamma);
}
/* make slice contribution */
/* HEY: this is *NOT* aware of shape->fromOrientation */
if (glyphsLimn) {
lookIdx = limnObjectLookAdd(glyphsLimn);
look = glyphsLimn->look + lookIdx;
ELL_4V_SET_TT(look->rgba, float, sliceGray, sliceGray, sliceGray, 1);
ELL_3V_SET(look->kads, 1, 0, 0);
look->spow = 0;
glyphIdx = limnObjectSquareAdd(glyphsLimn, lookIdx);
ELL_4M_IDENTITY_SET(mA);
ell_4m_post_mul_d(mA, sRot);
if (!npos) {
ELL_4M_SCALE_SET(mB,
shape->voxLen[0],
shape->voxLen[1],
shape->voxLen[2]);
}
ell_4m_post_mul_d(mA, mB);
ELL_4M_TRANSLATE_SET(mB, pW[0], pW[1], pW[2]);
ell_4m_post_mul_d(mA, mB);
ELL_4M_TRANSLATE_SET(mB,
originOffset[0],
originOffset[1],
originOffset[2]);
ell_4m_post_mul_d(mA, mB);
ELL_4M_COPY_TT(mA_f, float, mA);
limnObjectPartTransform(glyphsLimn, glyphIdx, mA_f);
}
if (glyphsEcho) {
esquare = echoObjectNew(glyphsEcho,echoTypeRectangle);
ELL_3V_ADD2(((echoRectangle*)esquare)->origin, pW, originOffset);
ELL_3V_COPY(((echoRectangle*)esquare)->edge0, edge0);
ELL_3V_COPY(((echoRectangle*)esquare)->edge1, edge1);
echoColorSet(esquare,
AIR_CAST(echoCol_t, sliceGray),
AIR_CAST(echoCol_t, sliceGray),
AIR_CAST(echoCol_t, sliceGray), 1);
/* this is pretty arbitrary- but I want shadows to have some effect.
Previously, the material was all ambient: (A,D,S) = (1,0,0),
which avoided all shadow effects. */
echoMatterPhongSet(glyphsEcho, esquare, 0.4f, 0.6f, 0, 40);
echoListAdd(list, esquare);
}
}
if (parm->onlyPositive) {
if (eval[2] < 0) {
/* didn't have all positive eigenvalues, its outta here */
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: not all evals %g %g %g > 0\n",
me, idx, numGlyphs, eval[0], eval[1], eval[2]);
}
continue;
}
}
if (!( tdata[0] >= parm->confThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: conf %g < thresh %g\n",
me, idx, numGlyphs, tdata[0], parm->confThresh);
}
continue;
}
if (!( tenAnisoEval_f(eval, parm->anisoType) >= parm->anisoThresh )) {
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: aniso[%d] %g < thresh %g\n",
me, idx, numGlyphs, parm->anisoType,
tenAnisoEval_f(eval, parm->anisoType), parm->anisoThresh);
}
continue;
}
glyphAniso = tenAnisoEval_f(eval, parm->colAnisoType);
/*
fprintf(stderr, "%s: eret = %d; evals = %g %g %g\n", me,
eret, eval[0], eval[1], eval[2]);
ELL_3V_CROSS(tmp1, evec+0, evec+3); tmp2[0] = ELL_3V_LEN(tmp1);
ELL_3V_CROSS(tmp1, evec+0, evec+6); tmp2[1] = ELL_3V_LEN(tmp1);
ELL_3V_CROSS(tmp1, evec+3, evec+6); tmp2[2] = ELL_3V_LEN(tmp1);
fprintf(stderr, "%s: crosses = %g %g %g\n", me,
tmp2[0], tmp2[1], tmp2[2]);
*/
/* set transform (in mA) */
ELL_4M_IDENTITY_SET(mA); /* reset */
ELL_3V_SCALE(eval, parm->glyphScale, eval); /* scale by evals */
ELL_4M_SCALE_SET(mB, eval[0], eval[1], eval[2]);
ell_4m_post_mul_d(mA, mB);
ELL_43M_INSET(mB, rotEvec); /* rotate by evecs */
ell_4m_post_mul_d(mA, mB);
ELL_4M_TRANSLATE_SET(mB, pW[0], pW[1], pW[2]); /* translate */
ell_4m_post_mul_d(mA, mB);
/* set color (in R,G,B) */
cvec = evec + 3*(AIR_CLAMP(0, parm->colEvec, 2));
R = AIR_ABS(cvec[0]); /* standard mapping */
G = AIR_ABS(cvec[1]);
B = AIR_ABS(cvec[2]);
/* desaturate by colMaxSat */
R = AIR_AFFINE(0.0, parm->colMaxSat, 1.0, parm->colIsoGray, R);
G = AIR_AFFINE(0.0, parm->colMaxSat, 1.0, parm->colIsoGray, G);
B = AIR_AFFINE(0.0, parm->colMaxSat, 1.0, parm->colIsoGray, B);
/* desaturate some by anisotropy */
R = AIR_AFFINE(0.0, parm->colAnisoModulate, 1.0,
R, AIR_AFFINE(0.0, glyphAniso, 1.0, parm->colIsoGray, R));
G = AIR_AFFINE(0.0, parm->colAnisoModulate, 1.0,
G, AIR_AFFINE(0.0, glyphAniso, 1.0, parm->colIsoGray, G));
B = AIR_AFFINE(0.0, parm->colAnisoModulate, 1.0,
B, AIR_AFFINE(0.0, glyphAniso, 1.0, parm->colIsoGray, B));
/* clamp and do gamma */
R = AIR_CLAMP(0.0, R, 1.0);
G = AIR_CLAMP(0.0, G, 1.0);
B = AIR_CLAMP(0.0, B, 1.0);
R = pow(R, parm->colGamma);
G = pow(G, parm->colGamma);
B = pow(B, parm->colGamma);
/* which is the axis of revolution */
cl = AIR_MIN(0.99, tenAnisoEval_f(eval, tenAniso_Cl1));
cp = AIR_MIN(0.99, tenAnisoEval_f(eval, tenAniso_Cp1));
if (cl > cp) {
axis = 0;
qA = pow(1-cp, parm->sqdSharp);
qB = pow(1-cl, parm->sqdSharp);
} else {
axis = 2;
qA = pow(1-cl, parm->sqdSharp);
qB = pow(1-cp, parm->sqdSharp);
}
/* add the glyph */
if (parm->verbose >= 2) {
fprintf(stderr, "%s: glyph %d/%d: the glyph stays!\n",
me, idx, numGlyphs);
}
if (glyphsLimn) {
lookIdx = limnObjectLookAdd(glyphsLimn);
look = glyphsLimn->look + lookIdx;
ELL_4V_SET_TT(look->rgba, float, R, G, B, 1);
ELL_3V_SET(look->kads, parm->ADSP[0], parm->ADSP[1], parm->ADSP[2]);
look->spow = 0;
switch(parm->glyphType) {
case tenGlyphTypeBox:
glyphIdx = limnObjectCubeAdd(glyphsLimn, lookIdx);
break;
case tenGlyphTypeSphere:
glyphIdx = limnObjectPolarSphereAdd(glyphsLimn, lookIdx, axis,
2*parm->facetRes, parm->facetRes);
break;
case tenGlyphTypeCylinder:
glyphIdx = limnObjectCylinderAdd(glyphsLimn, lookIdx, axis,
parm->facetRes);
break;
case tenGlyphTypeSuperquad:
default:
glyphIdx = limnObjectPolarSuperquadAdd(glyphsLimn, lookIdx, axis,
AIR_CAST(float, qA),
AIR_CAST(float, qB),
2*parm->facetRes,
parm->facetRes);
break;
}
ELL_4M_COPY_TT(mA_f, float, mA);
limnObjectPartTransform(glyphsLimn, glyphIdx, mA_f);
}
if (glyphsEcho) {
switch(parm->glyphType) {
case tenGlyphTypeBox:
eglyph = echoObjectNew(glyphsEcho, echoTypeCube);
/* nothing else to set */
break;
case tenGlyphTypeSphere:
eglyph = echoObjectNew(glyphsEcho, echoTypeSphere);
echoSphereSet(eglyph, 0, 0, 0, 1);
break;
case tenGlyphTypeCylinder:
eglyph = echoObjectNew(glyphsEcho, echoTypeCylinder);
echoCylinderSet(eglyph, axis);
break;
case tenGlyphTypeSuperquad:
default:
eglyph = echoObjectNew(glyphsEcho, echoTypeSuperquad);
echoSuperquadSet(eglyph, axis, qA, qB);
break;
}
echoColorSet(eglyph,
AIR_CAST(echoCol_t, R),
AIR_CAST(echoCol_t, G),
AIR_CAST(echoCol_t, B), 1);
echoMatterPhongSet(glyphsEcho, eglyph,
parm->ADSP[0], parm->ADSP[1],
parm->ADSP[2], parm->ADSP[3]);
inst = echoObjectNew(glyphsEcho, echoTypeInstance);
ELL_4M_COPY(eM, mA);
echoInstanceSet(inst, eM, eglyph);
echoListAdd(list, inst);
}
}
if (glyphsLimn) {
glyphsLimn->setVertexRGBAFromLook = svRGBAfl;
}
if (glyphsEcho) {
split = echoListSplit3(glyphsEcho, list, 10);
echoObjectAdd(glyphsEcho, split);
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *err, *outS;
hestOpt *hopt=NULL;
airArray *mop;
int sx, sy, xi, yi, samp, version, whole, right;
float *tdata;
double p[3], xyz[3], q[4], len, hackcp=0, maxca;
double ca, cp, mD[9], mRF[9], mRI[9], mT[9], hack;
Nrrd *nten;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "n", "# samples", airTypeInt, 1, 1, &samp, "4",
"number of glyphs along each edge of triangle");
hestOptAdd(&hopt, "p", "x y z", airTypeDouble, 3, 3, p, NULL,
"location in quaternion quotient space");
hestOptAdd(&hopt, "ca", "max ca", airTypeDouble, 1, 1, &maxca, "0.8",
"maximum ca to use at bottom edge of triangle");
hestOptAdd(&hopt, "r", NULL, airTypeInt, 0, 0, &right, NULL,
"sample a right-triangle-shaped region, instead of "
"a roughly equilateral triangle. ");
hestOptAdd(&hopt, "w", NULL, airTypeInt, 0, 0, &whole, NULL,
"sample the whole triangle of constant trace, "
"instead of just the "
"sixth of it in which the eigenvalues have the "
"traditional sorted order. ");
hestOptAdd(&hopt, "hack", "hack", airTypeDouble, 1, 1, &hack, "0.04",
"this is a hack");
hestOptAdd(&hopt, "v", "version", airTypeInt, 1, 1, &version, "1",
"which version of the Westin metrics to use to parameterize "
"triangle; \"1\" for ISMRM 97, \"2\" for MICCAI 99");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output file to save tensors 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);
nten = nrrdNew();
airMopAdd(mop, nten, (airMopper)nrrdNuke, airMopAlways);
if (!( 1 == version || 2 == version )) {
fprintf(stderr, "%s: version must be 1 or 2 (not %d)\n", me, version);
airMopError(mop);
return 1;
}
if (right) {
sx = samp;
sy = (int)(1.0*samp/sqrt(3.0));
} else {
sx = 2*samp-1;
sy = samp;
}
if (nrrdMaybeAlloc_va(nten, nrrdTypeFloat, 4,
AIR_CAST(size_t, 7),
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy),
AIR_CAST(size_t, 3))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
q[0] = 1.0;
q[1] = p[0];
q[2] = p[1];
q[3] = p[2];
len = ELL_4V_LEN(q);
ELL_4V_SCALE(q, 1.0/len, q);
washQtoM3(mRF, q);
ELL_3M_TRANSPOSE(mRI, mRF);
if (right) {
_ra2t(nten, 0.00, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.10, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.10, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.20, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.20, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.20, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 20.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 40.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 15.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 45.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 12.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 24.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 36.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 48.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 60.0, mRI, mRF, hack);
/* _ra2t(nten, 0.60, 30.0, mRI, mRF, hack); */
_ra2t(nten, 0.60, 40.0, mRI, mRF, hack);
_ra2t(nten, 0.60, 50.0, mRI, mRF, hack);
_ra2t(nten, 0.60, 60.0, mRI, mRF, hack);
/* _ra2t(nten, 0.70, 34.3, mRI, mRF, hack); */
/* _ra2t(nten, 0.70, 42.8, mRI, mRF, hack); */
_ra2t(nten, 0.70, 51.4, mRI, mRF, hack);
_ra2t(nten, 0.70, 60.0, mRI, mRF, hack);
/* _ra2t(nten, 0.80, 45.0, mRI, mRF, hack); */
_ra2t(nten, 0.80, 52.5, mRI, mRF, hack);
_ra2t(nten, 0.80, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.90, 60.0, mRI, mRF, hack);
_ra2t(nten, 1.00, 60.0, mRI, mRF, hack);
/*
_ra2t(nten, 0.000, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.125, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.125, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.250, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.250, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.250, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 20.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 40.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 15.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 45.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.625, 37.0, mRI, mRF, hack);
_ra2t(nten, 0.625, 47.5, mRI, mRF, hack);
_ra2t(nten, 0.625, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.750, 49.2, mRI, mRF, hack);
_ra2t(nten, 0.750, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.875, 60.0, mRI, mRF, hack);
_ra2t(nten, 1.000, 60.0, mRI, mRF, hack);
*/
nten->axis[1].spacing = 1;
nten->axis[2].spacing = (sx-1)/(sqrt(3.0)*(sy-1));
nten->axis[3].spacing = 1;
} else {
for (yi=0; yi<samp; yi++) {
if (whole) {
ca = AIR_AFFINE(0, yi, samp-1, 0.0, 1.0);
} else {
ca = AIR_AFFINE(0, yi, samp-1, hack, maxca);
hackcp = AIR_AFFINE(0, yi, samp-1, hack, 0);
}
for (xi=0; xi<=yi; xi++) {
if (whole) {
cp = AIR_AFFINE(0, xi, samp-1, 0.0, 1.0);
} else {
cp = AIR_AFFINE(0, xi, samp-1, hackcp, maxca-hack/2.0);
}
_cap2xyz(xyz, ca, cp, version, whole);
/*
fprintf(stderr, "%s: (%d,%d) -> (%g,%g) -> %g %g %g\n", me,
yi, xi, ca, cp, xyz[0], xyz[1], xyz[2]);
*/
ELL_3M_IDENTITY_SET(mD);
ELL_3M_DIAG_SET(mD, xyz[0], xyz[1], xyz[2]);
ELL_3M_IDENTITY_SET(mT);
ell_3m_post_mul_d(mT, mRI);
ell_3m_post_mul_d(mT, mD);
ell_3m_post_mul_d(mT, mRF);
tdata = (float*)nten->data +
7*(2*(samp-1-xi) - (samp-1-yi) + (2*samp-1)*((samp-1-yi) + samp));
tdata[0] = 1.0;
TEN_M2T(tdata, mT);
}
}
nten->axis[1].spacing = 1;
nten->axis[2].spacing = 1.5;
nten->axis[3].spacing = 1;
}
if (nrrdSave(outS, nten, 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;
}
