Changeset 884 for trunk/vizservers/nanovis

Timestamp:

Feb 13, 2008 7:38:58 PM (16 years ago)

Author:

vrinside

Message:

Adding Volume animation

Location:

trunk/vizservers/nanovis

Files:

• Command.cpp (modified) (1 diff)
• Makefile.in (modified) (3 diffs)
• Texture3D.cpp (modified) (3 diffs)
• Texture3D.h (modified) (1 diff)
• Volume.cpp (modified) (4 diffs)
• Volume.h (modified) (2 diffs)
• VolumeInterpolator.cpp (added)
• VolumeInterpolator.h (added)
• VolumeRenderer.cpp (modified) (12 diffs)
• VolumeRenderer.h (modified) (4 diffs)
• nanovis.cpp (modified) (4 diffs)
• nanovis.h (modified) (1 diff)
• shaders/one_volume.cg (modified) (1 diff)

trunk/vizservers/nanovis/Command.cpp

@@ -1128 +1128 @@
             }
         }
-    } else if ((c == 't') && (strcmp(argv[1],"test2") == 0)) {
+    } 
+    else if (strcmp(argv[1],"animation") == 0) {
+        
+        if (strcmp(argv[2],"volumes") == 0) {
+            vector<unsigned int> ivol;
+            if (GetVolumeIndices(interp, argc-4, argv+4, &ivol) != TCL_OK) {
+                return TCL_ERROR;
+            }
+
+            NanoVis::vol_renderer->clearAnimatedVolumeInfo();
+
+            vector<unsigned int>::iterator iter;
+            for (iter = ivol.begin(); iter != ivol.end(); iter++) {
+                NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volume[*iter], *iter);
+            }
+        }
+        else if (strcmp(argv[2],"start") == 0) {
+                NanoVis::vol_renderer->startVolumeAnimation();
+        }
+        else if (strcmp(argv[2],"stop") == 0) {
+                NanoVis::vol_renderer->stopVolumeAnimation();
+        }
+        else if (strcmp(argv[2],"clear") == 0) {
+                NanoVis::vol_renderer->clearAnimatedVolumeInfo();
+        }
+
+    }
+    else if ((c == 't') && (strcmp(argv[1],"test2") == 0)) {
         NanoVis::volume[1]->disable_data();
         NanoVis::volume[1]->disable();

trunk/vizservers/nanovis/Makefile.in

@@ -52 +52 @@
         ConvexPolygon.o \
         Event.o \
+        GradientFilter.o \
         Grid.o \
         HeightMap.o \
@@ -105 +106 @@
         Vector4.o \
         Volume.o \
+        VolumeInterpolator.o \
         VolumeRenderer.o \
         ZincBlendeVolume.o \
@@ -303 +305 @@
 
 RenderContext.o: RenderContext.cpp RenderContext.h
+VolumeInterpolator.o: VolumeInterpolator.cpp VolumeInterpolator.h
+GradientFilter.o: GradientFilter.cpp GradientFilter.h
 
 Util.o: Util.cpp Util.h

trunk/vizservers/nanovis/Texture3D.cpp

@@ -52 +52 @@
 }
 
-GLuint Texture3D::initialize(float *data)
+void Texture3D::update(float* data)
 {
         //load texture with 16 bit half floating point precision if card is 6 series NV40
@@ -59 +59 @@
         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
-        glGenTextures(1, &id);
         glBindTexture(GL_TEXTURE_3D, id);
         assert(id!=-1);
@@ -115 +114 @@
         
         gl_resource_allocated = true;
+
+}
+
+GLuint Texture3D::initialize(float *data)
+{
+        if (id != 0) glDeleteTextures(1, &id);
+
+        //load texture with 16 bit half floating point precision if card is 6 series NV40
+        //half float with linear interpolation is only supported by 6 series and up cards
+        //If NV40 not defined, data is quantized to 8-bit from 32-bit.
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+        glGenTextures(1, &id);
+        glBindTexture(GL_TEXTURE_3D, id);
+        assert(id!=-1);
+
+        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+        if(interp_type==GL_LINEAR){
+                glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        }
+        else{
+                glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        }
+
+        //to do: add handling to more formats
+        if(type==GL_FLOAT){
+          switch(n_components){
+            #ifdef NV40
+                case 1:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE16F_ARB, width, height, depth, 0, GL_LUMINANCE, GL_FLOAT, data);
+                        break;
+                case 2:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE_ALPHA16F_ARB, width, height, depth, 0, GL_LUMINANCE_ALPHA, GL_FLOAT, data);
+                        break;
+                case 3:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB16F_ARB, width, height, depth, 0, GL_RGB, GL_FLOAT, data);
+                        break;
+                case 4:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA16F_ARB, width, height, depth, 0, GL_RGBA, GL_FLOAT, data);
+                        break;
+            #else
+                case 1:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE, width, height, depth, 0, GL_LUMINANCE, GL_FLOAT, data);
+                        break;
+                case 2:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE_ALPHA, width, height, depth, 0, GL_LUMINANCE_ALPHA, GL_FLOAT, data);
+                        break;
+                case 3:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, width, height, depth, 0, GL_RGB, GL_FLOAT, data);
+                        break;
+                case 4:
+                        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, width, height, depth, 0, GL_RGBA, GL_FLOAT, data);
+                        break;
+            #endif
+                default:
+                        break;
+          }
+        }
+
+
+        assert(glGetError()==0);
+        
+        gl_resource_allocated = true;
         return id;
 }

