/*
** creaseProj
**
** eigenvectors (with non-zero eigenvalues) of output posproj are
** tangents to the directions along which particle is allowed to move
** *downward* (in height) for constraint satisfaction (according to
** tangent 1 or tangents 1&2)
**
** negproj is the same, but for points moving upwards (according to
** negativetangent1 or negativetangent 1&2)
*/
static void
creaseProj(pullTask *task, pullPoint *point,
int tang1Use, int tang2Use,
int negtang1Use, int negtang2Use,
/* output */
double posproj[9], double negproj[9]) {
#if PRAYING
static const char me[]="creaseProj";
#endif
double pp[9];
double *tng;
ELL_3M_ZERO_SET(posproj);
if (tang1Use) {
tng = point->info + task->pctx->infoIdx[pullInfoTangent1];
#if PRAYING
fprintf(stderr, "!%s: tng1 = %g %g %g\n", me, tng[0], tng[1], tng[2]);
#endif
ELL_3MV_OUTER(pp, tng, tng);
ELL_3M_ADD2(posproj, posproj, pp);
}
if (tang2Use) {
tng = point->info + task->pctx->infoIdx[pullInfoTangent2];
ELL_3MV_OUTER(pp, tng, tng);
ELL_3M_ADD2(posproj, posproj, pp);
}
ELL_3M_ZERO_SET(negproj);
if (negtang1Use) {
tng = point->info + task->pctx->infoIdx[pullInfoNegativeTangent1];
ELL_3MV_OUTER(pp, tng, tng);
ELL_3M_ADD2(negproj, negproj, pp);
}
if (negtang2Use) {
tng = point->info + task->pctx->infoIdx[pullInfoNegativeTangent2];
ELL_3MV_OUTER(pp, tng, tng);
ELL_3M_ADD2(negproj, negproj, pp);
}
if (!tang1Use && !tang2Use && !negtang1Use && !negtang2Use) {
/* we must be after points, and so need freedom to go after them */
/* for now we do this via posproj not negproj; see haveNada below */
ELL_3M_IDENTITY_SET(posproj);
}
return;
}
int
tend_helixMain(int argc, char **argv, char *me, hestParm *hparm) {
int pret;
hestOpt *hopt = NULL;
char *perr, *err;
airArray *mop;
int size[3], nit;
Nrrd *nout;
double R, r, S, bnd, angle, ev[3], ip[3], iq[4], mp[3], mq[4], tmp[9],
orig[3], i2w[9], rot[9], mf[9], spd[4][3], bge;
char *outS;
hestOptAdd(&hopt, "s", "size", airTypeInt, 3, 3, size, NULL,
"sizes along fast, medium, and slow axes of the sampled volume, "
"often called \"X\", \"Y\", and \"Z\". It is best to use "
"slightly different sizes here, to expose errors in interpreting "
"axis ordering (e.g. \"-s 39 40 41\")");
hestOptAdd(&hopt, "ip", "image orientation", airTypeDouble, 3, 3, ip,
"0 0 0",
"quaternion quotient space orientation of image");
hestOptAdd(&hopt, "mp", "measurement orientation", airTypeDouble, 3, 3, mp,
"0 0 0",
"quaternion quotient space orientation of measurement frame");
hestOptAdd(&hopt, "b", "boundary", airTypeDouble, 1, 1, &bnd, "10",
"parameter governing how fuzzy the boundary between high and "
"low anisotropy is. Use \"-b 0\" for no fuzziness");
hestOptAdd(&hopt, "r", "little radius", airTypeDouble, 1, 1, &r, "30",
"(minor) radius of cylinder tracing helix");
hestOptAdd(&hopt, "R", "big radius", airTypeDouble, 1, 1, &R, "50",
"(major) radius of helical turns");
hestOptAdd(&hopt, "S", "spacing", airTypeDouble, 1, 1, &S, "100",
"spacing between turns of helix (along its axis)");
hestOptAdd(&hopt, "a", "angle", airTypeDouble, 1, 1, &angle, "60",
"maximal angle of twist of tensors along path. There is no "
"twist at helical core of path, and twist increases linearly "
"with radius around this path. Positive twist angle with "
"positive spacing resulting in a right-handed twist around a "
"right-handed helix. ");
hestOptAdd(&hopt, "nit", NULL, airTypeInt, 0, 0, &nit, NULL,
"changes behavior of twist angle as function of distance from "
"center of helical core: instead of increasing linearly as "
"describe above, be at a constant angle");
hestOptAdd(&hopt, "ev", "eigenvalues", airTypeDouble, 3, 3, ev,
"0.006 0.002 0.001",
"eigenvalues of tensors (in order) along direction of coil, "
"circumferential around coil, and radial around coil. ");
hestOptAdd(&hopt, "bg", "background", airTypeDouble, 1, 1, &bge, "0.5",
"eigenvalue of isotropic background");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output file");
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
USAGE(_tend_helixInfoL);
JUSTPARSE();
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(nout, nrrdTypeFloat, 4,
AIR_CAST(size_t, 7),
AIR_CAST(size_t, size[0]),
AIR_CAST(size_t, size[1]),
AIR_CAST(size_t, size[2]))) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble allocating output:\n%s\n", me, err);
airMopError(mop); return 1;
}
ELL_4V_SET(iq, 1.0, ip[0], ip[1], ip[2]);
ell_q_to_3m_d(rot, iq);
ELL_3V_SET(orig,
-2*R + 2*R/size[0],
-2*R + 2*R/size[1],
-2*R + 2*R/size[2]);
ELL_3M_ZERO_SET(i2w);
ELL_3M_DIAG_SET(i2w, 4*R/size[0], 4*R/size[1], 4*R/size[2]);
ELL_3MV_MUL(tmp, rot, orig);
ELL_3V_COPY(orig, tmp);
ELL_3M_MUL(tmp, rot, i2w);
ELL_3M_COPY(i2w, tmp);
ELL_4V_SET(mq, 1.0, mp[0], mp[1], mp[2]);
ell_q_to_3m_d(mf, mq);
tend_helixDoit(nout, bnd,
orig, i2w, mf,
r, R, S, angle*AIR_PI/180, !nit, ev, bge);
nrrdSpaceSet(nout, nrrdSpaceRightAnteriorSuperior);
nrrdSpaceOriginSet(nout, orig);
ELL_3V_SET(spd[0], AIR_NAN, AIR_NAN, AIR_NAN);
ELL_3MV_COL0_GET(spd[1], i2w);
ELL_3MV_COL1_GET(spd[2], i2w);
ELL_3MV_COL2_GET(spd[3], i2w);
nrrdAxisInfoSet_va(nout, nrrdAxisInfoSpaceDirection,
spd[0], spd[1], spd[2], spd[3]);
nrrdAxisInfoSet_va(nout, nrrdAxisInfoCenter,
nrrdCenterUnknown, nrrdCenterCell,
nrrdCenterCell, nrrdCenterCell);
nrrdAxisInfoSet_va(nout, nrrdAxisInfoKind,
nrrdKind3DMaskedSymMatrix, nrrdKindSpace,
nrrdKindSpace, nrrdKindSpace);
nout->measurementFrame[0][0] = mf[0];
nout->measurementFrame[1][0] = mf[1];
nout->measurementFrame[2][0] = mf[2];
nout->measurementFrame[0][1] = mf[3];
nout->measurementFrame[1][1] = mf[4];
nout->measurementFrame[2][1] = mf[5];
nout->measurementFrame[0][2] = mf[6];
nout->measurementFrame[1][2] = mf[7];
nout->measurementFrame[2][2] = mf[8];
if (nrrdSave(outS, nout, NULL)) {
airMopAdd(mop, err=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble writing:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
/* Calculates 2 new centroids (and a new segmentation) from distances
between Q-balls and centroids, returns true if segmentation changed
*/
int
_tenCalccent2(const int gradcount, const double qpoints[],
const double dists[], double centroid[6], unsigned int seg[]) {
#if 0
/* HEY: Attempt to implement better line-adding by adding
outerproducts of points and estimating major eigenvector
afterwards */
int i,changed=AIR_FALSE;
double sum0[9],sum1[9],mat[9], eval[3],evec[9];
ELL_3M_ZERO_SET( sum0 );
ELL_3M_ZERO_SET( sum1 );
for( i = 0; i < gradcount; i++ ) {
if( dists[i] < dists[gradcount+i] ) {
ELL_3MV_OUTER( mat, qpoints +3*i, qpoints +3*i );
ELL_3M_ADD2( sum0, sum0, mat );
changed = changed || (seg[i] != 0);
seg[i] = 0;
} else {
ELL_3MV_OUTER( mat, qpoints +3*i +gradcount, qpoints +3*i +gradcount );
ELL_3M_ADD2( sum1, sum1, mat );
changed = changed || (seg[i] != 1);
seg[i] = 1;
}
}
ell_3m_eigensolve_d( eval, evec, sum0, 0 );
ELL_3V_COPY( centroid, evec + 3*ELL_MAX3_IDX( eval[0], eval[1], eval[2] ) );
/* ELL_3V_SCALE( centroid, ELL_3V_LEN( centroid ), centroid ); */
ell_3m_eigensolve_d( eval, evec, sum1, 0 );
ELL_3V_COPY( centroid +3, evec + 3*ELL_MAX3_IDX( eval[0], eval[1], eval[2] ) );
/* ELL_3V_SCALE( centroid +3, ELL_3V_LEN( centroid ), centroid +3); Normalize */
return changed;
#endif
int i, sign, seg0count=0, seg1count=0, changed=AIR_FALSE;
double oldcentroid[6], diff[3], sum[3];
memcpy( oldcentroid, centroid, 6 * sizeof( double ));
for( i = 0; i < gradcount; i++ ) {
if( dists[ 0*gradcount +i] < dists[1*gradcount +i] ) {
/* Try to resolve sign so that centroid do not end up as all 0 */
/* Choose signs so that the point lies "on the same side" as */
/* the previous centroid. */
diff[0] = oldcentroid[0] - qpoints[3*i +0];
diff[1] = oldcentroid[1] - qpoints[3*i +1];
diff[2] = oldcentroid[2] - qpoints[3*i +2];
sum[0] = oldcentroid[0] + qpoints[3*i +0];
sum[1] = oldcentroid[1] + qpoints[3*i +1];
sum[2] = oldcentroid[2] + qpoints[3*i +2];
sign = (diff[0]*diff[0] + diff[1]*diff[1] + diff[2]*diff[2]) <
(sum[0]*sum[0] + sum[1]*sum[1] + sum[2]*sum[2]) ? -1 : +1;
changed = changed || (seg[i] != 0);
seg[i] = 0;
centroid[0] += sign * qpoints[3*i +0];
centroid[1] += sign * qpoints[3*i +1];
centroid[2] += sign * qpoints[3*i +2];
seg0count++;
} else {
diff[0] = oldcentroid[3+0] - qpoints[3*i +0];
diff[1] = oldcentroid[3+1] - qpoints[3*i +1];
diff[2] = oldcentroid[3+2] - qpoints[3*i +2];
sum[0] = oldcentroid[3+0] + qpoints[3*i +0];
sum[1] = oldcentroid[3+1] + qpoints[3*i +1];
sum[2] = oldcentroid[3+2] + qpoints[3*i +2];
sign = (diff[0]*diff[0] + diff[1]*diff[1] + diff[2]*diff[2]) <
(sum[0]*sum[0] + sum[1]*sum[1] + sum[2]*sum[2]) ? -1 : +1;
changed = changed || (seg[i] != 1);
seg[i] = 1;
centroid[3+0] += sign * qpoints[3*i +0];
centroid[3+1] += sign * qpoints[3*i +1];
centroid[3+2] += sign * qpoints[3*i +2];
seg1count++;
}
}
centroid[0] /= seg0count;
centroid[1] /= seg0count;
centroid[2] /= seg0count;
centroid[3+0] /= seg1count;
centroid[3+1] /= seg1count;
centroid[3+2] /= seg1count;
/* printf("cent = %f %f %f %f %f %f\n", centroid[0],centroid[1],centroid[2],centroid[3],centroid[4],centroid[5] ); */
/*
Should give error if any segment contains less than 6 elements,
i.e. if( seg0count < 6 || seg1count < 6 ), since that would
imply that a tensor cannot be computed for that segment.
*/
return changed;
}
void
_gageSclAnswer (gageContext *ctx, gagePerVolume *pvl) {
char me[]="_gageSclAnswer";
double gmag=0, *hess, *norm, *gvec, *gten, *k1, *k2, curv=0,
sHess[9]={0,0,0,0,0,0,0,0,0};
double tmpMat[9], tmpVec[3], hevec[9], heval[3];
double len, gp1[3], gp2[3], *nPerp, ncTen[9], nProj[9]={0,0,0,0,0,0,0,0,0};
double alpha = 0.5;
double beta = 0.5;
double gamma = 5;
double cc = 1e-6;
#define FD_MEDIAN_MAX 16
int fd, nidx, xi, yi, zi;
double *fw, iv3wght[2*FD_MEDIAN_MAX*FD_MEDIAN_MAX*FD_MEDIAN_MAX],
wghtSum, wght;
/* convenience pointers for work below */
hess = pvl->directAnswer[gageSclHessian];
gvec = pvl->directAnswer[gageSclGradVec];
norm = pvl->directAnswer[gageSclNormal];
nPerp = pvl->directAnswer[gageSclNPerp];
gten = pvl->directAnswer[gageSclGeomTens];
k1 = pvl->directAnswer[gageSclK1];
k2 = pvl->directAnswer[gageSclK2];
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclValue)) {
/* done if doV */
if (ctx->verbose) {
fprintf(stderr, "%s: val = % 15.7f\n", me,
(double)(pvl->directAnswer[gageSclValue][0]));
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGradVec)) {
/* done if doD1 */
if (ctx->verbose) {
fprintf(stderr, "%s: gvec = ", me);
ell_3v_print_d(stderr, gvec);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGradMag)) {
/* this is the true value of gradient magnitude */
gmag = pvl->directAnswer[gageSclGradMag][0] = sqrt(ELL_3V_DOT(gvec, gvec));
}
/* NB: it would seem that gageParmGradMagMin is completely ignored ... */
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclNormal)) {
if (gmag) {
ELL_3V_SCALE(norm, 1/gmag, gvec);
/* polishing ...
len = sqrt(ELL_3V_DOT(norm, norm));
ELL_3V_SCALE(norm, 1/len, norm);
*/
} else {
ELL_3V_COPY(norm, gageZeroNormal);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclNPerp)) {
/* nPerp = I - outer(norm, norm) */
/* NB: this sets both nPerp and nProj */
ELL_3MV_OUTER(nProj, norm, norm);
ELL_3M_SCALE(nPerp, -1, nProj);
nPerp[0] += 1;
nPerp[4] += 1;
nPerp[8] += 1;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessian)) {
/* done if doD2 */
if (ctx->verbose) {
fprintf(stderr, "%s: hess = \n", me);
ell_3m_print_d(stderr, hess);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclLaplacian)) {
pvl->directAnswer[gageSclLaplacian][0] = hess[0] + hess[4] + hess[8];
if (ctx->verbose) {
fprintf(stderr, "%s: lapl = %g + %g + %g = %g\n", me,
hess[0], hess[4], hess[8],
pvl->directAnswer[gageSclLaplacian][0]);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessFrob)) {
pvl->directAnswer[gageSclHessFrob][0] = ELL_3M_FROB(hess);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessEval)) {
/* HEY: look at the return value for root multiplicity? */
ell_3m_eigensolve_d(heval, hevec, hess, AIR_TRUE);
ELL_3V_COPY(pvl->directAnswer[gageSclHessEval], heval);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessEvec)) {
ELL_3M_COPY(pvl->directAnswer[gageSclHessEvec], hevec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessRidgeness)) {
double A, B, S;
if (heval[1] >0 || heval[2]>0) {
pvl->directAnswer[gageSclHessRidgeness][0] = 0;
}
else if (AIR_ABS(heval[1])<1e-10 || AIR_ABS(heval[2])<1e-10) {
pvl->directAnswer[gageSclHessRidgeness][0] = 0;
}
else {
double *ans;
A = AIR_ABS(heval[1])/AIR_ABS(heval[2]);
B = AIR_ABS(heval[0])/sqrt(AIR_ABS(heval[1]*heval[2]));
S = sqrt(heval[0]*heval[0] + heval[1]*heval[1] + heval[2]*heval[2]);
ans = pvl->directAnswer[gageSclHessRidgeness];
ans[0] = (1-exp(-A*A/(2*alpha*alpha))) *
exp(-B*B/(2*beta*beta)) *
(1-exp(-S*S/(2*gamma*gamma))) *
exp(-2*cc*cc/(AIR_ABS(heval[1])*heval[2]*heval[2]));
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessValleyness)) {
double A, B, S;
if (heval[0] <0 || heval[1]<0) {
pvl->directAnswer[gageSclHessValleyness][0] = 0;
}
else if (AIR_ABS(heval[0])<1e-10 || AIR_ABS(heval[1])<1e-10) {
pvl->directAnswer[gageSclHessValleyness][0] = 0;
}
else {
double *ans;
A = AIR_ABS(heval[1])/AIR_ABS(heval[0]);
B = AIR_ABS(heval[2])/sqrt(AIR_ABS(heval[1]*heval[0]));
S = sqrt(heval[0]*heval[0] + heval[1]*heval[1] + heval[2]*heval[2]);
ans = pvl->directAnswer[gageSclHessValleyness];
ans[0] = (1-exp(-A*A/(2*alpha*alpha))) *
exp(-B*B/(2*beta*beta)) *
(1-exp(-S*S/(2*gamma*gamma))) *
exp(-2*cc*cc/(AIR_ABS(heval[1])*heval[0]*heval[0]));
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclHessMode)) {
pvl->directAnswer[gageSclHessMode][0] = airMode3_d(heval);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageScl2ndDD)) {
ELL_3MV_MUL(tmpVec, hess, norm);
pvl->directAnswer[gageScl2ndDD][0] = ELL_3V_DOT(norm, tmpVec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGeomTens)) {
if (gmag > ctx->parm.gradMagCurvMin) {
/* parm.curvNormalSide applied here to determine the sense of the
normal when doing all curvature calculations */
ELL_3M_SCALE(sHess, -(ctx->parm.curvNormalSide)/gmag, hess);
/* gten = nPerp * sHess * nPerp */
ELL_3M_MUL(tmpMat, sHess, nPerp);
ELL_3M_MUL(gten, nPerp, tmpMat);
if (ctx->verbose) {
fprintf(stderr, "%s: gten: \n", me);
ell_3m_print_d(stderr, gten);
ELL_3MV_MUL(tmpVec, gten, norm);
len = ELL_3V_LEN(tmpVec);
fprintf(stderr, "%s: should be small: %30.15f\n", me, (double)len);
ell_3v_perp_d(gp1, norm);
ELL_3MV_MUL(tmpVec, gten, gp1);
len = ELL_3V_LEN(tmpVec);
fprintf(stderr, "%s: should be bigger: %30.15f\n", me, (double)len);
ELL_3V_CROSS(gp2, gp1, norm);
ELL_3MV_MUL(tmpVec, gten, gp2);
len = ELL_3V_LEN(tmpVec);
fprintf(stderr, "%s: should (also) be bigger: %30.15f\n",
me, (double)len);
}
} else {
ELL_3M_ZERO_SET(gten);
}
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclTotalCurv)) {
curv = pvl->directAnswer[gageSclTotalCurv][0] = ELL_3M_FROB(gten);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclShapeTrace)) {
pvl->directAnswer[gageSclShapeTrace][0] = (curv
? ELL_3M_TRACE(gten)/curv
: 0);
}
if ( (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclK1)) ||
(GAGE_QUERY_ITEM_TEST(pvl->query, gageSclK2)) ){
double T, N, D;
T = ELL_3M_TRACE(gten);
N = curv;
D = 2*N*N - T*T;
/*
if (D < -0.0000001) {
fprintf(stderr, "%s: %g %g\n", me, T, N);
fprintf(stderr, "%s: !!! D curv determinant % 22.10f < 0.0\n", me, D);
fprintf(stderr, "%s: gten: \n", me);
ell_3m_print_d(stderr, gten);
}
*/
D = AIR_MAX(D, 0);
D = sqrt(D);
k1[0] = 0.5*(T + D);
k2[0] = 0.5*(T - D);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclMeanCurv)) {
pvl->directAnswer[gageSclMeanCurv][0] = (*k1 + *k2)/2;
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclGaussCurv)) {
pvl->directAnswer[gageSclGaussCurv][0] = (*k1)*(*k2);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclShapeIndex)) {
pvl->directAnswer[gageSclShapeIndex][0] =
-(2/AIR_PI)*atan2(*k1 + *k2, *k1 - *k2);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclCurvDir1)) {
/* HEY: this only works when K1, K2, 0 are all well mutually distinct,
since these are the eigenvalues of the geometry tensor, and this
code assumes that the eigenspaces are all one-dimensional */
ELL_3M_COPY(tmpMat, gten);
ELL_3M_DIAG_SET(tmpMat, gten[0] - *k1, gten[4]- *k1, gten[8] - *k1);
ell_3m_1d_nullspace_d(tmpVec, tmpMat);
ELL_3V_COPY(pvl->directAnswer[gageSclCurvDir1], tmpVec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclCurvDir2)) {
/* HEY: this only works when K1, K2, 0 are all well mutually distinct,
since these are the eigenvalues of the geometry tensor, and this
code assumes that the eigenspaces are all one-dimensional */
ELL_3M_COPY(tmpMat, gten);
ELL_3M_DIAG_SET(tmpMat, gten[0] - *k2, gten[4] - *k2, gten[8] - *k2);
ell_3m_1d_nullspace_d(tmpVec, tmpMat);
ELL_3V_COPY(pvl->directAnswer[gageSclCurvDir2], tmpVec);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclFlowlineCurv)) {
if (gmag >= ctx->parm.gradMagCurvMin) {
/* because of the gageSclGeomTens prerequisite, sHess, nPerp, and
nProj are all already set */
/* ncTen = nPerp * sHess * nProj */
ELL_3M_MUL(tmpMat, sHess, nProj);
ELL_3M_MUL(ncTen, nPerp, tmpMat);
} else {
ELL_3M_ZERO_SET(ncTen);
}
/* there used to be a wrong extra sqrt() here */
pvl->directAnswer[gageSclFlowlineCurv][0] = ELL_3M_FROB(ncTen);
}
if (GAGE_QUERY_ITEM_TEST(pvl->query, gageSclMedian)) {
/* this item is currently a complete oddball in that it does not
benefit from anything done in the "filter" stage, which is in
fact a waste of time if the query consists only of this item */
fd = 2*ctx->radius;
if (fd > FD_MEDIAN_MAX) {
fprintf(stderr, "%s: PANIC: current filter diameter = %d "
"> FD_MEDIAN_MAX = %d\n", me, fd, FD_MEDIAN_MAX);
exit(1);
}
fw = ctx->fw + fd*3*gageKernel00;
/* HEY: this needs some optimization help */
wghtSum = 0;
nidx = 0;
for (xi=0; xi<fd; xi++) {
for (yi=0; yi<fd; yi++) {
for (zi=0; zi<fd; zi++) {
iv3wght[0 + 2*nidx] = pvl->iv3[nidx];
iv3wght[1 + 2*nidx] = fw[xi + 0*fd]*fw[yi + 1*fd]*fw[zi + 2*fd];
wghtSum += iv3wght[1 + 2*nidx];
nidx++;
}
}
}
qsort(iv3wght, fd*fd*fd, 2*sizeof(double), nrrdValCompare[nrrdTypeDouble]);
wght = 0;
for (nidx=0; nidx<fd*fd*fd; nidx++) {
wght += iv3wght[1 + 2*nidx];
if (wght > wghtSum/2) {
break;
}
}
pvl->directAnswer[gageSclMedian][0] = iv3wght[0 + 2*nidx];
}
return;
}
