/*
******** gageUpdate()
**
** call just before probing begins.
*/
int
gageUpdate(gageContext *ctx) {
static const char me[]="gageUpdate";
unsigned int pi;
int i, haveQuery;
if (!( ctx )) {
biffAddf(GAGE, "%s: got NULL pointer", me);
return 1;
}
if (0 == ctx->pvlNum) {
biffAddf(GAGE, "%s: context has no attached pervolumes", me);
return 1;
}
haveQuery = AIR_FALSE;
for (pi=0; pi<ctx->pvlNum; pi++) {
haveQuery |= GAGE_QUERY_NONZERO(ctx->pvl[pi]->query);
}
if (!haveQuery) {
biffAddf(GAGE, "%s: no query item set in %s", me,
(ctx->pvlNum == 1
? "the pervolume"
: "any of the pervolumes"));
return 1;
}
/* HEY: shouldn't there be some more logic/state for this? */
if (ctx->parm.stackUse) {
if (!ctx->ksp[gageKernelStack]) {
biffAddf(GAGE, "%s: can't do stack without ksp[%s]", me,
airEnumStr(gageKernel, gageKernelStack));
return 1;
}
if (!( 2 <= ctx->pvlNum )) {
biffAddf(GAGE, "%s: need at least 2 pervolumes for stack", me);
return 1;
}
for (pi=1; pi<ctx->pvlNum; pi++) {
if (!( ctx->pvl[0]->kind == ctx->pvl[pi]->kind )) {
biffAddf(GAGE, "%s: pvl[%u] kind (%s) != pvl[0] kind (%s)", me,
pi, ctx->pvl[pi]->kind->name, ctx->pvl[0]->kind->name);
return 1;
}
}
}
/* start traversing the whole update graph . . . */
if (ctx->verbose) {
fprintf(stderr, "%s: hello ____________________ \n", me);
fprintf(stderr, " context flags:");
for (i=gageCtxFlagUnknown+1; i<gageCtxFlagLast; i++) {
fprintf(stderr, " %d=%d", i, ctx->flag[i]);
}
fprintf(stderr, "\n");
fprintf(stderr, " pvl flags:");
for (i=gagePvlFlagUnknown+1; i<gagePvlFlagLast; i++) {
fprintf(stderr, " %d=%d", i, _gagePvlFlagCheck(ctx, i));
}
fprintf(stderr, "\n");
}
if (_gagePvlFlagCheck(ctx, gagePvlFlagQuery)) {
_gagePvlNeedDUpdate(ctx);
_gagePvlFlagDown(ctx, gagePvlFlagQuery);
}
if (_gagePvlFlagCheck(ctx, gagePvlFlagNeedD)) {
_gageNeedDUpdate(ctx);
_gagePvlFlagDown(ctx, gagePvlFlagNeedD);
}
if (ctx->flag[gageCtxFlagNeedD] || ctx->flag[gageCtxFlagK3Pack]) {
if (_gageNeedKUpdate(ctx)) {
biffAddf(GAGE, "%s: trouble", me); return 1;
}
ctx->flag[gageCtxFlagNeedD] = AIR_FALSE;
ctx->flag[gageCtxFlagK3Pack] = AIR_FALSE;
}
if (ctx->flag[gageCtxFlagKernel] || ctx->flag[gageCtxFlagNeedK]) {
if (_gageRadiusUpdate(ctx)) {
biffAddf(GAGE, "%s: trouble", me); return 1;
}
ctx->flag[gageCtxFlagKernel] = AIR_FALSE;
ctx->flag[gageCtxFlagNeedK] = AIR_FALSE;
}
if (ctx->flag[gageCtxFlagRadius]
/* HEY HEY HEY: this is a total hack: right now its possible for a
new pvl to have unallocated iv3,iv2,iv1, if it was attached to a
context which had already been probing, as was the case with
_tenRegisterDoit. So, with this hack we reallocate ALL caches
just because a new pervolume was attached . . . */
|| _gagePvlFlagCheck(ctx, gagePvlFlagVolume)) {
if (_gageCacheSizeUpdate(ctx)) {
biffAddf(GAGE, "%s: trouble", me); return 1;
}
}
if (ctx->flag[gageCtxFlagRadius]
|| ctx->flag[gageCtxFlagShape]
/* see above; following flags that triggered _gageCacheSizeUpdate(ctx) */
|| _gagePvlFlagCheck(ctx, gagePvlFlagVolume)) {
_gageOffValueUpdate(ctx);
ctx->flag[gageCtxFlagShape] = AIR_FALSE;
}
ctx->flag[gageCtxFlagRadius] = AIR_FALSE;
/* chances are, something above has invalidated the state maintained
during successive calls to gageProbe() */
gagePointReset(&ctx->point);
for (pi=0; pi<ctx->pvlNum; pi++) {
if (ctx->pvl[pi]->kind->pvlDataUpdate) {
if (ctx->pvl[pi]->kind->pvlDataUpdate(ctx->pvl[pi]->kind,
ctx,
ctx->pvl[pi],
ctx->pvl[pi]->data)) {
biffAddf(GAGE, "%s: pvlDataUpdate(pvl[%u]) failed", me, pi);
return 1;
}
}
}
if (ctx->verbose > 3 && ctx->stackPos) {
fprintf(stderr, "%s: pvlNum = %u -> stack of %u [0,%u]\n", me,
ctx->pvlNum, ctx->pvlNum-1, ctx->pvlNum-2);
for (pi=0; pi<ctx->pvlNum-1; pi++) {
fprintf(stderr, "%s: stackPos[%u] = %g\n", me, pi, ctx->stackPos[pi]);
}
}
if (ctx->verbose) fprintf(stderr, "%s: bye ^^^^^^^^^^^^^^^^^^^ \n", me);
return 0;
}
int
miteRenderBegin(miteRender **mrrP, miteUser *muu) {
static const char me[]="miteRenderBegin";
gagePerVolume *pvl;
int E, T, pvlIdx;
gageQuery queryScl, queryVec, queryTen;
gageItemSpec isp;
unsigned int axi, thr;
if (!(mrrP && muu)) {
biffAddf(MITE, "%s: got NULL pointer", me);
return 1;
}
if (_miteUserCheck(muu)) {
biffAddf(MITE, "%s: problem with user-set parameters", me);
return 1;
}
if (!( *mrrP = _miteRenderNew() )) {
biffAddf(MITE, "%s: couldn't alloc miteRender", me);
return 1;
}
if (_miteNtxfAlphaAdjust(*mrrP, muu)) {
biffAddf(MITE, "%s: trouble copying and alpha-adjusting txfs", me);
return 1;
}
GAGE_QUERY_RESET(queryScl);
GAGE_QUERY_RESET(queryVec);
GAGE_QUERY_RESET(queryTen);
GAGE_QUERY_RESET((*mrrP)->queryMite);
for (T=0; T<muu->ntxfNum; T++) {
for (axi=1; axi<muu->ntxf[T]->dim; axi++) {
miteVariableParse(&isp, muu->ntxf[T]->axis[axi].label);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite, &isp);
}
}
miteVariableParse((*mrrP)->normalSpec, muu->normalStr);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->normalSpec);
miteShadeSpecParse((*mrrP)->shadeSpec, muu->shadeStr);
miteShadeSpecQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->shadeSpec);
(*mrrP)->queryMiteNonzero = GAGE_QUERY_NONZERO((*mrrP)->queryMite);
E = 0;
pvlIdx = 0;
if (muu->nsin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nsin, gageKindScl));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryScl);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->sclPvlIdx = pvlIdx++;
}
if (muu->nvin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nvin, gageKindVec));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryVec);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->vecPvlIdx = pvlIdx++;
}
if (muu->ntin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->ntin, tenGageKind));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryTen);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->tenPvlIdx = pvlIdx++;
}
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel00,
muu->ksp[gageKernel00]->kernel,
muu->ksp[gageKernel00]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel11,
muu->ksp[gageKernel11]->kernel,
muu->ksp[gageKernel11]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel22,
muu->ksp[gageKernel22]->kernel,
muu->ksp[gageKernel22]->parm);
if (!E) E |= gageUpdate(muu->gctx0);
if (E) {
biffMovef(MITE, GAGE, "%s: gage trouble", me);
return 1;
}
fprintf(stderr, "!%s: kernel support = %d^3 samples\n",
me, 2*muu->gctx0->radius);
if (nrrdMaybeAlloc_va(muu->nout, mite_nt, 3,
AIR_CAST(size_t, 5) /* RGBAZ */ ,
AIR_CAST(size_t, muu->hctx->imgSize[0]),
AIR_CAST(size_t, muu->hctx->imgSize[1]))) {
biffMovef(MITE, NRRD, "%s: nrrd trouble", me);
return 1;
}
muu->nout->axis[1].center = nrrdCenterCell;
muu->nout->axis[1].min = muu->hctx->cam->uRange[0];
muu->nout->axis[1].max = muu->hctx->cam->uRange[1];
muu->nout->axis[2].center = nrrdCenterCell;
muu->nout->axis[2].min = muu->hctx->cam->vRange[0];
muu->nout->axis[2].max = muu->hctx->cam->vRange[1];
for (thr=0; thr<muu->hctx->numThreads; thr++) {
(*mrrP)->tt[thr] = miteThreadNew();
if (!((*mrrP)->tt[thr])) {
biffAddf(MITE, "%s: couldn't allocate thread[%d]", me, thr);
return 1;
}
airMopAdd((*mrrP)->rmop, (*mrrP)->tt[thr],
(airMopper)miteThreadNix, airMopAlways);
}
(*mrrP)->time0 = airTime();
return 0;
}
int
_miteUserCheck(miteUser *muu) {
char me[]="miteUserCheck", err[BIFF_STRLEN];
int T, gotOpac;
gageItemSpec isp;
gageQuery queryScl, queryVec, queryTen, queryMite;
miteShadeSpec *shpec;
airArray *mop;
unsigned int axi;
if (!muu) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(MITE, err); return 1;
}
mop = airMopNew();
if (!( muu->ntxfNum >= 1 )) {
sprintf(err, "%s: need at least one transfer function", me);
biffAdd(MITE, err); airMopError(mop); return 1;
}
gotOpac = AIR_FALSE;
GAGE_QUERY_RESET(queryScl);
GAGE_QUERY_RESET(queryVec);
GAGE_QUERY_RESET(queryTen);
GAGE_QUERY_RESET(queryMite); /* not actually used here */
/* add on all queries associated with transfer functions */
for (T=0; T<muu->ntxfNum; T++) {
if (miteNtxfCheck(muu->ntxf[T])) {
sprintf(err, "%s: ntxf[%d] (%d of %d) can't be used as a txf",
me, T, T+1, muu->ntxfNum);
biffAdd(MITE, err); airMopError(mop); return 1;
}
/* NOTE: no error checking because miteNtxfCheck succeeded */
for (axi=1; axi<muu->ntxf[T]->dim; axi++) {
miteVariableParse(&isp, muu->ntxf[T]->axis[axi].label);
miteQueryAdd(queryScl, queryVec, queryTen, queryMite, &isp);
}
gotOpac |= !!strchr(muu->ntxf[T]->axis[0].label, 'A');
}
if (!gotOpac) {
fprintf(stderr, "\n\n%s: ****************************************"
"************************\n", me);
fprintf(stderr, "%s: !!! WARNING !!! opacity (\"A\") not set "
"by any transfer function\n", me);
fprintf(stderr, "%s: ****************************************"
"************************\n\n\n", me);
}
/* add on "normal"-based queries */
if (airStrlen(muu->normalStr)) {
miteVariableParse(&isp, muu->normalStr);
if (miteValGageKind == isp.kind) {
sprintf(err, "%s: normalStr \"%s\" refers to a miteVal "
"(normal must be data-intrinsic)", me, muu->normalStr);
biffAdd(MITE, err); airMopError(mop); return 1;
}
if (3 != isp.kind->table[isp.item].answerLength) {
sprintf(err, "%s: %s not a vector: can't be used as normal",
me, muu->normalStr);
biffAdd(MITE, err); return 1;
}
miteQueryAdd(queryScl, queryVec, queryTen, queryMite, &isp);
}
/* add on shading-based queries */
shpec = miteShadeSpecNew();
airMopAdd(mop, shpec, (airMopper)miteShadeSpecNix, airMopAlways);
if (miteShadeSpecParse(shpec, muu->shadeStr)) {
sprintf(err, "%s: couldn't parse shading spec \"%s\"",
me, muu->shadeStr);
biffAdd(MITE, err); airMopError(mop); return 1;
}
miteShadeSpecQueryAdd(queryScl, queryVec, queryTen, queryMite, shpec);
/* see if anyone asked for an unspecified normal */
if ((GAGE_QUERY_ITEM_TEST(queryMite, miteValNdotV)
|| GAGE_QUERY_ITEM_TEST(queryMite, miteValNdotL)
|| GAGE_QUERY_ITEM_TEST(queryMite, miteValVrefN))
&& !airStrlen(muu->normalStr)) {
sprintf(err, "%s: txf or shading requested a miteVal's use of the "
"\"normal\", but one has not been specified in muu->normalStr",
me);
biffAdd(MITE, err); airMopError(mop); return 1;
}
/* see if we have volumes for requested queries */
if (GAGE_QUERY_NONZERO(queryScl) && !(muu->nsin)) {
sprintf(err, "%s: txf or shading require %s volume, but don't have one",
me, gageKindScl->name);
biffAdd(MITE, err); airMopError(mop); return 1;
}
if (GAGE_QUERY_NONZERO(queryVec) && !(muu->nvin)) {
sprintf(err, "%s: txf or shading require %s volume, but don't have one",
me, gageKindVec->name);
biffAdd(MITE, err); airMopError(mop); return 1;
}
if (GAGE_QUERY_NONZERO(queryTen) && !(muu->ntin)) {
sprintf(err, "%s: txf or shading require %s volume, but don't have one",
me, tenGageKind->name);
biffAdd(MITE, err); airMopError(mop); return 1;
}
/* check appropriateness of given volumes */
if (muu->nsin) {
if (gageVolumeCheck(muu->gctx0, muu->nsin, gageKindScl)) {
sprintf(err, "%s: trouble with input %s volume",
me, gageKindScl->name);
biffMove(MITE, err, GAGE); airMopError(mop); return 1;
}
}
if (muu->nvin) {
if (gageVolumeCheck(muu->gctx0, muu->nvin, gageKindVec)) {
sprintf(err, "%s: trouble with input %s volume",
me, gageKindVec->name);
biffMove(MITE, err, GAGE); airMopError(mop); return 1;
}
}
if (muu->ntin) {
if (gageVolumeCheck(muu->gctx0, muu->ntin, tenGageKind)) {
sprintf(err, "%s: trouble with input %s volume",
me, tenGageKind->name);
biffMove(MITE, err, GAGE); airMopError(mop); return 1;
}
}
if (!muu->nout) {
sprintf(err, "%s: rendered image nrrd is NULL", me);
biffAdd(MITE, err); airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
