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);
}
/*
** bins on boundary now extend to infinity; so the only time this
** returns NULL (indicating error) is for non-existant positions
*/
pullBin *
_pullBinLocate(pullContext *pctx, double *posWorld) {
char me[]="_pullBinLocate", err[BIFF_STRLEN];
unsigned int axi, eidx[3], binIdx;
if (!ELL_3V_EXISTS(posWorld)) {
sprintf(err, "%s: non-existant position (%g,%g,%g)", me,
posWorld[0], posWorld[1], posWorld[2]);
biffAdd(PULL, err); return NULL;
}
if (pctx->binSingle) {
binIdx = 0;
} else {
for (axi=0; axi<3; axi++) {
eidx[axi] = airIndexClamp(pctx->bboxMin[axi],
posWorld[axi],
pctx->bboxMax[axi],
pctx->binsEdge[axi]);
}
binIdx = (eidx[0]
+ pctx->binsEdge[0]*(eidx[1]
+ pctx->binsEdge[1]*eidx[2]));
}
/*
fprintf(stderr, "!%s: bin(%g,%g,%g) = %u\n", me,
_posWorld[0], _posWorld[1], _posWorld[2], binIdx);
*/
return pctx->bin + binIdx;
}
void
_miteStageRun(miteThread *mtt, miteUser *muu) {
static const char me[]="_miteStageRun";
int stageIdx, ri, rii;
unsigned int txfIdx, finalIdx;
miteStage *stage;
mite_t *rangeData;
double *dbg=NULL;
finalIdx = 0;
if (mtt->verbose) {
dbg = muu->debug + muu->debugIdx;
}
for (stageIdx=0; stageIdx<mtt->stageNum; stageIdx++) {
stage = &(mtt->stage[stageIdx]);
if (stage->qn) {
/* its a vector-valued txf domain variable */
txfIdx = stage->qn(stage->val);
/* right now, we can't store vector-valued txf domain variables */
} else {
/* its a scalar txf domain variable */
txfIdx = airIndexClamp(stage->min, *(stage->val),
stage->max, stage->size);
if (mtt->verbose) {
fprintf(stderr, "!%s: %s=%g in [%g,%g]/%u -> %u\n", me,
stage->label, *(stage->val),
stage->min, stage->max, stage->size, txfIdx);
dbg[0 + 2*stageIdx] = *(stage->val);
}
}
finalIdx = stage->size*finalIdx + txfIdx;
if (mtt->verbose) {
dbg[1 + 2*stageIdx] = txfIdx;
}
if (stage->data) {
rangeData = stage->data + stage->rangeNum*finalIdx;
for (rii=0; rii<stage->rangeNum; rii++) {
ri = stage->rangeIdx[rii];
switch(stage->op) {
case miteStageOpMin:
mtt->range[ri] = AIR_MIN(mtt->range[ri], rangeData[rii]);
break;
case miteStageOpMax:
mtt->range[ri] = AIR_MAX(mtt->range[ri], rangeData[rii]);
break;
case miteStageOpAdd:
mtt->range[ri] += rangeData[rii];
break;
case miteStageOpMultiply:
default:
mtt->range[ri] *= rangeData[rii];
break;
}
}
finalIdx = 0;
}
}
return;
}
/*
** hist[0]: hue vs sat
** hist[1]: hue vs val
*/
void
imageProc(Nrrd *nhproj[3], Nrrd *nhist[2], unsigned int sH,
float *rgb, unsigned int size0, unsigned int sXY,
unsigned int overSampleNum, float overSampleScale) {
unsigned int xyi, hi, si, vi, oi;
float rr, gg, bb, hh, ss, vv, *hist[2];
double rndA, rndB;
nrrdZeroSet(nhist[0]);
nrrdZeroSet(nhist[1]);
hist[0] = AIR_CAST(float *, nhist[0]->data);
hist[1] = AIR_CAST(float *, nhist[1]->data);
for (xyi=0; xyi<sXY; xyi++) {
rr = AIR_CLAMP(0, rgb[0], 255);
gg = AIR_CLAMP(0, rgb[1], 255);
bb = AIR_CLAMP(0, rgb[2], 255);
rr = AIR_AFFINE(-1, rr, 256, 0, 1);
gg = AIR_AFFINE(-1, gg, 256, 0, 1);
bb = AIR_AFFINE(-1, bb, 256, 0, 1);
dyeRGBtoHSV(&hh, &ss, &vv, rr, gg, bb);
si = airIndexClamp(0, ss, 1, sH);
vi = airIndexClamp(0, vv, 1, sH);
#define UPDATE_HIST(rnd) \
hi = airIndexClamp(0, hh + overSampleScale*(1-ss)*(rnd), 1, sH); \
hist[0][hi + sH*si] += 1.0/overSampleNum; \
hist[1][hi + sH*vi] += 1.0/overSampleNum
if (overSampleNum % 2 == 1) {
airNormalRand(&rndA, NULL);
UPDATE_HIST(rndA);
overSampleNum -= 1;
}
for (oi=0; oi<overSampleNum; oi+=2) {
airNormalRand(&rndA, &rndB);
UPDATE_HIST(rndA);
UPDATE_HIST(rndB);
}
rgb += size0;
}
nrrdProject(nhproj[0], nhist[0], 1, nrrdMeasureHistoMean, nrrdTypeFloat);
nrrdProject(nhproj[1], nhist[1], 1, nrrdMeasureHistoMean, nrrdTypeFloat);
nrrdProject(nhproj[2], nhist[1], 1, nrrdMeasureSum, nrrdTypeFloat);
}
/*
** bins on boundary now extend to infinity; so the only time this
** returns NULL (indicating error) is for non-existent positions
*/
pushBin *
_pushBinLocate(pushContext *pctx, double *_posWorld) {
static const char me[]="_pushBinLocate";
double posWorld[4], posIdx[4];
unsigned int axi, eidx[3], binIdx;
if (!ELL_3V_EXISTS(_posWorld)) {
biffAddf(PUSH, "%s: non-existent position (%g,%g,%g)", me,
_posWorld[0], _posWorld[1], _posWorld[2]);
return NULL;
}
if (pctx->binSingle) {
binIdx = 0;
} else {
ELL_3V_COPY(posWorld, _posWorld);
posWorld[3] = 1.0;
ELL_4MV_MUL(posIdx, pctx->gctx->shape->WtoI, posWorld);
ELL_34V_HOMOG(posIdx, posIdx);
for (axi=0; axi<3; axi++) {
eidx[axi] = airIndexClamp(-0.5,
posIdx[axi],
pctx->gctx->shape->size[axi]-0.5,
pctx->binsEdge[axi]);
}
binIdx = (eidx[0]
+ pctx->binsEdge[0]*(eidx[1]
+ pctx->binsEdge[1]*eidx[2]));
}
/*
fprintf(stderr, "!%s: bin(%g,%g,%g) = %u\n", me,
_posWorld[0], _posWorld[1], _posWorld[2], binIdx);
*/
return pctx->bin + binIdx;
}
/*
** _nrrdApply2DLutOrRegMap()
**
** the guts of nrrdApply2DLut and nrrdApply2DRegMap
**
** yikes, does NOT use biff, since we're only supposed to be called
** after copious error checking.
**
** FOR INSTANCE, this allows nout == nin, which could be a big
** problem if mapAxis == 1.
**
** we don't need a typeOut arg because nout has already been allocated
** as some specific type; we'll look at that.
**
** NOTE: non-existant values get passed through regular maps and luts
** "unchanged". However, if the output type is integral, the results
** are probaby undefined. HEY: there is currently no warning message
** or error handling based on nrrdStateDisallowIntegerNonExist, but
** there really should be.
*/
int
_nrrdApply2DLutOrRegMap(Nrrd *nout, const Nrrd *nin,
const NrrdRange *range0, const NrrdRange *range1,
const Nrrd *nmap, int ramps,
int rescale0, int rescale1) {
char me[]="_nrrdApply2DLutOrRegMap";
char *inData, *outData, *mapData, *entData;
size_t N, I;
double (*inLoad)(const void *v), (*mapLup)(const void *v, size_t I),
(*outInsert)(void *v, size_t I, double d),
val0, val1, domMin0, domMax0, domMin1, domMax1;
unsigned int i, mapAxis, mapLen0, mapLen1, mapIdx0, mapIdx1,
entSize, entLen, inSize, outSize;
mapAxis = nmap->dim - 2; /* axis of nmap containing entries */
mapData = (char *)nmap->data; /* map data, as char* */
/* low end of map domain */
domMin0 = _nrrdApplyDomainMin(nmap, ramps, mapAxis + 0);
domMin1 = _nrrdApplyDomainMin(nmap, ramps, mapAxis + 1);
/* high end of map domain */
domMax0 = _nrrdApplyDomainMax(nmap, ramps, mapAxis + 0);
domMax1 = _nrrdApplyDomainMax(nmap, ramps, mapAxis + 1);
mapLen0 = nmap->axis[mapAxis+0].size; /* number of entries in map axis 0 */
mapLen1 = nmap->axis[mapAxis+1].size; /* number of entries in map axis 1 */
mapLup = nrrdDLookup[nmap->type]; /* how to get doubles out of map */
inData = (char *)nin->data; /* input data, as char* */
inLoad = nrrdDLoad[nin->type]; /* how to get doubles out of nin */
inSize = nrrdElementSize(nin); /* size of one input value */
outData = (char *)nout->data; /* output data, as char* */
outInsert = nrrdDInsert[nout->type]; /* putting doubles into output */
entLen = (mapAxis /* number of elements in one entry */
? nmap->axis[0].size
: 1);
outSize = entLen*nrrdElementSize(nout); /* size of entry in output */
entSize = entLen*nrrdElementSize(nmap); /* size of entry in map */
/*
fprintf(stderr, "!%s: entLen = %u, mapLen = %u,%u\n", me,
entLen, mapLen0, mapLen1);
*/
N = nrrdElementNumber(nin)/2; /* number of value pairs to be mapped */
/* _VV = 1; */
if (ramps) {
fprintf(stderr, "%s: PANIC: unimplemented\n", me);
exit(1);
} else {
/* lookup table */
for (I=0; I<N; I++) {
val0 = inLoad(inData + 0*inSize);
val1 = inLoad(inData + 1*inSize);
if (rescale0) {
val0 = AIR_AFFINE(range0->min, val0, range0->max, domMin0, domMax0);
}
if (rescale1) {
val1 = AIR_AFFINE(range1->min, val1, range1->max, domMin1, domMax1);
}
if (AIR_EXISTS(val0) && AIR_EXISTS(val1)) {
mapIdx0 = airIndexClamp(domMin0, val0, domMax0, mapLen0);
mapIdx1 = airIndexClamp(domMin1, val1, domMax1, mapLen1);
entData = mapData + entSize*(mapIdx0 + mapLen0*mapIdx1);
for (i=0; i<entLen; i++) {
outInsert(outData, i, mapLup(entData, i));
}
} else {
/* copy non-existant values from input to output */
for (i=0; i<entLen; i++) {
outInsert(outData, i, val0 + val1); /* HEY this is weird */
}
}
inData += 2*inSize;
outData += outSize;
}
}
return 0;
}
/*
** _nrrdApply1DLutOrRegMap()
**
** the guts of nrrdApply1DLut and nrrdApply1DRegMap
**
** yikes, does NOT use biff, since we're only supposed to be called
** after copious error checking.
**
** FOR INSTANCE, this allows nout == nin, which could be a big
** problem if mapAxis == 1.
**
** we don't need a typeOut arg because nout has already been allocated
** as some specific type; we'll look at that.
**
** NOTE: non-existant values get passed through regular maps and luts
** "unchanged". However, if the output type is integral, the results
** are probaby undefined. HEY: there is currently no warning message
** or error handling based on nrrdStateDisallowIntegerNonExist, but
** there really should be.
*/
int
_nrrdApply1DLutOrRegMap(Nrrd *nout, const Nrrd *nin, const NrrdRange *range,
const Nrrd *nmap, int ramps, int rescale, int multi) {
/* char me[]="_nrrdApply1DLutOrRegMap"; */
char *inData, *outData, *mapData, *entData0, *entData1;
size_t N, I;
double (*inLoad)(const void *v), (*mapLup)(const void *v, size_t I),
(*outInsert)(void *v, size_t I, double d),
val, mapIdxFrac, domMin, domMax;
unsigned int i, mapAxis, mapLen, mapIdx, entSize, entLen, inSize, outSize;
if (!multi) {
mapAxis = nmap->dim - 1; /* axis of nmap containing entries */
} else {
mapAxis = nmap->dim - nin->dim - 1;
}
mapData = (char *)nmap->data; /* map data, as char* */
/* low end of map domain */
domMin = _nrrdApplyDomainMin(nmap, ramps, mapAxis);
/* high end of map domain */
domMax = _nrrdApplyDomainMax(nmap, ramps, mapAxis);
mapLen = nmap->axis[mapAxis].size; /* number of entries in map */
mapLup = nrrdDLookup[nmap->type]; /* how to get doubles out of map */
inData = (char *)nin->data; /* input data, as char* */
inLoad = nrrdDLoad[nin->type]; /* how to get doubles out of nin */
inSize = nrrdElementSize(nin); /* size of one input value */
outData = (char *)nout->data; /* output data, as char* */
outInsert = nrrdDInsert[nout->type]; /* putting doubles into output */
entLen = (mapAxis /* number of elements in one entry */
? nmap->axis[0].size
: 1);
outSize = entLen*nrrdElementSize(nout); /* size of entry in output */
entSize = entLen*nrrdElementSize(nmap); /* size of entry in map */
N = nrrdElementNumber(nin); /* the number of values to be mapped */
if (ramps) {
/* regular map */
for (I=0; I<N; I++) {
/* ...
if (!(I % 100)) fprintf(stderr, "I = %d\n", (int)I);
... */
val = inLoad(inData);
/* ...
fprintf(stderr, "##%s: val = \na% 31.15f --> ", me, val);
... */
if (rescale) {
val = AIR_AFFINE(range->min, val, range->max, domMin, domMax);
/* ...
fprintf(stderr, "\nb% 31.15f (min,max = %g,%g)--> ", val,
range->min, range->max);
... */
}
/* ...
fprintf(stderr, "\nc% 31.15f --> clamp(%g,%g), %d --> ",
val, domMin, domMax, mapLen);
... */
if (AIR_EXISTS(val)) {
val = AIR_CLAMP(domMin, val, domMax);
mapIdxFrac = AIR_AFFINE(domMin, val, domMax, 0, mapLen-1);
/* ...
fprintf(stderr, "mapIdxFrac = \nd% 31.15f --> ",
mapIdxFrac);
... */
mapIdx = (unsigned int)mapIdxFrac;
mapIdx -= mapIdx == mapLen-1;
mapIdxFrac -= mapIdx;
/* ...
fprintf(stderr, "%s: (%d,\ne% 31.15f) --> \n",
me, mapIdx, mapIdxFrac);
... */
entData0 = mapData + mapIdx*entSize;
entData1 = mapData + (mapIdx+1)*entSize;
for (i=0; i<entLen; i++) {
val = ((1-mapIdxFrac)*mapLup(entData0, i) +
mapIdxFrac*mapLup(entData1, i));
outInsert(outData, i, val);
/* ...
fprintf(stderr, "f% 31.15f\n", val);
... */
}
} else {
/* copy non-existant values from input to output */
for (i=0; i<entLen; i++) {
outInsert(outData, i, val);
}
}
inData += inSize;
outData += outSize;
if (multi) {
mapData += mapLen*entSize;
}
}
} else {
/* lookup table */
for (I=0; I<N; I++) {
val = inLoad(inData);
if (rescale) {
val = AIR_AFFINE(range->min, val, range->max, domMin, domMax);
}
if (AIR_EXISTS(val)) {
mapIdx = airIndexClamp(domMin, val, domMax, mapLen);
entData0 = mapData + mapIdx*entSize;
for (i=0; i<entLen; i++) {
outInsert(outData, i, mapLup(entData0, i));
}
} else {
/* copy non-existant values from input to output */
for (i=0; i<entLen; i++) {
outInsert(outData, i, val);
}
}
inData += inSize;
outData += outSize;
if (multi) {
mapData += mapLen*entSize;
}
}
}
return 0;
}
