/* ******** 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; }