Changeset 1493 for trunk/packages

Timestamp:

Jun 8, 2009, 8:31:59 AM (15 years ago)

Author:

gah

Message:

Changed vector id to name

Location:

trunk/packages/vizservers/nanovis

Files:

• Command.cpp (modified) (31 diffs)
• FlowCmd.cpp (modified) (6 diffs)
• FlowCmd.h (modified) (1 diff)
• HeightMap.cpp (modified) (11 diffs)
• HeightMap.h (modified) (2 diffs)
• NvColorTableShader.h (modified) (1 diff)
• PlaneRenderer.cpp (modified) (3 diffs)
• TransferFunction.cpp (modified) (1 diff)
• TransferFunction.h (modified) (2 diffs)
• VelocityArrowsSlice.cpp (modified) (1 diff)
• VelocityArrowsSlice.h (modified) (2 diffs)
• Volume.cpp (modified) (2 diffs)
• Volume.h (modified) (3 diffs)
• VolumeInterpolator.cpp (modified) (2 diffs)
• VolumeRenderer.cpp (modified) (11 diffs)
• VolumeRenderer.h (modified) (1 diff)
• dxReader.cpp (modified) (37 diffs)
• dxReader2.cpp (modified) (7 diffs)
• nanovis.cpp (modified) (10 diffs)
• nanovis.h (modified) (5 diffs)

trunk/packages/vizservers/nanovis/Command.cpp

@@ -91 +91 @@
 extern Texture2D* plane[10];
 
-extern bool load_volume_stream(Rappture::Outcome &status, int index, 
-                        std::iostream& fin);
-extern bool load_volume_stream_odx(Rappture::Outcome &status, int index, 
-        const char *buf, int nBytes);
-extern bool load_volume_stream2(Rappture::Outcome &status, int index, 
-        std::iostream& fin);
-
-extern bool load_vector_stream(Rappture::Outcome &result, int index, 
-        size_t length, char *bytes);
-extern bool load_vector_stream2(Rappture::Outcome &result, int index, 
-        size_t length, char *bytes);
-extern bool MakeVectorFieldFromUnirect3d(Rappture::Outcome &result, 
-        Rappture::Unirect3d &data);
-
-extern void load_volume(int index, int width, int height, int depth,
-            int n_component, float* data, double vmin, double vmax,
-            double nzero_min);
 // Tcl interpreter for incoming messages
 
@@ -301 +284 @@
     hmPtr = new HeightMap();
     hmPtr->setHeight(xMin, yMin, xMax, yMax, xNum, yNum, heights);
-    hmPtr->setColorMap(NanoVis::get_transfunc("default"));
+    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
     hmPtr->setVisible(true);
     hmPtr->setLineContourVisible(true);
@@ -353 +336 @@
     hmPtr = NanoVis::heightMap[index];
     if (hmPtr == NULL) {
-        Tcl_AppendResult(interp, "no heightmap defined for index \"",
-                         Tcl_GetString(objPtr), "\"", (char*)NULL);
-        return TCL_ERROR;
+        if (interp != NULL) {
+            Tcl_AppendResult(interp, "no heightmap defined for index \"",
+                             Tcl_GetString(objPtr), "\"", (char*)NULL);
+        }
+        return TCL_ERROR;
     }
     *hmPtrPtr = hmPtr;
@@ -361 +346 @@
 }
 
+
 /*
  * ----------------------------------------------------------------------
- * FUNCTION: GetVolumeDataID
+ * FUNCTION: GetVolumeFromObj
  *
  * Used internally to decode a series of volume index values and
@@ -375 +361 @@
  */
 static int
-GetVolumeIndex(Tcl_Interp *interp, Tcl_Obj *objPtr, unsigned int *idPtr)
-{
-    int index;
-    if (Tcl_GetIntFromObj(interp, objPtr, &index) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    if (index < 0) {
-        Tcl_AppendResult(interp, "can't have negative index \"",
-                         Tcl_GetString(objPtr), "\"", (char*)NULL);
-        return TCL_ERROR;
-    }
-    if (index >= (int)NanoVis::volumes.size()) {
-        Tcl_AppendResult(interp, "index \"", Tcl_GetString(objPtr),
-                         "\" is out of range", (char*)NULL);
-        return TCL_ERROR;
-    }
-    if (NanoVis::volumes[index] == NULL) {
-        Tcl_AppendResult(interp, "can't find volume \"", Tcl_GetString(objPtr),
-                     "\"", (char*)NULL);
-        return TCL_ERROR;
-    }
-    *idPtr = (unsigned int)index;
+GetVolumeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Volume **volPtrPtr)
+{
+    const char *string;
+    string = Tcl_GetString(objPtr);
+
+    Tcl_HashEntry *hPtr;
+    hPtr = Tcl_FindHashEntry(&NanoVis::volumeTable, string);
+    if (hPtr == NULL) {
+        if (interp != NULL) {
+            Tcl_AppendResult(interp, "can't find a volume name \"",
+                         string, "\"", (char*)NULL);
+        }
+        return TCL_ERROR;
+    }
+    *volPtrPtr = (Volume *)Tcl_GetHashValue(hPtr);
     return TCL_OK;
 }
@@ -402 +381 @@
 /*
  * ----------------------------------------------------------------------
- * FUNCTION: GetVolumeFromObj
+ * FUNCTION: GetVolumes()
  *
  * Used internally to decode a series of volume index values and
@@ -414 +393 @@
  */
 static int
-GetVolumeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Volume **volPtrPtr)
-{
-    unsigned int index;
-    if (GetVolumeIndex(interp, objPtr, &index) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    Volume *volPtr;
-    volPtr = NanoVis::volumes[index];
-    if (volPtr == NULL) {
-        Tcl_AppendResult(interp, "no volume defined for index \"",
-                         Tcl_GetString(objPtr), "\"", (char*)NULL);
-        return TCL_ERROR;
-    }
-    *volPtrPtr = volPtr;
-    return TCL_OK;
-}
-
-/*
- * ----------------------------------------------------------------------
- * FUNCTION: GetVolumeIndices()
- *
- * Used internally to decode a series of volume index values and
- * store then in the specified vector.  If there are no volume index
- * arguments, this means "all volumes" to most commands, so all
- * active volume indices are stored in the vector.
- *
- * Updates pushes index values into the vector.  Returns TCL_OK or
- * TCL_ERROR to indicate an error.
- * ----------------------------------------------------------------------
- */
-static int
-GetVolumeIndices(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
-                 vector<unsigned int>* vectorPtr)
-{
-    if (objc == 0) {
-        vector<Volume *>::iterator iter;
-        for (iter = NanoVis::volumes.begin(); iter != NanoVis::volumes.end(); 
-             ++iter) {
-            if ((*iter) != NULL) {
-                vectorPtr->push_back((*iter)->dataID());
-            }
-        }
-    } else {
-        vector<Volume *>::iterator iter;
-        for (int n = 0; n < objc; n++) {
-            unsigned int index;
-
-            if (GetVolumeIndex(interp, objv[n], &index) != TCL_OK) {
-                return TCL_ERROR;
-            }
-            if (NanoVis::volumes[index] != NULL) {
-                vectorPtr->push_back(index);
-            }
-        }
-    }
-    return TCL_OK;
-}
-
-/*
- * ----------------------------------------------------------------------
- * FUNCTION: GetVolumes()
- *
- * Used internally to decode a series of volume index values and
- * store then in the specified vector.  If there are no volume index
- * arguments, this means "all volumes" to most commands, so all
- * active volume indices are stored in the vector.
- *
- * Updates pushes index values into the vector.  Returns TCL_OK or
- * TCL_ERROR to indicate an error.
- * ----------------------------------------------------------------------
- */
-static int
 GetVolumes(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
            vector<Volume *>* vectorPtr)
@@ -491 +398 @@
     if (objc == 0) {
         // No arguments. Get all volumes. 
-        vector<Volume *>::iterator iter;
-        for (iter = NanoVis::volumes.begin(); iter != NanoVis::volumes.end(); 
-             ++iter) {
-            if ((*iter) != NULL) {
-                vectorPtr->push_back((*iter));
-            }
-        }
+        Tcl_HashSearch iter;
+        Tcl_HashEntry *hPtr;
+        for (hPtr = Tcl_FirstHashEntry(&NanoVis::volumeTable, &iter); 
+             hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+            Volume *volPtr;
+            volPtr = (Volume *)Tcl_GetHashValue(hPtr);
+            vectorPtr->push_back(volPtr);
+        }
     } else {
         // Get the volumes associated with the given index arguments.
@@ -947 +855 @@
     }
 
-    const char *string = Tcl_GetString(objv[1]);
+    const char *name;
+    name = Tcl_GetString(objv[1]);
     TransferFunction *tf;
-    tf = NanoVis::get_transfunc(string);
+    tf = NanoVis::get_transfunc(name);
     if (tf == NULL) {
-        Tcl_AppendResult(interp, "unknown transfer function \"", string, "\"",
+        Tcl_AppendResult(interp, "unknown transfer function \"", name, "\"",
                              (char*)NULL);
         return TCL_ERROR;
     }
-    const char *label;
-    label = Tcl_GetString(objv[1]);
     int w, h;
     if ((Tcl_GetIntFromObj(interp, objv[2], &w) != TCL_OK) ||
@@ -965 +872 @@
         NanoVis::SetVolumeRanges();
     }
-    NanoVis::render_legend(tf, Volume::valueMin, Volume::valueMax, w, h, label);
+    NanoVis::render_legend(tf, Volume::valueMin, Volume::valueMax, w, h, name);
     return TCL_OK;
 }
@@ -1201 +1108 @@
     }
     Trace("parsing volume data identifier\n");
