void
_ra2t(Nrrd *nten, double rad, double angle,
double mRI[9], double mRF[9], double hack) {
double x, y, xyz[3], XX[3], YY[3], CC[3], EE[3], VV[3], tmp, mD[9], mT[9];
float *tdata;
int xi, yi, sx, sy;
sx = nten->axis[1].size;
sy = nten->axis[2].size;
x = rad*sin(AIR_PI*angle/180);
y = rad*cos(AIR_PI*angle/180);
xi = airIndexClamp(0.0, x, sqrt(3.0)/2.0, sx);
yi = airIndexClamp(0.0, y, 0.5, sy);
ELL_3V_SET(VV, 0, 3, 0);
ELL_3V_SET(EE, 1.5, 1.5, 0);
ELL_3V_SET(CC, 1, 1, 1);
ELL_3V_SUB(YY, EE, CC);
ELL_3V_SUB(XX, VV, EE);
ELL_3V_NORM(XX, XX, tmp);
ELL_3V_NORM(YY, YY, tmp);
ELL_3V_SCALE_ADD3(xyz, 1.0, CC, hack*x, XX, hack*y, YY);
ELL_3M_IDENTITY_SET(mD);
ELL_3M_DIAG_SET(mD, xyz[0], xyz[1], xyz[2]);
ELL_3M_IDENTITY_SET(mT);
ell_3m_post_mul_d(mT, mRI);
ell_3m_post_mul_d(mT, mD);
ell_3m_post_mul_d(mT, mRF);
tdata = (float*)(nten->data) + 7*(xi + sx*(yi + 1*sy));
tdata[0] = 1.0;
TEN_M2T(tdata, mT);
}
int
_echoRayIntx_Sphere(RAYINTX_ARGS(Sphere)) {
echoPos_t t, A, B, C, r[3], dscr, pos[3], tmp;
AIR_UNUSED(parm);
AIR_UNUSED(tstate);
ELL_3V_SUB(r, ray->from, obj->pos);
A = ELL_3V_DOT(ray->dir, ray->dir);
B = 2*ELL_3V_DOT(ray->dir, r);
C = ELL_3V_DOT(r, r) - obj->rad*obj->rad;
dscr = B*B - 4*A*C;
if (dscr <= 0) {
/* grazes or misses (most common case) */
return AIR_FALSE;
}
/* else */
dscr = sqrt(dscr);
t = (-B - dscr)/(2*A);
if (!AIR_IN_CL(ray->neer, t, ray->faar)) {
t = (-B + dscr)/(2*A);
if (!AIR_IN_CL(ray->neer, t, ray->faar)) {
return AIR_FALSE;
}
}
/* else one of the intxs is in [neer,faar] segment */
intx->t = t;
ELL_3V_SCALE_ADD2(pos, 1, ray->from, t, ray->dir);
ELL_3V_SUB(intx->norm, pos, obj->pos);
ELL_3V_NORM(intx->norm, intx->norm, tmp);
intx->obj = OBJECT(obj);
/* does NOT set u, v */
return AIR_TRUE;
}
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;
}
int
_echoRayIntx_TriMesh(RAYINTX_ARGS(TriMesh)) {
echoPos_t *pos, vert0[3], edge0[3], edge1[3], pvec[3], qvec[3], tvec[3],
det, t, tmax, u, v, tmp;
echoTriMesh *trim;
int i, ret;
AIR_UNUSED(parm);
trim = TRIMESH(obj);
if (!_echoRayIntx_CubeSolid(&t, &tmax,
trim->min[0], trim->max[0],
trim->min[1], trim->max[1],
trim->min[2], trim->max[2], ray)) {
if (tstate->verbose) {
fprintf(stderr, "%s%s: trimesh bbox (%g,%g,%g) --> (%g,%g,%g) not hit\n",
_echoDot(tstate->depth), "_echoRayIntx_TriMesh",
trim->min[0], trim->min[1], trim->min[2],
trim->max[0], trim->max[1], trim->max[2]);
}
return AIR_FALSE;
}
/* stupid linear search for now */
ret = AIR_FALSE;
for (i=0; i<trim->numF; i++) {
pos = trim->pos + 3*trim->vert[0 + 3*i];
ELL_3V_COPY(vert0, pos);
pos = trim->pos + 3*trim->vert[1 + 3*i];
ELL_3V_SUB(edge0, pos, vert0);
pos = trim->pos + 3*trim->vert[2 + 3*i];
ELL_3V_SUB(edge1, pos, vert0);
TRI_INTX(ray, vert0, edge0, edge1,
pvec, qvec, tvec, det, t, u, v,
(v < 0.0 || u + v > 1.0), continue);
if (ray->shadow) {
return AIR_TRUE;
}
intx->t = ray->faar = t;
ELL_3V_CROSS(intx->norm, edge0, edge1);
ELL_3V_NORM(intx->norm, intx->norm, tmp);
intx->obj = (echoObject *)obj;
intx->face = i;
ret = AIR_TRUE;
}
/* does NOT set u, v */
return ret;
}
int
_echoRayIntx_Triangle(RAYINTX_ARGS(Triangle)) {
echoPos_t pvec[3], qvec[3], tvec[3], det, t, u, v, edge0[3], edge1[3], tmp;
AIR_UNUSED(parm);
AIR_UNUSED(tstate);
ELL_3V_SUB(edge0, obj->vert[1], obj->vert[0]);
ELL_3V_SUB(edge1, obj->vert[2], obj->vert[0]);
TRI_INTX(ray, obj->vert[0], edge0, edge1,
pvec, qvec, tvec, det, t, u, v,
(v < 0.0 || u + v > 1.0), return AIR_FALSE);
intx->t = t;
intx->u = u;
intx->v = v;
ELL_3V_CROSS(intx->norm, edge0, edge1);
ELL_3V_NORM(intx->norm, intx->norm, tmp);
intx->obj = (echoObject *)obj;
/* DOES set u, v */
return AIR_TRUE;
}
void
_echoRayIntxUV_TriMesh(echoIntx *intx) {
echoPos_t u, v, norm[3], len;
echoTriMesh *trim;
trim = TRIMESH(intx->obj);
ELL_3V_SUB(norm, intx->pos, trim->meanvert);
ELL_3V_NORM(norm, norm, len);
if (norm[0] || norm[1]) {
u = atan2(norm[1], norm[0]);
intx->u = AIR_AFFINE(-AIR_PI, u, AIR_PI, 0.0, 1.0);
v = -asin(norm[2]);
intx->v = AIR_AFFINE(-AIR_PI/2, v, AIR_PI/2, 0.0, 1.0);
}
else {
intx->u = 0;
intx->v = AIR_AFFINE(1.0, norm[2], -1.0, 0.0, 1.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;
}
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;
}
/*
** Do asynchronous update of positions in "npos', based on force
** calculations wherein the distances are normalized "edge". Using a
** small "edge" allows forces to either underflow to zero, or be
** finite, instead of exploding to infinity, for high exponents.
**
** The smallest seen edge length is recorded in "*edgeMin", which is
** initialized to the given "edge". This allows, for example, the
** caller to try again with a smaller edge normalization.
**
** The mean velocity of the points through the update is recorded in
** "*meanVel".
**
** Based on the observation that when using large exponents, numerical
** difficulties arise from the (force-based) update of the positions
** of the two (or few) closest particles, this function puts a speed
** limit (variable "limit") on the distance a particle may move during
** update, expressed as a fraction of the normalizing edge length.
** "limit" has been set heuristically, according to the exponent (we
** have to clamp speeds more aggresively with higher exponents), as
** well as (even more heuristically) according to the number of times
** the step size has been decreased. This latter factor has to be
** bounded, so that the update is not unnecessarily bounded when the
** step size gets very small at the last stages of computation.
** Without the step-size-based speed limit, the step size would
** sometimes (e.g. num=200, expo=300) have to reduced to a miniscule
** value, which slows subsequent convergence terribly.
**
** this function is not static, though it could be, so that mac's
** "Sampler" app can profile this
*/
int
_tenGradientUpdate(double *meanVel, double *edgeMin,
Nrrd *npos, double edge, tenGradientParm *tgparm) {
/* static const char me[]="_tenGradientUpdate"; */
double *pos, newpos[3], grad[3], ngrad[3],
dir[3], len, rep, step, diff[3], limit, expo;
int num, ii, jj, E;
E = 0;
pos = AIR_CAST(double *, npos->data);
num = AIR_UINT(npos->axis[1].size);
*meanVel = 0;
*edgeMin = edge;
expo = tgparm->expo ? tgparm->expo : tgparm->expo_d;
limit = expo*AIR_MIN(sqrt(expo),
log(1 + tgparm->initStep/tgparm->step));
for (ii=0; ii<num; ii++) {
ELL_3V_SET(grad, 0, 0, 0);
for (jj=0; jj<num; jj++) {
if (ii == jj) {
continue;
}
ELL_3V_SUB(dir, pos + 3*ii, pos + 3*jj);
ELL_3V_NORM(dir, dir, len);
*edgeMin = AIR_MIN(*edgeMin, len);
if (tgparm->expo) {
rep = airIntPow(edge/len, tgparm->expo+1);
} else {
rep = pow(edge/len, tgparm->expo_d+1);
}
ELL_3V_SCALE_INCR(grad, rep/num, dir);
if (!tgparm->single) {
ELL_3V_ADD2(dir, pos + 3*ii, pos + 3*jj);
ELL_3V_NORM(dir, dir, len);
*edgeMin = AIR_MIN(*edgeMin, len);
if (tgparm->expo) {
rep = airIntPow(edge/len, tgparm->expo+1);
} else {
rep = pow(edge/len, tgparm->expo_d+1);
}
ELL_3V_SCALE_INCR(grad, rep/num, dir);
}
}
ELL_3V_NORM(ngrad, grad, len);
if (!( AIR_EXISTS(len) )) {
/* things blew up, either in incremental force
additions, or in the attempt at normalization */
E = 1;
*meanVel = AIR_NAN;
break;
}
if (0 == len) {
/* if the length of grad[] underflowed to zero, we can
legitimately zero out ngrad[] */
ELL_3V_SET(ngrad, 0, 0, 0);
}
step = AIR_MIN(len*tgparm->step, edge/limit);
ELL_3V_SCALE_ADD2(newpos,
1.0, pos + 3*ii,
step, ngrad);
ELL_3V_NORM(newpos, newpos, len);
ELL_3V_SUB(diff, pos + 3*ii, newpos);
*meanVel += ELL_3V_LEN(diff);
ELL_3V_COPY(pos + 3*ii, newpos);
}
*meanVel /= num;
return E;
}
void
tenGradientMeasure(double *pot, double *minAngle, double *minEdge,
const Nrrd *npos, tenGradientParm *tgparm,
int edgeNormalize) {
/* static const char me[]="tenGradientMeasure"; */
double diff[3], *pos, atmp=0, ptmp, edge, len;
unsigned int ii, jj, num;
/* allow minAngle NULL */
if (!(pot && npos && tgparm )) {
return;
}
num = AIR_UINT(npos->axis[1].size);
pos = AIR_CAST(double *, npos->data);
edge = (edgeNormalize
? tenGradientIdealEdge(num, tgparm->single)
: 1.0);
*pot = 0;
if (minAngle) {
*minAngle = AIR_PI;
}
if (minEdge) {
*minEdge = 2;
}
for (ii=0; ii<num; ii++) {
for (jj=0; jj<ii; jj++) {
ELL_3V_SUB(diff, pos + 3*ii, pos + 3*jj);
len = ELL_3V_LEN(diff);
if (minEdge) {
*minEdge = AIR_MIN(*minEdge, len);
}
if (tgparm->expo) {
ptmp = airIntPow(edge/len, tgparm->expo);
} else {
ptmp = pow(edge/len, tgparm->expo_d);
}
*pot += ptmp;
if (minAngle) {
atmp = ell_3v_angle_d(pos + 3*ii, pos + 3*jj);
*minAngle = AIR_MIN(atmp, *minAngle);
}
if (!tgparm->single) {
*pot += ptmp;
ELL_3V_ADD2(diff, pos + 3*ii, pos + 3*jj);
len = ELL_3V_LEN(diff);
if (minEdge) {
*minEdge = AIR_MIN(*minEdge, len);
}
if (tgparm->expo) {
*pot += 2*airIntPow(edge/len, tgparm->expo);
} else {
*pot += 2*pow(edge/len, tgparm->expo_d);
}
if (minAngle) {
*minAngle = AIR_MIN(AIR_PI-atmp, *minAngle);
}
}
}
}
return;
}
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;
}
/* HEY: have to make sure that scale position point->pos[3]
** is not modified anywhere in here: constraints are ONLY spatial
**
** This uses biff, but only for showstopper problems
*/
int
_pullConstraintSatisfy(pullTask *task, pullPoint *point,
double travelMax,
/* output */
int *constrFailP) {
static const char me[]="_pullConstraintSatisfy";
double stepMax;
unsigned int iterMax;
double pos3Orig[3], pos3Diff[3], travel;
ELL_3V_COPY(pos3Orig, point->pos);
stepMax = task->pctx->voxelSizeSpace;
iterMax = task->pctx->iterParm.constraintMax;
/*
dlim = _pullDistLimit(task, point);
if (iterMax*stepMax > dlim) {
stepMax = dlim/iterMax;
}
*/
/*
fprintf(stderr, "!%s(%d): hi ==== %g %g %g, stepMax = %g, iterMax = %u\n",
me, point->idtag, point->pos[0], point->pos[1], point->pos[2],
stepMax, iterMax);
*/
task->pctx->count[pullCountConstraintSatisfy] += 1;
switch (task->pctx->constraint) {
case pullInfoHeightLaplacian: /* zero-crossing edges */
if (constraintSatLapl(task, point, stepMax/4, 4*iterMax, constrFailP)) {
biffAddf(PULL, "%s: trouble", me);
return 1;
}
break;
case pullInfoIsovalue:
if (constraintSatIso(task, point, stepMax, iterMax, constrFailP)) {
biffAddf(PULL, "%s: trouble", me);
return 1;
}
break;
case pullInfoHeight:
if (constraintSatHght(task, point,
!!task->pctx->ispec[pullInfoTangent1],
!!task->pctx->ispec[pullInfoTangent2],
!!task->pctx->ispec[pullInfoNegativeTangent1],
!!task->pctx->ispec[pullInfoNegativeTangent2],
stepMax, iterMax, constrFailP)) {
biffAddf(PULL, "%s: trouble", me);
return 1;
}
break;
default:
fprintf(stderr, "%s: constraint on %s (%d) unimplemented!!\n", me,
airEnumStr(pullInfo, task->pctx->constraint),
task->pctx->constraint);
}
ELL_3V_SUB(pos3Diff, pos3Orig, point->pos);
travel = ELL_3V_LEN(pos3Diff)/task->pctx->voxelSizeSpace;
if (travel > travelMax) {
*constrFailP = pullConstraintFailTravel;
}
/*
fprintf(stderr, "!%s(%u) %s @ (%g,%g,%g) = (%g,%g,%g) + (%g,%g,%g)\n", me,
point->idtag,
(*constrFailP
? airEnumStr(pullConstraintFail, *constrFailP)
: "#GOOD#"),
point->pos[0], point->pos[1], point->pos[2],
pos3Diff[0], pos3Diff[1], pos3Diff[2],
pos3Orig[0], pos3Orig[1], pos3Orig[2]);
*/
return 0;
}
/*
** _gageShapeSet
**
** we are serving two masters here. If ctx is non-NULL, we are being called
** from within gage, and we are to be lax or strict according to the settings
** of ctx->parm.requireAllSpacings and ctx->parm.requireEqualCenters. If
** ctx is NULL, gageShapeSet was called, in which case we go with lax
** behavior (nothing "required")
**
** This function has subsumed the old gageVolumeCheck, and hence has
** become this weird beast- part error checker and part (gageShape)
** initializer. Oh well...
*/
int
_gageShapeSet(const gageContext *ctx, gageShape *shape,
const Nrrd *nin, unsigned int baseDim) {
char me[]="_gageShapeSet", err[BIFF_STRLEN];
int ai, cx, cy, cz, defCenter, statCalc[3];
unsigned int minsize, sx, sy, sz;
const NrrdAxisInfo *ax[3];
double maxLen, defSpacing,
vecA[4], vecB[3], vecC[3], vecD[4], matA[9],
spcCalc[3], vecCalc[3][NRRD_SPACE_DIM_MAX], orig[NRRD_SPACE_DIM_MAX];
/* ------ basic error checking */
if (!( shape && nin )) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(GAGE, err); if (shape) { gageShapeReset(shape); }
return 1;
}
if (nrrdCheck(nin)) {
sprintf(err, "%s: basic nrrd validity check failed", me);
biffMove(GAGE, err, NRRD); gageShapeReset(shape);
return 1;
}
if (nrrdTypeBlock == nin->type) {
sprintf(err, "%s: need a non-block type nrrd", me);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
if (!(nin->dim == 3 + baseDim)) {
sprintf(err, "%s: nrrd should be %u-D, not %u-D",
me, 3 + baseDim, nin->dim);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
ax[0] = &(nin->axis[baseDim+0]);
ax[1] = &(nin->axis[baseDim+1]);
ax[2] = &(nin->axis[baseDim+2]);
/*
if (1) {
unsigned int ai;
for (ai=0; ai<3; ai++) {
fprintf(stderr, "!%s: ax[%u] spc = %g, sd = %g %g %g\n", me, ai,
ax[ai]->spacing,
ax[ai]->spaceDirection[0],
ax[ai]->spaceDirection[1],
ax[ai]->spaceDirection[2]);
}
}
*/
statCalc[0] = nrrdSpacingCalculate(nin, baseDim + 0,
spcCalc + 0, vecCalc[0]);
statCalc[1] = nrrdSpacingCalculate(nin, baseDim + 1,
spcCalc + 1, vecCalc[1]);
statCalc[2] = nrrdSpacingCalculate(nin, baseDim + 2,
spcCalc + 2, vecCalc[2]);
/*
fprintf(stderr, "!%s: axis stat %d %d %d\n", me,
statCalc[0], statCalc[1], statCalc[2]);
*/
/* see if nrrdSpacingCalculate ever *failed* */
if (nrrdSpacingStatusUnknown == statCalc[0]
|| nrrdSpacingStatusUnknown == statCalc[1]
|| nrrdSpacingStatusUnknown == statCalc[2]) {
sprintf(err, "%s: nrrdSpacingCalculate trouble on axis %d, %d, or %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
/* see if nrrdSpacingCalculate encountered an axis with no space
direction in a nrrd that nominally has a surrounding space */
if (nrrdSpacingStatusScalarWithSpace == statCalc[0]
|| nrrdSpacingStatusScalarWithSpace == statCalc[1]
|| nrrdSpacingStatusScalarWithSpace == statCalc[2]) {
sprintf(err, "%s: nrrdSpacingCalculate weirdness on axis %d, %d, or %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
if (!( ( nrrdSpacingStatusDirection == statCalc[0]
&& nrrdSpacingStatusDirection == statCalc[1]
&& nrrdSpacingStatusDirection == statCalc[2])
||
( nrrdSpacingStatusDirection != statCalc[0]
&& nrrdSpacingStatusDirection != statCalc[1]
&& nrrdSpacingStatusDirection != statCalc[2])
)) {
sprintf(err, "%s: inconsistent space directions use "
"in axis %d, %d, and %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
if ( nrrdSpacingStatusDirection == statCalc[0]
&& nrrdSpacingStatusDirection == statCalc[1]
&& nrrdSpacingStatusDirection == statCalc[2]) {
/* this will get reset to false in case of error */
shape->fromOrientation = AIR_TRUE;
} else {
shape->fromOrientation = AIR_FALSE;
}
/* oh yea, we should make sure the space dimension is right! */
if (shape->fromOrientation && 3 != nin->spaceDim) {
sprintf(err, "%s: orientation space dimension %d != 3",
me, nin->spaceDim);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
/* ------ find centering (set shape->center) */
/* HEY: when we have full orientation information (via spaceDirections
and spaceOrigin) the centering information is moot for determining
shape, but until all usage of gageShape stuff is properly overhauled
to take orientation into account, we'll still set shape->center */
cx = ax[0]->center;
cy = ax[1]->center;
cz = ax[2]->center;
if (ctx && ctx->parm.requireEqualCenters) {
if (!( cx == cy && cx == cz )) {
sprintf(err, "%s: axes %d,%d,%d centerings (%s,%s,%s) not equal", me,
baseDim+0, baseDim+1, baseDim+2,
airEnumStr(nrrdCenter, cx),
airEnumStr(nrrdCenter, cy),
airEnumStr(nrrdCenter, cz));
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
} else {
if ( (nrrdCenterUnknown != cx && nrrdCenterUnknown != cy && cx != cy)
|| (nrrdCenterUnknown != cy && nrrdCenterUnknown != cz && cy != cz)
|| (nrrdCenterUnknown != cx && nrrdCenterUnknown != cz && cx != cz) ) {
sprintf(err, "%s: two known centerings (of %s,%s,%s) are unequal", me,
airEnumStr(nrrdCenter, cx),
airEnumStr(nrrdCenter, cy),
airEnumStr(nrrdCenter, cz));
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
}
defCenter = ctx ? ctx->parm.defaultCenter : shape->defaultCenter;
shape->center = (nrrdCenterUnknown != cx ? cx
: (nrrdCenterUnknown != cy ? cy
: (nrrdCenterUnknown != cz ? cz
: defCenter)));
/* ------ find sizes (set shape->size[0,1,2]) */
sx = ax[0]->size;
sy = ax[1]->size;
sz = ax[2]->size;
minsize = (nrrdCenterCell == shape->center ? 1 : 2);
/* HEY: perhaps this should be relaxed if we have full orientation info */
if (!(sx >= minsize && sy >= minsize && sz >= minsize )) {
sprintf(err, "%s: sizes (%u,%u,%u) must all be >= %u "
"(min number of %s-centered samples)", me,
sx, sy, sz, minsize, airEnumStr(nrrdCenter, shape->center));
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
shape->size[0] = sx;
shape->size[1] = sy;
shape->size[2] = sz;
/* ------ find spacings (set shape->spacing[0,1,2]) */
if (shape->fromOrientation) {
shape->spacing[0] = AIR_ABS(spcCalc[0]);
shape->spacing[1] = AIR_ABS(spcCalc[1]);
shape->spacing[2] = AIR_ABS(spcCalc[2]);
for (ai=0; ai<=2; ai++) {
shape->volHalfLen[ai] = AIR_NAN;
shape->voxLen[ai] = AIR_NAN;
}
} else {
double xs, ys, zs;
unsigned int num[3];
xs = ax[0]->spacing;
ys = ax[1]->spacing;
zs = ax[2]->spacing;
if (ctx && ctx->parm.requireAllSpacings) {
if (!( AIR_EXISTS(xs) && AIR_EXISTS(ys) && AIR_EXISTS(zs) )) {
sprintf(err, "%s: spacings for axes %d,%d,%d don't all exist",
me, baseDim+0, baseDim+1, baseDim+2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
}
/* there is no shape->defaultSpacing, we'll go out on a limb ... */
defSpacing = ctx ? ctx->parm.defaultSpacing : nrrdDefaultSpacing;
xs = AIR_EXISTS(xs) ? xs : defSpacing;
ys = AIR_EXISTS(ys) ? ys : defSpacing;
zs = AIR_EXISTS(zs) ? zs : defSpacing;
if (!( xs != 0 && ys != 0 && zs != 0 )) {
sprintf(err, "%s: spacings (%g,%g,%g) for axes %d,%d,%d not all "
"non-zero", me, xs, ys, zs, baseDim+0, baseDim+1, baseDim+2);
biffAdd(GAGE, err); gageShapeReset(shape);
return 1;
}
/* ------ learn lengths for bounding nrrd in bi-unit cube
(set shape->volHalfLen[0,1,2] and shape->voxLen[0,1,2]) */
shape->spacing[0] = AIR_ABS(xs);
shape->spacing[1] = AIR_ABS(ys);
shape->spacing[2] = AIR_ABS(zs);
maxLen = 0.0;
for (ai=0; ai<=2; ai++) {
num[ai] = (nrrdCenterNode == shape->center
? shape->size[ai]-1
: shape->size[ai]);
shape->volHalfLen[ai] = num[ai]*shape->spacing[ai];
maxLen = AIR_MAX(maxLen, shape->volHalfLen[ai]);
}
/* Thu Dec 13 02:45:01 EST 2007
fixed long-standing bug in handling vols without full orientation info:
spacing[ai] was never scaled to account for being crammed into
the bi-unit cube!! */
for (ai=0; ai<=2; ai++) {
shape->volHalfLen[ai] /= maxLen;
shape->spacing[ai] = shape->voxLen[ai] = 2*shape->volHalfLen[ai]/num[ai];
}
}
/* ------ set transform matrices */
if (shape->fromOrientation) {
/* find translation vector (we check above that spaceDim == 3) */
nrrdSpaceOriginGet(nin, orig);
if (!( AIR_EXISTS(orig[0]) &&
AIR_EXISTS(orig[1]) &&
AIR_EXISTS(orig[2]) )) {
/* don't have origin, so set it to come from the middle of volume */
ELL_3V_SET(orig, 0.0f, 0.0f, 0.0f);
ELL_3V_SCALE_INCR(orig, -(shape->size[0] - 1.0f)*spcCalc[0]/2.0f,
vecCalc[0]);
ELL_3V_SCALE_INCR(orig, -(shape->size[1] - 1.0f)*spcCalc[1]/2.0f,
vecCalc[1]);
ELL_3V_SCALE_INCR(orig, -(shape->size[2] - 1.0f)*spcCalc[2]/2.0f,
vecCalc[2]);
}
vecD[3] = 0;
ELL_3V_SCALE(vecD, spcCalc[0], vecCalc[0]);
ELL_4MV_COL0_SET(shape->ItoW, vecD);
ELL_3V_SCALE(vecD, spcCalc[1], vecCalc[1]);
ELL_4MV_COL1_SET(shape->ItoW, vecD);
ELL_3V_SCALE(vecD, spcCalc[2], vecCalc[2]);
ELL_4MV_COL2_SET(shape->ItoW, vecD);
vecD[3] = 1;
ELL_3V_COPY(vecD, orig);
ELL_4MV_COL3_SET(shape->ItoW, vecD);
/*
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[0], vecCalc[0][0], vecCalc[0][1], vecCalc[0][2]);
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[1], vecCalc[1][0], vecCalc[1][1], vecCalc[1][2]);
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[2], vecCalc[2][0], vecCalc[2][1], vecCalc[2][2]);
*/
} else {
ELL_3V_SET(vecC, 0, 0, 0);
_gageShapeUnitItoW(shape, vecA, vecC);
ELL_3V_SET(vecC, 1, 0, 0);
_gageShapeUnitItoW(shape, vecB, vecC);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL0_SET(shape->ItoW, vecD);
ELL_3V_SET(vecC, 0, 1, 0);
_gageShapeUnitItoW(shape, vecB, vecC);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL1_SET(shape->ItoW, vecD);
ELL_3V_SET(vecC, 0, 0, 1);
_gageShapeUnitItoW(shape, vecB, vecC);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL2_SET(shape->ItoW, vecD);
vecA[3] = 1;
ELL_4MV_COL3_SET(shape->ItoW, vecA);
}
ell_4m_inv_d(shape->WtoI, shape->ItoW);
ELL_34M_EXTRACT(matA, shape->ItoW);
ell_3m_inv_d(shape->ItoWSubInv, matA);
ELL_3M_TRANSPOSE(shape->ItoWSubInvTransp, shape->ItoWSubInv);
return 0;
}
/*
******** 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[]) {
hestOpt *hopt=NULL;
hestParm *hparm;
Nrrd *nlight, *nmap, *ndebug;
const char *me;
char *outS, *errS, *debugS;
airArray *mop;
float amb[3], *linfo, *debug, *map, vscl;
unsigned li, ui, vi;
int qn, bits, method, doerr;
limnLight *light;
limnCamera *cam;
double u, v, r, w, V2W[9], diff, WW[3], VV[3];
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hparm->elideSingleEmptyStringDefault = AIR_TRUE;
cam = limnCameraNew();
airMopAdd(mop, cam, (airMopper)limnCameraNix, airMopAlways);
hestOptAdd(&hopt, "i", "nlight", airTypeOther, 1, 1, &nlight, NULL,
"input nrrd containing light information",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "b", "# bits", airTypeInt, 1, 1, &bits, "16",
"number of bits to use for normal quantization, "
"between 8 and 16 inclusive. ");
hestOptAdd(&hopt, "amb", "ambient RGB", airTypeFloat, 3, 3, amb, "0 0 0",
"ambient light color");
hestOptAdd(&hopt, "fr", "from point", airTypeDouble, 3, 3, cam->from,"1 0 0",
"position of camera, used to determine view vector");
hestOptAdd(&hopt, "at", "at point", airTypeDouble, 3, 3, cam->at, "0 0 0",
"camera look-at point, used to determine view vector");
hestOptAdd(&hopt, "up", "up vector", airTypeDouble, 3, 3, cam->up, "0 0 1",
"camera pseudo-up vector, used to determine view coordinates");
hestOptAdd(&hopt, "rh", NULL, airTypeInt, 0, 0, &(cam->rightHanded), NULL,
"use a right-handed UVN frame (V points down)");
hestOptAdd(&hopt, "vs", "view-dir scaling", airTypeFloat, 1, 1, &vscl, "1",
"scaling along view-direction of location of "
"view-space lights");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, NULL,
"file to write output envmap to");
hestOptAdd(&hopt, "d", "filename", airTypeString, 1, 1, &debugS, "",
"Use this option to save out (to the given filename) a rendering "
"of the front (on the left) and back (on the right) of a sphere "
"as shaded with the new environment map. U increases "
"right-ward, V increases downward. The back sphere half is "
"rendered as though the front half was removed");
hestOptAdd(&hopt, "err", NULL, airTypeInt, 0, 0, &doerr, NULL,
"If using \"-d\", make the image represent the error between the "
"real and quantized vector");
hestParseOrDie(hopt, argc-1, argv+1, hparm, me, emapInfo,
AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
switch(bits) {
case 16:
method = limnQN16octa;
break;
case 15:
method = limnQN15octa;
break;
case 14:
method = limnQN14octa;
break;
case 13:
method = limnQN13octa;
break;
case 12:
method = limnQN12octa;
break;
case 11:
method = limnQN11octa;
break;
case 10:
method = limnQN10octa;
break;
case 9:
method = limnQN9octa;
break;
case 8:
method = limnQN8octa;
break;
default:
fprintf(stderr, "%s: requested #bits (%d) not in valid range [8,16]\n",
me, bits);
airMopError(mop);
return 1;
}
if (!(nrrdTypeFloat == nlight->type &&
2 == nlight->dim &&
7 == nlight->axis[0].size &&
LIMN_LIGHT_NUM >= nlight->axis[1].size)) {
fprintf(stderr, "%s: nlight isn't valid format for light specification, "
"must be: float type, 2-dimensional, 7\tx\tN size, N <= %d\n",
me, LIMN_LIGHT_NUM);
airMopError(mop);
return 1;
}
cam->neer = -0.000000001;
cam->dist = 0;
cam->faar = 0.0000000001;
cam->atRelative = AIR_TRUE;
if (limnCameraUpdate(cam)) {
airMopAdd(mop, errS = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: problem with camera:\n%s\n", me, errS);
airMopError(mop);
return 1;
}
light = limnLightNew();
airMopAdd(mop, light, (airMopper)limnLightNix, airMopAlways);
limnLightAmbientSet(light, amb[0], amb[1], amb[2]);
for (li=0; li<nlight->axis[1].size; li++) {
int vsp;
float lxyz[3];
linfo = (float *)(nlight->data) + 7*li;
vsp = !!linfo[0];
ELL_3V_COPY(lxyz, linfo + 4);
if (vsp) {
lxyz[2] *= vscl;
}
limnLightSet(light, li, vsp,
linfo[1], linfo[2], linfo[3], lxyz[0], lxyz[1], lxyz[2]);
}
if (limnLightUpdate(light, cam)) {
airMopAdd(mop, errS = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: problem with lights:\n%s\n", me, errS);
airMopError(mop);
return 1;
}
nmap=nrrdNew();
airMopAdd(mop, nmap, (airMopper)nrrdNuke, airMopAlways);
if (limnEnvMapFill(nmap, limnLightDiffuseCB, method, light)) {
airMopAdd(mop, errS = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: problem making environment map:\n%s\n", me, errS);
airMopError(mop);
return 1;
}
map = (float *)nmap->data;
if (nrrdSave(outS, nmap, NULL)) {
fprintf(stderr, "%s: trouble:\n%s", me, errS = biffGetDone(NRRD));
free(errS);
return 1;
}
if (airStrlen(debugS)) {
ELL_34M_EXTRACT(V2W, cam->V2W);
ndebug = nrrdNew();
nrrdMaybeAlloc_va(ndebug, nrrdTypeFloat, 3,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, 1024),
AIR_CAST(size_t, 512));
airMopAdd(mop, ndebug, (airMopper)nrrdNuke, airMopAlways);
debug = (float *)ndebug->data;
for (vi=0; vi<=511; vi++) {
v = AIR_AFFINE(0, vi, 511, -0.999, 0.999);
for (ui=0; ui<=511; ui++) {
u = AIR_AFFINE(0, ui, 511, -0.999, 0.999);
r = sqrt(u*u + v*v);
if (r > 1) {
continue;
}
w = sqrt(1 - r*r);
/* first, the near side of the sphere */
ELL_3V_SET(VV, u, v, -w);
ELL_3MV_MUL(WW, V2W, VV);
qn = limnVtoQN_d[method](WW);
if (doerr) {
limnQNtoV_d[method](VV, qn);
ELL_3V_SUB(WW, WW, VV);
diff = ELL_3V_LEN(WW);
ELL_3V_SET_TT(debug + 3*(ui + 1024*vi), float,
diff, diff, diff);
} else {
ELL_3V_COPY(debug + 3*(ui + 1024*vi), map + 3*qn);
}
/* second, the far side of the sphere */
ELL_3V_SET(VV, u, v, w);
ELL_3MV_MUL(WW, V2W, VV);
qn = limnVtoQN_d[method](WW);
if (doerr) {
limnQNtoV_d[method](VV, qn);
ELL_3V_SUB(WW, WW, VV);
diff = ELL_3V_LEN(WW);
ELL_3V_SET_TT(debug + 3*(ui + 512 + 1024*vi), float,
diff, diff, diff);
} else {
ELL_3V_COPY(debug + 3*(ui + 512 + 1024*vi), map + 3*qn);
}
}
}
double
miteSample(miteThread *mtt, miteRender *mrr, miteUser *muu,
int num, double rayT, int inside,
double samplePosWorld[3],
double samplePosIndex[3]) {
static const char me[]="miteSample";
mite_t R, G, B, A;
double *NN;
double NdotV, kn[3], knd[3], ref[3], len, *dbg=NULL;
if (!inside) {
return mtt->rayStep;
}
if (mtt->skip) {
/* we have one verbose pixel, but we're not on it */
return 0.0;
}
/* early ray termination */
if (1-mtt->TT >= muu->opacNear1) {
mtt->TT = 0.0;
return 0.0;
}
/* set (fake) view based on fake from */
if (AIR_EXISTS(muu->fakeFrom[0])) {
ELL_3V_SUB(mtt->V, samplePosWorld, muu->fakeFrom);
ELL_3V_NORM(mtt->V, mtt->V, len);
}
/* do probing at this location to determine values of everything
that might appear in the txf domain */
if (gageProbe(mtt->gctx,
samplePosIndex[0],
samplePosIndex[1],
samplePosIndex[2])) {
biffAddf(MITE, "%s: gage trouble: %s (%d)", me,
mtt->gctx->errStr, mtt->gctx->errNum);
return AIR_NAN;
}
if (mrr->queryMiteNonzero) {
/* There is some optimal trade-off between slowing things down
with too many branches on all possible checks of queryMite,
and slowing things down with doing the work of setting them all.
This code has not been profiled whatsoever */
mtt->directAnsMiteVal[miteValXw][0] = samplePosWorld[0];
mtt->directAnsMiteVal[miteValXi][0] = samplePosIndex[0];
mtt->directAnsMiteVal[miteValYw][0] = samplePosWorld[1];
mtt->directAnsMiteVal[miteValYi][0] = samplePosIndex[1];
mtt->directAnsMiteVal[miteValZw][0] = samplePosWorld[2];
mtt->directAnsMiteVal[miteValZi][0] = samplePosIndex[2];
mtt->directAnsMiteVal[miteValRw][0] = ELL_3V_LEN(samplePosWorld);
mtt->directAnsMiteVal[miteValRi][0] = ELL_3V_LEN(samplePosIndex);
mtt->directAnsMiteVal[miteValTw][0] = rayT;
mtt->directAnsMiteVal[miteValTi][0] = num;
ELL_3V_COPY(mtt->directAnsMiteVal[miteValView], mtt->V);
NN = mtt->directAnsMiteVal[miteValNormal];
if (mtt->_normal) {
if (1 == muu->normalSide) {
ELL_3V_SCALE(NN, -1, mtt->_normal);
} else {
ELL_3V_COPY(NN, mtt->_normal);
}
}
if ((GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValNdotV)
|| GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValNdotL)
|| GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValVrefN))) {
mtt->directAnsMiteVal[miteValNdotV][0] = ELL_3V_DOT(NN, mtt->V);
mtt->directAnsMiteVal[miteValNdotL][0] =
ELL_3V_DOT(NN, muu->lit->dir[0]);
if (!muu->normalSide) {
mtt->directAnsMiteVal[miteValNdotV][0] =
AIR_ABS(mtt->directAnsMiteVal[miteValNdotV][0]);
mtt->directAnsMiteVal[miteValNdotL][0] =
AIR_ABS(mtt->directAnsMiteVal[miteValNdotL][0]);
}
NdotV = mtt->directAnsMiteVal[miteValNdotV][0];
ELL_3V_SCALE_ADD2(ref, 2*NdotV, NN, -1, mtt->V);
ELL_3V_NORM(mtt->directAnsMiteVal[miteValVrefN], ref, len);
}
if (GAGE_QUERY_ITEM_TEST(mrr->queryMite, miteValGTdotV)) {
ELL_3MV_MUL(kn, mtt->nPerp, mtt->V);
ELL_3V_NORM(kn, kn, len);
ELL_3MV_MUL(knd, mtt->geomTens, kn);
mtt->directAnsMiteVal[miteValGTdotV][0] = ELL_3V_DOT(knd, kn);
}
}
/* initialize txf range quantities, and apply all txfs */
if (mtt->verbose) {
muu->debugIdx = airArrayLenIncr(muu->debugArr, muu->ndebug->axis[0].size);
}
memcpy(mtt->range, muu->rangeInit, MITE_RANGE_NUM*sizeof(mite_t));
_miteStageRun(mtt, muu);
/* if there's opacity, do shading and compositing */
if (mtt->range[miteRangeAlpha]) {
/* fprintf(stderr, "%s: mtt->TT = %g\n", me, mtt->TT); */
/*
if (mtt->verbose) {
fprintf(stderr, "%s: before compositing: RGBT = %g,%g,%g,%g\n",
me, mtt->RR, mtt->GG, mtt->BB, mtt->TT);
}
*/
_miteRGBACalc(&R, &G, &B, &A, mtt, mrr, muu);
mtt->RR += mtt->TT*A*R;
mtt->GG += mtt->TT*A*G;
mtt->BB += mtt->TT*A*B;
mtt->TT *= 1-A;
/*
if (mtt->verbose) {
fprintf(stderr, "%s: after compositing: RGBT = %g,%g,%g,%g\n",
me, mtt->RR, mtt->GG, mtt->BB, mtt->TT);
}
*/
/* fprintf(stderr, "%s: mtt->TT = %g\n", me, mtt->TT); */
} else {
R = G = B = A = 0;
}
if (mtt->verbose) {
dbg = muu->debug + muu->debugIdx;
dbg[0 + 2*mtt->stageNum] = R;
dbg[1 + 2*mtt->stageNum] = G;
dbg[2 + 2*mtt->stageNum] = B;
dbg[3 + 2*mtt->stageNum] = A;
dbg[4 + 2*mtt->stageNum] = rayT;
}
/* set Z if it hasn't been set already */
if (1-mtt->TT >= muu->opacMatters && !AIR_EXISTS(mtt->ZZ)) {
mtt->ZZ = rayT;
}
/* this is used to index mtt->debug */
mtt->raySample += 1;
return mtt->rayStep;
}
/*
** _gageShapeSet
**
** we are serving two masters here. If ctx is non-NULL, we are being called
** from within gage, and we are to be lax or strict according to the settings
** of ctx->parm.requireAllSpacings and ctx->parm.requireEqualCenters. If
** ctx is NULL, gageShapeSet was called, in which case we go with lax
** behavior (nothing "required")
**
** This function has subsumed the contents of the old gageVolumeCheck,
** and hence has become this weird beast- part error checker and part
** (gageShape) initializer. Oh well...
*/
int
_gageShapeSet(const gageContext *ctx, gageShape *shape,
const Nrrd *nin, unsigned int baseDim) {
static const char me[]="_gageShapeSet";
int ai, cx, cy, cz, statCalc[3], status, ofspc;
unsigned int minsize;
const NrrdAxisInfo *ax[3];
double vecA[4], vecB[3], vecC[3], vecD[4], matA[9],
spcCalc[3], vecCalc[3][NRRD_SPACE_DIM_MAX], orig[NRRD_SPACE_DIM_MAX];
airArray *mop;
/*
fprintf(stderr, "!%s: ctx = %p (%s, %s)\n", me, ctx,
(ctx
? (ctx->shape->fromOrientation
? "YES from orient"
: "not from orient")
: "???"),
(ctx
? (ctx->parm.orientationFromSpacing
? "YES ofs"
: "not ofs")
: "???"));
*/
/* ------ basic error checking */
mop = airMopNew();
airMopAdd(mop, shape, _mopShapeReset, airMopOnError);
if (!( shape && nin )) {
biffAddf(GAGE, "%s: got NULL pointer", me);
airMopError(mop); return 1;
}
if (nrrdCheck(nin)) {
biffMovef(GAGE, NRRD, "%s: basic nrrd validity check failed", me);
airMopError(mop); return 1;
}
if (nrrdTypeBlock == nin->type) {
biffAddf(GAGE, "%s: need a non-block type nrrd", me);
airMopError(mop); return 1;
}
if (!(nin->dim == 3 + baseDim)) {
biffAddf(GAGE, "%s: nrrd should be %u-D, not %u-D",
me, 3 + baseDim, nin->dim);
airMopError(mop); return 1;
}
ax[0] = &(nin->axis[baseDim+0]);
ax[1] = &(nin->axis[baseDim+1]);
ax[2] = &(nin->axis[baseDim+2]);
statCalc[0] = nrrdSpacingCalculate(nin, baseDim + 0,
spcCalc + 0, vecCalc[0]);
statCalc[1] = nrrdSpacingCalculate(nin, baseDim + 1,
spcCalc + 1, vecCalc[1]);
statCalc[2] = nrrdSpacingCalculate(nin, baseDim + 2,
spcCalc + 2, vecCalc[2]);
/* see if nrrdSpacingCalculate ever *failed* */
if (nrrdSpacingStatusUnknown == statCalc[0]
|| nrrdSpacingStatusUnknown == statCalc[1]
|| nrrdSpacingStatusUnknown == statCalc[2]) {
biffAddf(GAGE, "%s: nrrdSpacingCalculate trouble on axis %d, %d, or %d",
me, baseDim + 0, baseDim + 1, baseDim + 2);
airMopError(mop); return 1;
}
if (!( statCalc[0] == statCalc[1] && statCalc[1] == statCalc[2] )) {
biffAddf(GAGE, "%s: inconsistent spacing information on axes "
"%u (%s), %u (%s), and %u (%s)", me,
baseDim + 0, airEnumDesc(nrrdSpacingStatus, statCalc[0]),
baseDim + 1, airEnumDesc(nrrdSpacingStatus, statCalc[1]),
baseDim + 2, airEnumDesc(nrrdSpacingStatus, statCalc[2]));
airMopError(mop); return 1;
}
/* this simplifies reasoning in the code that follows */
status = statCalc[0];
/* zero spacing would be problematic */
if (0 == spcCalc[0] && 0 == spcCalc[1] && 0 == spcCalc[2]) {
biffAddf(GAGE, "%s: spacings (%g,%g,%g) for axes %d,%d,%d not all "
"non-zero", me, spcCalc[1], spcCalc[1], spcCalc[2],
baseDim+0, baseDim+1, baseDim+2);
airMopError(mop); return 1;
}
/* error checking based on status */
if (nrrdSpacingStatusScalarWithSpace == status) {
biffAddf(GAGE, "%s: sorry, can't handle per-axis spacing that isn't part "
"of a surrounding world space (%s)",
me, airEnumStr(nrrdSpacingStatus, status));
airMopError(mop); return 1;
}
/* we no longer allow a nrrd to come in with no spacing info at all */
if (nrrdSpacingStatusNone == status) {
biffAddf(GAGE, "%s: sorry, need some spacing info for spatial axes "
"%u, %u, %u", me,
baseDim+0, baseDim+1, baseDim+2);
airMopError(mop); return 1;
}
/* actually, there shouldn't be any other options for spacing status
besides these too; this is just being careful */
if (!( nrrdSpacingStatusDirection == status
|| nrrdSpacingStatusScalarNoSpace == status )) {
biffAddf(GAGE, "%s: sorry, can only handle spacing status %d (%s) "
"or %d (%s), not %d (%s)", me,
nrrdSpacingStatusDirection,
airEnumStr(nrrdSpacingStatus, nrrdSpacingStatusDirection),
nrrdSpacingStatusScalarNoSpace,
airEnumStr(nrrdSpacingStatus, nrrdSpacingStatusScalarNoSpace),
status, airEnumStr(nrrdSpacingStatus, status));
airMopError(mop); return 1;
}
if (nrrdSpacingStatusDirection == status) {
shape->fromOrientation = AIR_TRUE;
if (3 != nin->spaceDim) {
biffAddf(GAGE, "%s: orientation space dimension %d != 3",
me, nin->spaceDim);
airMopError(mop); return 1;
}
} else {
shape->fromOrientation = AIR_FALSE;
}
/* ------ find centering (set shape->center) */
/* NOTE: when the volume is being crammed in a bi-unit cube, the centering
will actually affect the positions of the samples. Otherwise,
(having full orientation, or using orientationFromSpacing), the
centering will only affect the probe-able bounds of the volume, but
the sample positions in space don't depend on centering */
cx = ax[0]->center;
cy = ax[1]->center;
cz = ax[2]->center;
if (!( cx == cy && cy == cz )) {
biffAddf(GAGE,
"%s: axes %d,%d,%d centerings (%s,%s,%s) not all equal",
me, baseDim+0, baseDim+1, baseDim+2,
airEnumStr(nrrdCenter, cx),
airEnumStr(nrrdCenter, cy),
airEnumStr(nrrdCenter, cz));
airMopError(mop); return 1;
}
/* Hopefully, ctx->parm.defaultCenter == shape->defaultCenter; and this
worry will be moot if ctx->parm.defaultCenter goes away */
shape->center = (nrrdCenterUnknown != cx
? cx /* cx == cy == cz, by above */
: (ctx
? ctx->parm.defaultCenter
: shape->defaultCenter));
/* ------ find sizes (set shape->size[0,1,2]) */
shape->size[0] = ax[0]->size;
shape->size[1] = ax[1]->size;
shape->size[2] = ax[2]->size;
minsize = (nrrdCenterCell == shape->center ? 1 : 2);
/* this can't be relaxed in the face of having full orientation info,
because even then, you can't have a non-zero probe-able volume if
there's only one sample along a node-centered axis */
if (!(shape->size[0] >= minsize
&& shape->size[1] >= minsize
&& shape->size[2] >= minsize )) {
biffAddf(GAGE, "%s: sizes (%u,%u,%u) must all be >= %u "
"(min number of %s-centered samples)", me,
shape->size[0], shape->size[1], shape->size[2],
minsize, airEnumStr(nrrdCenter, shape->center));
airMopError(mop); return 1;
}
/* ------ find spacings[0,1,2] and ItoW matrix */
/* Hopefully, ctx->parm.orientationFromSpacing and
shape->orientationFromSpacing don't represent competing interests;
this worry will be moot if ctx->parm.orientationFromSpacing goes away */
ofspc = ((ctx && ctx->parm.orientationFromSpacing)
|| shape->orientationFromSpacing);
if (shape->fromOrientation || ofspc) {
if (ofspc) {
/* need abs() in case an axis had negative spacing */
ELL_3V_ABS(shape->spacing, spcCalc);
ELL_3V_SET(vecCalc[0], airSgn(spcCalc[0]), 0.0, 0.0);
ELL_3V_SET(vecCalc[1], 0.0, airSgn(spcCalc[1]), 0.0);
ELL_3V_SET(vecCalc[2], 0.0, 0.0, airSgn(spcCalc[2]));
} else {
ELL_3V_COPY(shape->spacing, spcCalc);
/* vecCalc set by nrrdSpacingCalculate */
}
if (shape->fromOrientation) {
/* if the spaceOrigin isn't set, this will be all NaNs */
nrrdSpaceOriginGet(nin, orig);
} else {
/* sorry, if you want to specify an image origin that over-rides the
behavior of centering the volume at (0,0,0), then it has to be
done through the full orientation info. That is, we don't want
to use nrrdOriginCalculate() because otherwise the logic gets
too complicated */
ELL_3V_SET(orig, AIR_NAN, AIR_NAN, AIR_NAN);
}
if (!ELL_3V_EXISTS(orig)) {
/* don't have origin, for whatever reason; center volume on (0,0,0) */
ELL_3V_SET(orig, 0.0, 0.0, 0.0);
ELL_3V_SCALE_INCR(orig, -(shape->size[0] - 1.0)*shape->spacing[0]/2.0,
vecCalc[0]);
ELL_3V_SCALE_INCR(orig, -(shape->size[1] - 1.0)*shape->spacing[1]/2.0,
vecCalc[1]);
ELL_3V_SCALE_INCR(orig, -(shape->size[2] - 1.0)*shape->spacing[2]/2.0,
vecCalc[2]);
}
vecD[3] = 0;
ELL_3V_SCALE(vecD, spcCalc[0], vecCalc[0]);
ELL_4MV_COL0_SET(shape->ItoW, vecD);
ELL_3V_SCALE(vecD, spcCalc[1], vecCalc[1]);
ELL_4MV_COL1_SET(shape->ItoW, vecD);
ELL_3V_SCALE(vecD, spcCalc[2], vecCalc[2]);
ELL_4MV_COL2_SET(shape->ItoW, vecD);
vecD[3] = 1;
ELL_3V_COPY(vecD, orig);
ELL_4MV_COL3_SET(shape->ItoW, vecD);
/*
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[0], vecCalc[0][0], vecCalc[0][1], vecCalc[0][2]);
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[1], vecCalc[1][0], vecCalc[1][1], vecCalc[1][2]);
fprintf(stderr, "%s: %g (%g,%g,%g)\n", me,
spcCalc[2], vecCalc[2][0], vecCalc[2][1], vecCalc[2][2]);
*/
/*
fprintf(stderr, "%s: ItoW = %g %g %g %g\n", me,
shape->ItoW[ 0], shape->ItoW[ 1], shape->ItoW[ 2], shape->ItoW[ 3]);
fprintf(stderr, "%s: %g %g %g %g\n", me,
shape->ItoW[ 4], shape->ItoW[ 5], shape->ItoW[ 6], shape->ItoW[ 7]);
fprintf(stderr, "%s: %g %g %g %g\n", me,
shape->ItoW[ 8], shape->ItoW[ 9], shape->ItoW[10], shape->ItoW[11]);
fprintf(stderr, "%s: %g %g %g %g\n", me,
shape->ItoW[12], shape->ItoW[13], shape->ItoW[14], shape->ItoW[15]);
*/
} else { /* not (shape->fromOrientation || ofspc) */
double maxLen, volHalfLen[3];
size_t num[3];
/* ------ learn lengths for bounding nrrd in bi-unit cube */
ELL_3V_ABS(shape->spacing, spcCalc);
maxLen = 0.0;
for (ai=0; ai<=2; ai++) {
num[ai] = (nrrdCenterNode == shape->center
? shape->size[ai]-1
: shape->size[ai]);
volHalfLen[ai] = num[ai]*shape->spacing[ai];
maxLen = AIR_MAX(maxLen, volHalfLen[ai]);
}
/* Thu Dec 13 02:45:01 EST 2007
fixed long-standing bug in handling vols without full orientation info:
spacing[ai] was never scaled to account for being crammed into
the bi-unit cube!! */
for (ai=0; ai<=2; ai++) {
volHalfLen[ai] /= maxLen;
shape->spacing[ai] = 2*volHalfLen[ai]/num[ai];
}
ELL_3V_SET(vecC, 0, 0, 0);
shapeUnitItoW(shape, vecA, vecC, volHalfLen);
ELL_3V_SET(vecC, 1, 0, 0);
shapeUnitItoW(shape, vecB, vecC, volHalfLen);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL0_SET(shape->ItoW, vecD);
ELL_3V_SET(vecC, 0, 1, 0);
shapeUnitItoW(shape, vecB, vecC, volHalfLen);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL1_SET(shape->ItoW, vecD);
ELL_3V_SET(vecC, 0, 0, 1);
shapeUnitItoW(shape, vecB, vecC, volHalfLen);
ELL_3V_SUB(vecD, vecB, vecA);
vecD[3] = 0;
ELL_4MV_COL2_SET(shape->ItoW, vecD);
vecA[3] = 1;
ELL_4MV_COL3_SET(shape->ItoW, vecA);
}
/* ------ set the rest of the matrices */
ell_4m_inv_d(shape->WtoI, shape->ItoW);
ELL_34M_EXTRACT(matA, shape->ItoW);
ell_3m_inv_d(shape->ItoWSubInv, matA);
ELL_3M_TRANSPOSE(shape->ItoWSubInvTransp, shape->ItoWSubInv);
airMopOkay(mop);
return 0;
}
static int
constraintSatLapl(pullTask *task, pullPoint *point,
double stepMax, unsigned int iterMax,
/* output */
int *constrFailP) {
static const char me[]="constraintSatLapl";
double
step, /* current step size */
valLast, val, /* last and current function values */
grad[4], dir[3], len,
posOld[3], posNew[3], tmpv[3];
double a=0, b=1, s, fa, fb, fs, tmp, diff;
int side = 0;
unsigned int iter = 0; /* 0: initial probe, 1..iterMax: probes in loop */
step = stepMax/2;
PROBEG(val, grad);
if (0 == val) {
/* already exactly at the zero, we're done. This actually happens! */
/* printf("!%s: a lapl == 0!\n", me); */
return 0;
}
valLast = val;
NORMALIZE(dir, grad, len);
/* first phase: follow normalized gradient until laplacian sign change */
for (iter=1; iter<=iterMax; iter++) {
double sgn;
ELL_3V_COPY(posOld, point->pos);
sgn = airSgn(val); /* lapl < 0 => downhill; lapl > 0 => uphill */
ELL_3V_SCALE_INCR(point->pos, sgn*step, dir);
_pullPointHistAdd(point, pullCondConstraintSatA);
PROBEG(val, grad);
if (val*valLast < 0) {
/* laplacian has changed sign; stop looking */
break;
}
valLast = val;
NORMALIZE(dir, grad, len);
}
if (iter > iterMax) {
*constrFailP = pullConstraintFailIterMaxed;
return 0;
}
/* second phase: find the zero-crossing, looking between
f(posOld)=valLast and f(posNew)=val */
ELL_3V_COPY(posNew, point->pos);
ELL_3V_SUB(tmpv, posNew, posOld);
len = ELL_3V_LEN(tmpv);
fa = valLast;
fb = val;
if (AIR_ABS(fa) < AIR_ABS(fb)) {
ELL_SWAP2(a, b, tmp); ELL_SWAP2(fa, fb, tmp);
}
for (iter=1; iter<=iterMax; iter++) {
s = AIR_AFFINE(fa, 0, fb, a, b);
ELL_3V_LERP(point->pos, s, posOld, posNew);
_pullPointHistAdd(point, pullCondConstraintSatB);
PROBE(fs);
if (0 == fs) {
/* exactly nailed the zero, we're done. This actually happens! */
printf("!%s: b lapl == 0!\n", me);
break;
}
/* "Illinois" false-position. Dumb, but it works. */
if (fs*fb > 0) { /* not between s and b */
b = s;
fb = fs;
if (+1 == side) {
fa /= 2;
}
side = +1;
} else { /* not between a and s */
a = s;
fa = fs;
if (-1 == side) {
fb /= 2;
}
side = -1;
}
diff = (b - a)*len;
if (AIR_ABS(diff) < stepMax*task->pctx->sysParm.constraintStepMin) {
/* converged! */
break;
}
}
if (iter > iterMax) {
*constrFailP = pullConstraintFailIterMaxed;
} else {
*constrFailP = AIR_FALSE;
}
return 0;
}
static int
constraintSatHght(pullTask *task, pullPoint *point,
int tang1Use, int tang2Use,
int negtang1Use, int negtang2Use,
double stepMax, unsigned int iterMax,
int *constrFailP) {
static const char me[]="constraintSatHght";
double val, grad[3], hess[9], posproj[9], negproj[9],
state[1+3+9+9+9+3], hack, step,
d1, d2, pdir[3], plen, pgrad[3];
#if PRAYING
double _tmpv[3]={0,0,0};
#endif
int havePos, haveNeg, haveNada;
unsigned int iter = 0; /* 0: initial probe, 1..iterMax: probes in loop */
/* http://en.wikipedia.org/wiki/Newton%27s_method_in_optimization */
havePos = tang1Use || tang2Use;
haveNeg = negtang1Use || negtang2Use;
haveNada = !havePos && !haveNeg;
#if PRAYING
{
double stpmin;
/* HEY: shouldn't stpmin also be used later in this function? */
stpmin = task->pctx->voxelSizeSpace*task->pctx->sysParm.constraintStepMin;
fprintf(stderr, "!%s(%u): starting at %g %g %g %g\n", me, point->idtag,
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
fprintf(stderr, "!%s: pt %d %d nt %d %d (nada %d) "
"stepMax %g, iterMax %u\n", me,
tang1Use, tang2Use, negtang1Use, negtang2Use, haveNada,
stepMax, iterMax);
fprintf(stderr, "!%s: stpmin = %g = voxsize %g * parm.stepmin %g\n", me,
stpmin, task->pctx->voxelSizeSpace,
task->pctx->sysParm.constraintStepMin);
}
#endif
_pullPointHistAdd(point, pullCondOld);
PROBE(val, grad, hess, posproj, negproj);
#if PRAYING
PRINT("initial probe");
#endif
SAVE(state, val, grad, hess, posproj, negproj, point->pos);
hack = 1;
for (iter=1; iter<=iterMax; iter++) {
#if PRAYING
fprintf(stderr, "!%s: =============== begin iter %u\n", me, iter);
#endif
/* HEY: no opportunistic increase of hack? */
if (havePos || haveNada) {
POSNORM(d1, d2, pdir, plen, pgrad, grad, hess, posproj);
if (!plen) {
/* this use to be a biff error, which got to be annoying */
*constrFailP = pullConstraintFailProjGradZeroA;
return 0;
}
step = (d2 <= 0 ? -plen : -d1/d2);
#if PRAYING
fprintf(stderr, "!%s: (+) iter %u step = (%g <= 0 ? %g : %g) --> %g\n",
me, iter, d2, -plen, -d1/d2, step);
#endif
step = step > 0 ? AIR_MIN(stepMax, step) : AIR_MAX(-stepMax, step);
if (AIR_ABS(step) < stepMax*task->pctx->sysParm.constraintStepMin) {
/* no further iteration needed; we're converged */
#if PRAYING
fprintf(stderr, " |step| %g < %g*%g = %g ==> converged!\n",
AIR_ABS(step),
stepMax, task->pctx->sysParm.constraintStepMin,
stepMax*task->pctx->sysParm.constraintStepMin);
#endif
if (!haveNeg) {
break;
} else {
goto nextstep;
}
}
/* else we have to take a significant step */
#if PRAYING
fprintf(stderr, " -> step %g, |pdir| = %g\n",
step, ELL_3V_LEN(pdir));
ELL_3V_COPY(_tmpv, point->pos);
fprintf(stderr, " -> pos (%g,%g,%g,%g) += %g * %g * (%g,%g,%g)\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3],
hack, step, pdir[0], pdir[1], pdir[2]);
#endif
ELL_3V_SCALE_INCR(point->pos, hack*step, pdir);
#if PRAYING
ELL_3V_SUB(_tmpv, _tmpv, point->pos);
fprintf(stderr, " -> moved to %g %g %g %g\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
fprintf(stderr, " (moved %g)\n", ELL_3V_LEN(_tmpv));
#endif
_pullPointHistAdd(point, pullCondConstraintSatA);
PROBE(val, grad, hess, posproj, negproj);
#if PRAYING
fprintf(stderr, " (+) probed at (%g,%g,%g,%g)\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
PRINT("after move");
fprintf(stderr, " val(%g,%g,%g,%g)=%g %s state[0]=%g\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3],
val, val <= state[0] ? "<=" : ">", state[0]);
#endif
if (val <= state[0]) {
/* we made progress */
#if PRAYING
fprintf(stderr, " (+) progress!\n");
#endif
SAVE(state, val, grad, hess, posproj, negproj, point->pos);
hack = 1;
} else {
/* oops, we went uphill instead of down; try again */
#if PRAYING
fprintf(stderr, " val *increased*; backing hack from %g to %g\n",
hack, hack*task->pctx->sysParm.backStepScale);
#endif
hack *= task->pctx->sysParm.backStepScale;
RESTORE(val, grad, hess, posproj, negproj, point->pos, state);
#if PRAYING
fprintf(stderr, " restored to pos (%g,%g,%g,%g)\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
#endif
}
}
nextstep:
if (haveNeg) {
/* HEY: copy and paste from above, minus fluff */
NEGNORM(d1, d2, pdir, plen, pgrad, grad, hess, negproj);
if (!plen && !haveNeg) {
/* this use to be a biff error, which got to be annoying */
*constrFailP = pullConstraintFailProjGradZeroA;
return 0;
}
step = (d2 <= 0 ? -plen : -d1/d2);
#if PRAYING
fprintf(stderr, "!%s: -+) iter %u step = (%g <= 0 ? %g : %g) --> %g\n",
me, iter, d2, -plen, -d1/d2, step);
#endif
step = step > 0 ? AIR_MIN(stepMax, step) : AIR_MAX(-stepMax, step);
if (AIR_ABS(step) < stepMax*task->pctx->sysParm.constraintStepMin) {
#if PRAYING
fprintf(stderr, " |step| %g < %g*%g = %g ==> converged!\n",
AIR_ABS(step),
stepMax, task->pctx->sysParm.constraintStepMin,
stepMax*task->pctx->sysParm.constraintStepMin);
#endif
/* no further iteration needed; we're converged */
break;
}
/* else we have to take a significant step */
#if PRAYING
fprintf(stderr, " -> step %g, |pdir| = %g\n",
step, ELL_3V_LEN(pdir));
ELL_3V_COPY(_tmpv, point->pos);
fprintf(stderr, " -> pos (%g,%g,%g,%g) += %g * %g * (%g,%g,%g)\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3],
hack, step, pdir[0], pdir[1], pdir[2]);
#endif
ELL_3V_SCALE_INCR(point->pos, hack*step, pdir);
#if PRAYING
ELL_3V_SUB(_tmpv, _tmpv, point->pos);
fprintf(stderr, " -> moved to %g %g %g %g\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
fprintf(stderr, " (moved %g)\n", ELL_3V_LEN(_tmpv));
#endif
_pullPointHistAdd(point, pullCondConstraintSatA);
PROBE(val, grad, hess, posproj, negproj);
#if PRAYING
fprintf(stderr, " (-) probed at (%g,%g,%g,%g)\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
PRINT("after move");
fprintf(stderr, " val(%g,%g,%g,%g)=%g %s state[0]=%g\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3],
val, val >= state[0] ? ">=" : "<", state[0]);
#endif
if (val >= state[0]) {
/* we made progress */
#if PRAYING
fprintf(stderr, " (-) progress!\n");
#endif
SAVE(state, val, grad, hess, posproj, negproj, point->pos);
hack = 1;
} else {
/* oops, we went uphill instead of down; try again */
#if PRAYING
fprintf(stderr, " val *increased*; backing hack from %g to %g\n",
hack, hack*task->pctx->sysParm.backStepScale);
#endif
hack *= task->pctx->sysParm.backStepScale;
RESTORE(val, grad, hess, posproj, negproj, point->pos, state);
#if PRAYING
fprintf(stderr, " restored to pos (%g,%g,%g,%g)\n",
point->pos[0], point->pos[1], point->pos[2], point->pos[3]);
#endif
}
}
}
if (iter > iterMax) {
*constrFailP = pullConstraintFailIterMaxed;
} else {
*constrFailP = AIR_FALSE;
}
/*
printf("!%s: %d %s\n", me, *constrFailP,
*constrFailP ? "FAILED!" : "ok");
*/
return 0;
}
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;
}
int
main(int argc, char *argv[]) {
float angleA_f, axisA_f[3], angleB_f, axisB_f[3],
qA_f[4], qB_f[4], qC_f[4],
mat3A_f[9], mat4A_f[16], mat3B_f[9], mat4B_f[16], mat3C_f[9], mat4C_f[16],
pntA_f[4], pntB_f[4], pntC_f[4];
double angleA_d, axisA_d[3], angleB_d, axisB_d[3],
qA_d[4], qB_d[4], qC_d[4],
mat3A_d[9], mat4A_d[16], mat3B_d[9], mat4B_d[16], mat3C_d[9], mat4C_d[16],
pntA_d[4], pntB_d[4], pntC_d[4];
int I, N;
double tmp, det, frob;
me = argv[0];
N = 100000;
AIR_UNUSED(pntA_d);
AIR_UNUSED(pntB_d);
AIR_UNUSED(pntC_d);
AIR_UNUSED(mat4C_d);
AIR_UNUSED(mat3C_d);
AIR_UNUSED(mat4B_d);
AIR_UNUSED(mat3B_d);
AIR_UNUSED(mat4A_d);
AIR_UNUSED(mat3A_d);
AIR_UNUSED(qC_d);
AIR_UNUSED(qB_d);
AIR_UNUSED(qA_d);
AIR_UNUSED(axisB_d);
AIR_UNUSED(angleB_d);
AIR_UNUSED(axisA_d);
AIR_UNUSED(angleA_d);
AIR_UNUSED(argc);
for (I=0; I<N; I++) {
/* make a rotation (as a quaternion) */
ELL_3V_SET(axisA_f, 2*airDrandMT()-1, 2*airDrandMT()-1, 2*airDrandMT()-1);
ELL_3V_NORM(axisA_f, axisA_f, tmp); /* yea, not uniform, so what */
angleA_f = AIR_PI*(2*airDrandMT()-1);
ell_aa_to_q_f(qA_f, angleA_f, axisA_f);
/* convert to AA and back, and back */
angleB_f = ell_q_to_aa_f(axisB_f, qA_f);
if (ELL_3V_DOT(axisB_f, axisA_f) < 0) {
ELL_3V_SCALE(axisB_f, -1, axisB_f);
angleB_f *= -1;
}
ELL_3V_SUB(axisA_f, axisA_f, axisB_f);
printf(" aa -> q -> aa error: %g, %g\n",
CA + AIR_ABS(angleA_f - angleB_f), CA + ELL_3V_LEN(axisA_f));
/* convert to 3m and back, and back */
ell_q_to_3m_f(mat3A_f, qA_f);
ell_3m_to_q_f(qB_f, mat3A_f);
if (ELL_4V_DOT(qA_f, qB_f) < 0) {
ELL_4V_SCALE(qB_f, -1, qB_f);
}
ELL_4V_SUB(qC_f, qA_f, qB_f);
ELL_Q_TO_3M(mat3B_f, qA_f);
ELL_3M_SUB(mat3C_f, mat3B_f, mat3A_f);
printf(" q -> 3m -> q error: %g, %g\n",
CA + ELL_4V_LEN(qC_f), CA + ELL_3M_FROB(mat3C_f));
/* convert to 4m and back, and back */
ell_q_to_4m_f(mat4A_f, qA_f);
ell_4m_to_q_f(qB_f, mat4A_f);
if (ELL_4V_DOT(qA_f, qB_f) < 0) {
ELL_4V_SCALE(qB_f, -1, qB_f);
}
ELL_4V_SUB(qC_f, qA_f, qB_f);
ELL_Q_TO_4M(mat4B_f, qA_f);
ELL_4M_SUB(mat4C_f, mat4B_f, mat4A_f);
printf(" q -> 4m -> q error: %g, %g\n",
CA + ELL_4V_LEN(qC_f), CA + ELL_4M_FROB(mat4C_f));
/* make a point that we'll rotate */
ELL_3V_SET(pntA_f, 2*airDrandMT()-1, 2*airDrandMT()-1, 2*airDrandMT()-1);
/* effect rotation in two different ways, and compare results */
ELL_3MV_MUL(pntB_f, mat3A_f, pntA_f);
ell_q_3v_rotate_f(pntC_f, qA_f, pntA_f);
ELL_3V_SUB(pntA_f, pntB_f, pntC_f);
printf(" rotation error = %g\n", CA + ELL_3V_LEN(pntA_f));
/* mix up inversion with conversion */
ell_3m_inv_f(mat3C_f, mat3A_f);
ell_3m_to_q_f(qB_f, mat3C_f);
ell_q_mul_f(qC_f, qA_f, qB_f);
if (ELL_4V_DOT(qA_f, qC_f) < 0) {
ELL_4V_SCALE(qC_f, -1, qC_f);
}
printf(" inv mul = %g %g %g %g\n", qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
ell_q_inv_f(qC_f, qB_f);
ELL_4V_SUB(qC_f, qB_f, qB_f);
printf(" inv diff = %g %g %g %g\n", CA + qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
/* exp and log */
ell_q_log_f(qC_f, qA_f);
ell_q_log_f(qB_f, qC_f);
ell_q_exp_f(qC_f, qB_f);
ell_q_exp_f(qB_f, qC_f);
ELL_4V_SUB(qC_f, qB_f, qA_f);
printf(" exp/log diff = %g %g %g %g\n", CA + qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
/* pow, not very exhaustive */
ell_q_to_3m_f(mat3A_f, qA_f);
ell_3m_post_mul_f(mat3A_f, mat3A_f);
ell_3m_post_mul_f(mat3A_f, mat3A_f);
ell_q_pow_f(qB_f, qA_f, 4);
ell_q_to_3m_f(mat3B_f, qB_f);
ELL_3M_SUB(mat3B_f, mat3B_f, mat3A_f);
printf(" pow diff = %g\n", CA + ELL_3M_FROB(mat3B_f));
if (ELL_3M_FROB(mat3B_f) > 2) {
printf(" start q = %g %g %g %g\n", qA_f[0], qA_f[1], qA_f[2], qA_f[3]);
angleA_f = ell_q_to_aa_f(axisA_f, qA_f);
printf(" --> aa = %g (%g %g %g)\n", angleA_f,
axisA_f[0], axisA_f[1], axisA_f[2]);
printf(" q^3 = %g %g %g %g\n", qB_f[0], qB_f[1], qB_f[2], qB_f[3]);
angleA_f = ell_q_to_aa_f(axisA_f, qB_f);
printf(" --> aa = %g (%g %g %g)\n", angleA_f,
axisA_f[0], axisA_f[1], axisA_f[2]);
exit(1);
}
/* make sure it looks like a rotation matrix */
ell_q_to_3m_f(mat3A_f, qA_f);
det = ELL_3M_DET(mat3A_f);
frob = ELL_3M_FROB(mat3A_f);
ELL_3M_TRANSPOSE(mat3B_f, mat3A_f);
ell_3m_inv_f(mat3C_f, mat3A_f);
ELL_3M_SUB(mat3C_f, mat3B_f, mat3C_f);
printf(" det = %g; size = %g; err = %g\n", det, frob*frob/3,
CA + ELL_3M_FROB(mat3C_f));
}
exit(0);
}
