CS 553 -- Winter Quarter 2009

Project #4: Volume Slicing

100 Points

Due: January 30

This page was last updated: January 6, 2009

Requirements:

1. Put this project number and your name in the title bar.

2. The scenario is that you are visualizing the same volume of points that you used in Projects #2 and #3. Because it is an equation, the number of points you use is up to you.

3. Make three volume cutting planes: parallel to XY, YZ, and XZ. Allow each of them to be toggled on and off independently.

4. Compute a scalar value at each node point in each plane according to the same formula you used in Projects #2 and #3.

5. Allow each cutting plane to be moved independently.

6. Allow the cutting planes to show scalar values in the plane by toggling between using smooth color shading and using contour lines..

7. Use the same color transfer function you used in Project #3.

8. Display an X-Y-Z set of axes as a reference. Allow these to be toggled on and off from a GLUI checkbox.

9. Allow the user to toggle between orthographic and perspective projections using a GLUI checkbox.

10. Allow scaling and rotation of the 3D scene.

Suggestions:

• Setup a two dimensional array representing the discrete nodes in a cutting plane. For example:

  
  struct node
  {
  	float x, y, z;
  	float t;
  };
  
  struct node  PlaneXY[NX][NY], PlaneXZ[NX][NZ], PlaneYZ[NY][NZ];
  
  

• Use small values for NX, NY, and NZ to start with (5?) so that debugging printout will have some meaning.

• For the interpolated color part of the assignment, compute a color at each vertex, and use glShadeModel( GL_SMOOTH ) to get OpenGL to interpolate the colors for you inside the quadrilateral cutting plane:

  glShadeMoidel( GL_SMOOTH );
  glBegin( GL_QUADS );
  	glColor3f( r0, g0, b0 );
  	glVertex3f( x0, y0, z0 );
  	glColor3f( r1, g1, b1 );
  	glVertex3f( x1, y1, z1 );
  	glColor3f( r2, g2, b2 );
  	glVertex3f( x2, y2, z2 );
  	glColor3f( r3, g3, b3 );
  	glVertex3f( x3, y3, z3 );
  glEnd();
  

• For the contour part of the assignment, write a routine that will generate the correct contours for one single quadrilateral. If you use structures, you could pass in pointers to each point:

  
  void
  ProcessQuad( struct node *p0, struct node *p1, struct node *p2, struct node *p3 )
  {
  	. . .
  	... p0->x ...
  	... p3->t ...
  	. . .
  }
  

  If you aren't comfortable with structures and pointers, you can create the same routine but pass in the 3 array indices for each of the four bounding vertices:

  
  void
  Process3uad( int i0, int j0, int k0, int i1, int j1, int k1, int i2, int j2, int k2, int i3, int j3, int k3 )
  {
  	. . .
  }
  

• The nice part of having this ProcessQuad() routine setup like this is that you can use it to draw the contour lines on the cutting plane and the contour lines that will become the Project #5 isosurfaces.

• Each cutting plane moves in one dimension only -- perpendicular to itself. For example, the XZ cutting plane only moves in Y. So, its grid points have X and Z coordinates that never change. At any given Y position of the XZ cutting plane, use each node's X and Z coordinates combined with the Y of the cutting plane to recompute via the equation the scalar value at each node. Thus, the 3D cutting planes are really a 2D contour-generation exercise.

• In "real life" you don't usually get an equation. You typically get data that has been sampled or computed at each 3D node. In that case, you would have to interpolate between known data layers.

Marching Squares

Remember that in the Marching Squares contour algorithm, you determine where (if anywhere) a contour line of the magic temperature, T*, would cross each edge of the square:

Grading: