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);
}
double *
mossMatLeftMultiply (double *_mat, double *_x) {
double mat[9], x[9];
MOSS_MAT_6TO9(x, _x);
MOSS_MAT_6TO9(mat, _mat);
ell_3m_post_mul_d(mat, x);
MOSS_MAT_9TO6(_mat, mat);
return _mat;
}
int
main(int argc, const char *argv[]) {
const char *me;
char *err, *outS;
hestOpt *hopt=NULL;
airArray *mop;
int xi, yi, zi, samp;
float *tdata;
double clp[2], xyz[3], q[4], len;
double mD[9], mRF[9], mRI[9], mT[9];
Nrrd *nten;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "n", "# samples", airTypeInt, 1, 1, &samp, "4",
"number of samples along each edge of cube");
hestOptAdd(&hopt, "c", "cl cp", airTypeDouble, 2, 2, clp, NULL,
"shape of tensor to use; \"cl\" and \"cp\" are cl1 "
"and cp1 values, both in [0.0,1.0]");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output file to save tensors into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nten = nrrdNew();
airMopAdd(mop, nten, (airMopper)nrrdNuke, airMopAlways);
_clp2xyz(xyz, clp);
fprintf(stderr, "%s: want evals = %g %g %g\n", me, xyz[0], xyz[1], xyz[2]);
if (nrrdMaybeAlloc_va(nten, nrrdTypeFloat, 4,
AIR_CAST(size_t, 7),
AIR_CAST(size_t, samp),
AIR_CAST(size_t, samp),
AIR_CAST(size_t, samp))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
ELL_3M_IDENTITY_SET(mD);
ELL_3M_DIAG_SET(mD, xyz[0], xyz[1], xyz[2]);
tdata = (float*)nten->data;
for (zi=0; zi<samp; zi++) {
for (yi=0; yi<samp; yi++) {
for (xi=0; xi<samp; xi++) {
q[0] = 1.0;
q[1] = AIR_AFFINE(-0.5, (float)xi, samp-0.5, -1, 1);
q[2] = AIR_AFFINE(-0.5, (float)yi, samp-0.5, -1, 1);
q[3] = AIR_AFFINE(-0.5, (float)zi, samp-0.5, -1, 1);
len = ELL_4V_LEN(q);
ELL_4V_SCALE(q, 1.0/len, q);
washQtoM3(mRF, q);
ELL_3M_TRANSPOSE(mRI, mRF);
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[0] = 1.0;
TEN_M2T(tdata, mT);
tdata += 7;
}
}
}
if (nrrdSave(outS, nten, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
const char *me;
char *err, *outS;
double eval[3], matA[9], matB[9], sval[3], uu[9], vv[9], escl[5],
view[3];
float matAf[9], matBf[16];
float pp[3], qq[4], mR[9], len, gamma;
float os, vs, rad, AB[2], ten[7];
hestOpt *hopt=NULL;
airArray *mop;
limnObject *obj;
limnLook *look; int lookRod, lookSoid;
float kadsRod[3], kadsSoid[3];
int gtype, partIdx=-1; /* sssh */
int res;
FILE *file;
me = argv[0];
hestOptAdd(&hopt, "sc", "evals", airTypeDouble, 3, 3, eval, "1 1 1",
"original eigenvalues of tensor to be visualized");
hestOptAdd(&hopt, "AB", "A, B exponents", airTypeFloat, 2, 2, AB, "nan nan",
"Directly set the A, B parameters to the superquadric surface, "
"over-riding the default behavior of determining them from the "
"scalings \"-sc\" as superquadric tensor glyphs");
hestOptAdd(&hopt, "os", "over-all scaling", airTypeFloat, 1, 1, &os, "1",
"over-all scaling (multiplied by scalings)");
hestOptAdd(&hopt, "vs", "view-dir scaling", airTypeFloat, 1, 1, &vs, "1",
"scaling along view-direction (to show off bas-relief "
"ambibuity of ellipsoids versus superquads)");
hestOptAdd(&hopt, "es", "extra scaling", airTypeDouble, 5, 5, escl,
"2 1 0 0 1", "extra scaling specified with five values "
"0:tensor|1:geometry|2:none vx vy vz scaling");
hestOptAdd(&hopt, "fr", "from (eye) point", airTypeDouble, 3, 3, &view,
"4 4 4", "eye point, needed for non-unity \"-vs\"");
hestOptAdd(&hopt, "gamma", "superquad sharpness", airTypeFloat, 1, 1,
&gamma, "0",
"how much to sharpen edges as a "
"function of differences between eigenvalues");
hestOptAdd(&hopt, "g", "glyph shape", airTypeEnum, 1, 1, >ype, "sqd",
"glyph to use; not all are implemented here",
NULL, tenGlyphType);
hestOptAdd(&hopt, "pp", "x y z", airTypeFloat, 3, 3, pp, "0 0 0",
"transform: rotation identified by"
"location in quaternion quotient space");
hestOptAdd(&hopt, "r", "radius", airTypeFloat, 1, 1, &rad, "0.015",
"black axis cylinder radius (or 0.0 to not drawn these)");
hestOptAdd(&hopt, "res", "resolution", airTypeInt, 1, 1, &res, "25",
"tesselation resolution for both glyph and axis cylinders");
hestOptAdd(&hopt, "pg", "ka kd ks", airTypeFloat, 3, 3, kadsSoid,
"0.2 0.8 0.0",
"phong coefficients for glyph");
hestOptAdd(&hopt, "pr", "ka kd ks", airTypeFloat, 3, 3, kadsRod, "1 0 0",
"phong coefficients for black rods (if being drawn)");
hestOptAdd(&hopt, "o", "output OFF", airTypeString, 1, 1, &outS, "out.off",
"output file to save OFF into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
obj = limnObjectNew(1000, AIR_TRUE);
airMopAdd(mop, obj, (airMopper)limnObjectNix, airMopAlways);
if (!( 0 == escl[0] || 1 == escl[0] || 2 == escl[0] )) {
fprintf(stderr, "%s: escl[0] %g not 0, 1 or 2\n", me, escl[0]);
airMopError(mop); return 1;
}
if (!(tenGlyphTypeBox == gtype ||
tenGlyphTypeSphere == gtype ||
tenGlyphTypeSuperquad == gtype)) {
fprintf(stderr, "%s: got %s %s, but here only do %s, %s, or %s\n", me,
tenGlyphType->name,
airEnumStr(tenGlyphType, gtype),
airEnumStr(tenGlyphType, tenGlyphTypeBox),
airEnumStr(tenGlyphType, tenGlyphTypeSphere),
airEnumStr(tenGlyphType, tenGlyphTypeSuperquad));
airMopError(mop); return 1;
}
/* create limnLooks for glyph and for rods */
lookSoid = limnObjectLookAdd(obj);
look = obj->look + lookSoid;
ELL_4V_SET(look->rgba, 1, 1, 1, 1);
ELL_3V_COPY(look->kads, kadsSoid);
look->spow = 0;
lookRod = limnObjectLookAdd(obj);
look = obj->look + lookRod;
ELL_4V_SET(look->rgba, 0, 0, 0, 1);
ELL_3V_COPY(look->kads, kadsRod);
look->spow = 0;
ELL_3M_IDENTITY_SET(matA); /* A = I */
ELL_3V_SCALE(eval, os, eval);
ELL_3M_SCALE_SET(matB, eval[0], eval[1], eval[2]); /* B = diag(eval) */
ell_3m_post_mul_d(matA, matB); /* A = B*A = diag(eval) */
if (0 == escl[0]) {
scalingMatrix(matB, escl + 1, escl[4]);
ell_3m_post_mul_d(matA, matB);
}
if (1 != vs) {
if (!ELL_3V_LEN(view)) {
fprintf(stderr, "%s: need non-zero view for vs %g != 1\n", me, vs);
airMopError(mop); return 1;
}
scalingMatrix(matB, view, vs);
/* the scaling along the view direction is a symmetric matrix,
but applying that scaling to the symmetric input tensor
is not necessarily symmetric */
ell_3m_post_mul_d(matA, matB); /* A = B*A */
}
/* so we do an SVD to get rotation U and the scalings sval[] */
/* U * diag(sval) * V */
ell_3m_svd_d(uu, sval, vv, matA, AIR_TRUE);
/*
fprintf(stderr, "%s: ____________________________________\n", me);
fprintf(stderr, "%s: mat = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: uu = \n", me);
ell_3m_print_d(stderr, uu);
ELL_3M_TRANSPOSE(matC, uu);
ELL_3M_MUL(matB, uu, matC);
fprintf(stderr, "%s: uu * uu^T = \n", me);
ell_3m_print_d(stderr, matB);
fprintf(stderr, "%s: sval = %g %g %g\n", me, sval[0], sval[1], sval[2]);
fprintf(stderr, "%s: vv = \n", me);
ell_3m_print_d(stderr, vv);
ELL_3M_MUL(matB, vv, vv);
fprintf(stderr, "%s: vv * vv^T = \n", me);
ELL_3M_TRANSPOSE(matC, vv);
ELL_3M_MUL(matB, vv, matC);
ell_3m_print_d(stderr, matB);
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu);
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]);
ell_3m_pre_mul_d(matA, matB);
ell_3m_pre_mul_d(matA, vv);
fprintf(stderr, "%s: uu * diag(sval) * vv = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", me);
*/
/* now create symmetric matrix out of U and sval */
/* A = I */
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu); /* A = A*U = I*U = U */
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]); /* B = diag(sval) */
ell_3m_pre_mul_d(matA, matB); /* A = U*diag(sval) */
ELL_3M_TRANSPOSE(matB, uu);
ell_3m_pre_mul_d(matA, matB); /* A = U*diag(sval)*U^T */
TEN_M2T(ten, matA);
partIdx = soidDoit(obj, lookSoid,
gtype, gamma, res,
(AIR_EXISTS(AB[0]) && AIR_EXISTS(AB[1])) ? AB : NULL,
ten);
if (1 == escl[0]) {
scalingMatrix(matB, escl + 1, escl[4]);
ELL_43M_INSET(matBf, matB);
limnObjectPartTransform(obj, partIdx, matBf);
}
/* this is a rotate on the geomtry; nothing to do with the tensor */
ELL_4V_SET(qq, 1, pp[0], pp[1], pp[2]);
ELL_4V_NORM(qq, qq, len);
ell_q_to_3m_f(mR, qq);
ELL_43M_INSET(matBf, mR);
limnObjectPartTransform(obj, partIdx, matBf);
if (rad) {
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-eval[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, (1+eval[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-eval[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, -(1+eval[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-eval[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, (1+eval[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-eval[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, -(1+eval[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, (1+eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, -(1+eval[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
}
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
if (limnObjectWriteOFF(file, obj)) {
airMopAdd(mop, err = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
const char *me;
char *err, *outS;
double scale[3], matA[9], matB[9], matC[9], sval[3], uu[9], vv[9];
float matAf[9], matBf[16];
float p[3], q[4], mR[9], len, gamma;
float os, vs, rad, AB[2], ten[7], view[3];
hestOpt *hopt=NULL;
airArray *mop;
limnObject *obj;
limnLook *look; int lookRod, lookSoid;
int partIdx=-1; /* sssh */
int res, sphere;
FILE *file;
me = argv[0];
hestOptAdd(&hopt, "sc", "scalings", airTypeDouble, 3, 3, scale, "1 1 1",
"axis-aligned scaling to do on ellipsoid");
hestOptAdd(&hopt, "AB", "A, B exponents", airTypeFloat, 2, 2, AB, "nan nan",
"Directly set the A, B parameters to the superquadric surface, "
"over-riding the default behavior of determining them from the "
"scalings \"-sc\" as superquadric tensor glyphs");
hestOptAdd(&hopt, "os", "over-all scaling", airTypeFloat, 1, 1, &os, "1",
"over-all scaling (multiplied by scalings)");
hestOptAdd(&hopt, "vs", "over-all scaling", airTypeFloat, 1, 1, &vs, "1",
"scaling along view-direction (to show off bas-relief "
"ambibuity of ellipsoids versus superquads)");
hestOptAdd(&hopt, "fr", "from (eye) point", airTypeFloat, 3, 3, &view,
"4 4 4", "eye point, needed for non-unity \"-vs\"");
hestOptAdd(&hopt, "gamma", "superquad sharpness", airTypeFloat, 1, 1,
&gamma, "0",
"how much to sharpen edges as a "
"function of differences between eigenvalues");
hestOptAdd(&hopt, "sphere", NULL, airTypeInt, 0, 0, &sphere, NULL,
"use a sphere instead of a superquadric");
hestOptAdd(&hopt, "p", "x y z", airTypeFloat, 3, 3, p, "0 0 0",
"location in quaternion quotient space");
hestOptAdd(&hopt, "r", "radius", airTypeFloat, 1, 1, &rad, "0.015",
"black axis cylinder radius (or 0.0 to not drawn these)");
hestOptAdd(&hopt, "res", "resolution", airTypeInt, 1, 1, &res, "25",
"tesselation resolution for both glyph and axis cylinders");
hestOptAdd(&hopt, "o", "output OFF", airTypeString, 1, 1, &outS, "out.off",
"output file to save OFF into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
obj = limnObjectNew(1000, AIR_TRUE);
airMopAdd(mop, obj, (airMopper)limnObjectNix, airMopAlways);
/* create limnLooks for ellipsoid and for rods */
lookSoid = limnObjectLookAdd(obj);
look = obj->look + lookSoid;
ELL_4V_SET(look->rgba, 1, 1, 1, 1);
ELL_3V_SET(look->kads, 0.2, 0.8, 0);
look->spow = 0;
lookRod = limnObjectLookAdd(obj);
look = obj->look + lookRod;
ELL_4V_SET(look->rgba, 0, 0, 0, 1);
ELL_3V_SET(look->kads, 1, 0, 0);
look->spow = 0;
ELL_3M_IDENTITY_SET(matA);
ELL_3V_SCALE(scale, os, scale);
ELL_3M_SCALE_SET(matB, scale[0], scale[1], scale[2]);
ell_3m_post_mul_d(matA, matB);
if (1 != vs) {
ELL_3V_NORM(view, view, len);
if (!len) {
/* HEY: perhaps do more diplomatic error message here */
fprintf(stderr, "%s: stupido!\n", me);
exit(1);
}
ELL_3MV_OUTER(matB, view, view);
ELL_3M_SCALE(matB, vs-1, matB);
ELL_3M_IDENTITY_SET(matC);
ELL_3M_ADD2(matB, matC, matB);
ell_3m_post_mul_d(matA, matB);
}
ell_3m_svd_d(uu, sval, vv, matA, AIR_TRUE);
/*
fprintf(stderr, "%s: ____________________________________\n", me);
fprintf(stderr, "%s: mat = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: uu = \n", me);
ell_3m_print_d(stderr, uu);
ELL_3M_TRANSPOSE(matC, uu);
ELL_3M_MUL(matB, uu, matC);
fprintf(stderr, "%s: uu * uu^T = \n", me);
ell_3m_print_d(stderr, matB);
fprintf(stderr, "%s: sval = %g %g %g\n", me, sval[0], sval[1], sval[2]);
fprintf(stderr, "%s: vv = \n", me);
ell_3m_print_d(stderr, vv);
ELL_3M_MUL(matB, vv, vv);
fprintf(stderr, "%s: vv * vv^T = \n", me);
ELL_3M_TRANSPOSE(matC, vv);
ELL_3M_MUL(matB, vv, matC);
ell_3m_print_d(stderr, matB);
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu);
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]);
ell_3m_pre_mul_d(matA, matB);
ell_3m_pre_mul_d(matA, vv);
fprintf(stderr, "%s: uu * diag(sval) * vv = \n", me);
ell_3m_print_d(stderr, matA);
fprintf(stderr, "%s: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", me);
*/
ELL_3M_IDENTITY_SET(matA);
ell_3m_pre_mul_d(matA, uu);
ELL_3M_SCALE_SET(matB, sval[0], sval[1], sval[2]);
ell_3m_pre_mul_d(matA, matB);
ELL_3M_TRANSPOSE(matB, uu);
ell_3m_pre_mul_d(matA, matB);
TEN_M2T(ten, matA);
partIdx = soidDoit(obj, lookSoid,
sphere, gamma, res,
(AIR_EXISTS(AB[0]) && AIR_EXISTS(AB[1])) ? AB : NULL,
ten);
ELL_4V_SET(q, 1, p[0], p[1], p[2]);
ELL_4V_NORM(q, q, len);
ell_q_to_3m_f(mR, q);
ELL_43M_INSET(matBf, mR);
limnObjectPartTransform(obj, partIdx, matBf);
if (rad) {
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-scale[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, (1+scale[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 0, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, (1-scale[0])/2, rad, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, -(1+scale[0])/2, 0.0, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-scale[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, (1+scale[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 1, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, (1-scale[1])/2, rad);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, -(1+scale[1])/2, 0.0);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, (1+scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
partIdx = limnObjectCylinderAdd(obj, lookRod, 2, res);
ELL_4M_IDENTITY_SET(matAf);
ELL_4M_SCALE_SET(matBf, rad, rad, (1-scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
ELL_4M_TRANSLATE_SET(matBf, 0.0, 0.0, -(1+scale[2])/2);
ell_4m_post_mul_f(matAf, matBf);
limnObjectPartTransform(obj, partIdx, matAf);
}
file = airFopen(outS, stdout, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
if (limnObjectWriteOFF(file, obj)) {
airMopAdd(mop, err = biffGetDone(LIMN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble:\n%s\n", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *err, *outS;
hestOpt *hopt=NULL;
airArray *mop;
int sx, sy, xi, yi, samp, version, whole, right;
float *tdata;
double p[3], xyz[3], q[4], len, hackcp=0, maxca;
double ca, cp, mD[9], mRF[9], mRI[9], mT[9], hack;
Nrrd *nten;
mop = airMopNew();
me = argv[0];
hestOptAdd(&hopt, "n", "# samples", airTypeInt, 1, 1, &samp, "4",
"number of glyphs along each edge of triangle");
hestOptAdd(&hopt, "p", "x y z", airTypeDouble, 3, 3, p, NULL,
"location in quaternion quotient space");
hestOptAdd(&hopt, "ca", "max ca", airTypeDouble, 1, 1, &maxca, "0.8",
"maximum ca to use at bottom edge of triangle");
hestOptAdd(&hopt, "r", NULL, airTypeInt, 0, 0, &right, NULL,
"sample a right-triangle-shaped region, instead of "
"a roughly equilateral triangle. ");
hestOptAdd(&hopt, "w", NULL, airTypeInt, 0, 0, &whole, NULL,
"sample the whole triangle of constant trace, "
"instead of just the "
"sixth of it in which the eigenvalues have the "
"traditional sorted order. ");
hestOptAdd(&hopt, "hack", "hack", airTypeDouble, 1, 1, &hack, "0.04",
"this is a hack");
hestOptAdd(&hopt, "v", "version", airTypeInt, 1, 1, &version, "1",
"which version of the Westin metrics to use to parameterize "
"triangle; \"1\" for ISMRM 97, \"2\" for MICCAI 99");
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
"output file to save tensors into");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
nten = nrrdNew();
airMopAdd(mop, nten, (airMopper)nrrdNuke, airMopAlways);
if (!( 1 == version || 2 == version )) {
fprintf(stderr, "%s: version must be 1 or 2 (not %d)\n", me, version);
airMopError(mop);
return 1;
}
if (right) {
sx = samp;
sy = (int)(1.0*samp/sqrt(3.0));
} else {
sx = 2*samp-1;
sy = samp;
}
if (nrrdMaybeAlloc_va(nten, nrrdTypeFloat, 4,
AIR_CAST(size_t, 7),
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy),
AIR_CAST(size_t, 3))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
q[0] = 1.0;
q[1] = p[0];
q[2] = p[1];
q[3] = p[2];
len = ELL_4V_LEN(q);
ELL_4V_SCALE(q, 1.0/len, q);
washQtoM3(mRF, q);
ELL_3M_TRANSPOSE(mRI, mRF);
if (right) {
_ra2t(nten, 0.00, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.10, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.10, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.20, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.20, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.20, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 20.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 40.0, mRI, mRF, hack);
_ra2t(nten, 0.30, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 15.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 45.0, mRI, mRF, hack);
_ra2t(nten, 0.40, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 12.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 24.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 36.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 48.0, mRI, mRF, hack);
_ra2t(nten, 0.50, 60.0, mRI, mRF, hack);
/* _ra2t(nten, 0.60, 30.0, mRI, mRF, hack); */
_ra2t(nten, 0.60, 40.0, mRI, mRF, hack);
_ra2t(nten, 0.60, 50.0, mRI, mRF, hack);
_ra2t(nten, 0.60, 60.0, mRI, mRF, hack);
/* _ra2t(nten, 0.70, 34.3, mRI, mRF, hack); */
/* _ra2t(nten, 0.70, 42.8, mRI, mRF, hack); */
_ra2t(nten, 0.70, 51.4, mRI, mRF, hack);
_ra2t(nten, 0.70, 60.0, mRI, mRF, hack);
/* _ra2t(nten, 0.80, 45.0, mRI, mRF, hack); */
_ra2t(nten, 0.80, 52.5, mRI, mRF, hack);
_ra2t(nten, 0.80, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.90, 60.0, mRI, mRF, hack);
_ra2t(nten, 1.00, 60.0, mRI, mRF, hack);
/*
_ra2t(nten, 0.000, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.125, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.125, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.250, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.250, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.250, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 20.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 40.0, mRI, mRF, hack);
_ra2t(nten, 0.375, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 0.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 15.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 30.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 45.0, mRI, mRF, hack);
_ra2t(nten, 0.500, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.625, 37.0, mRI, mRF, hack);
_ra2t(nten, 0.625, 47.5, mRI, mRF, hack);
_ra2t(nten, 0.625, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.750, 49.2, mRI, mRF, hack);
_ra2t(nten, 0.750, 60.0, mRI, mRF, hack);
_ra2t(nten, 0.875, 60.0, mRI, mRF, hack);
_ra2t(nten, 1.000, 60.0, mRI, mRF, hack);
*/
nten->axis[1].spacing = 1;
nten->axis[2].spacing = (sx-1)/(sqrt(3.0)*(sy-1));
nten->axis[3].spacing = 1;
} else {
for (yi=0; yi<samp; yi++) {
if (whole) {
ca = AIR_AFFINE(0, yi, samp-1, 0.0, 1.0);
} else {
ca = AIR_AFFINE(0, yi, samp-1, hack, maxca);
hackcp = AIR_AFFINE(0, yi, samp-1, hack, 0);
}
for (xi=0; xi<=yi; xi++) {
if (whole) {
cp = AIR_AFFINE(0, xi, samp-1, 0.0, 1.0);
} else {
cp = AIR_AFFINE(0, xi, samp-1, hackcp, maxca-hack/2.0);
}
_cap2xyz(xyz, ca, cp, version, whole);
/*
fprintf(stderr, "%s: (%d,%d) -> (%g,%g) -> %g %g %g\n", me,
yi, xi, ca, cp, xyz[0], xyz[1], xyz[2]);
*/
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*(2*(samp-1-xi) - (samp-1-yi) + (2*samp-1)*((samp-1-yi) + samp));
tdata[0] = 1.0;
TEN_M2T(tdata, mT);
}
}
nten->axis[1].spacing = 1;
nten->axis[2].spacing = 1.5;
nten->axis[3].spacing = 1;
}
if (nrrdSave(outS, nten, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}