trunk/vizservers/nanovis/Texture3D.h

@@ -49 +49 @@
         static void check_max_unit();
 
+    void update(float* data);
+
 };
 

trunk/vizservers/nanovis/Volume.cpp

@@ -16 +16 @@
 #include <assert.h>
 #include "Volume.h"
+#include "Trace.h"
 
 
@@ -41 +42 @@
     iso_surface(0)
 {
+    Trace("Volume constructor\n");
 
     tex = new Texture3D(w, h, d, NVIS_FLOAT, NVIS_LINEAR_INTERP, n);
-    tex->initialize(data);
+
+    _data = new float[width * height * depth * n_components];
+    if (data)
+    {
+        Trace("data is copied\n");
+        memcpy(_data, data, sizeof(width *height* depth * n_components *sizeof(float)));
+        tex->initialize(data);
+    }
+    else
+    {
+        Trace("data is null\n");
+        memset(_data, 0x00, sizeof(width *height* depth * n_components *sizeof(float)));
+        tex->initialize(_data);
+    }
+
     id = tex->id;
     
@@ -63 +79 @@
     label[1] = "Y Label";
     label[2] = "Z Label";
+
+    Trace("End -- Volume constructor\n");
 }
-
 
 Volume::~Volume()
@@ -72 +89 @@
         // TBD...
     }
+
+    delete [] _data;
+
     delete tex; 
 }

trunk/vizservers/nanovis/Volume.h

@@ -64 +64 @@
 
     Texture3D* tex;             // OpenGL texture storing the volume
+
+    float* _data;
     
     int pointsetIndex;
@@ -100 +102 @@
            float size, int n_component, float* data, double vmin, double vmax, 
            double nonzero_min);
+
+  
     ~Volume();
         

trunk/vizservers/nanovis/VolumeRenderer.cpp

@@ -18 +18 @@
 #include "VolumeRenderer.h"
 #include "NvStdVertexShader.h"
+#include <time.h>
+#include <sys/time.h>
+#include "Trace.h"
 
 
@@ -32 +35 @@
     R2string path = R2FilePath::getInstance()->getPath("Font.bmp");
     init_font((const char*) path);
+
+    _volumeInterpolator = new VolumeInterpolator();
 }
 
@@ -39 +44 @@
     delete _regularVolumeShader;
     delete _stdVertexShader;
+    delete _volumeInterpolator;
 }
 
@@ -141 +147 @@
 }
 