-    vector<Volume *>::iterator iter;
-    for (iter = volumes.begin(); iter != volumes.end(); iter++) {
-        Trace("volDataID: %d\n", (*iter)->dataID());
-        NanoVis::vol_renderer->addAnimatedVolume((*iter));
+    Tcl_HashSearch iter;
+    Tcl_HashEntry *hPtr;
+    for (hPtr = Tcl_FirstHashEntry(&NanoVis::volumeTable, &iter); hPtr != NULL;
+         hPtr = Tcl_NextHashEntry(&iter)) {
+        Volume *volPtr;
+        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
+        NanoVis::vol_renderer->addAnimatedVolume(volPtr);
     }
     return TCL_OK;
@@ -1272 +1182 @@
     fflush(stdout);
 
-    Volume *volPtr = 0;
-    int volDataID = -1;
-    if (strcmp(header, "<HDR>") == 0) {
+    Volume *volPtr;
+    volPtr = NULL;                      // Supress compiler warning.
+    if (strncmp(header, "<HDR>", 5) == 0) {
         printf("ZincBlende stream is in\n");
         fflush(stdout);
-        //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
+         //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
         //fdata.write(buf.bytes(),buf.size());
         //vol = NvZincBlendeReconstructor::getInstance()->loadFromStream(fdata);
@@ -1288 +1198 @@
         if (volPtr == NULL) {
             Tcl_AppendResult(interp, "can't get volume instance", (char *)NULL);
-            return TCL_OK;
+            return TCL_ERROR;
         }
         printf("finish loading\n");
@@ -1295 +1205 @@
         // INSOO
         // TBD..
-        volDataID = NanoVis::volumes.size();  // Next identifier available
+        // Next identifier available
         float dx0 = -0.5;
         float dy0 = -0.5*volPtr->height/volPtr->width;
         float dz0 = -0.5*volPtr->depth/volPtr->width;
         volPtr->location(Vector3(dx0, dy0, dz0));
-        volPtr->dataID(volDataID);
-        NanoVis::volumes.push_back(volPtr);
+        int isNew;
+        Tcl_HashEntry *hPtr;
+        hPtr = Tcl_CreateHashEntry(&NanoVis::volumeTable, tag, &isNew);
+        if (!isNew) {
+            Tcl_AppendResult(interp, "volume \"", tag, "\" already exists.",
+                             (char *)NULL);
+            return TCL_ERROR;
+        }
+        Tcl_SetHashValue(hPtr, volPtr);
+        volPtr->name(Tcl_GetHashKey(&NanoVis::volumeTable, hPtr));
 #if __TEST_CODE__
-    } else if (strcmp(header, "<FET>") == 0) {
+    } else if (strncmp(header, "<FET>", 5) == 0) {
         printf("FET loading...\n");
         fflush(stdout);
         std::stringstream fdata;
         fdata.write(buf.bytes(),buf.size());
-        if (!load_volume_stream3(err, n, fdata)) {
+        volPtr = load_volume_stream3(err, tag, fdata);
+        if (volPtr == NULL) {
             Tcl_AppendResult(interp, err.remark(), (char*)NULL);
             return TCL_ERROR;
         }
 #endif  /*__TEST_CODE__*/
-    } else if (strcmp(header, "<ODX>") == 0) {
+    } else if (strncmp(header, "<ODX>", 5) == 0) {
         /*
         Rappture::Outcome err;
@@ -1319 +1238 @@
         printf("Loading DX using OpenDX library...\n");
         fflush(stdout);
-        if (!load_volume_stream_odx(err, n, buf.bytes()+5, buf.size()-5)) {
+        volPtr = load_volume_stream_odx(err, n, buf.bytes()+5, buf.size()-5);
+        if (volPtr == NULL) {
             Tcl_AppendResult(interp, err.remark(), (char*)NULL);
             return TCL_ERROR;
@@ -1325 +1245 @@
         */
     } else {
-        printf("test\n");
-#ifdef notdef
-        Rappture::Unirect3d *dataPtr;
-
-        dataPtr = new Rappture::Unirect3d(1);
-        if (!dataPtr->ImportDx(result, 1, buf.size(), (char *)buf.bytes())) {
-            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
-            delete dataPtr;
-            return TCL_ERROR;
-        }
-#if !ISO_TEST
-        dataPtr->Resample(context, 30);
-#endif
-        volPtr = NanoVis::load_volume(-1, nx, ny, nz, 4, data, vmin, vmax,
-                                      nzero_min);
-    
-        volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMin() + (nx * dx));
-        volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMin() + (ny * dy));
-        volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMin() + (nz * dz));
-        volPtr->wAxis.SetRange(vmin, vmax);
-        volPtr->update_pending = true;
-        
-        flowPtr->SetData(dataPtr);
-#endif
         printf("OpenDX loading...\n");
         fflush(stdout);
         std::stringstream fdata;
-        fdata.write(buf.bytes(),buf.size());
+        fdata.write(buf.bytes(), buf.size());
         if (buf.size() <= 0) {
             fprintf(stderr, "data buffer is empty\n");
             abort();
         }
-        bool result;
         Rappture::Outcome context;
 #if ISO_TEST
-        result = load_volume_stream2(context, volPtr->dataID(), fdata);
+        volPtr = load_volume_stream2(context, tag, fdata);
 #else
-        result = load_volume_stream(context, volPtr->dataID(), fdata);
+        volPtr = load_volume_stream(context, tag, fdata);
 #endif
-        if (!result) {
+        if (volPtr == NULL) {
             Tcl_AppendResult(interp, context.remark(), (char*)NULL);
             return TCL_ERROR;
@@ -1379 +1274 @@
         //volPtr->n_slices(512-n);
         //volPtr->n_slices(256-n);
-        volPtr->n_slices(256);
         volPtr->disable_cutplane(0);
         volPtr->disable_cutplane(1);
@@ -1394 +1288 @@
 
         // 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, volDataID, volPtr->wAxis.min(), volPtr->wAxis.max(),
+        sprintf(info, "nv>data tag %s min %g max %g vmin %g vmax %g\n", tag, 
+                volPtr->wAxis.min(), volPtr->wAxis.max(),
                 Volume::valueMin, Volume::valueMax);
         nWritten  = write(0, info, strlen(info));
@@ -1440 +1334 @@
     }
     return (*proc) (clientData, interp, objc, objv);
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * VolumeDeleteOp --
+ *
+ *---------------------------------------------------------------------------
+ */
+/*ARGSUSED*/
+static int
+VolumeDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
+               Tcl_Obj *const *objv)
+{
+    int i;
+
+    for (i = 2; i < objc; i++) {
+        Volume *volPtr;
+
+        if (GetVolumeFromObj(interp, objv[i], &volPtr) != TCL_OK) {
+            return TCL_ERROR;
+        }
+        NanoVis::remove_volume(volPtr);
+    }
+    NanoVis::EventuallyRedraw();
+    return TCL_OK;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * VolumeExistsOp --
+ *
+ *---------------------------------------------------------------------------
+ */
+/*ARGSUSED*/
+static int
+VolumeExistsOp(ClientData clientData, Tcl_Interp *interp, int objc,
+               Tcl_Obj *const *objv)
+{
+    bool value;
+    Volume *volPtr;
+
+    value = false;
+    if (GetVolumeFromObj(NULL, objv[2], &volPtr) == TCL_OK) {
+        value = true;
+    }
+    Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (int)value);
+    return TCL_OK;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * VolumeNamesOp --
+ *
+ *---------------------------------------------------------------------------
+ */
+/*ARGSUSED*/
+static int
+VolumeNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
+              Tcl_Obj *const *objv)
+{
+    Tcl_Obj *listObjPtr;
+    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
+    Tcl_HashEntry *hPtr; 
+    Tcl_HashSearch iter;
+    for (hPtr = Tcl_FirstHashEntry(&NanoVis::volumeTable, &iter); hPtr != NULL; 
+         hPtr = Tcl_NextHashEntry(&iter)) {
+        Volume *volPtr;
+        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
+        Tcl_Obj *objPtr;
+        objPtr = Tcl_NewStringObj(volPtr->name(), -1);
+        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
+    }
+    Tcl_SetObjResult(interp, listObjPtr);
+    return TCL_OK;
 }
 
@@ -1585 +1556 @@
                          Tcl_Obj *const *objv)
 {
-    TransferFunction *tf;
+    TransferFunction *tfPtr;
     const char *name = Tcl_GetString(objv[3]);
-    tf = NanoVis::get_transfunc(name);
-    if (tf == NULL) {
+    tfPtr = NanoVis::get_transfunc(name);
+    if (tfPtr == NULL) {
         Tcl_AppendResult(interp, "transfer function \"", name,
                          "\" is not defined", (char*)NULL);
@@ -1599 +1570 @@
     vector<Volume *>::iterator iter;
     for (iter = ivol.begin(); iter != ivol.end(); iter++) {
-        (*iter)->transferFunction(tf);
+        Trace("setting %s with transfer function %s\n", (*iter)->name(),
+              tfPtr->name());
+        (*iter)->transferFunction(tfPtr);
 #ifdef POINTSET
         // TBD..
@@ -1687 +1660 @@
              Tcl_Obj *const *objv)
 {
-    Volume *volPtr;
-    size_t i;
-    
-    volPtr = NULL;
     // Find the first volume in the vector.
-    for (i = 0; i < NanoVis::volumes.size(); i++) {
-        if (NanoVis::volumes[i] != NULL) {
-            volPtr = NanoVis::volumes[i];
-            break;
-        }
-    }
-    if (volPtr != NULL) {
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+    hPtr = Tcl_FirstHashEntry(&NanoVis::volumeTable, &iter); 
+    if (hPtr != NULL) {
+        Volume *volPtr;
+        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
         volPtr->data_enabled(false);
         volPtr->visible(false);
@@ -1708 +1676 @@
     {"animation", 2, VolumeAnimationOp,   3, 0, "oper ?args?",},
     {"axis",      2, VolumeAxisOp,        4, 0, "label axis value ?indices?",},
-    {"data",      1, VolumeDataOp,        3, 0, "oper ?args?",},
+    {"data",      2, VolumeDataOp,        3, 0, "oper ?args?",},
+    {"delete",    2, VolumeDeleteOp,      3, 0, "?name...?",},
+    {"exists",    1, VolumeExistsOp,      3, 3, "name",},
+    {"names",     1, VolumeNamesOp,       2, 3, "?pattern?",},
     {"outline",   1, VolumeOutlineOp,     3, 0, "oper ?args?",},
     {"shading",   2, VolumeShadingOp,     3, 0, "oper ?args?",},
@@ -1751 +1722 @@
 // ============================= FLOW ==================================
 
-static int
-FlowDataFollowsOp(ClientData clientData, Tcl_Interp *interp, int objc,
-                    Tcl_Obj *const *objv)
-{
-    Rappture::Outcome result;
-
-    Trace("Flow Data Loading\n");
-
-    int nbytes;
-    if (Tcl_GetIntFromObj(interp, objv[3], &nbytes) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    int extents;
-    if (Tcl_GetIntFromObj(interp, objv[4], &extents) != TCL_OK) {
-        return TCL_ERROR;
-    }
-
-    Rappture::Buffer buf;
-    if (GetDataStream(interp, buf, nbytes) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    int n = NanoVis::n_volumes;
-    if (strncmp(buf.bytes(), "<DX>", 4) == 0) {
-        if (!load_vector_stream2(result, n, buf.size(), (char *)buf.bytes())) {
-            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
-            return TCL_ERROR;
-        }
-#ifdef notdef
-    } else if (strncmp(buf.bytes(), "<unirect3d>", 4) == 0) {
-
-        Rappture::Unirect3d data;
-        Tcl_CmdInfo cmdInfo;
-
-        /* Set the clientdata field of the unirect3d command to contain
-         * the local data structure. */
-        if (!Tcl_GetCommandInfo(interp, "unirect3d", &cmdInfo)) {
-            return TCL_ERROR;
-        }
-        data.extents(extents);
-        cmdInfo.objClientData = (ClientData)&data;      
-        Tcl_SetCommandInfo(interp, "unirect3d", &cmdInfo);
-        if (Tcl_Eval(interp, (const char *)buf.bytes()) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        if (!data.isInitialized()) {
-            return TCL_ERROR;
-        }
-        if (!MakeVectorFieldFromUnirect3d(result, data)) {
-            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
-            return TCL_ERROR;
-        }
-#endif
-    }
-
-    Volume *volPtr = NanoVis::volume[NanoVis::n_volumes];
-    //
-    // BE CAREFUL:  Set the number of slices to something
-    //   slightly different for each volume.  If we have
-    //   identical volumes at exactly the same position
-    //   with exactly the same number of slices, the second
-    //   volume will overwrite the first, so the first won't
-    //   appear at all.
-    //
-    volPtr->set_n_slice(256-n);
-    // volPtr->set_n_slice(512-n);
-    volPtr->disable_cutplane(0);
-    volPtr->disable_cutplane(1);
-    volPtr->disable_cutplane(2);
-    volPtr->transferFunction(NanoVis::get_transfunc("default"));
-
-    float dx0 = -0.5;
-    float dy0 = -0.5*volPtr->height/volPtr->width;
-    float dz0 = -0.5*volPtr->depth/volPtr->width;
-    volPtr->move(Vector3(dx0, dy0, dz0));
-    return TCL_OK;
-}
-
-static Rappture::CmdSpec flowDataOps[] = {
-    {"follows",   1, FlowDataFollowsOp, 4, 4, "size",},
-};
-static int nFlowDataOps = NumCmdSpecs(flowDataOps);
-
-static int
-FlowDataOp(ClientData clientData, Tcl_Interp *interp, int objc,
-             Tcl_Obj *const *objv)
-{
-    Tcl_ObjCmdProc *proc;
-
-    proc = Rappture::GetOpFromObj(interp, nFlowDataOps, flowDataOps,
-                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
-    if (proc == NULL) {
-        return TCL_ERROR;
-    }
-    return (*proc) (clientData, interp, objc, objv);
-}
 
 // INSOO
@@ -2290 +2166 @@
     hmPtr->setHeight(grid.xMin(), grid.yMin(), grid.xMax(), grid.yMax(), 
                      grid.xNum(), grid.yNum(), grid.acceptValues());
-    hmPtr->setColorMap(NanoVis::get_transfunc("default"));
+    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
     hmPtr->setVisible(true);
     hmPtr->setLineContourVisible(true);
@@ -2431 +2307 @@
         return TCL_ERROR;
     }
-    TransferFunction *tf;
-    tf = hmPtr->getColorMap();
-    if (tf == NULL) {
+    TransferFunction *tfPtr;
+    tfPtr = hmPtr->transferFunction();
+    if (tfPtr == NULL) {
         Tcl_AppendResult(interp, "no transfer function defined for heightmap \"",
                          Tcl_GetString(objv[2]), "\"", (char*)NULL);
@@ -2447 +2323 @@
     }
 
-    NanoVis::render_legend(tf, HeightMap::valueMin, HeightMap::valueMax, w, h,
-       "label");
+    NanoVis::render_legend(tfPtr, HeightMap::valueMin, HeightMap::valueMax, 
+                w, h, "label");
     return TCL_OK;
 }
@@ -2521 +2397 @@
     float maxy = 3.5f;
     hmPtr->setHeight(minx, miny, maxx, maxy, 20, 20, data);
-    hmPtr->setColorMap(NanoVis::get_transfunc("default"));
+    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
     hmPtr->setVisible(true);
     hmPtr->setLineContourVisible(true);
@@ -2541 +2417 @@
     const char *name;
     name = Tcl_GetString(objv[2]);
-    TransferFunction *tf;
-    tf = NanoVis::get_transfunc(name);
-    if (tf == NULL) {
+    TransferFunction *tfPtr;
+    tfPtr = NanoVis::get_transfunc(name);
+    if (tfPtr == NULL) {
         Tcl_AppendResult(interp, "transfer function \"", name,
                          "\" is not defined", (char*)NULL);
@@ -2554 +2430 @@
     vector<HeightMap *>::iterator iter;
     for (iter = imap.begin(); iter != imap.end(); iter++) {
-        (*iter)->setColorMap(tf);
+        (*iter)->transferFunction(tfPtr);
     }
     return TCL_OK;
@@ -2905 +2781 @@
     Tcl_CreateObjCommand(interp, "test", TestCmd, NULL, NULL);
 #endif
-
+    Tcl_InitHashTable(&NanoVis::volumeTable, TCL_STRING_KEYS);
     // create a default transfer function
     if (Tcl_Eval(interp, def_transfunc) != TCL_OK) {

trunk/packages/vizservers/nanovis/FlowCmd.cpp

@@ -53 +53 @@
 
 Rappture::SwitchSpec FlowCmd::_switches[] = {
+    {Rappture::SWITCH_BOOLEAN, "-arrows", "boolean",
+        offsetof(FlowValues, showArrows), 0},
+    {Rappture::SWITCH_CUSTOM, "-axis", "axis",
+        offsetof(FlowValues, slicePos.axis), 0, 0, &axisSwitch},
+    {Rappture::SWITCH_FLOAT, "-diffuse", "value",
+        offsetof(FlowValues, diffuse), 0},
+    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
+        offsetof(FlowValues, isHidden), 0},
+    {Rappture::SWITCH_FLOAT, "-opacity", "value",
+        offsetof(FlowValues, opacity), 0},
+    {Rappture::SWITCH_BOOLEAN, "-outline", "boolean",
+        offsetof(FlowValues, showOutline), 0},
+    {Rappture::SWITCH_CUSTOM, "-position", "number",
+        offsetof(FlowValues, slicePos), 0, 0, &positionSwitch},
     {Rappture::SWITCH_BOOLEAN, "-slice", "boolean",
         offsetof(FlowValues, sliceVisible), 0},
-    {Rappture::SWITCH_CUSTOM, "-axis", "axis",
-        offsetof(FlowValues, slicePos.axis), 0, 0, &axisSwitch},
-    {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
-        offsetof(FlowValues, isHidden), 0},
-    {Rappture::SWITCH_CUSTOM, "-position", "number",
-        offsetof(FlowValues, slicePos), 0, 0, &positionSwitch},
+    {Rappture::SWITCH_FLOAT, "-specular", "value",
+        offsetof(FlowValues, specular), 0},
     {Rappture::SWITCH_CUSTOM, "-transferfunction", "name",
         offsetof(FlowValues, tfPtr), 0, 0, &transferFunctionSwitch},
     {Rappture::SWITCH_BOOLEAN, "-volume", "boolean",
         offsetof(FlowValues, showVolume), 0},
-    {Rappture::SWITCH_BOOLEAN, "-outline", "boolean",
-        offsetof(FlowValues, showOutline), 0},
-    {Rappture::SWITCH_FLOAT, "-diffuse", "value",
-        offsetof(FlowValues, diffuse), 0},
-    {Rappture::SWITCH_FLOAT, "-opacity", "value",
-        offsetof(FlowValues, opacity), 0},
-    {Rappture::SWITCH_FLOAT, "-specular", "value",
-        offsetof(FlowValues, specular), 0},
     {Rappture::SWITCH_END}
 };
@@ -295 +297 @@
     }
      if (_volPtr != NULL) {
-         assert((size_t)_volId == _volPtr->dataID());
-         fprintf(stderr, "from ~FlowCmd volId=%d\n", _volId);
-         NanoVis::remove_volume(_volId);
+         NanoVis::remove_volume(_volPtr);
          _volPtr = NULL;
     }
@@ -510 +510 @@
 {
     if (_volPtr != NULL) {
-        assert((size_t)_volId == _volPtr->dataID());
-        fprintf(stderr, "from ScaleVectorField volId=%d\n", _volId);
-        NanoVis::remove_volume(_volId);
+        fprintf(stderr, "from ScaleVectorField volId=%s\n", _volPtr->name());
+        NanoVis::remove_volume(_volPtr);
         _volPtr = NULL;
     }
@@ -563 +562 @@
 
     if (NanoVis::velocityArrowsSlice != NULL) {
-        NanoVis::velocityArrowsSlice->vectorField(volPtr->id,
+        NanoVis::velocityArrowsSlice->vectorField(_volPtr->id,
             //*(volPtr->get_location()),
             1.0f,
-            volPtr->aspect_ratio_height / volPtr->aspect_ratio_width,
-            volPtr->aspect_ratio_depth / volPtr->aspect_ratio_width
+            _volPtr->aspect_ratio_height / _volPtr->aspect_ratio_width,
+            _volPtr->aspect_ratio_depth / _volPtr->aspect_ratio_width
             //,volPtr->wAxis.max()
             );
+        Trace("Arrows enabled set to %d\n", _sv.showArrows);
+        NanoVis::velocityArrowsSlice->axis(_sv.slicePos.axis);
+        NanoVis::velocityArrowsSlice->slicePos(_sv.slicePos.value);
+        NanoVis::velocityArrowsSlice->enabled(_sv.showArrows);
     }
     FlowParticles *particlesPtr;
@@ -628 +631 @@
 {
     Volume *volPtr;
-    /* Reuse the volume index. The first time it's -1, which means to generate
-     * a new volume slot. */
-    volPtr = NanoVis::load_volume(_volId, _dataPtr->xNum(), _dataPtr->yNum(), 
+    volPtr = NanoVis::load_volume(_name, _dataPtr->xNum(), _dataPtr->yNum(), 
         _dataPtr->zNum(), 4, data, NanoVis::magMin, NanoVis::magMax, 0);
-    /* Save the volume index.  This only matters the first time through. */
-    _volId = volPtr->dataID();
     volPtr->xAxis.SetRange(_dataPtr->xMin(), _dataPtr->xMax());
     volPtr->yAxis.SetRange(_dataPtr->yMin(), _dataPtr->yMax());
@@ -646 +645 @@
     // volPtr->set_n_slice(512- _volIndex);
     // TBD..
-    volPtr->n_slices(256);
+    //volPtr->n_slices(256-n);
     volPtr->disable_cutplane(0);
     volPtr->disable_cutplane(1);

trunk/packages/vizservers/nanovis/FlowCmd.h

@@ -136 +136 @@
     TransferFunction *tfPtr;
     FlowPosition slicePos;
+    int showArrows;
     int sliceVisible;
     int showVolume;

trunk/packages/vizservers/nanovis/HeightMap.cpp

@@ -30 +30 @@
     _contour(0), 
     _topContour(0), 
-    _colorMap(0), 
+    _tfPtr(0), 
     _indexBuffer(0), 
     _indexCount(0), 
@@ -43 +43 @@
     _shader = new NvShader();
     _shader->loadFragmentProgram("heightcolor.cg", "main");
-    _tf = _shader->getNamedParameterFromFP("tf");
+    _tfParam = _shader->getNamedParameterFromFP("tf");
 }
 
@@ -55 +55 @@
 
     // TMP
-    //if (_colorMap) delete _colorMap;
+    //if (_tfPtr) delete _tfPtr;
 }
 
@@ -93 +93 @@
         glDisableClientState(GL_NORMAL_ARRAY);
         
-        if (_colorMap) {
+        if (_tfPtr) {
             // PUT vertex program here
             //
@@ -101 +101 @@
             cgGLEnableProfile(CG_PROFILE_FP30);
             
-            cgGLSetTextureParameter(_tf, _colorMap->id);
-            cgGLEnableTextureParameter(_tf);
+            cgGLSetTextureParameter(_tfParam, _tfPtr->id());
+            cgGLEnableTextureParameter(_tfParam);
             
             glEnable(GL_TEXTURE_1D);
-            _colorMap->getTexture()->activate();
+            _tfPtr->getTexture()->activate();
             
             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
@@ -128 +128 @@
         
         glDisableClientState(GL_VERTEX_ARRAY);
-        if (_colorMap) {
-            _colorMap->getTexture()->deactivate();
+        if (_tfPtr != NULL) {
+            _tfPtr->getTexture()->deactivate();
             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
             
@@ -388 +388 @@
     
     ContourLineFilter lineFilter;
-    //lineFilter.setColorMap(_colorMap);
+    //lineFilter.transferFunction(_tfPtr);
     _contour = lineFilter.create(0.0f, 1.0f, 10, heightMap, xNum, yNum);
     
@@ -439 +439 @@
     }
     return vertices;
-}
-
-void HeightMap::setColorMap(TransferFunction* colorMap)
-{
-    //if (colorMap) colorMap->addRef();
-    //if (_colorMap) _colorMap->unrefDelete();
-    _colorMap = colorMap;
 }
 
@@ -501 +494 @@
 
     ContourLineFilter lineFilter;
-    //lineFilter.setColorMap(_colorMap);
+    //lineFilter.transferFunction(_tfPtr);
     _contour = lineFilter.create(0.0f, 1.0f, 10, vertices, xNum_, yNum_);
     
@@ -568 +561 @@
         glDisableClientState(GL_NORMAL_ARRAY);
         
-        if (_colorMap) {
+        if (_tfPtr != NULL) {
             cgGLBindProgram(_shader->getFP());
             cgGLEnableProfile(CG_PROFILE_FP30);
             
-            cgGLSetTextureParameter(_tf, _colorMap->id);
-            cgGLEnableTextureParameter(_tf);
+            cgGLSetTextureParameter(_tfParam, _tfPtr->id());
+            cgGLEnableTextureParameter(_tfParam);
             
             glEnable(GL_TEXTURE_1D);
-            _colorMap->getTexture()->activate();
+            _tfPtr->getTexture()->activate();
             
             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
@@ -602 +595 @@
         
         glDisableClientState(GL_VERTEX_ARRAY);
-        if (_colorMap) {
-            _colorMap->getTexture()->deactivate();
+        if (_tfPtr != NULL) {
+            _tfPtr->getTexture()->deactivate();
             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
             

trunk/packages/vizservers/nanovis/HeightMap.h

@@ -26 +26 @@
     unsigned int _textureBufferObjectID;
     int _vertexCount;
-    CGparameter _tf;
+    CGparameter _tfParam;
     R2Geometry* _contour;
     R2Geometry* _topContour;
-    TransferFunction* _colorMap;
+    TransferFunction* _tfPtr;
     NvShader* _shader;
     int *_indexBuffer;
@@ -90 +90 @@
      *@brief Define a color map for color shading of heightmap
      */
-    void setColorMap(TransferFunction* colorMap);
-
+    void transferFunction(TransferFunction* tfPtr) {
+        _tfPtr = tfPtr;
+    }
     /**
      *@brief Get the color map defined for shading of this heightmap
      */
-    TransferFunction *getColorMap(void) {
-        return _colorMap;
+    TransferFunction *transferFunction(void) {
+        return _tfPtr;
     }
     /**

trunk/packages/vizservers/nanovis/NvColorTableShader.h

@@ -25 +25 @@
 {
     cgGLSetTextureParameter(_dataParam, plane->id);
-    cgGLSetTextureParameter(_tfParam, tf->id);
+    cgGLSetTextureParameter(_tfParam, tf->id());
     cgGLEnableTextureParameter(_dataParam);
     cgGLEnableTextureParameter(_tfParam);

trunk/packages/vizservers/nanovis/PlaneRenderer.cpp

@@ -50 +50 @@
 
 int 
-PlaneRenderer::add_plane(Texture2D* _p, TransferFunction* _tf)
+PlaneRenderer::add_plane(Texture2D* _p, TransferFunction* tfPtr)
 {
     int ret = n_planes;
 
     plane.push_back(_p);
-    tf.push_back(_tf);
+    tf.push_back(tfPtr);
 
     if(ret==0)
@@ -95 +95 @@
 
     //if no active plane
-    if(active_plane == -1)
+    if (active_plane == -1)
         return;
 
@@ -112 +112 @@
 PlaneRenderer::activate_shader(int index)
 {
-
     cgGLSetTextureParameter(m_data_param, plane[index]->id);
-    cgGLSetTextureParameter(m_tf_param, tf[index]->id);
+    cgGLSetTextureParameter(m_tf_param, tf[index]->id());
     cgGLEnableTextureParameter(m_data_param);
     cgGLEnableTextureParameter(m_tf_param);

trunk/packages/vizservers/nanovis/TransferFunction.cpp

@@ -28 +28 @@
     _data = new float[_size];
     memcpy(_data, data, sizeof(float) * _size);
-
     _tex->initialize_float_rgba(_data);
-    id = _tex->id;
+    _id = _tex->id;
 }
 

trunk/packages/vizservers/nanovis/TransferFunction.h

@@ -28 +28 @@
     float* _data;
     Texture1D* _tex;            //the texture storing the colors 
-    
+    const char *_name;
+    GLuint _id;                 //OpenGL's texture identifier
 protected :
     ~TransferFunction();
 public:
-    GLuint id;                  //OpenGL's texture identifier
-
     TransferFunction(int size, float *data);
     void update(float *data);
     void update(int size, float *data);
+    GLuint id(void) {
+        return _id;
+    }
+    void id(GLuint id) {
+        _id = id;
+    }
     Texture1D* getTexture(void) {
         return _tex;
@@ -43 +48 @@
         return _data; 
     }
-    int getSize() const;
+    int getSize() const {
+        return _size;
+    }
+    const char *name(void) const {
+        return _name;
+    }
+    void name(const char *name) {
+        _name = name;
+    }
 };
 
-inline int TransferFunction::getSize() const
-{
-    return _size;
-}
 #endif

trunk/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

@@ -265 +265 @@
 void VelocityArrowsSlice::render()
 {
-        //if (!_enabled || (_vectorFieldGraphicsID == 0)) return;       
-        if (!_enabled) return;
-
-        if (_dirty)
-        {
-                computeSamplingTicks();
-                queryVelocity();
-                _dirty = false;
-        }
-
-
-        glPushMatrix();
-        
-        glScalef(_vfXscale,_vfYscale, _vfZscale);
-        glTranslatef(-0.5f, -0.5f, -0.5f);
-        if (_renderMode == LINES)
-        {
-
-                glDisable(GL_TEXTURE_2D);
-                glLineWidth(2.0);
-                glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
-                glBegin(GL_LINES);
-                Vector3 pos;
-                Vector3 pos2;
-                Vector3 vel(1, 0, 0);
-                Vector3 v, v2;
-                if (_axis == 2)
-                {
-                        int index = 0;
-                        for (int y = 1; y <= _tickCountY; ++y)
-                                for (int x = 1; x <= _tickCountX; ++x, ++index)
-                                {
-                                        pos = this->_samplingPositions[index];
-                                        pos2 = this->_velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
-                                        glVertex3f(pos.x, pos.y, pos.z);
-                                        glVertex3f(pos2.x, pos2.y, pos2.z);
-                                        /*v = pos - pos2;
-                                        
-                                        
-                                        v2.x = 1;
-                                        v2.y = 1;
-                                        v2.z = (-(x1-x2)-(y1-y2))/(z1-z2)
-                                        adj = v.length() / (4 * sqrt((x3^2)+(y3^2)+(z3^2)));
-                                        x3 *= adj
-                                        y3 *= adj
-                                        z3 *= adj
-                                        */
-
-                                }
-                }
-                else if (_axis == 1)
-                {
-                        int index = 0;
-                        for (int z = 1; z <= _tickCountZ; ++z)
-                                for (int x = 1; x <= _tickCountX; ++x, ++index)
-                                {
-                                        pos = _samplingPositions[index];
-                                        pos2 = this->_velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
-
-                                        glVertex3f(pos.x, pos.y, pos.z);
-                                        glVertex3f(pos2.x, pos2.y, pos2.z);
-                                }
-                }
-                else if (_axis == 0)
-                {
-                        int index = 0;
-                        for (int z = 1; z <= _tickCountZ; ++z)
-                                for (int y = 1; y <= _tickCountY; ++y, ++index)
-                                {
-                                        pos = _samplingPositions[index];
-                                        pos2 = this->_velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
-
-                                        glVertex3f(pos.x, pos.y, pos.z);
-                                        glVertex3f(pos2.x, pos2.y, pos2.z);
-                                }
-                }
-                
-                glEnd();
-                glLineWidth(1.0);
-        }
-        else 
-        {
-                glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
-                glEnable(GL_BLEND);
-                glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-                glEnable(GL_POINT_SPRITE_NV);
-                glPointSize(20);                                
-                glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
-
-#ifdef USE_NANOVIS_LIB
-                _arrowsTex->activate(); 
-#else
-                _arrowsTex->bind(0);
-                glEnable(GL_TEXTURE_2D);
-#endif
-                glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
-
-                glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
-                glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
-                glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
-
-                cgGLBindProgram(_particleVP);
-                cgGLBindProgram(_particleFP);
-                cgGLEnableProfile(CG_PROFILE_VP40);
-                cgGLEnableProfile(CG_PROFILE_FP40);
-
-                cgGLSetTextureParameter(_vectorParticleParam, _vectorFieldGraphicsID);
-                cgGLEnableTextureParameter(_vectorParticleParam);
-
-
-                //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * 0.5) * _screenHeight * 0.5);
-                
-                cgGLSetStateMatrixParameter(_mvpParticleParam,
-                                                CG_GL_MODELVIEW_PROJECTION_MATRIX,
-                                                CG_GL_MATRIX_IDENTITY);
-                cgGLSetStateMatrixParameter(_mvParticleParam,
-                                                CG_GL_MODELVIEW_MATRIX,
-                                                CG_GL_MATRIX_IDENTITY);
-
-                glEnableClientState(GL_VERTEX_ARRAY);
-                glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
-                glVertexPointer(3, GL_FLOAT, 0, 0);
-                //glEnableClientState(GL_COLOR_ARRAY);
-
-                // TBD..
-                glDrawArrays(GL_POINTS, 0, _pointCount);
-                glPointSize(1);
-                glDrawArrays(GL_POINTS, 0, _pointCount);
-
-                glDisableClientState(GL_VERTEX_ARRAY);
-                
-                cgGLDisableProfile(CG_PROFILE_VP40);
-                cgGLDisableProfile(CG_PROFILE_FP40);
-
-                glDepthMask(GL_TRUE);
-                
-                glDisable(GL_POINT_SPRITE_NV);
-                glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
-
-                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                glDisable(GL_BLEND);
-#ifdef USE_NANOVIS_LIB
-                _arrowsTex->deactivate(); 
-#else
-                _arrowsTex->unbind();
-#endif
-        }
-        glPopMatrix();
-}
-
-void VelocityArrowsSlice::enabled(bool e)
-{
-        _enabled = e;
-}
-
-void VelocityArrowsSlice::vectorField(unsigned int vfGraphicsID, 
-                                float xScale, float yScale, float zScale)
+    //if (!_enabled || (_vectorFieldGraphicsID == 0)) return;   
+    if (!_enabled) return;
+    
+    if (_dirty) {
+        computeSamplingTicks();
+        queryVelocity();
+        _dirty = false;
+    }
+    
+    
+    glPushMatrix();
+    
+    glScalef(_vfXscale,_vfYscale, _vfZscale);
+    glTranslatef(-0.5f, -0.5f, -0.5f);
+    if (_renderMode == LINES) {
+        
+        glDisable(GL_TEXTURE_2D);
+        glLineWidth(2.0);
+        glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
+        glBegin(GL_LINES);
+        Vector3 pos;
+        Vector3 pos2;
+        Vector3 vel(1, 0, 0);
+        Vector3 v, v2;
+        if (_axis == 2) {
+            int index = 0;
+            for (int y = 1; y <= _tickCountY; ++y) {
+                for (int x = 1; x <= _tickCountX; ++x, ++index) {
+                    pos = this->_samplingPositions[index];
+                    pos2 = this->_velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
+                    glVertex3f(pos.x, pos.y, pos.z);
+                    glVertex3f(pos2.x, pos2.y, pos2.z);
+                    /*v = pos - pos2;
+                      
+                    
+                    v2.x = 1;
+                    v2.y = 1;
+                    v2.z = (-(x1-x2)-(y1-y2))/(z1-z2)
+                    adj = v.length() / (4 * sqrt((x3^2)+(y3^2)+(z3^2)));
+                    x3 *= adj
+                    y3 *= adj
+                    z3 *= adj
+                    */
+                    
+                }
+            }
+        } else if (_axis == 1) {
+            int index = 0;
+            for (int z = 1; z <= _tickCountZ; ++z)
+                for (int x = 1; x <= _tickCountX; ++x, ++index) {
+                    pos = _samplingPositions[index];
+                    pos2 = this->_velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
+                    
+                    glVertex3f(pos.x, pos.y, pos.z);
+                    glVertex3f(pos2.x, pos2.y, pos2.z);
+                }
+        } else if (_axis == 0) {
+            int index = 0;
+            for (int z = 1; z <= _tickCountZ; ++z)
+                for (int y = 1; y <= _tickCountY; ++y, ++index) {
+                    pos = _samplingPositions[index];
+                    pos2 = this->_velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
+                    
+                    glVertex3f(pos.x, pos.y, pos.z);
+                    glVertex3f(pos2.x, pos2.y, pos2.z);
+                }
+        }
+        
+        glEnd();
+        glLineWidth(1.0);
+    } else {
+        glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+        glEnable(GL_POINT_SPRITE_NV);
+        glPointSize(20);                                
+        glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
+        
+#ifdef USE_NANOVIS_LIB
+        _arrowsTex->activate(); 
+#else
+        _arrowsTex->bind(0);
+        glEnable(GL_TEXTURE_2D);
+#endif
+        glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
+        
+        glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
+        glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
+        glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
+        
+        cgGLBindProgram(_particleVP);
+        cgGLBindProgram(_particleFP);
+        cgGLEnableProfile(CG_PROFILE_VP40);
+        cgGLEnableProfile(CG_PROFILE_FP40);
+        
+        cgGLSetTextureParameter(_vectorParticleParam, _vectorFieldGraphicsID);
+        cgGLEnableTextureParameter(_vectorParticleParam);
+        
+        
+        //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * 0.5) * _screenHeight * 0.5);
+        
+        cgGLSetStateMatrixParameter(_mvpParticleParam,
+                                    CG_GL_MODELVIEW_PROJECTION_MATRIX,
+                                    CG_GL_MATRIX_IDENTITY);
+        cgGLSetStateMatrixParameter(_mvParticleParam,
+                                    CG_GL_MODELVIEW_MATRIX,
+                                    CG_GL_MATRIX_IDENTITY);
+        
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
+        glVertexPointer(3, GL_FLOAT, 0, 0);
+        //glEnableClientState(GL_COLOR_ARRAY);
+        
+        // TBD..
+        glDrawArrays(GL_POINTS, 0, _pointCount);
+        glPointSize(1);
+        glDrawArrays(GL_POINTS, 0, _pointCount);
+        
+        glDisableClientState(GL_VERTEX_ARRAY);
+        
+        cgGLDisableProfile(CG_PROFILE_VP40);
+        cgGLDisableProfile(CG_PROFILE_FP40);
+        
+        glDepthMask(GL_TRUE);
+        
+        glDisable(GL_POINT_SPRITE_NV);
+        glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
+        
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glDisable(GL_BLEND);
+#ifdef USE_NANOVIS_LIB
+        _arrowsTex->deactivate(); 
+#else
+        _arrowsTex->unbind();
+#endif
+    }
+    glPopMatrix();
+}
+
+
+void 
+VelocityArrowsSlice::vectorField(unsigned int vfGraphicsID, 
+                                 float xScale, float yScale, float zScale)
 {
     _vectorFieldGraphicsID = vfGraphicsID;

trunk/packages/vizservers/nanovis/VelocityArrowsSlice.h

@@ -132 +132 @@
         void queryVelocity();
         void render();
-        void enabled(bool e);
-        bool enabled() const;
-        void tickCountForMinSizeAxis(int tickCount);
+    void enabled(bool enabled) {
+        _enabled = enabled;
+    }
+    bool enabled(void) const {
+        return _enabled;
+    }
+    void tickCountForMinSizeAxis(int tickCount);
     int tickCountForMinSizeAxis() const;
     void arrowColor(const Vector3& color);
-        void renderMode(RenderMode mode);
-        RenderMode renderMode() const;
+    void renderMode(RenderMode mode);
+    RenderMode renderMode() const;
 };
 
@@ -151 +155 @@
 }
 
-
-inline bool VelocityArrowsSlice::enabled() const
-{
-        return _enabled;
-}
 
 inline int VelocityArrowsSlice::tickCountForMinSizeAxis() const

trunk/packages/vizservers/nanovis/Volume.cpp

@@ -31 +31 @@
     _diffuse(3.),               // default value
     _opacity_scale(10.),        // default value
+    _name(NULL),
     _n_components(n),
     _nonzero_min(nz_min),
@@ -47 +48 @@
     size(s)
 {
-    _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

@@ +1 @@
+
 /*
  * ----------------------------------------------------------------------
@@ -54 +55 @@
                                         // the object is to appear like
                                         // plastic
-    int _volumeDataID;
+    const char *_name;
     Vector3 _physical_min;
     Vector3 _physical_max;
@@ -222 +223 @@
     Vector3& getPhysicalBBoxMax();
 
-    void dataID(size_t index) {
-        _volumeDataID = index;
-    }
-    size_t dataID(void) const {
-        return _volumeDataID;
+    const char *name(void) {
+        return _name;
+    }
+    void name(const char *name) {
+        _name = name;
     }
 };

trunk/packages/vizservers/nanovis/VolumeInterpolator.cpp

@@ -144 +144 @@
                              refPtr->wAxis.max(), 
                              refPtr->nonzero_min());
+        /*
         _referenceOfVolume = refPtr->dataID();
+        */
         _volume->n_slices(256-1);
         _volume->disable_cutplane(0);
@@ -155 +157 @@
         _volume->opacity_scale(refPtr->opacity_scale());
         _volume->isosurface(0);
-        Trace("VOL : location %f %f %f\n\tid : %d\n", loc.x, loc.y, loc.z, 
-                refPtr->dataID());
+        Trace("VOL : location %f %f %f\n\tid : %s\n", loc.x, loc.y, loc.z, 
+                refPtr->name());
     }
     _volumes.push_back(_volume);
-    Trace("a Volume[%d] is added to VolumeInterpolator\n", refPtr->dataID());
+    Trace("a Volume[%s] is added to VolumeInterpolator\n", refPtr->name());
 }
 

trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

@@ -88 +88 @@
 }
 
-void VolumeRenderer::render_all_points()
-{
-#ifdef notdef
-    double x0 = 0;
-    double y0 = 0;
-    double z0 = 0;
-    
-    for(int i=0; i<n_volumes; i++){
-        int volume_index = i;
-        if(!volume[i]->visible())
-            continue; //skip this volume
-        
-        Vector3* location = volume[volume_index]->get_location();
-        Vector4 shift_4d(location->x, location->y, location->z, 0);
-        
-        glPushMatrix();
-        glTranslatef(shift_4d.x, shift_4d.y, shift_4d.z);
-        
-        if (volume[volume_index]->outline()) {
-            float olcolor[3];
-            volume[volume_index]->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();
-    }
-#endif
-}
 
 void 
@@ -132 +103 @@
     // Determine the volumes that are to be rendered.
     vector<Volume *> volumes;
-    for (size_t i = 0; i < NanoVis::volumes.size(); i++) {
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+    for (hPtr = Tcl_FirstHashEntry(&NanoVis::volumeTable, &iter); hPtr != NULL;
+         hPtr = Tcl_NextHashEntry(&iter)) {
         Volume* volPtr;
-    
-        volPtr = NanoVis::volumes[i];
-        Trace("volume %d: %x id=%d\n", i, volPtr, 
-              (volPtr != NULL) ? volPtr->dataID() : -1);
-        if (volPtr == NULL) {
-            continue;                   // Empty slot in volume vector.
-        }
+        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
+        Trace("volume %s addr=%x\n", volPtr->name(), volPtr);
         if(!volPtr->visible()) {
-            Trace("volume [%d] %d skipped, size=%d id=%d\n", volPtr->dataID(),
-                  volPtr->visible(), volumes.size(), volPtr->dataID());
             continue;                   // Skip this volume
         }
+        // BE CAREFUL: Set the number of slices to something slightly
+        // different for each volume.  If we have identical volumes at exactly
+        // the same position with exactly the same number of slices, the
+        // second volume will overwrite the first, so the first won't appear
+        // at all.
         volumes.push_back(volPtr);
+        volPtr->n_slices(256 - volumes.size());
     }
 
@@ -162 +135 @@
         volPtr = volumes[i];
 
-        Trace("render: volume [%d] rendering visible=%d\n", volPtr->dataID(),
-              volPtr->visible());
         int n_slices = volPtr->n_slices();
         if (volPtr->isosurface()) {
@@ -249 +220 @@
         size_t n_actual_slices;
         
-        if (volPtr->data()) {
+        if (volPtr->data_enabled()) {
             n_actual_slices = (int)(fabs(zNear-zFar)/z_step + 1);
             polys[i] = new ConvexPolygon*[n_actual_slices];
@@ -380 +351 @@
         
     } //iterate all volumes
-    //fprintf(stderr, "total slices: %d\n", total_rendered_slices); 
+    fprintf(stderr, "total slices: %d\n", total_rendered_slices); 
     Trace("end loop\n");
     
-    //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);
+    // 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);
     
     size_t counter = 0;
@@ -405 +377 @@
     glEnable(GL_BLEND);
     
-    for(size_t i = 0; i <total_rendered_slices; i++){
+    for(size_t i = 0; i < total_rendered_slices; i++){
         Volume* volPtr;
 
@@ -417 +389 @@
                  volPtr->aspect_ratio_depth);
         
+#ifdef notdef
+        Trace("shading slice: volume %s addr=%x slice=%d, volume=%d\n", 
+              volPtr->name(), volPtr, slice_index, volume_index);
+#endif
         activate_volume_shader(volPtr, false);
         glPopMatrix();
@@ -426 +402 @@
         deactivate_volume_shader();
     }
-    
     
     glDisable(GL_DEPTH_TEST);
@@ -445 +420 @@
 }
 
-void 
-VolumeRenderer::render(int volDataID)
-{
-    assert(volDataID >= 0 && (size_t)volDataID < NanoVis::volumes.size());
-    Volume* vol;
-    vol = NanoVis::volumes[volDataID];
-    if ((vol == NULL) || (!vol->visible())) {
-        Trace("volume [%d] skipped\n", volDataID);
-        return;                         // Empty slot or volume is not to be
-                                        // rendered.
-    }
-    Trace("volume [%d] rendering visible=%d\n", vol->dataID(), 
-          vol->visible());
-    int n_slices = vol->n_slices();
-
-    //volume start location
-    Vector3 loc = vol->location();
-    Vector4 shift_4d(loc.x, loc.y, loc.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);
-    
-    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
-    if (vol->outline()) {
-        draw_bounding_box(x0, y0, z0, x0+1, y0+1, z0+1, 0.8, 0.1, 0.1, 1.5);
-    }
-    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);
-    //fprintf(stderr, "zNear:%f, zFar:%f\n", zNear, zFar);
-    //fflush(stderr);
-    
-    //compute actual rendering slices
-    float z_step = fabs(zNear-zFar)/n_slices;           
-    int n_actual_slices = (int)(fabs(zNear-zFar)/z_step + 1);
-    //fprintf(stderr, "slices: %d\n", n_actual_slices);
-    //fflush(stderr);
-    
-    static ConvexPolygon staticPoly;    
-    float slice_z;
-    
-    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));
-    
-    glEnable(GL_BLEND);
-    
-    if(slice_mode){
-        glEnable(GL_DEPTH_TEST);
-        
-        //render the cut planes
-        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) {
-                vert1 = Vector4(-10, -10, offset, 1);
-                vert2 = Vector4(-10, +10, offset, 1);
-                vert3 = Vector4(+10, +10, offset, 1);
-                vert4 = Vector4(+10, -10, offset, 1);
-            } else if(axis==2){
-                vert1 = Vector4(offset, -10, -10, 1);
-                vert2 = Vector4(offset, +10, -10, 1);
-                vert3 = Vector4(offset, +10, +10, 1);
-                vert4 = Vector4(offset, -10, +10, 1);
-            } else if(axis==3) {
-                vert1 = Vector4(-10, offset, -10, 1);
-                vert2 = Vector4(+10, offset, -10, 1);
-                vert3 = Vector4(+10, offset, +10, 1);
-                vert4 = Vector4(-10, offset, +10, 1);
-            }
-            
-            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 *poly;
-            poly = &staticPoly;
-            poly->vertices.clear();
-            
-            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_inverse);
-            //poly->translate(shift_4d);
-            //poly->transform(model_view);
-            poly->transform(model_view_no_trans_inverse);
-            poly->transform(model_view_trans);
-            
-            glPushMatrix();
-            glScalef(vol->aspect_ratio_width, vol->aspect_ratio_height, 
-                     vol->aspect_ratio_depth);
-            
-            activate_volume_shader(vol, true);
-            glPopMatrix();
-            
-            glBegin(GL_POLYGON);
-            poly->Emit(true); 
-            glEnd();
-            
-            deactivate_volume_shader();
-        }
-    } //slice_mode
-    
-    
-    if(volume_mode){ 
-        glEnable(GL_DEPTH_TEST);
-        
-        for (int i=0; i<n_actual_slices; i++){
-            slice_z = zFar + i * z_step;        //back to front
-            
-            ConvexPolygon *poly;
-            poly = &staticPoly;
-            poly->vertices.clear();
-            
-            //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);
-            }
-            
-            //move the volume to the proper location
-            //poly->transform(model_view_inverse);
-            //poly->translate(shift_4d);
-            //poly->transform(model_view);
-            
-            poly->transform(model_view_no_trans_inverse);
-            poly->transform(model_view_trans);
-            
-            glPushMatrix();
-            glScalef(vol->aspect_ratio_width, vol->aspect_ratio_height, 
-                     vol->aspect_ratio_depth);
-            
-            /* 
-            //draw slice lines only
-            glDisable(GL_BLEND);
-            glDisable(GL_TEXTURE_3D);
-            glDisable(GL_TEXTURE_2D);
-            glLineWidth(1.0);
-            glColor3f(1,1,1);
-            glBegin(GL_LINE_LOOP);
-            poly->Emit(false);
-            glEnd();
-            */
-            
-            activate_volume_shader(vol, true);
-            glPopMatrix();
-            
-            glBegin(GL_POLYGON);
-            poly->Emit(true); 
-            glEnd();
-            
-            deactivate_volume_shader();
-            
-        }
-    } //volume_mode
-    
-    glDisable(GL_BLEND);
-    glDisable(GL_DEPTH_TEST);
-}
- 
 void 
 VolumeRenderer::draw_bounding_box(float x0, float y0, float z0, 
@@ -793 +543 @@
 
 void 
-VolumeRenderer::activate_volume_shader(Volume* vol, bool slice_mode)
+VolumeRenderer::activate_volume_shader(Volume* volPtr, bool slice_mode)
 {
     //vertex shader
     _stdVertexShader->bind();
-    TransferFunction *tf  = vol->transferFunction();
-    if (vol->volume_type() == Volume::CUBIC) {
-        //regular cubic volume
-        _regularVolumeShader->bind(tf->id, vol, slice_mode);
-    } else if (vol->volume_type() == Volume::ZINCBLENDE) {
-        _zincBlendeShader->bind(tf->id, vol, slice_mode);
+    TransferFunction *tfPtr  = volPtr->transferFunction();
+    if (volPtr->volume_type() == Volume::CUBIC) {
+        Trace("regular volume shader: volume=%s tf=%s slice_mode=%d\n",
+              volPtr->name(), tfPtr->name(), slice_mode);
+        _regularVolumeShader->bind(tfPtr->id(), volPtr, slice_mode);
+    } else if (volPtr->volume_type() == Volume::ZINCBLENDE) {
+        Trace("zincblende volume shader: volume=%s tf=%s slice_mode=%d\n",
+              volPtr->name(), tfPtr->name(), slice_mode);
+        _zincBlendeShader->bind(tfPtr->id(), volPtr, slice_mode);
     }
 }
@@ -879 +632 @@
     
     if (fread(&bfType, sizeof(short int), 1, f) != 1) {
-        fprintf(stderr, "can't read %d bytes from font file \"%s\"\n", 
-                sizeof(short int), filename);
+        fprintf(stderr, "can't read %lu bytes from font file \"%s\"\n", 
+                (unsigned long)sizeof(short int), filename);
         goto error;
     }

trunk/packages/vizservers/nanovis/VolumeRenderer.h

@@ -100 +100 @@
     ~VolumeRenderer();
 
-    void add_volume(Volume* _vol, TransferFunction* _tf); 
-    void render(int volumeID);
-    void render_all();  //render all enabled volumes;
-    void render_all_points(void); //render all enabled volumes;
+    void render_all();                  //render all enabled volumes;
     void specular(float val);
     void diffuse(float val);
-    void set_slice_mode(bool val); //control independently.
+    void set_slice_mode(bool val);      //control independently.
     void set_volume_mode(bool val);
-    void switch_slice_mode(); //switch_cutplane_mode
+    void switch_slice_mode();           //switch_cutplane_mode
     void switch_volume_mode();
 

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -47 +47 @@
 /* Load a 3D volume from a dx-format file
  */
-bool
-load_volume_stream2(Rappture::Outcome &result, int volDataID, std::iostream& fin)
+Volume *
+load_volume_stream2(Rappture::Outcome &result, const char *tag, 
+                    std::iostream& fin)
 {
-    printf("load_volume_stream2\n");
+    printf("load_volume_stream2 %s\n", tag);
     Rappture::MeshTri2D xymesh;
     int dummy, nx, ny, nz, nxy, npts;
@@ -118 +119 @@
                 } else {
                     result.error("triangularization failed");
-                    return false;
+                    return NULL;
                 }
                 unlink(fpts), unlink(fcells);
@@ -143 +144 @@
             result.addError("don't know how to handle multiple non-zero"
                             " delta values");
-            return false;
+            return NULL;
         }
             } else if (sscanf(start, "object %d class array type %s rank 0 items %d data follows", &dummy, type, &npts) == 3) {
@@ -149 +150 @@
                     result.addError("inconsistent data: expected %d points "
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 } else if (!isrect && (npts != nxy*nz)) {
                     result.addError("inconsistent data: expected %d points "
                                     " but found %d points", nxy*nz, npts);
-                    return false;
+                    return NULL;
                 }
                 break;
@@ -160 +161 @@
                     result.addError("inconsistent data: expected %d points "
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 }
                 break;
@@ -172 +173 @@
     if (fin.eof()) {
         result.addError("EOF found: expecting %d points", npts);
-        return false;
+        return NULL;
     }
-    Volume *volPtr = 0;
+    Volume *volPtr = NULL;
     if (isrect) {
         double dval[6];
@@ -220 +221 @@
             result.addError("inconsistent data: expected %d points "
                             " but found %d points", nx*ny*nz, nread);
-            return false;
+            return NULL;
         }
         
@@ -247 +248 @@
         dz = nz;
         
-        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
+        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
                                       vmin, vmax, nzero_min);
         volPtr->xAxis.SetRange(x0, x0 + (nx * dx));
@@ -269 +270 @@
                 result.addError("after %d of %d points: can't read number", 
                                 nread, npts);
-                return false;
+                return NULL;
             } else {
                 int nid = nxy*iz + ixy;
@@ -286 +287 @@
             result.addError("inconsistent data: expected %d points "
                             "but found %d points", nxy*nz, nread);
-            return false;
+            return NULL;
         }
         
@@ -387 +388 @@
         }
         
-        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(), nzero_min);
+        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data, 
+                field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -409 +410 @@
         printf("volume moved\n");
     }
-    return true;
+    return volPtr;
 }
 
-bool
-load_volume_stream(Rappture::Outcome &result, int volDataID, std::iostream& fin)
+Volume *
+load_volume_stream(Rappture::Outcome &result, const char *tag, 
+                   std::iostream& fin)
 {
     printf("load_volume_stream\n");
@@ -431 +433 @@
         if (fin.fail()) {
             result.error("error in data stream");
-            return false;
+            return NULL;
         }
         for (start=line; *start == ' ' || *start == '\t'; start++)
@@ -490 +492 @@
                 } else {
                     result.error("triangularization failed");
-                    return false;
+                    return NULL;
                 }
                 unlink(fpts);
@@ -507 +509 @@
                     result.addError("inconsistent data: expected %d points"
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 } else if (!isrect && (npts != nxy*nz)) {
                     result.addError("inconsistent data: expected %d points"
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 }
                 break;
@@ -518 +520 @@
                     result.addError("inconsistent data: expected %d points"
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 }
                 break;
@@ -527 +529 @@
     if (fin.eof()) {
         result.error("data not found in stream");
-        return false;
+        return NULL;
     }
     Volume *volPtr = 0;
@@ -545 +547 @@
             if (fin.fail()) {
                 result.addError("error reading data points");
-                return false;
+                return NULL;
             }
             int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
@@ -568 +570 @@
             result.addError("inconsistent data: expected %d points"
                             " but found %d points", nx*ny*nz, npts);
-            return false;
+            return NULL;
         }
         
@@ -653 +655 @@
         }
 #endif  
-        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);
@@ -659 +660 @@
         fflush(stdout);
         
