miteRender *
_miteRenderNew(void) {
miteRender *mrr;
mrr = (miteRender *)calloc(1, sizeof(miteRender));
if (mrr) {
mrr->rmop = airMopNew();
if (!mrr->rmop) {
airFree(mrr);
return NULL;
}
mrr->ntxf = NULL;
mrr->ntxfNum = 0;
mrr->sclPvlIdx = -1;
mrr->vecPvlIdx = -1;
mrr->tenPvlIdx = -1;
mrr->normalSpec = gageItemSpecNew();
airMopAdd(mrr->rmop, mrr->normalSpec,
(airMopper)gageItemSpecNix, airMopAlways);
mrr->shadeSpec = miteShadeSpecNew();
airMopAdd(mrr->rmop, mrr->shadeSpec,
(airMopper)miteShadeSpecNix, airMopAlways);
mrr->time0 = AIR_NAN;
GAGE_QUERY_RESET(mrr->queryMite);
mrr->queryMiteNonzero = AIR_FALSE;
}
return mrr;
}
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;
}
