/*
******** miteThreadBegin()
**
** this has some of the body of what would be miteThreadInit
*/
int
miteThreadBegin(miteThread **mttP, miteRender *mrr,
miteUser *muu, int whichThread) {
char me[]="miteThreadBegin", err[BIFF_STRLEN];
/* all the miteThreads have already been allocated */
(*mttP) = mrr->tt[whichThread];
if (!whichThread) {
/* this is the first thread- it just points to the parent gageContext */
(*mttP)->gctx = muu->gctx0;
} else {
/* we have to generate a new gageContext */
(*mttP)->gctx = gageContextCopy(muu->gctx0);
if (!(*mttP)->gctx) {
sprintf(err, "%s: couldn't set up thread %d", me, whichThread);
biffMove(MITE, err, GAGE); return 1;
}
}
if (-1 != mrr->sclPvlIdx) {
(*mttP)->ansScl = (*mttP)->gctx->pvl[mrr->sclPvlIdx]->answer;
(*mttP)->nPerp = ((*mttP)->ansScl
+ gageKindAnswerOffset(gageKindScl, gageSclNPerp));
(*mttP)->geomTens = ((*mttP)->ansScl
+ gageKindAnswerOffset(gageKindScl, gageSclGeomTens));
} else {
(*mttP)->ansScl = NULL;
(*mttP)->nPerp = NULL;
(*mttP)->geomTens = NULL;
}
(*mttP)->ansVec = (-1 != mrr->vecPvlIdx
? (*mttP)->gctx->pvl[mrr->vecPvlIdx]->answer
: NULL);
(*mttP)->ansTen = (-1 != mrr->tenPvlIdx
? (*mttP)->gctx->pvl[mrr->tenPvlIdx]->answer
: NULL);
(*mttP)->thrid = whichThread;
(*mttP)->raySample = 0;
(*mttP)->samples = 0;
(*mttP)->verbose = 0;
(*mttP)->skip = 0;
(*mttP)->_normal = _miteAnswerPointer(*mttP, mrr->normalSpec);
/* set up shading answers */
switch(mrr->shadeSpec->method) {
case miteShadeMethodNone:
/* nothing to do */
break;
case miteShadeMethodPhong:
(*mttP)->shadeVec0 = _miteAnswerPointer(*mttP, mrr->shadeSpec->vec0);
break;
case miteShadeMethodLitTen:
(*mttP)->shadeVec0 = _miteAnswerPointer(*mttP, mrr->shadeSpec->vec0);
(*mttP)->shadeVec1 = _miteAnswerPointer(*mttP, mrr->shadeSpec->vec1);
(*mttP)->shadeScl0 = _miteAnswerPointer(*mttP, mrr->shadeSpec->scl0);
(*mttP)->shadeScl1 = _miteAnswerPointer(*mttP, mrr->shadeSpec->scl1);
break;
default:
sprintf(err, "%s: shade method %d not implemented!",
me, mrr->shadeSpec->method);
biffAdd(MITE, err); return 1;
break;
}
if (_miteStageSet(*mttP, mrr)) {
sprintf(err, "%s: trouble setting up stage array", me);
biffAdd(MITE, err); return 1;
}
return 0;
}
/*
** _miteStageSet
**
** ALLOCATES and initializes stage array in a miteThread
*/
int
_miteStageSet(miteThread *mtt, miteRender *mrr) {
static const char me[]="_miteStageSet";
char *value;
int ni, di, stageIdx, rii, stageNum, ilog2;
Nrrd *ntxf;
miteStage *stage;
gageItemSpec isp;
char rc;
stageNum = _miteStageNum(mrr);
/* fprintf(stderr, "!%s: stageNum = %d\n", me, stageNum); */
mtt->stage = AIR_CALLOC(stageNum, miteStage);
if (!mtt->stage) {
biffAddf(MITE, "%s: couldn't alloc array of %d stages", me, stageNum);
return 1;
}
airMopAdd(mtt->rmop, mtt->stage, airFree, airMopAlways);
mtt->stageNum = stageNum;
stageIdx = 0;
for (ni=0; ni<mrr->ntxfNum; ni++) {
ntxf = mrr->ntxf[ni];
for (di=ntxf->dim-1; di>=1; di--) {
stage = mtt->stage + stageIdx;
_miteStageInit(stage);
miteVariableParse(&isp, ntxf->axis[di].label);
stage->val = _miteAnswerPointer(mtt, &isp);
stage->label = ntxf->axis[di].label;
/*
fprintf(stderr, "!%s: ans=%p + offset[%d]=%d == %p\n", me,
mtt->ans, dom, kind->ansOffset[dom], stage->val);
*/
stage->size = ntxf->axis[di].size;
stage->min = ntxf->axis[di].min;
stage->max = ntxf->axis[di].max;
if (di > 1) {
stage->data = NULL;
} else {
stage->data = (mite_t *)ntxf->data;
value = nrrdKeyValueGet(ntxf, "miteStageOp");
if (value) {
stage->op = airEnumVal(miteStageOp, value);
if (miteStageOpUnknown == stage->op) {
stage->op = miteStageOpMultiply;
}
} else {
stage->op = miteStageOpMultiply;
}
if (1 == isp.kind->table[isp.item].answerLength) {
stage->qn = NULL;
} else if (3 == isp.kind->table[isp.item].answerLength) {
char stmp[AIR_STRLEN_SMALL];
ilog2 = airLog2(ntxf->axis[di].size);
switch(ilog2) {
case 8: stage->qn = limnVtoQN_d[ limnQN8octa]; break;
case 9: stage->qn = limnVtoQN_d[ limnQN9octa]; break;
case 10: stage->qn = limnVtoQN_d[limnQN10octa]; break;
case 11: stage->qn = limnVtoQN_d[limnQN11octa]; break;
case 12: stage->qn = limnVtoQN_d[limnQN12octa]; break;
case 13: stage->qn = limnVtoQN_d[limnQN13octa]; break;
case 14: stage->qn = limnVtoQN_d[limnQN14octa]; break;
case 15: stage->qn = limnVtoQN_d[limnQN15octa]; break;
case 16: stage->qn = limnVtoQN_d[limnQN16octa]; break;
default:
biffAddf(MITE, "%s: txf axis %d size %s not usable for "
"vector txf domain variable %s", me, di,
airSprintSize_t(stmp, ntxf->axis[di].size),
ntxf->axis[di].label);
return 1;
break;
}
} else {
biffAddf(MITE, "%s: %s not scalar or vector (len = %d): can't be "
"a txf domain variable", me,
ntxf->axis[di].label,
isp.kind->table[isp.item].answerLength);
return 1;
}
stage->rangeNum = ntxf->axis[0].size;
for (rii=0; rii<stage->rangeNum; rii++) {
rc = ntxf->axis[0].label[rii];
stage->rangeIdx[rii] = strchr(miteRangeChar, rc) - miteRangeChar;
/*
fprintf(stderr, "!%s: range: %c -> %d\n", "_miteStageSet",
ntxf->axis[0].label[rii], stage->rangeIdx[rii]);
*/
}
}
stageIdx++;
}
}
return 0;
}