-        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(), nzero_min);
+        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
+                field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -695 +696 @@
                 result.addError("after %d of %d points: can't read number", 
                                 nread, npts);
-                return false;
+                return NULL;
             } else {
                 int nid = nxy*iz + ixy;
@@ -712 +713 @@
             result.addError("inconsistent data: expected %d points"
                             " but found %d points", nx*ny*nz, npts);
-            return false;
+            return NULL;
         }
         
@@ -804 +805 @@
         }
         
-        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(), nzero_min);
+        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
+                field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -838 +839 @@
         volPtr->location(Vector3(dx0, dy0, dz0));
     }
-    return true;
+    return volPtr;
 }
 
 
-bool
-load_volume_stream_insoo(Rappture::Outcome &result, int volDataID, 
+Volume *
+load_volume_stream_insoo(Rappture::Outcome &result, const char *tag, 
                          std::iostream& fin)
 {
@@ -862 +863 @@
         if (fin.fail()) {
             result.addError("line \"%s\"error in data stream");
-            return false;
+            return NULL;
         }
         for (start=line; *start == ' ' || *start == '\t'; start++)
@@ -921 +922 @@
                 } else {
                     result.error("triangularization failed");
-                    return false;
+                    return NULL;
                 }
                 unlink(fpts), unlink(fcells);
@@ -937 +938 @@
                     result.addError("inconsistent data: expected %d points"
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 } else if (!isrect && (npts != nxy*nz)) {
                     result.addError("inconsistent data: expected %d points"
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 }
                 break;
@@ -948 +949 @@
                     result.addError("inconsistent data: expected %d points"
                                     " but found %d points", nx*ny*nz, npts);
-                    return false;
+                    return NULL;
                 }
                 break;
@@ -958 +959 @@
     if (fin.eof()) {
         result.error("data not found in stream");
-        return false;
+        return NULL;
     }
 
@@ -977 +978 @@
             if (fin.fail()) {
                 result.error("error reading data points");
-                return false;
+                return NULL;
             }
             int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
@@ -1002 +1003 @@
             result.addError("inconsistent data: expected %d points"
                             " but found %d points", nx*ny*nz, npts);
-            return false;
+            return NULL;
         }
         
