void
_tenFiberAlign(tenFiberContext *tfx, double vec[3]) {
if (!(tfx->lastDirSet)) {
/* this is the first step (or one of the intermediate steps
for RK4) in this fiber half; 1st half follows the
eigenvector determined at seed point, 2nd goes opposite */
if (!tfx->dir) {
/* 1st half */
if (ELL_3V_DOT(tfx->firstEvec, vec) < 0) {
ELL_3V_SCALE(vec, -1, vec);
}
} else {
/* 2nd half */
if (ELL_3V_DOT(tfx->firstEvec, vec) > 0) {
ELL_3V_SCALE(vec, -1, vec);
}
}
} else {
/* we have some history in this fiber half */
if (ELL_3V_DOT(tfx->lastDir, vec) < 0) {
ELL_3V_SCALE(vec, -1, vec);
}
}
return;
}
int
_tenFiberIntegrate_Euler(tenFiberContext *tfx, double forwDir[3]) {
_tenFiberStep[tfx->fiberType](tfx, forwDir);
ELL_3V_SCALE(forwDir, tfx->stepSize, forwDir);
return 0;
}
int
tenDWMRIKeyValueFromExperSpecSet(Nrrd *ndwi, const tenExperSpec *espec) {
static char me[]="tenDWMRIKeyValueFromExperSpecSet";
char keystr[AIR_STRLEN_MED], valstr[AIR_STRLEN_MED];
double maxb, bb;
unsigned int ii;
if (!(ndwi && espec)) {
biffAddf(TEN, "%s: got NULL pointer", me);
return 1;
}
nrrdKeyValueAdd(ndwi, tenDWMRIModalityKey, tenDWMRIModalityVal);
maxb = tenExperSpecMaxBGet(espec);
sprintf(valstr, "%.17g", maxb);
nrrdKeyValueAdd(ndwi, tenDWMRIBValueKey, valstr);
for (ii=0; ii<espec->imgNum; ii++) {
double vec[3];
sprintf(keystr, tenDWMRIGradKeyFmt, ii);
ELL_3V_COPY(vec, espec->grad + 3*ii);
bb = espec->bval[ii];
/* Thu Dec 20 03:25:20 CST 2012 this rescaling is not, btw,
what is causing the small discrepency between ngrad before
and after saving to KVPs */
ELL_3V_SCALE(vec, sqrt(bb/maxb), vec);
sprintf(valstr, "%.17g %.17g %.17g", vec[0], vec[1], vec[2]);
nrrdKeyValueAdd(ndwi, keystr, valstr);
}
/* HEY what if its a full B-matrix? */
return 0;
}
/*
******** ell_3m_eigenvalues_d()
**
** finds eigenvalues of given matrix.
**
** returns information about the roots according to ellCubeRoot enum,
** see header for ellCubic for details.
**
** given matrix is NOT modified
**
** This does NOT use biff
**
** Doing the frobenius normalization proved successfull in avoiding the
** the creating of NaN eigenvalues when the coefficients of the matrix
** were really large (> 50000). Also, when the matrix norm was really
** small, the comparison to "epsilon" in ell_cubic mistook three separate
** roots for a single and a double, with this matrix in particular:
** 1.7421892 0.0137642 0.0152975
** 0.0137642 1.7565432 -0.0062296
** 0.0152975 -0.0062296 1.7700019
** (actually, this is prior to tenEigensolve's isotropic removal)
**
** HEY: tenEigensolve_d and tenEigensolve_f start by removing the
** isotropic part of the tensor. It may be that that smarts should
** be migrated here, but GLK is uncertain how it would change the
** handling of non-symmetric matrices.
*/
int
ell_3m_eigenvalues_d(double _eval[3], const double _m[9], const int newton) {
double A, B, C, scale, frob, m[9], eval[3];
int roots;
frob = ELL_3M_FROB(_m);
scale = frob ? 1.0/frob : 1.0;
ELL_3M_SCALE(m, scale, _m);
/*
printf("!%s: m = %g %g %g; %g %g %g; %g %g %g\n", "ell_3m_eigenvalues_d",
m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
*/
/*
** from gordon with mathematica; these are the coefficients of the
** cubic polynomial in x: det(x*I - M). The full cubic is
** x^3 + A*x^2 + B*x + C.
*/
A = -m[0] - m[4] - m[8];
B = m[0]*m[4] - m[3]*m[1]
+ m[0]*m[8] - m[6]*m[2]
+ m[4]*m[8] - m[7]*m[5];
C = (m[6]*m[4] - m[3]*m[7])*m[2]
+ (m[0]*m[7] - m[6]*m[1])*m[5]
+ (m[3]*m[1] - m[0]*m[4])*m[8];
/*
printf("!%s: A B C = %g %g %g\n", "ell_3m_eigenvalues_d", A, B, C);
*/
roots = ell_cubic(eval, A, B, C, newton);
/* no longer need to sort here */
ELL_3V_SCALE(_eval, 1.0/scale, eval);
return roots;
}
int
echoRayIntx(echoIntx *intx, echoRay *ray, echoScene *scene,
echoRTParm *parm, echoThreadState *tstate) {
unsigned int idx;
int ret;
echoObject *kid;
echoPos_t tmp;
_echoVerbose = tstate->verbose;
ret = AIR_FALSE;
for (idx=0; idx<scene->rendArr->len; idx++) {
kid = scene->rend[idx];
if (_echoRayIntx[kid->type](intx, ray, kid, parm, tstate)) {
ray->faar = intx->t;
ret = AIR_TRUE;
if (ray->shadow) {
/* no point in testing any further */
return ret;
}
}
}
if (ret) {
/* being here means we're not a shadow ray */
ELL_3V_SCALE_ADD2(intx->pos, 1, ray->from, intx->t, ray->dir);
ELL_3V_SCALE(intx->view, -1, ray->dir);
ELL_3V_NORM(intx->view, intx->view, tmp);
/* this is needed for phong materials; for glass and metal,
it is either used directly, or as a reference in fuzzification */
_ECHO_REFLECT(intx->refl, intx->norm, intx->view, tmp);
}
return ret;
}
/*
******** tenGradientRandom
**
** generates num random unit vectors of type double
*/
int
tenGradientRandom(Nrrd *ngrad, unsigned int num, unsigned int seed) {
static const char me[]="tenGradientRandom";
double *grad, len;
unsigned int gi;
if (nrrdMaybeAlloc_va(ngrad, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, num))) {
biffMovef(TEN, NRRD, "%s: couldn't allocate output", me);
return 1;
}
airSrandMT(seed);
grad = AIR_CAST(double*, ngrad->data);
for (gi=0; gi<num; gi++) {
do {
grad[0] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1);
grad[1] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1);
grad[2] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1);
len = ELL_3V_LEN(grad);
} while (len > 1 || !len);
ELL_3V_SCALE(grad, 1.0/len, grad);
grad += 3;
}
return 0;
}
void
testeigen(double tt[7], double eval[3], double evec[9]) {
double mat[9], dot[3], cross[3];
unsigned int ii;
TEN_T2M(mat, tt);
printf("evals %g %g %g\n", eval[0], eval[1], eval[2]);
printf("evec0 (%g) %g %g %g\n",
ELL_3V_LEN(evec + 0), evec[0], evec[1], evec[2]);
printf("evec1 (%g) %g %g %g\n",
ELL_3V_LEN(evec + 3), evec[3], evec[4], evec[5]);
printf("evec2 (%g) %g %g %g\n",
ELL_3V_LEN(evec + 6), evec[6], evec[7], evec[8]);
printf("Mv - lv: (len) X Y Z (should be ~zeros)\n");
for (ii=0; ii<3; ii++) {
double uu[3], vv[3], dd[3];
ELL_3MV_MUL(uu, mat, evec + 3*ii);
ELL_3V_SCALE(vv, eval[ii], evec + 3*ii);
ELL_3V_SUB(dd, uu, vv);
printf("%d: (%g) %g %g %g\n", ii, ELL_3V_LEN(dd), dd[0], dd[1], dd[2]);
}
dot[0] = ELL_3V_DOT(evec + 0, evec + 3);
dot[1] = ELL_3V_DOT(evec + 0, evec + 6);
dot[2] = ELL_3V_DOT(evec + 3, evec + 6);
printf("pairwise dots: (%g) %g %g %g\n",
ELL_3V_LEN(dot), dot[0], dot[1], dot[2]);
ELL_3V_CROSS(cross, evec+0, evec+3);
printf("right-handed: %g\n", ELL_3V_DOT(evec+6, cross));
return;
}
/*
** leaves v+3*0 untouched, but makes sure that v+3*0, v+3*1, and v+3*2
** are mutually orthogonal. Also leaves the magnitudes of all
** vectors unchanged.
*/
void
_ell_3m_enforce_orthogonality(double v[9]) {
double d00, d10, d11, d20, d21, d22, scl, tv[3];
d00 = ELL_3V_DOT(v+3*0, v+3*0);
d10 = ELL_3V_DOT(v+3*1, v+3*0);
d11 = ELL_3V_DOT(v+3*1, v+3*1);
ELL_3V_SCALE_ADD2(tv, 1, v+3*1, -d10/d00, v+3*0);
scl = sqrt(d11/ELL_3V_DOT(tv, tv));
ELL_3V_SCALE(v+3*1, scl, tv);
d20 = ELL_3V_DOT(v+3*2, v+3*0);
d21 = ELL_3V_DOT(v+3*2, v+3*1);
d22 = ELL_3V_DOT(v+3*2, v+3*2);
ELL_3V_SCALE_ADD3(tv, 1, v+3*2, -d20/d00, v+3*0, -d21/d00, v+3*1);
scl = sqrt(d22/ELL_3V_DOT(tv, tv));
ELL_3V_SCALE(v+3*2, scl, tv);
return;
}
/*
** makes sure that v+3*2 has a positive dot product with
** cross product of v+3*0 and v+3*1
*/
void
_ell_3m_make_right_handed_d(double v[9]) {
double x[3];
ELL_3V_CROSS(x, v+3*0, v+3*1);
if (0 > ELL_3V_DOT(x, v+3*2)) {
ELL_3V_SCALE(v+3*2, -1, v+3*2);
}
}
void
gageShapeItoW(gageShape *shape, double _world[3], double _index[3]) {
double world[4], index[4];
ELL_3V_COPY(index, _index);
index[3] = 1.0;
ELL_4MV_MUL(world, shape->ItoW, index);
ELL_3V_SCALE(_world, 1.0/world[3], world);
}
void
gageShapeWtoI(gageShape *shape, double _index[3], double _world[3]) {
double index[4], world[4];
ELL_3V_COPY(world, _world);
world[3] = 1.0;
ELL_4MV_MUL(index, shape->WtoI, world);
ELL_3V_SCALE(_index, 1.0/index[3], index);
}
void
_ell_align3_d(double v[9]) {
double d0, d1, d2;
int Mi, ai, bi;
d0 = ELL_3V_DOT(v+0, v+0);
d1 = ELL_3V_DOT(v+3, v+3);
d2 = ELL_3V_DOT(v+6, v+6);
Mi = ELL_MAX3_IDX(d0, d1, d2);
ai = (Mi + 1) % 3;
bi = (Mi + 2) % 3;
/* lop A */
if (ELL_3V_DOT(v+3*Mi, v+3*ai) < 0) {
ELL_3V_SCALE(v+3*ai, -1, v+3*ai);
}
if (ELL_3V_DOT(v+3*Mi, v+3*bi) < 0) {
ELL_3V_SCALE(v+3*bi, -1, v+3*bi);
}
/* lob B */
/* we can't guarantee that dot(v+3*ai,v+3*bi) > 0 . . . */
}
/*
** assign random signs to the vectors and measures the length of their
** mean, as quickly as possible
*/
static double
party(Nrrd *npos, airRandMTState *rstate) {
double *pos, mean[3];
unsigned int ii, num, rnd, rndBit;
pos = (double *)(npos->data);
num = AIR_UINT(npos->axis[1].size);
rnd = airUIrandMT_r(rstate);
rndBit = 0;
ELL_3V_SET(mean, 0, 0, 0);
for (ii=0; ii<num; ii++) {
if (32 == rndBit) {
rnd = airUIrandMT_r(rstate);
rndBit = 0;
}
if (rnd & (1 << rndBit++)) {
ELL_3V_SCALE(pos + 3*ii, -1, pos + 3*ii);
}
ELL_3V_INCR(mean, pos + 3*ii);
}
ELL_3V_SCALE(mean, 1.0/num, mean);
return ELL_3V_LEN(mean);
}
/*
******* echoLightColor()
**
** sets "col" to RGB color for current sample of given light, which
** is at distance Ldist. Knowing distance allows computation of the
** inverse square fall-off of light intensity
*/
void
echoLightColor(echoCol_t rgb[3], echoPos_t Ldist,
echoObject *light, echoRTParm *parm, echoThreadState *tstate) {
echoCol_t rgba[4], falloff;
echoPos_t x, y;
x = tstate->jitt[0 + 2*echoJittableLight] + 0.5;
y = tstate->jitt[1 + 2*echoJittableLight] + 0.5;
if (light->ntext) {
echoTextureLookup(rgba, light->ntext, x, y, parm);
ELL_3V_COPY(rgb, rgba);
} else {
ELL_3V_COPY(rgb, light->rgba);
}
ELL_3V_SCALE(rgb, light->mat[echoMatterLightPower], rgb);
if (light->mat[echoMatterLightUnit]) {
falloff = AIR_CAST(echoCol_t, light->mat[echoMatterLightUnit]/Ldist);
falloff *= falloff;
ELL_3V_SCALE(rgb, falloff, rgb);
}
return;
}
void
gageShapeWtoI(gageShape *shape, double _index[3], double _world[3]) {
/* char me[]="gageShapeWtoI"; */
double index[4], world[4];
/*
fprintf(stderr, "!%s: hello %p %p %p; %p\n", me,
shape, _index, _world, shape->WtoI);
*/
ELL_3V_COPY(world, _world);
world[3] = 1.0;
ELL_4MV_MUL(index, shape->WtoI, world);
ELL_3V_SCALE(_index, 1.0/index[3], index);
}
/*
** parm[0]: lerp between 1 and the stuff below
** parm[1]: "t": (parm[1],0) is control point between (0,0) and (1,1)
** parm[2]: "d": parabolic blend between parm[1]-parm[2] and parm[1]+parm[2]
*/
void
_tenFiberAnisoSpeed(double *step, double xx, double parm[3]) {
double aa, dd, tt, yy;
tt = parm[1];
dd = parm[2];
aa = 1.0/(DBL_EPSILON + 4*dd*(1.0-tt));
yy = xx - tt + dd;
xx = (xx < tt - dd
? 0
: (xx < tt + dd
? aa*yy*yy
: (xx - tt)/(1 - tt)));
xx = AIR_LERP(parm[0], 1, xx);
ELL_3V_SCALE(step, xx, step);
}
/* unlike with the K stuff, with the R stuff I seemed to have more luck
implementing pair-wise interpolation in terms of log and exp
*/
void
tenQGLInterpTwoEvalR(double oeval[3],
const double evalA[3], const double evalB[3],
const double tt) {
double RThPhA[3], RThPhB[3], rlog[3], oRThPh[3];
tenTripleConvertSingle_d(RThPhA, tenTripleTypeRThetaPhi,
evalA, tenTripleTypeEigenvalue);
tenTripleConvertSingle_d(RThPhB, tenTripleTypeRThetaPhi,
evalB, tenTripleTypeEigenvalue);
_tenQGL_Rlog(rlog, RThPhA, RThPhB);
ELL_3V_SCALE(rlog, tt, rlog);
_tenQGL_Rexp(oRThPh, RThPhA, rlog);
tenTripleConvertSingle_d(oeval, tenTripleTypeEigenvalue,
oRThPh, tenTripleTypeRThetaPhi);
return;
}
int
miteRayBegin(miteThread *mtt, miteRender *mrr, miteUser *muu,
int uIndex, int vIndex,
double rayLen,
double rayStartWorld[3], double rayStartIndex[3],
double rayDirWorld[3], double rayDirIndex[3]) {
airPtrPtrUnion appu;
AIR_UNUSED(mrr);
AIR_UNUSED(rayStartWorld);
AIR_UNUSED(rayStartIndex);
AIR_UNUSED(rayDirIndex);
mtt->ui = uIndex;
mtt->vi = vIndex;
mtt->rayStep = (muu->rayStep*rayLen /
(muu->hctx->cam->vspFaar - muu->hctx->cam->vspNeer));
if (!uIndex) {
fprintf(stderr, "%d/%d ", vIndex, muu->hctx->imgSize[1]);
fflush(stderr);
}
mtt->verbose = (uIndex == muu->verbUi && vIndex == muu->verbVi);
mtt->skip = (muu->verbUi >= 0 && muu->verbVi >= 0
&& !mtt->verbose);
if (mtt->verbose) {
/* create muu->ndebug */
muu->ndebug = nrrdNew();
/* we want to store the value and index for each txf domain variable,
plus the RGBAZ computed for that sample */
muu->ndebug->axis[0].size = 2*mtt->stageNum + 5;
/* we really do want to associate ndebug with the miteUser's mop,
because the information stored in it has to persist for as long as
the user wants: mite itself doesn't call miteUserNix */
airMopAdd(muu->umop, muu->ndebug, (airMopper)nrrdNuke, airMopAlways);
/* but the scope of the debug array allocation is within this ray */
muu->debugArr = airArrayNew((appu.d = &(muu->debug), appu.v),
NULL, sizeof(double), 128);
}
mtt->raySample = 0;
mtt->RR = mtt->GG = mtt->BB = 0.0;
mtt->TT = 1.0;
mtt->ZZ = AIR_NAN;
ELL_3V_SCALE(mtt->V, -1, rayDirWorld);
return 0;
}
double
_energyInterParticle(pullTask *task, pullPoint *me, pullPoint *she,
/* output */
double egrad[4]) {
char meme[]="_energyInterParticle";
double spadist, sparad, diff[4], rr, enr, frc, *parm;
ELL_4V_SUB(diff, she->pos, me->pos);
spadist = ELL_3V_LEN(diff);
sparad = task->pctx->radiusSpace;
rr = spadist/(2*sparad);
/*
fprintf(stderr, "!%s: rr(%u,%u) = %g\n", meme, me->idtag, she->idtag, rr);
*/
if (rr > 1) {
ELL_4V_SET(egrad, 0, 0, 0, 0);
return 0;
}
if (rr == 0) {
fprintf(stderr, "%s: pos of pts %u, %u equal: (%g,%g,%g,%g)\n",
meme, me->idtag, she->idtag,
me->pos[0], me->pos[1], me->pos[2], me->pos[3]);
ELL_4V_SET(egrad, 0, 0, 0, 0);
return 0;
}
parm = task->pctx->energySpec->parm;
enr = task->pctx->energySpec->energy->eval(&frc, rr, parm);
frc *= -1.0/(2*sparad*spadist);
ELL_3V_SCALE(egrad, frc, diff);
egrad[3] = 0;
/*
fprintf(stderr, "%s: %u <-- %u = %g,%g,%g -> egrad = %g,%g,%g, enr = %g\n",
meme, me->idtag, she->idtag,
diff[0], diff[1], diff[2],
egrad[0], egrad[1], egrad[2], enr);
*/
return enr;
}
/*
******** echoTriMeshSet()
**
** This has to be called any time that the locations of the points are
** changing, even if the connectivity is not changed, because of how
** the bounding box and mean vert position is calculated here.
**
** NB: the TriMesh will directly use the given pos[] and vert[] arrays,
** so don't go freeing them after they've been passed here.
*/
void
echoTriMeshSet(echoObject *trim,
int numV, echoPos_t *pos,
int numF, int *vert) {
int i;
if (trim && echoTypeTriMesh == trim->type) {
TRIMESH(trim)->numV = numV;
TRIMESH(trim)->numF = numF;
TRIMESH(trim)->pos = pos;
TRIMESH(trim)->vert = vert;
ELL_3V_SET(TRIMESH(trim)->min, ECHO_POS_MAX, ECHO_POS_MAX, ECHO_POS_MAX);
ELL_3V_SET(TRIMESH(trim)->max, ECHO_POS_MIN, ECHO_POS_MIN, ECHO_POS_MIN);
ELL_3V_SET(TRIMESH(trim)->meanvert, 0.0, 0.0, 0.0);
for (i=0; i<numV; i++) {
ELL_3V_MIN(TRIMESH(trim)->min, TRIMESH(trim)->min, pos + 3*i);
ELL_3V_MAX(TRIMESH(trim)->max, TRIMESH(trim)->max, pos + 3*i);
ELL_3V_INCR(TRIMESH(trim)->meanvert, pos + 3*i);
}
ELL_3V_SCALE(TRIMESH(trim)->meanvert, 1.0/numV, TRIMESH(trim)->meanvert);
}
return;
}
void
tend_helixDoit(Nrrd *nout, double bnd,
double orig[3], double i2w[9], double mf[9],
double r, double R, double S, double angle, int incrtwist,
double ev[3], double bgEval) {
int sx, sy, sz, xi, yi, zi;
double th, t0, t1, t2, t3, v1, v2,
wpos[3], vpos[3], mfT[9],
W2H[9], H2W[9], H2C[9], C2H[9], fv[3], rv[3], uv[3], mA[9], mB[9], inside,
tmp[3], len;
float *out;
sx = nout->axis[1].size;
sy = nout->axis[2].size;
sz = nout->axis[3].size;
out = (float*)nout->data;
ELL_3M_TRANSPOSE(mfT, mf);
for (zi=0; zi<sz; zi++) {
fprintf(stderr, "zi = %d/%d\n", zi, sz);
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
ELL_3V_SET(tmp, xi, yi, zi);
ELL_3MV_MUL(vpos, i2w, tmp);
ELL_3V_INCR(vpos, orig);
#define WPOS(pos, th) ELL_3V_SET((pos),R*cos(th), R*sin(th), S*(th)/(2*AIR_PI))
#define VAL(th) (WPOS(wpos, th), ELL_3V_DIST(wpos, vpos))
#define RR 0.61803399
#define CC (1.0-RR)
#define SHIFT3(a,b,c,d) (a)=(b); (b)=(c); (c)=(d)
#define SHIFT2(a,b,c) (a)=(b); (b)=(c)
th = atan2(vpos[1], vpos[0]);
th += 2*AIR_PI*floor(0.5 + vpos[2]/S - th/(2*AIR_PI));
if (S*th/(2*AIR_PI) > vpos[2]) {
t0 = th - AIR_PI; t3 = th;
} else {
t0 = th; t3 = th + AIR_PI;
}
t1 = RR*t0 + CC*t3;
t2 = CC*t0 + RR*t3;
v1 = VAL(t1);
v2 = VAL(t2);
while ( t3-t0 > 0.000001*(AIR_ABS(t1)+AIR_ABS(t2)) ) {
if (v1 < v2) {
SHIFT3(t3, t2, t1, CC*t0 + RR*t2);
SHIFT2(v2, v1, VAL(t1));
} else {
SHIFT3(t0, t1, t2, RR*t1 + CC*t3);
SHIFT2(v1, v2, VAL(t2));
}
}
/* t1 (and t2) are now the th for which the point on the helix
(R*cos(th), R*sin(th), S*(th)/(2*AIR_PI)) is closest to vpos */
WPOS(wpos, t1);
ELL_3V_SUB(wpos, vpos, wpos);
ELL_3V_SET(fv, -R*sin(t1), R*cos(t1), S/AIR_PI); /* helix tangent */
ELL_3V_NORM(fv, fv, len);
ELL_3V_COPY(rv, wpos);
ELL_3V_NORM(rv, rv, len);
len = ELL_3V_DOT(rv, fv);
ELL_3V_SCALE(tmp, -len, fv);
ELL_3V_ADD2(rv, rv, tmp);
ELL_3V_NORM(rv, rv, len); /* rv now normal to helix, closest to
pointing to vpos */
ELL_3V_CROSS(uv, rv, fv);
ELL_3V_NORM(uv, uv, len); /* (rv,fv,uv) now right-handed frame */
ELL_3MV_ROW0_SET(W2H, uv); /* as is (uv,rv,fv) */
ELL_3MV_ROW1_SET(W2H, rv);
ELL_3MV_ROW2_SET(W2H, fv);
ELL_3M_TRANSPOSE(H2W, W2H);
inside = 0.5 - 0.5*airErf((ELL_3V_LEN(wpos)-r)/(bnd + 0.0001));
if (incrtwist) {
th = angle*ELL_3V_LEN(wpos)/r;
} else {
th = angle;
}
ELL_3M_ROTATE_Y_SET(H2C, th);
ELL_3M_TRANSPOSE(C2H, H2C);
ELL_3M_SCALE_SET(mA,
AIR_LERP(inside, bgEval, ev[1]),
AIR_LERP(inside, bgEval, ev[2]),
AIR_LERP(inside, bgEval, ev[0]));
ELL_3M_MUL(mB, mA, H2C);
ELL_3M_MUL(mA, mB, W2H);
ELL_3M_MUL(mB, mA, mf);
ELL_3M_MUL(mA, C2H, mB);
ELL_3M_MUL(mB, H2W, mA);
ELL_3M_MUL(mA, mfT, mB);
TEN_M2T_TT(out, float, mA);
out[0] = 1.0;
out += 7;
}
}
}
return;
}
/*
******** 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, const char *argv[]) {
const char *me;
char *err, *outS;
double scale[3], matA[9], matB[9], matC[9], sval[3], uu[9], vv[9];
float matAf[9], matBf[16];
float p[3], q[4], mR[9], len, gamma;
float os, vs, rad, AB[2], ten[7], view[3];
hestOpt *hopt=NULL;
airArray *mop;
limnObject *obj;
limnLook *look; int lookRod, lookSoid;
int partIdx=-1; /* sssh */
int res, sphere;
FILE *file;
me = argv[0];
hestOptAdd(&hopt, "sc", "scalings", airTypeDouble, 3, 3, scale, "1 1 1",
"axis-aligned scaling to do on ellipsoid");
hestOptAdd(&hopt, "AB", "A, B exponents", airTypeFloat, 2, 2, AB, "nan nan",
"Directly set the A, B parameters to the superquadric surface, "
"over-riding the default behavior of determining them from the "
"scalings \"-sc\" as superquadric tensor glyphs");
hestOptAdd(&hopt, "os", "over-all scaling", airTypeFloat, 1, 1, &os, "1",
"over-all scaling (multiplied by scalings)");
hestOptAdd(&hopt, "vs", "over-all scaling", airTypeFloat, 1, 1, &vs, "1",
"scaling along view-direction (to show off bas-relief "
"ambibuity of ellipsoids versus superquads)");
hestOptAdd(&hopt, "fr", "from (eye) point", airTypeFloat, 3, 3, &view,
"4 4 4", "eye point, needed for non-unity \"-vs\"");
hestOptAdd(&hopt, "gamma", "superquad sharpness", airTypeFloat, 1, 1,
&gamma, "0",
"how much to sharpen edges as a "
"function of differences between eigenvalues");
hestOptAdd(&hopt, "sphere", NULL, airTypeInt, 0, 0, &sphere, NULL,
"use a sphere instead of a superquadric");
hestOptAdd(&hopt, "p", "x y z", airTypeFloat, 3, 3, p, "0 0 0",
"location in quaternion quotient space");
hestOptAdd(&hopt, "r", "radius", airTypeFloat, 1, 1, &rad, "0.015",
"black axis cylinder radius (or 0.0 to not drawn these)");
hestOptAdd(&hopt, "res", "resolution", airTypeInt, 1, 1, &res, "25",
"tesselation resolution for both glyph and axis cylinders");
hestOptAdd(&hopt, "o", "output OFF", airTypeString, 1, 1, &outS, "out.off",
"output file to save OFF into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
obj = limnObjectNew(1000, AIR_TRUE);
airMopAdd(mop, obj, (airMopper)limnObjectNix, airMopAlways);
/* create limnLooks for ellipsoid and for rods */
lookSoid = limnObjectLookAdd(obj);
look = obj->look + lookSoid;
ELL_4V_SET(look->rgba, 1, 1, 1, 1);
ELL_3V_SET(look->kads, 0.2, 0.8, 0);
look->spow = 0;
lookRod = limnObjectLookAdd(obj);
look = obj->look + lookRod;
ELL_4V_SET(look->rgba, 0, 0, 0, 1);
ELL_3V_SET(look->kads, 1, 0, 0);
look->spow = 0;
ELL_3M_IDENTITY_SET(matA);
ELL_3V_SCALE(scale, os, scale);
ELL_3M_SCALE_SET(matB, scale[0], scale[1], scale[2]);
ell_3m_post_mul_d(matA, matB);
if (1 != vs) {
ELL_3V_NORM(view, view, len);
if (!len) {
/* HEY: perhaps do more diplomatic error message here */
fprintf(stderr, "%s: stupido!\n", me);
exit(1);
}
ELL_3MV_OUTER(matB, view, view);
ELL_3M_SCALE(matB, vs-1, matB);
ELL_3M_IDENTITY_SET(matC);
ELL_3M_ADD2(matB, matC, matB);
ell_3m_post_mul_d(matA, matB);
}
ell_3m_svd_d(uu, sval, vv, matA, AIR_TRUE);
/*
fprintf(stderr, "%s: ____________________________________\n", me);
fprintf(stderr, "%s: mat = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: uu = \n", me);
ell_3m_print_d(stderr, uu);
ELL_3M_TRANSPOSE(matC, uu);
ELL_3M_MUL(matB, uu, matC);
fprintf(stderr, "%s: uu * uu^T = \n", me);
ell_3m_print_d(stderr, matB);
fprintf(stderr, "%s: sval = %g %g %g\n", me, sval[0], sval[1], sval[2]);
fprintf(stderr, "%s: vv = \n", me);
ell_3m_print_d(stderr, vv);
ELL_3M_MUL(matB, vv, vv);
fprintf(stderr, "%s: vv * vv^T = \n", me);
ELL_3M_TRANSPOSE(matC, vv);
ELL_3M_MUL(matB, vv, matC);
ell_3m_print_d(stderr, matB);
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu);
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]);
ell_3m_pre_mul_d(matA, matB);
ell_3m_pre_mul_d(matA, vv);
fprintf(stderr, "%s: uu * diag(sval) * vv = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", me);
*/
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu);
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]);
ell_3m_pre_mul_d(matA, matB);
ELL_3M_TRANSPOSE(matB, uu);
ell_3m_pre_mul_d(matA, matB);
TEN_M2T(ten, matA);
partIdx = soidDoit(obj, lookSoid,
sphere, gamma, res,
(AIR_EXISTS(AB[0]) && AIR_EXISTS(AB[1])) ? AB : NULL,
ten);
ELL_4V_SET(q, 1, p[0], p[1], p[2]);
ELL_4V_NORM(q, q, len);
ell_q_to_3m_f(mR, q);
ELL_43M_INSET(matBf, mR);
limnObjectPartTransform(obj, partIdx, matBf);
if (rad) {
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-scale[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, (1+scale[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-scale[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, -(1+scale[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-scale[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, (1+scale[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-scale[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, -(1+scale[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, (1+scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, -(1+scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
}
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
if (limnObjectWriteOFF(file, obj)) {
airMopAdd(mop, err = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
/*
******** limnCameraUpdate()
**
** sets in cam: W2V, V2W, U, V, N, vspNeer, vspFaar, vspDist
** and, if fov and aspect are set, this also sets uRange and vRange
**
** This does use biff to describe problems with camera settings
*/
int
limnCameraUpdate(limnCamera *cam) {
static const char me[] = "limnCameraUpdate";
double len, bb[4], uu[4], vv[4], nn[4], TT[16], RR[16];
if (!cam) {
biffAddf(LIMN, "%s: got NULL pointer", me);
return 1;
}
ELL_4V_SET(uu, 0, 0, 0, 0);
ELL_4V_SET(vv, 0, 0, 0, 0);
ELL_4V_SET(nn, 0, 0, 0, 0);
ELL_4V_SET(bb, 0, 0, 0, 1);
ELL_3V_SUB(nn, cam->at, cam->from);
len = ELL_3V_LEN(nn);
if (!len) {
biffAddf(LIMN, "%s: cam->at (%g,%g,%g) == cam->from", me,
cam->at[0], cam->at[1], cam->at[2]);
return 1;
}
if (cam->atRelative) {
/* ctx->cam->{neer,dist} are "at" relative */
cam->vspNeer = cam->neer + len;
cam->vspFaar = cam->faar + len;
cam->vspDist = cam->dist + len;
}
else {
/* ctx->cam->{neer,dist} are eye relative */
cam->vspNeer = cam->neer;
cam->vspFaar = cam->faar;
cam->vspDist = cam->dist;
}
if (!(cam->vspNeer > 0 && cam->vspDist > 0 && cam->vspFaar > 0)) {
biffAddf(LIMN, "%s: eye-relative near (%g), dist (%g), or far (%g) <= 0",
me, cam->vspNeer, cam->vspDist, cam->vspFaar);
return 1;
}
if (!(cam->vspNeer <= cam->vspFaar)) {
biffAddf(LIMN, "%s: eye-relative near (%g) further than far (%g)",
me, cam->vspNeer, cam->vspFaar);
return 1 ;
}
if (AIR_EXISTS(cam->fov)) {
if (!( AIR_IN_OP(0.0, cam->fov, 180.0) )) {
biffAddf(LIMN, "%s: cam->fov (%g) not in valid range between 0 and 180",
me, cam->fov);
return 1 ;
}
if (!AIR_EXISTS(cam->aspect)) {
biffAddf(LIMN, "%s: cam->fov set, but cam->aspect isn't", me);
return 1;
}
/* "fov" is half vertical angle */
cam->vRange[0] = -tan(cam->fov*AIR_PI/360)*(cam->vspDist);
cam->vRange[1] = -cam->vRange[0];
cam->uRange[0] = cam->vRange[0]*(cam->aspect);
cam->uRange[1] = -cam->uRange[0];
}
/* else cam->fov isn't set, but we're not going to complain if
uRange and vRange aren't both set ... */
ELL_3V_SCALE(nn, 1.0/len, nn);
ELL_3V_CROSS(uu, nn, cam->up);
len = ELL_3V_LEN(uu);
if (!len) {
biffAddf(LIMN, "%s: cam->up is co-linear with view direction", me);
return 1 ;
}
ELL_3V_SCALE(uu, 1.0/len, uu);
if (cam->rightHanded) {
ELL_3V_CROSS(vv, nn, uu);
}
else {
ELL_3V_CROSS(vv, uu, nn);
}
ELL_4V_COPY(cam->U, uu);
ELL_4V_COPY(cam->V, vv);
ELL_4V_COPY(cam->N, nn);
ELL_4M_TRANSLATE_SET(TT, -cam->from[0], -cam->from[1], -cam->from[2]);
ELL_4M_ROWS_SET(RR, uu, vv, nn, bb);
ELL_4M_MUL(cam->W2V, RR, TT);
ell_4m_inv_d(cam->V2W, cam->W2V);
return 0;
}
int
tenGlyphGen(limnObject *glyphsLimn, echoScene *glyphsEcho,
tenGlyphParm *parm,
const Nrrd *nten, const Nrrd *npos, const Nrrd *nslc) {
static const char me[]="tenGlyphGen";
gageShape *shape;
airArray *mop;
float *tdata, eval[3], evec[9], *cvec, rotEvec[9], mA_f[16],
absEval[3], glyphScl[3];
double pI[3], pW[3], cl, cp, sRot[16], mA[16], mB[16], msFr[9], tmpvec[3],
R, G, B, qA, qB, qC, glyphAniso, sliceGray;
unsigned int duh;
int slcCoord[3], idx, 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];
char stmp[AIR_STRLEN_SMALL];
/*
int eret;
double tmp1[3], tmp2[3];
*/
if (!( (glyphsLimn || glyphsEcho) && nten && parm)) {
biffAddf(TEN, "%s: got NULL pointer", me);
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 )) {
biffAddf(TEN, "%s: nten isn't 2-D 7-by-N array", me);
airMopError(mop); return 1;
}
if (!( 2 == npos->dim && 3 == npos->axis[0].size
&& nten->axis[1].size == npos->axis[1].size )) {
biffAddf(TEN, "%s: npos isn't 2-D 3-by-%s array", me,
airSprintSize_t(stmp, nten->axis[1].size));
airMopError(mop); return 1;
}
if (!( nrrdTypeFloat == nten->type && nrrdTypeFloat == npos->type )) {
biffAddf(TEN, "%s: nten and npos must be %s, not %s and %s", me,
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nten->type),
airEnumStr(nrrdType, npos->type));
airMopError(mop); return 1;
}
} else {
if (tenTensorCheck(nten, nrrdTypeFloat, AIR_TRUE, AIR_TRUE)) {
biffAddf(TEN, "%s: didn't get a valid DT volume", me);
airMopError(mop); return 1;
}
}
if (tenGlyphParmCheck(parm, nten, npos, nslc)) {
biffAddf(TEN, "%s: trouble", me);
airMopError(mop); return 1;
}
if (!npos) {
if (gageShapeSet(shape, nten, tenGageKind->baseDim)) {
biffMovef(TEN, GAGE, "%s: trouble", me);
airMopError(mop); return 1;
}
}
if (parm->doSlice) {
ELL_3V_COPY(edge0, shape->spacing);
ELL_3V_COPY(edge1, shape->spacing);
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->spacing);
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 = AIR_UINT(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++) {
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-existent 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->spacing[0],
shape->spacing[1],
shape->spacing[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_3V_ABS(absEval, eval);
ELL_4M_IDENTITY_SET(mA); /* reset */
ELL_3V_SCALE(glyphScl, parm->glyphScale, absEval); /* scale by evals */
ELL_4M_SCALE_SET(mB, glyphScl[0], glyphScl[1], glyphScl[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);
/* find axis, and superquad exponents qA and qB */
if (eval[2] > 0) {
/* all evals positive */
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);
}
qC = qB;
} else if (eval[0] < 0) {
/* all evals negative */
float aef[3];
aef[0] = absEval[2];
aef[1] = absEval[1];
aef[2] = absEval[0];
cl = AIR_MIN(0.99, tenAnisoEval_f(aef, tenAniso_Cl1));
cp = AIR_MIN(0.99, tenAnisoEval_f(aef, tenAniso_Cp1));
if (cl > cp) {
axis = 2;
qA = pow(1-cp, parm->sqdSharp);
qB = pow(1-cl, parm->sqdSharp);
} else {
axis = 0;
qA = pow(1-cl, parm->sqdSharp);
qB = pow(1-cp, parm->sqdSharp);
}
qC = qB;
} else {
#define OOSQRT2 0.70710678118654752440
#define OOSQRT3 0.57735026918962576451
/* double poleA[3]={OOSQRT3, OOSQRT3, OOSQRT3}; */
double poleB[3]={1, 0, 0};
double poleC[3]={OOSQRT2, OOSQRT2, 0};
double poleD[3]={OOSQRT3, -OOSQRT3, -OOSQRT3};
double poleE[3]={OOSQRT2, 0, -OOSQRT2};
double poleF[3]={OOSQRT3, OOSQRT3, -OOSQRT3};
double poleG[3]={0, -OOSQRT2, -OOSQRT2};
double poleH[3]={0, 0, -1};
/* double poleI[3]={-OOSQRT3, -OOSQRT3, -OOSQRT3}; */
double funk[3]={0,4,2}, thrn[3]={1,4,4};
double octa[3]={0,2,2}, cone[3]={1,2,2};
double evalN[3], tmp, bary[3];
double qq[3];
ELL_3V_NORM(evalN, eval, tmp);
if (eval[1] >= -eval[2]) {
/* inside B-F-C */
ell_3v_barycentric_spherical_d(bary, poleB, poleF, poleC, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], octa, bary[1], thrn, bary[2], cone);
axis = 2;
} else if (eval[0] >= -eval[2]) {
/* inside B-D-F */
if (eval[1] >= 0) {
/* inside B-E-F */
ell_3v_barycentric_spherical_d(bary, poleB, poleE, poleF, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], octa, bary[1], funk, bary[2], thrn);
axis = 2;
} else {
/* inside B-D-E */
ell_3v_barycentric_spherical_d(bary, poleB, poleD, poleE, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], cone, bary[1], thrn, bary[2], funk);
axis = 0;
}
} else if (eval[0] < -eval[1]) {
/* inside D-G-H */
ell_3v_barycentric_spherical_d(bary, poleD, poleG, poleH, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], thrn, bary[1], cone, bary[2], octa);
axis = 0;
} else if (eval[1] < 0) {
/* inside E-D-H */
ell_3v_barycentric_spherical_d(bary, poleE, poleD, poleH, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], funk, bary[1], thrn, bary[2], octa);
axis = 0;
} else {
/* inside F-E-H */
ell_3v_barycentric_spherical_d(bary, poleF, poleE, poleH, evalN);
ELL_3V_SCALE_ADD3(qq, bary[0], thrn, bary[1], funk, bary[2], cone);
axis = 2;
}
qA = qq[0];
qB = qq[1];
qC = qq[2];
#undef OOSQRT2
#undef OOSQRT3
}
/* 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 =
limnObjectPolarSuperquadFancyAdd(glyphsLimn, lookIdx, axis,
AIR_CAST(float, qA),
AIR_CAST(float, qB),
AIR_CAST(float, qC), 0,
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, const char *argv[]) {
const char *me;
char *err, *outS;
float p[3], q[4], mR[9], eval[3]={0,0,0}, scale[3], len, sh, cl, cp, qA, qB;
float matA[16], matB[16], os, rad, AB[2];
hestOpt *hopt=NULL;
airArray *mop;
limnObject *obj;
limnLook *look; int lookRod, lookSoid;
int partIdx=-1; /* sssh */
int res, axis, sphere;
FILE *file;
me = argv[0];
hestOptAdd(&hopt, "sc", "scalings", airTypeFloat, 3, 3, scale, "1 1 1",
"axis-aligned scaling to do on ellipsoid");
hestOptAdd(&hopt, "AB", "A, B exponents", airTypeFloat, 2, 2, AB, "nan nan",
"Directly set the A, B parameters to the superquadric surface, "
"over-riding the default behavior of determining them from the "
"scalings \"-sc\" as superquadric tensor glyphs");
hestOptAdd(&hopt, "os", "over-all scaling", airTypeFloat, 1, 1, &os, "1",
"over-all scaling (multiplied by scalings)");
hestOptAdd(&hopt, "sh", "superquad sharpness", airTypeFloat, 1, 1, &sh, "0",
"how much to sharpen edges as a "
"function of differences between eigenvalues");
hestOptAdd(&hopt, "sphere", NULL, airTypeInt, 0, 0, &sphere, NULL,
"use a sphere instead of a superquadric");
hestOptAdd(&hopt, "p", "x y z", airTypeFloat, 3, 3, p, "0 0 0",
"location in quaternion quotient space");
hestOptAdd(&hopt, "r", "radius", airTypeFloat, 1, 1, &rad, "0.015",
"black axis cylinder radius (or 0.0 to not drawn these)");
hestOptAdd(&hopt, "res", "resolution", airTypeInt, 1, 1, &res, "25",
"tesselation resolution for both glyph and axis cylinders");
hestOptAdd(&hopt, "o", "output OFF", airTypeString, 1, 1, &outS, "out.off",
"output file to save OFF into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
obj = limnObjectNew(100, AIR_FALSE);
airMopAdd(mop, obj, (airMopper)limnObjectNix, airMopAlways);
/* create limnLooks for ellipsoid and for rods */
lookSoid = limnObjectLookAdd(obj);
look = obj->look + lookSoid;
ELL_4V_SET(look->rgba, 1, 1, 1, 1);
ELL_3V_SET(look->kads, 0.2, 0.8, 0);
look->spow = 0;
lookRod = limnObjectLookAdd(obj);
look = obj->look + lookRod;
ELL_4V_SET(look->rgba, 0, 0, 0, 1);
ELL_3V_SET(look->kads, 1, 0, 0);
look->spow = 0;
ELL_4V_SET(q, 1, p[0], p[1], p[2]);
ELL_4V_NORM(q, q, len);
ell_q_to_3m_f(mR, q);
if (AIR_EXISTS(AB[0]) && AIR_EXISTS(AB[1])) {
qA = AB[0];
qB = AB[1];
axis = 2;
} else {
ELL_3V_SCALE(scale, os, scale);
ELL_3V_COPY(eval, scale);
ELL_SORT3(eval[0], eval[1], eval[2], cl);
cl = (eval[0] - eval[1])/(eval[0] + eval[1] + eval[2]);
cp = 2*(eval[1] - eval[2])/(eval[0] + eval[1] + eval[2]);
if (cl > cp) {
axis = ELL_MAX3_IDX(scale[0], scale[1], scale[2]);
qA = pow(1-cp, sh);
qB = pow(1-cl, sh);
} else {
axis = ELL_MIN3_IDX(scale[0], scale[1], scale[2]);
qA = pow(1-cl, sh);
qB = pow(1-cp, sh);
}
/*
fprintf(stderr, "eval = %g %g %g -> cl=%g %s cp=%g -> axis = %d\n",
eval[0], eval[1], eval[2], cl, cl > cp ? ">" : "<", cp, axis);
*/
}
if (sphere) {
partIdx = limnObjectPolarSphereAdd(obj, lookSoid,
0, 2*res, res);
} else {
partIdx = limnObjectPolarSuperquadAdd(obj, lookSoid,
axis, qA, qB, 2*res, res);
}
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, scale[0], scale[1], scale[2]);
ell_4m_post_mul_f(matA, matB);
ELL_43M_INSET(matB, mR);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
if (rad) {
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, (1-eval[0])/2, rad, rad);
ell_4m_post_mul_f(matA, matB);
ELL_4M_TRANSLATE_SET(matB, (1+eval[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, (1-eval[0])/2, rad, rad);
ell_4m_post_mul_f(matA, matB);
ELL_4M_TRANSLATE_SET(matB, -(1+eval[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, rad, (1-eval[1])/2, rad);
ell_4m_post_mul_f(matA, matB);
ELL_4M_TRANSLATE_SET(matB, 0.0, (1+eval[1])/2, 0.0);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, rad, (1-eval[1])/2, rad);
ell_4m_post_mul_f(matA, matB);
ELL_4M_TRANSLATE_SET(matB, 0.0, -(1+eval[1])/2, 0.0);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, rad, rad, (1-eval[2])/2);
ell_4m_post_mul_f(matA, matB);
ELL_4M_TRANSLATE_SET(matB, 0.0, 0.0, (1+eval[2])/2);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matA);
ELL_4M_SCALE_SET(matB, rad, rad, (1-eval[2])/2);
ell_4m_post_mul_f(matA, matB);
ELL_4M_TRANSLATE_SET(matB, 0.0, 0.0, -(1+eval[2])/2);
ell_4m_post_mul_f(matA, matB);
limnObjectPartTransform(obj, partIdx, matA);
}
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
if (limnObjectWriteOFF(file, obj)) {
airMopAdd(mop, err = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
/*
** parm vector:
** 0 1 2 3 4 5 (6)
** step K_perp K_tan lerp X_ring Y_ring
*/
void
_coilKindScalarFilterModifiedCurvatureRings(coil_t *delta,
int xi, int yi, int zi,
coil_t **iv3, double spacing[3],
double parm[COIL_PARMS_NUM]) {
coil_t forwX[3], backX[3], forwY[3], backY[3], forwZ[3], backZ[3],
grad[3], gm, eps, KK, LL, denom, rspX, rspY, rspZ, lerp;
double bas0[3], bas1[3], bas2[3], len, norm[3], sk;
AIR_UNUSED(zi);
ELL_3V_SET(bas0, 0, 0, 1);
ELL_3V_SET(bas1, xi - parm[4], yi - parm[5], 0);
ELL_3V_NORM(bas1, bas1, len);
ELL_3V_CROSS(bas2, bas0, bas1);
rspX = AIR_CAST(coil_t, 1.0/spacing[0]);
rspY = AIR_CAST(coil_t, 1.0/spacing[1]);
rspZ = AIR_CAST(coil_t, 1.0/spacing[2]);
_coilKindScalar3x3x3Gradients(forwX, backX,
forwY, backY,
forwZ, backZ,
iv3,
rspX, rspY, rspZ);
grad[0] = rspX*(iv3[2][4] - iv3[0][4]);
grad[1] = rspY*(iv3[1][5] - iv3[1][3]);
grad[2] = rspZ*(iv3[1][7] - iv3[1][1]);
gm = AIR_CAST(coil_t, ELL_3V_LEN(grad));
if (gm) {
double tc, rcsq;
ELL_3V_SCALE(norm, 1.0/gm, grad);
tc = ELL_3V_DOT(norm, bas2);
rcsq = 1 - tc*tc;
sk = AIR_LERP(rcsq, parm[1], parm[2]);
} else {
sk = parm[1];
}
/* compute fluxes */
eps = 0.0000000001f;
KK = AIR_CAST(coil_t, sk*sk);
LL = ELL_3V_DOT(forwX, forwX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwY, forwY);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(forwZ, forwZ);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
forwZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backX, backX);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backX[0] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backY, backY);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backY[1] *= _COIL_CONDUCT(LL, KK)*denom;
LL = ELL_3V_DOT(backZ, backZ);
denom = AIR_CAST(coil_t, 1.0/(eps + sqrt(LL)));
backZ[2] *= _COIL_CONDUCT(LL, KK)*denom;
lerp = AIR_CAST(coil_t, parm[2]);
delta[0] = (lerp*_coilLaplacian3(iv3, spacing)
+ (1-lerp)*gm*(rspX*(forwX[0] - backX[0])
+ rspY*(forwY[1] - backY[1])
+ rspZ*(forwZ[2] - backZ[2])));
delta[0] *= AIR_CAST(coil_t, parm[0]);
}
void *
_hooverThreadBody(void *_arg) {
_hooverThreadArg *arg;
void *thread;
int ret, /* to catch return values from callbacks */
sampleI, /* which sample we're on */
inside, /* we're inside the volume */
vI, uI; /* integral coords in image */
double tmp,
mm, /* lowest position in index space, for all axes */
Mx, My, Mz, /* highest position in index space on each axis */
u, v, /* floating-point coords in image */
uvScale, /* how to scale (u,v) to go from image to
near plane, according to ortho or perspective */
lx, ly, lz, /* half edge-lengths of volume */
rayLen=0, /* length of segment formed by ray line intersecting
the near and far clipping planes */
rayT, /* current position along ray (world-space) */
rayDirW[3], /* unit-length ray direction (world-space) */
rayDirI[3], /* rayDirW transformed into index space;
not unit length, but a unit change in
world space along rayDirW translates to
this change in index space along rayDirI */
rayPosW[3], /* current ray location (world-space) */
rayPosI[3], /* current ray location (index-space) */
rayStartW[3], /* ray start on near plane (world-space) */
rayStartI[3], /* ray start on near plane (index-space) */
rayStep, /* distance between samples (world-space) */
vOff[3], uOff[3]; /* offsets in arg->ec->wU and arg->ec->wV
directions towards start of ray */
arg = (_hooverThreadArg *)_arg;
if ( (ret = (arg->ctx->threadBegin)(&thread,
arg->render,
arg->ctx->user,
arg->whichThread)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrThreadBegin;
return arg;
}
lx = arg->ec->volHLen[0];
ly = arg->ec->volHLen[1];
lz = arg->ec->volHLen[2];
if (nrrdCenterNode == arg->ctx->volCentering) {
mm = 0;
Mx = arg->ctx->volSize[0]-1;
My = arg->ctx->volSize[1]-1;
Mz = arg->ctx->volSize[2]-1;
} else {
mm = -0.5;
Mx = arg->ctx->volSize[0]-0.5;
My = arg->ctx->volSize[1]-0.5;
Mz = arg->ctx->volSize[2]-0.5;
}
if (arg->ctx->cam->orthographic) {
ELL_3V_COPY(rayDirW, arg->ctx->cam->N);
rayDirI[0] = AIR_DELTA(-lx, rayDirW[0], lx, mm, Mx);
rayDirI[1] = AIR_DELTA(-ly, rayDirW[1], ly, mm, My);
rayDirI[2] = AIR_DELTA(-lz, rayDirW[2], lz, mm, Mz);
rayLen = arg->ctx->cam->vspFaar - arg->ctx->cam->vspNeer;
uvScale = 1.0;
} else {
uvScale = arg->ctx->cam->vspNeer/arg->ctx->cam->vspDist;
}
while (1) {
/* the work assignment is simply the next scanline to be rendered:
the result of all this is setting vI */
if (arg->ctx->workMutex) {
airThreadMutexLock(arg->ctx->workMutex);
}
vI = arg->ctx->workIdx;
if (arg->ctx->workIdx < arg->ctx->imgSize[1]) {
arg->ctx->workIdx += 1;
}
if (arg->ctx->workMutex) {
airThreadMutexUnlock(arg->ctx->workMutex);
}
if (vI == arg->ctx->imgSize[1]) {
/* we're done! */
break;
}
if (nrrdCenterCell == arg->ctx->imgCentering) {
v = uvScale*AIR_AFFINE(-0.5, vI, arg->ctx->imgSize[1]-0.5,
arg->ctx->cam->vRange[0],
arg->ctx->cam->vRange[1]);
} else {
v = uvScale*AIR_AFFINE(0.0, vI, arg->ctx->imgSize[1]-1.0,
arg->ctx->cam->vRange[0],
arg->ctx->cam->vRange[1]);
}
ELL_3V_SCALE(vOff, v, arg->ctx->cam->V);
for (uI=0; uI<arg->ctx->imgSize[0]; uI++) {
if (nrrdCenterCell == arg->ctx->imgCentering) {
u = uvScale*AIR_AFFINE(-0.5, uI, arg->ctx->imgSize[0]-0.5,
arg->ctx->cam->uRange[0],
arg->ctx->cam->uRange[1]);
} else {
u = uvScale*AIR_AFFINE(0.0, uI, arg->ctx->imgSize[0]-1.0,
arg->ctx->cam->uRange[0],
arg->ctx->cam->uRange[1]);
}
ELL_3V_SCALE(uOff, u, arg->ctx->cam->U);
ELL_3V_ADD3(rayStartW, uOff, vOff, arg->ec->rayZero);
rayStartI[0] = AIR_AFFINE(-lx, rayStartW[0], lx, mm, Mx);
rayStartI[1] = AIR_AFFINE(-ly, rayStartW[1], ly, mm, My);
rayStartI[2] = AIR_AFFINE(-lz, rayStartW[2], lz, mm, Mz);
if (!arg->ctx->cam->orthographic) {
ELL_3V_SUB(rayDirW, rayStartW, arg->ctx->cam->from);
ELL_3V_NORM(rayDirW, rayDirW, tmp);
rayDirI[0] = AIR_DELTA(-lx, rayDirW[0], lx, mm, Mx);
rayDirI[1] = AIR_DELTA(-ly, rayDirW[1], ly, mm, My);
rayDirI[2] = AIR_DELTA(-lz, rayDirW[2], lz, mm, Mz);
rayLen = ((arg->ctx->cam->vspFaar - arg->ctx->cam->vspNeer)/
ELL_3V_DOT(rayDirW, arg->ctx->cam->N));
}
if ( (ret = (arg->ctx->rayBegin)(thread,
arg->render,
arg->ctx->user,
uI, vI, rayLen,
rayStartW, rayStartI,
rayDirW, rayDirI)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrRayBegin;
return arg;
}
sampleI = 0;
rayT = 0;
while (1) {
ELL_3V_SCALE_ADD2(rayPosW, 1.0, rayStartW, rayT, rayDirW);
ELL_3V_SCALE_ADD2(rayPosI, 1.0, rayStartI, rayT, rayDirI);
inside = (AIR_IN_CL(mm, rayPosI[0], Mx) &&
AIR_IN_CL(mm, rayPosI[1], My) &&
AIR_IN_CL(mm, rayPosI[2], Mz));
rayStep = (arg->ctx->sample)(thread,
arg->render,
arg->ctx->user,
sampleI, rayT,
inside,
rayPosW, rayPosI);
if (!AIR_EXISTS(rayStep)) {
/* sampling failed */
arg->errCode = 0;
arg->whichErr = hooverErrSample;
return arg;
}
if (!rayStep) {
/* ray decided to finish itself */
break;
}
/* else we moved to a new location along the ray */
rayT += rayStep;
if (!AIR_IN_CL(0, rayT, rayLen)) {
/* ray stepped outside near-far clipping region, its done. */
break;
}
sampleI++;
}
if ( (ret = (arg->ctx->rayEnd)(thread,
arg->render,
arg->ctx->user)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrRayEnd;
return arg;
}
} /* end this scanline */
} /* end while(1) assignment of scanlines */
if ( (ret = (arg->ctx->threadEnd)(thread,
arg->render,
arg->ctx->user)) ) {
arg->errCode = ret;
arg->whichErr = hooverErrThreadEnd;
return arg;
}
/* returning NULL actually indicates that there was NOT an error */
return NULL;
}
int
main(int argc, char *argv[]) {
char *me;
hestOpt *hopt=NULL;
airArray *mop;
double tripA[3], tripB[3], evalA[3], evalB[3],
rt_A[3], rt_B[3], trip[3], eval[3], lasteval[3], lastxyz[3],
logAB[3], ndist;
int ittype, ottype, ptype, rttype;
unsigned int NN, ii;
tenInterpParm *tip;
void (*interp)(double oeval[3], const double evalA[3],
const double evalB[3], const double tt);
double (*qdist)(const double RTh_A[3], const double RTh_B[3]);
void (*qlog)(double klog[3],
const double RThZA[3], const double RThZB[3]);
void (*qexp)(double RThZB[3],
const double RThZA[3], const double klog[3]);
void (*grads)(double grad[3][3], const double eval[3]);
me = argv[0];
mop = airMopNew();
tip = tenInterpParmNew();
airMopAdd(mop, tip, (airMopper)tenInterpParmNix, airMopAlways);
hestOptAdd(&hopt, "a", "start", airTypeDouble, 3, 3, tripA, NULL,
"start triple of values");
hestOptAdd(&hopt, "b", "end", airTypeDouble, 3, 3, tripB, NULL,
"end triple of values");
hestOptAdd(&hopt, "it", "type", airTypeEnum, 1, 1, &ittype, NULL,
"type of given start and end triples", NULL, tenTripleType);
hestOptAdd(&hopt, "ot", "type", airTypeEnum, 1, 1, &ottype, NULL,
"type of triples for output", NULL, tenTripleType);
hestOptAdd(&hopt, "p", "type", airTypeEnum, 1, 1, &ptype, NULL,
"type of path interpolation", NULL, tenInterpType);
hestOptAdd(&hopt, "n", "# steps", airTypeUInt, 1, 1, &NN, "100",
"number of steps along path");
hestOptAdd(&hopt, "v", "verbosity", airTypeInt, 1, 1,
&(tip->verbose), "0", "verbosity");
hestOptAdd(&hopt, "s", "stepsize", airTypeDouble, 1, 1,
&(tip->convStep), "1", "step size in update");
hestOptAdd(&hopt, "r", "recurse", airTypeInt, 0, 0,
&(tip->enableRecurse), NULL,
"enable recursive solution, when useful");
hestOptAdd(&hopt, "mn", "minnorm", airTypeDouble, 1, 1,
&(tip->minNorm), "0.000001",
"minnorm of something");
hestOptAdd(&hopt, "mi", "maxiter", airTypeUInt, 1, 1,
&(tip->maxIter), "0",
"if non-zero, max # iterations for computation");
hestOptAdd(&hopt, "c", "conv", airTypeDouble, 1, 1,
&(tip->convEps), "0.0001",
"convergence threshold of length fraction");
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 (!( tenInterpTypeQuatGeoLoxK == ptype
|| tenInterpTypeQuatGeoLoxR == ptype )) {
fprintf(stderr, "%s: need type %s or %s, not %s\n", me,
airEnumStr(tenInterpType, tenInterpTypeQuatGeoLoxK),
airEnumStr(tenInterpType, tenInterpTypeQuatGeoLoxR),
airEnumStr(tenInterpType, ptype));
airMopError(mop);
return 1;
}
if (tenInterpTypeQuatGeoLoxK == ptype) {
interp = tenQGLInterpTwoEvalK;
qdist = _tenQGL_Kdist;
qlog = _tenQGL_Klog;
qexp = _tenQGL_Kexp;
grads = kgrads;
rttype = tenTripleTypeRThetaZ;
} else {
interp = tenQGLInterpTwoEvalR;
qdist = _tenQGL_Rdist;
qlog = _tenQGL_Rlog;
qexp = _tenQGL_Rexp;
grads = rgrads;
rttype = tenTripleTypeRThetaPhi;
}
fprintf(stderr, "%s: (%s) %f %f %f \n--%s--> %f %f %f\n", me,
airEnumStr(tenTripleType, ittype),
tripA[0], tripA[1], tripA[2],
airEnumStr(tenInterpType, ptype),
tripB[0], tripB[1], tripB[2]);
tenTripleConvertSingle_d(evalA, tenTripleTypeEigenvalue, tripA, ittype);
tenTripleConvertSingle_d(evalB, tenTripleTypeEigenvalue, tripB, ittype);
tenTripleConvertSingle_d(rt_A, rttype, tripA, ittype);
tenTripleConvertSingle_d(rt_B, rttype, tripB, ittype);
ndist = 0;
ELL_3V_SET(lasteval, AIR_NAN, AIR_NAN, AIR_NAN);
ELL_3V_SET(lastxyz, AIR_NAN, AIR_NAN, AIR_NAN);
qlog(logAB, rt_A, rt_B);
fprintf(stderr, "%s: log = %g %g %g (%g)\n", me,
logAB[0], logAB[1], logAB[2], ELL_3V_LEN(logAB));
for (ii=0; ii<NN; ii++) {
double tt, xyz[3], dot[3], ll[3], prayRT[3], prayO[3];
tt = AIR_AFFINE(0, ii, NN-1, 0.0, 1.0);
interp(eval, evalA, evalB, tt);
tenTripleConvertSingle_d(trip, ottype,
eval, tenTripleTypeEigenvalue);
tenTripleConvertSingle_d(xyz, tenTripleTypeXYZ,
eval, tenTripleTypeEigenvalue);
ELL_3V_SCALE(ll, tt, logAB);
qexp(prayRT, rt_A, ll);
tenTripleConvertSingle_d(prayO, ottype, prayRT, rttype);
if (ii) {
double diff[3], gr[3][3];
ELL_3V_SUB(diff, lasteval, eval);
ndist += ELL_3V_LEN(diff);
ELL_3V_SUB(diff, lastxyz, xyz);
grads(gr, eval);
dot[0] = ELL_3V_DOT(diff, gr[0]);
dot[1] = ELL_3V_DOT(diff, gr[1]);
dot[2] = ELL_3V_DOT(diff, gr[2]);
} else {
ELL_3V_SET(dot, 0, 0, 0);
}
printf("%03u %g %g %g %g %g %g 00 %g %g %g\n", ii,
trip[0], prayO[0],
trip[1], prayO[1],
trip[2], prayO[2],
dot[0], dot[1], dot[2]);
ELL_3V_COPY(lasteval, eval);
ELL_3V_COPY(lastxyz, xyz);
}
fprintf(stderr, "%s: dist %g =?= %g\n", me,
qdist(rt_A, rt_B), ndist);
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
const char *me;
char *err, *outS;
double eval[3], matA[9], matB[9], sval[3], uu[9], vv[9], escl[5],
view[3];
float matAf[9], matBf[16];
float pp[3], qq[4], mR[9], len, gamma;
float os, vs, rad, AB[2], ten[7];
hestOpt *hopt=NULL;
airArray *mop;
limnObject *obj;
limnLook *look; int lookRod, lookSoid;
float kadsRod[3], kadsSoid[3];
int gtype, partIdx=-1; /* sssh */
int res;
FILE *file;
me = argv[0];
hestOptAdd(&hopt, "sc", "evals", airTypeDouble, 3, 3, eval, "1 1 1",
"original eigenvalues of tensor to be visualized");
hestOptAdd(&hopt, "AB", "A, B exponents", airTypeFloat, 2, 2, AB, "nan nan",
"Directly set the A, B parameters to the superquadric surface, "
"over-riding the default behavior of determining them from the "
"scalings \"-sc\" as superquadric tensor glyphs");
hestOptAdd(&hopt, "os", "over-all scaling", airTypeFloat, 1, 1, &os, "1",
"over-all scaling (multiplied by scalings)");
hestOptAdd(&hopt, "vs", "view-dir scaling", airTypeFloat, 1, 1, &vs, "1",
"scaling along view-direction (to show off bas-relief "
"ambibuity of ellipsoids versus superquads)");
hestOptAdd(&hopt, "es", "extra scaling", airTypeDouble, 5, 5, escl,
"2 1 0 0 1", "extra scaling specified with five values "
"0:tensor|1:geometry|2:none vx vy vz scaling");
hestOptAdd(&hopt, "fr", "from (eye) point", airTypeDouble, 3, 3, &view,
"4 4 4", "eye point, needed for non-unity \"-vs\"");
hestOptAdd(&hopt, "gamma", "superquad sharpness", airTypeFloat, 1, 1,
&gamma, "0",
"how much to sharpen edges as a "
"function of differences between eigenvalues");
hestOptAdd(&hopt, "g", "glyph shape", airTypeEnum, 1, 1, >ype, "sqd",
"glyph to use; not all are implemented here",
NULL, tenGlyphType);
hestOptAdd(&hopt, "pp", "x y z", airTypeFloat, 3, 3, pp, "0 0 0",
"transform: rotation identified by"
"location in quaternion quotient space");
hestOptAdd(&hopt, "r", "radius", airTypeFloat, 1, 1, &rad, "0.015",
"black axis cylinder radius (or 0.0 to not drawn these)");
hestOptAdd(&hopt, "res", "resolution", airTypeInt, 1, 1, &res, "25",
"tesselation resolution for both glyph and axis cylinders");
hestOptAdd(&hopt, "pg", "ka kd ks", airTypeFloat, 3, 3, kadsSoid,
"0.2 0.8 0.0",
"phong coefficients for glyph");
hestOptAdd(&hopt, "pr", "ka kd ks", airTypeFloat, 3, 3, kadsRod, "1 0 0",
"phong coefficients for black rods (if being drawn)");
hestOptAdd(&hopt, "o", "output OFF", airTypeString, 1, 1, &outS, "out.off",
"output file to save OFF into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
obj = limnObjectNew(1000, AIR_TRUE);
airMopAdd(mop, obj, (airMopper)limnObjectNix, airMopAlways);
if (!( 0 == escl[0] || 1 == escl[0] || 2 == escl[0] )) {
fprintf(stderr, "%s: escl[0] %g not 0, 1 or 2\n", me, escl[0]);
airMopError(mop); return 1;
}
if (!(tenGlyphTypeBox == gtype ||
tenGlyphTypeSphere == gtype ||
tenGlyphTypeSuperquad == gtype)) {
fprintf(stderr, "%s: got %s %s, but here only do %s, %s, or %s\n", me,
tenGlyphType->name,
airEnumStr(tenGlyphType, gtype),
airEnumStr(tenGlyphType, tenGlyphTypeBox),
airEnumStr(tenGlyphType, tenGlyphTypeSphere),
airEnumStr(tenGlyphType, tenGlyphTypeSuperquad));
airMopError(mop); return 1;
}
/* create limnLooks for glyph and for rods */
lookSoid = limnObjectLookAdd(obj);
look = obj->look + lookSoid;
ELL_4V_SET(look->rgba, 1, 1, 1, 1);
ELL_3V_COPY(look->kads, kadsSoid);
look->spow = 0;
lookRod = limnObjectLookAdd(obj);
look = obj->look + lookRod;
ELL_4V_SET(look->rgba, 0, 0, 0, 1);
ELL_3V_COPY(look->kads, kadsRod);
look->spow = 0;
ELL_3M_IDENTITY_SET(matA); /* A = I */
ELL_3V_SCALE(eval, os, eval);
ELL_3M_SCALE_SET(matB, eval[0], eval[1], eval[2]); /* B = diag(eval) */
ell_3m_post_mul_d(matA, matB); /* A = B*A = diag(eval) */
if (0 == escl[0]) {
scalingMatrix(matB, escl + 1, escl[4]);
ell_3m_post_mul_d(matA, matB);
}
if (1 != vs) {
if (!ELL_3V_LEN(view)) {
fprintf(stderr, "%s: need non-zero view for vs %g != 1\n", me, vs);
airMopError(mop); return 1;
}
scalingMatrix(matB, view, vs);
/* the scaling along the view direction is a symmetric matrix,
but applying that scaling to the symmetric input tensor
is not necessarily symmetric */
ell_3m_post_mul_d(matA, matB); /* A = B*A */
}
/* so we do an SVD to get rotation U and the scalings sval[] */
/* U * diag(sval) * V */
ell_3m_svd_d(uu, sval, vv, matA, AIR_TRUE);
/*
fprintf(stderr, "%s: ____________________________________\n", me);
fprintf(stderr, "%s: mat = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: uu = \n", me);
ell_3m_print_d(stderr, uu);
ELL_3M_TRANSPOSE(matC, uu);
ELL_3M_MUL(matB, uu, matC);
fprintf(stderr, "%s: uu * uu^T = \n", me);
ell_3m_print_d(stderr, matB);
fprintf(stderr, "%s: sval = %g %g %g\n", me, sval[0], sval[1], sval[2]);
fprintf(stderr, "%s: vv = \n", me);
ell_3m_print_d(stderr, vv);
ELL_3M_MUL(matB, vv, vv);
fprintf(stderr, "%s: vv * vv^T = \n", me);
ELL_3M_TRANSPOSE(matC, vv);
ELL_3M_MUL(matB, vv, matC);
ell_3m_print_d(stderr, matB);
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu);
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]);
ell_3m_pre_mul_d(matA, matB);
ell_3m_pre_mul_d(matA, vv);
fprintf(stderr, "%s: uu * diag(sval) * vv = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", me);
*/
/* now create symmetric matrix out of U and sval */
/* A = I */
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu); /* A = A*U = I*U = U */
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]); /* B = diag(sval) */
ell_3m_pre_mul_d(matA, matB); /* A = U*diag(sval) */
ELL_3M_TRANSPOSE(matB, uu);
ell_3m_pre_mul_d(matA, matB); /* A = U*diag(sval)*U^T */
TEN_M2T(ten, matA);
partIdx = soidDoit(obj, lookSoid,
gtype, gamma, res,
(AIR_EXISTS(AB[0]) && AIR_EXISTS(AB[1])) ? AB : NULL,
ten);
if (1 == escl[0]) {
scalingMatrix(matB, escl + 1, escl[4]);
ELL_43M_INSET(matBf, matB);
limnObjectPartTransform(obj, partIdx, matBf);
}
/* this is a rotate on the geomtry; nothing to do with the tensor */
ELL_4V_SET(qq, 1, pp[0], pp[1], pp[2]);
ELL_4V_NORM(qq, qq, len);
ell_q_to_3m_f(mR, qq);
ELL_43M_INSET(matBf, mR);
limnObjectPartTransform(obj, partIdx, matBf);
if (rad) {
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-eval[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, (1+eval[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-eval[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, -(1+eval[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-eval[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, (1+eval[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-eval[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, -(1+eval[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, (1+eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, -(1+eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
}
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
if (limnObjectWriteOFF(file, obj)) {
airMopAdd(mop, err = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
