source: nanovis/branches/1.1/Command.cpp @ 4829

Last change on this file since 4829 was 4829, checked in by ldelgass, 5 years ago

Add stub imgflush command

  • Property svn:eol-style set to native
File size: 67.7 KB
Line 
1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * ----------------------------------------------------------------------
4 * Command.cpp
5 *
6 *      This modules creates the Tcl interface to the nanovis server.  The
7 *      communication protocol of the server is the Tcl language.  Commands
8 *      given to the server by clients are executed in a safe interpreter and
9 *      the resulting image rendered offscreen is returned as BMP-formatted
10 *      image data.
11 *
12 * ======================================================================
13 *  AUTHOR:  Wei Qiao <qiaow@purdue.edu>
14 *           Michael McLennan <mmclennan@purdue.edu>
15 *           Purdue Rendering and Perceptualization Lab (PURPL)
16 *
17 *  Copyright (c) 2004-2013  HUBzero Foundation, LLC
18 *
19 *  See the file "license.terms" for information on usage and
20 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
21 * ======================================================================
22 */
23
24/*
25 * TODO:  In no particular order...
26 *        o Use Tcl command option parser to reduce size of procedures, remove
27 *          lots of extra error checking code. (almost there)
28 *        o Add bookkeeping for volumes, heightmaps, flows, etc. to track
29 *          1) simulation # 2) include/exclude.  The include/exclude
30 *          is to indicate whether the item should contribute to the overall
31 *          limits of the axes.
32 */
33
34#include <assert.h>
35#include <stdlib.h>
36#include <unistd.h>                     /* Needed for getpid, gethostname,
37                                         * write, etc. */
38#include <tcl.h>
39
40#include <RpEncode.h>
41#include <RpOutcome.h>
42#include <RpBuffer.h>
43
44#include <vrmath/Vector3f.h>
45
46#include "nanovis.h"
47#include "CmdProc.h"
48#include "FlowCmd.h"
49#include "dxReader.h"
50#include "VtkReader.h"
51#include "Grid.h"
52#include "HeightMap.h"
53#include "NvCamera.h"
54#include "NvZincBlendeReconstructor.h"
55#include "Unirect.h"
56#include "Volume.h"
57#include "VolumeRenderer.h"
58#include "Trace.h"
59
60using namespace nv::graphics;
61using namespace vrmath;
62
63// default transfer function
64static const char def_transfunc[] =
65    "transfunc define default {\n\
66  0.00  0 0 1\n\
67  0.25  0 1 1\n\
68  0.50  0 1 0\n\
69  0.75  1 1 0\n\
70  1.00  1 0 0\n\
71} {\n\
72  0.000000 0.0\n\
73  0.107847 0.0\n\
74  0.107857 1.0\n\
75  0.177857 1.0\n\
76  0.177867 0.0\n\
77  0.250704 0.0\n\
78  0.250714 1.0\n\
79  0.320714 1.0\n\
80  0.320724 0.0\n\
81  0.393561 0.0\n\
82  0.393571 1.0\n\
83  0.463571 1.0\n\
84  0.463581 0.0\n\
85  0.536419 0.0\n\
86  0.536429 1.0\n\
87  0.606429 1.0\n\
88  0.606439 0.0\n\
89  0.679276 0.0\n\
90  0.679286 1.0\n\
91  0.749286 1.0\n\
92  0.749296 0.0\n\
93  0.822133 0.0\n\
94  0.822143 1.0\n\
95  0.892143 1.0\n\
96  0.892153 0.0\n\
97  1.000000 0.0\n\
98}";
99
100static int lastCmdStatus;
101
102bool
103GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, bool *boolPtr)
104{
105    int value;
106
107    if (Tcl_GetBooleanFromObj(interp, objPtr, &value) != TCL_OK) {
108        return TCL_ERROR;
109    }
110    *boolPtr = (bool)value;
111    return TCL_OK;
112}
113
114int
115GetFloatFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, float *valuePtr)
116{
117    double value;
118
119    if (Tcl_GetDoubleFromObj(interp, objPtr, &value) != TCL_OK) {
120        return TCL_ERROR;
121    }
122    *valuePtr = (float)value;
123    return TCL_OK;
124}
125
126static int
127GetCullMode(Tcl_Interp *interp, Tcl_Obj *objPtr,
128            RenderContext::CullMode *modePtr)
129{
130    const char *string = Tcl_GetString(objPtr);
131    if (strcmp(string, "none") == 0) {
132        *modePtr = RenderContext::NO_CULL;
133    } else if (strcmp(string, "front") == 0) {
134        *modePtr = RenderContext::FRONT;
135    } else if (strcmp(string, "back") == 0) {
136        *modePtr = RenderContext::BACK;
137    } else {
138        Tcl_AppendResult(interp, "invalid cull mode \"", string,
139                         "\": should be front, back, or none\"", (char *)NULL);
140        return TCL_ERROR;
141    }
142    return TCL_OK;
143}
144
145static int
146GetShadingModel(Tcl_Interp *interp, Tcl_Obj *objPtr,
147                RenderContext::ShadingModel *modelPtr)
148{
149    const char *string = Tcl_GetString(objPtr);
150
151    if (strcmp(string,"flat") == 0) {
152        *modelPtr = RenderContext::FLAT;
153    } else if (strcmp(string,"smooth") == 0) {
154        *modelPtr = RenderContext::SMOOTH;
155    } else {
156        Tcl_AppendResult(interp, "bad shading model \"", string,
157                         "\": should be flat or smooth", (char *)NULL);
158        return TCL_ERROR;
159    }
160    return TCL_OK;
161}
162
163static int
164GetPolygonMode(Tcl_Interp *interp, Tcl_Obj *objPtr,
165               RenderContext::PolygonMode *modePtr)
166{
167    const char *string = Tcl_GetString(objPtr);
168
169    if (strcmp(string,"wireframe") == 0) {
170        *modePtr = RenderContext::LINE;
171    } else if (strcmp(string,"fill") == 0) {
172        *modePtr = RenderContext::FILL;
173    } else {
174        Tcl_AppendResult(interp, "invalid polygon mode \"", string,
175                         "\": should be wireframe or fill\"", (char *)NULL);
176        return TCL_ERROR;
177    }
178    return TCL_OK;
179}
180
181/**
182 * Creates a heightmap from the given the data. The format of the data
183 * should be as follows:
184 *
185 *     xMin, xMax, xNum, yMin, yMax, yNum, heights...
186 *
187 * xNum and yNum must be integer values, all others are real numbers.
188 * The number of heights must be xNum * yNum;
189 */
190static HeightMap *
191CreateHeightMap(ClientData clientData, Tcl_Interp *interp, int objc,
192                Tcl_Obj *const *objv)
193{
194    float xMin, yMin, xMax, yMax;
195    int xNum, yNum;
196
197    if (objc != 7) {
198        Tcl_AppendResult(interp,
199        "wrong # of values: should be xMin yMin xMax yMax xNum yNum heights",
200        (char *)NULL);
201        return NULL;
202    }
203    if ((GetFloatFromObj(interp, objv[0], &xMin) != TCL_OK) ||
204        (GetFloatFromObj(interp, objv[1], &yMin) != TCL_OK) ||
205        (GetFloatFromObj(interp, objv[2], &xMax) != TCL_OK) ||
206        (GetFloatFromObj(interp, objv[3], &yMax) != TCL_OK) ||
207        (Tcl_GetIntFromObj(interp, objv[4], &xNum) != TCL_OK) ||
208        (Tcl_GetIntFromObj(interp, objv[5], &yNum) != TCL_OK)) {
209        return NULL;
210    }
211    int nValues;
212    Tcl_Obj **elem;
213    if (Tcl_ListObjGetElements(interp, objv[6], &nValues, &elem) != TCL_OK) {
214        return NULL;
215    }
216    if ((xNum <= 0) || (yNum <= 0)) {
217        Tcl_AppendResult(interp, "bad number of x or y values", (char *)NULL);
218        return NULL;
219    }
220    if (nValues != (xNum * yNum)) {
221        Tcl_AppendResult(interp, "wrong # of heights", (char *)NULL);
222        return NULL;
223    }
224
225    float *heights;
226    heights = new float[nValues];
227    if (heights == NULL) {
228        Tcl_AppendResult(interp, "can't allocate array of heights",
229                         (char *)NULL);
230        return NULL;
231    }
232
233    int i;
234    for (i = 0; i < nValues; i++) {
235        if (GetFloatFromObj(interp, elem[i], heights + i) != TCL_OK) {
236            delete [] heights;
237            return NULL;
238        }
239    }
240    HeightMap *heightMap = new HeightMap();
241    heightMap->setHeight(xMin, yMin, xMax, yMax, xNum, yNum, heights);
242    heightMap->transferFunction(NanoVis::getTransferFunction("default"));
243    heightMap->setVisible(true);
244    heightMap->setLineContourVisible(true);
245    delete [] heights;
246    return heightMap;
247}
248
249static int
250GetHeightMapFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, HeightMap **hmPtrPtr)
251{
252    const char *string = Tcl_GetString(objPtr);
253
254    NanoVis::HeightMapHashmap::iterator itr = NanoVis::heightMapTable.find(string);
255    if (itr == NanoVis::heightMapTable.end()) {
256        if (interp != NULL) {
257            Tcl_AppendResult(interp, "can't find a heightmap named \"",
258                         string, "\"", (char*)NULL);
259        }
260        return TCL_ERROR;
261    }
262    *hmPtrPtr = itr->second;
263    return TCL_OK;
264}
265
266/**
267 * Used internally to decode a series of volume index values and
268 * store then in the specified vector.  If there are no volume index
269 * arguments, this means "all volumes" to most commands, so all
270 * active volume indices are stored in the vector.
271 *
272 * Updates pushes index values into the vector.  Returns TCL_OK or
273 * TCL_ERROR to indicate an error.
274 */
275static int
276GetVolumeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Volume **volPtrPtr)
277{
278    const char *string = Tcl_GetString(objPtr);
279
280    NanoVis::VolumeHashmap::iterator itr = NanoVis::volumeTable.find(string);
281    if (itr == NanoVis::volumeTable.end()) {
282        if (interp != NULL) {
283            Tcl_AppendResult(interp, "can't find a volume named \"",
284                         string, "\"", (char*)NULL);
285        }
286        return TCL_ERROR;
287    }
288    *volPtrPtr = itr->second;
289    return TCL_OK;
290}
291
292/**
293 * Used internally to decode a series of volume index values and
294 * store then in the specified vector.  If there are no volume index
295 * arguments, this means "all volumes" to most commands, so all
296 * active volume indices are stored in the vector.
297 *
298 * Updates pushes index values into the vector.  Returns TCL_OK or
299 * TCL_ERROR to indicate an error.
300 */
301static int
302GetVolumes(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
303           std::vector<Volume *>* vectorPtr)
304{
305    if (objc == 0) {
306        // No arguments. Get all volumes.
307        NanoVis::VolumeHashmap::iterator itr;
308        for (itr = NanoVis::volumeTable.begin();
309             itr != NanoVis::volumeTable.end(); ++itr) {
310            vectorPtr->push_back(itr->second);
311        }
312    } else {
313        // Get the volumes associated with the given index arguments.
314        for (int n = 0; n < objc; n++) {
315            Volume *volume;
316            if (GetVolumeFromObj(interp, objv[n], &volume) != TCL_OK) {
317                return TCL_ERROR;
318            }
319            vectorPtr->push_back(volume);
320        }
321    }
322    return TCL_OK;
323}
324
325/**
326 * Used internally to decode a series of volume index values and
327 * store then in the specified vector.  If there are no volume index
328 * arguments, this means "all volumes" to most commands, so all
329 * active volume indices are stored in the vector.
330 *
331 * Updates pushes index values into the vector.  Returns TCL_OK or
332 * TCL_ERROR to indicate an error.
333 */
334static int
335GetHeightMaps(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv,
336              std::vector<HeightMap *>* vectorPtr)
337{
338    if (objc == 0) {
339        // No arguments. Get all heightmaps.
340        NanoVis::HeightMapHashmap::iterator itr;
341        for (itr = NanoVis::heightMapTable.begin();
342             itr != NanoVis::heightMapTable.end(); ++itr) {
343            vectorPtr->push_back(itr->second);
344        }
345    } else {
346        for (int n = 0; n < objc; n++) {
347            HeightMap *heightMap;
348            if (GetHeightMapFromObj(interp, objv[n], &heightMap) != TCL_OK) {
349                return TCL_ERROR;
350            }
351            vectorPtr->push_back(heightMap);
352        }
353    }
354    return TCL_OK;
355}
356
357/**
358 * Used internally to decode an axis value from a string ("x", "y",
359 * or "z") to its index (0, 1, or 2).  Returns TCL_OK if successful,
360 * along with a value in valPtr.  Otherwise, it returns TCL_ERROR
361 * and an error message in the interpreter.
362 */
363static int
364GetAxis(Tcl_Interp *interp, const char *string, int *indexPtr)
365{
366    if (string[1] == '\0') {
367        char c;
368
369        c = tolower((unsigned char)string[0]);
370        if (c == 'x') {
371            *indexPtr = 0;
372            return TCL_OK;
373        } else if (c == 'y') {
374            *indexPtr = 1;
375            return TCL_OK;
376        } else if (c == 'z') {
377            *indexPtr = 2;
378            return TCL_OK;
379        }
380        /*FALLTHRU*/
381    }
382    Tcl_AppendResult(interp, "bad axis \"", string,
383                     "\": should be x, y, or z", (char*)NULL);
384    return TCL_ERROR;
385}
386
387/**
388 * Used internally to decode an axis value from a string ("x", "y",
389 * or "z") to its index (0, 1, or 2).  Returns TCL_OK if successful,
390 * along with a value in indexPtr.  Otherwise, it returns TCL_ERROR
391 * and an error message in the interpreter.
392 */
393int
394GetAxisFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *indexPtr)
395{
396    return GetAxis(interp, Tcl_GetString(objPtr), indexPtr);
397}
398
399/**
400 * Used internally to decode an axis value from a string ("x", "y",
401 * or "z") to its index (0, 1, or 2).  Returns TCL_OK if successful,
402 * along with a value in indexPtr.  Otherwise, it returns TCL_ERROR
403 * and an error message in the interpreter.
404 */
405static int
406GetAxisDirFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *indexPtr, int *dirPtr)
407{
408    const char *string = Tcl_GetString(objPtr);
409
410    int sign = 1;
411    if (*string == '-') {
412        sign = -1;
413        string++;
414    }
415    if (GetAxis(interp, string, indexPtr) != TCL_OK) {
416        return TCL_ERROR;
417    }
418    if (dirPtr != NULL) {
419        *dirPtr = sign;
420    }
421    return TCL_OK;
422}
423
424/**
425 * Used internally to decode a color value from a string ("R G B")
426 * as a list of three numbers 0-1.  Returns TCL_OK if successful,
427 * along with RGB values in rgbPtr.  Otherwise, it returns TCL_ERROR
428 * and an error message in the interpreter.
429 */
430static int
431GetColor(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, float *rgbPtr)
432{
433    if (objc < 3) {
434        Tcl_AppendResult(interp, "missing color values\": ",
435                         "should list of R G B values 0.0 - 1.0", (char*)NULL);
436        return TCL_ERROR;
437    }
438    if ((GetFloatFromObj(interp, objv[0], rgbPtr + 0) != TCL_OK) ||
439        (GetFloatFromObj(interp, objv[1], rgbPtr + 1) != TCL_OK) ||
440        (GetFloatFromObj(interp, objv[2], rgbPtr + 2) != TCL_OK)) {
441        return TCL_ERROR;
442    }
443    return TCL_OK;
444}
445
446/**
447 * Read the requested number of bytes from standard input into the given
448 * buffer.  The buffer is then decompressed and decoded.
449 */
450int
451GetDataStream(Tcl_Interp *interp, Rappture::Buffer &buf, int nBytes)
452{
453    char buffer[8096];
454
455    clearerr(NanoVis::stdin);
456    while (nBytes > 0) {
457        unsigned int chunk;
458        int nRead;
459
460        chunk = (sizeof(buffer) < (unsigned int) nBytes) ?
461            sizeof(buffer) : nBytes;
462        nRead = fread(buffer, sizeof(char), chunk, NanoVis::stdin);
463        if (ferror(NanoVis::stdin)) {
464            Tcl_AppendResult(interp, "while reading data stream: ",
465                             Tcl_PosixError(interp), (char*)NULL);
466            return TCL_ERROR;
467        }
468        if (feof(NanoVis::stdin)) {
469            Tcl_AppendResult(interp, "premature EOF while reading data stream",
470                             (char*)NULL);
471            return TCL_ERROR;
472        }
473        buf.append(buffer, nRead);
474        nBytes -= nRead;
475    }
476    if (NanoVis::recfile != NULL) {
477        ssize_t nWritten;
478
479        nWritten = fwrite(buf.bytes(), sizeof(char), buf.size(), 
480                          NanoVis::recfile);
481        assert(nWritten == (ssize_t)buf.size());
482        fflush(NanoVis::recfile);
483    }
484    Rappture::Outcome err;
485    TRACE("Checking header[%.13s]", buf.bytes());
486    if (strncmp (buf.bytes(), "@@RP-ENC:", 9) == 0) {
487        /* There's a header on the buffer, use it to decode the data. */
488        if (!Rappture::encoding::decode(err, buf, RPENC_HDR)) {
489            Tcl_AppendResult(interp, err.remark(), (char*)NULL);
490            return TCL_ERROR;
491        }
492    } else if (Rappture::encoding::isBase64(buf.bytes(), buf.size())) {
493        /* No header, but it's base64 encoded.  It's likely that it's both
494         * base64 encoded and compressed. */
495        if (!Rappture::encoding::decode(err, buf, RPENC_B64 | RPENC_Z)) {
496            Tcl_AppendResult(interp, err.remark(), (char*)NULL);
497            return TCL_ERROR;
498        }
499    }
500    return TCL_OK;
501}
502
503static int
504CameraAngleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
505              Tcl_Obj *const *objv)
506{
507    float theta, phi, psi;
508    if ((GetFloatFromObj(interp, objv[2], &phi) != TCL_OK) ||
509        (GetFloatFromObj(interp, objv[3], &theta) != TCL_OK) ||
510        (GetFloatFromObj(interp, objv[4], &psi) != TCL_OK)) {
511        return TCL_ERROR;
512    }
513    NanoVis::cam->rotate(phi, theta, psi);
514    return TCL_OK;
515}
516
517static int
518CameraOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
519               Tcl_Obj *const *objv)
520{
521    double quat[4];
522    if ((Tcl_GetDoubleFromObj(interp, objv[2], &quat[3]) != TCL_OK) ||
523        (Tcl_GetDoubleFromObj(interp, objv[3], &quat[0]) != TCL_OK) ||
524        (Tcl_GetDoubleFromObj(interp, objv[4], &quat[1]) != TCL_OK) ||
525        (Tcl_GetDoubleFromObj(interp, objv[5], &quat[2]) != TCL_OK)) {
526        return TCL_ERROR;
527    }
528    NanoVis::cam->rotate(quat);
529    return TCL_OK;
530}
531
532static int
533CameraPanOp(ClientData clientData, Tcl_Interp *interp, int objc, 
534             Tcl_Obj *const *objv)
535{
536    float x, y;
537    if ((GetFloatFromObj(interp, objv[2], &x) != TCL_OK) ||
538        (GetFloatFromObj(interp, objv[3], &y) != TCL_OK)) {
539        return TCL_ERROR;
540    }
541    NanoVis::pan(x, y);
542    return TCL_OK;
543}
544
545static int
546CameraPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
547                 Tcl_Obj *const *objv)
548{
549    float x, y, z;
550    if ((GetFloatFromObj(interp, objv[2], &x) != TCL_OK) ||
551        (GetFloatFromObj(interp, objv[3], &y) != TCL_OK) ||
552        (GetFloatFromObj(interp, objv[4], &z) != TCL_OK)) {
553        return TCL_ERROR;
554    }
555    NanoVis::cam->x(x);
556    NanoVis::cam->y(y);
557    NanoVis::cam->z(z);
558    return TCL_OK;
559}
560
561static int
562CameraResetOp(ClientData clientData, Tcl_Interp *interp, int objc, 
563              Tcl_Obj *const *objv)
564{
565    bool all = false;
566    if (objc == 3) {
567        const char *string = Tcl_GetString(objv[2]);
568        char c = string[0];
569        if ((c != 'a') || (strcmp(string, "all") != 0)) {
570            Tcl_AppendResult(interp, "bad camera reset option \"", string,
571                             "\": should be all", (char*)NULL);
572            return TCL_ERROR;
573        }
574        all = true;
575    }
576    NanoVis::resetCamera(all);
577    return TCL_OK;
578}
579
580static int
581CameraZoomOp(ClientData clientData, Tcl_Interp *interp, int objc, 
582             Tcl_Obj *const *objv)
583{
584    float z;
585    if (GetFloatFromObj(interp, objv[2], &z) != TCL_OK) {
586        return TCL_ERROR;
587    }
588    NanoVis::zoom(z);
589    return TCL_OK;
590}
591
592static Rappture::CmdSpec cameraOps[] = {
593    {"angle",   2, CameraAngleOp,    5, 5, "xAngle yAngle zAngle",},
594    {"orient",  1, CameraOrientOp,   6, 6, "qw qx qy qz",},
595    {"pan",     2, CameraPanOp,      4, 4, "x y",},
596    {"pos",     2, CameraPositionOp, 5, 5, "x y z",},
597    {"reset",   1, CameraResetOp,    2, 3, "?all?",},
598    {"zoom",    1, CameraZoomOp,     3, 3, "factor",},
599};
600static int nCameraOps = NumCmdSpecs(cameraOps);
601
602static int
603CameraCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
604          Tcl_Obj *const *objv)
605{
606    Tcl_ObjCmdProc *proc;
607
608    proc = Rappture::GetOpFromObj(interp, nCameraOps, cameraOps,
609                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
610    if (proc == NULL) {
611        return TCL_ERROR;
612    }
613    return (*proc) (clientData, interp, objc, objv);
614}
615
616static int
617SnapshotCmd(ClientData clientData, Tcl_Interp *interp, int objc,
618            Tcl_Obj *const *objv)
619{
620    int origWidth, origHeight, width, height;
621
622    origWidth = NanoVis::winWidth;
623    origHeight = NanoVis::winHeight;
624    width = 2048;
625    height = 2048;
626
627    NanoVis::resizeOffscreenBuffer(width, height);
628    NanoVis::bindOffscreenBuffer();
629    NanoVis::render();
630    NanoVis::readScreen();
631
632    NanoVis::ppmWrite("nv>image -type print -bytes");
633    NanoVis::resizeOffscreenBuffer(origWidth, origHeight);
634
635    return TCL_OK;
636}
637
638static int
639CutplanePositionOp(ClientData clientData, Tcl_Interp *interp, int objc,
640                   Tcl_Obj *const *objv)
641{
642    float relval;
643    if (GetFloatFromObj(interp, objv[2], &relval) != TCL_OK) {
644        return TCL_ERROR;
645    }
646
647    // keep this just inside the volume so it doesn't disappear
648    if (relval < 0.01f) {
649        relval = 0.01f;
650    } else if (relval > 0.99f) {
651        relval = 0.99f;
652    }
653
654    int axis;
655    if (GetAxisFromObj(interp, objv[3], &axis) != TCL_OK) {
656        return TCL_ERROR;
657    }
658
659    std::vector<Volume *> ivol;
660    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
661        return TCL_ERROR;
662    }
663    std::vector<Volume *>::iterator iter;
664    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
665        (*iter)->moveCutplane(axis, relval);
666    }
667    return TCL_OK;
668}
669
670static int
671CutplaneStateOp(ClientData clientData, Tcl_Interp *interp, int objc,
672                Tcl_Obj *const *objv)
673{
674    bool state;
675    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
676        return TCL_ERROR;
677    }
678
679    int axis;
680    if (GetAxisFromObj(interp, objv[3], &axis) != TCL_OK) {
681        return TCL_ERROR;
682    }
683
684    std::vector<Volume *> ivol;
685    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
686        return TCL_ERROR;
687    }
688    if (state) {
689        std::vector<Volume *>::iterator iter;
690        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
691            (*iter)->enableCutplane(axis);
692        }
693    } else {
694        std::vector<Volume *>::iterator iter;
695        for (iter = ivol.begin(); iter != ivol.end(); iter++) {
696            (*iter)->disableCutplane(axis);
697        }
698    }
699    return TCL_OK;
700}
701
702static int
703CutplaneVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
704                  Tcl_Obj *const *objv)
705{
706    bool state;
707    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
708        return TCL_ERROR;
709    }
710
711    std::vector<Volume *> ivol;
712    if (GetVolumes(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
713        return TCL_ERROR;
714    }
715    std::vector<Volume *>::iterator iter;
716    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
717        (*iter)->cutplanesVisible(state);
718    }
719    return TCL_OK;
720}
721
722static Rappture::CmdSpec cutplaneOps[] = {
723    {"position", 1, CutplanePositionOp, 4, 0, "relval axis ?indices?",},
724    {"state",    1, CutplaneStateOp,    4, 0, "bool axis ?indices?",},
725    {"visible",  1, CutplaneVisibleOp,  3, 0, "bool ?indices?",},
726};
727static int nCutplaneOps = NumCmdSpecs(cutplaneOps);
728
729/*
730 * ----------------------------------------------------------------------
731 * CLIENT COMMAND:
732 *   cutplane state on|off <axis> ?<volume>...?
733 *   cutplane position <relvalue> <axis> ?<volume>...?
734 *
735 * Clients send these commands to manipulate the cutplanes in one or
736 * more data volumes.  The "state" command turns a cutplane on or
737 * off.  The "position" command changes the position to a relative
738 * value in the range 0-1.  The <axis> can be x, y, or z.  These
739 * options are applied to the volumes represented by one or more
740 * <volume> indices.  If no volumes are specified, then all volumes
741 * are updated.
742 * ----------------------------------------------------------------------
743 */
744static int
745CutplaneCmd(ClientData clientData, Tcl_Interp *interp, int objc,
746            Tcl_Obj *const *objv)
747{
748    Tcl_ObjCmdProc *proc;
749
750    proc = Rappture::GetOpFromObj(interp, nCutplaneOps, cutplaneOps,
751                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
752    if (proc == NULL) {
753        return TCL_ERROR;
754    }
755    return (*proc) (clientData, interp, objc, objv);
756}
757
758/*
759 * ClientInfoCmd --
760 *
761 *      Log initial values to stats file.  The first time this is called
762 *      "render_start" is written into the stats file.  Afterwards, it
763 *      is "render_info".
764 *       
765 *         clientinfo list
766 */
767static int
768ClientInfoCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
769              Tcl_Obj *const *objv)
770{
771    Tcl_DString ds;
772    Tcl_Obj *objPtr, *listObjPtr, **items;
773    int result;
774    int i, numItems, length;
775    char buf[BUFSIZ];
776    const char *string;
777    static int first = 1;
778
779    if (objc != 2) {
780        Tcl_AppendResult(interp, "wrong # of arguments: should be \"", 
781                Tcl_GetString(objv[0]), " list\"", (char *)NULL);
782        return TCL_ERROR;
783    }
784#ifdef KEEPSTATS
785    /* Use the initial client key value pairs as the parts for a generating
786     * a unique file name. */
787    int f = NanoVis::getStatsFile(objv[1]);
788    if (f < 0) {
789        Tcl_AppendResult(interp, "can't open stats file: ", 
790                         Tcl_PosixError(interp), (char *)NULL);
791        return TCL_ERROR;
792    }
793#endif
794    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
795    Tcl_IncrRefCount(listObjPtr);
796    if (first) {
797        first = false;
798        objPtr = Tcl_NewStringObj("render_start", 12);
799        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
800        /* renderer */
801        objPtr = Tcl_NewStringObj("renderer", 8);
802        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
803        objPtr = Tcl_NewStringObj("nanovis", 7);
804        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
805        /* pid */
806        objPtr = Tcl_NewStringObj("pid", 3);
807        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
808        Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewLongObj((long)NanoVis::stats.pid));
809        /* host */
810        objPtr = Tcl_NewStringObj("host", 4);
811        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
812        gethostname(buf, BUFSIZ-1);
813        buf[BUFSIZ-1] = '\0';
814        objPtr = Tcl_NewStringObj(buf, -1);
815        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
816    } else {
817        objPtr = Tcl_NewStringObj("render_info", 11);
818        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
819    }
820    Tcl_DStringInit(&ds);
821    /* date */
822    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("date", 4));
823    strcpy(buf, ctime(&NanoVis::stats.start.tv_sec));
824    buf[strlen(buf) - 1] = '\0';
825    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj(buf, -1));
826    /* date_secs */
827    Tcl_ListObjAppendElement(interp, listObjPtr, 
828                             Tcl_NewStringObj("date_secs", 9));
829    Tcl_ListObjAppendElement(interp, listObjPtr, 
830                             Tcl_NewLongObj(NanoVis::stats.start.tv_sec));
831    /* Client arguments. */
832    if (Tcl_ListObjGetElements(interp, objv[1], &numItems, &items) != TCL_OK) {
833        return TCL_ERROR;
834    }
835    for (i = 0; i < numItems; i++) {
836        Tcl_ListObjAppendElement(interp, listObjPtr, items[i]);
837    }
838    Tcl_DStringInit(&ds);
839    string = Tcl_GetStringFromObj(listObjPtr, &length);
840    Tcl_DStringAppend(&ds, string, length);
841    Tcl_DStringAppend(&ds, "\n", 1);
842#ifdef KEEPSTATS
843    result = NanoVis::writeToStatsFile(f, Tcl_DStringValue(&ds), 
844                                       Tcl_DStringLength(&ds));
845#else
846    TRACE("clientinfo: %s", Tcl_DStringValue(&ds));
847#endif
848    Tcl_DStringFree(&ds);
849    Tcl_DecrRefCount(listObjPtr);
850    return result;
851}
852
853/*
854 * ----------------------------------------------------------------------
855 * CLIENT COMMAND:
856 *   legend <volumeIndex> <width> <height>
857 *
858 * Clients use this to generate a legend image for the specified
859 * transfer function.  The legend image is a color gradient from 0
860 * to one, drawn in the given transfer function.  The resulting image
861 * is returned in the size <width> x <height>.
862 * ----------------------------------------------------------------------
863 */
864static int
865LegendCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
866          Tcl_Obj *const *objv)
867{
868    if (objc != 4) {
869        Tcl_AppendResult(interp, "wrong # args: should be \"",
870            Tcl_GetString(objv[0]), " transfunc width height\"", (char*)NULL);
871        return TCL_ERROR;
872    }
873
874    const char *tfName = Tcl_GetString(objv[1]);
875    TransferFunction *tf = NanoVis::getTransferFunction(tfName);
876    if (tf == NULL) {
877        Tcl_AppendResult(interp, "unknown transfer function \"", tfName, "\"",
878                             (char*)NULL);
879        return TCL_ERROR;
880    }
881    int w, h;
882    if ((Tcl_GetIntFromObj(interp, objv[2], &w) != TCL_OK) ||
883        (Tcl_GetIntFromObj(interp, objv[3], &h) != TCL_OK)) {
884        return TCL_ERROR;
885    }
886    if (Volume::updatePending) {
887        NanoVis::setVolumeRanges();
888    }
889    NanoVis::renderLegend(tf, Volume::valueMin, Volume::valueMax, w, h, tfName);
890    return TCL_OK;
891}
892
893static int
894ScreenBgColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
895                Tcl_Obj *const *objv)
896{
897    float rgb[3];
898    if ((GetFloatFromObj(interp, objv[2], &rgb[0]) != TCL_OK) ||
899        (GetFloatFromObj(interp, objv[3], &rgb[1]) != TCL_OK) ||
900        (GetFloatFromObj(interp, objv[4], &rgb[2]) != TCL_OK)) {
901        return TCL_ERROR;
902    }
903    NanoVis::setBgColor(rgb);
904    return TCL_OK;
905}
906
907/*
908 * ----------------------------------------------------------------------
909 * CLIENT COMMAND:
910 *   screen size <width> <height>
911 *
912 * Clients send this command to set the size of the rendering area.
913 * Future images are generated at the specified width/height.
914 * ----------------------------------------------------------------------
915 */
916static int
917ScreenSizeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
918             Tcl_Obj *const *objv)
919{
920    int w, h;
921    if ((Tcl_GetIntFromObj(interp, objv[2], &w) != TCL_OK) ||
922        (Tcl_GetIntFromObj(interp, objv[3], &h) != TCL_OK)) {
923        return TCL_ERROR;
924    }
925    NanoVis::resizeOffscreenBuffer(w, h);
926    return TCL_OK;
927}
928
929static Rappture::CmdSpec screenOps[] = {
930    {"bgcolor",  1, ScreenBgColorOp,  5, 5, "r g b",},
931    {"size",     1, ScreenSizeOp, 4, 4, "width height",},
932};
933static int nScreenOps = NumCmdSpecs(screenOps);
934
935static int
936ScreenCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
937          Tcl_Obj *const *objv)
938{
939    Tcl_ObjCmdProc *proc;
940
941    proc = Rappture::GetOpFromObj(interp, nScreenOps, screenOps,
942                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
943    if (proc == NULL) {
944        return TCL_ERROR;
945    }
946    return (*proc) (clientData, interp, objc, objv);
947}
948
949/*
950 * ----------------------------------------------------------------------
951 * CLIENT COMMAND:
952 *   transfunc define <name> <colormap> <alphamap>
953 *     where <colormap> = { <v> <r> <g> <b> ... }
954 *           <alphamap> = { <v> <w> ... }
955 *
956 * Clients send these commands to manipulate the transfer functions.
957 * ----------------------------------------------------------------------
958 */
959static int
960TransfuncCmd(ClientData clientData, Tcl_Interp *interp, int objc,
961             Tcl_Obj *const *objv)
962{
963    if (objc < 2) {
964        Tcl_AppendResult(interp, "wrong # args: should be \"",
965                Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
966        return TCL_ERROR;
967    }
968
969    const char *string = Tcl_GetString(objv[1]);
970    char c = string[0];
971    if ((c == 'd') && (strcmp(string, "define") == 0)) {
972        if (objc != 5) {
973            Tcl_AppendResult(interp, "wrong # args: should be \"",
974                Tcl_GetString(objv[0]), " define name colorMap alphaMap\"",
975                (char*)NULL);
976            return TCL_ERROR;
977        }
978
979        // decode the data and store in a series of fields
980        int cmapc, amapc, i;
981        Tcl_Obj **cmapv;
982        Tcl_Obj **amapv;
983
984        amapv = cmapv = NULL;
985        if (Tcl_ListObjGetElements(interp, objv[3], &cmapc, &cmapv) != TCL_OK) {
986            return TCL_ERROR;
987        }
988        if ((cmapc % 4) != 0) {
989            Tcl_AppendResult(interp, "wrong # elements is colormap: should be ",
990                "{ v r g b ... }", (char*)NULL);
991            return TCL_ERROR;
992        }
993        if (Tcl_ListObjGetElements(interp, objv[4], &amapc, &amapv) != TCL_OK) {
994            return TCL_ERROR;
995        }
996        if ((amapc % 2) != 0) {
997            Tcl_AppendResult(interp, "wrong # elements in alphamap: should be ",
998                " { v w ... }", (char*)NULL);
999            return TCL_ERROR;
1000        }
1001
1002        int numColors = cmapc/4;
1003        float *colorKeys = new float[numColors];
1004        Vector3f *colors = new Vector3f[numColors];
1005        for (i = 0; i < cmapc; i += 4) {
1006            int j;
1007            double q[4];
1008
1009            for (j=0; j < 4; j++) {
1010                if (Tcl_GetDoubleFromObj(interp, cmapv[i+j], &q[j]) != TCL_OK) {
1011                    return TCL_ERROR;
1012                }
1013                if ((q[j] < 0.0) || (q[j] > 1.0)) {
1014                    Tcl_AppendResult(interp, "bad colormap value \"",
1015                        Tcl_GetString(cmapv[i+j]),
1016                        "\": should be in the range 0-1", (char*)NULL);
1017                    return TCL_ERROR;
1018                }
1019            }
1020
1021            colorKeys[i/4] = (float)q[0];
1022            colors[i/4].set((float)q[1], (float)q[2], (float)q[3]);
1023        }
1024        int numAlphas = amapc/2;
1025        float *alphaKeys = new float[numAlphas];
1026        float *alphas = new float[numAlphas];
1027        for (i=0; i < amapc; i += 2) {
1028            double q[2];
1029            int j;
1030
1031            for (j=0; j < 2; j++) {
1032                if (Tcl_GetDoubleFromObj(interp, amapv[i+j], &q[j]) != TCL_OK) {
1033                    return TCL_ERROR;
1034                }
1035                if ((q[j] < 0.0) || (q[j] > 1.0)) {
1036                    Tcl_AppendResult(interp, "bad alphamap value \"",
1037                        Tcl_GetString(amapv[i+j]),
1038                        "\": should be in the range 0-1", (char*)NULL);
1039                    return TCL_ERROR;
1040                }
1041            }
1042            alphaKeys[i/2] = (float)q[0];
1043            alphas[i/2] = (float)q[1];
1044        }
1045        // sample the given function into discrete slots
1046        const int nslots = 256;
1047        float data[4*nslots];
1048        for (i=0; i < nslots; i++) {
1049            float x = float(i)/(nslots-1);
1050            Vector3f color;
1051            float alpha;
1052            TransferFunction::sample(x, colorKeys, colors, numColors, &color);
1053            TransferFunction::sample(x, alphaKeys, alphas, numAlphas, &alpha);
1054
1055            data[4*i]   = color.r;
1056            data[4*i+1] = color.g;
1057            data[4*i+2] = color.b;
1058            data[4*i+3] = alpha;
1059        }
1060        delete [] colorKeys;
1061        delete [] colors;
1062        delete [] alphaKeys;
1063        delete [] alphas;
1064        // find or create this transfer function
1065        NanoVis::defineTransferFunction(Tcl_GetString(objv[2]), nslots, data);
1066    } else {
1067        Tcl_AppendResult(interp, "bad option \"", string,
1068                "\": should be define", (char*)NULL);
1069        return TCL_ERROR;
1070    }
1071    return TCL_OK;
1072}
1073
1074/*
1075 * ----------------------------------------------------------------------
1076 * CLIENT COMMAND:
1077 *   up axis
1078 *
1079 * Clients use this to set the "up" direction for all volumes.  Volumes
1080 * are oriented such that this direction points upward.
1081 * ----------------------------------------------------------------------
1082 */
1083static int
1084UpCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
1085{
1086    if (objc != 2) {
1087        Tcl_AppendResult(interp, "wrong # args: should be \"",
1088                         Tcl_GetString(objv[0]), " x|y|z|-x|-y|-z\"", (char*)NULL);
1089        return TCL_ERROR;
1090    }
1091
1092    int sign;
1093    int axis;
1094    if (GetAxisDirFromObj(interp, objv[1], &axis, &sign) != TCL_OK) {
1095        return TCL_ERROR;
1096    }
1097    NanoVis::updir = (axis+1)*sign;
1098    return TCL_OK;
1099}
1100
1101static int
1102VolumeAnimationCaptureOp(ClientData clientData, Tcl_Interp *interp, int objc,
1103                         Tcl_Obj *const *objv)
1104{
1105    int total;
1106    if (Tcl_GetIntFromObj(interp, objv[3], &total) != TCL_OK) {
1107        return TCL_ERROR;
1108    }
1109    VolumeInterpolator *interpolator =
1110        NanoVis::volRenderer->getVolumeInterpolator();
1111    interpolator->start();
1112    if (interpolator->isStarted()) {
1113        const char *dirName = (objc < 5) ? NULL : Tcl_GetString(objv[4]);
1114        for (int frameNum = 0; frameNum < total; ++frameNum) {
1115            float fraction;
1116
1117            fraction = ((float)frameNum) / (total - 1);
1118            TRACE("fraction : %f", fraction);
1119            interpolator->update(fraction);
1120
1121            int fboOrig;
1122            glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboOrig);
1123
1124            NanoVis::bindOffscreenBuffer();  //enable offscreen render
1125
1126            NanoVis::render();
1127            NanoVis::readScreen();
1128
1129            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
1130
1131            NanoVis::bmpWriteToFile(frameNum, dirName);
1132        }
1133    }
1134    return TCL_OK;
1135}
1136
1137static int
1138VolumeAnimationClearOp(ClientData clientData, Tcl_Interp *interp, int objc,
1139                       Tcl_Obj *const *objv)
1140{
1141    NanoVis::volRenderer->clearAnimatedVolumeInfo();
1142    return TCL_OK;
1143}
1144
1145static int
1146VolumeAnimationStartOp(ClientData clientData, Tcl_Interp *interp, int objc,
1147                       Tcl_Obj *const *objv)
1148{
1149    NanoVis::volRenderer->startVolumeAnimation();
1150    return TCL_OK;
1151}
1152
1153static int
1154VolumeAnimationStopOp(ClientData clientData, Tcl_Interp *interp, int objc,
1155                      Tcl_Obj *const *objv)
1156{
1157    NanoVis::volRenderer->stopVolumeAnimation();
1158    return TCL_OK;
1159}
1160
1161static int
1162VolumeAnimationVolumesOp(ClientData clientData, Tcl_Interp *interp, int objc,
1163                         Tcl_Obj *const *objv)
1164{
1165    std::vector<Volume *> volumes;
1166    if (GetVolumes(interp, objc - 3, objv + 3, &volumes) != TCL_OK) {
1167        return TCL_ERROR;
1168    }
1169    TRACE("parsing volume data identifier");
1170    NanoVis::VolumeHashmap::iterator itr;
1171    for (itr = NanoVis::volumeTable.begin();
1172         itr != NanoVis::volumeTable.end(); ++itr) {
1173        NanoVis::volRenderer->addAnimatedVolume(itr->second);
1174    }
1175    return TCL_OK;
1176}
1177
1178static Rappture::CmdSpec volumeAnimationOps[] = {
1179    {"capture",   2, VolumeAnimationCaptureOp,  4, 5, "numframes ?filename?",},
1180    {"clear",     2, VolumeAnimationClearOp,    3, 3, "",},
1181    {"start",     3, VolumeAnimationStartOp,    3, 3, "",},
1182    {"stop",      3, VolumeAnimationStopOp,     3, 3, "",},
1183    {"volumes",   1, VolumeAnimationVolumesOp,  3, 0, "?indices?",},
1184};
1185
1186static int nVolumeAnimationOps = NumCmdSpecs(volumeAnimationOps);
1187
1188static int
1189VolumeAnimationOp(ClientData clientData, Tcl_Interp *interp, int objc,
1190                  Tcl_Obj *const *objv)
1191{
1192    Tcl_ObjCmdProc *proc;
1193
1194    proc = Rappture::GetOpFromObj(interp, nVolumeAnimationOps, 
1195                volumeAnimationOps, Rappture::CMDSPEC_ARG2, objc, objv, 0);
1196    if (proc == NULL) {
1197        return TCL_ERROR;
1198    }
1199    return (*proc) (clientData, interp, objc, objv);
1200}
1201
1202static int
1203VolumeDataFollowsOp(ClientData clientData, Tcl_Interp *interp, int objc,
1204                    Tcl_Obj *const *objv)
1205{
1206    TRACE("Data Loading");
1207
1208    int nbytes;
1209    if (Tcl_GetIntFromObj(interp, objv[3], &nbytes) != TCL_OK) {
1210        return TCL_ERROR;
1211    }
1212    const char *tag = Tcl_GetString(objv[4]);
1213    Rappture::Buffer buf;
1214    if (GetDataStream(interp, buf, nbytes) != TCL_OK) {
1215        return TCL_ERROR;
1216    }
1217    const char *bytes;
1218    size_t nBytes;
1219
1220    bytes = buf.bytes();
1221    nBytes = buf.size();
1222
1223    TRACE("Checking header[%.20s]", bytes);
1224
1225    Volume *volume = NULL;
1226
1227    if ((nBytes > 5) && (strncmp(bytes, "<HDR>", 5) == 0)) {
1228        TRACE("ZincBlende Stream loading...");
1229         //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
1230        //fdata.write(buf.bytes(),buf.size());
1231        //vol = NvZincBlendeReconstructor::getInstance()->loadFromStream(fdata);
1232
1233        volume = NvZincBlendeReconstructor::getInstance()->loadFromMemory((void*) buf.bytes());
1234        if (volume == NULL) {
1235            Tcl_AppendResult(interp, "can't get volume instance", (char *)NULL);
1236            return TCL_ERROR;
1237        }
1238        TRACE("finish loading");
1239
1240        Vector3f scale = volume->getPhysicalScaling();
1241        Vector3f loc(scale);
1242        loc *= -0.5;
1243        volume->location(loc);
1244
1245        NanoVis::VolumeHashmap::iterator itr = NanoVis::volumeTable.find(tag);
1246        if (itr != NanoVis::volumeTable.end()) {
1247            Tcl_AppendResult(interp, "volume \"", tag, "\" already exists.",
1248                             (char *)NULL);
1249            return TCL_ERROR;
1250        }
1251        NanoVis::volumeTable[tag] = volume;
1252        volume->name(tag);
1253    } else if ((nBytes > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
1254        TRACE("VTK loading...");
1255        std::stringstream fdata;
1256        fdata.write(bytes, nBytes);
1257        if (nBytes <= 0) {
1258            ERROR("data buffer is empty");
1259            abort();
1260        }
1261        Rappture::Outcome context;
1262        volume = load_vtk_volume_stream(context, tag, fdata);
1263        if (volume == NULL) {
1264            Tcl_AppendResult(interp, context.remark(), (char*)NULL);
1265            return TCL_ERROR;
1266        }
1267    } else {
1268        // **Deprecated** OpenDX format
1269        if ((nBytes > 5) && (strncmp(bytes, "<ODX>", 5) == 0)) {
1270            bytes += 5;
1271            nBytes -= 5;
1272        } else if ((nBytes > 4) && (strncmp(bytes, "<DX>", 4) == 0)) {
1273            bytes += 4;
1274            nBytes -= 4;
1275        }
1276        TRACE("DX loading...");
1277        std::stringstream fdata;
1278        fdata.write(bytes, nBytes);
1279        if (nBytes <= 0) {
1280            ERROR("data buffer is empty");
1281            abort();
1282        }
1283        Rappture::Outcome context;
1284        volume = load_dx_volume_stream(context, tag, fdata);
1285        if (volume == NULL) {
1286            Tcl_AppendResult(interp, context.remark(), (char*)NULL);
1287            return TCL_ERROR;
1288        }
1289    }
1290
1291    if (volume != NULL) {
1292        volume->disableCutplane(0);
1293        volume->disableCutplane(1);
1294        volume->disableCutplane(2);
1295        volume->transferFunction(NanoVis::getTransferFunction("default"));
1296        volume->visible(true);
1297
1298        char info[1024];
1299        ssize_t nWritten;
1300
1301        if (Volume::updatePending) {
1302            NanoVis::setVolumeRanges();
1303        }
1304
1305        // FIXME: strlen(info) is the return value of sprintf
1306        sprintf(info, "nv>data tag %s min %g max %g vmin %g vmax %g\n", tag, 
1307                volume->wAxis.min(), volume->wAxis.max(),
1308                Volume::valueMin, Volume::valueMax);
1309        nWritten  = write(1, info, strlen(info));
1310        assert(nWritten == (ssize_t)strlen(info));
1311    }
1312    return TCL_OK;
1313}
1314
1315static int
1316VolumeDataStateOp(ClientData clientData, Tcl_Interp *interp, int objc,
1317                  Tcl_Obj *const *objv)
1318{
1319    bool state;
1320    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
1321        return TCL_ERROR;
1322    }
1323    std::vector<Volume *> ivol;
1324    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1325        return TCL_ERROR;
1326    }
1327    std::vector<Volume *>::iterator iter;
1328    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1329        (*iter)->dataEnabled(state);
1330    }
1331    return TCL_OK;
1332}
1333
1334static Rappture::CmdSpec volumeDataOps[] = {
1335    {"follows",   1, VolumeDataFollowsOp, 5, 5, "nbytes tag",},
1336    {"state",     1, VolumeDataStateOp,   4, 0, "bool ?indices?",},
1337};
1338static int nVolumeDataOps = NumCmdSpecs(volumeDataOps);
1339
1340static int
1341VolumeDataOp(ClientData clientData, Tcl_Interp *interp, int objc,
1342             Tcl_Obj *const *objv)
1343{
1344    Tcl_ObjCmdProc *proc;
1345
1346    proc = Rappture::GetOpFromObj(interp, nVolumeDataOps, volumeDataOps,
1347                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
1348    if (proc == NULL) {
1349        return TCL_ERROR;
1350    }
1351    return (*proc) (clientData, interp, objc, objv);
1352}
1353
1354static int
1355VolumeDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
1356               Tcl_Obj *const *objv)
1357{
1358    for (int i = 2; i < objc; i++) {
1359        Volume *volume;
1360        if (GetVolumeFromObj(interp, objv[i], &volume) != TCL_OK) {
1361            return TCL_ERROR;
1362        }
1363        NanoVis::removeVolume(volume);
1364    }
1365    NanoVis::eventuallyRedraw();
1366    return TCL_OK;
1367}
1368
1369static int
1370VolumeExistsOp(ClientData clientData, Tcl_Interp *interp, int objc,
1371               Tcl_Obj *const *objv)
1372{
1373    bool value;
1374    Volume *volume;
1375
1376    value = false;
1377    if (GetVolumeFromObj(NULL, objv[2], &volume) == TCL_OK) {
1378        value = true;
1379    }
1380    Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (int)value);
1381    return TCL_OK;
1382}
1383
1384static int
1385VolumeNamesOp(ClientData clientData, Tcl_Interp *interp, int objc,
1386              Tcl_Obj *const *objv)
1387{
1388    Tcl_Obj *listObjPtr;
1389    listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
1390    NanoVis::VolumeHashmap::iterator itr;
1391    for (itr = NanoVis::volumeTable.begin();
1392         itr != NanoVis::volumeTable.end(); ++itr) {
1393        Tcl_Obj *objPtr = Tcl_NewStringObj(itr->second->name(), -1);
1394        Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
1395    }
1396    Tcl_SetObjResult(interp, listObjPtr);
1397    return TCL_OK;
1398}
1399
1400static int
1401VolumeOutlineColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
1402                     Tcl_Obj *const *objv)
1403{
1404    float rgb[3];
1405    if (GetColor(interp, objc - 3, objv + 3, rgb) != TCL_OK) {
1406        return TCL_ERROR;
1407    }
1408    std::vector<Volume *> ivol;
1409    if (GetVolumes(interp, objc - 6, objv + 6, &ivol) != TCL_OK) {
1410        return TCL_ERROR;
1411    }
1412    std::vector<Volume *>::iterator iter;
1413    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1414        (*iter)->setOutlineColor(rgb);
1415    }
1416    return TCL_OK;
1417}
1418
1419static int
1420VolumeOutlineStateOp(ClientData clientData, Tcl_Interp *interp, int objc,
1421                     Tcl_Obj *const *objv)
1422{
1423    bool state;
1424    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
1425        return TCL_ERROR;
1426    }
1427    std::vector<Volume *> ivol;
1428    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1429        return TCL_ERROR;
1430    }
1431    std::vector<Volume *>::iterator iter;
1432    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1433        (*iter)->outline(state);
1434    }
1435    return TCL_OK;
1436}
1437
1438static Rappture::CmdSpec volumeOutlineOps[] = {
1439    {"color",     1, VolumeOutlineColorOp,  6, 0, "r g b ?indices?",},
1440    {"state",     1, VolumeOutlineStateOp,  4, 0, "bool ?indices?",},
1441    {"visible",   1, VolumeOutlineStateOp,  4, 0, "bool ?indices?",},
1442};
1443static int nVolumeOutlineOps = NumCmdSpecs(volumeOutlineOps);
1444
1445static int
1446VolumeOutlineOp(ClientData clientData, Tcl_Interp *interp, int objc,
1447                Tcl_Obj *const *objv)
1448{
1449    Tcl_ObjCmdProc *proc;
1450
1451    proc = Rappture::GetOpFromObj(interp, nVolumeOutlineOps, volumeOutlineOps,
1452        Rappture::CMDSPEC_ARG2, objc, objv, 0);
1453    if (proc == NULL) {
1454        return TCL_ERROR;
1455    }
1456    return (*proc) (clientData, interp, objc, objv);
1457}
1458
1459static int
1460VolumeShadingAmbientOp(ClientData clientData, Tcl_Interp *interp, int objc,
1461                       Tcl_Obj *const *objv)
1462{
1463    float ambient;
1464    if (GetFloatFromObj(interp, objv[3], &ambient) != TCL_OK) {
1465        return TCL_ERROR;
1466    }
1467    if (ambient < 0.0f || ambient > 1.0f) {
1468        WARN("Invalid ambient coefficient requested: %g, should be [0,1]", ambient);
1469    }
1470    std::vector<Volume *> ivol;
1471    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1472        return TCL_ERROR;
1473    }
1474    std::vector<Volume *>::iterator iter;
1475    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1476        (*iter)->ambient(ambient);
1477    }
1478    return TCL_OK;
1479}
1480
1481static int
1482VolumeShadingDiffuseOp(ClientData clientData, Tcl_Interp *interp, int objc,
1483                       Tcl_Obj *const *objv)
1484{
1485    float diffuse;
1486    if (GetFloatFromObj(interp, objv[3], &diffuse) != TCL_OK) {
1487        return TCL_ERROR;
1488    }
1489    if (diffuse < 0.0f || diffuse > 1.0f) {
1490        WARN("Invalid diffuse coefficient requested: %g, should be [0,1]", diffuse);
1491    }
1492    std::vector<Volume *> ivol;
1493    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1494        return TCL_ERROR;
1495    }
1496    std::vector<Volume *>::iterator iter;
1497    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1498        (*iter)->diffuse(diffuse);
1499    }
1500    return TCL_OK;
1501}
1502
1503static int
1504VolumeShadingIsosurfaceOp(ClientData clientData, Tcl_Interp *interp, int objc,
1505                          Tcl_Obj *const *objv)
1506{
1507    bool iso_surface;
1508    if (GetBooleanFromObj(interp, objv[3], &iso_surface) != TCL_OK) {
1509        return TCL_ERROR;
1510    }
1511    std::vector<Volume *> ivol;
1512    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1513        return TCL_ERROR;
1514    }
1515    std::vector<Volume *>::iterator iter;
1516    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1517        (*iter)->isosurface(iso_surface);
1518    }
1519    return TCL_OK;
1520}
1521
1522static int
1523VolumeShadingLight2SideOp(ClientData clientData, Tcl_Interp *interp, int objc,
1524                          Tcl_Obj *const *objv)
1525{
1526    bool twoSidedLighting;
1527    if (GetBooleanFromObj(interp, objv[3], &twoSidedLighting) != TCL_OK) {
1528        return TCL_ERROR;
1529    }
1530    std::vector<Volume *> ivol;
1531    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1532        return TCL_ERROR;
1533    }
1534    std::vector<Volume *>::iterator iter;
1535    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1536        (*iter)->twoSidedLighting(twoSidedLighting);
1537    }
1538    return TCL_OK;
1539}
1540
1541static int
1542VolumeShadingOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
1543                       Tcl_Obj *const *objv)
1544{
1545
1546    float opacity;
1547    if (GetFloatFromObj(interp, objv[3], &opacity) != TCL_OK) {
1548        return TCL_ERROR;
1549    }
1550    TRACE("set opacity %f", opacity);
1551    std::vector<Volume *> ivol;
1552    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1553        return TCL_ERROR;
1554    }
1555    std::vector<Volume *>::iterator iter;
1556    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1557        (*iter)->opacityScale(opacity);
1558    }
1559    return TCL_OK;
1560}
1561
1562static int
1563VolumeShadingSpecularOp(ClientData clientData, Tcl_Interp *interp, int objc,
1564                        Tcl_Obj *const *objv)
1565{
1566    float specular;
1567    if (GetFloatFromObj(interp, objv[3], &specular) != TCL_OK) {
1568        return TCL_ERROR;
1569    }
1570    if (specular < 0.0f || specular > 1.0f) {
1571        WARN("Invalid specular coefficient requested: %g, should be [0,1]", specular);
1572    }
1573    std::vector<Volume *> ivol;
1574    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1575        return TCL_ERROR;
1576    }
1577    std::vector<Volume *>::iterator iter;
1578    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1579        (*iter)->specularLevel(specular);
1580    }
1581    return TCL_OK;
1582}
1583
1584static int
1585VolumeShadingSpecularExpOp(ClientData clientData, Tcl_Interp *interp, int objc,
1586                           Tcl_Obj *const *objv)
1587{
1588    float specularExp;
1589    if (GetFloatFromObj(interp, objv[3], &specularExp) != TCL_OK) {
1590        return TCL_ERROR;
1591    }
1592    if (specularExp < 0.0f || specularExp > 128.0f) {
1593        WARN("Invalid specular exponent requested: %g, should be [0,128]", specularExp);
1594    }
1595    std::vector<Volume *> ivol;
1596    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1597        return TCL_ERROR;
1598    }
1599    std::vector<Volume *>::iterator iter;
1600    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1601        (*iter)->specularExponent(specularExp);
1602    }
1603    return TCL_OK;
1604}
1605
1606static int
1607VolumeShadingTransFuncOp(ClientData clientData, Tcl_Interp *interp, int objc,
1608                         Tcl_Obj *const *objv)
1609{
1610    const char *name = Tcl_GetString(objv[3]);
1611    TransferFunction *tf = NanoVis::getTransferFunction(name);
1612    if (tf == NULL) {
1613        Tcl_AppendResult(interp, "transfer function \"", name,
1614                         "\" is not defined", (char*)NULL);
1615        return TCL_ERROR;
1616    }
1617    std::vector<Volume *> ivol;
1618    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
1619        return TCL_ERROR;
1620    }
1621    std::vector<Volume *>::iterator iter;
1622    for (iter = ivol.begin(); iter != ivol.end(); ++iter) {
1623        TRACE("setting %s with transfer function %s", (*iter)->name(),
1624               tf->name());
1625        (*iter)->transferFunction(tf);
1626    }
1627    return TCL_OK;
1628}
1629
1630static Rappture::CmdSpec volumeShadingOps[] = {
1631    {"ambient",       1, VolumeShadingAmbientOp,     4, 0, "value ?indices?",},
1632    {"diffuse",       1, VolumeShadingDiffuseOp,     4, 0, "value ?indices?",},
1633    {"isosurface",    1, VolumeShadingIsosurfaceOp,  4, 0, "bool ?indices?",},
1634    {"light2side",    1, VolumeShadingLight2SideOp,  4, 0, "bool ?indices?",},
1635    {"opacity",       1, VolumeShadingOpacityOp,     4, 0, "value ?indices?",},
1636    {"specularExp",   9, VolumeShadingSpecularExpOp, 4, 0, "value ?indices?",},
1637    {"specularLevel", 9, VolumeShadingSpecularOp,    4, 0, "value ?indices?",},
1638    {"transfunc",     1, VolumeShadingTransFuncOp,   4, 0, "funcName ?indices?",},
1639};
1640static int nVolumeShadingOps = NumCmdSpecs(volumeShadingOps);
1641
1642static int
1643VolumeShadingOp(ClientData clientData, Tcl_Interp *interp, int objc,
1644                Tcl_Obj *const *objv)
1645{
1646    Tcl_ObjCmdProc *proc;
1647
1648    proc = Rappture::GetOpFromObj(interp, nVolumeShadingOps, volumeShadingOps,
1649        Rappture::CMDSPEC_ARG2, objc, objv, 0);
1650    if (proc == NULL) {
1651        return TCL_ERROR;
1652    }
1653    return (*proc) (clientData, interp, objc, objv);
1654}
1655
1656static int
1657VolumeStateOp(ClientData clientData, Tcl_Interp *interp, int objc,
1658              Tcl_Obj *const *objv)
1659{
1660    bool state;
1661    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
1662        return TCL_ERROR;
1663    }
1664    std::vector<Volume *> ivol;
1665    if (GetVolumes(interp, objc - 3, objv + 3, &ivol) != TCL_OK) {
1666        return TCL_ERROR;
1667    }
1668    std::vector<Volume *>::iterator iter;
1669    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
1670        (*iter)->visible(state);
1671    }
1672    return TCL_OK;
1673}
1674
1675static Rappture::CmdSpec volumeOps[] = {
1676    {"animation", 2, VolumeAnimationOp,   3, 0, "oper ?args?",},
1677    {"data",      2, VolumeDataOp,        3, 0, "oper ?args?",},
1678    {"delete",    2, VolumeDeleteOp,      3, 0, "?name...?",},
1679    {"exists",    1, VolumeExistsOp,      3, 3, "name",},
1680    {"names",     1, VolumeNamesOp,       2, 2, "",},
1681    {"outline",   1, VolumeOutlineOp,     3, 0, "oper ?args?",},
1682    {"shading",   2, VolumeShadingOp,     3, 0, "oper ?args?",},
1683    {"state",     2, VolumeStateOp,       3, 0, "bool ?indices?",},
1684};
1685static int nVolumeOps = NumCmdSpecs(volumeOps);
1686
1687static int
1688VolumeCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
1689          Tcl_Obj *const *objv)
1690{
1691    Tcl_ObjCmdProc *proc;
1692
1693    proc = Rappture::GetOpFromObj(interp, nVolumeOps, volumeOps,
1694        Rappture::CMDSPEC_ARG1, objc, objv, 0);
1695    if (proc == NULL) {
1696        return TCL_ERROR;
1697    }
1698    return (*proc) (clientData, interp, objc, objv);
1699}
1700
1701static int
1702HeightMapDataFollowsOp(ClientData clientData, Tcl_Interp *interp, int objc,
1703                       Tcl_Obj *const *objv)
1704{
1705    int nBytes;
1706    if (Tcl_GetIntFromObj(interp, objv[3], &nBytes) != TCL_OK) {
1707        return TCL_ERROR;
1708    }
1709    const char *tag = Tcl_GetString(objv[4]);
1710
1711    Rappture::Buffer buf;
1712    if (GetDataStream(interp, buf, nBytes) != TCL_OK) {
1713        return TCL_ERROR;
1714    }
1715    Rappture::Unirect2d data(1);
1716    if (data.parseBuffer(interp, buf) != TCL_OK) {
1717        return TCL_ERROR;
1718    }
1719    if (data.nValues() == 0) {
1720        Tcl_AppendResult(interp, "no data found in stream", (char *)NULL);
1721        return TCL_ERROR;
1722    }
1723    if (!data.isInitialized()) {
1724        return TCL_ERROR;
1725    }
1726    HeightMap *heightMap;
1727    NanoVis::HeightMapHashmap::iterator itr = NanoVis::heightMapTable.find(tag);
1728    if (itr != NanoVis::heightMapTable.end()) {
1729        heightMap = itr->second;
1730    } else {
1731        heightMap = new HeightMap();
1732        NanoVis::heightMapTable[tag] = heightMap;
1733    }
1734    TRACE("Number of heightmaps=%d", NanoVis::heightMapTable.size());
1735    // Must set units before the heights.
1736    heightMap->xAxis.units(data.xUnits());
1737    heightMap->yAxis.units(data.yUnits());
1738    heightMap->zAxis.units(data.vUnits());
1739    heightMap->wAxis.units(data.yUnits());
1740    heightMap->setHeight(data.xMin(), data.yMin(), data.xMax(), data.yMax(), 
1741                         data.xNum(), data.yNum(), data.transferValues());
1742    heightMap->transferFunction(NanoVis::getTransferFunction("default"));
1743    heightMap->setVisible(true);
1744    heightMap->setLineContourVisible(true);
1745    NanoVis::eventuallyRedraw();
1746    return TCL_OK;
1747}
1748
1749static int
1750HeightMapDataVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
1751                       Tcl_Obj *const *objv)
1752{
1753    bool visible;
1754    if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
1755        return TCL_ERROR;
1756    }
1757    std::vector<HeightMap *> imap;
1758    if (GetHeightMaps(interp, objc - 4, objv + 4, &imap) != TCL_OK) {
1759        return TCL_ERROR;
1760    }
1761    std::vector<HeightMap *>::iterator iter;
1762    for (iter = imap.begin(); iter != imap.end(); iter++) {
1763        (*iter)->setVisible(visible);
1764    }
1765    NanoVis::eventuallyRedraw();
1766    return TCL_OK;
1767}
1768
1769static Rappture::CmdSpec heightMapDataOps[] = {
1770    {"follows",  1, HeightMapDataFollowsOp, 5, 5, "size heightmapName",},
1771    {"visible",  1, HeightMapDataVisibleOp, 4, 0, "bool ?heightmapNames...?",},
1772};
1773static int nHeightMapDataOps = NumCmdSpecs(heightMapDataOps);
1774
1775static int
1776HeightMapDataOp(ClientData clientData, Tcl_Interp *interp, int objc,
1777                Tcl_Obj *const *objv)
1778{
1779    Tcl_ObjCmdProc *proc;
1780
1781    proc = Rappture::GetOpFromObj(interp, nHeightMapDataOps, heightMapDataOps,
1782                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
1783    if (proc == NULL) {
1784        return TCL_ERROR;
1785    }
1786    return (*proc) (clientData, interp, objc, objv);
1787}
1788
1789static int
1790HeightMapLineContourColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
1791                            Tcl_Obj *const *objv)
1792{
1793    float rgb[3];
1794    if (GetColor(interp, objc - 3, objv + 3, rgb) != TCL_OK) {
1795        return TCL_ERROR;
1796    }
1797    std::vector<HeightMap *> imap;
1798    if (GetHeightMaps(interp, objc - 6, objv + 6, &imap) != TCL_OK) {
1799        return TCL_ERROR;
1800    }
1801    std::vector<HeightMap *>::iterator iter;
1802    for (iter = imap.begin(); iter != imap.end(); iter++) {
1803        (*iter)->setLineContourColor(rgb);
1804    }
1805    NanoVis::eventuallyRedraw();
1806    return TCL_OK;
1807}
1808
1809static int
1810HeightMapLineContourVisibleOp(ClientData clientData, Tcl_Interp *interp, 
1811                              int objc, Tcl_Obj *const *objv)
1812{
1813    bool visible;
1814    if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
1815        return TCL_ERROR;
1816    }
1817    std::vector<HeightMap *> imap;
1818    if (GetHeightMaps(interp, objc - 4, objv + 4, &imap) != TCL_OK) {
1819        return TCL_ERROR;
1820    }
1821    std::vector<HeightMap *>::iterator iter;
1822    for (iter = imap.begin(); iter != imap.end(); iter++) {
1823        (*iter)->setLineContourVisible(visible);
1824    }
1825    NanoVis::eventuallyRedraw();
1826    return TCL_OK;
1827}
1828
1829static Rappture::CmdSpec heightMapLineContourOps[] = {
1830    {"color",   1, HeightMapLineContourColorOp,   6, 0, "r g b ?heightmapNames...?",},
1831    {"visible", 1, HeightMapLineContourVisibleOp, 4, 0, "bool ?heightmapNames...?",},
1832};
1833static int nHeightMapLineContourOps = NumCmdSpecs(heightMapLineContourOps);
1834
1835static int 
1836HeightMapLineContourOp(ClientData clientData, Tcl_Interp *interp, int objc,
1837                       Tcl_Obj *const *objv)
1838{
1839    Tcl_ObjCmdProc *proc;
1840
1841    proc = Rappture::GetOpFromObj(interp, nHeightMapLineContourOps,
1842        heightMapLineContourOps, Rappture::CMDSPEC_ARG2, objc, objv, 0);
1843    if (proc == NULL) {
1844        return TCL_ERROR;
1845    }
1846    return (*proc) (clientData, interp, objc, objv);
1847}
1848
1849static int
1850HeightMapCullOp(ClientData clientData, Tcl_Interp *interp, int objc,
1851                Tcl_Obj *const *objv)
1852{
1853    RenderContext::CullMode mode;
1854    if (GetCullMode(interp, objv[2], &mode) != TCL_OK) {
1855        return TCL_ERROR;
1856    }
1857    NanoVis::renderContext->setCullMode(mode);
1858    NanoVis::eventuallyRedraw();
1859    return TCL_OK;
1860}
1861
1862static int
1863HeightMapCreateOp(ClientData clientData, Tcl_Interp *interp, int objc,
1864                  Tcl_Obj *const *objv)
1865{
1866    const char *tag = Tcl_GetString(objv[2]);
1867    NanoVis::HeightMapHashmap::iterator itr = NanoVis::heightMapTable.find(tag);
1868    if (itr != NanoVis::heightMapTable.end()) {
1869        Tcl_AppendResult(interp, "heightmap \"", tag, "\" already exists.",
1870                         (char *)NULL);
1871        return TCL_ERROR;
1872    }
1873    /* heightmap create xmin ymin xmax ymax xnum ynum values */
1874    HeightMap *heightMap = CreateHeightMap(clientData, interp, objc - 3, objv + 3);
1875    if (heightMap == NULL) {
1876        return TCL_ERROR;
1877    }
1878    NanoVis::heightMapTable[tag] = heightMap;
1879    NanoVis::eventuallyRedraw();
1880    TRACE("Number of heightmaps=%d", NanoVis::heightMapTable.size());
1881    return TCL_OK;
1882}
1883
1884static int
1885HeightMapLegendOp(ClientData clientData, Tcl_Interp *interp, int objc,
1886                  Tcl_Obj *const *objv)
1887{
1888    HeightMap *hmPtr;
1889    if (GetHeightMapFromObj(interp, objv[2], &hmPtr) != TCL_OK) {
1890        return TCL_ERROR;
1891    }
1892    const char *tag;
1893    tag = Tcl_GetString(objv[2]);
1894    TransferFunction *tfPtr;
1895    tfPtr = hmPtr->transferFunction();
1896    if (tfPtr == NULL) {
1897        Tcl_AppendResult(interp, "no transfer function defined for heightmap"
1898                         " \"", tag, "\"", (char*)NULL);
1899        return TCL_ERROR;
1900    }
1901    int w, h;
1902    if ((Tcl_GetIntFromObj(interp, objv[3], &w) != TCL_OK) ||
1903        (Tcl_GetIntFromObj(interp, objv[4], &h) != TCL_OK)) {
1904        return TCL_ERROR;
1905    }
1906    if (HeightMap::updatePending) {
1907        NanoVis::setHeightmapRanges();
1908    }
1909    NanoVis::renderLegend(tfPtr, HeightMap::valueMin, HeightMap::valueMax, 
1910                          w, h, tag);
1911    return TCL_OK;
1912}
1913
1914static int
1915HeightMapPolygonOp(ClientData clientData, Tcl_Interp *interp, int objc,
1916                   Tcl_Obj *const *objv)
1917{
1918    RenderContext::PolygonMode mode;
1919    if (GetPolygonMode(interp, objv[2], &mode) != TCL_OK) {
1920        return TCL_ERROR;
1921    }
1922    NanoVis::renderContext->setPolygonMode(mode);
1923    NanoVis::eventuallyRedraw();
1924    return TCL_OK;
1925}
1926
1927static int
1928HeightMapShadingOp(ClientData clientData, Tcl_Interp *interp, int objc,
1929                 Tcl_Obj *const *objv)
1930{
1931    RenderContext::ShadingModel model;
1932    if (GetShadingModel(interp, objv[2], &model) != TCL_OK) {
1933        return TCL_ERROR;
1934    }
1935    NanoVis::renderContext->setShadingModel(model);
1936    NanoVis::eventuallyRedraw();
1937    return TCL_OK;
1938}
1939
1940static int
1941HeightMapTransFuncOp(ClientData clientData, Tcl_Interp *interp, int objc,
1942                     Tcl_Obj *const *objv)
1943{
1944    const char *name;
1945    name = Tcl_GetString(objv[2]);
1946    TransferFunction *tf = NanoVis::getTransferFunction(name);
1947    if (tf == NULL) {
1948        Tcl_AppendResult(interp, "transfer function \"", name,
1949                         "\" is not defined", (char*)NULL);
1950        return TCL_ERROR;
1951    }
1952    std::vector<HeightMap *> imap;
1953    if (GetHeightMaps(interp, objc - 3, objv + 3, &imap) != TCL_OK) {
1954        return TCL_ERROR;
1955    }
1956    std::vector<HeightMap *>::iterator iter;
1957    for (iter = imap.begin(); iter != imap.end(); iter++) {
1958        (*iter)->transferFunction(tf);
1959    }
1960    NanoVis::eventuallyRedraw();
1961    return TCL_OK;
1962}
1963
1964static int
1965HeightMapOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
1966                   Tcl_Obj *const *objv)
1967{
1968    float opacity;
1969    if (GetFloatFromObj(interp, objv[2], &opacity) != TCL_OK) {
1970        return TCL_ERROR;
1971    }
1972    std::vector<HeightMap *> heightmaps;
1973    if (GetHeightMaps(interp, objc - 3, objv + 3, &heightmaps) != TCL_OK) {
1974        return TCL_ERROR;
1975    }
1976    std::vector<HeightMap *>::iterator iter;
1977    for (iter = heightmaps.begin(); iter != heightmaps.end(); iter++) {
1978        (*iter)->opacity(opacity);
1979    }
1980    NanoVis::eventuallyRedraw();
1981    return TCL_OK;
1982}
1983
1984static Rappture::CmdSpec heightMapOps[] = {
1985    {"create",       2, HeightMapCreateOp,      10, 10, "heightmapName xmin ymin xmax ymax xnum ynum values",},
1986    {"cull",         2, HeightMapCullOp,        3, 3, "mode",},
1987    {"data",         1, HeightMapDataOp,        3, 0, "oper ?args?",},
1988    {"legend",       2, HeightMapLegendOp,      5, 5, "heightmapName width height",},
1989    {"linecontour",  2, HeightMapLineContourOp, 2, 0, "oper ?args?",},
1990    {"opacity",      1, HeightMapOpacityOp,     3, 0, "value ?heightmapNames...? ",},
1991    {"polygon",      1, HeightMapPolygonOp,     3, 3, "mode",},
1992    {"shading",      1, HeightMapShadingOp,     3, 3, "model",},
1993    {"transfunc",    2, HeightMapTransFuncOp,   3, 0, "name ?heightmapNames...?",},
1994};
1995static int nHeightMapOps = NumCmdSpecs(heightMapOps);
1996
1997static int
1998HeightMapCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
1999             Tcl_Obj *const *objv)
2000{
2001    Tcl_ObjCmdProc *proc;
2002
2003    proc = Rappture::GetOpFromObj(interp, nHeightMapOps, heightMapOps,
2004                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
2005    if (proc == NULL) {
2006        return TCL_ERROR;
2007    }
2008    return (*proc) (clientData, interp, objc, objv);
2009}
2010
2011static int
2012GridAxisColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
2013                Tcl_Obj *const *objv)
2014{
2015    float r, g, b, a;
2016    if ((GetFloatFromObj(interp, objv[2], &r) != TCL_OK) ||
2017        (GetFloatFromObj(interp, objv[3], &g) != TCL_OK) ||
2018        (GetFloatFromObj(interp, objv[4], &b) != TCL_OK)) {
2019        return TCL_ERROR;
2020    }
2021    a = 1.0f;
2022    if ((objc == 6) && (GetFloatFromObj(interp, objv[5], &a) != TCL_OK)) {
2023        return TCL_ERROR;
2024    }
2025    if (NanoVis::grid) {
2026        NanoVis::grid->setAxisColor(r, g, b, a);
2027    }
2028    return TCL_OK;
2029}
2030
2031static int
2032GridAxisNameOp(ClientData clientData, Tcl_Interp *interp, int objc, 
2033               Tcl_Obj *const *objv)
2034{
2035    int axis;
2036    if (GetAxisFromObj(interp, objv[2], &axis) != TCL_OK) {
2037        return TCL_ERROR;
2038    }
2039    if (NanoVis::grid != NULL) {
2040        Axis *axisPtr;
2041
2042        axisPtr = NULL;     /* Suppress compiler warning. */
2043        switch (axis) {
2044        case 0: axisPtr = &NanoVis::grid->xAxis; break;
2045        case 1: axisPtr = &NanoVis::grid->yAxis; break;
2046        case 2: axisPtr = &NanoVis::grid->zAxis; break;
2047        }
2048        axisPtr->name(Tcl_GetString(objv[3]));
2049        axisPtr->units(Tcl_GetString(objv[4]));
2050    }
2051    return TCL_OK;
2052}
2053
2054static int
2055GridLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
2056                Tcl_Obj *const *objv)
2057{
2058    float r, g, b, a;
2059    if ((GetFloatFromObj(interp, objv[2], &r) != TCL_OK) ||
2060        (GetFloatFromObj(interp, objv[3], &g) != TCL_OK) ||
2061        (GetFloatFromObj(interp, objv[4], &b) != TCL_OK)) {
2062        return TCL_ERROR;
2063    }
2064    a = 1.0f;
2065    if ((objc == 6) && (GetFloatFromObj(interp, objv[5], &a) != TCL_OK)) {
2066        return TCL_ERROR;
2067    }
2068    if (NanoVis::grid) {
2069        NanoVis::grid->setLineColor(r, g, b, a);
2070    }
2071    return TCL_OK;
2072}
2073
2074static int
2075GridVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
2076              Tcl_Obj *const *objv)
2077{
2078    bool visible;
2079    if (GetBooleanFromObj(interp, objv[2], &visible) != TCL_OK) {
2080        return TCL_ERROR;
2081    }
2082    NanoVis::grid->setVisible(visible);
2083    return TCL_OK;
2084}
2085
2086static Rappture::CmdSpec gridOps[] = {
2087    {"axiscolor",  5, GridAxisColorOp,  5, 6, "r g b ?a?",},
2088    {"axisname",   5, GridAxisNameOp,   5, 5, "index title units",},
2089    {"linecolor",  7, GridLineColorOp,  5, 6, "r g b ?a?",},
2090    {"visible",    1, GridVisibleOp,    3, 3, "bool",},
2091};
2092static int nGridOps = NumCmdSpecs(gridOps);
2093
2094static int
2095GridCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
2096        Tcl_Obj *const *objv)
2097{
2098    Tcl_ObjCmdProc *proc;
2099
2100    proc = Rappture::GetOpFromObj(interp, nGridOps, gridOps,
2101                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
2102    if (proc == NULL) {
2103        return TCL_ERROR;
2104    }
2105    return (*proc) (clientData, interp, objc, objv);
2106}
2107
2108static int
2109AxisCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
2110        Tcl_Obj *const *objv)
2111{
2112    if (objc < 2) {
2113        Tcl_AppendResult(interp, "wrong # args: should be \"",
2114                Tcl_GetString(objv[0]), " option arg arg...\"", (char*)NULL);
2115        return TCL_ERROR;
2116    }
2117    const char *string = Tcl_GetString(objv[1]);
2118    char c = string[0];
2119    if ((c == 'v') && (strcmp(string, "visible") == 0)) {
2120        bool visible;
2121
2122        if (GetBooleanFromObj(interp, objv[2], &visible) != TCL_OK) {
2123            return TCL_ERROR;
2124        }
2125        NanoVis::axisOn = visible;
2126    } else {
2127        Tcl_AppendResult(interp, "bad axis option \"", string,
2128                         "\": should be visible", (char*)NULL);
2129        return TCL_ERROR;
2130    }
2131    return TCL_OK;
2132}
2133
2134static int
2135ImageFlushCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
2136              Tcl_Obj *const *objv)
2137{
2138    lastCmdStatus = TCL_BREAK;
2139    return TCL_OK;
2140}
2141
2142Tcl_Interp *
2143initTcl()
2144{
2145    Tcl_Interp *interp = Tcl_CreateInterp();
2146    Tcl_MakeSafe(interp);
2147
2148    Tcl_CreateObjCommand(interp, "axis",        AxisCmd,        NULL, NULL);
2149    Tcl_CreateObjCommand(interp, "camera",      CameraCmd,      NULL, NULL);
2150    Tcl_CreateObjCommand(interp, "clientinfo",  ClientInfoCmd,  NULL, NULL);
2151    Tcl_CreateObjCommand(interp, "cutplane",    CutplaneCmd,    NULL, NULL);
2152    if (FlowCmdInitProc(interp) != TCL_OK) {
2153        return NULL;
2154    }
2155    Tcl_CreateObjCommand(interp, "grid",        GridCmd,        NULL, NULL);
2156    Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   NULL, NULL);
2157    Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  NULL, NULL);
2158    Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      NULL, NULL);
2159    Tcl_CreateObjCommand(interp, "screen",      ScreenCmd,      NULL, NULL);
2160    Tcl_CreateObjCommand(interp, "snapshot",    SnapshotCmd,    NULL, NULL);
2161    Tcl_CreateObjCommand(interp, "transfunc",   TransfuncCmd,   NULL, NULL);
2162    Tcl_CreateObjCommand(interp, "up",          UpCmd,          NULL, NULL);
2163    Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      NULL, NULL);
2164
2165    // create a default transfer function
2166    if (Tcl_Eval(interp, def_transfunc) != TCL_OK) {
2167        WARN("bad default transfer function:\n%s", 
2168             Tcl_GetStringResult(interp));
2169    }
2170    return interp;
2171}
Note: See TracBrowser for help on using the repository browser.