Changeset 1429

Timestamp:

May 11, 2009, 4:39:13 PM (16 years ago)

Author:

gah

Message:

Initial commit of new flow visualization command structure

Location:

trunk/packages/vizservers/nanovis

Files:

• Command.cpp (modified) (8 diffs)
• FlowCmd.cpp (added)
• FlowCmd.h (added)
• FlowCmds.cpp (modified) (34 diffs)
• LoadVector.cpp (modified) (8 diffs)
• Makefile.in (modified) (1 diff)
• NvFlowVisRenderer.h (modified) (1 diff)
• NvLIC.cpp (modified) (5 diffs)
• NvParticleRenderer.cpp (modified) (4 diffs)
• Switch.h (modified) (1 diff)
• Trace.h (modified) (1 diff)
• Unirect.cpp (modified) (16 diffs)
• Unirect.h (modified) (2 diffs)
• Volume.cpp (modified) (1 diff)
• VolumeRenderer.cpp (modified) (3 diffs)
• VolumeRenderer.h (modified) (1 diff)
• config.h (modified) (1 diff)
• dxReader.cpp (modified) (7 diffs)
• nanovis.cpp (modified) (19 diffs)
• nanovis.h (modified) (2 diffs)

trunk/packages/vizservers/nanovis/Command.cpp

@@ -141 +141 @@
 static Tcl_ObjCmdProc CameraCmd;
 static Tcl_ObjCmdProc CutplaneCmd;
-static Tcl_ObjCmdProc FlowCmd;
+extern Tcl_AppInitProc FlowCmdInitProc;
 static Tcl_ObjCmdProc GridCmd;
 static Tcl_ObjCmdProc LegendCmd;
@@ -1725 +1725 @@
 // ========================= VOLUME END ==================================
 
+#ifdef notdef
 // ============================= FLOW ==================================
 
@@ -1957 +1958 @@
         return TCL_ERROR;
     }
-    NanoVis::lic_on = state;
+    /* NanoVis::lic_on = state; */
     return TCL_OK;
 }
@@ -1973 +1974 @@
         return TCL_ERROR;
     }
+#ifdef notdef
     switch (axis) {
     case 0 :
@@ -1984 +1986 @@
         break;
     }
+#endif
     return TCL_OK;
 }
@@ -2053 +2056 @@
     }
 
-    NanoVis::particle_on = state;
+    /* NanoVis::particle_on = state; */
     return TCL_OK;
 }
@@ -2199 +2202 @@
 
 // ============================ FLOW END ==================================
+#endif
 
 static int
@@ -2832 +2836 @@
     Tcl_Interp *interp;
     interp = Tcl_CreateInterp();
+    /*
     Tcl_MakeSafe(interp);
-
+    */
     Tcl_CreateObjCommand(interp, "axis",        AxisCmd,        NULL, NULL);
     Tcl_CreateObjCommand(interp, "camera",      CameraCmd,      NULL, NULL);
     Tcl_CreateObjCommand(interp, "cutplane",    CutplaneCmd,    NULL, NULL);
-    Tcl_CreateObjCommand(interp, "flow",        FlowCmd,        NULL, NULL);
+    if (FlowCmdInitProc(interp) != TCL_OK) {
+        return NULL;
+    }
     Tcl_CreateObjCommand(interp, "grid",        GridCmd,        NULL, NULL);
     Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   NULL, NULL);

trunk/packages/vizservers/nanovis/FlowCmds.cpp

@@ -42 +42 @@
 #include <assert.h>
 #include <stdlib.h>
-#include <tcl.h>
+#include <stddef.h>
+/*#include <tcl.h>*/
+#include "Vector4.h"
 #include "Switch.h"
+#include "Unirect.h"
+#include "FlowCmd.h"
+
 #include <RpField1D.h>
 #include <RpFieldRect3D.h>
@@ -70 +75 @@
 #include "RenderContext.h"
 #include "NvLIC.h"
-#include "Unirect.h"
-#include "FlowCmd.h"
 
 static Tcl_HashTable flowTable;
 
-static int
-GetFlowFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, FlowCmd **flowPtrPtr)
-{
-    Tcl_HashEntry *hPtr;
-    hPtr = Tcl_FindHashEntry(&flowTable, Tcl_GetString(objPtr));
-    if (hPtr == NULL) {
-        if (interp != NULL) {
-            Tcl_AppendResult(interp, "can't find a flow \"", 
-                             Tcl_GetString(objPtr), "\"", (char *)NULL);
-        }
-        return TCL_ERROR;
-    }
-    *flowPtrPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
-    return TCL_OK;
-}
+extern bool load_vector_stream2(Rappture::Outcome &result, int index, 
+        size_t length, Rappture::Unirect3d *dataPtr);
+
+/*
+    physicalMin.set(dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
+    physicalMax.set(dataPtr->xMax(), dataPtr->yMax(), dataPtr->zMax());
+*/
+static float *
+MakeFlowVector(Rappture::Unirect3d *dataPtr, double minMag, double maxMag)
+{
+    float *data = new float[4* dataPtr->nValues()];
+    if (data == NULL) {
+        return NULLL;
+    }
+    memset(data, 0, sizeof(float) * 4 * dataPtr->nValues());
+    float *destPtr = data;
+    float *srcPtr = dataPtr->values();
+    for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
+        for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
+            for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
+                double vx, vy, vz, vm;
+                vx = values[0];
+                vy = values[1];
+                vz = values[2];
+                vm = sqrt(vx*vx + vy*vy + vz*vz);
+                destPtr[0] = vm / maxMag; 
+                destPtr[1] = vx /(2.0*maxMag) + 0.5; 
+                destPtr[2] = vy /(2.0*maxMag) + 0.5; 
+                destPtr[3] = vz /(2.0*maxMag) + 0.5; 
+                srcPtr += 3;
+                destPtr += 4;
+            }
+        }
+    }
+    return data;
+}
+
+static Volume *
+MakeFlowVolume(Rappture::Unirect3d *dataPtr, double minMag, double maxMag, 
+               float *data)
+{
+    Volume *volPtr;
+
+    ivol = NanoVis::n_volumes;
+    volPtr = NanoVis::load_volume(ivol, dataPtr->xNum(), dataPtr->yNum(), 
+        dataPtr->zNum(), 4, data, minMag, maxMag, 0);
+    volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMax());
+    volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMax());
+    volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMax());
+    volPtr->wAxis.SetRange(minMag, maxMag);
+    volPtr->update_pending = true;
+    volPtr->setPhysicalBBox(physicalMin, physicalMax);
+    //
+    // 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);
+    
+    NanoVis::vol_renderer->add_volume(volPtr, 
+        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 volPtr;
+}
+
 
 static int
@@ -95 +159 @@
                Tcl_Obj *const *objv)
 {
-    Rappture::Outcome context;
+    Rappture::Outcome result;
 
     const char *fileName;
@@ -106 +170 @@
     }
     Rappture::Buffer buf;
-    if (!buf.load(context, fileName)) {
+    if (!buf.load(result, fileName)) {
         Tcl_AppendResult(interp, "can't load data from \"", fileName, "\": ",
-                         context.remark(), (char *)NULL);
+                         result.remark(), (char *)NULL);
         return TCL_ERROR;
     }
@@ -114 +178 @@
     FlowCmd *flowPtr = (FlowCmd *)clientData;
     if (strncmp(buf.bytes(), "<DX>", 4) == 0) {
-        Rappture::Unirect3d data;
-        if (!load_vector_stream2(context, buf.size(), (char *)buf.bytes(), 
-                                 data)) {
-            Tcl_AppendResult(interp, context.remark(), (char *)NULL);
+        Rappture::Unirect3d *dataPtr;
+
+        dataPtr = new Rappture::Unirect3d();
+        if (!dataPtr->ReadVectorDataFromDx(result, buf.size(), 
+                (char *)buf.bytes())) {
+            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
+            delete dataPtr;
             return TCL_ERROR;
         }
-        flowPtr->dataPtr = &data;
+        flowPtr->dataPtr = dataPtr;
     } else if (strncmp(buf.bytes(), "<unirect3d>", 4) == 0) {
-        Rappture::Unirect3d data;
+        Rappture::Unirect3d *dataPtr;
         Tcl_CmdInfo cmdInfo;
 
@@ -130 +197 @@
             return TCL_ERROR;
         }
-        data.extents(extents);
-        cmdInfo.objClientData = (ClientData)&data;      
+        dataPtr = new Rappture::Unirect3d();
+        dataPtr->extents(extents);
+        cmdInfo.objClientData = (ClientData)dataPtr;    
         Tcl_SetCommandInfo(interp, "unirect3d", &cmdInfo);
         if (Tcl_Eval(interp, (const char *)buf.bytes()) != TCL_OK) {
+            delete dataPtr;
             return TCL_ERROR;
         }
-        if (!data.isInitialized()) {
+        if (!dataPtr->isInitialized()) {
+            delete dataPtr;
             return TCL_ERROR;
         }
-        flowPtr->dataPtr = &data;
+        flowPtr->dataPtr = dataPtr;
     }
 
@@ -174 +244 @@
                     Tcl_Obj *const *objv)
 {
-    Rappture::Outcome context;
+    Rappture::Outcome result;
 
     Trace("Flow Data Loading\n");
@@ -192 +262 @@
     FlowCmd *flowPtr = (FlowCmd *)clientData;
     if (strncmp(buf.bytes(), "<DX>", 4) == 0) {
-        if (!load_vector_stream2(context, buf.size(), (char *)buf.bytes(), 
-                flowPtr)) {
-            Tcl_AppendResult(interp, context.remark(), (char *)NULL);
+        Rappture::Unirect3d *dataPtr;
+
+        dataPtr = new Rappture::Unirect3d();
+        if (!dataPtr->ReadVectorDataFromDx(result, buf.size(), 
+                (char *)buf.bytes())) {
+            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
+            delete dataPtr;
             return TCL_ERROR;
         }
+        flowPtr->dataPtr = dataPtr;
     } else if (strncmp(buf.bytes(), "<unirect3d>", 4) == 0) {
-        Rappture::Unirect3d data;
+        Rappture::Unirect3d *dataPtr;
         Tcl_CmdInfo cmdInfo;
 
         /* Set the clientdata field of the unirect3d command to contain
          * the local data structure. */
+        dataPtr = new Rappture::Unirect3d();
         if (!Tcl_GetCommandInfo(interp, "unirect3d", &cmdInfo)) {
             return TCL_ERROR;
         }
-        data.extents(extents);
-        cmdInfo.objClientData = (ClientData)&data;      
+        dataPtr->extents(extents);
+        cmdInfo.objClientData = (ClientData)dataPtr;    
         Tcl_SetCommandInfo(interp, "unirect3d", &cmdInfo);
         if (Tcl_Eval(interp, (const char *)buf.bytes()) != TCL_OK) {
+            delete dataPtr;
             return TCL_ERROR;
         }
-        if (!data.isInitialized()) {
+        if (!dataPtr->isInitialized()) {
+            delete dataPtr;
             return TCL_ERROR;
         }
-        if (!SetVectorFieldDataFromUnirect3d(context, data, flowPtr)) {
-            Tcl_AppendResult(interp, context.remark(), (char *)NULL);
-            return TCL_ERROR;
-        }
-    }
-    if (flowPtr->volPtr != NULL) {
-        delete flowPtr->volPtr;
-    }
-    #ifdef notdef
+        flowPtr->dataPtr = dataPtr;
+    }
+#ifdef notdef
     // FIXME: Move this to flow pending routine.
 
@@ -249 +321 @@
     float dz0 = -0.5*flowPtr->volPtr->depth/flowPtr->volPtr->width;
     flowPtr->volPtr->move(Vector3(dx0, dy0, dz0));
-    #endif
+#endif
     return TCL_OK;
 }
@@ -273 +345 @@
 }
 