+#if 0
+void VolumeRenderer::render_all()
+{
+    Volume* vol = 0;
+    Volume* ani_vol = 0;
+    TransferFunction* cur_tf = 0;
+    TransferFunction* ani_tf = 0;
+
+  int total_rendered_slices = 0;
+  int num_volumes = n_volumes;
+
+// TEST
+/*
+  if (_volumeInterpolator->is_started())
+  {
+    Trace("get ani... TEST\n");
+    ++ num_volumes;
+    ani_tf = tf[_volumeInterpolator->getReferenceVolumeID()];
+    ani_vol = _volumeInterpolator->getVolume();
+  }
+  */
+
+  ConvexPolygon*** polys = new ConvexPolygon**[num_volumes];    //two dimension pointer array
+                                                                        //storing the slices
+  int* actual_slices = new int[num_volumes]; //number of actual slices for each volume
+
+  for(int i=0; i < num_volumes; i++) {
+    int volume_index = i;
+
+    if (volume_index != n_volumes)
+    {
+        vol = volume[volume_index];
+        cur_tf = tf[volume_index];
+    }
+    else
+    {
+        vol = ani_vol;
+        cur_tf = ani_tf;
+    }
+
+    polys[volume_index] = NULL;
+    actual_slices[volume_index] = 0;
+
+    if(!vol->is_enabled())
+      continue; //skip this volume
+
+    // TEST
+    //if (i != n_volumes) continue;
+
+    int n_slices = vol->get_n_slice();
+
+    Trace("SLICES : %d\n", n_slices);
+
+    if (vol->get_isosurface())
+    {
+                // double the number of slices
+        n_slices <<= 1;
+        }
+
+    //volume start location
+    Vector3* location = vol->get_location();
+    Vector4 shift_4d(location->x, location->y, location->z, 0);
+
+    double x0 = 0;
+    double y0 = 0;
+    double z0 = 0;
+
+    Mat4x4 model_view_no_trans, model_view_trans;
+    Mat4x4 model_view_no_trans_inverse, model_view_trans_inverse;
+
+    double zNear, zFar;
+
+    //initialize volume plane with world coordinates
+    Plane volume_planes[6];
+    volume_planes[0].set_coeffs(1, 0, 0, -x0);
+    volume_planes[1].set_coeffs(-1, 0, 0, x0+1);
+    volume_planes[2].set_coeffs(0, 1, 0, -y0);
+    volume_planes[3].set_coeffs(0, -1, 0, y0+1);
+    volume_planes[4].set_coeffs(0, 0, 1, -z0);
+    volume_planes[5].set_coeffs(0, 0, -1, z0+1);
+  
+    //get modelview matrix with no translation
+    glPushMatrix();
+    glScalef(vol->aspect_ratio_width, 
+          vol->aspect_ratio_height, 
+          vol->aspect_ratio_depth);
+
+    glEnable(GL_DEPTH_TEST);
+
+    GLfloat mv_no_trans[16];
+    glGetFloatv(GL_MODELVIEW_MATRIX, mv_no_trans);
+
+    model_view_no_trans = Mat4x4(mv_no_trans);
+    model_view_no_trans_inverse = model_view_no_trans.inverse();
+
+    glPopMatrix();
+
+    //get modelview matrix with translation
+    glPushMatrix();
+    glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
+    glScalef(vol->aspect_ratio_width, 
+          vol->aspect_ratio_height, 
+          vol->aspect_ratio_depth);
+    GLfloat mv_trans[16];
+    glGetFloatv(GL_MODELVIEW_MATRIX, mv_trans);
+
+    model_view_trans = Mat4x4(mv_trans);
+    model_view_trans_inverse = model_view_trans.inverse();
+
+    //draw volume bounding box with translation (the correct location in space)
+    if (vol->outline_is_enabled()) {
+        float olcolor[3];
+        vol->get_outline_color(olcolor);
+        draw_bounding_box(x0, y0, z0, x0+1, y0+1, z0+1,
+            (double)olcolor[0], (double)olcolor[1], (double)olcolor[2],
+            1.5);
+    }
+    glPopMatrix();
+
+    //draw labels
+    glPushMatrix();
+    glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
+    if(vol->outline_is_enabled()) 
+    {
+       draw_label(vol);
+    }
+    glPopMatrix();
+
+    //transform volume_planes to eye coordinates.
+    for(int j=0; j<6; j++)
+      volume_planes[i].transform(model_view_no_trans);
+
+    get_near_far_z(mv_no_trans, zNear, zFar);
+
+    //compute actual rendering slices
+    float z_step = fabs(zNear-zFar)/n_slices;           
+    int n_actual_slices;
+
+    if (vol->data_is_enabled()) 
+    {
+        n_actual_slices = (int)(fabs(zNear-zFar)/z_step + 1);
+        polys[volume_index] = new ConvexPolygon*[n_actual_slices];
+    } else {
+        n_actual_slices = 0;
+        polys[volume_index] = NULL;
+    }
+    actual_slices[volume_index] = n_actual_slices;
+
+    Vector4 vert1 = (Vector4(-10, -10, -0.5, 1));
+    Vector4 vert2 = (Vector4(-10, +10, -0.5, 1));
+    Vector4 vert3 = (Vector4(+10, +10, -0.5, 1));
+    Vector4 vert4 = (Vector4(+10, -10, -0.5, 1));
+
+    
+    //Render cutplanes first with depth test enabled.
+    //They will mark the image with their depth values. Then we render other volume slices.
+    //These volume slices will be occluded correctly by the cutplanes and vice versa.
+
+    ConvexPolygon static_poly;
+    for(int i=0; i<vol->get_cutplane_count(); i++)
+    {
+      if(!vol->cutplane_is_enabled(i))
+        continue;
+
+      float offset = vol->get_cutplane(i)->offset;
+      int axis = vol->get_cutplane(i)->orient;
+
+      if(axis==3){
+        vert1 = Vector4(-10, -10, offset, 1);
+        vert2 = Vector4(-10, +10, offset, 1);
+        vert3 = Vector4(+10, +10, offset, 1);
+        vert4 = Vector4(+10, -10, offset, 1);
+        //continue;
+      }
+      else if(axis==1){
+        vert1 = Vector4(offset, -10, -10, 1);
+        vert2 = Vector4(offset, +10, -10, 1);
+        vert3 = Vector4(offset, +10, +10, 1);
+        vert4 = Vector4(offset, -10, +10, 1);
+        //continue;
+      }
+      else if(axis==2){
+        vert1 = Vector4(-10, offset, -10, 1);
+        vert2 = Vector4(+10, offset, -10, 1);
+        vert3 = Vector4(+10, offset, +10, 1);
+        vert4 = Vector4(-10, offset, +10, 1);
+        //continue;
+      }
+
+      vert1 = model_view_no_trans.transform(vert1);
+      vert2 = model_view_no_trans.transform(vert2);
+      vert3 = model_view_no_trans.transform(vert3);
+      vert4 = model_view_no_trans.transform(vert4);
+
+      ConvexPolygon* p = &static_poly;
+      p->vertices.clear();
+
+      p->append_vertex(vert1);
+      p->append_vertex(vert2);
+      p->append_vertex(vert3);
+      p->append_vertex(vert4);
+
+      for(int k=0; k<6; k++){
+        p->clip(volume_planes[k], true);
+      }
+
+      p->transform(model_view_no_trans_inverse);
+      p->transform(model_view_trans);
+
+      glPushMatrix();
+      glScalef(vol->aspect_ratio_width, vol->aspect_ratio_height, vol->aspect_ratio_depth);
+
+      activate_volume_shader(vol, cur_tf, true);
+      glPopMatrix();
+
+      glEnable(GL_DEPTH_TEST);
+      glDisable(GL_BLEND);
+
+      glBegin(GL_POLYGON);
+        p->Emit(true); 
+      glEnd();
+      glDisable(GL_DEPTH_TEST);
+
+      deactivate_volume_shader();
+    } //done cutplanes
+
+   
+    //Now do volume rendering
+
+    vert1 = (Vector4(-10, -10, -0.5, 1));
+    vert2 = (Vector4(-10, +10, -0.5, 1));
+    vert3 = (Vector4(+10, +10, -0.5, 1));
+    vert4 = (Vector4(+10, -10, -0.5, 1));
+
+    int counter = 0;
+    
+    //transform slices and store them
+    float slice_z;
+    for (int i=0; i<n_actual_slices; i++){
+      slice_z = zFar + i * z_step;      //back to front
+
+      ConvexPolygon *poly = new ConvexPolygon();
+      polys[volume_index][counter] = poly;
+      counter++;
+
+      poly->vertices.clear();
+      poly->set_id(volume_index);
+
+      //Setting Z-coordinate 
+      vert1.z = slice_z;
+      vert2.z = slice_z;
+      vert3.z = slice_z;
+      vert4.z = slice_z;
+                
+      poly->append_vertex(vert1);
+      poly->append_vertex(vert2);
+      poly->append_vertex(vert3);
+      poly->append_vertex(vert4);
+        
+      for(int k=0; k<6; k++){
+        poly->clip(volume_planes[k], true);
+      }
+
+      poly->transform(model_view_no_trans_inverse);
+      poly->transform(model_view_trans);
+
+      if(poly->vertices.size()>=3)
+        total_rendered_slices++; 
+    }
+    
+  } //iterate all volumes
+  //fprintf(stderr, "total slices: %d\n", total_rendered_slices); 
+
+  //We sort all the polygons according to their eye-space depth, from farthest to the closest.
+  //This step is critical for correct blending
+
+  SortElement* slices = (SortElement*) malloc(sizeof(SortElement)*total_rendered_slices);
+
+  int counter = 0;
+  for(int i=0; i<num_volumes; i++)
+  {
+    for(int j=0; j<actual_slices[i]; j++){
+      if(polys[i][j]->vertices.size() >= 3){
+        slices[counter] = SortElement(polys[i][j]->vertices[0].z, i, j);
+        counter++;
+      }
+    }
+  }
+
+  //sort them
+  qsort(slices, total_rendered_slices, sizeof(SortElement), slice_sort);
+
+  /*
+  //debug
+  for(int i=0; i<total_rendered_slices; i++){
+    fprintf(stderr, "%f ", slices[i].z);
+  }
+  fprintf(stderr, "\n\n");
+  */
+
+  //Now we are ready to render all the slices from back to front
+  glEnable(GL_DEPTH_TEST);
+  glEnable(GL_BLEND);
+
+  for(int i=0; i<total_rendered_slices; i++)
+  {
+    int volume_index = slices[i].volume_id;
+    int slice_index = slices[i].slice_id;
+    ConvexPolygon* cur = polys[volume_index][slice_index];
+    /*
+    if (volume_index == n_volumes)
+    {
+        // TEST
+        vol = ani_vol;
+        //vol = volume[0];
+        cur_tf = ani_tf;
+    }
+    else
+    {
+    */
+        vol = volume[volume_index];
+        cur_tf = tf[volume_index];
+    //}
+
+    glPushMatrix();
+    glScalef(vol->aspect_ratio_width, vol->aspect_ratio_height, vol->aspect_ratio_depth);
+    
+    activate_volume_shader(vol, cur_tf, false);
+    glPopMatrix();
+
+    glBegin(GL_POLYGON);
+      cur->Emit(true); 
+    glEnd();
+
+    deactivate_volume_shader();
+  }
+
+  glDisable(GL_DEPTH_TEST);
+  glDisable(GL_BLEND);
+
+  //Deallocate all the memory used
+  for(int i=0; i<num_volumes; i++)
+  {
+    for(int j=0; j<actual_slices[i]; j++){
+      delete polys[i][j];
+    }
+    if (polys[i]) {
+      delete[] polys[i];
+    }
+  }
+  delete[] polys;
+  delete[] actual_slices;
+  free(slices);
+
+}
+#endif
+void VolumeRenderer::render_all()
+{
+
+    Volume* cur_vol = 0;
+    Volume* ani_vol = 0;
+    TransferFunction* cur_tf = 0;
+    TransferFunction* ani_tf = 0;
+    int total_rendered_slices = 0;
+    int num_volumes = n_volumes;
+/*
+    if (_volumeInterpolator->is_started())
+    {
+        Trace("get ani... TEST\n");
+        ++ num_volumes;
+        ani_tf = tf[_volumeInterpolator->getReferenceVolumeID()];
+        ani_vol = _volumeInterpolator->getVolume();
+    }
+    */
+
+  ConvexPolygon*** polys = new ConvexPolygon**[num_volumes];    //two dimension pointer array
+  int* actual_slices = new int[num_volumes]; //number of actual slices for each volume
+
+  for(int i=0; i<n_volumes; i++){
+    int vol_index= i;
+    if (vol_index != n_volumes)
+    {
+        cur_vol = volume[vol_index];
+        cur_tf = tf[vol_index];
+    }
+    else
+    {
+        cur_vol = ani_vol;
+        cur_tf = ani_tf;
+    }
+    
+    polys[i] = NULL;
+    actual_slices[i] = 0;
+
+    if(!cur_vol->is_enabled())
+      continue; //skip this volume
+
+    int n_slices = cur_vol->get_n_slice();
+    if (cur_vol->get_isosurface())
+    {
+                // double the number of slices
+        n_slices <<= 1;
+        }
+
+    //volume start location
+    Vector3* location = cur_vol->get_location();
+    Vector4 shift_4d(location->x, location->y, location->z, 0);
+
+    double x0 = 0;
+    double y0 = 0;
+    double z0 = 0;
+
+    Mat4x4 model_view_no_trans, model_view_trans;
+    Mat4x4 model_view_no_trans_inverse, model_view_trans_inverse;
+
+    double zNear, zFar;
+
+    //initialize volume plane with world coordinates
+    Plane volume_planes[6];
+    volume_planes[0].set_coeffs(1, 0, 0, -x0);
+    volume_planes[1].set_coeffs(-1, 0, 0, x0+1);
+    volume_planes[2].set_coeffs(0, 1, 0, -y0);
+    volume_planes[3].set_coeffs(0, -1, 0, y0+1);
+    volume_planes[4].set_coeffs(0, 0, 1, -z0);
+    volume_planes[5].set_coeffs(0, 0, -1, z0+1);
+  
+    //get modelview matrix with no translation
+    glPushMatrix();
+    glScalef(cur_vol->aspect_ratio_width, 
+          cur_vol->aspect_ratio_height, 
+          cur_vol->aspect_ratio_depth);
+
+    glEnable(GL_DEPTH_TEST);
+
+    GLfloat mv_no_trans[16];
+    glGetFloatv(GL_MODELVIEW_MATRIX, mv_no_trans);
+
+    model_view_no_trans = Mat4x4(mv_no_trans);
+    model_view_no_trans_inverse = model_view_no_trans.inverse();
+
+    glPopMatrix();
+
+    //get modelview matrix with translation
+    glPushMatrix();
+    glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
+    glScalef(cur_vol->aspect_ratio_width, 
+          cur_vol->aspect_ratio_height, 
+          cur_vol->aspect_ratio_depth);
+    GLfloat mv_trans[16];
+    glGetFloatv(GL_MODELVIEW_MATRIX, mv_trans);
+
+    model_view_trans = Mat4x4(mv_trans);
+    model_view_trans_inverse = model_view_trans.inverse();
+
+    //draw volume bounding box with translation (the correct location in space)
+    if (cur_vol->outline_is_enabled()) {
+        float olcolor[3];
+        cur_vol->get_outline_color(olcolor);
+        draw_bounding_box(x0, y0, z0, x0+1, y0+1, z0+1,
+            (double)olcolor[0], (double)olcolor[1], (double)olcolor[2],
+            1.5);
+    }
+    glPopMatrix();
+
+    //draw labels
+    glPushMatrix();
+    glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
+    if(cur_vol->outline_is_enabled()) {
+       //draw_label(i);
+    }
+    glPopMatrix();
+
+    //transform volume_planes to eye coordinates.
+    for(int i=0; i<6; i++)
+      volume_planes[i].transform(model_view_no_trans);
+    get_near_far_z(mv_no_trans, zNear, zFar);
+
+    //compute actual rendering slices
+    float z_step = fabs(zNear-zFar)/n_slices;           
+    int n_actual_slices;
+
+    if (cur_vol->data_is_enabled()) {
+        n_actual_slices = (int)(fabs(zNear-zFar)/z_step + 1);
+        polys[vol_index] = new ConvexPolygon*[n_actual_slices];
+    } else {
+        n_actual_slices = 0;
+        polys[vol_index] = NULL;
+    }
+    actual_slices[vol_index] = n_actual_slices;
+
+    Vector4 vert1 = (Vector4(-10, -10, -0.5, 1));
+    Vector4 vert2 = (Vector4(-10, +10, -0.5, 1));
+    Vector4 vert3 = (Vector4(+10, +10, -0.5, 1));
+    Vector4 vert4 = (Vector4(+10, -10, -0.5, 1));
+
+    
+    //Render cutplanes first with depth test enabled.
+    //They will mark the image with their depth values. Then we render other volume slices.
+    //These volume slices will be occluded correctly by the cutplanes and vice versa.
+
+    ConvexPolygon static_poly;
+    for(int i=0; i<cur_vol->get_cutplane_count(); i++)
+    {
+      if(!cur_vol->cutplane_is_enabled(i))
+        continue;
+
+      float offset = cur_vol->get_cutplane(i)->offset;
+      int axis = cur_vol->get_cutplane(i)->orient;
+
+      if(axis==3){
+        vert1 = Vector4(-10, -10, offset, 1);
+        vert2 = Vector4(-10, +10, offset, 1);
+        vert3 = Vector4(+10, +10, offset, 1);
+        vert4 = Vector4(+10, -10, offset, 1);
+        //continue;
+      }
+      else if(axis==1){
+        vert1 = Vector4(offset, -10, -10, 1);
+        vert2 = Vector4(offset, +10, -10, 1);
+        vert3 = Vector4(offset, +10, +10, 1);
+        vert4 = Vector4(offset, -10, +10, 1);
+        //continue;
+      }
+      else if(axis==2){
+        vert1 = Vector4(-10, offset, -10, 1);
+        vert2 = Vector4(+10, offset, -10, 1);
+        vert3 = Vector4(+10, offset, +10, 1);
+        vert4 = Vector4(-10, offset, +10, 1);
+        //continue;
+      }
+
+      vert1 = model_view_no_trans.transform(vert1);
+      vert2 = model_view_no_trans.transform(vert2);
+      vert3 = model_view_no_trans.transform(vert3);
+      vert4 = model_view_no_trans.transform(vert4);
+
+      ConvexPolygon* p = &static_poly;
+      p->vertices.clear();
+
+      p->append_vertex(vert1);
+      p->append_vertex(vert2);
+      p->append_vertex(vert3);
+      p->append_vertex(vert4);
+
+      for(int k=0; k<6; k++){
+        p->clip(volume_planes[k], true);
+      }
+
+      p->transform(model_view_no_trans_inverse);
+      p->transform(model_view_trans);
+
+      glPushMatrix();
+      glScalef(cur_vol->aspect_ratio_width, cur_vol->aspect_ratio_height, cur_vol->aspect_ratio_depth);
+
+      activate_volume_shader(cur_vol, cur_tf, true);
+      glPopMatrix();
+
+      glEnable(GL_DEPTH_TEST);
+      glDisable(GL_BLEND);
+
+      glBegin(GL_POLYGON);
+        p->Emit(true); 
+      glEnd();
+      glDisable(GL_DEPTH_TEST);
+
+      deactivate_volume_shader();
+    } //done cutplanes
+
+   
+    //Now do volume rendering
+
+    vert1 = (Vector4(-10, -10, -0.5, 1));
+    vert2 = (Vector4(-10, +10, -0.5, 1));
+    vert3 = (Vector4(+10, +10, -0.5, 1));
+    vert4 = (Vector4(+10, -10, -0.5, 1));
+
+    int counter = 0;
+    
+    //transform slices and store them
+    float slice_z;
+    for (int i=0; i<n_actual_slices; i++){
+      slice_z = zFar + i * z_step;      //back to front
+
+      ConvexPolygon *poly = new ConvexPolygon();
+      polys[vol_index][counter] = poly;
+      counter++;
+
+      poly->vertices.clear();
+      poly->set_id(vol_index);
+
+      //Setting Z-coordinate 
+      vert1.z = slice_z;
+      vert2.z = slice_z;
+      vert3.z = slice_z;
+      vert4.z = slice_z;
+                
+      poly->append_vertex(vert1);
+      poly->append_vertex(vert2);
+      poly->append_vertex(vert3);
+      poly->append_vertex(vert4);
+        
+      for(int k=0; k<6; k++){
+        poly->clip(volume_planes[k], true);
+      }
+
+      poly->transform(model_view_no_trans_inverse);
+      poly->transform(model_view_trans);
+
+      if(poly->vertices.size()>=3)
+        total_rendered_slices++; 
+    }
+    
+  } //iterate all volumes
+  //fprintf(stderr, "total slices: %d\n", total_rendered_slices); 
+
+  //We sort all the polygons according to their eye-space depth, from farthest to the closest.
+  //This step is critical for correct blending
+
+  SortElement* slices = (SortElement*) malloc(sizeof(SortElement)*total_rendered_slices);
+
+  int counter = 0;
+  for(int i=0; i<n_volumes; i++){
+    for(int j=0; j<actual_slices[i]; j++){
+      if(polys[i][j]->vertices.size() >= 3){
+        slices[counter] = SortElement(polys[i][j]->vertices[0].z, i, j);
+        counter++;
+      }
+    }
+  }
+
+  //sort them
+  qsort(slices, total_rendered_slices, sizeof(SortElement), slice_sort);
+
+  /*
+  //debug
+  for(int i=0; i<total_rendered_slices; i++){
+    fprintf(stderr, "%f ", slices[i].z);
+  }
+  fprintf(stderr, "\n\n");
+  */
+
+  //Now we are ready to render all the slices from back to front
+  glEnable(GL_DEPTH_TEST);
+  glEnable(GL_BLEND);
+
+  for(int i=0; i<total_rendered_slices; i++){
+    int volume_index = slices[i].volume_id;
+    int slice_index = slices[i].slice_id;
+    ConvexPolygon* cur = polys[volume_index][slice_index];
+
+    if (volume_index == n_volumes)
+    {
+        cur_vol = ani_vol;
+        cur_tf = ani_tf;
+    }
+    else
+    {
+        cur_vol = volume[volume_index];
+        cur_tf = tf[volume_index];
+    }
+
+
+    glPushMatrix();
+    glScalef(cur_vol->aspect_ratio_width, cur_vol->aspect_ratio_height, cur_vol->aspect_ratio_depth);
+    
+    activate_volume_shader(cur_vol, cur_tf, false);
+    glPopMatrix();
+
+    glBegin(GL_POLYGON);
+      cur->Emit(true); 
+    glEnd();
+
+    deactivate_volume_shader();
+  }
+
+
+  glDisable(GL_DEPTH_TEST);
+  glDisable(GL_BLEND);
+
+  //Deallocate all the memory used
+  for(int i=0; i<n_volumes; i++){
+    for(int j=0; j<actual_slices[i]; j++){
+      delete polys[i][j];
+    }
+    if (polys[i]) {
+      delete[] polys[i];
+    }
+  }
+  delete[] polys;
+  delete[] actual_slices;
+  free(slices);
+}
+#if 0
 void VolumeRenderer::render_all()
 {
@@ -229 +928 @@
     glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
     if(volume[i]->outline_is_enabled()) {
-       draw_label(i);
+       draw_label(volume[i]);
     }
     glPopMatrix();
@@ -315 +1014 @@
       glScalef(volume[volume_index]->aspect_ratio_width, volume[volume_index]->aspect_ratio_height, volume[volume_index]->aspect_ratio_depth);
 
-      activate_volume_shader(volume_index, true);
+      activate_volume_shader(volume[volume_index], tf[volume_index],true);
       glPopMatrix();
 
@@ -414 +1113 @@
     glScalef(volume[volume_index]->aspect_ratio_width, volume[volume_index]->aspect_ratio_height, volume[volume_index]->aspect_ratio_depth);
     
-    activate_volume_shader(volume_index, false);
+    activate_volume_shader(volume[volume_index], tf[volume_index],false);
     glPopMatrix();
 
@@ -441 +1140 @@
   free(slices);
 }
