Changeset 1475 for trunk/packages

Timestamp:

May 29, 2009, 1:13:42 PM (15 years ago)

Author:

vrinside

Message:

mofified a way of dealing with volumes by adding reference counts to data objects.

• To-do : check any memory leaks for graphics objects

Location:

trunk/packages/vizservers/nanovis

Files:

• Command.cpp (modified) (22 diffs)
• FlowCmd.cpp (modified) (6 diffs)
• FlowCmd.h (modified) (1 diff)
• R2/include/R2/R2Object.h (modified) (1 diff)
• TransferFunction.cpp (modified) (1 diff)
• TransferFunction.h (modified) (3 diffs)
• Volume.cpp (modified) (1 diff)
• Volume.h (modified) (5 diffs)
• VolumeInterpolator.cpp (modified) (1 diff)
• VolumeRenderer.cpp (modified) (19 diffs)
• VolumeRenderer.h (modified) (4 diffs)
• dxReader.cpp (modified) (16 diffs)
• dxReader2.cpp (modified) (4 diffs)
• nanovis.cpp (modified) (4 diffs)
• nanovis.h (modified) (5 diffs)

trunk/packages/vizservers/nanovis/Command.cpp

@@ -363 +363 @@
 /*
  * ----------------------------------------------------------------------
- * FUNCTION: GetVolumeIndex
+ * FUNCTION: GetVolumeDataID
  *
  * Used internally to decode a series of volume index values and
@@ -375 +375 @@
  */
 static int