-
+/*
+ *      Can configure axis of stream plane, the position on the axis, and if
+ *      the stream plane is visible.
+ *
+ */
 static Rappture::SwitchSpec streamSwitches[] = 
 {
@@ -284 +360 @@
 
 static int
-FlowStreamConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
+FlowSliceConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
                      Tcl_Obj *const *objv)
 {
@@ -295 +371 @@
     streamPtr = flowPtr->streams + axis;
 
-    if (Rappture::ParseSwitches(interp, streamSwitches, objc - 3, objv + 3, 
+    if (flowPtr->ParseRappture::ParseSwitches(interp, streamSwitches, objc - 3, objv + 3, 
         streamPtr, SWITCH_DEFAULTS) < 0) {
         return TCL_ERROR;
     }
+    // Save the values in the stream
+    streamPtr->axis;
     NanoVis::lic_slice_x = streamPtr->position;
     NanoVis::licRenderer->set_axis(axis);
@@ -324 +402 @@
     return (*proc) (clientData, interp, objc, objv);
 }
-
-static int
-FlowParticlesVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
-             Tcl_Obj *const *objv)
-{
-    bool state;
-    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
-        return TCL_ERROR;
-    }
-
-    NanoVis::particle_on = state;
-    return TCL_OK;
-}
-
-static Rappture::CmdSpec flowParticlesOps[] = {
-    {"visible",    1, FlowParticlesVisibleOp,  4, 4, "on|off",},
-};
-static int nFlowParticlesOps = NumCmdSpecs(flowParticlesOps);
-
-static int
-FlowParticlesOp(ClientData clientData, Tcl_Interp *interp, int objc,
-             Tcl_Obj *const *objv)
-{
-    Tcl_ObjCmdProc *proc;
-
-    proc = Rappture::GetOpFromObj(interp, nFlowParticlesOps, flowParticlesOps,
-                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
-    if (proc == NULL) {
-        return TCL_ERROR;
-    }
-    return (*proc) (clientData, interp, objc, objv);
-}
-
 
 static int
@@ -387 +432 @@
 }
 
-static Rappture::SwitchSpec flowSwitches[] = 
-{
-    {Rappture::SWITCH_BOOLEAN, "-lic", "boolean",
-        offsetof(FlowCmd, lic), 0},
+static Rappture::SwitchSpec streamSwitches[] = 
+{
     {Rappture::SWITCH_BOOLEAN, "-hide", "boolean",
-        offsetof(FlowCmd, hidden), 0},
+        offsetof(Stream, hidden), 0},
+    {Rappture::SWITCH_FLOAT, "-position", "number",
+        offsetof(Stream, position), 0},
     {Rappture::SWITCH_END}
 };
 