@@ -1132 +1133 @@
             */
 
-        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(), nzero_min);
+        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
+                field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -1170 +1171 @@
                         nread, npts);
                 result.error(mesg);
-                return false;
+                return NULL;
             } else {
                 int nid = nxy*iz + ixy;
@@ -1187 +1188 @@
             result.addError("inconsistent data: expected %d points"
                             " but found %d points", nx*ny*nz, npts);
-            return false;
+            return NULL;
         }
         
@@ -1279 +1280 @@
         }
         
-        volPtr = NanoVis::load_volume(volDataID, nx, ny, nz, 4, data,
-                                      field.valueMin(), field.valueMax(), nzero_min);
+        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
+                field.valueMin(), field.valueMax(), nzero_min);
         volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
                                field.rangeMax(Rappture::xaxis));
@@ -1313 +1314 @@
         volPtr->location(Vector3(dx0, dy0, dz0));
     }
-    return true;
+    return volPtr;
 }

trunk/packages/vizservers/nanovis/dxReader2.cpp

@@ -16 +16 @@
 /* Load a 3D volume from a dx-format file the new way
  */
-bool
-load_volume_stream_odx(Rappture::Outcome &context, int userID, const char *buf,
-                       int nBytes)
+Volume *
+load_volume_stream_odx(Rappture::Outcome &context, const char *tag, 
+                        const char *buf, int nBytes)
 {
     char dxfilename[128];
@@ -24 +24 @@
     if (nBytes <= 0) {
         context.error("empty data buffer\n");
-        return false;
+        return NULL;
     }
 
@@ -42 +42 @@
         context.addError("Can't read %d bytes from file \"%s\"\n", 
                          nBytes, dxfilename);
-        return false;
+        return NULL;
     }
 
