void
add_quats(float q1[4], float q2[4], float dest[4])
{
static int count=0;
float t1[4], t2[4], t3[4];
float tf[4];
vcopy(q1,t1);
vscale(t1,q2[3]);
vcopy(q2,t2);
vscale(t2,q1[3]);
vcross(q2,q1,t3);
vadd(t1,t2,tf);
vadd(t3,tf,tf);
tf[3] = q1[3] * q2[3] - vdot(q1,q2);
dest[0] = tf[0];
dest[1] = tf[1];
dest[2] = tf[2];
dest[3] = tf[3];
if (++count > RENORMCOUNT) {
count = 0;
normalize_quat(dest);
}
}
void add_quats(double q1[4], double q2[4], double dest[4]){
static int count=0;
double t1[4], t2[4], t3[4];
double tf[4];
vcopy(t1, q1);
vscale(t1,q2[3]);
vcopy(t2, q2);
vscale(t2,q1[3]);
vcross(t3,q2,q1);
vadd(tf,t1,t2);
vadd(tf,t3,tf);
tf[3] = q1[3] * q2[3] - vdot(q1,q2);
dest[0] = tf[0];
dest[1] = tf[1];
dest[2] = tf[2];
dest[3] = tf[3];
if (++count > RENORMCOUNT) {
count = 0;
normalize_quat(dest);
}
}
void Trackball :: spin ( float friction )
{
const int RENORMCOUNT = 97 ;
static int count=0;
//float * q1, * q2, * dest ;
float q1[4], * q2, * dest ;
float t1[4], t2[4], t3[4];
float tf[4];
//q1 = m_lastquat ;
if( friction != 1.0 )
{
float temp ;
temp = vlength(m_lastquat);
if( temp != 0 )
{
vcopy(m_lastquat,q1);
vnormal(q1) ;
temp = asin(temp)*friction ;
q1[0] *= sin(temp) ;
q1[1] *= sin(temp) ;
q1[2] *= sin(temp) ;
q1[3] = cos(temp) ;
}
else
{
vcopy(m_lastquat,q1);
q1[3] = m_lastquat[3] ;
}
}
else
{
vcopy(m_lastquat,q1);
q1[3] = m_lastquat[3] ;
}
q2 = m_currquat ;
dest = m_currquat ;
vcopy(q1,t1);
vscale(t1,q2[3]);
vcopy(q2,t2);
vscale(t2,q1[3]);
vcross(q2,q1,t3);
vadd(t1,t2,tf);
vadd(t3,tf,tf);
tf[3] = q1[3] * q2[3] - vdot(q1,q2);
dest[0] = tf[0];
dest[1] = tf[1];
dest[2] = tf[2];
dest[3] = tf[3];
if (++count > RENORMCOUNT) {
count = 0;
normalize_quat(dest);
}
}
void
quat_to_axis(float q[4], float axis[3], float &phi) {
if (q[3] > 1)
normalize_quat(q); // if w>1 acos and sqrt will produce errors, this cant happen if quaternion is normalised
phi = 2 * acos(q[3]);
float s = sqrtf(1-q[3]*q[3]); // assuming quaternion normalised then w is less than 1, so term always positive.
if (s < 0.001f) { // test to avoid divide by zero, s is always positive due to sqrt
// if s close to zero then direction of axis not important
axis[0] = q[0]; // if it is important that axis is normalised then replace with x=1; y=z=0;
axis[1] = q[1];
axis[2] = q[2];
} else {
axis[0] = q[0] / s; // normalise axis
axis[1] = q[1] / s;
axis[2] = q[2] / s;
}
}
void
add_quats(float q1[4], float q2[4], float dest[4])
{
static int count=0;
float t1[4], t2[4], t3[4];
float tf[4];
#if 0
printf("q1 = %f %f %f %f\n", q1[0], q1[1], q1[2], q1[3]);
printf("q2 = %f %f %f %f\n", q2[0], q2[1], q2[2], q2[3]);
#endif
vcopy(q1,t1);
vscale(t1,q2[3]);
vcopy(q2,t2);
vscale(t2,q1[3]);
vcross(q2,q1,t3);
vadd(t1,t2,tf);
vadd(t3,tf,tf);
tf[3] = q1[3] * q2[3] - vdot(q1,q2);
#if 0
printf("tf = %f %f %f %f\n", tf[0], tf[1], tf[2], tf[3]);
#endif
dest[0] = tf[0];
dest[1] = tf[1];
dest[2] = tf[2];
dest[3] = tf[3];
if (++count > RENORMCOUNT) {
count = 0;
normalize_quat(dest);
}
}
int
main(int argc, char **argv)
{
int ix; /*index for nx*/
int iy; /*index for ny*/
int nx; /*number of sampels in horizon*/
int ny; /*number of sampels in horizon*/
float xmin,xmax;
float ymin,ymax;
float zmin,zmax;
float ***databot; /*data for plotting*/
float ***datatop;
float ***emisbot; /*color on top horizon*/
float ***emistop; /*color right above base horizon*/
float v0;
int verbose; /*if =1 print some useful information*/
float eyez;
int ihz; /*index for interfaces*/
int *ntris; /*number of triangles*/
int nt; /*number of samples in each ray*/
int iray; /*index for nrays*/
int it; /*index for nt*/
int iw,iwf,nwf;
int is,ns; /*number of sources*/
float q0[4];
char *rayfile=""; /*ray file*/
char *wffile="";
char *sttfile="";
FILE *rayfp=NULL;
FILE *wffp=NULL;
FILE *sttfp=NULL;
Layer *horz;
Layer *ray;
Layer *wf;
float vmin=99999.0;
float vmax=0.0;
float tt; /*debugging information in the ray file*/
int itri;
char names[10];
int iflag; /*flag: =1 means ray effective*/
float emission[4];
float tmax=0.0,tmin=FLT_MAX;
float ***stt=NULL;
float **ttt=NULL;
int ntr;
/* hook up getpar */
initargs(argc,argv);
requestdoc(1);
/* get parameters */
if (!getparint("verbose",&verbose)) verbose=0;
/******************************************
Read model parameters from hzfile
******************************************/
fread(&nhz,sizeof(int),1,stdin);
fread(&nx,sizeof(int),1,stdin);
fread(&ny,sizeof(int),1,stdin);
fread(&xmin,sizeof(float),1,stdin);
fread(&xmax,sizeof(float),1,stdin);
fread(&ymin,sizeof(float),1,stdin);
fread(&ymax,sizeof(float),1,stdin);
fread(&zmin,sizeof(float),1,stdin);
fread(&zmax,sizeof(float),1,stdin);
if (verbose)
fprintf(stderr,"xmin=%f\nxmax=%f\nymin=%f\nymax=%f\nzmin=%f\nzmax=%f\n",
xmin,xmax,ymin,ymax,zmin,zmax);
if (getparstring("rayfile",&rayfile))
if ((rayfp=fopen(rayfile,"r"))==NULL)
err("Can not open rayfile %s",rayfile);
if (getparstring("wffile",&wffile))
if ((wffp=fopen(wffile,"r"))==NULL)
err("Can not open wffile %s",wffile);
if (getparstring("sttfile",&sttfile))
if ((sttfp=fopen(sttfile,"r"))==NULL)
err("Can not open sttfile %s",sttfile);
if (!getparfloat("tbs",&tbs)) tbs=0.8;
if (!getparint("hue",&glb_hue)) glb_hue=1; /*1 for glb_hue*/
if (verbose)
warn("nhz=%d, nx=%d, ny=%d\n",nhz,nx,ny);
glb_on_or_off=(enum On_or_Off *)ealloc1int(3*nhz+6);
for (ihz=0;ihz<nhz;ihz++) glb_on_or_off[ihz]=ON;
horz=(Layer *)alloc1float(sizeof(Layer)*(nhz+1));
/*********************************************************
Do not use GLUT_INDEX, which gives no image;
GLUT_SINGLE will cause redrawing every time you retate it;
*********************************************************/
glutInit(&argc, argv);
glutInitWindowSize(768,768);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("viewer3");
glutDisplayFunc(redraw);
glutIdleFunc(NULL);
if (!getparfloat("q",q0)){
q0[0]=-0.6;
q0[1]=0.05;
q0[2]=-0.06;
q0[3]=0.8;
}
checkpars();
normalize_quat(q0);
curquat[0]=q0[0];
curquat[1]=q0[1];
curquat[2]=q0[2];
curquat[3]=q0[3];
glutReshapeFunc(myReshape);
glutVisibilityFunc(vis);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutCreateMenu(controlLights);
glutAddMenuEntry("Quit",-1);
glutAddMenuEntry("Full Screen",0);
glutAddMenuEntry("White/Color Rays",1);
glutAddMenuEntry("Plot Rays",2);
glutAddMenuEntry("Surface Traveltimes",3);
glutAddMenuEntry("Wired or Solid WFs",4);
glutAddMenuEntry("Plot Wavefronts",5);
glutAddMenuEntry("TRI or TETRA or LAYER or HORZ",6);
for (ihz=0;ihz<nhz;ihz++) {
sprintf(names,"Layer %d",ihz+1);
glutAddMenuEntry(names,ihz+7);
}
glutAttachMenu(GLUT_RIGHT_BUTTON);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
eyez=25;
glMatrixMode(GL_PROJECTION);
gluPerspective(
40.0, /*fovy: view angle in y direction*/
1.0, /*aspect: ratio of width (x) to y (height)*/
eyez-DIAMETER, /*near clipping plane*/
eyez+DIAMETER); /*far clipping plane*/
glMatrixMode(GL_MODELVIEW);
gluLookAt(
0.0, 0.0, eyez, /*(eyex,eyey,eyez): the eye position*/
0.0, 0.0, 0.0, /*(centerx,centery,centerz): the center*/
0.0, 1.0, 0.0); /*(upx,upy,upz): the up direction*/
glPushMatrix();
/*the order that tetramod uses is like this*/
for (ihz=0;ihz<nhz;ihz++) {
fprintf(stderr,"reading horizon information %d\n",ihz);
/**********************************************************
input the horizon information from file hzfile:
**********************************************************/
horz[ihz].x=ealloc2float(nx,ny);
horz[ihz].y=ealloc2float(nx,ny);
horz[ihz].z=ealloc2float(nx,ny);
horz[ihz].v0=ealloc2float(nx,ny);
horz[ihz].v1=ealloc2float(nx,ny);
fprintf(stderr,"read horz[%d].x...\n",ihz);
if (fread(horz[ihz].x[0],sizeof(float),nx*ny,
stdin)!=nx*ny)
err("Can not read x to stdin");
fprintf(stderr,"read horz[%d].y...\n",ihz);
if (fread(horz[ihz].y[0],sizeof(float),nx*ny,
stdin)!=nx*ny)
err("Can not read y to stdin");
fprintf(stderr,"read horz[%d].z...\n",ihz);
if (fread(horz[ihz].z[0],sizeof(float),nx*ny,
stdin)!=nx*ny)
err("Can not read z to stdin");
fprintf(stderr,"read horz[%d].v0...\n",ihz);
if (fread(horz[ihz].v0[0],sizeof(float),nx*ny,stdin)!=
nx*ny)
err("Can not read v0 to stdin");
fprintf(stderr,"read horz[%d].v1...\n",ihz);
if (fread(horz[ihz].v1[0],sizeof(float),nx*ny,stdin)!=
nx*ny)
err("Can not read v1 to stdin");
for (iy=0;iy<ny;iy++) {
for (ix=0;ix<nx;ix++) {
vmin=MIN(vmin,horz[ihz].v0[iy][ix]);
vmax=MAX(vmax,horz[ihz].v0[iy][ix]);
vmin=MIN(vmin,horz[ihz].v1[iy][ix]);
vmax=MAX(vmax,horz[ihz].v1[iy][ix]);
}
}
}
if (verbose)
fprintf(stderr,"vmin=%f, vmax=%f\n",vmin,vmax);
horz[nhz].x=ealloc2float(nx,ny);
horz[nhz].y=ealloc2float(nx,ny);
horz[nhz].z=ealloc2float(nx,ny);
fprintf(stderr,"assign horz[%d].x,y,z\n",nhz);
for (ix=0;ix<nx;ix++) {
for (iy=0;iy<ny;iy++) {
horz[nhz].x[iy][ix]=horz[nhz-1].x[iy][ix];
horz[nhz].y[iy][ix]=horz[nhz-1].y[iy][ix];
horz[nhz].z[iy][ix]=zmax;
}
}
databot=ealloc3float(3,nx,ny);
emisbot=ealloc3float(4,nx,ny);
datatop=ealloc3float(3,nx,ny);
emistop=ealloc3float(4,nx,ny);
for (ihz=0;ihz<nhz;ihz++) {
fprintf(stderr,"assigning datatop for ihz=%d\n",ihz);
for (ix=0;ix<nx;ix++) {
for (iy=0;iy<ny;iy++) {
datatop[iy][ix][0]=(
(horz[ihz].x[iy][ix]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
datatop[iy][ix][1]=-(
(horz[ihz].y[iy][ix]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
datatop[iy][ix][2]=(
(horz[ihz].z[iy][ix]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
v0=horz[ihz].v0[iy][ix];
vEmission(v0,vmin,vmax,emistop[iy][ix]);
}
}
fprintf(stderr,"assigning databot for ihz=%d\n",ihz);
for (ix=0;ix<nx;ix++) {
for (iy=0;iy<ny;iy++) {
databot[iy][ix][0]=(
(horz[ihz+1].x[iy][ix]-xmin)
/(xmax-xmin)-0.5)*DIAMETER;
databot[iy][ix][1]=-(
(horz[ihz+1].y[iy][ix]-ymin)
/(ymax-ymin)-0.5)*DIAMETER;
databot[iy][ix][2]=(
(horz[ihz+1].z[iy][ix]-zmin)
/(zmax-zmin)-0.5)*DIAMETER;
v0=horz[ihz].v1[iy][ix];
vEmission(v0,vmin,vmax,emisbot[iy][ix]);
}
}
showLayer(ihz,databot,datatop,nx,ny,emisbot,emistop);
showHorz(ihz,datatop,nx,ny,emistop);
showTetra(ihz,databot,datatop,nx,ny,emisbot,emistop);
showTri(ihz,datatop,nx,ny,emistop);
}
free3float(databot);
free3float(datatop);
free3float(emisbot);
free3float(emistop);
/*******************************************************************
The ray positions are generated by sutetraray, named by rayfile.
This part will be ignored if rayfile not specified.
********************************************************************/
if (rayfp!=NULL) {
fscanf(rayfp,
"%d =Number of shots\n",&ns);
fprintf(stderr,"ns=%d\n",ns);
if (ns<=0 || ns>100) {
ns=0;
rayfp=NULL;
}
ray=(Layer *)alloc1float(sizeof(Layer)*ns);
tmax=0.0;
for (is=0;is<ns;is++) {
fscanf(rayfp,
"%d =Maximum number of segments\n",&nt);
fprintf(stderr,"%d =Maximum number of segments\n",nt);
fscanf(rayfp,
"%d =Number of rays\n",&ray[is].nrays);
fprintf(stderr,"%d =Number of rays\n",ray[is].nrays);
ray[is].x=ealloc2float(ray[is].nrays,nt);
ray[is].y=ealloc2float(ray[is].nrays,nt);
ray[is].z=ealloc2float(ray[is].nrays,nt);
ray[is].v0=ealloc2float(ray[is].nrays,nt);
ray[is].nseg=ealloc1int(ray[is].nrays);
for (iray=0;iray<ray[is].nrays;iray++) {
fscanf(rayfp,"%d=nseg %f=ttotal\n",&ray[is].nseg[iray],&tt);
if (nt<ray[is].nseg[iray]) err("nt should >=ray[is].nseg[iray]");
for (it=0;it<ray[is].nseg[iray];it++) {
fscanf(rayfp,"%f %f %f %f %f\n",
&ray[is].x[it][iray],
&ray[is].y[it][iray],
&ray[is].z[it][iray],
&ray[is].v0[it][iray],&tt);
tmax=MAX(tmax,ray[is].v0[it][iray]);
}
ray[is].z[ray[is].nseg[iray]-1][iray]=
MAX(0.001,ray[is].z[ray[is].nseg[iray]-1][iray]);
for (it=0;it<ray[is].nseg[iray];it++) {
ray[is].x[it][iray]=((ray[is].x[it][iray]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
ray[is].y[it][iray]=-((ray[is].y[it][iray]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
ray[is].z[it][iray]=((ray[is].z[it][iray]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
}
}
}
fclose(rayfp);
/*white rays*/
glNewList(nhz*4+3,GL_COMPILE);
emission[0]=emission[1]=emission[2]=emission[3]=1.0;
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
for (is=0;is<ns;is++) {
for (iray=0;iray<ray[is].nrays;iray++) {
iflag=0;
glBegin(GL_LINE_STRIP);
for (it=0;it<ray[is].nseg[iray];it++) {
if (fabs(ray[is].x[it][iray])<RADIUS &&
fabs(ray[is].y[it][iray])<RADIUS &&
fabs(ray[is].z[it][iray])<RADIUS) {
glVertex3f(ray[is].x[it][iray],ray[is].y[it][iray],
ray[is].z[it][iray]);
iflag=1;
} else if (iflag) break; /*once good, now bad*/
}
glEnd();
}
}
glEndList();
/*colored rays*/
glNewList(nhz*4+4,GL_COMPILE);
for (is=0;is<ns;is++) {
for (iray=0;iray<ray[is].nrays;iray++) {
iflag=0;
glBegin(GL_LINE_STRIP);
for (it=0;it<ray[is].nseg[iray];it++) {
if (fabs(ray[is].x[it][iray])<RADIUS &&
fabs(ray[is].y[it][iray])<RADIUS &&
fabs(ray[is].z[it][iray])<RADIUS) {
tEmission(
ray[is].v0[it][iray],
0.0, /*tmin*/
tmax,
emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3f(
ray[is].x[it][iray],
ray[is].y[it][iray],
ray[is].z[it][iray]);
iflag=1;
} else if (iflag) break; /*once good, now bad*/
}
glEnd();
}
}
glEndList();
}
/*************************************************************
Plot the wavefront if it is given. If the wffile does not
contain effective data, ntris may be wild. In this case, do
thing about the wavefront.
*************************************************************/
if (wffp!=NULL) {
fscanf(wffp,"%d = nwf2dump\n",&nwf);
fprintf(stderr,"nwf2dump=%d\n",nwf);
if (nwf>200) wffp=NULL;
}
if (wffp!=NULL) {
emission[0]=1.0;
emission[1]=1.0;
emission[2]=0.0;
emission[3]=1.0;
wf=(Layer *)alloc1float(sizeof(Layer)*nwf);
ntris=ealloc1int(sizeof(int)*nwf);
for (iwf=0;iwf<nwf;iwf++) {
if (1!=fscanf(wffp,"%d = ntris\n",&ntris[iwf])) {
nwf=iwf;
break;
}
if (ntris[iwf]==0) {
nwf=iwf;
break;
}
if (verbose)
warn("ntris=%d of nwf=%d\n",ntris[iwf],nwf);
wf[iwf].x=ealloc2float(3,ntris[iwf]);
wf[iwf].y=ealloc2float(3,ntris[iwf]);
wf[iwf].z=ealloc2float(3,ntris[iwf]);
for (it=0;it<ntris[iwf];it++) {
fscanf(wffp,"%f %f %f %f %f %f %f %f %f\n",
wf[iwf].x[it], wf[iwf].y[it], wf[iwf].z[it],
wf[iwf].x[it]+1,wf[iwf].y[it]+1,wf[iwf].z[it]+1,
wf[iwf].x[it]+2,wf[iwf].y[it]+2,wf[iwf].z[it]+2);
}
fprintf(stderr,"Totally read in %d wavefront triangles\n",ntris[iwf]);
for (it=0;it<ntris[iwf];it++) {
for (iw=0;iw<3;iw++) {
wf[iwf].x[it][iw]=((wf[iwf].x[it][iw]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
wf[iwf].y[it][iw]=-((wf[iwf].y[it][iw]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
wf[iwf].z[it][iw]=((wf[iwf].z[it][iw]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
}
}
}
fclose(wffp);
fprintf(stderr,"Click right MB to get menu\n");
fprintf(stderr,"Click left MB and drag to rotate\n");
fprintf(stderr,"Press shift and push left MB to scale\n");
glNewList(nhz*4+6,GL_COMPILE);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
for (iwf=0;iwf<nwf;iwf++) {
for (itri=0;itri<ntris[iwf];itri++) {
glBegin(GL_LINE_LOOP);
if (fabs(wf[iwf].x[itri][0])<RADIUS &&
fabs(wf[iwf].y[itri][0])<RADIUS &&
fabs(wf[iwf].z[itri][0])<RADIUS &&
fabs(wf[iwf].x[itri][1])<RADIUS &&
fabs(wf[iwf].y[itri][1])<RADIUS &&
fabs(wf[iwf].z[itri][1])<RADIUS &&
fabs(wf[iwf].x[itri][2])<RADIUS &&
fabs(wf[iwf].y[itri][2])<RADIUS &&
fabs(wf[iwf].z[itri][2])<RADIUS) {
glVertex3f(wf[iwf].x[itri][0],
wf[iwf].y[itri][0],
wf[iwf].z[itri][0]);
glVertex3f(wf[iwf].x[itri][1],
wf[iwf].y[itri][1],
wf[iwf].z[itri][1]);
glVertex3f(wf[iwf].x[itri][2],
wf[iwf].y[itri][2],
wf[iwf].z[itri][2]);
} else {
fprintf(stderr,"warning: some triangles ignored\n");
glEnd();
break;
}
glEnd();
}
}
glEndList();
/*solid wavefronts*/
glNewList(nhz*4+7,GL_COMPILE);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
for (iwf=0;iwf<nwf;iwf++) {
for (itri=0;itri<ntris[iwf];itri++) {
glBegin(GL_TRIANGLE_STRIP);
if (fabs(wf[iwf].x[itri][0])<RADIUS &&
fabs(wf[iwf].y[itri][0])<RADIUS &&
fabs(wf[iwf].z[itri][0])<RADIUS &&
fabs(wf[iwf].x[itri][1])<RADIUS &&
fabs(wf[iwf].y[itri][1])<RADIUS &&
fabs(wf[iwf].z[itri][1])<RADIUS &&
fabs(wf[iwf].x[itri][2])<RADIUS &&
fabs(wf[iwf].y[itri][2])<RADIUS &&
fabs(wf[iwf].z[itri][2])<RADIUS) {
glVertex3f(wf[iwf].x[itri][0],
wf[iwf].y[itri][0],
wf[iwf].z[itri][0]);
glVertex3f(wf[iwf].x[itri][1],
wf[iwf].y[itri][1],
wf[iwf].z[itri][1]);
glVertex3f(wf[iwf].x[itri][2],
wf[iwf].y[itri][2],
wf[iwf].z[itri][2]);
} else {
fprintf(stderr,"warning: some triangles ignored\n");
glEnd();
break;
}
glEnd();
}
}
glEndList();
}
/*surface traveltimes*/
if (sttfp!=NULL) {
fscanf(sttfp,"%d = ntris\n",&ntr);
fprintf(stderr,"ntr=%d\n",ntr);
if (ntr>2000) sttfp=NULL;
}
if (sttfp!=NULL && ntr>0) {
stt=ealloc3float(3,3,ntr);
ttt=ealloc2float(3,ntr);
tmax=0.0;
tmin=1.0e+10;
for (itri=0;itri<ntr;itri++) {
fscanf(sttfp,"%f %f %f %f %f %f %f %f %f %f %f %f\n",
&stt[itri][0][0],
&stt[itri][0][1],
&stt[itri][0][2],
&ttt[itri][0],
&stt[itri][1][0],
&stt[itri][1][1],
&stt[itri][1][2],
&ttt[itri][1],
&stt[itri][2][0],
&stt[itri][2][1],
&stt[itri][2][2],
&ttt[itri][2]);
tmax=MAX(tmax,ttt[itri][0]);
tmax=MAX(tmax,ttt[itri][1]);
tmax=MAX(tmax,ttt[itri][2]);
tmin=MIN(tmin,ttt[itri][0]);
tmin=MIN(tmin,ttt[itri][1]);
tmin=MIN(tmin,ttt[itri][2]);
stt[itri][0][0]=((stt[itri][0][0]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
stt[itri][0][1]=-((stt[itri][0][1]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
stt[itri][0][2]=((stt[itri][0][2]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
stt[itri][1][0]=((stt[itri][1][0]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
stt[itri][1][1]=-((stt[itri][1][1]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
stt[itri][1][2]=((stt[itri][1][2]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
stt[itri][2][0]=((stt[itri][2][0]-xmin)/
(xmax-xmin)-0.5)*DIAMETER;
stt[itri][2][1]=-((stt[itri][2][1]-ymin)/
(ymax-ymin)-0.5)*DIAMETER;
stt[itri][2][2]=((stt[itri][2][2]-zmin)/
(zmax-zmin)-0.5)*DIAMETER;
}
}
tmax=MAX(tmax,tmin+0.01);
glNewList(nhz*4+5,GL_COMPILE);
for (itri=0;itri<ntr;itri++) {
glBegin(GL_TRIANGLE_STRIP);
tEmission(ttt[itri][0],tmin,tmax,emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3fv(stt[itri][0]);
tEmission(ttt[itri][1],tmin,tmax,emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3fv(stt[itri][1]);
tEmission(ttt[itri][2],tmin,tmax,emission);
glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
glVertex3fv(stt[itri][2]);
glEnd();
}
glEndList();
glutMainLoop();
return 0;
}
int
main(int argc, char **argv)
{
int n1; /*number of samples in the fastest direction.*/
int n2; /*number of samples in the 2nd direction*/
int n3; /*number of samples in slownest direction*/
int n1s; /*stride in the fastest direction.*/
int n2s; /*stride in the 2nd direction*/
int n3s; /*stride in slownest direction*/
int i1,i2,i3;
int i1min,i1max; /*indice for min max in n1*/
int i2min,i2max; /*indice for min max in n2*/
int i3min,i3max; /*indice for min max in n3*/
int newn1,newn2,newn3;
int i1new,i2new,i3new;
float v0;
float emission[4];
float ***data; /*data for plotting*/
float ***emis; /*emission for plotting*/
int verbose; /*if =1 print some useful information*/
float ***cube; /*the 3D data set*/
float vmin;
float vmax;
float xmin,xmax;
float ymin,ymax;
float zmin,zmax;
float eyez;
float q0[4];
int cx,cy,cz; /*center of the 1st, 2nd and 3rd view plane*/
/* hook up getpar */
initargs(argc,argv);
requestdoc(1);
/* get parameters */
if (!getparint("n1",&n1)) err("Must specify n1");
if (!getparint("n2",&n2)) err("Must specify n2\n");
if (!getparint("n3",&n3)) err("Must specify n3\n");
if (!getparint("n1s",&n1s)) n1s=1;
if (!getparint("n2s",&n2s)) n2s=1;
if (!getparint("n3s",&n3s)) n3s=1;
if (!getparint("hue",&glb_hue)) glb_hue=1; /*1 for glb_hue*/
if (!getparfloat("tbs",&tbs)) tbs=0.8;
if (glb_hue!=0) glb_hue=1;
if (n1<1) err("n1=%d < 1",n1);
if (n2<1) err("n2=%d < 1",n2);
if (n3<1) err("n3=%d < 1",n3);
n1s=MAX(1,n1s);
n1s=MIN(n1,n1s);
n2s=MAX(1,n2s);
n2s=MIN(n2,n2s);
n3s=MAX(1,n3s);
n3s=MIN(n3,n3s);
newn1=MAX(2,n1/n1s);
newn2=MAX(2,n2/n2s);
newn3=MAX(2,n3/n3s);
if (!getparint("verbose",&verbose)) verbose=0;
if (!getparint("cx",&cx)) cx=n2/2;
if (!getparint("cy",&cy)) cy=n3/2;
if (!getparint("cz",&cz)) cz=n1/2;
cx=MAX(0,MIN(newn2-1,cx/n2s));
cy=MAX(0,MIN(newn3-1,cy/n3s));
cz=MAX(0,MIN(newn1-1,cz/n1s));
if (verbose) {
warn("newn1=%d\nnewn2=%d\nnewn3=%d\ncx=%d\ncy=%d\ncz=%d",
newn1,newn2,newn3,cx,cy,cz);
warn("hue=%d",glb_hue);
}
cube=ealloc3float(newn1,newn2,newn3);
for (i3=0;i3<n3;i3++) {
for (i2=0;i2<n2;i2++) {
for (i1=0;i1<n1;i1++) {
if (fread(&v0,sizeof(float),1,stdin)!=1)
err("Can not read in cube");
if ( i3%n3s==0 &&
i2%n2s==0 &&
i1%n1s==0) {
i3new=MIN(newn3-1,i3/n3s);
i2new=MIN(newn2-1,i2/n2s);
i1new=MIN(newn1-1,i1/n1s);
cube[i3new][i2new][i1new]=v0;
if (n1/n1s<2)
cube[i3new][i2new][1]=cube[i3new][i2new][0];
if (n2/n2s<2)
cube[i3new][1][i1new]=cube[i3new][0][i1new];
if (n3/n3s<2)
cube[1][i2new][i1new]=cube[0][i2new][i1new];
}
}
}
}
n1=newn1;
n2=newn2;
n3=newn3;
zmin=0; zmax=MAX(n1-1,1);
ymin=0; ymax=MAX(n3-1,1);
xmin=0; xmax=MAX(n2-1,1);
glb_plane_flag=(enum On_or_Off *)ealloc1int(3);
glb_plane_flag[2]=OFF;
glb_plane_flag[1]=ON;
glb_plane_flag[0]=OFF;
glb_plot_axis=DO_NOT_PLOT_AXIS;
vmin=cube[0][0][0];
vmax=vmin;
i1min=i2min=i3min=0;
i1max=i2max=i3max=0;
for (i1=0;i1<n1;i1++) {
for (i2=0;i2<n2;i2++) {
for (i3=0;i3<n3;i3++) {
if (vmin<cube[i3][i2][i1]) {
i3min=i3;
i2min=i2;
i1min=i1;
vmin=cube[i3][i2][i1];
}
if (vmax>cube[i3][i2][i1]) {
i3max=i3;
i2max=i2;
i1max=i1;
vmax=cube[i3][i2][i1];
}
}
}
}
fprintf(stderr,
"max value=%e, at i3=%d i2=%d i1=%d\n",vmin,i3min,i2min,i1min);
fprintf(stderr,
"min value=%e, at i3=%d i2=%d i1=%d\n",vmax,i3max,i2max,i1max);
glutInit(&argc, argv);
glutInitWindowSize(512, 512);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("trip");
glutDisplayFunc(redraw);
glutIdleFunc(NULL);
if (!getparfloat("q",q0)){
q0[0]=-0.6;
q0[1]=0.05;
q0[2]=-0.06;
q0[3]=0.8;
}
normalize_quat(q0);
curquat[0]=q0[0];
curquat[1]=q0[1];
curquat[2]=q0[2];
curquat[3]=q0[3];
glutReshapeFunc(myReshape);
glutVisibilityFunc(vis);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutCreateMenu(controlPanel);
glutAddMenuEntry("Full screen",1);
glutAddMenuEntry("Quit", 2);
glutAddMenuEntry("First vertical plane",3);
glutAddMenuEntry("Second vertical plane",4);
glutAddMenuEntry("Horizontal plane",5);
glutAddMenuEntry("Plot Axes",6);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glShadeModel(GL_SMOOTH); /* colors will be continuous */
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glLineWidth(1.0);
glMatrixMode(GL_PROJECTION);
eyez=25;
gluPerspective(
40.0, /*fovy: view angle in y direction*/
1.0, /*aspect: ratio of width (x) to y (height)*/
eyez-DIAMETER, /*near clipping plane*/
eyez+DIAMETER); /*far clipping plane*/
glMatrixMode(GL_MODELVIEW);
gluLookAt(
0.0, 0.0, eyez, /*(eyex,eyey,eyez): the eye position*/
0.0, 0.0, 0.0, /*(centerx,centery,centerz): the center*/
0.0, 1.0, 0.0); /*(upx,upy,upz): the up direction*/
glPushMatrix();
/****************************************************
Let's plot the first vertical plane (facing x-axis):
****************************************************/
data=ealloc3float(3,n1,n3);
emis=ealloc3float(4,n1,n3);
for (i1=0;i1<n1;i1++) {
for (i3=0;i3<n3;i3++) {
data[i3][i1][0]=((cx-xmin)/(xmax-xmin)-0.5)*DIAMETER;
data[i3][i1][1]=((i3-ymin)/(ymax-ymin)-0.5)*DIAMETER;
data[i3][i1][2]=((i1-zmin)/(zmax-zmin)-0.5)*DIAMETER;
v0=cube[i3][cx][i1];
zmEmission(v0,vmin,vmax,emis[i3][i1]);
}
}
showPlane(
3, /*list of plot*/
data, /*2-D plane data*/
emis, /*emission*/
n3, /*slow dimension in the 2D data*/
n1); /*fast dimension in the 2D data*/
free3float(data);
free3float(emis);
/****************************************************
Let's plot the second vertical plane (facing y-axis):
****************************************************/
data=ealloc3float(3,n1,n2);
emis=ealloc3float(4,n1,n2);
for (i1=0;i1<n1;i1++) {
for (i2=0;i2<n2;i2++) {
data[i2][i1][0]=((i2-xmin)/(xmax-xmin)-0.5)*DIAMETER;
data[i2][i1][1]=((cy-ymin)/(ymax-ymin)-0.5)*DIAMETER;
data[i2][i1][2]=((i1-zmin)/(zmax-zmin)-0.5)*DIAMETER;
v0=cube[cy][i2][i1];
zmEmission(v0,vmin,vmax,emis[i2][i1]);
}
}
showPlane(
4, /*list of plot*/
data, /*2-D plane data*/
emis, /*emission*/
n2, /*slow dimension in the 2D data*/
n1); /*fast dimension in the 2D data*/
free3float(data);
free3float(emis);
/****************************************************
Let's plot the horizontal plane:
****************************************************/
data=ealloc3float(3,n3,n2);
emis=ealloc3float(4,n3,n2);
for (i3=0;i3<n3;i3++) {
for (i2=0;i2<n2;i2++) {
data[i2][i3][0]=((i2-xmin)/(xmax-xmin)-0.5)*DIAMETER;
data[i2][i3][1]=((i3-ymin)/(ymax-ymin)-0.5)*DIAMETER;
data[i2][i3][2]=((cz-zmin)/(zmax-zmin)-0.5)*DIAMETER;
v0=cube[i3][i2][cz];
zmEmission(v0,vmin,vmax,emis[i2][i3]);
}
}
showPlane(
5, /*list of plot*/
data, /*2-D plane data*/
emis, /*emission*/
n2, /*slow dimension in the 2D data*/
n3); /*fast dimension in the 2D data*/
free3float(data);
free3float(emis);
/*show axes*/
glNewList(6,GL_COMPILE);
glLineWidth(1.5);
emission[0]=1.0;
emission[1]=1.0;
emission[2]=1.0;
emission[3]=1.0;
glMaterialfv(GL_FRONT,GL_EMISSION,emission);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(RADIUS,0.0,0.0);
glEnd();
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(0.0,RADIUS,0.0);
glEnd();
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(0.0,0.0,-RADIUS);
glEnd();
glEndList();
glutMainLoop();
return 0;
}