+static Rappture::SwitchParseProc AxisSwitchProc;
+
+static Rappture:;SwitchCustom axisSwitch = {
+    AxisSwitchProc, NULL, 0,
+};
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * AxisSwitch --
+ *
+ *      Convert a Tcl_Obj representing the label of a child node into its
+ *      integer node id.
+ *
+ * Results:
+ *      The return value is a standard Tcl result.
+ *
+ *---------------------------------------------------------------------------
+ */
+/*ARGSUSED*/
+static int
+AxisSwitch(
+    ClientData clientData,      /* Flag indicating if the node is considered
+                                 * before or after the insertion position. */
+    Tcl_Interp *interp,         /* Interpreter to send results back to */
+    const char *switchName,     /* Not used. */
+    Tcl_Obj *objPtr,            /* String representation */
+    char *record,               /* Structure record */
+    int offset,                 /* Not used. */
+    int flags)                  /* Not used. */
+{
+    const char *string = Tcl_GetString(objPtr);
+    if (string[1] == '\0') {
+        FlowCmd::SliceAxis *axisPtr = (FlowCmd::SliceAxis *)(record + offset);
+        char c;
+        c = tolower((unsigned char)string[0]);
+        if (c == 'x') {
+            *axisPtr = FlowCmd::SliceAxis::AXIS_X;
+            return TCL_OK;
+        } else if (c == 'y') {
+            *axisPtr = FlowCmd::SliceAxis::AXIS_Y;
+            return TCL_OK;
+        } else if (c == 'z') {
+            *axisPtr = FlowCmd::SliceAxis::AXIS_Z;
+            return TCL_OK;
+        }
+        /*FALLTHRU*/
+    }
+    Tcl_AppendResult(interp, "bad axis \"", string,
+                     "\": should be x, y, or z", (char*)NULL);
+    return TCL_ERROR;
+}
+
 static int
 FlowConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
                 Tcl_Obj *const *objv)
 {
-    int axis;
-    if (GetAxisFromObj(interp, objv[3], &axis) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    FlowCmd *flowPtr = (FlowCmd *)clientData;
-    if (Rappture::ParseSwitches(interp, flowSwitches, objc - 3, objv + 3, 
-        flowPtr, SWITCH_DEFAULTS) < 0) {
-        return TCL_ERROR;
-    }
+    FlowCmd *flowPtr = (FlowCmd *)clientData;
+
+    if (flowPtr->ParseSwitches(interp, objc - 3, objv + 3) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    flowPtr->SetAxis();
+    flowPtr->SetSlicePosition();
+    flowPtr->SliceVisible();
+    flowPtr->Visible();
     return TCL_OK;
 }
@@ -421 +519 @@
 };
 
-static int
-FlowInjectorAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
-                Tcl_Obj *const *objv)
+
+static int
+FlowParticlesAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
+                   Tcl_Obj *const *objv)
+{
+    FlowCmd *flowPtr = (FlowCmd *)clientData;
+
+    if (flowPtr->CreatePlane(interp, objv[3])) {
+        return TCL_ERROR;
+    }
+    Particles *particlesPtr;
+    if (flowPtr->GetPlane(interp, objv[3], &particlesPtr) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (particlesPtr->ParseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
+        flowPtr->DestroyPlane(particlesPtr);
+        return TCL_ERROR;
+    }
+    particlesPtr->SetPosition();
+    particlesPtr->SetColor();
+    particlesPtr->SetAxis();
+    particlesPtr->Visible();
+    return TCL_OK;
+}
+
+static int
+FlowParticlesConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
+                         Tcl_Obj *const *objv)
+{
+    FlowCmd *flowPtr = (FlowCmd *)clientData;
+
+    Particles *particlesPtr;
+    if (flowPtr->GetPlane(interp, objv[3], &particlesPtr) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (particlesPtr->ParseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    particlesPtr->SetPosition();
+    particlesPtr->SetColor();
+    particlesPtr->SetAxis();
+    particlesPtr->Visible();
+    return TCL_OK;
+}
+
+static int
+FlowParticlesDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
+                      Tcl_Obj *const *objv)
+{
+    FlowCmd *flowPtr = (FlowCmd *)clientData;
+    int i;
+    for (i = 3; i < objc; i++) {
+        Particles *particlesPtr;
+
+        if (flowPtr->GetPlane(interp, objv[i], &particlesPtr)!=TCL_OK) {
+            return TCL_ERROR;
+        }
+        flowPtr->DestroyPlane(particlesPtr);
+    }
+    return TCL_OK;
+}
+
+static int
+FlowParticlesNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
+                     Tcl_Obj *const *objv)
+{
+    FlowCmd *flowPtr = (FlowCmd *)clientData;
+    Tcl_Obj *listObjPtr;
+    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
+    ParticlesIterator iter;
+    Particles *particlesPtr;
+    for (particlesPtr = flowPtr->FirstPlane(&iter); particlesPtr != NULL; 
+         particlesPtr = flowPtr->NextPlane(&iter)) {
+
+        objPtr = Tcl_NewStringObj(particlesPtr->Name(), -1);
+        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
+    }
+    Tcl_SetObjResult(interp, listObjPtr);
+    return TCL_OK;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * FlowParticlesObjCmd --
+ *
+ *      This procedure is invoked to process commands on behalf of the flow
+ *      object.
+ *
+ * Results:
+ *      A standard Tcl result.
+ *
+ * Side effects:
+ *      See the user documentation.
+ *
+ * $flow particles oper $name 
+ *---------------------------------------------------------------------------
+ */
+static Rappture::CmdSpec flowParticlesOps[] = {
+    {"add",        1, FlowParticlesAddOp,        3, 0, "name ?switches?",},
+    {"configure",  1, FlowParticlesConfigureOp,  3, 0, "name ?switches?",},
+    {"delete",     1, FlowParticlesDeleteOp,     3, 0, "?name...?"},
+    {"names",      1, FlowParticlesNamesOp,      3, 4, "?pattern?"},
+};
+
+static int nFlowInjectorOps = NumCmdSpecs(flowInjectorOps);
+
+static int
+FlowInjectorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+    proc = Rappture::GetOpFromObj(interp, nFlowInjectorOps, flowInjectorOps, 
+        Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    FlowCmd *flowPtr = (FlowCmd *)clientData;
+    Tcl_Preserve(flowPtr);
+    int result;
+    result = (*proc) (clientData, interp, objc, objv);
+    Tcl_Release(flowPtr);
+    return result;
+}
+
+static int
+FlowShapeAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
+               Tcl_Obj *const *objv)
 {
     FlowCmd *flowPtr = (FlowCmd *)clientData;
@@ -456 +679 @@
 
 static int
-FlowInjectorDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
+FlowShapeDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
                    Tcl_Obj *const *objv)
 {
@@ -476 +699 @@
 
 static int
-FlowInjectorNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
+FlowShapeNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
              Tcl_Obj *const *objv)
 {
@@ -483 +706 @@
     Tcl_HashSearch iter;
     Tcl_Obj *listObjPtr;
+
     listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
     for (hPtr = Tcl_FirstHashEntry(&flowPtr->injectTable, &iter);
@@ -498 +722 @@
 
 static int
-FlowInjectorConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
+FlowShapeConfigureOp(ClientData clientData, Tcl_Interp *interp, int objc,
                         Tcl_Obj *const *objv)
 {
@@ -519 +743 @@
 }
 
-
-/*
- *---------------------------------------------------------------------------
- *
- * FlowInjectorObjCmd --
+/*
+ *---------------------------------------------------------------------------
+ *
+ * FlowShapeOp--
  *
  *      This procedure is invoked to process commands on behalf of the flow
@@ -536 +759 @@
  *---------------------------------------------------------------------------
  */
-static Rappture::CmdSpec flowInjectorOps[] = {
-    {"add",        1, FlowInjectorAddOp,        3, 0, "name ?switches?",},
-    {"configure",  1, FlowInjectorConfigureOp,  3, 5, "name ?switches?",},
-    {"delete",     1, FlowInjectorDeleteOp,     3, 0, "?name...?"},
-    {"names",      1, FlowInjectorNamesOp,      3, 4, "?pattern?"},
+static Rappture::CmdSpec flowShapeOps[] = {
+    {"add",        1, FlowShapeAddOp,        3, 0, "name ?switches?",},
+    {"configure",  1, FlowShapeConfigureOp,  3, 5, "name ?switches?",},
+    {"delete",     1, FlowShapeDeleteOp,     3, 0, "?name...?"},
+    {"names",      1, FlowShapeNamesOp,      3, 4, "?pattern?"},
 };
 
-static int nFlowInjectorOps = NumCmdSpecs(flowInjectorOps);
-
-static int
-FlowInjectorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+static int nFlowShapeOps = NumCmdSpecs(flowShapeOps);
+
+static int
+FlowShapeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
 {
     Tcl_ObjCmdProc *proc;
-    proc = Rappture::GetOpFromObj(interp, nFlowInjectorOps, flowInjectorOps, 
+    proc = Rappture::GetOpFromObj(interp, nFlowShapeOps, flowShapeOps, 
         Rappture::CMDSPEC_ARG1, objc, objv, 0);
     if (proc == NULL) {
@@ -566 +789 @@
  *---------------------------------------------------------------------------
  *
- * FlowShapeOp--
+ * FlowInstObjCmd --
  *
  *      This procedure is invoked to process commands on behalf of the flow
@@ -579 +802 @@
  *---------------------------------------------------------------------------
  */
-static Rappture::CmdSpec flowShapeOps[] = {
-    {"add",        1, FlowInjectorAddOp,        3, 0, "name ?switches?",},
-    {"configure",  1, FlowInjectorConfigureOp,  3, 5, "name ?switches?",},
-    {"delete",     1, FlowInjectorDeleteOp,     3, 0, "?name...?"},
-    {"names",      1, FlowInjectorNamesOp,      3, 4, "?pattern?"},
+static Rappture::CmdSpec flowInstOps[] = {
+    {"configure",   1, FlowConfigureOp,  3, 5, "?switches?",},
+    {"data",        1, FlowDataOp,       4, 0, "oper ?args?"},
+    {"particles",   1, FlowParticlesOp,  3, 0, "oper ?args?",},
+    {"shape",       2, FlowShapeOp,      3, 0, "oper ?args?",},
 };
-
-static int nFlowShapeOps = NumCmdSpecs(flowShapeOps);
-
-static int
-FlowShapeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+static int nFlowInstOps = NumCmdSpecs(flowInstOps);
+
+static int
+FlowInstObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
 {
     Tcl_ObjCmdProc *proc;
-    proc = Rappture::GetOpFromObj(interp, nFlowShapeOps, flowShapeOps, 
+    proc = Rappture::GetOpFromObj(interp, nFlowInstOps, flowInstOps, 
         Rappture::CMDSPEC_ARG1, objc, objv, 0);
     if (proc == NULL) {
@@ -609 +831 @@
  *---------------------------------------------------------------------------
  *
- * FlowInstObjCmd --
- *
- *      This procedure is invoked to process commands on behalf of the flow
- *      object.
- *
- * Results:
- *      A standard Tcl result.
- *
- * Side effects:
- *      See the user documentation.
- *
- *---------------------------------------------------------------------------
- */
-static Rappture::CmdSpec flowInstOps[] = {
-    {"configure",   1, FlowConfigureOp,  3, 5, "?switches?",},
-    {"data",        1, FlowDataOp,       4, 0, "oper ?args?"},
-    {"injector",    1, FlowInjectorOp,   3, 0, "oper ?args?",},
-    {"particles",   1, FlowParticlesOp,  3, 0, "oper ?args?",},
-    {"shape",       2, FlowShapeOp,      3, 0, "oper ?args?",},
-    {"stream",      2, FlowStreamOp,     4, 0, "oper axis ?args?",},
-};
-static int nFlowInstOps = NumCmdSpecs(flowInstOps);
-
-static int
-FlowInstObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
-               Tcl_Obj *const *objv)
-{
-    Tcl_ObjCmdProc *proc;
-    proc = Rappture::GetOpFromObj(interp, nFlowInstOps, flowInstOps, 
-        Rappture::CMDSPEC_ARG1, objc, objv, 0);
-    if (proc == NULL) {
-        return TCL_ERROR;
-    }
-    FlowCmd *flowPtr = (FlowCmd *)clientData;
-    Tcl_Preserve(flowPtr);
-    int result;
-    result = (*proc) (clientData, interp, objc, objv);
-    Tcl_Release(flowPtr);
-    return result;
-}
-
-/*
- *---------------------------------------------------------------------------
- *
  * FlowInstDeleteProc --
  *
@@ -667 +845 @@
 {
     FlowCmd *flowPtr = (FlowCmd *)clientData;
-
-    if (flowPtr->hashPtr != NULL) {
-        Tcl_DeleteHashEntry(flowPtr->hashPtr);
-    }
     delete flowPtr;
 }
@@ -686 +860 @@
           Tcl_Obj *const *objv)
 {
-    const char *name;
-    name = Tcl_GetString(objv[2]);
-
-    Tcl_HashEntry *hPtr;
-    int isNew;
-    hPtr = Tcl_CreateHashEntry(&flowTable, name, &isNew);
-    if (!isNew) {
-        Tcl_AppendResult(interp, "flow \"", name, "\" already exists.",
-                         (char *)NULL);
-        return TCL_ERROR;
-    }
-    Tcl_CmdInfo cmdInfo;
-    if (Tcl_GetCommandInfo(interp, name, &cmdInfo)) {
-        Tcl_AppendResult(interp, "an another command \"", name, 
-                         "\" already exists.", (char *)NULL);
-        return TCL_ERROR;
-    }   
-    FlowCmd *flowPtr;
-    flowPtr = new FlowCmd;
-    if (flowPtr == NULL) {
-        Tcl_AppendResult(interp, "can't allocate a flow object \"", name, 
-                         "\"", (char *)NULL);
-        return TCL_ERROR;
-    }
-    flowPtr->hashPtr = hPtr;
-    flowPtr->name = Tcl_GetHashKey(&flowTable, hPtr);
-    flowPtr->cmdToken = Tcl_CreateObjCommand(interp, (char *)name, 
-        (Tcl_ObjCmdProc *)FlowInstObjCmd, flowPtr, FlowInstDeleteProc);
-    Tcl_SetHashValue(hPtr, flowPtr);
-    flowPtr->volPtr = NULL;
-    return TCL_OK;
+    return FlowCmd::NewFlow(interp, Tcl_GetString(objv[2]));
 }
 
@@ -736 +880 @@
         FlowCmd *flowPtr;
 
-        if (GetFlowFromObj(interp, objv[i], &flowPtr) != TCL_OK) {
+        if (FlowCmd::GetFlowFromObj(interp, objv[i], &flowPtr) != TCL_OK) {
             return TCL_ERROR;
         }
-        Tcl_DeleteCommandFromToken(interp, flowPtr->cmdToken);
-#ifdef notdef
-        NanoVis::flowVisRenderer->removeVectorField(flowPtr);
-#endif
         delete flowPtr;
     }
@@ -890 +1030 @@
 
     // Generate the latest frame and send it back to the client
-    if (NanoVis::licRenderer->isActivated()) {
-        NanoVis::licRenderer->convolve();
-    }
-    NanoVis::flowVisRenderer->advect();
+    NanoVis::licRenderer->convolve();
+    FlowCmd::AdvectFlows();
     NanoVis::offscreen_buffer_capture();  //enable offscreen render
     NanoVis::display();
@@ -943 +1081 @@
         return TCL_ERROR;
     }
-
-    if (NanoVis::licRenderer) {
-        NanoVis::licRenderer->activate();
-    }
-    if (NanoVis::flowVisRenderer) {
-        NanoVis::flowVisRenderer->activate();
-    }
+    if (NanoVis::licRenderer == NULL) {
+        Tcl_AppendResult(interp, "no lic renderer.", (char *)NULL);
+        return TCL_ERROR;
+    }
+    if (NanoVis::flowVisRenderer == NULL) {
+        Tcl_AppendResult(interp, "no flow renderer.", (char *)NULL);
+        return TCL_ERROR;
+    }
+    NanoVis::licRenderer->activate();
+    NanoVis::flowVisRenderer->activate();
 
     // Save the old dimensions of the offscreen buffer.
@@ -966 +1107 @@
     Trace("FLOW started\n");
 
-    Rappture::Outcome context;
+    Rappture::Outcome result;
     Rappture::AVTranslate movie(width, height, frameRate, bitRate);
 
@@ -974 +1115 @@
     }
 
-    movie.init(context, fileName);
+    movie.init(result, fileName);
 
     for (int i = 0; i < numFrames; i++) {
         // Generate the latest frame and send it back to the client
-        if (NanoVis::licRenderer &&
-            NanoVis::licRenderer->isActivated()) {
-            NanoVis::licRenderer->convolve();
-        }
-        if (NanoVis::flowVisRenderer &&
-            NanoVis::flowVisRenderer->isActivated()) {
-            NanoVis::flowVisRenderer->advect();
-        }
+        NanoVis::licRenderer->convolve();
+        FlowCmd::AdvectFlows();
         NanoVis::offscreen_buffer_capture();  //enable offscreen render
         NanoVis::display();
@@ -994 +1129 @@
         // This is done before bmp_write_to_file because bmp_write_to_file
         // turns rgb data to bgr
-        movie.append(context, NanoVis::screen_buffer, pad);
+        movie.append(result, NanoVis::screen_buffer, pad);
         // NanoVis::bmp_write_to_file(frame_count, fileName);
     }
 
-    movie.done(context);
+    movie.done(result);
     Trace("FLOW end\n");
 
@@ -1011 +1146 @@
     // FIXME: find a way to get the data from the movie object as a void*
     Rappture::Buffer data;
-    if (!data.load(context, fileName)) {
+    if (!data.load(result, fileName)) {
         Tcl_AppendResult(interp, "can't load data from temporary movie file \"",
-                fileName, "\": ", context.remark(), (char *)NULL);
+                fileName, "\": ", result.remark(), (char *)NULL);
         return TCL_ERROR;
     }
@@ -1088 +1223 @@
 }
 
-#ifdef notdef
-void
-MapFlowVectors(Tcl_Interp *interp)
-{
-    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
-
-    if (debug_flag) {
-        fprintf(stderr, "in SetHeightmapRanges\n");
-    }
-    xMin = yMin = zMin = wMin = DBL_MAX;
-    xMax = yMax = zMax = wMax = -DBL_MAX;
-    Tcl_HashEntry *hPtr;
-    Tcl_HashSearch iter;
-    for (hPtr = Tcl_FirstHashEntry(&flowTable, &iter); hPtr != NULL; 
-        hPtr = Tcl_NextHashEntry(&iter)) {
-        FlowCmd *flowPtr;
-        flowPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
-
-        flowPtr->
-
-    for (unsigned int i = 0; i < heightMap.size(); i++) {
-        HeightMap *hmPtr;
-
-        hmPtr = heightMap[i];
-        if (hmPtr == NULL) {
-            continue;
-        }
-        if (xMin > hmPtr->xAxis.min()) {
-            xMin = hmPtr->xAxis.min();
-        }
-        if (xMax < hmPtr->xAxis.max()) {
-            xMax = hmPtr->xAxis.max();
-        }
-        if (yMin > hmPtr->yAxis.min()) {
-            yMin = hmPtr->yAxis.min();
-        }
-        if (yMax < hmPtr->yAxis.max()) {
-            yMax = hmPtr->yAxis.max();
-        }
-        if (zMin > hmPtr->zAxis.min()) {
-            zMin = hmPtr->zAxis.min();
-        }
-        if (zMax < hmPtr->zAxis.max()) {
-            zMax = hmPtr->zAxis.max();
-        }
-        if (wMin > hmPtr->wAxis.min()) {
-            wMin = hmPtr->wAxis.min();
-        }
-        if (wMax < hmPtr->wAxis.max()) {
-            wMax = hmPtr->wAxis.max();
-        }
-    }
-    if ((xMin < DBL_MAX) && (xMax > -DBL_MAX)) {
-        grid->xAxis.SetScale(xMin, xMax);
-    }
-    if ((yMin < DBL_MAX) && (yMax > -DBL_MAX)) {
-        grid->yAxis.SetScale(yMin, yMax);
-    }
-    if ((zMin < DBL_MAX) && (zMax > -DBL_MAX)) {
-        grid->zAxis.SetScale(zMin, zMax);
-    }
-    if ((wMin < DBL_MAX) && (wMax > -DBL_MAX)) {
-        HeightMap::valueMin = grid->yAxis.min();
-        HeightMap::valueMax = grid->yAxis.max();
-    }
-    for (unsigned int i = 0; i < heightMap.size(); i++) {
-        HeightMap *hmPtr;
-
-        hmPtr = heightMap[i];
-        if (hmPtr == NULL) {
-            continue;
-        }
-        hmPtr->MapToGrid(grid);
-    }
-    HeightMap::update_pending = false;
-    if (debug_flag) {
-        fprintf(stderr, "leaving SetHeightmapRanges\n");
-    }
-}
-
-    Tcl_Obj *listObjPtr;
-    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
-
-    Tcl_HashEntry *hPtr;
-    Tcl_HashSearch iter;
-    for (hPtr = Tcl_FirstHashEntry(&flowTable, &iter); hPtr != NULL; 
-        hPtr = Tcl_NextHashEntry(&iter)) {
-        FlowCmd *flowPtr;
-        flowPtr = (FlowCmd *)Tcl_GetHashValue(hPtr);
-        if (flowPtr->fieldPtr != NULL) {
-            delete flowPtr->fieldPtr; // Remove the vector field.
-            flowPtr->fieldPtr = NULL;
-        }
-    }
-
-
-            Volume *volPtr;
-            volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
-                        field.valueMin(), field.valueMax(), nzero_min);
-            volPtr->xAxis.SetRange(field.rangeMin(Rappture::xaxis),
-                   field.rangeMax(Rappture::xaxis));
-            volPtr->yAxis.SetRange(field.rangeMin(Rappture::yaxis),
-                   field.rangeMax(Rappture::yaxis));
-            volPtr->zAxis.SetRange(field.rangeMin(Rappture::zaxis),
-                   field.rangeMax(Rappture::zaxis));
-            volPtr->wAxis.SetRange(field.valueMin(), field.valueMax());
-            volPtr->update_pending = true;
-            delete [] data;
-#endif

trunk/packages/vizservers/nanovis/LoadVector.cpp

@@ -12 +12 @@
 #include "FlowCmd.h"
 
-static INLINE char *
-skipspaces(char *string) 
+    
+
+bool
+ScaleVectorFieldData(Rappture::Outcome &context, Rappture::Unirect3d *dataPtr)
 {
-    while (isspace(*string)) {
-        string++;
-    }
-    return string;
-}
-
-static INLINE char *
-getline(char **stringPtr, char *endPtr) 
-{
-    char *line, *p;
-
-    line = skipspaces(*stringPtr);
-    for (p = line; p < endPtr; p++) {
-        if (*p == '\n') {
-            *p++ = '\0';
-            *stringPtr = p;
-            return line;
-        }
-    }
-    *stringPtr = p;
-    return line;
-}
-
-bool
-SetVectorFieldData(Rappture::Outcome &context, 
-                   float xMin, float xMax, size_t xNum, 
-                   float yMin, float yMax, size_t yNum, 
-                   float zMin, float zMax, size_t zNum, 
-                   size_t nValues, float *values, Unirect3d *dataPtr)
-{
+    float *values = dataPtr->values();
+    float *nValues = dataPtr->nValues();
 #ifdef notdef
     double max_x = -1e21, min_x = 1e21;
@@ -74 +48 @@
             xNum, yNum, zNum, xNum * yNum * zNum);
     
-    // Generate the uniformly sampled rectangle that we need for a volume
     float *destPtr = data;
     float *srcPtr = values;
@@ -97 +70 @@
         }
     }
-    dataPtr->xMin(xMin);
-    dataPtr->xMax(xMax);
-    dataPtr->xNum(xNum);
-    dataPtr->yMin(yMin);
-    dataPtr->yMax(yMax);
+    dataPtr->SetValues(xMin, xMax, xNum, yMin, yMax(yMax);
     dataPtr->yNum(yNum);
     dataPtr->yMin(zMin);
@@ -113 +82 @@
 
 bool
-SetResampledVectorFieldData(Rappture::Outcome &context, 
-                            float xMin, float xMax, size_t xNum, 
-                            float yMin, float yMax, size_t yNum, 
-                            float zMin, float zMax, size_t zNum, 
-                            size_t nValues, float *values, FlowCmd *flowPtr)
+ScaleResampledVectorFieldData(Rappture::Outcome &context, 
+                              Rappture::Unirect3d *dataPtr)
 {
-    Rappture::Mesh1D xgrid(xMin, xMax, xNum);
-    Rappture::Mesh1D ygrid(yMin, yMax, yNum);
-    Rappture::Mesh1D zgrid(zMin, zMax, zNum);
+    Rappture::Mesh1D xgrid(dataPtr->xMin(), dataPtr->xMax(), dataPtr->xNum());
+    Rappture::Mesh1D ygrid(dataPtr->yMin(), dataPtr->yMax(), dataPtr->yNum());
+    Rappture::Mesh1D zgrid(dataPtr->zMin(), dataPtr->zMax(), dataPtr->zNum());
     Rappture::FieldRect3D xfield(xgrid, ygrid, zgrid);
     Rappture::FieldRect3D yfield(xgrid, ygrid, zgrid);
@@ -135 +101 @@
     max_mag = -1e21, nzero_min = min_mag = 1e21;
     size_t i, j;
-    for (i = j = 0; i < nValues; i += 3, j++) {
+    for (i = j = 0; i < dataPtr->nValues(); i += 3, j++) {
         double vx, vy, vz, vm;
 
-        vx = values[i];
-        vy = values[i+1];
-        vz = values[i+2];
+        vx = dataPtr->values[i];
+        vy = dataPtr->values[i+1];
+        vz = dataPtr->values[i+2];
         
         xfield.define(j, vx);
@@ -217 +183 @@
         }
     }
-    
+    dataPtr->zMin()
     flowPtr->xMin = xMin;
     flowPtr->xMax = xMax;
@@ -246 +212 @@
 
 
-#ifdef notdef
 /*
  * Load a 3D vector field from a dx-format file
@@ -371 +336 @@
 }
 
-#endif

trunk/packages/vizservers/nanovis/Makefile.in

@@ -104 +104 @@
                 Event.o \
                 Unirect.o \
+                FlowCmd.o \
+                FlowCmds.o \
+                LoadVector.o \
+                Switch.o \
                 GradientFilter.o \
                 Grid.o \

trunk/packages/vizservers/nanovis/NvFlowVisRenderer.h

@@ -44 +44 @@
         void reset();
         void render();
+
+        void addVectorField(Volume* volPtr, const Vector3& ori, float scaleX, 
+                float scaleY, float scaleZ, float max);
 
         void addVectorField(const std::string& vfName, Volume* volPtr, const Vector3& ori, float scaleX, float scaleY, float scaleZ, float max);

trunk/packages/vizservers/nanovis/NvLIC.cpp

@@ -308 +308 @@
     float x1, x2, y, px, py;
     
+    glPushMatrix();
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
     
@@ -313 +314 @@
     glLoadIdentity(); 
     glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
+
+    /*glPushMatrix();*/
     glViewport(0, 0, (GLsizei) NPIX, (GLsizei) NPIX);
     //glTranslatef(-1.0, -1.0, 0.0); 
@@ -397 +400 @@
     glPopMatrix();
     glMatrixMode(GL_PROJECTION);
-    glPopMatrix();
+    /*glPopMatrix();*/
     glMatrixMode(GL_MODELVIEW);
 }
@@ -488 +491 @@
 
 void 
-NvLIC::setVectorField(unsigned int texID, const Vector3& ori, float scaleX, float scaleY, 
-                      float scaleZ, float max)
+NvLIC::setVectorField(unsigned int texID, const Vector3& ori, 
+                      float scaleX, float scaleY, float scaleZ, float max)
 {
     Trace("NvLIC: vector field is assigned [%d]\n", texID);
@@ -531 +534 @@
 NvLIC::set_offset(float v)
 {
-        switch (axis)
-        {
-        case 0 : offset.x = v; break;
-        case 1 : offset.y = v; break;
-        case 2 : offset.z = v; break;
-        }
-
-        get_slice();
+    switch (axis) {
+    case 0 : offset.x = v; break;
+    case 1 : offset.y = v; break;
+    case 2 : offset.z = v; break;
+    }
+    get_slice();
 }
 

trunk/packages/vizservers/nanovis/NvParticleRenderer.cpp

@@ -25 +25 @@
 #include <stdlib.h>
 
-
 #define NV_32
 
@@ -51 +50 @@
     m_vertex_array = new RenderVertexArray(psys_width*psys_height, 3, GL_FLOAT);
 
-    assert(glGetError()==0);
+    assert(CheckGL(AT));
 
     glGenFramebuffersEXT(2, psys_fbo);
@@ -131 +130 @@
     glDeleteFramebuffersEXT(2, psys_fbo);
 
+    delete m_vertex_array;
+    delete _advectionShader;
     free(data);
 }
@@ -244 +245 @@
     if (reborn) 
         reset();
-
+    
     glDisable(GL_BLEND);
     glDisable(GL_DEPTH_TEST);

trunk/packages/vizservers/nanovis/Switch.h

@@ -34 +34 @@
 #  include <stddef.h>
 #endif /* HAVE_STDDEF_H */
-
-#ifdef offsetof
-#define SwitchOffset(type, field) ((int) offsetof(type, field))
-#else
-#define SwitchOffset(type, field) ((int) ((char *) &((type *) 0)->field))
-#endif
 
 namespace Rappture {

trunk/packages/vizservers/nanovis/Trace.h

@@ -5 +5 @@
 #include <GL/glut.h>
 
+#define MAKE_STRING(x) #x
+#define NEWSTRING(x) MAKE_STRING(x)
+#define AT __FILE__ ":" NEWSTRING(__LINE__)
+
 extern void Trace(const char* format, ...);
 extern bool CheckFBO(GLenum *statusPtr);

trunk/packages/vizservers/nanovis/Unirect.cpp

@@ -1 +1 @@
 
+#include <float.h>
 #include <tcl.h>
 #include <Unirect.h>
+#include "RpField1D.h"
+#include "RpFieldRect3D.h"
 
 extern int GetFloatFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, 
         float *valuePtr);
 extern int GetAxisFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *indexPtr);
+
+static INLINE char *
+skipspaces(char *string) 
+{
+    while (isspace(*string)) {
+        string++;
+    }
+    return string;
+}
+
+static INLINE char *
+getline(char **stringPtr, char *endPtr) 
+{
+    char *line, *p;
+
+    line = skipspaces(*stringPtr);
+    for (p = line; p < endPtr; p++) {
+        if (*p == '\n') {
+            *p++ = '\0';
+            *stringPtr = p;
+            return line;
+        }
+    }
+    *stringPtr = p;
+    return line;
+}
 
 int 
@@ -30 +59 @@
     axis3 = 0;                  /* X-axis */
 
-    int extents = 1;
     values = NULL;
     num[0] = num[1] = num[2] = nValues = 0;
@@ -115 +143 @@
             }
         } else if ((c == 'u') && (strcmp(string, "units") == 0)) {
-            vUnits_ = strdup(Tcl_GetString(objv[i+1]));
+            _vUnits = strdup(Tcl_GetString(objv[i+1]));
         } else if ((c == 'o') && (strcmp(string, "order") == 0)) {
             Tcl_Obj **axes;
@@ -142 +170 @@
         return TCL_ERROR;
     }
-    if (nValues != (num[0] * num[1] * num[2] * extents)) {
+    if ((size_t)nValues != (num[0] * num[1] * num[2] * _nComponents)) {
         Tcl_AppendResult(interp, 
                 "wrong number of values: must be xnum*ynum*znum*extents", 
@@ -149 +177 @@
     }
     
-    fprintf(stderr, "generating %dx%dx%dx%d = %d points\n", 
-            num[0], num[1], num[2], extents, num[0]*num[1]*num[2]*extents);
-
     if ((axis1 != 2) || (axis2 != 1) || (axis3 != 0)) {
         // Reorder the data into x, y, z where x varies fastest and so on.
@@ -165 +190 @@
 
                 for (x = 0; x < num[2]; x++) {
-                    int i, v;
+                    int i;
                     
                     /* Compute the index from the data's described ordering. */
                     i = ((z*num[axis2]*num[axis3]) + (y*num[axis3]) + x) * 3;
-                    for(v = 0; v < extents; v++) {
+                    for(size_t v = 0; v < _nComponents; v++) {
                         dp[v] = values[i+v];
                     }
-                    dp += extents;
+                    dp += _nComponents;
                 }
             }
@@ -180 +205 @@
     }
 
-    values_ = values;
-    nValues_ = nValues;
-    extents_ = extents;
+    _values = values;
+    _nValues = nValues;
     if (units[3] != NULL) {
-        vUnits_ = strdup(units[3]);
-    }
-    xMin_ = min[axis3];
-    xMax_ = max[axis3];
-    xNum_ = num[axis3];
+        _vUnits = strdup(units[3]);
+    }
+    _xMin = min[axis3];
+    _xMax = max[axis3];
+    _xNum = num[axis3];
     if (units[axis3] != NULL) {
-        xUnits_ = strdup(units[axis3]);
-    }
-    yMin_ = min[axis2];
-    yMax_ = max[axis2];
-    yNum_ = num[axis2];
+        _xUnits = strdup(units[axis3]);
+    }
+    _yMin = min[axis2];
+    _yMax = max[axis2];
+    _yNum = num[axis2];
     if (units[axis2] != NULL) {
-        yUnits_ = strdup(units[axis2]);
-    }
-    zMin_ = min[axis1];
-    zMax_ = max[axis1];
-    zNum_ = num[axis1];
+        _yUnits = strdup(units[axis2]);
+    }
+    _zMin = min[axis1];
+    _zMax = max[axis1];
+    _zNum = num[axis1];
     if (units[axis1] != NULL) {
-        zUnits_ = strdup(units[axis1]);
-    }
-    initialized_ = true;
+        _zUnits = strdup(units[axis1]);
+    }
+    _initialized = true;
     return TCL_OK;
 }
@@ -225 +249 @@
     axis[1] = 0;                        /* Y-axis */
 
-    extents_ = 1;
-    xNum_ = yNum_ = nValues_ = 0;
-    xMin_ = yMin_ = xMax_ = yMax_ = 0.0f;
-    if (xUnits_ != NULL) {
-        free(xUnits_);
-    }
-    if (yUnits_ != NULL) {
-        free(yUnits_);
-    }
-    if (vUnits_ != NULL) {
-        free(vUnits_);
-    }
-    xUnits_ = yUnits_ = vUnits_ = NULL;
-    if (values_ != NULL) {
-        delete [] values_;
-    }
-    values_ = NULL;
+    _xNum = _yNum = _nValues = 0;
+    _xMin = _yMin = _xMax = _yMax = 0.0f;
+    if (_xUnits != NULL) {
+        free(_xUnits);
+    }
+    if (_yUnits != NULL) {
+        free(_yUnits);
+    }
+    if (_vUnits != NULL) {
+        free(_vUnits);
+    }
+    _xUnits = _yUnits = _vUnits = NULL;
+    if (_values != NULL) {
+        delete [] _values;
+    }
+    _values = NULL;
 
     int i;
@@ -251 +274 @@
         c = string[0];
         if ((c == 'x') && (strcmp(string, "xmin") == 0)) {
-            if (GetFloatFromObj(interp, objv[i+1], &xMin_) != TCL_OK) {
+            if (GetFloatFromObj(interp, objv[i+1], &_xMin) != TCL_OK) {
                 return TCL_ERROR;
             }
         } else if ((c == 'x') && (strcmp(string, "xmax") == 0)) {
-            if (GetFloatFromObj(interp, objv[i+1], &xMax_) != TCL_OK) {
+            if (GetFloatFromObj(interp, objv[i+1], &_xMax) != TCL_OK) {
                 return TCL_ERROR;
             }
@@ -268 +291 @@
                 return TCL_ERROR;
             }
-            xNum_ = n;
+            _xNum = n;
         } else if ((c == 'x') && (strcmp(string, "xunits") == 0)) {
-            xUnits_ = strdup(Tcl_GetString(objv[i+1]));
+            _xUnits = strdup(Tcl_GetString(objv[i+1]));
         } else if ((c == 'y') && (strcmp(string, "ymin") == 0)) {
-            if (GetFloatFromObj(interp, objv[i+1], &yMin_) != TCL_OK) {
+            if (GetFloatFromObj(interp, objv[i+1], &_yMin) != TCL_OK) {
                 return TCL_ERROR;
             }
         } else if ((c == 'y') && (strcmp(string, "ymax") == 0)) {
-            if (GetFloatFromObj(interp, objv[i+1], &yMax_) != TCL_OK) {
+            if (GetFloatFromObj(interp, objv[i+1], &_yMax) != TCL_OK) {
                 return TCL_ERROR;
             }
@@ -289 +312 @@
                 return TCL_ERROR;
             }
-            yNum_ = n;
+            _yNum = n;
         } else if ((c == 'y') && (strcmp(string, "yunits") == 0)) {
-            yUnits_ = strdup(Tcl_GetString(objv[i+1]));
+            _yUnits = strdup(Tcl_GetString(objv[i+1]));
         } else if ((c == 'v') && (strcmp(string, "values") == 0)) {
             Tcl_Obj **vobj;
@@ -304 +327 @@
                 return TCL_ERROR;
             }
-            nValues_ = n;
-            values_ = new float[nValues_];
+            _nValues = n;
+            _values = new float[_nValues];
             size_t j;
-            for (j = 0; j < nValues_; j++) {
-                if (GetFloatFromObj(interp, vobj[j], values_ + j)!=TCL_OK) {
+            for (j = 0; j < _nValues; j++) {
+                if (GetFloatFromObj(interp, vobj[j], _values + j)!=TCL_OK) {
                     return TCL_ERROR;
                 }
             }
         } else if ((c == 'u') && (strcmp(string, "units") == 0)) {
-            vUnits_ = strdup(Tcl_GetString(objv[i+1]));
+            _vUnits = strdup(Tcl_GetString(objv[i+1]));
         } else if ((c == 'e') && (strcmp(string, "extents") == 0)) {
             int n;
@@ -325 +348 @@
                 return TCL_ERROR;
             }
-            extents_ = n;
+            _nComponents = n;
         } else if ((c == 'a') && (strcmp(string, "axisorder") == 0)) {
             Tcl_Obj **order;
@@ -350 +373 @@
         }
     }
-    if (values_ == NULL) {
+    if (_values == NULL) {
         Tcl_AppendResult(interp, "missing \"values\" key", (char *)NULL);
         return TCL_ERROR;
     }
-    if (nValues_ != (xNum_ * yNum_ * extents_)) {
+    if (_nValues != (_xNum * _yNum * _nComponents)) {
         Tcl_AppendResult(interp, 
                 "wrong number of values: must be xnum*ynum*extents", 
@@ -361 +384 @@
     }
     
-    fprintf(stderr, "generating %dx%dx%d = %d points\n", 
-            xNum_, yNum_, extents_, xNum_ * yNum_ * extents_);
-
 #ifndef notdef
     if ((axis[0] != 1) || (axis[1] != 0)) {
@@ -371 +391 @@
         float *data, *dp;
 
-        dp = data = new float[nValues_];
-        for (y = 0; y < yNum_; y++) {
+        dp = data = new float[_nValues];
+        for (y = 0; y < _yNum; y++) {
             size_t x;
 
-            for (x = 0; x < xNum_; x++) {
+            for (x = 0; x < _xNum; x++) {
                 size_t i, v;
                     
                 /* Compute the index from the data's described ordering. */
-                i = (y + (yNum_ * x)) * extents_;
-                for(v = 0; v < extents_; v++) {
-                    dp[v] = values_[i+v];
+                i = (y + (_yNum * x)) * _nComponents;
+                for(v = 0; v < _nComponents; v++) {
+                    dp[v] = _values[i+v];
                 }
-                dp += extents_;
-            }
-        }
-        delete [] values_;
-        values_ = data;
+                dp += _nComponents;
+            }
+        }
+        delete [] _values;
+        _values = data;
     }
 #endif
-    initialized_ = true;
+    _initialized = true;
     return TCL_OK;
 }
+
+
+bool
+Rappture::Unirect3d::ReadVectorDataFromDx(Rappture::Outcome &result, 
+        size_t length, char *string) 
+{
+    size_t nx, ny, nz, npts;
+    double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
+    char *p, *endPtr;
+
+    dx = dy = dz = 0.0;         // Suppress compiler warning.
+    x0 = y0 = z0 = 0.0;         // May not have an origin line.
+    for (p = string, endPtr = p + length; p < endPtr; /*empty*/) {
+        char *line;
+
+        line = getline(&p, endPtr);
+        if (line == endPtr) {
+            break;
+        }
+        if ((line[0] == '#') || (line == '\0')) {
+            continue;           // Skip blank or comment lines.
+        }
+        if (sscanf(line, "object %*d class gridpositions counts %d %d %d", 
+                   &nx, &ny, &nz) == 3) {
+            if ((nx < 0) || (ny < 0) || (nz < 0)) {
+                result.addError("invalid grid size: x=%d, y=%d, z=%d", 
+                        nx, ny, nz);
+                return false;
+            }
+        } else if (sscanf(line, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
+            // found origin
+        } else if (sscanf(line, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
+            // found one of the delta lines
+            if (ddx != 0.0) {
+                dx = ddx;
+            } else if (ddy != 0.0) {
+                dy = ddy;
+            } else if (ddz != 0.0) {
+                dz = ddz;
+            }
+        } else if (sscanf(line, "object %*d class array type %*s shape 3"
+                " rank 1 items %d data follows", &npts) == 1) {
+            printf("#points=%d\n", npts);
+            if (npts != nx*ny*nz) {
+                result.addError("inconsistent data: expected %d points"
+                                " but found %d points", nx*ny*nz, npts);
+                return false;
+            }
+            break;
+        } else if (sscanf(line, "object %*d class array type %*s rank 0"
+                " times %d data follows", &npts) == 1) {
+            if (npts != nx*ny*nz) {
+                result.addError("inconsistent data: expected %d points"
+                                " but found %d points", nx*ny*nz, npts);
+                return false;
+            }
+            break;
+        }
+    }
+    if (npts != nx*ny*nz) {
+        result.addError("inconsistent data: expected %d points"
+                        " but found %d points", nx*ny*nz, npts);
+        return false;
+    }
+
+    _initialized = false;
+    _xValueMin = _yValueMin = _zValueMin = FLT_MAX;
+    _xValueMax = _yValueMax = _zValueMax = -FLT_MAX;
+    _xMin = x0, _yMin = y0, _zMin = z0;
+    _xNum = nx, _yNum = ny, _zNum = nz;
+    _xMax = _xMin + dx * _xNum;
+    _yMax = _yMin + dy * _yNum;
+    _zMax = _zMin + dz * _zNum;
+    if (_values != NULL) {
+        delete [] _values;
+    }
+    _values = new float[npts * _nComponents];
+    _nValues = 0;
+    for (size_t ix = 0; ix < _xNum; ix++) {
+        for (size_t iy = 0; iy < _yNum; iy++) {
+            for (size_t iz = 0; iz < _zNum; iz++) {
+                char *line;
+                if ((p == endPtr) || (_nValues > (size_t)npts)) {
+                    break;
+                }
+                line = getline(&p, endPtr);
+                if ((line[0] == '#') || (line[0] == '\0')) {
+                    continue;   // Skip blank or comment lines.
+                }
+                double vx, vy, vz;
+                if (sscanf(line, "%lg %lg %lg", &vx, &vy, &vz) == 3) {
+                    int nindex = (iz*nx*ny + iy*nx + ix) * 3;
+                    if (vx < _xValueMin) {
+                        _xValueMin = vx;
+                    } else if (vx > _xValueMax) {
+                        _xValueMax = vx;
+                    }
+                    if (vy < _yValueMin) {
+                        _yValueMin = vy;
+                    } else if (vy > _yValueMax) {
+                        _yValueMax = vy;
+                    }
+                    if (vz < _zValueMin) {
+                        _zValueMin = vz;
+                    } else if (vz > _zValueMax) {
+                        _zValueMax = vz;
+                    }
+                    if (nindex >= (npts*3)) {
+                        fprintf(stderr, "nindex=%d, npts=%d, z=%d, y=%d, x=%d\n",
+                                nindex, npts, iz, iy, ix);
+                    }
+                    _values[nindex] = vx;
+                    _values[nindex+1] = vy;
+                    _values[nindex+2] = vz;
+                    _nValues++;
+                }
+            }
+        }
+    }
+    // make sure that we read all of the expected points
+    if (_nValues != npts) {
+        result.addError("inconsistent data: expected %d points"
+                        " but found %d points", npts, _nValues);
+        delete []  _values;
+        _values = NULL;
+        return false;
+    }
+    _nValues *= _nComponents;
+    _initialized = true;
+    return true;
+}
+
+
+bool
+Rappture::Unirect3d::Resample(Rappture::Outcome &result, int nSamples)
+{
+    Rappture::Mesh1D xgrid(_xMin, _xMax, _xNum);
+    Rappture::Mesh1D ygrid(_yMin, _yMax, _yNum);
+    Rappture::Mesh1D zgrid(_zMin, _zMax, _zNum);
+    Rappture::FieldRect3D xfield(xgrid, ygrid, zgrid);
+    Rappture::FieldRect3D yfield(xgrid, ygrid, zgrid);
+    Rappture::FieldRect3D zfield(xgrid, ygrid, zgrid);
+
+    size_t i, j;
+    for (i = 0, j = 0; i < _nValues; i += _nComponents, j++) {
+        double vx, vy, vz;
+
+        vx = _values[i];
+        vy = _values[i+1];
+        vz = _values[i+2];
+        
+        xfield.define(j, vx);
+        yfield.define(j, vy);
+        zfield.define(j, vz);
+    }
+    // Figure out a good mesh spacing
+    double dx, dy, dz;
+    dx = xfield.rangeMax(Rappture::xaxis) - xfield.rangeMin(Rappture::xaxis);
+    dy = xfield.rangeMax(Rappture::yaxis) - xfield.rangeMin(Rappture::yaxis);
+    dz = xfield.rangeMax(Rappture::zaxis) - xfield.rangeMin(Rappture::zaxis);
+
+    double dmin;
+    dmin = pow((dx*dy*dz)/(nSamples*nSamples*nSamples), 0.333);
+    
+    printf("dx:%lf dy:%lf dz:%lf dmin:%lf\n", dx, dy, dz, dmin);
+
+    /* Recompute new number of points for each axis. */
+    _xNum = (size_t)ceil(dx/dmin);
+    _yNum = (size_t)ceil(dy/dmin);
+    _zNum = (size_t)ceil(dz/dmin);
+    
+#ifndef NV40
+    // must be an even power of 2 for older cards
+    _xNum = (int)pow(2.0, ceil(log10((double)_xNum)/log10(2.0)));
+    _yNum = (int)pow(2.0, ceil(log10((double)_yNum)/log10(2.0)));
+    _zNum = (int)pow(2.0, ceil(log10((double)_zNum)/log10(2.0)));
+#endif
+
+    size_t n = _nComponents * _xNum * _yNum * _zNum;
+    float *data = new float[n];
+    memset(data, 0, sizeof(float) * n);
+    
+    // Generate the uniformly sampled rectangle that we need for a volume
+    float *destPtr = data;
+    for (size_t i = 0; i < _zNum; i++) {
+        double z;
+
+        z = _zMin + (i * dmin);
+        for (size_t j = 0; j < _yNum; j++) {
+            double y;
+                
+            y = _yMin + (j * dmin);
+            for (size_t k = 0; k < _xNum; k++) {
+                double x;
+
+                x = _xMin + (k * dmin);
+                destPtr[0] = xfield.value(x, y, z);
+                destPtr[1] = yfield.value(x, y, z);
+                destPtr[2] = zfield.value(x, y, z);
+            }
+        }
+    }
+    delete [] _values;
+    _values = data;
+    _nValues = _xNum * _yNum * _zNum * _nComponents;
+    return true;
+}
+

trunk/packages/vizservers/nanovis/Unirect.h

@@ -7 +7 @@
 
 class Unirect3d {
-    size_t xNum_, yNum_, zNum_;
-    size_t nValues_;
-    int extents_;
-
-    float xMin_, xMax_;
-    float yMin_, yMax_;
-    float zMin_, zMax_;
-    float vMin_, vMax_;
-
-    char *xUnits_;
-    char *yUnits_;
-    char *zUnits_;
-    char *vUnits_;
-
-    float *values_;
-    bool initialized_;
+    size_t _xNum, _yNum, _zNum;
+    size_t _nValues;
+    size_t _nComponents;
+    float _xMin, _xMax, _yMin, _yMax, _zMin, _zMax;
+    float _xValueMin, _xValueMax;
+    float _yValueMin, _yValueMax;
+    float _zValueMin, _zValueMax;
+    char *_xUnits;
+    char *_yUnits;
+    char *_zUnits;
+    char *_vUnits;
+
+    float *_values;
+    bool _initialized;
 
 public:
@@ -28 +26 @@
               float yMin, float yMax, size_t yNum, 
               float zMin, float zMax, size_t zNum, 
-              size_t nValues, float *values) {
-        xMax_ = xMax;
-        xMin_ = xMin;
-        xNum_ = xNum;
-        yMax_ = yMax;
-        yMin_ = yMin;
-        yNum_ = yNum;
-        zMax_ = zMax;
-        zMin_ = zMin;
-        zNum_ = zNum;
-        nValues_ = nValues;
-        values_ = values;
-        initialized_ = true;
-    }
-
-    Unirect3d(void) {
-        values_ = NULL;
-        initialized_ = false;
-        xNum_ = yNum_ = zNum_ = 0;
-        nValues_ = 0;
-        xUnits_ = yUnits_ = zUnits_ = vUnits_ = NULL;
+              size_t nValues, float *values, size_t nComponents) 
+    {
+        SetValues(xMin, xMax, xNum, yMin, yMax, yNum, zMin, zMax, zNum, 
+                  nValues, values, nComponents);
+    }
+
+    Unirect3d(size_t nComponents = 1) {
+        _values = NULL;
+        _initialized = false;
+        _xNum = _yNum = _zNum = 0;
+        _nValues = 0;
+        _xUnits = _yUnits = _zUnits = _vUnits = NULL;
+        _nComponents = nComponents;
     }
     ~Unirect3d(void) {
-        if (values_ != NULL) {
-            delete [] values_;
-        }
-        if (xUnits_ != NULL) {
-            free(xUnits_);
-        }
-        if (yUnits_ != NULL) {
-            free(yUnits_);
-        }
-        if (zUnits_ != NULL) {
-            free(zUnits_);
-        }
-        if (vUnits_ != NULL) {
-            free(vUnits_);
-        }
+        if (_values != NULL) {
+            delete [] _values;
+        }
+        if (_xUnits != NULL) {
+            free(_xUnits);
+        }
+        if (_yUnits != NULL) {
+            free(_yUnits);
+        }
+        if (_zUnits != NULL) {
+            free(_zUnits);
+        }
+        if (_vUnits != NULL) {
+            free(_vUnits);
+        }
+    }
+    void SetValues(float xMin, float xMax, size_t xNum, 
+                   float yMin, float yMax, size_t yNum, 
+                   float zMin, float zMax, size_t zNum, 
+                   size_t nValues, float *values, size_t nComponents) {
+        _xMax = xMax;
+        _xMin = xMin;
+        _xNum = xNum;
+        _yMax = yMax;
+        _yMin = yMin;
+        _yNum = yNum;
+        _zMax = zMax;
+        _zMin = zMin;
+        _zNum = zNum;
+        _nValues = nValues;
+        _values = values;
+        _initialized = true;
+        _nComponents = nComponents;
     }
     size_t xNum(void) {
-        return xNum_;
+        return _xNum;
     }
     size_t yNum(void) {
-        return yNum_;
+        return _yNum;
     }
     size_t zNum(void) {
-        return zNum_;
+        return _zNum;
     }
     float xMin(void) {
-        return xMin_;
+        return _xMin;
     }
     float yMin(void) {
-        return yMin_;
+        return _yMin;
     }
     float zMin(void) {
-        return zMin_;
+        return _zMin;
     }
     float xMax(void) {
-        return xMax_;
+        return _xMax;
     }
     float yMax(void) {
-        return yMax_;
+        return _yMax;
     }
     float zMax(void) {
-        return zMax_;
+        return _zMax;
+    }
+    float xValueMin(void) {
+        return _xValueMin;
+    }
+    float yValueMin(void) {
+        return _yValueMin;
+    }
+    float zValueMin(void) {
+        return _zValueMin;
+    }
+    float xValueMax(void) {
+        return _xValueMax;
+    }
+    float yValueMax(void) {
+        return _yValueMax;
+    }
+    float zValueMax(void) {
+        return _zValueMax;
+    }
+    size_t nComponents(void) {
+        return _nComponents;
     }
     const char *xUnits(void) {
-        return xUnits_;
+        return _xUnits;
     }
     const char *yUnits(void) {
-        return yUnits_;
+        return _yUnits;
     }
     const char *zUnits(void) {
-        return zUnits_;
+        return _zUnits;
     }
     const char *vUnits(void) {
-        return vUnits_;
+        return _vUnits;
+    }
+    const float *values(void) {
+        return _values;
+    }
+    const float *SaveValues(void) {
+        float *values;
+        values = _values;
+        _values = NULL;
+        _nValues = 0;
+        return values;
+    }
+    size_t nValues(void) {
+        return _nValues;
+    }
+    int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
+
+    bool ReadVectorDataFromDx(Rappture::Outcome &result, size_t length, 
+        char *string);
+    bool Resample(Rappture::Outcome &context, int nSamples = 30);
+    bool isInitialized(void) {
+        return _initialized;
+    }
+};
+
+class Unirect2d {
+    size_t _xNum, _yNum;
+    size_t _nValues;
+    size_t _nComponents;
+
+    float _xMin, _xMax;
+    float _yMin, _yMax;
+    float _xValueMin, _xValueMax;
+    float _yValueMin, _yValueMax;
+
+    char *_xUnits;
+    char *_yUnits;
+    char *_vUnits;
+
+    float *_values;
+    bool _initialized;
+
+public:
+    Unirect2d(size_t nComponents = 1) {
+        _values = NULL;
+        _initialized = false;
+        _xNum = _yNum = 0;
+        _nValues = 0;
+        _xUnits = _yUnits = _vUnits = NULL;
+        _nComponents = nComponents;
+    }
+    ~Unirect2d(void) {
+        if (_values != NULL) {
+            delete [] _values;
+        }
+        if (_xUnits != NULL) {
+            free(_xUnits);
+        }
+        if (_yUnits != NULL) {
+            free(_yUnits);
+        }
+        if (_vUnits != NULL) {
+            free(_vUnits);
+        }
+    }
+    size_t xNum(void) {
+        return _xNum;
+    }
+    size_t yNum(void) {
+        return _yNum;
+    }
+    float xMin(void) {
+        return _xMin;
+    }
+    float yMin(void) {
+        return _yMin;
+    }
+    float xMax(void) {
+        return _xMax;
+    }
+    float yMax(void) {
+        return _yMax;
+    }
+    const char *xUnits(void) {
+        return _xUnits;
+    }
+    const char *yUnits(void) {
+        return _yUnits;
+    }
+    const char *vUnits(void) {
+        return _vUnits;
     }
     float *values(void) {
-        return values_;
-    }
-    float *SaveValues(void) {
+        return _values;
+    }
+    float *acceptValues(void) {
         float *values;
-        values = values_;
-        values_ = NULL;
-        nValues_ = 0;
+        values = _values;
+        _values = NULL;
+        _nValues = 0;
         return values;
     }
     size_t nValues(void) {
-        return nValues_;
-    }
-    size_t extents(void) {
-        return extents_;
-    }
-    void extents(size_t extents) {
-        extents_ = extents;
+        return _nValues;
     }
     int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
     bool isInitialized(void) {
-        return initialized_;
+        return _initialized;
     }
 };
 
-class Unirect2d {
-    size_t xNum_, yNum_;
-    size_t nValues_;
-    size_t extents_;
-
-    float xMin_, xMax_;
-    float yMin_, yMax_;
-    float vMin_, vMax_;
-
-    char *xUnits_;
-    char *yUnits_;
-    char *vUnits_;
-
-    float *values_;
-    bool initialized_;
-
-public:
-    Unirect2d(void) {
-        values_ = NULL;
-        initialized_ = false;
-        xNum_ = yNum_ = 0;
-        nValues_ = 0;
-        xUnits_ = yUnits_ = vUnits_ = NULL;
-    }
-    ~Unirect2d(void) {
-        if (values_ != NULL) {
-            delete [] values_;
-        }
-        if (xUnits_ != NULL) {
-            free(xUnits_);
-        }
-        if (yUnits_ != NULL) {
-            free(yUnits_);
-        }
-        if (vUnits_ != NULL) {
-            free(vUnits_);
-        }
-    }
-    size_t xNum(void) {
-        return xNum_;
-    }
-    size_t yNum(void) {
-        return yNum_;
-    }
-    float xMin(void) {
-        return xMin_;
-    }
-    float yMin(void) {
-        return yMin_;
-    }
-    float xMax(void) {
-        return xMax_;
-    }
-    float yMax(void) {
-        return yMax_;
-    }
-    const char *xUnits(void) {
-        return xUnits_;
-    }
-    const char *yUnits(void) {
-        return yUnits_;
-    }
-    const char *vUnits(void) {
-        return vUnits_;
-    }
-    float *values(void) {
-        return values_;
-    }
-    float *acceptValues(void) {
-        float *values;
-        values = values_;
-        values_ = NULL;
-        nValues_ = 0;
-        return values;
-    }
-    size_t nValues(void) {
-        return nValues_;
-    }
-    size_t extents(void) {
-        return extents_;
-    }
-    void extents(size_t extents) {
-        extents_ = extents;
-    }
-    int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
-    bool isInitialized(void) {
-        return initialized_;
-    }
-};
-
 }
 

trunk/packages/vizservers/nanovis/Volume.cpp

@@ -49 +49 @@
     int fcount = width * height * depth * n_components;
     _data = new float[fcount];
-    if (data) {
+    if (data != NULL) {
         Trace("data is copied\n");
         memcpy(_data, data, fcount * sizeof(float));

trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

@@ -89 +89 @@
 }
 
+/*
+ * FIXME:  This is a good example of the wrong data structures being used.
+ *         The volumes should be in a list not a vector.  Each list
+ *         element should contain pointers to both the volume and the
+ *         transfer function.  The shouldn't be parallel vectors.  
+ * 
+ *         And there shouldn't be one vector for "all" volumes and another
+ *         for those being rendered, unless you work to keep them in sync.  
+ *         Use one master list instead.
+ */
+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--;
+}
+
 void
 VolumeRenderer::shade_volume(Volume* _vol, TransferFunction* _tf)
@@ -177 +208 @@
 
     for(int vol_index = 0; vol_index< num_volumes; vol_index++) {
+        cur_vol = NULL;
+        cur_tf = NULL;
+#ifdef notdef
         if (vol_index != n_volumes) {
             cur_vol = volume[vol_index];
@@ -184 +218 @@
             cur_tf = ani_tf;
         }
-    
+#else
+        cur_vol = volume[vol_index];
+        cur_tf = tf[vol_index];
+#endif
+
         polys[vol_index] = NULL;
         actual_slices[vol_index] = 0;
 
-        if(!cur_vol->is_enabled())
+        if(!cur_vol->is_enabled()) {
             continue; //skip this volume
+        }
 
         int n_slices = cur_vol->get_n_slice();

trunk/packages/vizservers/nanovis/VolumeRenderer.h

@@ -106 +106 @@
 
     int add_volume(Volume* _vol, TransferFunction* _tf); 
+    void remove_volume(size_t volIndex); 
     // add a volume and its transfer function
     // we require a transfer function when a 

trunk/packages/vizservers/nanovis/config.h

@@ -31 +31 @@
 #define PROTOTYPE               1
 
-//#define NEW_FLOW_ENGINE
+#define NEW_FLOW_ENGINE         1
 
 /* 

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -162 +162 @@
     }
     return new Rappture::Unirect3d(x0, x0 + dx * nx, nx, y0, y0 + dy * ny, ny,
-                                   z0, z0 + dz * nz, nz, nValues, values);
+                                   z0, z0 + dz * nz, nz, nValues, values, 3);
 }
 
 
+#ifdef notdef
 /*
  * Load a 3D vector field from a dx-format file
@@ -363 +364 @@
     return true;
 }
+#endif
 
 /* Load a 3D volume from a dx-format file
@@ -744 +746 @@
     while (!fin.eof()) {
         fin.getline(line, sizeof(line) - 1);
-        fprintf(stderr, "line is %s\n", line);
         if (fin.fail()) {
             result.error("error in data stream");
@@ -840 +841 @@
         }
     }
-    fprintf(stderr, "found nx=%d ny=%d, nz=%d, x0=%f, y0=%f, z0=%f\n",
-            nx, ny, nz, x0, y0, z0);
     // read data points
     if (fin.eof()) {
@@ -869 +868 @@
                 int nindex = iz*nx*ny + iy*nx + ix;
                 field.define(nindex, dval[p]);
-                fprintf(stderr,"nindex = %i\tdval[%i] = %lg\n", nindex, p,
-                        dval[p]);
                 fflush(stderr);
                 nread++;
@@ -1177 +1174 @@
     while (!fin.eof()) {
         fin.getline(line, sizeof(line) - 1);
-        fprintf(stderr, "line is %s\n", line);
         if (fin.fail()) {
             result.addError("line \"%s\"error in data stream");
@@ -1273 +1269 @@
     }
 
-    fprintf(stderr, "found nx=%d ny=%d, nz=%d, x0=%f, y0=%f, z0=%f\n",
-            nx, ny, nz, x0, y0, z0);
     // read data points
     if (fin.eof()) {

trunk/packages/vizservers/nanovis/nanovis.cpp

@@ -69 +69 @@
 #include <R2/R2Fonts.h>
 
+#include "Unirect.h"
+#include "Switch.h"
+#include "FlowCmd.h"
+
 #define SIZEOF_BMP_HEADER   54
 
@@ -126 +130 @@
 FILE *NanoVis::recfile = NULL;
 
-bool NanoVis::lic_on = false;
-bool NanoVis::particle_on = false;
-bool NanoVis::vector_on = false;
 bool NanoVis::axis_on = true;
 bool NanoVis::config_pending = false;
 bool NanoVis::debug_flag = false;
-bool NanoVis::lic_slice_x_visible = false;
-bool NanoVis::lic_slice_y_visible = false;
-bool NanoVis::lic_slice_z_visible = false;
 
 Tcl_Interp *NanoVis::interp;
@@ -427 +425 @@
     int result;
 
+#ifdef notdef
     if (NanoVis::debug_flag) {
         fprintf(stderr, "in ExecuteCommand(%s)\n", Tcl_DStringValue(dsPtr));
     }
-
+#endif
     gettimeofday(&tv, NULL);
     start = CVT2SECS(tv);
 
+#ifdef notdef
     if (NanoVis::logfile != NULL) {
         fprintf(NanoVis::logfile, "%s", Tcl_DStringValue(dsPtr));
         fflush(NanoVis::logfile);
     }
+#endif
     if (NanoVis::recfile != NULL) {
         fprintf(NanoVis::recfile, "%s", Tcl_DStringValue(dsPtr));
@@ -450 +451 @@
     stats.cmdTime += finish - start;
     stats.nCommands++;
+#ifdef notdef
     if (NanoVis::debug_flag) {
         fprintf(stderr, "leaving ExecuteCommand status=%d\n", result);
     }
+#endif
     return result;
 }
@@ -506 +509 @@
     volume[index] = 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];
 }
@@ -665 +669 @@
     }
     
-    if (screen_buffer) {
-        delete[] screen_buffer;
+    if (screen_buffer != NULL) {
+        delete [] screen_buffer;
         screen_buffer = NULL;
     }
@@ -827 +831 @@
 
 
-#if PROTOTYPE
-    licRenderer = new NvLIC(NMESH, NPIX, NPIX, lic_axis, Vector3(lic_slice_x, lic_slice_y, lic_slice_z), g_context);
-#endif
+    licRenderer = new NvLIC(NMESH, NPIX, NPIX, lic_axis, 
+                            Vector3(lic_slice_x, lic_slice_y, lic_slice_z), 
+                            g_context);
 
     ImageLoaderFactory::getInstance()->addLoaderImpl("bmp", new BMPImageLoaderImpl());
@@ -835 +839 @@
     grid->setFont(fonts);
 
+#ifdef notdef
     pointset_renderer = new PointSetRenderer();
+#endif
 }
 
@@ -1041 +1047 @@
             sprintf(filename, "/tmp/flow_animation/image%03d.bmp", frame_number);
 
-        printf("Writing %s\n", filename);
+        fprintf(stderr, "Writing %s\n", filename);
         f = fopen(filename, "wb");
         if (f == 0) {
@@ -1052 +1058 @@
         }
     }
-    ssize_t nWritten;
-    nWritten = fwrite(header, SIZEOF_BMP_HEADER, 1, f);
-    assert(nWritten == SIZEOF_BMP_HEADER);
-    nWritten = fwrite(screen_buffer, (3*win_width+pad)*win_height, 1, f);
-    assert(nWritten == (3*win_width+pad)*win_height);
+    if (fwrite(header, SIZEOF_BMP_HEADER, 1, f) != 1) {
+        Trace("can't write header: short write\n");
+    }
+    if (fwrite(screen_buffer, (3*win_width+pad)*win_height, 1, f) != 1) {
+        Trace("can't write data: short write\n");
+    }
     fclose(f);
 }
@@ -1633 +1640 @@
         fprintf(stderr, "in display\n");
     }
+
+    if (FlowCmd::flags & FlowCmd::MAP_PENDING) {
+        FlowCmd::MapFlows();
+    }
     //assert(glGetError()==0);
     if (HeightMap::update_pending) {
@@ -1701 +1712 @@
         if ((licRenderer != NULL) && (licRenderer->isActivated())) {
             licRenderer->render();
-        }
-
+            /*FlowCmd::SetupFlows();*/
+        }
+#ifdef notdef
         if ((flowVisRenderer != NULL) && (flowVisRenderer->isActivated())) {
             flowVisRenderer->render();
+        }
+#endif
+        if (FlowCmd::flags & FlowCmd::REDRAW_PENDING) {
+            FlowCmd::RenderFlows();
         }
 
@@ -1732 +1748 @@
         perf->disable();
     }
-
     perf->reset();
     if (debug_flag) {
         fprintf(stderr, "leaving display\n");
     }
+
 
 }
@@ -1923 +1939 @@
                 break;
         case '5' :
-                {
-                        printf("vector field deleted (vf_name2)\n");
+86              {
+a                       printf("vector field deleted (vf_name2)\n");
                         NanoVis::flowVisRenderer->removeVectorField("vf_name2");
                 }
@@ -2063 +2079 @@
     int status = TCL_OK;
 
-    //
     //  Read and execute as many commands as we can from stdin...
-    //
+
     bool isComplete = false;
-    while (status == TCL_OK) {
+    while ((!feof(NanoVis::stdin)) && (status == TCL_OK)) {
         //
         //  Read the next command from the buffer.  First time through we
@@ -2088 +2103 @@
                     break;
                 }
-                DoExit(0);
+                DoExit(100);
             }
             ch = (char)c;
@@ -2103 +2118 @@
             break;
         }
-
         if (isComplete) {
             // back to original flags during command evaluation...
@@ -2167 +2181 @@
 #endif
     if (feof(NanoVis::stdin)) {
-        DoExit(0);
+        DoExit(90);
     }
     if (debug_flag) {
@@ -2336 +2350 @@
 
     glutMainLoop();
-    DoExit(0);
+    DoExit(80);
 }
 

trunk/packages/vizservers/nanovis/nanovis.h

@@ -137 +137 @@
     static float lic_slice_y;
     static float lic_slice_z;
-    static bool lic_slice_x_visible;
-    static bool lic_slice_y_visible;
-    static bool lic_slice_z_visible;
     static int lic_axis;        /* 0:x, 1:y, 2:z */
 
@@ -149 +146 @@
 
     static bool debug_flag;
-    static bool lic_on;
-    static bool particle_on;
-    static bool vector_on;
 
     static Tcl_Interp *interp;