@@ -49 +49 @@
     if (unlink(dxfilename) != 0) {
         context.addError("Error deleting dx file: %s\n", dxfilename);
-        return false;
+        return NULL;
     }
 
@@ -88 +88 @@
     computeSimpleGradient(data, nx, ny, nz);
 
-    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 +94 @@
 
     Volume *volPtr;
-    volPtr = NanoVis::load_volume(userID, nx, ny, nz, 4, data, 
+    volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data, 
                                   dxObj.dataMin(), 
                                   dxObj.dataMax(), 
@@ -117 +116 @@
     float dz0 = -0.5*dz/dx;
     volPtr->location(Vector3(dx0, dy0, dz0));
-    return true;
+    return volPtr;
 }

trunk/packages/vizservers/nanovis/nanovis.cpp

@@ -77 +77 @@
 
 extern void NvInitCG(); // in Shader.cpp
-extern bool load_vector_stream2(Rappture::Outcome &result, int index, 
-        size_t length, char *string);
 
 // Indicates "up" axis:  x=1, y=2, z=3, -x=-1, -y=-2, -z=-3
@@ -107 +105 @@
 int NanoVis::updir = Y_POS;
 NvCamera* NanoVis::cam = NULL;
-vector<Volume *>  NanoVis::volumes;
+Tcl_HashTable NanoVis::volumeTable;
 vector<HeightMap*> NanoVis::heightMap;
 VolumeRenderer* NanoVis::vol_renderer = NULL;
