/*
******** tenGradientRandom
**
** generates num random unit vectors of type double
*/
int
tenGradientRandom(Nrrd *ngrad, unsigned int num, unsigned int seed) {
static const char me[]="tenGradientRandom";
double *grad, len;
unsigned int gi;
if (nrrdMaybeAlloc_va(ngrad, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, num))) {
biffMovef(TEN, NRRD, "%s: couldn't allocate output", me);
return 1;
}
airSrandMT(seed);
grad = AIR_CAST(double*, ngrad->data);
for (gi=0; gi<num; gi++) {
do {
grad[0] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1);
grad[1] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1);
grad[2] = AIR_AFFINE(0, airDrandMT(), 1, -1, 1);
len = ELL_3V_LEN(grad);
} while (len > 1 || !len);
ELL_3V_SCALE(grad, 1.0/len, grad);
grad += 3;
}
return 0;
}
/*
******** tenGradientJitter
**
** moves all gradients by amount dist on tangent plane, in a random
** direction, and then renormalizes. The distance is a fraction
** of the ideal edge length (via tenGradientIdealEdge)
*/
int
tenGradientJitter(Nrrd *nout, const Nrrd *nin, double dist) {
static const char me[]="tenGradientJitter";
double *grad, perp0[3], perp1[3], len, theta, cc, ss, edge;
unsigned int gi, num;
if (nrrdConvert(nout, nin, nrrdTypeDouble)) {
biffMovef(TEN, NRRD, "%s: trouble converting input to double", me);
return 1;
}
if (tenGradientCheck(nout, nrrdTypeDouble, 3)) {
biffAddf(TEN, "%s: didn't get valid gradients", me);
return 1;
}
grad = AIR_CAST(double*, nout->data);
num = AIR_UINT(nout->axis[1].size);
/* HEY: possible confusion between single and not */
edge = tenGradientIdealEdge(num, AIR_FALSE);
for (gi=0; gi<num; gi++) {
ELL_3V_NORM(grad, grad, len);
ell_3v_perp_d(perp0, grad);
ELL_3V_CROSS(perp1, perp0, grad);
theta = AIR_AFFINE(0, airDrandMT(), 1, 0, 2*AIR_PI);
cc = dist*edge*cos(theta);
ss = dist*edge*sin(theta);
ELL_3V_SCALE_ADD3(grad, 1.0, grad, cc, perp0, ss, perp1);
ELL_3V_NORM(grad, grad, len);
grad += 3;
}
return 0;
}
void
makeSceneBVH(limnCamera *cam, echoRTParm *parm, echoObject **sceneP) {
echoObject *sphere;
int i, N;
float r, g, b;
echoObject *scene;
double time0, time1;
*sceneP = scene = echoObjectNew(echoList);
ELL_3V_SET(cam->from, 9, 6, 0);
ELL_3V_SET(cam->at, 0, 0, 0);
ELL_3V_SET(cam->up, 0, 0, 1);
cam->uRange[0] = -3;
cam->uRange[1] = 3;
cam->vRange[0] = -3;
cam->vRange[1] = 3;
parm->jitterType = echoJitterNone;
parm->numSamples = 1;
parm->imgResU = 500;
parm->imgResV = 500;
parm->aperture = 0.0;
parm->renderLights = AIR_TRUE;
parm->renderBoxes = AIR_FALSE;
parm->seedRand = AIR_FALSE;
parm->maxRecDepth = 10;
parm->shadow = 0.0;
N = 1000000;
airArrayLenSet(LIST(scene)->objArr, N);
for (i=0; i<N; i++) {
sphere = echoObjectNew(echoSphere);
echoSphereSet(sphere,
4*airDrandMT()-2, 4*airDrandMT()-2, 4*airDrandMT()-2, 0.005);
_dyeHSVtoRGB(&r, &g, &b, AIR_AFFINE(0, i, N, 0.0, 1.0), 1.0, 1.0);
echoMatterPhongSet(sphere, r, g, b, 1.0,
1.0, 0.0, 0.0, 50);
LIST(scene)->obj[i] = sphere;
}
time0 = airTime();
*sceneP = scene = echoListSplit3(scene, 8);
time1 = airTime();
printf("BVH build time = %g seconds\n", time1 - time0);
}
/*
** 0 1 (2)
** texp N
*/
int
main(int argc, char *argv[]) {
char *me;
unsigned int ii, NN;
me = argv[0];
if (2 != argc || 1 != sscanf(argv[1], "%u", &NN)) {
fprintf(stderr, "%s: need one uint as argument\n", me);
exit(1);
}
for (ii=0; ii<NN; ii++) {
double xx;
xx = AIR_AFFINE(0.0, airDrandMT(), 1.0, -10, 10);
printf("%f %f\n", exp(xx), airFastExp(xx));
}
exit(0);
}
float frand(float min, float max) {
return (min + airDrandMT() * (max - min));
}
static double _nrrdUnaryOpRand(double a) {
AIR_UNUSED(a);
return airDrandMT();
}
int
main(int argc, char *argv[]) {
float angleA_f, axisA_f[3], angleB_f, axisB_f[3],
qA_f[4], qB_f[4], qC_f[4],
mat3A_f[9], mat4A_f[16], mat3B_f[9], mat4B_f[16], mat3C_f[9], mat4C_f[16],
pntA_f[4], pntB_f[4], pntC_f[4];
double angleA_d, axisA_d[3], angleB_d, axisB_d[3],
qA_d[4], qB_d[4], qC_d[4],
mat3A_d[9], mat4A_d[16], mat3B_d[9], mat4B_d[16], mat3C_d[9], mat4C_d[16],
pntA_d[4], pntB_d[4], pntC_d[4];
int I, N;
double tmp, det, frob;
me = argv[0];
N = 100000;
AIR_UNUSED(pntA_d);
AIR_UNUSED(pntB_d);
AIR_UNUSED(pntC_d);
AIR_UNUSED(mat4C_d);
AIR_UNUSED(mat3C_d);
AIR_UNUSED(mat4B_d);
AIR_UNUSED(mat3B_d);
AIR_UNUSED(mat4A_d);
AIR_UNUSED(mat3A_d);
AIR_UNUSED(qC_d);
AIR_UNUSED(qB_d);
AIR_UNUSED(qA_d);
AIR_UNUSED(axisB_d);
AIR_UNUSED(angleB_d);
AIR_UNUSED(axisA_d);
AIR_UNUSED(angleA_d);
AIR_UNUSED(argc);
for (I=0; I<N; I++) {
/* make a rotation (as a quaternion) */
ELL_3V_SET(axisA_f, 2*airDrandMT()-1, 2*airDrandMT()-1, 2*airDrandMT()-1);
ELL_3V_NORM(axisA_f, axisA_f, tmp); /* yea, not uniform, so what */
angleA_f = AIR_PI*(2*airDrandMT()-1);
ell_aa_to_q_f(qA_f, angleA_f, axisA_f);
/* convert to AA and back, and back */
angleB_f = ell_q_to_aa_f(axisB_f, qA_f);
if (ELL_3V_DOT(axisB_f, axisA_f) < 0) {
ELL_3V_SCALE(axisB_f, -1, axisB_f);
angleB_f *= -1;
}
ELL_3V_SUB(axisA_f, axisA_f, axisB_f);
printf(" aa -> q -> aa error: %g, %g\n",
CA + AIR_ABS(angleA_f - angleB_f), CA + ELL_3V_LEN(axisA_f));
/* convert to 3m and back, and back */
ell_q_to_3m_f(mat3A_f, qA_f);
ell_3m_to_q_f(qB_f, mat3A_f);
if (ELL_4V_DOT(qA_f, qB_f) < 0) {
ELL_4V_SCALE(qB_f, -1, qB_f);
}
ELL_4V_SUB(qC_f, qA_f, qB_f);
ELL_Q_TO_3M(mat3B_f, qA_f);
ELL_3M_SUB(mat3C_f, mat3B_f, mat3A_f);
printf(" q -> 3m -> q error: %g, %g\n",
CA + ELL_4V_LEN(qC_f), CA + ELL_3M_FROB(mat3C_f));
/* convert to 4m and back, and back */
ell_q_to_4m_f(mat4A_f, qA_f);
ell_4m_to_q_f(qB_f, mat4A_f);
if (ELL_4V_DOT(qA_f, qB_f) < 0) {
ELL_4V_SCALE(qB_f, -1, qB_f);
}
ELL_4V_SUB(qC_f, qA_f, qB_f);
ELL_Q_TO_4M(mat4B_f, qA_f);
ELL_4M_SUB(mat4C_f, mat4B_f, mat4A_f);
printf(" q -> 4m -> q error: %g, %g\n",
CA + ELL_4V_LEN(qC_f), CA + ELL_4M_FROB(mat4C_f));
/* make a point that we'll rotate */
ELL_3V_SET(pntA_f, 2*airDrandMT()-1, 2*airDrandMT()-1, 2*airDrandMT()-1);
/* effect rotation in two different ways, and compare results */
ELL_3MV_MUL(pntB_f, mat3A_f, pntA_f);
ell_q_3v_rotate_f(pntC_f, qA_f, pntA_f);
ELL_3V_SUB(pntA_f, pntB_f, pntC_f);
printf(" rotation error = %g\n", CA + ELL_3V_LEN(pntA_f));
/* mix up inversion with conversion */
ell_3m_inv_f(mat3C_f, mat3A_f);
ell_3m_to_q_f(qB_f, mat3C_f);
ell_q_mul_f(qC_f, qA_f, qB_f);
if (ELL_4V_DOT(qA_f, qC_f) < 0) {
ELL_4V_SCALE(qC_f, -1, qC_f);
}
printf(" inv mul = %g %g %g %g\n", qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
ell_q_inv_f(qC_f, qB_f);
ELL_4V_SUB(qC_f, qB_f, qB_f);
printf(" inv diff = %g %g %g %g\n", CA + qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
/* exp and log */
ell_q_log_f(qC_f, qA_f);
ell_q_log_f(qB_f, qC_f);
ell_q_exp_f(qC_f, qB_f);
ell_q_exp_f(qB_f, qC_f);
ELL_4V_SUB(qC_f, qB_f, qA_f);
printf(" exp/log diff = %g %g %g %g\n", CA + qC_f[0],
CA + qC_f[1], CA + qC_f[2], CA + qC_f[3]);
/* pow, not very exhaustive */
ell_q_to_3m_f(mat3A_f, qA_f);
ell_3m_post_mul_f(mat3A_f, mat3A_f);
ell_3m_post_mul_f(mat3A_f, mat3A_f);
ell_q_pow_f(qB_f, qA_f, 4);
ell_q_to_3m_f(mat3B_f, qB_f);
ELL_3M_SUB(mat3B_f, mat3B_f, mat3A_f);
printf(" pow diff = %g\n", CA + ELL_3M_FROB(mat3B_f));
if (ELL_3M_FROB(mat3B_f) > 2) {
printf(" start q = %g %g %g %g\n", qA_f[0], qA_f[1], qA_f[2], qA_f[3]);
angleA_f = ell_q_to_aa_f(axisA_f, qA_f);
printf(" --> aa = %g (%g %g %g)\n", angleA_f,
axisA_f[0], axisA_f[1], axisA_f[2]);
printf(" q^3 = %g %g %g %g\n", qB_f[0], qB_f[1], qB_f[2], qB_f[3]);
angleA_f = ell_q_to_aa_f(axisA_f, qB_f);
printf(" --> aa = %g (%g %g %g)\n", angleA_f,
axisA_f[0], axisA_f[1], axisA_f[2]);
exit(1);
}
/* make sure it looks like a rotation matrix */
ell_q_to_3m_f(mat3A_f, qA_f);
det = ELL_3M_DET(mat3A_f);
frob = ELL_3M_FROB(mat3A_f);
ELL_3M_TRANSPOSE(mat3B_f, mat3A_f);
ell_3m_inv_f(mat3C_f, mat3A_f);
ELL_3M_SUB(mat3C_f, mat3B_f, mat3C_f);
printf(" det = %g; size = %g; err = %g\n", det, frob*frob/3,
CA + ELL_3M_FROB(mat3C_f));
}
exit(0);
}