-
-
-void VolumeRenderer::render(int volume_index){
+#endif
+
+void VolumeRenderer::render(int volume_index)
+{
   int n_slices = volume[volume_index]->get_n_slice();
 
@@ -577 +1277 @@
     glScalef(volume[volume_index]->aspect_ratio_width, volume[volume_index]->aspect_ratio_height, volume[volume_index]->aspect_ratio_depth);
 
-    activate_volume_shader(volume_index, true);
+    activate_volume_shader(volume[volume_index], tf[volume_index], true);
     glPopMatrix();
 
@@ -637 +1337 @@
     */
     
-    activate_volume_shader(volume_index, false);
+    activate_volume_shader(volume[volume_index], tf[volume_index], true);
     glPopMatrix();
 
@@ -704 +1404 @@
 
 
-void VolumeRenderer::activate_volume_shader(int volume_index, bool slice_mode)
+void VolumeRenderer::activate_volume_shader(Volume* vol, TransferFunction* tf, bool slice_mode)
 {
   //vertex shader
   _stdVertexShader->bind();
 
-  if (volume[volume_index]->volume_type == CUBIC)
+  if (vol->volume_type == CUBIC)
   {
     //regular cubic volume
-    _regularVolumeShader->bind(tf[volume_index]->id, volume[volume_index], slice_mode);
-  }
-  else if (volume[volume_index]->volume_type == ZINCBLENDE)
+    _regularVolumeShader->bind(tf->id, vol, slice_mode);
+  }
+  else if (vol->volume_type == ZINCBLENDE)
   {
-    _zincBlendeShader->bind(tf[volume_index]->id, volume[volume_index], slice_mode);
+    _zincBlendeShader->bind(tf->id, vol, slice_mode);
   }
 }
@@ -922 +1622 @@
 
 
-void VolumeRenderer::draw_label(int volume_index){
-
-  Volume* vol = volume[volume_index];
- 
+void VolumeRenderer::draw_label(Volume* vol){
+
   //glEnable(GL_TEXTURE_2D);
   glDisable(GL_TEXTURE_2D);

trunk/vizservers/nanovis/VolumeRenderer.h

@@ -37 +37 @@
 #include "NvZincBlendeVolumeShader.h"
 #include "NvStdVertexShader.h"
+#include "VolumeInterpolator.h"
 
 class VolumeRenderer {
 
+    friend class NanoVis;
 private:
     std::vector <Volume*> volume;           //!<- array of volumes
     std::vector <TransferFunction*> tf;    //!<- array of corresponding transfer functions 
+    VolumeInterpolator* _volumeInterpolator;
+
     int n_volumes;
 
@@ -78 +82 @@
 
   void init_shaders();
-  void activate_volume_shader(int volume_index, bool slice_mode);
+  void activate_volume_shader(Volume* vol, TransferFunction* tf, bool slice_mode);
   void deactivate_volume_shader();
 
@@ -91 +95 @@
   GLuint font_texture;                          //the id of the font texture
   void glPrint(char* string, int set);          //there are two sets of font in the texture. 0, 1
-  void draw_label(int volume_index);            //draw label using bitmap texture
+  void draw_label(Volume* vol);         //draw label using bitmap texture
   GLuint font_base;                             //the base of the font display list
   void build_font();                            //register the location of each alphabet in the texture
@@ -117 +121 @@
   void enable_volume(int index); //enable a volume
   void disable_volume(int index); //disable a volume
+
+    void clearAnimatedVolumeInfo();
+    void addAnimatedVolume(Volume* volume, unsigned int volumeId);
+    void startVolumeAnimation();
+    void stopVolumeAnimation();
 };
 
+inline void VolumeRenderer::clearAnimatedVolumeInfo()
+{
+    _volumeInterpolator->clearAll();
+}
+
+inline void VolumeRenderer::addAnimatedVolume(Volume* volume, unsigned int volumeId)
+{
+    _volumeInterpolator->addVolume(volume, volumeId);
+}
+
+inline void VolumeRenderer::startVolumeAnimation()
+{
+    _volumeInterpolator->start();
+}
+
+inline void VolumeRenderer::stopVolumeAnimation()
+{
+    _volumeInterpolator->stop();
+}
+
+
 #endif

trunk/vizservers/nanovis/nanovis.cpp

@@ -23 +23 @@
 #include <sstream>
 #include <string>
+#include <time.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ -28 +29 @@
 #include <fcntl.h>
 #include <signal.h>
+#include <stdlib.h>
 
 #include "Nv.h"
@@ -56 +58 @@
 #include "HeightMap.h"
 #include "Grid.h"
+#include "VolumeInterpolator.h"
 #include <RenderContext.h>
 
@@ -1364 +1367 @@
 #endif
 
+void NanoVis::update()
+{
+    if (vol_renderer->_volumeInterpolator->is_started())
+    {
+    struct timeval clock;
+    gettimeofday(&clock, NULL);
+    double cur_time = clock.tv_sec + clock.tv_usec/1000000.0;
+
+    float fraction;
+    float f = fmod(cur_time - vol_renderer->_volumeInterpolator->getStartTime(), 
+                    vol_renderer->_volumeInterpolator->getInterval());
+
+    if (f == 0.0f) fraction = 0.0f;
+    else fraction = f / vol_renderer->_volumeInterpolator->getInterval();
+
+    vol_renderer->_volumeInterpolator->update(fraction);
+  }
+}
 
 /*----------------------------------------------------*/

trunk/vizservers/nanovis/nanovis.h

@@ -152 +152 @@
     static void bmp_write_to_file(int frame_number);
     static void display(void);
+    static void update(void);
     static void display_offscreen_buffer();
     static void read_screen();

trunk/vizservers/nanovis/shaders/one_volume.cg

@@ -62 +62 @@
     //float normal_dot_half = abs(dot(normal, half_vector));
 
+
     float ambient = 0.8;
     float diffuse = normal_dot_light * renderParameters.z;