@@ -174 +172 @@
 
 // maps transfunc name to TransferFunction object
-static Tcl_HashTable tftable;
+Tcl_HashTable NanoVis::tfTable;
 
 // pointers to 2D planes, currently handle up 10
@@ -513 +511 @@
  */
 Volume *
-NanoVis::load_volume(int dataID, int width, int height, int depth,
-                     int n_component, float* data, double vmin,
-                     double vmax, double nzero_min)
-{
-    // Check if we're attempting to load the volume into an already
-    // occupied slot.
-
-        
-    Volume* volPtr = new Volume(0.f, 0.f, 0.f, width, height, depth, 1.,
-                                n_component, data, vmin, vmax, nzero_min);
-    if (dataID < 0) {
-        dataID = volumes.size();
-        volumes.push_back(volPtr);
-    } else {
-        int i;
-        // Create new slots it needed.
-        for (i = volumes.size(); i <= dataID; i++) {
-            volumes.push_back(NULL);
-        }
-        assert (volumes[dataID] == NULL);
-        volumes[dataID] = volPtr;
-    }
-    volPtr->dataID(dataID);
-    fprintf(stderr, "VOLID=%d, # of volume slots=%d\n", dataID, 
-            volumes.size());
+NanoVis::load_volume(const char *name, int width, int height, int depth, 
+                     int n_component, float* data, double vmin, double vmax, 
+                     double nzero_min)
+{
+    Tcl_HashEntry *hPtr;
+    hPtr = Tcl_FindHashEntry(&NanoVis::volumeTable, name);
+    if (hPtr != NULL) {
+        Volume *volPtr; 
+        Trace("volume \"%s\" already exists", name);
+        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
+        remove_volume(volPtr);
+    }
+    int isNew;
+    hPtr = Tcl_CreateHashEntry(&NanoVis::volumeTable, name, &isNew);
+    Volume* volPtr;
+    volPtr = new Volume(0.f, 0.f, 0.f, width, height, depth, 1., n_component,
+                data, vmin, vmax, nzero_min);
+    Tcl_SetHashValue(hPtr, volPtr);
+    volPtr->name(Tcl_GetHashKey(&NanoVis::volumeTable, hPtr));
     return volPtr;
 }
@@ -547 +539 @@
     Tcl_HashEntry *hPtr;
 
-    hPtr = Tcl_FindHashEntry(&tftable, name);
+    hPtr = Tcl_FindHashEntry(&tfTable, name);
     if (hPtr == NULL) {
         return NULL;
@@ -560 +552 @@
     int isNew;
     Tcl_HashEntry *hPtr;
-    TransferFunction *tf;
-
-    hPtr = Tcl_CreateHashEntry(&tftable, name, &isNew);
+    TransferFunction *tfPtr;
+
+    hPtr = Tcl_CreateHashEntry(&tfTable, name, &isNew);
     if (isNew) {
-        tf = new TransferFunction(n, data);
-        Tcl_SetHashValue(hPtr, (ClientData)tf);
+        tfPtr = new TransferFunction(n, data);
+        tfPtr->name(Tcl_GetHashKey(&tfTable, hPtr));
+        Tcl_SetHashValue(hPtr, tfPtr);
     } else {
         /* 
@@ -571 +564 @@
          * objects may be holding its pointer.  We must update it.
          */
-        tf = (TransferFunction *)Tcl_GetHashValue(hPtr);
-        tf->update(n, data);
-    }
-    return tf;
+        tfPtr = (TransferFunction *)Tcl_GetHashValue(hPtr);
+        tfPtr->update(n, data);
+    }
+    return tfPtr;
 }
 