-GetVolumeIndex(Tcl_Interp *interp, Tcl_Obj *objPtr, unsigned int *indexPtr)
-{
-    int index;
-    if (Tcl_GetIntFromObj(interp, objPtr, &index) != TCL_OK) {
+GetVolumeDataID(Tcl_Interp *interp, Tcl_Obj *objPtr, unsigned int *dataIDPtr)
+{
+    int volDataID;
+    if (Tcl_GetIntFromObj(interp, objPtr, &volDataID) != TCL_OK) {
         return TCL_ERROR;
     }
@@ -386 +386 @@
         return TCL_ERROR;
     }
+        /*
     if (index >= (int)NanoVis::volume.size()) {
         Tcl_AppendResult(interp, "index \"", Tcl_GetString(objPtr),
@@ -391 +392 @@
         return TCL_ERROR;
     }
-    *indexPtr = (unsigned int)index;
+        */
+
+    NanoVis::VolumeMap::iterator iter = NanoVis::volumeMap.find(volDataID);
+    if (iter == NanoVis::volumeMap.end())
+    {
+        Tcl_AppendResult(interp, "dataID \"", Tcl_GetString(objPtr),
+                     "\" is out found", (char*)NULL);
+        return TCL_ERROR;
+    }
+
+    *dataIDPtr = (unsigned int)volDataID;
     return TCL_OK;
 }
@@ -411 +422 @@
 GetVolumeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Volume **volPtrPtr)
 {
-    unsigned int index;
-    if (GetVolumeIndex(interp, objPtr, &index) != TCL_OK) {
+    unsigned int volDataID;
+    if (GetVolumeDataID(interp, objPtr, &volDataID) != TCL_OK) {
         return TCL_ERROR;
     }
     Volume *vol;
-    vol = NanoVis::volume[index];
+    vol = NanoVis::volumeMap[volDataID];
     if (vol == NULL) {
-        Tcl_AppendResult(interp, "no volume defined for index \"",
+        Tcl_AppendResult(interp, "no volume defined for volDataID \"",
                          Tcl_GetString(objPtr), "\"", (char*)NULL);
         return TCL_ERROR;
     }
     *volPtrPtr = vol;
+    //printf("volume [%d] found\n", vol->getDataID());
     return TCL_OK;
 }
@@ -428 +440 @@
 /*
  * ----------------------------------------------------------------------
- * FUNCTION: GetVolumeIndices()
+ * FUNCTION: GetVolumeDataIDs()
  *
  * Used internally to decode a series of volume index values and
@@ -440 +452 @@
  */
 static int
-GetVolumeIndices(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
+GetVolumeDataIDs(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
                  vector<unsigned int>* vectorPtr)
 {
     if (objc == 0) {
-        for (unsigned int n = 0; n < NanoVis::volume.size(); n++) {
-            if (NanoVis::volume[n] != NULL) {
-                vectorPtr->push_back(n);
-            }
+        NanoVis::VolumeMap::iterator iter;
+        for (iter = NanoVis::volumeMap.begin(); iter != NanoVis::volumeMap.end(); ++iter) {
+                if ((*iter).second != NULL) {
+                        vectorPtr->push_back((*iter).first);
+                }
         }
     } else {
+        NanoVis::VolumeMap::iterator iter;
         for (int n = 0; n < objc; n++) {
-            unsigned int index;
-
-            if (GetVolumeIndex(interp, objv[n], &index) != TCL_OK) {
+            unsigned int volDataID;
+
+            if (GetVolumeDataID(interp, objv[n], &volDataID) != TCL_OK) {
                 return TCL_ERROR;
             }
-            if (NanoVis::volume[index] != NULL) {
-                vectorPtr->push_back(index);
+
+            iter = NanoVis::volumeMap.find(volDataID);
+            if ((iter != NanoVis::volumeMap.end()) && ((*iter).second != 0)) {
+                vectorPtr->push_back(volDataID);
             }
         }
@@ -482 +498 @@
 {
     if (objc == 0) {
-        for (unsigned int n = 0; n < NanoVis::volume.size(); n++) {
-            if (NanoVis::volume[n] != NULL) {
-                vectorPtr->push_back(NanoVis::volume[n]);
+       NanoVis::VolumeMap::iterator iter;
+        for (iter = NanoVis::volumeMap.begin(); iter != NanoVis::volumeMap.end(); ++iter) {
+            if ((*iter).second != NULL) {
+                vectorPtr->push_back((*iter).second);
             }
         }
@@ -1185 +1202 @@
 {
     vector<unsigned int> ivol;
-    if (GetVolumeIndices(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    Trace("parsing volume index\n");
+    if (GetVolumeDataIDs(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    Trace("parsing volume data identifier\n");
     vector<unsigned int>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        Trace("index: %d\n", *iter);
-        NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volume[*iter], *iter);
+        Trace("volDataID: %d\n", *iter);
+        NanoVis::vol_renderer->addAnimatedVolume(NanoVis::volumeMap[*iter], *iter);
     }
     return TCL_OK;
@@ -1239 +1256 @@
         return TCL_ERROR;
     }
-    int n = NanoVis::n_volumes;
     char header[6];
     memcpy(header, buf.bytes(), sizeof(char) * 5);
@@ -1260 +1276 @@
     printf("Checking header[%s]\n", header);
     fflush(stdout);
+
+    Volume *volPtr = 0;
+    int volDataID = -1;
     if (strcmp(header, "<HDR>") == 0) {
-        Volume* vol = NULL;
-
         printf("ZincBlende stream is in\n");
         fflush(stdout);
@@ -1270 +1287 @@
 
 #if _LOCAL_ZINC_TEST_
-        vol = NvZincBlendeReconstructor::getInstance()->loadFromMemory(b);
+        volPtr = NvZincBlendeReconstructor::getInstance()->loadFromMemory(b);
 #else
-        vol = NvZincBlendeReconstructor::getInstance()->loadFromMemory((void*) buf.bytes());
+        volPtr = NvZincBlendeReconstructor::getInstance()->loadFromMemory((void*) buf.bytes());
 #endif  /*_LOCAL_ZINC_TEST_*/
-        if (vol == NULL) {
+        if (volPtr == NULL) {
             Tcl_AppendResult(interp, "can't get volume instance", (char *)NULL);
             return TCL_OK;
@@ -1280 +1297 @@
         printf("finish loading\n");
         fflush(stdout);
-        while (NanoVis::n_volumes <= n) {
-            NanoVis::volume.push_back((Volume*) NULL);
-            NanoVis::n_volumes++;
-        }
-
-        if (NanoVis::volume[n] != NULL) {
-            delete NanoVis::volume[n];
-            NanoVis::volume[n] = NULL;
+
+        // INSOO
+        // TBD..
+        volDataID = NanoVis::generate_data_identifier();
+        NanoVis::VolumeMap::iterator iter;
+        iter = NanoVis::volumeMap.find(volDataID);
+        if (iter != NanoVis::volumeMap.end())
+        {
+            if (iter->second != NULL) {
+                iter->second->unref();
+                iter->second = 0;
+            }
         }
 
         float dx0 = -0.5;
-        float dy0 = -0.5*vol->height/vol->width;
-        float dz0 = -0.5*vol->depth/vol->width;
-        vol->move(Vector3(dx0, dy0, dz0));
-
-        NanoVis::volume[n] = vol;
+        float dy0 = -0.5*volPtr->height/volPtr->width;
+        float dz0 = -0.5*volPtr->depth/volPtr->width;
+        volPtr->move(Vector3(dx0, dy0, dz0));
+
+        NanoVis::volumeMap[volDataID] = volPtr;
 #if __TEST_CODE__
     } else if (strcmp(header, "<FET>") == 0) {
@@ -1308 +1329 @@
 #endif  /*__TEST_CODE__*/
     } else if (strcmp(header, "<ODX>") == 0) {
+        /*
         Rappture::Outcome err;
 
@@ -1316 +1338 @@
             return TCL_ERROR;
         }
+        */
     } else {
+        volDataID = NanoVis::generate_data_identifier();
+        printf("test\n");
 #ifdef notdef
         Rappture::Unirect3d *dataPtr;
@@ -1329 +1354 @@
         dataPtr->Resample(context, 30);
 #endif
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, vmin, vmax,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data, vmin, vmax,
                                   nzero_min);
     
@@ -1353 +1377 @@
         Rappture::Outcome context;
 #if ISO_TEST
-        result = load_volume_stream2(context, n, fdata);
+        result = load_volume_stream2(context, volDataID, fdata);
 #else
-        result = load_volume_stream(context, n, fdata);
+        result = load_volume_stream(context, volDataID, fdata);
 #endif
         if (!result) {
@@ -1361 +1385 @@
             return TCL_ERROR;
         }
+        volPtr = NanoVis::volumeMap[volDataID];
     }
 
@@ -1369 +1394 @@
     // overwrite the first, so the first won't appear at all.
     //
-    if (NanoVis::volume[n] != NULL) {
-        //NanoVis::volume[n]->set_n_slice(512-n);
-        NanoVis::volume[n]->set_n_slice(256-n);
-        NanoVis::volume[n]->disable_cutplane(0);
-        NanoVis::volume[n]->disable_cutplane(1);
-        NanoVis::volume[n]->disable_cutplane(2);
-
-        NanoVis::vol_renderer->add_volume(NanoVis::volume[n],
+    if (volPtr != NULL) {
+        //volPtr->set_n_slice(512-n);
+        //volPtr->set_n_slice(256-n);
+        volPtr->set_n_slice(256);
+        volPtr->disable_cutplane(0);
+        volPtr->disable_cutplane(1);
+        volPtr->disable_cutplane(2);
+
+        NanoVis::vol_renderer->add_volume(volPtr,
                                           NanoVis::get_transfunc("default"));
-    }
-
-    {
-        Volume *volPtr;
+
         char info[1024];
         ssize_t nWritten;
@@ -1388 +1411 @@
             NanoVis::SetVolumeRanges();
         }
-        volPtr = NanoVis::volume[n];
+
         // FIXME: strlen(info) is the return value of sprintf
         sprintf(info, "nv>data tag %s id %d min %g max %g vmin %g vmax %g\n",
-                tag, n, volPtr->wAxis.min(), volPtr->wAxis.max(),
+                tag, volDataID, volPtr->wAxis.min(), volPtr->wAxis.max(),
                 Volume::valueMin, Volume::valueMax);
         nWritten  = write(0, info, strlen(info));
@@ -1683 +1706 @@
              Tcl_Obj *const *objv)
 {
-    NanoVis::volume[1]->data(false);
-    NanoVis::volume[1]->visible(false);
+    NanoVis::VolumeMap::iterator iter = NanoVis::volumeMap.find(1);
+    if (iter != NanoVis::volumeMap.end())
+    {
+        NanoVis::volumeMap[1]->data(false);
+        NanoVis::volumeMap[1]->visible(false);
+    }
     return TCL_OK;
 }
@@ -2413 +2440 @@
         NanoVis::SetHeightmapRanges();
     }
+
     NanoVis::render_legend(tf, HeightMap::valueMin, HeightMap::valueMax, w, h,
-        "label");
+       "label");
     return TCL_OK;
 }

trunk/packages/vizservers/nanovis/FlowCmd.cpp

@@ -272 +272 @@
     _interp = interp;
     _hashPtr = hPtr;
-    _volIndex = -1;                     /* Indicates that no volume slot has
+    _volDataID = -1;                    /* Indicates that no volume slot has
                                          * been allocated for this vector. */
     _sv.sliceVisible = 1;
@@ -296 +296 @@
     }
      if (_volPtr != NULL) {
-        delete _volPtr;
+        _volPtr->unref();
         _volPtr = NULL;
-        NanoVis::volume[_volIndex] = NULL;
-        NanoVis::vol_renderer->remove_volume(_volIndex);
+        NanoVis::remove_volume(_volDataID);
+        NanoVis::vol_renderer->remove_volume(_volDataID);
     }
 
@@ -500 +500 @@
 {
     if (_volPtr != NULL) {
-        delete _volPtr;
+        _volPtr->unref();
         _volPtr = NULL;
-        NanoVis::volume[_volIndex] = NULL;
-        NanoVis::vol_renderer->remove_volume(_volIndex);
+        NanoVis::remove_volume(_volDataID);
+        NanoVis::vol_renderer->remove_volume(_volDataID);
     }
     // Remove the associated vector field.
@@ -528 +528 @@
 {
     if (_volPtr != NULL) {
-        delete _volPtr;
+        _volPtr->unref();
         _volPtr = NULL;
-        NanoVis::volume[_volIndex] = NULL;
-        NanoVis::vol_renderer->remove_volume(_volIndex);
+        NanoVis::remove_volume(_volDataID);
+        NanoVis::vol_renderer->remove_volume(_volDataID);
     }
     float *vdata;
@@ -632 +632 @@
 FlowCmd::MakeVolume(float *data)
 {
-    if (_volIndex < 0) {
-        _volIndex = NanoVis::n_volumes;
-        Trace("VolumeIndex is %d\n", _volIndex);
+    if (_volDataID < 0) {
+        _volDataID = NanoVis::generate_data_identifier();
+        Trace("VolumeDataID is %d\n", _volDataID);
     }
     Volume *volPtr;
-    volPtr = NanoVis::load_volume(_volIndex, _dataPtr->xNum(), 
+    volPtr = NanoVis::load_volume(_volDataID, _dataPtr->xNum(), 
         _dataPtr->yNum(), _dataPtr->zNum(), 4, data, 
         NanoVis::magMin, NanoVis::magMax, 0);
@@ -650 +650 @@
     volPtr->setPhysicalBBox(physicalMin, physicalMax);
 
-    volPtr->set_n_slice(256 - _volIndex);
+    //volPtr->set_n_slice(256 - _volIndex);
     // volPtr->set_n_slice(512- _volIndex);
+    // TBD..
+    volPtr->set_n_slice(256);
     volPtr->disable_cutplane(0);
     volPtr->disable_cutplane(1);

trunk/packages/vizservers/nanovis/FlowCmd.h

@@ -169 +169 @@
                                          * flow.  This isn't the same thing as
                                          * a normal volume displayed. */
-    int _volIndex;                      /* The index of slot in the volume
+    int _volDataID;                     /* The index of slot in the volume
                                          * vector. -1 indicates that a slot
                                          * hasn't been previously allocated.

trunk/packages/vizservers/nanovis/R2/include/R2/R2Object.h

@@ -37 +37 @@
         --_referenceCount;
     }
-    delete this;
+
+    if (_referenceCount <= 0) delete this;
 }
 

trunk/packages/vizservers/nanovis/TransferFunction.cpp

@@ -51 +51 @@
 TransferFunction::update(int size, float *data)
 {
-    assert((size*4) == _size);
+    // TBD..
+    //assert((size*4) == _size);
     update(data);
 }

trunk/packages/vizservers/nanovis/TransferFunction.h

@@ -20 +20 @@
 
 #include "Texture1D.h"
+#include <R2/R2Object.h>
 
 
-class TransferFunction{
+class TransferFunction : public R2Object {
     int _size;                  //the resolution of the color map, how many
                                 //(RGBA) quadraples
@@ -28 +29 @@
     Texture1D* _tex;            //the texture storing the colors 
     
+protected :
+    ~TransferFunction();
 public:
     GLuint id;                  //OpenGL's texture identifier
 
     TransferFunction(int size, float *data);
-    ~TransferFunction();
     void update(float *data);
     void update(int size, float *data);
@@ -41 +43 @@
         return _data; 
     }
+    int getSize() const;
 };
 
+inline int TransferFunction::getSize() const
+{
+    return _size;
+}
 #endif

trunk/packages/vizservers/nanovis/Volume.cpp

@@ -46 +46 @@
     iso_surface(0)
 {
+    _volumeDataID = -1;
+
     tex = new Texture3D(w, h, d, NVIS_FLOAT, NVIS_LINEAR_INTERP, n);
     int fcount = width * height * depth * n_components;

trunk/packages/vizservers/nanovis/Volume.h

@@ -25 +25 @@
 #include "Vector3.h"
 #include "AxisRange.h"
+#include "R2/R2Object.h"
 
 struct CutPlane{
@@ -39 +40 @@
 enum {CUBIC, VOLQD, ZINCBLENDE};
 
-class Volume {
+class Volume : public R2Object {
 public:
+    int                         _volumeDataID;
+
     int width;                  // The resolution of the data (how many points
                                 // in each direction.
@@ -103 +106 @@
     int iso_surface;
 
+public :
     Volume(float x, float y, float z, int width, int height, int depth, 
            float size, int n_component, float* data, double vmin, double vmax, 
            double nonzero_min);
 
-  
+protected :
     ~Volume();
         
+public :
     void visible(bool value) { 
         enabled = value; 
@@ -183 +188 @@
     Vector3& getPhysicalBBoxMin();
     Vector3& getPhysicalBBoxMax();
+
+    void setDataID(int id);
+    int getDataID() const;
 };
 
@@ -314 +322 @@
 }
 
+inline void 
+Volume::setDataID(int id)
+{
+        _volumeDataID = id;
+}
+
+inline int 
+Volume::getDataID() const
+{
+        return _volumeDataID;
+}
+
 #endif

trunk/packages/vizservers/nanovis/VolumeInterpolator.cpp

@@ -120 +120 @@
     _volumes.clear();
 
-    if (_volume) delete _volume;
+    if (_volume) _volume->unref();
 }
 

trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

@@ -29 +29 @@
 
 VolumeRenderer::VolumeRenderer():
-  n_volumes(0),
   slice_mode(false),
   volume_mode(true)
 {
-    volume.clear();
-    tf.clear(); 
+    volumes.clear();
 
     init_shaders();
@@ -50 +48 @@
 VolumeRenderer::~VolumeRenderer()
 {
+    remove_all_volumes();
+
     delete _zincBlendeShader;
     delete _regularVolumeShader;
@@ -76 +76 @@
 }
 
-
-int 
-VolumeRenderer::add_volume(Volume* _vol, TransferFunction* _tf)
-{
-  volume.push_back(_vol);
-  tf.push_back(_tf);
-
-  int ret = n_volumes;
-  n_volumes++;
-  return ret;
+void 
+VolumeRenderer::remove_all_volumes()
+{
+    vector<VolumeData*>::iterator iter;
+    for (iter = volumes.begin(); iter != volumes.end(); ++iter)
+    {
+        delete (*iter);
+    }
+    volumes.clear();
+}
+
+void 
+VolumeRenderer::add_volume(Volume* vol, TransferFunction* tf)
+{
+    VolumeData * volData = new VolumeData(vol, tf); 
+    volumes.push_back(volData);
+    printf("volume[%d] added\n", volData->volume->getDataID());
 }
 
@@ -99 +106 @@
  */
 void
-VolumeRenderer::remove_volume(size_t volIndex)
-{
-    vector<Volume *>::iterator vIter;
-    vector<TransferFunction *>::iterator tfIter;
-
-    assert(volIndex < volume.size());
-    assert(volIndex < tf.size());
-
-    vIter = volume.begin();
-    tfIter = tf.begin();
-    size_t i;
-    for (i = 0; i < volIndex; i++) {
-        tfIter++;
-        vIter++;
-    }
-    volume.erase(vIter);
-    tf.erase(tfIter);
-    n_volumes--;
+VolumeRenderer::remove_volume(size_t volDataID)
+{
+    std::vector<VolumeData*>::iterator iter;
+    for (iter = volumes.begin(); iter != volumes.end(); ++iter)
+    {
+        if ((*iter)->volume->getDataID() == volDataID)
+        {
+                delete (*iter);
+                volumes.erase(iter);
+                break;
+        }
+    }
 }
 
@@ -122 +123 @@
 VolumeRenderer::shade_volume(Volume* _vol, TransferFunction* _tf)
 {
-    for (unsigned int i=0; i < volume.size(); i++) {
-        if (volume[i] == _vol) {
-            tf[i] = _tf;
-        }
-    }
-}
+    if (_vol == 0) printf("shade volume : null vol parameter\n");
+    for (unsigned int i=0; i < volumes.size(); i++) {
+        if (volumes[i]->volume == _vol) {
+            if (_tf != volumes[i]->tf)
+            {
+                _tf->ref();
+
+                if (volumes[i]->tf)
+                    volumes[i]->tf->unref();
+
+                volumes[i]->tf = _tf;
+                printf("transfer function changed [volid %d]\n", volumes[i]->volume->getDataID());
+            }
+        }
+    }
+}
+
 
 TransferFunction*
 VolumeRenderer::get_volume_shading(Volume* _vol)
 {
-    for (unsigned int i=0; i < volume.size(); i++) {
-        if (volume[i] == _vol) {
-            return tf[i];
+    for (unsigned int i=0; i < volumes.size(); i++) {
+        if (volumes[i]->volume == _vol) {
+            return volumes[i]->tf;
         }
     }
     return NULL;
 }
+
 
 struct SortElement {
@@ -193 +206 @@
     TransferFunction* ani_tf = 0;
     int total_rendered_slices = 0;
-    int num_volumes = n_volumes;
+    int num_volumes = volumes.size();
 
     if (_volumeInterpolator->is_started()) {
         ++num_volumes;
-        ani_tf = tf[_volumeInterpolator->getReferenceVolumeID()];
+        ani_tf = volumes[_volumeInterpolator->getReferenceVolumeID()]->tf;
         ani_vol = _volumeInterpolator->getVolume();
     }
@@ -206 +219 @@
     int* actual_slices = new int[num_volumes]; 
 
-    for(int vol_index = 0; vol_index< num_volumes; vol_index++) {
+
+    Volume* vol;
+    int vol_index = 0;
+    std::vector<VolumeData*>::iterator iter;
+    for (iter = volumes.begin(); iter != volumes.end(); ++iter, ++vol_index) {
         cur_vol = NULL;
         cur_tf = NULL;
 #ifdef notdef
         if (vol_index != n_volumes) {
-            cur_vol = volume[vol_index];
-            cur_tf = tf[vol_index];
+            cur_vol = (*iter)->volume;
+            cur_tf = (*iter)->tf;
         } else {
             cur_vol = ani_vol;
@@ -218 +235 @@
         }
 #else
-        cur_vol = volume[vol_index];
-        cur_tf = tf[vol_index];
+        cur_vol = (*iter)->volume;
+        cur_tf = (*iter)->tf;
 #endif
 
@@ -226 +243 @@
 
         if(!cur_vol->visible()) {
+            //printf("volume [%d] skipped\n", cur_vol->getDataID());
             continue; //skip this volume
         }
@@ -474 +492 @@
         ConvexPolygon* cur = polys[volume_index][slice_index];
         
+#ifdef notdef
         if (volume_index == n_volumes) {
             cur_vol = ani_vol;
             cur_tf = ani_tf;
         } else {
-            cur_vol = volume[volume_index];
-            cur_tf = tf[volume_index];
+            cur_vol = volumes[volume_index]->volume;
+            cur_tf = volumes[volume_index]->tf;
         }
+#else
+        cur_vol = volumes[volume_index]->volume;
+        cur_tf = volumes[volume_index]->tf;
+#endif
         
         
@@ -516 +539 @@
 }
 
-void VolumeRenderer::render(int volume_index)
-{
-  int n_slices = volume[volume_index]->get_n_slice();
+void VolumeRenderer::render(int volDataID)
+{
+    Volume* vol = 0;
+    TransferFunction* tf = 0;
+    std::vector<VolumeData*>::iterator iter;
+    for (iter = volumes.begin(); iter != volumes.end(); ++iter)
+    {
+        if ((*iter)->volume && ((*iter)->volume->getDataID() == volDataID))
+        {
+            vol = (*iter)->volume;
+            tf = (*iter)->tf;
+            break;
+        }
+    }
+
+    if (vol == 0) return;
+
+  int n_slices = vol->get_n_slice();
 
   //volume start location
-  Vector4 shift_4d(volume[volume_index]->location.x, 
-                   volume[volume_index]->location.y, 
-                   volume[volume_index]->location.z, 0);
+  Vector4 shift_4d(vol->location.x, 
+                   vol->location.y, 
+                   vol->location.z, 0);
 
   double x0 = 0;
@@ -545 +583 @@
   glPushMatrix();
 
-  glScalef(volume[volume_index]->aspect_ratio_width, 
-          volume[volume_index]->aspect_ratio_height, 
-          volume[volume_index]->aspect_ratio_depth);
+  glScalef(vol->aspect_ratio_width, 
+          vol->aspect_ratio_height, 
+          vol->aspect_ratio_depth);
 
   glEnable(GL_DEPTH_TEST);
@@ -562 +600 @@
   glPushMatrix();
   glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
-  glScalef(volume[volume_index]->aspect_ratio_width, 
-          volume[volume_index]->aspect_ratio_height, 
-          volume[volume_index]->aspect_ratio_depth);
+  glScalef(vol->aspect_ratio_width, 
+          vol->aspect_ratio_height, 
+          vol->aspect_ratio_depth);
   GLfloat mv_trans[16];
   glGetFloatv(GL_MODELVIEW_MATRIX, mv_trans);
@@ -572 +610 @@
 
   //draw volume bounding box
-  if (volume[volume_index]->outline()) {
+  if (vol->outline()) {
       draw_bounding_box(x0, y0, z0, x0+1, y0+1, z0+1, 0.8, 0.1, 0.1, 1.5);
   }
@@ -605 +643 @@
 
   //render the cut planes
-  for(int i=0; i<volume[volume_index]->get_cutplane_count(); i++){
-    float offset = volume[volume_index]->get_cutplane(i)->offset;
-    int axis = volume[volume_index]->get_cutplane(i)->orient;
+  for(int i=0; i<vol->get_cutplane_count(); i++){
+    float offset = vol->get_cutplane(i)->offset;
+    int axis = vol->get_cutplane(i)->orient;
 
     if (axis==1) {
@@ -651 +689 @@
 
     glPushMatrix();
-    glScalef(volume[volume_index]->aspect_ratio_width, volume[volume_index]->aspect_ratio_height, volume[volume_index]->aspect_ratio_depth);
-
-    activate_volume_shader(volume[volume_index], tf[volume_index], true);
+    glScalef(vol->aspect_ratio_width, vol->aspect_ratio_height, vol->aspect_ratio_depth);
+
+    activate_volume_shader(vol, tf, true);
     glPopMatrix();
 
@@ -699 +737 @@
 
     glPushMatrix();
-    glScalef(volume[volume_index]->aspect_ratio_width, volume[volume_index]->aspect_ratio_height, volume[volume_index]->aspect_ratio_depth);
+    glScalef(vol->aspect_ratio_width, vol->aspect_ratio_height, vol->aspect_ratio_depth);
     
    /* 
@@ -713 +751 @@
     */
     
-    activate_volume_shader(volume[volume_index], tf[volume_index], true);
+    activate_volume_shader(vol, tf, true);
     glPopMatrix();
 
@@ -919 +957 @@
 void VolumeRenderer::switch_volume_mode() { volume_mode = (!volume_mode); }
 
-void VolumeRenderer::enable_volume(int index){
-  volume[index]->visible(true);
-}
-
-void VolumeRenderer::disable_volume(int index){
-  volume[index]->visible(false);
+void VolumeRenderer::enable_volume(int volDataID)
+{
+   printf("enable volume [%d]\n", volDataID);
+   std::vector<VolumeData*>::iterator iter;
+   for (iter = volumes.begin(); iter != volumes.end(); ++iter)
+   {
+       if ((*iter)->volume && ((*iter)->volume->getDataID() == volDataID))
+       {
+          (*iter)->volume->visible(true);
+          printf("volume [%d] is visible\n", volDataID);
+       }
+   }
+}
+
+void VolumeRenderer::disable_volume(int volDataID)
+{
+   printf("disable volume [%d]\n", volDataID);
+   std::vector<VolumeData*>::iterator iter;
+   for (iter = volumes.begin(); iter != volumes.end(); ++iter)
+   {
+       if ((*iter)->volume && ((*iter)->volume->getDataID() == volDataID))
+       {
+          (*iter)->volume->visible(false);
+          printf("volume [%d] is visible\n", volDataID);
+       }
+   }
 }
 

trunk/packages/vizservers/nanovis/VolumeRenderer.h

@@ -39 +39 @@
 #include "VolumeInterpolator.h"
 
+class VolumeData {
+        friend class VolumeRenderer;
+        friend class NanoVis;
+private :
+        Volume* volume;
+        TransferFunction* tf;
+public :
+        VolumeData() : volume(0), tf(0) {}
+        VolumeData(Volume* vol, TransferFunction* t) : volume(vol), tf(t) 
+        {
+                if (volume) volume->ref();
+                if (tf) tf->ref();
+        }
+        ~VolumeData()
+        {
+                if (volume) volume->unref();
+                if (tf) tf->unref();
+        }
+};
+
 class VolumeRenderer {
     friend class NanoVis;
 private:
-    std::vector <Volume*> volume;           //!<- array of volumes
-    std::vector <TransferFunction*> tf;    //!<- array of corresponding transfer functions 
+    std::vector<VolumeData*> volumes;    //!<- array of volumes
     VolumeInterpolator* _volumeInterpolator;
-
-    int n_volumes;
 
     bool slice_mode;    //!<- enable cut planes
@@ -105 +122 @@
     ~VolumeRenderer();
 
-    int add_volume(Volume* _vol, TransferFunction* _tf); 
-    void remove_volume(size_t volIndex); 
+    void add_volume(Volume* _vol, TransferFunction* _tf); 
+    void remove_all_volumes();
+    void remove_volume(size_t volDataID); 
     // add a volume and its transfer function
     // we require a transfer function when a 
@@ -113 +131 @@
     TransferFunction* get_volume_shading(Volume* _vol); 
 
-    void render(int volume_index);
+    void render(int volumeID);
     void render_all();  //render all enabled volumes;
     void render_all_points(void); //render all enabled volumes;
@@ -122 +140 @@
     void switch_slice_mode(); //switch_cutplane_mode
     void switch_volume_mode();
-    void enable_volume(int index); //enable a volume
-    void disable_volume(int index); //disable a volume
+    void enable_volume(int volumeDataID); //enable a volume
+    void disable_volume(int volumeDataID); //disable a volume
 
     void clearAnimatedVolumeInfo(void) {

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -48 +48 @@
  */
 bool
-load_volume_stream2(Rappture::Outcome &result, int index, std::iostream& fin)
+load_volume_stream2(Rappture::Outcome &result, int volDataID, std::iostream& fin)
 {
     printf("load_volume_stream2\n");
@@ -174 +174 @@
         return false;
     }
+    Volume *volPtr = 0;
     if (isrect) {
         double dval[6];
@@ -246 +247 @@
         dz = nz;
         
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
                                       vmin, vmax, nzero_min);
         volPtr->xAxis.SetRange(x0, x0 + (nx * dx));
@@ -387 +387 @@
         }
         
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
                                       field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
@@ -406 +405 @@
     float dy0 = -0.5*dy/dx;
     float dz0 = -0.5*dz/dx;
-    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
+    if (volPtr) volPtr->move(Vector3(dx0, dy0, dz0));
+     printf("volume moved\n");
     return true;
 }
 
 bool
-load_volume_stream(Rappture::Outcome &result, int index, std::iostream& fin)
+load_volume_stream(Rappture::Outcome &result, int volDataID, std::iostream& fin)
 {
     printf("load_volume_stream\n");
@@ -527 +527 @@
         return false;
     }
+    Volume *volPtr = 0;
     if (isrect) {
         Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
@@ -650 +651 @@
         }
 #endif  
-        fprintf(stdout,"End Data Stats index = %i\n",index);
+        fprintf(stdout,"End Data Stats DataID = %i\n",volDataID);
         fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);
         fprintf(stdout,"dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
@@ -656 +657 @@
         fflush(stdout);
         
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
                                       field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
@@ -802 +802 @@
         }
         
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
                                       field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
@@ -834 +833 @@
     float dy0 = -0.5*dy/dx;
     float dz0 = -0.5*dz/dx;
-    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
+    if (volPtr) volPtr->move(Vector3(dx0, dy0, dz0));
     return true;
 }
@@ -840 +839 @@
 
 bool
-load_volume_stream_insoo(Rappture::Outcome &result, int index, 
+load_volume_stream_insoo(Rappture::Outcome &result, int volDataID, 
                          std::iostream& fin)
 {
@@ -958 +957 @@
     }
 
+    Volume* volPtr = 0;
     if (isrect) {
         Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
@@ -1121 +1121 @@
             }
 
-            fprintf(stdout,"End Data Stats index = %i\n",index);
+            fprintf(stdout,"End Data Stats volDataID = %i\n",volDataID);
             fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);
             fprintf(stdout,"dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
@@ -1128 +1128 @@
             */
 
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
                                       field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
@@ -1276 +1275 @@
         }
         
-        Volume *volPtr;
-        volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
                                       field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
@@ -1308 +1306 @@
     float dy0 = -0.5*dy/dx;
     float dz0 = -0.5*dz/dx;
-    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
+    if (volPtr) volPtr->move(Vector3(dx0, dy0, dz0));
     return true;
 }

trunk/packages/vizservers/nanovis/dxReader2.cpp

@@ -17 +17 @@
  */
 bool
-load_volume_stream_odx(Rappture::Outcome &context, int index, const char *buf,
+load_volume_stream_odx(Rappture::Outcome &context, int userID, const char *buf,
                        int nBytes)
 {
@@ -88 +88 @@
     computeSimpleGradient(data, nx, ny, nz);
 
-    fprintf(stdout,"End Data Stats index = %i\n",index);
+    fprintf(stdout,"End Data Stats userID = %i\n",userID);
     fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);
     fprintf(stdout,"dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
@@ -95 +95 @@
 
     Volume *volPtr;
-    volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, 
+    volPtr = NanoVis::load_volume(userID, nx, ny, nz, 4, data, 
                                   dxObj.dataMin(), 
                                   dxObj.dataMax(), 
@@ -116 +116 @@
     float dy0 = -0.5*dy/dx;
     float dz0 = -0.5*dz/dx;
-    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
+    volPtr->move(Vector3(dx0, dy0, dz0));
     return true;
 }

trunk/packages/vizservers/nanovis/nanovis.cpp

@@ -106 +106 @@
 int NanoVis::updir = Y_POS;
 NvCamera* NanoVis::cam = NULL;
-int NanoVis::n_volumes = 0;
-vector<Volume*> NanoVis::volume;
+NanoVis::VolumeMap NanoVis::volumeMap;
+int  NanoVis::_last_data_id = 0;
 vector<HeightMap*> NanoVis::heightMap;
 VolumeRenderer* NanoVis::vol_renderer = 0;
@@ -514 +514 @@
  */
 Volume *
-NanoVis::load_volume(int index, int width, int height, int depth,
+NanoVis::load_volume(int volDataID, int width, int height, int depth,
                      int n_component, float* data, double vmin,
                      double vmax, double nzero_min)
 {
-    while (n_volumes <= index) {
-        volume.push_back(NULL);
-        n_volumes++;
-    }
-
-    Volume* vol = volume[index];
-    if (vol != NULL) {
-        volume[index] = NULL;
-
-        if (vol->pointsetIndex != -1) {
-            if (((unsigned  int) vol->pointsetIndex) < pointSet.size() &&
-                pointSet[vol->pointsetIndex] != NULL) {
-                delete pointSet[vol->pointsetIndex];
-                pointSet[vol->pointsetIndex] = 0;
+    NanoVis::VolumeMap::iterator iter  = volumeMap.find(volDataID);
+    if (iter != volumeMap.end())
+    {
+        Volume* vol = iter->second;
+        if (vol != NULL) 
+        {
+            iter->second = NULL;
+
+            if (vol->pointsetIndex != -1) 
+            {
+                // TBD
+                /*
+                if (((unsigned  int) vol->pointsetIndex) < pointSet.size() &&
+                    pointSet[vol->pointsetIndex] != NULL) {
+                    delete pointSet[vol->pointsetIndex];
+                    pointSet[vol->pointsetIndex] = 0;
+                }
+                */
             }
         }
-        delete vol;
-    }
-    volume[index] = new Volume(0.f, 0.f, 0.f, width, height, depth, 1.,
+        vol->unref();
+    }
+
+    Volume* newVol = new Volume(0.f, 0.f, 0.f, width, height, depth, 1.,
                                n_component, data, vmin, vmax, nzero_min);
-    fprintf(stderr, "VOLINDEX=%d, n_volumes=%d\n", index, n_volumes);
-    return volume[index];
+    newVol->setDataID(volDataID);
+    volumeMap[volDataID] = newVol;
+    
+    
+    fprintf(stderr, "VOLID=%d, # of volumes=%d\n", volDataID, volumeMap.size());
+    return newVol;
 }
 
@@ -1538 +1547 @@
     xMin = yMin = zMin = wMin = DBL_MAX;
     xMax = yMax = zMax = wMax = -DBL_MAX;
-    for (unsigned int i = 0; i < volume.size(); i++) {
-        Volume *volPtr;
-
-        volPtr = volume[i];
+    NanoVis::VolumeMap::iterator iter;
+    for (iter = volumeMap.begin(); iter != volumeMap.end(); ++iter)
+    {
+        Volume *volPtr = iter->second;
+
         if (volPtr == NULL) {
             continue;
@@ -2546 +2556 @@
     return TCL_OK;
 }
+
+int NanoVis::generate_data_identifier()
+{
+    return _last_data_id++;
+}
+
+void NanoVis::remove_volume(int volDataID)
+{
+
+    NanoVis::VolumeMap::iterator iter  = volumeMap.find(volDataID);
+    if (iter != volumeMap.end())
+    {
+        (*iter).second->unref();
+        volumeMap.erase(iter);
+    }
+}

trunk/packages/vizservers/nanovis/nanovis.h

@@ -109 +109 @@
     static NVISid final_fbo, final_color_tex, final_depth_rb;
 public:
+    typedef std::map<int, Volume*> VolumeMap;
+public:
     static VolumeRenderer* vol_renderer;
     static PointSetRenderer* pointset_renderer;
@@ -128 +130 @@
     static vector<HeightMap*> heightMap;
     static unsigned char* screen_buffer;
-    static vector<Volume*> volume;
+    static VolumeMap volumeMap;
     static vector<NvVectorField*> flow;
     static Grid* grid;
@@ -152 +154 @@
     static Tcl_DString cmdbuffer;
 
+    static int _last_data_id;
+public :
     static TransferFunction* get_transfunc(const char *name);
     static TransferFunction* DefineTransferFunction(const char *name, 
@@ -179 +183 @@
     static int render_legend(TransferFunction *tf, double min, double max, 
         int width, int height, const char* volArg);
-    static Volume *load_volume(int index, int width, int height, int depth, 
+    static Volume *load_volume(int volDataID, int width, int height, int depth, 
         int n, float* data, double vmin, double vmax, double nzero_min);
     static void xinetd_listen(void);
@@ -228 +232 @@
     };
     static void EventuallyRedraw(unsigned int flag = 0);
+    static void remove_volume(int volUserID);
+    static int generate_data_identifier();
 };