@@ -916 +909 @@
 
     // init table of transfer functions
-    Tcl_InitHashTable(&tftable, TCL_STRING_KEYS);
+    Tcl_InitHashTable(&tfTable, TCL_STRING_KEYS);
 
     //check if performance query is supported
@@ -1542 +1535 @@
     xMin = yMin = zMin = wMin = DBL_MAX;
     xMax = yMax = zMax = wMax = -DBL_MAX;
-    vector<Volume *>::iterator iter;
-    for (iter = volumes.begin(); iter != volumes.end(); ++iter) {
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+    for (hPtr = Tcl_FirstHashEntry(&volumeTable, &iter); hPtr != NULL;
+         hPtr = Tcl_NextHashEntry(&iter)) {
         Volume *volPtr;
 
-        volPtr = (*iter);
-        if (volPtr == NULL) {
-            continue;                   // Empty slot.
-        }
+        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
         if (xMin > volPtr->xAxis.min()) {
             xMin = volPtr->xAxis.min();
@@ -2555 +2547 @@
 
 void 
-NanoVis::remove_volume(size_t index)
-{
-    fprintf(stderr, "index=%d #volumes=%d\n", index, volumes.size());
-    assert(index < volumes.size());
-    Volume* volPtr;
-    volPtr = volumes[index];
-    if (volPtr == NULL)  {
-        return;                         // Empty slot 
-    }
-    delete volPtr;                      // Delete the volume and mark the 
-    volumes[index] = NULL;              // slot as empty.
+NanoVis::remove_volume(Volume *volPtr)
+{
+    Tcl_HashEntry *hPtr;
+    hPtr = Tcl_FindHashEntry(&volumeTable, volPtr->name());
+    if (hPtr != NULL) {
+        Tcl_DeleteHashEntry(hPtr);
+    }
+    delete volPtr;                      
 }
 

trunk/packages/vizservers/nanovis/nanovis.h

@@ -43 +43 @@
 #include "global.h"
 #include "socket/Socket.h"
+#include "rappture.h"
 #include "NvCamera.h"
 #include "ConvexPolygon.h"
@@ -131 +132 @@
     static vector<HeightMap*> heightMap;
     static unsigned char* screen_buffer;
-    static vector<Volume *> volumes;
+    static Tcl_HashTable volumeTable;
     static vector<NvVectorField*> flow;
     static Grid* grid;
     static R2Fonts* fonts;
-    static int n_volumes;
     static int updir;
     static NvCamera *cam;
@@ -155 +155 @@
     static Tcl_DString cmdbuffer;
 
-    static int _last_data_id;
 public :
     static TransferFunction* get_transfunc(const char *name);
@@ -184 +183 @@
     static int render_legend(TransferFunction *tf, double min, double max, 
         int width, int height, const char* volArg);
-    static Volume *load_volume(int volDataID, int width, int height, int depth, 
-        int n, float* data, double vmin, double vmax, double nzero_min);
+    static Volume *load_volume(const char *tag, int width, int height, 
+                int depth, int n, float* data, double vmin, double vmax, 
+                double nzero_min);
     static void xinetd_listen(void);
     static int render_2d_contour(HeightMap* heightmap, int width, int height);
@@ -233 +233 @@
     };
     static void EventuallyRedraw(unsigned int flag = 0);
-    static void remove_volume(size_t index);
-    static int generate_data_identifier();
+    static void remove_volume(Volume *volPtr);
+    static Tcl_HashTable tfTable;
 };
 
+extern Volume *load_volume_stream(Rappture::Outcome &status, const char *tag, 
+                        std::iostream& fin);
+extern Volume *load_volume_stream_odx(Rappture::Outcome &status, 
+        const char *tag, const char *buf, int nBytes);
+extern Volume *load_volume_stream2(Rappture::Outcome &status, const char *tag, 
+        std::iostream& fin);
+
+extern Volume *load_vector_stream(Rappture::Outcome &result, const char *tag, 
+        size_t length, char *bytes);
+extern Volume *load_vector_stream2(Rappture::Outcome &result, const char *tag, 
+        size_t length, char *bytes);
+
 
 #endif  /* __NANOVIS_H__ */